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

package/dist/messages/es.js

@@ -0,0 +1,234 @@
+/**
+ * @file The Spanish messages. Its shape is the shape of every catalog: `en.ts` must match it.
+ * Each message is a string or a function that builds one. Only what the terminal shows lives
+ * here: what is written in the repo (commit message, hook command, `docs/agent-cloud.md` outside
+ * the environment section) and the prompts for Claude stay where they are.
+ */
+/** Command that continues a prepare run. */
+const RESUME = "npx agent-cloud-kit prepare --resume";
+/** Command that launches the cloud verification. */
+const VERIFY = "npx agent-cloud-kit verify";
+export const es = {
+    help: `agent-cloud-kit: prepara repos para las sesiones cloud de Claude Code.
+
+Uso: agent-cloud-kit <comando> [--lang es|en]
+
+Comandos:
+  setup [--repo <path>]  prepara la máquina para cada repo del directorio home (o solo <path>)
+  session                informa el estado de la máquina y conecta las herramientas a la sesión
+  docker                 inicia el demonio de Docker y espera a que responda
+  doctor                 revisa los dominios permitidos, las herramientas, Docker y el estado de la máquina
+  init                   crea .claude/cloud.json y registra el hook SessionStart
+  manual                 escribe docs/agent-cloud.md a partir de .claude/cloud.json
+  prepare [--pr|--here|--resume]
+                         corre en local: deja el repo listo para la nube, en un PR nuevo (--pr) o en la
+                         rama actual sin commit (--here); sin opción, pregunta dónde
+  verify                 corre en local: lanza una sesión cloud que verifica la rama actual (ya subida)
+
+Opciones:
+  --lang es|en           idioma de los mensajes (español por defecto; AGENT_CLOUD_KIT_LANG=es|en lo fija)
+  --help                 muestra esta ayuda
+  --version              muestra la versión del paquete
+`,
+    lang: {
+        invalid: (source, value) => `${source} espera es o en: ${value}`,
+    },
+    cli: {
+        versionMismatch: (running, file, pinned) => `corriendo la versión ${running}, aunque ${file} pide la ${pinned}`,
+        setupSummary: (repo, steps, failed, names) => `setup ${repo}: ${steps} pasos, ${failed} fallaron${names.length ? ` (${names.join(", ")})` : ""}`,
+        skip: (repo, reason) => `se omite ${repo}: ${reason}`,
+        relaunching: (version, repo) => `relanzando con la versión ${version} para ${repo}`,
+        relaunchFailed: (version, repo, error) => `falló el relanzamiento con la versión ${version} para ${repo}: ${error}`,
+        repoNeedsPath: (option) => `${option} necesita una ruta`,
+        noRepos: (home) => `no se encontraron repos en ${home}`,
+        setupErrorFor: (repo, error) => `error en setup de ${repo}: ${error}`,
+        setupError: (error) => `error en setup: ${error}`,
+        sessionDelegateFailed: (version, error) => `falló session con la versión ${version}: ${error}`,
+        manualWritten: (file) => `se escribió ${file}`,
+        unknownOption: (command, options) => `opción desconocida para ${command}: ${options}`,
+        onlyOne: (options) => `usa solo una de ${options}`,
+    },
+    config: {
+        dockerNotObject: '"docker" debe ser un objeto',
+        unknownField: (key) => `campo desconocido "${key}"`,
+        badPull: '"docker.pull" debe ser "auto", false o un arreglo de strings',
+        notStringList: (key) => `"${key}" debe ser un arreglo de strings`,
+        badHost: (host) => `"domains" tiene un host inválido: ${host}`,
+        badVersion: '"version" debe ser un semver exacto, como "1.0.0"',
+        notesNotString: '"notes" debe ser un string',
+        unreadable: (reason) => `no se pudo leer el archivo: ${reason}`,
+        notObject: "debe contener un objeto JSON",
+        missing: (file) => `no hay ${file}`,
+    },
+    run: {
+        timedOut: (cmd, ms) => `${cmd} superó el límite de ${ms}ms`,
+        exitCode: (cmd, code) => `${cmd} terminó con el código ${code}`,
+        exitSignal: (cmd, signal) => `${cmd} terminó con la señal ${signal}`,
+    },
+    docker: {
+        missing: "dockerd no está instalado",
+        didNotStart: (log) => `dockerd no arrancó; revisa ${log}`,
+    },
+    doctor: {
+        domain: (host, ok) => `red ${host}: ${ok ? "ok" : "bloqueado"}`,
+        toolInvalid: (tool, version) => `herramienta ${tool} ${version}: versión inválida`,
+        toolUnresolved: (tool, version) => `herramienta ${tool} ${version}: sin resolver (setup no la instaló)`,
+        tool: (tool, version, present) => `herramienta ${tool} ${version}: ${present ? "ok" : "falta"}`,
+        fileMissing: (file) => `${file}: falta`,
+        stateMissing: "estado: falta (setup no corrió)",
+        fingerprint: (same) => `huella: ${same ? "ok" : "distinta"}`,
+        step: (name, ok, seconds) => `paso ${name}: ${ok ? "ok" : "falló"} (${seconds}s)`,
+        docker: (ok) => `docker: ${ok ? "ok" : "falta"}`,
+        plugin: (name) => `aviso: el plugin ${name} está activado pero no está en el repo; no llegará a la nube (copia sus skills con skills-manager)`,
+        skill: (dir, installed, version) => `aviso: ${dir} está en ${installed} y el paquete en ${version}; corre npx agent-cloud-kit@${version} init`,
+        groupError: (group, error) => `${group}: error: ${error}`,
+        groups: { network: "red", tools: "herramientas", docker: "docker", state: "estado", plugins: "plugins", skill: "skill" },
+        allOk: "Todo en orden",
+        someFailed: (failed, total) => (failed === 1 ? `Falló 1 de ${total} revisiones` : `Fallaron ${failed} de ${total} revisiones`),
+        warnings: (count) => (count === 1 ? "1 aviso" : `${count} avisos`),
+        failedHint: "revisa las líneas con falta, bloqueado o falló",
+    },
+    session: {
+        genericNote: "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).",
+        setupNotRun: (repo, spec) => `el setup del entorno no corrió para ${repo}. Pon como script de setup del entorno en claude.ai: npx -y ${spec} setup`,
+        setupFailed: (names) => `falló el setup: ${names.join(", ")}. Corre agent-cloud-kit doctor.`,
+        otherConfig: "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.",
+        slow: (time) => `el setup tardó ${time}, cerca del límite de ~5 minutos.`,
+        envFileFailed: (variable, file, error) => `no se pudo escribir ${variable} (${file}): ${error}`,
+        stepTimedOut: (command) => `el paso de sesión superó el tiempo límite: ${command}`,
+        stepFailed: (command) => `falló el paso de sesión: ${command}`,
+        missingEnv: (names) => `faltan variables de entorno: ${names.join(", ")}`,
+        dockerFailed: (problem) => `no se pudo iniciar dockerd: ${problem}`,
+        error: (error) => `error en session: ${error}`,
+    },
+    setup: {
+        aptRepoHttps: (prefix) => `el repo de apt debe ser una URL ${prefix}`,
+        badDebianName: "nombre de paquete Debian inválido",
+        badImage: "referencia de imagen inválida",
+        packageMismatch: (source, found, version) => `el paquete en ${source} es ${found ?? "desconocido"}, no ${version}`,
+        noConfig: "sin configuración",
+    },
+    /** Names of the setup steps, built from the name stored in the state (which never changes). */
+    steps: {
+        aptRepo: (url) => `repo de apt ${url}`,
+        aptPackage: (name) => `paquete de apt ${name}`,
+        selfInstall: (version) => `autoinstalación ${version}`,
+        writeState: "guardar el estado",
+        lane: (index) => `grupo ${index}`,
+        config: "configuración",
+    },
+    installers: {
+        notInShasums: (file, shasums) => `${file} no aparece en ${shasums}`,
+        unsupportedArch: (arch) => `arquitectura no soportada para node: ${arch}`,
+        invalidVersion: (tool, version) => `versión inválida para ${tool}: ${version}`,
+        indexNotList: "el índice de versiones de node no es una lista",
+        noNodeMatch: (requested) => `ninguna versión de node coincide con ${requested}`,
+        nodeMustResolve: (version) => `node ${version} debe resolverse primero a una versión exacta`,
+    },
+    init: {
+        byHand: (file, reason, entry) => `${file} ${reason}; no se tocó. Agrega esta entrada a hooks.SessionStart a mano: ${entry}`,
+        notJson: "no es JSON válido",
+        notObject: "no es un objeto JSON",
+        hooksNotObject: 'tiene un "hooks" que no es un objeto',
+        sessionStartNotArray: 'tiene un "hooks.SessionStart" que no es un arreglo',
+        configExists: (file) => `${file} ya existe; se dejó como estaba`,
+        configCreated: (file) => `se creó ${file}`,
+        hookExists: (file) => `${file} ya tiene el hook SessionStart`,
+        hookAdded: (file) => `se agregó el hook SessionStart a ${file}`,
+    },
+    skill: {
+        current: (dir, version) => `${dir} ya está en ${version}`,
+        missing: (path, root) => `no se encontró ${path}/SKILL.md en ${root}`,
+        installed: (dir, version) => `se instaló ${dir} ${version}`,
+        updated: (dir, from, to) => `se actualizó ${dir} de ${from} a ${to}`,
+        linked: (link, dir) => `se enlazó ${link} a ${dir}`,
+    },
+    manual: {
+        noConfig: (file) => `no existe ${file}; corre init primero`,
+    },
+    /** The "configure the environment" section, shown by `prepare` (the manual keeps it in Spanish). */
+    environment: {
+        title: "## Configurar el entorno en claude.ai",
+        intro: "Elige el entorno con `/remote-env` y edítalo en claude.ai/code:",
+        network: (hosts) => `- **Acceso a la red:** Limitado (Custom) con "Permitir administradores de paquetes" encendido ("Also include default list of common package managers"). Dominios extra: ${hosts}.`,
+        variables: (names) => `- **Variables:** ${names}.`,
+        namesOnly: (names) => `${names} (solo los nombres; los valores los pones tú)`,
+        none: "ninguno",
+        noneVariables: "ninguna",
+        githubApp: "- **Claude GitHub App:** instalado en el repo, o la sesión no puede pushear.",
+        setupScript: "- **Setup script:**",
+        variablesWarning: "> ⚠️ Quien use el entorno puede leer las variables, y no llegan al setup script (solo a la sesión).",
+    },
+    menu: {
+        cancelled: "Cancelado",
+    },
+    preflight: {
+        noTty: (command) => `${command} necesita una terminal interactiva (corre el comando directamente en tu terminal)`,
+        noGit: (command) => `esto no es un repositorio git; corre ${command} dentro del repo`,
+        noOrigin: (command) => `el repositorio no tiene el remoto 'origin'; ${command} necesita subir una rama a GitHub`,
+        noClaude: (command) => `claude no está instalado o no está en el PATH; instala Claude Code y vuelve a correr ${command}`,
+        noCloud: (command) => `tu versión de claude no soporta --cloud; actualiza Claude Code y vuelve a correr ${command}`,
+    },
+    banner: {
+        title: "Ahora se abre Claude Code",
+        subtitle: "con la skill cloud-ready",
+        step1: "Claude revisa el repo y te propone cómo prepararlo para la nube",
+        step2: "Responde sus preguntas",
+        step3: (done, exit, after) => `Cuando diga ${done}, sal con ${exit} ${after}`,
+        configureDone: "configure terminó",
+        afterPr: "→ prepare hace commit, push y PR",
+        afterHere: "→ quedan los cambios sin commit",
+        free: (script) => `Se abre con ${script} (sin sandbox ni preguntas de permisos): el repo usa claude-repo-guard`,
+        enter: "abre Claude Code",
+        cancel: "· Ctrl+C cancela",
+        continue: "cuando hayas configurado el entorno en claude.ai",
+        continueHint: "· abre la sesión cloud que lo verifica",
+    },
+    prepare: {
+        interrupted: "interrumpido",
+        resume: (reason, worktree) => `${reason}; el worktree está en ${worktree}; corre ${RESUME} ahí para continuar`,
+        noConfig: (file) => `no existe ${file}`,
+        noNotes: (file) => `no existe el archivo de notas ${file}`,
+        worktreeExists: (worktree) => `${worktree} ya existe; bórralo (git worktree remove ${worktree}) o continúa ahí con ${RESUME}`,
+        branchExists: (branch) => `la rama ${branch} ya existe; bórrala (git branch -D ${branch}) o corre prepare otro día`,
+        worktreeCreated: (worktree, branch) => `se creó el worktree ${worktree} en la rama ${branch}`,
+        worktreeFailed: (error) => `no se pudo crear el worktree: ${error}`,
+        agentStopped: "el agente local se detuvo",
+        prepareStopped: "prepare se detuvo",
+        configureUnfinished: (problem) => `configure no terminó: ${problem}`,
+        otherChanges: "el agente local también cambió:",
+        includeQuestion: "¿Incluir estos cambios en el commit? [s/N]",
+        leftUncommitted: (worktree) => `quedó sin commitear en ${worktree}`,
+        nothingToCommit: "no hay nada nuevo que commitear",
+        pushed: (branch) => `se subió la rama ${branch}`,
+        pushFailed: (error, worktree) => `no se pudo hacer commit y push: ${error}; corrígelo en ${worktree} y corre ${RESUME} ahí`,
+        prReused: (pr) => `se reutiliza el PR abierto #${pr}`,
+        prDraft: (url) => `PR en borrador: ${url}`,
+        prByHand: (link, branch) => `no se pudo abrir el PR con gh; ábrelo a mano${link ? `: ${link}` : ` desde la rama ${branch}`}`,
+        interruptedHere: "interrumpido; lo que alcanzó a cambiar quedó sin commit en tu rama",
+        interruptedNothing: "interrumpido; no se creó nada",
+        nothingToResume: (suffix, prefix) => `no hay nada que reanudar: corre prepare --resume en el worktree *${suffix}, sobre una rama ${prefix}*`,
+        resumeUnfinished: (worktree, problem) => `configure no terminó en ${worktree}: ${problem}; corre claude "/cloud-ready configure" ahí primero y luego ${RESUME}`,
+        nothingChanged: "no se cambió nada",
+        cloudFailedResume: (error, worktree) => `falló claude --cloud: ${error}; corre ${RESUME} en ${worktree} para reintentar`,
+        placeQuestion: "¿Dónde preparo el repo?",
+        placePr: "En un PR nuevo",
+        placePrHint: (base) => `recomendado · parte de origin/${base}, no toca tu rama ni tus archivos`,
+        placeHere: "En la rama actual, sin commit",
+        placeHereHint: `los revisas con git diff, haces commit y push, y luego corres ${VERIFY}`,
+        stoppedHere: "prepare se detuvo; lo que alcanzó a cambiar quedó sin commit en tu rama",
+        hereUnfinished: (problem) => `configure no terminó: ${problem}; corre claude "/cloud-ready configure" y luego prepare otra vez`,
+        manualFailed: (file, error) => `no se pudo escribir ${file}: ${error}`,
+        hereTitle: "Listo, sin commit",
+        hereSteps: (manual) => ["Revisa los cambios con git diff", "Haz commit y push", `Configura el entorno en claude.ai (${manual})`, `Corre ${VERIFY}`],
+        noBranch: "no estás en una rama; cámbiate a la rama que quieres verificar",
+        notPrepared: (problem) => `el repo no está preparado (${problem}); corre npx agent-cloud-kit prepare primero`,
+        dirty: "hay cambios sin commit en la preparación; haz commit y push: la nube solo ve lo que está en origin",
+        notPushed: (branch) => `la rama ${branch} no está subida o tiene commits sin subir; haz git push y vuelve a correr verify`,
+        cloudFailed: (error) => `falló claude --cloud: ${error}`,
+        cloudStarted: "La sesión cloud está en marcha",
+        cloudWillReport: (branch, pr) => `la sesión cloud avisará con un push a ${branch}${pr ? " y un comentario en el PR" : ""}`,
+        rowBranch: "Rama",
+        rowPr: "PR",
+    },
+};

