@hoilab/ada-cli 0.84.22 → 0.85.0

package/dist/core/importar/formatos.js

@@ -0,0 +1,235 @@
+/**
+ * Importar sesiones de Claude Code y de Codex.
+ *
+ * Es coste de cambio. Quien lleva meses trabajando con otra herramienta tiene
+ * ahí su historial: lo que decidió, por qué, y las conversaciones que busca
+ * cuando vuelve a un proyecto. Pedirle que lo deje atrás es pedirle que empiece
+ * de cero, y eso pesa más que cualquier comparativa de capacidades.
+ *
+ * QUÉ SE IMPORTA Y QUÉ NO, dicho antes de que alguien lo descubra por su
+ * cuenta: se importa la CONVERSACIÓN —lo que se dijo, en orden y con su
+ * estructura de padres— y no el ESTADO. Las llamadas a herramientas y sus
+ * resultados se aplanan a texto legible, porque no se pueden reproducir: los
+ * ficheros han cambiado, los procesos murieron y los identificadores de
+ * herramienta no significan nada aquí. Una sesión importada sirve para leerla,
+ * buscarla y continuarla con contexto; no para rebobinarla.
+ *
+ * Fingir lo contrario sería peor que no importar: el usuario haría `undo` sobre
+ * una sesión importada y no pasaría nada.
+ */
+function aMilisegundos(valor) {
+    if (typeof valor === "number")
+        return valor;
+    if (typeof valor === "string") {
+        const t = Date.parse(valor);
+        if (!Number.isNaN(t))
+            return t;
+    }
+    return 0;
+}
+/**
+ * Aplana el contenido de un mensaje a bloques de texto.
+ *
+ * Las llamadas a herramienta se convierten en una línea legible en vez de
+ * desaparecer: leer «⚙ bash: npm test» explica el hilo de la conversación,
+ * mientras que quitarlo deja saltos que no se entienden.
+ */
+function aTexto(contenido) {
+    if (typeof contenido === "string")
+        return contenido.trim() ? [{ type: "text", text: contenido }] : [];
+    if (!Array.isArray(contenido))
+        return [];
+    const bloques = [];
+    for (const bruto of contenido) {
+        if (typeof bruto === "string") {
+            if (bruto.trim())
+                bloques.push({ type: "text", text: bruto });
+            continue;
+        }
+        if (!bruto || typeof bruto !== "object")
+            continue;
+        const b = bruto;
+        switch (b.type) {
+            case "text":
+            case "input_text":
+            case "output_text":
+                if (typeof b.text === "string" && b.text.trim())
+                    bloques.push({ type: "text", text: b.text });
+                break;
+            case "thinking":
+            case "reasoning":
+                if (typeof b.thinking === "string" && b.thinking.trim())
+                    bloques.push({ type: "text", text: b.thinking });
+                break;
+            case "tool_use":
+            case "function_call":
+                bloques.push({
+                    type: "text",
+                    text: `⚙ ${String(b.name ?? "herramienta")}: ${JSON.stringify(b.input ?? b.arguments ?? {}).slice(0, 400)}`,
+                });
+                break;
+            case "tool_result":
+            case "function_call_output": {
+                const salida = aTexto(b.content ?? b.output)
+                    .map((x) => x.text)
+                    .join("\n");
+                if (salida.trim())
+                    bloques.push({ type: "text", text: `↩ ${salida.slice(0, 800)}` });
+                break;
+            }
+            default:
+                break;
+        }
+    }
+    return bloques;
+}
+/** La cabecera que abre un fichero de sesión de Ada. */
+function cabecera(id, cwd, cuando) {
+    return { type: "session", id, cwd, timestamp: cuando, version: 1 };
+}
+/**
+ * Claude Code: un JSONL con entradas `user` y `assistant` encadenadas por
+ * `parentUuid`. El resto de tipos (`attachment`, `queue-operation`, `mode`…) es
+ * estado interno suyo y no tiene sentido aquí.
+ */
+export function convertirClaudeCode(lineas, idSesion) {
+    const salida = [];
+    let cwd = "";
+    let primero = 0;
+    for (const linea of lineas) {
+        let d;
+        try {
+            d = JSON.parse(linea);
+        }
+        catch {
+            continue;
+        }
+        if (d.type !== "user" && d.type !== "assistant")
+            continue;
+        const mensaje = d.message;
+        if (!mensaje)
+            continue;
+        const bloques = aTexto(mensaje.content);
+        if (bloques.length === 0)
+            continue;
+        const cuando = aMilisegundos(d.timestamp);
+        if (!cwd && typeof d.cwd === "string")
+            cwd = d.cwd;
+        if (!primero)
+            primero = cuando;
+        salida.push({
+            type: "message",
+            id: String(d.uuid ?? `${salida.length}`),
+            // Se conserva la cadena de padres del origen: es lo que permite que
+            // las ramas de la conversación sigan siendo ramas al importarlas.
+            ...(typeof d.parentUuid === "string" ? { parentId: d.parentUuid } : {}),
+            timestamp: cuando,
+            message: { role: String(mensaje.role ?? d.type), content: bloques, timestamp: cuando },
+        });
+    }
+    return salida.length === 0 ? [] : [cabecera(idSesion, cwd, primero), ...salida];
+}
+/**
+ * Codex: un «rollout» con `session_meta` y `response_item`.
+ *
+ * No trae cadena de padres, así que se encadena por orden de aparición, que es
+ * como se leyó la conversación. Los mensajes de rol `developer` son la
+ * inyección de sistema de su harness y no forman parte de lo que dijo nadie.
+ */
+export function convertirCodex(lineas, idSesion) {
+    const salida = [];
+    let cwd = "";
+    let primero = 0;
+    let anterior;
+    for (const linea of lineas) {
+        let d;
+        try {
+            d = JSON.parse(linea);
+        }
+        catch {
+            continue;
+        }
+        const carga = d.payload;
+        if (d.type === "session_meta" && carga && typeof carga.cwd === "string") {
+            cwd = carga.cwd;
+            continue;
+        }
+        if (d.type !== "response_item" || !carga || carga.type !== "message")
+            continue;
+        const rol = String(carga.role ?? "");
+        if (rol === "developer" || rol === "system")
+            continue;
+        const bloques = aTexto(carga.content);
+        if (bloques.length === 0)
+            continue;
+        const cuando = aMilisegundos(d.timestamp);
+        if (!primero)
+            primero = cuando;
+        const id = String(carga.id ?? `${salida.length}`);
+        salida.push({
+            type: "message",
+            id,
+            ...(anterior ? { parentId: anterior } : {}),
+            timestamp: cuando,
+            message: { role: rol, content: bloques, timestamp: cuando },
+        });
+        anterior = id;
+    }
+    return salida.length === 0 ? [] : [cabecera(idSesion, cwd, primero), ...salida];
+}
+/** Reconoce el formato por la forma de sus líneas, no por la extensión. */
+export function detectarFormato(lineas) {
+    for (const linea of lineas.slice(0, 40)) {
+        try {
+            const d = JSON.parse(linea);
+            if (d.type === "session_meta" || (d.type === "response_item" && d.payload))
+                return "codex";
+            if ((d.type === "user" || d.type === "assistant") && d.message && d.sessionId)
+                return "claude-code";
+        }
+        catch {
+            // Una línea ilegible no dice nada del formato del fichero.
+        }
+    }
+    return null;
+}
+export function convertir(lineas, idSesion) {
+    const formato = detectarFormato(lineas);
+    if (!formato)
+        return null;
+    const entradas = formato === "codex" ? convertirCodex(lineas, idSesion) : convertirClaudeCode(lineas, idSesion);
+    return entradas.length === 0 ? null : { formato, entradas };
+}
+/**
+ * ¿Este mensaje de usuario lo escribió una persona, o lo inyectó el harness?
+ *
+ * Codex mete su `<environment_context>` y el AGENTS.md del proyecto como
+ * mensajes de rol `user`, así que el "primer prompt" de media sesión importada
+ * salía siendo un volcado de configuración. Se importan igual —formaban parte
+ * del contexto— pero no sirven para que alguien reconozca su sesión en una
+ * lista, que es para lo que existe el resumen.
+ *
+ * Se descubrió convirtiendo ficheros reales, no las muestras.
+ */
+function pareceInyeccion(texto) {
+    const inicio = texto.trimStart().slice(0, 120);
+    return (inicio.startsWith("<environment_context>") ||
+        inicio.startsWith("<INSTRUCTIONS>") ||
+        inicio.startsWith("# AGENTS.md") ||
+        inicio.startsWith("<skills_instructions>") ||
+        inicio.startsWith("<system-reminder>"));
+}
+/** Lo que hace falta para elegir una sesión de una lista. */
+export function resumir(entradas, formato, ruta) {
+    const mensajes = entradas.filter((e) => e.type === "message");
+    const primerUsuario = mensajes.find((e) => e.message?.role === "user" && !pareceInyeccion(e.message.content[0]?.text ?? ""));
+    return {
+        formato,
+        ruta,
+        cwd: entradas[0]?.cwd ?? "",
+        mensajes: mensajes.length,
+        primerPrompt: (primerUsuario?.message?.content[0]?.text ?? "").replace(/\s+/g, " ").slice(0, 80),
+        cuando: entradas[0]?.timestamp ?? 0,
+    };
+}
+//# sourceMappingURL=formatos.js.map

