superacli 1.1.4 → 1.1.5

package/__tests__/adapter-schema.test.js

@@ -44,6 +44,8 @@ describe("adapter-schema", () => {
     expect(() => validateAdapterConfig({ adapter: "mcp", adapterConfig: { tool: 1 } })).toThrow(/requires adapterConfig.tool/)
     expect(() => validateAdapterConfig({ adapter: "mcp", adapterConfig: { tool: "t" } })).toThrow(/requires one source/)
     expect(() => validateAdapterConfig({ adapter: "mcp", adapterConfig: { tool: "t", server: "s" } })).not.toThrow()
+    expect(() => validateAdapterConfig({ adapter: "mcp", adapterConfig: { tool: "t", server: "s", timeout_ms: 180000 } })).not.toThrow()
+    expect(() => validateAdapterConfig({ adapter: "mcp", adapterConfig: { tool: "t", server: "s", timeout_ms: 180001 } })).toThrow(/cannot exceed 180000ms/)
   })
 
   test("process adapter validation", () => {

package/__tests__/config.test.js

@@ -13,7 +13,9 @@ const {
   showConfig,
   setMcpServer,
   removeMcpServer,
-  listMcpServers
+  listMcpServers,
+  upsertCommand,
+  removeCommandsByNamespace
 } = require("../cli/config")
 const { getInstalledPluginCommands, listInstalledPlugins } = require("../cli/plugins-store")
 
@@ -298,6 +300,46 @@ describe("config", () => {
     })
   })
 
+  describe("command management", () => {
+    test("upsertCommand adds and updates local command aliases", async () => {
+      fs.existsSync.mockReturnValue(true)
+      fs.readFileSync.mockReturnValue(JSON.stringify({
+        commands: [
+          { namespace: "a", resource: "b", action: "c", adapter: "http" }
+        ]
+      }))
+
+      await upsertCommand({
+        namespace: "ai",
+        resource: "browser",
+        action: "probe",
+        adapter: "mcp",
+        adapterConfig: { server: "browser-use", tool: "navigate" }
+      })
+
+      let lastWrite = JSON.parse(fs.writeFileSync.mock.calls[0][1])
+      expect(lastWrite.commands).toEqual(expect.arrayContaining([
+        expect.objectContaining({ namespace: "a", resource: "b", action: "c" }),
+        expect.objectContaining({ namespace: "ai", resource: "browser", action: "probe", adapter: "mcp" })
+      ]))
+
+      fs.readFileSync.mockReturnValue(JSON.stringify(lastWrite))
+      fs.writeFileSync.mockClear()
+
+      await upsertCommand({
+        namespace: "ai",
+        resource: "browser",
+        action: "probe",
+        adapter: "mcp",
+        description: "updated"
+      })
+
+      lastWrite = JSON.parse(fs.writeFileSync.mock.calls[0][1])
+      const updated = lastWrite.commands.find(c => c.namespace === "ai" && c.resource === "browser" && c.action === "probe")
+      expect(updated.description).toBe("updated")
+    })
+  })
+
   describe("showConfig", () => {
     test("returns message if no cache", async () => {
       fs.existsSync.mockReturnValue(false)
@@ -338,5 +380,24 @@ describe("config", () => {
       expect(result.mcp_servers).toBe(0)
       expect(result.specs).toBe(0)
     })
+
+    test("removeCommandsByNamespace removes all matching namespace commands", async () => {
+      fs.existsSync.mockReturnValue(true)
+      fs.readFileSync.mockReturnValue(JSON.stringify({
+        commands: [
+          { namespace: "browseruse", resource: "tool", action: "list-skills" },
+          { namespace: "browseruse", resource: "tool", action: "browser-task" },
+          { namespace: "ai", resource: "text", action: "summarize" }
+        ]
+      }))
+
+      const removed = await removeCommandsByNamespace("browseruse")
+      expect(removed).toBe(2)
+
+      const lastWrite = JSON.parse(fs.writeFileSync.mock.calls[0][1])
+      expect(lastWrite.commands).toEqual([
+        { namespace: "ai", resource: "text", action: "summarize" }
+      ])
+    })
   })
 })

package/__tests__/help-json.test.js

