@danieltmn/tamnora 0.7.1 → 0.9.0

package/harness/packages/server/test/telegram-voz.test.js

@@ -0,0 +1,156 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtemp } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { Store } from '../../core/src/index.js';
+import { createApprovalBroker } from '../src/lib/approvals.js';
+import { startTelegramChannel } from '../src/lib/channels/telegram.js';
+
+const reply = (data) => ({ ok: true, json: async () => data });
+
+const FAKE_FRAME = new TextEncoder().encode('Path:audio\r\nFFF364MP3').buffer;
+
+/** WebSocket falso: entrega un frame de audio y cierra con turn.end. */
+class FakeWebSocket {
+  constructor() {
+    this.listeners = new Map();
+    this.binaryType = 'arraybuffer';
+    setTimeout(() => {
+      this.fire('open', {});
+      this.fire('message', FAKE_FRAME);
+      this.fire('message', 'X-RequestId:1\r\nPath:turn.end\r\n');
+    }, 0);
+  }
+  addEventListener(type, fn) {
+    if (!this.listeners.has(type)) this.listeners.set(type, new Set());
+    this.listeners.get(type).add(fn);
+  }
+  removeEventListener() {}
+  send() {}
+  close() {
+    this.fire('close', {});
+  }
+  fire(type, arg) {
+    for (const fn of this.listeners.get(type) ?? []) fn({ data: arg, message: 'fake' });
+  }
+}
+
+/** Mock de fetch que registra los envios multipart (sendVoice/sendAudio). */
+function installVozFetchMock() {
+  const sent = [];
+  const multipart = [];
+  const updates = [];
+  const original = global.fetch;
+  global.fetch = async (url, opts = {}) => {
+    const method = String(url).split('/').pop();
+    if (opts.body instanceof FormData) {
+      multipart.push({ method, chatId: String(opts.body.get('chat_id') ?? '') });
+      return reply({ ok: true, result: true });
+    }
+    const body = opts.body ? JSON.parse(opts.body) : {};
+    if (method === 'getUpdates') {
+      const out = updates.splice(0, updates.length);
+      if (!out.length) await new Promise((resolve) => setTimeout(resolve, 20));
+      return reply({ ok: true, result: out });
+    }
+    if (method === 'sendMessage' || method === 'editMessageText') {
+      sent.push(body);
+      return reply({ ok: true, result: { message_id: sent.length } });
+    }
+    return reply({ ok: true, result: true });
+  };
+  return { sent, updates, multipart, restore: () => { global.fetch = original; } };
+}
+
+function makeCtx(cwd, app = {}) {
+  const store = new Store(':memory:');
+  const provider = {
+    id: 'fake',
+    async streamChat(_config, { onEvent }) {
+      onEvent?.({ type: 'text', delta: 'listo', full: 'listo' });
+      return { content: 'listo', reasoning: '', toolCalls: [] };
+    },
+  };
+  return {
+    cwd,
+    config: { maxRounds: 2, permissions: {}, telegram: {} },
+    app,
+    store,
+    approvals: createApprovalBroker({ timeoutMs: 1000 }),
+    effectiveProviderId: () => 'fake',
+    effectiveModel: () => 'm',
+    effectiveMode: () => 'agent',
+    providerSettings: () => ({ baseUrl: 'http://127.0.0.1:1', apiKey: '' }),
+    apiKeyFor: () => '',
+    customProviderDefs: () => [],
+    resolveProvider: () => ({ provider, config: {} }),
+    getMcp: async () => null,
+    systemPromptFor: async () => 'sys',
+    agentTools: { definitions: [], handles: () => false, execute: async () => '' },
+  };
+}
+
+async function waitFor(fn, timeout = 3000) {
+  const start = Date.now();
+  while (Date.now() - start < timeout) {
+    if (fn()) return;
+    await new Promise((resolve) => setTimeout(resolve, 10));
+  }
+  throw new Error('timeout esperando la condición');
+}
+
+test('con la voz activada, el turno de Telegram termina con una nota de voz', async () => {
+  const cwd = await mkdtemp(path.join(tmpdir(), 'tamnora-tgvoz-'));
+  const ctx = makeCtx(cwd, { tts: { enabled: true, voice: 'es-AR-ElenaNeural', rate: '+0%', announce: { end: true } } });
+  const mock = installVozFetchMock();
+  const original = global.WebSocket;
+  global.WebSocket = FakeWebSocket;
+  const channel = startTelegramChannel(ctx, { token: 'x', allowedChatIds: ['7'], log: () => {} });
+  try {
+    mock.updates.push({ update_id: 1, message: { chat: { id: 7 }, text: 'hola' } });
+    await waitFor(() => mock.multipart.length > 0);
+    const nota = mock.multipart[0];
+    assert.equal(nota.chatId, '7');
+    assert.match(nota.method, /^send(Voice|Audio)$/);
+  } finally {
+    global.WebSocket = original;
+    channel.stop();
+    mock.restore();
+  }
+});
+
+test('con la voz apagada, el turno de Telegram termina sin audios', async () => {
+  const cwd = await mkdtemp(path.join(tmpdir(), 'tamnora-tgvoz-'));
+  const ctx = makeCtx(cwd, {});
+  const mock = installVozFetchMock();
+  const channel = startTelegramChannel(ctx, { token: 'x', allowedChatIds: ['7'], log: () => {} });
+  try {
+    mock.updates.push({ update_id: 1, message: { chat: { id: 7 }, text: 'hola' } });
+    await waitFor(() => mock.sent.some((m) => /✓ terminado/.test(m.text ?? '')));
+    assert.equal(mock.multipart.length, 0);
+  } finally {
+    channel.stop();
+    mock.restore();
+  }
+});
+
+test('la tool speak manda una nota de voz aunque la narración esté apagada', async () => {
+  const cwd = await mkdtemp(path.join(tmpdir(), 'tamnora-tgspeak-'));
+  const ctx = makeCtx(cwd, {});
+  const mock = installVozFetchMock();
+  const original = global.WebSocket;
+  global.WebSocket = FakeWebSocket;
+  const channel = startTelegramChannel(ctx, { token: 'x', allowedChatIds: ['7'], log: () => {} });
+  try {
+    ctx.store.setSetting('telegram:session:sess-1', '7');
+    channel.notify('sess-1', { type: 'tool_call', data: { name: 'speak', args: { texto: 'Hola, esto es una prueba' } } });
+    await waitFor(() => mock.multipart.length > 0);
+    assert.equal(mock.multipart[0].chatId, '7');
+    assert.match(mock.multipart[0].method, /^send(Voice|Audio)$/);
+  } finally {
+    global.WebSocket = original;
+    channel.stop();
+    mock.restore();
+  }
+});

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

