framer-code-link 0.1.3 → 0.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "framer-code-link",
-  "version": "0.1.3",
+  "version": "0.2.0",
   "description": "CLI tool for syncing Framer code components - controller-centric architecture",
   "main": "dist/index.js",
   "type": "module",
@@ -19,18 +19,18 @@
   "author": "",
   "license": "MIT",
   "dependencies": {
-    "@typescript/ata": "^0.9.7",
-    "chokidar": "^4.0.3",
-    "commander": "^12.1.0",
-    "prettier": "^3.6.2",
-    "typescript": "^5.7.2",
-    "ws": "^8.18.0"
+    "@typescript/ata": "^0.9.8",
+    "chokidar": "^5.0.0",
+    "commander": "^14.0.2",
+    "prettier": "^3.7.4",
+    "typescript": "^5.9.3",
+    "ws": "^8.18.3"
   },
   "devDependencies": {
-    "@types/node": "^22.10.2",
-    "@types/ws": "^8.5.13",
-    "tsdown": "^0.2.17",
-    "tsx": "^4.19.2",
-    "vitest": "^2.1.8"
+    "@types/node": "^22.19.2",
+    "@types/ws": "^8.18.1",
+    "tsdown": "^0.17.4",
+    "tsx": "^4.21.0",
+    "vitest": "^4.0.15"
   }
 }

package/src/controller.test.ts

@@ -1,98 +1,7 @@
-import { describe, it, expect, vi, beforeEach } from "vitest"
-import { transition } from "./controller.js"
-import { createHashTracker } from "./utils/hashing.js"
-import type { Conflict, Config } from "./types.js"
-import type { Installer } from "./helpers/installer.js"
-import * as connection from "./helpers/connection.js"
-import * as filesHelper from "./helpers/files.js"
-import * as statePersistence from "./utils/state-persistence.js"
+import { describe, it, expect } from "vitest"
+import { filterEchoedFiles, transition } from "./controller.js"
+import { createHashTracker } from "./utils/hash-tracker.js"
 import type { WebSocket } from "ws"
