theus-cli-linux-x64 0.2.84

package/vendor/theus-arsenal/scripts/hooks/notificacion-escritorio.js

@@ -0,0 +1,208 @@
+#!/usr/bin/env node
+/**
+ * Hook de notificación de escritorio (Stop)
+ *
+ * Envía una notificación nativa del sistema con el resumen de la tarea cuando
+ * el agente termina de responder. Soporta:
+ *   - macOS: secuencia de escape OSC 9 en iTerm2/Ghostty (preferida) o
+ *     osascript como respaldo (display notification).
+ *   - Linux: notify-send si está disponible.
+ *   - WSL: PowerShell 7 o Windows PowerShell con el módulo BurntToast.
+ *
+ * En macOS bajo iTerm2/Ghostty la notificación pertenece a la terminal;
+ * al hacer clic enfoca la pestaña donde corre Theus. Fuera de esas
+ * terminales se usa osascript.
+ *
+ * Se desactiva con THEUS_ARSENAL_SIN_NOTIFICACIONES=1. Nunca falla la
+ * sesión: cualquier error termina con exit 0 y salida silenciosa.
+ */
+
+'use strict';
+
+const { spawnSync, execFileSync } = require('child_process');
+const fs = require('fs');
+const { isMacOS, log } = require('../lib/utils');
+
+const TITULO = 'Theus';
+const LARGO_MAX_CUERPO = 100;
+const PROFUNDIDAD_MAX_TTY = 30;
+const PS_TIMEOUT_MS = 2000;
+
+// Detección de WSL memorizada al cargar el módulo (evita lecturas repetidas
+// de /proc/version).
+let esWSL = false;
+if (process.platform === 'linux') {
+  try {
+    esWSL = fs.readFileSync('/proc/version', 'utf8').toLowerCase().includes('microsoft');
+  } catch {
+    esWSL = false;
+  }
+}
+
+// Busca un ejecutable de PowerShell accesible desde WSL.
+function buscarPowerShell() {
+  if (!esWSL) return null;
+  const candidatos = [
+    'pwsh.exe',
+    'powershell.exe',
+    '/mnt/c/Program Files/PowerShell/7/pwsh.exe',
+    '/mnt/c/Windows/System32/WindowsPowerShell/v1.0/powershell.exe',
+  ];
+  for (const ruta of candidatos) {
+    try {
+      const r = spawnSync(ruta, ['-Command', 'exit 0'], { stdio: ['ignore', 'pipe', 'ignore'], timeout: 3000 });
+      if (r.status === 0) return ruta;
+    } catch {
+      // seguir con el siguiente candidato
+    }
+  }
+  return null;
+}
+
+// Notificación toast de Windows vía BurntToast. Devuelve { exito, motivo }.
+function notificarWindows(rutaPwsh, titulo, cuerpo) {
+  const cuerpoSeguro = cuerpo.replace(/'/g, "''");
+  const tituloSeguro = titulo.replace(/'/g, "''");
+  const comando = `Import-Module BurntToast; New-BurntToastNotification -Text '${tituloSeguro}', '${cuerpoSeguro}'`;
+  const r = spawnSync(rutaPwsh, ['-Command', comando], { stdio: ['ignore', 'pipe', 'pipe'], timeout: 5000 });
+  if (r.status === 0) return { exito: true, motivo: null };
+  const err = r.error ? r.error.message : r.stderr?.toString();
+  return { exito: false, motivo: err || `exit ${r.status}` };
+}
+
+// Notificación de escritorio en Linux nativo vía notify-send.
+function notificarLinux(titulo, cuerpo) {
+  const r = spawnSync('notify-send', [titulo, cuerpo], { stdio: 'ignore', timeout: 5000 });
+  if (r.error || r.status !== 0) {
+    log(`[NotificacionEscritorio] notify-send no disponible o falló: ${r.error ? r.error.message : `exit ${r.status}`}`);
+  }
+}
+
+// Extrae un resumen corto del último mensaje del asistente: primera línea
+// no vacía, truncada a LARGO_MAX_CUERPO caracteres.
+function extraerResumen(mensaje) {
+  if (!mensaje || typeof mensaje !== 'string') return 'Tarea terminada';
+  const primeraLinea = mensaje
+    .split('\n')
+    .map(l => l.trim())
+    .find(l => l.length > 0);
+  if (!primeraLinea) return 'Tarea terminada';
+  return primeraLinea.length > LARGO_MAX_CUERPO
+    ? `${primeraLinea.slice(0, LARGO_MAX_CUERPO)}...`
+    : primeraLinea;
+}
+
+// Sube por el árbol de procesos hasta encontrar un ancestro con TTY real.
+// El subproceso del hook está desacoplado de la terminal, pero el proceso
+// padre de Theus sigue siendo dueño del tty del emulador (p. ej. la pestaña
+// de iTerm2). Devuelve una ruta como "/dev/ttys017" o null.
+function buscarTTYTerminal() {
+  let pid = process.pid;
+  for (let nivel = 0; nivel < PROFUNDIDAD_MAX_TTY; nivel += 1) {
+    try {
+      const salida = execFileSync('ps', ['-o', 'ppid=,tty=', '-p', String(pid)], {
+        stdio: ['ignore', 'pipe', 'ignore'],
+        timeout: PS_TIMEOUT_MS,
+      }).toString().trim();
+      const m = salida.match(/^\s*(\d+)\s+(\S+)\s*$/);
+      if (!m) return null;
+      const [, ppidStr, tty] = m;
+      if (tty && !tty.startsWith('?')) {
+        // `ps -o tty=` puede emitir "ttys001" o la forma corta "s001" según
+        // la versión de macOS; normalizamos para que la ruta exista.
+        const nombre = tty.startsWith('tty') ? tty : `tty${tty}`;
+        return `/dev/${nombre}`;
+      }
+      const ppid = parseInt(ppidStr, 10);
+      if (!ppid || ppid <= 1) return null;
+      pid = ppid;
+    } catch {
+      return null;
+    }
+  }
+  return null;
+}
+
+// Detecta multiplexores (tmux/screen) que se tragan OSC 9: en ese caso se
+// omite la vía rápida de iTerm2 y se usa osascript.
+function bajoMultiplexor() {
+  if (process.env.TMUX) return true;
+  const term = process.env.TERM || '';
+  return /^screen/.test(term) || /^tmux/.test(term);
+}
+
+// Notificación en macOS: OSC 9 al tty de la terminal si es iTerm2/Ghostty
+// (y no hay multiplexor); si no, osascript. Las cadenas de AppleScript no
+// soportan escapes con backslash: se reemplazan comillas dobles por comillas
+// tipográficas y se eliminan los backslashes antes de incrustar.
+function notificarMacOS(titulo, cuerpo) {
+  const soportaOsc9 =
+    process.env.TERM_PROGRAM === 'iTerm.app' ||
+    process.env.TERM_PROGRAM === 'ghostty';
+  if (soportaOsc9 && !bajoMultiplexor()) {
+    try {
+      const tty = buscarTTYTerminal();
+      if (tty) {
+        // Se eliminan caracteres de control (incl. ESC/BEL) para impedir
+        // inyección de secuencias de escape.
+        // eslint-disable-next-line no-control-regex
+        const mensaje = `${titulo}: ${cuerpo}`.replace(/[\x00-\x1f\x7f]/g, ' ');
+        fs.writeFileSync(tty, `\x1b]9;${mensaje}\x07`);
+        return;
+      }
+    } catch (err) {
+      log(`[NotificacionEscritorio] Falló el escape de iTerm, usando osascript: ${err.message}`);
+    }
+  }
+  const cuerpoSeguro = cuerpo.replace(/\\/g, '').replace(/"/g, '“');
+  const tituloSeguro = titulo.replace(/\\/g, '').replace(/"/g, '“');
+  const script = `display notification "${cuerpoSeguro}" with title "${tituloSeguro}"`;
+  const r = spawnSync('osascript', ['-e', script], { stdio: 'ignore', timeout: 5000 });
+  if (r.error || r.status !== 0) {
+    log(`[NotificacionEscritorio] osascript falló: ${r.error ? r.error.message : `exit ${r.status}`}`);
+  }
+}
+
+function run(raw) {
+  try {
+    if (process.env.THEUS_ARSENAL_SIN_NOTIFICACIONES === '1') return;
+    const entrada = raw && raw.trim() ? JSON.parse(raw) : {};
+    const resumen = extraerResumen(entrada.last_assistant_message);
+
+    if (isMacOS) {
+      notificarMacOS(TITULO, resumen);
+    } else if (esWSL) {
+      const ps = buscarPowerShell();
+      if (ps) {
+        const { exito, motivo } = notificarWindows(ps, TITULO, resumen);
+        if (!exito && motivo && motivo.toLowerCase().includes('burnttoast')) {
+          log('[NotificacionEscritorio] Sugerencia: instala el módulo BurntToast de PowerShell para habilitar las notificaciones');
+        } else if (!exito && motivo) {
+          log(`[NotificacionEscritorio] Falló la notificación: ${motivo}`);
+        }
+      } else {
+        log('[NotificacionEscritorio] Sugerencia: instala PowerShell con el módulo BurntToast para recibir notificaciones');
+      }
+    } else if (process.platform === 'linux') {
+      notificarLinux(TITULO, resumen);
+    }
+  } catch (err) {
+    log(`[NotificacionEscritorio] Error: ${err.message}`);
+  }
+}
+
+module.exports = { run };
+
+// Vía directa por stdin (invocación registrada en hooks.json)
+if (require.main === module) {
+  const MAX_STDIN = 1024 * 1024;
+  let datos = '';
+  process.stdin.setEncoding('utf8');
+  process.stdin.on('data', trozo => {
+    if (datos.length < MAX_STDIN) datos += trozo.substring(0, MAX_STDIN - datos.length);
+  });
+  process.stdin.on('end', () => {
+    run(datos);
+    process.exit(0);
+  });
+}

package/vendor/theus-arsenal/scripts/hooks/plugin-hook-bootstrap.js

@@ -0,0 +1,280 @@
+#!/usr/bin/env node
+/**
+ * Bootstrap de hooks del plugin (lanzador delgado).
+ *
+ * En Theus la raíz del plugin NO se busca: el motor la entrega siempre por la
+ * variable de entorno THEUS_PLUGIN_ROOT. Este script solo resuelve la ruta del
+ * hook dentro de esa raíz (rechazando path traversal), lo ejecuta con Node o
+ * con un shell, y hace passthrough del payload cuando corresponde.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+function readStdinRaw() {
+  try {
+    return fs.readFileSync(0, 'utf8');
+  } catch (_error) {
+    return '';
+  }
+}
+
+function writeStderr(stderr) {
+  if (typeof stderr === 'string' && stderr.length > 0) {
+    process.stderr.write(stderr);
+  }
+}
+
+function passthrough(raw, result) {
+  const stdout = typeof result?.stdout === 'string' ? result.stdout : '';
+  if (stdout) {
+    process.stdout.write(stdout);
+    return;
+  }
+
+  if (!Number.isInteger(result?.status) || result.status === 0) {
+    process.stdout.write(raw);
+  }
+}
+
+function normalizePluginRootForPlatform(rootDir, platform = process.platform) {
+  if (platform !== 'win32' || typeof rootDir !== 'string') {
+    return rootDir;
+  }
+
+  const match = rootDir.match(/^\/([a-zA-Z])(?:\/(.*))?$/);
+  if (!match) {
+    return rootDir;
+  }
+
+  const [, driveLetter, rest = ''] = match;
+  return `${driveLetter.toUpperCase()}:/${rest}`;
+}
+
+function resolveTarget(rootDir, relPath) {
+  const resolvedRoot = path.resolve(rootDir);
+  const resolvedTarget = path.resolve(rootDir, relPath);
+  if (
+    resolvedTarget !== resolvedRoot &&
+    !resolvedTarget.startsWith(resolvedRoot + path.sep)
+  ) {
+    throw new Error(`Path traversal rechazado: ${relPath}`);
+  }
+  return resolvedTarget;
+}
+
+let _cachedShell = undefined;
+let _cachedBash = undefined;
+
+function isPowerShellBin(bin) {
+  const base = path.basename(bin).toLowerCase();
+  return base === 'pwsh.exe' || base === 'pwsh' || base === 'powershell.exe' || base === 'powershell';
+}
+
+function findShellBinary() {
+  if (_cachedShell !== undefined) return _cachedShell;
+
+  const candidates = [];
+
+  // El override explícito siempre gana — se comprueba antes de sondear la
+  // plataforma. Advertencia: fijar BASH a un binario de bash en Windows evita
+  // la preferencia por PowerShell y puede reintroducir la acumulación de
+  // procesos bash.exe zombis.
+  if (process.env.BASH && process.env.BASH.trim()) {
+    candidates.push(process.env.BASH.trim());
+  }
+
+  if (process.platform === 'win32') {
+    // Preferir PowerShell en Windows — es nativo y no deja procesos zombis
+    // bash.exe / conhost.exe como sí lo hace MSYS2/Git Bash.
+    // Nota: PowerShell solo sirve para scripts .ps1; quien necesite ejecutar
+    // scripts .sh no debe usar esta función.
+    candidates.push('pwsh.exe', 'powershell.exe', 'bash.exe', 'bash');
+  } else {
+    candidates.push('bash', 'sh');
+  }
+
+  const psProbeArgs = ['-NoProfile', '-NonInteractive', '-Command', 'exit 0'];
+  const shProbeArgs = ['-c', ':'];
+
+  for (const candidate of candidates) {
+    const probe = spawnSync(candidate, isPowerShellBin(candidate) ? psProbeArgs : shProbeArgs, {
+      stdio: 'ignore',
+      windowsHide: true,
+      timeout: 30000,
+    });
+    // Un candidato solo es utilizable si arranca Y termina limpio. El
+    // lanzador WSL bash.exe de System32 en Windows arranca sin error pero
+    // sale con código distinto de cero cuando no hay distro instalada, así
+    // que !probe.error por sí solo no basta.
+    if (!probe.error && probe.status === 0) {
+      _cachedShell = candidate;
+      return _cachedShell;
+    }
+  }
+
+  _cachedShell = null;
+  return null;
+}
+
+function findBashBinary() {
+  if (_cachedBash !== undefined) return _cachedBash;
+
+  const candidates = [];
+  if (process.env.BASH && process.env.BASH.trim() && !isPowerShellBin(process.env.BASH.trim())) {
+    candidates.push(process.env.BASH.trim());
+  }
+  candidates.push('bash.exe', 'bash');
+
+  for (const candidate of candidates) {
+    const probe = spawnSync(candidate, ['-c', ':'], { stdio: 'ignore', windowsHide: true, timeout: 30000 });
+    // Exige una salida limpia, no solo un spawn exitoso: el stub WSL bash.exe
+    // de System32 en Windows arranca bien pero sale con error sin distro instalada.
+    if (!probe.error && probe.status === 0) {
+      _cachedBash = candidate;
+      return _cachedBash;
+    }
+  }
+
+  _cachedBash = null;
+  return null;
+}
+
+function spawnNode(rootDir, relPath, raw, args) {
+  const hookEnv = {
+    ...process.env,
+    THEUS_PLUGIN_ROOT: rootDir,
+  };
+  return spawnSync(process.execPath, [resolveTarget(rootDir, relPath), ...args], {
+    input: raw,
+    encoding: 'utf8',
+    env: hookEnv,
+    cwd: process.cwd(),
+    timeout: 30000,
+    windowsHide: true,
+  });
+}
+
+// spawnShell no lo usa ningún hook de la configuración hooks.json distribuida
+// (todos los hooks usan el modo 'node'). Se ofrece para plugins de terceros
+// que registren hooks respaldados por shell. Los plugins deben aportar
+// scripts .ps1 en Windows y .sh en Unix; mezclarlos produce una omisión con
+// un aviso por stderr.
+function spawnShell(rootDir, relPath, raw, args) {
+  const shell = findShellBinary();
+  if (!shell) {
+    return {
+      status: 0,
+      stdout: '',
+      stderr: '[Hook] runtime de shell no disponible; se omite el hook respaldado por shell\n',
+    };
+  }
+
+  const hookEnv = {
+    ...process.env,
+    THEUS_PLUGIN_ROOT: rootDir,
+  };
+  const scriptPath = resolveTarget(rootDir, relPath);
+  const isPs = isPowerShellBin(shell);
+
+  // PowerShell no puede interpretar scripts de bash — recurrir a un candidato
+  // de bash en lugar de fallar el hook en silencio.
+  if (isPs && scriptPath.endsWith('.sh')) {
+    const bash = findBashBinary();
+    if (!bash) {
+      return {
+        status: 0,
+        stdout: '',
+        stderr: '[Hook] se pidió un script .sh pero no se encontró un binario de bash en Windows; se omite\n',
+      };
+    }
+    return spawnSync(bash, [scriptPath, ...args], {
+      input: raw,
+      encoding: 'utf8',
+      env: hookEnv,
+      cwd: process.cwd(),
+      timeout: 30000,
+      windowsHide: true,
+    });
+  }
+
+  const shellArgs = isPs
+    // -ExecutionPolicy Bypass: la política por defecto de Windows (Restricted)
+    // bloquea la ejecución de scripts .ps1 con -File; Bypass aplica solo a
+    // este proceso hijo.
+    ? ['-NoProfile', '-NonInteractive', '-ExecutionPolicy', 'Bypass', '-File', scriptPath, ...args]
+    : [scriptPath, ...args];
+
+  return spawnSync(shell, shellArgs, {
+    input: raw,
+    encoding: 'utf8',
+    env: hookEnv,
+    cwd: process.cwd(),
+    timeout: 30000,
+    windowsHide: true,
+  });
+}
+
+function main() {
+  const [, , mode, relPath, ...args] = process.argv;
+  const raw = readStdinRaw();
+  // Raíz del plugin = THEUS_PLUGIN_ROOT, sin búsqueda alternativa: el motor
+  // Theus la inyecta siempre en el entorno de cada hook.
+  const rootDir = normalizePluginRootForPlatform(process.env.THEUS_PLUGIN_ROOT);
+
+  if (!mode || !relPath || !rootDir) {
+    process.stdout.write(raw);
+    process.exit(0);
+  }
+
+  let result;
+  try {
+    if (mode === 'node') {
+      result = spawnNode(rootDir, relPath, raw, args);
+    } else if (mode === 'shell') {
+      result = spawnShell(rootDir, relPath, raw, args);
+    } else {
+      writeStderr(`[Hook] modo de bootstrap desconocido: ${mode}\n`);
+      process.stdout.write(raw);
+      process.exit(0);
+    }
+  } catch (error) {
+    writeStderr(`[Hook] falló la resolución del bootstrap: ${error.message}\n`);
+    process.stdout.write(raw);
+    process.exit(0);
+  }
+
+  passthrough(raw, result);
+  writeStderr(result.stderr);
+
+  if (result.error || result.signal || result.status === null) {
+    const reason = result.error
+      ? result.error.message
+      : result.signal
+        ? `terminado por la señal ${result.signal}`
+        : 'falta el código de salida';
+    writeStderr(`[Hook] falló la ejecución del bootstrap: ${reason}\n`);
+    process.exit(0);
+  }
+
+  process.exit(Number.isInteger(result.status) ? result.status : 0);
+}
+
+// Se ejecuta al invocarse como entrada de hook. Algunas configuraciones cargan
+// este módulo vía `node -e "...; process.argv.splice(1,0,s); require(s)"`; en
+// Node 21+ eso deja require.main como undefined (no este módulo), lo que antes
+// omitía main() y convertía cada hook del plugin en un no-op silencioso. Se
+// cubre tanto el caso de entrada directa como ese caso de eval-bootstrap.
+// Cuando se importa por sus exports (tests), require.main es un módulo real y
+// distinto, así que main() queda inactivo.
+if (require.main === module || require.main === undefined) {
+  main();
+}
+
+module.exports = {
+  main,
+  normalizePluginRootForPlatform,
+};

package/vendor/theus-arsenal/scripts/hooks/post-bash-command-log.js

@@ -0,0 +1,87 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const MAX_STDIN = 1024 * 1024;
+let raw = '';
+
+const MODE_CONFIG = {
+  audit: {
+    fileName: 'bash-commands.log',
+    format: command => `[${new Date().toISOString()}] ${command}`,
+  },
+  cost: {
+    fileName: 'cost-tracker.log',
+    format: command => `[${new Date().toISOString()}] tool=Bash command=${command}`,
+  },
+};
+
+function sanitizeCommand(command) {
+  return String(command || '')
+    .replace(/\n/g, ' ')
+    .replace(/--token[= ][^ ]*/g, '--token=<REDACTED>')
+    .replace(/Authorization:[: ]*[^ ]*[: ]*[^ ]*/gi, 'Authorization:<REDACTED>')
+    .replace(/\bAKIA[A-Z0-9]{16}\b/g, '<REDACTED>')
+    .replace(/\bASIA[A-Z0-9]{16}\b/g, '<REDACTED>')
+    .replace(/password[= ][^ ]*/gi, 'password=<REDACTED>')
+    .replace(/\bghp_[A-Za-z0-9_]+\b/g, '<REDACTED>')
+    .replace(/\bgho_[A-Za-z0-9_]+\b/g, '<REDACTED>')
+    .replace(/\bghs_[A-Za-z0-9_]+\b/g, '<REDACTED>')
+    .replace(/\bgithub_pat_[A-Za-z0-9_]+\b/g, '<REDACTED>');
+}
+
+function appendLine(filePath, line) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.appendFileSync(filePath, `${line}\n`, 'utf8');
+}
+
+// Directorio de estado persistente: el data home del arsenal
+// (~/.theus/arsenal por defecto), estable en todos los contextos de ejecución.
+function getLogDir() {
+  const { resolveAgentDataHome } = require('../lib/agent-data-home');
+  return resolveAgentDataHome();
+}
+
+function run(rawInput, mode = 'audit') {
+  const config = MODE_CONFIG[mode];
+
+  try {
+    if (config) {
+      const input = String(rawInput || '').trim() ? JSON.parse(String(rawInput)) : {};
+      const command = sanitizeCommand(input.tool_input?.command || '?');
+      appendLine(path.join(getLogDir(), config.fileName), config.format(command));
+    }
+  } catch {
+    // El registro nunca debe bloquear al hook que lo llama.
+  }
+
+  return typeof rawInput === 'string' ? rawInput : JSON.stringify(rawInput);
+}
+
+function main() {
+  const mode = process.argv[2];
+
+  process.stdin.setEncoding('utf8');
+  process.stdin.on('data', chunk => {
+    if (raw.length < MAX_STDIN) {
+      const remaining = MAX_STDIN - raw.length;
+      raw += chunk.substring(0, remaining);
+    }
+  });
+
+  process.stdin.on('end', () => {
+    process.stdout.write(run(raw, mode));
+  });
+}
+
+if (require.main === module) {
+  main();
+}
+
+module.exports = {
+  run,
+  sanitizeCommand,
+};

package/vendor/theus-arsenal/scripts/hooks/post-bash-dispatcher.js

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+'use strict';
+
+const { runPostBash } = require('./bash-hook-dispatcher');
+
+let raw = '';
+const MAX_STDIN = 1024 * 1024;
+
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', chunk => {
+  if (raw.length < MAX_STDIN) {
+    const remaining = MAX_STDIN - raw.length;
+    raw += chunk.substring(0, remaining);
+  }
+});
+
+process.stdin.on('end', () => {
+  const result = runPostBash(raw);
+  if (result.stderr) {
+    process.stderr.write(result.stderr);
+  }
+  process.stdout.write(result.output);
+  process.exitCode = result.exitCode;
+});