package/dist/core/importar/formatos.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"formatos.js","sourceRoot":"","sources":["../../../src/core/importar/formatos.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Importar sesiones de Claude Code y de Codex.\n *\n * Es coste de cambio. Quien lleva meses trabajando con otra herramienta tiene\n * ahí su historial: lo que decidió, por qué, y las conversaciones que busca\n * cuando vuelve a un proyecto. Pedirle que lo deje atrás es pedirle que empiece\n * de cero, y eso pesa más que cualquier comparativa de capacidades.\n *\n * QUÉ SE IMPORTA Y QUÉ NO, dicho antes de que alguien lo descubra por su\n * cuenta: se importa la CONVERSACIÓN —lo que se dijo, en orden y con su\n * estructura de padres— y no el ESTADO. Las llamadas a herramientas y sus\n * resultados se aplanan a texto legible, porque no se pueden reproducir: los\n * ficheros han cambiado, los procesos murieron y los identificadores de\n * herramienta no significan nada aquí. Una sesión importada sirve para leerla,\n * buscarla y continuarla con contexto; no para rebobinarla.\n *\n * Fingir lo contrario sería peor que no importar: el usuario haría `undo` sobre\n * una sesión importada y no pasaría nada.\n */\n\n/** Una entrada del fichero de sesión de Ada. */\nexport interface EntradaAda {\n\ttype: \"session\" | \"message\";\n\tid: string;\n\tparentId?: string;\n\ttimestamp: number;\n\tcwd?: string;\n\tversion?: number;\n\tmessage?: { role: string; content: Array<{ type: string; text: string }>; timestamp: number };\n}\n\nexport type Formato = \"claude-code\" | \"codex\";\n\n/** Resumen de una sesión importable, para poder elegir sin abrirla. */\nexport interface ResumenSesion {\n\tformato: Formato;\n\truta: string;\n\tcwd: string;\n\tmensajes: number;\n\tprimerPrompt: string;\n\tcuando: number;\n}\n\nfunction aMilisegundos(valor: unknown): number {\n\tif (typeof valor === \"number\") return valor;\n\tif (typeof valor === \"string\") {\n\t\tconst t = Date.parse(valor);\n\t\tif (!Number.isNaN(t)) return t;\n\t}\n\treturn 0;\n}\n\n/**\n * Aplana el contenido de un mensaje a bloques de texto.\n *\n * Las llamadas a herramienta se convierten en una línea legible en vez de\n * desaparecer: leer «⚙ bash: npm test» explica el hilo de la conversación,\n * mientras que quitarlo deja saltos que no se entienden.\n */\nfunction aTexto(contenido: unknown): Array<{ type: string; text: string }> {\n\tif (typeof contenido === \"string\") return contenido.trim() ? [{ type: \"text\", text: contenido }] : [];\n\tif (!Array.isArray(contenido)) return [];\n\tconst bloques: Array<{ type: string; text: string }> = [];\n\tfor (const bruto of contenido) {\n\t\tif (typeof bruto === \"string\") {\n\t\t\tif (bruto.trim()) bloques.push({ type: \"text\", text: bruto });\n\t\t\tcontinue;\n\t\t}\n\t\tif (!bruto || typeof bruto !== \"object\") continue;\n\t\tconst b = bruto as Record<string, unknown>;\n\t\tswitch (b.type) {\n\t\t\tcase \"text\":\n\t\t\tcase \"input_text\":\n\t\t\tcase \"output_text\":\n\t\t\t\tif (typeof b.text === \"string\" && b.text.trim()) bloques.push({ type: \"text\", text: b.text });\n\t\t\t\tbreak;\n\t\t\tcase \"thinking\":\n\t\t\tcase \"reasoning\":\n\t\t\t\tif (typeof b.thinking === \"string\" && b.thinking.trim()) bloques.push({ type: \"text\", text: b.thinking });\n\t\t\t\tbreak;\n\t\t\tcase \"tool_use\":\n\t\t\tcase \"function_call\":\n\t\t\t\tbloques.push({\n\t\t\t\t\ttype: \"text\",\n\t\t\t\t\ttext: `⚙ ${String(b.name ?? \"herramienta\")}: ${JSON.stringify(b.input ?? b.arguments ?? {}).slice(0, 400)}`,\n\t\t\t\t});\n\t\t\t\tbreak;\n\t\t\tcase \"tool_result\":\n\t\t\tcase \"function_call_output\": {\n\t\t\t\tconst salida = aTexto(b.content ?? b.output)\n\t\t\t\t\t.map((x) => x.text)\n\t\t\t\t\t.join(\"\\n\");\n\t\t\t\tif (salida.trim()) bloques.push({ type: \"text\", text: `↩ ${salida.slice(0, 800)}` });\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tdefault:\n\t\t\t\tbreak;\n\t\t}\n\t}\n\treturn bloques;\n}\n\n/** La cabecera que abre un fichero de sesión de Ada. */\nfunction cabecera(id: string, cwd: string, cuando: number): EntradaAda {\n\treturn { type: \"session\", id, cwd, timestamp: cuando, version: 1 };\n}\n\n/**\n * Claude Code: un JSONL con entradas `user` y `assistant` encadenadas por\n * `parentUuid`. El resto de tipos (`attachment`, `queue-operation`, `mode`…) es\n * estado interno suyo y no tiene sentido aquí.\n */\nexport function convertirClaudeCode(lineas: string[], idSesion: string): EntradaAda[] {\n\tconst salida: EntradaAda[] = [];\n\tlet cwd = \"\";\n\tlet primero = 0;\n\tfor (const linea of lineas) {\n\t\tlet d: Record<string, unknown>;\n\t\ttry {\n\t\t\td = JSON.parse(linea) as Record<string, unknown>;\n\t\t} catch {\n\t\t\tcontinue;\n\t\t}\n\t\tif (d.type !== \"user\" && d.type !== \"assistant\") continue;\n\t\tconst mensaje = d.message as { role?: string; content?: unknown } | undefined;\n\t\tif (!mensaje) continue;\n\t\tconst bloques = aTexto(mensaje.content);\n\t\tif (bloques.length === 0) continue;\n\t\tconst cuando = aMilisegundos(d.timestamp);\n\t\tif (!cwd && typeof d.cwd === \"string\") cwd = d.cwd;\n\t\tif (!primero) primero = cuando;\n\t\tsalida.push({\n\t\t\ttype: \"message\",\n\t\t\tid: String(d.uuid ?? `${salida.length}`),\n\t\t\t// Se conserva la cadena de padres del origen: es lo que permite que\n\t\t\t// las ramas de la conversación sigan siendo ramas al importarlas.\n\t\t\t...(typeof d.parentUuid === \"string\" ? { parentId: d.parentUuid } : {}),\n\t\t\ttimestamp: cuando,\n\t\t\tmessage: { role: String(mensaje.role ?? d.type), content: bloques, timestamp: cuando },\n\t\t});\n\t}\n\treturn salida.length === 0 ? [] : [cabecera(idSesion, cwd, primero), ...salida];\n}\n\n/**\n * Codex: un «rollout» con `session_meta` y `response_item`.\n *\n * No trae cadena de padres, así que se encadena por orden de aparición, que es\n * como se leyó la conversación. Los mensajes de rol `developer` son la\n * inyección de sistema de su harness y no forman parte de lo que dijo nadie.\n */\nexport function convertirCodex(lineas: string[], idSesion: string): EntradaAda[] {\n\tconst salida: EntradaAda[] = [];\n\tlet cwd = \"\";\n\tlet primero = 0;\n\tlet anterior: string | undefined;\n\tfor (const linea of lineas) {\n\t\tlet d: Record<string, unknown>;\n\t\ttry {\n\t\t\td = JSON.parse(linea) as Record<string, unknown>;\n\t\t} catch {\n\t\t\tcontinue;\n\t\t}\n\t\tconst carga = d.payload as Record<string, unknown> | undefined;\n\t\tif (d.type === \"session_meta\" && carga && typeof carga.cwd === \"string\") {\n\t\t\tcwd = carga.cwd;\n\t\t\tcontinue;\n\t\t}\n\t\tif (d.type !== \"response_item\" || !carga || carga.type !== \"message\") continue;\n\t\tconst rol = String(carga.role ?? \"\");\n\t\tif (rol === \"developer\" || rol === \"system\") continue;\n\t\tconst bloques = aTexto(carga.content);\n\t\tif (bloques.length === 0) continue;\n\t\tconst cuando = aMilisegundos(d.timestamp);\n\t\tif (!primero) primero = cuando;\n\t\tconst id = String(carga.id ?? `${salida.length}`);\n\t\tsalida.push({\n\t\t\ttype: \"message\",\n\t\t\tid,\n\t\t\t...(anterior ? { parentId: anterior } : {}),\n\t\t\ttimestamp: cuando,\n\t\t\tmessage: { role: rol, content: bloques, timestamp: cuando },\n\t\t});\n\t\tanterior = id;\n\t}\n\treturn salida.length === 0 ? [] : [cabecera(idSesion, cwd, primero), ...salida];\n}\n\n/** Reconoce el formato por la forma de sus líneas, no por la extensión. */\nexport function detectarFormato(lineas: string[]): Formato | null {\n\tfor (const linea of lineas.slice(0, 40)) {\n\t\ttry {\n\t\t\tconst d = JSON.parse(linea) as Record<string, unknown>;\n\t\t\tif (d.type === \"session_meta\" || (d.type === \"response_item\" && d.payload)) return \"codex\";\n\t\t\tif ((d.type === \"user\" || d.type === \"assistant\") && d.message && d.sessionId) return \"claude-code\";\n\t\t} catch {\n\t\t\t// Una línea ilegible no dice nada del formato del fichero.\n\t\t}\n\t}\n\treturn null;\n}\n\nexport function convertir(lineas: string[], idSesion: string): { formato: Formato; entradas: EntradaAda[] } | null {\n\tconst formato = detectarFormato(lineas);\n\tif (!formato) return null;\n\tconst entradas = formato === \"codex\" ? convertirCodex(lineas, idSesion) : convertirClaudeCode(lineas, idSesion);\n\treturn entradas.length === 0 ? null : { formato, entradas };\n}\n\n/**\n * ¿Este mensaje de usuario lo escribió una persona, o lo inyectó el harness?\n *\n * Codex mete su `<environment_context>` y el AGENTS.md del proyecto como\n * mensajes de rol `user`, así que el \"primer prompt\" de media sesión importada\n * salía siendo un volcado de configuración. Se importan igual —formaban parte\n * del contexto— pero no sirven para que alguien reconozca su sesión en una\n * lista, que es para lo que existe el resumen.\n *\n * Se descubrió convirtiendo ficheros reales, no las muestras.\n */\nfunction pareceInyeccion(texto: string): boolean {\n\tconst inicio = texto.trimStart().slice(0, 120);\n\treturn (\n\t\tinicio.startsWith(\"<environment_context>\") ||\n\t\tinicio.startsWith(\"<INSTRUCTIONS>\") ||\n\t\tinicio.startsWith(\"# AGENTS.md\") ||\n\t\tinicio.startsWith(\"<skills_instructions>\") ||\n\t\tinicio.startsWith(\"<system-reminder>\")\n\t);\n}\n\n/** Lo que hace falta para elegir una sesión de una lista. */\nexport function resumir(entradas: EntradaAda[], formato: Formato, ruta: string): ResumenSesion {\n\tconst mensajes = entradas.filter((e) => e.type === \"message\");\n\tconst primerUsuario = mensajes.find(\n\t\t(e) => e.message?.role === \"user\" && !pareceInyeccion(e.message.content[0]?.text ?? \"\"),\n\t);\n\treturn {\n\t\tformato,\n\t\truta,\n\t\tcwd: entradas[0]?.cwd ?? \"\",\n\t\tmensajes: mensajes.length,\n\t\tprimerPrompt: (primerUsuario?.message?.content[0]?.text ?? \"\").replace(/\\s+/g, \" \").slice(0, 80),\n\t\tcuando: entradas[0]?.timestamp ?? 0,\n\t};\n}\n"]}

