@jpkme/diff-review 0.1.10 → 0.1.13

package/lib/acp-shell.test.mjs

@@ -0,0 +1,158 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { checkShell, tokenizeShell } from "./acp-shell.mjs";
+
+const win = process.platform === "win32";
+const repo = win ? "C:\\repos\\app" : "/repos/app";
+const out = "diff-rev_75eca0c739_52eb729c8f.json";
+const ok = (cmd) => checkShell(cmd, { repo }).ok;
+
+test("tokenizeShell respeta comillas y separa cadenas y pipes", () => {
+  const parsed = tokenizeShell(`git show main:a.ts | grep -n "a\\|b|c" ; echo 'x; y' && ls`);
+  assert.equal(parsed.ok, true);
+  assert.deepEqual(parsed.pipelines, [
+    [
+      ["git", "show", "main:a.ts"],
+      ["grep", "-n", "a\\|b|c"],
+    ],
+    [["echo", "x; y"]],
+    [["ls"]],
+  ]);
+});
+
+test("tokenizeShell descarta salida a /dev/null y rechaza el resto de redirecciones", () => {
+  assert.equal(tokenizeShell("git diff 2>&1").ok, true);
+  assert.equal(tokenizeShell("git diff 2>/dev/null || true").ok, true);
+  assert.equal(tokenizeShell("git diff &>/dev/null").ok, true);
+  assert.equal(tokenizeShell("Get-Content a.txt 2>$null").ok, true);
+  assert.equal(tokenizeShell("git diff > x.patch").ok, false);
+  assert.equal(tokenizeShell("git diff >> x.patch").ok, false);
+  assert.equal(tokenizeShell("cat < a").ok, false);
+  assert.equal(tokenizeShell('echo "$(whoami)"').ok, false);
+  assert.equal(tokenizeShell("echo `whoami`").ok, false);
+  assert.equal(tokenizeShell("sleep 1 & curl x").ok, false);
+  assert.equal(tokenizeShell('echo "sin cerrar').ok, false);
+});
+
+test("checkShell deja git de lectura, el validate y comandos que solo leen", () => {
+  for (const cmd of [
+    "git diff main~1...main",
+    "git --no-pager log --oneline -5",
+    `git -C "${repo}" diff --stat a...b`,
+    "git merge-base develop feat/x && git diff --stat develop...feat/x",
+    "git show HEAD:lib/a.mjs | head -50",
+    "git branch --show-current",
+    "git remote get-url origin",
+    "git config --get remote.origin.url",
+    `npx --yes @jpkme/diff-review validate ${out}`,
+    `npx --yes @jpkme/diff-review@latest validate ${out}`,
+    `cd "${repo}" && git diff a...b`,
+    `cd "${repo}"; git diff`,
+    // Lo que mandó Claude en las pruebas.
+    `git show main:web/src/routes/+page.svelte | sed -n 560,660p; git show main:web/src/lib/report/storage.ts | sed -n 1,60p`,
+    `git show main:web/src/routes/+page.svelte | grep -n -A6 "function updateMeta\\|openNewReport(pendingDoc\\|const ctx"`,
+    `grep -rn "validateDocument(" web/src --include="*.ts"`,
+    "cat package.json | head -20",
+    "ls -la lib",
+    "find web/src -name '*.svelte' -type f",
+    "wc -l lib/*.mjs",
+    "rg -n 'export function' lib",
+    "sed -n '10,40p' lib/agents.mjs",
+    "git diff a...b -- lib 2>/dev/null || true",
+    "Get-Content lib/agents.mjs | Select-Object -First 40",
+    "Select-String -Path lib/*.mjs -Pattern 'export'",
+  ]) {
+    assert.equal(ok(cmd), true, cmd);
+  }
+});
+
+test("checkShell rechaza escrituras, ejecución y paths fuera del repo", () => {
+  const home = win ? "C:\\Users\\me\\.ssh\\id_rsa" : "/home/me/.ssh/id_rsa";
+  for (const cmd of [
+    "",
+    "git checkout main",
+    "git branch -D feat",
+    "git push",
+    "git -c core.pager=sh log",
+    "git diff --output=x.patch main",
+    "git diff --ext-diff",
+    "git grep -O foo",
+    "git diff; rm -rf .",
+    "git log | xargs rm",
+    "git diff > x.patch",
+    "GIT_PAGER=sh git log",
+    "npm install",
+    "curl https://example.com",
+    "node -e 'x'",
+    `npx --yes @jpkme/diff-review validate ${out} && rm x`,
+    "npx --yes other-pkg validate x.json",
+    "sed -i 's/a/b/' lib/a.mjs",
+    "sed -n 's/a/b/w out' lib/a.mjs",
+    "find . -name '*.js' -delete",
+    "find . -exec rm {} ;",
+    "sort -o out.txt a.txt",
+    "uniq a.txt b.txt",
+    "rg --pre sh foo",
+    `cat "${home}"`,
+    "cat ~/.ssh/id_rsa",
+    "cat ../otro/secreto",
+    `cd "${join(repo, "..")}" && git diff a...b`,
+    "cd && cat .bashrc",
+    "Remove-Item lib",
+    "Get-ChildItem | ForEach-Object { Remove-Item $_ }",
+  ]) {
+    assert.equal(ok(cmd), false, cmd);
+  }
+});
+
+test("checkShell sin repo no acepta cd", () => {
+  assert.equal(checkShell(`cd "${repo}" && git diff`).ok, false);
+});
+
+test("checkShell permite mkdir bajo .diff-review en el repo", () => {
+  assert.equal(ok("mkdir .diff-review"), true);
+  assert.equal(ok("mkdir -p .diff-review"), true);
+  assert.equal(ok("mkdir .diff-review/tmp"), true);
+  assert.equal(ok(`mkdir "${join(repo, ".diff-review")}"`), true);
+  assert.equal(ok("mkdir lib"), false);
+  assert.equal(ok("mkdir .diff-review other"), false);
+  assert.equal(ok("New-Item -ItemType Directory .diff-review"), true);
+  assert.equal(ok("New-Item -ItemType Directory lib"), false);
+});
+
+test("checkShell entiende paths de Git Bash y WSL en Windows", { skip: !win }, () => {
+  assert.equal(ok("cat /c/repos/app/lib/a.mjs"), true);
+  assert.equal(ok("cat /c/Users/me/.ssh/id_rsa"), false);
+  assert.equal(ok("cd /mnt/c/repos/app && ls -la"), true);
+  assert.equal(ok("cat /mnt/c/repos/app/lib/a.mjs"), true);
+  assert.equal(ok("cd /mnt/c/Users/me && ls"), false);
+  assert.equal(ok("cat /mnt/c/Users/me/.ssh/id_rsa"), false);
+});
+
+test("checkShell rechaza symlink dentro del repo que apunta afuera", () => {
+  const root = mkdtempSync(join(tmpdir(), "dr-shell-"));
+  const outside = mkdtempSync(join(tmpdir(), "dr-shell-out-"));
+  writeFileSync(join(outside, "secret.txt"), "secret");
+  mkdirSync(join(root, "lib"), { recursive: true });
+  writeFileSync(join(root, "lib", "ok.mjs"), "ok");
+  const link = join(root, "escape");
+  try {
+    symlinkSync(outside, link, process.platform === "win32" ? "junction" : "dir");
+  } catch (err) {
+    rmSync(root, { recursive: true, force: true });
+    rmSync(outside, { recursive: true, force: true });
+    if (err && (err.code === "EPERM" || err.code === "EACCES")) return;
+    throw err;
+  }
+  try {
+    assert.equal(checkShell(`cat "${join(root, "lib", "ok.mjs")}"`, { repo: root }).ok, true);
+    assert.equal(checkShell(`cat "${join(link, "secret.txt")}"`, { repo: root }).ok, false);
+    assert.equal(checkShell(`cd "${link}" && ls`, { repo: root }).ok, false);
+  } finally {
+    rmSync(root, { recursive: true, force: true });
+    rmSync(outside, { recursive: true, force: true });
+  }
+});

