@kuador-npm/runner 0.0.0-stage → 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/README.md CHANGED
@@ -1,3 +1,38 @@
1
- # Temporary Holding Version
1
+ # Kuador runner
2
2
 
3
- This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
3
+ Deja trabajando a los agentes del tablero en tu máquina (Mac, Linux o Windows) con tu propio cliente de IA y tu suscripción: sin claves de API.
4
+
5
+ ```
6
+ npx @kuador-npm/runner install --server https://<api-del-tablero>
7
+ ```
8
+
9
+ La instalación:
10
+
11
+ 1. Revisa que tengas Claude Code con tu sesión iniciada.
12
+ 2. Muestra un código que apruebas en el tablero (Agentes locales → Aprobar una máquina), como al conectar una TV. Funciona igual por SSH.
13
+ 3. Pregunta **qué roles atiende esta máquina**, cuántas tarjetas a la vez y, en tableros de software, dónde está el repo.
14
+ 4. Lo deja como servicio que arranca solo: launchd (Mac), systemd de usuario (Linux) o el Programador de tareas (Windows).
15
+
16
+ ## Cómo trabaja
17
+
18
+ - Escucha al tablero en tiempo real y, como respaldo, revisa cada 5 minutos.
19
+ - Pide una tarjeta: el tablero se la presta a la máquina por 3 minutos y el runner renueva el préstamo mientras el agente trabaja. Si la máquina se apaga, el préstamo vence y la tarjeta vuelve a la cola.
20
+ - Lanza `claude -p` en una carpeta por tarjeta (una copia aparte del repo con `git worktree` si es de código), con el tablero conectado por MCP, las instrucciones vigentes del rol y el modelo del agente.
21
+ - Lo que supervisas lo atiende tu máquina; lo libre lo toma la primera máquina del equipo con ese rol. Tres cortes en un día y la tarjeta deja de ofrecerse.
22
+ - Si tu suscripción llega a su límite, se pausa hasta que se renueve.
23
+
24
+ ## Comandos
25
+
26
+ | Comando | Qué hace |
27
+ |---|---|
28
+ | `install` | Conecta la máquina, elige roles e instala el servicio (`--no-service` para no instalarlo) |
29
+ | `roles` | Cambia los roles que atiende |
30
+ | `link <TABLERO> <carpeta>` | Vincula el repo de un tablero de software |
31
+ | `status` | Qué está haciendo ahora |
32
+ | `pause` / `resume` | Deja de tomar tarjetas nuevas / vuelve a tomarlas |
33
+ | `start` | En primer plano (lo usa el servicio) |
34
+ | `uninstall` | Quita el servicio y la conexión |
35
+
36
+ Todo vive en `~/.kuador` (o `KUADOR_HOME`): `runner.json` con la conexión (solo legible por ti), `logs/` y `work/`. La conexión al tablero que usa Claude Code se escribe fuera de la carpeta de trabajo, nunca dentro del repo.
37
+
38
+ Codex y OpenCode llegan en la próxima versión.
@@ -0,0 +1,7 @@
1
+ #!/usr/bin/env node
2
+ import { main } from "../src/cli.js";
3
+
4
+ main(process.argv.slice(2)).catch((e) => {
5
+ console.error(`\n✖ ${e?.message ?? e}`);
6
+ process.exit(1);
7
+ });
package/package.json CHANGED
@@ -1,6 +1,11 @@
1
1
  {
2
2
  "name": "@kuador-npm/runner",
3
- "version": "0.0.0-stage",
4
- "stub": true,
5
- "description": "Temporary package placeholder for staged publishing"
6
- }
3
+ "version": "0.1.0",
4
+ "description": "Deja trabajando a los agentes del tablero de Kuador en tu máquina (Mac, Linux o Windows), con tu propio cliente de IA.",
5
+ "type": "module",
6
+ "bin": { "kuador-runner": "bin/kuador-runner.js" },
7
+ "files": ["bin", "src", "README.md"],
8
+ "engines": { "node": ">=20" },
9
+ "scripts": { "test": "node --test test/*.test.js" },
10
+ "license": "UNLICENSED"
11
+ }
package/src/api.js ADDED
@@ -0,0 +1,69 @@
1
+ /** Cliente de la API del tablero (rutas del runner). */
2
+ export const VERSION = "0.1.0";
3
+
4
+ export class ApiError extends Error {
5
+ constructor(status, message) {
6
+ super(message);
7
+ this.status = status;
8
+ }
9
+ }
10
+
11
+ export function api(server, token) {
12
+ const base = server.replace(/\/+$/, "");
13
+ const call = async (method, path, body, { allow = [] } = {}) => {
14
+ const res = await fetch(base + path, {
15
+ method,
16
+ headers: {
17
+ "Content-Type": "application/json",
18
+ "User-Agent": `kuador-runner/${VERSION}`,
19
+ ...(token ? { Authorization: `Bearer ${token}` } : {}),
20
+ },
21
+ body: body === undefined ? undefined : JSON.stringify(body),
22
+ signal: AbortSignal.timeout(30_000),
23
+ });
24
+ if (res.ok || allow.includes(res.status)) {
25
+ const text = await res.text();
26
+ return { status: res.status, body: text ? JSON.parse(text) : null };
27
+ }
28
+ let detail = "";
29
+ try {
30
+ const p = await res.json();
31
+ detail = p.detail || p.title || "";
32
+ } catch {
33
+ // Sin cuerpo.
34
+ }
35
+ if (res.status === 401) throw new ApiError(401, "El tablero no reconoce esta máquina (la conexión venció o la revocaron). Vuelve a ejecutar: npx @kuador-npm/runner install");
36
+ throw new ApiError(res.status, detail || `El tablero respondió ${res.status} en ${path}.`);
37
+ };
38
+ return {
39
+ base,
40
+ health: () => fetch(base + "/livez", { signal: AbortSignal.timeout(10_000) }).then((r) => r.ok, () => false),
41
+ pair: (machineName) => call("POST", "/api/runner/pair", { machineName }).then((r) => r.body),
42
+ pairToken: (deviceCode) => call("POST", "/api/runner/pair/token", { deviceCode }, { allow: [202, 410] }),
43
+ setup: () => call("GET", "/api/runner/setup").then((r) => r.body),
44
+ heartbeat: (body) => call("PUT", "/api/runner/heartbeat", body).then((r) => r.body),
45
+ claim: (machineId) => call("POST", "/api/runner/claim", { machineId }).then((r) => (r.status === 204 ? null : r.body)),
46
+ renew: (machineId, key) => call("POST", `/api/runner/leases/${encodeURIComponent(key)}/renew`, { machineId }, { allow: [409] }).then((r) => r.status === 200),
47
+ release: (machineId, key, outcome, message) =>
48
+ call("POST", `/api/runner/leases/${encodeURIComponent(key)}/release`, { machineId, outcome, message: message?.slice(0, 480) }),
49
+ /** Avisos en tiempo real: llama a onSignal con cada «trabajo». Termina cuando se corta la conexión. */
50
+ async events(onSignal, signal) {
51
+ const res = await fetch(base + "/api/runner/events", {
52
+ headers: { Accept: "text/event-stream", Authorization: `Bearer ${token}`, "User-Agent": `kuador-runner/${VERSION}` },
53
+ signal,
54
+ });
55
+ if (!res.ok || !res.body) throw new ApiError(res.status, `No se pudo escuchar al tablero (${res.status}).`);
56
+ const decoder = new TextDecoder();
57
+ let buffer = "";
58
+ for await (const chunk of res.body) {
59
+ buffer += decoder.decode(chunk, { stream: true });
60
+ let index;
61
+ while ((index = buffer.indexOf("\n\n")) >= 0) {
62
+ const block = buffer.slice(0, index);
63
+ buffer = buffer.slice(index + 2);
64
+ if (/^event:\s*trabajo/m.test(block)) onSignal();
65
+ }
66
+ }
67
+ },
68
+ };
69
+ }
package/src/cli.js ADDED
@@ -0,0 +1,226 @@
1
+ import { randomUUID } from "node:crypto";
2
+ import { existsSync, rmSync, writeFileSync } from "node:fs";
3
+ import { hostname } from "node:os";
4
+ import { resolve } from "node:path";
5
+
6
+ import { api, VERSION } from "./api.js";
7
+ import { ensureDirs, HOME, load, PAUSE, readState, requireConfig, save } from "./config.js";
8
+ import { start } from "./daemon.js";
9
+ import { prompter } from "./prompt.js";
10
+ import { install as installService, openBrowser, osName, restart, uninstall as uninstallService } from "./service.js";
11
+ import { detect, TOOLS } from "./tools.js";
12
+ import { isRepo } from "./workdir.js";
13
+
14
+ const HELP = `Kuador runner ${VERSION}: deja trabajando a los agentes del tablero en esta máquina.
15
+
16
+ install [--server URL] Conecta esta máquina, elige qué roles atiende e instálalo como servicio
17
+ roles Cambia los roles que atiende esta máquina
18
+ link <TABLERO> <carpeta> Vincula el repo de un tablero de software en esta máquina
19
+ status Qué está haciendo ahora
20
+ pause | resume Deja de tomar tarjetas nuevas / vuelve a tomarlas
21
+ start Lo ejecuta en primer plano (el servicio usa esto)
22
+ uninstall Quita el servicio y la conexión de esta máquina
23
+ `;
24
+
25
+ export async function main(argv) {
26
+ const [command = "help", ...rest] = argv;
27
+ const flag = (name) => {
28
+ const i = rest.indexOf(`--${name}`);
29
+ return i >= 0 ? rest[i + 1] : undefined;
30
+ };
31
+ switch (command) {
32
+ case "install":
33
+ return install(flag("server"), rest.includes("--no-service"));
34
+ case "start":
35
+ return start();
36
+ case "roles":
37
+ return roles();
38
+ case "link":
39
+ return link(rest[0], rest[1]);
40
+ case "status":
41
+ return status();
42
+ case "pause":
43
+ ensureDirs();
44
+ writeFileSync(PAUSE, new Date().toISOString());
45
+ return console.log("En pausa: termina lo que está haciendo y no toma tarjetas nuevas. Para seguir: kuador-runner resume");
46
+ case "resume":
47
+ rmSync(PAUSE, { force: true });
48
+ return console.log("Listo: vuelve a tomar tarjetas.");
49
+ case "uninstall":
50
+ return uninstall();
51
+ case "--version":
52
+ case "version":
53
+ return console.log(VERSION);
54
+ default:
55
+ return console.log(HELP);
56
+ }
57
+ }
58
+
59
+ // ---- Instalación ----
60
+
61
+ async function install(serverFlag, noService = false) {
62
+ ensureDirs();
63
+ const previous = load();
64
+ const p = prompter();
65
+ try {
66
+ console.log(`\nKuador runner ${VERSION}\nDeja a los agentes del tablero trabajando en esta máquina con tu propia cuenta de IA.\n`);
67
+
68
+ // 1. La herramienta de IA (hoy Claude Code; Codex y OpenCode en la próxima versión).
69
+ const version = detect("claude");
70
+ if (!version) {
71
+ throw new Error("No encontré Claude Code en esta máquina. Instálalo (https://claude.com/claude-code), inicia sesión con tu cuenta y vuelve a ejecutar la instalación.");
72
+ }
73
+ console.log(`✔ ${TOOLS.claude.label} ${version}: usa tu suscripción de Claude, sin claves de API.`);
74
+
75
+ // 2. El tablero.
76
+ const server = (serverFlag || (await p.ask("Dirección del tablero (la que muestra «Agentes locales»)", previous?.server ?? ""))).replace(/\/+$/, "");
77
+ if (!/^https?:\/\//.test(server)) throw new Error("La dirección debe empezar con https://");
78
+ if (!(await api(server).health())) throw new Error(`No pude conectar con ${server}. Revisa la dirección y tu conexión.`);
79
+ const name = await p.ask("Nombre de esta máquina", previous?.name ?? hostname().replace(/\.local$/, ""));
80
+
81
+ // 3. Emparejar: la persona aprueba el código con su sesión en el tablero.
82
+ let token = previous?.server === server ? previous.token : null;
83
+ if (token && !(await p.confirm("Esta máquina ya está conectada. ¿Mantener la conexión?", true))) token = null;
84
+ if (!token) token = await pair(server, name);
85
+ const client = api(server, token);
86
+ const setup = await client.setup();
87
+ console.log(`✔ Conectada a nombre de ${setup.person}.\n`);
88
+
89
+ // 4. Qué roles atiende.
90
+ console.log("¿Qué roles atiende esta máquina? Solo tomará tarjetas de esos roles.");
91
+ const options = setup.roles.map((r) => ({
92
+ value: r.key,
93
+ label: `${r.name}${r.worksOnCode ? " · escribe código" : ""}${r.local ? "" : " · hoy trabaja en el servidor del tablero"}`,
94
+ }));
95
+ const preset = previous?.roles?.length ? previous.roles : setup.roles.filter((r) => r.local).map((r) => r.key);
96
+ const chosen = await p.choose("Roles", options, preset.filter((k) => options.some((o) => o.value === k)));
97
+ const serverOnly = setup.roles.filter((r) => chosen.includes(r.key) && !r.local);
98
+ if (serverOnly.length) {
99
+ console.log(` Nota: ${serverOnly.map((r) => r.name).join(", ")} hoy trabaja${serverOnly.length > 1 ? "n" : ""} en el servidor. Para que lo atienda esta máquina, en el tablero cámbialo a «En la PC de una persona».`);
100
+ }
101
+ const capacity = Math.max(1, Math.min(6, Number.parseInt(await p.ask("¿Cuántas tarjetas a la vez? (1 a 6)", String(previous?.capacity ?? 2)), 10) || 2));
102
+
103
+ // 5. Repos de los tableros de software (para trabajar en una copia aparte por tarjeta).
104
+ const repos = { ...(previous?.repos ?? {}) };
105
+ const software = setup.projects.filter((x) => x.kind === "SOFTWARE");
106
+ const codeRoles = setup.roles.filter((r) => chosen.includes(r.key) && r.worksOnCode);
107
+ if (software.length && codeRoles.length) {
108
+ console.log("\nRepos: los agentes que escriben código trabajan en una copia aparte del repo por tarjeta.");
109
+ for (const board of software) {
110
+ const answer = await p.ask(` Carpeta del repo de ${board.name} (${board.key}) en esta máquina (Enter = omitir)`, repos[board.key] ?? "");
111
+ if (!answer) continue;
112
+ const path = resolve(answer.replace(/^~(?=$|\/)/, process.env.HOME ?? "~"));
113
+ if (isRepo(path)) repos[board.key] = path;
114
+ else console.log(` ✖ ${path} no es un repositorio git: lo omito (puedes vincularlo después con «kuador-runner link ${board.key} <carpeta>»).`);
115
+ }
116
+ }
117
+
118
+ // 6. Que no se duerma mientras trabaja.
119
+ let keepAwake = false;
120
+ if (osName() !== "windows") {
121
+ keepAwake = await p.confirm("¿Evitar que la máquina se duerma mientras haya un agente trabajando?", previous?.keepAwake ?? true);
122
+ } else {
123
+ console.log("Nota: en Windows, configura la energía para que no se suspenda mientras quieras que trabaje.");
124
+ }
125
+
126
+ const config = {
127
+ server,
128
+ token,
129
+ machineId: previous?.machineId ?? randomUUID(),
130
+ name,
131
+ tool: "claude",
132
+ roles: chosen,
133
+ capacity,
134
+ repos,
135
+ keepAwake,
136
+ timeoutMinutes: previous?.timeoutMinutes ?? 60,
137
+ needsRegister: true,
138
+ };
139
+ save(config);
140
+ await client.heartbeat({ machineId: config.machineId, name, os: osName(), tool: "claude", roles: chosen, capacity, version: VERSION, register: true });
141
+ delete config.needsRegister;
142
+ save(config);
143
+
144
+ // 7. Como servicio: arranca solo al prender la máquina.
145
+ const service = noService ? { kind: "sin servicio: ejecuta «kuador-runner start»" } : installService();
146
+ console.log(`\n✔ Listo. «${name}» atiende: ${setup.roles.filter((r) => chosen.includes(r.key)).map((r) => r.name).join(", ")} (hasta ${capacity} a la vez).`);
147
+ console.log(noService ? " Para que trabaje: npx @kuador-npm/runner start. Lo ves en el tablero, en «Agentes locales»." : ` Arranca solo al iniciar sesión (${service.kind}). Lo ves en el tablero, en «Agentes locales».`);
148
+ console.log(" Qué está haciendo: npx @kuador-npm/runner status · Registros: " + HOME + "/logs\n");
149
+ } finally {
150
+ p.close();
151
+ }
152
+ }
153
+
154
+ /** Empareja como una TV: muestra el código, abre el tablero y espera a que la persona lo apruebe. */
155
+ async function pair(server, name) {
156
+ const client = api(server);
157
+ const started = await client.pair(name);
158
+ console.log(`\nAprueba esta máquina en el tablero con el código:\n\n ${started.userCode}\n\n ${started.verifyUrl}\n`);
159
+ if (openBrowser(started.verifyUrl)) console.log(" (Abrí el enlace en tu navegador.)");
160
+ const deadline = Date.now() + started.expiresIn * 1000;
161
+ process.stdout.write(" Esperando la aprobación");
162
+ while (Date.now() < deadline) {
163
+ await new Promise((r) => setTimeout(r, started.interval * 1000));
164
+ const r = await client.pairToken(started.deviceCode);
165
+ if (r.status === 200) {
166
+ process.stdout.write(" ✔\n");
167
+ return r.body.token;
168
+ }
169
+ if (r.status === 410) break;
170
+ process.stdout.write(".");
171
+ }
172
+ process.stdout.write("\n");
173
+ throw new Error("El código venció sin aprobarse. Vuelve a ejecutar la instalación.");
174
+ }
175
+
176
+ // ---- Ajustes ----
177
+
178
+ async function roles() {
179
+ const config = requireConfig();
180
+ const client = api(config.server, config.token);
181
+ const setup = await client.setup();
182
+ const p = prompter();
183
+ try {
184
+ const options = setup.roles.map((r) => ({ value: r.key, label: `${r.name}${r.worksOnCode ? " · escribe código" : ""}` }));
185
+ config.roles = await p.choose("Roles que atiende esta máquina", options, config.roles ?? []);
186
+ } finally {
187
+ p.close();
188
+ }
189
+ await client.heartbeat({ machineId: config.machineId, name: config.name, os: osName(), tool: config.tool, roles: config.roles, capacity: config.capacity, version: VERSION, register: true });
190
+ save(config);
191
+ restart();
192
+ console.log(`Listo: ahora atiende ${config.roles.join(", ")}.`);
193
+ }
194
+
195
+ function link(board, folder) {
196
+ if (!board || !folder) throw new Error("Uso: kuador-runner link <TABLERO> <carpeta del repo>");
197
+ const config = requireConfig();
198
+ const path = resolve(folder);
199
+ if (!isRepo(path)) throw new Error(`${path} no es un repositorio git.`);
200
+ config.repos = { ...(config.repos ?? {}), [board.toUpperCase()]: path };
201
+ save(config);
202
+ restart();
203
+ console.log(`Listo: las tarjetas de ${board.toUpperCase()} trabajan en copias de ${path}.`);
204
+ }
205
+
206
+ function status() {
207
+ const config = requireConfig();
208
+ const s = readState();
209
+ console.log(`${config.name} · ${config.server}`);
210
+ console.log(`Roles: ${(config.roles ?? []).join(", ")} · hasta ${config.capacity} a la vez`);
211
+ if (!s) return console.log("El runner todavía no arrancó (o no está corriendo como servicio).");
212
+ const age = (Date.now() - new Date(s.updatedAt).getTime()) / 1000;
213
+ if (age > 120) console.log(`⚠ Sin señal desde hace ${Math.round(age / 60)} min: ¿está corriendo el servicio?`);
214
+ if (s.paused) console.log("⏸ Pausada desde el tablero.");
215
+ if (s.localPaused || existsSync(PAUSE)) console.log("⏸ En pausa en esta máquina (kuador-runner resume para seguir).");
216
+ if (s.pausedUntil) console.log(`⏳ Límite de la suscripción: retoma a las ${new Date(s.pausedUntil).toLocaleTimeString()}.`);
217
+ if (!s.jobs.length) return console.log("Sin tarjetas en curso: esperando trabajo.");
218
+ for (const j of s.jobs) console.log(`▶ ${j.issue} · ${j.role} · ${j.title} (desde ${new Date(j.since).toLocaleTimeString()})`);
219
+ }
220
+
221
+ function uninstall() {
222
+ uninstallService();
223
+ const config = load();
224
+ rmSync(HOME + "/runner.json", { force: true });
225
+ console.log("Listo: quité el servicio y la conexión de esta máquina." + (config ? " En el tablero, «Agentes locales», puedes quitarla de la lista." : ""));
226
+ }
package/src/config.js ADDED
@@ -0,0 +1,54 @@
1
+ import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
2
+ import { homedir } from "node:os";
3
+ import { join } from "node:path";
4
+
5
+ /** Todo vive en ~/.kuador (o KUADOR_HOME): la configuración con la conexión (solo legible por ti), los registros y las carpetas de trabajo. */
6
+ export const HOME = process.env.KUADOR_HOME || join(homedir(), ".kuador");
7
+ export const CONFIG = join(HOME, "runner.json");
8
+ export const STATE = join(HOME, "state.json");
9
+ export const PAUSE = join(HOME, "paused");
10
+ export const LOGS = join(HOME, "logs");
11
+ export const WORK = join(HOME, "work");
12
+ export const SECRETS = join(HOME, "mcp");
13
+ export const APP = join(HOME, "app");
14
+
15
+ export function ensureDirs() {
16
+ for (const dir of [HOME, LOGS, WORK, SECRETS, APP]) mkdirSync(dir, { recursive: true, mode: 0o700 });
17
+ }
18
+
19
+ export function load() {
20
+ if (!existsSync(CONFIG)) return null;
21
+ return JSON.parse(readFileSync(CONFIG, "utf8"));
22
+ }
23
+
24
+ export function save(config) {
25
+ ensureDirs();
26
+ writeFileSync(CONFIG, JSON.stringify(config, null, 2), { mode: 0o600 });
27
+ try {
28
+ chmodSync(CONFIG, 0o600);
29
+ } catch {
30
+ // Windows: los permisos los da la carpeta del usuario.
31
+ }
32
+ }
33
+
34
+ export function requireConfig() {
35
+ const config = load();
36
+ if (!config?.token || !config?.machineId) throw new Error("Esta máquina todavía no está conectada. Ejecuta: npx @kuador-npm/runner install");
37
+ return config;
38
+ }
39
+
40
+ export function readState() {
41
+ try {
42
+ return JSON.parse(readFileSync(STATE, "utf8"));
43
+ } catch {
44
+ return null;
45
+ }
46
+ }
47
+
48
+ export function writeState(state) {
49
+ try {
50
+ writeFileSync(STATE, JSON.stringify(state, null, 2));
51
+ } catch {
52
+ // El estado es solo para «status»: si no se puede escribir, el runner sigue.
53
+ }
54
+ }
package/src/daemon.js ADDED
@@ -0,0 +1,203 @@
1
+ import { appendFileSync, createWriteStream, existsSync, rmSync } from "node:fs";
2
+ import { join } from "node:path";
3
+
4
+ import { api, VERSION } from "./api.js";
5
+ import { ensureDirs, LOGS, PAUSE, requireConfig, save, SECRETS, writeState } from "./config.js";
6
+ import { keepAwake, osName } from "./service.js";
7
+ import { launch, outcome } from "./tools.js";
8
+ import { cleanup, prepare } from "./workdir.js";
9
+
10
+ const HEARTBEAT_MS = 30_000;
11
+ const RENEW_MS = 60_000;
12
+ const FALLBACK_MS = 5 * 60_000;
13
+
14
+ function log(message) {
15
+ const line = `${new Date().toISOString()} ${message}`;
16
+ console.log(line);
17
+ try {
18
+ appendFileSync(join(LOGS, "runner.log"), line + "\n");
19
+ } catch {
20
+ // Sin registro en disco: queda en la salida del servicio.
21
+ }
22
+ }
23
+
24
+ const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
25
+
26
+ /**
27
+ * El runner trabajando: escucha al tablero, pide tarjetas mientras tenga lugar, lanza el cliente de IA en la carpeta de
28
+ * cada una, renueva su préstamo y la libera al terminar. Si la suscripción llega a su límite, se pausa hasta que se renueve.
29
+ */
30
+ export async function start() {
31
+ ensureDirs();
32
+ const config = requireConfig();
33
+ const client = api(config.server, config.token);
34
+ const jobs = new Map();
35
+ let machine = { paused: false, capacity: config.capacity ?? 2, roles: config.roles ?? [] };
36
+ let pausedUntil = 0;
37
+ let pumping = false;
38
+ let timer = null;
39
+ let stopping = false;
40
+
41
+ const state = () =>
42
+ writeState({
43
+ updatedAt: new Date().toISOString(),
44
+ paused: machine.paused,
45
+ localPaused: existsSync(PAUSE),
46
+ pausedUntil: pausedUntil > Date.now() ? new Date(pausedUntil).toISOString() : null,
47
+ capacity: machine.capacity,
48
+ roles: machine.roles,
49
+ jobs: [...jobs.values()].map((j) => ({ issue: j.claim.issueKey, title: j.claim.title, role: j.claim.roleName, since: j.started })),
50
+ });
51
+
52
+ const heartbeat = async (register = false) => {
53
+ try {
54
+ machine = await client.heartbeat({
55
+ machineId: config.machineId,
56
+ name: config.name,
57
+ os: osName(),
58
+ tool: config.tool ?? "claude",
59
+ roles: config.roles,
60
+ capacity: config.capacity,
61
+ version: VERSION,
62
+ register,
63
+ });
64
+ // El tablero manda: ahí se pueden cambiar roles, capacidad o pausar la máquina.
65
+ if (machine.roles.join() !== (config.roles ?? []).join() || machine.capacity !== config.capacity) {
66
+ config.roles = machine.roles;
67
+ config.capacity = machine.capacity;
68
+ save(config);
69
+ }
70
+ state();
71
+ } catch (e) {
72
+ log(`Sin señal con el tablero: ${e.message}`);
73
+ }
74
+ };
75
+
76
+ const canTake = () => !stopping && !machine.paused && !existsSync(PAUSE) && Date.now() >= pausedUntil && jobs.size < machine.capacity;
77
+
78
+ /** Varios avisos juntos cuentan como uno; con más trabajo en curso se espera un poco más (así se reparte con el equipo). */
79
+ const schedule = () => {
80
+ clearTimeout(timer);
81
+ timer = setTimeout(pump, 2000 + jobs.size * 3000);
82
+ };
83
+
84
+ const pump = async () => {
85
+ if (pumping) return;
86
+ pumping = true;
87
+ try {
88
+ while (canTake()) {
89
+ const claim = await client.claim(config.machineId);
90
+ if (!claim) break;
91
+ run(claim);
92
+ }
93
+ } catch (e) {
94
+ log(`No se pudo pedir trabajo: ${e.message}`);
95
+ } finally {
96
+ pumping = false;
97
+ }
98
+ };
99
+
100
+ const run = (claim) => {
101
+ const started = new Date().toISOString();
102
+ let work;
103
+ try {
104
+ work = prepare(config, claim);
105
+ } catch (e) {
106
+ log(`${claim.issueKey}: no se pudo preparar la carpeta de trabajo: ${e.message}`);
107
+ client.release(config.machineId, claim.issueKey, "FAILED", `No se pudo preparar la carpeta: ${e.message}`).catch(() => {});
108
+ return;
109
+ }
110
+ const logFile = join(LOGS, `${claim.issueKey}-${started.replace(/[:.]/g, "-")}.log`);
111
+ const stream = createWriteStream(logFile);
112
+ log(`${claim.issueKey} → ${claim.agentName} (${claim.roleName}) en ${work.dir}${work.repo ? " (copia del repo)" : ""}`);
113
+ const { child, done } = launch(config, claim, work.dir, stream);
114
+ const job = { claim, started, child, lost: false, timedOut: false };
115
+ jobs.set(claim.issueKey, job);
116
+ state();
117
+ if (config.keepAwake !== false) keepAwake(child.pid);
118
+
119
+ const renew = setInterval(async () => {
120
+ try {
121
+ if (!(await client.renew(config.machineId, claim.issueKey))) {
122
+ // La tarjeta ya no es de esta máquina (la movieron o la tomó otra): se corta.
123
+ job.lost = true;
124
+ log(`${claim.issueKey}: el préstamo ya no es de esta máquina; se detiene.`);
125
+ child.kill();
126
+ }
127
+ } catch (e) {
128
+ log(`${claim.issueKey}: no se pudo renovar (${e.message}); se reintenta.`);
129
+ }
130
+ }, RENEW_MS);
131
+ const limit = setTimeout(() => {
132
+ job.timedOut = true;
133
+ log(`${claim.issueKey}: pasó el tiempo máximo (${config.timeoutMinutes ?? 60} min); se detiene.`);
134
+ child.kill();
135
+ }, (config.timeoutMinutes ?? 60) * 60_000);
136
+
137
+ done.then(async (result) => {
138
+ clearInterval(renew);
139
+ clearTimeout(limit);
140
+ stream.end();
141
+ rmSync(join(SECRETS, `${claim.issueKey}.json`), { force: true });
142
+ jobs.delete(claim.issueKey);
143
+ if (!job.lost && !stopping) {
144
+ const r = job.timedOut ? { outcome: "TIMEOUT", message: `Pasó el tiempo máximo de ${config.timeoutMinutes ?? 60} minutos.` } : outcome(result);
145
+ if (r.outcome === "RATE_LIMITED") {
146
+ pausedUntil = r.resumeAt.getTime();
147
+ log(`La suscripción llegó a su límite: pausa hasta ${r.resumeAt.toLocaleString()}.`);
148
+ setTimeout(schedule, Math.max(0, pausedUntil - Date.now()) + 1000);
149
+ }
150
+ log(`${claim.issueKey}: ${r.outcome}${r.message ? ` · ${r.message.slice(0, 160)}` : ""}`);
151
+ await client.release(config.machineId, claim.issueKey, r.outcome, r.message).catch((e) => log(`${claim.issueKey}: no se pudo liberar: ${e.message}`));
152
+ }
153
+ state();
154
+ schedule();
155
+ });
156
+ };
157
+
158
+ const listen = async () => {
159
+ let wait = 5000;
160
+ while (!stopping) {
161
+ const ac = new AbortController();
162
+ try {
163
+ await client.events(() => schedule(), ac.signal);
164
+ wait = 5000;
165
+ } catch (e) {
166
+ if (e.status === 401) {
167
+ log(e.message);
168
+ process.exit(2);
169
+ }
170
+ log(`Se cortó la escucha del tablero (${e.message}); reconecta en ${wait / 1000} s.`);
171
+ }
172
+ await sleep(wait);
173
+ wait = Math.min(wait * 2, 60_000);
174
+ }
175
+ };
176
+
177
+ const shutdown = async () => {
178
+ if (stopping) return;
179
+ stopping = true;
180
+ log("Deteniendo: se liberan las tarjetas en curso.");
181
+ await Promise.all(
182
+ [...jobs.values()].map(async (j) => {
183
+ j.child.kill();
184
+ await client.release(config.machineId, j.claim.issueKey, "CANCELLED", "Se detuvo el runner.").catch(() => {});
185
+ }),
186
+ );
187
+ process.exit(0);
188
+ };
189
+ process.on("SIGTERM", shutdown);
190
+ process.on("SIGINT", shutdown);
191
+
192
+ log(`Kuador runner ${VERSION} · ${config.name} · roles: ${(config.roles ?? []).join(", ")} · hasta ${config.capacity} a la vez`);
193
+ await heartbeat(Boolean(config.needsRegister));
194
+ if (config.needsRegister) {
195
+ delete config.needsRegister;
196
+ save(config);
197
+ }
198
+ setInterval(() => heartbeat(), HEARTBEAT_MS);
199
+ setInterval(schedule, FALLBACK_MS);
200
+ setInterval(() => cleanup(config, new Set(jobs.keys())), 6 * 3600_000);
201
+ listen();
202
+ schedule();
203
+ }
package/src/prompt.js ADDED
@@ -0,0 +1,31 @@
1
+ import { createInterface } from "node:readline/promises";
2
+ import { stdin, stdout } from "node:process";
3
+
4
+ /** Preguntas en la terminal, sin dependencias. */
5
+ export function prompter() {
6
+ const rl = createInterface({ input: stdin, output: stdout });
7
+ const ask = async (question, fallback = "") => {
8
+ const answer = (await rl.question(fallback ? `${question} [${fallback}]: ` : `${question}: `)).trim();
9
+ return answer || fallback;
10
+ };
11
+ const confirm = async (question, yes = true) => {
12
+ const answer = (await rl.question(`${question} ${yes ? "[S/n]" : "[s/N]"}: `)).trim().toLowerCase();
13
+ return answer ? answer.startsWith("s") || answer.startsWith("y") : yes;
14
+ };
15
+ /** Varias opciones por número («1,3,5»), con las marcadas por defecto. Devuelve los valores elegidos. */
16
+ const choose = async (question, options, preselected) => {
17
+ options.forEach((o, i) => console.log(` ${String(i + 1).padStart(2)}. ${preselected.includes(o.value) ? "[x]" : "[ ]"} ${o.label}`));
18
+ for (;;) {
19
+ const answer = (await rl.question(`${question} (números separados por coma; Enter = los marcados): `)).trim();
20
+ if (!answer) {
21
+ if (preselected.length) return preselected;
22
+ console.log(" Elige al menos uno.");
23
+ continue;
24
+ }
25
+ const picked = [...new Set(answer.split(/[\s,]+/).map((n) => Number.parseInt(n, 10) - 1))];
26
+ if (picked.length && picked.every((i) => i >= 0 && i < options.length)) return picked.map((i) => options[i].value);
27
+ console.log(" No entendí: escribe los números de la lista, por ejemplo 1,3.");
28
+ }
29
+ };
30
+ return { ask, confirm, choose, close: () => rl.close() };
31
+ }
package/src/service.js ADDED
@@ -0,0 +1,142 @@
1
+ import { spawnSync } from "node:child_process";
2
+ import { cpSync, existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
3
+ import { homedir } from "node:os";
4
+ import { dirname, join } from "node:path";
5
+ import { fileURLToPath } from "node:url";
6
+
7
+ import { APP, LOGS } from "./config.js";
8
+
9
+ const LABEL = "ai.kuador.runner";
10
+ const here = dirname(dirname(fileURLToPath(import.meta.url)));
11
+ const run = (cmd, args) => spawnSync(cmd, args, { encoding: "utf8", shell: process.platform === "win32" });
12
+
13
+ /** Sistema operativo con nombre legible. */
14
+ export function osName() {
15
+ return { darwin: "macos", linux: "linux", win32: "windows" }[process.platform] ?? process.platform;
16
+ }
17
+
18
+ /**
19
+ * Copia el runner a ~/.kuador/app (npx lo deja en una carpeta temporal) y lo deja como servicio que arranca solo al
20
+ * iniciar sesión: launchd en Mac, systemd de usuario en Linux y el Programador de tareas en Windows.
21
+ */
22
+ export function install() {
23
+ rmSync(APP, { recursive: true, force: true });
24
+ mkdirSync(APP, { recursive: true });
25
+ for (const part of ["bin", "src", "package.json"]) cpSync(join(here, part), join(APP, part), { recursive: true });
26
+ const node = process.execPath;
27
+ const script = join(APP, "bin", "kuador-runner.js");
28
+ const path = process.env.PATH ?? "";
29
+
30
+ if (process.platform === "darwin") {
31
+ const plist = join(homedir(), "Library", "LaunchAgents", `${LABEL}.plist`);
32
+ mkdirSync(dirname(plist), { recursive: true });
33
+ writeFileSync(
34
+ plist,
35
+ `<?xml version="1.0" encoding="UTF-8"?>
36
+ <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
37
+ <plist version="1.0"><dict>
38
+ <key>Label</key><string>${LABEL}</string>
39
+ <key>ProgramArguments</key><array><string>${node}</string><string>${script}</string><string>start</string></array>
40
+ <key>EnvironmentVariables</key><dict><key>PATH</key><string>${xml(path)}</string></dict>
41
+ <key>RunAtLoad</key><true/>
42
+ <key>KeepAlive</key><true/>
43
+ <key>ThrottleInterval</key><integer>30</integer>
44
+ <key>StandardOutPath</key><string>${join(LOGS, "service.log")}</string>
45
+ <key>StandardErrorPath</key><string>${join(LOGS, "service.log")}</string>
46
+ </dict></plist>
47
+ `,
48
+ );
49
+ const domain = `gui/${process.getuid()}`;
50
+ run("launchctl", ["bootout", domain, plist]);
51
+ const r = run("launchctl", ["bootstrap", domain, plist]);
52
+ if (r.status !== 0) throw new Error(`launchd no aceptó el servicio: ${r.stderr.trim()}`);
53
+ return { kind: "launchd", file: plist };
54
+ }
55
+
56
+ if (process.platform === "linux") {
57
+ const unit = join(homedir(), ".config", "systemd", "user", "kuador-runner.service");
58
+ mkdirSync(dirname(unit), { recursive: true });
59
+ writeFileSync(
60
+ unit,
61
+ `[Unit]
62
+ Description=Kuador runner: agentes del tablero en esta máquina
63
+ After=network-online.target
64
+
65
+ [Service]
66
+ ExecStart="${node}" "${script}" start
67
+ Environment="PATH=${path}"
68
+ Restart=always
69
+ RestartSec=30
70
+
71
+ [Install]
72
+ WantedBy=default.target
73
+ `,
74
+ );
75
+ run("systemctl", ["--user", "daemon-reload"]);
76
+ const r = run("systemctl", ["--user", "enable", "--now", "kuador-runner.service"]);
77
+ if (r.status !== 0) throw new Error(`systemd no aceptó el servicio: ${r.stderr.trim()}`);
78
+ // Para que siga trabajando sin una sesión abierta (p. ej. por SSH).
79
+ run("loginctl", ["enable-linger", process.env.USER ?? ""]);
80
+ return { kind: "systemd", file: unit };
81
+ }
82
+
83
+ if (process.platform === "win32") {
84
+ const r = run("schtasks", ["/Create", "/TN", "KuadorRunner", "/SC", "ONLOGON", "/RL", "LIMITED", "/F", "/TR", `"\\"${node}\\" \\"${script}\\" start"`]);
85
+ if (r.status !== 0) throw new Error(`El Programador de tareas no aceptó el servicio: ${(r.stderr || r.stdout).trim()}`);
86
+ run("schtasks", ["/Run", "/TN", "KuadorRunner"]);
87
+ return { kind: "schtasks", file: "KuadorRunner" };
88
+ }
89
+ throw new Error(`Sistema no soportado para servicio: ${process.platform}. Usa «kuador-runner start».`);
90
+ }
91
+
92
+ export function uninstall() {
93
+ if (process.platform === "darwin") {
94
+ const plist = join(homedir(), "Library", "LaunchAgents", `${LABEL}.plist`);
95
+ run("launchctl", ["bootout", `gui/${process.getuid()}`, plist]);
96
+ if (existsSync(plist)) rmSync(plist);
97
+ } else if (process.platform === "linux") {
98
+ run("systemctl", ["--user", "disable", "--now", "kuador-runner.service"]);
99
+ rmSync(join(homedir(), ".config", "systemd", "user", "kuador-runner.service"), { force: true });
100
+ } else if (process.platform === "win32") {
101
+ run("schtasks", ["/End", "/TN", "KuadorRunner"]);
102
+ run("schtasks", ["/Delete", "/TN", "KuadorRunner", "/F"]);
103
+ }
104
+ }
105
+
106
+ /** Reinicia el servicio (tras cambiar roles o repos). */
107
+ export function restart() {
108
+ if (process.platform === "darwin") run("launchctl", ["kickstart", "-k", `gui/${process.getuid()}/${LABEL}`]);
109
+ else if (process.platform === "linux") run("systemctl", ["--user", "restart", "kuador-runner.service"]);
110
+ else if (process.platform === "win32") {
111
+ run("schtasks", ["/End", "/TN", "KuadorRunner"]);
112
+ run("schtasks", ["/Run", "/TN", "KuadorRunner"]);
113
+ }
114
+ }
115
+
116
+ /**
117
+ * Mientras haya trabajo, que la máquina no se duerma: caffeinate en Mac, systemd-inhibit en Linux. En Windows no hay
118
+ * equivalente sin permisos: se avisa en la instalación.
119
+ */
120
+ export function keepAwake(pid) {
121
+ if (process.platform === "darwin") return spawnDetached("caffeinate", ["-i", "-w", String(pid)]);
122
+ if (process.platform === "linux" && run("which", ["systemd-inhibit"]).status === 0) {
123
+ return spawnDetached("systemd-inhibit", ["--what=sleep", "--why=Kuador: un agente está trabajando", "tail", `--pid=${pid}`, "-f", "/dev/null"]);
124
+ }
125
+ return null;
126
+ }
127
+
128
+ function spawnDetached(cmd, args) {
129
+ const r = spawnSync("sh", ["-c", `${cmd} ${args.map((a) => `'${a.replace(/'/g, "'\\''")}'`).join(" ")} >/dev/null 2>&1 &`]);
130
+ return r.status === 0;
131
+ }
132
+
133
+ /** Abre el enlace en el navegador si se puede (por SSH no hay: se muestra para copiarlo). */
134
+ export function openBrowser(url) {
135
+ if (process.env.KUADOR_NO_BROWSER) return false;
136
+ const cmd = { darwin: "open", win32: "start", linux: "xdg-open" }[process.platform];
137
+ if (!cmd) return false;
138
+ const r = process.platform === "win32" ? run("cmd", ["/c", "start", "", url]) : run(cmd, [url]);
139
+ return r.status === 0;
140
+ }
141
+
142
+ const xml = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
package/src/tools.js ADDED
@@ -0,0 +1,94 @@
1
+ import { spawn, spawnSync } from "node:child_process";
2
+ import { writeFileSync } from "node:fs";
3
+ import { join } from "node:path";
4
+
5
+ import { SECRETS } from "./config.js";
6
+
7
+ const WINDOWS = process.platform === "win32";
8
+
9
+ /** Herramientas de IA que el runner sabe lanzar. Codex y OpenCode llegan en la próxima versión. */
10
+ export const TOOLS = {
11
+ claude: { label: "Claude Code", command: "claude", ready: true },
12
+ codex: { label: "Codex", command: "codex", ready: false },
13
+ opencode: { label: "OpenCode", command: "opencode", ready: false },
14
+ };
15
+
16
+ /** Versión instalada de la herramienta, o null si no está. */
17
+ export function detect(tool) {
18
+ const r = spawnSync(TOOLS[tool].command, ["--version"], { encoding: "utf8", shell: WINDOWS, timeout: 15_000 });
19
+ return r.status === 0 ? (r.stdout || r.stderr).trim().split("\n")[0] : null;
20
+ }
21
+
22
+ /** Modelos que entiende Claude Code (los del tablero pueden ser de otro proveedor: entonces usa el de tu cuenta). */
23
+ const claudeModel = (model) => (model && /^(claude-|opus|sonnet|haiku|fable)/i.test(model) ? model : null);
24
+ const EFFORTS = ["low", "medium", "high", "xhigh", "max"];
25
+
26
+ /**
27
+ * Lanza el cliente de IA con la tarjeta. La conexión al tablero va en un archivo fuera de la carpeta de trabajo (nunca
28
+ * dentro del repo) y solo legible por ti. Devuelve el proceso y una promesa con el resultado.
29
+ */
30
+ export function launch(config, claim, cwd, logStream) {
31
+ const mcpFile = join(SECRETS, `${claim.issueKey}.json`);
32
+ writeFileSync(
33
+ mcpFile,
34
+ JSON.stringify({ mcpServers: { [claim.mcpServer]: { type: "http", url: claim.mcpUrl, headers: { Authorization: `Bearer ${config.token}` } } } }),
35
+ { mode: 0o600 },
36
+ );
37
+ const args = [
38
+ "-p",
39
+ claim.prompt,
40
+ "--mcp-config",
41
+ mcpFile,
42
+ "--strict-mcp-config",
43
+ "--append-system-prompt",
44
+ claim.instructions,
45
+ "--allowedTools",
46
+ claim.allowedTools.join(","),
47
+ "--output-format",
48
+ "json",
49
+ ];
50
+ const model = claudeModel(claim.model);
51
+ if (model) args.push("--model", model);
52
+ if (claim.effort && EFFORTS.includes(claim.effort)) args.push("--effort", claim.effort);
53
+
54
+ const child = spawn(TOOLS.claude.command, args, { cwd, shell: WINDOWS, env: { ...process.env, KUADOR_ISSUE: claim.issueKey }, windowsHide: true });
55
+ let out = "";
56
+ let err = "";
57
+ child.stdout.on("data", (d) => {
58
+ out += d;
59
+ logStream?.write(d);
60
+ });
61
+ child.stderr.on("data", (d) => {
62
+ err += d;
63
+ logStream?.write(d);
64
+ });
65
+ const done = new Promise((resolve) => {
66
+ child.on("error", (e) => resolve({ code: -1, out, err: err + String(e) }));
67
+ child.on("close", (code) => resolve({ code, out, err }));
68
+ });
69
+ return { child, done };
70
+ }
71
+
72
+ /** Interpreta lo que devolvió Claude Code: terminó bien, falló o llegó al límite de la suscripción. */
73
+ export function outcome({ code, out, err }) {
74
+ const text = `${out}\n${err}`;
75
+ let result = null;
76
+ try {
77
+ result = JSON.parse(out.trim().split("\n").filter(Boolean).pop() ?? "");
78
+ } catch {
79
+ // No es JSON: se mira el texto.
80
+ }
81
+ if (/usage limit|rate.?limit|limit reached|quota|5-hour limit|weekly limit/i.test(text) && (code !== 0 || result?.is_error)) {
82
+ return { outcome: "RATE_LIMITED", message: "La suscripción de IA llegó a su límite de uso.", resumeAt: resetTime(text) };
83
+ }
84
+ if (code === 0 && !result?.is_error) return { outcome: "DONE", message: String(result?.result ?? "").slice(0, 300), usage: result?.usage };
85
+ const why = (result?.result || err || out || `salió con código ${code}`).toString().trim().split("\n").slice(-3).join(" ");
86
+ return { outcome: "FAILED", message: `Claude Code: ${why}`.slice(0, 480) };
87
+ }
88
+
89
+ /** Si el mensaje dice cuándo se renueva el límite; si no, en 30 minutos se vuelve a intentar. */
90
+ function resetTime(text) {
91
+ const epoch = text.match(/\|(\d{10})\b/);
92
+ if (epoch) return new Date(Number(epoch[1]) * 1000);
93
+ return new Date(Date.now() + 30 * 60_000);
94
+ }
package/src/workdir.js ADDED
@@ -0,0 +1,49 @@
1
+ import { spawnSync } from "node:child_process";
2
+ import { existsSync, mkdirSync, readdirSync, rmSync, statSync } from "node:fs";
3
+ import { join } from "node:path";
4
+
5
+ import { WORK } from "./config.js";
6
+
7
+ const git = (cwd, ...args) => spawnSync("git", args, { cwd, encoding: "utf8", timeout: 120_000 });
8
+
9
+ /** ¿Es un repositorio git? */
10
+ export function isRepo(path) {
11
+ return existsSync(path) && git(path, "rev-parse", "--is-inside-work-tree").stdout?.trim() === "true";
12
+ }
13
+
14
+ /**
15
+ * Carpeta de trabajo de la tarjeta. Con el repo del tablero vinculado, una copia aparte (git worktree) por tarjeta: así
16
+ * varias trabajan en paralelo sin pisarse las ramas. Sin repo (ventas, marketing...), una carpeta vacía.
17
+ */
18
+ export function prepare(config, claim) {
19
+ const dir = join(WORK, claim.issueKey);
20
+ const repo = config.repos?.[claim.projectKey];
21
+ if (repo && isRepo(repo)) {
22
+ if (existsSync(dir) && isRepo(dir)) return { dir, repo: true };
23
+ git(repo, "fetch", "--quiet", "--all", "--prune");
24
+ git(repo, "worktree", "prune");
25
+ const base = ["origin/develop", "origin/main", "origin/master", "HEAD"].find((ref) => git(repo, "rev-parse", "--verify", "--quiet", ref).status === 0);
26
+ const r = git(repo, "worktree", "add", "--detach", dir, base ?? "HEAD");
27
+ if (r.status === 0) return { dir, repo: true };
28
+ }
29
+ mkdirSync(dir, { recursive: true });
30
+ return { dir, repo: false };
31
+ }
32
+
33
+ /** Borra las carpetas de tarjetas sin tocar hace más de una semana (las copias del repo, con git). */
34
+ export function cleanup(config, active) {
35
+ if (!existsSync(WORK)) return;
36
+ const old = Date.now() - 7 * 24 * 3600_000;
37
+ for (const name of readdirSync(WORK)) {
38
+ if (active.has(name)) continue;
39
+ const dir = join(WORK, name);
40
+ try {
41
+ if (statSync(dir).mtimeMs > old) continue;
42
+ const repo = Object.values(config.repos ?? {}).find((r) => isRepo(r) && git(r, "worktree", "list").stdout.includes(dir));
43
+ if (repo) git(repo, "worktree", "remove", "--force", dir);
44
+ rmSync(dir, { recursive: true, force: true });
45
+ } catch {
46
+ // Se reintenta en la próxima limpieza.
47
+ }
48
+ }
49
+ }