@danieltmn/tamnora 0.16.1 → 0.18.0

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

@@ -76,12 +76,28 @@ export function registerChat(route, ctx) {
     sendJson(res, 200, { pending: ctx.approvals.list({ sessionId }) });
   });
 
+  // Respuesta de un formulario interactivo (`ask_user`).
+  route('POST', '/api/questions/:askId', async ({ req, res, params }) => {
+    const body = await readJson(req);
+    const answers = body.answers && typeof body.answers === 'object' ? body.answers : {};
+    if (!ctx.questions.answer(params.askId, answers)) {
+      return sendError(res, 404, 'Formulario expirado o inexistente.');
+    }
+    sendJson(res, 200, { ok: true });
+  });
+
+  route('GET', '/api/questions', ({ res, query }) => {
+    const sessionId = query.get('sessionId') ?? undefined;
+    sendJson(res, 200, { pending: ctx.questions.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);
-    // Un run esperando una aprobacion quedaria colgado: la denegamos para que
-    // el bucle del agente pueda desenrollarse y termine.
+    // Un run esperando una aprobacion o un formulario quedaria colgado: los
+    // resolvemos para que el bucle del agente pueda desenrollarse y termine.
     ctx.approvals.cancelForSession(params.id);
+    ctx.questions.cancelForSession(params.id);
     sendJson(res, 200, { ok: true, stopped: true });
   });
 
@@ -155,7 +171,16 @@ export function registerChat(route, ctx) {
     }
 
     if (ctx.runs.isActive(sessionId)) {
-      return sendError(res, 409, 'La sesión ya tiene una respuesta en curso.');
+      // "Interrumpir": si el cliente lo pide, cancelamos el run en curso y
+      // esperamos a que se desenrolle antes de arrancar el nuevo. Sin esto, un
+      // segundo mensaje del mismo cliente chocaria con el 409.
+      if (body.interrupt !== true) {
+        return sendError(res, 409, 'La sesión ya tiene una respuesta en curso.');
+      }
+      ctx.runs.cancel(sessionId);
+      ctx.approvals.cancelForSession(sessionId);
+      ctx.questions.cancelForSession(sessionId);
+      await ctx.runs.waitForIdle(sessionId);
     }
 
     const mode = resolveMode(body.mode ?? ctx.store.getSetting('activeMode'));
@@ -200,13 +225,23 @@ export function registerChat(route, ctx) {
           ctx.runs.emit(sessionId, 'permission_resolved', { askId, allow });
           return allow;
         };
+    const onQuestion = async ({ title, questions }) => {
+      const askId = randomUUID();
+      ctx.runs.emit(sessionId, 'question', { askId, sessionId, title, questions });
+      const result = await ctx.questions.ask(askId, { sessionId, title, questions });
+      ctx.runs.emit(sessionId, 'question_answered', { askId, answers: result.answers, cancelled: !result.ok });
+      return result;
+    };
     const local = createTools({
       root: sessionCwd,
       enabled,
       permissions: ctx.config.permissions,
       yes: autoApprove,
       onAsk,
+      onQuestion,
       mcp,
+      mcpMode: ctx.effectiveMcpMode(),
+      mcpPinned: ctx.effectiveMcpPinned(),
       signal: ctx.runs.signal(sessionId),
     });
     // En modo plan (solo lectura) no exponemos las tools de administración.
@@ -220,6 +255,8 @@ export function registerChat(route, ctx) {
       model,
       permissions: ctx.config.permissions,
       mcp,
+      mcpMode: ctx.effectiveMcpMode(),
+      mcpPinned: ctx.effectiveMcpPinned(),
       signal: ctx.runs.signal(sessionId),
       exclude: [...admin.definitions.map((d) => d.function.name), ...(ctx.plugins?.list?.().map((t) => t.name) ?? [])],
       emit: emitAgent,

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

@@ -3,8 +3,14 @@ import {
   mcpTransport,
   getMcpRegistryServer,
   registryServerToConfig,
+  registryServerToCandidate,
+  searchMcpRegistry,
   normalizeMcpConfig,
+  MCP_CATALOG,
+  mcpCatalogEntry,
   maskEnv,
+  useLazyMcp,
+  MCP_AUTO_THRESHOLD,
 } from '../lib/core.js';
 import { readJson, sendJson, sendError } from '../lib/http.js';
 
@@ -79,11 +85,15 @@ function parseServer(body, id, existing = null) {
 export function registerMcp(route, ctx) {
   route('GET', '/api/mcp', async ({ res, query }) => {
     const servers = listServers(ctx);
+    const mode = ctx.effectiveMcpMode();
+    const pinned = ctx.effectiveMcpPinned();
+    let toolCount = null;
 
     if (query.get('connect')) {
       const connectable = ctx.mergedMcpServers().filter((s) => s.enabled !== false);
       const registry = await buildMcpRegistry(connectable);
       try {
+        toolCount = registry.definitions.length;
         for (const server of servers) {
           const session = registry.sessions.find((s) => s.server.id === server.id);
           const failure = registry.errors.find((e) => e.server.id === server.id);
@@ -108,14 +118,56 @@ export function registerMcp(route, ctx) {
       }
     }
 
-    sendJson(res, 200, { servers });
+    sendJson(res, 200, {
+      servers,
+      mode,
+      pinned,
+      threshold: MCP_AUTO_THRESHOLD,
+      toolCount,
+      lazy: toolCount === null ? null : useLazyMcp(mode, toolCount, MCP_AUTO_THRESHOLD),
+    });
+  });
+
+  route('GET', '/api/mcp/catalog', ({ res }) => {
+    const installed = new Set(ctx.mergedMcpServers().map((s) => s.id));
+    sendJson(res, 200, {
+      catalog: MCP_CATALOG.map((entry) => ({
+        id: entry.id,
+        name: entry.name,
+        description: entry.description ?? '',
+        transport: entry.type === 'http' ? 'http' : 'stdio',
+        command: entry.command ?? null,
+        args: entry.args ?? [],
+        requiredEnv: entry.requiredEnv ?? [],
+        installed: installed.has(entry.id),
+      })),
+    });
+  });
+
+  route('GET', '/api/mcp/search', async ({ res, query }) => {
+    const q = String(query.get('q') ?? '').trim();
+    if (!q) return sendJson(res, 200, { results: [] });
+    let servers;
+    try {
+      servers = await searchMcpRegistry(q, { limit: 15 });
+    } catch (error) {
+      return sendError(res, 502, `No pude consultar el registro MCP: ${error.message}`);
+    }
+    const installed = new Set(ctx.mergedMcpServers().map((s) => s.id));
+    sendJson(res, 200, {
+      results: servers.map(registryServerToCandidate).map((c) => ({ ...c, installed: installed.has(c.id) })),
+    });
   });
 
   route('POST', '/api/mcp/import', async ({ req, res }) => {
     const body = await readJson(req);
     let record;
     try {
-      if (body.json !== undefined || body.config !== undefined) {
+      if (body.catalog) {
+        const entry = mcpCatalogEntry(String(body.catalog));
+        if (!entry) return sendError(res, 404, 'Ese servidor no está en el catálogo.');
+        record = entry;
+      } else if (body.json !== undefined || body.config !== undefined) {
         record = normalizeMcpConfig(body.json ?? body.config, body.id);
       } else if (body.name) {
         const server = await getMcpRegistryServer(String(body.name), { strict: true });

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

@@ -1,58 +1,79 @@
 import { startTunnel } from '../lib/core.js';
 import { readJson, sendJson, sendError } from '../lib/http.js';
+import { requireLocal, localOk } from '../lib/workspace.js';
 
 /**
- * Preview de un dev server para acceso remoto: abre un tunel aparte al puerto
- * del proceso (asi el celular puede embeber la app aunque este detras del
- * tunel del harness). Devuelve `{ close }` para liberar el tunel al apagar.
+ * Preview de un dev server para acceso remoto. Con `tailscale` publica el puerto
+ * en el tailnet (`tailscale serve --https=8443`, privado); con `tunnelmole` abre
+ * un tunel publico. El estado vive en memoria y se expone en `GET /api/preview`
+ * para que el cliente lo recupere tras una recarga. Devuelve `{ close }` para
+ * liberar el tunel al apagar.
  */
 export function registerPreview(route, ctx) {
   let tunnel = null;
 
+  const view = (t) => (t ? { url: t.url, port: t.port, provider: t.provider } : null);
+
+  const stopCurrent = () => {
+    try {
+      tunnel?.stop?.();
+    } catch {
+      // ignore
+    }
+    tunnel = null;
+  };
+
   route('GET', '/api/preview', ({ res }) => {
-    sendJson(res, 200, { tunnel: tunnel ? { url: tunnel.url, port: tunnel.port } : null });
+    sendJson(res, 200, { tunnel: view(tunnel) });
   });
 
   route('POST', '/api/preview/tunnel', async ({ req, res }) => {
+    if (!ctx.authEnabled && !requireLocal(req, res, 'Abrir túneles solo está disponible en conexiones locales.')) {
+      return;
+    }
     const body = await readJson(req);
     const port = Number(body.port);
     if (!Number.isInteger(port) || port < 1 || port > 65535) return sendError(res, 400, 'Puerto inválido.');
-    if (tunnel) {
-      try {
-        tunnel.stop?.();
-      } catch {
-        // ignore
-      }
-      tunnel = null;
+    // Remoto autenticado: solo puertos de procesos que el server ya corre.
+    if (ctx.authEnabled && !localOk(req)) {
+      const known = ctx.procs?.list?.().some((proc) => proc.running && proc.port === port);
+      if (!known) return sendError(res, 403, 'Solo podés exponer puertos de procesos activos.');
     }
-    const provider = ctx.config.preview?.provider || 'tunnelmole';
+
+    const preview = ctx.config.preview || {};
+    const provider = String(body.provider || preview.provider || 'tailscale').toLowerCase();
+    const httpsPort = Number(preview.tailscalePort) || 8443;
+
+    stopCurrent();
+    let started;
     try {
-      const started = await startTunnel(port, provider);
-      tunnel = { url: started.url, port, stop: started.stop };
-      sendJson(res, 200, { tunnel: { url: tunnel.url, port } });
+      started = await startTunnel(port, provider, { preview: true, httpsPort });
     } catch (error) {
-      sendError(res, 502, `No se pudo abrir el túnel: ${error.message}`);
+      if (provider !== 'tunnelmole' && preview.fallback !== false) {
+        try {
+          started = await startTunnel(port, 'tunnelmole');
+        } catch (fallbackError) {
+          return sendError(res, 502, `No se pudo abrir el túnel: ${fallbackError.message}`);
+        }
+      } else {
+        return sendError(res, 502, `No se pudo abrir el túnel: ${error.message}`);
+      }
     }
+    tunnel = { url: started.url, port, provider: started.provider, stop: started.stop };
+    sendJson(res, 200, { tunnel: view(tunnel) });
   });
 
-  route('DELETE', '/api/preview/tunnel', ({ res }) => {
-    try {
-      tunnel?.stop?.();
-    } catch {
-      // ignore
+  route('DELETE', '/api/preview/tunnel', ({ req, res }) => {
+    if (!ctx.authEnabled && !requireLocal(req, res, 'Cerrar túneles solo está disponible en conexiones locales.')) {
+      return;
     }
-    tunnel = null;
+    stopCurrent();
     sendJson(res, 200, { ok: true });
   });
 
   return {
     close() {
-      try {
-        tunnel?.stop?.();
-      } catch {
-        // ignore
-      }
-      tunnel = null;
+      stopCurrent();
     },
   };
 }

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

@@ -1,4 +1,4 @@
-import { detectProcs, killPort } from '../lib/core.js';
+import { detectProcs, killPort, portInfo } from '../lib/core.js';
 import { readJson, sendJson, sendError } from '../lib/http.js';
 import { requireLocal, resolveDirOr400 } from '../lib/workspace.js';
 
@@ -8,9 +8,11 @@ export function registerProcs(route, ctx) {
   });
 
   route('GET', '/api/procs/detect', ({ res, query }) => {
+    if (!ctx.procsEnabled) return sendJson(res, 200, { cwd: ctx.cwd, chips: [] });
     const dir = resolveDirOr400(res, query.get('cwd'), ctx.cwd);
     if (!dir) return;
-    sendJson(res, 200, { cwd: dir, chips: detectProcs(dir) });
+    const chips = detectProcs(dir).map((chip) => ({ ...chip, allowed: ctx.procs.allows(chip.command) }));
+    sendJson(res, 200, { cwd: dir, chips });
   });
 
   route('POST', '/api/procs/start', async ({ req, res }) => {
@@ -43,7 +45,7 @@ export function registerProcs(route, ctx) {
     sendJson(res, 200, { ok: true });
   });
 
-  route('POST', '/api/procs/kill', async ({ req, res }) => {
+  async function killPortHandler({ req, res }) {
     if (!requireLocal(req, res, 'Matar procesos solo está disponible en conexiones locales.')) {
       return;
     }
@@ -53,5 +55,20 @@ export function registerProcs(route, ctx) {
     } catch (error) {
       sendError(res, 400, error.message);
     }
+  }
+
+  route('POST', '/api/procs/kill', killPortHandler);
+
+  route('POST', '/api/ports/kill', killPortHandler);
+
+  route('GET', '/api/ports/:port', async ({ req, res, params }) => {
+    if (!requireLocal(req, res, 'Consultar puertos solo está disponible en conexiones locales.')) {
+      return;
+    }
+    try {
+      sendJson(res, 200, await portInfo(params.port));
+    } catch (error) {
+      sendError(res, 400, error.message);
+    }
   });
 }

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

@@ -78,6 +78,8 @@ export function registerProviders(route, ctx) {
     maxOutputTokens: ctx.effectiveMaxOutputTokens(),
     defaultCwd: ctx.store.getSetting('defaultCwd') || '',
     strictScope: ctx.effectiveStrictScope(),
+    mcpMode: ctx.effectiveMcpMode(),
+    mcpPinned: ctx.effectiveMcpPinned(),
   });
 
   route('GET', '/api/settings', ({ res }) => {
@@ -91,6 +93,16 @@ export function registerProviders(route, ctx) {
     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);
     if (body.strictScope !== undefined) ctx.store.setSetting('strictScope', Boolean(body.strictScope));
+    if (body.mcpMode !== undefined) {
+      const mode = String(body.mcpMode);
+      ctx.store.setSetting('mcpMode', ['auto', 'eager', 'lazy'].includes(mode) ? mode : 'auto');
+    }
+    if (body.mcpPinned !== undefined) {
+      const list = Array.isArray(body.mcpPinned)
+        ? body.mcpPinned.map((v) => String(v).trim()).filter(Boolean)
+        : String(body.mcpPinned).split(/[\s,]+/).map((v) => v.trim()).filter(Boolean);
+      ctx.store.setSetting('mcpPinned', list);
+    }
     for (const key of ['maxRounds', 'maxTokens', 'maxDurationMs', 'maxOutputTokens']) {
       if (body[key] === undefined) continue;
       const value = Number(body[key]);

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

@@ -6,7 +6,7 @@ import { rewindSession, checkpointTurns } from '../lib/checkpoints.js';
 
 export function registerSessions(route, ctx) {
   route('GET', '/api/sessions', ({ res }) => {
-    const awaiting = awaitingBySession(ctx.approvals.list());
+    const awaiting = awaitingBySession([...ctx.approvals.list(), ...ctx.questions.list()]);
     const sessions = ctx.store.listSessions(50).map((session) => sessionState(session, ctx, awaiting.get(session.id) ?? 0));
     sendJson(res, 200, { sessions });
   });
@@ -68,6 +68,8 @@ export function registerSessions(route, ctx) {
       // 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 }),
+      // Idem para los formularios interactivos (`ask_user`).
+      questions: ctx.questions.list({ sessionId: params.id }),
     });
   });
 

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

@@ -1,8 +1,18 @@
 import path from 'node:path';
-import { homeDir, parseSkillRef, fetchSkillFromGithub, writeSkillFiles } from '../lib/core.js';
+import {
+  homeDir,
+  parseSkillRef,
+  fetchSkillFromGithub,
+  searchSkillsGithub,
+  writeSkillFiles,
+  SKILLS_CATALOG,
+  skillCatalogEntry,
+  envValue,
+} from '../lib/core.js';
 import { readJson, sendJson, sendError } from '../lib/http.js';
 import {
   SKILL_ID_PATTERN,
+  allSkills,
   skillsView,
   findSkill,
   writeSkill,
@@ -46,6 +56,43 @@ export function registerSkills(route, ctx) {
     sendJson(res, 200, { skills: skillsView(ctx) });
   });
 
+  route('GET', '/api/skills/catalog', ({ res }) => {
+    sendJson(res, 200, {
+      catalog: SKILLS_CATALOG.map((entry) => ({
+        id: entry.id,
+        name: entry.name,
+        description: entry.description ?? '',
+        when: entry.when ?? '',
+        installed: Boolean(findSkill(ctx, entry.id)),
+      })),
+    });
+  });
+
+  route('GET', '/api/skills/search', async ({ res, query }) => {
+    const q = String(query.get('q') ?? '').trim();
+    if (!q) return sendJson(res, 200, { results: [] });
+    let results;
+    try {
+      results = await searchSkillsGithub(q, { token: envValue(['GITHUB_TOKEN', 'GH_TOKEN']) });
+    } catch (error) {
+      return sendError(res, 502, `No pude buscar en GitHub: ${error.message}`);
+    }
+    const installed = new Set(allSkills(ctx.cwd).map((s) => s.id));
+    sendJson(res, 200, { results: results.map((r) => ({ ...r, installed: installed.has(r.slug || r.repo) })) });
+  });
+
+  /** Instala una skill del catalogo (queda deshabilitada hasta que la prendan). */
+  route('POST', '/api/skills', async ({ req, res }) => {
+    const body = await readJson(req);
+    const entry = skillCatalogEntry(String(body.id ?? ''));
+    if (!entry) return sendError(res, 404, 'Esa skill no está en el catálogo.');
+    const id = sanitizeId(entry.id);
+    if (!SKILL_ID_PATTERN.test(id)) return sendError(res, 500, 'Id de skill inválido.');
+    await writeSkill(id, { name: entry.name, description: entry.description, when: entry.when, body: entry.body });
+    setSkillEnabled(ctx.store, id, false);
+    sendJson(res, 200, { installed: id, skills: skillsView(ctx) });
+  });
+
   route('GET', '/api/skills/:id', ({ res, params }) => {
     const skill = findSkill(ctx, params.id);
     if (!skill) return sendError(res, 404, 'Skill no encontrada.');

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

@@ -14,7 +14,8 @@ import { sessionState, awaitingBySession } from '../lib/sessionView.js';
 export function registerState(route, ctx) {
   route('GET', '/api/state', ({ res }) => {
     const permissions = ctx.approvals.list();
-    const awaiting = awaitingBySession(permissions);
+    const questions = ctx.questions.list();
+    const awaiting = awaitingBySession([...permissions, ...questions]);
     const sessions = ctx.store.listSessions(50).map((session) => sessionState(session, ctx, awaiting.get(session.id) ?? 0));
     sendJson(res, 200, {
       sessions,
@@ -25,6 +26,12 @@ export function registerState(route, ctx) {
         args,
         requestedAt,
       })),
+      questions: questions.map(({ askId, sessionId, title, requestedAt }) => ({
+        askId,
+        sessionId,
+        title,
+        requestedAt,
+      })),
       // Para que el cliente pueda detectar que el server va en otro reloj.
       now: Date.now(),
     });

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

@@ -12,6 +12,9 @@ import {
   resolveApiKey,
   composeProviderSettings,
   buildMcpRegistry,
+  buildMcpIndex,
+  useLazyMcp,
+  MCP_AUTO_THRESHOLD,
   readPackageVersion,
   scopeDirective,
 } from './lib/core.js';
@@ -20,6 +23,7 @@ import { createPromptBuilder, DEFAULT_SYSTEM_PROMPT } from './lib/prompt.js';
 import { profilePrompt, resolveProfile } from './lib/profile.js';
 import { skillsBlock } from './lib/skills.js';
 import { createApprovalBroker } from './lib/approvals.js';
+import { createQuestionBroker } from './lib/questions.js';
 import { createPresence } from './lib/presence.js';
 import { createRunManager } from './lib/runManager.js';
 import { createProcManager } from './lib/procs.js';
@@ -91,6 +95,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 questions = createQuestionBroker({ timeoutMs: config.questionTimeoutMs });
   const presence = createPresence();
   const runs = createRunManager({ store });
   const procs = createProcManager({ allow: config.processes?.allow });
@@ -122,11 +127,17 @@ export async function createTamnoraServer({
   };
 
   let mcpPromise = null;
+  let mcpMeta = null;
   const getMcp = async () => {
     if (!loadMcp) return null;
     const servers = mergedMcpServers().filter((s) => s.enabled !== false);
     if (!servers.length) return null;
-    if (!mcpPromise) mcpPromise = buildMcpRegistry(servers);
+    if (!mcpPromise) {
+      mcpPromise = buildMcpRegistry(servers).then((registry) => {
+        mcpMeta = { total: registry.definitions.length, index: buildMcpIndex(registry.tools ?? []) };
+        return registry;
+      });
+    }
     return mcpPromise;
   };
 
@@ -138,6 +149,7 @@ export async function createTamnoraServer({
       // ignore MCP shutdown errors
     }
     mcpPromise = null;
+    mcpMeta = null;
   };
 
   const customProviderDefs = () =>
@@ -168,6 +180,24 @@ export async function createTamnoraServer({
   const effectiveMaxDurationMs = () => settingNumber('maxDurationMs', config.maxDurationMs);
   const effectiveMaxOutputTokens = () => settingNumber('maxOutputTokens', config.maxOutputTokens);
   const effectiveStrictScope = () => store.getSetting('strictScope') === true;
+  const MCP_MODES = new Set(['auto', 'eager', 'lazy']);
+  const effectiveMcpMode = () => {
+    const value = String(store.getSetting('mcpMode') ?? config.mcpMode ?? 'auto');
+    return MCP_MODES.has(value) ? value : 'auto';
+  };
+  const effectiveMcpPinned = () => {
+    const stored = store.getSetting('mcpPinned');
+    if (Array.isArray(stored)) return stored.map(String);
+    return Array.isArray(config.mcpPinned) ? config.mcpPinned.map(String) : [];
+  };
+  // Indice de tools MCP (para carga diferida con `mcp_call`): solo si el modo
+  // es diferido y el registro ya se conecto. Se rearma con cada `reloadMcp`.
+  const mcpText = () => {
+    if (!mcpMeta?.index) return '';
+    const total = mcpMeta.total;
+    if (!useLazyMcp(effectiveMcpMode(), total, MCP_AUTO_THRESHOLD)) return '';
+    return mcpMeta.index;
+  };
 
   const ctx = {
     cwd,
@@ -176,6 +206,7 @@ export async function createTamnoraServer({
     authEnabled,
     store,
     approvals,
+    questions,
     presence,
     runs,
     isAutoApprove,
@@ -189,6 +220,9 @@ export async function createTamnoraServer({
     effectiveMaxDurationMs,
     effectiveMaxOutputTokens,
     effectiveStrictScope,
+    effectiveMcpMode,
+    effectiveMcpPinned,
+    mcpText,
     providerSettings,
     customProviderDefs,
     apiKeyFor: (id) => resolveApiKey(providerSettings(id).apiKey, process.env),
@@ -212,6 +246,7 @@ export async function createTamnoraServer({
     files: config.instructions,
     profileText: () => profilePrompt(resolveProfile(ctx.app)),
     skillsText: () => skillsBlock(ctx),
+    mcpText: () => ctx.mcpText(),
     scopeText: () => scopeDirective(ctx.effectiveStrictScope()),
     ruleFiles: config.rules ?? [],
     memory: config.memory?.enabled !== false,
@@ -377,6 +412,7 @@ export async function createTamnoraServer({
 
   const close = async () => {
     approvals.cancelAll();
+    questions.cancelAll();
     runs.cancelAll();
     ctx.scheduler?.stop();
     channels.stop();

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

@@ -0,0 +1,111 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtemp, writeFile, unlink } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { createTamnoraServer } from '../src/index.js';
+import { setHome, bridgeStatePath } from '../../core/src/index.js';
+
+async function startServer() {
+  const cwd = await mkdtemp(path.join(tmpdir(), 'tamnora-preview-'));
+  setHome(cwd);
+  // provider "none": la ruta no lanza un tunel real en los tests.
+  await writeFile(path.join(cwd, 'tamnora.json'), JSON.stringify({ preview: { provider: 'none' } }));
+  const instance = await createTamnoraServer({
+    cwd,
+    dbPath: path.join(cwd, 'tamnora.db'),
+    loadMcp: false,
+    telegram: false,
+  });
+  const info = await instance.listen({ port: 0 });
+  return { instance, base: info.url, cwd };
+}
+
+/** Deja un bridge.json apuntando a un tunel publico vivo (este proceso). */
+async function fakePublicTunnel() {
+  await writeFile(
+    bridgeStatePath(),
+    `${JSON.stringify({ pid: process.pid, url: 'https://fake.tunnelmole.net', provider: 'tunnelmole', port: 4517 })}\n`
+  );
+}
+
+async function clearTunnel() {
+  try {
+    await unlink(bridgeStatePath());
+  } catch {
+    /* nada */
+  }
+}
+
+test('GET /api/preview arranca sin tunel', async () => {
+  const { instance, base } = await startServer();
+  try {
+    const data = await (await fetch(`${base}/api/preview`)).json();
+    assert.equal(data.tunnel, null);
+  } finally {
+    await clearTunnel();
+    await instance.close();
+  }
+});
+
+test('POST/GET/DELETE /api/preview/tunnel mantiene el estado', async () => {
+  const { instance, base } = await startServer();
+  try {
+    const post = await fetch(`${base}/api/preview/tunnel`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ port: 8080 }),
+    });
+    assert.equal(post.status, 200);
+    const created = await post.json();
+    assert.equal(created.tunnel.port, 8080);
+    assert.equal(created.tunnel.provider, 'none');
+
+    const got = await (await fetch(`${base}/api/preview`)).json();
+    assert.equal(got.tunnel.port, 8080);
+
+    const del = await fetch(`${base}/api/preview/tunnel`, { method: 'DELETE' });
+    assert.equal(del.status, 200);
+    const after = await (await fetch(`${base}/api/preview`)).json();
+    assert.equal(after.tunnel, null);
+  } finally {
+    await clearTunnel();
+    await instance.close();
+  }
+});
+
+test('POST /api/preview/tunnel rechaza un puerto invalido', async () => {
+  const { instance, base } = await startServer();
+  try {
+    const post = await fetch(`${base}/api/preview/tunnel`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ port: 0 }),
+    });
+    assert.equal(post.status, 400);
+  } finally {
+    await clearTunnel();
+    await instance.close();
+  }
+});
+
+test('con un tunel publico activo el preview queda cerrado para no locales', async () => {
+  const { instance, base } = await startServer();
+  try {
+    await fakePublicTunnel();
+    await new Promise((resolve) => setTimeout(resolve, 1100));
+
+    const post = await fetch(`${base}/api/preview/tunnel`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ port: 8080 }),
+    });
+    assert.equal(post.status, 403);
+
+    const del = await fetch(`${base}/api/preview/tunnel`, { method: 'DELETE' });
+    assert.equal(del.status, 403);
+  } finally {
+    await clearTunnel();
+    await instance.close();
+  }
+});