package/lib/acp.mjs

@@ -0,0 +1,368 @@
+/**
+ * Sesión con un agente por ACP (Agent Client Protocol): JSON-RPC por stdin/stdout del proceso del agente.
+ *
+ * A diferencia de `runAgent` (una vuelta headless), el proceso queda vivo: la misma sesión sirve para generar la
+ * review y después para las preguntas y los cambios que se le pidan desde la web. Cada pedido de permiso pasa por
+ * `decide` (ver `acp-policy.mjs`): no hay nadie mirando una terminal para aprobar.
+ */
+import { Readable, Writable } from "node:stream";
+import * as acp from "@agentclientprotocol/sdk";
+import { spawnCommand } from "./agents.mjs";
+import { permissionOutcome } from "./acp-policy.mjs";
+import { looksLikeAuthFailure } from "./agent-login.mjs";
+import { readModelsCache, writeModelsCache } from "./models-cache.mjs";
+
+/**
+ * @typedef {import('./agents.mjs').DetectedAgent} DetectedAgent
+ * @typedef {import('@agentclientprotocol/sdk').SessionUpdate} SessionUpdate
+ * @typedef {import('@agentclientprotocol/sdk').RequestPermissionRequest} PermissionRequest
+ * @typedef {{ allow: boolean, reason: string }} Decision
+ * @typedef {{ value: string, name: string }} ModelOption
+ * @typedef {{
+ *   cwd: string,
+ *   model?: string,
+ *   resumeSessionId?: string,
+ *   decide: (toolCall: PermissionRequest['toolCall']) => Decision,
+ *   onUpdate?: (update: SessionUpdate) => void,
+ *   onPermission?: (toolCall: PermissionRequest['toolCall'], decision: Decision) => void,
+ *   // Si la política niega: pedir confirmación al usuario.
+ *   // `true` / `{ allow: true }` = allow_once; `{ allow: true, always: true }` = allow_always (si el agente lo ofrece).
+ *   onDeniedPermission?: (
+ *     toolCall: PermissionRequest['toolCall'],
+ *     decision: Decision,
+ *   ) => Promise<boolean | { allow: boolean, always?: boolean }>,
+ *   onExit?: (info: { code: number | null, stderr: string }) => void,
+ *   timeoutMs?: number,
+ * }} AcpSessionOptions
+ * @typedef {{
+ *   sessionId: string,
+ *   resumed: boolean,
+ *   models: ModelOption[],
+ *   currentModel: string,
+ *   modelWarning?: string,
+ *   setModel: (model: string) => Promise<{ currentModel: string, warning?: string }>,
+ *   prompt: (text: string) => Promise<{ stopReason: string }>,
+ *   cancel: () => Promise<void>,
+ *   close: () => void,
+ *   closed: Promise<void>,
+ *   stderrTail: () => string,
+ * }} AcpSession
+ */
+
+/** Cuántos caracteres de stderr del agente se guardan para explicar un fallo. */
+const STDERR_TAIL = 4000;
+
+/** El agente tiene un modo ACP declarado (no todos los agentes lo traen). */
+export function supportsAcp(agent) {
+  return typeof agent?.def?.acp === "function";
+}
+
+/**
+ * Opción de modelo (`configOptions` con id/categoría "model") de la respuesta de `session/new` o `session/load`.
+ * @param {{ configOptions?: any[] | null }} response
+ */
+export function modelConfig(response) {
+  const option = (response?.configOptions ?? []).find((o) => o?.category === "model" || o?.id === "model");
+  if (!option || option.type !== "select") return null;
+  const flat = (option.options ?? []).flatMap((o) => (Array.isArray(o?.options) ? o.options : [o]));
+  return {
+    configId: String(option.id),
+    current: String(option.currentValue ?? ""),
+    options: flat
+      .filter((o, i) => o && typeof o.value === "string" && flat.findIndex((x) => x?.value === o.value) === i)
+      .map((o) => ({ value: o.value, name: String(o.name ?? o.value) })),
+  };
+}
+
+/** Tiempo máximo para initialize + session/new|load (+ set model). */
+const ACP_START_TIMEOUT_MS = 90_000;
+
+/**
+ * Lanza el agente en modo ACP, negocia y abre (o retoma) una sesión.
+ * @param {DetectedAgent} agent
+ * @param {AcpSessionOptions} opts
+ * @returns {Promise<AcpSession>}
+ */
+export async function startAcpSession(agent, opts) {
+  if (!supportsAcp(agent)) throw new Error(`${agent.def.label} no tiene modo ACP.`);
+  const { file, args, env, sessionMeta } = agent.def.acp({ path: agent.path });
+  const child = spawnCommand(file, args, {
+    cwd: opts.cwd,
+    stdio: ["pipe", "pipe", "pipe"],
+    ...(env ? { env: { ...process.env, ...env } } : {}),
+  });
+
+  let stderr = "";
+  child.stderr?.on("data", (chunk) => {
+    stderr = (stderr + String(chunk)).slice(-STDERR_TAIL);
+  });
+  child.stdin?.on("error", () => {});
+
+  const conn = acp
+    .client({ name: "diff-review" })
+    .onRequest(acp.methods.client.session.requestPermission, async (ctx) => {
+      const toolCall = ctx.params.toolCall;
+      const decision = safeDecide(opts.decide, toolCall);
+      if (decision.allow) {
+        opts.onPermission?.(toolCall, decision);
+        return permissionOutcome(ctx.params.options, true);
+      }
+      // Política niega: no rechazar al toque — la UI puede permitir una vez / sesión / siempre.
+      let allow = false;
+      let always = false;
+      if (opts.onDeniedPermission) {
+        try {
+          const answer = await opts.onDeniedPermission(toolCall, decision);
+          if (answer && typeof answer === "object") {
+            allow = Boolean(answer.allow);
+            always = Boolean(answer.always);
+          } else {
+            allow = Boolean(answer);
+          }
+        } catch {
+          allow = false;
+          always = false;
+        }
+      }
+      const final = {
+        allow,
+        reason: allow ? (always ? "permitido siempre" : "permitido por el usuario") : decision.reason,
+      };
+      opts.onPermission?.(toolCall, final);
+      return permissionOutcome(ctx.params.options, allow, { always });
+    })
+    .onNotification(acp.methods.client.session.update, (ctx) => {
+      opts.onUpdate?.(ctx.params.update);
+    })
+    .connect(acp.ndJsonStream(Writable.toWeb(child.stdin), Readable.toWeb(child.stdout)));
+
+  const exited = new Promise((resolve) => {
+    child.once("error", (err) => {
+      stderr += `\n${err.message}`;
+      resolve(null);
+    });
+    child.once("exit", (code) => resolve(code));
+  });
+  exited.then((code) => {
+    conn.close(new Error(`${agent.def.label} terminó (código ${code ?? "?"}).`));
+    opts.onExit?.({ code, stderr });
+  });
+
+  const close = () => {
+    conn.close();
+    if (child.exitCode == null) child.kill();
+  };
+
+  const timeoutMs = Math.max(15_000, Number(opts.timeoutMs) || ACP_START_TIMEOUT_MS);
+  let timedOut = false;
+  const timer = setTimeout(() => {
+    timedOut = true;
+    close();
+  }, timeoutMs);
+
+  try {
+    const init = await conn.agent.request(acp.methods.agent.initialize, {
+      protocolVersion: acp.PROTOCOL_VERSION,
+      clientCapabilities: { fs: { readTextFile: false, writeTextFile: false }, terminal: false },
+      clientInfo: { name: "diff-review", version: "0" },
+    });
+
+    const authMethods = Array.isArray(init.authMethods) ? init.authMethods : [];
+    /** Métodos donde el agente maneja el login por `authenticate` (no terminal interactiva). */
+    const agentAuthMethods = authMethods.filter((m) => m && (!m.type || m.type === "agent") && m.id);
+
+    /** Si session/new falla por auth, pedimos `authenticate` una vez y reintentamos. */
+    const tryAuthenticate = async () => {
+      for (const method of agentAuthMethods) {
+        try {
+          await conn.agent.request(acp.methods.agent.authenticate, { methodId: method.id });
+          return true;
+        } catch {
+          /* siguiente método */
+        }
+      }
+      return false;
+    };
+
+    const openNewSession = async () => {
+      try {
+        return await conn.agent.request(acp.methods.agent.session.new, {
+          cwd: opts.cwd,
+          mcpServers: [],
+          ...(sessionMeta ? { _meta: sessionMeta } : {}),
+        });
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        if (agentAuthMethods.length && looksLikeAuthFailure(msg) && (await tryAuthenticate())) {
+          return await conn.agent.request(acp.methods.agent.session.new, {
+            cwd: opts.cwd,
+            mcpServers: [],
+            ...(sessionMeta ? { _meta: sessionMeta } : {}),
+          });
+        }
+        throw err;
+      }
+    };
+
+    let sessionId = "";
+    let response;
+    let resumed = false;
+    if (opts.resumeSessionId && init.agentCapabilities?.loadSession) {
+      try {
+        response = await conn.agent.request(acp.methods.agent.session.load, {
+          sessionId: opts.resumeSessionId,
+          cwd: opts.cwd,
+          mcpServers: [],
+          ...(sessionMeta ? { _meta: sessionMeta } : {}),
+        });
+        sessionId = opts.resumeSessionId;
+        resumed = true;
+      } catch {
+        /* la sesión ya no existe del lado del agente: se abre una nueva */
+      }
+    }
+    if (!resumed) {
+      response = await openNewSession();
+      sessionId = response.sessionId;
+    }
+
+    const models = modelConfig(response);
+    let currentModel = models?.current ?? "";
+
+    /**
+     * @param {string} model
+     * @returns {Promise<{ currentModel: string, warning?: string }>}
+     */
+    const setModel = async (model) => {
+      const wanted = String(model || "").trim();
+      if (!wanted || wanted === currentModel) return { currentModel };
+      if (!models) {
+        return { currentModel, warning: `El agente no deja elegir el modelo por ACP; usa el suyo.` };
+      }
+      if (!models.options.some((o) => o.value === wanted)) {
+        return {
+          currentModel,
+          warning: `El agente no ofrece el modelo "${wanted}"; sigue con "${currentModel}".`,
+        };
+      }
+      await conn.agent.request(acp.methods.agent.session.setConfigOption, {
+        sessionId,
+        configId: models.configId,
+        value: wanted,
+      });
+      currentModel = wanted;
+      return { currentModel };
+    };
+
+    let modelWarning;
+    const initialWanted = String(opts.model || "").trim();
+    if (initialWanted) {
+      const applied = await setModel(initialWanted);
+      if (applied.warning) modelWarning = applied.warning;
+    }
+
+    clearTimeout(timer);
+    return {
+      sessionId,
+      resumed,
+      models: models?.options ?? [],
+      get currentModel() {
+        return currentModel;
+      },
+      ...(modelWarning ? { modelWarning } : {}),
+      setModel,
+      prompt: async (text) => {
+        const res = await conn.agent.request(acp.methods.agent.session.prompt, {
+          sessionId,
+          prompt: [{ type: "text", text }],
+        });
+        return { stopReason: String(res.stopReason) };
+      },
+      cancel: () => conn.agent.notify(acp.methods.agent.session.cancel, { sessionId }),
+      close,
+      closed: conn.closed,
+      stderrTail: () => stderr,
+    };
+  } catch (err) {
+    clearTimeout(timer);
+    close();
+    const tail = stderr.trim().split(/\r?\n/).slice(-8).join("\n");
+    if (timedOut) {
+      const msg = `Timeout (${Math.round(timeoutMs / 1000)}s) al lanzar ${agent.def.label}. ¿Está autenticado el CLI?`;
+      throw new Error(tail ? `${msg}\n${tail}` : msg);
+    }
+    const reason = err instanceof Error ? err.message : String(err);
+    throw new Error(tail ? `${reason}\n${tail}` : reason);
+  }
+}
+
+/**
+ * Modelos ACP con caché en `~/.diff-review/models-cache.json` (TTL 24h).
+ * @param {DetectedAgent} agent
+ * @param {{ cwd: string, timeoutMs?: number, force?: boolean }} opts
+ * @returns {Promise<{ models: ModelOption[], currentModel: string, fromCache: boolean }>}
+ */
+export async function listAcpModelsCached(agent, opts) {
+  const force = Boolean(opts?.force);
+  if (!force) {
+    const hit = readModelsCache(agent.def.id);
+    if (hit) {
+      return { models: hit.models, currentModel: hit.currentModel, fromCache: true };
+    }
+  }
+  const result = await listAcpModels(agent, opts);
+  if (result.models.length) writeModelsCache(agent.def.id, result);
+  return { ...result, fromCache: false };
+}
+
+/**
+ * Modelos que ofrece el agente por ACP (abre una sesión, lee las opciones y la cierra; no manda ningún prompt).
+ * @param {DetectedAgent} agent
+ * @param {{ cwd: string, timeoutMs?: number }} opts
+ * @returns {Promise<{ models: ModelOption[], currentModel: string }>}
+ */
+export async function listAcpModels(agent, { cwd, timeoutMs = 45_000 }) {
+  const ms = Math.max(5_000, Number(timeoutMs) || 45_000);
+  /** @type {AcpSession | null} */
+  let session = null;
+  const pending = startAcpSession(agent, {
+    cwd,
+    decide: () => ({ allow: false, reason: "solo se listan modelos" }),
+  }).then((s) => {
+    session = s;
+    return s;
+  });
+  const timeout = new Promise((_, reject) => {
+    setTimeout(() => {
+      reject(
+        new Error(
+          `Timeout (${Math.round(ms / 1000)}s) al consultar modelos de ${agent.def.label}. Reintentá en unos segundos.`
+        )
+      );
+    }, ms);
+  });
+  try {
+    const opened = await Promise.race([pending, timeout]);
+    const out = { models: opened.models, currentModel: opened.currentModel };
+    opened.close();
+    session = null;
+    return out;
+  } catch (err) {
+    pending.then((s) => s.close()).catch(() => {});
+    try {
+      session?.close();
+    } catch {
+      /* ya cerrada */
+    }
+    throw err;
+  }
+}
+
+/** Un error en la política no puede colgar al agente esperando respuesta: se rechaza. */
+function safeDecide(decide, toolCall) {
+  try {
+    return decide(toolCall);
+  } catch (err) {
+    return { allow: false, reason: `error en la política: ${err instanceof Error ? err.message : err}` };
+  }
+}