package/dist/core/interactivo/deteccion.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Detectar si un proceso vivo está ESPERANDO ENTRADA.
+ *
+ * Es la pieza difícil del hueco: `bash` normal lanza y espera a que el
+ * proceso termine solo, y un comando que pregunta "¿seguro? [s/n]" o pide una
+ * contraseña no termina nunca por su cuenta — se queda ahí, y `bash` lo lee
+ * como "no responde" hasta que salta el timeout.
+ *
+ * Dos señales, ninguna perfecta por sí sola:
+ *
+ *   1. PATRÓN EN LA SALIDA. La cola de lo escrito coincide con una pregunta
+ *      conocida (confirmación s/n, contraseña, prompt de intérprete…). Es la
+ *      señal fuerte: determinista y explicable.
+ *   2. INACTIVIDAD CON EL PROCESO VIVO. No ha llegado salida nueva en un
+ *      rato Y lo último que se escribió no terminó en salto de línea — que es
+ *      justo la forma de un `print("Password: ")` sin `\n` al final. Sola,
+ *      esta señal confundiría "está esperando" con "está pensando"; por eso
+ *      exige la falta de salto de línea, no solo el silencio.
+ *
+ * Lo que NO se hace: hilar todos los prompts posibles del universo. Un
+ * comando normal (`echo hola`) termina solo — el proceso deja de estar vivo
+ * antes de que esto se llegue a preguntar, así que ni siquiera hace falta que
+ * la lista de patrones sea exhaustiva para no dispararse con él.
+ */
+/** Busca un patrón conocido en la cola de salida. `null` si ninguno coincide. */
+export declare function detectarPromptEnSalida(salida: string): {
+    nombre: string;
+} | null;
+export interface EstadoDeEspera {
+    esperando: boolean;
+    /** Por qué se decidió. `null` cuando `esperando` es `false`: no hay nada que explicar. */
+    motivo: string | null;
+}
+export declare function detectarEsperaEntrada(opciones: {
+    /** Toda la salida acumulada desde la última consulta (o desde el arranque). */
+    salidaReciente: string;
+    /** Milisegundos desde el último byte recibido. */
+    msDesdeUltimaSalida: number;
+    /** Si el proceso sigue vivo. Un proceso muerto no puede estar esperando nada. */
+    vivo: boolean;
+    /** A partir de cuánta inactividad se considera la señal débil. Por defecto 1200ms. */
+    umbralInactividadMs?: number;
+}): EstadoDeEspera;
+//# sourceMappingURL=deteccion.d.ts.map

