heyio 0.31.0 → 0.33.0

package/dist/mcp/config.js

@@ -0,0 +1,37 @@
+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");
+// Mutable override for tests — mirrors the setDbPathForTests pattern.
+let _configPath = MCP_CONFIG_PATH;
+export function setMcpConfigPathForTests(path) {
+    _configPath = path;
+}
+export function resetMcpConfigPath() {
+    _configPath = MCP_CONFIG_PATH;
+}
+export function loadMcpConfig() {
+    if (!existsSync(_configPath)) {
+        return { servers: [] };
+    }
+    try {
+        const raw = readFileSync(_configPath, "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(_configPath);
+    if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+    }
+    writeFileSync(_configPath, 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/dist/store/instances.js

@@ -1,6 +1,7 @@
 import { getDb } from "./db.js";
 import { getDecisions } from "./squads.js";
 import { worktreeExists } from "./worktrees.js";
+import { readSquadWikiPages } from "../wiki/fs.js";
 export function ensureInstanceTables() {
     const db = getDb();
     db.exec(`
@@ -108,7 +109,14 @@ export function deleteInstance(id) {
  */
 export function buildContextSnapshot(masterSquadSlug, limit = 30) {
     const decisions = getDecisions(masterSquadSlug, limit);
-    return JSON.stringify(decisions.map((d) => ({ decision: d.decision, context: d.context, created_at: d.created_at })));
+    const wikiPages = readSquadWikiPages(masterSquadSlug);
+    const snapshot = {
+        decisions: decisions.map((d) => ({ decision: d.decision, context: d.context, created_at: d.created_at })),
+    };
+    if (wikiPages.length > 0) {
+        snapshot.wiki = wikiPages.map(p => ({ path: p.path, content: p.content }));
+    }
+    return JSON.stringify(snapshot);
 }
 /**
  * Reconcile instances on startup: detect orphaned worktrees and mark stale active instances.

package/dist/store/instances.test.js

@@ -234,18 +234,19 @@ describe("deleteInstance", () => {
 });
 // ── buildContextSnapshot ──────────────────────────────────────────────────────
 describe("buildContextSnapshot", () => {
-    it("returns a JSON array of recent squad decisions", () => {
+    it("returns a JSON object with decisions array", () => {
         logDecision("test-squad", "use TypeScript everywhere", "consistency");
         logDecision("test-squad", "prefer functional style");
         const snapshot = buildContextSnapshot("test-squad");
         const parsed = JSON.parse(snapshot);
-        assert.ok(Array.isArray(parsed));
-        assert.equal(parsed.length, 2);
-        assert.ok(parsed.some((d) => d.decision === "use TypeScript everywhere"));
+        assert.ok(Array.isArray(parsed.decisions));
+        assert.equal(parsed.decisions.length, 2);
+        assert.ok(parsed.decisions.some((d) => d.decision === "use TypeScript everywhere"));
     });
-    it("returns an empty JSON array for a squad with no decisions", () => {
+    it("returns empty decisions array for a squad with no decisions", () => {
         const snapshot = buildContextSnapshot("test-squad");
-        assert.deepEqual(JSON.parse(snapshot), []);
+        const parsed = JSON.parse(snapshot);
+        assert.deepEqual(parsed.decisions, []);
     });
     it("respects the limit parameter", () => {
         for (let i = 0; i < 10; i++) {
@@ -253,7 +254,25 @@ describe("buildContextSnapshot", () => {
         }
         const snapshot = buildContextSnapshot("test-squad", 5);
         const parsed = JSON.parse(snapshot);
-        assert.equal(parsed.length, 5);
+        assert.equal(parsed.decisions.length, 5);
+    });
+    it("includes wiki pages when they exist", async () => {
+        const { writePage, deletePage } = await import("../wiki/fs.js");
+        const testSlug = `test-squad-snap-${Date.now()}`;
+        const pagePath = `pages/squads/${testSlug}/rules.md`;
+        try {
+            writePage(pagePath, "# Rules\nNo force push.");
+            logDecision(testSlug, "test decision");
+            const snapshot = buildContextSnapshot(testSlug);
+            const parsed = JSON.parse(snapshot);
+            assert.ok(parsed.wiki);
+            assert.equal(parsed.wiki.length, 1);
+            assert.equal(parsed.wiki[0].path, pagePath);
+            assert.ok(parsed.wiki[0].content.includes("No force push"));
+        }
+        finally {
+            deletePage(pagePath);
+        }
     });
 });
 // ── reconcileInstances ────────────────────────────────────────────────────────

package/dist/telegram/bot.js

@@ -2,8 +2,17 @@ import { Bot } from "grammy";
 import { config } from "../config.js";
 const TELEGRAM_MAX_LENGTH = 4096;
 const EDIT_DEBOUNCE_MS = 500;
+const FILE_SIZE_LIMIT_BYTES = 5 * 1024 * 1024; // 5MB
 let bot;
 let messageHandler;
+async function downloadTelegramFile(botInstance, fileId) {
+    const file = await botInstance.api.getFile(fileId);
+    const url = `https://api.telegram.org/file/bot${config.telegramBotToken}/${file.file_path}`;
+    const response = await fetch(url);
+    const buffer = Buffer.from(await response.arrayBuffer());
+    const mimeType = response.headers.get("content-type") ?? "application/octet-stream";
+    return { data: buffer.toString("base64"), mimeType, size: buffer.length };
+}
 export function setMessageHandler(handler) {
     messageHandler = handler;
 }
@@ -82,6 +91,172 @@ export function createBot() {
             await editReply("An error occurred while processing your message.");
         }
     });
+    // ---------------------------------------------------------------------------
+    // Photo handler
+    // ---------------------------------------------------------------------------
+    bot.on("message:photo", async (ctx) => {
+        const userId = ctx.from?.id;
+        if (config.authorizedUserId && userId !== config.authorizedUserId)
+            return;
+        if (!messageHandler || !bot) {
+            console.error("[io] No message handler registered");
+            return;
+        }
+        // Telegram sends an array of sizes — last element is the highest resolution
+        const photos = ctx.message.photo;
+        const photo = photos[photos.length - 1];
+        const chatId = ctx.chat.id;
+        const messageId = ctx.message.message_id;
+        const caption = ctx.message.caption ?? "";
+        await ctx.replyWithChatAction("typing");
+        const ack = await ctx.reply("📎 Processing attachment…");
+        try {
+            const { data, mimeType, size } = await downloadTelegramFile(bot, photo.file_id);
+            if (size > FILE_SIZE_LIMIT_BYTES) {
+                await ctx.api.editMessageText(chatId, ack.message_id, "⚠️ File too large (max 5MB). Attachment not processed.");
+                return;
+            }
+            const attachment = { type: "blob", data, mimeType, displayName: "photo.jpg" };
+            const placeholder = await ctx.reply("…");
+            let accumulated = "";
+            let lastEditTime = 0;
+            let pendingEdit;
+            const editReply = async (content) => {
+                try {
+                    const truncated = content.length > TELEGRAM_MAX_LENGTH
+                        ? content.slice(0, TELEGRAM_MAX_LENGTH - 20) + "\n\n[…truncated]"
+                        : content;
+                    await ctx.api.editMessageText(chatId, placeholder.message_id, truncated);
+                }
+                catch (err) {
+                    const message = err instanceof Error ? err.message : String(err);
+                    if (!message.includes("message is not modified")) {
+                        console.error("[io] Failed to edit message:", message);
+                    }
+                }
+            };
+            await ctx.api.deleteMessage(chatId, ack.message_id);
+            await messageHandler(caption, chatId, messageId, (chunk, done) => {
+                accumulated += chunk;
+                if (done) {
+                    if (pendingEdit) {
+                        clearTimeout(pendingEdit);
+                        pendingEdit = undefined;
+                    }
+                    return;
+                }
+                const now = Date.now();
+                const timeSinceLastEdit = now - lastEditTime;
+                if (timeSinceLastEdit >= EDIT_DEBOUNCE_MS) {
+                    lastEditTime = now;
+                    void editReply(accumulated);
+                }
+                else if (!pendingEdit) {
+                    pendingEdit = setTimeout(() => {
+                        pendingEdit = undefined;
+                        lastEditTime = Date.now();
+                        void editReply(accumulated);
+                    }, EDIT_DEBOUNCE_MS - timeSinceLastEdit);
+                }
+            }, [attachment]);
+            if (pendingEdit)
+                clearTimeout(pendingEdit);
+            if (accumulated.length > 0)
+                await editReply(accumulated);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            console.error("[io] Error handling photo:", message);
+            await ctx.api.editMessageText(chatId, ack.message_id, "An error occurred while processing the attachment.");
+        }
+    });
+    // ---------------------------------------------------------------------------
+    // Document handler
+    // ---------------------------------------------------------------------------
+    bot.on("message:document", async (ctx) => {
+        const userId = ctx.from?.id;
+        if (config.authorizedUserId && userId !== config.authorizedUserId)
+            return;
+        if (!messageHandler || !bot) {
+            console.error("[io] No message handler registered");
+            return;
+        }
+        const doc = ctx.message.document;
+        const chatId = ctx.chat.id;
+        const messageId = ctx.message.message_id;
+        const caption = ctx.message.caption ?? "";
+        // Reject oversized files before downloading (file_size may be undefined for large files)
+        if (doc.file_size !== undefined && doc.file_size > FILE_SIZE_LIMIT_BYTES) {
+            await ctx.reply("⚠️ File too large (max 5MB). Attachment not processed.");
+            return;
+        }
+        await ctx.replyWithChatAction("typing");
+        const ack = await ctx.reply("📎 Processing attachment…");
+        try {
+            const { data, mimeType, size } = await downloadTelegramFile(bot, doc.file_id);
+            if (size > FILE_SIZE_LIMIT_BYTES) {
+                await ctx.api.editMessageText(chatId, ack.message_id, "⚠️ File too large (max 5MB). Attachment not processed.");
+                return;
+            }
+            const attachment = {
+                type: "blob",
+                data,
+                mimeType,
+                displayName: doc.file_name ?? "document",
+            };
+            const placeholder = await ctx.reply("…");
+            let accumulated = "";
+            let lastEditTime = 0;
+            let pendingEdit;
+            const editReply = async (content) => {
+                try {
+                    const truncated = content.length > TELEGRAM_MAX_LENGTH
+                        ? content.slice(0, TELEGRAM_MAX_LENGTH - 20) + "\n\n[…truncated]"
+                        : content;
+                    await ctx.api.editMessageText(chatId, placeholder.message_id, truncated);
+                }
+                catch (err) {
+                    const message = err instanceof Error ? err.message : String(err);
+                    if (!message.includes("message is not modified")) {
+                        console.error("[io] Failed to edit message:", message);
+                    }
+                }
+            };
+            await ctx.api.deleteMessage(chatId, ack.message_id);
+            await messageHandler(caption, chatId, messageId, (chunk, done) => {
+                accumulated += chunk;
+                if (done) {
+                    if (pendingEdit) {
+                        clearTimeout(pendingEdit);
+                        pendingEdit = undefined;
+                    }
+                    return;
+                }
+                const now = Date.now();
+                const timeSinceLastEdit = now - lastEditTime;
+                if (timeSinceLastEdit >= EDIT_DEBOUNCE_MS) {
+                    lastEditTime = now;
+                    void editReply(accumulated);
+                }
+                else if (!pendingEdit) {
+                    pendingEdit = setTimeout(() => {
+                        pendingEdit = undefined;
+                        lastEditTime = Date.now();
+                        void editReply(accumulated);
+                    }, EDIT_DEBOUNCE_MS - timeSinceLastEdit);
+                }
+            }, [attachment]);
+            if (pendingEdit)
+                clearTimeout(pendingEdit);
+            if (accumulated.length > 0)
+                await editReply(accumulated);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            console.error("[io] Error handling document:", message);
+            await ctx.api.editMessageText(chatId, ack.message_id, "An error occurred while processing the attachment.");
+        }
+    });
     bot.catch((err) => {
         console.error("[io] Grammy bot error:", err.message);
     });

package/dist/wiki/fs.js

@@ -149,4 +149,15 @@ export function writeLogFile(content) {
 export function getWikiDir() {
     return WIKI_DIR;
 }
+/**
+ * Read all wiki pages for a squad by slug.
+ * Returns array of { path, content } for pages under pages/squads/{slug}/.
+ */
+export function readSquadWikiPages(slug) {
+    const prefix = `pages/squads/${slug}/`;
+    return listPages()
+        .filter(p => p.startsWith(prefix))
+        .map(p => ({ path: p, content: readPage(p) ?? "" }))
+        .filter(entry => entry.content.length > 0);
+}
 //# sourceMappingURL=fs.js.map

package/dist/wiki/wiki-squad.test.js

@@ -0,0 +1,54 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { readSquadWikiPages, writePage, deletePage } from "./fs.js";
+describe("readSquadWikiPages", () => {
+    it("returns empty array for non-existent squad", () => {
+        const pages = readSquadWikiPages("nonexistent-squad-xyz");
+        assert.ok(Array.isArray(pages));
+        assert.equal(pages.length, 0);
+    });
+    it("returns pages under pages/squads/{slug}/ prefix", () => {
+        const testSlug = `test-squad-${Date.now()}`;
+        const pagePath = `pages/squads/${testSlug}/workflow.md`;
+        try {
+            writePage(pagePath, "# Workflow Rules\nAlways use feature branches.");
+            const pages = readSquadWikiPages(testSlug);
+            assert.equal(pages.length, 1);
+            assert.equal(pages[0].path, pagePath);
+            assert.ok(pages[0].content.includes("feature branches"));
+        }
+        finally {
+            deletePage(pagePath);
+        }
+    });
+    it("filters out empty pages", () => {
+        const testSlug = `test-squad-empty-${Date.now()}`;
+        const pagePath = `pages/squads/${testSlug}/empty.md`;
+        try {
+            writePage(pagePath, "");
+            const pages = readSquadWikiPages(testSlug);
+            assert.equal(pages.length, 0);
+        }
+        finally {
+            deletePage(pagePath);
+        }
+    });
+    it("returns multiple pages for a squad", () => {
+        const testSlug = `test-squad-multi-${Date.now()}`;
+        const page1 = `pages/squads/${testSlug}/workflow.md`;
+        const page2 = `pages/squads/${testSlug}/coding-standards.md`;
+        try {
+            writePage(page1, "# Workflow\nUse PRs.");
+            writePage(page2, "# Standards\nESLint required.");
+            const pages = readSquadWikiPages(testSlug);
+            assert.equal(pages.length, 2);
+            const paths = pages.map(p => p.path).sort();
+            assert.deepEqual(paths, [page2, page1].sort());
+        }
+        finally {
+            deletePage(page1);
+            deletePage(page2);
+        }
+    });
+});
+//# sourceMappingURL=wiki-squad.test.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "heyio",
-  "version": "0.31.0",
+  "version": "0.33.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"