@danieltmn/tamnora 0.8.0 → 0.9.1

package/harness/packages/cli/src/lib/daemon.js

@@ -1,69 +1,121 @@
 import { spawn, spawnSync } from 'node:child_process';
-import { readFileSync, writeFileSync, unlinkSync } from 'node:fs';
+import { appendFileSync, readFileSync, writeFileSync, unlinkSync } from 'node:fs';
+import path from 'node:path';
 import {
+  setHome,
+  ensureHome,
   runtimePath,
   pidPath,
-  bridgeLogPath,
+  bridgeStatePath,
   serverLogPath,
+  bridgeLogPath,
+  killPidTree,
+  pidAlive,
 } from '../../../core/src/index.js';
 
 /** Mata un proceso y su arbol de hijos (taskkill en Windows; grupo en POSIX). */
 export function killPid(pid) {
-  if (!pid) return;
-  try {
-    if (process.platform === 'win32') {
-      spawn('taskkill', ['/PID', String(pid), '/T', '/F'], { windowsHide: true });
-    } else {
+  killPidTree(pid);
+}
+
+export { pidAlive };
+
+/** Crea `setHome` + env TAMNORA_HOME a partir de `--home` (comun a CLI commands). */
+export function applyHomeOverride(values) {
+  if (!values?.home) return;
+  setHome(values.home);
+  process.env.TAMNORA_HOME = path.resolve(values.home);
+}
+
+/** read/write/clear de un archivo JSON de estado (runtime del server, bridge). */
+function jsonStateIO(file, { extraClear = [] } = {}) {
+  return {
+    read() {
       try {
-        process.kill(-pid, 'SIGTERM');
+        return JSON.parse(readFileSync(file, 'utf8'));
       } catch {
-        /* sin grupo propio */
+        return null;
       }
+    },
+    write(data) {
+      ensureHome();
       try {
-        process.kill(pid, 'SIGTERM');
+        writeFileSync(file, `${JSON.stringify(data, null, 2)}\n`);
       } catch {
-        /* ya no esta */
+        /* sin estado no detenemos nada */
       }
-    }
-  } catch {
-    /* ya no esta */
-  }
+    },
+    clear() {
+      for (const f of [file, ...extraClear]) {
+        try {
+          unlinkSync(f);
+        } catch {
+          /* nada */
+        }
+      }
+    },
+  };
 }
 
-export function pidAlive(pid) {
-  if (!pid) return false;
-  try {
-    process.kill(pid, 0);
-    return true;
-  } catch {
-    return false;
-  }
-}
+export const runtimeState = jsonStateIO(runtimePath(), { extraClear: [pidPath()] });
+export const bridgeState = jsonStateIO(bridgeStatePath());
 
 export function readRuntime() {
-  try {
-    return JSON.parse(readFileSync(runtimePath(), 'utf8'));
-  } catch {
-    return null;
-  }
+  return runtimeState.read();
 }
-
 export function writeRuntime(data) {
-  try {
-    writeFileSync(runtimePath(), `${JSON.stringify(data, null, 2)}\n`);
-  } catch {
-    /* sin runtime no detenemos nada */
-  }
+  runtimeState.write(data);
 }
-
 export function clearRuntime() {
-  for (const file of [runtimePath(), pidPath()]) {
+  runtimeState.clear();
+}
+
+/** Logger con timestamp a archivo + consola (server, bridge, tunnel). */
+export function createFileLogger(logPath) {
+  return (line) => {
+    const text = `[${new Date().toISOString()}] ${line}`;
     try {
-      unlinkSync(file);
+      ensureHome();
+      appendFileSync(logPath, `${text}\n`);
     } catch {
-      /* nada */
+      /* sin log no detenemos nada */
     }
-  }
+    console.log(text);
+  };
+}
+
+/** Hijo detached con un flag de env que marca que es el proceso child. */
+export function spawnDetached(args, { envFlag, env = process.env } = {}) {
+  const child = spawn(process.execPath, args, {
+    detached: true,
+    stdio: 'ignore',
+    windowsHide: true,
+    env: envFlag ? { ...env, [envFlag]: '1' } : { ...env },
+  });
+  child.unref();
+  let dead = false;
+  child.on('exit', () => {
+    dead = true;
+  });
+  return { child, isDead: () => dead };
+}
+
+/**
+ * Espera a que `readFn()` devuelva un estado cuyo pid este vivo (y sea el
+ * child esperado, si hay). Null si el child murio o vencio el timeout.
+ */
+export function waitForState(readFn, { childPid, isDead = () => false, timeoutMs = 30000, tickMs = 400 } = {}) {
+  return new Promise((resolve) => {
+    const start = Date.now();
+    const tick = () => {
+      if (isDead()) return resolve(null);
+      const state = readFn();
+      if (state?.pid && pidAlive(state.pid) && (!childPid || state.pid === childPid)) return resolve(state);
+      if (Date.now() - start > timeoutMs) return resolve(null);
+      setTimeout(tick, tickMs);
+    };
+    tick();
+  });
 }
 
 /** PIDs escuchando en un puerto TCP (netstat en Windows; lsof en el resto). */

