framer-code-link 0.2.0 → 0.2.1

package/src/helpers/connection.ts

@@ -1,187 +0,0 @@
-/**
- * WebSocket connection helper
- *
- * Thin wrapper around ws.Server that normalizes handshake and surfaces
- * simple callbacks. Keeps raw socket API localized.
- */
-
-import { WebSocketServer, WebSocket } from "ws"
-import type { IncomingMessage, OutgoingMessage } from "../types.js"
-import { debug, error } from "../utils/logging.js"
-
-export interface ConnectionCallbacks {
-  onHandshake: (
-    client: WebSocket,
-    message: { projectId: string; projectName: string }
-  ) => void
-  onMessage: (message: IncomingMessage) => void
-  onDisconnect: () => void
-  onError: (error: Error) => void
-}
-
-export interface Connection {
-  on(event: "handshake", handler: ConnectionCallbacks["onHandshake"]): void
-  on(event: "message", handler: ConnectionCallbacks["onMessage"]): void
-  on(event: "disconnect", handler: ConnectionCallbacks["onDisconnect"]): void
-  on(event: "error", handler: ConnectionCallbacks["onError"]): void
-  close(): void
-}
-
-/**
- * Initializes a WebSocket server and returns a connection interface
- * Returns a Promise that resolves when the server is ready, or rejects on startup errors
- */
-export function initConnection(port: number): Promise<Connection> {
-  return new Promise((resolve, reject) => {
-    const wss = new WebSocketServer({ port })
-    const handlers: Partial<ConnectionCallbacks> = {}
-    let connectionId = 0
-    let isReady = false
-
-    // Handle server-level errors (e.g., EADDRINUSE)
-    wss.on("error", (err: NodeJS.ErrnoException) => {
-      if (!isReady) {
-        // Startup error - reject the promise with a helpful message
-        if (err.code === "EADDRINUSE") {
-          error(`Port ${port} is already in use.`)
-          error(
-            `This usually means another instance of Code Link is already running.`
-          )
-          error(``)
-          error(`To fix this:`)
-          error(
-            `  1. Close any other terminal running Code Link for this project`
-          )
-          error(`  2. Or run: lsof -i :${port} | grep LISTEN`)
-          error(`     Then kill the process: kill -9 <PID>`)
-          reject(new Error(`Port ${port} is already in use`))
-        } else {
-          error(`Failed to start WebSocket server: ${err.message}`)
-          reject(err)
-        }
-        return
-      }
-      // Runtime error - log but don't crash
-      error(`WebSocket server error: ${err.message}`)
-    })
-
-    // Server is ready when it starts listening
-    wss.on("listening", () => {
-      isReady = true
-      debug(`WebSocket server listening on port ${port}`)
-
-      wss.on("connection", (ws: WebSocket) => {
-        const connId = ++connectionId
-        let handshakeReceived = false
-        debug(`Client connected (conn ${connId})`)
-
-        ws.on("message", (data: Buffer) => {
-          try {
-            const message = JSON.parse(data.toString()) as IncomingMessage
-
-            // Special handling for handshake
-            if (message.type === "handshake") {
-              debug(`Received handshake (conn ${connId})`)
-              handshakeReceived = true
-              handlers.onHandshake?.(ws, message)
-            } else if (handshakeReceived) {
-              handlers.onMessage?.(message)
-            } else {
-              // Ignore messages before handshake - plugin will send full snapshot after
-              debug(
-                `Ignoring ${message.type} before handshake (conn ${connId})`
-              )
-            }
-          } catch (err) {
-            error(`Failed to parse message:`, err)
-          }
-        })
-
-        ws.on("close", (code, reason) => {
-          debug(
-            `Client disconnected (code: ${code}, reason: ${reason?.toString() || "none"})`
-          )
-          handlers.onDisconnect?.()
-        })
-
-        ws.on("error", (err) => {
-          error(`WebSocket error:`, err)
-        })
-      })
-
-      resolve({
-        on(
-          event: "handshake" | "message" | "disconnect" | "error",
-          handler: any
-        ): void {
-          if (event === "handshake") {
-            handlers.onHandshake = handler
-          } else if (event === "message") {
-            handlers.onMessage = handler
-          } else if (event === "disconnect") {
-            handlers.onDisconnect = handler
-          } else if (event === "error") {
-            handlers.onError = handler
-          }
-        },
-
-        close(): void {
-          wss.close()
-        },
-      })
-    })
-  })
-}
-
-/**
- * WebSocket readyState constants for reference
- */
-const READY_STATE = {
-  CONNECTING: 0,
-  OPEN: 1,
-  CLOSING: 2,
-  CLOSED: 3,
-} as const
-
-function readyStateToString(state: number): string {
-  switch (state) {
-    case 0:
-      return "CONNECTING"
-    case 1:
-      return "OPEN"
-    case 2:
-      return "CLOSING"
-    case 3:
-      return "CLOSED"
-    default:
-      return `UNKNOWN(${state})`
-  }
-}
-
-/**
- * Sends a message to a connected socket
- * Returns false if the socket is not open (instead of throwing)
- */
-export function sendMessage(
-  socket: WebSocket,
-  message: OutgoingMessage
-): Promise<boolean> {
-  return new Promise((resolve) => {
-    // Check socket state before attempting to send
-    if (socket.readyState !== READY_STATE.OPEN) {
-      const stateStr = readyStateToString(socket.readyState)
-      debug(`Cannot send ${message.type}: socket is ${stateStr}`)
-      resolve(false)
-      return
-    }
-
-    socket.send(JSON.stringify(message), (err) => {
-      if (err) {
-        debug(`Send error for ${message.type}: ${err.message}`)
-        resolve(false)
-      } else {
-        resolve(true)
-      }
-    })
-  })
-}

