heyio 0.31.0 → 0.33.0

package/dist/copilot/orchestrator.js

@@ -16,6 +16,9 @@ import { delegateToAgent, getActiveAgentTasks, clearAgentInMemorySession } from
 import { saveConfig } from "../config.js";
 import { checkForUpdate } from "../update.js";
 import { startInstanceWatchdog } from "../instance-watchdog.js";
+import { loadMcpConfig } from "../mcp/config.js";
+import { McpConnectionManager } from "../mcp/client.js";
+import { createMcpTools } from "../mcp/registry.js";
 import { createInstance, getInstance, listInstances, updateInstanceStatus, logInstanceDecision, getInstanceDecisions, mergeInstanceDecisions, deleteInstance, buildContextSnapshot, reconcileInstances, ensureInstanceTables, } from "../store/instances.js";
 import { createWorktree, removeWorktree } from "../store/worktrees.js";
 // ---------------------------------------------------------------------------
@@ -141,11 +144,40 @@ function getToolDeps() {
         createWorktree,
         removeWorktree,
         activeInstanceId: undefined,
+        reloadMcpTools: initMcpTools,
     };
 }
+// MCP state — loaded at startup, refreshed on config change
+let mcpToolEntries = [];
+let mcpManager = null;
+export async function initMcpTools() {
+    const config = loadMcpConfig();
+    if (config.servers.length === 0) {
+        mcpToolEntries = [];
+        return;
+    }
+    if (!mcpManager) {
+        mcpManager = new McpConnectionManager();
+    }
+    else {
+        await mcpManager.disconnectAll();
+    }
+    try {
+        mcpToolEntries = await createMcpTools(mcpManager, config);
+        console.error(`[mcp] Loaded ${mcpToolEntries.length} tool(s) from ${config.servers.filter(s => s.enabled !== false).length} server(s)`);
+    }
+    catch (err) {
+        console.error("[mcp] Error loading MCP tools:", err instanceof Error ? err.message : err);
+        mcpToolEntries = [];
+    }
+}
+export function getMcpManager() {
+    return mcpManager;
+}
 function getSessionConfig() {
     const tools = createTools(getToolDeps());
-    return { tools, skillDirectories: getSkillDirectories() };
+    const allTools = [...tools, ...mcpToolEntries.map(e => e.tool)];
+    return { tools: allTools, skillDirectories: getSkillDirectories() };
 }
 /** Hash of tool names + version — used to detect when tools change across updates. */
 function toolFingerprint(tools) {
@@ -315,7 +347,7 @@ function invalidateSession() {
 // ---------------------------------------------------------------------------
 // Message execution
 // ---------------------------------------------------------------------------
-async function executeOnSession(prompt, callback) {
+async function executeOnSession(prompt, callback, attachments) {
     const session = await ensureOrchestratorSession();
     let accumulated = "";
     const unsubDelta = session.on("assistant.message_delta", (event) => {
@@ -324,7 +356,10 @@ async function executeOnSession(prompt, callback) {
         callback(delta, false);
     });
     try {
-        const result = await session.sendAndWait({ prompt }, SEND_TIMEOUT_MS);
+        const sendPayload = { prompt };
+        if (attachments && attachments.length > 0)
+            sendPayload.attachments = attachments;
+        const result = await session.sendAndWait(sendPayload, SEND_TIMEOUT_MS);
         unsubDelta();
         const finalText = result?.data.content ?? accumulated;
         callback("", true);
@@ -380,7 +415,7 @@ async function processQueue() {
             let lastError;
             for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
                 try {
-                    const response = await executeOnSession(taggedPrompt, msg.callback);
+                    const response = await executeOnSession(taggedPrompt, msg.callback, msg.attachments);
                     logConversation("assistant", response, sourceLabel(msg.source));
                     msg.resolve();
                     lastError = undefined;
@@ -431,6 +466,8 @@ export async function initOrchestrator(copilotClient) {
     }
     startInstanceWatchdog();
     clearStaleTasks();
+    // Load MCP server tools
+    await initMcpTools();
     // Validate the configured model and resolve model tiers
     try {
         const models = await copilotClient.listModels();
@@ -473,10 +510,10 @@ export async function initOrchestrator(copilotClient) {
         console.error("[io] Eager session creation failed (will retry on first message):", err instanceof Error ? err.message : err);
     }
 }
-export async function sendToOrchestrator(prompt, source, callback) {
+export async function sendToOrchestrator(prompt, source, callback, attachments) {
     logConversation("user", prompt, sourceLabel(source));
     return new Promise((resolve, reject) => {
-        messageQueue.push({ prompt, source, callback, resolve, reject });
+        messageQueue.push({ prompt, source, callback, attachments, resolve, reject });
         processQueue();
     });
 }

package/dist/copilot/tools.js

@@ -6,6 +6,7 @@ import { join, dirname, resolve } from "path";
 import { homedir } from "os";
 import { UNIVERSES, getOrCreateUniverse, generateUniverseRoster } from "./universes.js";
 import { createFeedEntry } from "../store/feed.js";
+import { loadMcpConfig, saveMcpConfig } from "../mcp/config.js";
 import { validateCron, nextRun } from "./cron.js";
 import { createIoSchedule, deleteIoSchedule, getIoSchedule, listIoSchedules, setIoScheduleEnabled, updateIoScheduleNextRun, } from "../store/io-schedules.js";
 import { runIoScheduleNow } from "./io-scheduler.js";
@@ -1934,7 +1935,95 @@ export function createTools(deps) {
             return "Notification sent.";
         },
     });
-    return [wikiRead, wikiWrite, wikiSearch, wikiDelete, wikiList, squadCreate, squadRecall, squadStatus, squadLogDecision, squadDelegate, squadTaskStatus, squadDelete, squadAnalyze, squadAddAgent, squadAgents, squadRemoveAgent, squadResetAgent, squadSetLead, squadSetQA, squadTaskReviews, squadScheduleCreate, squadScheduleList, squadScheduleDelete, squadSchedulePause, squadScheduleResume, squadScheduleRunNow, scheduleCreate, scheduleList, scheduleDelete, schedulePause, scheduleResume, scheduleRunNow, skillList, skillInstall, skillRemove, skillSearch, configUpdate, checkUpdate, shell, fileOps, bash, readFile, viewTool, grepTool, strReplaceEditor, github, squadInstanceCreate, squadInstanceList, squadInstanceStatus, squadInstanceComplete, squadInstanceAbort, squadInstanceCleanup, squadInstanceActivate, squadInstanceDeactivate, sendToInbox, sendNotification];
+    const mcpServerList = defineTool("mcp_server_list", {
+        description: "List all configured MCP servers with their status (enabled/disabled, connected/disconnected).",
+        skipPermission: true,
+        parameters: z.object({}),
+        handler: async () => {
+            const config = loadMcpConfig();
+            if (config.servers.length === 0)
+                return "No MCP servers configured. Add one with mcp_server_add.";
+            return config.servers.map(s => {
+                const status = s.enabled === false ? "disabled" : "enabled";
+                const transport = s.url ? `SSE: ${s.url}` : `stdio: ${s.command} ${(s.args ?? []).join(" ")}`;
+                return `- **${s.name}** [${status}] — ${transport}`;
+            }).join("\n");
+        },
+    });
+    const mcpServerAdd = defineTool("mcp_server_add", {
+        description: "Add a new MCP server to the configuration. Provide either command+args (stdio transport) or url (SSE transport).",
+        skipPermission: true,
+        parameters: z.object({
+            name: z.string().describe("Unique name for the server (e.g., 'figma', 'postgres')"),
+            command: z.string().optional().describe("Executable command for stdio transport (e.g., 'npx')"),
+            args: z.array(z.string()).optional().describe("Command arguments (e.g., ['-y', '@anthropic/mcp-server-figma'])"),
+            url: z.string().optional().describe("URL for SSE transport (e.g., 'http://localhost:3001/sse')"),
+            env: z.record(z.string(), z.string()).optional().describe("Environment variables for the server process"),
+        }),
+        handler: async ({ name, command, args, url, env }) => {
+            if (!command && !url)
+                return "Error: provide either 'command' (stdio) or 'url' (SSE).";
+            const config = loadMcpConfig();
+            if (config.servers.some(s => s.name === name)) {
+                return `Error: server "${name}" already exists. Remove it first with mcp_server_remove.`;
+            }
+            config.servers.push({ name, command, args, url, env, enabled: true });
+            saveMcpConfig(config);
+            return `MCP server "${name}" added. Use mcp_server_reload to connect.`;
+        },
+    });
+    const mcpServerRemove = defineTool("mcp_server_remove", {
+        description: "Remove an MCP server from the configuration by name.",
+        skipPermission: true,
+        parameters: z.object({
+            name: z.string().describe("Name of the server to remove"),
+        }),
+        handler: async ({ name }) => {
+            const config = loadMcpConfig();
+            const idx = config.servers.findIndex(s => s.name === name);
+            if (idx === -1)
+                return `Server "${name}" not found.`;
+            config.servers.splice(idx, 1);
+            saveMcpConfig(config);
+            return `MCP server "${name}" removed. Use mcp_server_reload to apply.`;
+        },
+    });
+    const mcpServerToggle = defineTool("mcp_server_toggle", {
+        description: "Enable or disable an MCP server without removing it from the config.",
+        skipPermission: true,
+        parameters: z.object({
+            name: z.string().describe("Name of the server to toggle"),
+            enabled: z.boolean().describe("true to enable, false to disable"),
+        }),
+        handler: async ({ name, enabled }) => {
+            const config = loadMcpConfig();
+            const server = config.servers.find(s => s.name === name);
+            if (!server)
+                return `Server "${name}" not found.`;
+            server.enabled = enabled;
+            saveMcpConfig(config);
+            return `MCP server "${name}" ${enabled ? "enabled" : "disabled"}. Use mcp_server_reload to apply changes.`;
+        },
+    });
+    const mcpServerReload = defineTool("mcp_server_reload", {
+        description: "Reload MCP server connections and tools. Call after adding, removing, or toggling servers to apply changes without restarting IO.",
+        skipPermission: true,
+        parameters: z.object({}),
+        handler: async () => {
+            if (!deps.reloadMcpTools)
+                return "MCP reload not available in this context.";
+            try {
+                await deps.reloadMcpTools();
+                const config = loadMcpConfig();
+                const enabled = config.servers.filter(s => s.enabled !== false);
+                return `MCP tools reloaded. ${enabled.length} server(s) active.`;
+            }
+            catch (err) {
+                return `Error reloading MCP tools: ${err instanceof Error ? err.message : String(err)}`;
+            }
+        },
+    });
+    return [wikiRead, wikiWrite, wikiSearch, wikiDelete, wikiList, squadCreate, squadRecall, squadStatus, squadLogDecision, squadDelegate, squadTaskStatus, squadDelete, squadAnalyze, squadAddAgent, squadAgents, squadRemoveAgent, squadResetAgent, squadSetLead, squadSetQA, squadTaskReviews, squadScheduleCreate, squadScheduleList, squadScheduleDelete, squadSchedulePause, squadScheduleResume, squadScheduleRunNow, scheduleCreate, scheduleList, scheduleDelete, schedulePause, scheduleResume, scheduleRunNow, skillList, skillInstall, skillRemove, skillSearch, configUpdate, checkUpdate, shell, fileOps, bash, readFile, viewTool, grepTool, strReplaceEditor, github, squadInstanceCreate, squadInstanceList, squadInstanceStatus, squadInstanceComplete, squadInstanceAbort, squadInstanceCleanup, squadInstanceActivate, squadInstanceDeactivate, sendToInbox, sendNotification, mcpServerList, mcpServerAdd, mcpServerRemove, mcpServerToggle, mcpServerReload];
 }
 function walkDirectory(dir, maxDepth = 3, depth = 0) {
     if (depth >= maxDepth)

package/dist/daemon.js

@@ -110,8 +110,8 @@ export async function startDaemon() {
     await startApiServer();
     // Wire up Telegram handler
     if (config.telegramEnabled) {
-        setTelegramHandler(async (text, chatId, messageId, callback) => {
-            await sendToOrchestrator(text, { type: "telegram", chatId, messageId }, callback);
+        setTelegramHandler(async (text, chatId, messageId, callback, attachments) => {
+            await sendToOrchestrator(text, { type: "telegram", chatId, messageId }, callback, attachments);
         });
         createBot();
         await startBot();

package/dist/instance-watchdog.js

@@ -3,23 +3,55 @@
  *
  * Periodically checks for active squad instances that haven't had any
  * task activity beyond a configurable timeout and auto-aborts them.
+ * Also detects instances stuck in 'merging' state (#267).
  */
 import { getDb } from "./store/db.js";
 import { updateInstanceStatus } from "./store/instances.js";
 import { createFeedEntry } from "./store/feed.js";
 const DEFAULT_CHECK_INTERVAL_MS = 5 * 60_000; // Check every 5 minutes
 const DEFAULT_STALE_THRESHOLD_MS = 30 * 60_000; // 30 minutes with no task activity
+const DEFAULT_MERGING_THRESHOLD_MS = 5 * 60_000; // 5 minutes stuck in merging
 /**
- * Find active instances whose last task activity exceeds the threshold.
- * "Activity" is defined as the most recent started_at or completed_at
- * in agent_tasks for that instance, or the instance's created_at if no tasks.
+ * Find instances that are stale or stuck.
+ *
+ * For 'active' instances: uses task-activity-based staleness (last started_at/completed_at).
+ * For 'merging' instances: uses wall-clock since entering merging state (shorter threshold).
  */
-export function findStaleInstances(thresholdMs) {
+export function findStaleInstances(thresholdMs, mergingThresholdMs = DEFAULT_MERGING_THRESHOLD_MS) {
     const db = getDb();
     const now = Date.now();
-    const activeInstances = db.prepare("SELECT * FROM squad_instances WHERE status = 'active'").all();
+    const instances = db.prepare("SELECT * FROM squad_instances WHERE status IN ('active', 'merging')").all();
     const stale = [];
-    for (const instance of activeInstances) {
+    for (const instance of instances) {
+        if (instance.status === "merging") {
+            // Merging instances: use the time they've been in merging state.
+            // We approximate this from completed_at (set when status changes to terminal)
+            // or fall back to created_at. Since updateInstanceStatus doesn't set completed_at
+            // for non-terminal states, we use a query on the DB's internal timestamp approach.
+            // Best proxy: last task completed_at (since merging happens after task completion).
+            const lastTaskCompleted = db.prepare(`
+        SELECT MAX(completed_at) AS last_ts
+        FROM agent_tasks
+        WHERE instance_id = ?
+      `).get(instance.id);
+            const rawTs = lastTaskCompleted?.last_ts ?? instance.created_at;
+            const lastTs = new Date(rawTs.includes("T") ? rawTs : rawTs + "Z").getTime();
+            const idleMs = now - lastTs;
+            if (idleMs >= mergingThresholdMs) {
+                stale.push({ instance, idleMs });
+            }
+            continue;
+        }
+        // Active instances: skip those whose most recent task completed successfully —
+        // auto-complete in agents.ts handles these (#261)
+        const latestTaskStatus = db.prepare(`
+      SELECT status FROM agent_tasks
+      WHERE instance_id = ?
+      ORDER BY COALESCE(completed_at, started_at) DESC
+      LIMIT 1
+    `).get(instance.id);
+        if (latestTaskStatus?.status === "done")
+            continue;
         // Find the most recent task activity for this instance
         const lastActivity = db.prepare(`
       SELECT MAX(COALESCE(completed_at, started_at)) AS last_ts
@@ -41,16 +73,18 @@ export function findStaleInstances(thresholdMs) {
 export function startInstanceWatchdog(opts = {}) {
     const checkInterval = opts.checkIntervalMs ?? DEFAULT_CHECK_INTERVAL_MS;
     const staleThreshold = opts.staleThresholdMs ?? DEFAULT_STALE_THRESHOLD_MS;
+    const mergingThreshold = opts.mergingThresholdMs ?? DEFAULT_MERGING_THRESHOLD_MS;
     const timer = setInterval(() => {
         try {
-            const staleInstances = findStaleInstances(staleThreshold);
+            const staleInstances = findStaleInstances(staleThreshold, mergingThreshold);
             for (const { instance, idleMs } of staleInstances) {
-                console.error(`[instance-watchdog] Auto-aborting stale instance "${instance.id}" — idle for ${Math.round(idleMs / 60_000)}m (threshold: ${Math.round(staleThreshold / 60_000)}m)`);
+                const reason = instance.status === "merging" ? "stuck in merging" : "idle";
+                console.error(`[instance-watchdog] Auto-aborting ${reason} instance "${instance.id}" — ${Math.round(idleMs / 60_000)}m (threshold: ${Math.round(instance.status === "merging" ? mergingThreshold / 60_000 : staleThreshold / 60_000)}m)`);
                 updateInstanceStatus(instance.id, "failed");
                 createFeedEntry({
                     type: "notification",
                     title: `[${instance.master_squad_slug}] Instance auto-aborted`,
-                    body: `Instance "${instance.id}" was auto-aborted after ${Math.round(idleMs / 60_000)} minutes of inactivity. Worktree preserved at: ${instance.worktree_path}`,
+                    body: `Instance "${instance.id}" was auto-aborted (${reason}) after ${Math.round(idleMs / 60_000)} minutes. Worktree preserved at: ${instance.worktree_path}`,
                     source_type: "instance-watchdog",
                 });
                 if (opts.onAbort) {

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