refactor(server): remove LEGACY_ELEMENT_SELECTED support and dead code

ashtonchew · ashtonchew · commit 4ce493e5a32e · 2025-10-01T14:35:36.000-07:00
- Remove LEGACY_ELEMENT_SELECTED message handling - only DOM_ELEMENT_POINTED supported
- Delete unused mcp-handler.ts and websocket-server.ts files
- Remove StateDataV1 and LegacySharedState types
- Simplify SharedStateService to only handle V2 format
- Update tests to remove legacy test cases
diff --git a/packages/server/src/__tests__/factories/shared-state-factory.ts b/packages/server/src/__tests__/factories/shared-state-factory.ts
@@ -1,6 +1,6 @@
-import { TargetedElement, RawPointedDOMElement, PointerMessageType } from '@mcp-pointer/shared/types';
+import { RawPointedDOMElement, PointerMessageType } from '@mcp-pointer/shared/types';
 import {
-  SharedState, StateDataV1, StateDataV2, ProcessedPointedDOMElement,
+  SharedState, StateDataV2, ProcessedPointedDOMElement,
 } from '../../types';
 
 export const createProcessedElement = (
@@ -39,29 +39,6 @@ export const createRawElement = (
   ...overrides,
 });
 
-export const createLegacyElement = (
-  overrides: Partial<TargetedElement> = {},
-): TargetedElement => ({
-  selector: 'div',
-  tagName: 'div',
-  classes: [],
-  innerText: 'test content',
-  attributes: {},
-  position: {
-    x: 10, y: 20, width: 100, height: 50,
-  },
-  cssProperties: {
-    display: 'block',
-    position: 'relative',
-    fontSize: '16px',
-    color: '#000000',
-    backgroundColor: '#ffffff',
-  },
-  timestamp: 1672531200000,
-  url: 'https://example.com',
-  ...overrides,
-});
-
 export const createStateV2 = (
   rawOverrides: Partial<RawPointedDOMElement> = {},
   processedOverrides: Partial<ProcessedPointedDOMElement> = {},
@@ -76,18 +53,3 @@ export const createStateV2 = (
     },
   } as StateDataV2,
 });
-
-export const createStateV1 = (
-  legacyOverrides: Partial<TargetedElement> = {},
-  processedOverrides: Partial<ProcessedPointedDOMElement> = {},
-): SharedState => ({
-  stateVersion: 1,
-  data: {
-    rawPointedDOMElement: createLegacyElement(legacyOverrides),
-    processedPointedDOMElement: createProcessedElement(processedOverrides),
-    metadata: {
-      receivedAt: '2023-01-01T00:00:00.000Z',
-      messageType: PointerMessageType.LEGACY_ELEMENT_SELECTED,
-    },
-  } as StateDataV1,
-});
diff --git a/packages/server/src/__tests__/services/shared-state-service.test.ts b/packages/server/src/__tests__/services/shared-state-service.test.ts
@@ -2,7 +2,7 @@ import fs from 'fs/promises';
 import path from 'path';
 import os from 'os';
 import SharedStateService from '../../services/shared-state-service';
