@danieltmn/tamnora 0.8.0 → 0.9.1

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

@@ -1,4 +1,7 @@
 import { spawn } from 'node:child_process';
+import { readFileSync } from 'node:fs';
+import { bridgeStatePath } from './config/home.js';
+import { pidAlive, killPidTree } from './pid.js';
 
 /**
  * Tuneles publicos. v1 soporta tunnelmole (gratis, sin cuenta; URL aleatoria)
@@ -7,27 +10,39 @@ import { spawn } from 'node:child_process';
 
 function killTree(child) {
   if (!child || child.killed) return;
-  const pid = child.pid;
+  killPidTree(child.pid);
+}
+
+/**
+ * Estado del bridge (escrito por `tamnora bridge`), si el supervisor sigue
+ * vivo. Lo consulta el server para saber que hay un tunel publico activo y
+ * ajustar el modelo de confianza (guards locales, cookie Secure).
+ * Cache de 1 s: se lee en cada request sensible y el pid no cambia tan rapido.
+ */
+let tunnelCache = { key: null, at: 0, state: null };
+export function tunnelState() {
+  let statePath;
   try {
-    if (process.platform === 'win32' && pid) {
-      spawn('taskkill', ['/PID', String(pid), '/T', '/F'], { windowsHide: true });
-    } else {
-      if (pid) {
-        try {
-          process.kill(-pid, 'SIGTERM');
-        } catch {
-          /* sin grupo */
-        }
-      }
-      try {
-        child.kill('SIGTERM');
-      } catch {
-        /* ya murio */
-      }
-    }
+    statePath = bridgeStatePath();
+  } catch {
+    return null;
+  }
+  const now = Date.now();
+  if (tunnelCache.key === statePath && now - tunnelCache.at < 1000) return tunnelCache.state;
+  let state = null;
+  try {
+    const parsed = JSON.parse(readFileSync(statePath, 'utf8'));
+    if (parsed?.pid && pidAlive(parsed.pid)) state = parsed;
   } catch {
-    /* ya murio */
+    /* sin bridge */
   }
+  tunnelCache = { key: statePath, at: now, state };
+  return state;
+}
+
+/** True si hay un tunel publico activo hacia este server. */
+export function tunnelActive() {
+  return Boolean(tunnelState());
 }
 
 export function parseTunnelmoleUrls(text) {
@@ -74,7 +89,7 @@ function spawnTunnel(bin, args, opts = {}) {
         settled = true;
         clearTimeout(timer);
         log(`${label}: ${url} -> localhost:${opts.port}`);
-        resolve({ url, provider: opts.provider, pid: child.pid, stop: () => killTree(child) });
+        resolve({ url, provider: opts.provider, pid: child.pid, child, stop: () => killTree(child) });
       }
     };
     child.stdout.on('data', feed);
@@ -104,10 +119,156 @@ export function startTunnelmole(port, opts = {}) {
   });
 }
 
