framer-code-link 0.1.4 → 0.2.1

package/src/controller.ts

@@ -1,1368 +0,0 @@
-/**
- * Controller
- * Single source of truth for all runtime state and orchestrates the sync lifecycle.
- * Helpers are functions that provide data - they never hold control or callbacks.
- */
-
-import fs from "fs/promises"
-import type { WebSocket } from "ws"
-import type {
-  Config,
-  IncomingMessage,
-  OutgoingMessage,
-  FileInfo,
-  Conflict,
-  WatcherEvent,
-  ConflictVersionData,
-} from "./types.js"
-import { initConnection, sendMessage } from "./helpers/connection.js"
-import { initWatcher } from "./helpers/watcher.js"
-import {
-  listFiles,
-  detectConflicts,
-  writeRemoteFiles,
-  deleteLocalFile,
-  readFileSafe,
-  autoResolveConflicts,
-} from "./helpers/files.js"
-import { Installer } from "./helpers/installer.js"
-import { createHashTracker } from "./utils/hash-tracker.js"
-import {
-  info,
-  warn,
-  error,
-  success,
-  debug,
-  status,
-  fileDown,
-  fileUp,
-  fileDelete,
-  scheduleDisconnectMessage,
-  cancelDisconnectMessage,
-  didShowDisconnect,
-  wasRecentlyDisconnected,
-  resetDisconnectState,
-} from "./utils/logging.js"
-import { hashFileContent } from "./utils/state-persistence.js"
-import {
-  FileMetadataCache,
-  type FileSyncMetadata,
-} from "./utils/file-metadata-cache.js"
-import { UserActionCoordinator } from "./helpers/user-actions.js"
-import { validateIncomingChange } from "./helpers/sync-validator.js"
-import { findOrCreateProjectDir } from "./utils/project.js"
-import { pluralize, shortProjectHash } from "@code-link/shared"
-
-/**
- * Explicit sync lifecycle modes
- */
-export type SyncMode =
-  | "disconnected"
-  | "handshaking"
-  | "snapshot_processing"
-  | "conflict_resolution"
-  | "watching"
-
-/**
- * Pending operation for echo suppression and replay
- */
-type PendingOperation =
-  | { id: string; type: "write"; file: string; hash: string }
-  | { id: string; type: "delete"; file: string; previousHash?: string }
-
-/**
- * Shared state that persists across all lifecycle modes
- */
-interface SyncStateBase {
-  queuedDiffs: FileInfo[]
-  pendingOperations: Map<string, PendingOperation>
-  nextOperationId: number
-}
-
-type DisconnectedState = SyncStateBase & {
-  mode: "disconnected"
-  socket: null
-}
-
-type HandshakingState = SyncStateBase & {
-  mode: "handshaking"
-  socket: WebSocket
-}
-
-type SnapshotProcessingState = SyncStateBase & {
-  mode: "snapshot_processing"
-  socket: WebSocket
-}
-
-type ConflictResolutionState = SyncStateBase & {
-  mode: "conflict_resolution"
-  socket: WebSocket
-  pendingConflicts: Conflict[]
-}
-
-type WatchingState = SyncStateBase & {
-  mode: "watching"
-  socket: WebSocket
-}
-
-export type SyncState =
-  | DisconnectedState
-  | HandshakingState
-  | SnapshotProcessingState
-  | ConflictResolutionState
-  | WatchingState
-
-/**
- * Events that drive state transitions
- */
-type SyncEvent =
-  | {
-      type: "HANDSHAKE"
-      socket: WebSocket
-      projectInfo: { projectId: string; projectName: string }
-    }
-  | { type: "REQUEST_FILES" }
-  | { type: "FILE_LIST"; files: FileInfo[] }
-  | {
-      type: "CONFLICTS_DETECTED"
-      conflicts: Conflict[]
-      safeWrites: FileInfo[]
-      localOnly: FileInfo[]
-    }
-  | { type: "FILE_CHANGE"; file: FileInfo; fileMeta?: FileSyncMetadata }
-  | { type: "REMOTE_FILE_DELETE"; fileName: string }
-  | { type: "REMOTE_DELETE_CONFIRMED"; fileName: string }
-  | { type: "REMOTE_DELETE_CANCELLED"; fileName: string; content: string }
-  | {
-      type: "CONFLICTS_RESOLVED"
-      resolution: "local" | "remote"
-    }
-  | {
-      type: "FILE_SYNCED"
-      fileName: string
-      remoteModifiedAt: number
-    }
-  | { type: "DISCONNECT" }
-  | { type: "WATCHER_EVENT"; event: WatcherEvent }
-  | {
-      type: "CONFLICT_VERSION_RESPONSE"
-      versions: ConflictVersionData[]
-    }
-
-/**
- * Side effects emitted by transitions
- */
-type Effect =
-  | {
-      type: "INIT_WORKSPACE"
-      projectInfo: { projectId: string; projectName: string }
-    }
-  | { type: "LOAD_PERSISTED_STATE" }
-  | { type: "SEND_MESSAGE"; payload: OutgoingMessage }
-  | { type: "LIST_LOCAL_FILES" }
-  | { type: "DETECT_CONFLICTS"; remoteFiles: FileInfo[] }
-  | { type: "WRITE_FILES"; files: FileInfo[]; silent?: boolean }
-  | { type: "DELETE_LOCAL_FILES"; names: string[] }
-  | { type: "REQUEST_CONFLICT_DECISIONS"; conflicts: Conflict[] }
-  | { type: "REQUEST_CONFLICT_VERSIONS"; conflicts: Conflict[] }
-  | {
-      type: "REQUEST_DELETE_CONFIRMATION"
-      fileName: string
-      requireConfirmation: boolean
-    }
-  | {
-      type: "UPDATE_FILE_METADATA"
-      fileName: string
-      remoteModifiedAt: number
-    }
-  | {
-      type: "SEND_LOCAL_CHANGE"
-      fileName: string
-      content: string
-    }
-  | {
-      type: "REQUEST_LOCAL_DELETE_DECISION"
-      fileName: string
-      requireConfirmation: boolean
-    }
-  | { type: "PERSIST_STATE" }
-  | {
-      type: "SYNC_COMPLETE"
-      totalCount: number
-      updatedCount: number
-      unchangedCount: number
-    }
-  | { type: "LOG"; level: "info" | "debug" | "warn"; message: string }
-
-/** Log helper */
-function log(level: "info" | "debug" | "warn", message: string): Effect {
-  return { type: "LOG", level, message }
-}
-
-/**
- * Pure state transition function
- * Takes current state + event, returns new state + effects to execute
- */
-function transition(
-  state: SyncState,
-  event: SyncEvent
-): { state: SyncState; effects: Effect[] } {
-  const effects: Effect[] = []
-
-  switch (event.type) {
-    case "HANDSHAKE": {
-      if (state.mode !== "disconnected") {
-        effects.push(
-          log("warn", `Received HANDSHAKE in mode ${state.mode}, ignoring`)
-        )
-        return { state, effects }
-      }
-
-      effects.push(
-        { type: "INIT_WORKSPACE", projectInfo: event.projectInfo },
-        { type: "LOAD_PERSISTED_STATE" },
-        { type: "SEND_MESSAGE", payload: { type: "request-files" } }
-      )
-
-      return {
-        state: {
-          ...state,
-          mode: "handshaking",
-          socket: event.socket,
-        },
-        effects,
-      }
-    }
-
-    case "FILE_SYNCED": {
-      // Remote confirms they received our local change
-      effects.push(log("debug", `Remote confirmed sync: ${event.fileName}`), {
-        type: "UPDATE_FILE_METADATA",
-        fileName: event.fileName,
-        remoteModifiedAt: event.remoteModifiedAt,
-      })
-
-      return { state, effects }
-    }
-
-    case "DISCONNECT": {
-      effects.push(
-        { type: "PERSIST_STATE" },
-        log("debug", "Disconnected, persisting state")
-      )
-
-      if (state.mode === "conflict_resolution") {
-        const { pendingConflicts: _discarded, ...rest } = state
-        return {
-          state: {
-            ...rest,
-            mode: "disconnected",
-            socket: null,
-          },
-          effects,
-        }
-      }
-
-      return {
-        state: {
-          ...state,
-          mode: "disconnected",
-          socket: null,
-        },
-        effects,
-      }
-    }
-
-    case "REQUEST_FILES": {
-      // Plugin is asking for our local file list
-      // Valid in any mode except disconnected
-      if (state.mode === "disconnected") {
-        effects.push(
-          log("warn", "Received REQUEST_FILES while disconnected, ignoring")
-        )
-        return { state, effects }
-      }
-
-      effects.push(log("debug", "Plugin requested file list"), {
-        type: "LIST_LOCAL_FILES",
-      })
-
-      return { state, effects }
-    }
-
-    case "FILE_LIST": {
-      if (state.mode !== "handshaking") {
-        effects.push(
-          log("warn", `Received FILE_LIST in mode ${state.mode}, ignoring`)
-        )
-        return { state, effects }
-      }
-
-      effects.push(
-        log("debug", `Received file list: ${event.files.length} files`)
-      )
-
-      // Detect conflicts between remote snapshot and local files
-      effects.push({
-        type: "DETECT_CONFLICTS",
-        remoteFiles: event.files,
-      })
-
-      // Transition to snapshot_processing - conflict detection effect will determine next mode
-      return {
-        state: {
-          ...state,
-          mode: "snapshot_processing",
-          queuedDiffs: event.files,
-        },
-        effects,
-      }
-    }
-
-    case "CONFLICTS_DETECTED": {
-      if (state.mode !== "snapshot_processing") {
-        effects.push(
-          log(
-            "warn",
-            `Received CONFLICTS_DETECTED in mode ${state.mode}, ignoring`
-          )
-        )
-        return { state, effects }
-      }
-
-      const { conflicts, safeWrites, localOnly } = event
-
-      // detectConflicts returns:
-      // - safeWrites = files we can apply (remote-only or local unchanged)
-      // - conflicts = files that need manual resolution (content or deletion conflicts)
-      // - localOnly = files to upload
-
-      // Apply safe writes
-      if (safeWrites.length > 0) {
-        effects.push(
-          log("debug", `Applying ${safeWrites.length} safe writes`),
-          { type: "WRITE_FILES", files: safeWrites, silent: true }
-        )
-      }
-
-      // Upload local-only files
-      if (localOnly.length > 0) {
-        effects.push(
-          log("debug", `Uploading ${localOnly.length} local-only files`)
-        )
-        for (const file of localOnly) {
-          effects.push({
-            type: "SEND_MESSAGE",
-            payload: {
-              type: "file-change",
-              fileName: file.name,
-              content: file.content,
-            },
-          })
-        }
-      }
-
-      // If conflicts remain, request remote version data before surfacing to user
-      if (conflicts.length > 0) {
-        effects.push(
-          log(
-            "debug",
-            `${pluralize(conflicts.length, "conflict")} require version check`
-          ),
-          { type: "REQUEST_CONFLICT_VERSIONS", conflicts }
-        )
-
-        return {
-          state: {
-            ...state,
-            mode: "conflict_resolution",
-            pendingConflicts: conflicts,
-          },
-          effects,
-        }
-      }
-
-      // No conflicts - transition to watching
-      const totalSynced = safeWrites.length + localOnly.length
-      const remoteTotal = state.queuedDiffs.length
-      const totalCount = remoteTotal + localOnly.length
-      const updatedCount = safeWrites.length + localOnly.length
-      const unchangedCount = Math.max(0, remoteTotal - safeWrites.length)
-      effects.push(
-        { type: "PERSIST_STATE" },
-        {
-          type: "SYNC_COMPLETE",
-          totalCount,
-          updatedCount,
-          unchangedCount,
-        }
-      )
-
-      return {
-        state: {
-          ...state,
-          mode: "watching",
-          queuedDiffs: [],
-        },
-        effects,
-      }
-    }
-
-    case "FILE_CHANGE": {
-      // Use helper to validate the incoming change
-      const validation = validateIncomingChange(
-        event.file,
-        event.fileMeta,
-        state.mode
-      )
-
-      if (validation.action === "queue") {
-        effects.push(
-          log(
-            "debug",
-            `Queueing file change: ${event.file.name} (${validation.reason})`
-          )
-        )
-
-        return {
-          state: {
-            ...state,
-            queuedDiffs: [...state.queuedDiffs, event.file],
-          },
-          effects,
-        }
-      }
-
-      if (validation.action === "reject") {
-        effects.push(
-          log(
-            "warn",
-            `Rejected file change: ${event.file.name} (${validation.reason})`
-          )
-        )
-        return { state, effects }
-      }
-
-      // Apply the change
-      effects.push(log("debug", `Applying remote change: ${event.file.name}`), {
-        type: "WRITE_FILES",
-        files: [event.file],
-      })
-
-      return { state, effects }
-    }
-
-    case "REMOTE_FILE_DELETE": {
-      // Reject if not connected
-      if (state.mode === "disconnected") {
-        effects.push(
-          log("warn", `Rejected delete while disconnected: ${event.fileName}`)
-        )
-        return { state, effects }
-      }
-
-      // Remote deletes should always be applied immediately
-      // (the file is already gone from Framer)
-      effects.push(
-        log("debug", `Remote delete applied: ${event.fileName}`),
-        { type: "DELETE_LOCAL_FILES", names: [event.fileName] },
-        { type: "PERSIST_STATE" }
-      )
-
-      return { state, effects }
-    }
-
-    case "REMOTE_DELETE_CONFIRMED": {
-      // User confirmed the delete - apply it
-      effects.push(
-        log("debug", `Delete confirmed: ${event.fileName}`),
-        { type: "DELETE_LOCAL_FILES", names: [event.fileName] },
-        { type: "PERSIST_STATE" }
-      )
-
-      return { state, effects }
-    }
-
-    case "REMOTE_DELETE_CANCELLED": {
-      // User cancelled - restore the file
-      effects.push(log("debug", `Delete cancelled: ${event.fileName}`))
-      effects.push({
-        type: "WRITE_FILES",
-        files: [
-          {
-            name: event.fileName,
-            content: event.content,
-            modifiedAt: Date.now(),
-          },
-        ],
-      })
-
-      return { state, effects }
-    }
-
-    case "CONFLICTS_RESOLVED": {
-      // Only valid in conflict_resolution mode
-      if (state.mode !== "conflict_resolution") {
-        effects.push(
-          log(
-            "warn",
-            `Received CONFLICTS_RESOLVED in mode ${state.mode}, ignoring`
-          )
-        )
-        return { state, effects }
-      }
-
-      // User picked one resolution for ALL conflicts
-      if (event.resolution === "remote") {
-        // Apply all remote versions (or delete locally if remote is null)
-        for (const conflict of state.pendingConflicts) {
-          if (conflict.remoteContent === null) {
-            // Remote deleted this file - delete locally
-            effects.push({
-              type: "DELETE_LOCAL_FILES",
-              names: [conflict.fileName],
-            })
-          } else {
-            effects.push({
-              type: "WRITE_FILES",
-              files: [
-                {
-                  name: conflict.fileName,
-                  content: conflict.remoteContent,
-                  modifiedAt: conflict.remoteModifiedAt,
-                },
-              ],
-            })
-          }
-        }
-        effects.push(
-          log(
-            "debug",
-            `Applied ${state.pendingConflicts.length} remote versions`
-          )
-        )
-      } else {
-        // Send all local versions (or delete from Framer if local is null)
-        for (const conflict of state.pendingConflicts) {
-          if (conflict.localContent === null) {
-            // Local deleted this file - delete from Framer
-            effects.push({
-              type: "SEND_MESSAGE",
-              payload: {
-                type: "file-delete",
-                fileNames: [conflict.fileName],
-              },
-            })
-          } else {
-            effects.push({
-              type: "SEND_MESSAGE",
-              payload: {
-                type: "file-change",
-                fileName: conflict.fileName,
-                content: conflict.localContent,
-              },
-            })
-          }
-        }
-        effects.push(
-          log(
-            "debug",
-            `Applied ${state.pendingConflicts.length} local versions`
-          )
-        )
-      }
-
-      // All conflicts resolved - transition to watching
-      effects.push(
-        { type: "PERSIST_STATE" },
-        {
-          type: "SYNC_COMPLETE",
-          totalCount: state.pendingConflicts.length,
-          updatedCount: state.pendingConflicts.length,
-          unchangedCount: 0,
-        }
-      )
-
-      const { pendingConflicts: _discarded, ...rest } = state
-      return {
-        state: {
-          ...rest,
-          mode: "watching",
-        },
-        effects,
-      }
-    }
-
-    case "WATCHER_EVENT": {
-      // Local file system change detected
-      const { kind, relativePath, content } = event.event
-
-      // Only process changes in watching mode
-      if (state.mode !== "watching") {
-        effects.push(
-          log(
-            "debug",
-            `Ignoring watcher event in ${state.mode} mode: ${kind} ${relativePath}`
-          )
-        )
-        return { state, effects }
-      }
-
-      switch (kind) {
-        case "add":
-        case "change": {
-          if (content === undefined) {
-            effects.push(
-              log("warn", `Watcher event missing content: ${relativePath}`)
-            )
-            return { state, effects }
-          }
-
-          effects.push({
-            type: "SEND_LOCAL_CHANGE",
-            fileName: relativePath,
-            content,
-          })
-          break
-        }
-
-        case "delete": {
-          effects.push(log("debug", `Local delete detected: ${relativePath}`), {
-            type: "REQUEST_LOCAL_DELETE_DECISION",
-            fileName: relativePath,
-            requireConfirmation: true, // Will be overridden by config in effect
-          })
-          break
-        }
-      }
-
-      return { state, effects }
-    }
-
-    case "CONFLICT_VERSION_RESPONSE": {
-      if (state.mode !== "conflict_resolution") {
-        effects.push(
-          log(
-            "warn",
-            `Received CONFLICT_VERSION_RESPONSE in mode ${state.mode}, ignoring`
-          )
-        )
-        return { state, effects }
-      }
-
-      const { autoResolvedLocal, autoResolvedRemote, remainingConflicts } =
-        autoResolveConflicts(state.pendingConflicts, event.versions)
-
-      if (autoResolvedLocal.length > 0) {
-        effects.push(
-          log(
-            "debug",
-            `Auto-resolved ${autoResolvedLocal.length} local changes`
-          )
-        )
-        for (const conflict of autoResolvedLocal) {
-          if (conflict.localContent === null) {
-            // Local deleted - delete from Framer
-            effects.push({
-              type: "SEND_MESSAGE",
-              payload: {
-                type: "file-delete",
-                fileNames: [conflict.fileName],
-              },
-            })
-          } else {
-            effects.push({
-              type: "SEND_LOCAL_CHANGE",
-              fileName: conflict.fileName,
-              content: conflict.localContent,
-            })
-          }
-        }
-      }
-
-      if (autoResolvedRemote.length > 0) {
-        effects.push(
-          log(
-            "debug",
-            `Auto-resolved ${autoResolvedRemote.length} remote changes`
-          )
-        )
-        for (const conflict of autoResolvedRemote) {
-          if (conflict.remoteContent === null) {
-            // Remote deleted - delete locally
-            effects.push({
-              type: "DELETE_LOCAL_FILES",
-              names: [conflict.fileName],
-            })
-          } else {
-            effects.push({
-              type: "WRITE_FILES",
-              files: [
-                {
-                  name: conflict.fileName,
-                  content: conflict.remoteContent,
-                  modifiedAt: conflict.remoteModifiedAt ?? Date.now(),
-                },
-              ],
-            })
-          }
-        }
-      }
-
-      if (remainingConflicts.length > 0) {
-        effects.push(
-          log(
-            "warn",
-            `${pluralize(remainingConflicts.length, "conflict")} require resolution`
-          ),
-          { type: "REQUEST_CONFLICT_DECISIONS", conflicts: remainingConflicts }
-        )
-
-        return {
-          state: {
-            ...state,
-            pendingConflicts: remainingConflicts,
-          },
-          effects,
-        }
-      }
-
-      const resolvedCount = autoResolvedLocal.length + autoResolvedRemote.length
-      effects.push(
-        { type: "PERSIST_STATE" },
-        {
-          type: "SYNC_COMPLETE",
-          totalCount: resolvedCount,
-          updatedCount: resolvedCount,
-          unchangedCount: 0,
-        }
-      )
-
-      const { pendingConflicts: _discarded, ...rest } = state
-      return {
-        state: {
-          ...rest,
-          mode: "watching",
-          queuedDiffs: [],
-        },
-        effects,
-      }
-    }
-
-    default: {
-      effects.push(log("warn", `Unhandled event type in transition`))
-      return { state, effects }
-    }
-  }
-}
-
-/**
- * Effect executor - interprets effects and calls helpers
- * Returns additional events that should be processed (e.g., CONFLICTS_DETECTED after DETECT_CONFLICTS)
- */
-async function executeEffect(
-  effect: Effect,
-  context: {
-    config: Config
-    hashTracker: ReturnType<typeof createHashTracker>
-    installer: Installer | null
-    fileMetadataCache: FileMetadataCache
-    userActions: UserActionCoordinator
-    syncState: SyncState
-  }
-): Promise<SyncEvent[]> {
-  const {
-    config,
-    hashTracker,
-    installer,
-    fileMetadataCache,
-    userActions,
-    syncState,
-  } = context
-
-  switch (effect.type) {
-    case "INIT_WORKSPACE": {
-      // Initialize project directory if not already set
-      if (!config.projectDir) {
-        const projectName =
-          config.explicitName ?? effect.projectInfo.projectName
-        config.projectDir = await findOrCreateProjectDir(
-          config.projectHash,
-          projectName,
-          config.explicitDir
-        )
-        config.filesDir = `${config.projectDir}/files`
-        debug(`Files directory: ${config.filesDir}`)
-
-        // Create files directory
-        await fs.mkdir(config.filesDir, { recursive: true })
-      }
-      return []
-    }
-
-    case "LOAD_PERSISTED_STATE": {
-      if (config.projectDir) {
-        await fileMetadataCache.initialize(config.projectDir)
-        debug(`Loaded persisted metadata for ${fileMetadataCache.size()} files`)
-      }
-      return []
-    }
-
-    case "LIST_LOCAL_FILES": {
-      if (!config.filesDir) {
-        return []
-      }
-
-      // List all local files and send to plugin
-      const files = await listFiles(config.filesDir)
-
-      if (syncState.socket) {
-        await sendMessage(syncState.socket, {
-          type: "file-list",
-          files,
-        })
-      }
-
-      return []
-    }
-
-    case "DETECT_CONFLICTS": {
-      if (!config.filesDir) {
-        return []
-      }
-
-      // Use existing helper to detect conflicts
-      const { conflicts, writes, localOnly } = await detectConflicts(
-        effect.remoteFiles,
-        config.filesDir,
-        { persistedState: fileMetadataCache.getPersistedState() }
-      )
-
-      // Return CONFLICTS_DETECTED event to continue the flow
-      return [
-        {
-          type: "CONFLICTS_DETECTED",
-          conflicts,
-          safeWrites: writes,
-          localOnly,
-        },
-      ]
-    }
-
-    case "SEND_MESSAGE": {
-      if (syncState.socket) {
-        const sent = await sendMessage(syncState.socket, effect.payload)
-        if (!sent) {
-          warn(`Failed to send message: ${effect.payload.type}`)
-        }
-      } else {
-        warn(`No socket available to send: ${effect.payload.type}`)
-      }
-      return []
-    }
-
-    case "WRITE_FILES": {
-      if (config.filesDir) {
-        await writeRemoteFiles(
-          effect.files,
-          config.filesDir,
-          hashTracker,
-          installer ?? undefined
-        )
-        for (const file of effect.files) {
-          if (!effect.silent) {
-            fileDown(file.name)
-          }
-          const remoteTimestamp = file.modifiedAt ?? Date.now()
-          fileMetadataCache.recordRemoteWrite(
-            file.name,
-            file.content,
-            remoteTimestamp
-          )
-        }
-      }
-      return []
-    }
-
-    case "DELETE_LOCAL_FILES": {
-      if (config.filesDir) {
-        for (const fileName of effect.names) {
-          await deleteLocalFile(fileName, config.filesDir, hashTracker)
-          fileDelete(fileName)
-          fileMetadataCache.recordDelete(fileName)
-        }
-      }
-      return []
-    }
-
-    case "REQUEST_CONFLICT_DECISIONS": {
-      await userActions.requestConflictDecisions(
-        syncState.socket,
-        effect.conflicts
-      )
-
-      return []
-    }
-
-    case "REQUEST_CONFLICT_VERSIONS": {
-      if (!syncState.socket) {
-        warn("Cannot request conflict versions without active socket")
-        return []
-      }
-
-      const persistedState = fileMetadataCache.getPersistedState()
-      const versionRequests = effect.conflicts.map((conflict) => {
-        const persisted = persistedState.get(conflict.fileName)
-        return {
-          fileName: conflict.fileName,
-          lastSyncedAt: conflict.lastSyncedAt ?? persisted?.timestamp,
-        }
-      })
-
-      debug(
-        `Requesting remote version data for ${pluralize(versionRequests.length, "file")}`
-      )
-
-      await sendMessage(syncState.socket, {
-        type: "conflict-version-request",
-        conflicts: versionRequests,
-      })
-
-      return []
-    }
-
-    case "REQUEST_DELETE_CONFIRMATION": {
-      if (syncState.socket) {
-        // Send delete request to plugin
-        await sendMessage(syncState.socket, {
-          type: "file-delete",
-          fileNames: [effect.fileName],
-          requireConfirmation: effect.requireConfirmation,
-        })
-      }
-      // Response will come via delete-confirmed or delete-cancelled message
-      return []
-    }
-
-    case "UPDATE_FILE_METADATA": {
-      if (!config.filesDir || !config.projectDir) {
-        return []
-      }
-
-      // Read current file content to compute hash
-      const currentContent = await readFileSafe(
-        effect.fileName,
-        config.filesDir
-      )
-
-      if (currentContent !== null) {
-        const contentHash = hashFileContent(currentContent)
-        fileMetadataCache.recordSyncedSnapshot(
-          effect.fileName,
-          contentHash,
-          effect.remoteModifiedAt
-        )
-      }
-
-      return []
-    }
-
-    case "SEND_LOCAL_CHANGE": {
-      const contentHash = hashFileContent(effect.content)
-      const metadata = fileMetadataCache.get(effect.fileName)
-
-      // Skip if file matches last confirmed remote content
-      if (metadata?.lastSyncedHash === contentHash) {
-        debug(
-          `Skipping local change for ${effect.fileName}: matches last synced content`
-        )
-        return []
-      }
-
-      // Echo prevention: skip if we just wrote this exact content
-      if (hashTracker.shouldSkip(effect.fileName, effect.content)) {
-        return []
-      }
-
-      debug(`Local change detected: ${effect.fileName}`)
-
-      try {
-        // Send change to plugin
-        if (syncState.socket) {
-          await sendMessage(syncState.socket, {
-            type: "file-change",
-            fileName: effect.fileName,
-            content: effect.content,
-          })
-          fileUp(effect.fileName)
-        }
-
-        // Only remember hash after successful send (prevents re-sending on failure)
-        hashTracker.remember(effect.fileName, effect.content)
-
-        // Trigger type installer
-        if (installer) {
-          installer.process(effect.fileName, effect.content)
-        }
-      } catch (err) {
-        warn(`Failed to push ${effect.fileName}`)
-      }
-
-      return []
-    }
-
-    case "REQUEST_LOCAL_DELETE_DECISION": {
-      // Echo prevention: skip if this is a remote-initiated delete
-      const shouldSkip = hashTracker.shouldSkipDelete(effect.fileName)
-
-      if (shouldSkip) {
-        // Clear the delete marker now that we've caught the echo
-        hashTracker.clearDelete(effect.fileName)
-        return []
-      }
-
-      try {
-        const shouldDelete = await userActions.requestDeleteDecision(
-          syncState.socket,
-          {
-            fileName: effect.fileName,
-            requireConfirmation: !config.dangerouslyAutoDelete,
-          }
-        )
-
-        if (shouldDelete) {
-          hashTracker.forget(effect.fileName)
-          fileMetadataCache.recordDelete(effect.fileName)
-
-          if (syncState.socket) {
-            await sendMessage(syncState.socket, {
-              type: "file-delete",
-              fileNames: [effect.fileName],
-            })
-          }
-        }
-      } catch (err) {
-        console.warn(`Failed to handle deletion for ${effect.fileName}:`, err)
-      }
-
-      return []
-    }
-
-    case "PERSIST_STATE": {
-      await fileMetadataCache.flush()
-      return []
-    }
-
-    case "SYNC_COMPLETE": {
-      const wasDisconnected = wasRecentlyDisconnected()
-
-      if (wasDisconnected) {
-        // Only show reconnect message if we actually showed the disconnect notice
-        if (didShowDisconnect()) {
-          success(
-            `Reconnected, synced ${effect.totalCount} files (${effect.updatedCount} updated, ${effect.unchangedCount} unchanged)`
-          )
-          status("Watching for changes...")
-        }
-        resetDisconnectState()
-        return []
-      }
-
-      success(
-        `Synced ${effect.totalCount} files (${effect.updatedCount} updated, ${effect.unchangedCount} unchanged)`
-      )
-      status("Watching for changes...")
-      return []
-    }
-
-    case "LOG": {
-      const logFn =
-        effect.level === "info" ? info : effect.level === "warn" ? warn : debug
-      logFn(effect.message)
-      return []
-    }
-  }
-}
-
-/**
- * Starts the sync controller with the given configuration
- */
-export async function start(config: Config): Promise<void> {
-  status("Waiting for Plugin connection...")
-
-  const hashTracker = createHashTracker()
-  const fileMetadataCache = new FileMetadataCache()
-  let installer: Installer | null = null
-
-  // State machine state
-  let syncState: SyncState = {
-    mode: "disconnected",
-    socket: null,
-    queuedDiffs: [],
-    pendingOperations: new Map(),
-    nextOperationId: 1,
-  }
-
-  const userActions = new UserActionCoordinator()
-
-  // State Machine Execution Helper
-  // Process events through state machine and execute effects recursively
-  async function processEvent(event: SyncEvent) {
-    const socketState = syncState.socket?.readyState
-    debug(
-      `[STATE] Processing event: ${event.type} (mode: ${syncState.mode}, socket: ${socketState ?? "none"})`
-    )
-
-    const result = transition(syncState, event)
-    syncState = result.state
-
-    if (result.effects.length > 0) {
-      debug(
-        `[STATE] Event produced ${result.effects.length} effects: ${result.effects.map((e) => e.type).join(", ")}`
-      )
-    }
-
-    // Execute all effects and process any follow-up events
-    for (const effect of result.effects) {
-      // Check socket state before each effect
-      const currentSocketState = syncState.socket?.readyState
-      if (currentSocketState !== undefined && currentSocketState !== 1) {
-        debug(
-          `[STATE] Socket not open (state: ${currentSocketState}) before executing ${effect.type}`
-        )
-      }
-
-      const followUpEvents = await executeEffect(effect, {
-        config,
-        hashTracker,
-        installer,
-        fileMetadataCache,
-        userActions,
-        syncState,
-      })
-
-      // Recursively process follow-up events
-      for (const followUpEvent of followUpEvents) {
-        await processEvent(followUpEvent)
-      }
-    }
-  }
-
-  // WebSocket Connection
-  const connection = await initConnection(config.port)
-
-  // Handle initial handshake
-  connection.on("handshake", async (client: WebSocket, message) => {
-    debug(`Received handshake: ${message.projectName} (${message.projectId})`)
-
-    // Validate project hash (normalize both to short hash for comparison)
-    const expectedShort = shortProjectHash(config.projectHash)
-    const receivedShort = shortProjectHash(message.projectId)
-    if (receivedShort !== expectedShort) {
-      warn(
-        `Project ID mismatch: expected ${expectedShort}, got ${receivedShort}`
-      )
-      client.close()
-      return
-    }
-
-    // Process handshake through state machine
-    await processEvent({
-      type: "HANDSHAKE",
-      socket: client,
-      projectInfo: {
-        projectId: message.projectId,
-        projectName: message.projectName,
-      },
-    })
-
-    // Initialize installer if needed
-    if (config.projectDir && !installer) {
-      installer = new Installer({ projectDir: config.projectDir })
-      await installer.initialize()
-      // Start file watcher now that we have a directory
-      startWatcher()
-    }
-
-    // Cancel any pending disconnect message (fast reconnect)
-    cancelDisconnectMessage()
-
-    // Only show "Connected" on initial connection, not reconnects
-    // Reconnect confirmation happens in SYNC_COMPLETE
-    const wasDisconnected = wasRecentlyDisconnected()
-    if (!wasDisconnected && !didShowDisconnect()) {
-      success(`Connected to ${message.projectName}`)
-    }
-  })
-
-  // Message Handler
-  async function handleMessage(message: IncomingMessage) {
-    // Ensure project is initialized before handling messages
-    if (!config.projectDir || !installer) {
-      warn("Received message before handshake completed - ignoring")
-      return
-    }
-
-    let event: SyncEvent | null = null
-
-    // Map incoming messages to state machine events
-    switch (message.type) {
-      case "request-files":
-        event = { type: "REQUEST_FILES" }
-        break
-
-      case "file-list": {
-        const totalSize = message.files.reduce(
-          (sum, f) => sum + (f.content?.length ?? 0),
-          0
-        )
-        debug(
-          `Received file list: ${message.files.length} files (${(totalSize / 1024).toFixed(1)}KB)`
-        )
-        event = { type: "FILE_LIST", files: message.files }
-        break
-      }
-
-      case "file-change":
-        event = {
-          type: "FILE_CHANGE",
-          file: {
-            name: message.fileName,
-            content: message.content,
-            // Remote modifiedAt is expensive to compute (requires getVerions API call), so we
-            // use local receipt time. Conflict detection uses content hashes, not timestamps.
-            modifiedAt: Date.now(),
-          },
-          fileMeta: fileMetadataCache.get(message.fileName),
-        }
-        break
-
-      case "file-delete": {
-        // Remote deletes are always applied immediately (file is already gone from Framer)
-        for (const fileName of message.fileNames) {
-          await processEvent({
-            type: "REMOTE_FILE_DELETE",
-            fileName,
-          })
-        }
-        return
-      }
-
-      case "delete-confirmed": {
-        const unmatched: string[] = []
-
-        for (const fileName of message.fileNames) {
-          const handled = userActions.handleConfirmation(
-            `delete:${fileName}`,
-            true
-          )
-
-          if (!handled) {
-            unmatched.push(fileName)
-          }
-        }
-
-        for (const fileName of unmatched) {
-          await processEvent({ type: "REMOTE_DELETE_CONFIRMED", fileName })
-        }
-
-        return
-      }
-
-      case "delete-cancelled": {
-        for (const file of message.files) {
-          userActions.handleConfirmation(`delete:${file.fileName}`, false)
-
-          await processEvent({
-            type: "REMOTE_DELETE_CANCELLED",
-            fileName: file.fileName,
-            content: file.content ?? "",
-          })
-        }
-
-        return
-      }
-
-      case "file-synced":
-        event = {
-          type: "FILE_SYNCED",
-          fileName: message.fileName,
-          remoteModifiedAt: message.remoteModifiedAt,
-        }
-        break
-
-      case "conflicts-resolved":
-        event = {
-          type: "CONFLICTS_RESOLVED",
-          resolution: message.resolution,
-        }
-        break
-
-      case "conflict-version-response":
-        event = {
-          type: "CONFLICT_VERSION_RESPONSE",
-          versions: message.versions,
-        }
-        break
-
-      default:
-        warn(`Unhandled message type: ${message.type}`)
-        return
-    }
-
-    if (event) {
-      await processEvent(event)
-    }
-  }
-
-  connection.on("message", async (message: IncomingMessage) => {
-    try {
-      await handleMessage(message)
-    } catch (err) {
-      error("Error handling message:", err)
-    }
-  })
-
-  connection.on("disconnect", async () => {
-    // Schedule disconnect message with delay - if reconnect happens quickly, we skip it
-    scheduleDisconnectMessage(() => {
-      status("Disconnected, waiting to reconnect...")
-    })
-    await processEvent({ type: "DISCONNECT" })
-    userActions.cleanup()
-  })
-
-  connection.on("error", (err) => {
-    error("Error on WebSocket connection:", err)
-  })
-
-  // File Watcher Setup
-  // Note: Watcher will be initialized after handshake when filesDir is set
-
-  let watcher: ReturnType<typeof initWatcher> | null = null
-
-  const startWatcher = () => {
-    if (!config.filesDir || watcher) return
-    watcher = initWatcher(config.filesDir)
-
-    watcher.on("change", async (event) => {
-      await processEvent({ type: "WATCHER_EVENT", event })
-    })
-  }
-
-  // Lifecycle - no additional startup messages needed (banner shown in index.ts)
-
-  // Graceful shutdown
-  process.on("SIGINT", async () => {
-    console.log() // newline after ^C
-    status("Shutting down...")
-    if (watcher) {
-      await watcher.close()
-    }
-    connection.close()
-    process.exit(0)
-  })
-}
-
-// Export for testing
-export { transition }