@danieltmn/tamnora 0.9.1 → 0.9.2

package/harness/packages/server/src/lib/profile.js

@@ -0,0 +1,63 @@
+// Perfil del usuario: datos que el agente conoce de la persona (cómo llamarla,
+// idioma, notas y pares libres). Vive en app.json (la casa) como JSON legible y
+// se inyecta en el system prompt de todas las corridas del server.
+
+export const DEFAULT_PROFILE = {
+  address: '',
+  name: '',
+  language: '',
+  notes: '',
+  fields: {},
+};
+
+const text = (value) => String(value ?? '').trim();
+const clamp = (value, max) => text(value).slice(0, max);
+
+/** Normaliza los pares clave/valor extra (claves y valores no vacíos, acotados). */
+export function sanitizeFields(raw) {
+  if (!raw || typeof raw !== 'object' || Array.isArray(raw)) return {};
+  const out = {};
+  for (const [key, value] of Object.entries(raw)) {
+    const name = clamp(key, 60);
+    if (!name) continue;
+    const val = clamp(value, 500);
+    if (val) out[name] = val;
+  }
+  return out;
+}
+
+/** Merge de defaults + lo guardado en app.json. */
+export function resolveProfile(app) {
+  const saved = app?.profile && typeof app.profile === 'object' ? app.profile : {};
+  return {
+    address: clamp(saved.address, 120),
+    name: clamp(saved.name, 120),
+    language: clamp(saved.language, 60),
+    notes: clamp(saved.notes, 2000),
+    fields: sanitizeFields(saved.fields),
+  };
+}
+
+/** Aplica un body de PUT sobre el perfil actual. */
+export function sanitizeProfile(body, current = DEFAULT_PROFILE) {
+  const value = body && typeof body === 'object' ? body : {};
+  const next = { ...current };
+  if ('address' in value) next.address = clamp(value.address, 120);
+  if ('name' in value) next.name = clamp(value.name, 120);
+  if ('language' in value) next.language = clamp(value.language, 60);
+  if ('notes' in value) next.notes = clamp(value.notes, 2000);
+  if ('fields' in value) next.fields = sanitizeFields(value.fields);
+  return next;
+}
+
+/** Bloque de system prompt con lo que el agente sabe del usuario ('' si vacío). */
+export function profilePrompt(profile) {
+  const lines = [];
+  if (profile.address) lines.push(`- Dirigite a la persona como: "${profile.address}".`);
+  if (profile.name) lines.push(`- Nombre: ${profile.name}.`);
+  if (profile.language) lines.push(`- Idioma preferido: ${profile.language}.`);
+  if (profile.notes) lines.push(`- Notas: ${profile.notes}`);
+  for (const [key, value] of Object.entries(profile.fields)) lines.push(`- ${key}: ${value}`);
+  if (!lines.length) return '';
+  return `## Sobre el usuario\n${lines.join('\n')}`;
+}

package/harness/packages/server/src/lib/prompt.js

