@arp-protocol/cli 0.0.0-stage → 0.0.1

package/dist/chunks/commands-dnk10vze.js

@@ -0,0 +1,805 @@
+#!/usr/bin/env node
+import"./cli-g5zvr10v.js";
+
+// src/install/commands.ts
+import {
+  chmodSync,
+  copyFileSync,
+  existsSync as existsSync2,
+  mkdirSync,
+  readFileSync as readFileSync2,
+  renameSync,
+  rmSync,
+  statSync,
+  writeFileSync
+} from "node:fs";
+import { dirname, join as join2 } from "node:path";
+
+// src/install/targets.ts
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+
+// src/install/edits.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parseJsonConfig(text) {
+  if (text === null || text.trim().length === 0)
+    return {};
+  try {
+    const parsed = JSON.parse(text);
+    return isRecord(parsed) ? parsed : new Error("not a JSON object");
+  } catch (error) {
+    return error instanceof Error ? error : new Error(String(error));
+  }
+}
+function formatJson(value) {
+  return `${JSON.stringify(value, null, 2)}
+`;
+}
+function withMcpServer(config, name, entry) {
+  const servers = isRecord(config.mcpServers) ? { ...config.mcpServers } : {};
+  if (entry === null)
+    delete servers[name];
+  else
+    servers[name] = entry;
+  const next = { ...config, mcpServers: servers };
+  if (entry === null && Object.keys(servers).length === 0)
+    delete next.mcpServers;
+  return next;
+}
+var CLAUDE_HOOKS = {
+  shape: "nested",
+  events: [
+    { name: "PostToolUse", matcher: "*" },
+    { name: "PostToolUseFailure", matcher: "*" }
+  ],
+  entry: (command) => ({ type: "command", command, async: true, timeout: 10 })
+};
+function isOurs(hook, marker) {
+  return isRecord(hook) && typeof hook.command === "string" && hook.command.includes(marker);
+}
+function strip(list, spec, marker) {
+  if (!Array.isArray(list))
+    return [];
+  if (spec.shape === "flat")
+    return list.filter((entry) => !isOurs(entry, marker));
+  const kept = [];
+  for (const group of list) {
+    if (!isRecord(group) || !Array.isArray(group.hooks)) {
+      kept.push(group);
+      continue;
+    }
+    const rest = group.hooks.filter((hook) => !isOurs(hook, marker));
+    if (rest.length > 0)
+      kept.push({ ...group, hooks: rest });
+  }
+  return kept;
+}
+function ours(list, spec, marker) {
+  if (!Array.isArray(list))
+    return [];
+  if (spec.shape === "flat")
+    return list.filter((entry) => isOurs(entry, marker));
+  return list.flatMap((group) => isRecord(group) && Array.isArray(group.hooks) ? group.hooks.filter((hook) => isOurs(hook, marker)) : []);
+}
+function withHooks(settings, spec, command, marker) {
+  const hooks = isRecord(settings.hooks) ? { ...settings.hooks } : {};
+  for (const event of spec.events) {
+    const kept = strip(hooks[event.name], spec, marker);
+    if (command !== null) {
+      const entry = spec.entry(command);
+      kept.push(spec.shape === "flat" ? entry : { ...event.matcher === undefined ? {} : { matcher: event.matcher }, hooks: [entry] });
+    }
+    if (kept.length > 0)
+      hooks[event.name] = kept;
+    else
+      delete hooks[event.name];
+  }
+  const next = { ...settings, hooks };
+  if (Object.keys(hooks).length === 0) {
+    delete next.hooks;
+    if (spec.shape === "flat" && Object.keys(next).length === 1 && "version" in next)
+      return {};
+  } else if (spec.shape === "flat" && next.version === undefined) {
+    return { version: 1, ...next };
+  }
+  return next;
+}
+function hooksOf(settings, spec, marker) {
+  if (!isRecord(settings.hooks))
+    return {};
+  const out = {};
+  for (const event of spec.events) {
+    const found = ours(settings.hooks[event.name], spec, marker);
+    if (found.length > 0)
+      out[event.name] = found;
+  }
+  return out;
+}
+function hasHooks(settings, spec, marker) {
+  const found = hooksOf(settings, spec, marker);
+  return spec.events.every((event) => (event.name in found));
+}
+var TOML_BEGIN = "# >>> arp — managed by `arp init`, removed by `arp uninstall` >>>";
+var TOML_END = "# <<< arp <<<";
+function tomlString(value) {
+  return JSON.stringify(value);
+}
+function withoutCodexTable(text) {
+  let inside = false;
+  return text.split(`
+`).filter((line) => {
+    if (/^\s*\[\[?[^\]]+\]\]?\s*(#.*)?$/.test(line)) {
+      inside = /^\s*\[mcp_servers\.arp(\.[^\]]+)?\]/.test(line);
+    }
+    return !inside;
+  }).join(`
+`);
+}
+function withCodexServer(text, entry, force = false) {
+  const current = text ?? "";
+  const begin = current.indexOf(TOML_BEGIN);
+  const end = current.indexOf(TOML_END);
+  const hasBlock = begin !== -1 && end > begin;
+  const kept = hasBlock ? current.slice(0, begin) + current.slice(end + TOML_END.length) : current;
+  const foreign = /^\s*\[mcp_servers\.arp\]/m.test(kept);
+  if (foreign && !force) {
+    return new Error("an [mcp_servers.arp] table exists that `arp init` did not write");
+  }
+  const outside = foreign ? withoutCodexTable(kept) : kept;
+  let base = outside.replace(/\n{3,}/g, `
+
+`).replace(/\s+$/, "");
+  if (entry === null)
+    return base.length === 0 ? "" : `${base}
+`;
+  const block = [
+    TOML_BEGIN,
+    "[mcp_servers.arp]",
+    `command = ${tomlString(entry.command)}`,
+    `args = [${entry.args.map(tomlString).join(", ")}]`,
+    `env = { ${Object.entries(entry.env).map(([key, value]) => `${key} = ${tomlString(value)}`).join(", ")} }`,
+    TOML_END
+  ].join(`
+`);
+  base = base.length === 0 ? "" : `${base}
+
+`;
+  return `${base}${block}
+`;
+}
+function codexBlockOf(text) {
+  if (text === null)
+    return [];
+  const begin = text.indexOf(TOML_BEGIN);
+  const end = text.indexOf(TOML_END);
+  return begin === -1 || end < begin ? [] : text.slice(begin, end + TOML_END.length).split(`
+`);
+}
+function hasCodexServer(text) {
+  return text !== null && text.includes(TOML_BEGIN) && text.includes(TOML_END);
+}
+
+// src/install/targets.ts
+var RUNTIME_IDS = [
+  "claude",
+  "grok",
+  "cursor",
+  "gemini",
+  "codex",
+  "copilot"
+];
+var SERVER_NAME = "arp";
+function namesOurServer(text, cliPath) {
+  return text.includes("@arp-protocol/cli") || text.includes(cliPath) || /apps[\\/]cli[\\/]dist[\\/]cli\.js/.test(text) || /[\\/]dist[\\/]cli\.js/.test(text) && text.includes("ARP_TARGET") || /(?:packaging[\\/]claude[\\/]arp|plugins[\\/]cache[\\/]arp[\\/]arp[\\/][^\\/]+)[\\/]bin[\\/]arp\.js/.test(text);
+}
+function foreignServerStep(where) {
+  return {
+    kind: "skip",
+    summary: `MCP server "arp" in ${where} is not one ARP wrote; left as it is`
+  };
+}
+function foreignRefusal(where) {
+  return {
+    kind: "skip",
+    failed: true,
+    summary: `MCP server "arp" in ${where} is not one ARP wrote; left as it is. Rename it, or run arp init --force to replace it`
+  };
+}
+function read(path) {
+  try {
+    return existsSync(path) ? readFileSync(path, "utf8") : null;
+  } catch {
+    return null;
+  }
+}
+function npxLaunch(pkg) {
+  return {
+    command: "sh",
+    args: ["-c", `export ARP_PROJECT_DIR="$PWD"; cd / && exec npx --prefix / -y --fetch-retries=0 --fetch-timeout=5000 ${pkg} mcp`]
+  };
+}
+var SERVER_ENV = { ARP_TARGET: "testnet" };
+var SPONSORED_ENV = {
+  ...SERVER_ENV,
+  ARP_TOOLS: "sponsored",
+  ARP_SKILLS_DIR: ".claude/skills"
+};
+function commandsFor(env, cliPath, capture = false, sponsored = false, force = false) {
+  const hookFile = join(env.home, ".arp", "bin", "hook.js");
+  const fromNpx = /[\\/]_npx[\\/]/.test(cliPath);
+  const mcp = {
+    ...fromNpx ? {
+      ...npxLaunch(`@arp-protocol/cli@${env.version}`)
+    } : { command: env.node, args: [cliPath, "mcp"] },
+    env: sponsored ? SPONSORED_ENV : SERVER_ENV
+  };
+  const hook = `"${env.node}" "${hookFile}"${capture ? " --capture" : ""}`;
+  return { mcp, hook, hookFile, cliPath, capture, force };
+}
+function diffLines(before, after) {
+  const lines = (value, sign) => value === undefined || typeof value === "object" && value !== null && Object.keys(value).length === 0 ? [] : JSON.stringify(value, null, 2).split(`
+`).map((line) => `${sign} ${line}`);
+  return [...lines(before, "-"), ...lines(after, "+")];
+}
+function serversOf(config) {
+  return typeof config.mcpServers === "object" && config.mcpServers !== null && !Array.isArray(config.mcpServers) ? config.mcpServers : {};
+}
+function jsonStep(path, edit, summary, view) {
+  const before = read(path);
+  const parsed = parseJsonConfig(before);
+  if (parsed instanceof Error) {
+    return {
+      kind: "skip",
+      failed: true,
+      summary: `${path} is not valid JSON (${parsed.message}); left as it is`
+    };
+  }
+  const next = edit(parsed);
+  const after = Object.keys(next).length === 0 ? null : formatJson(next);
+  return { kind: "file", path, before, after, summary, diff: diffLines(view(parsed), view(next)) };
+}
+function hasForeignServer(path, commands) {
+  const config = parseJsonConfig(read(path));
+  if (config instanceof Error)
+    return false;
+  const entry = serversOf(config)[SERVER_NAME];
+  return entry !== undefined && !namesOurServer(JSON.stringify(entry), commands.cliPath);
+}
+function claudeFiles(env, project) {
+  const root = project ? env.cwd : env.home;
+  return {
+    mcp: project ? join(env.cwd, ".mcp.json") : join(env.home, ".claude.json"),
+    settings: join(root, ".claude", "settings.json")
+  };
+}
+function mcpEntry(server, typed) {
+  return typed ? { type: "stdio", command: server.command, args: server.args, env: server.env } : { command: server.command, args: server.args, env: server.env };
+}
+function claudeMcpSteps(env, commands, project, remove, allowCli) {
+  const files = claudeFiles(env, project);
+  if (allowCli && !project && env.which("claude") !== null) {
+    const got = env.run(["claude", "mcp", "get", SERVER_NAME]);
+    const present = got.code === 0;
+    const same = present && [
+      commands.mcp.command,
+      ...commands.mcp.args,
+      ...Object.entries(commands.mcp.env).map(([key, value]) => `${key}=${value}`)
+    ].every((part) => got.stdout.includes(part));
+    const removeStep = {
+      kind: "command",
+      argv: ["claude", "mcp", "remove", SERVER_NAME, "--scope", "user"],
+      summary: "claude mcp remove arp --scope user",
+      diff: present ? got.stdout.trim().split(`
+`).map((line) => `- ${line.replace(/=\S+/g, "=…")}`) : []
+    };
+    const entry = mcpEntry(commands.mcp, true);
+    const addStep = {
+      kind: "command",
+      argv: ["claude", "mcp", "add-json", SERVER_NAME, JSON.stringify(entry), "--scope", "user"],
+      summary: "claude mcp add-json arp … --scope user",
+      diff: diffLines(undefined, entry)
+    };
+    if (remove) {
+      if (!present)
+        return [{ kind: "skip", summary: 'MCP server "arp" not declared (claude mcp get arp)' }];
+      return namesOurServer(got.stdout, commands.cliPath) ? [removeStep] : [foreignServerStep("claude mcp get arp")];
+    }
+    if (same)
+      return [
+        {
+          kind: "skip",
+          summary: 'MCP server "arp" already declared with this command (claude mcp get arp)'
+        }
+      ];
+    if (present && !commands.force && !namesOurServer(got.stdout, commands.cliPath)) {
+      return [foreignRefusal("claude mcp get arp")];
+    }
+    return present ? [removeStep, addStep] : [addStep];
+  }
+  if (remove && hasForeignServer(files.mcp, commands))
+    return [foreignServerStep(files.mcp)];
+  if (!remove && !commands.force && hasForeignServer(files.mcp, commands)) {
+    return [foreignRefusal(files.mcp)];
+  }
+  return [
+    jsonStep(files.mcp, (config) => withMcpServer(config, SERVER_NAME, remove ? null : mcpEntry(commands.mcp, false)), remove ? "mcpServers.arp removed" : `mcpServers.arp → ${commands.mcp.command} ${commands.mcp.args.join(" ")}`, (config) => serversOf(config)[SERVER_NAME])
+  ];
+}
+function claudeHookStep(env, commands, project, remove) {
+  return jsonStep(claudeFiles(env, project).settings, (settings) => withHooks(settings, CLAUDE_HOOKS, remove ? null : commands.hook, commands.hookFile), remove ? "hooks: arp removed from PostToolUse and PostToolUseFailure" : "hooks: arp on PostToolUse and PostToolUseFailure, async", (settings) => hooksOf(settings, CLAUDE_HOOKS, commands.hookFile));
+}
+var CLAUDE_HOOKS_SEEN_FROM = [2, 1, 316];
+function claudeVersionCheck(env) {
+  if (env.which("claude") === null)
+    return [];
+  const found = /(\d+)\.(\d+)\.(\d+)/.exec(env.run(["claude", "--version"]).stdout);
+  const seen = CLAUDE_HOOKS_SEEN_FROM.join(".");
+  if (found === null)
+    return [[`claude --version answers (hooks seen working from ${seen})`, false]];
+  const version = found.slice(1, 4).map(Number);
+  const newer = (() => {
+    for (const [i, floor] of CLAUDE_HOOKS_SEEN_FROM.entries()) {
+      const part = version[i] ?? 0;
+      if (part !== floor)
+        return part > floor;
+    }
+    return true;
+  })();
+  return [[`claude ${found[0]} runs hooks (seen working from ${seen}; claude update)`, newer]];
+}
+function claudeChecks(env, commands, project) {
+  const files = claudeFiles(env, project);
+  const mcp = parseJsonConfig(read(files.mcp));
+  const settings = parseJsonConfig(read(files.settings));
+  const servers = mcp instanceof Error ? {} : serversOf(mcp);
+  const viaCli = !project && env.which("claude") !== null ? env.run(["claude", "mcp", "get", SERVER_NAME]).code === 0 : false;
+  return [
+    [
+      `MCP server "arp" declared (${viaCli ? "claude mcp get" : files.mcp})`,
+      viaCli || SERVER_NAME in servers
+    ],
+    [
+      `hook on PostToolUse and PostToolUseFailure (${files.settings})`,
+      !(settings instanceof Error) && hasHooks(settings, CLAUDE_HOOKS, commands.hookFile)
+    ],
+    ...claudeVersionCheck(env)
+  ];
+}
+var claude = {
+  id: "claude",
+  name: "Claude Code",
+  detect: (env) => env.which("claude") !== null || existsSync(join(env.home, ".claude")),
+  install: (env, commands, project) => [
+    ...claudeMcpSteps(env, commands, project, false, true),
+    claudeHookStep(env, commands, project, false)
+  ],
+  remove: (env, commands, project) => [
+    ...claudeMcpSteps(env, commands, project, true, true),
+    claudeHookStep(env, commands, project, true)
+  ],
+  check: claudeChecks
+};
+var grok = {
+  id: "grok",
+  name: "Grok Build",
+  detect: (env) => env.which("grok") !== null || existsSync(join(env.home, ".grok")),
+  install: (env, commands, project) => claude.detect(env) ? [{ kind: "skip", summary: "reads Claude Code's files, written above" }] : [
+    ...claudeMcpSteps(env, commands, project, false, false),
+    claudeHookStep(env, commands, project, false)
+  ],
+  remove: (env, commands, project) => claude.detect(env) ? [{ kind: "skip", summary: "reads Claude Code's files, handled above" }] : [
+    ...claudeMcpSteps(env, commands, project, true, false),
+    claudeHookStep(env, commands, project, true)
+  ],
+  check: claudeChecks
+};
+var CODEX_HOOKS = {
+  shape: "nested",
+  events: [{ name: "PostToolUse", matcher: "mcp__.*" }],
+  entry: (command) => ({ type: "command", command, timeout: 10 })
+};
+var GEMINI_HOOKS = {
+  shape: "nested",
+  events: [{ name: "AfterTool", matcher: "mcp_.*" }],
+  entry: (command) => ({ type: "command", command, timeout: 1e4 })
+};
+var CURSOR_HOOKS = {
+  shape: "flat",
+  events: [{ name: "postToolUse" }, { name: "postToolUseFailure" }, { name: "afterMCPExecution" }],
+  entry: (command) => ({ command, timeout: 10 })
+};
+var COPILOT_HOOKS = {
+  shape: "flat",
+  events: [{ name: "postToolUse" }],
+  entry: (command) => ({ type: "command", command, timeoutSec: 10 })
+};
+var NO_HOOK = {
+  kind: "skip",
+  summary: "no hook: it cannot read this runtime yet (`arp init --capture` helps, task 33i)"
+};
+function noHook(path, spec, commands) {
+  const removal = hookStep(path, spec, commands, true);
+  return removal.kind === "file" && removal.before !== removal.after ? removal : NO_HOOK;
+}
+function hookStep(path, spec, commands, remove) {
+  return jsonStep(path, (settings) => withHooks(settings, spec, remove ? null : commands.hook, commands.hookFile), remove ? `hooks: arp removed (${spec.events.map((e) => e.name).join(", ")})` : `hooks: arp on ${spec.events.map((e) => e.name).join(", ")}${commands.capture ? ", capturing" : ""}`, (settings) => hooksOf(settings, spec, commands.hookFile));
+}
+function jsonMcpRuntime(options) {
+  const { id, name, dir, file, typed, binary, hook } = options;
+  const root = (env, project) => project ? env.cwd : env.home;
+  const path = (env, project) => join(root(env, project), dir, file);
+  const hookPath = (env, project) => join(root(env, project), dir, hook.file);
+  const mcpEdit = (commands) => (config) => withMcpServer(config, SERVER_NAME, commands === null ? null : mcpEntry(commands.mcp, typed));
+  const steps = (env, commands, project, remove) => {
+    const withHook = remove || commands.capture;
+    const foreignHere = hasForeignServer(path(env, project), commands);
+    if (!remove && !commands.force && foreignHere) {
+      const refusal = foreignRefusal(path(env, project));
+      if (hook.file === file || !withHook)
+        return [refusal];
+      return [refusal, hookStep(hookPath(env, project), hook.spec, commands, false)];
+    }
+    const foreign = remove && foreignHere;
+    const serverEdit = foreign ? (config) => config : mcpEdit(remove ? null : commands);
+    if (hook.file === file) {
+      return [
+        jsonStep(path(env, project), (config) => withHooks(serverEdit(config), hook.spec, withHook && !remove ? commands.hook : null, commands.hookFile), foreign ? 'the arp hook removed; MCP server "arp" is not one ARP wrote, and stays' : remove ? "mcpServers.arp and the arp hook removed" : `mcpServers.arp${commands.capture ? " and the hook, capturing" : ""}`, (config) => ({
+          mcpServers: { arp: serversOf(config)[SERVER_NAME] },
+          hooks: hooksOf(config, hook.spec, commands.hookFile)
+        }))
+      ];
+    }
+    return [
+      foreign ? foreignServerStep(path(env, project)) : jsonStep(path(env, project), serverEdit, remove ? "mcpServers.arp removed" : `mcpServers.arp → ${commands.mcp.command} ${commands.mcp.args.join(" ")}`, (config) => serversOf(config)[SERVER_NAME]),
+      withHook ? hookStep(hookPath(env, project), hook.spec, commands, remove) : noHook(hookPath(env, project), hook.spec, commands)
+    ];
+  };
+  return {
+    id,
+    name,
+    detect: (env) => env.which(binary) !== null || existsSync(join(env.home, dir)),
+    install: (env, commands, project) => steps(env, commands, project, false),
+    remove: (env, commands, project) => steps(env, commands, project, true),
+    check: (env, _commands, project) => {
+      const config = parseJsonConfig(read(path(env, project)));
+      const present = !(config instanceof Error) && SERVER_NAME in serversOf(config);
+      return [[`MCP server "arp" declared (${path(env, project)})`, present]];
+    }
+  };
+}
+function codexStep(env, entry, project, force = false) {
+  const path = join(project ? env.cwd : env.home, ".codex", "config.toml");
+  const before = read(path);
+  const after = withCodexServer(before, entry, force);
+  if (after instanceof Error) {
+    const way = entry === null ? "" : ". Rename it, or run arp init --force to replace it";
+    return { kind: "skip", failed: true, summary: `${path}: ${after.message}; left as it is${way}` };
+  }
+  return {
+    kind: "file",
+    path,
+    before,
+    after: after.length === 0 ? null : after,
+    summary: entry === null ? "[mcp_servers.arp] removed" : `[mcp_servers.arp] → ${entry.command} ${entry.args.join(" ")}`,
+    diff: [
+      ...codexBlockOf(before).map((line) => `- ${line}`),
+      ...codexBlockOf(after).map((line) => `+ ${line}`)
+    ]
+  };
+}
+var codex = {
+  id: "codex",
+  name: "Codex",
+  detect: (env) => env.which("codex") !== null || existsSync(join(env.home, ".codex")),
+  install: (env, commands, project) => [
+    codexStep(env, commands.mcp, project, commands.force),
+    commands.capture ? hookStep(join(project ? env.cwd : env.home, ".codex", "hooks.json"), CODEX_HOOKS, commands, false) : noHook(join(project ? env.cwd : env.home, ".codex", "hooks.json"), CODEX_HOOKS, commands)
+  ],
+  remove: (env, commands, project) => [
+    codexStep(env, null, project),
+    hookStep(join(project ? env.cwd : env.home, ".codex", "hooks.json"), CODEX_HOOKS, commands, true)
+  ],
+  check: (env, _commands, project) => {
+    const path = join(project ? env.cwd : env.home, ".codex", "config.toml");
+    return [[`MCP server "arp" declared (${path})`, hasCodexServer(read(path))]];
+  }
+};
+var RUNTIMES = [
+  claude,
+  grok,
+  jsonMcpRuntime({
+    id: "cursor",
+    name: "Cursor",
+    dir: ".cursor",
+    file: "mcp.json",
+    typed: true,
+    binary: "cursor",
+    hook: { file: "hooks.json", spec: CURSOR_HOOKS }
+  }),
+  jsonMcpRuntime({
+    id: "gemini",
+    name: "Gemini CLI",
+    dir: ".gemini",
+    file: "settings.json",
+    typed: false,
+    binary: "gemini",
+    hook: { file: "settings.json", spec: GEMINI_HOOKS }
+  }),
+  codex,
+  jsonMcpRuntime({
+    id: "copilot",
+    name: "Copilot (VS Code, CLI)",
+    dir: ".copilot",
+    file: "mcp-config.json",
+    typed: true,
+    binary: "copilot",
+    hook: { file: join("hooks", "arp.json"), spec: COPILOT_HOOKS }
+  })
+];
+
+// src/install/commands.ts
+var EXIT = {
+  ok: 0,
+  problems: 1,
+  usage: 2,
+  refused: 3,
+  nothingFound: 4,
+  writeFailed: 5,
+  partly: 6
+};
+function parseFlags(args) {
+  const flags = {
+    yes: false,
+    noInput: false,
+    dryRun: false,
+    project: false,
+    print: false,
+    capture: false,
+    sponsored: false,
+    force: false,
+    runtimes: null
+  };
+  for (let i = 0;i < args.length; i += 1) {
+    const arg = args[i];
+    if (arg === "--yes" || arg === "-y")
+      flags.yes = true;
+    else if (arg === "--no-input")
+      flags.noInput = true;
+    else if (arg === "--dry-run" || arg === "-n")
+      flags.dryRun = true;
+    else if (arg === "--project")
+      flags.project = true;
+    else if (arg === "--print")
+      flags.print = true;
+    else if (arg === "--capture")
+      flags.capture = true;
+    else if (arg === "--sponsored")
+      flags.sponsored = true;
+    else if (arg === "--force")
+      flags.force = true;
+    else if (arg === "--runtime") {
+      const list = (args[i + 1] ?? "").split(",").filter((name) => name.length > 0);
+      i += 1;
+      const unknown = list.filter((name) => !RUNTIME_IDS.includes(name));
+      if (list.length === 0 || unknown.length > 0) {
+        return new Error(`--runtime takes a comma list of: ${RUNTIME_IDS.join(", ")}`);
+      }
+      flags.runtimes = list;
+    } else
+      return new Error(`unknown option ${String(arg)}`);
+  }
+  return flags;
+}
+function selected(env, flags) {
+  return RUNTIMES.filter((runtime) => flags.runtimes === null ? runtime.detect(env) : flags.runtimes.includes(runtime.id));
+}
+function installsHook(runtimes, capture) {
+  return capture ? runtimes.length > 0 : runtimes.some((runtime) => runtime.id === "claude" || runtime.id === "grok");
+}
+function read2(path) {
+  try {
+    return existsSync2(path) ? readFileSync2(path, "utf8") : null;
+  } catch {
+    return null;
+  }
+}
+function changes(step) {
+  return step.kind === "command" || step.kind === "file" && step.before !== step.after;
+}
+function stamp(date) {
+  return date.toISOString().replace(/[-:]/g, "").replace(/\..+$/, "").replace("T", "-");
+}
+function apply(env, step) {
+  try {
+    if (step.kind === "command") {
+      const result = env.run(step.argv);
+      return result.code === 0 ? null : `${step.argv.join(" ")}: ${result.stderr.trim() || `exit ${String(result.code)}`}`;
+    }
+    if (step.kind !== "file")
+      return null;
+    if (step.before !== null)
+      copyFileSync(step.path, `${step.path}.arp-backup-${stamp(env.now())}`);
+    if (step.after === null) {
+      rmSync(step.path, { force: true });
+      return null;
+    }
+    mkdirSync(dirname(step.path), { recursive: true });
+    const mode = step.before === null ? undefined : statSync(step.path).mode & 511;
+    const temp = `${step.path}.arp-tmp`;
+    writeFileSync(temp, step.after, mode === undefined ? undefined : { mode });
+    if (mode !== undefined)
+      chmodSync(temp, mode);
+    renameSync(temp, step.path);
+    return null;
+  } catch (error) {
+    return `${step.kind === "file" ? step.path : ""}: ${String(error)}`;
+  }
+}
+function hookFileStep(env, commands, remove) {
+  const before = read2(commands.hookFile);
+  const after = remove ? null : read2(join2(env.dist, "hook.js"));
+  if (!remove && after === null) {
+    return {
+      kind: "skip",
+      failed: true,
+      summary: `no hook.js next to this arp (${env.dist}); build it first`
+    };
+  }
+  return {
+    kind: "file",
+    path: commands.hookFile,
+    before,
+    after,
+    summary: remove ? "removed" : `the hook, ${after?.length ?? 0} bytes, run by ${env.node}`,
+    diff: []
+  };
+}
+async function consent(env, flags, question) {
+  if (flags.yes)
+    return true;
+  if (flags.noInput || !env.interactive) {
+    env.err("arp: changes needed and no terminal to ask. Re-run with --yes, or --dry-run to look first.");
+    return false;
+  }
+  return env.ask(question);
+}
+async function change(env, flags, plan, verb) {
+  const pending = plan.flatMap((group) => group.steps.filter(changes));
+  const leftOut = plan.flatMap((group) => group.steps.flatMap((step) => step.kind === "skip" && step.failed === true ? [`${group.runtime}: ${step.summary}`] : []));
+  const finish = () => {
+    if (leftOut.length === 0)
+      return EXIT.ok;
+    env.err(`
+Not done in ${leftOut.length} place(s):`);
+    for (const line of leftOut)
+      env.err(`  ${line}`);
+    return EXIT.partly;
+  };
+  for (const group of plan) {
+    env.out(group.runtime);
+    for (const step of group.steps) {
+      if (step.kind === "skip")
+        env.out(`  --  ${step.summary}`);
+      else if (step.kind === "command")
+        env.out(`  run ${step.summary}`);
+      else
+        env.out(`  ${changes(step) ? step.after === null ? "del" : "set" : "ok "} ${step.path}
+        ${step.summary}`);
+      if (step.kind !== "skip" && changes(step))
+        for (const line of step.diff)
+          env.out(`        ${line}`);
+    }
+  }
+  if (pending.length === 0) {
+    env.out(`
+Nothing to change.`);
+    return finish();
+  }
+  if (flags.dryRun) {
+    env.out(`
+--dry-run: ${pending.length} change(s) shown, nothing written.`);
+    return finish();
+  }
+  env.out(`
+Each file is backed up as <file>.arp-backup-<date> before it is written. A change through the \`claude\` command has no backup: what it removes is printed above.`);
+  if (!await consent(env, flags, `${verb} ${pending.length} change(s)?`))
+    return EXIT.refused;
+  const failures = pending.map((step) => apply(env, step)).filter((f) => f !== null);
+  for (const failure of failures)
+    env.err(`arp: ${failure}`);
+  if (failures.length > 0)
+    return EXIT.writeFailed;
+  env.out(`Done. ${verb === "Install" ? "Restart your agent runtime to load the MCP server; hooks load on their own." : "Removed."}`);
+  return finish();
+}
+async function init(env, flags, cliPath) {
+  const commands = commandsFor(env, cliPath, flags.capture, flags.sponsored, flags.force);
+  if (flags.print) {
+    env.out(JSON.stringify({ mcpServers: { arp: commands.mcp } }, null, 2));
+    return EXIT.ok;
+  }
+  const runtimes = selected(env, flags);
+  if (runtimes.length === 0) {
+    env.err(`arp: no supported runtime found (${RUNTIME_IDS.join(", ")}).`);
+    env.err("For any other MCP client, `arp init --print` prints the entry to paste.");
+    return EXIT.nothingFound;
+  }
+  const plan = runtimes.map((runtime) => ({
+    runtime: runtime.name,
+    steps: runtime.install(env, commands, flags.project)
+  }));
+  if (installsHook(runtimes, flags.capture)) {
+    plan.push({ runtime: "hook", steps: [hookFileStep(env, commands, false)] });
+  }
+  return change(env, flags, plan, "Install");
+}
+async function uninstall(env, flags, cliPath) {
+  const commands = commandsFor(env, cliPath);
+  const runtimes = selected(env, flags);
+  const plan = runtimes.map((runtime) => ({
+    runtime: runtime.name,
+    steps: runtime.remove(env, commands, flags.project)
+  }));
+  plan.push({ runtime: "hook", steps: [hookFileStep(env, commands, true)] });
+  const code = await change(env, flags, plan, "Remove");
+  const captures = join2(env.home, ".arp", "captures");
+  if (existsSync2(captures))
+    env.out(`Captures kept in ${captures}. Delete them when you no longer need them.`);
+  return code;
+}
+var INITIALIZE = `${JSON.stringify({ jsonrpc: "2.0", id: 1, method: "initialize", params: {} })}
+`;
+function doctor(env, flags, cliPath) {
+  const commands = commandsFor(env, cliPath);
+  const runtimes = selected(env, flags);
+  const rows = [];
+  if (runtimes.length === 0)
+    rows.push(["runtime", `none of ${RUNTIME_IDS.join(", ")} found`, false]);
+  for (const runtime of runtimes) {
+    for (const [what, ok] of runtime.check(env, commands, flags.project))
+      rows.push([runtime.name, what, ok]);
+  }
+  if (installsHook(runtimes, false)) {
+    const installed = read2(commands.hookFile);
+    const packaged = read2(join2(env.dist, "hook.js"));
+    rows.push(["hook", `${commands.hookFile} present`, installed !== null]);
+    if (installed !== null && packaged !== null) {
+      rows.push([
+        "hook",
+        "same version as this arp (else run arp init again)",
+        installed === packaged
+      ]);
+    }
+    rows.push(["hook", `node at ${env.node}`, existsSync2(env.node)]);
+  }
+  const answer = env.run([commands.mcp.command, ...commands.mcp.args], INITIALIZE, 30000);
+  rows.push([
+    "MCP server",
+    `answers initialize (${commands.mcp.command} ${commands.mcp.args.join(" ")})`,
+    answer.stdout.includes('"name":"ARP"')
+  ]);
+  const log = read2(join2(env.cwd, ".arp", "session.jsonl"));
+  const last = log?.trim().split(`
+`).pop();
+  let lastAt = null;
+  try {
+    const parsed = last === undefined ? null : JSON.parse(last);
+    if (typeof parsed === "object" && parsed !== null && "at" in parsed && typeof parsed.at === "string")
+      lastAt = parsed.at;
+  } catch {
+    lastAt = null;
+  }
+  for (const [where, what, ok] of rows)
+    env.out(`${ok ? "ok  " : "FAIL"}  ${where.padEnd(12)} ${what}`);
+  env.out(`--    session log  ${lastAt === null ? `no call recorded in ${join2(env.cwd, ".arp")}` : `last call recorded ${lastAt}`}`);
+  return rows.every(([, , ok]) => ok) ? EXIT.ok : EXIT.problems;
+}
+export {
+  uninstall,
+  parseFlags,
+  init,
+  doctor,
+  EXIT
+};