superacli 1.0.1 → 1.1.2

package/__tests__/config.test.js

@@ -0,0 +1,297 @@
+const fs = require("fs")
+const os = require("os")
+
+jest.mock("fs")
+jest.mock("os", () => ({
+  homedir: jest.fn(() => "/home/user")
+}))
+jest.mock("../cli/plugins-store")
+
+const {
+  loadConfig,
+  syncConfig,
+  showConfig,
+  setMcpServer,
+  removeMcpServer,
+  listMcpServers
+} = require("../cli/config")
+const { getInstalledPluginCommands, listInstalledPlugins } = require("../cli/plugins-store")
+
+global.fetch = jest.fn()
+
+describe("config", () => {
+  const mockHomedir = "/home/user"
+  const cacheDir = mockHomedir + "/.supercli"
+  const cacheFile = cacheDir + "/config.json"
+
+  beforeEach(() => {
+    jest.clearAllMocks()
+    os.homedir.mockReturnValue(mockHomedir)
+    getInstalledPluginCommands.mockReturnValue([])
+    listInstalledPlugins.mockReturnValue([])
+    jest.spyOn(Date, "now").mockReturnValue(1000000)
+  })
+
+  afterEach(() => {
+    jest.restoreAllMocks()
+  })
+
+  describe("loadConfig", () => {
+    test("returns empty config if no cache exists", async () => {
+      fs.existsSync.mockReturnValue(false)
+      const config = await loadConfig()
+      expect(config.version).toBe("1")
+      expect(config.commands).toEqual([])
+    })
+
+    test("returns cached config merged with plugin commands", async () => {
+      fs.existsSync.mockReturnValue(true)
+      fs.readFileSync.mockReturnValue(JSON.stringify({
+        version: "2",
+        commands: [{ id: "base" }]
+      }))
+      getInstalledPluginCommands.mockReturnValue([{ id: "plugin" }])
+
+      const config = await loadConfig()
+      expect(config.version).toBe("2")
+      expect(config.commands).toEqual([{ id: "base" }, { id: "plugin" }])
+    })
+
+    test("handles corrupted cache by returning empty config", async () => {
+      fs.existsSync.mockReturnValue(true)
+      fs.readFileSync.mockReturnValue("invalid-json")
+      const config = await loadConfig()
+      expect(config.commands).toEqual([])
+    })
+
+    test("handles cache with missing commands field", async () => {
+      fs.existsSync.mockReturnValue(true)
+      fs.readFileSync.mockReturnValue(JSON.stringify({ version: "2" }))
+      const config = await loadConfig()
+      expect(config.commands).toEqual([])
+    })
+  })
+
+  describe("syncConfig", () => {
+    test("fetches and writes cache", async () => {
+      fs.existsSync.mockReturnValue(false) // Trigger mkdirSync
+      const mockConfig = { version: "2", mcp_servers: [], specs: [], commands: [] }
+      global.fetch.mockResolvedValue({
+        ok: true,
+        json: () => Promise.resolve(mockConfig)
+      })
+
+      const result = await syncConfig("http://server")
+
+      expect(fs.mkdirSync).toHaveBeenCalledWith(cacheDir, { recursive: true })
+      expect(fs.writeFileSync).toHaveBeenCalledWith(
+        cacheFile,
+        expect.stringContaining('"version": "2"')
+      )
+      expect(result.version).toBe("2")
+      expect(result.fetchedAt).toBe(1000000)
+    })
+
+    test("throws if server not provided", async () => {
+      await expect(syncConfig()).rejects.toThrow("SUPERCLI_SERVER is not configured")
+    })
+
+    test("throws if fetch fails", async () => {
+      global.fetch.mockResolvedValue({ ok: false, status: 500, statusText: "Internal Error" })
+      await expect(syncConfig("http://server")).rejects.toThrow("Failed to fetch config: 500 Internal Error")
+    })
+
+    test("handles missing mcp_servers or specs in main response", async () => {
+      global.fetch
+        .mockResolvedValueOnce({
+          ok: true,
+          json: () => Promise.resolve({ version: "2" })
+        })
+        .mockResolvedValueOnce({
+          ok: true,
+          json: () => Promise.resolve([{ name: "mcp1" }])
+        })
+        .mockResolvedValueOnce({
+          ok: true,
+          json: () => Promise.resolve([{ name: "spec1" }])
+        })
+
+      const config = await syncConfig("http://server")
+      expect(config.mcp_servers).toEqual([{ name: "mcp1" }])
+      expect(config.specs).toEqual([{ name: "spec1" }])
+    })
+
+    test("handles non-ok response from secondary fetches", async () => {
+      global.fetch
+        .mockResolvedValueOnce({
+          ok: true,
+          json: () => Promise.resolve({ version: "2" })
+        })
+        .mockResolvedValueOnce({ ok: false })
+        .mockResolvedValueOnce({ ok: false })
+
+      const config = await syncConfig("http://server")
+      expect(config.mcp_servers).toEqual([])
+      expect(config.specs).toEqual([])
+    })
+
+    test("handles network errors in secondary mcp/specs fetches", async () => {
+      global.fetch
+        .mockResolvedValueOnce({
+          ok: true,
+          json: () => Promise.resolve({ version: "2" })
+        })
+        .mockRejectedValueOnce(new Error("network error"))
+        .mockRejectedValueOnce(new Error("network error"))
+
+      const config = await syncConfig("http://server")
+      expect(config.mcp_servers).toEqual([])
+      expect(config.specs).toEqual([])
+    })
+
+    test("ensures commands is an array if missing", async () => {
+      global.fetch.mockResolvedValue({
+        ok: true,
+        json: () => Promise.resolve({ version: "2", mcp_servers: [], specs: [] })
+      })
+      const config = await syncConfig("http://server")
+      expect(config.commands).toEqual([])
+    })
+  })
+
+  describe("MCP Server management", () => {
+    test("setMcpServer adds new server to empty config", async () => {
+      fs.existsSync.mockReturnValue(false)
+      await setMcpServer("new", "http://new")
+      
+      const lastWrite = JSON.parse(fs.writeFileSync.mock.calls[0][1])
+      expect(lastWrite.mcp_servers).toContainEqual({ name: "new", url: "http://new" })
+    })
+
+    test("setMcpServer updates existing server and sorts correctly", async () => {
+      fs.existsSync.mockReturnValue(true)
+      fs.readFileSync.mockReturnValue(JSON.stringify({
+        mcp_servers: [
+          { name: "z", url: "http://z" },
+          { name: "m", url: "http://m" },
+          { name: "a", url: "http://a" }
+        ]
+      }))
+      
+      await setMcpServer("m", "http://updated")
+      
+      const lastWrite = JSON.parse(fs.writeFileSync.mock.calls[0][1])
+      expect(lastWrite.mcp_servers.map(s => s.name)).toEqual(["a", "m", "z"])
+    })
+
+    test("setMcpServer handles config without mcp_servers array", async () => {
+      fs.existsSync.mockReturnValue(true)
+      fs.readFileSync.mockReturnValue(JSON.stringify({ version: "1" }))
+      await setMcpServer("s1", "u1")
+      const lastWrite = JSON.parse(fs.writeFileSync.mock.calls[0][1])
+      expect(lastWrite.mcp_servers).toEqual([{ name: "s1", url: "u1" }])
+    })
+
+    test("removeMcpServer removes existing server", async () => {
+      fs.existsSync.mockReturnValue(true)
+      fs.readFileSync.mockReturnValue(JSON.stringify({
+        mcp_servers: [{ name: "target", url: "http://target" }, { name: "other" }]
+      }))
+
+      const removed = await removeMcpServer("target")
+      expect(removed).toBe(true)
+      
+      const lastWrite = JSON.parse(fs.writeFileSync.mock.calls[0][1])
+      expect(lastWrite.mcp_servers).toHaveLength(1)
+      expect(lastWrite.mcp_servers[0].name).toBe("other")
+    })
+
+    test("removeMcpServer returns false if not found", async () => {
+      fs.existsSync.mockReturnValue(true)
+      fs.readFileSync.mockReturnValue(JSON.stringify({
+        mcp_servers: [{ name: "other" }]
+      }))
+      const removed = await removeMcpServer("missing")
+      expect(removed).toBe(false)
+    })
+
+    test("removeMcpServer handles empty config", async () => {
+      fs.existsSync.mockReturnValue(false)
+      const removed = await removeMcpServer("any")
+      expect(removed).toBe(false)
+    })
+
+    test("listMcpServers returns servers from config", async () => {
+      fs.existsSync.mockReturnValue(true)
+      fs.readFileSync.mockReturnValue(JSON.stringify({
+        mcp_servers: [{ name: "s1" }]
+      }))
+      const servers = await listMcpServers()
+      expect(servers).toEqual([{ name: "s1" }])
+    })
+
+    test("listMcpServers returns empty array if field missing", async () => {
+      fs.existsSync.mockReturnValue(true)
+      fs.readFileSync.mockReturnValue(JSON.stringify({ version: "1" }))
+      const servers = await listMcpServers()
+      expect(servers).toEqual([])
+    })
+
+    test("handles null or invalid items in mcp_servers array", async () => {
+      fs.existsSync.mockReturnValue(true)
+      fs.readFileSync.mockReturnValue(JSON.stringify({
+        mcp_servers: [null, { name: 123 }, { name: "z" }]
+      }))
+      
+      await setMcpServer("a", "http://a")
+      const lastWrite = JSON.parse(fs.writeFileSync.mock.calls[0][1])
+      expect(lastWrite.mcp_servers.some(s => s && s.name === "a")).toBe(true)
+      expect(lastWrite.mcp_servers.find(s => s && s.name === 123)).toBeUndefined()
+      
+      const removed = await removeMcpServer("z")
+      expect(removed).toBe(true)
+    })
+  })
+
+  describe("showConfig", () => {
+    test("returns message if no cache", async () => {
+      fs.existsSync.mockReturnValue(false)
+      const result = await showConfig()
+      expect(result.cached).toBe(false)
+      expect(result.message).toContain("No config cached")
+    })
+
+    test("returns summary of cached config", async () => {
+      fs.existsSync.mockReturnValue(true)
+      fs.readFileSync.mockReturnValue(JSON.stringify({
+        version: "1.0",
+        ttl: 3600,
+        fetchedAt: 1000000,
+        commands: [1, 2],
+        mcp_servers: [1],
+        specs: [1, 2, 3]
+      }))
+      listInstalledPlugins.mockReturnValue([1, 2, 3, 4])
+
+      const result = await showConfig()
+      expect(result.version).toBe("1.0")
+      expect(result.commands).toBe(2)
+      expect(result.plugins).toBe(4)
+      expect(result.mcp_servers).toBe(1)
+      expect(result.specs).toBe(3)
+      expect(result.cacheFile).toBe(cacheFile)
+    })
+
+    test("handles cached config with missing fields in showConfig", async () => {
+      fs.existsSync.mockReturnValue(true)
+      fs.readFileSync.mockReturnValue(JSON.stringify({
+        version: "1.0",
+        fetchedAt: 1000000
+      }))
+      const result = await showConfig()
+      expect(result.commands).toBe(0)
+      expect(result.mcp_servers).toBe(0)
+      expect(result.specs).toBe(0)
+    })
+  })
+})

