@abraca/mcp 2.6.0 → 2.7.0

package/src/tools/channel.ts

@@ -1,115 +1,155 @@
 /**
  * Channel tools — reply to channel events and send chat messages.
  */
-import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
-import { z } from 'zod'
-import type { AbracadabraMCPServer } from '../server.ts'
-import { makeEntryMap } from '@abraca/dabra'
-import { populateYDocFromMarkdown } from '../converters/markdownToYjs.ts'
 
-export function registerChannelTools(mcp: McpServer, server: AbracadabraMCPServer) {
-  mcp.tool(
-    'reply',
-    'Create a document reply. Creates a child document under doc_id with the reply content as a rich-text document. Use this for structured, persistent responses. For conversational chat, use send_chat_message instead.',
-    {
-      doc_id: z.string().describe('Document ID to create the reply under.'),
-      text: z.string().describe('Markdown content for the reply.'),
-      task_id: z.string().optional().describe('If replying to an ai:task, the task ID to clear from awareness.'),
-    },
-    async ({ doc_id, text, task_id }) => {
-      try {
-        server.setAutoStatus('writing', doc_id)
-        server.setActiveToolCall({ name: 'reply', target: doc_id })
+import { makeEntryMap } from "@abraca/dabra";
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import { populateYDocFromMarkdown } from "../converters/markdownToYjs.ts";
+import type { AbracadabraMCPServer } from "../server.ts";
 
-        const treeMap = server.getTreeMap()
-        const rootDoc = server.rootDocument
-        if (!treeMap || !rootDoc) {
-          return { content: [{ type: 'text' as const, text: 'Not connected' }], isError: true }
-        }
+export function registerChannelTools(
+	mcp: McpServer,
+	server: AbracadabraMCPServer,
+) {
+	mcp.tool(
+		"reply",
+		"Create a document reply. Creates a child document under doc_id with the reply content as a rich-text document. Use this for structured, persistent responses. For conversational chat, use send_chat_message instead.",
+		{
+			doc_id: z.string().describe("Document ID to create the reply under."),
+			text: z.string().describe("Markdown content for the reply."),
+			task_id: z
+				.string()
+				.optional()
+				.describe(
+					"If replying to an ai:task, the task ID to clear from awareness.",
+				),
+		},
+		async ({ doc_id, text, task_id }) => {
+			try {
+				server.setAutoStatus("writing", doc_id);
+				server.setActiveToolCall({ name: "reply", target: doc_id });
 
-        const timestamp = new Date().toISOString().replace('T', ' ').slice(0, 19)
-        const snippet = text.slice(0, 40).replace(/\n/g, ' ')
-        const label = `AI Reply — ${timestamp}: ${snippet}`
-        const replyId = crypto.randomUUID()
-        const now = Date.now()
+				const treeMap = server.getTreeMap();
+				const rootDoc = server.rootDocument;
+				if (!treeMap || !rootDoc) {
+					return {
+						content: [{ type: "text" as const, text: "Not connected" }],
+						isError: true,
+					};
+				}
 
-        rootDoc.transact(() => {
-          treeMap.set(replyId, makeEntryMap({
-            label,
-            parentId: doc_id,
-            order: now,
-            type: 'doc',
-            createdAt: now,
-            updatedAt: now,
-          }))
-        })
+				const timestamp = new Date()
+					.toISOString()
+					.replace("T", " ")
+					.slice(0, 19);
+				const snippet = text.slice(0, 40).replace(/\n/g, " ");
+				const label = `AI Reply — ${timestamp}: ${snippet}`;
+				const replyId = crypto.randomUUID();
+				const now = Date.now();
 
-        const replyProvider = await server.getChildProvider(replyId)
-        const fragment = replyProvider.document.getXmlFragment('default')
-        populateYDocFromMarkdown(fragment, text)
+				rootDoc.transact(() => {
+					treeMap.set(
+						replyId,
+						makeEntryMap({
+							label,
+							parentId: doc_id,
+							order: now,
+							type: "doc",
+							createdAt: now,
+							updatedAt: now,
+						}),
+					);
+				});
 
-        if (task_id) {
-          server.clearAiTask(task_id)
-        }
+				const replyProvider = await server.getChildProvider(replyId);
+				const fragment = replyProvider.document.getXmlFragment("default");
+				populateYDocFromMarkdown(fragment, text);
 
+				if (task_id) {
+					server.clearAiTask(task_id);
+				}
 
-        return {
-          content: [{ type: 'text' as const, text: JSON.stringify({ replyDocId: replyId, parentId: doc_id }) }],
-        }
-      } catch (error: any) {
-        return {
-          content: [{ type: 'text' as const, text: `Error: ${error.message}` }],
-          isError: true,
-        }
-      }
-    }
-  )
+				return {
+					content: [
+						{
+							type: "text" as const,
+							text: JSON.stringify({ replyDocId: replyId, parentId: doc_id }),
+						},
+					],
+				};
+			} catch (error: any) {
+				return {
+					content: [{ type: "text" as const, text: `Error: ${error.message}` }],
+					isError: true,
+				};
+			}
+		},
+	);
 
-  mcp.tool(
-    'send_chat_message',
-    'Send a chat message visible in the dashboard chat UI. Pass channel_doc_id — the UUID of a doc with kind "channel" (group chat under a Space) or "dm" (direct message). Use list_connected_users + the doc tree to discover channels.',
-    {
-      channel_doc_id: z.string().describe('Channel doc UUID (kind = "channel" or "dm")'),
-      text: z.string().describe('Message text'),
-    },
-    async ({ channel_doc_id, text }) => {
-      try {
-        const rootProvider = server.rootYProvider
-        if (!rootProvider) {
-          return { content: [{ type: 'text' as const, text: 'Not connected' }], isError: true }
-        }
+	mcp.tool(
+		"send_chat_message",
+		'Send a chat message visible in the dashboard chat UI. Pass channel_doc_id — the UUID of a doc with kind "channel" (group chat under a Space) or "dm" (direct message). Use list_connected_users + the doc tree to discover channels.',
+		{
+			channel_doc_id: z
+				.string()
+				.describe('Channel doc UUID (kind = "channel" or "dm")'),
+			text: z.string().describe("Message text"),
+		},
+		async ({ channel_doc_id, text }) => {
+			try {
+				const rootProvider = server.rootYProvider;
+				if (!rootProvider) {
+					return {
+						content: [{ type: "text" as const, text: "Not connected" }],
+						isError: true,
+					};
+				}
 
-        // Normalize literal escape sequences. Some LLM outputs emit the
-        // 2-char `\n` / `\t` / `\r` instead of the real control chars, which
-        // then render literally in the chat (markdown renderer can't see a
-        // newline where there is just "\n"). Convert them back to real chars.
-        const normalized = text
-          .replace(/\\r\\n/g, '\n')
-          .replace(/\\n/g, '\n')
-          .replace(/\\t/g, '\t')
-          .replace(/\\r/g, '\n')
+				// Normalize literal escape sequences. Some LLM outputs emit the
+				// 2-char `\n` / `\t` / `\r` instead of the real control chars, which
+				// then render literally in the chat (markdown renderer can't see a
+				// newline where there is just "\n"). Convert them back to real chars.
+				const normalized = text
+					.replace(/\\r\\n/g, "\n")
+					.replace(/\\n/g, "\n")
+					.replace(/\\t/g, "\t")
+					.replace(/\\r/g, "\n");
 
-        // Order matters: clear status + tool pill FIRST so the dashboard's
-        // typing-indicator filter (which hides typing while an activeToolCall
-        // exists) doesn't swallow the burst. Then emit the typing frame, then
-        // the actual messages:send. The clear also flushes toolHistory + turnId.
-        server.setAutoStatus(null)
-        server.sendTypingIndicator(channel_doc_id)
+				// Show a brief "writing" phase so the dashboard renders typing dots
+				// just before the message lands (the reasoning phase showed the
+				// incantation; this is the distinct compose/send phase). Clear any
+				// tool pill, mark status 'writing' (the dashboard maps this to typing
+				// dots, not the phrase), emit a typing frame, and pause briefly so
+				// the dots are actually visible before the bubble appears.
+				server.setActiveToolCall(null);
+				server.setWritingStatus(channel_doc_id);
+				await new Promise((r) => setTimeout(r, 650));
 
-        rootProvider.sendStateless(JSON.stringify({
-          type: 'messages:send',
-          channel_doc_id,
-          content: normalized,
-          mentions: [],
-        }))
+				rootProvider.sendStateless(
+					JSON.stringify({
+						type: "messages:send",
+						channel_doc_id,
+						content: normalized,
+						mentions: [],
+					}),
+				);
 
-        return { content: [{ type: 'text' as const, text: `Sent to ${channel_doc_id}` }] }
-      } catch (error: any) {
-        return {
-          content: [{ type: 'text' as const, text: `Error: ${error.message}` }],
-          isError: true,
-        }
-      }
-    }
-  )
+				// End the turn AFTER the send: clears status, tool pill, turn id and
+				// stops the typing heartbeat so nothing lingers after the reply.
+				server.setAutoStatus(null);
+
+				return {
+					content: [
+						{ type: "text" as const, text: `Sent to ${channel_doc_id}` },
+					],
+				};
+			} catch (error: any) {
+				return {
+					content: [{ type: "text" as const, text: `Error: ${error.message}` }],
+					isError: true,
+				};
+			}
+		},
+	);
 }

package/src/tools/hooks.ts

@@ -1,42 +1,51 @@
 /**
  * Hook tools — provides Claude Code hook configuration for activity bridging.
  */
-import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
-import type { HookBridge } from '../hook-bridge.ts'
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { HookBridge } from "../hook-bridge.ts";
 
 export function registerHookTools(mcp: McpServer, hookBridge: HookBridge) {
-  mcp.tool(
-    'get_hook_config',
-    'Returns Claude Code hook configuration JSON for bridging activity to the Abracadabra dashboard. Copy the "hooks" object into your .claude/settings.local.json to enable real-time activity indicators (tool calls, subagents, etc.) visible to all connected users.',
-    {},
-    async () => {
-      const port = hookBridge.port
-      if (!port) {
-        return {
-          content: [{ type: 'text', text: 'Hook bridge is not running.' }],
-          isError: true,
-        }
-      }
-
-      const url = `http://127.0.0.1:${port}/hook`
-      const hookEntry = { type: 'http', url, timeout: 3 }
-
-      const config = {
-        hooks: {
-          PreToolUse: [{ hooks: [hookEntry] }],
-          PostToolUse: [{ hooks: [hookEntry] }],
-          SubagentStart: [{ hooks: [hookEntry] }],
-          SubagentStop: [{ hooks: [hookEntry] }],
-          Stop: [{ hooks: [hookEntry] }],
-        },
-      }
+	mcp.tool(
+		"get_hook_config",
+		'Returns Claude Code hook configuration JSON for bridging activity to the Abracadabra dashboard. Copy the "hooks" object into your .claude/settings.json (or settings.local.json) to enable real-time tool-call activity cards in the chat, visible to all connected users.',
+		{},
+		async () => {
+			const config = { hooks: buildHookConfig(hookBridge.portFile) };
+			return {
+				content: [
+					{
+						type: "text",
+						text: JSON.stringify(config, null, 2),
+					},
+				],
+			};
+		},
+	);
+}
 
-      return {
-        content: [{
-          type: 'text',
-          text: JSON.stringify(config, null, 2),
-        }],
-      }
-    },
-  )
+/**
+ * Build the Claude Code `hooks` object. We use a `command` hook (not `http`)
+ * that reads the bridge's port file at execution time and POSTs the event
+ * JSON (received on stdin) to it. This survives MCP restarts that pick a new
+ * random port — the URL is resolved fresh each call instead of being baked in.
+ *
+ * The command is a no-op (`exit 0`) when the port file is missing or curl
+ * fails, so a stopped bridge never blocks a tool call.
+ */
+export function buildHookConfig(portFile: string): Record<string, unknown> {
+	const cmd = `P=$(cat ${JSON.stringify(portFile)} 2>/dev/null); [ -n "$P" ] && curl -s -m 3 -X POST "http://127.0.0.1:$P/hook" --data-binary @- >/dev/null 2>&1; exit 0`;
+	const hookEntry = { type: "command", command: cmd, timeout: 5 };
+	const events = [
+		"UserPromptSubmit",
+		"PreToolUse",
+		"PostToolUse",
+		"SubagentStart",
+		"SubagentStop",
+		"Stop",
+	];
+	const hooks: Record<string, unknown> = {};
+	for (const ev of events) {
+		hooks[ev] = [{ hooks: [hookEntry] }];
+	}
+	return hooks;
 }