agent-cloud-kit 1.0.0-rc.1 → 1.0.0-rc.3

package/dist/prepare/index.js

@@ -9,7 +9,8 @@ import { readConfig } from "../config.js";
 import { CONFIG_FILE, OUTPUT_PREFIX, PACKAGE } from "../constants.js";
 import { defaultBranch } from "../detect.js";
 import { init } from "../init.js";
-import { renderEnvironmentSection, writeManual } from "../manual.js";
+import { MANUAL_FILE, renderEnvironmentSection, writeManual } from "../manual.js";
+import { claudeCommand, enterLine, hasFreeScript, renderBanner } from "./banner.js";
 import { preflight } from "./detect.js";
 import { configurePrompt, verifyPrompt } from "./prompts.js";
 /** Prefix of the branch `prepare` creates; the day follows it. */
@@ -29,21 +30,23 @@ const KNOWN_PATHS = [
 /** Project file of the test-audit skill, committed too when it exists. */
 const TEST_AUDIT_PROJECT_FILE = ".agents/skills/test-audit/project.md";
 /** Message of the commit `prepare` makes. */
-const COMMIT_MESSAGE = "chore: prepare the repo for the Claude Code cloud";
+const COMMIT_MESSAGE = "chore: prepara el repo para la nube de Claude Code";
 /** Question asked before committing changes outside the known files. */
-const INCLUDE_QUESTION = "Include these changes in the commit? [y/N]";
+const INCLUDE_QUESTION = "¿Incluir estos cambios en el commit? [s/N]";
 /** Answers to `INCLUDE_QUESTION` that mean yes. */
-const YES_ANSWER = /^y(es)?$/i;
+const YES_ANSWER = /^(s|si|sí|y|yes)$/i;
 /** Text shown while the user configures the environment in claude.ai. */
-const WAIT_TEXT = "Configure the environment in claude.ai, then press Enter";
+const WAIT_TEXT = "Configura el entorno en claude.ai y luego presiona Enter ";
 /** Matches a GitHub remote URL (https or ssh) and captures `owner/repo`. */
 const GITHUB_REMOTE = /github\.com[:/]([^/\s]+\/[^/\s]+?)(?:\.git)?\/?$/;
 /** Matches a pull request URL and captures its number. */
 const PR_URL = /\/pull\/(\d+)/;
 /** Command that continues a prepare run; `npx` because a first-time user does not have the binary on PATH. */
 const RESUME_COMMAND = `npx ${PACKAGE} prepare --resume`;
-/** Printed just before the local agent starts: `prepare` continues only when `claude` exits. */
-const EXIT_CLAUDE_HINT = `${OUTPUT_PREFIX}when the skill says configure is done, exit claude (/exit) and prepare will commit, push and open the PR`;
+/** Question of the place menu. */
+const PLACE_QUESTION = "¿Dónde preparo el repo?";
+/** Command that launches the cloud verification of the current branch. */
+const VERIFY_COMMAND = `npx ${PACKAGE} verify`;
 /** Exit code for success. */
 const EXIT_OK = 0;
 /** Exit code for failure. */
@@ -56,7 +59,7 @@ const PR_NUMBER = /^\d+$/;
 export class InterruptedError extends Error {
     /** Builds the error. */
     constructor() {
-        super("interrupted");
+        super("interrumpido");
         this.name = "InterruptedError";
     }
 }
@@ -79,10 +82,10 @@ export function branchDay(date) {
  * @param worktree - Worktree folder.
  * @returns The line to print.
  * @example
- * resumeLine("interrupted", "/home/u/app-cloud-ready"); // "interrupted; the worktree is at ...; run ... --resume there"
+ * resumeLine("interrumpido", "/home/u/app-cloud-ready"); // "interrumpido; el worktree está en ...; corre ... --resume ahí para continuar"
  */
 function resumeLine(reason, worktree) {
-    return `${reason}; the worktree is at ${worktree}; run ${RESUME_COMMAND} there`;
+    return `${reason}; el worktree está en ${worktree}; corre ${RESUME_COMMAND} ahí para continuar`;
 }
 /**
  * Runs a capture and trims its output; never throws.
@@ -153,7 +156,7 @@ function worktreePath(repo) {
 function configureProblem(worktree) {
     const { config, errors } = readConfig(worktree);
     if (!config || errors.length)
-        return errors[0] ?? `${CONFIG_FILE} not found`;
+        return errors[0] ?? `no existe ${CONFIG_FILE}`;
     const notes = config.notes ?? DEFAULT_NOTES_FILE;
     const rel = relative(worktree, join(worktree, notes));
     const inside = !isAbsolute(notes) && rel !== "" && rel !== ".." && !rel.startsWith(`..${sep}`);
@@ -164,7 +167,7 @@ function configureProblem(worktree) {
     catch {
         // NOTE: a missing file is reported below.
     }
-    return `the notes file ${notes} does not exist`;
+    return `no existe el archivo de notas ${notes}`;
 }
 /**
  * Lists the paths of `git status --porcelain=v1 -z` output.
@@ -247,11 +250,11 @@ async function findResume(repo, deps) {
  */
 async function createAndConfigure(repo, branch, worktree, deps, progress) {
     if (existsSync(worktree)) {
-        deps.print(`${OUTPUT_PREFIX}${worktree} already exists; remove it (git worktree remove ${worktree}) or continue there with ${RESUME_COMMAND}`);
+        deps.print(`${OUTPUT_PREFIX}${worktree} ya existe; bórralo (git worktree remove ${worktree}) o continúa ahí con ${RESUME_COMMAND}`);
         return false;
     }
     if ((await tryCapture(deps, "git", ["rev-parse", "--verify", "--quiet", `refs/heads/${branch}`], repo)) !== undefined) {
-        deps.print(`${OUTPUT_PREFIX}branch ${branch} already exists; delete it (git branch -D ${branch}) or run prepare another day`);
+        deps.print(`${OUTPUT_PREFIX}la rama ${branch} ya existe; bórrala (git branch -D ${branch}) o corre prepare otro día`);
         return false;
     }
     const base = `origin/${defaultBranch(repo)}`;
@@ -261,10 +264,10 @@ async function createAndConfigure(repo, branch, worktree, deps, progress) {
         progress.worktree = worktree;
     }
     catch (err) {
-        deps.print(`${OUTPUT_PREFIX}could not create the worktree: ${message(err)}`);
+        deps.print(`${OUTPUT_PREFIX}no se pudo crear el worktree: ${message(err)}`);
         return false;
     }
-    const stopped = resumeLine("the local agent stopped", worktree);
+    const stopped = resumeLine("el agente local se detuvo", worktree);
     try {
         const result = init(worktree, deps.packageVersion, deps.packageRoot);
         for (const line of result.lines)
@@ -279,18 +282,19 @@ async function createAndConfigure(repo, branch, worktree, deps, progress) {
         deps.print(stopped);
         return false;
     }
-    deps.print(EXIT_CLAUDE_HINT);
     try {
-        await runInteractive(deps, progress, [configurePrompt()], worktree);
+        await runConfigure(deps, progress, "pr", worktree);
     }
-    catch {
+    catch (err) {
+        if (err instanceof InterruptedError)
+            throw err;
         deps.print(stopped);
         return false;
     }
     const problem = configureProblem(worktree);
     if (problem !== undefined) {
-        deps.print(`${OUTPUT_PREFIX}configure did not finish: ${problem}`);
-        deps.print(resumeLine("prepare stopped", worktree));
+        deps.print(`${OUTPUT_PREFIX}configure no terminó: ${problem}`);
+        deps.print(resumeLine("prepare se detuvo", worktree));
         return false;
     }
     return true;
@@ -317,7 +321,7 @@ async function commitAndPush(worktree, branch, deps) {
         const status = await deps.capture("git", ["status", "--porcelain=v1", "-z", "--untracked-files=all"], { cwd: worktree });
         const others = statusPaths(status).filter((path) => !covered(path, known));
         if (others.length) {
-            deps.print(`${OUTPUT_PREFIX}the local agent also changed:`);
+            deps.print(`${OUTPUT_PREFIX}el agente local también cambió:`);
             for (const path of others)
                 deps.print(`  ${path}`);
             if (YES_ANSWER.test((await deps.ask(INCLUDE_QUESTION, "")).trim())) {
@@ -325,48 +329,49 @@ async function commitAndPush(worktree, branch, deps) {
             }
             else {
                 await deps.run("git", ["reset", "-q", "--", ...others], { cwd: worktree });
-                deps.print(`${OUTPUT_PREFIX}left uncommitted in ${worktree}`);
+                deps.print(`${OUTPUT_PREFIX}quedó sin commitear en ${worktree}`);
             }
         }
         const staged = await deps.capture("git", ["diff", "--cached", "--name-only"], { cwd: worktree });
         if (staged.trim())
             await deps.run("git", ["commit", "-m", COMMIT_MESSAGE], { cwd: worktree });
         else
-            deps.print(`${OUTPUT_PREFIX}nothing new to commit`);
+            deps.print(`${OUTPUT_PREFIX}no hay nada nuevo que commitear`);
         await deps.run("git", ["push", "-u", "origin", branch], { cwd: worktree });
     }
     catch (err) {
         if (err instanceof InterruptedError)
             throw err;
-        deps.print(`${OUTPUT_PREFIX}could not commit and push: ${message(err)}; fix it in ${worktree} and run ${RESUME_COMMAND} there`);
+        deps.print(`${OUTPUT_PREFIX}no se pudo hacer commit y push: ${message(err)}; corrígelo en ${worktree} y corre ${RESUME_COMMAND} ahí`);
         return false;
     }
     const existing = await tryCapture(deps, "gh", ["pr", "view", branch, "--json", "number", "--jq", ".number"], worktree);
     if (existing !== undefined && PR_NUMBER.test(existing)) {
-        deps.print(`${OUTPUT_PREFIX}reusing the open PR #${existing}`);
+        deps.print(`${OUTPUT_PREFIX}se reutiliza el PR abierto #${existing}`);
         return { pr: existing };
     }
     try {
         const url = await deps.capture("gh", ["pr", "create", "--draft", "--fill"], { cwd: worktree });
-        deps.print(`${OUTPUT_PREFIX}draft PR: ${url.trim()}`);
+        deps.print(`${OUTPUT_PREFIX}PR en borrador: ${url.trim()}`);
         return { pr: PR_URL.exec(url)?.[1] };
     }
     catch {
         const origin = await tryCapture(deps, "git", ["remote", "get-url", "origin"], worktree);
         const link = compareLink(origin, branch);
-        deps.print(`${OUTPUT_PREFIX}could not open the PR with gh; open it by hand${link ? `: ${link}` : ` from branch ${branch}`}`);
+        deps.print(`${OUTPUT_PREFIX}no se pudo abrir el PR con gh; ábrelo a mano${link ? `: ${link}` : ` desde la rama ${branch}`}`);
         return {};
     }
 }
 /**
- * Prepares a repo for Claude Code cloud sessions: checks, asks, creates a worktree on a new
- * branch, runs the local agent with the `cloud-ready` skill, commits, pushes, opens a draft PR,
+ * Prepares a repo for Claude Code cloud sessions: checks, asks where to work (a new PR or the
+ * current branch, see `prepareHere`), creates a worktree on a new branch, runs the local agent with the `cloud-ready` skill, commits, pushes, opens a draft PR,
  * waits while the user configures the environment and starts a cloud session that verifies it.
  *
  * @param repo - Folder where the user runs `prepare` (inside the repo, or the worktree with resume).
  * @param deps - Dependencies.
  * @param options - `resume` continues in an existing prepare worktree.
- * @returns 0 when the cloud session was started, 130 after Ctrl+C at a question, 1 otherwise.
+ * @returns 0 when the cloud session was started (or, in the current branch, when it is prepared),
+ *   130 after Ctrl+C at a question, 1 otherwise.
  * @example
  * process.exitCode = await prepare(process.cwd(), deps);
  */
@@ -374,9 +379,8 @@ export async function prepare(repo, deps, options = {}) {
     const gitRoot = await tryCapture(deps, "git", ["rev-parse", "--show-toplevel"], repo);
     const cwd = gitRoot ?? repo;
     const hasOrigin = (await tryCapture(deps, "git", ["remote", "get-url", "origin"], cwd)) !== undefined;
-    const clean = options.resume ? true : (await tryCapture(deps, "git", ["status", "--porcelain"], cwd)) === "";
     const claudeHelp = await tryCapture(deps, "claude", ["--help"], cwd);
-    const problems = preflight({ isTty: deps.isTty, gitRoot, hasOrigin, clean, claudeHelp });
+    const problems = preflight({ isTty: deps.isTty, gitRoot, hasOrigin, claudeHelp });
     if (problems.length || gitRoot === undefined) {
         for (const problem of problems)
             deps.print(`${OUTPUT_PREFIX}${problem}`);
@@ -408,32 +412,54 @@ export async function prepare(repo, deps, options = {}) {
  *
  * @param deps - Dependencies.
  * @param progress - Marks the child as owning the terminal.
- * @param args - Arguments of `claude`.
+ * @param command - Command and arguments that open Claude.
  * @param cwd - Worktree.
  * @returns Resolves when `claude` exits 0.
  * @throws When `claude` exits non-zero.
  * @example
- * await runInteractive(deps, progress, ["--cloud", prompt], "/home/u/app-cloud-ready");
+ * await runInteractive(deps, progress, { cmd: "claude", args: ["--cloud", prompt] }, "/home/u/app-cloud-ready");
  */
-async function runInteractive(deps, progress, args, cwd) {
+async function runInteractive(deps, progress, command, cwd) {
     progress.childOwnsTerminal = true;
     try {
-        await deps.run("claude", args, { cwd });
+        await deps.run(command.cmd, command.args, { cwd });
     }
     finally {
         progress.childOwnsTerminal = false;
     }
 }
+/**
+ * Shows the screen before Claude Code opens, waits for Enter, and runs the local agent with
+ * `cloud-ready configure` (through the repo's `claude:free` script when it has one).
+ *
+ * @param deps - Dependencies.
+ * @param progress - Marks the child as owning the terminal.
+ * @param place - Where `prepare` works.
+ * @param cwd - Folder where Claude runs.
+ * @returns Resolves when Claude exits 0.
+ * @throws InterruptedError on Ctrl+C at the Enter line; an error when Claude exits non-zero.
+ * @example
+ * await runConfigure(deps, progress, "pr", "/home/u/app-cloud-ready");
+ */
+async function runConfigure(deps, progress, place, cwd) {
+    const color = deps.color ?? false;
+    for (const line of renderBanner({ place, free: hasFreeScript(cwd), color }))
+        deps.print(line);
+    await deps.waitEnter(enterLine(color));
+    await runInteractive(deps, progress, claudeCommand(cwd, configurePrompt()), cwd);
+}
 /**
  * The line printed on Ctrl+C: where the worktree is, when it exists.
  *
  * @param progress - What exists so far.
  * @returns The line.
  * @example
- * interruptedLine({}); // "agent-cloud-kit: interrupted; nothing was created"
+ * interruptedLine({}); // "agent-cloud-kit: interrumpido; no se creó nada"
  */
 function interruptedLine(progress) {
-    return progress.worktree === undefined ? `${OUTPUT_PREFIX}interrupted; nothing was created` : resumeLine("interrupted", progress.worktree);
+    if (progress.here)
+        return `${OUTPUT_PREFIX}interrumpido; lo que alcanzó a cambiar quedó sin commit en tu rama`;
+    return progress.worktree === undefined ? `${OUTPUT_PREFIX}interrumpido; no se creó nada` : resumeLine("interrumpido", progress.worktree);
 }
 /**
  * Everything after the preflight: resume or create the worktree, commit, wait, launch.
@@ -453,18 +479,25 @@ async function prepareSteps(gitRoot, deps, options, progress) {
     if (options.resume) {
         const found = await findResume(gitRoot, deps);
         if (!found) {
-            deps.print(`${OUTPUT_PREFIX}nothing to resume: run it in the ${WORKTREE_SUFFIX} worktree on a ${BRANCH_PREFIX}* branch`);
+            deps.print(`${OUTPUT_PREFIX}no hay nada que reanudar: corre prepare --resume en el worktree *${WORKTREE_SUFFIX}, sobre una rama ${BRANCH_PREFIX}*`);
             return EXIT_FAIL;
         }
         ({ worktree, branch } = found);
         progress.worktree = worktree;
         const problem = configureProblem(worktree);
         if (problem) {
-            deps.print(`${OUTPUT_PREFIX}configure is not finished in ${worktree}: ${problem}; run claude "/cloud-ready configure" there first, then ${RESUME_COMMAND}`);
+            deps.print(`${OUTPUT_PREFIX}configure no terminó en ${worktree}: ${problem}; corre claude "/cloud-ready configure" ahí primero y luego ${RESUME_COMMAND}`);
             return EXIT_FAIL;
         }
     }
     else {
+        const place = options.place ?? (await askPlace(gitRoot, deps));
+        if (place === null) {
+            deps.print(`${OUTPUT_PREFIX}no se cambió nada`);
+            return EXIT_FAIL;
+        }
+        if (place === "here")
+            return prepareHere(gitRoot, deps, progress);
         branch = `${BRANCH_PREFIX}${deps.today}`;
         worktree = worktreePath(gitRoot);
         if (!(await createAndConfigure(gitRoot, branch, worktree, deps, progress)))
@@ -478,12 +511,143 @@ async function prepareSteps(gitRoot, deps, options, progress) {
         deps.print(renderEnvironmentSection(config, deps.packageVersion));
     await deps.waitEnter(WAIT_TEXT);
     try {
-        await runInteractive(deps, progress, ["--cloud", verifyPrompt({ branch, pr: pushed.pr })], worktree);
+        await runInteractive(deps, progress, { cmd: "claude", args: ["--cloud", verifyPrompt({ branch, pr: pushed.pr })] }, worktree);
+    }
+    catch (err) {
+        deps.print(`${OUTPUT_PREFIX}falló claude --cloud: ${message(err)}; corre ${RESUME_COMMAND} en ${worktree} para reintentar`);
+        return EXIT_FAIL;
+    }
+    deps.print(`${OUTPUT_PREFIX}la sesión cloud avisará con un push a ${branch} y un comentario en el PR`);
+    return EXIT_OK;
+}
+/**
+ * Asks where to work, with the same options as agent-kitchen.
+ *
+ * @param gitRoot - Git root.
+ * @param deps - Dependencies.
+ * @returns The place, or null when cancelled.
+ * @example
+ * await askPlace("/home/u/app", deps); // "pr"
+ */
+async function askPlace(gitRoot, deps) {
+    return deps.choose(PLACE_QUESTION, [
+        { value: "pr", label: "En un PR nuevo", hint: `recomendado · parte de origin/${defaultBranch(gitRoot)}, no toca tu rama ni tus archivos` },
+        { value: "here", label: "En la rama actual, sin commit", hint: `los revisas con git diff, haces commit y push, y luego corres ${VERIFY_COMMAND}` },
+    ], "pr");
+}
+/**
+ * The "current branch" place: installs the kit, runs the local agent and writes the manual in the
+ * checkout, without committing. The cloud verification comes later, with `verify`, once pushed.
+ *
+ * @param gitRoot - Git root (the current checkout).
+ * @param deps - Dependencies.
+ * @param progress - Marks the checkout as changed.
+ * @returns The exit code.
+ * @example
+ * await prepareHere("/home/u/app", deps, {}); // 0
+ */
+async function prepareHere(gitRoot, deps, progress) {
+    progress.here = true;
+    const stopped = `${OUTPUT_PREFIX}prepare se detuvo; lo que alcanzó a cambiar quedó sin commit en tu rama`;
+    try {
+        const result = init(gitRoot, deps.packageVersion, deps.packageRoot);
+        for (const line of result.lines)
+            deps.print(line);
+        if (!result.ok) {
+            deps.print(stopped);
+            return EXIT_FAIL;
+        }
     }
     catch (err) {
-        deps.print(`${OUTPUT_PREFIX}claude --cloud failed: ${message(err)}; run ${RESUME_COMMAND} in ${worktree} to try again`);
+        deps.print(`${OUTPUT_PREFIX}${message(err)}`);
+        deps.print(stopped);
         return EXIT_FAIL;
     }
-    deps.print(`${OUTPUT_PREFIX}the cloud session will report back as a push to ${branch} and a comment on the PR`);
+    try {
+        await runConfigure(deps, progress, "here", gitRoot);
+    }
+    catch (err) {
+        if (err instanceof InterruptedError)
+            throw err;
+        deps.print(stopped);
+        return EXIT_FAIL;
+    }
+    const problem = configureProblem(gitRoot);
+    if (problem !== undefined) {
+        deps.print(`${OUTPUT_PREFIX}configure no terminó: ${problem}; corre claude "/cloud-ready configure" y luego prepare otra vez`);
+        return EXIT_FAIL;
+    }
+    try {
+        writeManual(gitRoot, deps.packageVersion);
+    }
+    catch (err) {
+        deps.print(`${OUTPUT_PREFIX}no se pudo escribir ${MANUAL_FILE}: ${message(err)}`);
+        return EXIT_FAIL;
+    }
+    const config = readConfig(gitRoot).config;
+    if (config)
+        deps.print(renderEnvironmentSection(config, deps.packageVersion));
+    deps.print(`${OUTPUT_PREFIX}listo, sin commit. Revisa los cambios con git diff, haz commit y push, configura el entorno en claude.ai (${MANUAL_FILE}) y corre ${VERIFY_COMMAND}`);
+    return EXIT_OK;
+}
+/**
+ * Launches the cloud verification of the current branch: checks that the preparation is there
+ * and pushed (the cloud only sees origin), then starts `claude --cloud` with `cloud-ready verify`.
+ *
+ * @param repo - Folder where the user runs `verify`.
+ * @param deps - Dependencies (`ask`, `choose`, `waitEnter` and `today` are not used).
+ * @returns 0 when the cloud session was started, 1 otherwise.
+ * @example
+ * process.exitCode = await verifyBranch(process.cwd(), deps);
+ */
+export async function verifyBranch(repo, deps) {
+    const gitRoot = await tryCapture(deps, "git", ["rev-parse", "--show-toplevel"], repo);
+    const cwd = gitRoot ?? repo;
+    const hasOrigin = (await tryCapture(deps, "git", ["remote", "get-url", "origin"], cwd)) !== undefined;
+    const claudeHelp = await tryCapture(deps, "claude", ["--help"], cwd);
+    const problems = preflight({ isTty: deps.isTty, gitRoot, hasOrigin, claudeHelp }, "verify");
+    if (problems.length || gitRoot === undefined) {
+        for (const problem of problems)
+            deps.print(`${OUTPUT_PREFIX}${problem}`);
+        return EXIT_FAIL;
+    }
+    const branch = await tryCapture(deps, "git", ["rev-parse", "--abbrev-ref", "HEAD"], gitRoot);
+    if (branch === undefined || branch === "HEAD") {
+        deps.print(`${OUTPUT_PREFIX}no estás en una rama; cámbiate a la rama que quieres verificar`);
+        return EXIT_FAIL;
+    }
+    const problem = configureProblem(gitRoot);
+    if (problem !== undefined) {
+        deps.print(`${OUTPUT_PREFIX}el repo no está preparado (${problem}); corre npx ${PACKAGE} prepare primero`);
+        return EXIT_FAIL;
+    }
+    const notes = readConfig(gitRoot).config?.notes ?? DEFAULT_NOTES_FILE;
+    const files = [CONFIG_FILE, MANUAL_FILE, notes].filter((path) => entryExists(join(gitRoot, path)));
+    const dirty = await tryCapture(deps, "git", ["status", "--porcelain", "--", ...files], gitRoot);
+    if (dirty) {
+        deps.print(`${OUTPUT_PREFIX}hay cambios sin commit en la preparación; haz commit y push: la nube solo ve lo que está en origin`);
+        return EXIT_FAIL;
+    }
+    const head = await tryCapture(deps, "git", ["rev-parse", "HEAD"], gitRoot);
+    const remote = (await tryCapture(deps, "git", ["ls-remote", "origin", `refs/heads/${branch}`], gitRoot))?.split(/\s/)[0];
+    if (!head || remote !== head) {
+        deps.print(`${OUTPUT_PREFIX}la rama ${branch} no está subida o tiene commits sin subir; haz git push y vuelve a correr verify`);
+        return EXIT_FAIL;
+    }
+    const found = await tryCapture(deps, "gh", ["pr", "view", branch, "--json", "number", "--jq", ".number"], gitRoot);
+    const pr = found !== undefined && PR_NUMBER.test(found) ? found : undefined;
+    const progress = {};
+    const stop = deps.onInterrupt?.(() => !progress.childOwnsTerminal);
+    try {
+        await runInteractive(deps, progress, { cmd: "claude", args: ["--cloud", verifyPrompt({ branch, pr })] }, gitRoot);
+    }
+    catch (err) {
+        deps.print(`${OUTPUT_PREFIX}falló claude --cloud: ${message(err)}`);
+        return EXIT_FAIL;
+    }
+    finally {
+        stop?.();
+    }
+    deps.print(`${OUTPUT_PREFIX}la sesión cloud avisará con un push a ${branch}${pr ? " y un comentario en el PR" : ""}`);
     return EXIT_OK;
 }

package/dist/run.js

@@ -16,7 +16,7 @@ export class RunTimeoutError extends Error {
      * @param ms - Time limit, in milliseconds.
      */
     constructor(cmd, ms) {
-        super(`${cmd} timed out after ${ms}ms`);
+        super(`${cmd} superó el límite de ${ms}ms`);
         this.name = "RunTimeoutError";
     }
 }
@@ -82,7 +82,7 @@ function spawnAndWait(cmd, args, opts, stdio, onStdout) {
             clearTimeout(timer);
             if (code === 0)
                 return resolve();
-            reject(new Error(`${cmd} exited with ${code === null ? `signal ${signal}` : `code ${code}`}`));
+            reject(new Error(`${cmd} terminó con ${code === null ? `la señal ${signal}` : `el código ${code}`}`));
         });
     });
 }

package/dist/select.js

@@ -0,0 +1,112 @@
+/**
+ * @file A small arrow-key menu for the terminal, with the look of agent-kitchen's (`@clack/prompts`)
+ * and no dependencies: ↑/↓ move, Enter picks, Esc or Ctrl+C cancels.
+ */
+import { emitKeypressEvents } from "node:readline";
+/** ANSI codes used by the menu. */
+const ANSI = {
+    dim: (text) => `\x1b[2m${text}\x1b[22m`,
+    cyan: (text) => `\x1b[36m${text}\x1b[39m`,
+    green: (text) => `\x1b[32m${text}\x1b[39m`,
+    hideCursor: "\x1b[?25l",
+    showCursor: "\x1b[?25h",
+    up: (lines) => (lines > 0 ? `\x1b[${lines}A` : ""),
+    clearDown: "\r\x1b[J",
+};
+/**
+ * Applies one key to the menu.
+ *
+ * @param state - Current state.
+ * @param key - Key pressed.
+ * @param count - Number of options.
+ * @returns The new state.
+ * @example
+ * menuKey({ active: 0 }, { name: "down" }, 2); // { active: 1 }
+ */
+export function menuKey(state, key, count) {
+    if (key.ctrl && key.name === "c")
+        return { ...state, done: "cancelled" };
+    if (key.name === "escape")
+        return { ...state, done: "cancelled" };
+    if (key.name === "return" || key.name === "enter")
+        return { ...state, done: "picked" };
+    if (key.name === "up" || key.name === "k")
+        return { active: (state.active - 1 + count) % count };
+    if (key.name === "down" || key.name === "j")
+        return { active: (state.active + 1) % count };
+    return state;
+}
+/**
+ * Draws the menu: the question, the options (hint only on the active one) and, once done, the
+ * picked option or "Cancelado".
+ *
+ * @param message - Question.
+ * @param choices - Options.
+ * @param state - Current state.
+ * @returns The lines to print.
+ * @example
+ * renderMenu("¿Dónde?", [{ value: "a", label: "A" }], { active: 0 })[0]; // "◆  ¿Dónde?" (with color)
+ */
+export function renderMenu(message, choices, state) {
+    const bar = ANSI.dim("│");
+    if (state.done === "picked")
+        return [`${ANSI.green("◇")}  ${message}`, `${bar}  ${ANSI.dim(choices[state.active]?.label ?? "")}`, bar];
+    if (state.done === "cancelled")
+        return [`${ANSI.dim("■")}  ${message}`, `${bar}  ${ANSI.dim("Cancelado")}`, bar];
+    const lines = [`${ANSI.cyan("◆")}  ${message}`];
+    choices.forEach((choice, index) => {
+        if (index === state.active) {
+            const hint = choice.hint ? ` ${ANSI.dim(`(${choice.hint})`)}` : "";
+            lines.push(`${ANSI.cyan("│")}  ${ANSI.green("●")} ${choice.label}${hint}`);
+        }
+        else {
+            lines.push(`${ANSI.cyan("│")}  ${ANSI.dim(`○ ${choice.label}`)}`);
+        }
+    });
+    lines.push(ANSI.cyan("└"));
+    return lines;
+}
+/**
+ * Shows the menu on the process terminal. Raw mode is on only while it is open, so a later
+ * `readline` question or a child process gets a normal terminal.
+ *
+ * @param message - Question.
+ * @param choices - Options.
+ * @param initial - Value active at the start.
+ * @returns The picked value, or null on Esc or Ctrl+C.
+ * @example
+ * await chooseTerminal("¿Dónde preparo el repo?", [{ value: "pr", label: "En un PR nuevo" }], "pr"); // "pr"
+ */
+export const chooseTerminal = async (message, choices, initial) => {
+    const { stdin, stdout } = process;
+    let state = { active: Math.max(0, choices.findIndex((c) => c.value === initial)) };
+    let drawn = 0;
+    const draw = () => {
+        const lines = renderMenu(message, choices, state);
+        stdout.write(`${ANSI.up(drawn)}${ANSI.clearDown}${lines.join("\n")}\n`);
+        drawn = lines.length;
+    };
+    emitKeypressEvents(stdin);
+    stdin.setRawMode(true);
+    stdin.resume();
+    stdout.write(ANSI.hideCursor);
+    draw();
+    try {
+        return await new Promise((resolvePick) => {
+            const onKey = (_text, key = {}) => {
+                state = menuKey(state, key, choices.length);
+                draw();
+                if (state.done === undefined)
+                    return;
+                stdin.off("keypress", onKey);
+                resolvePick(state.done === "picked" ? (choices[state.active]?.value ?? null) : null);
+            };
+            stdin.on("keypress", onKey);
+        });
+    }
+    finally {
+        stdin.setRawMode(false);
+        stdin.pause();
+        stdout.write(ANSI.showCursor);
+    }
+};

package/dist/session.js

@@ -15,7 +15,7 @@ import { resolveNotes } from "./manual.js";
 import { RunTimeoutError } from "./run.js";
 import { fingerprint, readState } from "./state.js";
 /** Generic note shown in every cloud session. */
-const GENERIC_NOTE = "you are in a Claude Code cloud session. There are no open ports or previews: test against localhost. gh pr and gh issue fail (the GitHub proxy blocks GraphQL): use gh api (REST).";
+const GENERIC_NOTE = "estás en una sesión cloud de Claude Code. No hay puertos abiertos ni previews: prueba contra localhost. gh pr y gh issue fallan (el proxy de GitHub bloquea GraphQL): usa gh api (REST).";
 /** Milliseconds in a second. */
 const MS_PER_SECOND = 1000;
 /** Seconds in a minute. */
@@ -97,19 +97,19 @@ export function expectedFingerprint(repo, config, state) {
 function machineWarnings(repo, config, state, packageVersion) {
     if (!state) {
         return [
-            `the environment setup did not run for ${basename(repo)}. Set the setup script of the environment in claude.ai to: npx -y ${packageSpec(packageVersion)} setup`,
+            `el setup del entorno no corrió para ${basename(repo)}. Pon como script de setup del entorno en claude.ai: npx -y ${packageSpec(packageVersion)} setup`,
         ];
     }
     const out = [];
     const failed = state.steps.filter((s) => !s.ok).map((s) => s.name);
     if (failed.length)
-        out.push(`setup failed: ${failed.join(", ")}. Run agent-cloud-kit doctor.`);
+        out.push(`falló el setup: ${failed.join(", ")}. Corre agent-cloud-kit doctor.`);
     if (expectedFingerprint(repo, config, state) !== state.fingerprint) {
-        out.push("the machine was prepared with another configuration. Edit the setup script field in claude.ai (any change) so it is rebuilt.");
+        out.push("la máquina se preparó con otra configuración. Edita el campo del script de setup en claude.ai (cualquier cambio) para que se reconstruya.");
     }
     const total = state.steps.reduce((sum, s) => sum + s.ms, 0);
     if (total > SETUP_SLOW_MS)
-        out.push(`setup took ${minutesSeconds(total)}, close to the ~5 minute limit.`);
+        out.push(`el setup tardó ${minutesSeconds(total)}, cerca del límite de ~5 minutos.`);
     return out;
 }
 /**
@@ -129,7 +129,7 @@ function writeEnvFile(env, lines) {
         return undefined;
     }
     catch (err) {
-        return `could not write ${ENV_FILE_VAR} (${file}): ${err instanceof Error ? err.message : String(err)}`;
+        return `no se pudo escribir ${ENV_FILE_VAR} (${file}): ${err instanceof Error ? err.message : String(err)}`;
     }
 }
 /**
@@ -170,7 +170,7 @@ async function runSessionSteps(repo, commands, run, env) {
             await run("bash", ["-c", command], { cwd: repo, env, stdio: "stderr", timeoutMs: SESSION_STEP_TIMEOUT_MS });
         }
         catch (err) {
-            problems.push(`${err instanceof RunTimeoutError ? "session step timed out" : "session step failed"}: ${command}`);
+            problems.push(`${err instanceof RunTimeoutError ? "el paso de sesión superó el tiempo límite" : "falló el paso de sesión"}: ${command}`);
         }
     }
     return problems;
@@ -213,13 +213,13 @@ async function sessionBody(repo, ctx, out) {
         out.push(...machineWarnings(repo, config, state, ctx.packageVersion));
     const missing = (config?.requiredEnv ?? []).filter((name) => !ctx.env[name]);
     if (missing.length)
-        out.push(`missing environment variables: ${missing.join(", ")}`);
+        out.push(`faltan variables de entorno: ${missing.join(", ")}`);
     const notes = resolveNotes(repo, config?.notes)?.trim();
     if (notes)
         out.push(notes);
     const dockerProblem = startDocker(ctx.docker ?? realDocker);
     if (dockerProblem)
-        out.push(`could not start dockerd: ${dockerProblem}`);
+        out.push(`no se pudo iniciar dockerd: ${dockerProblem}`);
     const env = toolsEnv(dirs, ctx.env, ca);
     await syncGit(repo, ctx.run, env);
     out.push(...(await runSessionSteps(repo, config?.session ?? [], ctx.run, env)));
@@ -240,7 +240,7 @@ export async function session(repo, ctx) {
         await sessionBody(repo, ctx, out);
     }
     catch (err) {
-        out.push(`session error: ${err instanceof Error ? err.message : String(err)}`);
+        out.push(`error en session: ${err instanceof Error ? err.message : String(err)}`);
     }
     return out.map((line) => OUTPUT_PREFIX + line);
 }