tandem-editor 0.4.0 → 0.6.0

package/dist/channel/index.js

@@ -6799,7 +6799,7 @@ var require_dist = __commonJS({
   }
 });
 
-// src/channel/index.ts
+// src/channel/run.ts
 import { createConnection } from "net";
 
 // node_modules/zod/v3/external.js
@@ -17915,13 +17915,24 @@ var SESSION_MAX_AGE = 30 * 24 * 60 * 60 * 1e3;
 var CHANNEL_MAX_RETRIES = 5;
 var CHANNEL_RETRY_DELAY_MS = 2e3;
 
+// src/shared/cli-runtime.ts
+function redirectConsoleToStderr() {
+  console.log = console.error;
+  console.warn = console.error;
+  console.info = console.error;
+}
+function resolveTandemUrl(override) {
+  const raw = override ?? process.env.TANDEM_URL ?? `http://localhost:${DEFAULT_MCP_PORT}`;
+  return raw.replace(/\/$/, "");
+}
+
 // src/server/events/types.ts
 var VALID_EVENT_TYPES = /* @__PURE__ */ new Set([
   "annotation:created",
   "annotation:accepted",
   "annotation:dismissed",
+  "annotation:reply",
   "chat:message",
-  "selection:changed",
   "document:opened",
   "document:closed",
   "document:switched"
@@ -17949,15 +17960,17 @@ function formatEventContent(event) {
       const { annotationId, textSnippet } = event.payload;
       return `User dismissed annotation ${annotationId}${textSnippet ? ` ("${textSnippet}")` : ""}${doc}`;
     }
+    case "annotation:reply": {
+      const { annotationId, replyAuthor, replyText, textSnippet } = event.payload;
+      const who = replyAuthor === "claude" ? "Claude" : "User";
+      const snippet = textSnippet ? ` (on "${textSnippet}")` : "";
+      return `${who} replied to annotation ${annotationId}${snippet}: ${replyText}${doc}`;
+    }
     case "chat:message": {
-      const { text, replyTo } = event.payload;
+      const { text, replyTo, selection } = event.payload;
       const reply = replyTo ? ` (replying to ${replyTo})` : "";
-      return `User says${reply}: ${text}${doc}`;
-    }
-    case "selection:changed": {
-      const { from, to, selectedText } = event.payload;
-      if (!selectedText) return `User cleared selection${doc}`;
-      return `User is pointing at text (${from}-${to}): "${selectedText}"${doc} \u2014 respond via tandem_reply`;
+      const sel = selection && selection.selectedText ? ` [selection: "${selection.selectedText}"${"from" in selection ? ` (${selection.from}-${selection.to})` : ""}]` : "";
+      return `User says${reply}: ${text}${sel}${doc}`;
     }
     case "document:opened": {
       const { fileName, format } = event.payload;
@@ -17988,11 +18001,13 @@ function formatEventMeta(event) {
     case "annotation:dismissed":
       meta.annotation_id = event.payload.annotationId;
       break;
+    case "annotation:reply":
+      meta.annotation_id = event.payload.annotationId;
+      meta.reply_id = event.payload.replyId;
+      break;
     case "chat:message":
       meta.message_id = event.payload.messageId;
-      break;
-    case "selection:changed":
-      meta.respond_via = "tandem_reply";
+      if (event.payload.selection?.selectedText) meta.has_selection = "true";
       break;
     case "document:opened":
     case "document:closed":
@@ -18008,14 +18023,13 @@ function formatEventMeta(event) {
 
 // src/channel/event-bridge.ts
 var AWARENESS_DEBOUNCE_MS = 500;
-var SELECTION_DEBOUNCE_MS = 300;
 var MODE_CACHE_TTL_MS = 2e3;
-async function startEventBridge(mcp2, tandemUrl) {
+async function startEventBridge(mcp, tandemUrl) {
   let retries = 0;
   let lastEventId;
   while (retries < CHANNEL_MAX_RETRIES) {
     try {
-      await connectAndStream(mcp2, tandemUrl, lastEventId, (id) => {
+      await connectAndStream(mcp, tandemUrl, lastEventId, (id) => {
         lastEventId = id;
         retries = 0;
       });
@@ -18048,7 +18062,7 @@ async function startEventBridge(mcp2, tandemUrl) {
     }
   }
 }
-async function connectAndStream(mcp2, tandemUrl, lastEventId, onEventId) {
+async function connectAndStream(mcp, tandemUrl, lastEventId, onEventId) {
   const headers = { Accept: "text/event-stream" };
   if (lastEventId) headers["Last-Event-ID"] = lastEventId;
   const res = await fetch(`${tandemUrl}/api/events`, { headers });
@@ -18096,35 +18110,7 @@ async function connectAndStream(mcp2, tandemUrl, lastEventId, onEventId) {
     if (awarenessTimer) clearTimeout(awarenessTimer);
     awarenessTimer = setTimeout(flushAwareness, AWARENESS_DEBOUNCE_MS);
   }
-  let selectionTimer = null;
-  let pendingSelection = null;
-  let transportBroken = false;
-  async function flushSelection() {
-    if (!pendingSelection) return;
-    const { event, eventId } = pendingSelection;
-    pendingSelection = null;
-    if (eventId) onEventId(eventId);
-    try {
-      await mcp2.notification({
-        method: "notifications/claude/channel",
-        params: {
-          content: formatEventContent(event),
-          meta: formatEventMeta(event)
-        }
-      });
-    } catch (err) {
-      console.error("[Channel] MCP notification failed (transport broken?):", err);
-      transportBroken = true;
-      return;
-    }
-    scheduleAwareness(event);
-  }
-  function isSelectionCleared(event) {
-    const p = event.payload;
-    return !p || p.from === p.to && !p.selectedText;
-  }
   while (true) {
-    if (transportBroken) throw new Error("MCP transport broken (detected in debounced flush)");
     const { done, value } = await reader.read();
     if (done) throw new Error("SSE stream ended");
     buffer += decoder.decode(value, { stream: true });
@@ -18159,17 +18145,9 @@ async function connectAndStream(mcp2, tandemUrl, lastEventId, onEventId) {
           continue;
         }
       }
-      if (event.type === "selection:changed") {
-        if (eventId) onEventId(eventId);
-        if (isSelectionCleared(event)) continue;
-        pendingSelection = { event, eventId };
-        if (selectionTimer) clearTimeout(selectionTimer);
-        selectionTimer = setTimeout(flushSelection, SELECTION_DEBOUNCE_MS);
-        continue;
-      }
       if (eventId) onEventId(eventId);
       try {
-        await mcp2.notification({
+        await mcp.notification({
           method: "notifications/claude/channel",
           params: {
             content: formatEventContent(event),
@@ -18208,11 +18186,143 @@ async function getCachedMode(tandemUrl) {
   return cachedMode;
 }
 
-// src/channel/index.ts
-console.log = console.error;
-console.warn = console.error;
-console.info = console.error;
-var TANDEM_URL = process.env.TANDEM_URL || "http://localhost:3479";
+// src/channel/run.ts
+async function runChannel(opts = {}) {
+  redirectConsoleToStderr();
+  const tandemUrl = resolveTandemUrl();
+  const mcp = new Server(
+    { name: "tandem-channel", version: "0.1.0" },
+    {
+      capabilities: {
+        experimental: {
+          "claude/channel": {},
+          "claude/channel/permission": {}
+        },
+        tools: {}
+      },
+      instructions: [
+        'Events from Tandem arrive as <channel source="tandem-channel" event_type="..." document_id="...">.',
+        "These are real-time push notifications of user actions in the collaborative document editor.",
+        "Event types: annotation:created, annotation:accepted, annotation:dismissed, annotation:reply,",
+        "chat:message, document:opened, document:closed, document:switched.",
+        "Chat messages may include a 'selection' field with buffered selection context.",
+        "Use your tandem MCP tools (tandem_getTextContent, tandem_comment, tandem_highlight, etc.) to act on them.",
+        "Reply to chat messages using tandem_reply. Pass document_id from the tag attributes.",
+        "Do not reply to non-chat events \u2014 just act on them using tools.",
+        "If you haven't received channel notifications recently, call tandem_checkInbox as a fallback."
+      ].join(" ")
+    }
+  );
+  mcp.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: [
+      {
+        name: "tandem_reply",
+        description: "Reply to a chat message in Tandem",
+        inputSchema: {
+          type: "object",
+          properties: {
+            text: { type: "string", description: "The reply message" },
+            documentId: {
+              type: "string",
+              description: "Document ID from the channel event (optional)"
+            },
+            replyTo: {
+              type: "string",
+              description: "Message ID being replied to (optional)"
+            }
+          },
+          required: ["text"]
+        }
+      }
+    ]
+  }));
+  mcp.setRequestHandler(CallToolRequestSchema, async (req) => {
+    if (req.params.name === "tandem_reply") {
+      const args = req.params.arguments;
+      try {
+        const res = await fetch(`${tandemUrl}/api/channel-reply`, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(args)
+        });
+        let data;
+        try {
+          data = await res.json();
+        } catch {
+          data = { message: "Non-JSON response" };
+        }
+        if (!res.ok) {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `Reply failed (${res.status}): ${JSON.stringify(data)}`
+              }
+            ],
+            isError: true
+          };
+        }
+        return { content: [{ type: "text", text: JSON.stringify(data) }] };
+      } catch (err) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Failed to send reply: ${err instanceof Error ? err.message : String(err)}`
+            }
+          ],
+          isError: true
+        };
+      }
+    }
+    throw new Error(`Unknown tool: ${req.params.name}`);
+  });
+  const PermissionRequestSchema = external_exports.object({
+    method: external_exports.literal("notifications/claude/channel/permission_request"),
+    params: external_exports.object({
+      request_id: external_exports.string(),
+      tool_name: external_exports.string(),
+      description: external_exports.string(),
+      input_preview: external_exports.string()
+    })
+  });
+  mcp.setNotificationHandler(PermissionRequestSchema, async ({ params }) => {
+    try {
+      const res = await fetch(`${tandemUrl}/api/channel-permission`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          requestId: params.request_id,
+          toolName: params.tool_name,
+          description: params.description,
+          inputPreview: params.input_preview
+        })
+      });
+      if (!res.ok) {
+        console.error(
+          `[Channel] Permission relay got HTTP ${res.status} \u2014 browser may not see prompt`
+        );
+      }
+    } catch (err) {
+      console.error("[Channel] Failed to forward permission request:", err);
+    }
+  });
+  console.error(`[Channel] Tandem channel shim starting (server: ${tandemUrl})`);
+  if (!opts.skipReachabilityLog) {
+    const reachable = await checkServerReachable(tandemUrl);
+    if (!reachable) {
+      console.error(`[Channel] Cannot reach Tandem server at ${tandemUrl}`);
+      console.error("[Channel] Start it with: tandem start");
+    }
+  }
+  const transport = new StdioServerTransport();
+  await mcp.connect(transport);
+  console.error("[Channel] Connected to Claude Code via stdio");
+  startEventBridge(mcp, tandemUrl).catch((err) => {
+    console.error("[Channel] Event bridge failed unexpectedly:", err);
+    process.exit(1);
+  });
+}
 async function checkServerReachable(url, timeoutMs = 2e3) {
   let parsed;
   try {
@@ -18241,138 +18351,9 @@ async function checkServerReachable(url, timeoutMs = 2e3) {
     });
   });
 }
-var mcp = new Server(
-  { name: "tandem-channel", version: "0.1.0" },
-  {
-    capabilities: {
-      experimental: {
-        "claude/channel": {},
-        "claude/channel/permission": {}
-      },
-      tools: {}
-    },
-    instructions: [
-      'Events from Tandem arrive as <channel source="tandem-channel" event_type="..." document_id="...">.',
-      "These are real-time push notifications of user actions in the collaborative document editor.",
-      "Event types: annotation:created, annotation:accepted, annotation:dismissed,",
-      "chat:message, selection:changed, document:opened, document:closed, document:switched.",
-      "Use your tandem MCP tools (tandem_getTextContent, tandem_comment, tandem_highlight, etc.) to act on them.",
-      "Reply to chat messages using tandem_reply. Pass document_id from the tag attributes.",
-      "Do not reply to non-chat events \u2014 just act on them using tools.",
-      "If you haven't received channel notifications recently, call tandem_checkInbox as a fallback."
-    ].join(" ")
-  }
-);
-mcp.setRequestHandler(ListToolsRequestSchema, async () => ({
-  tools: [
-    {
-      name: "tandem_reply",
-      description: "Reply to a chat message in Tandem",
-      inputSchema: {
-        type: "object",
-        properties: {
-          text: { type: "string", description: "The reply message" },
-          documentId: {
-            type: "string",
-            description: "Document ID from the channel event (optional)"
-          },
-          replyTo: {
-            type: "string",
-            description: "Message ID being replied to (optional)"
-          }
-        },
-        required: ["text"]
-      }
-    }
-  ]
-}));
-mcp.setRequestHandler(CallToolRequestSchema, async (req) => {
-  if (req.params.name === "tandem_reply") {
-    const args = req.params.arguments;
-    try {
-      const res = await fetch(`${TANDEM_URL}/api/channel-reply`, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify(args)
-      });
-      let data;
-      try {
-        data = await res.json();
-      } catch {
-        data = { message: "Non-JSON response" };
-      }
-      if (!res.ok) {
-        return {
-          content: [
-            {
-              type: "text",
-              text: `Reply failed (${res.status}): ${JSON.stringify(data)}`
-            }
-          ],
-          isError: true
-        };
-      }
-      return { content: [{ type: "text", text: JSON.stringify(data) }] };
-    } catch (err) {
-      return {
-        content: [
-          {
-            type: "text",
-            text: `Failed to send reply: ${err instanceof Error ? err.message : String(err)}`
-          }
-        ],
-        isError: true
-      };
-    }
-  }
-  throw new Error(`Unknown tool: ${req.params.name}`);
-});
-var PermissionRequestSchema = external_exports.object({
-  method: external_exports.literal("notifications/claude/channel/permission_request"),
-  params: external_exports.object({
-    request_id: external_exports.string(),
-    tool_name: external_exports.string(),
-    description: external_exports.string(),
-    input_preview: external_exports.string()
-  })
-});
-mcp.setNotificationHandler(PermissionRequestSchema, async ({ params }) => {
-  try {
-    const res = await fetch(`${TANDEM_URL}/api/channel-permission`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({
-        requestId: params.request_id,
-        toolName: params.tool_name,
-        description: params.description,
-        inputPreview: params.input_preview
-      })
-    });
-    if (!res.ok) {
-      console.error(
-        `[Channel] Permission relay got HTTP ${res.status} \u2014 browser may not see prompt`
-      );
-    }
-  } catch (err) {
-    console.error("[Channel] Failed to forward permission request:", err);
-  }
-});
-async function main() {
-  console.error(`[Channel] Tandem channel shim starting (server: ${TANDEM_URL})`);
-  const reachable = await checkServerReachable(TANDEM_URL);
-  if (!reachable) {
-    console.error(`[Channel] Cannot reach Tandem server at ${TANDEM_URL}`);
-    console.error("[Channel] Start it with: npm run dev:standalone");
-  }
-  const transport = new StdioServerTransport();
-  await mcp.connect(transport);
-  console.error("[Channel] Connected to Claude Code via stdio");
-  startEventBridge(mcp, TANDEM_URL).catch((err) => {
-    console.error("[Channel] Event bridge failed unexpectedly:", err);
-    process.exit(1);
-  });
-}
-main().catch((err) => {
+
+// src/channel/index.ts
+runChannel().catch((err) => {
   console.error("[Channel] Fatal error:", err);
   process.exit(1);
 });