superacli 1.1.0 → 1.1.2

package/__tests__/plugin-visual-explainer.test.js

@@ -0,0 +1,62 @@
+const { spawnSync } = require("child_process")
+const { addProvider, syncCatalog } = require("../cli/skills-catalog")
+const {
+  run,
+  buildRemoteEntriesFromTree
+} = require("../plugins/visual-explainer/scripts/post-install")
+
+jest.mock("child_process")
+jest.mock("../cli/skills-catalog")
+
+describe("plugin-visual-explainer", () => {
+  beforeEach(() => {
+    jest.clearAllMocks()
+  })
+
+  test("buildRemoteEntriesFromTree filters only normalized markdown skills", () => {
+    const entries = buildRemoteEntriesFromTree({
+      tree: [
+        { type: "blob", path: "plugins/visual-explainer-normalized/SKILL.md" },
+        { type: "blob", path: "plugins/visual-explainer-normalized/commands/diff-review.md" },
+        { type: "blob", path: "plugins/visual-explainer/commands/diff-review.md" },
+        { type: "blob", path: "plugins/visual-explainer-normalized/templates/architecture.html" }
+      ]
+    })
+
+    expect(entries).toHaveLength(2)
+    expect(entries[0].id).toBe("visual-explainer.commands.diff-review")
+    expect(entries[1].id).toBe("visual-explainer.skill")
+  })
+
+  test("run stores provider and syncs catalog", () => {
+    spawnSync.mockReturnValue({
+      status: 0,
+      stdout: JSON.stringify({
+        tree: [
+          { type: "blob", path: "plugins/visual-explainer-normalized/SKILL.md" },
+          { type: "blob", path: "plugins/visual-explainer-normalized/commands/generate-web-diagram.md" }
+        ]
+      })
+    })
+    syncCatalog.mockReturnValue({ skills: [1, 2, 3] })
+
+    const result = run()
+
+    expect(addProvider).toHaveBeenCalledWith(expect.objectContaining({
+      name: "visual-explainer",
+      type: "remote_static",
+      entries: expect.any(Array)
+    }))
+    expect(syncCatalog).toHaveBeenCalled()
+    expect(result).toEqual({
+      provider: "visual-explainer",
+      entries: 2,
+      synced_skills: 3
+    })
+  })
+
+  test("run throws on curl failure", () => {
+    spawnSync.mockReturnValue({ status: 22, stderr: "404" })
+    expect(() => run()).toThrow(/Failed to fetch visual-explainer metadata/)
+  })
+})

package/__tests__/plugins-manager.test.js

@@ -8,7 +8,6 @@ jest.mock("fs")
 jest.mock("child_process")
 jest.mock("../cli/plugins-store")
 jest.mock("../cli/plugins-registry")
