superacli 1.0.1 → 1.1.2

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

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

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

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__/help-json.test.js

@@ -0,0 +1,19 @@
+const { buildCapabilities } = require("../cli/help-json")
+
+describe("help-json", () => {
+  test("includes plugins and hides sync when no server", () => {
+    const data = buildCapabilities({ commands: [] }, false)
+
+    expect(data.commands.plugins).toBeDefined()
+    expect(data.commands.sync).toBeUndefined()
+    expect(data.flags["--help-json"]).toBeDefined()
+  })
+
+  test("includes sync when server is available", () => {
+    const data = buildCapabilities({ commands: [{ namespace: "a" }] }, true)
+
+    expect(data.commands.sync).toBeDefined()
+    expect(data.total_commands).toBe(1)
+    expect(data.namespaces).toEqual(["a"])
+  })
+})

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