superacli 1.1.0 → 1.1.2

package/__tests__/server-storage-file.test.js

@@ -0,0 +1,73 @@
+const fs = require("fs").promises
+const path = require("path")
+const FileAdapter = require("../server/storage/file")
+
+jest.mock("fs", () => ({
+  promises: {
+    readFile: jest.fn(),
+    writeFile: jest.fn(),
+    unlink: jest.fn(),
+    readdir: jest.fn(),
+    mkdir: jest.fn()
+  },
+  existsSync: jest.fn()
+}))
+const fsMock = require("fs")
+
+describe("FileAdapter", () => {
+  const baseDir = "/tmp/storage"
+  let adapter
+
+  beforeEach(() => {
+    jest.clearAllMocks()
+    adapter = new FileAdapter(baseDir)
+  })
+
+  test("get returns parsed JSON", async () => {
+    fs.readFile.mockResolvedValue('{"a": 1}')
+    const result = await adapter.get("mykey")
+    expect(result).toEqual({ a: 1 })
+    expect(fs.readFile).toHaveBeenCalledWith(expect.stringContaining("mykey.json"), "utf-8")
+  })
+
+  test("get returns null on ENOENT", async () => {
+    fs.readFile.mockRejectedValue({ code: "ENOENT" })
+    expect(await adapter.get("missing")).toBeNull()
+  })
+
+  test("get throws other errors", async () => {
+    fs.readFile.mockRejectedValue(new Error("crash"))
+    await expect(adapter.get("err")).rejects.toThrow("crash")
+  })
+
+  test("set creates dir and writes file", async () => {
+    await adapter.set("key", { x: 1 })
+    expect(fs.mkdir).toHaveBeenCalledWith(baseDir, { recursive: true })
+    expect(fs.writeFile).toHaveBeenCalledWith(
+      expect.stringContaining("key.json"),
+      expect.stringContaining('"x": 1'),
+      "utf-8"
+    )
+  })
+
+  test("delete unlinks file", async () => {
+    await adapter.delete("key")
+    expect(fs.unlink).toHaveBeenCalled()
+  })
+
+  test("delete ignores ENOENT", async () => {
+    fs.unlink.mockRejectedValue({ code: "ENOENT" })
+    await expect(adapter.delete("key")).resolves.not.toThrow()
+  })
+
+  test("listKeys filters and maps files", async () => {
+    fs.readdir.mockResolvedValue(["abc_1.json", "abc_2.json", "other.json", "abc_3.txt"])
+    const keys = await adapter.listKeys("abc")
+    expect(keys).toEqual(["abc_1", "abc_2"])
+  })
+
+  test("listKeys returns empty on ENOENT", async () => {
+    fs.readdir.mockRejectedValue({ code: "ENOENT" })
+    expect(await adapter.listKeys()).toEqual([])
+  })
+})

package/__tests__/server-storage-mongo.test.js

@@ -0,0 +1,74 @@
+const MongoAdapter = require("../server/storage/mongo")
+const { MongoClient } = require("mongodb")
+
+jest.mock("mongodb")
+
+describe("MongoAdapter", () => {
+  let adapter
+  let mockCollection
+  let mockDb
+  let mockClient
+
+  beforeEach(() => {
+    jest.clearAllMocks()
+    mockCollection = {
+      findOne: jest.fn(),
+      updateOne: jest.fn(),
+      deleteOne: jest.fn(),
+      find: jest.fn().mockReturnThis(),
+      toArray: jest.fn()
+    }
+    mockDb = {
+      collection: jest.fn().mockReturnValue(mockCollection)
+    }
+    mockClient = {
+      connect: jest.fn().mockResolvedValue({}),
+      db: jest.fn().mockReturnValue(mockDb)
+    }
+    MongoClient.mockImplementation(() => mockClient)
+
+    adapter = new MongoAdapter("mongodb://uri")
+  })
+
+  test("get returns value field", async () => {
+    mockCollection.findOne.mockResolvedValue({ _id: "k", value: { x: 1 } })
+    const result = await adapter.get("k")
+    expect(result).toEqual({ x: 1 })
+    expect(mockCollection.findOne).toHaveBeenCalledWith({ _id: "k" })
+  })
+
+  test("get returns null if doc missing", async () => {
+    mockCollection.findOne.mockResolvedValue(null)
+    expect(await adapter.get("k")).toBeNull()
+  })
+
+  test("set updates with upsert", async () => {
+    await adapter.set("k", { y: 2 })
+    expect(mockCollection.updateOne).toHaveBeenCalledWith(
+      { _id: "k" },
+      { $set: { value: { y: 2 } } },
+      { upsert: true }
+    )
+  })
+
+  test("delete removes by _id", async () => {
+    await adapter.delete("k")
+    expect(mockCollection.deleteOne).toHaveBeenCalledWith({ _id: "k" })
+  })
+
+  test("listKeys uses regex and maps ids", async () => {
+    mockCollection.toArray.mockResolvedValue([{ _id: "pre:1" }, { _id: "pre:2" }])
+    const keys = await adapter.listKeys("pre:")
+    expect(keys).toEqual(["pre:1", "pre:2"])
+    expect(mockCollection.find).toHaveBeenCalledWith(
+      { _id: { $regex: "^pre:" } },
+      { projection: { _id: 1 } }
+    )
+  })
+
+  test("listKeys without prefix", async () => {
+    mockCollection.toArray.mockResolvedValue([])
+    await adapter.listKeys()
+    expect(mockCollection.find).toHaveBeenCalledWith({}, expect.anything())
+  })
+})