package/__tests__/docker-plugin.test.js

@@ -0,0 +1,95 @@
+const fs = require("fs")
+const os = require("os")
+const path = require("path")
+const { execSync, spawnSync } = 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 writeFakeDockerBinary(dir) {
+  const bin = path.join(dir, "docker")
+  fs.writeFileSync(bin, [
+    "#!/usr/bin/env node",
+    "const args = process.argv.slice(2);",
+    "if (args.includes('--version')) { console.log('Docker version 26.1.0, build test'); process.exit(0); }",
+    "console.log(JSON.stringify({ ok: true, args }));"
+  ].join("\n"), "utf-8")
+  fs.chmodSync(bin, 0o755)
+  return bin
+}
+
+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 || ""}`, SUPERCLI_HOME: tempHome }
+
+  beforeAll(() => {
+    runNoServer("plugins install ./plugins/docker --on-conflict replace --json", { env })
+  })
+
+  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", () => {
+    const r = runNoServer("docker container ls --json", { env })
+    expect(r.ok).toBe(true)
+    const data = JSON.parse(r.output)
+    expect(data.command).toBe("docker.container.ls")
+    expect(data.data.args[0]).toBe("ps")
+  })
+
+  test("maps docker run args and flags", () => {
+    const r = runNoServer("docker container run --image nginx:latest --detach --publish 8080:80 --volume /tmp:/tmp --env A=B --name demo --json", { env })
+    expect(r.ok).toBe(true)
+    const data = JSON.parse(r.output)
+    expect(data.command).toBe("docker.container.run")
+    expect(data.data.args[0]).toBe("run")
+    expect(data.data.args).toContain("nginx:latest")
+    expect(data.data.args).toContain("--detach")
+    expect(data.data.args).toContain("--publish")
+    expect(data.data.args).toContain("8080:80")
+    expect(data.data.args).toContain("--env")
+    expect(data.data.args).toContain("A=B")
+  })
+
+  test("rejects interactive flags in non-tty mode", () => {
+    const r = runNoServer("docker container run --image nginx:latest --interactive --json", { env })
+    expect(r.ok).toBe(false)
+    expect(r.code).toBe(91)
+    const payload = JSON.parse(r.output)
+    expect(payload.error.type).toBe("safety_violation")
+  })
+
+  test("can call real docker system version if installed", () => {
+    const whichDocker = spawnSync("which", ["docker"], { encoding: "utf-8", timeout: 3000 })
+    if (whichDocker.status !== 0) return
+
+    const r = runNoServer("docker system version --json")
+    expect(r.ok).toBe(true)
+    const data = JSON.parse(r.output)
+    expect(data.command).toBe("docker.system.version")
+  })
+})

package/__tests__/executor.test.js

@@ -0,0 +1,303 @@
+const { execute } = require("../cli/executor")
+const { validateAdapterConfig } = require("../cli/adapter-schema")
+const path = require("path")
+
+jest.mock("../cli/adapter-schema")
+
+// Mock adapters
+const mockAdapters = {
+  process: { execute: jest.fn() },
+  builtin: { execute: jest.fn() },
+  shell: { execute: jest.fn() },
+  http: { execute: jest.fn() },
+  mcp: { execute: jest.fn() },
+  openapi: { execute: jest.fn() }
+}
+
+jest.mock("../cli/adapters/process", () => mockAdapters.process, { virtual: true })
+jest.mock("../cli/adapters/builtin", () => mockAdapters.builtin, { virtual: true })
+jest.mock("../cli/adapters/shell", () => mockAdapters.shell, { virtual: true })
+jest.mock("../cli/adapters/http", () => mockAdapters.http, { virtual: true })
+jest.mock("../cli/adapters/mcp", () => mockAdapters.mcp, { virtual: true })
+jest.mock("../cli/adapters/openapi", () => mockAdapters.openapi, { virtual: true })
+
+global.fetch = jest.fn()
+
+describe("executor", () => {
+  beforeEach(() => {
+    jest.clearAllMocks()
+  })
+
+  test("executes basic command through adapter", async () => {
+    const cmd = { adapter: "process", namespace: "test", resource: "res", action: "act" }
+    const flags = { foo: "bar" }
+    const context = {}
+    
+    mockAdapters.process.execute.mockResolvedValue({ ok: true })
+    
+    const result = await execute(cmd, flags, context)
+    
+    expect(validateAdapterConfig).toHaveBeenCalledWith(cmd)
+    expect(mockAdapters.process.execute).toHaveBeenCalledWith(cmd, flags, context)
+    expect(result).toEqual({ ok: true })
+  })
+
+  test("throws error for unknown adapter", async () => {
+    const cmd = { adapter: "nonexistent", namespace: "test", resource: "res", action: "act" }
+    
+    await expect(execute(cmd, {}, {})).rejects.toMatchObject({
+      code: 110,
+      type: "internal_error"
+    })
+  })
+
+  test("executes workflow with multiple steps", async () => {
+    const workflow = {
+      type: "workflow",
+      namespace: "wf",
+      resource: "res",
+      action: "act",
+      steps: [
+        "ns1.res1.act1",
+        { command: "ns2.res2.act2", args: { extra: "val" } }
+      ]
+    }
+    
+    const context = {
+      config: {
+        commands: [
+          { namespace: "ns1", resource: "res1", action: "act1", adapter: "process" },
+          { namespace: "ns2", resource: "res2", action: "act2", adapter: "builtin" }
+        ]
+      }
+    }
+
+    mockAdapters.process.execute.mockResolvedValue({ data: "result1" })
+    mockAdapters.builtin.execute.mockResolvedValue({ data: "result2" })
+
+    const result = await execute(workflow, { initial: "flag" }, context)
+
+    expect(result.steps).toHaveLength(2)
+    expect(result.steps[0].result).toEqual({ data: "result1" })
+    expect(result.steps[1].result).toEqual({ data: "result2" })
+    
+    // Verify data piping and merging
+    expect(mockAdapters.builtin.execute).toHaveBeenCalledWith(
+      expect.objectContaining({ namespace: "ns2" }),
+      expect.objectContaining({ initial: "flag", extra: "val", data: "result1" }),
+      context
+    )
+  })
+
+  test("handles workflow step template replacement", async () => {
+    const workflow = {
+      type: "workflow",
+      steps: [
+        { command: "ns.res.act1", args: { name: "initial" } },
+        { command: "ns.res.act2", args: { greeting: "Hello {{args.user}}", info: "Last was {{step.0.result.data}}" } }
+      ]
+    }
+    
+    const context = {
+      config: {
+        commands: [
+          { namespace: "ns", resource: "res", action: "act1", adapter: "builtin" },
+          { namespace: "ns", resource: "res", action: "act2", adapter: "builtin" }
+        ]
+      }
+    }
+
+    mockAdapters.builtin.execute
+      .mockResolvedValueOnce({ data: "first-result" })
+      .mockResolvedValueOnce({ data: "second-result" })
+
+    await execute(workflow, { user: "Alice" }, context)
+
+    expect(mockAdapters.builtin.execute).toHaveBeenLastCalledWith(
+      expect.anything(),
+      expect.objectContaining({
+        greeting: "Hello Alice",
+        info: "Last was first-result"
+      }),
+      expect.anything()
+    )
+  })
+
+  test("handles workflow template replacement with invalid path", async () => {
+    const workflow = {
+      type: "workflow",
+      steps: [
+        { command: "ns.res.act1", args: { name: "initial" } },
+        { command: "ns.res.act2", args: { info: "Val is {{step.0.result.nonexistent}}" } }
+      ]
+    }
+    
+    const context = {
+      config: {
+        commands: [
+          { namespace: "ns", resource: "res", action: "act1", adapter: "builtin" },
+          { namespace: "ns", resource: "res", action: "act2", adapter: "builtin" }
+        ]
+      }
+    }
+
+    mockAdapters.builtin.execute
+      .mockResolvedValueOnce({ data: "result" })
+      .mockResolvedValueOnce({ ok: true })
+
+    await execute(workflow, {}, context)
+
+    expect(mockAdapters.builtin.execute).toHaveBeenLastCalledWith(
+      expect.anything(),
+      expect.objectContaining({
+        info: "Val is "
+      }),
+      expect.anything()
+    )
+  })
+
+  test("handles workflow template replacement with missing step", async () => {
+    const workflow = {
+      type: "workflow",
+      steps: [
+        { command: "ns.res.act", args: { info: "Val is {{step.5.result.data}}" } }
+      ]
+    }
+    
+    const context = {
+      config: {
+        commands: [
+          { namespace: "ns", resource: "res", action: "act", adapter: "builtin" }
+        ]
+      }
+    }
+
+    mockAdapters.builtin.execute.mockResolvedValue({ ok: true })
+
+    await execute(workflow, {}, context)
+
+    expect(mockAdapters.builtin.execute).toHaveBeenCalledWith(
+      expect.anything(),
+      expect.objectContaining({
+        info: "Val is "
+      }),
+      expect.anything()
+    )
+  })
+
+  test("handles workflow template replacement when value is not an object", async () => {
+    const workflow = {
+      type: "workflow",
+      steps: [
+        { command: "ns.res.act1", args: { name: "initial" } },
+        { command: "ns.res.act2", args: { info: "Val is {{step.0.result.data.sub}}" } }
+      ]
+    }
+    
+    const context = {
+      config: {
+        commands: [
+          { namespace: "ns", resource: "res", action: "act1", adapter: "builtin" },
+          { namespace: "ns", resource: "res", action: "act2", adapter: "builtin" }
+        ]
+      }
+    }
+
+    // result.data is a string, not an object, so data.sub should hit line 108
+    mockAdapters.builtin.execute
+      .mockResolvedValueOnce({ data: "not-an-object" })
+      .mockResolvedValueOnce({ ok: true })
+
+    await execute(workflow, {}, context)
+
+    expect(mockAdapters.builtin.execute).toHaveBeenLastCalledWith(
+      expect.anything(),
+      expect.objectContaining({
+        info: "Val is "
+      }),
+      expect.anything()
+    )
+  })
+
+  test("handles custom adapter loading", async () => {
+    const cmd = { adapter: "custom-adapter", namespace: "test", resource: "res", action: "act" }
+    const mockCustom = { execute: jest.fn().mockResolvedValue({ ok: true }) }
+    
+    // We need to mock path.resolve and require
+    // Actually, we can just mock the whole custom adapter path
+    jest.doMock(path.resolve("adapters", "custom-adapter"), () => mockCustom, { virtual: true })
+    
+    const result = await execute(cmd, {}, {})
+    expect(result).toEqual({ ok: true })
+    expect(mockCustom.execute).toHaveBeenCalled()
+  })
+
+  test("fetches missing command from server during workflow", async () => {
+    const workflow = {
+      type: "workflow",
+      steps: ["remote.res.act"]
+    }
+    
+    const context = {
+      server: "http://api.test",
+      config: { commands: [] }
+    }
+
+    const remoteCmd = { namespace: "remote", resource: "res", action: "act", adapter: "shell" }
+    
+    global.fetch.mockResolvedValue({
+      ok: true,
+      json: () => Promise.resolve(remoteCmd)
+    })
+    
+    mockAdapters.shell.execute.mockResolvedValue({ ok: true })
+
+    await execute(workflow, {}, context)
+
+    expect(global.fetch).toHaveBeenCalledWith("http://api.test/api/command/remote/res/act")
+    expect(mockAdapters.shell.execute).toHaveBeenCalledWith(remoteCmd, expect.anything(), context)
+  })
+
+  test("throws error if workflow step is invalid", async () => {
+    const workflow = {
+      type: "workflow",
+      steps: ["invalid-step"]
+    }
+    
+    await expect(execute(workflow, {}, {})).rejects.toMatchObject({
+      code: 85,
+      type: "invalid_argument"
+    })
+  })
+
+  test("throws error if command not found and no server", async () => {
+    const workflow = {
+      type: "workflow",
+      steps: ["missing.ns.act"]
+    }
+    
+    await expect(execute(workflow, {}, { config: { commands: [] } })).rejects.toMatchObject({
+      code: 92,
+      type: "resource_not_found"
+    })
+  })
+  
+  test("throws error if server fetch fails", async () => {
+    const workflow = {
+      type: "workflow",
+      steps: ["remote.res.act"]
+    }
+    
+    const context = {
+      server: "http://api.test",
+      config: { commands: [] }
+    }
+
+    global.fetch.mockResolvedValue({ ok: false })
+
+    await expect(execute(workflow, {}, context)).rejects.toMatchObject({
+      code: 92,
+      type: "resource_not_found"
+    })
+  })
+})