@danieltmn/tamnora 0.25.0 → 0.26.0

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

@@ -3,7 +3,7 @@ import net from 'node:net';
 import os from 'node:os';
 import path from 'node:path';
 import { sendError } from './http.js';
-import { tunnelState, realpathDeep } from './core.js';
+import { realpathDeep } from './core.js';
 
 /** True for 127.x / ::1 / ::ffff:127.x addresses. */
 export function isLoopback(address) {
@@ -13,19 +13,17 @@ export function isLoopback(address) {
 
 /**
  * "Local de verdad": el par TCP es loopback (remoteAddress, no localAddress:
- * esa es la direccion donde bindea el server, siempre 127.0.0.1) y no hay un
- * tunel publico activo. Con el tunel abierto las peticiones remotas TAMBIEN
- * llegan desde loopback (el cliente del tunel corre en la misma maquina), asi
- * que la ausencia de tunel es parte del check.
+ * esa es la direccion donde bindea el server, siempre 127.0.0.1). El bridge de
+ * tailscale tambien entra por loopback, asi que sigue siendo local.
  */
 export function localOk(req) {
-  return isLoopback(req?.socket?.remoteAddress) && !tunnelState();
+  return isLoopback(req?.socket?.remoteAddress);
 }
 
 /** `localOk` o 403. Devuelve true si la request puede seguir. */
 export function requireLocal(req, res, mensaje = 'Solo disponible en conexiones locales.') {
   if (localOk(req)) return true;
-  sendError(res, 403, tunnelState() ? `${mensaje} Hay un túnel público activo.` : mensaje);
+  sendError(res, 403, mensaje);
   return false;
 }
 
@@ -35,7 +33,7 @@ export function requireLocal(req, res, mensaje = 'Solo disponible en conexiones
 // victima contra 127.0.0.1 no puede ejecutar nada.
 // ---------------------------------------------------------------------------
 
-const TRUSTED_HOST_SUFFIXES = ['.ts.net', '.tunnelmole.net', '.localhost'];
+const TRUSTED_HOST_SUFFIXES = ['.ts.net', '.localhost'];
 
 /** Hostname (sin puerto, sin brackets de IPv6) del header `Host`. */
 export function hostNameOf(hostHeader) {
@@ -60,9 +58,9 @@ function normalizeHost(host) {
 
 /**
  * Guarda DNS-rebinding: el `Host` debe ser un nombre que controlamos — una IP
- * literal, localhost, el hostname de la maquina, un dominio de tailscale o del
- * tunel, o una lista explicita (`config.server.allowedHosts`). Una pagina que
- * rebindee su dominio hacia 127.0.0.1 llega con `Host: <su dominio>` y cae aca.
+ * literal, localhost, el hostname de la maquina, un dominio de tailscale, o una
+ * lista explicita (`config.server.allowedHosts`). Una pagina que rebindee su
+ * dominio hacia 127.0.0.1 llega con `Host: <su dominio>` y cae aca.
  */
 export function trustedHost(req, allowed = []) {
   const host = hostNameOf(req?.headers?.host);

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

@@ -0,0 +1,88 @@
+import { readJson, sendJson, sendError } from '../lib/http.js';
+import { normalizeEffort, resolveMode } from '../lib/core.js';
+import {
+  AGENT_ID_PATTERN,
+  agentsView,
+  findAgent,
+  writeAgent,
+  removeAgent,
+  setAgentEnabled,
+} from '../lib/agents.js';
+
+function cleanList(value) {
+  if (value === undefined || value === null) return null;
+  if (!Array.isArray(value)) return null;
+  return value.map((item) => String(item).trim()).filter(Boolean);
+}
+
+export function registerAgents(route, ctx) {
+  route('GET', '/api/agents', ({ res }) => {
+    sendJson(res, 200, { agents: agentsView(ctx) });
+  });
+
+  route('GET', '/api/agents/:id', ({ res, params }) => {
+    const agent = findAgent(ctx, params.id);
+    if (!agent) return sendError(res, 404, 'Subagente no encontrado.');
+    sendJson(res, 200, {
+      agent: {
+        id: agent.id,
+        name: agent.name || agent.id,
+        description: agent.description || '',
+        model: agent.model || '',
+        provider: agent.provider || '',
+        mode: agent.mode || '',
+        effort: agent.effort || '',
+        maxRounds: agent.maxRounds || 0,
+        tools: agent.tools,
+        skills: agent.skills,
+        body: agent.body,
+        removable: Boolean(agent.home),
+      },
+    });
+  });
+
+  route('PUT', '/api/agents/:id', async ({ req, res, params }) => {
+    const id = String(params.id);
+    if (!AGENT_ID_PATTERN.test(id)) return sendError(res, 400, 'Id de subagente inválido (a-z, 0-9, - y _).');
+    const body = await readJson(req);
+    if (!String(body.body ?? '').trim() && !String(body.description ?? '').trim()) {
+      return sendError(res, 400, 'El subagente necesita un cuerpo o una descripción.');
+    }
+    const mode = body.mode ? resolveMode(String(body.mode)).id : '';
+    const maxRounds = Number(body.maxRounds);
+    try {
+      await writeAgent(id, {
+        name: String(body.name ?? id).trim() || id,
+        description: String(body.description ?? '').trim(),
+        model: String(body.model ?? '').trim(),
+        provider: String(body.provider ?? '').trim(),
+        mode,
+        effort: normalizeEffort(body.effort),
+        maxRounds: Number.isFinite(maxRounds) && maxRounds > 0 ? Math.round(maxRounds) : 0,
+        tools: cleanList(body.tools),
+        skills: cleanList(body.skills),
+        body: String(body.body ?? ''),
+      });
+    } catch (error) {
+      return sendError(res, 500, `No se pudo guardar el subagente: ${error.message}`);
+    }
+    sendJson(res, 200, { agents: agentsView(ctx) });
+  });
+
+  route('DELETE', '/api/agents/:id', async ({ res, params }) => {
+    const agent = findAgent(ctx, params.id);
+    if (!agent) return sendError(res, 404, 'Subagente no encontrado.');
+    if (!agent.home) return sendError(res, 400, 'Ese subagente vive en el workspace y no se borra desde acá.');
+    await removeAgent(agent.id);
+    setAgentEnabled(ctx.store, agent.id, true);
+    sendJson(res, 200, { agents: agentsView(ctx) });
+  });
+
+  route('POST', '/api/agents/:id/toggle', async ({ res, params }) => {
+    const agent = findAgent(ctx, params.id);
+    if (!agent) return sendError(res, 404, 'Subagente no encontrado.');
+    const enabled = !agentsView(ctx).find((item) => item.id === agent.id)?.enabled;
+    setAgentEnabled(ctx.store, agent.id, enabled);
+    sendJson(res, 200, { id: agent.id, enabled, agents: agentsView(ctx) });
+  });
+}

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

@@ -3,11 +3,13 @@ import {
   runAgent,
   createTools,
   resolveMode,
+  normalizeEffort,
   MAX_TOOL_ROUNDS,
 } from '../lib/core.js';
 import { openSse, readJson, sendJson, sendError } from '../lib/http.js';
 import { workspaceForRequest, resolveExistingDir, localOk } from '../lib/workspace.js';
 import { createSubagentTool } from '../lib/tasks.js';
+import { enabledAgents } from '../lib/agents.js';
 import {
   combineToolset,
   combineLifecycle,
@@ -18,7 +20,6 @@ import {
   toolResultPayload,
 } from '../lib/agentRun.js';
 import { fraseInicio, fraseFin, fraseError, createFiltroTools } from '../lib/announcer.js';
-import { resolveAdvisor, advisorShouldRun, consultAdvisor } from '../lib/advisor.js';
 import { maybeAutoCompact } from '../lib/compact.js';
 import { createRulesInjector } from '../lib/rules.js';
 import { createCheckpointer } from '../lib/checkpoints.js';
@@ -162,6 +163,8 @@ export function registerChat(route, ctx) {
     const model = body.model || session?.model || ctx.effectiveModel();
     if (!model) return sendError(res, 400, 'Falta "model" (en el cuerpo, en Ajustes o en tamnora.json).');
     const mode = resolveMode(body.mode ?? session?.meta?.mode ?? ctx.store.getSetting('activeMode'));
+    // Esfuerzo de razonamiento: cuerpo > sesión > default global/config.
+    const effort = normalizeEffort(body.effort ?? session?.meta?.effort ?? ctx.effectiveEffort?.());
 
     if (!sessionId) {
       try {
@@ -174,7 +177,7 @@ export function registerChat(route, ctx) {
         provider: providerId,
         model,
         cwd: sessionCwd,
-        meta: { mode: mode.id },
+        meta: { mode: mode.id, effort },
       });
     }
 
@@ -209,6 +212,7 @@ export function registerChat(route, ctx) {
       provider: providerId,
       model,
       mode: mode.id,
+      effort,
       cwd: sessionCwd,
       say: fraseInicio(),
     });
@@ -271,6 +275,8 @@ export function registerChat(route, ctx) {
       providerId,
       model,
       parentMode: mode,
+      effort,
+      agents: enabledAgents(ctx),
       permissions: ctx.config.permissions,
       mcp,
       mcpMode: ctx.effectiveMcpMode(),
@@ -347,6 +353,7 @@ export function registerChat(route, ctx) {
           maxDurationMs: Number(body.maxDurationMs) || ctx.effectiveMaxDurationMs?.() || 0,
           maxOutputTokens: Number(body.maxOutputTokens) || ctx.effectiveMaxOutputTokens?.() || 0,
           promptCaching: ctx.effectivePromptCaching?.() ?? ctx.config.promptCaching === true,
+          reasoningEffort: effort,
           stallWarnMs: body.stallWarnMs ?? ctx.config.stallWarnMs,
           contextTokens,
           onEvent(event) {
@@ -411,48 +418,6 @@ export function registerChat(route, ctx) {
             durationMs,
             say: fraseFin({ stopReason: result.stopReason, rounds: result.rounds, toolCalls, durationMs }),
           });
-
-        // El asesor va despues del `done` pero antes del `finally`, asi el run
-        // sigue vivo y el evento llega/persiste. Puede quedarse callado.
-        const advisorOptions = resolveAdvisor(ctx.app);
-        if (
-          result.stopReason !== 'aborted' &&
-          advisorOptions.enabled &&
-          advisorShouldRun({ toolCalls, answer: result.content })
-        ) {
-          // El asesor puede tener proveedor/modelo propios; si no, usa los activos.
-          let advisorProvider = provider;
-          let advisorConfig = config;
-          let advisorModel = model;
-          if (advisorOptions.provider || advisorOptions.model) {
-            const resolved = resolveProviderFor(ctx, advisorOptions.provider || providerId);
-            advisorProvider = resolved.provider;
-            advisorConfig = resolved.config;
-            advisorModel = advisorOptions.model || model;
-          }
-          const advice = await consultAdvisor({
-            provider: advisorProvider,
-            config: advisorConfig,
-            model: advisorModel,
-            signal: ctx.runs.signal(sessionId),
-            userInput: input,
-            answer: result.content,
-            messages: newMessages,
-            options: advisorOptions,
-          });
-          // Un solo mensaje (estilo Jarvis): el asesor arranca con el resumen y
-          // sigue con la alerta/consejo en el mismo texto. Una sola locucion.
-          if (advice?.speak) {
-            ctx.store.addMessage(sessionId, {
-              role: 'assistant',
-              name: 'advisor',
-              content: advice.text,
-              mode: advice.kind,
-            });
-            ctx.runs.emit(sessionId, 'advice', { text: advice.text, kind: advice.kind, say: advice.text });
-            ctx.hooks?.dispatch({ type: 'advice', sessionId, text: advice.text, kind: advice.kind });
-          }
-        }
       } catch (error) {
         partials.flush();
         if (error?.name === 'AbortError') ctx.runs.emit(sessionId, 'aborted', { say: fraseFin({ stopReason: 'aborted' }) });

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

@@ -3,11 +3,10 @@ import { readJson, sendJson, sendError } from '../lib/http.js';
 import { requireLocal, localOk } from '../lib/workspace.js';
 
 /**
- * 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.
+ * Preview de un dev server para acceso remoto: publica el puerto en el tailnet
+ * (`tailscale serve --https=8443`, privado). 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;
@@ -49,23 +48,7 @@ export function registerPreview(route, ctx) {
     try {
       started = await startTunnel(port, provider, { preview: true, httpsPort });
     } catch (error) {
-      // El fallback a tunnelmole es un tunel PUBLICO: solo con consentimiento
-      // explicito (`allowPublic` o `preview.fallback: true`). Quien pidio un
-      // tunel privado no puede quedar expuesto sin saberlo.
-      const allowPublic = body.allowPublic === true || preview.fallback === true;
-      if (provider !== 'tunnelmole' && allowPublic) {
-        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}. Si querés exponerlo con tunnelmole (público), reintentá con ese proveedor.`
-        );
-      }
+      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) });

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

@@ -1,4 +1,4 @@
-import { detectProcs, killPort, portInfo } from '../lib/core.js';
+import { loadProjectProcs, killPort, portInfo } from '../lib/core.js';
 import { readJson, sendJson, sendError } from '../lib/http.js';
 import { requireLocal, resolveDirOr400 } from '../lib/workspace.js';
 
@@ -11,7 +11,7 @@ export function registerProcs(route, ctx) {
     if (!ctx.procsEnabled) return sendJson(res, 200, { cwd: ctx.cwd, chips: [] });
     const dir = resolveDirOr400(res, query.get('cwd'), ctx.cwd);
     if (!dir) return;
-    const chips = detectProcs(dir).map((chip) => ({ ...chip, allowed: ctx.procs.allows(chip.command) }));
+    const chips = loadProjectProcs(dir).map((chip) => ({ ...chip, allowed: ctx.procs.allows(chip.command) }));
     sendJson(res, 200, { cwd: dir, chips });
   });
 
@@ -53,8 +53,6 @@ export function registerProcs(route, ctx) {
     }
   }
 
-  route('POST', '/api/procs/kill', killPortHandler);
-
   route('POST', '/api/ports/kill', killPortHandler);
 
   route('GET', '/api/ports/:port', async ({ req, res, params }) => {

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

@@ -7,6 +7,7 @@ import {
   readApp,
   writeApp,
   maskSecret,
+  normalizeEffort,
 } from '../lib/core.js';
 import { resolveAppearance, sanitizeAppearance } from '../lib/appearance.js';
 import { readJson, sendJson, sendError } from '../lib/http.js';
@@ -26,6 +27,7 @@ export function providerList(ctx) {
       baseUrl: row?.baseUrl || '',
       defaultBaseUrl: meta.defaultBaseUrl,
       requiresKey: row?.requiresKey ?? meta.requiresKey,
+      reasoning: meta.reasoning ?? 'none',
       custom: false,
       builtin: true,
       stored: Boolean(row),
@@ -44,6 +46,7 @@ export function providerList(ctx) {
         baseUrl: row.baseUrl,
         defaultBaseUrl: '',
         requiresKey: row.requiresKey ?? true,
+        reasoning: 'none',
         custom: true,
         builtin: false,
         stored: true,
@@ -83,6 +86,7 @@ export function registerProviders(route, ctx) {
     maxDurationMs: ctx.effectiveMaxDurationMs(),
     maxOutputTokens: ctx.effectiveMaxOutputTokens(),
     promptCaching: ctx.effectivePromptCaching(),
+    effort: ctx.effectiveEffort(),
     defaultCwd: ctx.store.getSetting('defaultCwd') || '',
     strictScope: ctx.effectiveStrictScope(),
     mcpMode: ctx.effectiveMcpMode(),
@@ -101,6 +105,9 @@ 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.effort !== undefined) {
+      ctx.store.setSetting('activeEffort', normalizeEffort(body.effort) || null);
+    }
     if (body.promptCaching !== undefined) ctx.store.setSetting('promptCaching', Boolean(body.promptCaching));
     if (body.mcpMode !== undefined) {
       const mode = String(body.mcpMode);

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

@@ -1,5 +1,5 @@
 import { readJson, sendJson, sendError } from '../lib/http.js';
-import { resolveMode } from '../lib/core.js';
+import { resolveMode, normalizeEffort } from '../lib/core.js';
 import { workspaceForRequest } from '../lib/workspace.js';
 import { sessionView, sessionState, awaitingBySession } from '../lib/sessionView.js';
 import { summarizeSession, compactSession, SUMMARY_INSTRUCTION } from '../lib/compact.js';
@@ -49,6 +49,7 @@ export function registerSessions(route, ctx) {
     const meta = {};
     if (body.goal) meta.goal = String(body.goal);
     if (body.mode) meta.mode = resolveMode(String(body.mode)).id;
+    if ('effort' in body) meta.effort = normalizeEffort(body.effort);
     const id = ctx.store.createSession({
       title: String(body.title || 'Nueva sesión').slice(0, 80),
       provider: body.provider || ctx.effectiveProviderId(),
@@ -105,6 +106,7 @@ export function registerSessions(route, ctx) {
     const meta = {};
     if ('goal' in body) meta.goal = body.goal ? String(body.goal) : undefined;
     if ('mode' in body) meta.mode = resolveMode(String(body.mode)).id;
+    if ('effort' in body) meta.effort = normalizeEffort(body.effort);
     if (Object.keys(meta).length) patch.meta = meta;
     ctx.store.touchSession(params.id, patch);
     sendJson(res, 200, { session: sessionView(ctx.store.getSession(params.id)) });

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

@@ -40,7 +40,7 @@ export function registerTts(route, ctx) {
     if ('pitch' in body) next.pitch = sanearPitch(body.pitch, actual.pitch);
     if (body.announce && typeof body.announce === 'object') {
       const announce = { ...actual.announce };
-      for (const key of ['start', 'tools', 'end', 'advice', 'answer', 'summary']) {
+      for (const key of ['start', 'tools', 'end', 'answer']) {
         if (key in body.announce) announce[key] = body.announce[key] === true;
       }
       next.announce = announce;

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

@@ -17,6 +17,7 @@ import {
   MCP_AUTO_THRESHOLD,
   readPackageVersion,
   scopeDirective,
+  normalizeEffort,
 } from './lib/core.js';
 import { sendJson, sendError } from './lib/http.js';
 import { requireTrustedHost, requireSameOrigin } from './lib/workspace.js';
@@ -24,6 +25,7 @@ import { applySecurityHeaders, cspMode } from './lib/securityHeaders.js';
 import { createPromptBuilder, DEFAULT_SYSTEM_PROMPT } from './lib/prompt.js';
 import { profilePrompt, resolveProfile } from './lib/profile.js';
 import { skillsBlock } from './lib/skills.js';
+import { agentsIndexPrompt } from './lib/agents.js';
 import { createApprovalBroker } from './lib/approvals.js';
 import { createQuestionBroker } from './lib/questions.js';
 import { createPresence } from './lib/presence.js';
@@ -42,6 +44,7 @@ import { registerModels } from './routes/models.js';
 import { registerProviders } from './routes/providers.js';
 import { registerMcp } from './routes/mcp.js';
 import { registerSkills } from './routes/skills.js';
+import { registerAgents } from './routes/agents.js';
 import { registerMemory } from './routes/memory.js';
 import { registerChannels } from './routes/channels.js';
 import { registerProfile } from './routes/profile.js';
@@ -49,7 +52,6 @@ import { registerTts } from './routes/tts.js';
 import { registerTranscribe } from './routes/transcribe.js';
 import { registerUpdate } from './routes/update.js';
 import { registerReload } from './routes/reload.js';
-import { registerAdvisor } from './routes/advisor.js';
 import { registerProcs } from './routes/procs.js';
 import { registerShell } from './routes/shell.js';
 import { registerPreview } from './routes/preview.js';
@@ -57,7 +59,6 @@ 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';
 import { registerSchedules } from './routes/schedules.js';
 import { createScheduler } from './lib/scheduler.js';
 import { createHookRunner } from './lib/hooks.js';
@@ -96,7 +97,7 @@ export async function createTamnoraServer({
   const config = await loadConfig(cwd);
   const app = readApp();
   const authEnabled = Boolean(app.user && app.user.password);
-  const store = new Store(dbPath ?? databasePath(cwd));
+  const store = new Store(dbPath ?? databasePath());
   const approvals = createApprovalBroker({ timeoutMs: config.approvalTimeoutMs });
   const questions = createQuestionBroker({ timeoutMs: config.questionTimeoutMs });
   const presence = createPresence();
@@ -183,6 +184,7 @@ export async function createTamnoraServer({
   const effectiveMaxDurationMs = () => settingNumber('maxDurationMs', config.maxDurationMs);
   const effectiveMaxOutputTokens = () => settingNumber('maxOutputTokens', config.maxOutputTokens);
   const effectiveStrictScope = () => store.getSetting('strictScope') === true;
+  const effectiveEffort = () => normalizeEffort(store.getSetting('activeEffort') ?? config.effort);
   const effectivePromptCaching = () => {
     const stored = store.getSetting('promptCaching');
     if (stored === null || stored === undefined) return config.promptCaching === true;
@@ -228,6 +230,7 @@ export async function createTamnoraServer({
     effectiveMaxDurationMs,
     effectiveMaxOutputTokens,
     effectiveStrictScope,
+    effectiveEffort,
     effectivePromptCaching,
     effectiveMcpMode,
     effectiveMcpPinned,
@@ -269,6 +272,7 @@ export async function createTamnoraServer({
     files: config.instructions,
     profileText: () => profilePrompt(resolveProfile(ctx.app)),
     skillsText: () => skillsBlock(ctx),
+    agentsText: () => agentsIndexPrompt(ctx),
     mcpText: () => ctx.mcpText(),
     scopeText: () => scopeDirective(ctx.effectiveStrictScope()),
     ruleFiles: config.rules ?? [],
@@ -326,12 +330,12 @@ export async function createTamnoraServer({
   registerProviders(route, ctx);
   registerMcp(route, ctx);
   registerSkills(route, ctx);
+  registerAgents(route, ctx);
   registerMemory(route, ctx);
   registerChannels(route, ctx);
   registerProfile(route, ctx);
   registerTts(route, ctx);
   registerTranscribe(route, ctx);
-  registerAdvisor(route, ctx);
   registerUpdate(route, ctx);
   registerReload(route, ctx);
   registerProcs(route, ctx);
@@ -341,7 +345,6 @@ export async function createTamnoraServer({
   registerEvents(route, ctx);
   registerState(route, ctx);
   registerPresence(route, ctx);
-  registerEval(route, ctx);
   registerSchedules(route, ctx);
 
   route('GET', '/api/hooks', ({ res }) => {