heyio 0.30.1 → 0.32.0

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/db.js

@@ -162,7 +162,7 @@ GROUP BY agent_slug`,
     )`,
         `CREATE TABLE IF NOT EXISTS unified_feed (
       id INTEGER PRIMARY KEY AUTOINCREMENT,
-      type TEXT NOT NULL CHECK(type IN ('deliverable', 'notification')),
+      type TEXT NOT NULL CHECK(type IN ('inbox', 'notification')),
       title TEXT NOT NULL,
       body TEXT NOT NULL,
       source_type TEXT,
@@ -193,6 +193,26 @@ GROUP BY agent_slug`,
     )`,
         `ALTER TABLE agent_tasks ADD COLUMN instance_id TEXT`,
         `CREATE INDEX IF NOT EXISTS idx_instance_decisions_instance ON instance_decisions(instance_id, merged_to_master)`,
+        `ALTER TABLE unified_feed RENAME TO unified_feed_old`,
+        `CREATE TABLE unified_feed (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  type TEXT NOT NULL CHECK(type IN ('inbox', 'notification')),
+  title TEXT NOT NULL,
+  body TEXT NOT NULL,
+  source_type TEXT,
+  source_ref TEXT,
+  squad_slug TEXT,
+  instance_id TEXT,
+  task_id TEXT,
+  created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+  read_at DATETIME
+)`,
+        `INSERT INTO unified_feed (id, type, title, body, source_type, source_ref, created_at, read_at)
+  SELECT id, CASE WHEN type='deliverable' THEN 'inbox' ELSE type END, title, body, source_type, source_ref, created_at, read_at
+  FROM unified_feed_old`,
+        `DROP TABLE unified_feed_old`,
+        `CREATE INDEX IF NOT EXISTS idx_unified_feed_type ON unified_feed(type, created_at)`,
+        `CREATE INDEX IF NOT EXISTS idx_unified_feed_unread ON unified_feed(read_at, created_at)`,
     ];
     for (const migration of migrations) {
         try {

package/dist/store/feed.js

@@ -2,9 +2,9 @@ import { getDb } from "./db.js";
 export function createFeedEntry(input) {
     const db = getDb();
     const info = db
-        .prepare(`INSERT INTO unified_feed (type, title, body, source_type, source_ref)
-       VALUES (?, ?, ?, ?, ?)`)
-        .run(input.type, input.title, input.body, input.source_type ?? null, input.source_ref ?? null);
+        .prepare(`INSERT INTO unified_feed (type, title, body, source_type, source_ref, squad_slug, instance_id, task_id)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?)`)
+        .run(input.type, input.title, input.body, input.source_type ?? null, input.source_ref ?? null, input.squad_slug ?? null, input.instance_id ?? null, input.task_id ?? null);
     return db
         .prepare("SELECT * FROM unified_feed WHERE id = ?")
         .get(info.lastInsertRowid);

package/dist/store/feed.test.js

@@ -27,8 +27,8 @@ beforeEach(() => {
 // ── createFeedEntry ───────────────────────────────────────────────────────────
 describe("createFeedEntry", () => {
     it("creates a deliverable entry with correct fields", () => {
-        const entry = createFeedEntry({ type: "deliverable", title: "Task done", body: "Here are the results." });
-        assert.equal(entry.type, "deliverable");
+        const entry = createFeedEntry({ type: "inbox", title: "Task done", body: "Here are the results." });
+        assert.equal(entry.type, "inbox");
         assert.equal(entry.title, "Task done");
         assert.equal(entry.body, "Here are the results.");
         assert.equal(entry.read_at, null);
@@ -54,7 +54,7 @@ describe("createFeedEntry", () => {
         assert.equal(entry.source_ref, JSON.stringify({ id: 42 }));
     });
     it("autoincrements ids", () => {
-        const a = createFeedEntry({ type: "deliverable", title: "A", body: "a" });
+        const a = createFeedEntry({ type: "inbox", title: "A", body: "a" });
         const b = createFeedEntry({ type: "notification", title: "B", body: "b" });
         assert.ok(b.id > a.id);
     });
@@ -62,7 +62,7 @@ describe("createFeedEntry", () => {
 // ── listFeedEntries ───────────────────────────────────────────────────────────
 describe("listFeedEntries", () => {
     it("returns all entries newest first", () => {
-        createFeedEntry({ type: "deliverable", title: "First", body: "x" });
+        createFeedEntry({ type: "inbox", title: "First", body: "x" });
         createFeedEntry({ type: "notification", title: "Second", body: "y" });
         const entries = listFeedEntries();
         assert.equal(entries.length, 2);
@@ -70,14 +70,14 @@ describe("listFeedEntries", () => {
         assert.equal(entries[1].title, "First");
     });
     it("filters by type=deliverable", () => {
-        createFeedEntry({ type: "deliverable", title: "D", body: "d" });
+        createFeedEntry({ type: "inbox", title: "D", body: "d" });
         createFeedEntry({ type: "notification", title: "N", body: "n" });
-        const entries = listFeedEntries({ type: "deliverable" });
+        const entries = listFeedEntries({ type: "inbox" });
         assert.equal(entries.length, 1);
-        assert.equal(entries[0].type, "deliverable");
+        assert.equal(entries[0].type, "inbox");
     });
     it("filters by type=notification", () => {
-        createFeedEntry({ type: "deliverable", title: "D", body: "d" });
+        createFeedEntry({ type: "inbox", title: "D", body: "d" });
         createFeedEntry({ type: "notification", title: "N", body: "n" });
         const entries = listFeedEntries({ type: "notification" });
         assert.equal(entries.length, 1);
@@ -108,20 +108,20 @@ describe("countUnreadFeedEntries", () => {
         assert.equal(countUnreadFeedEntries(), 0);
     });
     it("increments on insert", () => {
-        createFeedEntry({ type: "deliverable", title: "T", body: "b" });
+        createFeedEntry({ type: "inbox", title: "T", body: "b" });
         assert.equal(countUnreadFeedEntries(), 1);
         createFeedEntry({ type: "notification", title: "N", body: "b" });
         assert.equal(countUnreadFeedEntries(), 2);
     });
     it("decreases when marked read", () => {
-        const e = createFeedEntry({ type: "deliverable", title: "T", body: "b" });
+        const e = createFeedEntry({ type: "inbox", title: "T", body: "b" });
         markFeedEntryRead(e.id);
         assert.equal(countUnreadFeedEntries(), 0);
     });
     it("filters by type", () => {
-        createFeedEntry({ type: "deliverable", title: "D", body: "d" });
+        createFeedEntry({ type: "inbox", title: "D", body: "d" });
         createFeedEntry({ type: "notification", title: "N", body: "n" });
-        assert.equal(countUnreadFeedEntries("deliverable"), 1);
+        assert.equal(countUnreadFeedEntries("inbox"), 1);
         assert.equal(countUnreadFeedEntries("notification"), 1);
     });
 });
@@ -158,11 +158,11 @@ describe("markAllFeedEntriesRead", () => {
         assert.equal(markAllFeedEntriesRead(), 0);
     });
     it("respects type filter — only marks matching type", () => {
-        createFeedEntry({ type: "deliverable", title: "D", body: "d" });
+        createFeedEntry({ type: "inbox", title: "D", body: "d" });
         createFeedEntry({ type: "notification", title: "N", body: "n" });
         const count = markAllFeedEntriesRead("notification");
         assert.equal(count, 1);
-        assert.equal(countUnreadFeedEntries("deliverable"), 1);
+        assert.equal(countUnreadFeedEntries("inbox"), 1);
         assert.equal(countUnreadFeedEntries("notification"), 0);
     });
 });
@@ -170,7 +170,7 @@ describe("markAllFeedEntriesRead", () => {
 describe("markFeedEntriesRead", () => {
     it("marks multiple entries read and returns change count", () => {
         const a = createFeedEntry({ type: "notification", title: "A", body: "a" });
-        const b = createFeedEntry({ type: "deliverable", title: "B", body: "b" });
+        const b = createFeedEntry({ type: "inbox", title: "B", body: "b" });
         const c = createFeedEntry({ type: "notification", title: "C", body: "c" });
         const count = markFeedEntriesRead([a.id, b.id, c.id]);
         assert.equal(count, 3);
@@ -182,7 +182,7 @@ describe("markFeedEntriesRead", () => {
         assert.equal(countUnreadFeedEntries(), 1);
     });
     it("works correctly for a single id", () => {
-        const e = createFeedEntry({ type: "deliverable", title: "Solo", body: "b" });
+        const e = createFeedEntry({ type: "inbox", title: "Solo", body: "b" });
         assert.equal(markFeedEntriesRead([e.id]), 1);
         const entries = listFeedEntries();
         assert.ok(entries[0].read_at !== null);
@@ -211,13 +211,13 @@ describe("deleteFeedEntry", () => {
         assert.equal(deleteFeedEntry(9999), false);
     });
     it("returns true and removes the entry", () => {
-        const e = createFeedEntry({ type: "deliverable", title: "T", body: "b" });
+        const e = createFeedEntry({ type: "inbox", title: "T", body: "b" });
         assert.equal(deleteFeedEntry(e.id), true);
         const entries = listFeedEntries();
         assert.equal(entries.find((x) => x.id === e.id), undefined);
     });
     it("second delete returns false (not idempotent)", () => {
-        const e = createFeedEntry({ type: "deliverable", title: "T", body: "b" });
+        const e = createFeedEntry({ type: "inbox", title: "T", body: "b" });
         deleteFeedEntry(e.id);
         assert.equal(deleteFeedEntry(e.id), false);
     });
@@ -226,7 +226,7 @@ describe("deleteFeedEntry", () => {
 describe("deleteFeedEntries", () => {
     it("deletes multiple entries and returns change count", () => {
         const a = createFeedEntry({ type: "notification", title: "A", body: "a" });
-        const b = createFeedEntry({ type: "deliverable", title: "B", body: "b" });
+        const b = createFeedEntry({ type: "inbox", title: "B", body: "b" });
         const c = createFeedEntry({ type: "notification", title: "C", body: "c" });
         const count = deleteFeedEntries([a.id, b.id, c.id]);
         assert.equal(count, 3);
@@ -249,7 +249,7 @@ describe("deleteFeedEntries", () => {
         assert.equal(deleteFeedEntries([9991, 9992, 9993]), 0);
     });
     it("mix of existing and non-existent ids — only deletes what exists", () => {
-        const e = createFeedEntry({ type: "deliverable", title: "Real", body: "b" });
+        const e = createFeedEntry({ type: "inbox", title: "Real", body: "b" });
         const count = deleteFeedEntries([e.id, 9999]);
         assert.equal(count, 1);
         assert.deepEqual(listFeedEntries(), []);

package/dist/store/squads.js

@@ -133,7 +133,7 @@ export function logDecision(squadSlug, decision, context) {
 }
 export function getDecisions(squadSlug, limit = 20) {
     return getDb()
-        .prepare("SELECT * FROM squad_decisions WHERE squad_slug = ? ORDER BY created_at DESC LIMIT ?")
+        .prepare("SELECT * FROM squad_decisions WHERE squad_slug = ? ORDER BY created_at DESC, id DESC LIMIT ?")
         .all(squadSlug, limit);
 }
 export function getDecisionsSummary(squadSlug) {