@@ -0,0 +1,133 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtemp } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { createTamnoraServer } from '../src/index.js';
+import { setHome } from '../../core/src/index.js';
+
+const FAKE_MP3 = 'FFF364MP3DEPRUEBA';
+
+/** Frame binario exacto (sin el pool de Buffer, que arrastra bytes ajenos). */
+const FAKE_FRAME = new TextEncoder().encode(`Path:audio\r\n${FAKE_MP3}`).buffer;
+
+/** WebSocket falso: entrega un frame de audio y cierra con turn.end. */
+class FakeWebSocket {
+  constructor() {
+    this.listeners = new Map();
+    this.binaryType = 'arraybuffer';
+    setTimeout(() => {
+      this.fire('open', {});
+      this.fire('message', FAKE_FRAME);
+      this.fire('message', 'X-RequestId:1\r\nPath:turn.end\r\n');
+    }, 0);
+  }
+  addEventListener(type, fn) {
+    if (!this.listeners.has(type)) this.listeners.set(type, new Set());
+    this.listeners.get(type).add(fn);
+  }
+  removeEventListener() {}
+  send() {}
+  close() {
+    this.fire('close', {});
+  }
+  fire(type, arg) {
+    for (const fn of this.listeners.get(type) ?? []) fn({ data: arg, message: 'fake' });
+  }
+}
+
+/** WebSocket falso que falla: para probar el 502 de la ruta. */
+class BrokenWebSocket {
+  constructor() {
+    this.listeners = new Map();
+    setTimeout(() => this.fire('error', {}), 0);
+  }
+  addEventListener(type, fn) {
+    if (!this.listeners.has(type)) this.listeners.set(type, new Set());
+    this.listeners.get(type).add(fn);
+  }
+  removeEventListener() {}
+  send() {}
+  close() {}
+  fire(type, arg) {
+    for (const fn of this.listeners.get(type) ?? []) fn({ data: arg, message: 'boom' });
+  }
+}
+
+async function startServer() {
+  const cwd = await mkdtemp(path.join(tmpdir(), 'tamnora-tts-'));
+  setHome(cwd);
+  const instance = await createTamnoraServer({
+    cwd,
+    dbPath: path.join(cwd, 'tamnora.db'),
+    loadMcp: false,
+    resolveProvider: () => ({ provider: { id: 'fake' }, config: {} }),
+  });
+  const info = await instance.listen({ port: 0 });
+  return { instance, base: info.url };
+}
+
+test('los ajustes de voz exponen defaults y sanitizan lo guardado', async () => {
+  const { instance, base } = await startServer();
+  const original = global.WebSocket;
+  global.WebSocket = FakeWebSocket;
+  try {
+    const initial = await (await fetch(`${base}/api/tts/settings`)).json();
+    assert.equal(initial.enabled, false);
+    assert.equal(initial.voice, 'es-AR-ElenaNeural');
+    assert.equal(initial.announce.start, true);
+    assert.equal(initial.announce.tools, true);
+    assert.equal(initial.announce.end, true);
+
+    const put = await fetch(`${base}/api/tts/settings`, {
+      method: 'PUT',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ enabled: true, voice: '<script>', rate: '150%' }),
+    });
+    const saved = await put.json();
+    assert.equal(saved.enabled, true);
+    assert.equal(saved.voice, 'es-AR-ElenaNeural');
+    assert.equal(saved.rate, '+100%');
+
+    const reread = await (await fetch(`${base}/api/tts/settings`)).json();
+    assert.equal(reread.enabled, true);
+    assert.equal(reread.rate, '+100%');
+  } finally {
+    global.WebSocket = original;
+    await instance.close();
+  }
+});
+
+test('la sintesis exige texto y entrega MP3', async () => {
+  const { instance, base } = await startServer();
+  const original = global.WebSocket;
+  global.WebSocket = FakeWebSocket;
+  try {
+    const falta = await fetch(`${base}/api/tts`);
+    assert.equal(falta.status, 400);
+
+    const res = await fetch(`${base}/api/tts?texto=${encodeURIComponent('hola')}`);
+    assert.equal(res.status, 200);
+    assert.equal(res.headers.get('content-type'), 'audio/mpeg');
+    const body = Buffer.from(await res.arrayBuffer());
+    assert.equal(body.toString('utf8'), FAKE_MP3);
+  } finally {
+    global.WebSocket = original;
+    await instance.close();
+  }
+});
+
+test('un fallo del servicio de voz se ve como 502, no como crash', async () => {
+  const { instance, base } = await startServer();
+  const original = global.WebSocket;
+  global.WebSocket = BrokenWebSocket;
+  try {
+    const res = await fetch(`${base}/api/tts?texto=${encodeURIComponent('hola')}`);
+    assert.equal(res.status, 502);
+    const data = await res.json();
+    assert.match(data.error, /No pude sintetizar/);
+  } finally {
+    global.WebSocket = original;
+    await instance.close();
+  }
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danieltmn/tamnora",
-  "version": "0.7.1",
+  "version": "0.9.0",
   "description": "Harness local para IAs: agente CLI-first con TUI, consola web y evaluacion. Node puro, sin dependencias.",
   "type": "module",
   "packageManager": "pnpm@11.25.0",