package/vendor/theus-arsenal/scripts/hooks/post-bash-pr-created.js

@@ -0,0 +1,60 @@
+#!/usr/bin/env node
+'use strict';
+
+const MAX_STDIN = 1024 * 1024;
+let raw = '';
+
+function run(rawInput) {
+  try {
+    const input = typeof rawInput === 'string' ? JSON.parse(rawInput) : rawInput;
+    const cmd = String(input.tool_input?.command || '');
+
+    if (/\bgh\s+pr\s+create\b/.test(cmd)) {
+      const out = String(input.tool_output?.output || '');
+      const match = out.match(/https:\/\/github\.com\/[^/]+\/[^/]+\/pull\/\d+/);
+      if (match) {
+        const prUrl = match[0];
+        const repo = prUrl.replace(/https:\/\/github\.com\/([^/]+\/[^/]+)\/pull\/\d+/, '$1');
+        const prNum = prUrl.replace(/.+\/pull\/(\d+)/, '$1');
+        return {
+          stdout: typeof rawInput === 'string' ? rawInput : JSON.stringify(rawInput),
+          stderr: [
+            `[Hook] PR creado: ${prUrl}`,
+            `[Hook] Para revisarlo: gh pr review ${prNum} --repo ${repo}`,
+          ].join('\n'),
+          exitCode: 0,
+        };
+      }
+    }
+  } catch {
+    // Ignorar errores de parseo y dejar pasar la entrada tal cual
+  }
+
+  return typeof rawInput === 'string' ? rawInput : JSON.stringify(rawInput);
+}
+
+if (require.main === module) {
+  process.stdin.setEncoding('utf8');
+  process.stdin.on('data', chunk => {
+    if (raw.length < MAX_STDIN) {
+      const remaining = MAX_STDIN - raw.length;
+      raw += chunk.substring(0, remaining);
+    }
+  });
+
+  process.stdin.on('end', () => {
+    const result = run(raw);
+    if (result && typeof result === 'object') {
+      if (result.stderr) {
+        process.stderr.write(`${result.stderr}\n`);
+      }
+      process.stdout.write(String(result.stdout || ''));
+      process.exit(Number.isInteger(result.exitCode) ? result.exitCode : 0);
+      return;
+    }
+
+    process.stdout.write(String(result));
+  });
+}
+
+module.exports = { run };