superacli 1.1.3 → 1.1.4

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__/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

@@ -70,6 +70,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 +216,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({
@@ -268,7 +313,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])

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)
+  })
+})

package/__tests__/mcp-adapter.test.js

@@ -42,6 +42,45 @@ describe("mcp adapter", () => {
       expect(mockChild.stdin.write).toHaveBeenCalledWith(expect.stringContaining('"tool":"calc"'))
     })
 
+    test("resolves stdio command from named server and merges args/env", async () => {
+      const promise = execute(
+        {
+          adapterConfig: {
+            tool: "calc",
+            server: "browser-use",
+            args: ["--header", "X-Test: 1"],
+            env: { MCP_CLIENT: "yes" }
+          }
+        },
+        {},
+        {
+          config: {
+            mcp_servers: [
+              {
+                name: "browser-use",
+                command: "npx",
+                args: ["mcp-remote", "https://api.browser-use.com/mcp"],
+                env: { MCP_SERVER: "yes" }
+              }
+            ]
+          }
+        }
+      )
+
+      await Promise.resolve()
+      mockChild.stdout.emit("data", '{"ok":true}')
+      mockChild.emit("close", 0)
+
+      await expect(promise).resolves.toEqual({ ok: true })
+      expect(spawn).toHaveBeenCalledWith(
+        "npx",
+        ["mcp-remote", "https://api.browser-use.com/mcp", "--header", "X-Test: 1"],
+        expect.objectContaining({
+          env: expect.objectContaining({ MCP_SERVER: "yes", MCP_CLIENT: "yes" })
+        })
+      )
+    })
+
     test("handles stdio tool error exit", async () => {
       const promise = execute({
         adapterConfig: { tool: "calc", command: "node" }
@@ -116,6 +155,46 @@ describe("mcp adapter", () => {
       expect(result).toEqual({ data: "ok" })
     })
 
+    test("merges server and command headers in http mode", async () => {
+      global.fetch.mockResolvedValue({
+        ok: true,
+        json: () => Promise.resolve({ ok: true })
+      })
+
+      await execute(
+        {
+          adapterConfig: {
+            tool: "t1",
+            server: "s1",
+            headers: { "X-Cmd": "2" }
+          }
+        },
+        {},
+        {
+          config: {
+            mcp_servers: [
+              {
+                name: "s1",
+                url: "http://server1",
+                headers: { "X-Server": "1" }
+              }
+            ]
+          }
+        }
+      )
+
+      expect(global.fetch).toHaveBeenCalledWith(
+        "http://server1/tool",
+        expect.objectContaining({
+          headers: expect.objectContaining({
+            "Content-Type": "application/json",
+            "X-Server": "1",
+            "X-Cmd": "2"
+          })
+        })
+      )
+    })
+
     test("resolves server url from local context", async () => {
       global.fetch.mockResolvedValue({
         ok: true,

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"],