{"version":3,"sources":["../src/mcp/server.ts","../src/presence/wrap-tool-with-activity.ts","../src/undo/undo-tools.ts","../src/bridges/git.ts"],"names":["emitActivity","undoOne","redoOne","readHistory","mutation"],"mappings":"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","file":"bridges-git.cjs","sourcesContent":["import {\n type CallToolResult,\n type JsonObject,\n type JsonRpcMessage,\n type JsonRpcRequest,\n type JsonRpcId,\n type RegisteredTool,\n type ServerCapabilities,\n type ServerInfo,\n type ToolDefinition,\n type ToolHandler,\n JSONRPC_INTERNAL_ERROR,\n JSONRPC_INVALID_PARAMS,\n JSONRPC_METHOD_NOT_FOUND,\n MCP_PROTOCOL_VERSION,\n} from \"./types\";\nimport { ToolRegistry } from \"./tool-host\";\n\nexport type McpServerOptions = {\n info: ServerInfo;\n /** Defaults to { tools: { listChanged: true } } */\n capabilities?: ServerCapabilities;\n /** Free-text instructions surfaced to clients during initialize. */\n instructions?: string;\n /**\n * The protocol revisions this server speaks, NEWEST FIRST.\n *\n * `initialize` echoes the client's requested revision when it is in this\n * list, and answers the first entry otherwise — the spec's rule, which leaves\n * the client to decide whether it can live with the answer.\n *\n * Defaults to `[MCP_PROTOCOL_VERSION]`: one revision, answered whatever the\n * client asks, which is exactly what this server did before the option\n * existed. Only list a revision the tools you register are correct under.\n */\n protocolVersions?: readonly string[];\n};\n\nexport type Transport = {\n /** Called by the server when it has a message to deliver to the client. */\n send: (message: JsonRpcMessage) => void;\n /** Called by the server when it's torn down so the transport can clean up. */\n close?: () => void;\n};\n\n/**\n * MicroMcpServer — protocol-level MCP server, transport-agnostic.\n *\n * Use it like:\n *\n * const server = new MicroMcpServer({ info: { name: \"session\", version: \"0.1\" } });\n * server.registerTool({ name: \"...\", inputSchema: { type: \"object\" } }, async (args) => ({...}));\n * const transport = new InProcessTransport();\n * server.attach(transport);\n * transport.deliver({ ... }); // client → server frames\n *\n * The same server can serve multiple transports (e.g. an in-process agent\n * AND a relayed external client) by attaching each one.\n */\nexport class MicroMcpServer extends ToolRegistry {\n private transports = new Set();\n /**\n * Transports owed a `tools/list_changed` at the end of this tick. Empty when\n * none is scheduled. See {@link scheduleListChangedNotification}.\n */\n private listChangedOwed = new Set();\n\n readonly info: ServerInfo;\n readonly capabilities: ServerCapabilities;\n readonly instructions?: string;\n readonly protocolVersions: readonly string[];\n\n constructor(options: McpServerOptions) {\n super();\n this.info = options.info;\n this.capabilities = options.capabilities ?? { tools: { listChanged: true } };\n this.instructions = options.instructions;\n if (options.protocolVersions && options.protocolVersions.length === 0) {\n // No answer exists for a client's initialize. Fail here, next to the\n // mistake, rather than in a handshake nobody is watching.\n throw new Error(\"MicroMcpServer: protocolVersions is empty — a server must speak at least one protocol revision.\");\n }\n this.protocolVersions = options.protocolVersions ? [...options.protocolVersions] : [MCP_PROTOCOL_VERSION];\n }\n\n attach(transport: Transport): () => void {\n this.transports.add(transport);\n return () => this.detach(transport);\n }\n\n detach(transport: Transport): void {\n if (this.transports.delete(transport)) {\n transport.close?.();\n }\n }\n\n unregisterTool(name: string): void {\n if (this.tools.delete(name)) {\n this.scheduleListChangedNotification();\n }\n }\n\n protected onToolsChanged(): void {\n this.scheduleListChangedNotification();\n }\n\n /**\n * Receive a JSON-RPC frame from a client (called by the transport).\n * The transport is responsible for sending the response back.\n */\n async receive(transport: Transport, message: JsonRpcMessage): Promise {\n if (!(\"method\" in message)) return; // It's a response, not a request — ignore.\n\n const isNotification = !(\"id\" in message);\n if (isNotification) {\n // Notifications are fire-and-forget. We ignore unknown methods.\n return;\n }\n\n const request = message as JsonRpcRequest;\n try {\n const result = await this.handle(request, transport);\n transport.send({ jsonrpc: \"2.0\", id: request.id, result });\n } catch (err) {\n transport.send({\n jsonrpc: \"2.0\",\n id: request.id,\n error: this.toRpcError(err),\n });\n }\n }\n\n private async handle(request: JsonRpcRequest, transport: Transport): Promise {\n const { method, params } = request;\n switch (method) {\n case \"initialize\":\n return {\n protocolVersion: this.negotiate(params?.protocolVersion),\n capabilities: this.capabilities,\n serverInfo: this.info,\n ...(this.instructions ? { instructions: this.instructions } : {}),\n };\n\n case \"tools/list\":\n return { tools: this.listTools() };\n\n case \"tools/call\": {\n const name = params?.name;\n const args = (params?.arguments ?? {}) as JsonObject;\n if (typeof name !== \"string\") {\n throw rpcError(JSONRPC_INVALID_PARAMS, \"tools/call requires `name`\");\n }\n const tool = this.tools.get(name);\n if (!tool) {\n throw rpcError(JSONRPC_METHOD_NOT_FOUND, this.missingToolMessage(name));\n }\n const result = await tool.handler(args, { transport });\n return result satisfies CallToolResult;\n }\n\n case \"ping\":\n return {};\n\n default:\n throw rpcError(JSONRPC_METHOD_NOT_FOUND, `Unsupported method: ${method}`);\n }\n }\n\n /** The revision to answer `initialize` with: the one asked for if spoken, else the newest. */\n private negotiate(requested: unknown): string {\n return typeof requested === \"string\" && this.protocolVersions.includes(requested)\n ? requested\n : this.protocolVersions[0];\n }\n\n /**\n * Tell the transports that SAW the old tool list that it changed.\n *\n * Changes in one tick coalesce into one notification. The recipients are the\n * transports attached at the moment of a change, not at the moment the\n * notification goes out: a transport attached afterwards never had the old\n * list, so \"your list is stale\" is noise to it — and on stdio, where a host\n * builds the server and attaches stdin/stdout in the same tick, it was the\n * first frame a client received, before it had even sent `initialize`.\n */\n private scheduleListChangedNotification(): void {\n if (this.transports.size === 0) return;\n const scheduled = this.listChangedOwed.size > 0;\n for (const t of this.transports) this.listChangedOwed.add(t);\n if (scheduled) return;\n queueMicrotask(() => {\n const owed = this.listChangedOwed;\n this.listChangedOwed = new Set();\n for (const t of owed) {\n // Detached since the change: it is not listening any more.\n if (this.transports.has(t)) t.send({ jsonrpc: \"2.0\", method: \"notifications/tools/list_changed\" });\n }\n });\n }\n\n /** Send an application notification to every client, or one attached transport. */\n notify(message: JsonRpcMessage, transport?: Transport): void {\n if (transport) transport.send(message);\n else this.broadcast(message);\n }\n\n private broadcast(message: JsonRpcMessage): void {\n for (const t of this.transports) t.send(message);\n }\n\n private toRpcError(err: unknown): { code: number; message: string; data?: any } {\n if (err && typeof err === \"object\" && \"code\" in err && \"message\" in err) {\n return err as any;\n }\n return {\n code: JSONRPC_INTERNAL_ERROR,\n message: err instanceof Error ? err.message : String(err),\n };\n }\n}\n\nexport function rpcError(code: number, message: string, data?: any) {\n return { code, message, ...(data !== undefined ? { data } : {}) };\n}\n\n/**\n * Helper to build a CallToolResult from a string or structured value.\n */\nexport function textResult(text: string, structured?: any): CallToolResult {\n return {\n content: [{ type: \"text\", text }],\n ...(structured !== undefined ? { structuredContent: structured } : {}),\n };\n}\n\nexport function errorResult(text: string): CallToolResult {\n return { content: [{ type: \"text\", text }], isError: true };\n}\n\n// Internal helper so the JsonRpcId import isn't dropped by tsup\ntype _KeepIdImport = JsonRpcId;\n","import type { CallToolResult } from \"../mcp/types\";\nimport { emitActivity } from \"./registry\";\nimport type { AgentTarget } from \"./types\";\n\nexport type ActivityAgent = { id: string; name?: string; color?: string };\n\nexport type ActivityResolverContext> = {\n /** Tool name as registered. */\n toolName: string;\n /** Arguments the tool was called with. */\n args: TArgs;\n /** The CallToolResult the underlying handler produced. */\n result: CallToolResult;\n};\n\n/**\n * Resolves an `AgentTarget` for an executed tool. Bridges declare one of\n * these per registration so the wrapper knows which surface / element /\n * screen the activity belongs to.\n *\n * The resolver runs AFTER the tool handler so it can inspect the result\n * (e.g. read a newly-created item id from `structuredContent`).\n */\nexport type ActivityTargetResolver> = (\n ctx: ActivityResolverContext,\n) => AgentTarget | null;\n\nexport type ToolHandler> = (\n args: TArgs,\n) => Promise | CallToolResult;\n\n/**\n * wrapToolWithActivity — decorate a bridge tool handler so every successful\n * call emits an `AgentActivityEvent`. Returns a new handler with the same shape.\n *\n * Usage in a bridge:\n *\n * server.registerTool(\n * definition,\n * wrapToolWithActivity(\n * handler,\n * { agent, kind: \"whiteboard\", resolveTarget: ({ args }) => ({\n * kind: \"whiteboard\", elementId: args.id as string,\n * }) },\n * ),\n * );\n */\nexport function wrapToolWithActivity>(\n handler: ToolHandler,\n options: {\n toolName: string;\n agent: ActivityAgent;\n /** Optional fancy-screens screen id this bridge is scoped to. */\n screenId?: string;\n /** Default target kind if the resolver returns one without `kind`. */\n kind: AgentTarget[\"kind\"];\n /** Per-call resolver. Return `null` to skip emitting (e.g. for read-only tools). */\n resolveTarget?: ActivityTargetResolver;\n /** Optional ttl override. */\n ttlMs?: number;\n /**\n * Build the `meta` broadcast to all relay peers. Defaults to the tool's full\n * `structuredContent`. Override to REDACT sensitive fields before fan-out —\n * e.g. the terminal bridge strips raw command/keystroke bytes so a command\n * line (or its secrets) is never broadcast verbatim to every peer.\n */\n buildMeta?: (result: CallToolResult) => Record | undefined;\n },\n): ToolHandler {\n return async (args) => {\n const result = await handler(args);\n if (result.isError) return result;\n\n let target: AgentTarget | null;\n if (options.resolveTarget) {\n target = options.resolveTarget({ toolName: options.toolName, args, result });\n } else {\n target = { kind: options.kind, screenId: options.screenId };\n }\n if (!target) return result;\n\n emitActivity({\n agentId: options.agent.id,\n agentName: options.agent.name,\n agentColor: options.agent.color,\n target: { ...target, kind: target.kind ?? options.kind, screenId: target.screenId ?? options.screenId },\n action: options.toolName,\n timestamp: Date.now(),\n meta: options.buildMeta ? options.buildMeta(result) : extractMeta(result),\n ttlMs: options.ttlMs,\n });\n return result;\n };\n}\n\nfunction extractMeta(result: CallToolResult): Record | undefined {\n const sc = result.structuredContent;\n if (sc && typeof sc === \"object\" && !Array.isArray(sc)) {\n return sc as Record;\n }\n return undefined;\n}\n","import { textResult, errorResult } from \"../mcp/server\";\nimport type { ToolHost } from \"../mcp/tool-host\";\nimport { readHistory, redoOne, undoOne } from \"./undo-stack\";\n\nexport type UndoToolsOptions = {\n /** Default agent id when the caller doesn't pass one. */\n defaultAgentId?: string;\n};\n\n/**\n * Idempotent tracker so multiple bridges on the same server only register\n * agent_undo / agent_redo / agent_history once.\n */\nconst installedHosts = new WeakSet();\n\n/**\n * The one owner every copy of the undo tools registers under. They are SHARED\n * on purpose — every bridge ensures them, and a host may also call\n * `registerUndoTools` itself — so all of those are the same registrant, and a\n * second registration replaces the first instead of being refused as a\n * collision. Anything else claiming `agent_undo` is still refused.\n */\nconst UNDO_TOOLS_OWNER = \"agent-undo\";\n\n/**\n * ensureUndoToolsRegistered — bridges call this on construction. Safe to\n * call repeatedly with the same server; subsequent calls are no-ops.\n */\nexport function ensureUndoToolsRegistered(host: ToolHost, options: UndoToolsOptions = {}): void {\n if (installedHosts.has(host)) return;\n installedHosts.add(host);\n registerUndoTools(host, options);\n}\n\n/**\n * registerUndoTools — add agent_undo / agent_redo / agent_history to the\n * server. Returns a disposer that unregisters all three.\n */\nexport function registerUndoTools(host: ToolHost, options: UndoToolsOptions = {}): () => void {\n const defaultAgent = options.defaultAgentId ?? \"agent\";\n const disposers: Array<() => void> = [];\n const agentOf = (args: any): string =>\n typeof args?.agentId === \"string\" ? args.agentId : defaultAgent;\n\n disposers.push(\n host.registerTool(\n {\n name: \"agent_undo\",\n description: \"Undo the most recent action on the agent's stack. Optional agentId targets a specific agent.\",\n inputSchema: {\n type: \"object\",\n properties: { agentId: { type: \"string\" } },\n additionalProperties: false,\n },\n },\n async (args) => {\n const entry = await undoOne(agentOf(args));\n if (!entry) return errorResult(\"Nothing to undo.\");\n return textResult(`Undid: ${entry.label}`, { entry: serialize(entry) });\n },\n { owner: UNDO_TOOLS_OWNER },\n ),\n );\n\n disposers.push(\n host.registerTool(\n {\n name: \"agent_redo\",\n description: \"Redo the most recently undone action.\",\n inputSchema: {\n type: \"object\",\n properties: { agentId: { type: \"string\" } },\n additionalProperties: false,\n },\n },\n async (args) => {\n const entry = await redoOne(agentOf(args));\n if (!entry) return errorResult(\"Nothing to redo.\");\n return textResult(`Redid: ${entry.label}`, { entry: serialize(entry) });\n },\n { owner: UNDO_TOOLS_OWNER },\n ),\n );\n\n disposers.push(\n host.registerTool(\n {\n name: \"agent_history\",\n description: \"List the agent's undo stack (oldest first). Useful for understanding what's reversible.\",\n inputSchema: {\n type: \"object\",\n properties: { agentId: { type: \"string\" } },\n additionalProperties: false,\n },\n },\n async (args) => {\n const history = readHistory(agentOf(args)).map(serialize);\n const text = history.map((e) => `${new Date(e.timestamp).toISOString()} ${e.bridgeId} ${e.action}: ${e.label}`).join(\"\\n\");\n return textResult(text || \"(empty)\", history);\n },\n { owner: UNDO_TOOLS_OWNER },\n ),\n );\n\n return () => disposers.forEach((d) => d());\n}\n\nfunction serialize(entry: import(\"./undo-stack\").UndoEntry) {\n return {\n timestamp: entry.timestamp,\n bridgeId: entry.bridgeId,\n action: entry.action,\n label: entry.label,\n };\n}\n","import { textResult, errorResult } from \"../mcp/server\";\nimport type { ToolHost } from \"../mcp/tool-host\";\nimport type { JsonObject } from \"../mcp/types\";\nimport type { Bridge } from \"./types\";\nimport { wrapToolWithActivity } from \"../presence/wrap-tool-with-activity\";\nimport { ensureUndoToolsRegistered } from \"../undo/undo-tools\";\n\nexport type GitProposal = {\n operation: string;\n arguments: Record;\n summary: string;\n};\n\nexport type GitBridgeAdapter = {\n status: () => Promise;\n log: (query: { ref?: string; limit?: number; skip?: number }) => Promise;\n diff: (query: { from?: string; to?: string; staged?: boolean; paths?: string[] }) => Promise;\n reviews?: (query: { state?: string; cursor?: string; limit?: number }) => Promise;\n checks?: (revision: string) => Promise;\n propose: (operation: string, args: Record) => Promise;\n applyProposal?: (proposal: GitProposal) => Promise;\n};\n\nexport type GitBridgeOptions = {\n adapter: GitBridgeAdapter;\n agent?: { id: string; name?: string; color?: string };\n /** Defaults to proposal-only. Set true only when the host has its own confirmation policy. */\n allowApply?: boolean;\n};\n\nexport function registerGitBridge(host: ToolHost, options: GitBridgeOptions): Bridge {\n const agent = { id: \"agent\", name: \"Agent\", color: \"#a855f7\", ...(options.agent ?? {}) };\n const disposers: Array<() => void> = [];\n // The bridge id is also its registrant identity on the host: the same bridge\n // may re-register (a remount), a different one claiming a name is refused.\n const bridgeId = \"git\";\n ensureUndoToolsRegistered(host, { defaultAgentId: agent.id });\n\n const reg = (\n name: string,\n description: string,\n properties: Record,\n required: string[],\n handler: (args: JsonObject) => Promise,\n mutation = false,\n ) => {\n const wrapped = async (args: JsonObject) => {\n try {\n return await handler(args);\n } catch (error) {\n return errorResult(error instanceof Error ? error.message : String(error));\n }\n };\n const final = mutation\n ? wrapToolWithActivity(wrapped as any, {\n toolName: name,\n agent,\n kind: \"git\",\n resolveTarget: ({ args }) => ({ kind: \"git\", elementId: typeof args.path === \"string\" ? args.path : undefined } as any),\n })\n : wrapped;\n disposers.push(host.registerTool({\n name,\n description,\n inputSchema: { type: \"object\", properties: properties as any, required, additionalProperties: false },\n }, final as any, { owner: bridgeId }));\n };\n\n reg(\"git_status\", \"Read normalized working-tree and branch status.\", {}, [], async () => {\n const result = await options.adapter.status();\n return textResult(JSON.stringify(result, null, 2), result as any);\n });\n reg(\"git_log\", \"Read normalized commit history.\", {\n ref: { type: \"string\" }, limit: { type: \"number\" }, skip: { type: \"number\" },\n }, [], async (args) => {\n const result = await options.adapter.log(args as any);\n return textResult(JSON.stringify(result, null, 2), result as any);\n });\n reg(\"git_diff\", \"Read a normalized Git diff.\", {\n from: { type: \"string\" }, to: { type: \"string\" }, staged: { type: \"boolean\" },\n paths: { type: \"array\", items: { type: \"string\" } },\n }, [], async (args) => {\n const result = await options.adapter.diff(args as any);\n return textResult(JSON.stringify(result, null, 2), result as any);\n });\n if (options.adapter.reviews) reg(\"git_reviews_list\", \"List normalized pull/merge requests.\", {\n state: { type: \"string\" }, cursor: { type: \"string\" }, limit: { type: \"number\" },\n }, [], async (args) => {\n const result = await options.adapter.reviews!(args as any);\n return textResult(JSON.stringify(result, null, 2), result as any);\n });\n if (options.adapter.checks) reg(\"git_checks\", \"Read checks or pipeline summaries for a revision.\", {\n revision: { type: \"string\" },\n }, [\"revision\"], async (args) => {\n const result = await options.adapter.checks!(String(args.revision));\n return textResult(JSON.stringify(result, null, 2), result as any);\n });\n\n const mutation = (name: string, description: string, properties: Record, required: string[]) =>\n reg(name, description, properties, required, async (args) => {\n const proposal = await options.adapter.propose(name.slice(4), args);\n if (args.apply === true) {\n if (!options.allowApply || !options.adapter.applyProposal) return errorResult(\"This host requires human confirmation before applying Git writes.\");\n const result = await options.adapter.applyProposal(proposal);\n return textResult(`Applied: ${proposal.summary}`, result as any);\n }\n return textResult(`Proposed: ${proposal.summary}`, proposal as any);\n }, true);\n\n mutation(\"git_stage\", \"Propose staging paths.\", { paths: { type: \"array\", items: { type: \"string\" } }, apply: { type: \"boolean\" } }, [\"paths\"]);\n mutation(\"git_unstage\", \"Propose unstaging paths.\", { paths: { type: \"array\", items: { type: \"string\" } }, apply: { type: \"boolean\" } }, [\"paths\"]);\n mutation(\"git_commit\", \"Propose committing staged changes.\", { message: { type: \"string\" }, apply: { type: \"boolean\" } }, [\"message\"]);\n mutation(\"git_checkout\", \"Propose checking out a ref.\", { target: { type: \"string\" }, apply: { type: \"boolean\" } }, [\"target\"]);\n mutation(\"git_fetch\", \"Propose fetching a remote.\", { remote: { type: \"string\" }, apply: { type: \"boolean\" } }, []);\n mutation(\"git_pull\", \"Propose a fast-forward-only pull.\", { remote: { type: \"string\" }, branch: { type: \"string\" }, apply: { type: \"boolean\" } }, []);\n mutation(\"git_push\", \"Propose pushing a branch.\", { remote: { type: \"string\" }, branch: { type: \"string\" }, apply: { type: \"boolean\" } }, []);\n mutation(\"git_review_create\", \"Propose creating a pull/merge request.\", {\n title: { type: \"string\" }, body: { type: \"string\" }, sourceBranch: { type: \"string\" }, targetBranch: { type: \"string\" }, draft: { type: \"boolean\" }, apply: { type: \"boolean\" },\n }, [\"title\", \"sourceBranch\", \"targetBranch\"]);\n\n return { id: bridgeId, title: \"Git\", dispose: () => disposers.forEach((dispose) => dispose()) };\n}\n"]}