superacli 1.1.0 → 1.1.2

package/__tests__/nextest-plugin.test.js

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

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

package/__tests__/nullclaw-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.includes('/git/trees/main?recursive=1')) {",
+    "  console.log(JSON.stringify({ tree: [",
+    "    { type: 'blob', path: 'README.md' },",
+    "    { type: 'blob', path: 'AGENTS.md' },",
+    "    { type: 'blob', path: 'CLAUDE.md' },",
+    "    { type: 'blob', path: 'CONTRIBUTING.md' },",
+    "    { type: 'blob', path: 'docs/en/README.md' },",
+    "    { type: 'blob', path: 'docs/en/installation.md' },",
+    "    { type: 'blob', path: 'docs/en/configuration.md' },",
+    "    { type: 'blob', path: 'docs/en/commands.md' },",
+    "    { type: 'blob', path: 'docs/en/usage.md' },",
+    "    { type: 'blob', path: 'docs/en/architecture.md' },",
+    "    { type: 'blob', path: 'docs/en/security.md' },",
+    "    { type: 'blob', path: 'docs/en/gateway-api.md' },",
+    "    { type: 'blob', path: 'docs/en/development.md' }",
+    "  ] }));",
+    "  process.exit(0);",
+    "}",
+    "if (url.includes('raw.githubusercontent.com/nullclaw/nullclaw/main/')) {",
+    "  const docPath = url.split('/main/')[1] || 'README.md';",
+    "  console.log(`# ${docPath}\\n\\nTest markdown for ${docPath}.`);",
+    "  process.exit(0);",
+    "}",
+    "console.error(`unsupported url: ${url}`);",
+    "process.exit(22);"
+  ].join("\n"), "utf-8")
+  fs.chmodSync(bin, 0o755)
+  return bin
+}
+
+function writeFakeNullclawBinary(dir) {
+  const bin = path.join(dir, "nullclaw")
+  fs.writeFileSync(bin, [
+    "#!/usr/bin/env node",
+    "const args = process.argv.slice(2);",
+    "if (args[0] === '--version' || args[0] === 'version') { console.log('nullclaw v2026.3.8-test'); process.exit(0); }",
+    "if (args[0] === 'status') { console.log('NullClaw status: healthy'); process.exit(0); }",
+    "console.log(JSON.stringify({ ok: true, args }));"
+  ].join("\n"), "utf-8")
+  fs.chmodSync(bin, 0o755)
+  return bin
+}
+
+describe("nullclaw hybrid plugin", () => {
+  const fakeDir = fs.mkdtempSync(path.join(os.tmpdir(), "dcli-nullclaw-"))
+  const tempHome = fs.mkdtempSync(path.join(os.tmpdir(), "dcli-home-nullclaw-"))
+  writeFakeCurlBinary(fakeDir)
+  writeFakeNullclawBinary(fakeDir)
+  const env = { ...process.env, PATH: `${fakeDir}:${process.env.PATH || ""}`, SUPERCLI_HOME: tempHome }
+  let removed = false
+
+  beforeAll(() => {
+    const install = runNoServer("plugins install ./plugins/nullclaw --on-conflict replace --json", { env })
+    expect(install.ok).toBe(true)
+  })
+
+  afterAll(() => {
+    if (!removed) runNoServer("plugins remove nullclaw --json", { env })
+    fs.rmSync(fakeDir, { recursive: true, force: true })
+    fs.rmSync(tempHome, { recursive: true, force: true })
+  })
+
+  test("indexes nullclaw skills provider", () => {
+    const provider = runNoServer("skills providers show --name nullclaw --json", { env })
+    expect(provider.ok).toBe(true)
+    const providerData = JSON.parse(provider.output)
+    expect(providerData.provider.name).toBe("nullclaw")
+
+    const list = runNoServer("skills list --catalog --provider nullclaw --json", { env })
+    expect(list.ok).toBe(true)
+    const listData = JSON.parse(list.output)
+    expect(listData.skills.some(skill => skill.id === "nullclaw:root.agents")).toBe(true)
+  })
+
+  test("routes wrapped version command", () => {
+    const r = runNoServer("nullclaw cli version --json", { env })
+    expect(r.ok).toBe(true)
+    const data = JSON.parse(r.output)
+    expect(data.command).toBe("nullclaw.cli.version")
+    expect(data.data.raw).toBe("nullclaw v2026.3.8-test")
+  })
+
+  test("routes wrapped system status command", () => {
+    const r = runNoServer("nullclaw system status --json", { env })
+    expect(r.ok).toBe(true)
+    const data = JSON.parse(r.output)
+    expect(data.command).toBe("nullclaw.system.status")
+    expect(data.data.raw).toBe("NullClaw status: healthy")
+  })
+
+  test("supports nullclaw namespace passthrough", () => {
+    const r = runNoServer("nullclaw models list --json", { env })
+    expect(r.ok).toBe(true)
+    const data = JSON.parse(r.output)
+    expect(data.command).toBe("nullclaw.passthrough")
+    expect(data.data.args[0]).toBe("models")
+    expect(data.data.args[1]).toBe("list")
+    expect(data.data.args).toContain("--json")
+  })
+
+  test("doctor reports curl and nullclaw dependencies as healthy", () => {
+    const r = runNoServer("plugins doctor nullclaw --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 === "nullclaw" && c.ok === true)).toBe(true)
+  })
+
+  test("removal cleans up the skills provider", () => {
+    const remove = runNoServer("plugins remove nullclaw --json", { env })
+    expect(remove.ok).toBe(true)
+    removed = true
+
+    const provider = runNoServer("skills providers show --name nullclaw --json", { env })
+    expect(provider.ok).toBe(false)
+
+    const list = runNoServer("skills list --catalog --provider nullclaw --json", { env })
+    expect(list.ok).toBe(true)
+    const listData = JSON.parse(list.output)
+    expect(listData.skills).toEqual([])
+  })
+})

package/__tests__/openapi-adapter.test.js

@@ -0,0 +1,199 @@
+describe("openapi adapter", () => {
+  const mockSpec = {
+    servers: [{ url: "https://api.test/v1" }],
+    paths: {
+      "/users/{id}": {
+        get: {
+          operationId: "getUser",
+          parameters: [
+            { name: "id", in: "path" },
+            { name: "q", in: "query" }
+          ]
+        }
+      },
+      "/users": {
+        post: {
+          operationId: "createUser"
+        }
+      }
+    }
+  }
+
+  let execute;
+
+  beforeEach(() => {
+    jest.clearAllMocks()
+    jest.resetModules()
+    global.fetch = jest.fn()
+    execute = require("../cli/adapters/openapi").execute
+  })
+
+  test("throws if spec or operationId missing", async () => {
+    await expect(execute({ adapterConfig: {} }, {}, {})).rejects.toThrow(/requires 'spec' and 'operationId'/)
+  })
+
+  test("successfully executes GET operation with path and query params", async () => {
+    global.fetch
+      .mockResolvedValueOnce({ 
+        ok: true,
+        json: () => Promise.resolve(mockSpec)
+      })
+      .mockResolvedValueOnce({ 
+        ok: true,
+        headers: { get: () => "application/json" },
+        json: () => Promise.resolve({ user: "alice" })
+      })
+
+    const context = {
+      config: {
+        specs: [{ name: "my-spec", url: "http://specs/my.json" }]
+      }
+    }
+
+    const result = await execute({
+      adapterConfig: { spec: "my-spec", operationId: "getUser" }
+    }, { id: "123", q: "query-val" }, context)
+
+    expect(global.fetch).toHaveBeenCalledWith("http://specs/my.json")
+    expect(global.fetch).toHaveBeenCalledWith(
+      "https://api.test/v1/users/123?q=query-val",
+      expect.objectContaining({ method: "GET" })
+    )
+    expect(result).toEqual({ user: "alice" })
+  })
+
+  test("successfully executes POST operation with body", async () => {
+    global.fetch
+      .mockResolvedValueOnce({ 
+        ok: true,
+        json: () => Promise.resolve(mockSpec)
+      })
+      .mockResolvedValueOnce({ 
+        ok: true,
+        headers: { get: () => "text/plain" },
+        text: () => Promise.resolve("done")
+      })
+
+    const context = {
+      config: {
+        specs: [{ name: "my-spec", url: "u" }]
+      }
+    }
+
+    const result = await execute({
+      adapterConfig: { spec: "my-spec", operationId: "createUser" }
+    }, { name: "bob" }, context)
+
+    expect(global.fetch).toHaveBeenCalledWith(
+      "https://api.test/v1/users",
+      expect.objectContaining({
+        method: "POST",
+        body: JSON.stringify({ name: "bob" })
+      })
+    )
+    expect(result).toEqual({ raw: "done" })
+  })
+
+  test("resolves spec from remote server if not in local config", async () => {
+    global.fetch
+      .mockResolvedValueOnce({ 
+        ok: true,
+        json: () => Promise.resolve([{ name: "remote-spec", url: "http://remote/spec.json" }])
+      })
+      .mockResolvedValueOnce({ 
+        ok: true,
+        json: () => Promise.resolve(mockSpec)
+      })
+      .mockResolvedValueOnce({ 
+        ok: true,
+        headers: { get: () => "json" },
+        json: () => Promise.resolve({ ok: true })
+      })
+
+    const context = { server: "http://api.test", config: { specs: [] } }
+
+    await execute({
+      adapterConfig: { spec: "remote-spec", operationId: "getUser" }
+    }, { id: "1" }, context)
+
+    expect(global.fetch).toHaveBeenCalledWith("http://api.test/api/specs?format=json")
+    expect(global.fetch).toHaveBeenCalledWith("http://remote/spec.json")
+  })
+
+  test("throws if spec not found and no server", async () => {
+    const context = { config: { specs: [] } }
+    await expect(execute({
+      adapterConfig: { spec: "missing", operationId: "op" }
+    }, {}, context)).rejects.toThrow(/not found in local config/)
+  })
+
+  test("throws if remote spec list fetch fails", async () => {
+    global.fetch.mockResolvedValue({ ok: false, status: 500 })
+    const context = { server: "http://api.test", config: { specs: [] } }
+    await expect(execute({
+      adapterConfig: { spec: "any", operationId: "op" }
+    }, {}, context)).rejects.toThrow(/Failed to fetch specs list: 500/)
+  })
+
+  test("throws if remote spec not found in list", async () => {
+    global.fetch.mockResolvedValue({
+      ok: true,
+      json: () => Promise.resolve([])
+    })
+    const context = { server: "http://api.test", config: { specs: [] } }
+    await expect(execute({
+      adapterConfig: { spec: "missing", operationId: "op" }
+    }, {}, context)).rejects.toThrow(/OpenAPI spec 'missing' not found/)
+  })
+
+  test("throws if actual spec fetch fails", async () => {
+    global.fetch
+      .mockResolvedValueOnce({ ok: true, json: () => Promise.resolve([{ name: "s", url: "u" }]) })
+      .mockResolvedValueOnce({ ok: false, status: 404 })
+    const context = { server: "http://api.test", config: { specs: [] } }
+    await expect(execute({
+      adapterConfig: { spec: "s", operationId: "op" }
+    }, {}, context)).rejects.toThrow(/Failed to fetch OpenAPI spec from u: 404/)
+  })
+
+  test("throws if operationId not found in spec", async () => {
+    global.fetch.mockResolvedValue({ ok: true, json: () => Promise.resolve(mockSpec) })
+    const context = { config: { specs: [{ name: "s", url: "u" }] } }
+    await expect(execute({
+      adapterConfig: { spec: "s", operationId: "missingOp" }
+    }, {}, context)).rejects.toThrow(/Operation 'missingOp' not found in spec/)
+  })
+
+  test("handles API call failure (500)", async () => {
+    global.fetch
+      .mockResolvedValueOnce({ ok: true, json: () => Promise.resolve(mockSpec) })
+      .mockResolvedValueOnce({ 
+        ok: false, 
+        status: 500, 
+        statusText: "Err", 
+        text: () => Promise.resolve("body"),
+        headers: { get: () => "text/plain" }
+      })
+    
+    const context = { config: { specs: [{ name: "s", url: "u" }] } }
+    await expect(execute({
+      adapterConfig: { spec: "s", operationId: "getUser" }
+    }, { id: "1" }, context)).rejects.toMatchObject({ code: 105 })
+  })
+
+  test("uses spec cache", async () => {
+    global.fetch
+      .mockResolvedValueOnce({ ok: true, json: () => Promise.resolve(mockSpec) })
+      .mockResolvedValue({ ok: true, headers: { get: () => "json" }, json: () => Promise.resolve({}) })
+
+    const context = { config: { specs: [{ name: "cached", url: "u" }] } }
+    
+    // First call: spec fetch + API call
+    await execute({ adapterConfig: { spec: "cached", operationId: "getUser" } }, { id: "1" }, context)
+    // Second call: only API call (spec is cached)
+    await execute({ adapterConfig: { spec: "cached", operationId: "getUser" } }, { id: "2" }, context)
+
+    expect(global.fetch).toHaveBeenCalledWith("u")
+    expect(global.fetch).toHaveBeenCalledTimes(3) // 1 spec fetch + 2 API calls
+  })
+})

package/__tests__/plugin-agency-agents.test.js

@@ -1,9 +1,9 @@
 const { spawnSync } = require("child_process")
 const { addProvider, syncCatalog } = require("../cli/skills-catalog")
 const {
-  installAgencyAgentsSkillProvider,
+  run,
   buildRemoteEntriesFromTree
-} = require("../cli/plugin-agency-agents")
+} = require("../plugins/agency-agents/scripts/post-install")
 
 jest.mock("child_process")
 jest.mock("../cli/skills-catalog")
