@danieltmn/tamnora 0.21.2 → 0.22.0

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

@@ -125,17 +125,19 @@ export function requireCsrf(app, req, res) {
 // ---------------------------------------------------------------------------
 // Bloqueo por intentos fallidos (en memoria: el server es un proceso).
 // ---------------------------------------------------------------------------
-// La clave usa remoteAddress: X-Forwarded-For lo controla el cliente y con un
-// header falsificado se rotaba de IP y se esquivaba el bloqueo.
+// La clave es solo la IP: con `ip|usuario` cada intento con un nombre distinto
+// tenia su propio contador y el bloqueo se esquivaba rotando el username. Y el
+// usuario se ignora a proposito: X-Forwarded-For lo controla el cliente y con
+// un header falsificado se rotaba de IP y se esquivaba el bloqueo.
 const MAX_ATTEMPTS = 5;
 const WINDOW_MS = 15 * 60 * 1000;
 const LOCK_MS = 15 * 60 * 1000;
 const MAX_KEYS = 256;
 const attempts = new Map();
 
-function clientKey(req, user) {
+function clientKey(req) {
   const ip = (req.socket && req.socket.remoteAddress) || 'desconocido';
-  return `${ip}|${String(user || '').trim().toLowerCase()}`;
+  return String(ip);
 }
 
 function sweepStale(now) {
@@ -146,18 +148,18 @@ function sweepStale(now) {
   }
 }
 
-export function loginLockRemaining(req, user) {
+export function loginLockRemaining(req) {
   const now = Date.now();
-  const st = attempts.get(clientKey(req, user));
+  const st = attempts.get(clientKey(req));
   if (!st || !st.lockUntil) return 0;
   const left = st.lockUntil - now;
   return left > 0 ? Math.ceil(left / 1000) : 0;
 }
 
-export function loginRecordFailure(req, user) {
+export function loginRecordFailure(req) {
   const now = Date.now();
   sweepStale(now);
-  const key = clientKey(req, user);
+  const key = clientKey(req);
   let st = attempts.get(key);
   if (!st || (!st.lockUntil && now - st.first > WINDOW_MS)) st = { count: 0, first: now, lockUntil: 0 };
   st.count += 1;
@@ -165,6 +167,6 @@ export function loginRecordFailure(req, user) {
   attempts.set(key, st);
 }
 
-export function loginClear(req, user) {
-  attempts.delete(clientKey(req, user));
+export function loginClear(req) {
+  attempts.delete(clientKey(req));
 }

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

@@ -49,7 +49,12 @@ export function combineLifecycle(handlers = []) {
     for (const handler of active) {
       const out = await Promise.resolve()
         .then(() => handler(event))
-        .catch(() => undefined);
+        .catch((error) => {
+          // El run no se corta por un handler, pero el fallo no puede ser
+          // invisible: sin esto un hook/regla roto desaparece sin rastro.
+          process.stderr.write(`tamnora: handler de ciclo de vida falló: ${error?.message ?? error}\n`);
+          return undefined;
+        });
       if (out && typeof out === 'object' && typeof out.inject === 'string' && out.inject.trim()) {
         injects.push(out.inject);
       }

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

@@ -520,6 +520,7 @@ export function startTelegramChannel(
         execute,
         toolContext: { cwd, sessionId },
         onLifecycle: createRulesInjector({ cwd, patterns: ctx.config.rules ?? [] }) ?? undefined,
+        redactExtra: ctx.secretExtra?.() ?? [],
         signal: controller.signal,
         maxRounds: ctx.effectiveMaxRounds?.() ?? ctx.config.maxRounds,
         maxTokens: ctx.effectiveMaxTokens?.() ?? 0,

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

@@ -6,6 +6,7 @@
 // cada entrada vence por TTL y el cliente la refresca con un latido.
 
 const DEFAULT_TTL_MS = 90000;
+const MAX_IDS = 256;
 
 /** Tracker en memoria: sessionId -> último latido. */
 export function createPresence({ ttlMs = DEFAULT_TTL_MS, now = Date.now } = {}) {
@@ -13,11 +14,21 @@ export function createPresence({ ttlMs = DEFAULT_TTL_MS, now = Date.now } = {})
 
   const alive = (ts) => now() - ts <= ttlMs;
 
+  const prune = () => {
+    for (const [id, ts] of seen) if (!alive(ts)) seen.delete(id);
+  };
+
   return {
     /** Marca como abiertas (vistas recién) esas sesiones. */
     touch(ids = []) {
       const ts = now();
-      for (const id of ids) if (id) seen.set(String(id), ts);
+      if (seen.size >= MAX_IDS) prune();
+      // Los ids vienen del body: se acotan y se limita el lote, que un cliente
+      // no pueda hacer crecer el Map sin techo.
+      for (const id of [].concat(ids).slice(0, MAX_IDS)) {
+        const key = String(id ?? '').slice(0, 64);
+        if (key) seen.set(key, ts);
+      }
       return this;
     },
     /** Marca como cerradas (quita la sesión sin esperar el TTL). */

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

@@ -41,7 +41,8 @@ async function runAgentSchedule(ctx, schedule) {
   let mcp = null;
   try {
     mcp = await ctx.getMcp();
-  } catch {
+  } catch (error) {
+    process.stderr.write(`tamnora: MCP no disponible en la tarea programada: ${error?.message ?? error}\n`);
     mcp = null;
   }
 
@@ -72,6 +73,7 @@ async function runAgentSchedule(ctx, schedule) {
     cwd,
     providerId,
     model,
+    parentMode: mode,
     permissions: ctx.config.permissions,
     mcp,
     mcpMode: ctx.effectiveMcpMode(),
@@ -100,6 +102,7 @@ async function runAgentSchedule(ctx, schedule) {
       execute,
       toolContext: { cwd, sessionId },
       onLifecycle: createRulesInjector({ cwd, patterns: ctx.config.rules ?? [] }) ?? undefined,
+      redactExtra: ctx.secretExtra?.() ?? [],
       signal,
       maxRounds: ctx.effectiveMaxRounds?.() || MAX_TOOL_ROUNDS,
       maxTokens: ctx.effectiveMaxTokens?.() || 0,
@@ -189,7 +192,13 @@ export function createScheduler(ctx, { intervalMs = 30000, log = () => {} } = {}
 
   function start() {
     if (timer) return;
-    timer = setInterval(() => tick().catch(() => {}), intervalMs);
+    timer = setInterval(
+      () =>
+        tick().catch((error) => {
+          process.stderr.write(`tamnora: tick del planificador falló: ${error?.message ?? error}\n`);
+        }),
+      intervalMs
+    );
     timer.unref?.();
   }
 

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

@@ -20,6 +20,20 @@ function definition(name, description, parameters, required = []) {
   };
 }
 
+/**
+ * El modo del subagente nunca amplia el del padre: Plan solo puede delegar en
+ * solo-lectura y Voz hereda su restriccion de extensiones, aunque el modelo
+ * pida `mode: 'agent'`.
+ */
+function clampMode(requested, parentMode) {
+  const parentTools = Array.isArray(parentMode?.tools) ? parentMode.tools : null;
+  const tools = parentTools
+    ? (requested.tools ?? [...parentTools]).filter((t) => parentTools.includes(t))
+    : (requested.tools ?? null);
+  const writeExtensions = parentMode?.writeExtensions ?? requested.writeExtensions;
+  return { id: requested.id, tools, writeExtensions };
+}
+
 /**
  * Crea la tool `task` para una sesión/run y la función `execute`.
  * `emit(type, data, agentId)` persiste y difunde el evento (via RunManager).
@@ -37,6 +51,7 @@ export function createSubagentTool(ctx, options) {
     signal,
     exclude = [],
     emit,
+    parentMode = null,
   } = options;
 
   const definitions = [
@@ -62,13 +77,14 @@ export function createSubagentTool(ctx, options) {
     if (!prompt) return 'La subtarea necesita "prompt".';
 
     const agentId = ctx.store.createAgent({ sessionId, kind: 'task', title: description, model });
-    const mode = resolveMode(args.mode ?? 'plan');
+    const mode = clampMode(resolveMode(args.mode ?? 'plan'), parentMode);
     emit('agent_start', { agentId, description, mode: mode.id, model }, agentId);
 
-    const enabled =
+    const requested =
       Array.isArray(args.tools) && args.tools.length
         ? args.tools.filter((tool) => !exclude.includes(tool))
-        : mode.tools ?? undefined;
+        : (mode.tools ?? undefined);
+    const enabled = mode.tools ? requested.filter((tool) => mode.tools.includes(tool)) : requested;
     const local = createTools({
       root: cwd,
       enabled,
@@ -98,6 +114,7 @@ export function createSubagentTool(ctx, options) {
         messages,
         tools: local.definitions,
         execute: local.execute,
+        redactExtra: ctx.secretExtra?.() ?? [],
         signal,
         maxRounds: ctx.config.agents?.maxRounds ?? 6,
         maxOutputTokens: ctx.config.agents?.maxOutputTokens ?? ctx.config.maxOutputTokens ?? 0,

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

@@ -1,7 +1,9 @@
 import fs from 'node:fs';
+import net from 'node:net';
+import os from 'node:os';
 import path from 'node:path';
 import { sendError } from './http.js';
-import { tunnelState } from './core.js';
+import { tunnelState, realpathDeep } from './core.js';
 
 /** True for 127.x / ::1 / ::ffff:127.x addresses. */
 export function isLoopback(address) {
@@ -27,6 +29,84 @@ export function requireLocal(req, res, mensaje = 'Solo disponible en conexiones
   return false;
 }
 
+// ---------------------------------------------------------------------------
+// Guardas de request: DNS-rebinding (Host) y CSRF (Origin). Aplican SIEMPRE,
+// con o sin autenticacion: una web maliciosa que abra el navegador de la
+// victima contra 127.0.0.1 no puede ejecutar nada.
+// ---------------------------------------------------------------------------
+
+const TRUSTED_HOST_SUFFIXES = ['.ts.net', '.tunnelmole.net', '.localhost'];
+
+/** Hostname (sin puerto, sin brackets de IPv6) del header `Host`. */
+export function hostNameOf(hostHeader) {
+  const raw = String(hostHeader ?? '').trim().toLowerCase();
+  if (!raw) return '';
+  if (raw.startsWith('[')) {
+    const end = raw.indexOf(']');
+    return end > 0 ? raw.slice(1, end) : raw;
+  }
+  const colon = raw.lastIndexOf(':');
+  const maybePort = colon >= 0 ? raw.slice(colon + 1) : '';
+  return /^\d+$/.test(maybePort) ? raw.slice(0, colon) : raw;
+}
+
+function normalizeHost(host) {
+  return String(host ?? '')
+    .trim()
+    .toLowerCase()
+    .replace(/:80$/, '')
+    .replace(/:443$/, '');
+}
+
+/**
+ * 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.
+ */
+export function trustedHost(req, allowed = []) {
+  const host = hostNameOf(req?.headers?.host);
+  if (!host) return true;
+  if (net.isIP(host)) return true;
+  if (host === 'localhost') return true;
+  if (host === String(os.hostname() ?? '').toLowerCase()) return true;
+  if (TRUSTED_HOST_SUFFIXES.some((s) => host.endsWith(s))) return true;
+  return (allowed ?? []).some((h) => hostNameOf(h) === host);
+}
+
+/** `trustedHost` o 403. Devuelve true si la request puede seguir. */
+export function requireTrustedHost(req, res, allowed = []) {
+  if (trustedHost(req, allowed)) return true;
+  sendError(res, 403, 'Host no reconocido.');
+  return false;
+}
+
+/**
+ * Guarda CSRF: si el navegador manda `Origin`, debe ser el propio server (mismo
+ * host:puerto). Los clientes que no son un navegador no mandan `Origin` y se
+ * aceptan; las webs, incluso las de "simple request" (text/plain), siempre lo
+ * mandan en un POST. `Origin: null` (iframe sandbox, file:) se rechaza.
+ */
+export function sameOrigin(req) {
+  const origin = String(req?.headers?.origin ?? '').trim();
+  if (!origin) return true;
+  if (origin === 'null') return false;
+  let parsed;
+  try {
+    parsed = new URL(origin);
+  } catch {
+    return false;
+  }
+  return normalizeHost(parsed.host) === normalizeHost(req?.headers?.host);
+}
+
+/** `sameOrigin` o 403. Devuelve true si la mutacion puede seguir. */
+export function requireSameOrigin(req, res) {
+  if (sameOrigin(req)) return true;
+  sendError(res, 403, 'Origen de la petición no válido.');
+  return false;
+}
+
 /** Filesystem roots (drive letters on Windows, `/` elsewhere). */
 export function rootDirs() {
   if (process.platform !== 'win32') return ['/'];
@@ -71,11 +151,19 @@ export function resolveDirOr400(res, raw, fallback) {
 }
 
 /** True si `target` es `root` o vive dentro de el (sin salirse por `..`). */
-export function isInside(root, target) {
+function insideLexical(root, target) {
   const rel = path.relative(root, target);
   return rel === '' || (!rel.startsWith('..') && !path.isAbsolute(rel));
 }
 
+/**
+ * Como el chequeo lexico, pero sobre `fs.realpath`: un symlink dentro del
+ * workspace puede apuntar afuera y el lexico no lo ve.
+ */
+export function isInside(root, target) {
+  return insideLexical(root, target) && insideLexical(realpathDeep(root), realpathDeep(target));
+}
+
 /**
  * Workspace for an HTTP request: the requested `cwd` (loopback-only) or the
  * server's default. Throws on invalid input.

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

@@ -31,20 +31,24 @@ export function registerAuth(route, ctx) {
     const password = String(body.password ?? '');
     const user = ctx.app.user;
 
-    const left = loginLockRemaining(req, name);
+    const left = loginLockRemaining(req);
     if (left > 0) {
       sendError(res, 429, `Demasiados intentos. Espera ${left}s.`);
       return;
     }
 
-    const ok = name.toLowerCase() === String(user.name).toLowerCase() && verifyPassword(password, user.password);
+    // Ambas verificaciones corren SIEMPRE: con `name === ... && verify(...)`
+    // el cortocircuito delataba por timing si el usuario existia.
+    const nameOk = name.toLowerCase() === String(user.name).toLowerCase();
+    const passOk = verifyPassword(password, user.password);
+    const ok = nameOk && passOk;
     if (!ok) {
-      loginRecordFailure(req, name);
+      loginRecordFailure(req);
       sendError(res, 401, 'Usuario o contrasena incorrectos');
       return;
     }
 
-    loginClear(req, name);
+    loginClear(req);
     const csrf = startSession(ctx.app, req, res);
     sendJson(res, 200, { ok: true, enabled: true, user: { name: user.name }, csrf });
   });

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

@@ -6,7 +6,7 @@ import {
   MAX_TOOL_ROUNDS,
 } from '../lib/core.js';
 import { openSse, readJson, sendJson, sendError } from '../lib/http.js';
-import { workspaceForRequest, resolveExistingDir } from '../lib/workspace.js';
+import { workspaceForRequest, resolveExistingDir, localOk } from '../lib/workspace.js';
 import { createSubagentTool } from '../lib/tasks.js';
 import {
   combineToolset,
@@ -197,7 +197,11 @@ export function registerChat(route, ctx) {
     // Desconectar no cancela: el run sigue y los eventos quedan persistidos.
     req.on('close', () => unsubscribe());
 
-    const autoApprove = body.yes ?? ctx.yes;
+    // `yes`/`baseUrl` del cuerpo solo valen en conexiones locales: remoto,
+    // auto-aprobar permisos o redirigir el proveedor (con la API key) a un
+    // baseUrl ajeno seria una puerta abierta.
+    const autoApprove = Boolean(localOk(req) ? (body.yes ?? ctx.yes) : ctx.yes);
+    const baseUrlOverride = localOk(req) ? String(body.baseUrl || '') : '';
     const asked = new Set();
 
     ctx.runs.emit(sessionId, 'start', {
@@ -217,7 +221,12 @@ export function registerChat(route, ctx) {
       ctx.runs.emit(sessionId, 'warning', { message: `MCP: ${error?.message ?? error}` });
     }
 
-    const enabled = Array.isArray(body.tools) && body.tools.length ? body.tools : mode.tools ?? undefined;
+    // `body.tools` acota pero nunca amplia: se intersecta con las tools del modo
+    // (un request no puede pedir `bash` en modo Plan).
+    let enabled = mode.tools ?? undefined;
+    if (Array.isArray(body.tools) && body.tools.length) {
+      enabled = enabled ? body.tools.filter((t) => enabled.includes(t)) : body.tools;
+    }
     const onAsk = autoApprove
       ? undefined
       : async (name, args) => {
@@ -261,6 +270,7 @@ export function registerChat(route, ctx) {
       cwd: sessionCwd,
       providerId,
       model,
+      parentMode: mode,
       permissions: ctx.config.permissions,
       mcp,
       mcpMode: ctx.effectiveMcpMode(),
@@ -280,7 +290,7 @@ export function registerChat(route, ctx) {
     });
 
     const { provider, config } = resolveProviderFor(ctx, providerId, {
-      baseUrl: body.baseUrl || ctx.providerSettings(providerId).baseUrl,
+      baseUrl: baseUrlOverride || ctx.providerSettings(providerId).baseUrl,
     });
 
     const userMessage = buildUserMessage(input, images);
@@ -330,6 +340,7 @@ export function registerChat(route, ctx) {
           execute,
           toolContext: { cwd: sessionCwd, sessionId },
           onLifecycle: onLifecycle ?? undefined,
+          redactExtra: ctx.secretExtra?.() ?? [],
           signal: ctx.runs.signal(sessionId),
           maxRounds: Number(body.maxRounds) || ctx.effectiveMaxRounds?.() || MAX_TOOL_ROUNDS,
           maxTokens: Number(body.maxTokens) || ctx.effectiveMaxTokens?.() || 0,

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

@@ -49,14 +49,22 @@ export function registerPreview(route, ctx) {
     try {
       started = await startTunnel(port, provider, { preview: true, httpsPort });
     } catch (error) {
-      if (provider !== 'tunnelmole' && preview.fallback !== false) {
+      // 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}`);
+        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.`
+        );
       }
     }
     tunnel = { url: started.url, port, provider: started.provider, stop: started.stop };

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

@@ -1,15 +1,18 @@
-import { MODES, MODE_IDS, resolveMode, PROVIDER_META, testProviderConnection, readApp, writeApp } from '../lib/core.js';
+import {
+  MODES,
+  MODE_IDS,
+  resolveMode,
+  PROVIDER_META,
+  testProviderConnection,
+  readApp,
+  writeApp,
+  maskSecret,
+} from '../lib/core.js';
 import { resolveAppearance, sanitizeAppearance } from '../lib/appearance.js';
 import { readJson, sendJson, sendError } from '../lib/http.js';
 
 const ID_PATTERN = /^[a-z0-9][a-z0-9_-]{0,39}$/i;
 
-function hint(apiKey) {
-  if (!apiKey) return '';
-  if (apiKey.startsWith('env:')) return apiKey;
-  return apiKey.length <= 4 ? '••••' : `••••${apiKey.slice(-4)}`;
-}
-
 /** Merge built-in metadata with stored overrides into the provider view. */
 export function providerList(ctx) {
   const stored = new Map(ctx.store.listProviders().map((p) => [p.id, p]));
@@ -27,7 +30,7 @@ export function providerList(ctx) {
       builtin: true,
       stored: Boolean(row),
       hasKey: Boolean(row?.apiKey),
-      apiKeyHint: hint(row?.apiKey),
+      apiKeyHint: maskSecret(row?.apiKey),
       models: row?.models ?? [],
     });
   }
@@ -44,7 +47,7 @@ export function providerList(ctx) {
         builtin: false,
         stored: true,
         hasKey: Boolean(row.apiKey),
-        apiKeyHint: hint(row.apiKey),
+        apiKeyHint: maskSecret(row.apiKey),
         models: row.models,
       });
     }

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

@@ -19,6 +19,7 @@ import {
   scopeDirective,
 } from './lib/core.js';
 import { sendJson, sendError } from './lib/http.js';
+import { requireTrustedHost, requireSameOrigin } from './lib/workspace.js';
 import { createPromptBuilder, DEFAULT_SYSTEM_PROMPT } from './lib/prompt.js';
 import { profilePrompt, resolveProfile } from './lib/profile.js';
 import { skillsBlock } from './lib/skills.js';
@@ -226,6 +227,20 @@ export async function createTamnoraServer({
     providerSettings,
     customProviderDefs,
     apiKeyFor: (id) => resolveApiKey(providerSettings(id).apiKey, process.env),
+    // Secretos conocidos (API keys guardadas, authSecret, token de Telegram):
+    // la redaccion de tool results los tapa aunque no matcheen los patrones
+    // genericos de tokens.
+    secretExtra: () => {
+      const values = [];
+      for (const provider of store.listProviders()) {
+        const key = String(provider.apiKey ?? '');
+        if (key && !key.startsWith('env:')) values.push(key);
+      }
+      for (const value of [app.authSecret, app.user?.password, ctx.channels?.readConfig?.().token]) {
+        if (value) values.push(String(value));
+      }
+      return values;
+    },
     resolveProvider: resolveProvider ?? ((settings) => resolveProviderRuntime(settings)),
     getMcp,
     reloadMcp,
@@ -359,6 +374,10 @@ export async function createTamnoraServer({
     if (url.pathname.startsWith('/api/')) {
       const matched = matchRoute(req.method, url.pathname);
       if (!matched) return sendError(res, 404, `Ruta no encontrada: ${req.method} ${url.pathname}`);
+      // Guardas de request SIEMPRE activas (con o sin auth): DNS-rebinding y
+      // CSRF drive-by. Una web ajena no puede leer ni mutar el server local.
+      if (!requireTrustedHost(req, res, config.server?.allowedHosts)) return;
+      if (req.method !== 'GET' && req.method !== 'HEAD' && !requireSameOrigin(req, res)) return;
       if (authEnabled && !AUTH_OPEN.has(url.pathname)) {
         if (!requireLogin(app, req, res)) return;
         if (req.method !== 'GET' && req.method !== 'HEAD' && !requireCsrf(app, req, res)) return;