agent-cloud-kit 1.0.0-rc.7 → 1.0.0-rc.8

package/dist/prepare/index.js

@@ -6,13 +6,15 @@
 import { existsSync, lstatSync, statSync } from "node:fs";
 import { basename, dirname, isAbsolute, join, relative, sep } from "node:path";
 import { readConfig } from "../config.js";
-import { CONFIG_FILE, PACKAGE } from "../constants.js";
+import { CONFIG_FILE } from "../constants.js";
 import { defaultBranch } from "../detect.js";
 import { init } from "../init.js";
+import { renderBlock } from "../block.js";
 import { MANUAL_FILE, renderEnvironmentSection, writeManual } from "../manual.js";
+import { t } from "../messages/index.js";
 import { claudeCommand, continueLine, enterLine, hasFreeScript, renderBanner } from "./banner.js";
 import { preflight } from "./detect.js";
-import { formatLine, initKind, nextSteps, styleMarkdown, unprefixed } from "./ui.js";
+import { formatLine, nextSteps, styleMarkdown } from "./ui.js";
 import { configurePrompt, verifyPrompt } from "./prompts.js";
 /** Prefix of the branch `prepare` creates; the day follows it. */
 const BRANCH_PREFIX = "chore/cloud-ready-";
@@ -30,23 +32,14 @@ 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. */
+/** Message of the commit `prepare` makes: it lives in the repo, so it is always in Spanish. */
 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 = "¿Incluir estos cambios en el commit? [s/N]";
-/** Answers to `INCLUDE_QUESTION` that mean yes. */
+/** Answers to the "include these changes?" question that mean yes, in either language. */
 const YES_ANSWER = /^(s|si|sí|y|yes)$/i;
-/** Text shown while the user configures the environment in claude.ai. */
 /** 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`;
-/** 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. */
@@ -59,7 +52,7 @@ const PR_NUMBER = /^\d+$/;
 export class InterruptedError extends Error {
     /** Builds the error. */
     constructor() {
-        super("interrumpido");
+        super(t().prepare.interrupted);
         this.name = "InterruptedError";
     }
 }
