superacli 1.1.0 → 1.1.2

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

package/__tests__/http-adapter.test.js

@@ -0,0 +1,118 @@
+const { execute } = require("../cli/adapters/http")
+
+describe("http adapter", () => {
+  beforeEach(() => {
+    global.fetch = jest.fn()
+  })
+
+  test("throws if url missing", async () => {
+    await expect(execute({ adapterConfig: {} }, {}, {})).rejects.toThrow(/requires 'url'/)
+  })
+
+  test("performs GET request with placeholders and query params", async () => {
+    global.fetch.mockResolvedValue({
+      ok: true,
+      headers: { get: () => "application/json" },
+      json: () => Promise.resolve({ data: "ok" })
+    })
+
+    const result = await execute({
+      adapterConfig: { url: "https://api.test/users/{id}" }
+    }, { id: "123", q: "search", human: true }, {})
+
+    expect(global.fetch).toHaveBeenCalledWith(
+      "https://api.test/users/123?q=search",
+      expect.objectContaining({ method: "GET" })
+    )
+    expect(result).toEqual({ data: "ok" })
+  })
+
+  test("performs POST request with body from flags", async () => {
+    global.fetch.mockResolvedValue({
+      ok: true,
+      headers: { get: () => "application/json" },
+      json: () => Promise.resolve({ ok: true })
+    })
+
+    const result = await execute({
+      adapterConfig: { url: "https://api.test/users", method: "POST" }
+    }, { name: "alice", role: "admin" }, {})
+
+    expect(global.fetch).toHaveBeenCalledWith(
+      "https://api.test/users",
+      expect.objectContaining({
+        method: "POST",
+        body: JSON.stringify({ name: "alice", role: "admin" })
+      })
+    )
+  })
+
+  test("performs POST request with predefined body", async () => {
+    global.fetch.mockResolvedValue({
+      ok: true,
+      headers: { get: () => "text/plain" },
+      text: () => Promise.resolve("raw-response")
+    })
+
+    const result = await execute({
+      adapterConfig: { 
+        url: "https://api.test/users", 
+        method: "PATCH",
+        body: { fixed: true }
+      }
+    }, { ignored: "val" }, {})
+
+    expect(global.fetch).toHaveBeenCalledWith(
+      "https://api.test/users",
+      expect.objectContaining({
+        method: "PATCH",
+        body: JSON.stringify({ fixed: true })
+      })
+    )
+    expect(result).toEqual({ raw: "raw-response" })
+  })
+
+  test("handles HTTP error codes (500)", async () => {
+    global.fetch.mockResolvedValue({
+      ok: false,
+      status: 500,
+      statusText: "Server Error",
+      text: () => Promise.resolve("error details")
+    })
+
+    await expect(execute({ adapterConfig: { url: "u" } }, {}, {}))
+      .rejects.toMatchObject({
+        code: 105,
+        type: "integration_error",
+        recoverable: true
+      })
+  })
+
+  test("handles HTTP error codes (404)", async () => {
+    global.fetch.mockResolvedValue({
+      ok: false,
+      status: 404,
+      statusText: "Not Found",
+      text: () => Promise.resolve("")
+    })
+
+    await expect(execute({ adapterConfig: { url: "u" } }, {}, {}))
+      .rejects.toMatchObject({
+        code: 92,
+        type: "resource_not_found",
+        recoverable: false
+      })
+  })
+  
+  test("handles fetch text failure in error path", async () => {
+    global.fetch.mockResolvedValue({
+      ok: false,
+      status: 400,
+      statusText: "Bad Request",
+      text: () => Promise.reject("cant-read-body")
+    })
+
+    await expect(execute({ adapterConfig: { url: "u" } }, {}, {}))
+      .rejects.toThrow(/HTTP request failed: 400 Bad Request/)
+  })
+})

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