package/dist/messages/index.js

@@ -0,0 +1,75 @@
+import { en } from "./en.js";
+import { es } from "./es.js";
+export { es };
+/** Catalog of the current run; Spanish until `useLang` says otherwise. */
+let current = es;
+/**
+ * The catalog of a language.
+ *
+ * @param lang - The language.
+ * @returns Its messages.
+ * @example
+ * messages("en").docker.missing; // "dockerd is not installed"
+ */
+export function messages(lang) {
+    return lang === "en" ? en : es;
+}
+/**
+ * Sets the language of this run.
+ *
+ * @param lang - The language.
+ * @example
+ * useLang("en");
+ */
+export function useLang(lang) {
+    current = messages(lang);
+}
+/**
+ * The messages of the current language.
+ *
+ * @returns The catalog.
+ * @example
+ * t().menu.cancelled; // "Cancelado"
+ */
+export function t() {
+    return current;
+}
+/**
+ * Turns the name of a setup step, as the state stores it, into the current language. The stored
+ * name never changes, so a state written in one language reads well in the other.
+ *
+ * @param name - Stored step name, like `self install 1.0.0` or `docker pull redis:7`.
+ * @returns The name to show.
+ * @example
+ * stepLabel("write state"); // "guardar el estado" in Spanish
+ */
+export function stepLabel(name) {
+    const m = current.steps;
+    const rest = (prefix) => (name.startsWith(prefix) ? name.slice(prefix.length) : undefined);
+    const aptRepo = rest(STEP.aptRepo);
+    if (aptRepo !== undefined)
+        return m.aptRepo(aptRepo);
+    const aptPackage = rest(STEP.aptPackage);
+    if (aptPackage !== undefined)
+        return m.aptPackage(aptPackage);
+    const selfInstall = rest(STEP.selfInstall);
+    if (selfInstall !== undefined)
+        return m.selfInstall(selfInstall);
+    const lane = rest(STEP.lane);
+    if (lane !== undefined && /^\d+$/.test(lane))
+        return m.lane(lane);
+    if (name === STEP.writeState)
+        return m.writeState;
+    if (name === STEP.config)
+        return m.config;
+    return name;
+}
+/** Stored names (or name prefixes) of the setup steps that have words in them. */
+export const STEP = {
+    aptRepo: "apt repo ",
+    aptPackage: "apt package ",
+    selfInstall: "self install ",
+    lane: "lane ",
+    writeState: "write state",
+    config: "config",
+};