+/**
+ * Relay propio (harness.tamnora.com): mailbox HTTP sobre cPanel (solo PHP).
+ * El daemon no recibe conexiones: llama hacia afuera (a=poll), ejecuta cada
+ * request contra el server local y empuja las respuestas (a=push).
+ */
+export function startRelay(port, opts = {}) {
+  const relayUrl = String(opts.relayUrl ?? '').replace(/\/+$/, '');
+  const token = String(opts.token ?? '');
+  if (!relayUrl || !/^https?:\/\//.test(relayUrl)) {
+    throw new Error('relay: falta tunnel.relayUrl (https://harness.tamnora.com/index.php)');
+  }
+  if (!token) throw new Error('relay: falta tunnel.token');
+  const log = opts.log ?? (() => {});
+  const local = `http://127.0.0.1:${port}`;
+  const state = { stopped: false };
+
+  const call = async (action, body = {}, { timeoutMs = 30000 } = {}) => {
+    const res = await fetch(`${relayUrl}?a=${action}`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ token, ...body }),
+      signal: AbortSignal.timeout(timeoutMs),
+    });
+    if (!res.ok) throw new Error(`relay ${action}: HTTP ${res.status}`);
+    return res.json();
+  };
+
+  async function push(rid, chunks) {
+    await call('push', { rid, chunks }, { timeoutMs: 60000 });
+  }
+
+  async function handleRequest(row) {
+    const envelope = typeof row.payload === 'string' ? JSON.parse(row.payload) : row.payload;
+    const method = envelope.method ?? 'GET';
+    const path = String(envelope.path ?? '/');
+    const target = `${local}${path.startsWith('/') ? path : `/${path}`}`;
+    const init = { method, headers: { ...envelope.headers } };
+    delete init.headers.host;
+    if (envelope.body != null) init.body = envelope.body;
+    const res = await fetch(target, init);
+    const contentType = String(res.headers.get('content-type') ?? '');
+    const flat = {};
+    for (const header of ['content-type']) {
+      const value = res.headers.get(header);
+      if (value) flat[header] = value;
+    }
+    const cookies = res.headers.getSetCookie?.() ?? [];
+    if (cookies.length) flat['set-cookie'] = cookies;
+
+    if (!contentType.includes('text/event-stream')) {
+      const buffer = Buffer.from(await res.arrayBuffer());
+      await push(row.id, [
+        {
+          status: res.status,
+          headers: flat,
+          body: buffer.toString('base64'),
+          done: true,
+        },
+      ]);
+      return;
+    }
+
+    // SSE: reenviamos cada frame tal cual (el cliente sabe reconectar con cursor).
+    let seq = 0;
+    await push(row.id, [{ seq: seq++, status: res.status, headers: flat, done: false }]);
+    const reader = res.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = '';
+    for (;;) {
+      const { value, done } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      let index;
+      while ((index = buffer.indexOf('\n\n')) !== -1) {
+        const frame = buffer.slice(0, index);
+        buffer = buffer.slice(index + 2);
+        let ev = '';
+        let data = '';
+        let id = null;
+        for (const line of frame.split('\n')) {
+          if (line.startsWith('event:')) ev = line.slice(6).trim();
+          else if (line.startsWith('data:')) data += line.slice(5).trim();
+          else if (line.startsWith('id:')) id = line.slice(3).trim();
+        }
+        if (!ev && !data) continue;
+        await push(row.id, [{ seq: seq++, ev: ev || 'message', data, id, done: false }]);
+      }
+    }
+    await push(row.id, [{ done: true }]);
+  }
+
+  async function pump() {
+    const registered = await call('register', {}, { timeoutMs: 20000 });
+    let cursor = Number(registered.cursor) || 0;
+    log(`relay: conectado a ${relayUrl} (inbox desde ${cursor})`);
+    while (!state.stopped) {
+      let rows;
+      try {
+        const batch = await call('poll', { after: cursor, wait: 20 }, { timeoutMs: 40000 });
+        rows = batch.rows ?? [];
+      } catch (error) {
+        if (state.stopped) break;
+        log(`relay poll: ${error?.message ?? error}`);
+        await new Promise((r) => setTimeout(r, 3000));
+        continue;
+      }
+      for (const row of rows) {
+        cursor = Math.max(cursor, Number(row.id) || 0);
+        try {
+          await handleRequest(row);
+        } catch (error) {
+          log(`relay request ${row.id}: ${error?.message ?? error}`);
+          try {
+            await push(row.id, [
+              {
+                status: 502,
+                headers: { 'content-type': 'application/json; charset=utf-8' },
+                body: Buffer.from(JSON.stringify({ error: `harness inaccesible: ${error?.message ?? error}` })).toString('base64'),
+                done: true,
+              },
+            ]);
+          } catch {
+            /* nada */
+          }
+        }
+      }
+    }
+  }
+
+  pump().catch((error) => {
+    if (!state.stopped) log(`relay pump: ${error?.message ?? error}`);
+  });
+
+  return {
+    url: relayUrl,
+    provider: 'relay',
+    pid: 0,
+    child: null,
+    probeUrl: `${relayUrl}?a=status`,
+    stop() {
+      state.stopped = true;
+    },
+  };
+}
+
 /** Devuelve { url, provider, pid, stop }. provider 'none' no abre nada. */
 export async function startTunnel(port, provider = 'tunnelmole', opts = {}) {
   const p = String(provider || 'tunnelmole').toLowerCase();
   if (p === 'none' || p === 'off' || p === '') return { url: '', provider: 'none', pid: 0, stop: () => {} };
   if (p === 'tunnelmole' || p === 'tmole') return startTunnelmole(port, opts);
+  if (p === 'relay') return startRelay(port, opts);
   throw new Error(`proveedor de tunel no soportado: ${provider}`);
 }

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