@@ -87,6 +80,23 @@ export function branchDay(date) {
 function say(deps, kind, text) {
     deps.print(formatLine(kind, text, deps.color ?? false));
 }
+/**
+ * Prints a final message: a block with Kuro in a terminal, else the plain prefixed lines.
+ *
+ * @param deps - Dependencies (`print`, `art`, `color`).
+ * @param block - What to say.
+ * @param plain - Lines to print without a terminal, without prefix.
+ * @example
+ * finish(deps, { mood: "ok", title: "Listo" }, ["listo"]);
+ */
+function finish(deps, block, plain) {
+    if (deps.art)
+        for (const line of renderBlock(block, { art: true, color: deps.color ?? false }))
+            deps.print(line);
+    else
+        for (const line of plain)
+            say(deps, block.mood === "error" ? "fail" : "ok", line);
+}
 /**
  * Says where the worktree is and how to continue there.
  *
@@ -97,7 +107,7 @@ function say(deps, kind, text) {
  * resumeLine("interrumpido", "/home/u/app-cloud-ready"); // "interrumpido; el worktree está en ...; corre ... --resume ahí para continuar"
  */
 function resumeLine(reason, worktree) {
-    return `${reason}; el worktree está en ${worktree}; corre ${RESUME_COMMAND} ahí para continuar`;
+    return t().prepare.resume(reason, worktree);
 }
 /**
  * Runs a capture and trims its output; never throws.
@@ -168,7 +178,7 @@ function worktreePath(repo) {
 function configureProblem(worktree) {
     const { config, errors } = readConfig(worktree);
     if (!config || errors.length)
-        return errors[0] ?? `no existe ${CONFIG_FILE}`;
+        return errors[0] ?? t().prepare.noConfig(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}`);
@@ -179,7 +189,7 @@ function configureProblem(worktree) {
     catch {
         // NOTE: a missing file is reported below.
     }
-    return `no existe el archivo de notas ${notes}`;
+    return t().prepare.noNotes(notes);
 }
 /**
  * Lists the paths of `git status --porcelain=v1 -z` output.
@@ -262,11 +272,11 @@ async function findResume(repo, deps) {
  */
 async function createAndConfigure(repo, branch, worktree, deps, progress) {
     if (existsSync(worktree)) {
-        say(deps, "fail", `${worktree} ya existe; bórralo (git worktree remove ${worktree}) o continúa ahí con ${RESUME_COMMAND}`);
+        say(deps, "fail", t().prepare.worktreeExists(worktree));
         return false;
     }
     if ((await tryCapture(deps, "git", ["rev-parse", "--verify", "--quiet", `refs/heads/${branch}`], repo)) !== undefined) {
-        say(deps, "fail", `la rama ${branch} ya existe; bórrala (git branch -D ${branch}) o corre prepare otro día`);
+        say(deps, "fail", t().prepare.branchExists(branch));
         return false;
     }
     const base = `origin/${defaultBranch(repo)}`;
@@ -274,17 +284,17 @@ async function createAndConfigure(repo, branch, worktree, deps, progress) {
         await deps.run("git", ["fetch", "-q", "origin"], { cwd: repo });
         await deps.run("git", ["worktree", "add", "-b", branch, worktree, base], { cwd: repo });
         progress.worktree = worktree;
-        say(deps, "ok", `se creó el worktree ${worktree} en la rama ${branch}`);
+        say(deps, "ok", t().prepare.worktreeCreated(worktree, branch));
     }
     catch (err) {
-        say(deps, "fail", `no se pudo crear el worktree: ${message(err)}`);
+        say(deps, "fail", t().prepare.worktreeFailed(message(err)));
         return false;
     }
-    const stopped = resumeLine("el agente local se detuvo", worktree);
+    const stopped = resumeLine(t().prepare.agentStopped, worktree);
     try {
         const result = init(worktree, deps.packageVersion, deps.packageRoot);
-        for (const line of result.lines)
-            say(deps, initKind(line), unprefixed(line));
+        for (const entry of result.entries)
+            say(deps, entry.kind, entry.text);
         if (!result.ok) {
             say(deps, "warn", stopped);
             return false;
@@ -306,8 +316,8 @@ async function createAndConfigure(repo, branch, worktree, deps, progress) {
     }
     const problem = configureProblem(worktree);
     if (problem !== undefined) {
-        say(deps, "fail", `configure no terminó: ${problem}`);
-        say(deps, "warn", resumeLine("prepare se detuvo", worktree));
+        say(deps, "fail", t().prepare.configureUnfinished(problem));
+        say(deps, "warn", resumeLine(t().prepare.prepareStopped, worktree));
         return false;
     }
     return true;
@@ -334,45 +344,45 @@ 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) {
-            say(deps, "warn", `el agente local también cambió:`);
+            say(deps, "warn", t().prepare.otherChanges);
             for (const path of others)
                 deps.print(`    ${path}`);
-            if (YES_ANSWER.test((await deps.ask(INCLUDE_QUESTION, "")).trim())) {
+            if (YES_ANSWER.test((await deps.ask(t().prepare.includeQuestion, "")).trim())) {
                 await deps.run("git", ["add", "--", ...others], { cwd: worktree });
             }
             else {
                 await deps.run("git", ["reset", "-q", "--", ...others], { cwd: worktree });
-                say(deps, "warn", `quedó sin commitear en ${worktree}`);
+                say(deps, "warn", t().prepare.leftUncommitted(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
-            say(deps, "same", `no hay nada nuevo que commitear`);
+            say(deps, "same", t().prepare.nothingToCommit);
         await deps.run("git", ["push", "-u", "origin", branch], { cwd: worktree });
-        say(deps, "ok", `se subió la rama ${branch}`);
+        say(deps, "ok", t().prepare.pushed(branch));
     }
     catch (err) {
         if (err instanceof InterruptedError)
             throw err;
-        say(deps, "fail", `no se pudo hacer commit y push: ${message(err)}; corrígelo en ${worktree} y corre ${RESUME_COMMAND} ahí`);
+        say(deps, "fail", t().prepare.pushFailed(message(err), worktree));
         return false;
     }
     const existing = await tryCapture(deps, "gh", ["pr", "view", branch, "--json", "number", "--jq", ".number"], worktree);
     if (existing !== undefined && PR_NUMBER.test(existing)) {
-        say(deps, "ok", `se reutiliza el PR abierto #${existing}`);
+        say(deps, "ok", t().prepare.prReused(existing));
         return { pr: existing };
     }
     try {
         const url = await deps.capture("gh", ["pr", "create", "--draft", "--fill"], { cwd: worktree });
-        say(deps, "ok", `PR en borrador: ${url.trim()}`);
+        say(deps, "ok", t().prepare.prDraft(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);
-        say(deps, "warn", `no se pudo abrir el PR con gh; ábrelo a mano${link ? `: ${link}` : ` desde la rama ${branch}`}`);
+        say(deps, "warn", t().prepare.prByHand(link, branch));
         return {};
     }
 }
@@ -472,8 +482,8 @@ async function runConfigure(deps, progress, place, cwd) {
  */
 function interruptedLine(progress) {
     if (progress.here)
-        return "interrumpido; lo que alcanzó a cambiar quedó sin commit en tu rama";
-    return progress.worktree === undefined ? "interrumpido; no se creó nada" : resumeLine("interrumpido", progress.worktree);
+        return t().prepare.interruptedHere;
+    return progress.worktree === undefined ? t().prepare.interruptedNothing : resumeLine(t().prepare.interrupted, progress.worktree);
 }
 /**
  * Everything after the preflight: resume or create the worktree, commit, wait, launch.
@@ -493,21 +503,21 @@ async function prepareSteps(gitRoot, deps, options, progress) {
     if (options.resume) {
         const found = await findResume(gitRoot, deps);
         if (!found) {
-            say(deps, "fail", `no hay nada que reanudar: corre prepare --resume en el worktree *${WORKTREE_SUFFIX}, sobre una rama ${BRANCH_PREFIX}*`);
+            say(deps, "fail", t().prepare.nothingToResume(WORKTREE_SUFFIX, BRANCH_PREFIX));
             return EXIT_FAIL;
         }
         ({ worktree, branch } = found);
         progress.worktree = worktree;
         const problem = configureProblem(worktree);
         if (problem) {
-            say(deps, "fail", `configure no terminó en ${worktree}: ${problem}; corre claude "/cloud-ready configure" ahí primero y luego ${RESUME_COMMAND}`);
+            say(deps, "fail", t().prepare.resumeUnfinished(worktree, problem));
             return EXIT_FAIL;
         }
     }
     else {
         const place = options.place ?? (await askPlace(gitRoot, deps));
         if (place === null) {
-            say(deps, "same", `no se cambió nada`);
+            say(deps, "same", t().prepare.nothingChanged);
             return EXIT_FAIL;
         }
         if (place === "here")
@@ -522,17 +532,17 @@ async function prepareSteps(gitRoot, deps, options, progress) {
         return EXIT_FAIL;
     const config = readConfig(worktree).config;
     if (config)
-        for (const line of styleMarkdown(renderEnvironmentSection(config, deps.packageVersion), deps.color ?? false))
+        for (const line of styleMarkdown(renderEnvironmentSection(config, deps.packageVersion, t().environment), deps.color ?? false))
             deps.print(line);
     await deps.waitEnter(continueLine(deps.color ?? false));
     try {
         await runInteractive(deps, progress, { cmd: "claude", args: ["--cloud", verifyPrompt({ branch, pr: pushed.pr })] }, worktree);
     }
     catch (err) {
-        say(deps, "fail", `falló claude --cloud: ${message(err)}; corre ${RESUME_COMMAND} en ${worktree} para reintentar`);
+        say(deps, "fail", t().prepare.cloudFailedResume(message(err), worktree));
         return EXIT_FAIL;
     }
-    say(deps, "ok", `la sesión cloud avisará con un push a ${branch} y un comentario en el PR`);
+    cloudStarted(deps, branch, pushed.pr, true);
     return EXIT_OK;
 }
 /**
@@ -545,9 +555,9 @@ async function prepareSteps(gitRoot, deps, options, progress) {
  * 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}` },
+    return deps.choose(t().prepare.placeQuestion, [
+        { value: "pr", label: t().prepare.placePr, hint: t().prepare.placePrHint(defaultBranch(gitRoot)) },
+        { value: "here", label: t().prepare.placeHere, hint: t().prepare.placeHereHint },
     ], "pr");
 }
 /**
@@ -563,11 +573,11 @@ async function askPlace(gitRoot, deps) {
  */
 async function prepareHere(gitRoot, deps, progress) {
     progress.here = true;
-    const stopped = `prepare se detuvo; lo que alcanzó a cambiar quedó sin commit en tu rama`;
+    const stopped = t().prepare.stoppedHere;
     try {
         const result = init(gitRoot, deps.packageVersion, deps.packageRoot);
-        for (const line of result.lines)
-            say(deps, initKind(line), unprefixed(line));
+        for (const entry of result.entries)
+            say(deps, entry.kind, entry.text);
         if (!result.ok) {
             say(deps, "warn", stopped);
             return EXIT_FAIL;
@@ -589,23 +599,26 @@ async function prepareHere(gitRoot, deps, progress) {
     }
     const problem = configureProblem(gitRoot);
     if (problem !== undefined) {
-        say(deps, "fail", `configure no terminó: ${problem}; corre claude "/cloud-ready configure" y luego prepare otra vez`);
+        say(deps, "fail", t().prepare.hereUnfinished(problem));
         return EXIT_FAIL;
     }
     try {
         writeManual(gitRoot, deps.packageVersion);
     }
     catch (err) {
-        say(deps, "fail", `no se pudo escribir ${MANUAL_FILE}: ${message(err)}`);
+        say(deps, "fail", t().prepare.manualFailed(MANUAL_FILE, message(err)));
         return EXIT_FAIL;
     }
     const config = readConfig(gitRoot).config;
     if (config)
-        for (const line of styleMarkdown(renderEnvironmentSection(config, deps.packageVersion), deps.color ?? false))
+        for (const line of styleMarkdown(renderEnvironmentSection(config, deps.packageVersion, t().environment), deps.color ?? false))
+            deps.print(line);
+    const steps = t().prepare.hereSteps(MANUAL_FILE);
+    if (deps.art)
+        finish(deps, { mood: "ok", title: t().prepare.hereTitle, lines: numbered(steps, deps.color ?? false) }, []);
+    else
+        for (const line of nextSteps(t().prepare.hereTitle, steps, deps.color ?? false))
             deps.print(line);
-    const steps = ["Revisa los cambios con git diff", "Haz commit y push", `Configura el entorno en claude.ai (${MANUAL_FILE})`, `Corre ${VERIFY_COMMAND}`];
-    for (const line of nextSteps("Listo, sin commit", steps, deps.color ?? false))
-        deps.print(line);
     return EXIT_OK;
 }
 /**
@@ -631,25 +644,25 @@ export async function verifyBranch(repo, deps) {
     }
     const branch = await tryCapture(deps, "git", ["rev-parse", "--abbrev-ref", "HEAD"], gitRoot);
     if (branch === undefined || branch === "HEAD") {
-        say(deps, "fail", `no estás en una rama; cámbiate a la rama que quieres verificar`);
+        say(deps, "fail", t().prepare.noBranch);
         return EXIT_FAIL;
     }
     const problem = configureProblem(gitRoot);
     if (problem !== undefined) {
-        say(deps, "fail", `el repo no está preparado (${problem}); corre npx ${PACKAGE} prepare primero`);
+        say(deps, "fail", t().prepare.notPrepared(problem));
         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) {
-        say(deps, "fail", `hay cambios sin commit en la preparación; haz commit y push: la nube solo ve lo que está en origin`);
+        say(deps, "fail", t().prepare.dirty);
         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) {
-        say(deps, "fail", `la rama ${branch} no está subida o tiene commits sin subir; haz git push y vuelve a correr verify`);
+        say(deps, "fail", t().prepare.notPushed(branch));
         return EXIT_FAIL;
     }
     const found = await tryCapture(deps, "gh", ["pr", "view", branch, "--json", "number", "--jq", ".number"], gitRoot);
@@ -660,12 +673,39 @@ export async function verifyBranch(repo, deps) {
         await runInteractive(deps, progress, { cmd: "claude", args: ["--cloud", verifyPrompt({ branch, pr })] }, gitRoot);
     }
     catch (err) {
-        say(deps, "fail", `falló claude --cloud: ${message(err)}`);
+        say(deps, "fail", t().prepare.cloudFailed(message(err)));
         return EXIT_FAIL;
     }
     finally {
         stop?.();
     }
-    say(deps, "ok", `la sesión cloud avisará con un push a ${branch}${pr ? " y un comentario en el PR" : ""}`);
+    cloudStarted(deps, branch, pr, pr !== undefined);
     return EXIT_OK;
 }
+/**
+ * Numbers some steps for a block, with the number in color.
+ *
+ * @param steps - Steps, in order.
+ * @param color - Whether to color.
+ * @returns The lines.
+ * @example
+ * numbered(["a"], false); // ["1  a"]
+ */
+function numbered(steps, color) {
+    return steps.map((step, i) => `${color ? `\x1b[1;35m${i + 1}\x1b[0m` : i + 1}  ${step}`);
+}
+/**
+ * The final message once the cloud session started: the branch, the PR and how it will report.
+ *
+ * @param deps - Dependencies.
+ * @param branch - Branch the session verifies.
+ * @param pr - PR number, when known.
+ * @param comment - Whether the session will comment on a PR.
+ * @example
+ * cloudStarted(deps, "main", "7", true);
+ */
+function cloudStarted(deps, branch, pr, comment) {
+    const m = t().prepare;
+    const rows = [[m.rowBranch, branch], ...(pr ? [[m.rowPr, `#${pr}`]] : [])];
+    finish(deps, { mood: "ok", title: m.cloudStarted, rows, lines: [m.cloudWillReport(branch, comment)] }, [m.cloudWillReport(branch, comment)]);
+}

package/dist/prepare/ui.js

@@ -40,33 +40,6 @@ export function formatLine(kind, text, color) {
     const { icon, code } = STYLE[kind];
     return `  ${paint(true, code, icon)} ${kind === "same" ? paint(true, "2", text) : text}`;
 }
-/**
- * Guesses the kind of a line `init` printed, from its wording.
- *
- * @param text - Line, with or without the prefix.
- * @returns `ok` for something done, `same` for something already there, `warn` otherwise.
- * @example
- * initKind("agent-cloud-kit: se creó .claude/cloud.json"); // "ok"
- */
-export function initKind(text) {
-    const plain = text.startsWith(OUTPUT_PREFIX) ? text.slice(OUTPUT_PREFIX.length) : text;
-    if (/^se (creó|agregó|instaló|enlazó|actualizó|escribió)(\s|$)/.test(plain))
-        return "ok";
-    if (/\bya (existe|tiene|está)\b/.test(plain))
-        return "same";
-    return "warn";
-}
-/**
- * Removes the `agent-cloud-kit: ` prefix of a line, if it has it.
- *
- * @param text - Line.
- * @returns The line without prefix.
- * @example
- * unprefixed("agent-cloud-kit: hola"); // "hola"
- */
-export function unprefixed(text) {
-    return text.startsWith(OUTPUT_PREFIX) ? text.slice(OUTPUT_PREFIX.length) : text;
-}
 /**
  * Styles a Markdown section for the terminal: headings in bold (and cyan for `##`), code fences
  * dropped and their lines indented, list items as bullets. Without color, the text is unchanged.

package/dist/run.js

@@ -3,6 +3,7 @@
  * Modules that execute processes receive a `Run` (or a `Capture`) so tests can inject a fake.
  */
 import { spawn } from "node:child_process";
+import { t } from "./messages/index.js";
 /** Signal sent to a process group that ran past its time limit. */
 const KILL_SIGNAL = "SIGKILL";
 /** File descriptor of the parent's stderr, reused as the child's stdout and stderr. */
@@ -16,7 +17,7 @@ export class RunTimeoutError extends Error {
      * @param ms - Time limit, in milliseconds.
      */
     constructor(cmd, ms) {
-        super(`${cmd} superó el límite de ${ms}ms`);
+        super(t().run.timedOut(cmd, ms));
         this.name = "RunTimeoutError";
     }
 }
@@ -82,7 +83,7 @@ function spawnAndWait(cmd, args, opts, stdio, onStdout) {
             clearTimeout(timer);
             if (code === 0)
                 return resolve();
-            reject(new Error(`${cmd} terminó con ${code === null ? `la señal ${signal}` : `el código ${code}`}`));
+            reject(new Error(code === null ? t().run.exitSignal(cmd, String(signal)) : t().run.exitCode(cmd, code)));
         });
     });
 }

package/dist/select.js

@@ -3,6 +3,7 @@
  * and no dependencies: ↑/↓ move, Enter picks, Esc or Ctrl+C cancels.
  */
 import { emitKeypressEvents } from "node:readline";
+import { t } from "./messages/index.js";
 /** ANSI codes used by the menu. */
 const ANSI = {
     dim: (text) => `\x1b[2m${text}\x1b[22m`,
@@ -38,7 +39,7 @@ export function menuKey(state, key, count) {
 }
 /**
  * Draws the menu: the question, the options (hint only on the active one) and, once done, the
- * picked option or "Cancelado".
+ * picked option or "Cancelado" (in the language of the terminal).
  *
  * @param message - Question.
  * @param choices - Options.
@@ -52,7 +53,7 @@ export function renderMenu(message, choices, state) {
     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];
+        return [`${ANSI.dim("■")}  ${message}`, `${bar}  ${ANSI.dim(t().menu.cancelled)}`, bar];
     const lines = [`${ANSI.cyan("◆")}  ${message}`];
     choices.forEach((choice, index) => {
         if (index === state.active) {

package/dist/session.js

@@ -12,10 +12,9 @@ import { realDocker } from "./docker.js";
 import { pathLine, toolBinDirs } from "./installers.js";
 import { linkDir } from "./launcher.js";
 import { resolveNotes } from "./manual.js";
+import { t } from "./messages/index.js";
 import { RunTimeoutError } from "./run.js";
 import { fingerprint, readState } from "./state.js";
-/** Generic note shown in every cloud session. */
-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. */
@@ -96,20 +95,18 @@ export function expectedFingerprint(repo, config, state) {
  */
 function machineWarnings(repo, config, state, packageVersion) {
     if (!state) {
-        return [
-            `el setup del entorno no corrió para ${basename(repo)}. Pon como script de setup del entorno en claude.ai: npx -y ${packageSpec(packageVersion)} setup`,
-        ];
+        return [t().session.setupNotRun(basename(repo), packageSpec(packageVersion))];
     }
     const out = [];
     const failed = state.steps.filter((s) => !s.ok).map((s) => s.name);
     if (failed.length)
-        out.push(`falló el setup: ${failed.join(", ")}. Corre agent-cloud-kit doctor.`);
+        out.push(t().session.setupFailed(failed));
     if (expectedFingerprint(repo, config, state) !== state.fingerprint) {
-        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.");
+        out.push(t().session.otherConfig);
     }
     const total = state.steps.reduce((sum, s) => sum + s.ms, 0);
     if (total > SETUP_SLOW_MS)
-        out.push(`el setup tardó ${minutesSeconds(total)}, cerca del límite de ~5 minutos.`);
+        out.push(t().session.slow(minutesSeconds(total)));
     return out;
 }
 /**
@@ -129,7 +126,7 @@ function writeEnvFile(env, lines) {
         return undefined;
     }
     catch (err) {
-        return `no se pudo escribir ${ENV_FILE_VAR} (${file}): ${err instanceof Error ? err.message : String(err)}`;
+        return t().session.envFileFailed(ENV_FILE_VAR, file, err instanceof Error ? err.message : String(err));
     }
 }
 /**
@@ -170,7 +167,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 ? "el paso de sesión superó el tiempo límite" : "falló el paso de sesión"}: ${command}`);
+            problems.push(err instanceof RunTimeoutError ? t().session.stepTimedOut(command) : t().session.stepFailed(command));
         }
     }
     return problems;
@@ -197,7 +194,7 @@ function startDocker(docker) {
  * @param out - Output lines, filled in order.
  */
 async function sessionBody(repo, ctx, out) {
-    out.push(GENERIC_NOTE);
+    out.push(t().session.genericNote);
     if (!existsSync(join(repo, CONFIG_FILE)))
         return;
     const { config, errors } = readConfig(repo);
@@ -213,13 +210,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(`faltan variables de entorno: ${missing.join(", ")}`);
+        out.push(t().session.missingEnv(missing));
     const notes = resolveNotes(repo, config?.notes)?.trim();
     if (notes)
         out.push(notes);
     const dockerProblem = startDocker(ctx.docker ?? realDocker);
     if (dockerProblem)
-        out.push(`no se pudo iniciar dockerd: ${dockerProblem}`);
+        out.push(t().session.dockerFailed(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 +237,7 @@ export async function session(repo, ctx) {
         await sessionBody(repo, ctx, out);
     }
     catch (err) {
-        out.push(`error en session: ${err instanceof Error ? err.message : String(err)}`);
+        out.push(t().session.error(err instanceof Error ? err.message : String(err)));
     }
     return out.map((line) => OUTPUT_PREFIX + line);
 }

package/dist/setup.js

@@ -13,6 +13,7 @@ import { configImages, readToolVersions } from "./detect.js";
 import { realDocker } from "./docker.js";
 import { curlNodeIndex, installTools, resolveVersions } from "./installers.js";
 import { linkPath, packageBin, packageInstallDir } from "./launcher.js";
+import { STEP, t } from "./messages/index.js";
 import { pathDirs, toolsEnv } from "./session.js";
 import { fingerprint, writeState } from "./state.js";
 import { lanes, step } from "./steps.js";
@@ -64,16 +65,16 @@ async function aptLane(config, deps) {
     const env = { ...deps.env, ...APT_ENV };
     const results = [];
     for (const url of config.aptRepos) {
-        const name = `apt repo ${url}`;
+        const name = `${STEP.aptRepo}${url}`;
         if (!url.startsWith(HTTPS_PREFIX)) {
-            results.push(await refused(name, `el repo de apt debe ser una URL ${HTTPS_PREFIX}`));
+            results.push(await refused(name, t().setup.aptRepoHttps(HTTPS_PREFIX)));
             continue;
         }
         results.push(await step(name, () => deps.run("bash", ["-c", APT_REPO_SCRIPT, SCRIPT_NAME, url], { env, timeoutMs: APT_STEP_TIMEOUT_MS })));
     }
     const valid = config.apt.filter((pkg) => DEBIAN_PACKAGE_NAME.test(pkg));
     for (const pkg of config.apt.filter((p) => !valid.includes(p))) {
-        results.push(await refused(`apt package ${pkg}`, "nombre de paquete Debian inválido"));
+        results.push(await refused(`${STEP.aptPackage}${pkg}`, t().setup.badDebianName));
     }
     if (!valid.length && !config.aptRepos.length)
         return results;
@@ -119,11 +120,11 @@ async function dockerLane(config, images, docker, deps) {
     const results = [];
     const valid = images.filter((image) => !WHITESPACE.test(image) && !image.startsWith("-") && image !== "");
     for (const image of images.filter((i) => !valid.includes(i))) {
-        results.push(await refused(`docker pull ${image}`, "referencia de imagen inválida"));
+        results.push(await refused(`docker pull ${image}`, t().setup.badImage));
     }
     const up = await docker.ensure().catch(() => false);
     if (!up)
-        return [...results, await refused("docker", `dockerd no arrancó; revisa ${DOCKERD_LOG}`)];
+        return [...results, await refused("docker", t().docker.didNotStart(DOCKERD_LOG))];
     return [...results, ...(await pullAll(valid, deps))];
 }
 /**
@@ -181,7 +182,7 @@ function manifestVersion(root) {
 function copyPackage(source, target, version) {
     const found = manifestVersion(source);
     if (found !== version)
-        throw new Error(`el paquete en ${source} es ${found ?? "desconocido"}, no ${version}`);
+        throw new Error(t().setup.packageMismatch(source, found, version));
     const temp = `${target}.${process.pid}.tmp`;
     rmSync(temp, { recursive: true, force: true });
     mkdirSync(temp, { recursive: true });
@@ -201,7 +202,7 @@ function copyPackage(source, target, version) {
  * @returns The self install result.
  */
 function selfInstall(version, toolsDir, source) {
-    return step(`self install ${version}`, async () => {
+    return step(`${STEP.selfInstall}${version}`, async () => {
         const target = packageInstallDir(toolsDir, version);
         if (manifestVersion(target) !== version)
             copyPackage(source, target, version);
@@ -243,7 +244,7 @@ async function runPhases(repo, config, ctx) {
         steps,
         resolved,
     };
-    const saved = await step("write state", async () => writeState(ctx.toolsDir, repo, state));
+    const saved = await step(STEP.writeState, async () => writeState(ctx.toolsDir, repo, state));
     return saved.ok ? state : { ...state, steps: [...steps, saved] };
 }
 /**
@@ -267,7 +268,7 @@ export async function setupRepo(repo, ctx) {
     });
     const { config, errors } = readConfig(repo);
     if (!config)
-        return failed("config", errors.join("; ") || "sin configuración");
+        return failed(STEP.config, errors.join("; ") || t().setup.noConfig);
     try {
         return await runPhases(repo, config, ctx);
     }