superacli 1.1.2 → 1.1.4

package/__tests__/mcp-local.test.js

@@ -52,12 +52,54 @@ describe("mcp-local", () => {
       setMcpServer: mockSetMcpServer,
     });
 
-    expect(mockSetMcpServer).toHaveBeenCalledWith("s1", "u1");
+    expect(mockSetMcpServer).toHaveBeenCalledWith("s1", expect.objectContaining({ url: "u1" }));
     expect(mockOutput).toHaveBeenCalledWith(
       expect.objectContaining({ ok: true }),
     );
   });
 
+  test("add subcommand supports command and JSON fields", async () => {
+    await handleMcpRegistryCommand({
+      positional: ["mcp", "add", "browser-use"],
+      flags: {
+        command: "npx",
+        "args-json": '["mcp-remote","https://api.browser-use.com/mcp"]',
+        "headers-json": '{"X-Browser-Use-API-Key":"k"}',
+        "env-json": '{"BROWSER_USE_API_KEY":"k"}',
+        "timeout-ms": "12000"
+      },
+      output: mockOutput,
+      setMcpServer: mockSetMcpServer,
+      outputError: mockOutputError
+    });
+
+    expect(mockSetMcpServer).toHaveBeenCalledWith(
+      "browser-use",
+      expect.objectContaining({
+        command: "npx",
+        args: ["mcp-remote", "https://api.browser-use.com/mcp"],
+        headers: { "X-Browser-Use-API-Key": "k" },
+        env: { BROWSER_USE_API_KEY: "k" },
+        timeout_ms: 12000
+      })
+    );
+    expect(mockOutputError).not.toHaveBeenCalled();
+  });
+
+  test("add subcommand reports invalid JSON flags", async () => {
+    await handleMcpRegistryCommand({
+      positional: ["mcp", "add", "s1"],
+      flags: { command: "npx", "args-json": "[" },
+      outputError: mockOutputError,
+      setMcpServer: mockSetMcpServer,
+    });
+
+    expect(mockOutputError).toHaveBeenCalledWith(
+      expect.objectContaining({ code: 85 }),
+    );
+    expect(mockSetMcpServer).not.toHaveBeenCalled();
+  });
+
   test("add subcommand validation error", async () => {
     await handleMcpRegistryCommand({
       positional: ["mcp", "add"],

package/__tests__/mongosh-plugin.test.js

@@ -0,0 +1,106 @@
+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 writeFakeMongoshBinary(dir) {
+  const bin = path.join(dir, "mongosh")
+  fs.writeFileSync(bin, [
+    "#!/usr/bin/env node",
+    "const args = process.argv.slice(2);",
+    "if (args[0] === '--version') { console.log('2.3.9-test'); process.exit(0); }",
+    "const evalIndex = args.indexOf('--eval');",
+    "if (evalIndex >= 0) {",
+    "  const script = args[evalIndex + 1];",
+    "  if (script === 'db.adminCommand({ ping: 1 })') {",
+    "    console.log(JSON.stringify({ ok: 1 }));",
+    "    process.exit(0);",
+    "  }",
+    "  console.log(JSON.stringify({ ok: 1, script }));",
+    "  process.exit(0);",
+    "}",
+    "console.log(JSON.stringify({ ok: true, args }));"
+  ].join("\n"), "utf-8")
+  fs.chmodSync(bin, 0o755)
+  return bin
+}
+
+describe("mongosh plugin", () => {
+  const fakeDir = fs.mkdtempSync(path.join(os.tmpdir(), "dcli-mongosh-"))
+  const tempHome = fs.mkdtempSync(path.join(os.tmpdir(), "dcli-home-mongosh-"))
+  writeFakeMongoshBinary(fakeDir)
+  const env = { ...process.env, PATH: `${fakeDir}:${process.env.PATH || ""}`, SUPERCLI_HOME: tempHome }
+
+  beforeAll(() => {
+    runNoServer("plugins install ./plugins/mongosh --on-conflict replace --json", { env })
+  })
+
+  afterAll(() => {
+    runNoServer("plugins remove mongosh --json", { env })
+    fs.rmSync(fakeDir, { recursive: true, force: true })
+    fs.rmSync(tempHome, { recursive: true, force: true })
+  })
+
+  test("routes cli version wrapped command", () => {
+    const r = runNoServer("mongosh cli version --json", { env })
+    expect(r.ok).toBe(true)
+    const data = JSON.parse(r.output)
+    expect(data.command).toBe("mongosh.cli.version")
+    expect(data.data.raw).toBe("2.3.9-test")
+  })
+
+  test("routes server ping wrapped command", () => {
+    const r = runNoServer("mongosh server ping --host 127.0.0.1 --port 27017 --json", { env })
+    expect(r.ok).toBe(true)
+    const data = JSON.parse(r.output)
+    expect(data.command).toBe("mongosh.server.ping")
+    expect(data.data.ok).toBe(1)
+  })
+
+  test("routes eval run wrapped command", () => {
+    const r = runNoServer("mongosh eval run --javascript \"db.runCommand({ buildInfo: 1 })\" --json", { env })
+    expect(r.ok).toBe(true)
+    const data = JSON.parse(r.output)
+    expect(data.command).toBe("mongosh.eval.run")
+    expect(data.data.script).toBe("db.runCommand({ buildInfo: 1 })")
+  })
+
+  test("supports namespace passthrough", () => {
+    const r = runNoServer("mongosh --help --json", { env })
+    expect(r.ok).toBe(true)
+    const data = JSON.parse(r.output)
+    expect(data.command).toBe("mongosh.passthrough")
+    expect(data.data.args).toContain("--help")
+    expect(data.data.args).toContain("--json")
+  })
+
+  test("doctor reports mongosh dependency as healthy", () => {
+    const r = runNoServer("plugins doctor mongosh --json", { env })
+    expect(r.ok).toBe(true)
+    const data = JSON.parse(r.output)
+    expect(data.ok).toBe(true)
+    expect(data.checks.some(c => c.type === "binary" && c.binary === "mongosh" && c.ok === true)).toBe(true)
+  })
+})

package/__tests__/mysql-plugin.test.js

@@ -0,0 +1,94 @@
+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 writeFakeMysqlBinary(dir) {
+  const bin = path.join(dir, "mysql")
+  fs.writeFileSync(bin, [
+    "#!/usr/bin/env node",
+    "const args = process.argv.slice(2);",
+    "if (args[0] === '--version') { console.log('mysql  Ver 8.4.0-test for Linux on x86_64'); process.exit(0); }",
+    "const executeIndex = args.indexOf('--execute');",
+    "if (executeIndex >= 0) {",
+    "  const sql = args[executeIndex + 1];",
+    "  console.log('RESULT\\t' + sql);",
+    "  process.exit(0);",
+    "}",
+    "console.log(JSON.stringify({ ok: true, args }));"
+  ].join("\n"), "utf-8")
+  fs.chmodSync(bin, 0o755)
+  return bin
+}
+
+describe("mysql plugin", () => {
+  const fakeDir = fs.mkdtempSync(path.join(os.tmpdir(), "dcli-mysql-"))
+  const tempHome = fs.mkdtempSync(path.join(os.tmpdir(), "dcli-home-mysql-"))
+  writeFakeMysqlBinary(fakeDir)
+  const env = { ...process.env, PATH: `${fakeDir}:${process.env.PATH || ""}`, SUPERCLI_HOME: tempHome }
+
+  beforeAll(() => {
+    runNoServer("plugins install ./plugins/mysql --on-conflict replace --json", { env })
+  })
+
+  afterAll(() => {
+    runNoServer("plugins remove mysql --json", { env })
+    fs.rmSync(fakeDir, { recursive: true, force: true })
+    fs.rmSync(tempHome, { recursive: true, force: true })
+  })
+
+  test("routes cli version wrapped command", () => {
+    const r = runNoServer("mysql cli version --json", { env })
+    expect(r.ok).toBe(true)
+    const data = JSON.parse(r.output)
+    expect(data.command).toBe("mysql.cli.version")
+    expect(data.data.raw).toContain("mysql  Ver 8.4.0-test")
+  })
+
+  test("routes query execute wrapped command", () => {
+    const r = runNoServer("mysql query execute --execute \"select 1\" --host 127.0.0.1 --user root --database mysql --json", { env })
+    expect(r.ok).toBe(true)
+    const data = JSON.parse(r.output)
+    expect(data.command).toBe("mysql.query.execute")
+    expect(data.data.raw).toBe("RESULT\tselect 1")
+  })
+
+  test("supports namespace passthrough", () => {
+    const r = runNoServer("mysql --help --json", { env })
+    expect(r.ok).toBe(true)
+    const data = JSON.parse(r.output)
+    expect(data.command).toBe("mysql.passthrough")
+    expect(data.data.args).toContain("--help")
+    expect(data.data.args).toContain("--json")
+  })
+
+  test("doctor reports mysql dependency as healthy", () => {
+    const r = runNoServer("plugins doctor mysql --json", { env })
+    expect(r.ok).toBe(true)
+    const data = JSON.parse(r.output)
+    expect(data.ok).toBe(true)
+    expect(data.checks.some(c => c.type === "binary" && c.binary === "mysql" && c.ok === true)).toBe(true)
+  })
+})

package/__tests__/plugin-blogwatcher.test.js

@@ -0,0 +1,55 @@
+const { addProvider, removeProvider, syncCatalog } = require("../cli/skills-catalog")
+const {
+  CATALOG_FILES,
+  buildRemoteEntries,
+  run
+} = require("../plugins/blogwatcher/scripts/post-install")
+const { run: runUninstall } = require("../plugins/blogwatcher/scripts/post-uninstall")
+
+jest.mock("../cli/skills-catalog")
+
+describe("plugin-blogwatcher", () => {
+  beforeEach(() => {
+    jest.clearAllMocks()
+  })
+
+  test("buildRemoteEntries maps curated blogwatcher docs", () => {
+    const entries = buildRemoteEntries()
+
+    expect(entries).toHaveLength(CATALOG_FILES.length)
+    expect(entries.map(entry => entry.id)).toEqual(["root.skill", "root.readme"])
+    expect(entries.every(entry => entry.source_url.includes("raw.githubusercontent.com/Hyaxia/blogwatcher/main/"))).toBe(true)
+  })
+
+  test("run stores provider and syncs catalog", () => {
+    syncCatalog.mockReturnValue({ skills: [1, 2, 3] })
+
+    const result = run()
+
+    expect(addProvider).toHaveBeenCalledWith(expect.objectContaining({
+      name: "blogwatcher",
+      type: "remote_static",
+      entries: expect.arrayContaining([
+        expect.objectContaining({ id: "root.skill" }),
+        expect.objectContaining({ id: "root.readme" })
+      ])
+    }))
+    expect(syncCatalog).toHaveBeenCalled()
+    expect(result).toEqual({
+      provider: "blogwatcher",
+      entries: CATALOG_FILES.length,
+      synced_skills: 3
+    })
+  })
+
+  test("post-uninstall removes provider and syncs catalog", () => {
+    removeProvider.mockReturnValue(true)
+    syncCatalog.mockReturnValue({ skills: [1] })
+
+    const result = runUninstall()
+
+    expect(removeProvider).toHaveBeenCalledWith("blogwatcher")
+    expect(syncCatalog).toHaveBeenCalled()
+    expect(result).toEqual({ provider: "blogwatcher", removed: true, synced_skills: 1 })
+  })
+})

package/__tests__/plugin-clix.test.js

@@ -0,0 +1,51 @@
+const { addProvider, removeProvider, syncCatalog } = require("../cli/skills-catalog")
+const {
+  CATALOG_FILES,
+  buildRemoteEntries,
+  run
+} = require("../plugins/clix/scripts/post-install")
+const { run: runUninstall } = require("../plugins/clix/scripts/post-uninstall")
+
+jest.mock("../cli/skills-catalog")
+
+describe("plugin-clix", () => {
+  beforeEach(() => {
+    jest.clearAllMocks()
+  })
+
+  test("buildRemoteEntries maps curated clix docs", () => {
+    const entries = buildRemoteEntries()
+
+    expect(entries).toHaveLength(CATALOG_FILES.length)
+    expect(entries.map(entry => entry.id)).toEqual(["root.skill", "root.readme"])
+    expect(entries.every(entry => entry.source_url.includes("raw.githubusercontent.com/spideystreet/clix/main/"))).toBe(true)
+  })
+
+  test("run stores provider and syncs catalog", () => {
+    syncCatalog.mockReturnValue({ skills: [1, 2] })
+
+    const result = run()
+
+    expect(addProvider).toHaveBeenCalledWith(expect.objectContaining({
+      name: "clix",
+      type: "remote_static",
+      entries: expect.arrayContaining([
+        expect.objectContaining({ id: "root.skill" }),
+        expect.objectContaining({ id: "root.readme" })
+      ])
+    }))
+    expect(syncCatalog).toHaveBeenCalled()
+    expect(result).toEqual({ provider: "clix", entries: CATALOG_FILES.length, synced_skills: 2 })
+  })
+
+  test("post-uninstall removes provider and syncs catalog", () => {
+    removeProvider.mockReturnValue(true)
+    syncCatalog.mockReturnValue({ skills: [1] })
+
+    const result = runUninstall()
+
+    expect(removeProvider).toHaveBeenCalledWith("clix")
+    expect(syncCatalog).toHaveBeenCalled()
+    expect(result).toEqual({ provider: "clix", removed: true, synced_skills: 1 })
+  })
+})

package/__tests__/plugin-xurl.test.js

@@ -0,0 +1,51 @@
+const { addProvider, removeProvider, syncCatalog } = require("../cli/skills-catalog")
+const {
+  CATALOG_FILES,
+  buildRemoteEntries,
+  run
+} = require("../plugins/xurl/scripts/post-install")
+const { run: runUninstall } = require("../plugins/xurl/scripts/post-uninstall")
+
+jest.mock("../cli/skills-catalog")
+
+describe("plugin-xurl", () => {
+  beforeEach(() => {
+    jest.clearAllMocks()
+  })
+
+  test("buildRemoteEntries maps curated xurl docs", () => {
+    const entries = buildRemoteEntries()
+
+    expect(entries).toHaveLength(CATALOG_FILES.length)
+    expect(entries.map(entry => entry.id)).toEqual(["root.skill", "root.readme"])
+    expect(entries.every(entry => entry.source_url.includes("raw.githubusercontent.com/xdevplatform/xurl/main/"))).toBe(true)
+  })
+
+  test("run stores provider and syncs catalog", () => {
+    syncCatalog.mockReturnValue({ skills: [1, 2] })
+
+    const result = run()
+
+    expect(addProvider).toHaveBeenCalledWith(expect.objectContaining({
+      name: "xurl",
+      type: "remote_static",
+      entries: expect.arrayContaining([
+        expect.objectContaining({ id: "root.skill" }),
+        expect.objectContaining({ id: "root.readme" })
+      ])
+    }))
+    expect(syncCatalog).toHaveBeenCalled()
+    expect(result).toEqual({ provider: "xurl", entries: CATALOG_FILES.length, synced_skills: 2 })
+  })
+
+  test("post-uninstall removes provider and syncs catalog", () => {
+    removeProvider.mockReturnValue(true)
+    syncCatalog.mockReturnValue({ skills: [1] })
+
+    const result = runUninstall()
+
+    expect(removeProvider).toHaveBeenCalledWith("xurl")
+    expect(syncCatalog).toHaveBeenCalled()
+    expect(result).toEqual({ provider: "xurl", removed: true, synced_skills: 1 })
+  })
+})

package/__tests__/server-config-service.test.js

@@ -32,7 +32,7 @@ describe("configService", () => {
     })
     mockStorage.get.mockImplementation((key) => {
       if (key === "command:n.r.a") return { namespace: "n", resource: "r", action: "a", adapter: "builtin" }
-      if (key === "mcp:s1") return { name: "s1", url: "u1" }
+      if (key === "mcp:s1") return { name: "s1", command: "npx", args: ["mcp-remote", "u1"], headers: { H: "v" }, env: { E: "1" } }
       if (key === "spec:sp1") return { name: "sp1", url: "u2", auth: "none" }
       if (key === "settings:config_version") return "10"
       return null
@@ -42,6 +42,13 @@ describe("configService", () => {
     expect(config.version).toBe("10")
     expect(config.commands).toHaveLength(1)
     expect(config.mcp_servers).toHaveLength(1)
+    expect(config.mcp_servers[0]).toEqual(expect.objectContaining({
+      name: "s1",
+      command: "npx",
+      args: ["mcp-remote", "u1"],
+      headers: { H: "v" },
+      env: { E: "1" }
+    }))
     expect(config.specs).toHaveLength(1)
   })
 

package/__tests__/skills.test.js

@@ -1,8 +1,10 @@
 const {
+  MCP_SERVERS_USAGE_SKILL_ID,
   normalizeSkillId,
   buildCommandSkillMarkdown,
   buildTeachSkillMarkdown,
   buildPluginsUsageSkillMarkdown,
+  buildMcpServersUsageSkillMarkdown,
   listSkillsMetadata,
   handleSkillsCommand,
   renderYamlObject
@@ -97,6 +99,14 @@ describe("skills", () => {
     expect(md).toContain("# Instruction")
   })
 
+  test("buildMcpServersUsageSkillMarkdown returns markdown", () => {
+    const md = buildMcpServersUsageSkillMarkdown({ showDag: true })
+    expect(md).toContain("skill_name: \"mcp_servers_usage\"")
+    expect(md).toContain("supercli mcp add browser-use --command npx")
+    expect(md).toContain("X-Browser-Use-API-Key")
+    expect(md).toContain("dag:")
+  })
+
   test("listSkillsMetadata keeps name and description only", () => {
     const skills = listSkillsMetadata({
       commands: [{ namespace: "x", resource: "y", action: "z", description: "desc" }]
@@ -104,6 +114,8 @@ describe("skills", () => {
     expect(skills).toEqual(expect.arrayContaining([{ name: "x.y.z", description: "desc" }]))
     const item = skills.find(s => s.name === "x.y.z")
     expect(item.description).toBe("desc")
+    const mcpSkill = skills.find(s => s.name === MCP_SERVERS_USAGE_SKILL_ID)
+    expect(mcpSkill).toBeTruthy()
   })
 
   describe("handleSkillsCommand", () => {
@@ -220,6 +232,20 @@ describe("skills", () => {
       consoleSpy.mockRestore()
     })
 
+    test("get subcommand (mcp servers usage)", () => {
+      const consoleSpy = jest.spyOn(console, "log").mockImplementation()
+      const result = handleSkillsCommand({
+        positional: ["skills", "get", "mcp.servers.usage"],
+        flags: { format: "skill.md" },
+        config: {},
+        output: mockOutput
+      })
+
+      expect(result).toBe(true)
+      expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("skill_name: \"mcp_servers_usage\""))
+      consoleSpy.mockRestore()
+    })
+
     test("get subcommand (catalog)", () => {
       const consoleSpy = jest.spyOn(console, "log").mockImplementation()
       catalog.getCatalogSkill.mockReturnValue({ markdown: "catalog-md" })

package/__tests__/wacli-plugin.test.js

@@ -0,0 +1,132 @@
+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 writeFakeWacliBinary(dir) {
+  const bin = path.join(dir, "wacli")
+  fs.writeFileSync(bin, [
+    "#!/usr/bin/env node",
+    "const args = process.argv.slice(2);",
+    "if (args[0] === '--version') { console.log('wacli 0.2.0-test'); process.exit(0); }",
+    "const hasJson = args.includes('--json');",
+    "const storeIndex = args.indexOf('--store');",
+    "const store = storeIndex >= 0 ? args[storeIndex + 1] : null;",
+    "const clean = args.filter((arg, i) => arg !== '--json' && arg !== '--store' && i !== storeIndex + 1);",
+    "if (clean[0] === 'doctor') { console.log(JSON.stringify({ ok: true, store })); process.exit(0); }",
+    "if (clean[0] === 'auth' && clean[1] === 'status') { console.log(JSON.stringify({ authenticated: true, store })); process.exit(0); }",
+    "if (clean[0] === 'chats' && clean[1] === 'list') { console.log(JSON.stringify([{ JID: '123@s.whatsapp.net', Name: 'Alice', store }])); process.exit(0); }",
+    "if (clean[0] === 'chats' && clean[1] === 'show') { console.log(JSON.stringify({ JID: clean[3], Name: 'Alice Chat', store })); process.exit(0); }",
+    "if (clean[0] === 'messages' && clean[1] === 'list') { console.log(JSON.stringify([{ ChatJID: '123@s.whatsapp.net', ID: 'm1', Text: 'hello', store }])); process.exit(0); }",
+    "if (clean[0] === 'messages' && clean[1] === 'search') { console.log(JSON.stringify([{ ID: 'm2', Text: clean[2], store }])); process.exit(0); }",
+    "if (clean[0] === 'messages' && clean[1] === 'show') { console.log(JSON.stringify({ ChatJID: clean[3], ID: clean[5], Text: 'full message', store })); process.exit(0); }",
+    "if (clean[0] === 'messages' && clean[1] === 'context') { console.log(JSON.stringify({ center: clean[5], messages: [{ ID: 'm0' }, { ID: clean[5] }, { ID: 'm3' }], store })); process.exit(0); }",
+    "if (clean[0] === 'contacts' && clean[1] === 'search') { console.log(JSON.stringify([{ JID: '123@s.whatsapp.net', Name: clean[2], store }])); process.exit(0); }",
+    "if (clean[0] === 'contacts' && clean[1] === 'show') { console.log(JSON.stringify({ JID: clean[3], Name: 'Alice', store })); process.exit(0); }",
+    "if (clean[0] === 'groups' && clean[1] === 'list') { console.log(JSON.stringify([{ JID: '456@g.us', Name: 'Test Group', store }])); process.exit(0); }",
+    "if (clean[0] === 'groups' && clean[1] === 'info') { console.log(JSON.stringify({ JID: clean[3], Name: 'Test Group', store })); process.exit(0); process.exit(0); }",
+    "if (hasJson) { console.log(JSON.stringify({ ok: true, args, store })); process.exit(0); }",
+    "console.log('human output');"
+  ].join("\n"), "utf-8")
+  fs.chmodSync(bin, 0o755)
+  return bin
+}
+
+describe("wacli plugin", () => {
+  const fakeDir = fs.mkdtempSync(path.join(os.tmpdir(), "dcli-wacli-"))
+  const tempHome = fs.mkdtempSync(path.join(os.tmpdir(), "dcli-home-wacli-"))
+  const fakeStore = path.join(tempHome, "store")
+  fs.mkdirSync(fakeStore, { recursive: true })
+  writeFakeWacliBinary(fakeDir)
+  const env = { ...process.env, PATH: `${fakeDir}:${process.env.PATH || ""}`, SUPERCLI_HOME: tempHome }
+
+  beforeAll(() => {
+    runNoServer("plugins install ./plugins/wacli --on-conflict replace --json", { env })
+  })
+
+  afterAll(() => {
+    runNoServer("plugins remove wacli --json", { env })
+    fs.rmSync(fakeDir, { recursive: true, force: true })
+    fs.rmSync(tempHome, { recursive: true, force: true })
+  })
+
+  test("routes version and doctor commands", () => {
+    const version = runNoServer("wacli cli version --json", { env })
+    expect(version.ok).toBe(true)
+    expect(JSON.parse(version.output).data.raw).toBe("wacli 0.2.0-test")
+
+    const doctor = runNoServer(`wacli doctor run --store ${fakeStore} --json`, { env })
+    expect(doctor.ok).toBe(true)
+    const doctorData = JSON.parse(doctor.output)
+    expect(doctorData.command).toBe("wacli.doctor.run")
+    expect(doctorData.data.ok).toBe(true)
+    expect(doctorData.data.store).toBe(fakeStore)
+  })
+
+  test("routes auth chats and messages wrappers", () => {
+    const auth = runNoServer(`wacli auth status --store ${fakeStore} --json`, { env })
+    expect(auth.ok).toBe(true)
+    expect(JSON.parse(auth.output).data.authenticated).toBe(true)
+
+    const chats = runNoServer(`wacli chats list --store ${fakeStore} --limit 5 --json`, { env })
+    expect(chats.ok).toBe(true)
+    expect(JSON.parse(chats.output).data[0].JID).toBe("123@s.whatsapp.net")
+
+    const show = runNoServer(`wacli chats show --jid 123@s.whatsapp.net --store ${fakeStore} --json`, { env })
+    expect(show.ok).toBe(true)
+    expect(JSON.parse(show.output).data.JID).toBe("123@s.whatsapp.net")
+
+    const search = runNoServer(`wacli messages search --query meeting --store ${fakeStore} --limit 10 --json`, { env })
+    expect(search.ok).toBe(true)
+    expect(JSON.parse(search.output).data[0].Text).toBe("meeting")
+  })
+
+  test("routes message context contacts and groups wrappers", () => {
+    const show = runNoServer(`wacli messages show --chat 123@s.whatsapp.net --id m1 --store ${fakeStore} --json`, { env })
+    expect(show.ok).toBe(true)
+    expect(JSON.parse(show.output).data.ID).toBe("m1")
+
+    const context = runNoServer(`wacli messages context --chat 123@s.whatsapp.net --id m1 --before 1 --after 1 --store ${fakeStore} --json`, { env })
+    expect(context.ok).toBe(true)
+    expect(JSON.parse(context.output).data.messages).toHaveLength(3)
+
+    const contact = runNoServer(`wacli contacts show --jid 123@s.whatsapp.net --store ${fakeStore} --json`, { env })
+    expect(contact.ok).toBe(true)
+    expect(JSON.parse(contact.output).data.Name).toBe("Alice")
+
+    const group = runNoServer(`wacli groups info --jid 456@g.us --store ${fakeStore} --json`, { env })
+    expect(group.ok).toBe(true)
+    expect(JSON.parse(group.output).data.JID).toBe("456@g.us")
+  })
+
+  test("does not expose passthrough and reports dependency health", () => {
+    const manifest = JSON.parse(fs.readFileSync(path.join(__dirname, "..", "plugins", "wacli", "plugin.json"), "utf-8"))
+    expect(manifest.commands.some(command => command.resource === "_" && command.action === "_")).toBe(false)
+
+    const doctor = runNoServer("plugins doctor wacli --json", { env })
+    expect(doctor.ok).toBe(true)
+    expect(JSON.parse(doctor.output).checks.some(c => c.type === "binary" && c.binary === "wacli" && c.ok === true)).toBe(true)
+  })
+})