@pinfix/plugin 0.1.0

package/dist/channel-server.js

@@ -0,0 +1,375 @@
+#!/usr/bin/env node
+
+// ../shared/dist/index.js
+var WS_PORT_DEFAULT = 24816;
+function isSessionStartMessage(msg) {
+  if (typeof msg !== "object" || msg === null) return false;
+  const m = msg;
+  return m.type === "session:start" && typeof m.pinId === "string" && typeof m.source === "string";
+}
+function isChatSendMessage(msg) {
+  if (typeof msg !== "object" || msg === null) return false;
+  const m = msg;
+  return m.type === "chat:send" && typeof m.pinId === "string" && typeof m.content === "string";
+}
+function isSessionEndMessage(msg) {
+  if (typeof msg !== "object" || msg === null) return false;
+  const m = msg;
+  return m.type === "session:end" && typeof m.pinId === "string";
+}
+function isWorkspaceResetMessage(msg) {
+  if (typeof msg !== "object" || msg === null) return false;
+  const m = msg;
+  return m.type === "workspace:reset" && (m.prompt === void 0 || typeof m.prompt === "string");
+}
+
+// ../channel-server/src/ws-server.ts
+import { WebSocketServer, WebSocket } from "ws";
+
+// ../channel-server/src/claude-provider.ts
+import { query } from "@anthropic-ai/claude-agent-sdk";
+function log(msg) {
+  process.stderr.write(`[pinfix:claude] ${msg}
+`);
+}
+function createClaudeSession(contextPrefix, cwd) {
+  let chunkCb = null;
+  let toolCb = null;
+  let doneCb = null;
+  let errorCb = null;
+  let killed = false;
+  let startupError = null;
+  const abortController = new AbortController();
+  let resolveNextMessage = null;
+  let firstMessage = true;
+  async function* userMessages() {
+    while (!killed) {
+      const msg = await new Promise((resolve2) => {
+        resolveNextMessage = resolve2;
+      });
+      if (killed) break;
+      yield msg;
+    }
+  }
+  async function startSession() {
+    try {
+      log("starting claude query...");
+      const stream = query({
+        prompt: userMessages(),
+        options: {
+          permissionMode: "auto",
+          includePartialMessages: true,
+          abortController,
+          ...cwd ? { cwd } : {}
+        }
+      });
+      for await (const message of stream) {
+        if (killed) break;
+        if (message.type === "stream_event" && message.event) {
+          const event = message.event;
+          if (event.type === "content_block_delta" && event.delta?.type === "text_delta") {
+            if (chunkCb) chunkCb(event.delta.text);
+          }
+          if (event.type === "content_block_start" && event.content_block?.type === "tool_use") {
+            const toolName = event.content_block.name;
+            log(`tool_use: ${toolName}`);
+            if (toolCb) toolCb(toolName);
+          }
+        }
+        if (message.type === "tool_progress") {
+        }
+        if (message.type === "result") {
+          log("claude query complete");
+          if (doneCb) doneCb();
+        }
+      }
+    } catch (err) {
+      if (!killed) {
+        const errorMessage = err.message || "Unknown error";
+        startupError = errorMessage;
+        log(`claude error: ${errorMessage}`);
+        if (errorCb) errorCb(errorMessage);
+      }
+    }
+  }
+  startSession();
+  function sendMessage(content) {
+    if (killed) return;
+    if (startupError) {
+      if (errorCb) errorCb(startupError);
+      return;
+    }
+    let prompt = content;
+    if (firstMessage) {
+      if (contextPrefix) {
+        prompt = `${contextPrefix}
+
+${content}`;
+      }
+      firstMessage = false;
+    }
+    log(`sending to claude: "${prompt.slice(0, 100)}"`);
+    if (resolveNextMessage) {
+      const resolve2 = resolveNextMessage;
+      resolveNextMessage = null;
+      resolve2({
+        type: "user",
+        message: { role: "user", content: prompt },
+        parent_tool_use_id: null
+      });
+    } else {
+      log("warning: no pending resolve, message may be lost");
+    }
+  }
+  function kill() {
+    log("session killed");
+    killed = true;
+    chunkCb = null;
+    toolCb = null;
+    doneCb = null;
+    errorCb = null;
+    abortController.abort();
+    if (resolveNextMessage) {
+      resolveNextMessage({
+        type: "user",
+        message: { role: "user", content: "" },
+        parent_tool_use_id: null
+      });
+      resolveNextMessage = null;
+    }
+  }
+  return {
+    sendMessage,
+    kill,
+    onChunk: (cb) => {
+      chunkCb = cb;
+    },
+    onTool: (cb) => {
+      toolCb = cb;
+    },
+    onDone: (cb) => {
+      doneCb = cb;
+    },
+    onError: (cb) => {
+      errorCb = cb;
+    }
+  };
+}
+var claudeProvider = {
+  name: "claude",
+  createSession: createClaudeSession
+};
+
+// ../channel-server/src/ws-server.ts
+function log2(msg) {
+  process.stderr.write(`[pinfix:ws] ${msg}
+`);
+}
+var HEARTBEAT_INTERVAL = 3e4;
+async function tryListen(port, maxRetries) {
+  let lastError = null;
+  for (let i = 0; i <= maxRetries; i++) {
+    const candidatePort = port + i;
+    try {
+      const wss = new WebSocketServer({ port: candidatePort });
+      await new Promise((resolve2, reject) => {
+        wss.once("listening", resolve2);
+        wss.once("error", reject);
+      });
+      return wss;
+    } catch (err) {
+      lastError = err;
+      if (err.code !== "EADDRINUSE") throw err;
+    }
+  }
+  throw lastError;
+}
+var DEFAULT_SYSTEM_PROMPT = `You are PinFix, a coding assistant. The user has annotated a UI element in their running app. You will receive the source location (file:line:column) and their request.
+
+Rules:
+- Read the relevant file first to understand context before making changes
+- Keep changes minimal and focused on what was asked
+- Reply concisely, explain what was changed
+- If the request is ambiguous, ask before modifying`;
+async function createWsServer(options) {
+  const { port, cwd, maxPortRetries = 5 } = options;
+  const pinContexts = /* @__PURE__ */ new Map();
+  let workspaceSession = null;
+  let workspacePrompt;
+  let activeTurn = null;
+  const wss = await tryListen(port, maxPortRetries);
+  const actualPort = wss.address().port;
+  const heartbeatInterval = setInterval(() => {
+    for (const ws of wss.clients) {
+      const client = ws;
+      if (client.isAlive === false) {
+        client.terminate();
+        continue;
+      }
+      client.isAlive = false;
+      client.ping();
+      if (client.readyState === WebSocket.OPEN) {
+        client.send(JSON.stringify({ type: "ping" }));
+      }
+    }
+  }, HEARTBEAT_INTERVAL);
+  wss.on("connection", (ws) => {
+    const client = ws;
+    client.isAlive = true;
+    log2("client connected");
+    ws.on("pong", () => {
+      client.isAlive = true;
+    });
+    ws.on("message", (raw) => {
+      try {
+        const msg = JSON.parse(raw.toString());
+        if (msg.type === "pong") return;
+        if (isSessionStartMessage(msg)) {
+          log2(`session:start pinId=${msg.pinId} source=${msg.source}`);
+          handleSessionStart(ws, msg.pinId, msg.source, msg.prompt);
+        } else if (isChatSendMessage(msg)) {
+          log2(`chat:send pinId=${msg.pinId} content="${msg.content.slice(0, 80)}"`);
+          handleChatSend(ws, msg.pinId, msg.content);
+        } else if (isSessionEndMessage(msg)) {
+          log2(`session:end pinId=${msg.pinId}`);
+          handleSessionEnd(msg.pinId);
+        } else if (isWorkspaceResetMessage(msg)) {
+          log2("workspace:reset");
+          handleWorkspaceReset(msg.prompt);
+        }
+      } catch {
+      }
+    });
+    ws.on("close", () => {
+      log2("client disconnected");
+    });
+  });
+  function handleSessionStart(_ws, pinId, source, _prompt) {
+    pinContexts.set(pinId, { source });
+    ensureWorkspaceSession();
+  }
+  function ensureWorkspaceSession() {
+    if (workspaceSession) return workspaceSession;
+    const systemPrompt = workspacePrompt || DEFAULT_SYSTEM_PROMPT;
+    const session = claudeProvider.createSession(systemPrompt, cwd);
+    session.onChunk((text) => {
+      if (!activeTurn) return;
+      send(activeTurn.ws, { type: "chat:chunk", pinId: activeTurn.pinId, text });
+    });
+    session.onTool((tool) => {
+      if (!activeTurn) return;
+      send(activeTurn.ws, { type: "chat:tool", pinId: activeTurn.pinId, tool });
+    });
+    session.onDone(() => {
+      if (!activeTurn) return;
+      const turn = activeTurn;
+      activeTurn = null;
+      send(turn.ws, { type: "chat:done", pinId: turn.pinId });
+    });
+    session.onError((error) => {
+      const turn = activeTurn;
+      activeTurn = null;
+      workspaceSession = null;
+      if (turn) {
+        send(turn.ws, { type: "chat:error", pinId: turn.pinId, error });
+      }
+    });
+    workspaceSession = session;
+    return session;
+  }
+  function handleChatSend(ws, pinId, content) {
+    const pinContext = pinContexts.get(pinId);
+    if (!pinContext) {
+      send(ws, { type: "chat:error", pinId, error: "No active session" });
+      return;
+    }
+    if (activeTurn) {
+      send(ws, { type: "chat:error", pinId, error: "Workspace session is busy" });
+      return;
+    }
+    const session = ensureWorkspaceSession();
+    activeTurn = { pinId, ws };
+    session.sendMessage(buildTurnPrompt(pinContext.source, content));
+  }
+  function handleSessionEnd(pinId) {
+    pinContexts.delete(pinId);
+    if (activeTurn?.pinId === pinId) {
+      activeTurn = null;
+      if (workspaceSession) {
+        workspaceSession.kill();
+        workspaceSession = null;
+      }
+    }
+  }
+  function handleWorkspaceReset(prompt) {
+    workspacePrompt = prompt;
+    activeTurn = null;
+    if (workspaceSession) {
+      workspaceSession.kill();
+      workspaceSession = null;
+    }
+    ensureWorkspaceSession();
+  }
+  const close = () => {
+    clearInterval(heartbeatInterval);
+    if (workspaceSession) {
+      workspaceSession.kill();
+      workspaceSession = null;
+    }
+    pinContexts.clear();
+    activeTurn = null;
+    wss.close();
+  };
+  return { port: actualPort, close };
+}
+function send(ws, msg) {
+  if (ws.readyState === WebSocket.OPEN) {
+    ws.send(JSON.stringify(msg));
+  }
+}
+function buildTurnPrompt(source, content) {
+  return `[source: ${source}]
+
+${content}`;
+}
+
+// ../channel-server/src/index.ts
+import { writeFileSync, mkdirSync, existsSync, unlinkSync } from "fs";
+import { resolve } from "path";
+async function main() {
+  const port = parseInt(process.env.PINFIX_PORT || String(WS_PORT_DEFAULT), 10);
+  const cwd = process.env.PINFIX_CWD || process.cwd();
+  const parentPid = process.ppid;
+  const server = await createWsServer({ port, cwd });
+  const pidDir = resolve(cwd, "node_modules", ".cache", "pinfix");
+  if (!existsSync(pidDir)) mkdirSync(pidDir, { recursive: true });
+  const pidFile = resolve(pidDir, "server.pid");
+  writeFileSync(pidFile, String(process.pid));
+  function cleanup() {
+    try {
+      unlinkSync(pidFile);
+    } catch {
+    }
+    server.close();
+    process.exit(0);
+  }
+  process.on("SIGTERM", cleanup);
+  process.on("SIGINT", cleanup);
+  process.on("disconnect", cleanup);
+  const parentCheck = setInterval(() => {
+    try {
+      process.kill(parentPid, 0);
+    } catch {
+      clearInterval(parentCheck);
+      cleanup();
+    }
+  }, 5e3);
+  parentCheck.unref();
+  process.stderr.write(`[pinfix] channel server ready, ws://localhost:${server.port}
+`);
+}
+main().catch((err) => {
+  process.stderr.write(`[pinfix] fatal: ${err.message}
+`);
+  process.exit(1);
+});