package/dist/core/interactivo/deteccion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deteccion.d.ts","sourceRoot":"","sources":["../../../src/core/interactivo/deteccion.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAyCH,kFAAiF;AACjF,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,MAAM,GAAG;IAAE,MAAM,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAMhF;AAED,MAAM,WAAW,cAAc;IAC9B,SAAS,EAAE,OAAO,CAAC;IACnB,4FAA0F;IAC1F,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;CACtB;AAKD,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE;IAC/C,gFAA+E;IAC/E,cAAc,EAAE,MAAM,CAAC;IACvB,mDAAkD;IAClD,mBAAmB,EAAE,MAAM,CAAC;IAC5B,iFAAiF;IACjF,IAAI,EAAE,OAAO,CAAC;IACd,yFAAsF;IACtF,mBAAmB,CAAC,EAAE,MAAM,CAAC;CAC7B,GAAG,cAAc,CAejB","sourcesContent":["/**\n * Detectar si un proceso vivo está ESPERANDO ENTRADA.\n *\n * Es la pieza difícil del hueco: `bash` normal lanza y espera a que el\n * proceso termine solo, y un comando que pregunta \"¿seguro? [s/n]\" o pide una\n * contraseña no termina nunca por su cuenta — se queda ahí, y `bash` lo lee\n * como \"no responde\" hasta que salta el timeout.\n *\n * Dos señales, ninguna perfecta por sí sola:\n *\n *   1. PATRÓN EN LA SALIDA. La cola de lo escrito coincide con una pregunta\n *      conocida (confirmación s/n, contraseña, prompt de intérprete…). Es la\n *      señal fuerte: determinista y explicable.\n *   2. INACTIVIDAD CON EL PROCESO VIVO. No ha llegado salida nueva en un\n *      rato Y lo último que se escribió no terminó en salto de línea — que es\n *      justo la forma de un `print(\"Password: \")` sin `\\n` al final. Sola,\n *      esta señal confundiría \"está esperando\" con \"está pensando\"; por eso\n *      exige la falta de salto de línea, no solo el silencio.\n *\n * Lo que NO se hace: hilar todos los prompts posibles del universo. Un\n * comando normal (`echo hola`) termina solo — el proceso deja de estar vivo\n * antes de que esto se llegue a preguntar, así que ni siquiera hace falta que\n * la lista de patrones sea exhaustiva para no dispararse con él.\n */\n\n/** Un patrón de prompt reconocido, con nombre para explicar la decisión. */\ninterface PatronDePrompt {\n\tnombre: string;\n\tregex: RegExp;\n}\n\n// Todos anclados a `$` (fin del trozo de salida mirado): un prompt de verdad\n// es lo ÚLTIMO que se escribió, no una frase que aparezca de pasada en medio\n// de un log. Sin el anclaje, un script que simplemente IMPRIME la palabra\n// \"password\" en un mensaje informativo se marcaría como esperando entrada.\nconst PATRONES_DE_PROMPT: PatronDePrompt[] = [\n\t{\n\t\t// \"[s/n]\", \"(y/n)\", \"[Y/n]\", \"(yes/no)\"… Restringido a palabras de\n\t\t// confirmación conocidas y NO a dígitos, porque \"[3/10]\" de una barra de\n\t\t// progreso tiene la misma forma y no es una pregunta.\n\t\tnombre: \"confirmación s/n\",\n\t\tregex: /[[(]\\s*(?:s[ií]?|y(?:es)?|n[oó]?)\\s*\\/\\s*(?:s[ií]?|y(?:es)?|n[oó]?)\\s*[\\])]\\s*:?\\s*$/iu,\n\t},\n\t{\n\t\tnombre: \"contraseña\",\n\t\tregex: /\\b(?:password|contrase[nñ]a|passphrase)\\s*:?\\s*$/iu,\n\t},\n\t{\n\t\tnombre: \"pulsa una tecla\",\n\t\tregex: /press\\s+(?:any\\s+key|enter|return)\\b/iu,\n\t},\n\t{\n\t\tnombre: \"confirmación abierta\",\n\t\tregex: /\\b(?:continue|continuar|proceed|are you sure)\\?\\s*$/iu,\n\t},\n\t{\n\t\t// Prompts de intérpretes conocidos: Python, IPython, Node, Ruby, MySQL,\n\t\t// psql, gdb, sqlite3. Cada uno es la forma exacta con la que ese REPL deja\n\t\t// el cursor esperando la siguiente línea.\n\t\tnombre: \"prompt de intérprete\",\n\t\tregex: /(?:^|\\n)\\s*(?:>>>|\\.\\.\\.|In \\[\\d+\\]:|irb\\([^)]*\\):\\d+:\\d+[>*]|mysql>|psql[^\\n]*[=#-]>|\\(gdb\\)|sqlite>)\\s*$/iu,\n\t},\n];\n\n/** Busca un patrón conocido en la cola de salida. `null` si ninguno coincide. */\nexport function detectarPromptEnSalida(salida: string): { nombre: string } | null {\n\tfor (const { nombre, regex } of PATRONES_DE_PROMPT) {\n\t\tregex.lastIndex = 0;\n\t\tif (regex.test(salida)) return { nombre };\n\t}\n\treturn null;\n}\n\nexport interface EstadoDeEspera {\n\tesperando: boolean;\n\t/** Por qué se decidió. `null` cuando `esperando` es `false`: no hay nada que explicar. */\n\tmotivo: string | null;\n}\n\n/** Cuánta cola de salida se mira. Un prompt vive en las últimas líneas, no en todo el historial. */\nconst VENTANA_DE_COLA = 500;\n\nexport function detectarEsperaEntrada(opciones: {\n\t/** Toda la salida acumulada desde la última consulta (o desde el arranque). */\n\tsalidaReciente: string;\n\t/** Milisegundos desde el último byte recibido. */\n\tmsDesdeUltimaSalida: number;\n\t/** Si el proceso sigue vivo. Un proceso muerto no puede estar esperando nada. */\n\tvivo: boolean;\n\t/** A partir de cuánta inactividad se considera la señal débil. Por defecto 1200ms. */\n\tumbralInactividadMs?: number;\n}): EstadoDeEspera {\n\tif (!opciones.vivo) return { esperando: false, motivo: null };\n\n\tconst cola = opciones.salidaReciente.slice(-VENTANA_DE_COLA);\n\n\tconst patron = detectarPromptEnSalida(cola);\n\tif (patron) return { esperando: true, motivo: `patrón de \"${patron.nombre}\" en la salida` };\n\n\tconst umbral = opciones.umbralInactividadMs ?? 1200;\n\tconst terminaSinSaltoDeLinea = cola.length > 0 && !/[\\n\\r]\\s*$/u.test(cola);\n\tif (terminaSinSaltoDeLinea && opciones.msDesdeUltimaSalida >= umbral) {\n\t\treturn { esperando: true, motivo: \"sin salida nueva y la última línea quedó sin terminar\" };\n\t}\n\n\treturn { esperando: false, motivo: null };\n}\n"]}