package/__tests__/shell-adapter.test.js

@@ -1,31 +1,90 @@
 const { execute } = require("../cli/adapters/shell")
+const { spawn } = require("child_process")
+const EventEmitter = require("events")
+
+jest.mock("child_process")
 
 describe("shell adapter", () => {
-  test("executes script and parses json", async () => {
-    const result = await execute({
-      adapterConfig: {
-        shell: "bash",
-        unsafe: true,
-        script: "printf '{\"ok\":true,\"msg\":\"{{text}}\"}'",
-        parseJson: true,
-        timeout_ms: 1000
-      }
-    }, { text: "hello" })
-
-    expect(result).toEqual({ ok: true, msg: "hello" })
+  let mockChild
+
+  beforeEach(() => {
+    jest.clearAllMocks()
+    mockChild = new EventEmitter()
+    mockChild.stdout = new EventEmitter()
+    mockChild.stdout.setEncoding = jest.fn()
+    mockChild.stderr = new EventEmitter()
+    mockChild.stderr.setEncoding = jest.fn()
+    mockChild.kill = jest.fn()
+    spawn.mockReturnValue(mockChild)
+  })
+
+  test("interpolates script and executes", async () => {
+    const promise = execute({
+      adapterConfig: { script: "echo {{name}}", parseJson: false }
+    }, { name: 'world"quoted' })
+
+    mockChild.stdout.emit("data", "hello world\\\"quoted")
+    mockChild.emit("close", 0)
+
+    const result = await promise
+    expect(result).toEqual({ raw: "hello world\\\"quoted" })
+    expect(spawn).toHaveBeenCalledWith("bash", ["-lc", "echo world\\\"quoted"], expect.anything())
+  })
+
+  test("handles JSON parsing", async () => {
+    const promise = execute({
+      adapterConfig: { script: "echo '{\"ok\":true}'" }
+    }, {})
+
+    mockChild.stdout.emit("data", '{"ok":true}')
+    mockChild.emit("close", 0)
+
+    const result = await promise
+    expect(result).toEqual({ ok: true })
   })
 
-  test("returns raw text when parseJson is false", async () => {
-    const result = await execute({
-      adapterConfig: {
-        shell: "bash",
-        unsafe: true,
-        script: "printf 'plain-output'",
-        parseJson: false,
-        timeout_ms: 1000
-      }
+  test("handles non-JSON when parseJson is true", async () => {
+    const promise = execute({
+      adapterConfig: { script: "echo not-json" }
     }, {})
 
-    expect(result).toEqual({ raw: "plain-output" })
+    mockChild.stdout.emit("data", "not-json")
+    mockChild.emit("close", 0)
+
+    const result = await promise
+    expect(result).toEqual({ raw: "not-json" })
+  })
+
+  test("handles timeout", async () => {
+    jest.useFakeTimers()
+    const promise = execute({
+      adapterConfig: { script: "sleep 10", timeout_ms: 100 }
+    }, {})
+
+    jest.advanceTimersByTime(200)
+
+    await expect(promise).rejects.toThrow(/timed out after 100ms/)
+    jest.useRealTimers()
+  })
+
+  test("handles spawn error", async () => {
+    const promise = execute({
+      adapterConfig: { script: "fail" }
+    }, {})
+
+    mockChild.emit("error", new Error("spawn fail"))
+
+    await expect(promise).rejects.toThrow("Failed to start shell adapter")
+  })
+
+  test("handles non-zero exit", async () => {
+    const promise = execute({
+      adapterConfig: { script: "exit 1" }
+    }, {})
+
+    mockChild.stderr.emit("data", "error details")
+    mockChild.emit("close", 1)
+
+    await expect(promise).rejects.toThrow(/Shell adapter failed.*error details/)
   })
 })

package/__tests__/stripe-plugin.test.js

@@ -39,8 +39,9 @@ function writeFakeStripeBinary(dir) {
 
 describe("stripe plugin", () => {
   const fakeDir = fs.mkdtempSync(path.join(os.tmpdir(), "dcli-stripe-"))
+  const tempHome = fs.mkdtempSync(path.join(os.tmpdir(), "dcli-home-stripe-"))
   writeFakeStripeBinary(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/stripe --on-conflict replace --json", { env })
@@ -49,6 +50,7 @@ describe("stripe plugin", () => {
   afterAll(() => {
     runNoServer("plugins remove stripe --json", { env })
     fs.rmSync(fakeDir, { recursive: true, force: true })
+    fs.rmSync(tempHome, { recursive: true, force: true })
   })
 
   test("routes customers list command", () => {

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

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

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

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