-jest.mock("../cli/plugin-agency-agents")
 
 const {
   installPlugin,
@@ -27,7 +26,6 @@ const {
 } = require("../cli/plugins-store")
 
 const { getRegistryPlugin } = require("../cli/plugins-registry")
-const { installAgencyAgentsSkillProvider } = require("../cli/plugin-agency-agents")
 
 describe("plugins-manager", () => {
   beforeEach(() => {
@@ -230,20 +228,48 @@ describe("plugins-manager", () => {
       fs.existsSync.mockReturnValue(true)
       fs.statSync.mockReturnValue({ isDirectory: () => false })
       fs.readFileSync.mockReturnValue(JSON.stringify(manifest))
-      installAgencyAgentsSkillProvider.mockReturnValue({ provider: "agency-agents", entries: 1, synced_skills: 1 })
-    })
-
-    test("runs agency-agents post install mapping", () => {
-      fs.readFileSync.mockReturnValue(JSON.stringify({ name: "agency-agents", commands: [] }))
-      const result = installPlugin("agency-agents")
-      expect(installAgencyAgentsSkillProvider).toHaveBeenCalled()
-      expect(result.post_install).toEqual({ provider: "agency-agents", entries: 1, synced_skills: 1 })
     })
 
     test("throws on invalid onConflict", () => {
       expect(() => installPlugin("p1", { onConflict: "invalid" })).toThrow(/Invalid --on-conflict/)
     })
 
+    test("runs manifest-defined post install hook", () => {
+      fs.readFileSync.mockReturnValue(JSON.stringify({
+        name: "visual-explainer",
+        commands: [],
+        post_install: { script: "scripts/post-install.js" }
+      }))
+      spawnSync.mockReturnValue({ status: 0, stdout: "{\"provider\":\"visual-explainer\"}" })
+      const result = installPlugin("visual-explainer")
+      expect(result.post_install).toEqual({ provider: "visual-explainer" })
+    })
+
+    test("rejects post install path traversal", () => {
+      fs.readFileSync.mockReturnValue(JSON.stringify({
+        name: "visual-explainer",
+        commands: [],
+        post_install: { script: "../evil.js" }
+      }))
+      expect(() => installPlugin("visual-explainer")).toThrow(/Invalid post-install script path/)
+    })
+
+    test("stores serialized uninstall hook for later removal", () => {
+      fs.readFileSync
+        .mockReturnValueOnce(JSON.stringify({
+          name: "nullclaw",
+          commands: [],
+          post_uninstall: { script: "scripts/post-uninstall.js" }
+        }))
+        .mockReturnValueOnce("module.exports = {}")
+      fs.existsSync.mockReturnValue(true)
+      fs.statSync.mockReturnValue({ isDirectory: () => false })
+
+      installPlugin("nullclaw")
+      const writtenLock = writePluginsLock.mock.calls[0][0]
+      expect(writtenLock.installed.nullclaw.lifecycle_hooks.post_uninstall.script_source).toBe("module.exports = {}")
+    })
+
     test("handles same plugin command (skip logic)", () => {
       readPluginsLock.mockReturnValue({
         installed: { p1: { name: "p1", commands: [{ namespace: "n", resource: "r", action: "a" }] } }
@@ -292,6 +318,29 @@ describe("plugins-manager", () => {
       readPluginsLock.mockReturnValue({ installed: { p1: { name: "p1" } } })
       expect(removePlugin("p1")).toBe(true)
     })
+    test("removePlugin runs stored uninstall hook", () => {
+      fs.mkdtempSync.mockReturnValue("/tmp/dcli-plugin-hook-123")
+      readPluginsLock.mockReturnValue({
+        installed: {
+          p1: {
+            name: "p1",
+            lifecycle_hooks: {
+              post_uninstall: {
+                runtime: "node",
+                timeout_ms: 1000,
+                script_name: "post-uninstall.js",
+                script_source: "process.stdout.write(JSON.stringify({ok:true}))"
+              }
+            }
+          }
+        }
+      })
+      spawnSync.mockReturnValue({ status: 0, stdout: "{\"ok\":true}" })
+      expect(removePlugin("p1")).toBe(true)
+      expect(spawnSync).toHaveBeenCalled()
+      const writtenLock = writePluginsLock.mock.calls[0][0]
+      expect(writtenLock.installed.p1).toBeUndefined()
+    })
     test("removePlugin fail", () => {
       readPluginsLock.mockReturnValue({ installed: {} })
       expect(removePlugin("p1")).toBe(false)

package/__tests__/pnpm-plugin.test.js

@@ -0,0 +1,81 @@
+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 writeFakePnpmBinary(dir) {
+  const bin = path.join(dir, "pnpm")
+  fs.writeFileSync(bin, [
+    "#!/usr/bin/env node",
+    "const args = process.argv.slice(2);",
+    "if (args[0] === '--version') { console.log('9.0.0-test'); process.exit(0); }",
+    "console.log(JSON.stringify({ ok: true, args }));"
+  ].join("\n"), "utf-8")
+  fs.chmodSync(bin, 0o755)
+  return bin
+}
+
+describe("pnpm plugin", () => {
+  const fakeDir = fs.mkdtempSync(path.join(os.tmpdir(), "dcli-pnpm-"))
+  const tempHome = fs.mkdtempSync(path.join(os.tmpdir(), "dcli-home-pnpm-"))
+  writeFakePnpmBinary(fakeDir)
+  const env = { ...process.env, PATH: `${fakeDir}:${process.env.PATH || ""}`, SUPERCLI_HOME: tempHome }
+
+  beforeAll(() => {
+    runNoServer("plugins install ./plugins/pnpm --on-conflict replace --json", { env })
+  })
+
+  afterAll(() => {
+    runNoServer("plugins remove pnpm --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("pnpm cli version --json", { env })
+    expect(r.ok).toBe(true)
+    const data = JSON.parse(r.output)
+    expect(data.command).toBe("pnpm.cli.version")
+    expect(data.data.raw).toBe("9.0.0-test")
+  })
+
+  test("supports namespace passthrough", () => {
+    const r = runNoServer("pnpm search react --json", { env })
+    expect(r.ok).toBe(true)
+    const data = JSON.parse(r.output)
+    expect(data.command).toBe("pnpm.passthrough")
+    expect(data.data.args[0]).toBe("search")
+    expect(data.data.args).toContain("react")
+    expect(data.data.args).toContain("--json")
+  })
+
+  test("doctor reports pnpm dependency as healthy", () => {
+    const r = runNoServer("plugins doctor pnpm --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 === "pnpm" && c.ok === true)).toBe(true)
+  })
+})

package/__tests__/poetry-plugin.test.js

@@ -0,0 +1,83 @@
+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 writeFakePoetryBinary(dir) {
+  const bin = path.join(dir, "poetry")
+  fs.writeFileSync(bin, [
+    "#!/usr/bin/env node",
+    "const args = process.argv.slice(2);",
+    "if (args[0] === '--version') { console.log('Poetry (version 2.1.1-test)'); process.exit(0); }",
+    "console.log(JSON.stringify({ ok: true, args }));"
+  ].join("\n"), "utf-8")
+  fs.chmodSync(bin, 0o755)
+  return bin
+}
+
+describe("poetry plugin", () => {
+  const fakeDir = fs.mkdtempSync(path.join(os.tmpdir(), "dcli-poetry-"))
+  const tempHome = fs.mkdtempSync(path.join(os.tmpdir(), "dcli-home-poetry-"))
+  writeFakePoetryBinary(fakeDir)
+  const env = { ...process.env, PATH: `${fakeDir}:${process.env.PATH || ""}`, SUPERCLI_HOME: tempHome }
+
+  beforeAll(() => {
+    runNoServer("plugins install ./plugins/poetry --on-conflict replace --json", { env })
+  })
+
+  afterAll(() => {
+    runNoServer("plugins remove poetry --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("poetry cli version --json", { env })
+    expect(r.ok).toBe(true)
+    const data = JSON.parse(r.output)
+    expect(data.command).toBe("poetry.cli.version")
+    expect(data.data.raw).toBe("Poetry (version 2.1.1-test)")
+  })
+
+  test("supports namespace passthrough", () => {
+    const r = runNoServer("poetry self show --format json --json", { env })
+    expect(r.ok).toBe(true)
+    const data = JSON.parse(r.output)
+    expect(data.command).toBe("poetry.passthrough")
+    expect(data.data.args[0]).toBe("self")
+    expect(data.data.args[1]).toBe("show")
+    expect(data.data.args).toContain("--format")
+    expect(data.data.args).toContain("json")
+    expect(data.data.args).toContain("--json")
+  })
+
+  test("doctor reports poetry dependency as healthy", () => {
+    const r = runNoServer("plugins doctor poetry --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 === "poetry" && c.ok === true)).toBe(true)
+  })
+})

package/__tests__/process-adapter.test.js

@@ -1,109 +1,143 @@
-const os = require("os")
 const { execute } = require("../cli/adapters/process")
+const { spawn, spawnSync } = require("child_process")
+const EventEmitter = require("events")
+const os = require("os")
+
+jest.mock("child_process")
 
 describe("process adapter", () => {
-  test("coerces array flags and skips false values", async () => {
-    const result = await execute({
-      adapterConfig: {
-        command: "node",
-        baseArgs: ["-e", "process.stdout.write(JSON.stringify(process.argv.slice(1)))", "--"],
-        parseJson: true,
-        timeout_ms: 2000
-      }
-    }, {
-      name: "demo",
-      tags: ["a", "b"],
-      enabled: false,
-      count: 2
-    })
+  let mockChild
 
-    expect(result).toContain("--name")
-    expect(result).toContain("demo")
-    expect(result).toContain("--tags")
-    expect(result).toContain("a")
-    expect(result).toContain("b")
-    expect(result).toContain("--count")
-    expect(result).not.toContain("--enabled")
+  beforeEach(() => {
+    jest.clearAllMocks()
+    mockChild = new EventEmitter()
+    mockChild.stdout = new EventEmitter()
+    mockChild.stdout.setEncoding = jest.fn()
+    mockChild.stderr = new EventEmitter()
+    mockChild.stderr.setEncoding = jest.fn()
+    mockChild.stdin = { write: jest.fn(), end: jest.fn() }
+    mockChild.kill = jest.fn()
+    spawn.mockReturnValue(mockChild)
+    spawnSync.mockReturnValue({ status: 0, stdout: "/bin/node" })
   })
 
-  test("returns invalid_argument with missing dependency help", async () => {
-    await expect(execute({
-      adapterConfig: {
-        command: "definitely_missing_binary_xyz",
-        parseJson: false,
-        missingDependencyHelp: "Run: dcli beads install steps"
-      }
-    }, {})).rejects.toMatchObject({
-      code: 85,
-      type: "invalid_argument"
-    })
+  test("detectInteractiveFlags coverage (short flags, long flag with equals)", async () => {
+    const oldTTY = process.stdout.isTTY
+    process.stdout.isTTY = false
+    try {
+      await expect(execute({
+        adapterConfig: { 
+          command: "node", 
+          passthrough: true,
+          interactiveFlags: ["--tty", "-i", "-t"] 
+        },
+      }, { __rawArgs: ["--tty=true", "-it"] })).rejects.toMatchObject({ code: 91 })
+    } finally {
+      process.stdout.isTTY = oldTTY
+    }
   })
 
-  test("supports cwd and env injection", async () => {
-    const result = await execute({
-      adapterConfig: {
-        command: "node",
-        baseArgs: ["-e", "process.stdout.write(JSON.stringify({cwd:process.cwd(),x:process.env.X_TEST}))", "--"],
-        parseJson: true,
-        cwd: os.tmpdir(),
-        env: { X_TEST: "ok" },
-        timeout_ms: 2000
-      }
-    }, {})
-
-    expect(result.cwd).toBe(os.tmpdir())
-    expect(result.x).toBe("ok")
+  test("throws if command missing", async () => {
+    await expect(execute({ adapterConfig: {} }, {})).rejects.toThrow(/requires adapterConfig.command/)
   })
 
-  test("rejects interactive flags in non-tty context", async () => {
-    const originalIsTTY = process.stdout.isTTY
-    Object.defineProperty(process.stdout, "isTTY", {
-      value: false,
-      configurable: true
-    })
+  test("successfully executes command and parses JSON", async () => {
+    const promise = execute({
+      adapterConfig: { command: "node", baseArgs: ["-e", "ok"], parseJson: true }
+    }, { foo: "bar" })
 
-    await expect(execute({
-      adapterConfig: {
-        command: "node",
-        baseArgs: ["-e", "process.stdout.write('ok')", "--"],
-        parseJson: false,
-        interactiveFlags: ["--interactive", "-i"]
-      }
-    }, {
-      interactive: true
-    })).rejects.toMatchObject({
-      code: 91,
-      type: "safety_violation"
-    })
+    mockChild.stdout.emit("data", '{"result": true}')
+    mockChild.emit("close", 0)
 
-    Object.defineProperty(process.stdout, "isTTY", {
-      value: originalIsTTY,
-      configurable: true
-    })
+    const result = await promise
+    expect(result).toEqual({ result: true })
   })
 
-  test("rejects requiresInteractive in non-tty context", async () => {
-    const originalIsTTY = process.stdout.isTTY
-    Object.defineProperty(process.stdout, "isTTY", {
-      value: false,
-      configurable: true
-    })
+  test("handles spawn error ENOENT", async () => {
+    const promise = execute({ adapterConfig: { command: "node" } }, {})
+    mockChild.emit("error", { code: "ENOENT" })
+    await expect(promise).rejects.toMatchObject({ code: 85 })
+  })
 
-    await expect(execute({
-      adapterConfig: {
-        command: "node",
-        baseArgs: ["-e", "process.stdout.write('ok')", "--"],
-        parseJson: false,
-        requiresInteractive: true
-      }
-    }, {})).rejects.toMatchObject({
-      code: 91,
-      type: "safety_violation"
-    })
+  test("handles timeout", async () => {
+    jest.useFakeTimers()
+    const promise = execute({ adapterConfig: { command: "node", timeout_ms: 100 } }, {})
+    jest.advanceTimersByTime(200)
+    await expect(promise).rejects.toThrow("timed out")
+    jest.useRealTimers()
+  })
 
-    Object.defineProperty(process.stdout, "isTTY", {
-      value: originalIsTTY,
-      configurable: true
+  test("handles non-zero exit", async () => {
+    const promise = execute({ adapterConfig: { command: "node" } }, {})
+    mockChild.stderr.emit("data", "error")
+    mockChild.emit("close", 1)
+    await expect(promise).rejects.toThrow("Process adapter failed")
+  })
+  
+  test("handles passthroughInteractive", async () => {
+    const promise = execute({
+      adapterConfig: { command: "node", passthrough: true }
+    }, { __passthroughInteractive: true })
+    mockChild.emit("close", 0)
+    const result = await promise
+    expect(result.passthrough).toBe(true)
+  })
+
+  test("includes nonTtyBaseArgs", async () => {
+    const oldTTY = process.stdout.isTTY
+    process.stdout.isTTY = false
+    try {
+      const promise = execute({
+        adapterConfig: { command: "node", nonTtyBaseArgs: ["--no-tty"] }
+      }, {})
+      mockChild.emit("close", 0)
+      await promise
+      expect(spawn).toHaveBeenCalledWith("node", ["--no-tty"], expect.anything())
+    } finally {
+      process.stdout.isTTY = oldTTY
+    }
+  })
+
+  test("handles JSON parse error", async () => {
+    const promise = execute({ adapterConfig: { command: "node", parseJson: true } }, {})
+    mockChild.stdout.emit("data", "invalid")
+    mockChild.emit("close", 0)
+    const result = await promise
+    expect(result.raw).toBe("invalid")
+  })
+
+  test("handles parseJson false", async () => {
+    const promise = execute({ adapterConfig: { command: "node", parseJson: false } }, {})
+    mockChild.stdout.emit("data", "text")
+    mockChild.emit("close", 0)
+    const result = await promise
+    expect(result.raw).toBe("text")
+  })
+
+  test("streams jsonl events incrementally", async () => {
+    const onStreamEvent = jest.fn()
+    const promise = execute({ adapterConfig: { command: "node", stream: "jsonl" } }, {}, { onStreamEvent })
+    mockChild.stdout.emit("data", '{"type":"say","text":"one"}\n{"type":"say"')
+    mockChild.stdout.emit("data", ',"text":"two"}\n')
+    mockChild.emit("close", 0)
+    const result = await promise
+    expect(onStreamEvent).toHaveBeenCalledTimes(2)
+    expect(onStreamEvent.mock.calls[0][0]).toEqual({ type: "say", text: "one" })
+    expect(result).toEqual({
+      streamed: true,
+      stream: "jsonl",
+      event_count: 2,
+      last_event: { type: "say", text: "two" }
     })
   })
+
+  test("flushes trailing jsonl line without newline", async () => {
+    const onStreamEvent = jest.fn()
+    const promise = execute({ adapterConfig: { command: "node", stream: "jsonl" } }, {}, { onStreamEvent })
+    mockChild.stdout.emit("data", '{"type":"task_started","taskId":"123"}')
+    mockChild.emit("close", 0)
+    const result = await promise
+    expect(onStreamEvent).toHaveBeenCalledWith({ type: "task_started", taskId: "123" })
+    expect(result.event_count).toBe(1)
+  })
 })

package/__tests__/pulumi-plugin.test.js

@@ -0,0 +1,81 @@
+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 writeFakePulumiBinary(dir) {
+  const bin = path.join(dir, "pulumi")
+  fs.writeFileSync(bin, [
+    "#!/usr/bin/env node",
+    "const args = process.argv.slice(2);",
+    "if (args[0] === 'version') { console.log('v3.160.0-test'); process.exit(0); }",
+    "console.log(JSON.stringify({ ok: true, args }));"
+  ].join("\n"), "utf-8")
+  fs.chmodSync(bin, 0o755)
+  return bin
+}
+
+describe("pulumi plugin", () => {
+  const fakeDir = fs.mkdtempSync(path.join(os.tmpdir(), "dcli-pulumi-"))
+  const tempHome = fs.mkdtempSync(path.join(os.tmpdir(), "dcli-home-pulumi-"))
+  writeFakePulumiBinary(fakeDir)
+  const env = { ...process.env, PATH: `${fakeDir}:${process.env.PATH || ""}`, SUPERCLI_HOME: tempHome }
+
+  beforeAll(() => {
+    runNoServer("plugins install ./plugins/pulumi --on-conflict replace --json", { env })
+  })
+
+  afterAll(() => {
+    runNoServer("plugins remove pulumi --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("pulumi cli version --json", { env })
+    expect(r.ok).toBe(true)
+    const data = JSON.parse(r.output)
+    expect(data.command).toBe("pulumi.cli.version")
+    expect(data.data.raw).toBe("v3.160.0-test")
+  })
+
+  test("supports namespace passthrough", () => {
+    const r = runNoServer("pulumi stack ls --json", { env })
+    expect(r.ok).toBe(true)
+    const data = JSON.parse(r.output)
+    expect(data.command).toBe("pulumi.passthrough")
+    expect(data.data.args[0]).toBe("stack")
+    expect(data.data.args[1]).toBe("ls")
+    expect(data.data.args).toContain("--json")
+  })
+
+  test("doctor reports pulumi dependency as healthy", () => {
+    const r = runNoServer("plugins doctor pulumi --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 === "pulumi" && c.ok === true)).toBe(true)
+  })
+})