@hoilab/ada-cli 0.84.21 → 0.85.0

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"]}

package/dist/core/interactivo/sesion.js

@@ -0,0 +1,156 @@
+/**
+ * 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.
+ */
+import { spawn } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { getShellConfig, getShellEnv, killProcessTree, trackDetachedChildPid, untrackDetachedChildPid, } from "../../utils/shell.js";
+import { detectarEsperaEntrada } from "./deteccion.js";
+/** Cuánta salida sin consumir se retiene por sesión. Un REPL ruidoso no debe reventar memoria. */
+const MAX_PENDIENTE_BYTES = 200_000;
+const AVISO_RECORTE = "[…salida antigua descartada, sesión demasiado ruidosa…]\n";
+const sesiones = new Map();
+function normalizarChunk(buf) {
+    return buf.toString("utf8").replace(/\r\n/gu, "\n");
+}
+function acumular(s, texto) {
+    s.pendiente += texto;
+    s.ultimaActividad = Date.now();
+    if (s.pendiente.length > MAX_PENDIENTE_BYTES) {
+        s.pendiente = AVISO_RECORTE + s.pendiente.slice(-MAX_PENDIENTE_BYTES);
+    }
+}
+function limpiar(s) {
+    if (s.pid !== undefined)
+        untrackDetachedChildPid(s.pid);
+}
+/**
+ * Espera a que la sesión dé una señal (prompt detectado o proceso muerto) o
+ * agote el tiempo. Sondea cada 80ms: es rápido de sobra frente a lo que
+ * tarda un humano en leer un prompt, y no quema CPU con un intervalo menor.
+ */
+async function esperarSenal(s, timeoutMs, umbralInactividadMs) {
+    const limite = Date.now() + timeoutMs;
+    for (;;) {
+        const estado = detectarEsperaEntrada({
+            salidaReciente: s.pendiente,
+            msDesdeUltimaSalida: Date.now() - s.ultimaActividad,
+            vivo: s.vivo,
+            umbralInactividadMs,
+        });
+        if (estado.esperando || !s.vivo || Date.now() >= limite)
+            return estado;
+        await new Promise((resolve) => setTimeout(resolve, 80));
+    }
+}
+function consumir(s) {
+    const salida = s.pendiente;
+    s.pendiente = "";
+    return salida;
+}
+function aResultado(s, estado) {
+    return {
+        id: s.id,
+        comando: s.comando,
+        salida: consumir(s),
+        esperando: estado.esperando,
+        motivo: estado.motivo,
+        vivo: s.vivo,
+        codigoSalida: s.codigoSalida,
+    };
+}
+/** Lanza un proceso interactivo y espera hasta el primer prompt (o a que termine, o al timeout). */
+export async function lanzarSesionInteractiva(comando, opciones) {
+    const shellConfig = getShellConfig(opciones.shellPath);
+    const comandoDesdeStdin = shellConfig.commandTransport === "stdin";
+    const proceso = spawn(shellConfig.shell, comandoDesdeStdin ? shellConfig.args : [...shellConfig.args, comando], {
+        cwd: opciones.cwd,
+        detached: process.platform !== "win32",
+        env: getShellEnv(),
+        stdio: "pipe",
+        windowsHide: true,
+    });
+    const s = {
+        id: randomUUID(),
+        comando,
+        pid: proceso.pid,
+        proceso,
+        pendiente: "",
+        ultimaActividad: Date.now(),
+        vivo: true,
+        codigoSalida: null,
+    };
+    sesiones.set(s.id, s);
+    if (proceso.pid)
+        trackDetachedChildPid(proceso.pid);
+    proceso.stdout.on("data", (chunk) => acumular(s, normalizarChunk(chunk)));
+    proceso.stderr.on("data", (chunk) => acumular(s, normalizarChunk(chunk)));
+    proceso.stdin.on("error", () => {
+        // Escribir tras la muerte del proceso no debe tirar la sesión abajo:
+        // `bash_enviar` ya distingue "sesión muerta" por `vivo`.
+    });
+    proceso.on("exit", (code) => {
+        s.vivo = false;
+        s.codigoSalida = code;
+        limpiar(s);
+    });
+    // El comando en sí es la primera "entrada": en modo `-s` (bash de WSL legacy)
+    // se escribe por stdin en vez de pasar por argv, y el fd es el mismo tanto
+    // para el resto del script como para lo que el propio comando pida leer
+    // luego — es idéntico a teclearlo a mano.
+    if (comandoDesdeStdin) {
+        proceso.stdin.write(`${comando}\n`);
+    }
+    const estado = await esperarSenal(s, opciones.timeoutMs ?? 10_000, opciones.umbralInactividadMs ?? 1200);
+    return aResultado(s, estado);
+}
+/**
+ * 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 async function enviarASesion(id, texto, opciones = {}) {
+    const s = sesiones.get(id);
+    if (!s)
+        return null;
+    if (!s.vivo)
+        return aResultado(s, { esperando: false, motivo: null });
+    s.proceso.stdin.write(`${texto}\n`);
+    const estado = await esperarSenal(s, opciones.timeoutMs ?? 10_000, opciones.umbralInactividadMs ?? 1200);
+    return aResultado(s, estado);
+}
+/** `null` si la sesión no existe; `true`/`false` según si había algo vivo que matar. */
+export function cerrarSesion(id) {
+    const s = sesiones.get(id);
+    if (!s)
+        return null;
+    const estabaViva = s.vivo;
+    if (s.pid !== undefined)
+        killProcessTree(s.pid);
+    s.vivo = false;
+    limpiar(s);
+    sesiones.delete(id);
+    return estabaViva;
+}
+/** Para pruebas y para el apagado del CLI: no debe sobrevivir ninguna. */
+export function cerrarTodasLasSesiones() {
+    for (const id of [...sesiones.keys()])
+        cerrarSesion(id);
+}
+/** Solo para pruebas: cuántas sesiones quedan registradas. */
+export function contarSesiones() {
+    return sesiones.size;
+}
+//# sourceMappingURL=sesion.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sesion.js","sourceRoot":"","sources":["../../../src/core/interactivo/sesion.ts"],"names":[],"mappings":"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","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"]}

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