package/__tests__/kubectl-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 writeFakeKubectlBinary(dir) {
+  const bin = path.join(dir, "kubectl")
+  fs.writeFileSync(bin, [
+    "#!/usr/bin/env node",
+    "const args = process.argv.slice(2);",
+    "if (args[0] === 'version' && args.includes('--client')) { console.log('Client Version: v1.35.0-test'); process.exit(0); }",
+    "if (args[0] === 'config' && args[1] === 'current-context') { console.log('mock-context'); process.exit(0); }",
+    "console.log(JSON.stringify({ ok: true, args }));"
+  ].join("\n"), "utf-8")
+  fs.chmodSync(bin, 0o755)
+  return bin
+}
+
+describe("kubectl plugin", () => {
+  const fakeDir = fs.mkdtempSync(path.join(os.tmpdir(), "dcli-kubectl-"))
+  const tempHome = fs.mkdtempSync(path.join(os.tmpdir(), "dcli-home-kubectl-"))
+  writeFakeKubectlBinary(fakeDir)
+  const env = { ...process.env, PATH: `${fakeDir}:${process.env.PATH || ""}`, SUPERCLI_HOME: tempHome }
+
+  beforeAll(() => {
+    runNoServer("plugins install ./plugins/kubectl --on-conflict replace --json", { env })
+  })
+
+  afterAll(() => {
+    runNoServer("plugins remove kubectl --json", { env })
+    fs.rmSync(fakeDir, { recursive: true, force: true })
+    fs.rmSync(tempHome, { recursive: true, force: true })
+  })
+
+  test("routes current-context wrapped command", () => {
+    const r = runNoServer("kubectl config current-context --json", { env })
+    expect(r.ok).toBe(true)
+    const data = JSON.parse(r.output)
+    expect(data.command).toBe("kubectl.config.current-context")
+    expect(data.data.raw).toBe("mock-context")
+  })
+
+  test("supports namespace passthrough", () => {
+    const r = runNoServer("kubectl get pods -o json", { env })
+    expect(r.ok).toBe(true)
+    const data = JSON.parse(r.output)
+    expect(data.command).toBe("kubectl.passthrough")
+    expect(data.data.args[0]).toBe("get")
+    expect(data.data.args[1]).toBe("pods")
+    expect(data.data.args).toContain("-o")
+    expect(data.data.args).toContain("json")
+  })
+
+  test("doctor reports kubectl dependency as healthy", () => {
+    const r = runNoServer("plugins doctor kubectl --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 === "kubectl" && c.ok === true)).toBe(true)
+  })
+})

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

package/__tests__/mcp-adapter.test.js

@@ -0,0 +1,187 @@
+const { execute } = require("../cli/adapters/mcp")
+const { spawn } = require("child_process")
+const EventEmitter = require("events")
+
+jest.mock("child_process")
+
+describe("mcp adapter", () => {
+  beforeEach(() => {
+    jest.clearAllMocks()
+    global.fetch = jest.fn()
+  })
+
+  test("throws if tool or source missing", async () => {
+    await expect(execute({ adapterConfig: {} }, {}, {})).rejects.toThrow(/requires 'tool'/)
+    await expect(execute({ adapterConfig: { tool: "t" } }, {}, {})).rejects.toThrow(/one of: 'server', 'url', or 'command'/)
+  })
+
+  describe("stdio source", () => {
+    let mockChild
+
+    beforeEach(() => {
+      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)
+    })
+
+    test("successfully calls stdio tool", async () => {
+      const promise = execute({
+        adapterConfig: { tool: "calc", command: "node", commandArgs: ["tool.js"] }
+      }, { x: 1 }, {})
+
+      mockChild.stdout.emit("data", '{"result": 42}')
+      mockChild.emit("close", 0)
+
+      const result = await promise
+      expect(result).toEqual({ result: 42 })
+      expect(mockChild.stdin.write).toHaveBeenCalledWith(expect.stringContaining('"tool":"calc"'))
+    })
+
+    test("handles stdio tool error exit", async () => {
+      const promise = execute({
+        adapterConfig: { tool: "calc", command: "node" }
+      }, {}, {})
+
+      mockChild.stderr.emit("data", "fatal error")
+      mockChild.emit("close", 1)
+
+      await expect(promise).rejects.toMatchObject({
+        message: expect.stringContaining("exited with code 1: fatal error")
+      })
+    })
+
+    test("handles stdio tool crash", async () => {
+      const promise = execute({
+        adapterConfig: { tool: "calc", command: "node" }
+      }, {}, {})
+
+      mockChild.emit("error", new Error("spawn error"))
+
+      await expect(promise).rejects.toMatchObject({
+        message: expect.stringContaining("Failed to start MCP stdio command: spawn error")
+      })
+    })
+
+    test("handles invalid JSON response", async () => {
+      const promise = execute({
+        adapterConfig: { tool: "calc", command: "node" }
+      }, {}, {})
+
+      mockChild.stdout.emit("data", "not-json")
+      mockChild.emit("close", 0)
+
+      await expect(promise).rejects.toMatchObject({
+        message: expect.stringContaining("response is not valid JSON")
+      })
+    })
+
+    test("handles timeout", async () => {
+      jest.useFakeTimers()
+      const promise = execute({
+        adapterConfig: { tool: "calc", command: "node", timeout_ms: 100 }
+      }, {}, {})
+
+      jest.advanceTimersByTime(101)
+
+      await expect(promise).rejects.toMatchObject({
+        message: expect.stringContaining("timed out after 100ms")
+      })
+      jest.useRealTimers()
+    })
+  })
+
+  describe("http source", () => {
+    test("successfully calls http mcp tool (direct url)", async () => {
+      global.fetch.mockResolvedValue({
+        ok: true,
+        json: () => Promise.resolve({ data: "ok" })
+      })
+
+      const result = await execute({
+        adapterConfig: { tool: "t1", url: "http://mcp.local" }
+      }, { arg1: "v1" }, {})
+
+      expect(global.fetch).toHaveBeenCalledWith(
+        "http://mcp.local/tool",
+        expect.objectContaining({
+          method: "POST",
+          body: JSON.stringify({ tool: "t1", input: { arg1: "v1" } })
+        })
+      )
+      expect(result).toEqual({ data: "ok" })
+    })
+
+    test("resolves server url from local context", async () => {
+      global.fetch.mockResolvedValue({
+        ok: true,
+        json: () => Promise.resolve({ ok: true })
+      })
+
+      const context = {
+        config: {
+          mcp_servers: [{ name: "s1", url: "http://server1" }]
+        }
+      }
+
+      await execute({
+        adapterConfig: { tool: "t1", server: "s1" }
+      }, {}, context)
+
+      expect(global.fetch).toHaveBeenCalledWith("http://server1/tool", expect.anything())
+    })
+
+    test("resolves server url from remote server", async () => {
+      global.fetch
+        .mockResolvedValueOnce({ // resolveHttpServerUrl fetch
+          ok: true,
+          json: () => Promise.resolve([{ name: "s2", url: "http://remote-s2" }])
+        })
+        .mockResolvedValueOnce({ // tool call fetch
+          ok: true,
+          json: () => Promise.resolve({ ok: true })
+        })
+
+      const context = { server: "http://api.test" }
+
+      await execute({
+        adapterConfig: { tool: "t1", server: "s2" }
+      }, {}, context)
+
+      expect(global.fetch).toHaveBeenCalledWith("http://api.test/api/mcp?format=json")
+      expect(global.fetch).toHaveBeenCalledWith("http://remote-s2/tool", expect.anything())
+    })
+
+    test("throws if server not found", async () => {
+      const context = { config: { mcp_servers: [] } }
+      await expect(execute({
+        adapterConfig: { tool: "t1", server: "missing" }
+      }, {}, context)).rejects.toThrow(/not found in local config/)
+    })
+
+    test("handles fetch remote mcp list failure", async () => {
+      global.fetch.mockResolvedValue({ ok: false, status: 500 })
+      const context = { server: "http://api.test" }
+
+      await expect(execute({
+        adapterConfig: { tool: "t1", server: "s1" }
+      }, {}, context)).rejects.toMatchObject({ code: 105 })
+    })
+
+    test("handles tool call failure", async () => {
+      global.fetch.mockResolvedValue({
+        ok: false,
+        status: 400,
+        text: () => Promise.resolve("bad tool")
+      })
+
+      await expect(execute({
+        adapterConfig: { tool: "t1", url: "http://u" }
+      }, {}, {})).rejects.toThrow(/MCP tool call failed: 400 bad tool/)
+    })
+  })
+})