package/dist/core/interactivo/deteccion.js

@@ -0,0 +1,82 @@
+/**
+ * Detectar si un proceso vivo está ESPERANDO ENTRADA.
+ *
+ * Es la pieza difícil del hueco: `bash` normal lanza y espera a que el
+ * proceso termine solo, y un comando que pregunta "¿seguro? [s/n]" o pide una
+ * contraseña no termina nunca por su cuenta — se queda ahí, y `bash` lo lee
+ * como "no responde" hasta que salta el timeout.
+ *
+ * Dos señales, ninguna perfecta por sí sola:
+ *
+ *   1. PATRÓN EN LA SALIDA. La cola de lo escrito coincide con una pregunta
+ *      conocida (confirmación s/n, contraseña, prompt de intérprete…). Es la
+ *      señal fuerte: determinista y explicable.
+ *   2. INACTIVIDAD CON EL PROCESO VIVO. No ha llegado salida nueva en un
+ *      rato Y lo último que se escribió no terminó en salto de línea — que es
+ *      justo la forma de un `print("Password: ")` sin `\n` al final. Sola,
+ *      esta señal confundiría "está esperando" con "está pensando"; por eso
+ *      exige la falta de salto de línea, no solo el silencio.
+ *
+ * Lo que NO se hace: hilar todos los prompts posibles del universo. Un
+ * comando normal (`echo hola`) termina solo — el proceso deja de estar vivo
+ * antes de que esto se llegue a preguntar, así que ni siquiera hace falta que
+ * la lista de patrones sea exhaustiva para no dispararse con él.
+ */
+// Todos anclados a `$` (fin del trozo de salida mirado): un prompt de verdad
+// es lo ÚLTIMO que se escribió, no una frase que aparezca de pasada en medio
+// de un log. Sin el anclaje, un script que simplemente IMPRIME la palabra
+// "password" en un mensaje informativo se marcaría como esperando entrada.
+const PATRONES_DE_PROMPT = [
+    {
+        // "[s/n]", "(y/n)", "[Y/n]", "(yes/no)"… Restringido a palabras de
+        // confirmación conocidas y NO a dígitos, porque "[3/10]" de una barra de
+        // progreso tiene la misma forma y no es una pregunta.
+        nombre: "confirmación s/n",
+        regex: /[[(]\s*(?:s[ií]?|y(?:es)?|n[oó]?)\s*\/\s*(?:s[ií]?|y(?:es)?|n[oó]?)\s*[\])]\s*:?\s*$/iu,
+    },
+    {
+        nombre: "contraseña",
+        regex: /\b(?:password|contrase[nñ]a|passphrase)\s*:?\s*$/iu,
+    },
+    {
+        nombre: "pulsa una tecla",
+        regex: /press\s+(?:any\s+key|enter|return)\b/iu,
+    },
+    {
+        nombre: "confirmación abierta",
+        regex: /\b(?:continue|continuar|proceed|are you sure)\?\s*$/iu,
+    },
+    {
+        // Prompts de intérpretes conocidos: Python, IPython, Node, Ruby, MySQL,
+        // psql, gdb, sqlite3. Cada uno es la forma exacta con la que ese REPL deja
+        // el cursor esperando la siguiente línea.
+        nombre: "prompt de intérprete",
+        regex: /(?:^|\n)\s*(?:>>>|\.\.\.|In \[\d+\]:|irb\([^)]*\):\d+:\d+[>*]|mysql>|psql[^\n]*[=#-]>|\(gdb\)|sqlite>)\s*$/iu,
+    },
+];
+/** Busca un patrón conocido en la cola de salida. `null` si ninguno coincide. */
+export function detectarPromptEnSalida(salida) {
+    for (const { nombre, regex } of PATRONES_DE_PROMPT) {
+        regex.lastIndex = 0;
+        if (regex.test(salida))
+            return { nombre };
+    }
+    return null;
+}
+/** Cuánta cola de salida se mira. Un prompt vive en las últimas líneas, no en todo el historial. */
+const VENTANA_DE_COLA = 500;
+export function detectarEsperaEntrada(opciones) {
+    if (!opciones.vivo)
+        return { esperando: false, motivo: null };
+    const cola = opciones.salidaReciente.slice(-VENTANA_DE_COLA);
+    const patron = detectarPromptEnSalida(cola);
+    if (patron)
+        return { esperando: true, motivo: `patrón de "${patron.nombre}" en la salida` };
+    const umbral = opciones.umbralInactividadMs ?? 1200;
+    const terminaSinSaltoDeLinea = cola.length > 0 && !/[\n\r]\s*$/u.test(cola);
+    if (terminaSinSaltoDeLinea && opciones.msDesdeUltimaSalida >= umbral) {
+        return { esperando: true, motivo: "sin salida nueva y la última línea quedó sin terminar" };
+    }
+    return { esperando: false, motivo: null };
+}
+//# sourceMappingURL=deteccion.js.map

package/dist/core/interactivo/deteccion.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"deteccion.js","sourceRoot":"","sources":["../../../src/core/interactivo/deteccion.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAQH,6EAA6E;AAC7E,+EAA6E;AAC7E,0EAA0E;AAC1E,4EAA2E;AAC3E,MAAM,kBAAkB,GAAqB;IAC5C;QACC,qEAAmE;QACnE,2EAAyE;QACzE,sDAAsD;QACtD,MAAM,EAAE,mBAAkB;QAC1B,KAAK,EAAE,4FAAwF;KAC/F;IACD;QACC,MAAM,EAAE,aAAY;QACpB,KAAK,EAAE,qDAAoD;KAC3D;IACD;QACC,MAAM,EAAE,iBAAiB;QACzB,KAAK,EAAE,wCAAwC;KAC/C;IACD;QACC,MAAM,EAAE,uBAAsB;QAC9B,KAAK,EAAE,uDAAuD;KAC9D;IACD;QACC,yEAAwE;QACxE,2EAA2E;QAC3E,2CAA0C;QAC1C,MAAM,EAAE,uBAAsB;QAC9B,KAAK,EAAE,8GAA8G;KACrH;CACD,CAAC;AAEF,kFAAiF;AACjF,MAAM,UAAU,sBAAsB,CAAC,MAAc,EAA6B;IACjF,KAAK,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,kBAAkB,EAAE,CAAC;QACpD,KAAK,CAAC,SAAS,GAAG,CAAC,CAAC;QACpB,IAAI,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC;YAAE,OAAO,EAAE,MAAM,EAAE,CAAC;IAC3C,CAAC;IACD,OAAO,IAAI,CAAC;AAAA,CACZ;AAQD,uGAAoG;AACpG,MAAM,eAAe,GAAG,GAAG,CAAC;AAE5B,MAAM,UAAU,qBAAqB,CAAC,QASrC,EAAkB;IAClB,IAAI,CAAC,QAAQ,CAAC,IAAI;QAAE,OAAO,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC;IAE9D,MAAM,IAAI,GAAG,QAAQ,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC,eAAe,CAAC,CAAC;IAE7D,MAAM,MAAM,GAAG,sBAAsB,CAAC,IAAI,CAAC,CAAC;IAC5C,IAAI,MAAM;QAAE,OAAO,EAAE,SAAS,EAAE,IAAI,EAAE,MAAM,EAAE,eAAc,MAAM,CAAC,MAAM,gBAAgB,EAAE,CAAC;IAE5F,MAAM,MAAM,GAAG,QAAQ,CAAC,mBAAmB,IAAI,IAAI,CAAC;IACpD,MAAM,sBAAsB,GAAG,IAAI,CAAC,MAAM,GAAG,CAAC,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAC5E,IAAI,sBAAsB,IAAI,QAAQ,CAAC,mBAAmB,IAAI,MAAM,EAAE,CAAC;QACtE,OAAO,EAAE,SAAS,EAAE,IAAI,EAAE,MAAM,EAAE,0DAAuD,EAAE,CAAC;IAC7F,CAAC;IAED,OAAO,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC;AAAA,CAC1C","sourcesContent":["/**\n * Detectar si un proceso vivo está ESPERANDO ENTRADA.\n *\n * Es la pieza difícil del hueco: `bash` normal lanza y espera a que el\n * proceso termine solo, y un comando que pregunta \"¿seguro? [s/n]\" o pide una\n * contraseña no termina nunca por su cuenta — se queda ahí, y `bash` lo lee\n * como \"no responde\" hasta que salta el timeout.\n *\n * Dos señales, ninguna perfecta por sí sola:\n *\n *   1. PATRÓN EN LA SALIDA. La cola de lo escrito coincide con una pregunta\n *      conocida (confirmación s/n, contraseña, prompt de intérprete…). Es la\n *      señal fuerte: determinista y explicable.\n *   2. INACTIVIDAD CON EL PROCESO VIVO. No ha llegado salida nueva en un\n *      rato Y lo último que se escribió no terminó en salto de línea — que es\n *      justo la forma de un `print(\"Password: \")` sin `\\n` al final. Sola,\n *      esta señal confundiría \"está esperando\" con \"está pensando\"; por eso\n *      exige la falta de salto de línea, no solo el silencio.\n *\n * Lo que NO se hace: hilar todos los prompts posibles del universo. Un\n * comando normal (`echo hola`) termina solo — el proceso deja de estar vivo\n * antes de que esto se llegue a preguntar, así que ni siquiera hace falta que\n * la lista de patrones sea exhaustiva para no dispararse con él.\n */\n\n/** Un patrón de prompt reconocido, con nombre para explicar la decisión. */\ninterface PatronDePrompt {\n\tnombre: string;\n\tregex: RegExp;\n}\n\n// Todos anclados a `$` (fin del trozo de salida mirado): un prompt de verdad\n// es lo ÚLTIMO que se escribió, no una frase que aparezca de pasada en medio\n// de un log. Sin el anclaje, un script que simplemente IMPRIME la palabra\n// \"password\" en un mensaje informativo se marcaría como esperando entrada.\nconst PATRONES_DE_PROMPT: PatronDePrompt[] = [\n\t{\n\t\t// \"[s/n]\", \"(y/n)\", \"[Y/n]\", \"(yes/no)\"… Restringido a palabras de\n\t\t// confirmación conocidas y NO a dígitos, porque \"[3/10]\" de una barra de\n\t\t// progreso tiene la misma forma y no es una pregunta.\n\t\tnombre: \"confirmación s/n\",\n\t\tregex: /[[(]\\s*(?:s[ií]?|y(?:es)?|n[oó]?)\\s*\\/\\s*(?:s[ií]?|y(?:es)?|n[oó]?)\\s*[\\])]\\s*:?\\s*$/iu,\n\t},\n\t{\n\t\tnombre: \"contraseña\",\n\t\tregex: /\\b(?:password|contrase[nñ]a|passphrase)\\s*:?\\s*$/iu,\n\t},\n\t{\n\t\tnombre: \"pulsa una tecla\",\n\t\tregex: /press\\s+(?:any\\s+key|enter|return)\\b/iu,\n\t},\n\t{\n\t\tnombre: \"confirmación abierta\",\n\t\tregex: /\\b(?:continue|continuar|proceed|are you sure)\\?\\s*$/iu,\n\t},\n\t{\n\t\t// Prompts de intérpretes conocidos: Python, IPython, Node, Ruby, MySQL,\n\t\t// psql, gdb, sqlite3. Cada uno es la forma exacta con la que ese REPL deja\n\t\t// el cursor esperando la siguiente línea.\n\t\tnombre: \"prompt de intérprete\",\n\t\tregex: /(?:^|\\n)\\s*(?:>>>|\\.\\.\\.|In \\[\\d+\\]:|irb\\([^)]*\\):\\d+:\\d+[>*]|mysql>|psql[^\\n]*[=#-]>|\\(gdb\\)|sqlite>)\\s*$/iu,\n\t},\n];\n\n/** Busca un patrón conocido en la cola de salida. `null` si ninguno coincide. */\nexport function detectarPromptEnSalida(salida: string): { nombre: string } | null {\n\tfor (const { nombre, regex } of PATRONES_DE_PROMPT) {\n\t\tregex.lastIndex = 0;\n\t\tif (regex.test(salida)) return { nombre };\n\t}\n\treturn null;\n}\n\nexport interface EstadoDeEspera {\n\tesperando: boolean;\n\t/** Por qué se decidió. `null` cuando `esperando` es `false`: no hay nada que explicar. */\n\tmotivo: string | null;\n}\n\n/** Cuánta cola de salida se mira. Un prompt vive en las últimas líneas, no en todo el historial. */\nconst VENTANA_DE_COLA = 500;\n\nexport function detectarEsperaEntrada(opciones: {\n\t/** Toda la salida acumulada desde la última consulta (o desde el arranque). */\n\tsalidaReciente: string;\n\t/** Milisegundos desde el último byte recibido. */\n\tmsDesdeUltimaSalida: number;\n\t/** Si el proceso sigue vivo. Un proceso muerto no puede estar esperando nada. */\n\tvivo: boolean;\n\t/** A partir de cuánta inactividad se considera la señal débil. Por defecto 1200ms. */\n\tumbralInactividadMs?: number;\n}): EstadoDeEspera {\n\tif (!opciones.vivo) return { esperando: false, motivo: null };\n\n\tconst cola = opciones.salidaReciente.slice(-VENTANA_DE_COLA);\n\n\tconst patron = detectarPromptEnSalida(cola);\n\tif (patron) return { esperando: true, motivo: `patrón de \"${patron.nombre}\" en la salida` };\n\n\tconst umbral = opciones.umbralInactividadMs ?? 1200;\n\tconst terminaSinSaltoDeLinea = cola.length > 0 && !/[\\n\\r]\\s*$/u.test(cola);\n\tif (terminaSinSaltoDeLinea && opciones.msDesdeUltimaSalida >= umbral) {\n\t\treturn { esperando: true, motivo: \"sin salida nueva y la última línea quedó sin terminar\" };\n\t}\n\n\treturn { esperando: false, motivo: null };\n}\n"]}

package/dist/core/interactivo/sesion.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Un proceso interactivo vivo, entre llamadas a tool.
+ *
+ * `bash` normal lanza y espera a que termine: una sola llamada, un solo
+ * resultado. Aquí el proceso sobrevive a la llamada que lo lanzó, para que
+ * una segunda llamada (`bash_enviar`) pueda escribirle más entrada — el
+ * "sí" a la confirmación, la contraseña, el siguiente comando del REPL.
+ *
+ * Reutiliza el MISMO seguimiento de huérfanos que ya usa `bash` normal
+ * (`trackDetachedChildPid` / `killTrackedDetachedChildren` en
+ * `utils/shell.ts`), que los tres modos del CLI —print, interactive, rpc—
+ * ya llaman al apagarse. No hace falta cablear un gancho de cierre nuevo:
+ * una sesión viva entra en el mismo Set que un `bash` colgado, y muere con
+ * él. Verificado en `sesion.test.ts` y con `ps` en el informe de la tarea.
+ */
+export interface ResultadoSesion {
+    id: string;
+    comando: string;
+    salida: string;
+    esperando: boolean;
+    motivo: string | null;
+    vivo: boolean;
+    codigoSalida: number | null;
+}
+export interface OpcionesLanzar {
+    cwd: string;
+    timeoutMs?: number;
+    umbralInactividadMs?: number;
+    shellPath?: string;
+}
+/** Lanza un proceso interactivo y espera hasta el primer prompt (o a que termine, o al timeout). */
+export declare function lanzarSesionInteractiva(comando: string, opciones: OpcionesLanzar): Promise<ResultadoSesion>;
+export interface OpcionesEnviar {
+    timeoutMs?: number;
+    umbralInactividadMs?: number;
+}
+/**
+ * Manda una línea a una sesión viva y espera la siguiente señal.
+ *
+ * `null` cuando la sesión no existe: NO es lo mismo que una sesión que
+ * existe pero no tiene nada nuevo que decir (eso es `salida: ""`).
+ */
+export declare function enviarASesion(id: string, texto: string, opciones?: OpcionesEnviar): Promise<ResultadoSesion | null>;
+/** `null` si la sesión no existe; `true`/`false` según si había algo vivo que matar. */
+export declare function cerrarSesion(id: string): boolean | null;
+/** Para pruebas y para el apagado del CLI: no debe sobrevivir ninguna. */
+export declare function cerrarTodasLasSesiones(): void;
+/** Solo para pruebas: cuántas sesiones quedan registradas. */
+export declare function contarSesiones(): number;
+//# sourceMappingURL=sesion.d.ts.map

package/dist/core/interactivo/sesion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sesion.d.ts","sourceRoot":"","sources":["../../../src/core/interactivo/sesion.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AA6BH,MAAM,WAAW,eAAe;IAC/B,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,OAAO,CAAC;IACnB,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,IAAI,EAAE,OAAO,CAAC;IACd,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;CAC5B;AA6DD,MAAM,WAAW,cAAc;IAC9B,GAAG,EAAE,MAAM,CAAC;IACZ,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,mBAAmB,CAAC,EAAE,MAAM,CAAC;IAC7B,SAAS,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,oGAAoG;AACpG,wBAAsB,uBAAuB,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,cAAc,GAAG,OAAO,CAAC,eAAe,CAAC,CA8CjH;AAED,MAAM,WAAW,cAAc;IAC9B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,mBAAmB,CAAC,EAAE,MAAM,CAAC;CAC7B;AAED;;;;;GAKG;AACH,wBAAsB,aAAa,CAClC,EAAE,EAAE,MAAM,EACV,KAAK,EAAE,MAAM,EACb,QAAQ,GAAE,cAAmB,GAC3B,OAAO,CAAC,eAAe,GAAG,IAAI,CAAC,CAQjC;AAED,2FAAwF;AACxF,wBAAgB,YAAY,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,GAAG,IAAI,CASvD;AAED,0EAA0E;AAC1E,wBAAgB,sBAAsB,IAAI,IAAI,CAE7C;AAED,+DAA8D;AAC9D,wBAAgB,cAAc,IAAI,MAAM,CAEvC","sourcesContent":["/**\n * Un proceso interactivo vivo, entre llamadas a tool.\n *\n * `bash` normal lanza y espera a que termine: una sola llamada, un solo\n * resultado. Aquí el proceso sobrevive a la llamada que lo lanzó, para que\n * una segunda llamada (`bash_enviar`) pueda escribirle más entrada — el\n * \"sí\" a la confirmación, la contraseña, el siguiente comando del REPL.\n *\n * Reutiliza el MISMO seguimiento de huérfanos que ya usa `bash` normal\n * (`trackDetachedChildPid` / `killTrackedDetachedChildren` en\n * `utils/shell.ts`), que los tres modos del CLI —print, interactive, rpc—\n * ya llaman al apagarse. No hace falta cablear un gancho de cierre nuevo:\n * una sesión viva entra en el mismo Set que un `bash` colgado, y muere con\n * él. Verificado en `sesion.test.ts` y con `ps` en el informe de la tarea.\n */\n\nimport { spawn } from \"node:child_process\";\nimport { randomUUID } from \"node:crypto\";\nimport {\n\tgetShellConfig,\n\tgetShellEnv,\n\tkillProcessTree,\n\ttrackDetachedChildPid,\n\tuntrackDetachedChildPid,\n} from \"../../utils/shell.ts\";\nimport { detectarEsperaEntrada } from \"./deteccion.ts\";\n\n/** Cuánta salida sin consumir se retiene por sesión. Un REPL ruidoso no debe reventar memoria. */\nconst MAX_PENDIENTE_BYTES = 200_000;\nconst AVISO_RECORTE = \"[…salida antigua descartada, sesión demasiado ruidosa…]\\n\";\n\ninterface SesionInteractiva {\n\tid: string;\n\tcomando: string;\n\tpid: number | undefined;\n\tproceso: import(\"node:child_process\").ChildProcessWithoutNullStreams;\n\t/** Lo que no se le ha devuelto todavía al agente. */\n\tpendiente: string;\n\tultimaActividad: number;\n\tvivo: boolean;\n\tcodigoSalida: number | null;\n}\n\nexport interface ResultadoSesion {\n\tid: string;\n\tcomando: string;\n\tsalida: string;\n\tesperando: boolean;\n\tmotivo: string | null;\n\tvivo: boolean;\n\tcodigoSalida: number | null;\n}\n\nconst sesiones = new Map<string, SesionInteractiva>();\n\nfunction normalizarChunk(buf: Buffer): string {\n\treturn buf.toString(\"utf8\").replace(/\\r\\n/gu, \"\\n\");\n}\n\nfunction acumular(s: SesionInteractiva, texto: string): void {\n\ts.pendiente += texto;\n\ts.ultimaActividad = Date.now();\n\tif (s.pendiente.length > MAX_PENDIENTE_BYTES) {\n\t\ts.pendiente = AVISO_RECORTE + s.pendiente.slice(-MAX_PENDIENTE_BYTES);\n\t}\n}\n\nfunction limpiar(s: SesionInteractiva): void {\n\tif (s.pid !== undefined) untrackDetachedChildPid(s.pid);\n}\n\n/**\n * Espera a que la sesión dé una señal (prompt detectado o proceso muerto) o\n * agote el tiempo. Sondea cada 80ms: es rápido de sobra frente a lo que\n * tarda un humano en leer un prompt, y no quema CPU con un intervalo menor.\n */\nasync function esperarSenal(\n\ts: SesionInteractiva,\n\ttimeoutMs: number,\n\tumbralInactividadMs: number,\n): Promise<ReturnType<typeof detectarEsperaEntrada>> {\n\tconst limite = Date.now() + timeoutMs;\n\tfor (;;) {\n\t\tconst estado = detectarEsperaEntrada({\n\t\t\tsalidaReciente: s.pendiente,\n\t\t\tmsDesdeUltimaSalida: Date.now() - s.ultimaActividad,\n\t\t\tvivo: s.vivo,\n\t\t\tumbralInactividadMs,\n\t\t});\n\t\tif (estado.esperando || !s.vivo || Date.now() >= limite) return estado;\n\t\tawait new Promise((resolve) => setTimeout(resolve, 80));\n\t}\n}\n\nfunction consumir(s: SesionInteractiva): string {\n\tconst salida = s.pendiente;\n\ts.pendiente = \"\";\n\treturn salida;\n}\n\nfunction aResultado(s: SesionInteractiva, estado: ReturnType<typeof detectarEsperaEntrada>): ResultadoSesion {\n\treturn {\n\t\tid: s.id,\n\t\tcomando: s.comando,\n\t\tsalida: consumir(s),\n\t\tesperando: estado.esperando,\n\t\tmotivo: estado.motivo,\n\t\tvivo: s.vivo,\n\t\tcodigoSalida: s.codigoSalida,\n\t};\n}\n\nexport interface OpcionesLanzar {\n\tcwd: string;\n\ttimeoutMs?: number;\n\tumbralInactividadMs?: number;\n\tshellPath?: string;\n}\n\n/** Lanza un proceso interactivo y espera hasta el primer prompt (o a que termine, o al timeout). */\nexport async function lanzarSesionInteractiva(comando: string, opciones: OpcionesLanzar): Promise<ResultadoSesion> {\n\tconst shellConfig = getShellConfig(opciones.shellPath);\n\tconst comandoDesdeStdin = shellConfig.commandTransport === \"stdin\";\n\tconst proceso = spawn(shellConfig.shell, comandoDesdeStdin ? shellConfig.args : [...shellConfig.args, comando], {\n\t\tcwd: opciones.cwd,\n\t\tdetached: process.platform !== \"win32\",\n\t\tenv: getShellEnv(),\n\t\tstdio: \"pipe\",\n\t\twindowsHide: true,\n\t});\n\n\tconst s: SesionInteractiva = {\n\t\tid: randomUUID(),\n\t\tcomando,\n\t\tpid: proceso.pid,\n\t\tproceso,\n\t\tpendiente: \"\",\n\t\tultimaActividad: Date.now(),\n\t\tvivo: true,\n\t\tcodigoSalida: null,\n\t};\n\tsesiones.set(s.id, s);\n\tif (proceso.pid) trackDetachedChildPid(proceso.pid);\n\n\tproceso.stdout.on(\"data\", (chunk: Buffer) => acumular(s, normalizarChunk(chunk)));\n\tproceso.stderr.on(\"data\", (chunk: Buffer) => acumular(s, normalizarChunk(chunk)));\n\tproceso.stdin.on(\"error\", () => {\n\t\t// Escribir tras la muerte del proceso no debe tirar la sesión abajo:\n\t\t// `bash_enviar` ya distingue \"sesión muerta\" por `vivo`.\n\t});\n\tproceso.on(\"exit\", (code) => {\n\t\ts.vivo = false;\n\t\ts.codigoSalida = code;\n\t\tlimpiar(s);\n\t});\n\n\t// El comando en sí es la primera \"entrada\": en modo `-s` (bash de WSL legacy)\n\t// se escribe por stdin en vez de pasar por argv, y el fd es el mismo tanto\n\t// para el resto del script como para lo que el propio comando pida leer\n\t// luego — es idéntico a teclearlo a mano.\n\tif (comandoDesdeStdin) {\n\t\tproceso.stdin.write(`${comando}\\n`);\n\t}\n\n\tconst estado = await esperarSenal(s, opciones.timeoutMs ?? 10_000, opciones.umbralInactividadMs ?? 1200);\n\treturn aResultado(s, estado);\n}\n\nexport interface OpcionesEnviar {\n\ttimeoutMs?: number;\n\tumbralInactividadMs?: number;\n}\n\n/**\n * Manda una línea a una sesión viva y espera la siguiente señal.\n *\n * `null` cuando la sesión no existe: NO es lo mismo que una sesión que\n * existe pero no tiene nada nuevo que decir (eso es `salida: \"\"`).\n */\nexport async function enviarASesion(\n\tid: string,\n\ttexto: string,\n\topciones: OpcionesEnviar = {},\n): Promise<ResultadoSesion | null> {\n\tconst s = sesiones.get(id);\n\tif (!s) return null;\n\tif (!s.vivo) return aResultado(s, { esperando: false, motivo: null });\n\n\ts.proceso.stdin.write(`${texto}\\n`);\n\tconst estado = await esperarSenal(s, opciones.timeoutMs ?? 10_000, opciones.umbralInactividadMs ?? 1200);\n\treturn aResultado(s, estado);\n}\n\n/** `null` si la sesión no existe; `true`/`false` según si había algo vivo que matar. */\nexport function cerrarSesion(id: string): boolean | null {\n\tconst s = sesiones.get(id);\n\tif (!s) return null;\n\tconst estabaViva = s.vivo;\n\tif (s.pid !== undefined) killProcessTree(s.pid);\n\ts.vivo = false;\n\tlimpiar(s);\n\tsesiones.delete(id);\n\treturn estabaViva;\n}\n\n/** Para pruebas y para el apagado del CLI: no debe sobrevivir ninguna. */\nexport function cerrarTodasLasSesiones(): void {\n\tfor (const id of [...sesiones.keys()]) cerrarSesion(id);\n}\n\n/** Solo para pruebas: cuántas sesiones quedan registradas. */\nexport function contarSesiones(): number {\n\treturn sesiones.size;\n}\n"]}