heyio 0.42.0 → 1.0.0

package/dist/instance-watchdog.test.js

@@ -1,183 +0,0 @@
-import { before, after, beforeEach, describe, it } 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";
-import { setDbPathForTests, closeDb, getDb } from "./store/db.js";
-import { ensureInstanceTables } from "./store/instances.js";
-import { findStaleInstances, startInstanceWatchdog } from "./instance-watchdog.js";
-let tmpDir;
-before(() => {
-    tmpDir = mkdtempSync(join(tmpdir(), "io-inst-watchdog-test-"));
-    setDbPathForTests(join(tmpDir, "io.db"));
-    ensureInstanceTables();
-});
-after(() => {
-    closeDb();
-    rmSync(tmpDir, { recursive: true, force: true });
-});
-beforeEach(() => {
-    const db = getDb();
-    db.prepare("DELETE FROM agent_tasks").run();
-    db.prepare("DELETE FROM squad_instances").run();
-    db.prepare("DELETE FROM squads").run();
-    db.prepare("INSERT INTO squads (slug, name, project_path) VALUES (?, ?, ?)").run("test-squad", "Test", "/tmp/test");
-});
-describe("instance watchdog", () => {
-    describe("findStaleInstances — active instances", () => {
-        it("detects stale active instances with no task activity", () => {
-            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--old", "test-squad", "/tmp/wt", "test-squad/instance/old");
-            const stale = findStaleInstances(30 * 60_000);
-            assert.strictEqual(stale.length, 1);
-            assert.strictEqual(stale[0].instance.id, "test-squad--old");
-        });
-        it("does not flag instances with recent task activity", () => {
-            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--recent", "test-squad", "/tmp/wt2", "test-squad/instance/recent");
-            db.prepare(`
-        INSERT INTO agent_tasks (task_id, agent_slug, description, instance_id, started_at)
-        VALUES (?, ?, ?, ?, datetime('now', '-5 minutes'))
-      `).run("task-recent", "agent-1", "Work", "test-squad--recent");
-            const stale = findStaleInstances(30 * 60_000);
-            assert.strictEqual(stale.length, 0);
-        });
-        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)
-        VALUES (?, ?, ?, ?, 'done', datetime('now', '-120 minutes'))
-      `).run("test-squad--done", "test-squad", "/tmp/wt3", "test-squad/instance/done");
-            const stale = findStaleInstances(30 * 60_000);
-            assert.strictEqual(stale.length, 0);
-        });
-        it("calculates idleMs correctly relative to now", () => {
-            const db = getDb();
-            db.prepare(`
-        INSERT INTO squad_instances (id, master_squad_slug, worktree_path, branch_name, status, created_at)
-        VALUES (?, ?, ?, ?, 'active', datetime('now', '-45 minutes'))
-      `).run("test-squad--mid", "test-squad", "/tmp/wt4", "test-squad/instance/mid");
-            const stale = findStaleInstances(30 * 60_000);
-            assert.strictEqual(stale.length, 1);
-            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 () => {
-            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--stale", "test-squad", "/tmp/wt5", "test-squad/instance/stale");
-            const aborted = [];
-            const stop = startInstanceWatchdog({
-                checkIntervalMs: 50,
-                staleThresholdMs: 30 * 60_000,
-                onAbort: (inst) => aborted.push(inst.id),
-            });
-            await new Promise((r) => setTimeout(r, 150));
-            stop();
-            assert.ok(aborted.includes("test-squad--stale"));
-            const row = db.prepare("SELECT status FROM squad_instances WHERE id = ?").get("test-squad--stale");
-            assert.strictEqual(row.status, "failed");
-        });
-        it("stop function prevents further checks", async () => {
-            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--late", "test-squad", "/tmp/wt6", "test-squad/instance/late");
-            let abortCount = 0;
-            const stop = startInstanceWatchdog({
-                checkIntervalMs: 50,
-                staleThresholdMs: 30 * 60_000,
-                onAbort: () => abortCount++,
-            });
-            stop();
-            await new Promise((r) => setTimeout(r, 150));
-            assert.strictEqual(abortCount, 0);
-        });
-    });
-});
-//# sourceMappingURL=instance-watchdog.test.js.map

package/dist/mcp/client.js

@@ -1,109 +0,0 @@
-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

@@ -1,99 +0,0 @@
-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.test.js

@@ -1,49 +0,0 @@
-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/registry.test.js

@@ -1,79 +0,0 @@
-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