@danieltmn/tamnora 0.7.1 → 0.9.0

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

@@ -4,12 +4,19 @@ import {
   createTools,
   resolveMode,
   MAX_TOOL_ROUNDS,
-  summarizeToolCall,
-  previewToolResult,
 } from '../lib/core.js';
 import { openSse, readJson, sendJson, sendError } from '../lib/http.js';
 import { workspaceForRequest, resolveExistingDir } from '../lib/workspace.js';
 import { createSubagentTool } from '../lib/tasks.js';
+import {
+  combineToolset,
+  composeAgentMessages,
+  buildUserMessage,
+  resolveProviderFor,
+  toolCallPayload,
+  toolResultPayload,
+} from '../lib/agentRun.js';
+import { fraseInicio, fraseFin, fraseError, createFiltroTools } from '../lib/announcer.js';
 
 /**
  * Emit streaming partials at most once per `ms` window, keeping only the
@@ -57,6 +64,13 @@ export function registerChat(route, ctx) {
     sendJson(res, 200, { ok: true, allow, scope });
   });
 
+  // Lo pendiente, para que un cliente sin stream abierto (el celular mirando
+  // otra sesion) sepa igual que hay un permiso esperando.
+  route('GET', '/api/permissions', ({ res, query }) => {
+    const sessionId = query.get('sessionId') ?? undefined;
+    sendJson(res, 200, { pending: ctx.approvals.list({ sessionId }) });
+  });
+
   route('POST', '/api/sessions/:id/stop', ({ res, params }) => {
     if (!ctx.runs.isActive(params.id)) return sendJson(res, 200, { ok: true, stopped: false });
     ctx.runs.cancel(params.id);
@@ -146,7 +160,14 @@ export function registerChat(route, ctx) {
     const autoApprove = body.yes ?? ctx.yes;
     const asked = new Set();
 
-    ctx.runs.emit(sessionId, 'start', { sessionId, provider: providerId, model, mode: mode.id, cwd: sessionCwd });
+    ctx.runs.emit(sessionId, 'start', {
+      sessionId,
+      provider: providerId,
+      model,
+      mode: mode.id,
+      cwd: sessionCwd,
+      say: fraseInicio(),
+    });
     ctx.runs.emit(sessionId, 'user', { content: input });
 
     let mcp = null;
@@ -165,7 +186,7 @@ export function registerChat(route, ctx) {
           asked.add(askId);
           askMeta.set(askId, { sessionId });
           ctx.runs.emit(sessionId, 'permission', { askId, sessionId, name, args });
-          const allow = await ctx.approvals.ask(askId);
+          const allow = await ctx.approvals.ask(askId, { sessionId, name, args });
           asked.delete(askId);
           askMeta.delete(askId);
           ctx.runs.emit(sessionId, 'permission_resolved', { askId, allow });
@@ -194,45 +215,24 @@ export function registerChat(route, ctx) {
       exclude: admin.definitions.map((d) => d.function.name),
       emit: emitAgent,
     });
-    const definitions = [
-      ...(exposeAdmin ? [...local.definitions, ...admin.definitions] : local.definitions),
-      ...tasks.definitions,
-    ];
-    const execute = (name, args, context) => {
-      if (tasks.handles(name)) return tasks.execute(name, args);
-      if (exposeAdmin && admin.handles(name)) {
-        return admin.execute(name, args, { approve: autoApprove ? async () => true : onAsk });
-      }
-      return local.execute(name, args, context);
-    };
+    const approve = autoApprove ? async () => true : (name, args) => onAsk(name, args);
+    const { definitions, execute } = combineToolset({ local, admin, tasks, exposeAdmin, approve });
 
-    const { provider, config } = ctx.resolveProvider({
-      ...ctx.providerSettings(providerId),
-      apiKey: ctx.apiKeyFor(providerId),
+    const { provider, config } = resolveProviderFor(ctx, providerId, {
       baseUrl: body.baseUrl || ctx.providerSettings(providerId).baseUrl,
     });
 
-    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 userMessage = buildUserMessage(input, images);
 
     const sessionRecord = ctx.store.getSession(sessionId);
-    const goal = sessionRecord?.meta?.goal;
-    const summary = sessionRecord?.meta?.summary;
-    const basePrompt = await ctx.systemPromptFor(sessionCwd);
-    const messages = [
-      { role: 'system', content: mode.systemPrompt ? `${basePrompt}\n\n${mode.systemPrompt}` : basePrompt },
-      ...(goal ? [{ role: 'system', content: `Objetivo de la sesión: ${goal}` }] : []),
-      ...(summary ? [{ role: 'system', content: `Resumen de la conversación anterior:\n${summary}` }] : []),
-      ...history,
+    const messages = await composeAgentMessages({
+      ctx,
+      cwd: sessionCwd,
+      mode,
+      history,
       userMessage,
-    ];
+      sessionRecord,
+    });
     // Persistimos el mensaje del usuario ya: asi sobrevive a un corte y la
     // reconexion puede reconstruir el turno desde el historial.
     ctx.store.addMessage(sessionId, userMessage);
@@ -240,6 +240,7 @@ export function registerChat(route, ctx) {
 
     (async () => {
       const startedAt = Date.now();
+      const filtroTools = createFiltroTools();
       const partials = createPartialThrottle(300, (name, payload) => ctx.runs.emit(sessionId, name, payload));
       try {
         const result = await runAgent({
@@ -264,6 +265,9 @@ export function registerChat(route, ctx) {
             } else if (event.type === 'retry') {
               partials.flush();
               ctx.runs.emit(sessionId, 'retry', { attempt: event.attempt, delayMs: event.delayMs, message: event.message });
+            } else if (event.type === 'usage') {
+              partials.flush();
+              ctx.runs.emit(sessionId, 'usage', { tokens: event.usage });
             } else if (event.type === 'trim') {
               partials.flush();
               ctx.runs.emit(sessionId, 'trim', { trimmed: event.trimmed, dropped: event.dropped, tokens: event.tokens });
@@ -272,17 +276,15 @@ export function registerChat(route, ctx) {
               ctx.runs.emit(sessionId, 'tools', { toolCalls: event.toolCalls });
             } else if (event.type === 'tool_call') {
               partials.flush();
-              ctx.runs.emit(sessionId, 'tool_call', {
+              const payload = toolCallPayload(event);
+              ctx.runs.emit(sessionId, 'tool_call', { ...payload, say: filtroTools(event.name, payload.summary) });
+            } else if (event.type === 'tool_result') {
+              partials.flush();
+              ctx.runs.emit(sessionId, 'tool_result', {
                 id: event.id,
                 name: event.name,
-                args: event.args,
-                summary: summarizeToolCall(event.name, event.args),
+                ...toolResultPayload(event),
               });
-            } else if (event.type === 'tool_result') {
-              partials.flush();
-              const { preview, truncated } = previewToolResult(event.name, event.result);
-              const failed = /^Error|^Permiso denegado/i.test(String(event.result));
-              ctx.runs.emit(sessionId, 'tool_result', { id: event.id, name: event.name, preview, truncated, failed });
             } else if (event.type === 'repeat') {
               partials.flush();
               ctx.runs.emit(sessionId, 'repeat', { name: event.name, count: event.count });
@@ -301,7 +303,8 @@ export function registerChat(route, ctx) {
         ctx.store.touchSession(sessionId, { provider: providerId, model, title });
         const toolCalls = newMessages.filter((message) => message.role === 'tool').length;
         const durationMs = Date.now() - startedAt;
-        if (result.stopReason === 'aborted') ctx.runs.emit(sessionId, 'aborted', { durationMs, toolCalls });
+        if (result.stopReason === 'aborted')
+          ctx.runs.emit(sessionId, 'aborted', { durationMs, toolCalls, say: fraseFin({ stopReason: 'aborted' }) });
         else
           ctx.runs.emit(sessionId, 'done', {
             sessionId,
@@ -313,11 +316,12 @@ export function registerChat(route, ctx) {
             tokens: result.usage ?? null,
             toolCalls,
             durationMs,
+            say: fraseFin({ stopReason: result.stopReason, rounds: result.rounds, toolCalls, durationMs }),
           });
       } catch (error) {
         partials.flush();
-        if (error?.name === 'AbortError') ctx.runs.emit(sessionId, 'aborted', {});
-        else ctx.runs.emit(sessionId, 'error', { message: error?.message ?? String(error) });
+        if (error?.name === 'AbortError') ctx.runs.emit(sessionId, 'aborted', { say: fraseFin({ stopReason: 'aborted' }) });
+        else ctx.runs.emit(sessionId, 'error', { message: error?.message ?? String(error), say: fraseError() });
       } finally {
         unsubscribe();
         sse.close();

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

@@ -0,0 +1,35 @@
+import { openSse } from '../lib/http.js';
+
+/**
+ * Canal global de eventos: un SSE por pestaña de la consola.
+ *
+ * Sirve para que varias ventanas (o la PC y el celular a la vez) se enteren de
+ * que un run arranco en una sesion, sin tener cada una su propio stream por
+ * sesion abierto.
+ *
+ * Solo van eventos de ciclo de vida y **los permisos**. El detalle del turno
+ * sigue yendo por `/api/sessions/:id/stream`: filtrar es obligatorio, porque
+ * `subscribeAll` ve cada parcial de texto de todos los runs y reenviarlos seria
+ * duplicar el stream por sesion.
+ *
+ * Los permisos van aparte justamente porque son lo unico que, si solo viviera
+ * en el stream, un cliente no suscrito a esa sesion no tendria forma de saber
+ * que esta esperando una decision suya.
+ *
+ * Al conectar se manda `snapshot` con las sesiones que ya estan corriendo y con
+ * los permisos pendientes: es lo que hace el canal auto-sanador. Si el stream se
+ * corta y vuelve, el snapshot le dice al cliente que se quedo a medio camino.
+ */
+const GLOBAL_EVENTS = new Set(['run_start', 'run_end', 'permission', 'permission_resolved']);
+
+export function registerEvents(route, ctx) {
+  route('GET', '/api/events', ({ req, res }) => {
+    const sse = openSse(req, res);
+    const unsubscribe = ctx.runs.subscribeAll((sessionId, event) => {
+      if (!GLOBAL_EVENTS.has(event.type)) return;
+      sse.event(event.type, event.data);
+    });
+    sse.event('snapshot', { active: ctx.runs.activeSessions(), permissions: ctx.approvals.list() });
+    req.on('close', unsubscribe);
+  });
+}

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