-import { createStateV1, createStateV2, createLegacyElement } from '../factories/shared-state-factory';
+import { createStateV2 } from '../factories/shared-state-factory';
 
 jest.mock('../../logger', () => ({
   debug: jest.fn(),
@@ -41,7 +41,7 @@ describe('SharedStateService', () => {
 
     it('overwrites corrupted file', async () => {
       await fs.writeFile(testPath, 'invalid json');
-      const state = createStateV1();
+      const state = createStateV2();
 
       await service.saveState(state);
 
@@ -53,7 +53,7 @@ describe('SharedStateService', () => {
   });
 
   describe('getPointedElement', () => {
-    it('returns processed element from v2 state', async () => {
+    it('returns processed element from state', async () => {
       const state = createStateV2();
       await fs.writeFile(testPath, JSON.stringify(state));
 
@@ -62,24 +62,6 @@ describe('SharedStateService', () => {
       expect(result).toEqual(state.data.processedPointedDOMElement);
     });
 
-    it('returns processed element from v1 state', async () => {
-      const state = createStateV1();
-      await fs.writeFile(testPath, JSON.stringify(state));
-
-      const result = await service.getPointedElement();
-
-      expect(result).toEqual(state.data.processedPointedDOMElement);
-    });
-
-    it('returns legacy element as-is', async () => {
-      const legacyElement = createLegacyElement();
-      await fs.writeFile(testPath, JSON.stringify(legacyElement));
-
-      const result = await service.getPointedElement();
-
-      expect(result).toEqual(legacyElement);
-    });
-
     it('returns null for invalid json', async () => {
       await fs.writeFile(testPath, 'invalid json');
 
diff --git a/packages/server/src/mcp-handler.ts b/packages/server/src/mcp-handler.ts
diff --git a/packages/server/src/message-handler.ts b/packages/server/src/message-handler.ts
@@ -1,8 +1,8 @@
-import { PointerMessageType, type TargetedElement, type RawPointedDOMElement } from '@mcp-pointer/shared/types';
+import { PointerMessageType, type RawPointedDOMElement } from '@mcp-pointer/shared/types';
 import logger from './logger';
 import ElementProcessor from './services/element-processor';
 import SharedStateService from './services/shared-state-service';
-import { SharedState, StateDataV1, StateDataV2 } from './types';
+import { SharedState, StateDataV2 } from './types';
 
 function buildMetadata(messageType: string) {
   const now = new Date().toISOString();
@@ -13,32 +13,12 @@ function buildMetadata(messageType: string) {
   };
 }
 
-function buildLegacyState(type: string, data: any): SharedState {
-  logger.info('Processing legacy element format');
-  const element = data as TargetedElement;
-
-  const stateData: StateDataV1 = {
-    rawPointedDOMElement: element,
-    processedPointedDOMElement: {
-      ...element,
-      timestamp: new Date(element.timestamp).toISOString(),
-      warnings: undefined,
-    },
-    metadata: buildMetadata(type),
-  };
-
-  return {
-    stateVersion: 1,
-    data: stateData,
-  };
-}
-
-function buildNewState(
+function buildState(
   type: string,
   data: any,
   elementProcessor: ElementProcessor,
 ): SharedState {
-  logger.info('Processing new raw element format');
+  logger.info('Processing raw element format');
   const raw = data as RawPointedDOMElement;
   const processed = elementProcessor.processFromRaw(raw);
 
@@ -59,15 +39,12 @@ function buildStateFromMessage(
   data: any,
   services: HandlerServices,
 ): SharedState | null {
-  switch (type) {
-    case PointerMessageType.LEGACY_ELEMENT_SELECTED:
-      return buildLegacyState(type, data);
-    case PointerMessageType.DOM_ELEMENT_POINTED:
-      return buildNewState(type, data, services.elementProcessor);
-    default:
-      logger.warn(`Received unknown message type: ${type}`);
-      return null;
+  if (type === PointerMessageType.DOM_ELEMENT_POINTED) {
+    return buildState(type, data, services.elementProcessor);
   }
+
+  logger.warn(`Received unknown message type: ${type}`);
+  return null;
 }
 
 interface HandlerServices {
diff --git a/packages/server/src/services/shared-state-service.ts b/packages/server/src/services/shared-state-service.ts
@@ -1,12 +1,10 @@
 import fs from 'fs/promises';
-import { type TargetedElement } from '@mcp-pointer/shared/types';
-import { SharedState, ProcessedPointedDOMElement, LegacySharedState } from '../types';
+import { SharedState, ProcessedPointedDOMElement } from '../types';
 import logger from '../logger';
 
 export default class SharedStateService {
   static SHARED_STATE_PATH = '/tmp/mcp-pointer-shared-state.json';
 
-  // New method for storing versioned data
   public async saveState(state: SharedState): Promise<void> {
     try {
       const json = JSON.stringify(state, null, 2);
@@ -18,23 +16,14 @@ export default class SharedStateService {
     }
   }
 
-  // Get processed element for MCP service
-  public async getPointedElement(): Promise<ProcessedPointedDOMElement | TargetedElement | null> {
+  public async getPointedElement(): Promise<ProcessedPointedDOMElement | null> {
     const state = await this.readState();
-    if (!state || typeof state !== 'object') return null;
+    if (!state) return null;
 
-    // If it's the new format, return the processed element
-    if ('stateVersion' in state) {
-      const sharedState = state as SharedState;
-      return sharedState.data.processedPointedDOMElement;
-    }
-
-    // Legacy format - return as-is
-    const legacyState = state as LegacySharedState;
-    return legacyState;
+    return state.data.processedPointedDOMElement;
   }
 
-  private async readState(): Promise<SharedState | LegacySharedState | null> {
+  private async readState(): Promise<SharedState | null> {
     try {
       const json = await fs.readFile(SharedStateService.SHARED_STATE_PATH, 'utf8');
       return JSON.parse(json);
diff --git a/packages/server/src/types.ts b/packages/server/src/types.ts
@@ -3,7 +3,6 @@ import {
   CSSProperties,
   ComponentInfo,
   RawPointedDOMElement,
-  TargetedElement,
 } from '@mcp-pointer/shared/types';
 
 // Server-processed data (extracted & enhanced)
@@ -33,16 +32,7 @@ export interface ProcessedPointedDOMElement {
   warnings?: string[];
 }
 
-// Version-specific data types
-export interface StateDataV1 {
-  rawPointedDOMElement: TargetedElement;
-  processedPointedDOMElement: ProcessedPointedDOMElement;
-  metadata: {
-    receivedAt: string;
-    messageType: string;
-  };
-}
-
+// State data structure
 export interface StateDataV2 {
   rawPointedDOMElement: RawPointedDOMElement;
   processedPointedDOMElement: ProcessedPointedDOMElement;
@@ -52,11 +42,8 @@ export interface StateDataV2 {
   };
 }
 
-// Storage format with versioned data
+// Storage format
 export interface SharedState {
-  stateVersion: number;
-  data: StateDataV1 | StateDataV2;
+  stateVersion: 2;
+  data: StateDataV2;
 }
-
-// Legacy format alias
-export type LegacySharedState = TargetedElement;
diff --git a/packages/server/src/websocket-server.ts b/packages/server/src/websocket-server.ts