-import { UserActionCoordinator } from "./helpers/user-actions.js"
-
-vi.mock("ws", () => {
-  class MockWebSocket {
-    send(
-      _data: string,
-      callback: (err?: Error | null) => void = () => undefined
-    ) {
-      callback(null)
-    }
-  }
-
-  class MockWebSocketServer {
-    constructor(_options: unknown) {}
-    on(): void {}
-    close(): void {}
-  }
-
-  return {
-    WebSocket: MockWebSocket,
-    WebSocketServer: MockWebSocketServer,
-  }
-})
-
-const sendMessageSpy = vi.spyOn(connection, "sendMessage")
-const writeRemoteFilesSpy = vi.spyOn(filesHelper, "writeRemoteFiles")
-const savePersistedStateSpy = vi.spyOn(statePersistence, "savePersistedState")
-const readFileSafeSpy = vi.spyOn(filesHelper, "readFileSafe")
-
-function createState(): RuntimeState {
-  return {
-    socket: {} as WebSocket,
-    initialSyncComplete: false,
-    pendingWrites: [],
-    pendingLocalAdds: [],
-    lastRemoteSync: new Map(),
-  }
-}
-
-function createConfig(): Config & { projectDir: string; filesDir: string } {
-  return {
-    port: 0,
-    projectHash: "test-project",
-    projectDir: "/tmp/project",
-    filesDir: "/tmp/project/files",
-    dangerouslyAutoDelete: false,
-  }
-}
-
-function createInstaller(): Installer {
-  return {
-    process: vi.fn(),
-  } as unknown as Installer
-}
-
-function createMockUserActions(): UserActionCoordinator & {
-  requestDeleteDecision: ReturnType<typeof vi.fn>
-  requestConflictDecisions: ReturnType<typeof vi.fn>
-  handleConfirmation: ReturnType<typeof vi.fn>
-  cleanup: ReturnType<typeof vi.fn>
-} {
-  return {
-    requestDeleteDecision: vi.fn(),
-    requestConflictDecisions: vi.fn(),
-    handleConfirmation: vi.fn(),
-    cleanup: vi.fn(),
-  } as unknown as UserActionCoordinator & {
-    requestDeleteDecision: ReturnType<typeof vi.fn>
-    requestConflictDecisions: ReturnType<typeof vi.fn>
-    handleConfirmation: ReturnType<typeof vi.fn>
-    cleanup: ReturnType<typeof vi.fn>
-  }
-}
-
-beforeEach(() => {
-  sendMessageSpy.mockReset()
-  sendMessageSpy.mockResolvedValue()
-  writeRemoteFilesSpy.mockReset()
-  writeRemoteFilesSpy.mockResolvedValue()
-  savePersistedStateSpy.mockReset()
-  savePersistedStateSpy.mockResolvedValue()
-  readFileSafeSpy.mockReset()
-  readFileSafeSpy.mockResolvedValue(null)
-})
-
-// Legacy tests - commented out after state machine migration
 describe("State Machine", () => {
   describe("HANDSHAKE transition", () => {
     it("transitions from disconnected to handshaking", () => {
@@ -176,7 +85,7 @@ describe("State Machine", () => {
       expect(result.effects[0]).toMatchObject({ type: "PERSIST_STATE" })
       expect(result.effects[1]).toMatchObject({
         type: "LOG",
-        level: "info",
+        level: "debug",
       })
     })
   })
@@ -206,7 +115,7 @@ describe("State Machine", () => {
       expect(result.effects).toHaveLength(2)
       expect(result.effects[0]).toMatchObject({
         type: "LOG",
-        level: "info",
+        level: "debug",
       })
       expect(result.effects[1]).toMatchObject({
         type: "DETECT_CONFLICTS",
@@ -362,7 +271,7 @@ describe("State Machine", () => {
   })
 
   describe("REMOTE_FILE_DELETE transition", () => {
-    it("requests confirmation in watching mode", () => {
+    it("applies delete immediately in watching mode", () => {
       const initialState = {
         mode: "watching" as const,
         socket: {} as WebSocket,
@@ -387,36 +296,9 @@ describe("State Machine", () => {
       })
 
       expect(result.state.mode).toBe("watching")
-      expect(
-        result.effects.some((e) => e.type === "REQUEST_DELETE_CONFIRMATION")
-      ).toBe(true)
-      const confirmEffect = result.effects.find(
-        (e) => e.type === "REQUEST_DELETE_CONFIRMATION"
+      expect(result.effects.some((e) => e.type === "DELETE_LOCAL_FILES")).toBe(
+        true
       )
-      expect(confirmEffect).toMatchObject({
-        type: "REQUEST_DELETE_CONFIRMATION",
-        fileName: "Test.tsx",
-        requireConfirmation: true,
-      })
-    })
-
-    it("auto-deletes when autoDelete is true", () => {
-      const initialState = {
-        mode: "watching" as const,
-        socket: {} as WebSocket,
-        files: new Map(),
-        queuedDiffs: [],
-        pendingOperations: new Map(),
-        nextOperationId: 1,
-      }
-
-      const result = transition(initialState, {
-        type: "REMOTE_FILE_DELETE",
-        fileName: "Test.tsx",
-        autoDelete: true,
-      })
-
-      expect(result.state.mode).toBe("watching")
       const deleteEffect = result.effects.find(
         (e) => e.type === "DELETE_LOCAL_FILES"
       )
@@ -424,12 +306,10 @@ describe("State Machine", () => {
         type: "DELETE_LOCAL_FILES",
         names: ["Test.tsx"],
       })
-      expect(
-        result.effects.some((e) => e.type === "PERSIST_STATE")
-      ).toBe(true)
+      expect(result.effects.some((e) => e.type === "PERSIST_STATE")).toBe(true)
     })
 
-    it("queues deletes during snapshot processing", () => {
+    it("applies deletes immediately during snapshot processing", () => {
       const initialState = {
         mode: "snapshot_processing" as const,
         socket: {} as WebSocket,
@@ -445,7 +325,9 @@ describe("State Machine", () => {
       })
 
       expect(result.state.mode).toBe("snapshot_processing")
-      expect(result.effects.some((e) => e.type === "DELETE_FILES")).toBe(false)
+      expect(result.effects.some((e) => e.type === "DELETE_LOCAL_FILES")).toBe(
+        true
+      )
       expect(result.effects.some((e) => e.type === "LOG")).toBe(true)
     })
 
@@ -465,7 +347,9 @@ describe("State Machine", () => {
       })
 
       expect(result.state.mode).toBe("disconnected")
-      expect(result.effects.some((e) => e.type === "DELETE_FILES")).toBe(false)
+      expect(result.effects.some((e) => e.type === "DELETE_LOCAL_FILES")).toBe(
+        false
+      )
       expect(
         result.effects.some((e) => e.type === "LOG" && e.level === "warn")
       ).toBe(true)
@@ -665,7 +549,7 @@ describe("State Machine", () => {
 
     it("ignores events when disconnected", () => {
       const initialState = {
-        mode: "watching" as const,
+        mode: "disconnected" as const,
         socket: null,
         files: new Map(),
         queuedDiffs: [],
@@ -774,13 +658,15 @@ describe("State Machine", () => {
       const writeEffects = result.effects.filter(
         (e) => e.type === "WRITE_FILES"
       )
-      expect(writeEffects).toHaveLength(1)
+      // Each conflict gets its own WRITE_FILES effect
+      expect(writeEffects).toHaveLength(2)
       expect(writeEffects[0]).toMatchObject({
         type: "WRITE_FILES",
-        files: [
-          { name: "Test1.tsx", content: "remote 1" },
-          { name: "Test2.tsx", content: "remote 2" },
-        ],
+        files: [{ name: "Test1.tsx", content: "remote 1" }],
+      })
+      expect(writeEffects[1]).toMatchObject({
+        type: "WRITE_FILES",
+        files: [{ name: "Test2.tsx", content: "remote 2" }],
       })
       expect(result.effects.some((e) => e.type === "PERSIST_STATE")).toBe(true)
     })
@@ -963,4 +849,43 @@ describe("State Machine", () => {
       }
     })
   })
+
+  describe("echo prevention filter", () => {
+    it("skips inbound file-change that matches last local send", () => {
+      const hashTracker = createHashTracker()
+      hashTracker.remember("Hey.tsx", "content")
+
+      const filtered = filterEchoedFiles(
+        [
+          {
+            name: "Hey.tsx",
+            content: "content",
+            modifiedAt: Date.now(),
+          },
+        ],
+        hashTracker
+      )
+
+      expect(filtered).toHaveLength(0)
+    })
+
+    it("keeps inbound change when content differs", () => {
+      const hashTracker = createHashTracker()
+      hashTracker.remember("Hey.tsx", "old content")
+
+      const filtered = filterEchoedFiles(
+        [
+          {
+            name: "Hey.tsx",
+            content: "new content",
+            modifiedAt: Date.now(),
+          },
+        ],
+        hashTracker
+      )
+
+      expect(filtered).toHaveLength(1)
+      expect(filtered[0]?.content).toBe("new content")
+    })
+  })
 })