package/dist/prepare/banner.js

@@ -1,9 +1,11 @@
 /**
- * @file The screen `prepare` shows before opening Claude Code: a small cloud, what will happen and
- * what the user has to do, in a few colored lines.
+ * @file The screen `prepare` shows before opening Claude Code: Kuro, what will happen and what the
+ * user has to do, in a few colored lines. `prepare` only runs in a terminal, so Kuro is always there.
  */
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
+import { renderBlock } from "../block.js";
+import { t } from "../messages/index.js";
 /** Script of claude-repo-guard that opens Claude without sandbox nor permission prompts. */
 export const FREE_SCRIPT = "claude:free";
 /**
@@ -26,27 +28,23 @@ function paint(on, code, text) {
  * @param input - Place, mode and color.
  * @returns The lines.
  * @example
- * renderBanner({ place: "pr", free: false, color: false })[2]; // "     .-(    ).     Ahora se abre Claude Code"
+ * renderBanner({ place: "pr", free: false, color: false })[2]; // " ≋≋██▀▀▀▀▀██              [>] Ahora se abre Claude Code"
  */
 export function renderBanner(input) {
+    const m = t().banner;
     const c = (code, text) => paint(input.color, code, text);
-    const cloud = (text) => c("36", text);
-    const step = (n, text) => `   ${c("1;35", String(n))}  ${text}`;
-    const after = input.place === "pr" ? "prepare hace commit, push y PR" : "quedan los cambios sin commit";
+    const step = (n, text) => `${c("1;35", String(n))}  ${text}`;
+    const after = input.place === "pr" ? m.afterPr : m.afterHere;
     const lines = [
+        c("2", m.subtitle),
         "",
-        cloud("        .--."),
-        `${cloud("     .-(    ).")}     ${c("1", "Ahora se abre Claude Code")}`,
-        `${cloud("    (___.__)__)")}    ${c("2", "con la skill cloud-ready")}`,
-        "",
-        step(1, "Claude revisa el repo y te propone cómo prepararlo para la nube"),
-        step(2, "Responde sus preguntas"),
-        step(3, `Cuando diga ${c("1", "configure terminó")}, sal con ${c("1;33", "/exit")} ${c("2", `→ ${after}`)}`),
+        step(1, m.step1),
+        step(2, m.step2),
+        step(3, m.step3(c("1", m.configureDone), c("1;33", "/exit"), c("2", after))),
     ];
     if (input.free)
-        lines.push("", c("2", `   Se abre con ${FREE_SCRIPT} (sin sandbox ni preguntas de permisos): el repo usa claude-repo-guard`));
-    lines.push("");
-    return lines;
+        lines.push("", c("2", m.free(FREE_SCRIPT)));
+    return renderBlock({ mood: "next", title: m.title, lines }, { art: true, color: input.color });
 }
 /**
  * The line asked after the banner.
@@ -57,7 +55,8 @@ export function renderBanner(input) {
  * enterLine(false); // "   ⏎ Enter abre Claude Code · Ctrl+C cancela "
  */
 export function enterLine(color) {
-    return `   ${paint(color, "1;32", "⏎ Enter")} abre Claude Code ${paint(color, "2", "· Ctrl+C cancela")} `;
+    const m = t().banner;
+    return `   ${paint(color, "1;32", "⏎ Enter")} ${m.enter} ${paint(color, "2", m.cancel)} `;
 }
 /**
  * The line asked while the user configures the environment in claude.ai.
@@ -68,7 +67,8 @@ export function enterLine(color) {
  * continueLine(false); // "\n   ⏎ Enter cuando hayas configurado el entorno en claude.ai · abre la sesión cloud que lo verifica "
  */
 export function continueLine(color) {
-    return `\n   ${paint(color, "1;32", "⏎ Enter")} cuando hayas configurado el entorno en claude.ai ${paint(color, "2", "· abre la sesión cloud que lo verifica")} `;
+    const m = t().banner;
+    return `\n   ${paint(color, "1;32", "⏎ Enter")} ${m.continue} ${paint(color, "2", m.continueHint)} `;
 }
 /** Config file claude-repo-guard installs; the free mode is used only when it is there. */
 const GUARD_CONFIG = ".claude/repo-guard.config.json";

