bankai-cli 0.2.0

package/README.md

@@ -0,0 +1,78 @@
+# bankai
+
+CLI tool that prints approval-bypass startup commands for coding agent CLIs.
+
+bankai does **not** execute the agents — it only outputs the commands for copy-paste.
+
+## Install
+
+```bash
+bun install -g bankai-cli
+```
+
+## Usage
+
+```bash
+# Print bypass command for a specific agent
+bankai claude
+
+# Interactive agent picker
+bankai
+
+# List all supported agents
+bankai agents
+
+# List only agents installed on your system
+bankai agents --installed
+```
+
+## Supported Agents
+
+### CLI Agents (flag output)
+
+| Agent | Command | Docs |
+|-------|---------|------|
+| Claude Code | `claude --dangerously-skip-permissions` | [Settings - Claude Code Docs](https://code.claude.com/docs/en/settings) |
+| Codex CLI | `codex --dangerously-bypass-approvals-and-sandbox` | [CLI Reference - OpenAI Codex](https://developers.openai.com/codex/cli/reference/) |
+| GitHub Copilot CLI | `copilot --allow-all-tools` | [Copilot CLI Docs](https://docs.github.com/en/copilot) |
+| Gemini CLI | `gemini --yolo` | [Configuration - Gemini CLI](https://github.com/google-gemini/gemini-cli/blob/main/docs/get-started/configuration.md) |
+| OpenHands | `openhands --always-approve` | [CLI Mode - OpenHands Docs](https://docs.openhands.dev/openhands/usage/run-openhands/cli-mode) |
+| Aider | `aider --yes-always` | [Options Reference - aider](https://aider.chat/docs/config/options.html) |
+| Qwen Code | `qwen-code --yolo` | [Approval Mode - Qwen Code Docs](https://qwenlm.github.io/qwen-code-docs/en/users/features/approval-mode/) |
+| Kimi Code | `kimi --yolo` | [Interaction Guide - Kimi Code Docs](https://www.kimi.com/code/docs/en/kimi-cli/guides/interaction.html) |
+
+### Settings Agents (config file / DB modification)
+
+| Agent | Target | Description |
+|-------|--------|-------------|
+| Cursor Agent CLI | `.cursor/cli.json` / `~/.cursor/cli-config.json` | Writes permission allow-list for Cursor Agent CLI |
+| Cursor IDE | SQLite DB (`state.vscdb`) | Enables Auto-Run Mode, disables protections (requires restart) |
+
+## Custom Agents
+
+Register agents not in the built-in list:
+
+```bash
+# Non-interactive
+bankai add --cmd opencode --line "opencode --yolo"
+
+# Interactive
+bankai add
+
+# Edit an existing custom agent
+bankai edit opencode
+
+# Remove a custom agent
+bankai remove opencode
+```
+
+Custom agents are stored in `~/.config/bankai/agents.json` (XDG-compliant, varies by OS).
+
+## Development
+
+```bash
+bun install
+bun run dev -- claude    # Run from source
+bun run build            # Build to dist/
+bun run test             # Run tests
+```

package/dist/main.js

@@ -0,0 +1,707 @@
+#!/usr/bin/env node
+
+// src/main.ts
+import { Command } from "commander";
+
+// src/commands/print.ts
+import chalk3 from "chalk";
+
+// src/registry/builtin.ts
+var builtinAgents = [
+  {
+    type: "cli",
+    cmd: "claude",
+    displayName: "Claude Code",
+    lines: ["claude --dangerously-skip-permissions"]
+  },
+  {
+    type: "cli",
+    cmd: "codex",
+    displayName: "Codex CLI",
+    lines: ["codex --dangerously-bypass-approvals-and-sandbox"]
+  },
+  {
+    type: "cli",
+    cmd: "copilot",
+    displayName: "GitHub Copilot CLI",
+    lines: ["copilot --allow-all-tools"]
+  },
+  {
+    type: "cli",
+    cmd: "gemini",
+    displayName: "Gemini CLI",
+    lines: ["gemini --yolo"],
+    cmdAliases: ["gemini-cli"]
+  },
+  {
+    type: "cli",
+    cmd: "openhands",
+    displayName: "OpenHands",
+    lines: ["openhands --always-approve"]
+  },
+  {
+    type: "cli",
+    cmd: "aider",
+    displayName: "Aider",
+    lines: ["aider --yes-always"]
+  },
+  {
+    type: "cli",
+    cmd: "qwen",
+    displayName: "Qwen Code",
+    lines: ["qwen-code --yolo"],
+    cmdAliases: ["qwen-code"]
+  },
+  {
+    type: "cli",
+    cmd: "kimi",
+    displayName: "Kimi Code",
+    lines: ["kimi --yolo"]
+  },
+  {
+    type: "settings",
+    cmd: "cursor-agent",
+    displayName: "Cursor Agent CLI",
+    targets: [
+      {
+        kind: "json",
+        scope: "project",
+        filePath: ".cursor/cli.json",
+        merge: {
+          permissions: {
+            allow: [
+              "Shell(**)",
+              "Read(**)",
+              "Write(**)",
+              "Delete(**)",
+              "Grep(**)",
+              "LS(**)"
+            ]
+          }
+        },
+        description: "Project (.cursor/cli.json)"
+      },
+      {
+        kind: "json",
+        scope: "global",
+        filePath: "~/.cursor/cli-config.json",
+        merge: {
+          permissions: {
+            allow: [
+              "Shell(**)",
+              "Read(**)",
+              "Write(**)",
+              "Delete(**)",
+              "Grep(**)",
+              "LS(**)"
+            ]
+          }
+        },
+        description: "Global (~/.cursor/cli-config.json)"
+      }
+    ]
+  },
+  {
+    type: "settings",
+    cmd: "cursor",
+    displayName: "Cursor IDE",
+    targets: [
+      {
+        kind: "sqlite",
+        scope: "global",
+        dbPath: "~/Library/Application Support/Cursor/User/globalStorage/state.vscdb",
+        table: "ItemTable",
+        key: "src.vs.platform.reactivestorage.browser.reactiveStorageServiceImpl.persistentStorage.applicationUser",
+        mergePath: "composerState",
+        merge: {
+          playwrightProtection: false,
+          yoloDotFilesDisabled: false,
+          yoloOutsideWorkspaceDisabled: false
+        },
+        modes4Patch: {
+          id: "agent",
+          set: { autoRun: true, fullAutoRun: true }
+        },
+        description: "IDE Auto-Run (SQLite DB)"
+      }
+    ]
+  }
+];
+
+// src/registry/custom.ts
+import fs from "fs";
+import path from "path";
+import envPaths from "env-paths";
+
+// src/registry/types.ts
+import { z } from "zod";
+var CliAgentDefSchema = z.object({
+  type: z.literal("cli").default("cli"),
+  cmd: z.string().min(1),
+  displayName: z.string().optional(),
+  lines: z.array(z.string().min(1)).min(1),
+  cmdAliases: z.array(z.string().min(1)).optional()
+});
+var JsonTargetSchema = z.object({
+  kind: z.literal("json"),
+  scope: z.enum(["project", "global"]),
+  filePath: z.string(),
+  merge: z.record(z.unknown()),
+  description: z.string().optional()
+});
+var SqliteTargetSchema = z.object({
+  kind: z.literal("sqlite"),
+  scope: z.literal("global"),
+  dbPath: z.string(),
+  table: z.string(),
+  key: z.string(),
+  mergePath: z.string(),
+  merge: z.record(z.unknown()),
+  modes4Patch: z.object({
+    id: z.string(),
+    set: z.record(z.unknown())
+  }).optional(),
+  description: z.string().optional()
+});
+var SettingsTargetSchema = z.union([
+  JsonTargetSchema,
+  SqliteTargetSchema
+]);
+var SettingsAgentDefSchema = z.object({
+  type: z.literal("settings"),
+  cmd: z.string().min(1),
+  displayName: z.string().optional(),
+  cmdAliases: z.array(z.string().min(1)).optional(),
+  targets: z.array(SettingsTargetSchema).min(1)
+});
+var AgentDefSchema = z.preprocess(
+  (val) => typeof val === "object" && val !== null && !("type" in val) ? { ...val, type: "cli" } : val,
+  z.discriminatedUnion("type", [CliAgentDefSchema, SettingsAgentDefSchema])
+);
+var CustomAgentDefSchema = CliAgentDefSchema;
+var CustomAgentsFileSchema = z.array(CustomAgentDefSchema);
+
+// src/registry/custom.ts
+var paths = envPaths("bankai");
+var agentsFile = path.join(paths.config, "agents.json");
+function ensureConfigDir() {
+  fs.mkdirSync(paths.config, { recursive: true });
+}
+function loadCustomAgents(filePath = agentsFile) {
+  if (!fs.existsSync(filePath)) return [];
+  const raw = JSON.parse(fs.readFileSync(filePath, "utf-8"));
+  return CustomAgentsFileSchema.parse(raw);
+}
+function saveCustomAgents(agents, filePath = agentsFile) {
+  if (filePath === agentsFile) ensureConfigDir();
+  fs.writeFileSync(filePath, JSON.stringify(agents, null, 2) + "\n");
+}
+function addAgent(agent, filePath = agentsFile) {
+  const agents = loadCustomAgents(filePath);
+  const existing = agents.findIndex((a) => a.cmd === agent.cmd);
+  if (existing !== -1) {
+    throw new Error(`Agent "${agent.cmd}" already exists. Use edit to update.`);
+  }
+  agents.push(agent);
+  saveCustomAgents(agents, filePath);
+}
+function updateAgent(cmd, updates, filePath = agentsFile) {
+  const agents = loadCustomAgents(filePath);
+  const idx = agents.findIndex((a) => a.cmd === cmd);
+  if (idx === -1) {
+    throw new Error(`Agent "${cmd}" not found.`);
+  }
+  agents[idx] = { ...agents[idx], ...updates };
+  saveCustomAgents(agents, filePath);
+}
+function removeAgent(cmd, filePath = agentsFile) {
+  const agents = loadCustomAgents(filePath);
+  const filtered = agents.filter((a) => a.cmd !== cmd);
+  if (filtered.length === agents.length) {
+    throw new Error(`Agent "${cmd}" not found.`);
+  }
+  saveCustomAgents(filtered, filePath);
+}
+
+// src/registry/resolve.ts
+function resolveAgent(cmd, customFilePath) {
+  const custom = loadCustomAgents(customFilePath);
+  for (const agent of custom) {
+    if (agent.cmd === cmd) return agent;
+    if (agent.cmdAliases?.includes(cmd)) return agent;
+  }
+  for (const agent of builtinAgents) {
+    if (agent.cmd === cmd) return agent;
+    if (agent.cmdAliases?.includes(cmd)) return agent;
+  }
+  return void 0;
+}
+function resolveAll(customFilePath) {
+  const custom = loadCustomAgents(customFilePath);
+  const merged = /* @__PURE__ */ new Map();
+  for (const agent of builtinAgents) {
+    merged.set(agent.cmd, agent);
+  }
+  for (const agent of custom) {
+    merged.set(agent.cmd, agent);
+  }
+  return [...merged.values()];
+}
+
+// src/format.ts
+import chalk from "chalk";
+function formatOutput(agent) {
+  const name = agent.displayName ?? agent.cmd;
+  const header = chalk.bold.cyan(`# ${name}`);
+  const lines = agent.lines.map((l) => chalk.green(l)).join("\n");
+  return `${header}
+${lines}`;
+}
+
+// src/commands/apply.ts
+import chalk2 from "chalk";
+import select from "@inquirer/select";
+import confirm from "@inquirer/confirm";
+
+// src/settings.ts
+import fs2 from "fs";
+import path2 from "path";
+import os from "os";
+import Database from "better-sqlite3";
+function resolveTargetPath(filePath) {
+  if (filePath.startsWith("~/")) {
+    return path2.join(os.homedir(), filePath.slice(2));
+  }
+  return path2.resolve(filePath);
+}
+function deepMerge(base, overlay) {
+  const result = { ...base };
+  for (const key of Object.keys(overlay)) {
+    const baseVal = base[key];
+    const overVal = overlay[key];
+    if (typeof baseVal === "object" && baseVal !== null && !Array.isArray(baseVal) && typeof overVal === "object" && overVal !== null && !Array.isArray(overVal)) {
+      result[key] = deepMerge(
+        baseVal,
+        overVal
+      );
+    } else {
+      result[key] = overVal;
+    }
+  }
+  return result;
+}
+function isDeepSubset(haystack, needle) {
+  if (needle === haystack) return true;
+  if (typeof needle === "object" && needle !== null && !Array.isArray(needle) && typeof haystack === "object" && haystack !== null && !Array.isArray(haystack)) {
+    const h = haystack;
+    const n = needle;
+    return Object.keys(n).every((key) => isDeepSubset(h[key], n[key]));
+  }
+  if (Array.isArray(needle) && Array.isArray(haystack)) {
+    if (needle.length !== haystack.length) return false;
+    return needle.every((item, i) => isDeepSubset(haystack[i], item));
+  }
+  return JSON.stringify(haystack) === JSON.stringify(needle);
+}
+function patchModes4(modes4, patch) {
+  return modes4.map((entry) => {
+    if (entry.id === patch.id) {
+      return { ...entry, ...patch.set };
+    }
+    return entry;
+  });
+}
+function isModes4PatchApplied(modes4, patch) {
+  const entry = modes4.find((e) => e.id === patch.id);
+  if (!entry) return false;
+  return Object.entries(patch.set).every(
+    ([key, val]) => entry[key] === val
+  );
+}
+function isJsonAlreadyApplied(target) {
+  const filePath = resolveTargetPath(target.filePath);
+  if (!fs2.existsSync(filePath)) return false;
+  try {
+    const data = JSON.parse(fs2.readFileSync(filePath, "utf-8"));
+    return isDeepSubset(data, target.merge);
+  } catch {
+    return false;
+  }
+}
+function applyJsonSettings(target) {
+  const filePath = resolveTargetPath(target.filePath);
+  let data = {};
+  if (fs2.existsSync(filePath)) {
+    try {
+      data = JSON.parse(fs2.readFileSync(filePath, "utf-8"));
+    } catch {
+    }
+  } else {
+    fs2.mkdirSync(path2.dirname(filePath), { recursive: true });
+  }
+  const merged = deepMerge(data, target.merge);
+  fs2.writeFileSync(filePath, JSON.stringify(merged, null, 2) + "\n");
+}
+function isSqliteAlreadyApplied(target) {
+  const dbPath = resolveTargetPath(target.dbPath);
+  if (!fs2.existsSync(dbPath)) return false;
+  try {
+    const db = new Database(dbPath, { readonly: true });
+    const row = db.prepare(`SELECT value FROM ${target.table} WHERE key = ?`).get(target.key);
+    db.close();
+    if (!row) return false;
+    const data = JSON.parse(row.value);
+    const sub = getNestedValue(data, target.mergePath);
+    if (sub === void 0) return false;
+    const mergeApplied = isDeepSubset(sub, target.merge);
+    if (target.modes4Patch) {
+      const modes4 = sub.modes4;
+      if (!modes4) return false;
+      return mergeApplied && isModes4PatchApplied(modes4, target.modes4Patch);
+    }
+    return mergeApplied;
+  } catch {
+    return false;
+  }
+}
+function applySqliteSettings(target) {
+  const dbPath = resolveTargetPath(target.dbPath);
+  if (!fs2.existsSync(dbPath)) {
+    throw new Error(`Database not found: ${dbPath}`);
+  }
+  const db = new Database(dbPath);
+  const row = db.prepare(`SELECT value FROM ${target.table} WHERE key = ?`).get(target.key);
+  let data = {};
+  if (row) {
+    data = JSON.parse(row.value);
+  }
+  let sub = getNestedValue(data, target.mergePath);
+  if (!sub || typeof sub !== "object") {
+    sub = {};
+  }
+  const merged = deepMerge(sub, target.merge);
+  if (target.modes4Patch && Array.isArray(merged.modes4)) {
+    merged.modes4 = patchModes4(
+      merged.modes4,
+      target.modes4Patch
+    );
+  }
+  setNestedValue(data, target.mergePath, merged);
+  const newValue = JSON.stringify(data);
+  if (row) {
+    db.prepare(`UPDATE ${target.table} SET value = ? WHERE key = ?`).run(
+      newValue,
+      target.key
+    );
+  } else {
+    db.prepare(`INSERT INTO ${target.table} (key, value) VALUES (?, ?)`).run(
+      target.key,
+      newValue
+    );
+  }
+  db.close();
+}
+function isAlreadyApplied(target) {
+  if (target.kind === "json") return isJsonAlreadyApplied(target);
+  return isSqliteAlreadyApplied(target);
+}
+function applySettings(target) {
+  if (target.kind === "json") {
+    applyJsonSettings(target);
+  } else {
+    applySqliteSettings(target);
+  }
+}
+function getNestedValue(obj, path3) {
+  const keys = path3.split(".");
+  let current = obj;
+  for (const key of keys) {
+    if (typeof current !== "object" || current === null) return void 0;
+    current = current[key];
+  }
+  return current;
+}
+function setNestedValue(obj, path3, value) {
+  const keys = path3.split(".");
+  let current = obj;
+  for (let i = 0; i < keys.length - 1; i++) {
+    if (typeof current[keys[i]] !== "object" || current[keys[i]] === null) {
+      current[keys[i]] = {};
+    }
+    current = current[keys[i]];
+  }
+  current[keys[keys.length - 1]] = value;
+}
+
+// src/commands/apply.ts
+async function applySettingsAgent(agent) {
+  const name = agent.displayName ?? agent.cmd;
+  console.log(chalk2.bold.cyan(`# ${name}`));
+  console.log(chalk2.dim("This agent uses settings files instead of CLI flags.\n"));
+  const statuses = agent.targets.map((t) => ({
+    target: t,
+    applied: isAlreadyApplied(t)
+  }));
+  const allApplied = statuses.every((s) => s.applied);
+  if (allApplied) {
+    console.log(
+      chalk2.green("All settings are already applied:")
+    );
+    for (const s of statuses) {
+      console.log(chalk2.green(`  \u2713 ${s.target.description ?? s.target.kind}`));
+    }
+    return;
+  }
+  for (const s of statuses) {
+    const label2 = s.target.description ?? s.target.kind;
+    if (s.applied) {
+      console.log(chalk2.green(`  \u2713 ${label2} (already applied)`));
+    } else {
+      console.log(chalk2.yellow(`  \u25CB ${label2} (not applied)`));
+    }
+  }
+  console.log();
+  const unapplied = statuses.filter((s) => !s.applied);
+  let target;
+  if (unapplied.length === 1) {
+    target = unapplied[0].target;
+  } else {
+    const chosen = await select({
+      message: "Select a target to apply:",
+      choices: unapplied.map((s) => ({
+        name: s.target.description ?? s.target.kind,
+        value: s.target
+      }))
+    });
+    target = chosen;
+  }
+  const label = target.description ?? target.kind;
+  const ok = await confirm({
+    message: `Apply settings to ${label}?`,
+    default: true
+  });
+  if (!ok) {
+    console.log(chalk2.dim("Cancelled."));
+    return;
+  }
+  try {
+    applySettings(target);
+    console.log(chalk2.green(`
+\u2713 Applied settings to ${label}`));
+    if (target.kind === "sqlite") {
+      console.log(chalk2.yellow("\nRestart the application for changes to take effect."));
+    }
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.error(chalk2.red(`
+Failed to apply settings: ${msg}`));
+    process.exitCode = 1;
+  }
+}
+
+// src/commands/print.ts
+async function printAgent(cmd) {
+  const agent = resolveAgent(cmd);
+  if (!agent) {
+    console.error(
+      chalk3.red(`Unsupported agent: "${cmd}".`) + `
+Run ${chalk3.yellow("bankai agents")} to see available agents, or ${chalk3.yellow("bankai add")} to register a custom one.`
+    );
+    process.exitCode = 1;
+    return;
+  }
+  if (agent.type === "settings") {
+    await applySettingsAgent(agent);
+  } else {
+    console.log(formatOutput(agent));
+  }
+}
+
+// src/commands/agents.ts
+import chalk4 from "chalk";
+
+// src/detect.ts
+import { spawnSync } from "child_process";
+function isInstalled(cmd) {
+  const result = spawnSync("command", ["-v", cmd], {
+    shell: true,
+    stdio: "ignore"
+  });
+  return result.status === 0;
+}
+function filterInstalled(agents) {
+  return agents.filter((a) => isInstalled(a.cmd));
+}
+
+// src/commands/agents.ts
+function listAgents(opts) {
+  let agents = resolveAll();
+  if (opts.installed) {
+    agents = filterInstalled(agents);
+    if (agents.length === 0) {
+      console.log(chalk4.yellow("No supported agents detected on this system."));
+      return;
+    }
+  }
+  for (const agent of agents) {
+    const name = agent.displayName ? `${chalk4.bold(agent.cmd)} ${chalk4.dim(`(${agent.displayName})`)}` : chalk4.bold(agent.cmd);
+    if (agent.type === "settings") {
+      const targets = agent.targets.map((t) => t.description ?? t.kind).join(", ");
+      console.log(`  ${name}  \u2192  ${chalk4.magenta(`[settings: ${targets}]`)}`);
+    } else {
+      const lines = agent.lines.map((l) => chalk4.green(l)).join(", ");
+      console.log(`  ${name}  \u2192  ${lines}`);
+    }
+  }
+}
+
+// src/commands/add.ts
+import chalk5 from "chalk";
+import input from "@inquirer/input";
+async function addAgentCommand(opts) {
+  let cmd = opts.cmd;
+  let lines = opts.line;
+  let displayName = opts.displayName;
+  let aliases = opts.alias;
+  if (!cmd) {
+    cmd = await input({ message: "Command name (e.g. myagent):" });
+    displayName = await input({
+      message: "Display name (optional, press Enter to skip):"
+    });
+    const linesRaw = await input({
+      message: "Bypass command(s), comma-separated:"
+    });
+    lines = linesRaw.split(",").map((l) => l.trim()).filter(Boolean);
+    const aliasRaw = await input({
+      message: "Aliases, comma-separated (optional, press Enter to skip):"
+    });
+    aliases = aliasRaw ? aliasRaw.split(",").map((a) => a.trim()).filter(Boolean) : void 0;
+  }
+  if (!lines || lines.length === 0) {
+    console.error(chalk5.red("At least one --line is required."));
+    process.exitCode = 1;
+    return;
+  }
+  const agent = CustomAgentDefSchema.parse({
+    cmd,
+    displayName: displayName || void 0,
+    lines,
+    cmdAliases: aliases && aliases.length > 0 ? aliases : void 0
+  });
+  try {
+    addAgent(agent);
+    console.log(chalk5.green(`Added custom agent "${cmd}".`));
+  } catch (err) {
+    console.error(chalk5.red(err.message));
+    process.exitCode = 1;
+  }
+}
+
+// src/commands/edit.ts
+import chalk6 from "chalk";
+import input2 from "@inquirer/input";
+async function editAgentCommand(cmd) {
+  const custom = loadCustomAgents();
+  const existing = custom.find((a) => a.cmd === cmd);
+  if (!existing) {
+    const builtin = resolveAgent(cmd);
+    if (builtin) {
+      console.error(
+        chalk6.red(`"${cmd}" is a built-in agent. Use ${chalk6.yellow("bankai add")} to create a custom override.`)
+      );
+    } else {
+      console.error(chalk6.red(`Custom agent "${cmd}" not found.`));
+    }
+    process.exitCode = 1;
+    return;
+  }
+  const displayName = await input2({
+    message: "Display name:",
+    default: existing.displayName ?? ""
+  });
+  const linesRaw = await input2({
+    message: "Bypass command(s), comma-separated:",
+    default: existing.lines.join(", ")
+  });
+  const lines = linesRaw.split(",").map((l) => l.trim()).filter(Boolean);
+  const aliasRaw = await input2({
+    message: "Aliases, comma-separated:",
+    default: existing.cmdAliases?.join(", ") ?? ""
+  });
+  const aliases = aliasRaw ? aliasRaw.split(",").map((a) => a.trim()).filter(Boolean) : void 0;
+  try {
+    updateAgent(cmd, {
+      displayName: displayName || void 0,
+      lines,
+      cmdAliases: aliases && aliases.length > 0 ? aliases : void 0
+    });
+    console.log(chalk6.green(`Updated agent "${cmd}".`));
+  } catch (err) {
+    console.error(chalk6.red(err.message));
+    process.exitCode = 1;
+  }
+}
+
+// src/commands/remove.ts
+import chalk7 from "chalk";
+function removeAgentCommand(cmd) {
+  try {
+    removeAgent(cmd);
+    console.log(chalk7.green(`Removed agent "${cmd}".`));
+  } catch (err) {
+    console.error(chalk7.red(err.message));
+    process.exitCode = 1;
+  }
+}
+
+// src/commands/select.ts
+import chalk8 from "chalk";
+import select2 from "@inquirer/select";
+async function selectAgent() {
+  const all = resolveAll();
+  const installed = filterInstalled(all);
+  const agents = installed.length > 0 ? installed : all;
+  const label = installed.length > 0 ? "Detected agents on this system" : "No agents detected \u2014 showing all supported agents";
+  console.log(chalk8.dim(label));
+  const chosen = await select2({
+    message: "Select an agent:",
+    choices: agents.map((a) => ({
+      name: a.displayName ?? a.cmd,
+      value: a.cmd
+    }))
+  });
+  const agent = agents.find((a) => a.cmd === chosen);
+  if (agent) {
+    console.log();
+    if (agent.type === "settings") {
+      await applySettingsAgent(agent);
+    } else {
+      console.log(formatOutput(agent));
+    }
+  }
+}
+
+// src/main.ts
+var program = new Command();
+program.name("bankai").description("Print approval-bypass startup commands for coding agent CLIs").version("0.2.0");
+program.argument("[cmd]", "agent command to look up").option("-a, --agent <cmd>", "agent command to look up (alternative)").action(async (cmd, opts) => {
+  const target = cmd || opts.agent;
+  if (target) {
+    await printAgent(target);
+  } else {
+    await selectAgent();
+  }
+});
+program.command("agents").description("List all supported agents").option("--installed", "Only show agents detected on this system").action((opts) => {
+  listAgents(opts);
+});
+program.command("add").description("Register a custom agent").option("--cmd <name>", "Command name").option("--line <line...>", "Bypass command line(s)").option("--display-name <name>", "Display name").option("--alias <alias...>", "Command aliases").action(async (opts) => {
+  await addAgentCommand(opts);
+});
+program.command("edit <cmd>").description("Edit an existing custom agent").action(async (cmd) => {
+  await editAgentCommand(cmd);
+});
+program.command("remove <cmd>").description("Remove a custom agent").action((cmd) => {
+  removeAgentCommand(cmd);
+});
+program.parse();

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "bankai-cli",
+  "version": "0.2.0",
+  "type": "module",
+  "files": ["dist", "README.md"],
+  "bin": {
+    "bankai": "./dist/main.js"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "bun run src/main.ts",
+    "test": "vitest run"
+  },
+  "dependencies": {
+    "@inquirer/confirm": "^6.0.4",
+    "@inquirer/input": "^4.1.0",
+    "@inquirer/select": "^4.1.0",
+    "better-sqlite3": "^12.6.2",
+    "chalk": "^5.4.1",
+    "commander": "^13.1.0",
+    "env-paths": "^3.0.0",
+    "zod": "^3.24.2"
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "^7.6.13",
+    "@types/node": "^22.13.1",
+    "tsup": "^8.3.6",
+    "typescript": "^5.7.3",
+    "vitest": "^3.0.5"
+  }
+}