@@ -31,9 +31,10 @@ function workspacePreamble(cwd) {
  * @param {object} opts
  * @param {string} opts.cwd - server default workspace
  * @param {string[]} opts.files - instruction file names (e.g. ['AGENTS.md'])
+ * @param {() => string} [opts.profileText] - user profile block, re-read on every call
  * @param {() => string} [opts.skillsText] - skills block, re-read on every call
  */
-export function createPromptBuilder({ cwd, files, skillsText }) {
+export function createPromptBuilder({ cwd, files, profileText, skillsText }) {
   const cache = new Map();
 
   async function buildFor(workspace) {
@@ -46,7 +47,11 @@ export function createPromptBuilder({ cwd, files, skillsText }) {
     const key = workspace || cwd;
     if (!cache.has(key)) cache.set(key, buildFor(key));
     const base = await cache.get(key);
+    const parts = [base];
+    const profile = typeof profileText === 'function' ? String(profileText() ?? '').trim() : '';
+    if (profile) parts.push(profile);
     const extra = typeof skillsText === 'function' ? String(skillsText() ?? '').trim() : '';
-    return extra ? `${base}\n\n---\n\n${extra}` : base;
+    if (extra) parts.push(extra);
+    return parts.join('\n\n---\n\n');
   };
 }

package/harness/packages/server/src/lib/transcribe.js

@@ -0,0 +1,51 @@
+// Transcripcion de audio a texto, compartida por Telegram (notas de voz) y la
+// consola (microfono en el input). Usa el endpoint OpenAI-compatible
+// `/audio/transcriptions` del proveedor (OpenAI, Groq, ...).
+
+export const DEFAULT_TRANSCRIBE_MODEL = 'whisper-1';
+
+/** Detalle legible del error del proveedor (OpenAI/Groq devuelven `{error:{message}}`). */
+async function providerError(res) {
+  const body = await res.text().catch(() => '');
+  try {
+    const json = JSON.parse(body);
+    return json?.error?.message || json?.error || json?.message || body;
+  } catch {
+    return body;
+  }
+}
+
+export async function transcribeAudio(
+  ctx,
+  { buffer, filename = 'audio.webm', mime = '', providerId, model, language } = {}
+) {
+  const id = providerId || ctx.effectiveProviderId();
+  const settings = { ...(ctx.providerSettings(id) ?? {}), apiKey: ctx.apiKeyFor(id) };
+  // `providerSettings` no trae el baseUrl de los proveedores builtin (lo resuelve
+  // el runtime), asi que resolvemos como lo hace el agente.
+  const resolved = ctx.resolveProvider?.(settings)?.config ?? {};
+  const baseUrl = String(settings.baseUrl || resolved.baseUrl || '').replace(/\/+$/, '');
+  const apiKey = settings.apiKey || resolved.apiKey || '';
+  if (!baseUrl) throw new Error(`el proveedor "${id}" no tiene baseUrl para transcribir`);
+  const form = new FormData();
+  form.append('file', new Blob([buffer], mime ? { type: mime } : undefined), filename);
+  form.append('model', model || DEFAULT_TRANSCRIBE_MODEL);
+  // Whisper espera ISO-639-1 (`es`, no `es-AR`): sin esto autodetecta y en clips
+  // cortos se confunde de idioma.
+  const idioma = String(language ?? '').trim().split(/[-_]/)[0].toLowerCase();
+  if (/^[a-z]{2}$/.test(idioma)) form.append('language', idioma);
+  const res = await fetch(`${baseUrl}/audio/transcriptions`, {
+    method: 'POST',
+    headers: apiKey ? { Authorization: `Bearer ${apiKey}` } : {},
+    body: form,
+  });
+  if (!res.ok) {
+    const detail = String((await providerError(res)) ?? '').replace(/\s+/g, ' ').trim().slice(0, 200);
+    const hint = res.status === 404 ? ` — "${id}" no expone /audio/transcriptions` : '';
+    throw new Error(
+      `transcripción falló (HTTP ${res.status})${hint}${detail ? `: ${detail}` : ''}`
+    );
+  }
+  const data = await res.json();
+  return String(data.text ?? '').trim();
+}

package/harness/packages/server/src/routes/channels.js

@@ -3,6 +3,7 @@
 
 import { readApp, writeApp } from '../lib/core.js';
 import { getTelegramBotInfo } from '../lib/channels/telegram.js';
+import { sanitizeNotify } from '../lib/channels/index.js';
 import { readJson, sendJson } from '../lib/http.js';
 
 function sanitizeAllowed(value) {
@@ -31,6 +32,7 @@ export function registerChannels(route, ctx) {
     if ('allowedChatIds' in body) next.allowedChatIds = sanitizeAllowed(body.allowedChatIds);
     if ('transcribeModel' in body) next.transcribeModel = String(body.transcribeModel ?? '').trim() || 'whisper-1';
     if ('transcribeProvider' in body) next.transcribeProvider = String(body.transcribeProvider ?? '').trim();
+    if ('notify' in body) next.notify = sanitizeNotify(body.notify);
 
     app.telegram = next;
     writeApp(app);

package/harness/packages/server/src/routes/presence.js

@@ -0,0 +1,17 @@
+// Reporte de pestañas abiertas de la consola. No hay estado que devolver: el
+// cliente manda su lista (latido) y las que cerró, y el server lo recuerda
+// mientras no venzan.
+
+import { readJson, sendJson } from '../lib/http.js';
+
+const toIds = (value) =>
+  Array.isArray(value) ? value.map((v) => String(v).trim()).filter(Boolean) : [];
+
+export function registerPresence(route, ctx) {
+  route('POST', '/api/presence', async ({ req, res }) => {
+    const body = await readJson(req).catch(() => ({}));
+    ctx.presence?.close?.(toIds(body.closed));
+    ctx.presence?.touch?.(toIds(body.sessions));
+    sendJson(res, 200, { ok: true });
+  });
+}

package/harness/packages/server/src/routes/profile.js

@@ -0,0 +1,22 @@
+// Perfil del usuario (app.json -> profile). El agente lo lee en cada corrida, así
+// que un cambio aplica sin recargar nada.
+
+import { readApp, writeApp } from '../lib/core.js';
+import { resolveProfile, sanitizeProfile } from '../lib/profile.js';
+import { readJson, sendJson } from '../lib/http.js';
+
+export function registerProfile(route, ctx) {
+  route('GET', '/api/profile', ({ res }) => {
+    sendJson(res, 200, { profile: resolveProfile(ctx.app) });
+  });
+
+  route('PUT', '/api/profile', async ({ req, res }) => {
+    const body = await readJson(req);
+    const app = readApp();
+    const next = sanitizeProfile(body, resolveProfile(ctx.app));
+    app.profile = next;
+    writeApp(app);
+    ctx.app = app;
+    sendJson(res, 200, { profile: next });
+  });
+}

package/harness/packages/server/src/routes/providers.js

@@ -75,6 +75,7 @@ export function registerProviders(route, ctx) {
     maxRounds: ctx.effectiveMaxRounds(),
     maxTokens: ctx.effectiveMaxTokens(),
     maxDurationMs: ctx.effectiveMaxDurationMs(),
+    defaultCwd: ctx.store.getSetting('defaultCwd') || '',
   });
 
   route('GET', '/api/settings', ({ res }) => {
@@ -86,6 +87,7 @@ export function registerProviders(route, ctx) {
     if (body.provider !== undefined) ctx.store.setSetting('activeProvider', String(body.provider) || null);
     if (body.model !== undefined) ctx.store.setSetting('activeModel', String(body.model) || null);
     if (body.mode !== undefined) ctx.store.setSetting('activeMode', resolveMode(String(body.mode)).id);
+    if (body.defaultCwd !== undefined) ctx.store.setSetting('defaultCwd', String(body.defaultCwd ?? '').trim() || null);
     for (const key of ['maxRounds', 'maxTokens', 'maxDurationMs']) {
       if (body[key] === undefined) continue;
       const value = Number(body[key]);

package/harness/packages/server/src/routes/transcribe.js

@@ -0,0 +1,115 @@
+// Transcripcion bajo demanda para la consola (dictado del input) + sus ajustes.
+// El microfono graba, manda el audio como data URL y recibe el texto. Comparte el
+// mismo helper que las notas de voz de Telegram.
+//
+// El proveedor activo no siempre sabe transcribir (p.ej. DeepSeek), por eso hay
+// un proveedor/modelo de transcripcion propio: `app.json` -> `transcribe`, con
+// fallback a lo configurado en Telegram y recien despues al proveedor activo.
+
+import { readApp, writeApp, reconocerGoogle } from '../lib/core.js';
+import { transcribeAudio } from '../lib/transcribe.js';
+import { readJson, sendJson, sendError } from '../lib/http.js';
+
+const MODES = new Set(['server', 'google', 'browser']);
+
+// El tipo puede traer parámetros (`audio/webm;codecs=opus`): el grupo 1 es el
+// MIME (sin coma) y el grupo 2 el base64.
+const DATA_URL = /^data:([^,]+);base64,(.+)$/s;
+
+const EXT_POR_MIME = [
+  ['wav', 'wav'],
+  ['ogg', 'ogg'],
+  ['opus', 'ogg'],
+  ['mp4', 'm4a'],
+  ['m4a', 'm4a'],
+  ['mpeg', 'mp3'],
+  ['mp3', 'mp3'],
+  ['flac', 'flac'],
+  ['webm', 'webm'],
+];
+
+/** Extension coherente con el MIME para que el proveedor detecte el formato. */
+function filenameFor(mime) {
+  const base = String(mime || '').toLowerCase();
+  const found = EXT_POR_MIME.find(([needle]) => base.includes(needle));
+  return `audio.${found ? found[1] : 'webm'}`;
+}
+
+/** Proveedor/modelo efectivos: ajuste propio -> Telegram -> proveedor activo. */
+export function resolveTranscribe(app = {}, override = {}) {
+  const saved = app.transcribe && typeof app.transcribe === 'object' ? app.transcribe : {};
+  const telegram = app.telegram && typeof app.telegram === 'object' ? app.telegram : {};
+  return {
+    provider:
+      String(override.provider ?? '').trim() || saved.provider || telegram.transcribeProvider || undefined,
+    model: String(override.model ?? '').trim() || saved.model || telegram.transcribeModel || undefined,
+  };
+}
+
+function settingsView(app) {
+  const saved = app.transcribe && typeof app.transcribe === 'object' ? app.transcribe : {};
+  const telegram = app.telegram && typeof app.telegram === 'object' ? app.telegram : {};
+  return {
+    // `server` usa el proveedor de abajo; `google` usa el servicio de voz de
+    // Chromium (sin API key, en el server); `browser` usa la transcripción nativa
+    // del navegador (Web Speech API), sin pasar por el server.
+    mode: MODES.has(saved.mode) ? saved.mode : 'server',
+    language: String(saved.language ?? 'es-AR'),
+    provider: String(saved.provider ?? ''),
+    model: String(saved.model ?? ''),
+    fallback: {
+      provider: String(telegram.transcribeProvider ?? ''),
+      model: String(telegram.transcribeModel ?? ''),
+    },
+  };
+}
+
+export function registerTranscribe(route, ctx) {
+  route('GET', '/api/transcribe/settings', ({ res }) => {
+    sendJson(res, 200, settingsView(ctx.app));
+  });
+
+  route('PUT', '/api/transcribe/settings', async ({ req, res }) => {
+    const body = await readJson(req);
+    const app = readApp();
+    const next = { ...(app.transcribe ?? {}) };
+    if ('mode' in body) next.mode = MODES.has(body.mode) ? body.mode : 'server';
+    if ('language' in body) next.language = String(body.language ?? '').trim() || 'es-AR';
+    if ('provider' in body) next.provider = String(body.provider ?? '').trim();
+    if ('model' in body) next.model = String(body.model ?? '').trim();
+    app.transcribe = next;
+    writeApp(app);
+    ctx.app = app;
+    sendJson(res, 200, settingsView(app));
+  });
+
+  route('POST', '/api/transcribe', async ({ req, res }) => {
+    const body = await readJson(req, { limit: 25 * 1024 * 1024 });
+    const match = DATA_URL.exec(String(body.audio ?? ''));
+    if (!match) return sendError(res, 400, 'Falta el audio (data URL base64).');
+    const mime = match[1].split(';')[0].trim();
+    const buffer = Buffer.from(match[2], 'base64');
+    if (!buffer.length) return sendError(res, 400, 'El audio está vacío.');
+    const { provider, model } = resolveTranscribe(ctx.app, body);
+    const language = String(body.language ?? '').trim() || ctx.app?.transcribe?.language || 'es-AR';
+    const mode = String(body.engine ?? '').trim() || (MODES.has(ctx.app?.transcribe?.mode) ? ctx.app.transcribe.mode : 'server');
+    try {
+      const text =
+        mode === 'google'
+          ? await reconocerGoogle(buffer, { lang: language })
+          : await transcribeAudio(ctx, {
+              buffer,
+              mime,
+              filename: filenameFor(mime),
+              providerId: provider,
+              model,
+              language,
+            });
+      if (!text) return sendError(res, 422, 'No se pudo transcribir el audio.');
+      sendJson(res, 200, { text });
+    } catch (error) {
+      console.error(`[transcribe] ${error?.message ?? error}`);
+      sendError(res, 502, error?.message ?? String(error));
+    }
+  });
+}

package/harness/packages/server/src/routes/tts.js

@@ -52,7 +52,8 @@ export function registerTts(route, ctx) {
   });
 
   route('GET', '/api/tts/voices', async ({ res, query }) => {
-    const filtro = /^[a-zA-Z]{2}-?$/.test(String(query.get('filter') ?? 'es-')) ? query.get('filter') : 'es-';
+    const pedido = String(query.get('filter') ?? 'es-').trim() || 'es-';
+    const filtro = /^[a-zA-Z]{2}-?$/.test(pedido) ? pedido : 'es-';
     try {
       const voces = await catalogoVoces(filtro);
       sendJson(res, 200, { voices: voces });

package/harness/packages/server/src/server.js

@@ -16,8 +16,10 @@ import {
 } from './lib/core.js';
 import { sendJson, sendError } from './lib/http.js';
 import { createPromptBuilder, DEFAULT_SYSTEM_PROMPT } from './lib/prompt.js';
+import { profilePrompt, resolveProfile } from './lib/profile.js';
 import { skillsPrompt } from './lib/skills.js';
 import { createApprovalBroker } from './lib/approvals.js';
+import { createPresence } from './lib/presence.js';
 import { createRunManager } from './lib/runManager.js';
 import { createProcManager } from './lib/procs.js';
 import { createChannelsManager } from './lib/channels/index.js';
@@ -34,13 +36,16 @@ import { registerProviders } from './routes/providers.js';
 import { registerMcp } from './routes/mcp.js';
 import { registerSkills } from './routes/skills.js';
 import { registerChannels } from './routes/channels.js';
+import { registerProfile } from './routes/profile.js';
 import { registerTts } from './routes/tts.js';
+import { registerTranscribe } from './routes/transcribe.js';
 import { registerProcs } from './routes/procs.js';
 import { registerShell } from './routes/shell.js';
 import { registerPreview } from './routes/preview.js';
 import { registerChat } from './routes/chat.js';
 import { registerEvents } from './routes/events.js';
 import { registerState } from './routes/state.js';
+import { registerPresence } from './routes/presence.js';
 import { registerEval } from './routes/eval.js';
 
 const VERSION = readPackageVersion();
@@ -78,6 +83,7 @@ export async function createTamnoraServer({
   const authEnabled = Boolean(app.user && app.user.password);
   const store = new Store(dbPath ?? databasePath(cwd));
   const approvals = createApprovalBroker({ timeoutMs: config.approvalTimeoutMs });
+  const presence = createPresence();
   const runs = createRunManager({ store });
   const procs = createProcManager({ allow: config.processes?.allow });
   const procsEnabled = config.processes?.enabled !== false;
@@ -160,6 +166,7 @@ export async function createTamnoraServer({
     authEnabled,
     store,
     approvals,
+    presence,
     runs,
     isAutoApprove,
     setAutoApprove,
@@ -184,6 +191,7 @@ export async function createTamnoraServer({
   ctx.systemPromptFor = createPromptBuilder({
     cwd,
     files: config.instructions,
+    profileText: () => profilePrompt(resolveProfile(ctx.app)),
     skillsText: () => skillsPrompt(ctx),
   });
   ctx.systemPrompt = (await ctx.systemPromptFor(cwd)) || DEFAULT_SYSTEM_PROMPT;
@@ -223,13 +231,16 @@ export async function createTamnoraServer({
   registerMcp(route, ctx);
   registerSkills(route, ctx);
   registerChannels(route, ctx);
+  registerProfile(route, ctx);
   registerTts(route, ctx);
+  registerTranscribe(route, ctx);
   registerProcs(route, ctx);
   registerShell(route, ctx);
   const preview = registerPreview(route, ctx);
   registerChat(route, ctx);
   registerEvents(route, ctx);
   registerState(route, ctx);
+  registerPresence(route, ctx);
   registerEval(route, ctx);
 
   function matchRoute(method, pathname) {

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

@@ -0,0 +1,85 @@
+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, readApp } from '../../core/src/index.js';
+import { resolveProfile, sanitizeProfile, profilePrompt } from '../src/lib/profile.js';
+
+const fakeProvider = {
+  id: 'fake',
+  async streamChat(_config, { onEvent }) {
+    onEvent?.({ type: 'text', delta: 'hola', full: 'hola' });
+    return { content: 'hola', reasoning: '', toolCalls: [] };
+  },
+};
+
+async function startServer(overrides = {}) {
+  const cwd = overrides.cwd ?? (await mkdtemp(path.join(tmpdir(), 'tamnora-prof-')));
+  setHome(cwd);
+  const instance = await createTamnoraServer({
+    cwd,
+    dbPath: path.join(cwd, 'tamnora.db'),
+    loadMcp: false,
+    resolveProvider: () => ({ provider: fakeProvider, config: {} }),
+    ...overrides,
+  });
+  const info = await instance.listen({ port: 0 });
+  return { instance, base: info.url, cwd };
+}
+
+test('resolveProfile y sanitizeProfile normalizan los datos', () => {
+  assert.deepEqual(resolveProfile({}), { address: '', name: '', language: '', notes: '', fields: {} });
+  const next = sanitizeProfile({
+    address: '  Amo  ',
+    name: 'Daniel',
+    language: 'es',
+    notes: '  corto y al pie  ',
+    fields: { 'zona horaria': 'CET', vacio: '', '  ': 'x' },
+  });
+  assert.equal(next.address, 'Amo');
+  assert.equal(next.notes, 'corto y al pie');
+  assert.deepEqual(next.fields, { 'zona horaria': 'CET' });
+});
+
+test('profilePrompt arma el bloque solo con lo que hay', () => {
+  assert.equal(profilePrompt(resolveProfile({})), '');
+  const block = profilePrompt({ address: 'Señor', name: 'Daniel', language: '', notes: 'Preferí respuestas cortas.', fields: { Empresa: 'Tamnora' } });
+  assert.match(block, /## Sobre el usuario/);
+  assert.match(block, /como: "Señor"/);
+  assert.match(block, /Nombre: Daniel/);
+  assert.match(block, /Notas: Preferí respuestas cortas\./);
+  assert.match(block, /Empresa: Tamnora/);
+  assert.ok(!block.includes('Idioma preferido'));
+});
+
+test('el perfil se guarda en app.json y se inyecta en el system prompt', async () => {
+  const { instance, base, cwd } = await startServer();
+  try {
+    const initial = await (await fetch(`${base}/api/profile`)).json();
+    assert.equal(initial.profile.address, '');
+
+    const put = await fetch(`${base}/api/profile`, {
+      method: 'PUT',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ address: 'Compañero', name: 'Daniel', language: 'es', fields: { ciudad: 'Rosario' } }),
+    });
+    assert.equal(put.status, 200);
+    const saved = (await put.json()).profile;
+    assert.equal(saved.address, 'Compañero');
+
+    // Persistido en la casa (app.json), no solo en memoria.
+    assert.equal(readApp().profile.address, 'Compañero');
+
+    const prompt = await instance.ctx.systemPromptFor(cwd);
+    assert.match(prompt, /## Sobre el usuario/);
+    assert.match(prompt, /como: "Compañero"/);
+    assert.match(prompt, /ciudad: Rosario/);
+
+    const reloaded = await (await fetch(`${base}/api/profile`)).json();
+    assert.equal(reloaded.profile.fields.ciudad, 'Rosario');
+  } finally {
+    await instance.close();
+  }
+});