package/src/helpers/files.test.ts

@@ -1,117 +0,0 @@
-import fs from "fs/promises"
-import os from "os"
-import path from "path"
-import { describe, it, expect } from "vitest"
-import { autoResolveConflicts, detectConflicts } from "./files.js"
-import type { Conflict } from "../types.js"
-import { hashFileContent } from "../utils/state-persistence.js"
-
-function makeConflict(overrides: Partial<Conflict> = {}): Conflict {
-  return {
-    fileName: overrides.fileName ?? "Test.tsx",
-    localContent: overrides.localContent ?? "local",
-    remoteContent: overrides.remoteContent ?? "remote",
-    localModifiedAt: overrides.localModifiedAt ?? Date.now(),
-    remoteModifiedAt: overrides.remoteModifiedAt ?? Date.now(),
-    lastSyncedAt: overrides.lastSyncedAt ?? Date.now(),
-    localClean: overrides.localClean,
-  }
-}
-
-describe("autoResolveConflicts", () => {
-  it("classifies conflicts as local when remote unchanged and local changed", () => {
-    const conflict = makeConflict({
-      lastSyncedAt: 5_000,
-      localClean: false,
-    })
-
-    const result = autoResolveConflicts(
-      [conflict],
-      [{ fileName: conflict.fileName, latestRemoteVersionMs: 5_000 }]
-    )
-
-    expect(result.autoResolvedLocal).toHaveLength(1)
-    expect(result.autoResolvedRemote).toHaveLength(0)
-    expect(result.remainingConflicts).toHaveLength(0)
-  })
-
-  it("classifies conflicts as remote when local is clean and remote changed", () => {
-    const conflict = makeConflict({
-      lastSyncedAt: 5_000,
-      localClean: true,
-    })
-
-    const result = autoResolveConflicts(
-      [conflict],
-      [{ fileName: conflict.fileName, latestRemoteVersionMs: 10_000 }]
-    )
-
-    expect(result.autoResolvedRemote).toHaveLength(1)
-    expect(result.autoResolvedLocal).toHaveLength(0)
-  })
-
-  it("keeps conflicts that have both sides changed", () => {
-    const conflict = makeConflict({
-      lastSyncedAt: 5_000,
-      localClean: false,
-    })
-
-    const result = autoResolveConflicts(
-      [conflict],
-      [{ fileName: conflict.fileName, latestRemoteVersionMs: 7_500 }]
-    )
-
-    expect(result.remainingConflicts).toHaveLength(1)
-    expect(result.autoResolvedLocal).toHaveLength(0)
-    expect(result.autoResolvedRemote).toHaveLength(0)
-  })
-
-  it("keeps conflicts when version data is missing", () => {
-    const conflict = makeConflict({
-      lastSyncedAt: 5_000,
-      localClean: true,
-    })
-
-    const result = autoResolveConflicts([conflict], [])
-
-    expect(result.remainingConflicts).toHaveLength(1)
-  })
-})
-
-describe("detectConflicts", () => {
-  it("marks conflicts as localClean when local matches persisted state", async () => {
-    const tmpRoot = await fs.mkdtemp(path.join(os.tmpdir(), "cl-test-"))
-    try {
-      const filesDir = path.join(tmpRoot, "files")
-      await fs.mkdir(filesDir, { recursive: true })
-
-      const localContent = "local content"
-      await fs.writeFile(path.join(filesDir, "Test.tsx"), localContent, "utf-8")
-
-      const persistedState = new Map([
-        [
-          "Test.tsx",
-          { contentHash: hashFileContent(localContent), timestamp: 1_000 },
-        ],
-      ])
-
-      const result = await detectConflicts(
-        [
-          {
-            name: "Test.tsx",
-            content: "remote content",
-            modifiedAt: 2_000,
-          },
-        ],
-        filesDir,
-        { persistedState }
-      )
-
-      expect(result.writes).toHaveLength(0)
-      expect(result.conflicts).toHaveLength(1)
-      expect(result.conflicts[0]?.localClean).toBe(true)
-    } finally {
-      await fs.rm(tmpRoot, { recursive: true, force: true })
-    }
-  })
-})