heyio 0.31.0 → 0.32.0

package/dist/instance-watchdog.test.js

@@ -24,7 +24,7 @@ beforeEach(() => {
     db.prepare("INSERT INTO squads (slug, name, project_path) VALUES (?, ?, ?)").run("test-squad", "Test", "/tmp/test");
 });
 describe("instance watchdog", () => {
-    describe("findStaleInstances", () => {
+    describe("findStaleInstances — active instances", () => {
         it("detects stale active instances with no task activity", () => {
             const db = getDb();
             db.prepare(`
@@ -48,7 +48,7 @@ describe("instance watchdog", () => {
             const stale = findStaleInstances(30 * 60_000);
             assert.strictEqual(stale.length, 0);
         });
-        it("does not flag non-active instances", () => {
+        it("does not flag non-active/non-merging instances", () => {
             const db = getDb();
             db.prepare(`
         INSERT INTO squad_instances (id, master_squad_slug, worktree_path, branch_name, status, created_at)
@@ -68,6 +68,80 @@ describe("instance watchdog", () => {
             assert.ok(stale[0].idleMs >= 44 * 60_000);
             assert.ok(stale[0].idleMs <= 46 * 60_000);
         });
+        it("skips active instances whose latest task status is done (#261)", () => {
+            const db = getDb();
+            db.prepare(`
+        INSERT INTO squad_instances (id, master_squad_slug, worktree_path, branch_name, status, created_at)
+        VALUES (?, ?, ?, ?, 'active', datetime('now', '-60 minutes'))
+      `).run("test-squad--task-done", "test-squad", "/tmp/wt7", "test-squad/instance/task-done");
+            db.prepare(`
+        INSERT INTO agent_tasks (task_id, agent_slug, description, status, instance_id, started_at, completed_at)
+        VALUES (?, ?, ?, 'done', ?, datetime('now', '-35 minutes'), datetime('now', '-34 minutes'))
+      `).run("task-done-1", "agent-1", "Finished work", "test-squad--task-done");
+            const stale = findStaleInstances(30 * 60_000);
+            assert.strictEqual(stale.length, 0);
+        });
+    });
+    describe("findStaleInstances — merging instances (#267)", () => {
+        it("detects merging instance older than merging threshold", () => {
+            const db = getDb();
+            db.prepare(`
+        INSERT INTO squad_instances (id, master_squad_slug, worktree_path, branch_name, status, created_at)
+        VALUES (?, ?, ?, ?, 'merging', datetime('now', '-30 minutes'))
+      `).run("test-squad--stuck-merge", "test-squad", "/tmp/wt-merge1", "test-squad/instance/merge1");
+            // Task completed 10 minutes ago — merging has been stuck since then
+            db.prepare(`
+        INSERT INTO agent_tasks (task_id, agent_slug, description, status, instance_id, started_at, completed_at)
+        VALUES (?, ?, ?, 'done', ?, datetime('now', '-15 minutes'), datetime('now', '-10 minutes'))
+      `).run("task-merge-1", "agent-1", "Work done", "test-squad--stuck-merge");
+            // 10 min since last task completed > 5 min merging threshold
+            const stale = findStaleInstances(30 * 60_000, 5 * 60_000);
+            assert.strictEqual(stale.length, 1);
+            assert.strictEqual(stale[0].instance.id, "test-squad--stuck-merge");
+            assert.strictEqual(stale[0].instance.status, "merging");
+        });
+        it("does not flag merging instance younger than merging threshold", () => {
+            const db = getDb();
+            db.prepare(`
+        INSERT INTO squad_instances (id, master_squad_slug, worktree_path, branch_name, status, created_at)
+        VALUES (?, ?, ?, ?, 'merging', datetime('now', '-30 minutes'))
+      `).run("test-squad--fresh-merge", "test-squad", "/tmp/wt-merge2", "test-squad/instance/merge2");
+            // Task completed 2 minutes ago — merging just started
+            db.prepare(`
+        INSERT INTO agent_tasks (task_id, agent_slug, description, status, instance_id, started_at, completed_at)
+        VALUES (?, ?, ?, 'done', ?, datetime('now', '-5 minutes'), datetime('now', '-2 minutes'))
+      `).run("task-merge-2", "agent-1", "Work done", "test-squad--fresh-merge");
+            // 2 min since last task completed < 5 min merging threshold
+            const stale = findStaleInstances(30 * 60_000, 5 * 60_000);
+            assert.strictEqual(stale.length, 0);
+        });
+        it("uses created_at as fallback when merging instance has no tasks", () => {
+            const db = getDb();
+            db.prepare(`
+        INSERT INTO squad_instances (id, master_squad_slug, worktree_path, branch_name, status, created_at)
+        VALUES (?, ?, ?, ?, 'merging', datetime('now', '-10 minutes'))
+      `).run("test-squad--no-tasks-merge", "test-squad", "/tmp/wt-merge3", "test-squad/instance/merge3");
+            // No tasks at all — falls back to created_at (10 min ago > 5 min threshold)
+            const stale = findStaleInstances(30 * 60_000, 5 * 60_000);
+            assert.strictEqual(stale.length, 1);
+            assert.strictEqual(stale[0].instance.id, "test-squad--no-tasks-merge");
+        });
+        it("does not apply done-task skip logic to merging instances", () => {
+            const db = getDb();
+            db.prepare(`
+        INSERT INTO squad_instances (id, master_squad_slug, worktree_path, branch_name, status, created_at)
+        VALUES (?, ?, ?, ?, 'merging', datetime('now', '-30 minutes'))
+      `).run("test-squad--merging-done-task", "test-squad", "/tmp/wt-merge4", "test-squad/instance/merge4");
+            // Latest task is done — but for merging instances this should NOT skip
+            db.prepare(`
+        INSERT INTO agent_tasks (task_id, agent_slug, description, status, instance_id, started_at, completed_at)
+        VALUES (?, ?, ?, 'done', ?, datetime('now', '-20 minutes'), datetime('now', '-10 minutes'))
+      `).run("task-merge-4", "agent-1", "Done", "test-squad--merging-done-task");
+            // 10 min since task completed > 5 min merging threshold — should be detected
+            const stale = findStaleInstances(30 * 60_000, 5 * 60_000);
+            assert.strictEqual(stale.length, 1);
+            assert.strictEqual(stale[0].instance.id, "test-squad--merging-done-task");
+        });
     });
     describe("startInstanceWatchdog", () => {
         it("calls onAbort for stale instances and stops cleanly", async () => {
@@ -82,11 +156,9 @@ describe("instance watchdog", () => {
                 staleThresholdMs: 30 * 60_000,
                 onAbort: (inst) => aborted.push(inst.id),
             });
-            // Wait for at least one interval to fire
             await new Promise((r) => setTimeout(r, 150));
             stop();
             assert.ok(aborted.includes("test-squad--stale"));
-            // Verify it was marked failed
             const row = db.prepare("SELECT status FROM squad_instances WHERE id = ?").get("test-squad--stale");
             assert.strictEqual(row.status, "failed");
         });
@@ -102,9 +174,8 @@ describe("instance watchdog", () => {
                 staleThresholdMs: 30 * 60_000,
                 onAbort: () => abortCount++,
             });
-            stop(); // Stop immediately before any tick fires
+            stop();
             await new Promise((r) => setTimeout(r, 150));
-            // Instance should NOT have been aborted since we stopped before first tick
             assert.strictEqual(abortCount, 0);
         });
     });

package/dist/mcp/client.js

@@ -0,0 +1,109 @@
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
+export class McpConnectionManager {
+    connections = new Map();
+    connecting = new Map();
+    async getClient(config) {
+        const existing = this.connections.get(config.name);
+        if (existing)
+            return existing;
+        // Deduplicate concurrent connection attempts
+        const pending = this.connecting.get(config.name);
+        if (pending)
+            return pending;
+        const promise = this.connect(config);
+        this.connecting.set(config.name, promise);
+        try {
+            const client = await promise;
+            this.connections.set(config.name, client);
+            return client;
+        }
+        finally {
+            this.connecting.delete(config.name);
+        }
+    }
+    async connect(config) {
+        const client = new Client({ name: "io-assistant", version: "1.0.0" }, { capabilities: {} });
+        let transport;
+        if (config.url) {
+            transport = new SSEClientTransport(new URL(config.url));
+        }
+        else if (config.command) {
+            transport = new StdioClientTransport({
+                command: config.command,
+                args: config.args,
+                env: config.env,
+            });
+        }
+        else {
+            throw new Error(`MCP server "${config.name}" has no command or url configured`);
+        }
+        await client.connect(transport);
+        return client;
+    }
+    async listTools(config) {
+        const execute = async () => {
+            const client = await this.getClient(config);
+            const result = await client.listTools();
+            return (result.tools ?? []).map((t) => ({
+                name: t.name,
+                description: t.description,
+                inputSchema: t.inputSchema,
+            }));
+        };
+        try {
+            return await execute();
+        }
+        catch (err) {
+            console.error(`[mcp] listTools failed for ${config.name}, attempting reconnect:`, err instanceof Error ? err.message : err);
+            this.connections.delete(config.name);
+            return await execute();
+        }
+    }
+    async callTool(config, toolName, args) {
+        const execute = async () => {
+            const client = await this.getClient(config);
+            const result = await client.callTool({ name: toolName, arguments: args });
+            // MCP returns content as an array of content blocks
+            if (result.content && Array.isArray(result.content)) {
+                return result.content
+                    .map((block) => block.type === "text" ? block.text : JSON.stringify(block))
+                    .join("\n");
+            }
+            return result.content ?? result;
+        };
+        try {
+            return await execute();
+        }
+        catch (err) {
+            // Connection likely dead — clear and retry once
+            console.error(`[mcp] Tool call failed for ${config.name}/${toolName}, attempting reconnect:`, err instanceof Error ? err.message : err);
+            this.connections.delete(config.name);
+            try {
+                return await execute();
+            }
+            catch (retryErr) {
+                throw new Error(`MCP tool ${config.name}/${toolName} failed after reconnect: ${retryErr instanceof Error ? retryErr.message : String(retryErr)}`);
+            }
+        }
+    }
+    async disconnect(name) {
+        const client = this.connections.get(name);
+        if (client) {
+            try {
+                await client.close();
+            }
+            catch { /* ignore */ }
+            this.connections.delete(name);
+        }
+    }
+    async disconnectAll() {
+        const names = [...this.connections.keys()];
+        await Promise.allSettled(names.map((n) => this.disconnect(n)));
+    }
+    isConnected(name) {
+        return this.connections.has(name);
+    }
+}
+//# sourceMappingURL=client.js.map

package/dist/mcp/client.test.js

@@ -0,0 +1,99 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { McpConnectionManager } from "./client.js";
+describe("McpConnectionManager — auto-reconnect", () => {
+    const testConfig = { name: "test-server", command: "echo", args: ["hello"] };
+    it("callTool retries once on connection failure", async () => {
+        const manager = new McpConnectionManager();
+        let attempts = 0;
+        // Inject a mock client that fails on first callTool, succeeds on second
+        const mockClient = {
+            callTool: async () => {
+                attempts++;
+                if (attempts === 1)
+                    throw new Error("connection reset");
+                return { content: [{ type: "text", text: "success" }] };
+            },
+            listTools: async () => ({ tools: [] }),
+            close: async () => { },
+        };
+        // Inject into connections map
+        manager.connections.set("test-server", mockClient);
+        // Override getClient to return a fresh mock on reconnect
+        const originalGetClient = manager.getClient.bind(manager);
+        manager.getClient = async (config) => {
+            if (!manager.connections.has(config.name)) {
+                // Simulate reconnect — put a working mock
+                const freshMock = {
+                    callTool: async () => ({ content: [{ type: "text", text: "reconnected" }] }),
+                    close: async () => { },
+                };
+                manager.connections.set(config.name, freshMock);
+                return freshMock;
+            }
+            return manager.connections.get(config.name);
+        };
+        const result = await manager.callTool(testConfig, "test_tool", {});
+        assert.equal(result, "reconnected");
+    });
+    it("callTool throws after retry also fails", async () => {
+        const manager = new McpConnectionManager();
+        const failingClient = {
+            callTool: async () => { throw new Error("permanently broken"); },
+            close: async () => { },
+        };
+        manager.connections.set("test-server", failingClient);
+        // Override getClient to always return a broken client
+        manager.getClient = async () => failingClient;
+        await assert.rejects(() => manager.callTool(testConfig, "test_tool", {}), (err) => {
+            assert.ok(err.message.includes("failed after reconnect"));
+            return true;
+        });
+    });
+    it("listTools retries once on connection failure", async () => {
+        const manager = new McpConnectionManager();
+        let attempts = 0;
+        const mockClient = {
+            listTools: async () => {
+                attempts++;
+                if (attempts === 1)
+                    throw new Error("connection lost");
+                return { tools: [{ name: "tool1", description: "A tool", inputSchema: {} }] };
+            },
+            close: async () => { },
+        };
+        manager.connections.set("test-server", mockClient);
+        manager.getClient = async (config) => {
+            if (!manager.connections.has(config.name)) {
+                const freshMock = {
+                    listTools: async () => ({ tools: [{ name: "tool1", description: "A tool", inputSchema: {} }] }),
+                    close: async () => { },
+                };
+                manager.connections.set(config.name, freshMock);
+                return freshMock;
+            }
+            return manager.connections.get(config.name);
+        };
+        const tools = await manager.listTools(testConfig);
+        assert.equal(tools.length, 1);
+        assert.equal(tools[0].name, "tool1");
+    });
+    it("clears dead connection from map on failure", async () => {
+        const manager = new McpConnectionManager();
+        const deadClient = {
+            callTool: async () => { throw new Error("dead"); },
+            close: async () => { },
+        };
+        manager.connections.set("test-server", deadClient);
+        assert.ok(manager.isConnected("test-server"));
+        // Override getClient to simulate a reconnect failure too
+        manager.getClient = async () => { throw new Error("cannot reconnect"); };
+        try {
+            await manager.callTool(testConfig, "test_tool", {});
+        }
+        catch { /* expected */ }
+        // Dead connection should have been cleared
+        assert.ok(!manager.isConnected("test-server"));
+    });
+});
+//# sourceMappingURL=client.test.js.map

package/dist/mcp/config.js

@@ -0,0 +1,29 @@
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import { dirname } from "path";
+import { IO_HOME } from "../paths.js";
+import { join } from "path";
+export const MCP_CONFIG_PATH = join(IO_HOME, "mcp.json");
+export function loadMcpConfig() {
+    if (!existsSync(MCP_CONFIG_PATH)) {
+        return { servers: [] };
+    }
+    try {
+        const raw = readFileSync(MCP_CONFIG_PATH, "utf-8");
+        const parsed = JSON.parse(raw);
+        if (!parsed.servers || !Array.isArray(parsed.servers)) {
+            return { servers: [] };
+        }
+        return parsed;
+    }
+    catch {
+        return { servers: [] };
+    }
+}
+export function saveMcpConfig(config) {
+    const dir = dirname(MCP_CONFIG_PATH);
+    if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+    }
+    writeFileSync(MCP_CONFIG_PATH, JSON.stringify(config, null, 2), "utf-8");
+}
+//# sourceMappingURL=config.js.map

package/dist/mcp/config.test.js

@@ -0,0 +1,49 @@
+import { describe, it, before, after } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+// We need to override MCP_CONFIG_PATH for testing.
+// Since config.ts uses IO_HOME from paths.ts, we'll test by directly
+// exercising the functions with a mocked path approach.
+import { loadMcpConfig, saveMcpConfig } from "./config.js";
+describe("MCP config", () => {
+    let tmpDir;
+    let originalConfigPath;
+    before(() => {
+        tmpDir = mkdtempSync(join(tmpdir(), "io-mcp-config-test-"));
+    });
+    after(() => {
+        rmSync(tmpDir, { recursive: true, force: true });
+    });
+    it("loadMcpConfig returns empty servers when no file exists", () => {
+        // MCP_CONFIG_PATH points to ~/.io/mcp.json which may or may not exist
+        // but the function handles missing files gracefully
+        const config = loadMcpConfig();
+        assert.ok(Array.isArray(config.servers));
+    });
+    it("saveMcpConfig and loadMcpConfig round-trip correctly", () => {
+        const testConfig = {
+            servers: [
+                { name: "figma", command: "npx", args: ["-y", "@anthropic/mcp-server-figma"], enabled: true },
+                { name: "postgres", url: "http://localhost:3001/sse", enabled: false },
+            ],
+        };
+        saveMcpConfig(testConfig);
+        const loaded = loadMcpConfig();
+        assert.equal(loaded.servers.length, 2);
+        assert.equal(loaded.servers[0].name, "figma");
+        assert.equal(loaded.servers[0].command, "npx");
+        assert.deepEqual(loaded.servers[0].args, ["-y", "@anthropic/mcp-server-figma"]);
+        assert.equal(loaded.servers[1].name, "postgres");
+        assert.equal(loaded.servers[1].url, "http://localhost:3001/sse");
+        assert.equal(loaded.servers[1].enabled, false);
+    });
+    it("loadMcpConfig handles malformed JSON gracefully", () => {
+        // This test verifies the catch block — in production, a corrupt file
+        // won't crash the app
+        const config = loadMcpConfig();
+        assert.ok(config.servers !== undefined);
+    });
+});
+//# sourceMappingURL=config.test.js.map

package/dist/mcp/index.js

@@ -0,0 +1,4 @@
+export { loadMcpConfig, saveMcpConfig, MCP_CONFIG_PATH } from "./config.js";
+export { McpConnectionManager } from "./client.js";
+export { createMcpTools } from "./registry.js";
+//# sourceMappingURL=index.js.map

package/dist/mcp/registry.js

@@ -0,0 +1,96 @@
+import { defineTool } from "@github/copilot-sdk";
+import { z } from "zod";
+/**
+ * Sanitize a name for use as a tool identifier (alphanumeric + underscore only).
+ */
+function sanitizeName(name) {
+    return name.replace(/[^a-zA-Z0-9]/g, "_").replace(/_+/g, "_").replace(/^_|_$/g, "");
+}
+/**
+ * Convert an MCP JSON Schema inputSchema to a Zod schema.
+ * Falls back to z.object({}) for passthrough if schema is missing or unparseable.
+ */
+function jsonSchemaToZod(inputSchema) {
+    if (!inputSchema || !inputSchema.properties) {
+        return z.object({}).passthrough();
+    }
+    const properties = inputSchema.properties;
+    const required = new Set(inputSchema.required ?? []);
+    const shape = {};
+    for (const [key, prop] of Object.entries(properties)) {
+        let field;
+        switch (prop.type) {
+            case "string":
+                field = z.string();
+                break;
+            case "number":
+            case "integer":
+                field = z.number();
+                break;
+            case "boolean":
+                field = z.boolean();
+                break;
+            case "array":
+                field = z.array(z.unknown());
+                break;
+            case "object":
+                field = z.record(z.string(), z.unknown());
+                break;
+            default:
+                field = z.unknown();
+        }
+        if (prop.description) {
+            field = field.describe(prop.description);
+        }
+        if (!required.has(key)) {
+            field = field.optional();
+        }
+        shape[key] = field;
+    }
+    return z.object(shape).passthrough();
+}
+/**
+ * Create Copilot SDK tools from all enabled MCP servers.
+ * Connects to each server, lists its tools, and wraps them.
+ */
+export async function createMcpTools(manager, config) {
+    const entries = [];
+    const enabledServers = config.servers.filter((s) => s.enabled !== false);
+    for (const serverConfig of enabledServers) {
+        try {
+            const tools = await manager.listTools(serverConfig);
+            for (const mcpTool of tools) {
+                const toolName = `mcp_${sanitizeName(serverConfig.name)}_${sanitizeName(mcpTool.name)}`;
+                const description = mcpTool.description
+                    ? `[MCP: ${serverConfig.name}] ${mcpTool.description}`
+                    : `[MCP: ${serverConfig.name}] ${mcpTool.name}`;
+                const parameters = jsonSchemaToZod(mcpTool.inputSchema);
+                const tool = defineTool(toolName, {
+                    description,
+                    skipPermission: true,
+                    parameters: parameters,
+                    handler: async (args) => {
+                        try {
+                            const result = await manager.callTool(serverConfig, mcpTool.name, args);
+                            return typeof result === "string" ? result : JSON.stringify(result);
+                        }
+                        catch (err) {
+                            return `MCP tool error (${serverConfig.name}/${mcpTool.name}): ${err instanceof Error ? err.message : String(err)}`;
+                        }
+                    },
+                });
+                entries.push({
+                    serverName: serverConfig.name,
+                    serverConfig,
+                    mcpToolName: mcpTool.name,
+                    tool: tool,
+                });
+            }
+        }
+        catch (err) {
+            console.error(`[mcp] Failed to connect to server "${serverConfig.name}":`, err instanceof Error ? err.message : err);
+        }
+    }
+    return entries;
+}
+//# sourceMappingURL=registry.js.map

package/dist/mcp/registry.test.js

@@ -0,0 +1,79 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { createMcpTools } from "./registry.js";
+// Mock connection manager that returns predefined tools
+function createMockManager(toolsMap) {
+    return {
+        listTools: async (config) => {
+            return toolsMap[config.name] ?? [];
+        },
+        callTool: async (_config, toolName, args) => {
+            return `Called ${toolName} with ${JSON.stringify(args)}`;
+        },
+        getClient: async () => { throw new Error("not needed"); },
+        disconnect: async () => { },
+        disconnectAll: async () => { },
+        isConnected: () => false,
+    };
+}
+describe("MCP registry", () => {
+    it("creates namespaced tools from MCP server tools", async () => {
+        const manager = createMockManager({
+            figma: [
+                { name: "get_file", description: "Get a Figma file", inputSchema: { type: "object", properties: { file_key: { type: "string", description: "Figma file key" } }, required: ["file_key"] } },
+                { name: "list_projects", description: "List projects" },
+            ],
+        });
+        const config = {
+            servers: [{ name: "figma", command: "npx", args: ["-y", "@anthropic/mcp-figma"], enabled: true }],
+        };
+        const entries = await createMcpTools(manager, config);
+        assert.equal(entries.length, 2);
+        assert.equal(entries[0].tool.name, "mcp_figma_get_file");
+        assert.equal(entries[1].tool.name, "mcp_figma_list_projects");
+        assert.equal(entries[0].serverName, "figma");
+        assert.equal(entries[0].mcpToolName, "get_file");
+    });
+    it("skips disabled servers", async () => {
+        const manager = createMockManager({
+            figma: [{ name: "get_file", description: "Get file" }],
+            postgres: [{ name: "query", description: "Run query" }],
+        });
+        const config = {
+            servers: [
+                { name: "figma", command: "npx", enabled: true },
+                { name: "postgres", command: "pg-mcp", enabled: false },
+            ],
+        };
+        const entries = await createMcpTools(manager, config);
+        assert.equal(entries.length, 1);
+        assert.equal(entries[0].serverName, "figma");
+    });
+    it("sanitizes tool names to valid identifiers", async () => {
+        const manager = createMockManager({
+            "my-server": [{ name: "get-data.v2", description: "Get data" }],
+        });
+        const config = {
+            servers: [{ name: "my-server", command: "cmd", enabled: true }],
+        };
+        const entries = await createMcpTools(manager, config);
+        assert.equal(entries[0].tool.name, "mcp_my_server_get_data_v2");
+    });
+    it("handles server connection failure gracefully", async () => {
+        const manager = {
+            listTools: async () => { throw new Error("Connection refused"); },
+            callTool: async () => { throw new Error("not connected"); },
+            getClient: async () => { throw new Error("not connected"); },
+            disconnect: async () => { },
+            disconnectAll: async () => { },
+            isConnected: () => false,
+        };
+        const config = {
+            servers: [{ name: "broken", command: "bad-cmd", enabled: true }],
+        };
+        // Should not throw — just returns empty
+        const entries = await createMcpTools(manager, config);
+        assert.equal(entries.length, 0);
+    });
+});
+//# sourceMappingURL=registry.test.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "heyio",
-  "version": "0.31.0",
+  "version": "0.32.0",
   "description": "IO — a personal AI assistant built on the GitHub Copilot SDK",
   "bin": {
     "io": "dist/index.js"
@@ -42,6 +42,7 @@
   "homepage": "https://github.com/michaeljolley/io#readme",
   "dependencies": {
     "@github/copilot-sdk": "^0.2.2",
+    "@modelcontextprotocol/sdk": "^1.29.0",
     "better-sqlite3": "^12.6.2",
     "commander": "^14.0.0",
     "dotenv": "^17.3.1",
@@ -52,7 +53,7 @@
   "devDependencies": {
     "@types/better-sqlite3": "^7.6.13",
     "@types/express": "^5.0.6",
-    "@types/node": "^25.3.0",
+    "@types/node": "^25.9.1",
     "tsx": "^4.21.0",
     "typescript": "^5.9.3",
     "vue-tsc": "^3.2.9"