package/dist/prepare/detect.js

@@ -1,6 +1,7 @@
 /**
  * @file Pure parts of `prepare`: preflight checks.
  */
+import { t } from "../messages/index.js";
 /** Flag `claude` must advertise in its help to launch cloud sessions. */
 const CLOUD_FLAG = "--cloud";
 /**
@@ -8,21 +9,22 @@ const CLOUD_FLAG = "--cloud";
  *
  * @param probe What was observed about the environment.
  * @param command Command named in the messages.
- * @returns Problems in Spanish, in a fixed order; empty when everything is fine.
+ * @returns Problems in the language of the terminal, in a fixed order; empty when everything is fine.
  * @example
  * preflight({ isTty: false, hasOrigin: true }); // ["prepare necesita una terminal interactiva", ...]
  */
 export function preflight(probe, command = "prepare") {
+    const m = t().preflight;
     const problems = [];
     if (!probe.isTty)
-        problems.push(`${command} necesita una terminal interactiva (corre el comando directamente en tu terminal)`);
+        problems.push(m.noTty(command));
     if (probe.gitRoot === undefined)
-        problems.push(`esto no es un repositorio git; corre ${command} dentro del repo`);
+        problems.push(m.noGit(command));
     if (!probe.hasOrigin)
-        problems.push(`el repositorio no tiene el remoto 'origin'; ${command} necesita subir una rama a GitHub`);
+        problems.push(m.noOrigin(command));
     if (probe.claudeHelp === undefined)
-        problems.push(`claude no está instalado o no está en el PATH; instala Claude Code y vuelve a correr ${command}`);
+        problems.push(m.noClaude(command));
     else if (!probe.claudeHelp.includes(CLOUD_FLAG))
-        problems.push(`tu versión de claude no soporta --cloud; actualiza Claude Code y vuelve a correr ${command}`);
+        problems.push(m.noCloud(command));
     return problems;
 }