@@ -0,0 +1,21 @@
+/**
+ * Tools de bash interactivo: `bash_interactivo`, `bash_enviar`, `bash_cerrar`.
+ *
+ * `bash` normal se queda colgado ante un comando que pregunta algo — una
+ * confirmación, una contraseña, un REPL— hasta que salta el timeout, y el
+ * agente lo lee como "el comando no responde". Estas tres tools abren un
+ * proceso que sobrevive entre llamadas: `bash_interactivo` lo lanza y
+ * devuelve lo que haya hasta el primer prompt (o hasta que termine, o hasta
+ * el timeout); `bash_enviar` le manda una línea más; `bash_cerrar` lo mata.
+ *
+ * Ninguna de las tres está en `LECTURA` ni `ESCRITURA` en
+ * `aprobacion/politica.ts`, así que `nivelDe()` las clasifica como
+ * `ejecucion` por su regla de "lo desconocido cuenta como ejecución" — la
+ * misma puerta que ya pasa `bash`, sin tocar ese fichero.
+ */
+import type { ToolDefinition } from "../extensions/types.ts";
+export declare const NOMBRES_INTERACTIVO_TOOLS: readonly ["bash_interactivo", "bash_enviar", "bash_cerrar"];
+export declare function crearInteractivoTools(opciones: {
+    cwd: string;
+}): Record<string, ToolDefinition>;
+//# sourceMappingURL=tools.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tools.d.ts","sourceRoot":"","sources":["../../../src/core/interactivo/tools.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAGH,OAAO,KAAK,EAAmB,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAkC9E,eAAO,MAAM,yBAAyB,6DAA8D,CAAC;AAErG,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE;IAAE,GAAG,EAAE,MAAM,CAAA;CAAE,GAAG,MAAM,CAAC,MAAM,EAAE,cAAc,CAAC,CA8E/F","sourcesContent":["/**\n * Tools de bash interactivo: `bash_interactivo`, `bash_enviar`, `bash_cerrar`.\n *\n * `bash` normal se queda colgado ante un comando que pregunta algo — una\n * confirmación, una contraseña, un REPL— hasta que salta el timeout, y el\n * agente lo lee como \"el comando no responde\". Estas tres tools abren un\n * proceso que sobrevive entre llamadas: `bash_interactivo` lo lanza y\n * devuelve lo que haya hasta el primer prompt (o hasta que termine, o hasta\n * el timeout); `bash_enviar` le manda una línea más; `bash_cerrar` lo mata.\n *\n * Ninguna de las tres está en `LECTURA` ni `ESCRITURA` en\n * `aprobacion/politica.ts`, así que `nivelDe()` las clasifica como\n * `ejecucion` por su regla de \"lo desconocido cuenta como ejecución\" — la\n * misma puerta que ya pasa `bash`, sin tocar ese fichero.\n */\n\nimport { Type } from \"typebox\";\nimport type { AgentToolResult, ToolDefinition } from \"../extensions/types.ts\";\nimport { cerrarSesion, enviarASesion, lanzarSesionInteractiva, type ResultadoSesion } from \"./sesion.ts\";\n\nconst GUIA = [\n\t\"Para un comando normal que termina solo, usa bash. Usa bash_interactivo solo cuando esperes que el comando pregunte algo: una confirmación, una contraseña, un REPL.\",\n\t\"bash_interactivo devuelve un id de sesión. Si sigue vivo, respóndele con bash_enviar pasando ese id y una línea de texto (puede ser vacía, para solo esperar más).\",\n\t\"Cierra la sesión con bash_cerrar en cuanto termines con ella: una sesión olvidada sigue consumiendo un proceso real.\",\n];\n\nfunction texto(t: string): AgentToolResult<unknown> {\n\treturn { content: [{ type: \"text\" as const, text: t }], details: undefined };\n}\n\nfunction fallo(error: unknown): AgentToolResult<unknown> {\n\treturn texto(`Error: ${error instanceof Error ? error.message : String(error)}`);\n}\n\n/** Frase de estado + qué hacer a continuación, para que el modelo no tenga que adivinar. */\nfunction narrarEstado(r: ResultadoSesion): string {\n\tif (!r.vivo) return `[sesión ${r.id}] terminó con código ${r.codigoSalida ?? \"desconocido\"}.`;\n\tif (r.esperando) {\n\t\treturn `[sesión ${r.id}] esperando entrada (${r.motivo}). Responde con bash_enviar (session=\"${r.id}\") o mátala con bash_cerrar.`;\n\t}\n\treturn `[sesión ${r.id}] sigue en marcha, sin señal reconocible de que esté esperando algo todavía. Puedes esperar más con bash_enviar (session=\"${r.id}\", texto=\"\") o cerrarla con bash_cerrar.`;\n}\n\nfunction conSalida(r: ResultadoSesion): string {\n\treturn `${narrarEstado(r)}\\n\\n${r.salida || \"(sin salida nueva)\"}`;\n}\n\nfunction segundosAMs(segundos: number | undefined): number | undefined {\n\treturn segundos === undefined ? undefined : segundos * 1000;\n}\n\nexport const NOMBRES_INTERACTIVO_TOOLS = [\"bash_interactivo\", \"bash_enviar\", \"bash_cerrar\"] as const;\n\nexport function crearInteractivoTools(opciones: { cwd: string }): Record<string, ToolDefinition> {\n\tconst lanzar: ToolDefinition<ReturnType<typeof Type.Object>> = {\n\t\tname: \"bash_interactivo\",\n\t\tlabel: \"Bash interactivo\",\n\t\tdescription:\n\t\t\t\"Lanza un comando de shell que puede pedir entrada (confirmación, contraseña, REPL) y devuelve \" +\n\t\t\t\"lo que haya escrito hasta el primer prompt reconocido, hasta que termine, o hasta el timeout. \" +\n\t\t\t\"El proceso queda vivo entre llamadas: sigue con bash_enviar.\",\n\t\tpromptSnippet: \"ejecutar un comando que puede preguntar algo y seguir hablando con él\",\n\t\tpromptGuidelines: GUIA,\n\t\tparameters: Type.Object({\n\t\t\tcommand: Type.String({ description: \"Comando de shell a ejecutar\" }),\n\t\t\ttimeout: Type.Optional(\n\t\t\t\tType.Number({\n\t\t\t\t\tdescription: \"Segundos a esperar por un prompt antes de devolver el control (por defecto 10)\",\n\t\t\t\t}),\n\t\t\t),\n\t\t}),\n\t\tasync execute(_id, input): Promise<AgentToolResult<unknown>> {\n\t\t\tconst comando = String(input.command ?? \"\").trim();\n\t\t\tif (!comando) return texto(\"Falta el comando.\");\n\t\t\ttry {\n\t\t\t\tconst r = await lanzarSesionInteractiva(comando, {\n\t\t\t\t\tcwd: opciones.cwd,\n\t\t\t\t\ttimeoutMs: segundosAMs(input.timeout as number | undefined),\n\t\t\t\t});\n\t\t\t\treturn texto(conSalida(r));\n\t\t\t} catch (error) {\n\t\t\t\treturn fallo(error);\n\t\t\t}\n\t\t},\n\t};\n\n\tconst enviar: ToolDefinition<ReturnType<typeof Type.Object>> = {\n\t\tname: \"bash_enviar\",\n\t\tlabel: \"Enviar a sesión interactiva\",\n\t\tdescription:\n\t\t\t\"Manda una línea de texto a una sesión abierta con bash_interactivo (por ejemplo la respuesta a una \" +\n\t\t\t\"confirmación o una contraseña) y espera la siguiente señal: otro prompt, más salida, o que termine.\",\n\t\tpromptSnippet: \"responder a una sesión de bash interactivo abierta\",\n\t\tpromptGuidelines: GUIA,\n\t\tparameters: Type.Object({\n\t\t\tsession: Type.String({ description: \"El id de sesión que devolvió bash_interactivo\" }),\n\t\t\ttexto: Type.String({ description: \"Línea a enviar (se añade un salto de línea). Puede ser vacía.\" }),\n\t\t\ttimeout: Type.Optional(Type.Number({ description: \"Segundos a esperar la siguiente señal (por defecto 10)\" })),\n\t\t}),\n\t\tasync execute(_id, input): Promise<AgentToolResult<unknown>> {\n\t\t\tconst id = String(input.session ?? \"\");\n\t\t\ttry {\n\t\t\t\tconst r = await enviarASesion(id, String(input.texto ?? \"\"), {\n\t\t\t\t\ttimeoutMs: segundosAMs(input.timeout as number | undefined),\n\t\t\t\t});\n\t\t\t\tif (r === null) return texto(`No hay ninguna sesión interactiva abierta con id \"${id}\".`);\n\t\t\t\treturn texto(conSalida(r));\n\t\t\t} catch (error) {\n\t\t\t\treturn fallo(error);\n\t\t\t}\n\t\t},\n\t};\n\n\tconst cerrar: ToolDefinition<ReturnType<typeof Type.Object>> = {\n\t\tname: \"bash_cerrar\",\n\t\tlabel: \"Cerrar sesión interactiva\",\n\t\tdescription: \"Mata una sesión abierta con bash_interactivo y libera el proceso.\",\n\t\tpromptSnippet: \"cerrar una sesión de bash interactivo abierta\",\n\t\tpromptGuidelines: GUIA,\n\t\tparameters: Type.Object({\n\t\t\tsession: Type.String({ description: \"El id de sesión a cerrar\" }),\n\t\t}),\n\t\tasync execute(_id, input): Promise<AgentToolResult<unknown>> {\n\t\t\tconst id = String(input.session ?? \"\");\n\t\t\tconst habiaAlgoVivo = cerrarSesion(id);\n\t\t\tif (habiaAlgoVivo === null) return texto(`No hay ninguna sesión interactiva abierta con id \"${id}\".`);\n\t\t\treturn texto(habiaAlgoVivo ? `Sesión ${id} cerrada.` : `La sesión ${id} ya había terminado; limpiada.`);\n\t\t},\n\t};\n\n\treturn { bash_interactivo: lanzar, bash_enviar: enviar, bash_cerrar: cerrar };\n}\n"]}

