@danieltmn/tamnora 0.5.1 → 0.6.0

package/harness/packages/server/public/styles.css

@@ -427,8 +427,38 @@ body.resizing * { cursor: col-resize !important; }
 .msg-actions button.msg-act.danger:hover { color: var(--danger); border-color: var(--danger); }
 .bubble .tools { margin-top: 10px; display: flex; flex-direction: column; gap: 6px; }
 
+.tools-actions { display: flex; align-items: center; gap: 8px; }
+.tools-actions[hidden] { display: none; }
+.tools-count { color: var(--muted); font-size: 12px; }
+.tools-toggle {
+  background: none;
+  border: none;
+  color: var(--accent);
+  cursor: pointer;
+  font: 600 12px var(--sans);
+  padding: 2px 0;
+}
+.tools-toggle:hover { text-decoration: underline; }
+
 .tool-card { font-size: 12.5px; border-left: 2px solid var(--border); padding-left: 10px; min-width: 0; }
-.tool-card .tool-head { display: flex; gap: 8px; align-items: baseline; min-width: 0; }
+.tool-card > .tool-head {
+  display: flex;
+  gap: 8px;
+  align-items: baseline;
+  min-width: 0;
+  cursor: pointer;
+  list-style: none;
+  touch-action: manipulation;
+}
+.tool-card > .tool-head::-webkit-details-marker { display: none; }
+.tool-card > .tool-head::before {
+  content: '▸';
+  color: var(--muted);
+  flex: 0 0 auto;
+  font-size: 10px;
+  transition: transform 0.12s ease;
+}
+.tool-card[open] > .tool-head::before { transform: rotate(90deg); }
 .tool-card .tool-glyph { color: var(--muted); flex: 0 0 auto; }
 .tool-card.running .tool-glyph { color: var(--accent); animation: pulse 1s steps(2, start) infinite; }
 .tool-card.done .tool-glyph { color: var(--ok); }
@@ -442,17 +472,78 @@ body.resizing * { cursor: col-resize !important; }
   text-overflow: ellipsis;
   white-space: nowrap;
 }