@@ -28,7 +28,7 @@ describe("plugin-agency-agents", () => {
     expect(entries[1].id).toBe("marketing.marketing-growth-hacker")
   })
 
-  test("installAgencyAgentsSkillProvider stores provider and syncs catalog", () => {
+  test("run stores provider and syncs catalog", () => {
     spawnSync.mockReturnValue({
       status: 0,
       stdout: JSON.stringify({
@@ -40,7 +40,7 @@ describe("plugin-agency-agents", () => {
     })
     syncCatalog.mockReturnValue({ skills: [1, 2, 3] })
 
-    const result = installAgencyAgentsSkillProvider()
+    const result = run()
 
     expect(addProvider).toHaveBeenCalledWith(expect.objectContaining({
       name: "agency-agents",
@@ -55,8 +55,8 @@ describe("plugin-agency-agents", () => {
     })
   })
 
-  test("installAgencyAgentsSkillProvider throws on curl failure", () => {
+  test("run throws on curl failure", () => {
     spawnSync.mockReturnValue({ status: 22, stderr: "404" })
-    expect(() => installAgencyAgentsSkillProvider()).toThrow(/Failed to fetch agency-agents metadata/)
+    expect(() => run()).toThrow(/Failed to fetch agency-agents metadata/)
   })
 })

package/__tests__/plugin-nullclaw.test.js

@@ -0,0 +1,78 @@
+const { spawnSync } = require("child_process")
+const { addProvider, removeProvider, syncCatalog } = require("../cli/skills-catalog")
+const {
+  CATALOG_FILES,
+  run,
+  buildRemoteEntriesFromTree
+} = require("../plugins/nullclaw/scripts/post-install")
+const { run: runUninstall } = require("../plugins/nullclaw/scripts/post-uninstall")
+
+jest.mock("child_process")
+jest.mock("../cli/skills-catalog")
+
+describe("plugin-nullclaw", () => {
+  beforeEach(() => {
+    jest.clearAllMocks()
+  })
+
+  test("buildRemoteEntriesFromTree keeps only curated nullclaw docs", () => {
+    const entries = buildRemoteEntriesFromTree({
+      tree: [
+        { type: "blob", path: "README.md" },
+        { type: "blob", path: "AGENTS.md" },
+        { type: "blob", path: "docs/en/commands.md" },
+        { type: "blob", path: "docs/zh/commands.md" },
+        { type: "blob", path: "spec/webchannel_v1.json" }
+      ]
+    })
+
+    expect(entries.map(entry => entry.id)).toEqual([
+      "root.readme",
+      "root.agents",
+      "docs.en.commands"
+    ])
+    expect(entries.every(entry => entry.source_url.includes("raw.githubusercontent.com/nullclaw/nullclaw/main/"))).toBe(true)
+  })
+
+  test("run stores provider and syncs catalog", () => {
+    spawnSync.mockReturnValue({
+      status: 0,
+      stdout: JSON.stringify({
+        tree: CATALOG_FILES.map(file => ({ type: "blob", path: file.path }))
+      })
+    })
+    syncCatalog.mockReturnValue({ skills: [1, 2, 3, 4] })
+
+    const result = run()
+
+    expect(addProvider).toHaveBeenCalledWith(expect.objectContaining({
+      name: "nullclaw",
+      type: "remote_static",
+      entries: expect.arrayContaining([
+        expect.objectContaining({ id: "root.agents" }),
+        expect.objectContaining({ id: "docs.en.architecture" })
+      ])
+    }))
+    expect(syncCatalog).toHaveBeenCalled()
+    expect(result).toEqual({
+      provider: "nullclaw",
+      entries: CATALOG_FILES.length,
+      synced_skills: 4
+    })
+  })
+
+  test("run throws on curl failure", () => {
+    spawnSync.mockReturnValue({ status: 22, stderr: "404" })
+    expect(() => run()).toThrow(/Failed to fetch nullclaw metadata/)
+  })
+
+  test("post-uninstall removes provider and syncs catalog", () => {
+    removeProvider.mockReturnValue(true)
+    syncCatalog.mockReturnValue({ skills: [1] })
+    const result = runUninstall()
+    expect(removeProvider).toHaveBeenCalledWith("nullclaw")
+    expect(addProvider).not.toHaveBeenCalled()
+    expect(syncCatalog).toHaveBeenCalled()
+    expect(result).toEqual({ provider: "nullclaw", removed: true, synced_skills: 1 })
+  })
+})