package/lib/acp.test.mjs

@@ -0,0 +1,58 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { AGENTS } from "./agents.mjs";
+import { modelConfig, supportsAcp } from "./acp.mjs";
+
+// Lo que devuelve claude-agent-acp en `session/new` (recortado).
+const claudeSession = {
+  sessionId: "s-1",
+  configOptions: [
+    { id: "mode", name: "Mode", category: "mode", type: "select", currentValue: "default", options: [{ value: "default", name: "Default" }] },
+    {
+      id: "model",
+      name: "Model",
+      category: "model",
+      type: "select",
+      currentValue: "default",
+      options: [
+        { value: "default", name: "Default (recommended)" },
+        { value: "opus", name: "Opus" },
+        { value: "haiku", name: "Haiku" },
+      ],
+    },
+  ],
+};
+
+test("modelConfig lee la opción de modelo de session/new", () => {
+  assert.deepEqual(modelConfig(claudeSession), {
+    configId: "model",
+    current: "default",
+    options: [
+      { value: "default", name: "Default (recommended)" },
+      { value: "opus", name: "Opus" },
+      { value: "haiku", name: "Haiku" },
+    ],
+  });
+});
+
+test("modelConfig aplana grupos de opciones y tolera agentes sin modelo", () => {
+  const grouped = {
+    configOptions: [
+      { id: "m", category: "model", type: "select", currentValue: "a", options: [{ group: "g", name: "G", options: [{ value: "a", name: "A" }] }] },
+    ],
+  };
+  assert.deepEqual(modelConfig(grouped)?.options, [{ value: "a", name: "A" }]);
+  assert.equal(modelConfig({ configOptions: [] }), null);
+  assert.equal(modelConfig({}), null);
+});
+
+test("supportsAcp: Claude Code tiene modo ACP", () => {
+  const claude = AGENTS.find((a) => a.id === "claude");
+  assert.equal(supportsAcp({ def: claude, path: "claude" }), true);
+  assert.equal(supportsAcp({ def: { ...claude, acp: undefined }, path: "claude" }), false);
+});
+
+test("modelConfig no repite modelos con el mismo valor", () => {
+  const dup = { configOptions: [{ id: "model", type: "select", currentValue: "auto", options: [{ value: "auto", name: "Auto" }, { value: "auto", name: "Auto" }, { value: "x", name: "X" }] }] };
+  assert.deepEqual(modelConfig(dup)?.options.map((o) => o.value), ["auto", "x"]);
+});