package/harness/packages/cli/test/release.test.js

@@ -32,3 +32,12 @@ test('renderChangelog promotes the Unreleased section', () => {
   assert.doesNotMatch(out, /## \[Unreleased\]/);
   assert.match(out, /## \[1\.0\.0\]/);
 });
+
+test('renderChangelog promotes the [No publicado] section', () => {
+  const cl = '# Changelog\n\n## [No publicado]\n\n### Agregado\n\n- algo\n\n## [1.0.0] - 2026-01-01\n\n- viejo\n';
+  const out = renderChangelog(cl, '1.1.0', '- nota', '2026-02-02');
+  assert.match(out, /## \[1\.1\.0\] - 2026-02-02/);
+  assert.match(out, /- algo/);
+  assert.doesNotMatch(out, /## \[No publicado\]/);
+  assert.match(out, /## \[1\.0\.0\]/);
+});

package/harness/packages/core/src/agent/modes.js

@@ -13,7 +13,7 @@ export const MODES = {
     id: 'plan',
     label: 'Plan',
     description: 'Solo lectura: investiga y propone un plan, sin modificar nada.',
-    tools: ['read', 'list', 'glob', 'grep', 'fetch_url', 'git_status', 'git_diff', 'git_log'],
+    tools: ['read', 'list', 'glob', 'grep', 'fetch_url', 'speak', 'git_status', 'git_diff', 'git_log'],
     systemPrompt:
       'Estás en modo PLAN: no modifiques archivos ni ejecutes comandos. Investigá el proyecto con las herramientas de solo lectura y respondé con un plan concreto y accionable.',
   },

package/harness/packages/core/src/index.js

@@ -93,7 +93,20 @@ export {
   registryServerToConfig,
   normalizeMcpConfig,
 } from './mcp/registry.js';
-export { parseTunnelmoleUrls, startTunnelmole, startTunnel } from './tunnel.js';
+export { parseTunnelmoleUrls, startTunnelmole, startRelay, startTunnel, tunnelState, tunnelActive } from './tunnel.js';
+export {
+  TRUSTED_CLIENT_TOKEN,
+  EDGE_VERSION,
+  FORMATO_POR_DEFECTO,
+  MAX_TEXTO,
+  VOZ_POR_DEFECTO,
+  generarSecMsGec,
+  generarSsml,
+  sintetizar,
+  listarVoces,
+} from './tts/edge.js';
+export { pidAlive, killPidTree } from './pid.js';
+export { openBrowser, openerFor } from './open.js';
 export { detectProcs, packageManager, DEFAULT_PROCESS_ALLOW, staticServerChip } from './procs/detect.js';
 export { killPort } from './procs/kill.js';
 export { readPackageVersion } from './version.js';

package/harness/packages/core/src/open.js

@@ -0,0 +1,43 @@
+import { spawn } from 'node:child_process';
+
+/**
+ * Abre una URL en el navegador predeterminado.
+ *
+ * Es best-effort y nunca falla el comando que la llama: si no hay navegador
+ * (contenedor, servicio, CI) solo se avisa y se sigue. Por eso devuelve una
+ * promesa que resuelve siempre.
+ */
+export function openBrowser(url, { platform = process.platform, log = console.warn } = {}) {
+  const [command, args] = openerFor(url, platform);
+  if (!command) {
+    log(`No se pudo abrir el navegador automaticamente: ${url}`);
+    return Promise.resolve(false);
+  }
+  return new Promise((resolve) => {
+    try {
+      const child = spawn(command, args, {
+        // Sin shell: una URL con query (&, ?) no debe pasar por cmd.
+        shell: false,
+        detached: true,
+        stdio: 'ignore',
+        windowsHide: true,
+      });
+      child.once('error', (error) => {
+        log(`No se pudo abrir el navegador (${error.message}). Entra a ${url}`);
+        resolve(false);
+      });
+      child.unref();
+      resolve(true);
+    } catch (error) {
+      log(`No se pudo abrir el navegador (${error.message}). Entra a ${url}`);
+      resolve(false);
+    }
+  });
+}
+
+/** El comando nativo de cada plataforma; `rundll32` evita el shell en Windows. */
+export function openerFor(url, platform = process.platform) {
+  if (platform === 'win32') return ['rundll32.exe', ['url.dll,FileProtocolHandler', url]];
+  if (platform === 'darwin') return ['open', [url]];
+  return ['xdg-open', [url]];
+}

package/harness/packages/core/src/pid.js

@@ -0,0 +1,35 @@
+import { spawn } from 'node:child_process';
+
+/** True si el proceso con ese pid esta vivo. */
+export function pidAlive(pid) {
+  if (!pid) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/** Mata un proceso y su arbol de hijos (taskkill /T en Windows; grupo + SIGTERM en POSIX). */
+export function killPidTree(pid) {
+  if (!pid) return;
+  try {
+    if (process.platform === 'win32') {
+      spawn('taskkill', ['/PID', String(pid), '/T', '/F'], { windowsHide: true });
+    } else {
+      try {
+        process.kill(-pid, 'SIGTERM');
+      } catch {
+        /* sin grupo propio */
+      }
+      try {
+        process.kill(pid, 'SIGTERM');
+      } catch {
+        /* ya no esta */
+      }
+    }
+  } catch {
+    /* ya no esta */
+  }
+}

package/harness/packages/core/src/tools/executors.js

@@ -404,6 +404,21 @@ export async function gitCommitTool(root, { message, files } = {}) {
   return runGit(root, ['commit', '-m', message]);
 }
 
+const MAX_SPEAK_TEXT = 1200;
+
+/**
+ * Pedido de audio: valida el texto y lo devuelve. La sintesis y la reproduccion
+ * son del cliente (la consola lo reproduce y Telegram lo manda como nota de
+ * voz), asi que aca solo se normaliza el pedido y se acota el largo.
+ */
+export function speakTool(_root, { texto, voice, rate } = {}) {
+  const value = String(texto ?? '').replace(/\s+/g, ' ').trim();
+  if (!value) return 'Error: falta "texto".';
+  const recortado = value.length > MAX_SPEAK_TEXT ? `${value.slice(0, MAX_SPEAK_TEXT - 1).trimEnd()}…` : value;
+  const opciones = [voice, rate].filter(Boolean).join(', ');
+  return `Audio pedido${opciones ? ` (${opciones})` : ''}: "${recortado}". El cliente lo reproduce o lo envía como nota de voz.`;
+}
+
 export const EXECUTORS = {
   read: readTool,
   write: writeTool,
@@ -417,4 +432,5 @@ export const EXECUTORS = {
   git_diff: gitDiffTool,
   git_log: gitLogTool,
   git_commit: gitCommitTool,
+  speak: speakTool,
 };

package/harness/packages/core/src/tools/labels.js

@@ -50,6 +50,8 @@ export function summarizeToolCall(name, args = {}) {
     }
     case 'fetch_url':
       return shorten(a.url, 90);
+    case 'speak':
+      return shorten(a.texto, 90);
     case 'git_diff':
       return [a.ref ? `vs ${shorten(a.ref, 30)}` : a.staged ? 'staged' : 'unstaged', a.path ? path(a.path) : '']
         .filter(Boolean)

package/harness/packages/core/src/tools/permissions.js

@@ -13,6 +13,7 @@ export const DEFAULT_PERMISSIONS = {
   git_diff: 'allow',
   git_log: 'allow',
   fetch_url: 'allow',
+  speak: 'allow',
   write: 'ask',
   edit: 'ask',
   bash: 'ask',

package/harness/packages/core/src/tools/schema.js

@@ -133,6 +133,23 @@ export const TOOL_DEFINITIONS = [
       },
     },
   },
+  {
+    type: 'function',
+    function: {
+      name: 'speak',
+      description:
+        'Speak a short text aloud to the user with text-to-speech. Use it when the user asks to hear something (e.g. an audio summary). Keep it concise: the web console plays it and Telegram sends it as a voice note.',
+      parameters: {
+        type: 'object',
+        properties: {
+          texto: { type: 'string', description: 'Text to speak (long text is trimmed)' },
+          voice: { type: 'string', description: 'Optional voice id, e.g. "es-AR-ElenaNeural"' },
+          rate: { type: 'string', description: 'Optional speed, e.g. "+10%"' },
+        },
+        required: ['texto'],
+      },
+    },
+  },
   {
     type: 'function',
     function: {

package/harness/packages/core/src/tts/edge.js

@@ -0,0 +1,232 @@
+// Sintesis de voz (TTS) con el servicio Edge Read Aloud de Microsoft: las
+// voces neuronales gratuitas de Edge, sin API key ni cuenta de Azure.
+//
+// Port del cliente de streaming de voice-tts, adaptado al WebSocket global de
+// Node (>=22, undici): ese WebSocket acepta `origin` y `headers` como bag de
+// opciones (extension no estandar de undici), que el servicio exige (User-Agent
+// de Edge + token anti-abuso Sec-MS-GEC en la URL). Sin dependencias.
+//
+// Aqui la salida es buffered (Promise<Buffer>): las frases que habla el harness
+// son cortas, el MP3 completo ronda los 50-150 KB y no vale la pena exponer un
+// stream con backpressure. Trampas heredadas del original:
+//   - sin Sec-MS-GEC (SHA-256 del file time de Windows + token) el servicio da 403;
+//   - un cierre del socket antes de `turn.end` deja un MP3 "truncado pero
+//     reproducible": eso se convierte en error, no en silencio.
+
+import { createHash, randomBytes } from 'node:crypto';
+
+/** Token publico del cliente de Edge (via en el codigo del navegador). */
+export const TRUSTED_CLIENT_TOKEN = '6A5AA1D4EAFF4E9FB37E23D68491D6F4';
+
+/** Version de Edge que declaramos. Si el servicio empieza a rechazar, subirla. */
+export const EDGE_VERSION = process.env.TTS_EDGE_VERSION ?? '143.0.3650.75';
+
+/** Formato por defecto: MP3 a 24 kHz, 48 kbps, mono (CBR). */
+export const FORMATO_POR_DEFECTO = 'audio-24khz-48kbitrate-mono-mp3';
+
+/** Tope de texto por sintesis: el servicio rechaza mas de ~3000 caracteres. */
+export const MAX_TEXTO = 2000;
+
+/** Voz por defecto del harness. */
+export const VOZ_POR_DEFECTO = 'es-AR-ElenaNeural';
+
+const URL_BASE = 'wss://speech.platform.bing.com/consumer/speech/synthesize/readaloud/edge/v1';
+const URL_VOCES = `https://speech.platform.bing.com/consumer/speech/synthesize/readaloud/voices/list?trustedclienttoken=${TRUSTED_CLIENT_TOKEN}`;
+const ORIGEN_EDGE = 'chrome-extension://jdiccldimpdaibmpdkjnbmckianbfold';
+const SEGUNDOS_EPOCA_WINDOWS = 11644473600;
+const VENTANA_TICKS = 3000000000n; // 5 minutos en ticks de 100 ns
+const DELIMITADOR_AUDIO = Buffer.from('Path:audio\r\n');
+
+const UA_EDGE = `Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/${EDGE_VERSION.split('.')[0]}.0.0.0 Safari/537.36 Edg/${EDGE_VERSION.split('.')[0]}.0.0.0`;
+
+/**
+ * Token anti-abuso `Sec-MS-GEC` que exige el servicio: SHA-256 del file time
+ * de Windows redondeado a 5 minutos + el client token.
+ *
+ * @param {number} [ahora] Marca de tiempo en ms (inyectable para pruebas).
+ * @returns {string} SHA-256 en mayusculas.
+ */
+export function generarSecMsGec(ahora = Date.now()) {
+  const segundos = Math.floor(ahora / 1000 + SEGUNDOS_EPOCA_WINDOWS);
+  const ticks = BigInt(segundos) * 10000000n;
+  const redondeado = ticks - (ticks % VENTANA_TICKS);
+  return createHash('sha256').update(`${redondeado}${TRUSTED_CLIENT_TOKEN}`, 'ascii').digest('hex').toUpperCase();
+}
+
+function escaparXml(valor) {
+  return String(valor).replace(/[<>&"']/g, (c) => {
+    switch (c) {
+      case '<': return '&lt;';
+      case '>': return '&gt;';
+      case '&': return '&amp;';
+      case '"': return '&quot;';
+      default: return '&apos;';
+    }
+  });
+}
+
+/** SSML de una sintesis. Exportado para probar el escape y la prosodia. */
+export function generarSsml({ voz, lang, rate, pitch, volume, texto }) {
+  const locale = lang ?? (/\w{2}-\w{2}/.exec(String(voz ?? ''))?.[0] ?? '');
+  if (!locale) throw new Error(`No se pudo deducir el locale de la voz "${voz}".`);
+  return (
+    `<speak version="1.0" xmlns="http://www.w3.org/2001/10/synthesis" xml:lang="${escaparXml(locale)}">` +
+    `<voice name="${escaparXml(voz)}">` +
+    `<prosody rate="${escaparXml(rate)}" pitch="${escaparXml(pitch)}" volume="${escaparXml(volume)}">` +
+    `${escaparXml(texto)}` +
+    '</prosody></voice></speak>'
+  );
+}
+
+function urlSintesis() {
+  const parametros = new URLSearchParams({
+    TrustedClientToken: TRUSTED_CLIENT_TOKEN,
+    'Sec-MS-GEC': generarSecMsGec(),
+    'Sec-MS-GEC-Version': `1-${EDGE_VERSION}`,
+    ConnectionId: randomBytes(16).toString('hex'),
+  });
+  return `${URL_BASE}?${parametros.toString()}`;
+}
+
+/**
+ * Sintetiza texto y devuelve el MP3 completo.
+ *
+ * @param {string} texto Texto a sintetizar (se recorta a MAX_TEXTO).
+ * @param {object} [opciones]
+ * @param {string} [opciones.voice] Voz (ej. "es-AR-ElenaNeural").
+ * @param {string} [opciones.rate] Velocidad, ej. "+20%".
+ * @param {string} [opciones.pitch] Tono, ej. "-10Hz".
+ * @param {string} [opciones.volume] Volumen, ej. "+0%".
+ * @param {string} [opciones.outputFormat] Formato de salida del servicio.
+ * @param {number} [opciones.idleTimeout] Maximo de ms sin frames antes de abortar.
+ * @param {AbortSignal} [opciones.signal] Para cancelar la sintesis.
+ * @returns {Promise<Buffer>} MP3.
+ */
+export function sintetizar(texto, opciones = {}) {
+  const {
+    voice: voz = VOZ_POR_DEFECTO,
+    rate = '+0%',
+    pitch = '+0Hz',
+    volume = '+0%',
+    outputFormat = FORMATO_POR_DEFECTO,
+    idleTimeout = 15000,
+    signal,
+  } = opciones;
+
+  const contenido = String(texto ?? '').slice(0, MAX_TEXTO).trim();
+  if (!contenido) throw new Error('El texto está vacío: no hay nada que sintetizar.');
+  if (signal?.aborted) throw new Error('La síntesis se canceló antes de empezar.');
+  if (typeof WebSocket === 'undefined') {
+    throw new Error('Este Node no trae WebSocket global (se necesita Node 22+).');
+  }
+
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    const ws = new WebSocket(urlSintesis(), {
+      origin: ORIGEN_EDGE,
+      headers: {
+        Pragma: 'no-cache',
+        'Cache-Control': 'no-cache',
+        'Accept-Encoding': 'gzip, deflate, br, zstd',
+        'Accept-Language': 'en-US,en;q=0.9',
+        'User-Agent': UA_EDGE,
+      },
+    });
+    ws.binaryType = 'arraybuffer';
+
+    let termino = false;
+    let vigilante = null;
+
+    const fallar = (error) => {
+      if (termino) return;
+      termino = true;
+      clearTimeout(vigilante);
+      signal?.removeEventListener('abort', alAbortar);
+      try {
+        ws.close();
+      } catch {
+        // ya cerrado
+      }
+      reject(error);
+    };
+
+    const alAbortar = () => fallar(new Error('La síntesis se canceló.'));
+    const vigilar = () => {
+      clearTimeout(vigilante);
+      vigilante = setTimeout(() => fallar(new Error(`El servicio no envió audio en ${idleTimeout} ms.`)), idleTimeout);
+      vigilante.unref?.();
+    };
+
+    signal?.addEventListener('abort', alAbortar, { once: true });
+    vigilar();
+
+    ws.addEventListener('open', () => {
+      ws.send(
+        'Content-Type:application/json; charset=utf-8\r\nPath:speech.config\r\n\r\n' +
+          JSON.stringify({
+            context: {
+              synthesis: {
+                audio: {
+                  metadataoptions: { sentenceBoundaryEnabled: false, wordBoundaryEnabled: false },
+                  outputFormat,
+                },
+              },
+            },
+          })
+      );
+      ws.send(
+        `X-RequestId:${randomBytes(16).toString('hex')}\r\nContent-Type:application/ssml+xml\r\nPath:ssml\r\n\r\n` +
+          generarSsml({ voz, rate, pitch, volume, texto: contenido })
+      );
+    });
+
+    ws.addEventListener('message', (event) => {
+      vigilar();
+      if (event.data instanceof ArrayBuffer) {
+        const frame = Buffer.from(event.data);
+        const corte = frame.indexOf(DELIMITADOR_AUDIO);
+        if (corte === -1) return;
+        const audio = frame.subarray(corte + DELIMITADOR_AUDIO.length);
+        if (audio.length) chunks.push(Buffer.from(audio));
+        return;
+      }
+      const frame = typeof event.data === 'string' ? event.data : Buffer.from(event.data).toString();
+      if (frame.includes('Path:turn.end')) {
+        termino = true;
+        clearTimeout(vigilante);
+        signal?.removeEventListener('abort', alAbortar);
+        ws.close();
+        if (!chunks.length) reject(new Error('El servicio cerró sin entregar audio.'));
+        else resolve(Buffer.concat(chunks));
+      }
+    });
+
+    ws.addEventListener('error', (event) => {
+      fallar(new Error(`Error de WebSocket con el servicio: ${event.message ?? 'sin detalle'}`));
+    });
+
+    ws.addEventListener('close', () => {
+      fallar(new Error('El servicio cerró la conexión antes de terminar: el audio quedaría truncado.'));
+    });
+  });
+}
+
+/**
+ * Catalogo de voces del servicio (endpoint publico, con cache propio).
+ *
+ * @param {string} [filtro] Prefijo de locale (ej. "es-"). Vacio = todas.
+ * @param {object} [opciones]
+ * @param {AbortSignal} [opciones.signal] Para cancelar la peticion.
+ * @returns {Promise<Array<object>>} Voces que empiezan con el filtro.
+ */
+export async function listarVoces(filtro = 'es-', { signal } = {}) {
+  const respuesta = await fetch(URL_VOCES, {
+    headers: { 'User-Agent': UA_EDGE, Accept: 'application/json' },
+    signal,
+  });
+  if (!respuesta.ok) throw new Error(`El servicio de voces respondió HTTP ${respuesta.status}.`);
+  const voces = await respuesta.json();
+  if (!Array.isArray(voces)) throw new Error('La respuesta del servicio de voces no es una lista.');
+  if (!filtro) return voces;
+  return voces.filter((v) => String(v.Locale ?? '').startsWith(filtro));
+}