superacli 1.0.1 → 1.1.2

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

package/__tests__/mcp-local.test.js

@@ -0,0 +1,105 @@
+const { handleMcpRegistryCommand } = require("../cli/mcp-local");
+
+describe("mcp-local", () => {
+  let mockOutput, mockOutputHumanTable, mockOutputError;
+  let mockSetMcpServer, mockRemoveMcpServer, mockListMcpServers;
+
+  beforeEach(() => {
+    mockOutput = jest.fn();
+    mockOutputHumanTable = jest.fn();
+    mockOutputError = jest.fn();
+    mockSetMcpServer = jest.fn();
+    mockRemoveMcpServer = jest.fn();
+    mockListMcpServers = jest.fn();
+  });
+
+  test("list subcommand", async () => {
+    const servers = [{ name: "s1", url: "u1" }];
+    mockListMcpServers.mockResolvedValue(servers);
+
+    await handleMcpRegistryCommand({
+      positional: ["mcp", "list"],
+      humanMode: false,
+      output: mockOutput,
+      listMcpServers: mockListMcpServers,
+    });
+
+    expect(mockListMcpServers).toHaveBeenCalled();
+    expect(mockOutput).toHaveBeenCalledWith({ mcp_servers: servers });
+  });
+
+  test("list subcommand in human mode", async () => {
+    const servers = [{ name: "s1", url: "u1" }];
+    mockListMcpServers.mockResolvedValue(servers);
+    const consoleSpy = jest.spyOn(console, "log").mockImplementation();
+
+    await handleMcpRegistryCommand({
+      positional: ["mcp", "list"],
+      humanMode: true,
+      outputHumanTable: mockOutputHumanTable,
+      listMcpServers: mockListMcpServers,
+    });
+
+    expect(mockOutputHumanTable).toHaveBeenCalled();
+    consoleSpy.mockRestore();
+  });
+
+  test("add subcommand", async () => {
+    await handleMcpRegistryCommand({
+      positional: ["mcp", "add", "s1"],
+      flags: { url: "u1" },
+      output: mockOutput,
+      setMcpServer: mockSetMcpServer,
+    });
+
+    expect(mockSetMcpServer).toHaveBeenCalledWith("s1", "u1");
+    expect(mockOutput).toHaveBeenCalledWith(
+      expect.objectContaining({ ok: true }),
+    );
+  });
+
+  test("add subcommand validation error", async () => {
+    await handleMcpRegistryCommand({
+      positional: ["mcp", "add"],
+      flags: {},
+      outputError: mockOutputError,
+    });
+
+    expect(mockOutputError).toHaveBeenCalledWith(
+      expect.objectContaining({ code: 85 }),
+    );
+  });
+
+  test("remove subcommand", async () => {
+    mockRemoveMcpServer.mockResolvedValue(true);
+
+    await handleMcpRegistryCommand({
+      positional: ["mcp", "remove", "s1"],
+      output: mockOutput,
+      removeMcpServer: mockRemoveMcpServer,
+    });
+
+    expect(mockRemoveMcpServer).toHaveBeenCalledWith("s1");
+    expect(mockOutput).toHaveBeenCalledWith({ ok: true, removed: true });
+  });
+
+  test("remove subcommand validation error", async () => {
+    await handleMcpRegistryCommand({
+      positional: ["mcp", "remove"],
+      outputError: mockOutputError,
+    });
+
+    expect(mockOutputError).toHaveBeenCalled();
+  });
+
+  test("unknown subcommand", async () => {
+    await handleMcpRegistryCommand({
+      positional: ["mcp", "unknown"],
+      outputError: mockOutputError,
+    });
+
+    expect(mockOutputError).toHaveBeenCalledWith(
+      expect.objectContaining({ code: 85 }),
+    );
+  });
+});

package/__tests__/namespace-passthrough.test.js

@@ -0,0 +1,69 @@
+const { findNamespacePassthrough } = require("../cli/namespace-passthrough");
+
+describe("namespace-passthrough", () => {
+  const mockConfig = {
+    commands: [
+      {
+        namespace: "test",
+        resource: "res",
+        action: "act",
+      },
+      {
+        namespace: "pass",
+        adapterConfig: { passthrough: true },
+      },
+    ],
+  };
+
+  test("returns null if no namespace", () => {
+    expect(findNamespacePassthrough(mockConfig, [], [])).toBeNull();
+  });
+
+  test("returns null if config missing", () => {
+    expect(findNamespacePassthrough(null, ["pass"], ["pass"])).toBeNull();
+  });
+
+  test("returns null if not a passthrough namespace", () => {
+    expect(findNamespacePassthrough(mockConfig, ["test"], ["test"])).toBeNull();
+  });
+
+  test("returns passthrough result if namespace matches and no exact command", () => {
+    const result = findNamespacePassthrough(
+      mockConfig,
+      ["pass"],
+      ["pass", "arg1", "arg2"],
+    );
+    expect(result).toMatchObject({
+      namespace: "pass",
+      passthroughArgs: ["arg1", "arg2"],
+    });
+  });
+
+  test("returns null if exact command exists", () => {
+    const configWithExact = {
+      commands: [
+        {
+          namespace: "pass",
+          adapterConfig: { passthrough: true },
+        },
+        {
+          namespace: "pass",
+          resource: "res",
+          action: "act",
+        },
+      ],
+    };
+    expect(
+      findNamespacePassthrough(
+        configWithExact,
+        ["pass"],
+        ["pass", "res", "act"],
+      ),
+    ).toBeNull();
+  });
+
+  test("handles rawArgs where namespace index is -1", () => {
+    const result = findNamespacePassthrough(mockConfig, ["pass"], ["other"]);
+    expect(result.passthroughArgs).toEqual([]);
+  });
+});

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