package/lib/agent-login.mjs

@@ -0,0 +1,105 @@
+/**
+ * Login de agentes ACP: mensajes claros + abrir una terminal interactiva cuando se pueda.
+ */
+import { spawn } from "node:child_process";
+
+/**
+ * @typedef {{ bin: string, args: string[], display: string }} LoginCommand
+ */
+
+/**
+ * Comando de login interactivo por agente (null = no hay CLI de login, p. ej. Cursor app).
+ * @param {string} agentId
+ * @returns {LoginCommand | null}
+ */
+export function loginCommand(agentId) {
+  switch (agentId) {
+    case "claude":
+      return { bin: "claude", args: ["/login"], display: "claude /login" };
+    case "copilot":
+      return { bin: "gh", args: ["auth", "login"], display: "gh auth login" };
+    case "codex":
+      return { bin: "codex", args: ["login"], display: "codex login" };
+    case "gemini":
+      return { bin: "gemini", args: [], display: "gemini" }; // el CLI guía el auth al arrancar
+    default:
+      return null;
+  }
+}
+
+/** @param {string} text */
+export function looksLikeAuthFailure(text) {
+  const s = String(text || "").toLowerCase();
+  return /(not\s+)?auth|login|unauthor|not logged|sign[\s-]?in|credentials|token.*(invalid|expired|missing)|please\s+run/.test(
+    s
+  );
+}
+
+/**
+ * Mensaje en español si el agente murió / falló por falta de login.
+ * @param {string} agentId
+ * @param {string} agentLabel
+ * @param {string} detail
+ * @returns {string | null}
+ */
+export function authFailureMessage(agentId, agentLabel, detail) {
+  if (!looksLikeAuthFailure(detail)) return null;
+  const cmd = loginCommand(agentId);
+  if (agentId === "cursor") {
+    return `${agentLabel} no está autenticado. Iniciá sesión en la app de Cursor y reintentá.`;
+  }
+  if (cmd) {
+    return `${agentLabel} no está autenticado. Corré \`${cmd.display}\` en una terminal y reintentá.`;
+  }
+  return `${agentLabel} no está autenticado. Revisá el login del agente y reintentá.`;
+}
+
+/**
+ * Abre una terminal nueva con el login del agente (Windows / macOS / Linux).
+ * @param {string} agentId
+ * @returns {{ display: string }}
+ */
+export function openLoginTerminal(agentId) {
+  const cmd = loginCommand(agentId);
+  if (!cmd) {
+    throw new Error(
+      agentId === "cursor"
+        ? "Cursor se autentica desde la app de escritorio, no desde una terminal."
+        : "Este agente no tiene un comando de login conocido."
+    );
+  }
+
+  const platform = process.platform;
+  if (platform === "win32") {
+    // `start "title" cmd /k …` — el primer quoted es el título de la ventana.
+    spawn("cmd.exe", ["/c", "start", `${cmd.bin} login`, "cmd.exe", "/k", cmd.bin, ...cmd.args], {
+      detached: true,
+      stdio: "ignore",
+      windowsHide: false,
+    }).unref();
+  } else if (platform === "darwin") {
+    const script = `tell application "Terminal" to do script ${JSON.stringify(`${cmd.bin} ${cmd.args.join(" ")}`.trim())}`;
+    spawn("osascript", ["-e", script], { detached: true, stdio: "ignore" }).unref();
+  } else {
+    const line = `${cmd.bin} ${cmd.args.join(" ")}`.trim();
+    const tried = [
+      ["x-terminal-emulator", ["-e", "bash", "-lc", `${line}; exec bash`]],
+      ["gnome-terminal", ["--", "bash", "-lc", `${line}; exec bash`]],
+      ["konsole", ["-e", "bash", "-lc", `${line}; exec bash`]],
+      ["xterm", ["-e", "bash", "-lc", `${line}; exec bash`]],
+    ];
+    let ok = false;
+    for (const [bin, args] of tried) {
+      try {
+        spawn(bin, args, { detached: true, stdio: "ignore" }).unref();
+        ok = true;
+        break;
+      } catch {
+        /* siguiente */
+      }
+    }
+    if (!ok) throw new Error(`No pude abrir una terminal. Corré a mano: ${cmd.display}`);
+  }
+
+  return { display: cmd.display };
+}