superacli 1.1.3 → 1.1.5

package/README.md

@@ -8,6 +8,7 @@ Discover and execute skills across CLIs, APIs, MCP servers, workflows, and custo
 - supercli (Brand)
 - scli (Brand smaller)
 - superacli (What was available) (Super Agent/ic CLI)
+- sc (For lazy people)
 
 ## What Is a Skill Layer?
 
@@ -243,6 +244,12 @@ A **plugin harness** bridges dcli to an external CLI tool. Each plugin:
 - Docker (`docker`)
 - Kubernetes (`kubectl`)
 - Terraform (`terraform`)
+- MySQL (`mysql`)
+- MongoDB Shell (`mongosh`)
+- Himalaya Email CLI (`himalaya`)
+- WhatsApp CLI (`wacli`)
+- X API CLI (`xurl`)
+- X Cookie CLI (`clix`)
 - npm, pip, cargo (package managers)
 - git, git-cliff (version control)
 - And many more...

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__/blogwatcher-plugin.test.js

@@ -0,0 +1,157 @@
+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('/SKILL.md')) { console.log('---\\nname: blogwatcher-cli\\ndescription: Test skill\\n---\\n# BlogWatcher CLI'); process.exit(0); }",
+    "if (url.endsWith('/README.md')) { console.log('# BlogWatcher\\n\\nTest readme.'); process.exit(0); }",
+    "console.error(`unsupported url: ${url}`);",
+    "process.exit(22);"
+  ].join("\n"), "utf-8")
+  fs.chmodSync(bin, 0o755)
+  return bin
+}
+
+function writeFakeBlogwatcherBinary(dir) {
+  const bin = path.join(dir, "blogwatcher")
+  fs.writeFileSync(bin, [
+    "#!/usr/bin/env node",
+    "const args = process.argv.slice(2);",
+    "if (args[0] === '--version') { console.log('blogwatcher 0.0.2-test'); process.exit(0); }",
+    "if (args[0] === 'blogs' && args.length === 1) { console.log('Tracked blogs (0):'); process.exit(0); }",
+    "if (args[0] === 'add') { console.log(`Added blog '${args[1]}'`); process.exit(0); }",
+    "if (args[0] === 'remove' && args.includes('--yes')) { console.log(`Removed blog '${args[args.length - 1]}'`); process.exit(0); }",
+    "if (args[0] === 'scan' && args.includes('--silent')) { console.log('scan done'); process.exit(0); }",
+    "if (args[0] === 'articles' && args[1] !== 'read-all') { console.log('No unread articles!'); process.exit(0); }",
+    "if (args[0] === 'read') { console.log(`Marked article ${args[1]} as read`); process.exit(0); }",
+    "if (args[0] === 'unread') { console.log(`Marked article ${args[1]} as unread`); process.exit(0); }",
+    "if (args[0] === 'read-all' && args.includes('--yes')) { console.log('Marked 0 article(s) as read'); process.exit(0); }",
+    "console.log(JSON.stringify({ ok: true, args }));"
+  ].join("\n"), "utf-8")
+  fs.chmodSync(bin, 0o755)
+  return bin
+}
+
+describe("blogwatcher hybrid plugin", () => {
+  const fakeDir = fs.mkdtempSync(path.join(os.tmpdir(), "dcli-blogwatcher-"))
+  const tempHome = fs.mkdtempSync(path.join(os.tmpdir(), "dcli-home-blogwatcher-"))
+  const fakeUserHome = fs.mkdtempSync(path.join(os.tmpdir(), "dcli-user-home-blogwatcher-"))
+  writeFakeCurlBinary(fakeDir)
+  writeFakeBlogwatcherBinary(fakeDir)
+  const env = {
+    ...process.env,
+    PATH: `${fakeDir}:${process.env.PATH || ""}`,
+    SUPERCLI_HOME: tempHome,
+    HOME: fakeUserHome
+  }
+  let removed = false
+
+  beforeAll(() => {
+    const install = runNoServer("plugins install ./plugins/blogwatcher --on-conflict replace --json", { env })
+    expect(install.ok).toBe(true)
+  })
+
+  afterAll(() => {
+    if (!removed) runNoServer("plugins remove blogwatcher --json", { env })
+    fs.rmSync(fakeDir, { recursive: true, force: true })
+    fs.rmSync(tempHome, { recursive: true, force: true })
+    fs.rmSync(fakeUserHome, { recursive: true, force: true })
+  })
+
+  test("indexes blogwatcher skills provider", () => {
+    const provider = runNoServer("skills providers show --name blogwatcher --json", { env })
+    expect(provider.ok).toBe(true)
+    const providerData = JSON.parse(provider.output)
+    expect(providerData.provider.name).toBe("blogwatcher")
+
+    const list = runNoServer("skills list --catalog --provider blogwatcher --json", { env })
+    expect(list.ok).toBe(true)
+    const listData = JSON.parse(list.output)
+    expect(listData.skills.some(skill => skill.id === "blogwatcher:root.skill")).toBe(true)
+    expect(listData.skills.some(skill => skill.id === "blogwatcher:root.readme")).toBe(true)
+  })
+
+  test("fetches indexed remote skill markdown", () => {
+    const skill = runNoServer("skills get blogwatcher:root.skill", { env })
+    expect(skill.ok).toBe(true)
+    expect(skill.output).toContain("BlogWatcher CLI")
+  })
+
+  test("routes wrapped commands", () => {
+    const version = runNoServer("blogwatcher cli version --json", { env })
+    expect(version.ok).toBe(true)
+    expect(JSON.parse(version.output).data.raw).toBe("blogwatcher 0.0.2-test")
+
+    const add = runNoServer("blogwatcher blogs add --name \"Example\" --url \"https://example.com/blog\" --feed-url \"https://example.com/feed.xml\" --json", { env })
+    expect(add.ok).toBe(true)
+    expect(JSON.parse(add.output).data.raw).toBe("Added blog 'Example'")
+
+    const scan = runNoServer("blogwatcher scan run --workers 2 --json", { env })
+    expect(scan.ok).toBe(true)
+    expect(JSON.parse(scan.output).data.raw).toBe("scan done")
+
+    const readAll = runNoServer("blogwatcher articles read-all --blog \"Example\" --json", { env })
+    expect(readAll.ok).toBe(true)
+    expect(JSON.parse(readAll.output).data.raw).toBe("Marked 0 article(s) as read")
+  })
+
+  test("supports blogwatcher namespace passthrough", () => {
+    const r = runNoServer("blogwatcher articles --all --json", { env })
+    expect(r.ok).toBe(true)
+    const data = JSON.parse(r.output)
+    expect(data.command).toBe("blogwatcher.passthrough")
+    expect(data.data.raw).toBe("No unread articles!")
+  })
+
+  test("doctor reports curl and blogwatcher dependencies as healthy", () => {
+    const r = runNoServer("plugins doctor blogwatcher --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 === "curl" && c.ok === true)).toBe(true)
+    expect(data.checks.some(c => c.type === "binary" && c.binary === "blogwatcher" && c.ok === true)).toBe(true)
+  })
+
+  test("removal cleans up the skills provider", () => {
+    const remove = runNoServer("plugins remove blogwatcher --json", { env })
+    expect(remove.ok).toBe(true)
+    removed = true
+
+    const provider = runNoServer("skills providers show --name blogwatcher --json", { env })
+    expect(provider.ok).toBe(false)
+
+    const list = runNoServer("skills list --catalog --provider blogwatcher --json", { env })
+    expect(list.ok).toBe(true)
+    const listData = JSON.parse(list.output)
+    expect(listData.skills).toEqual([])
+  })
+})

package/__tests__/clix-plugin.test.js

@@ -0,0 +1,143 @@
+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('/SKILL.md')) { console.log('---\\nname: clix\\ndescription: Test skill\\n---\\n# clix Skill'); process.exit(0); }",
+    "if (url.endsWith('/README.md')) { console.log('# clix\\n\\nTest readme.'); process.exit(0); }",
+    "console.error(`unsupported url: ${url}`);",
+    "process.exit(22);"
+  ].join("\n"), "utf-8")
+  fs.chmodSync(bin, 0o755)
+  return bin
+}
+
+function writeFakeClixBinary(dir) {
+  const bin = path.join(dir, "clix")
+  fs.writeFileSync(bin, [
+    "#!/usr/bin/env node",
+    "const args = process.argv.slice(2);",
+    "if (args[0] === 'auth' && args[1] === 'status') { console.log(JSON.stringify({ authenticated: true, account: 'default' })); process.exit(0); }",
+    "if (args[0] === 'feed') { console.log(JSON.stringify({ tweets: [{ id: '1', text: 'timeline item' }] })); process.exit(0); }",
+    "if (args[0] === 'search') { console.log(JSON.stringify({ tweets: [{ id: '2', text: args[2] || args[1] }] })); process.exit(0); }",
+    "if (args[0] === 'tweet') { console.log(JSON.stringify({ tweet: { id: args[2] || args[1], text: 'tweet body' } })); process.exit(0); }",
+    "if (args[0] === 'user') { console.log(JSON.stringify({ user: { handle: args[2] || args[1], name: 'OpenAI' } })); process.exit(0); }",
+    "if (args[0] === 'bookmarks') { console.log(JSON.stringify({ tweets: [{ id: '3', text: 'bookmark item' }] })); process.exit(0); }",
+    "console.log(JSON.stringify({ ok: true, args }));"
+  ].join("\n"), "utf-8")
+  fs.chmodSync(bin, 0o755)
+  return bin
+}
+
+describe("clix hybrid plugin", () => {
+  const fakeDir = fs.mkdtempSync(path.join(os.tmpdir(), "dcli-clix-"))
+  const tempHome = fs.mkdtempSync(path.join(os.tmpdir(), "dcli-home-clix-"))
+  writeFakeCurlBinary(fakeDir)
+  writeFakeClixBinary(fakeDir)
+  const env = { ...process.env, PATH: `${fakeDir}:${process.env.PATH || ""}`, SUPERCLI_HOME: tempHome }
+  let removed = false
+
+  beforeAll(() => {
+    const install = runNoServer("plugins install ./plugins/clix --on-conflict replace --json", { env })
+    expect(install.ok).toBe(true)
+  })
+
+  afterAll(() => {
+    if (!removed) runNoServer("plugins remove clix --json", { env })
+    fs.rmSync(fakeDir, { recursive: true, force: true })
+    fs.rmSync(tempHome, { recursive: true, force: true })
+  })
+
+  test("indexes clix skills provider", () => {
+    const provider = runNoServer("skills providers show --name clix --json", { env })
+    expect(provider.ok).toBe(true)
+    expect(JSON.parse(provider.output).provider.name).toBe("clix")
+
+    const list = runNoServer("skills list --catalog --provider clix --json", { env })
+    expect(list.ok).toBe(true)
+    const listData = JSON.parse(list.output)
+    expect(listData.skills.some(skill => skill.id === "clix:root.skill")).toBe(true)
+    expect(listData.skills.some(skill => skill.id === "clix:root.readme")).toBe(true)
+  })
+
+  test("fetches indexed remote skill markdown", () => {
+    const skill = runNoServer("skills get clix:root.skill", { env })
+    expect(skill.ok).toBe(true)
+    expect(skill.output).toContain("clix Skill")
+  })
+
+  test("routes wrapped read-only commands", () => {
+    const status = runNoServer("clix auth status --json", { env })
+    expect(status.ok).toBe(true)
+    expect(JSON.parse(status.output).data.authenticated).toBe(true)
+
+    const timeline = runNoServer("clix timeline list --type following --count 20 --json", { env })
+    expect(timeline.ok).toBe(true)
+    expect(JSON.parse(timeline.output).data.tweets[0].text).toBe("timeline item")
+
+    const search = runNoServer("clix posts search --query \"from:openai\" --type latest --count 20 --json", { env })
+    expect(search.ok).toBe(true)
+    expect(JSON.parse(search.output).data.tweets[0].text).toBe("from:openai")
+
+    const tweet = runNoServer("clix posts show --id 1234567890 --json", { env })
+    expect(tweet.ok).toBe(true)
+    expect(JSON.parse(tweet.output).data.tweet.id).toBe("1234567890")
+
+    const user = runNoServer("clix users show --handle openai --json", { env })
+    expect(user.ok).toBe(true)
+    expect(JSON.parse(user.output).data.user.handle).toBe("openai")
+
+    const bookmarks = runNoServer("clix bookmarks list --json", { env })
+    expect(bookmarks.ok).toBe(true)
+    expect(JSON.parse(bookmarks.output).data.tweets[0].text).toBe("bookmark item")
+  })
+
+  test("does not expose passthrough and reports dependencies as healthy", () => {
+    const manifest = JSON.parse(fs.readFileSync(path.join(__dirname, "..", "plugins", "clix", "plugin.json"), "utf-8"))
+    expect(manifest.commands.some(command => command.resource === "_" && command.action === "_")).toBe(false)
+
+    const doctor = runNoServer("plugins doctor clix --json", { env })
+    expect(doctor.ok).toBe(true)
+    const doctorData = JSON.parse(doctor.output)
+    expect(doctorData.checks.some(c => c.type === "binary" && c.binary === "curl" && c.ok === true)).toBe(true)
+    expect(doctorData.checks.some(c => c.type === "binary" && c.binary === "clix" && c.ok === true)).toBe(true)
+  })
+
+  test("removal cleans up the skills provider", () => {
+    const remove = runNoServer("plugins remove clix --json", { env })
+    expect(remove.ok).toBe(true)
+    removed = true
+
+    const provider = runNoServer("skills providers show --name clix --json", { env })
+    expect(provider.ok).toBe(false)
+  })
+})

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")
 