-.tool-card .tool-out {
+.tool-card > .tool-out {
   color: var(--muted);
   margin: 4px 0 2px 18px;
   padding-left: 10px;
   border-left: 1px solid var(--border);
   white-space: pre-wrap;
   word-break: break-word;
-  max-height: 260px;
+  max-height: 320px;
   overflow: auto;
 }
-.tool-card .tool-out:empty { display: none; }
+.tool-card > .tool-out:empty { display: none; }
+.tool-more {
+  display: inline-block;
+  margin: 2px 0 2px 18px;
+  background: none;
+  border: none;
+  color: var(--accent);
+  cursor: pointer;
+  font: 600 12px var(--sans);
+  padding: 0;
+}
+.tool-more[hidden] { display: none; }
+.tool-more:hover { text-decoration: underline; }
+
+.agent-card {
+  border: 1px solid var(--border);
+  border-radius: 7px;
+  padding: 6px 9px;
+  background: color-mix(in srgb, var(--accent) 4%, transparent);
+  min-width: 0;
+}
+.agent-card > .agent-head {
+  display: flex;
+  gap: 7px;
+  align-items: baseline;
+  cursor: pointer;
+  list-style: none;
+  touch-action: manipulation;
+}
+.agent-card > .agent-head::-webkit-details-marker { display: none; }
+.agent-card > .agent-head::before {
+  content: '▸';
+  color: var(--muted);
+  font-size: 10px;
+  transition: transform 0.12s ease;
+}
+.agent-card[open] > .agent-head::before { transform: rotate(90deg); }
+.agent-card .agent-glyph { color: var(--accent); flex: 0 0 auto; }
+.agent-card.running .agent-glyph { animation: pulse 1s steps(2, start) infinite; }
+.agent-card.done .agent-glyph { color: var(--ok); }
+.agent-card.failed .agent-glyph { color: var(--danger); }
+.agent-card .agent-title {
+  color: var(--text);
+  font-weight: 700;
+  flex: 1 1 auto;
+  min-width: 0;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+.agent-card .agent-status { color: var(--muted); font-size: 11px; flex: 0 0 auto; }
+.agent-card > .agent-body {
+  margin: 6px 0 2px 16px;
+  border-left: 1px solid var(--border);
+  padding-left: 10px;
+  display: flex;
+  flex-direction: column;
+  gap: 6px;
+}
+.agent-card .agent-text:empty { display: none; }
+.agent-card .agent-tools { display: flex; flex-direction: column; gap: 6px; }
+.agent-card .agent-tools:empty { display: none; }
 .tool-out .diff-line { display: block; }
 .tool-out .diff-add { color: var(--ok); }
 .tool-out .diff-del { color: var(--danger); }

package/harness/packages/server/src/lib/channels/index.js

@@ -0,0 +1,43 @@
+// Capa de canales de mensajeria. Hoy implementa Telegram; la interfaz comun
+// (`stop`, `notify`) permite sumar otros proveedores mas adelante.
+
+import { startTelegramChannel } from './telegram.js';
+
+/**
+ * Arranca los canales configurados y los suscribe a los eventos de los runs
+ * para avisar a los chats vinculados (por ejemplo, de la consola).
+ */
+export function startChannels(ctx, { log = () => {} } = {}) {
+  const tgConfig = { ...(ctx.app?.telegram ?? {}), ...(ctx.config?.telegram ?? {}) };
+  const token = tgConfig.token || process.env.TAMNORA_TELEGRAM_TOKEN || '';
+  const rawAllow = tgConfig.allowedChatIds ?? process.env.TAMNORA_TELEGRAM_CHAT_IDS ?? [];
+  const allowedChatIds = Array.isArray(rawAllow) ? rawAllow : String(rawAllow).split(/[,\s]+/).filter(Boolean);
+
+  const channels = [];
+  const telegram = startTelegramChannel(ctx, {
+    token,
+    allowedChatIds,
+    transcribeModel: tgConfig.transcribeModel,
+    log,
+  });
+  if (telegram) channels.push(telegram);
+
+  const unsubscribe = ctx.runs?.subscribeAll?.((sessionId, event) => {
+    for (const channel of channels) {
+      try {
+        channel.notify?.(sessionId, event);
+      } catch {
+        // un canal caido no debe frenar el run
+      }
+    }
+  });
+
+  return {
+    channels,
+    enabled: channels.length > 0,
+    stop() {
+      unsubscribe?.();
+      for (const channel of channels) channel.stop?.();
+    },
+  };
+}

package/harness/packages/server/src/lib/{telegram.js → channels/telegram.js}

@@ -1,5 +1,10 @@
-import { runAgent, createTools, resolveMode } from './core.js';
-import { resolveExistingDir } from './workspace.js';
+// Canal de Telegram: long polling (no necesita URL publica) con soporte de
+// texto, imagenes, notas de voz (transcripcion) y aprobaciones por botones
+// inline. Cada chat mapea a una sesion del harness.
+
+import { randomUUID } from 'node:crypto';
+import { runAgent, createTools, resolveMode, summarizeToolCall } from '../core.js';
+import { resolveExistingDir } from '../workspace.js';
 
 const API = 'https://api.telegram.org';
 
@@ -14,7 +19,7 @@ const HELP = [
   '/stop — cancela la respuesta en curso',
   '/help — esta ayuda',
   '',
-  'Cualquier otro texto se envía al agente.',
+  'Podés mandar texto, imágenes o notas de voz.',
 ].join('\n');
 
 async function tg(token, method, payload) {
@@ -37,6 +42,13 @@ async function tg(token, method, payload) {
   return data.result;
 }
 
+async function downloadFile(token, fileId) {
+  const file = await tg(token, 'getFile', { file_id: fileId });
+  const res = await fetch(`${API}/file/bot${token}/${file.file_path}`);
+  if (!res.ok) throw new Error(`no se pudo bajar el archivo (HTTP ${res.status})`);
+  return Buffer.from(await res.arrayBuffer());
+}
+
 function splitMessage(text, max = 3900) {
   const value = String(text ?? '').trim() || '(sin texto)';
   const parts = [];
@@ -47,24 +59,24 @@ function splitMessage(text, max = 3900) {
 const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 
 /**
- * Bot de Telegram por long polling (no necesita URL publica). Los chats
- * autorizados conversan con el mismo engine del harness; cada chat mapea a una
- * sesion. Devuelve `{ stop }` o `null` si no hay token.
+ * Arranca el canal de Telegram. Devuelve `{ stop, notify }` o `null` sin token.
  */
-export function startTelegramBot(ctx, { token, allowedChatIds = [], log = () => {} } = {}) {
+export function startTelegramChannel(ctx, { token, allowedChatIds = [], transcribeModel = 'whisper-1', log = () => {} } = {}) {
   if (!token) return null;
   const allowed = new Set(allowedChatIds.map(String));
   const controllers = new Map();
+  const ownSessions = new Set();
   let running = true;
   let offset = 0;
 
   const authorized = (chatId) => allowed.size > 0 && allowed.has(String(chatId));
   const sessionKey = (chatId) => `telegram:chat:${chatId}`;
+  const reverseKey = (sessionId) => `telegram:session:${sessionId}`;
 
-  async function send(chatId, text) {
+  async function send(chatId, text, extra = {}) {
     let first = null;
     for (const chunk of splitMessage(text)) {
-      const result = await tg(token, 'sendMessage', { chat_id: chatId, text: chunk, disable_web_page_preview: true });
+      const result = await tg(token, 'sendMessage', { chat_id: chatId, text: chunk, disable_web_page_preview: true, ...extra });
       if (!first) first = result;
     }
     return first;
@@ -91,10 +103,29 @@ export function startTelegramBot(ctx, { token, allowedChatIds = [], log = () =>
       });
       ctx.store.setSetting(key, sessionId);
     }
+    ctx.store.setSetting(reverseKey(sessionId), String(chatId));
     return sessionId;
   }
 
-  async function run(chatId, input) {
+  async function transcribe(buffer, filename) {
+    const providerId = ctx.effectiveProviderId();
+    const baseUrl = (ctx.providerSettings(providerId).baseUrl || '').replace(/\/+$/, '');
+    const apiKey = ctx.apiKeyFor(providerId);
+    if (!baseUrl) throw new Error('el proveedor no tiene baseUrl para transcribir');
+    const form = new FormData();
+    form.append('file', new Blob([buffer]), filename);
+    form.append('model', transcribeModel);
+    const res = await fetch(`${baseUrl}/audio/transcriptions`, {
+      method: 'POST',
+      headers: apiKey ? { Authorization: `Bearer ${apiKey}` } : {},
+      body: form,
+    });
+    if (!res.ok) throw new Error(`transcripción falló (HTTP ${res.status})`);
+    const data = await res.json();
+    return String(data.text ?? '').trim();
+  }
+
+  async function run(chatId, input, images = []) {
     const sessionId = ensureSession(chatId);
     const session = ctx.store.getSession(sessionId);
     const providerId = session.provider || ctx.effectiveProviderId();
@@ -114,11 +145,28 @@ export function startTelegramBot(ctx, { token, allowedChatIds = [], log = () =>
       mcp = null;
     }
 
+    const onAsk = async (name, args) => {
+      const askId = randomUUID();
+      const preview = JSON.stringify(args ?? {}).slice(0, 300);
+      await send(chatId, `⚠ Permiso para ${name}\n${preview}`, {
+        reply_markup: {
+          inline_keyboard: [
+            [
+              { text: 'Permitir', callback_data: `perm:${askId}:allow` },
+              { text: 'Denegar', callback_data: `perm:${askId}:deny` },
+            ],
+          ],
+        },
+      });
+      return ctx.approvals.ask(askId);
+    };
+
     const local = createTools({
       root: cwd,
       enabled: mode.tools ?? undefined,
       permissions: ctx.config.permissions,
       yes: false,
+      onAsk,
       mcp,
     });
     const exposeAdmin = !mode.tools;
@@ -126,26 +174,38 @@ export function startTelegramBot(ctx, { token, allowedChatIds = [], log = () =>
     const definitions = exposeAdmin ? [...local.definitions, ...admin.definitions] : local.definitions;
     const execute = (name, args, context) =>
       exposeAdmin && admin.handles(name)
-        ? admin.execute(name, args, { approve: async () => false })
+        ? admin.execute(name, args, { approve: onAsk })
         : local.execute(name, args, context);
     const { provider, config } = ctx.resolveProvider({
       ...ctx.providerSettings(providerId),
       apiKey: ctx.apiKeyFor(providerId),
     });
     const basePrompt = await ctx.systemPromptFor(cwd);
+    const userMessage = images.length
+      ? { role: 'user', content: [{ type: 'text', text: input }, ...images.map((url) => ({ type: 'image_url', image_url: { url } }))] }
+      : { role: 'user', content: input };
     const messages = [
       { role: 'system', content: mode.systemPrompt ? `${basePrompt}\n\n${mode.systemPrompt}` : basePrompt },
       ...history,
-      { role: 'user', content: input },
+      userMessage,
     ];
 
     const controller = new AbortController();
     controllers.set(String(chatId), controller);
+    ownSessions.add(sessionId);
     const message = await send(chatId, '…');
     let full = '';
+    let activity = '';
     let lastEdit = 0;
 
+    const render = () => {
+      const body = full.trim();
+      const suffix = activity ? `\n\n— ${activity}` : '';
+      return `${body || '…'}${suffix}`;
+    };
+
     try {
+      await tg(token, 'sendChatAction', { chat_id: chatId, action: 'typing' }).catch(() => null);
       const result = await runAgent({
         provider,
         config,
@@ -156,23 +216,30 @@ export function startTelegramBot(ctx, { token, allowedChatIds = [], log = () =>
         signal: controller.signal,
         maxRounds: ctx.config.maxRounds,
         onEvent(event) {
-          if (event.type !== 'text') return;
-          full = event.full;
+          if (event.type === 'text') {
+            full = event.full;
+          } else if (event.type === 'tool_call') {
+            activity = `${event.name} ${summarizeToolCall(event.name, event.args)}`.trim();
+          } else if (event.type === 'tool_result') {
+            activity = `${event.name} ✓`;
+          } else {
+            return;
+          }
           const now = Date.now();
           if (now - lastEdit > 1200) {
             lastEdit = now;
-            edit(chatId, message.message_id, full || '…');
+            edit(chatId, message.message_id, render());
           }
         },
       });
       await edit(chatId, message.message_id, result.content?.trim() || full || '(sin texto)');
-      const newMessages = result.messages.slice(1 + history.length);
-      ctx.store.addMessages(sessionId, newMessages);
+      ctx.store.addMessages(sessionId, result.messages.slice(messages.length));
       ctx.store.touchSession(sessionId, { provider: providerId, model });
     } catch (error) {
       await edit(chatId, message.message_id, error?.name === 'AbortError' ? 'Cancelado.' : `Error: ${error?.message ?? error}`);
     } finally {
       controllers.delete(String(chatId));
+      ownSessions.delete(sessionId);
       mcp?.close?.();
     }
   }
@@ -219,23 +286,62 @@ export function startTelegramBot(ctx, { token, allowedChatIds = [], log = () =>
     return send(chatId, `Comando desconocido: /${cmd}.\n\n${HELP}`);
   }
 
+  async function handleVoice(chatId, voice) {
+    await send(chatId, '🎧 Transcribiendo…');
+    try {
+      const buffer = await downloadFile(token, voice.file_id);
+      const text = await transcribe(buffer, voice.file_name || 'audio.ogg');
+      if (!text) return send(chatId, 'No pude transcribir el audio.');
+      await send(chatId, `📝 ${text}`);
+      return run(chatId, text);
+    } catch (error) {
+      return send(chatId, `No pude procesar el audio: ${error.message}`);
+    }
+  }
+
   async function handleMessage(message) {
     const chatId = String(message.chat.id);
     if (!authorized(chatId)) {
       await send(chatId, `No autorizado. Tu chat id es ${chatId}; agregalo a telegram.allowedChatIds para habilitarlo.`);
       return;
     }
-    const text = String(message.text ?? '').trim();
-    if (!text) return;
-    if (text.startsWith('/')) return handleCommand(chatId, text);
-    return run(chatId, text);
+    const text = String(message.text ?? message.caption ?? '').trim();
+    if (text.startsWith('/')) {
+      await handleCommand(chatId, text);
+      return;
+    }
+    if (message.voice || message.audio) {
+      await handleVoice(chatId, message.voice ?? message.audio);
+      return;
+    }
+    if (message.photo?.length) {
+      try {
+        const largest = message.photo[message.photo.length - 1];
+        const buffer = await downloadFile(token, largest.file_id);
+        const dataUrl = `data:image/jpeg;base64,${buffer.toString('base64')}`;
+        await run(chatId, text || '(imagen)', [dataUrl]);
+      } catch (error) {
+        await send(chatId, `No pude procesar la imagen: ${error.message}`);
+      }
+      return;
+    }
+    if (text) await run(chatId, text);
+  }
+
+  async function handleCallback(query) {
+    const [_, askId, action] = String(query.data ?? '').split(':');
+    if (askId) ctx.approvals.decide(askId, action === 'allow');
+    await tg(token, 'answerCallbackQuery', { callback_query_id: query.id, text: action === 'allow' ? 'Permitido' : 'Denegado' }).catch(() => null);
+    if (query.message) {
+      await tg(token, 'editMessageReplyMarkup', { chat_id: query.message.chat.id, message_id: query.message.message_id }).catch(() => null);
+    }
   }
 
   async function loop() {
     while (running) {
       let updates = [];
       try {
-        updates = await tg(token, 'getUpdates', { offset, timeout: 25, allowed_updates: ['message'] });
+        updates = await tg(token, 'getUpdates', { offset, timeout: 25, allowed_updates: ['message', 'callback_query'] });
       } catch (error) {
         if (error.status === 401 || error.status === 404) {
           log(`telegram: token inválido (${error.message}); se detiene el bot.`);
@@ -247,21 +353,46 @@ export function startTelegramBot(ctx, { token, allowedChatIds = [], log = () =>
       }
       for (const update of updates) {
         offset = update.update_id + 1;
-        if (update.message?.text) {
-          handleMessage(update.message).catch((error) => log(`telegram: ${error?.message ?? error}`));
-        }
+        if (update.message) handleMessage(update.message).catch((error) => log(`telegram: ${error?.message ?? error}`));
+        else if (update.callback_query) handleCallback(update.callback_query).catch((error) => log(`telegram: ${error?.message ?? error}`));
       }
     }
   }
 
-  // Arranca en segundo plano; no bloquea el server.
   loop().catch((error) => log(`telegram: ${error?.message ?? error}`));
 
   return {
+    id: 'telegram',
     stop() {
       running = false;
       for (const controller of controllers.values()) controller.abort();
       controllers.clear();
     },
+    /** Avisa a un chat vinculado sobre un run de otra interfaz (p.ej. la consola). */
+    notify(sessionId, event) {
+      if (ownSessions.has(sessionId)) return;
+      const chatId = ctx.store.getSetting(reverseKey(sessionId));
+      if (!chatId) return;
+      if (event.type === 'done') {
+        send(chatId, `✅ Sesión terminada.\n\n${String(event.data?.content ?? '').slice(0, 3500)}`).catch(() => {});
+      } else if (event.type === 'error') {
+        send(chatId, `✗ Error en la sesión: ${event.data?.message ?? ''}`).catch(() => {});
+      } else if (event.type === 'agent_end') {
+        send(chatId, `🤖 Subagente ${event.data?.status}: ${String(event.data?.content ?? '').slice(0, 1500)}`).catch(() => {});
+      } else if (event.type === 'permission') {
+        const askId = event.data?.askId;
+        if (!askId) return;
+        send(chatId, `⚠ Permiso para ${event.data?.name ?? 'una tool'} (desde la consola)`, {
+          reply_markup: {
+            inline_keyboard: [
+              [
+                { text: 'Permitir', callback_data: `perm:${askId}:allow` },
+                { text: 'Denegar', callback_data: `perm:${askId}:deny` },
+              ],
+            ],
+          },
+        }).catch(() => {});
+      }
+    },
   };
 }

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

@@ -55,9 +55,10 @@ export function openSse(req, res) {
   });
 
   return {
-    event(name, data) {
+    event(name, data, id) {
       if (closed || res.writableEnded) return;
-      res.write(`event: ${name}\ndata: ${JSON.stringify(data ?? {})}\n\n`);
+      const cursor = id === undefined || id === null ? '' : `id: ${id}\n`;
+      res.write(`${cursor}event: ${name}\ndata: ${JSON.stringify(data ?? {})}\n\n`);
     },
     comment(text) {
       if (closed || res.writableEnded) return;

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

@@ -0,0 +1,102 @@
+// Gestiona los runs activos del server, desacoplados del request HTTP: si el
+// cliente se desconecta (por ejemplo, el celular bloquea la pantalla), el run
+// sigue; cada evento se persiste con un cursor para que un cliente nuevo pueda
+// reconectar y reconstruir el turno en curso.
+
+/**
+ * @param {object} deps
+ * @param {import('../../../core/src/storage/sqlite.js').Store} deps.store
+ */
+export function createRunManager({ store }) {
+  const runs = new Map();
+  const listeners = new Set();
+
+  function persist(run, sessionId, type, data, agentId) {
+    const coalesce =
+      (type === 'text' || type === 'reasoning') &&
+      run?.lastEvent &&
+      run.lastEvent.type === type &&
+      run.lastEvent.agentId === agentId;
+    if (coalesce) {
+      store.updateSessionEvent(run.lastEvent.id, data);
+      return { id: run.lastEvent.id, type, data, agentId };
+    }
+    const id = store.addSessionEvent(sessionId, { agentId, type, data });
+    if (run) run.lastEvent = { id, type, agentId };
+    return { id, type, data, agentId };
+  }
+
+  function emit(sessionId, type, data, { agentId = null } = {}) {
+    const run = runs.get(sessionId) ?? null;
+    const event = persist(run, sessionId, type, data, agentId);
+    if (run) {
+      for (const subscriber of [...run.subscribers]) {
+        try {
+          subscriber(event);
+        } catch {
+          // un suscriptor caido no debe frenar el run
+        }
+      }
+    }
+    for (const listener of [...listeners]) {
+      try {
+        listener(sessionId, event);
+      } catch {
+        // un listener caido no debe frenar el run
+      }
+    }
+    return event;
+  }
+
+  function start(sessionId) {
+    if (runs.has(sessionId)) return null;
+    const controller = new AbortController();
+    const run = { sessionId, controller, subscribers: new Set(), lastEvent: null, startedAt: Date.now() };
+    runs.set(sessionId, run);
+    store.clearSessionEvents(sessionId);
+    return run;
+  }
+
+  function finish(sessionId) {
+    const run = runs.get(sessionId);
+    if (!run) return;
+    run.subscribers.clear();
+    runs.delete(sessionId);
+  }
+
+  function cancel(sessionId) {
+    runs.get(sessionId)?.controller.abort();
+  }
+
+  function cancelAll() {
+    for (const run of runs.values()) run.controller.abort();
+    runs.clear();
+  }
+
+  function isActive(sessionId) {
+    return runs.has(sessionId);
+  }
+
+  function signal(sessionId) {
+    return runs.get(sessionId)?.controller.signal;
+  }
+
+  function subscribe(sessionId, fn) {
+    const run = runs.get(sessionId);
+    if (!run) return () => {};
+    run.subscribers.add(fn);
+    return () => run.subscribers.delete(fn);
+  }
+
+  function activeSessions() {
+    return [...runs.keys()];
+  }
+
+  /** Suscriptor global de todos los runs (usado por los canales). */
+  function subscribeAll(fn) {
+    listeners.add(fn);
+    return () => listeners.delete(fn);
+  }
+
+  return { emit, start, finish, cancel, cancelAll, isActive, signal, subscribe, subscribeAll, activeSessions };
+}