superacli 1.0.1 → 1.1.2

package/__tests__/stripe-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 writeFakeStripeBinary(dir) {
+  const bin = path.join(dir, "stripe")
+  fs.writeFileSync(bin, [
+    "#!/usr/bin/env node",
+    "const args = process.argv.slice(2);",
+    "if (args.includes('--version')) { console.log('stripe version 1.21.0'); process.exit(0); }",
+    "console.log(JSON.stringify({ ok: true, args }));"
+  ].join("\n"), "utf-8")
+  fs.chmodSync(bin, 0o755)
+  return bin
+}
+
+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 || ""}`, SUPERCLI_HOME: tempHome }
+
+  beforeAll(() => {
+    runNoServer("plugins install ./plugins/stripe --on-conflict replace --json", { env })
+  })
+
+  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", () => {
+    const r = runNoServer("stripe customers list --limit 3 --json", { env })
+    expect(r.ok).toBe(true)
+    const data = JSON.parse(r.output)
+    expect(data.command).toBe("stripe.customers.list")
+    expect(data.data.args).toEqual(["customers", "list", "--limit", "3"])
+  })
+
+  test("supports namespace passthrough", () => {
+    const r = runNoServer("stripe trigger payment_intent.succeeded --json", { env })
+    expect(r.ok).toBe(true)
+    const data = JSON.parse(r.output)
+    expect(data.command).toBe("stripe.passthrough")
+    expect(data.data.args[0]).toBe("trigger")
+    expect(data.data.args[1]).toBe("payment_intent.succeeded")
+    expect(data.data.args).toContain("--json")
+  })
+
+  test("doctor reports stripe dependency as healthy", () => {
+    const r = runNoServer("plugins doctor stripe --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 === "stripe" && c.ok === true)).toBe(true)
+  })
+})

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

package/__tests__/watchexec-plugin.test.js

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

package/cli/adapter-schema.js

@@ -0,0 +1,108 @@
+const SUPPORTED_ADAPTERS = ["http", "openapi", "mcp", "process", "builtin", "shell"]
+
+function asInvalid(message, suggestions = []) {
+  return Object.assign(new Error(message), {
+    code: 85,
+    type: "invalid_argument",
+    recoverable: false,
+    suggestions
+  })
+}
+
+function assertType(value, expected, field) {
+  if (value === undefined || value === null) return
+  if (typeof value !== expected) throw asInvalid(`adapterConfig.${field} must be ${expected}`)
+}
+
+function validateCommonConfig(adapterName, config) {
+  if (!config || typeof config !== "object") throw asInvalid(`Adapter '${adapterName}' requires adapterConfig object`)
+
+  assertType(config.parseJson, "boolean", "parseJson")
+  assertType(config.unsafe, "boolean", "unsafe")
+  assertType(config.non_interactive, "boolean", "non_interactive")
+  assertType(config.cwd, "string", "cwd")
+  assertType(config.safetyLevel, "string", "safetyLevel")
+  assertType(config.stream, "string", "stream")
+  if (config.interactiveFlags !== undefined && !Array.isArray(config.interactiveFlags)) {
+    throw asInvalid("adapterConfig.interactiveFlags must be an array")
+  }
+  assertType(config.requiresInteractive, "boolean", "requiresInteractive")
+
+  if (config.non_interactive === false) {
+    throw asInvalid("Interactive command execution is not supported. Set adapterConfig.non_interactive=true or remove it.")
+  }
+
+  if (config.timeout_ms !== undefined) {
+    if (typeof config.timeout_ms !== "number" || Number.isNaN(config.timeout_ms) || config.timeout_ms <= 0) {
+      throw asInvalid("adapterConfig.timeout_ms must be a positive number")
+    }
+    if (config.timeout_ms > 15000) {
+      throw asInvalid("adapterConfig.timeout_ms cannot exceed 15000ms")
+    }
+  }
+
+  if (config.stream !== undefined && !["jsonl"].includes(config.stream)) {
+    throw asInvalid("adapterConfig.stream must be 'jsonl'")
+  }
+}
+
+function validateAdapterConfig(cmd) {
+  const adapterName = cmd.adapter
+  if (!SUPPORTED_ADAPTERS.includes(adapterName)) return
+
+  const config = cmd.adapterConfig || {}
+  validateCommonConfig(adapterName, config)
+
+  if (adapterName === "http") {
+    if (!config.url || typeof config.url !== "string") throw asInvalid("HTTP adapter requires adapterConfig.url")
+    if (config.method !== undefined && typeof config.method !== "string") throw asInvalid("adapterConfig.method must be string")
+    return
+  }
+
+  if (adapterName === "openapi") {
+    if (!config.spec || typeof config.spec !== "string") throw asInvalid("OpenAPI adapter requires adapterConfig.spec")
+    if (!config.operationId || typeof config.operationId !== "string") throw asInvalid("OpenAPI adapter requires adapterConfig.operationId")
+    return
+  }
+
+  if (adapterName === "mcp") {
+    if (!config.tool || typeof config.tool !== "string") throw asInvalid("MCP adapter requires adapterConfig.tool")
+    const sources = [config.server, config.url, config.command].filter(Boolean)
+    if (sources.length === 0) throw asInvalid("MCP adapter requires one source: adapterConfig.server, adapterConfig.url, or adapterConfig.command")
+    return
+  }
+
+  if (adapterName === "process") {
+    if (!config.command || typeof config.command !== "string") throw asInvalid("Process adapter requires adapterConfig.command")
+    if (config.baseArgs !== undefined && !Array.isArray(config.baseArgs)) throw asInvalid("adapterConfig.baseArgs must be an array")
+    if (config.positionalArgs !== undefined && !Array.isArray(config.positionalArgs)) throw asInvalid("adapterConfig.positionalArgs must be an array")
+    if (config.passthrough !== undefined && typeof config.passthrough !== "boolean") throw asInvalid("adapterConfig.passthrough must be boolean")
+    if (config.flagsBeforePositionals !== undefined && typeof config.flagsBeforePositionals !== "boolean") throw asInvalid("adapterConfig.flagsBeforePositionals must be boolean")
+    if (config.missingDependencyHelp !== undefined && typeof config.missingDependencyHelp !== "string") throw asInvalid("adapterConfig.missingDependencyHelp must be string")
+    if (config.env !== undefined && (typeof config.env !== "object" || Array.isArray(config.env))) throw asInvalid("adapterConfig.env must be object")
+    if (config.interactiveFlags !== undefined && config.interactiveFlags.some(v => typeof v !== "string")) {
+      throw asInvalid("adapterConfig.interactiveFlags values must be strings")
+    }
+    return
+  }
+
+  if (adapterName === "builtin") {
+    if (!config.builtin || typeof config.builtin !== "string") throw asInvalid("Builtin adapter requires adapterConfig.builtin")
+    return
+  }
+
+  if (adapterName === "shell") {
+    if (config.unsafe !== true) {
+      throw asInvalid("Shell adapter requires adapterConfig.unsafe=true")
+    }
+    if (!config.script || typeof config.script !== "string") throw asInvalid("Shell adapter requires adapterConfig.script")
+    if (config.shell !== undefined && typeof config.shell !== "string") throw asInvalid("adapterConfig.shell must be string")
+    if (config.env !== undefined && (typeof config.env !== "object" || Array.isArray(config.env))) throw asInvalid("adapterConfig.env must be object")
+    return
+  }
+}
+
+module.exports = {
+  SUPPORTED_ADAPTERS,
+  validateAdapterConfig
+}

package/cli/adapters/builtin.js

@@ -0,0 +1,43 @@
+function execute(cmd) {
+  const cfg = cmd.adapterConfig || {}
+  if (cfg.builtin === "beads_install_steps") {
+    return {
+      plugin: "beads",
+      binary: "br",
+      install_steps: [
+        "curl -fsSL \"https://raw.githubusercontent.com/Dicklesworthstone/beads_rust/main/install.sh?$(date +%s)\" | bash",
+        "br --version"
+      ],
+      note: "Install execution is delegated to your LLM automation (dcli/scli/supercli)."
+    }
+  }
+  if (cfg.builtin === "gwc_install_steps") {
+    return {
+      plugin: "gwc",
+      binary: "gws",
+      install_steps: [
+        "npm install -g @googleworkspace/cli",
+        "gws --version"
+      ],
+      note: "Install execution is delegated to your LLM automation (dcli/scli/supercli)."
+    }
+  }
+  if (cfg.builtin === "commiat_install_steps") {
+    return {
+      plugin: "commiat",
+      binary: "commiat",
+      install_steps: [
+        "npm install -g commiat",
+        "commiat --version"
+      ],
+      note: "Install execution is delegated to your LLM automation (dcli/scli/supercli)."
+    }
+  }
+  throw Object.assign(new Error(`Unknown builtin action: ${cfg.builtin || "(missing)"}`), {
+    code: 85,
+    type: "invalid_argument",
+    recoverable: false
+  })
+}
+
+module.exports = { execute }