@@ -5,6 +5,8 @@ describe("help-json", () => {
     const data = buildCapabilities({ commands: [] }, false)
 
     expect(data.commands.plugins).toBeDefined()
+    expect(data.commands.plugins.subcommands).toEqual(expect.arrayContaining(["learn"]))
+    expect(data.commands.mcp.subcommands).toEqual(expect.arrayContaining(["tools", "call", "bind", "doctor"]))
     expect(data.commands.sync).toBeUndefined()
     expect(data.flags["--help-json"]).toBeDefined()
   })

package/__tests__/mcp-adapter.test.js

@@ -4,6 +4,11 @@ const EventEmitter = require("events")
 
 jest.mock("child_process")
 
+function frame(obj) {
+  const body = JSON.stringify(obj)
+  return `Content-Length: ${Buffer.byteLength(body, "utf-8")}\r\n\r\n${body}`
+}
+
 describe("mcp adapter", () => {
   beforeEach(() => {
     jest.clearAllMocks()
@@ -43,6 +48,15 @@ describe("mcp adapter", () => {
     })
 
     test("resolves stdio command from named server and merges args/env", async () => {
+      mockChild.stdin.write = jest.fn((data) => {
+        if (String(data).includes('"method":"initialize"')) {
+          mockChild.stdout.emit("data", frame({ jsonrpc: "2.0", id: 1, result: { capabilities: {} } }))
+        }
+        if (String(data).includes('"method":"tools/call"')) {
+          mockChild.stdout.emit("data", frame({ jsonrpc: "2.0", id: 2, result: { ok: true } }))
+        }
+      })
+
       const promise = execute(
         {
           adapterConfig: {
@@ -67,10 +81,6 @@ describe("mcp adapter", () => {
         }
       )
 
-      await Promise.resolve()
-      mockChild.stdout.emit("data", '{"ok":true}')
-      mockChild.emit("close", 0)
-
       await expect(promise).resolves.toEqual({ ok: true })
       expect(spawn).toHaveBeenCalledWith(
         "npx",

package/__tests__/mcp-local.test.js

@@ -3,6 +3,7 @@ const { handleMcpRegistryCommand } = require("../cli/mcp-local");
 describe("mcp-local", () => {
   let mockOutput, mockOutputHumanTable, mockOutputError;
   let mockSetMcpServer, mockRemoveMcpServer, mockListMcpServers;
+  let mockLoadConfig, mockExecuteCommand, mockUpsertCommand, mockDiscoverTools;
 
   beforeEach(() => {
     mockOutput = jest.fn();
@@ -11,6 +12,10 @@ describe("mcp-local", () => {
     mockSetMcpServer = jest.fn();
     mockRemoveMcpServer = jest.fn();
     mockListMcpServers = jest.fn();
+    mockLoadConfig = jest.fn().mockResolvedValue({ mcp_servers: [] });
+    mockExecuteCommand = jest.fn().mockResolvedValue({ ok: true });
+    mockUpsertCommand = jest.fn(async (c) => c);
+    mockDiscoverTools = jest.fn().mockResolvedValue([]);
   });
 
   test("list subcommand", async () => {
@@ -41,9 +46,163 @@ describe("mcp-local", () => {
     });
 
     expect(mockOutputHumanTable).toHaveBeenCalled();
+    expect(mockOutputHumanTable.mock.calls[0][0][0]).toEqual(
+      expect.objectContaining({ transport: "http", source: "u1" }),
+    );
     consoleSpy.mockRestore();
   });
 
+  test("tools subcommand", async () => {
+    mockListMcpServers.mockResolvedValue([{ name: "browser-use", command: "npx" }]);
+    mockDiscoverTools.mockResolvedValue([{ name: "navigate", description: "Navigate" }]);
+
+    await handleMcpRegistryCommand({
+      positional: ["mcp", "tools"],
+      flags: { "mcp-server": "browser-use" },
+      output: mockOutput,
+      outputError: mockOutputError,
+      listMcpServers: mockListMcpServers,
+      discoverTools: mockDiscoverTools,
+    });
+
+    expect(mockDiscoverTools).toHaveBeenCalledWith(
+      expect.objectContaining({ name: "browser-use" }),
+    );
+    expect(mockOutput).toHaveBeenCalledWith(
+      expect.objectContaining({ discovered: 1 }),
+    );
+  });
+
+  test("call subcommand", async () => {
+    await handleMcpRegistryCommand({
+      positional: ["mcp", "call"],
+      flags: {
+        "mcp-server": "browser-use",
+        tool: "navigate",
+        "input-json": '{"url":"https://example.com"}',
+      },
+      output: mockOutput,
+      outputError: mockOutputError,
+      loadConfig: mockLoadConfig,
+      executeCommand: mockExecuteCommand,
+      serverUrl: "http://server",
+    });
+
+    expect(mockExecuteCommand).toHaveBeenCalledWith(
+      expect.objectContaining({
+        adapter: "mcp",
+        adapterConfig: expect.objectContaining({ server: "browser-use", tool: "navigate" }),
+      }),
+      { url: "https://example.com" },
+      expect.objectContaining({ server: "http://server" }),
+    );
+    expect(mockOutput).toHaveBeenCalledWith(expect.objectContaining({ ok: true }));
+  });
+
+  test("call subcommand supports timeout", async () => {
+    await handleMcpRegistryCommand({
+      positional: ["mcp", "call"],
+      flags: {
+        "mcp-server": "browser-use",
+        tool: "navigate",
+        "timeout-ms": "180000",
+      },
+      output: mockOutput,
+      outputError: mockOutputError,
+      loadConfig: mockLoadConfig,
+      executeCommand: mockExecuteCommand,
+      serverUrl: "http://server",
+    });
+
+    expect(mockExecuteCommand).toHaveBeenCalledWith(
+      expect.objectContaining({
+        adapterConfig: expect.objectContaining({ timeout_ms: 180000 }),
+      }),
+      expect.any(Object),
+      expect.any(Object),
+    );
+  });
+
+  test("call subcommand rejects oversized timeout", async () => {
+    await handleMcpRegistryCommand({
+      positional: ["mcp", "call"],
+      flags: {
+        "mcp-server": "browser-use",
+        tool: "navigate",
+        "timeout-ms": "180001",
+      },
+      outputError: mockOutputError,
+      executeCommand: mockExecuteCommand,
+    });
+
+    expect(mockOutputError).toHaveBeenCalledWith(expect.objectContaining({ code: 85 }));
+    expect(mockExecuteCommand).not.toHaveBeenCalled();
+  });
+
+  test("bind subcommand", async () => {
+    await handleMcpRegistryCommand({
+      positional: ["mcp", "bind"],
+      flags: {
+        "mcp-server": "browser-use",
+        tool: "navigate",
+        as: "ai.browser.probe",
+      },
+      output: mockOutput,
+      outputError: mockOutputError,
+      upsertCommand: mockUpsertCommand,
+    });
+
+    expect(mockUpsertCommand).toHaveBeenCalledWith(
+      expect.objectContaining({
+        namespace: "ai",
+        resource: "browser",
+        action: "probe",
+        adapter: "mcp",
+      }),
+    );
+    expect(mockOutput).toHaveBeenCalledWith(
+      expect.objectContaining({ command: "ai.browser.probe" }),
+    );
+  });
+
+  test("doctor subcommand", async () => {
+    const diagnose = jest.fn().mockResolvedValue({
+      server: "browser-use",
+      status: "degraded",
+      transport: "stdio",
+      checks: [{ id: "tools", ok: false, message: "No tools discovered" }],
+      issues: ["No tools discovered"],
+      tools: [],
+    });
+    mockListMcpServers.mockResolvedValue([{ name: "browser-use", command: "npx" }]);
+
+    await handleMcpRegistryCommand({
+      positional: ["mcp", "doctor"],
+      flags: { "mcp-server": "browser-use" },
+      output: mockOutput,
+      outputError: mockOutputError,
+      listMcpServers: mockListMcpServers,
+      diagnoseServer: diagnose,
+      discoverTools: mockDiscoverTools,
+    });
+
+    expect(diagnose).toHaveBeenCalledWith(
+      expect.objectContaining({ name: "browser-use" }),
+      expect.objectContaining({ discoverTools: mockDiscoverTools }),
+    );
+    expect(mockOutput).toHaveBeenCalledWith(expect.objectContaining({ status: "degraded" }));
+  });
+
+  test("doctor subcommand validation error", async () => {
+    await handleMcpRegistryCommand({
+      positional: ["mcp", "doctor"],
+      flags: {},
+      outputError: mockOutputError,
+    });
+
+    expect(mockOutputError).toHaveBeenCalledWith(expect.objectContaining({ code: 85 }));
+  });
+
   test("add subcommand", async () => {
     await handleMcpRegistryCommand({
       positional: ["mcp", "add", "s1"],

package/__tests__/mcp-stdio-jsonrpc.test.js

@@ -0,0 +1,105 @@
+const EventEmitter = require("events");
+const { spawn } = require("child_process");
+const {
+  shouldUseStdioJsonRpc,
+  stdioListToolsJsonRpc,
+  stdioCallToolJsonRpc,
+} = require("../cli/mcp-stdio-jsonrpc");
+
+jest.mock("child_process");
+
+function frame(obj) {
+  const body = JSON.stringify(obj);
+  return `Content-Length: ${Buffer.byteLength(body, "utf-8")}\r\n\r\n${body}`;
+}
+
+describe("mcp-stdio-jsonrpc", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  test("detects mcp-remote args for JSON-RPC mode", () => {
+    expect(shouldUseStdioJsonRpc({ args: ["mcp-remote", "https://x"] })).toBe(true);
+    expect(shouldUseStdioJsonRpc({ commandArgs: ["mcp-remote"] })).toBe(true);
+    expect(shouldUseStdioJsonRpc({ args: ["node"] })).toBe(false);
+  });
+
+  test("lists tools via stdio JSON-RPC", async () => {
+    const child = new EventEmitter();
+    child.stdout = new EventEmitter();
+    child.stderr = new EventEmitter();
+    child.stdin = {
+      write: jest.fn((data) => {
+        if (String(data).includes('"method":"initialize"')) {
+          child.stdout.emit(
+            "data",
+            Buffer.from(frame({ jsonrpc: "2.0", id: 1, result: { capabilities: {} } })),
+          );
+        }
+        if (String(data).includes('"method":"tools/list"')) {
+          child.stdout.emit(
+            "data",
+            Buffer.from(
+              frame({
+                jsonrpc: "2.0",
+                id: 2,
+                result: { tools: [{ name: "navigate", description: "Go" }] },
+              }),
+            ),
+          );
+        }
+      }),
+      end: jest.fn(),
+    };
+    child.kill = jest.fn();
+    spawn.mockReturnValue(child);
+
+    const out = await stdioListToolsJsonRpc({
+      command: "npx",
+      args: ["mcp-remote", "https://api.browser-use.com/mcp"],
+      timeoutMs: 2000,
+    });
+    expect(out.tools).toHaveLength(1);
+    expect(out.tools[0].name).toBe("navigate");
+  });
+
+  test("calls tool via stdio JSON-RPC", async () => {
+    const child = new EventEmitter();
+    child.stdout = new EventEmitter();
+    child.stderr = new EventEmitter();
+    child.stdin = {
+      write: jest.fn((data) => {
+        if (String(data).includes('"method":"initialize"')) {
+          child.stdout.emit(
+            "data",
+            Buffer.from(frame({ jsonrpc: "2.0", id: 1, result: { capabilities: {} } })),
+          );
+        }
+        if (String(data).includes('"method":"tools/call"')) {
+          child.stdout.emit(
+            "data",
+            Buffer.from(
+              frame({
+                jsonrpc: "2.0",
+                id: 2,
+                result: { content: [{ type: "text", text: "ok" }] },
+              }),
+            ),
+          );
+        }
+      }),
+      end: jest.fn(),
+    };
+    child.kill = jest.fn();
+    spawn.mockReturnValue(child);
+
+    const out = await stdioCallToolJsonRpc({
+      command: "npx",
+      args: ["mcp-remote", "https://api.browser-use.com/mcp"],
+      timeoutMs: 2000,
+      tool: "navigate",
+      input: { url: "https://example.com" },
+    });
+    expect(out).toEqual({ content: [{ type: "text", text: "ok" }] });
+  });
+});

package/__tests__/monty-plugin.test.js

@@ -0,0 +1,121 @@
+const fs = require("fs")
+const os = require("os")
+const path = require("path")
+const { execSync } = require("child_process")
+
+const CLI = path.join(__dirname, "..", "cli", "supercli.js")
+
+function runNoServer(args, options = {}) {
+  try {
+    const env = { ...process.env }
+    delete env.SUPERCLI_SERVER
+    const out = execSync(`node ${CLI} ${args}`, {
+      encoding: "utf-8",
+      timeout: 15000,
+      env: { ...env, ...(options.env || {}) }
+    })
+    return { ok: true, output: out.trim(), code: 0 }
+  } catch (err) {
+    return {
+      ok: false,
+      output: (err.stdout || "").trim(),
+      stderr: (err.stderr || "").trim(),
+      code: err.status
+    }
+  }
+}
+
+function writeFakeCurlBinary(dir) {
+  const bin = path.join(dir, "curl")
+  fs.writeFileSync(bin, [
+    "#!/usr/bin/env node",
+    "const args = process.argv.slice(2);",
+    "const url = args[args.length - 1] || '';",
+    "if (args.includes('--version')) { console.log('curl 8.0.0-test'); process.exit(0); }",
+    "if (url.endsWith('/CLAUDE.md')) { console.log('---\\nskill_name: monty-sandbox\\n---\\n# Monty Sandbox'); process.exit(0); }",
+    "if (url.endsWith('/README.md')) { console.log('# Monty\\n\\nTest readme.'); process.exit(0); }",
+    "if (url.endsWith('/docs/usage-guide.md')) { console.log('# Monty Usage\\n\\nTest usage guide.'); process.exit(0); }",
+    "process.exit(22);"
+  ].join("\n"), "utf-8")
+  fs.chmodSync(bin, 0o755)
+  return bin
+}
+
+describe("monty hybrid plugin", () => {
+  const fakeBinDir = fs.mkdtempSync(path.join(os.tmpdir(), "dcli-monty-bin-"))
+  const tempHome = fs.mkdtempSync(path.join(os.tmpdir(), "dcli-home-monty-"))
+  const fakeUserHome = fs.mkdtempSync(path.join(os.tmpdir(), "dcli-user-home-monty-"))
+  writeFakeCurlBinary(fakeBinDir)
+  
+  const env = {
+    ...process.env,
+    PATH: `${fakeBinDir}:${process.env.PATH || ""}`,
+    SUPERCLI_HOME: tempHome,
+    HOME: fakeUserHome
+  }
+  let removed = false
+
+  beforeAll(() => {
+    // Install the plugin
+    const install = runNoServer("plugins install ./plugins/monty --on-conflict replace --json", { env })
+    if (!install.ok) {
+        console.error("Install failed:", install.output, install.stderr)
+    }
+    expect(install.ok).toBe(true)
+  })
+
+  afterAll(() => {
+    if (!removed) runNoServer("plugins remove monty --json", { env })
+    fs.rmSync(fakeBinDir, { recursive: true, force: true })
+    fs.rmSync(tempHome, { recursive: true, force: true })
+    fs.rmSync(fakeUserHome, { recursive: true, force: true })
+  })
+
+  test("indexes monty skills provider", () => {
+    const list = runNoServer("skills list --catalog --provider monty --json", { env })
+    expect(list.ok).toBe(true)
+    const listData = JSON.parse(list.output)
+    expect(listData.skills.some(skill => skill.id === "monty:root.skill")).toBe(true)
+    expect(listData.skills.some(skill => skill.id === "monty:root.readme")).toBe(true)
+    expect(listData.skills.some(skill => skill.id === "monty:root.usage")).toBe(true)
+  })
+
+  test("fetches indexed remote skill markdown", () => {
+    const skill = runNoServer("skills get monty:root.skill", { env })
+    expect(skill.ok).toBe(true)
+    expect(skill.output).toContain("Monty Sandbox")
+  })
+
+  test("throws controlled error when @pydantic/monty is missing", () => {
+    // Force dependency missing error via env var
+    const r = runNoServer("monty python run --code \"1 + 1\" --json", { 
+        env: { ...env, MOCK_MISSING_MONTY: "1" } 
+    })
+    
+    expect(r.ok).toBe(false)
+    const data = JSON.parse(r.output || r.stderr)
+
+    expect(data.error.message).toContain("@pydantic/monty not found")
+    expect(data.error.suggestions).toContain("Run: supercli monty cli setup")
+  })
+
+  test("doctor reports node and npm dependencies as healthy", () => {
+    const r = runNoServer("plugins doctor monty --json", { env })
+    expect(r.ok).toBe(true)
+    const data = JSON.parse(r.output)
+    expect(data.ok).toBe(true)
+    expect(data.checks.some(c => c.binary === "node" && c.ok === true)).toBe(true)
+    expect(data.checks.some(c => c.binary === "npm" && c.ok === true)).toBe(true)
+  })
+
+  test("removal cleans up the skills provider", () => {
+    const remove = runNoServer("plugins remove monty --json", { env })
+    expect(remove.ok).toBe(true)
+    removed = true
+
+    const list = runNoServer("skills list --catalog --provider monty --json", { env })
+    expect(list.ok).toBe(true)
+    const listData = JSON.parse(list.output)
+    expect(listData.skills).toEqual([])
+  })
+})

package/__tests__/plugin-browser-use-uninstall.test.js

@@ -0,0 +1,23 @@
+const { removeProvider, syncCatalog } = require("../cli/skills-catalog")
+const { removeCommandsByNamespace } = require("../cli/config")
+const { run } = require("../plugins/browser-use/scripts/post-uninstall")
+
+jest.mock("../cli/skills-catalog")
+jest.mock("../cli/config")
+
+describe("plugin-browser-use post-uninstall", () => {
+  beforeEach(() => {
+    jest.clearAllMocks()
+    removeProvider.mockReturnValue(true)
+    removeCommandsByNamespace.mockResolvedValue(6)
+    syncCatalog.mockReturnValue({ skills: [1, 2] })
+  })
+
+  test("removes provider and browseruse commands", async () => {
+    const result = await run()
+    expect(removeCommandsByNamespace).toHaveBeenCalledWith("browseruse")
+    expect(removeProvider).toHaveBeenCalledWith("browser-use")
+    expect(result.removed_commands).toBe(6)
+    expect(result.removed_provider).toBe(true)
+  })
+})

package/__tests__/plugin-browser-use.test.js

@@ -0,0 +1,77 @@
+const { addProvider, syncCatalog } = require("../cli/skills-catalog")
+const { setMcpServer, listMcpServers, upsertCommand } = require("../cli/config")
+const { discoverMcpTools } = require("../cli/mcp-discovery")
+const {
+  run,
+  actionFromToolName,
+  buildToolCommand,
+  KNOWN_TOOLS,
+} = require("../plugins/browser-use/scripts/post-install")
+
+jest.mock("../cli/skills-catalog")
+jest.mock("../cli/config")
+jest.mock("../cli/mcp-discovery")
+
+describe("plugin-browser-use", () => {
+  beforeEach(() => {
+    jest.clearAllMocks()
+    listMcpServers.mockResolvedValue([])
+    setMcpServer.mockResolvedValue({})
+    upsertCommand.mockResolvedValue({})
+    syncCatalog.mockReturnValue({ skills: [1, 2, 3] })
+  })
+
+  test("actionFromToolName normalizes name", () => {
+    expect(actionFromToolName("list_skills")).toBe("list-skills")
+    expect(actionFromToolName("Browser Task")).toBe("browser-task")
+  })
+
+  test("buildToolCommand builds MCP command", () => {
+    const cmd = buildToolCommand("list_skills")
+    expect(cmd.namespace).toBe("browseruse")
+    expect(cmd.resource).toBe("tool")
+    expect(cmd.action).toBe("list-skills")
+    expect(cmd.adapter).toBe("mcp")
+    expect(cmd.adapterConfig.tool).toBe("list_skills")
+  })
+
+  test("run registers server, binds discovered tools, and adds local skill provider", async () => {
+    discoverMcpTools.mockResolvedValue([
+      { name: "list_skills" },
+      { name: "browser_task" },
+    ])
+
+    const result = await run()
+
+    expect(setMcpServer).toHaveBeenCalledWith("browser-use", expect.objectContaining({ command: "npx" }))
+    expect(upsertCommand).toHaveBeenCalledTimes(2)
+    expect(addProvider).toHaveBeenCalledWith(expect.objectContaining({
+      name: "browser-use",
+      type: "local_fs",
+      roots: expect.any(Array),
+    }))
+    expect(result.discovered_tools).toBe(2)
+    expect(result.bound_commands).toBe(2)
+  })
+
+  test("run uses fallback tools when discovery fails", async () => {
+    discoverMcpTools.mockRejectedValue(new Error("network"))
+
+    const result = await run()
+
+    expect(result.discovered_tools).toBe(KNOWN_TOOLS.length)
+    expect(result.bound_commands).toBe(KNOWN_TOOLS.length)
+    expect(result.warnings.length).toBeGreaterThan(0)
+    expect(upsertCommand).toHaveBeenCalledTimes(KNOWN_TOOLS.length)
+  })
+
+  test("run does not overwrite existing MCP server", async () => {
+    listMcpServers.mockResolvedValue([{ name: "browser-use", command: "npx", args: ["x"] }])
+    discoverMcpTools.mockResolvedValue([{ name: "list_skills" }])
+
+    const result = await run()
+
+    expect(setMcpServer).not.toHaveBeenCalled()
+    expect(result.server_created).toBe(false)
+  })
+})