@@ -70,6 +72,30 @@ describe("config", () => {
       const config = await loadConfig()
       expect(config.commands).toEqual([])
     })
+
+    test("normalizes claude-style mcpServers object", async () => {
+      fs.existsSync.mockReturnValue(true)
+      fs.readFileSync.mockReturnValue(
+        JSON.stringify({
+          version: "2",
+          mcpServers: {
+            "browser-use": {
+              command: "npx",
+              args: ["mcp-remote", "https://api.browser-use.com/mcp"]
+            }
+          }
+        })
+      )
+
+      const config = await loadConfig()
+      expect(config.mcp_servers).toEqual([
+        {
+          name: "browser-use",
+          command: "npx",
+          args: ["mcp-remote", "https://api.browser-use.com/mcp"]
+        }
+      ])
+    })
   })
 
   describe("syncConfig", () => {
@@ -192,6 +218,27 @@ describe("config", () => {
       expect(lastWrite.mcp_servers).toEqual([{ name: "s1", url: "u1" }])
     })
 
+    test("setMcpServer supports command, args, headers, env", async () => {
+      fs.existsSync.mockReturnValue(false)
+      await setMcpServer("browser-use", {
+        command: "npx",
+        args: ["mcp-remote", "https://api.browser-use.com/mcp"],
+        headers: { "X-Browser-Use-API-Key": "key" },
+        env: { BROWSER_USE_API_KEY: "key" },
+      })
+
+      const lastWrite = JSON.parse(fs.writeFileSync.mock.calls[0][1])
+      expect(lastWrite.mcp_servers).toContainEqual(
+        expect.objectContaining({
+          name: "browser-use",
+          command: "npx",
+          args: ["mcp-remote", "https://api.browser-use.com/mcp"],
+          headers: { "X-Browser-Use-API-Key": "key" },
+          env: { BROWSER_USE_API_KEY: "key" }
+        })
+      )
+    })
+
     test("removeMcpServer removes existing server", async () => {
       fs.existsSync.mockReturnValue(true)
       fs.readFileSync.mockReturnValue(JSON.stringify({
@@ -253,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)
@@ -268,7 +355,7 @@ describe("config", () => {
         ttl: 3600,
         fetchedAt: 1000000,
         commands: [1, 2],
-        mcp_servers: [1],
+        mcp_servers: [{ name: "s1", url: "http://s1" }],
         specs: [1, 2, 3]
       }))
       listInstalledPlugins.mockReturnValue([1, 2, 3, 4])
@@ -293,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__/himalaya-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 writeFakeHimalayaBinary(dir) {
+  const bin = path.join(dir, "himalaya")
+  fs.writeFileSync(bin, [
+    "#!/usr/bin/env node",
+    "const args = process.argv.slice(2);",
+    "const outJson = args[0] === '--output' && args[1] === 'json';",
+    "const payloadArgs = outJson ? args.slice(2) : args;",
+    "if (args[0] === '--version') { console.log('himalaya 1.2.0-test'); process.exit(0); }",
+    "if (outJson && payloadArgs[0] === 'account' && payloadArgs[1] === 'list') { console.log(JSON.stringify({ accounts: [{ name: 'personal', default: true }] })); process.exit(0); }",
+    "if (payloadArgs[0] === 'account' && payloadArgs[1] === 'doctor') { console.log('Account personal looks healthy'); process.exit(0); }",
+    "if (outJson && payloadArgs[0] === 'folder' && payloadArgs[1] === 'list') { console.log(JSON.stringify({ folders: [{ name: 'INBOX' }, { name: 'Archive' }] })); process.exit(0); }",
+    "if (outJson && payloadArgs[0] === 'envelope' && payloadArgs[1] === 'list') { console.log(JSON.stringify({ envelopes: [{ id: 42, subject: 'Hello' }] })); process.exit(0); }",
+    "if (outJson && payloadArgs[0] === 'envelope' && payloadArgs[1] === 'thread') { console.log(JSON.stringify({ thread: [{ id: 42 }, { id: 43 }] })); process.exit(0); }",
+    "if (outJson && payloadArgs[0] === 'message' && payloadArgs[1] === 'read' && payloadArgs.includes('--preview')) { console.log(JSON.stringify({ id: 42, preview: true, subject: 'Hello' })); process.exit(0); }",
+    "console.log(JSON.stringify({ ok: true, args }));"
+  ].join("\n"), "utf-8")
+  fs.chmodSync(bin, 0o755)
+  return bin
+}
+
+describe("himalaya plugin", () => {
+  const fakeDir = fs.mkdtempSync(path.join(os.tmpdir(), "dcli-himalaya-"))
+  const tempHome = fs.mkdtempSync(path.join(os.tmpdir(), "dcli-home-himalaya-"))
+  writeFakeHimalayaBinary(fakeDir)
+  const env = { ...process.env, PATH: `${fakeDir}:${process.env.PATH || ""}`, SUPERCLI_HOME: tempHome }
+
+  beforeAll(() => {
+    runNoServer("plugins install ./plugins/himalaya --on-conflict replace --json", { env })
+  })
+
+  afterAll(() => {
+    runNoServer("plugins remove himalaya --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("himalaya cli version --json", { env })
+    expect(r.ok).toBe(true)
+    const data = JSON.parse(r.output)
+    expect(data.command).toBe("himalaya.cli.version")
+    expect(data.data.raw).toBe("himalaya 1.2.0-test")
+  })
+
+  test("routes json account and folder wrappers", () => {
+    const accounts = runNoServer("himalaya account list --json", { env })
+    expect(accounts.ok).toBe(true)
+    expect(JSON.parse(accounts.output).data.accounts[0].name).toBe("personal")
+
+    const folders = runNoServer("himalaya folder list --account personal --json", { env })
+    expect(folders.ok).toBe(true)
+    expect(JSON.parse(folders.output).data.folders[0].name).toBe("INBOX")
+  })
+
+  test("routes envelope and message wrappers", () => {
+    const envelopes = runNoServer("himalaya envelope list --account personal --folder INBOX --page 1 --page-size 10 --json", { env })
+    expect(envelopes.ok).toBe(true)
+    expect(JSON.parse(envelopes.output).data.envelopes[0].id).toBe(42)
+
+    const thread = runNoServer("himalaya envelope thread --account personal --folder INBOX --id 42 --json", { env })
+    expect(thread.ok).toBe(true)
+    expect(JSON.parse(thread.output).data.thread).toHaveLength(2)
+
+    const message = runNoServer("himalaya message read-preview --account personal --folder INBOX --id 42 --json", { env })
+    expect(message.ok).toBe(true)
+    const messageData = JSON.parse(message.output)
+    expect(messageData.command).toBe("himalaya.message.read-preview")
+    expect(messageData.data.preview).toBe(true)
+  })
+
+  test("routes account doctor wrapper as raw text", () => {
+    const r = runNoServer("himalaya account doctor --account personal --json", { env })
+    expect(r.ok).toBe(true)
+    const data = JSON.parse(r.output)
+    expect(data.command).toBe("himalaya.account.doctor")
+    expect(data.data.raw).toBe("Account personal looks healthy")
+  })
+
+  test("supports namespace passthrough", () => {
+    const r = runNoServer("himalaya --output json account list", { env })
+    expect(r.ok).toBe(true)
+    const data = JSON.parse(r.output)
+    expect(data.command).toBe("himalaya.passthrough")
+    expect(data.data.raw).toContain('"accounts"')
+  })
+
+  test("doctor reports himalaya dependency as healthy", () => {
+    const r = runNoServer("plugins doctor himalaya --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 === "himalaya" && c.ok === true)).toBe(true)
+  })
+})