package/dist/core/interactivo/tools.js

@@ -0,0 +1,122 @@
+/**
+ * Tools de bash interactivo: `bash_interactivo`, `bash_enviar`, `bash_cerrar`.
+ *
+ * `bash` normal se queda colgado ante un comando que pregunta algo — una
+ * confirmación, una contraseña, un REPL— hasta que salta el timeout, y el
+ * agente lo lee como "el comando no responde". Estas tres tools abren un
+ * proceso que sobrevive entre llamadas: `bash_interactivo` lo lanza y
+ * devuelve lo que haya hasta el primer prompt (o hasta que termine, o hasta
+ * el timeout); `bash_enviar` le manda una línea más; `bash_cerrar` lo mata.
+ *
+ * Ninguna de las tres está en `LECTURA` ni `ESCRITURA` en
+ * `aprobacion/politica.ts`, así que `nivelDe()` las clasifica como
+ * `ejecucion` por su regla de "lo desconocido cuenta como ejecución" — la
+ * misma puerta que ya pasa `bash`, sin tocar ese fichero.
+ */
+import { Type } from "typebox";
+import { cerrarSesion, enviarASesion, lanzarSesionInteractiva } from "./sesion.js";
+const GUIA = [
+    "Para un comando normal que termina solo, usa bash. Usa bash_interactivo solo cuando esperes que el comando pregunte algo: una confirmación, una contraseña, un REPL.",
+    "bash_interactivo devuelve un id de sesión. Si sigue vivo, respóndele con bash_enviar pasando ese id y una línea de texto (puede ser vacía, para solo esperar más).",
+    "Cierra la sesión con bash_cerrar en cuanto termines con ella: una sesión olvidada sigue consumiendo un proceso real.",
+];
+function texto(t) {
+    return { content: [{ type: "text", text: t }], details: undefined };
+}
+function fallo(error) {
+    return texto(`Error: ${error instanceof Error ? error.message : String(error)}`);
+}
+/** Frase de estado + qué hacer a continuación, para que el modelo no tenga que adivinar. */
+function narrarEstado(r) {
+    if (!r.vivo)
+        return `[sesión ${r.id}] terminó con código ${r.codigoSalida ?? "desconocido"}.`;
+    if (r.esperando) {
+        return `[sesión ${r.id}] esperando entrada (${r.motivo}). Responde con bash_enviar (session="${r.id}") o mátala con bash_cerrar.`;
+    }
+    return `[sesión ${r.id}] sigue en marcha, sin señal reconocible de que esté esperando algo todavía. Puedes esperar más con bash_enviar (session="${r.id}", texto="") o cerrarla con bash_cerrar.`;
+}
+function conSalida(r) {
+    return `${narrarEstado(r)}\n\n${r.salida || "(sin salida nueva)"}`;
+}
+function segundosAMs(segundos) {
+    return segundos === undefined ? undefined : segundos * 1000;
+}
+export const NOMBRES_INTERACTIVO_TOOLS = ["bash_interactivo", "bash_enviar", "bash_cerrar"];
+export function crearInteractivoTools(opciones) {
+    const lanzar = {
+        name: "bash_interactivo",
+        label: "Bash interactivo",
+        description: "Lanza un comando de shell que puede pedir entrada (confirmación, contraseña, REPL) y devuelve " +
+            "lo que haya escrito hasta el primer prompt reconocido, hasta que termine, o hasta el timeout. " +
+            "El proceso queda vivo entre llamadas: sigue con bash_enviar.",
+        promptSnippet: "ejecutar un comando que puede preguntar algo y seguir hablando con él",
+        promptGuidelines: GUIA,
+        parameters: Type.Object({
+            command: Type.String({ description: "Comando de shell a ejecutar" }),
+            timeout: Type.Optional(Type.Number({
+                description: "Segundos a esperar por un prompt antes de devolver el control (por defecto 10)",
+            })),
+        }),
+        async execute(_id, input) {
+            const comando = String(input.command ?? "").trim();
+            if (!comando)
+                return texto("Falta el comando.");
+            try {
+                const r = await lanzarSesionInteractiva(comando, {
+                    cwd: opciones.cwd,
+                    timeoutMs: segundosAMs(input.timeout),
+                });
+                return texto(conSalida(r));
+            }
+            catch (error) {
+                return fallo(error);
+            }
+        },
+    };
+    const enviar = {
+        name: "bash_enviar",
+        label: "Enviar a sesión interactiva",
+        description: "Manda una línea de texto a una sesión abierta con bash_interactivo (por ejemplo la respuesta a una " +
+            "confirmación o una contraseña) y espera la siguiente señal: otro prompt, más salida, o que termine.",
+        promptSnippet: "responder a una sesión de bash interactivo abierta",
+        promptGuidelines: GUIA,
+        parameters: Type.Object({
+            session: Type.String({ description: "El id de sesión que devolvió bash_interactivo" }),
+            texto: Type.String({ description: "Línea a enviar (se añade un salto de línea). Puede ser vacía." }),
+            timeout: Type.Optional(Type.Number({ description: "Segundos a esperar la siguiente señal (por defecto 10)" })),
+        }),
+        async execute(_id, input) {
+            const id = String(input.session ?? "");
+            try {
+                const r = await enviarASesion(id, String(input.texto ?? ""), {
+                    timeoutMs: segundosAMs(input.timeout),
+                });
+                if (r === null)
+                    return texto(`No hay ninguna sesión interactiva abierta con id "${id}".`);
+                return texto(conSalida(r));
+            }
+            catch (error) {
+                return fallo(error);
+            }
+        },
+    };
+    const cerrar = {
+        name: "bash_cerrar",
+        label: "Cerrar sesión interactiva",
+        description: "Mata una sesión abierta con bash_interactivo y libera el proceso.",
+        promptSnippet: "cerrar una sesión de bash interactivo abierta",
+        promptGuidelines: GUIA,
+        parameters: Type.Object({
+            session: Type.String({ description: "El id de sesión a cerrar" }),
+        }),
+        async execute(_id, input) {
+            const id = String(input.session ?? "");
+            const habiaAlgoVivo = cerrarSesion(id);
+            if (habiaAlgoVivo === null)
+                return texto(`No hay ninguna sesión interactiva abierta con id "${id}".`);
+            return texto(habiaAlgoVivo ? `Sesión ${id} cerrada.` : `La sesión ${id} ya había terminado; limpiada.`);
+        },
+    };
+    return { bash_interactivo: lanzar, bash_enviar: enviar, bash_cerrar: cerrar };
+}
+//# sourceMappingURL=tools.js.map