superacli 1.1.0 → 1.1.2

package/__tests__/aws-plugin.test.js

@@ -0,0 +1,84 @@
+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 writeFakeAwsBinary(dir) {
+  const bin = path.join(dir, "aws")
+  fs.writeFileSync(bin, [
+    "#!/usr/bin/env node",
+    "const args = process.argv.slice(2);",
+    "if (args.includes('--version')) { console.log('aws-cli/2.0.0-test Python/3.11'); process.exit(0); }",
+    "if (args[0] === 'sts' && args[1] === 'get-caller-identity') {",
+    "  console.log(JSON.stringify({ Account: '123456789012', Arn: 'arn:aws:iam::123456789012:user/mock', UserId: 'AIDTEST' }));",
+    "  process.exit(0);",
+    "}",
+    "console.log(JSON.stringify({ ok: true, args }));"
+  ].join("\n"), "utf-8")
+  fs.chmodSync(bin, 0o755)
+  return bin
+}
+
+describe("aws plugin", () => {
+  const fakeDir = fs.mkdtempSync(path.join(os.tmpdir(), "dcli-aws-"))
+  const tempHome = fs.mkdtempSync(path.join(os.tmpdir(), "dcli-home-aws-"))
+  writeFakeAwsBinary(fakeDir)
+  const env = { ...process.env, PATH: `${fakeDir}:${process.env.PATH || ""}`, SUPERCLI_HOME: tempHome }
+
+  beforeAll(() => {
+    runNoServer("plugins install ./plugins/aws --on-conflict replace --json", { env })
+  })
+
+  afterAll(() => {
+    runNoServer("plugins remove aws --json", { env })
+    fs.rmSync(fakeDir, { recursive: true, force: true })
+    fs.rmSync(tempHome, { recursive: true, force: true })
+  })
+
+  test("routes account identity wrapped command", () => {
+    const r = runNoServer("aws account identity --json", { env })
+    expect(r.ok).toBe(true)
+    const data = JSON.parse(r.output)
+    expect(data.command).toBe("aws.account.identity")
+    expect(data.data.Account).toBe("123456789012")
+  })
+
+  test("supports namespace passthrough", () => {
+    const r = runNoServer("aws s3api list-buckets", { env })
+    expect(r.ok).toBe(true)
+    const data = JSON.parse(r.output)
+    expect(data.command).toBe("aws.passthrough")
+    expect(data.data.args[0]).toBe("s3api")
+    expect(data.data.args[1]).toBe("list-buckets")
+  })
+
+  test("doctor reports aws dependency as healthy", () => {
+    const r = runNoServer("plugins doctor aws --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 === "aws" && c.ok === true)).toBe(true)
+  })
+})

package/__tests__/az-plugin.test.js

@@ -0,0 +1,84 @@
+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 writeFakeAzBinary(dir) {
+  const bin = path.join(dir, "az")
+  fs.writeFileSync(bin, [
+    "#!/usr/bin/env node",
+    "const args = process.argv.slice(2);",
+    "if (args[0] === 'version') { console.log(JSON.stringify({ 'azure-cli': '2.0.0-test' })); process.exit(0); }",
+    "if (args[0] === 'account' && args[1] === 'show') {",
+    "  console.log(JSON.stringify({ id: 'sub-123', name: 'mock-subscription', state: 'Enabled' }));",
+    "  process.exit(0);",
+    "}",
+    "console.log(JSON.stringify({ ok: true, args }));"
+  ].join("\n"), "utf-8")
+  fs.chmodSync(bin, 0o755)
+  return bin
+}
+
+describe("az plugin", () => {
+  const fakeDir = fs.mkdtempSync(path.join(os.tmpdir(), "dcli-az-"))
+  const tempHome = fs.mkdtempSync(path.join(os.tmpdir(), "dcli-home-az-"))
+  writeFakeAzBinary(fakeDir)
+  const env = { ...process.env, PATH: `${fakeDir}:${process.env.PATH || ""}`, SUPERCLI_HOME: tempHome }
+
+  beforeAll(() => {
+    runNoServer("plugins install ./plugins/az --on-conflict replace --json", { env })
+  })
+
+  afterAll(() => {
+    runNoServer("plugins remove az --json", { env })
+    fs.rmSync(fakeDir, { recursive: true, force: true })
+    fs.rmSync(tempHome, { recursive: true, force: true })
+  })
+
+  test("routes account show wrapped command", () => {
+    const r = runNoServer("az account show --json", { env })
+    expect(r.ok).toBe(true)
+    const data = JSON.parse(r.output)
+    expect(data.command).toBe("az.account.show")
+    expect(data.data.id).toBe("sub-123")
+  })
+
+  test("supports namespace passthrough", () => {
+    const r = runNoServer("az group list", { env })
+    expect(r.ok).toBe(true)
+    const data = JSON.parse(r.output)
+    expect(data.command).toBe("az.passthrough")
+    expect(data.data.args[0]).toBe("group")
+    expect(data.data.args[1]).toBe("list")
+  })
+
+  test("doctor reports az dependency as healthy", () => {
+    const r = runNoServer("plugins doctor az --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 === "az" && c.ok === true)).toBe(true)
+  })
+})

package/__tests__/builtin-adapter.test.js

@@ -0,0 +1,29 @@
+const { execute } = require("../cli/adapters/builtin")
+
+describe("builtin adapter", () => {
+  test("returns beads install steps", () => {
+    const result = execute({ adapterConfig: { builtin: "beads_install_steps" } })
+    expect(result.plugin).toBe("beads")
+    expect(result.install_steps).toContain("br --version")
+  })
+
+  test("returns gwc install steps", () => {
+    const result = execute({ adapterConfig: { builtin: "gwc_install_steps" } })
+    expect(result.plugin).toBe("gwc")
+    expect(result.install_steps).toContain("gws --version")
+  })
+
+  test("returns commiat install steps", () => {
+    const result = execute({ adapterConfig: { builtin: "commiat_install_steps" } })
+    expect(result.plugin).toBe("commiat")
+    expect(result.install_steps).toContain("commiat --version")
+  })
+
+  test("throws for unknown builtin action", () => {
+    expect(() => execute({ adapterConfig: { builtin: "unknown" } })).toThrow(/Unknown builtin action: unknown/)
+  })
+
+  test("throws for missing builtin action", () => {
+    expect(() => execute({ adapterConfig: {} })).toThrow(/Unknown builtin action: \(missing\)/)
+  })
+})

package/__tests__/cline-plugin.test.js

@@ -0,0 +1,109 @@
+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 writeFakeClineBinary(dir) {
+  const bin = path.join(dir, "cline")
+  fs.writeFileSync(bin, [
+    "#!/usr/bin/env node",
+    "const args = process.argv.slice(2);",
+    "if (args[0] === '--version') { console.log('cline 3.71.0-test'); process.exit(0); }",
+    "if (args.includes('--json') && (args.includes('-a') || args.includes('-p'))) {",
+    "  const prompt = args[args.length - 1];",
+    "  console.log(JSON.stringify({ type: 'task_started', taskId: 'task-123' }));",
+    "  console.log(JSON.stringify({ type: 'say', say: 'task', text: prompt }));",
+    "  console.log(JSON.stringify({ type: 'say', say: 'completion_result', text: 'done', partial: false }));",
+    "  process.exit(0);",
+    "}",
+    "console.log(JSON.stringify({ ok: true, args }));"
+  ].join("\n"), "utf-8")
+  fs.chmodSync(bin, 0o755)
+  return bin
+}
+
+describe("cline plugin", () => {
+  const fakeDir = fs.mkdtempSync(path.join(os.tmpdir(), "dcli-cline-"))
+  const tempHome = fs.mkdtempSync(path.join(os.tmpdir(), "dcli-home-cline-"))
+  writeFakeClineBinary(fakeDir)
+  const env = { ...process.env, PATH: `${fakeDir}:${process.env.PATH || ""}`, SUPERCLI_HOME: tempHome }
+
+  beforeAll(() => {
+    runNoServer("plugins install ./plugins/cline --on-conflict replace --json", { env })
+  })
+
+  afterAll(() => {
+    runNoServer("plugins remove cline --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("cline cli version --json", { env })
+    expect(r.ok).toBe(true)
+    const data = JSON.parse(r.output)
+    expect(data.command).toBe("cline.cli.version")
+    expect(data.data.raw).toBe("cline 3.71.0-test")
+  })
+
+  test("streams act-mode task output with final summary", () => {
+    const r = runNoServer("cline task run --prompt \"List files with most LOC\" --cwd . --timeout 30 --json", { env })
+    expect(r.ok).toBe(true)
+    const lines = r.output.split("\n").filter(Boolean).map(line => JSON.parse(line))
+    expect(lines[0].stream).toBe(true)
+    expect(lines[0].command).toBe("cline.task.run")
+    expect(lines[0].data.type).toBe("task_started")
+    expect(lines[1].data.say).toBe("task")
+    expect(lines[2].data.say).toBe("completion_result")
+    expect(lines[3].stream).toBeUndefined()
+    expect(lines[3].data.streamed).toBe(true)
+    expect(lines[3].data.event_count).toBe(3)
+  })
+
+  test("streams plan-mode task output with final summary", () => {
+    const r = runNoServer("cline task plan --prompt \"Plan auth refactor\" --json", { env })
+    expect(r.ok).toBe(true)
+    const lines = r.output.split("\n").filter(Boolean).map(line => JSON.parse(line))
+    expect(lines[0].command).toBe("cline.task.plan")
+    expect(lines[3].data.last_event.say).toBe("completion_result")
+  })
+
+  test("supports namespace passthrough", () => {
+    const r = runNoServer("cline --help --json", { env })
+    expect(r.ok).toBe(true)
+    const data = JSON.parse(r.output)
+    expect(data.command).toBe("cline.passthrough")
+    expect(data.data.args).toContain("--help")
+    expect(data.data.args).toContain("--json")
+  })
+
+  test("doctor reports cline dependency as healthy", () => {
+    const r = runNoServer("plugins doctor cline --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 === "cline" && c.ok === true)).toBe(true)
+  })
+})

package/__tests__/cline-skill.test.js

@@ -0,0 +1,49 @@
+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
+    }
+  }
+}
+
+describe("cline local skill", () => {
+  const tempHome = fs.mkdtempSync(path.join(os.tmpdir(), "dcli-home-cline-skill-"))
+  const env = { ...process.env, SUPERCLI_HOME: tempHome }
+
+  afterAll(() => {
+    fs.rmSync(tempHome, { recursive: true, force: true })
+  })
+
+  test("syncs and resolves repo skill", () => {
+    const sync = runNoServer("skills sync --json", { env })
+    expect(sync.ok).toBe(true)
+
+    const list = runNoServer("skills list --catalog --provider repo --json", { env })
+    expect(list.ok).toBe(true)
+    const listData = JSON.parse(list.output)
+    expect(listData.skills.some(skill => skill.id === "repo:cline-non-interactive")).toBe(true)
+
+    const get = runNoServer("skills get repo:cline-non-interactive", { env })
+    expect(get.ok).toBe(true)
+    expect(get.output).toContain("supercli cline task run")
+  })
+})

package/__tests__/docker-plugin.test.js

@@ -39,8 +39,9 @@ function writeFakeDockerBinary(dir) {
 
 describe("docker plugin", () => {
   const fakeDir = fs.mkdtempSync(path.join(os.tmpdir(), "dcli-docker-"))
+  const tempHome = fs.mkdtempSync(path.join(os.tmpdir(), "dcli-home-docker-"))
   writeFakeDockerBinary(fakeDir)
-  const env = { ...process.env, PATH: `${fakeDir}:${process.env.PATH || ""}` }
+  const env = { ...process.env, PATH: `${fakeDir}:${process.env.PATH || ""}`, SUPERCLI_HOME: tempHome }
 
   beforeAll(() => {
     runNoServer("plugins install ./plugins/docker --on-conflict replace --json", { env })
@@ -49,6 +50,7 @@ describe("docker plugin", () => {
   afterAll(() => {
     runNoServer("plugins remove docker --json", { env })
     fs.rmSync(fakeDir, { recursive: true, force: true })
+    fs.rmSync(tempHome, { recursive: true, force: true })
   })
 
   test("routes docker container ls to docker ps", () => {

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

package/__tests__/gcloud-plugin.test.js

@@ -0,0 +1,86 @@
+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 writeFakeGcloudBinary(dir) {
+  const bin = path.join(dir, "gcloud")
+  fs.writeFileSync(bin, [
+    "#!/usr/bin/env node",
+    "const args = process.argv.slice(2);",
+    "if (args.includes('--version')) { console.log('Google Cloud SDK 999.0.0-test'); process.exit(0); }",
+    "if (args[0] === 'auth' && args[1] === 'list' && args.includes('--format=json')) {",
+    "  console.log(JSON.stringify([{ account: 'mock@example.com', status: 'ACTIVE' }]));",
+    "  process.exit(0);",
+    "}",
+    "console.log(JSON.stringify({ ok: true, args }));"
+  ].join("\n"), "utf-8")
+  fs.chmodSync(bin, 0o755)
+  return bin
+}
+
+describe("gcloud plugin", () => {
+  const fakeDir = fs.mkdtempSync(path.join(os.tmpdir(), "dcli-gcloud-"))
+  const tempHome = fs.mkdtempSync(path.join(os.tmpdir(), "dcli-home-gcloud-"))
+  writeFakeGcloudBinary(fakeDir)
+  const env = { ...process.env, PATH: `${fakeDir}:${process.env.PATH || ""}`, SUPERCLI_HOME: tempHome }
+
+  beforeAll(() => {
+    runNoServer("plugins install ./plugins/gcloud --on-conflict replace --json", { env })
+  })
+
+  afterAll(() => {
+    runNoServer("plugins remove gcloud --json", { env })
+    fs.rmSync(fakeDir, { recursive: true, force: true })
+    fs.rmSync(tempHome, { recursive: true, force: true })
+  })
+
+  test("routes account list wrapped command", () => {
+    const r = runNoServer("gcloud account list --json", { env })
+    expect(r.ok).toBe(true)
+    const data = JSON.parse(r.output)
+    expect(data.command).toBe("gcloud.account.list")
+    expect(Array.isArray(data.data)).toBe(true)
+    expect(data.data[0].account).toBe("mock@example.com")
+  })
+
+  test("supports namespace passthrough", () => {
+    const r = runNoServer("gcloud projects list --format=json", { env })
+    expect(r.ok).toBe(true)
+    const data = JSON.parse(r.output)
+    expect(data.command).toBe("gcloud.passthrough")
+    expect(data.data.args[0]).toBe("projects")
+    expect(data.data.args[1]).toBe("list")
+    expect(data.data.args).toContain("--format=json")
+  })
+
+  test("doctor reports gcloud dependency as healthy", () => {
+    const r = runNoServer("plugins doctor gcloud --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 === "gcloud" && c.ok === true)).toBe(true)
+  })
+})

package/__tests__/gh-plugin.test.js

@@ -0,0 +1,86 @@
+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 writeFakeGhBinary(dir) {
+  const bin = path.join(dir, "gh")
+  fs.writeFileSync(bin, [
+    "#!/usr/bin/env node",
+    "const args = process.argv.slice(2);",
+    "if (args.includes('--version')) { console.log('gh version 2.0.0-test'); process.exit(0); }",
+    "if (args[0] === 'auth' && args[1] === 'status' && args.includes('--json')) {",
+    "  console.log(JSON.stringify({ hosts: [{ hostname: 'github.com', status: 'logged_in', active: true }] }));",
+    "  process.exit(0);",
+    "}",
+    "console.log(JSON.stringify({ ok: true, args }));"
+  ].join("\n"), "utf-8")
+  fs.chmodSync(bin, 0o755)
+  return bin
+}
+
+describe("gh plugin", () => {
+  const fakeDir = fs.mkdtempSync(path.join(os.tmpdir(), "dcli-gh-"))
+  const tempHome = fs.mkdtempSync(path.join(os.tmpdir(), "dcli-home-gh-"))
+  writeFakeGhBinary(fakeDir)
+  const env = { ...process.env, PATH: `${fakeDir}:${process.env.PATH || ""}`, SUPERCLI_HOME: tempHome }
+
+  beforeAll(() => {
+    runNoServer("plugins install ./plugins/gh --on-conflict replace --json", { env })
+  })
+
+  afterAll(() => {
+    runNoServer("plugins remove gh --json", { env })
+    fs.rmSync(fakeDir, { recursive: true, force: true })
+    fs.rmSync(tempHome, { recursive: true, force: true })
+  })
+
+  test("routes account status wrapped command", () => {
+    const r = runNoServer("gh account status --json", { env })
+    expect(r.ok).toBe(true)
+    const data = JSON.parse(r.output)
+    expect(data.command).toBe("gh.account.status")
+    expect(Array.isArray(data.data.hosts)).toBe(true)
+    expect(data.data.hosts[0].hostname).toBe("github.com")
+  })
+
+  test("supports namespace passthrough", () => {
+    const r = runNoServer("gh repo list --limit 1 --json name", { env })
+    expect(r.ok).toBe(true)
+    const data = JSON.parse(r.output)
+    expect(data.command).toBe("gh.passthrough")
+    expect(data.data.args[0]).toBe("repo")
+    expect(data.data.args[1]).toBe("list")
+    expect(data.data.args).toContain("--json")
+  })
+
+  test("doctor reports gh dependency as healthy", () => {
+    const r = runNoServer("plugins doctor gh --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 === "gh" && c.ok === true)).toBe(true)
+  })
+})