@@ -0,0 +1,19 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { openerFor } from '../src/open.js';
+
+test('usa el abridor nativo de cada plataforma', () => {
+  // En Windows `rundll32` evita el shell: una URL con & o ? no debe pasar por cmd.
+  assert.deepEqual(openerFor('http://127.0.0.1:4517', 'win32'), [
+    'rundll32.exe',
+    ['url.dll,FileProtocolHandler', 'http://127.0.0.1:4517'],
+  ]);
+  assert.deepEqual(openerFor('http://127.0.0.1:4517', 'darwin'), ['open', ['http://127.0.0.1:4517']]);
+  assert.deepEqual(openerFor('http://127.0.0.1:4517', 'linux'), ['xdg-open', ['http://127.0.0.1:4517']]);
+});
+
+test('mantiene la query string intacta', () => {
+  const url = 'http://127.0.0.1:4517/?a=1&b=2';
+  const [, args] = openerFor(url, 'linux');
+  assert.deepEqual(args, [url]);
+});

package/harness/packages/core/test/tools.test.js

@@ -157,3 +157,15 @@ test('bash runs inside the workspace root', async () => {
   assert.match(out, /hola/);
   assert.match(out, /\[exit 0\]/);
 });
+
+test('la tool speak valida el texto y la recorta', async () => {
+  const root = await makeWorkspace();
+  const reg = createToolRegistry({ root });
+  assert.equal(evaluatePermission('speak', {}, {}), 'allow');
+  assert.match(await reg.execute('speak', {}), /falta "texto"/);
+  assert.match(await reg.execute('speak', { texto: 'Hola mundo' }), /Hola mundo/);
+  const largo = await reg.execute('speak', { texto: 'a'.repeat(2000) });
+  assert.ok(largo.length < 2000, 'el texto largo se recorta');
+  const { definitions } = createTools({ root: await makeWorkspace() });
+  assert.ok(definitions.some((d) => d.function.name === 'speak'));
+});

package/harness/packages/core/test/tts.test.js

@@ -0,0 +1,41 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { generarSecMsGec, generarSsml, sintetizar, MAX_TEXTO, VOZ_POR_DEFECTO } from '../src/index.js';
+
+const GEC_1700000000000 = '42301B335578FEFDAE2637DED1ABD614505D432559EC08032B82048483726AFF';
+
+test('generarSecMsGec es estable dentro de la ventana de 5 minutos', () => {
+  assert.equal(generarSecMsGec(1700000000000), GEC_1700000000000);
+  assert.equal(generarSecMsGec(1700000000000 + 59999), GEC_1700000000000);
+  assert.notEqual(generarSecMsGec(1700000000000 + 600000), GEC_1700000000000);
+  assert.match(generarSecMsGec(), /^[0-9A-F]{64}$/);
+});
+
+test('generarSsml escapa el texto y deduce el locale de la voz', () => {
+  const ssml = generarSsml({ voz: VOZ_POR_DEFECTO, rate: '+10%', pitch: '+0Hz', volume: '+0%', texto: 'hola <>&"\' mundo' });
+  assert.ok(ssml.includes('xml:lang="es-AR"'));
+  assert.ok(ssml.includes('<voice name="es-AR-ElenaNeural">'));
+  assert.ok(ssml.includes('rate="+10%"'));
+  assert.ok(!ssml.includes('hola <'));
+  assert.ok(ssml.includes('&lt;&gt;&amp;&quot;&apos;'));
+});
+
+test('generarSsml rechaza voces sin locale deducible', () => {
+  assert.throws(() => generarSsml({ voz: 'Elena', rate: '+0%', pitch: '+0Hz', volume: '+0%', texto: 'x' }), /locale/);
+});
+
+test('sintetizar rechaza texto vacio y señales ya abortadas sin abrir socket', () => {
+  assert.throws(() => sintetizar('   '), /vac/);
+  const controller = new AbortController();
+  controller.abort();
+  assert.throws(() => sintetizar('hola', { signal: controller.signal }), /cancel/);
+});
+
+test('sintetizar recorta el texto al tope del servicio', () => {
+  // El recorte ocurre antes de abrir el socket: con señal ya abortada el error
+  // de cancelacion llega antes que cualquier intento de conexion.
+  const controller = new AbortController();
+  controller.abort();
+  const largo = 'x'.repeat(MAX_TEXTO + 100);
+  assert.throws(() => sintetizar(largo, { signal: controller.signal }), /cancel/);
+});