@@ -3,28 +3,20 @@ import fsp from 'node:fs/promises';
 import path from 'node:path';
 import { readJson, sendJson, sendError } from '../lib/http.js';
 import { staticServerChip } from '../lib/core.js';
-import { isLoopback, resolveExistingDir } from '../lib/workspace.js';
+import { isInside, localOk, requireLocal, resolveDirOr400 } from '../lib/workspace.js';
 
 const MAX_PREVIEW = 200 * 1024;
 const IGNORED = new Set(['node_modules', '.git', '.tamnora', '.playwright-mcp', 'dist', '.cache']);
 
-function isInside(root, target) {
-  const rel = path.relative(root, target);
-  return rel === '' || (!rel.startsWith('..') && !path.isAbsolute(rel));
-}
-
 /** Resolve `?root` + `?path` into a confined filesystem target, or send an error. */
-function resolveTarget(req, res, query, fallback) {
-  if (!isLoopback(req.socket.localAddress)) {
-    sendError(res, 403, 'Explorar archivos solo está disponible en conexiones locales.');
-    return null;
-  }
+function resolveTarget(req, res, query, fallback, { allowAnyRoot }) {
   let root;
-  try {
-    root = resolveExistingDir(query.get('root') || fallback);
-  } catch (error) {
-    sendError(res, 400, error.message);
-    return null;
+  if (allowAnyRoot) {
+    root = resolveDirOr400(res, query.get('root'), fallback);
+    if (!root) return null;
+  } else {
+    // Sin conexion local de verdad: root fijo al workspace, se ignora ?root.
+    root = fallback;
   }
   const rel = String(query.get('path') ?? '').replace(/^[/\\]+/, '');
   const target = path.resolve(root, rel);
@@ -39,7 +31,11 @@ const toPosix = (value) => value.split(path.sep).join('/');
 
 export function registerFiles(route, ctx) {
   route('GET', '/api/files', ({ req, res, query }) => {
-    const resolved = resolveTarget(req, res, query, ctx.cwd);
+    const local = localOk(req);
+    if (!local && !ctx.authEnabled) {
+      return sendError(res, 403, 'Explorar archivos solo está disponible en conexiones locales.');
+    }
+    const resolved = resolveTarget(req, res, query, ctx.cwd, { allowAnyRoot: local });
     if (!resolved) return;
 
     let stat;
@@ -87,7 +83,11 @@ export function registerFiles(route, ctx) {
   });
 
   route('GET', '/api/files/content', async ({ req, res, query }) => {
-    const resolved = resolveTarget(req, res, query, ctx.cwd);
+    const local = localOk(req);
+    if (!local && !ctx.authEnabled) {
+      return sendError(res, 403, 'Explorar archivos solo está disponible en conexiones locales.');
+    }
+    const resolved = resolveTarget(req, res, query, ctx.cwd, { allowAnyRoot: local });
     if (!resolved) return;
 
     let stat;
@@ -117,19 +117,15 @@ export function registerFiles(route, ctx) {
   });
 
   route('POST', '/api/files/preview', async ({ req, res }) => {
-    if (!isLoopback(req.socket.localAddress)) {
-      return sendError(res, 403, 'La vista previa solo está disponible en conexiones locales.');
+    if (!requireLocal(req, res, 'La vista previa solo está disponible en conexiones locales.')) {
+      return;
     }
     if (!ctx.procsEnabled) {
       return sendError(res, 403, 'Los procesos están deshabilitados (processes.enabled = false).');
     }
     const body = await readJson(req);
-    let root;
-    try {
-      root = resolveExistingDir(body.root || ctx.cwd);
-    } catch (error) {
-      return sendError(res, 400, error.message);
-    }
+    const root = resolveDirOr400(res, body.root, ctx.cwd);
+    if (!root) return;
     const rel = String(body.path ?? '').replace(/^[/\\]+/, '');
     const target = path.resolve(root, rel);
     if (!isInside(root, target)) return sendError(res, 400, 'La ruta queda fuera del workspace.');

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

@@ -1,7 +1,7 @@
 import path from 'node:path';
 import { mkdir } from 'node:fs/promises';
 import { readJson, sendJson, sendError } from '../lib/http.js';
-import { isLoopback, rootDirs, listSubdirs, resolveExistingDir } from '../lib/workspace.js';
+import { requireLocal, rootDirs, listSubdirs, resolveDirOr400 } from '../lib/workspace.js';
 
 const INVALID_NAME = /[\\/:*?"<>|]/;
 
@@ -12,8 +12,8 @@ function validFolderName(name) {
 
 export function registerFolders(route) {
   route('GET', '/api/folders', ({ req, res, query }) => {
-    if (!isLoopback(req.socket.localAddress)) {
-      return sendError(res, 403, 'El navegador de carpetas solo está disponible en conexiones locales.');
+    if (!requireLocal(req, res, 'El navegador de carpetas solo está disponible en conexiones locales.')) {
+      return;
     }
 
     const raw = String(query.get('path') ?? '').trim();
@@ -26,12 +26,8 @@ export function registerFolders(route) {
       });
     }
 
-    let dir;
-    try {
-      dir = resolveExistingDir(raw);
-    } catch (error) {
-      return sendError(res, 400, error.message);
-    }
+    const dir = resolveDirOr400(res, raw);
+    if (!dir) return;
 
     let dirs;
     try {
@@ -49,8 +45,8 @@ export function registerFolders(route) {
   });
 
   route('POST', '/api/folders', async ({ req, res }) => {
-    if (!isLoopback(req.socket.localAddress)) {
-      return sendError(res, 403, 'Crear carpetas solo está disponible en conexiones locales.');
+    if (!requireLocal(req, res, 'Crear carpetas solo está disponible en conexiones locales.')) {
+      return;
     }
     const body = await readJson(req);
     const name = String(body.name ?? '').trim();
@@ -61,12 +57,8 @@ export function registerFolders(route) {
     if (!String(body.parent ?? '').trim()) {
       return sendError(res, 400, 'Elegí la carpeta contenedora primero.');
     }
-    let parent;
-    try {
-      parent = resolveExistingDir(body.parent);
-    } catch (error) {
-      return sendError(res, 400, error.message);
-    }
+    const parent = resolveDirOr400(res, body.parent);
+    if (!parent) return;
 
     const target = path.join(parent, name);
     try {

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

@@ -0,0 +1,35 @@
+import path from 'node:path';
+import { gitStatus, gitDiff } from '../lib/core.js';
+import { sendJson, sendError } from '../lib/http.js';
+import { isInside, localOk, requireLocal, resolveDirOr400 } from '../lib/workspace.js';
+
+export function registerGit(route, ctx) {
+  const resolveRoot = (req, res, raw) => {
+    if (!ctx.authEnabled && !requireLocal(req, res, 'El estado de git solo está disponible en conexiones locales.')) {
+      return null;
+    }
+    // Con auth (sesion ya validada) se permite por el tunel, pero el cwd
+    // pedido queda confinado al workspace salvo conexion local de verdad.
+    const root = resolveDirOr400(res, localOk(req) ? raw : null, ctx.cwd);
+    return root;
+  };
+
+  route('GET', '/api/git/status', async ({ req, res, query }) => {
+    const root = resolveRoot(req, res, query.get('cwd'));
+    if (!root) return;
+    const status = await gitStatus(root);
+    sendJson(res, 200, { root, ...status });
+  });
+
+  route('GET', '/api/git/diff', async ({ req, res, query }) => {
+    const root = resolveRoot(req, res, query.get('cwd'));
+    if (!root) return;
+    const rel = String(query.get('path') ?? '').replace(/^[/\\]+/, '');
+    if (rel && !isInside(root, path.resolve(root, rel))) {
+      return sendError(res, 400, 'La ruta queda fuera del workspace.');
+    }
+    const result = await gitDiff(root, { path: rel, staged: query.get('staged') === '1' });
+    if (!result.ok) return sendError(res, 400, result.error ?? 'No se pudo obtener el diff.');
+    sendJson(res, 200, { root, path: rel || null, ...result });
+  });
+}

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

@@ -1,6 +1,6 @@
-import { detectProcs } from '../lib/core.js';
+import { detectProcs, killPort } from '../lib/core.js';
 import { readJson, sendJson, sendError } from '../lib/http.js';
-import { resolveExistingDir } from '../lib/workspace.js';
+import { requireLocal, resolveDirOr400 } from '../lib/workspace.js';
 
 export function registerProcs(route, ctx) {
   route('GET', '/api/procs', ({ res }) => {
@@ -8,24 +8,19 @@ export function registerProcs(route, ctx) {
   });
 
   route('GET', '/api/procs/detect', ({ res, query }) => {
-    let dir;
-    try {
-      dir = resolveExistingDir(query.get('cwd') || ctx.cwd);
-    } catch (error) {
-      return sendError(res, 400, error.message);
-    }
+    const dir = resolveDirOr400(res, query.get('cwd'), ctx.cwd);
+    if (!dir) return;
     sendJson(res, 200, { cwd: dir, chips: detectProcs(dir) });
   });
 
   route('POST', '/api/procs/start', async ({ req, res }) => {
+    if (!ctx.authEnabled && !requireLocal(req, res, 'Iniciar procesos solo está disponible en conexiones locales.')) {
+      return;
+    }
     if (!ctx.procsEnabled) return sendError(res, 403, 'Los procesos están deshabilitados (processes.enabled = false).');
     const body = await readJson(req);
-    let dir;
-    try {
-      dir = resolveExistingDir(body.cwd || ctx.cwd);
-    } catch (error) {
-      return sendError(res, 400, error.message);
-    }
+    const dir = resolveDirOr400(res, body.cwd, ctx.cwd);
+    if (!dir) return;
     try {
       const proc = ctx.procs.start({ cwd: dir, command: body.command, args: body.args, port: body.port });
       sendJson(res, 201, { proc });
@@ -40,8 +35,23 @@ export function registerProcs(route, ctx) {
     sendJson(res, 200, data);
   });
 
-  route('POST', '/api/procs/:id/stop', ({ res, params }) => {
+  route('POST', '/api/procs/:id/stop', ({ req, res, params }) => {
+    if (!ctx.authEnabled && !requireLocal(req, res, 'Detener procesos solo está disponible en conexiones locales.')) {
+      return;
+    }
     if (!ctx.procs.stop(params.id)) return sendError(res, 404, 'Proceso no encontrado.');
     sendJson(res, 200, { ok: true });
   });
+
+  route('POST', '/api/procs/kill', async ({ req, res }) => {
+    if (!requireLocal(req, res, 'Matar procesos solo está disponible en conexiones locales.')) {
+      return;
+    }
+    const body = await readJson(req);
+    try {
+      sendJson(res, 200, await killPort(body.port));
+    } catch (error) {
+      sendError(res, 400, error.message);
+    }
+  });
 }

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

@@ -1,27 +1,16 @@
 import { runAgent } from '../lib/core.js';
 import { readJson, sendJson, sendError } from '../lib/http.js';
 import { workspaceForRequest } from '../lib/workspace.js';
-
-function view(session) {
-  return {
-    id: session.id,
-    title: session.title,
-    provider: session.provider,
-    model: session.model,
-    cwd: session.cwd,
-    goal: session.meta?.goal ?? null,
-    hasSummary: Boolean(session.meta?.summary),
-    createdAt: session.created_at,
-    updatedAt: session.updated_at,
-  };
-}
+import { sessionView, sessionState, awaitingBySession } from '../lib/sessionView.js';
 
 const COMPACT_INSTRUCTION =
   'Resumí la conversación en un texto conciso que preserve decisiones tomadas, archivos tocados, hallazgos y el estado actual, para poder continuar el trabajo sin el historial completo.';
 
 export function registerSessions(route, ctx) {
   route('GET', '/api/sessions', ({ res }) => {
-    sendJson(res, 200, { sessions: ctx.store.listSessions(50).map(view) });
+    const awaiting = awaitingBySession(ctx.approvals.list());
+    const sessions = ctx.store.listSessions(50).map((session) => sessionState(session, ctx, awaiting.get(session.id) ?? 0));
+    sendJson(res, 200, { sessions });
   });
 
   route('GET', '/api/search', ({ res, query }) => {
@@ -38,7 +27,7 @@ export function registerSessions(route, ctx) {
       return text.replace(/\s+/g, ' ').trim().slice(0, 200);
     };
     sendJson(res, 200, {
-      sessions: ctx.store.searchSessions(q, limit).map(view),
+      sessions: ctx.store.searchSessions(q, limit).map(sessionView),
       messages: ctx.store.searchMessages(q, limit).map((m) => ({
         id: m.id,
         sessionId: m.sessionId,
@@ -66,17 +55,21 @@ export function registerSessions(route, ctx) {
       cwd,
       meta,
     });
-    sendJson(res, 201, { session: view(ctx.store.getSession(id)) });
+    sendJson(res, 201, { session: sessionView(ctx.store.getSession(id)) });
   });
 
   route('GET', '/api/sessions/:id', ({ res, params }) => {
     const session = ctx.store.getSession(params.id);
     if (!session) return sendError(res, 404, 'Sesión no encontrada.');
     sendJson(res, 200, {
-      session: view(session),
+      session: sessionView(session),
       tokens: ctx.store.sessionTokens(params.id),
       messages: ctx.store.getMessages(params.id),
       running: ctx.runs?.isActive(params.id) ?? false,
+      // Un permiso pendiente NO se reconstruye desde los mensajes (no son
+      // mensajes), asi que va aparte: sin esto, recargar la pagina dejaba el run
+      // esperando una decision que no se podia tomar.
+      permissions: ctx.approvals.list({ sessionId: params.id }),
     });
   });
 
@@ -104,7 +97,7 @@ export function registerSessions(route, ctx) {
     if ('title' in body) patch.title = String(body.title || '').slice(0, 80) || session.title;
     if ('goal' in body) patch.meta = { goal: body.goal ? String(body.goal) : undefined };
     ctx.store.touchSession(params.id, patch);
-    sendJson(res, 200, { session: view(ctx.store.getSession(params.id)) });
+    sendJson(res, 200, { session: sessionView(ctx.store.getSession(params.id)) });
   });
 
   route('DELETE', '/api/sessions/:id/messages', ({ res, params }) => {

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

@@ -0,0 +1,19 @@
+import { createTools } from '../lib/core.js';
+import { readJson, sendJson, sendError } from '../lib/http.js';
+import { requireLocal, resolveDirOr400 } from '../lib/workspace.js';
+
+export function registerShell(route, ctx) {
+  route('POST', '/api/shell', async ({ req, res }) => {
+    if (!requireLocal(req, res, 'El shell solo está disponible en conexiones locales.')) {
+      return;
+    }
+    const body = await readJson(req);
+    const command = String(body.command ?? '').trim();
+    if (!command) return sendError(res, 400, 'Falta "command".');
+    const root = resolveDirOr400(res, body.cwd, ctx.cwd);
+    if (!root) return;
+    const tools = createTools({ root, enabled: ['bash'], yes: true });
+    const output = await tools.execute('bash', { command });
+    sendJson(res, 200, { command, cwd: root, output: String(output ?? '') });
+  });
+}

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

@@ -0,0 +1,32 @@
+import { sendJson } from '../lib/http.js';
+import { sessionState, awaitingBySession } from '../lib/sessionView.js';
+
+/**
+ * Snapshot de todo lo que el cliente necesita para reconciliar, en un solo
+ * request.
+ *
+ * Este endpoint es la **verdad**: los streams SSE son un atajo de latencia que
+ * se cae en cualquier enlace movil (y que iOS corta cuando manda la pestana a
+ * background). Por eso no lleva mensajes ni tool results — solo liveness, que es
+ * chico y se puede pedir seguido. El detalle de una sesion sigue bajo demanda
+ * en `/api/sessions/:id`.
+ */
+export function registerState(route, ctx) {
+  route('GET', '/api/state', ({ res }) => {
+    const permissions = ctx.approvals.list();
+    const awaiting = awaitingBySession(permissions);
+    const sessions = ctx.store.listSessions(50).map((session) => sessionState(session, ctx, awaiting.get(session.id) ?? 0));
+    sendJson(res, 200, {
+      sessions,
+      permissions: permissions.map(({ askId, sessionId, name, args, requestedAt }) => ({
+        askId,
+        sessionId,
+        name,
+        args,
+        requestedAt,
+      })),
+      // Para que el cliente pueda detectar que el server va en otro reloj.
+      now: Date.now(),
+    });
+  });
+}