@danieltmn/tamnora 0.1.0

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

@@ -0,0 +1,146 @@
+import { createHmac, randomBytes, timingSafeEqual } from 'node:crypto';
+import { sendError } from './lib/http.js';
+
+/**
+ * Autenticacion web con cookie de sesion firmada (stateless), CSRF y bloqueo
+ * por intentos fallidos. Sin dependencias externas.
+ *
+ * La cookie es HttpOnly; el token CSRF se entrega aparte (`/api/auth/me`) y el
+ * cliente lo reenvia en el header `x-csrf` en las mutaciones.
+ */
+
+const COOKIE = 'tamnora_session';
+const SESSION_DAYS = 7;
+
+function b64url(buf) {
+  return Buffer.from(buf).toString('base64url');
+}
+function sign(data, secret) {
+  return createHmac('sha256', secret).update(data).digest('base64url');
+}
+function safeEqual(a, b) {
+  const ba = Buffer.from(String(a));
+  const bb = Buffer.from(String(b));
+  if (ba.length !== bb.length) return false;
+  return timingSafeEqual(ba, bb);
+}
+
+export function parseCookies(header) {
+  const out = {};
+  for (const part of String(header || '').split(';')) {
+    const i = part.indexOf('=');
+    if (i < 0) continue;
+    const key = part.slice(0, i).trim();
+    if (key) out[key] = decodeURIComponent(part.slice(i + 1).trim());
+  }
+  return out;
+}
+
+// Detras del tunel el server recibe desde loopback: solo ahi confiamos en
+// X-Forwarded-Proto para marcar la cookie Secure.
+function isSecure(req) {
+  if (req.socket && req.socket.encrypted) return true;
+  const remote = req.socket && req.socket.remoteAddress;
+  const loopback = !remote || remote === '127.0.0.1' || remote === '::1' || remote === '::ffff:127.0.0.1';
+  if (!loopback) return false;
+  const proto = String(req.headers['x-forwarded-proto'] || '').split(',')[0].trim().toLowerCase();
+  return proto === 'https';
+}
+
+function serializeCookie(value, req, maxAge) {
+  const parts = [`${COOKIE}=${encodeURIComponent(value)}`, 'Path=/', 'HttpOnly', 'SameSite=Lax'];
+  if (isSecure(req)) parts.push('Secure');
+  if (typeof maxAge === 'number') parts.push(`Max-Age=${maxAge}`);
+  return parts.join('; ');
+}
+
+function makeSession(app, csrf, exp, pv) {
+  const payload = b64url(JSON.stringify({ c: csrf, e: exp, pv }));
+  return `${payload}.${sign(payload, app.authSecret)}`;
+}
+
+export function readSession(app, req) {
+  const raw = parseCookies(req.headers.cookie)[COOKIE];
+  if (!raw) return null;
+  const dot = raw.lastIndexOf('.');
+  if (dot < 0) return null;
+  const payload = raw.slice(0, dot);
+  const sig = raw.slice(dot + 1);
+  if (!safeEqual(sign(payload, app.authSecret), sig)) return null;
+  let data;
+  try {
+    data = JSON.parse(Buffer.from(payload, 'base64url').toString('utf8'));
+  } catch {
+    return null;
+  }
+  if (!data || typeof data.e !== 'number' || data.e < Math.floor(Date.now() / 1000)) return null;
+  if ((parseInt(data.pv, 10) || 1) !== (parseInt(app.user?.pv, 10) || 1)) return null;
+  return { c: data.c, e: data.e };
+}
+
+export function startSession(app, req, res) {
+  const csrf = randomBytes(16).toString('hex');
+  const exp = Math.floor(Date.now() / 1000) + SESSION_DAYS * 86400;
+  const token = makeSession(app, csrf, exp, app.user?.pv);
+  res.setHeader('Set-Cookie', serializeCookie(token, req, SESSION_DAYS * 86400));
+  return csrf;
+}
+
+export function endSession(req, res) {
+  res.setHeader('Set-Cookie', serializeCookie('', req, 0));
+}
+
+export function requireLogin(app, req, res) {
+  const session = readSession(app, req);
+  if (!session) {
+    sendError(res, 401, 'No autorizado');
+    return null;
+  }
+  return session;
+}
+
+export function requireCsrf(app, req, res) {
+  const session = readSession(app, req);
+  const given = String(req.headers['x-csrf'] || '').trim();
+  if (!session || !given || !safeEqual(session.c, given)) {
+    sendError(res, 403, 'Sesion invalida, recarga la pagina.');
+    return null;
+  }
+  return session;
+}
+
+// ---------------------------------------------------------------------------
+// Bloqueo por intentos fallidos (en memoria: el server es un proceso).
+// ---------------------------------------------------------------------------
+const MAX_ATTEMPTS = 5;
+const WINDOW_MS = 15 * 60 * 1000;
+const LOCK_MS = 15 * 60 * 1000;
+const attempts = new Map();
+
+function clientKey(req, user) {
+  const xff = String(req.headers['x-forwarded-for'] || '').split(',')[0].trim();
+  const ip = xff || (req.socket && req.socket.remoteAddress) || 'desconocido';
+  return `${ip}|${String(user || '').trim().toLowerCase()}`;
+}
+
+export function loginLockRemaining(req, user) {
+  const now = Date.now();
+  const st = attempts.get(clientKey(req, user));
+  if (!st || !st.lockUntil) return 0;
+  const left = st.lockUntil - now;
+  return left > 0 ? Math.ceil(left / 1000) : 0;
+}
+
+export function loginRecordFailure(req, user) {
+  const now = Date.now();
+  const key = clientKey(req, user);
+  let st = attempts.get(key);
+  if (!st || (!st.lockUntil && now - st.first > WINDOW_MS)) st = { count: 0, first: now, lockUntil: 0 };
+  st.count += 1;
+  if (st.count >= MAX_ATTEMPTS) st.lockUntil = now + LOCK_MS;
+  attempts.set(key, st);
+}
+
+export function loginClear(req, user) {
+  attempts.delete(clientKey(req, user));
+}

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

@@ -0,0 +1,61 @@
+import path from 'node:path';
+import { parseArgs } from 'node:util';
+import { createTamnoraServer } from './server.js';
+
+const OPTIONS = {
+  port: { type: 'string' },
+  host: { type: 'string' },
+  dir: { type: 'string' },
+  static: { type: 'string' },
+  yes: { type: 'boolean', short: 'y' },
+  help: { type: 'boolean', short: 'h' },
+};
+
+/** Entry point shared by `tamnora serve` and the standalone server bin. */
+export async function serveCommand(argv) {
+  const { values } = parseArgs({ args: argv, options: OPTIONS, allowPositionals: true, strict: false });
+  if (values.help) {
+    printHelp();
+    return 0;
+  }
+
+  const cwd = values.dir ? path.resolve(values.dir) : process.cwd();
+  const instance = await createTamnoraServer({
+    cwd,
+    port: values.port ? Number(values.port) : undefined,
+    host: values.host,
+    staticDir: values.static ? path.resolve(values.static) : undefined,
+    yes: Boolean(values.yes),
+  });
+
+  const info = await instance.listen();
+  process.stdout.write(`tamnora server → ${info.url}\n`);
+  process.stdout.write(`  workspace ${cwd}\n`);
+  process.stdout.write(`  ${instance.config.provider}/${instance.config.model || '(sin modelo)'}\n`);
+  process.stdout.write('  Ctrl+C para salir\n');
+
+  return new Promise((resolve) => {
+    let stopping = false;
+    const shutdown = async () => {
+      if (stopping) return;
+      stopping = true;
+      await instance.close();
+      resolve(0);
+    };
+    process.once('SIGINT', shutdown);
+    process.once('SIGTERM', shutdown);
+  });
+}
+
+function printHelp() {
+  console.log(`Uso: tamnora serve [opciones]
+
+Levanta la consola del harness (chat + evaluación) en localhost.
+
+Opciones:
+  --port <n>       Puerto (default: 4517)
+  --host <addr>    Interfaz (default: 127.0.0.1)
+  --dir <path>     Directorio del proyecto
+  --static <dir>   Servir un build estático propio en "/"
+  -y, --yes        Auto-aprobar tools con permiso "ask"`);
+}

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

@@ -0,0 +1 @@
+export { createTamnoraServer } from './server.js';

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

@@ -0,0 +1,51 @@
+/**
+ * Broker for interactive tool approvals. The chat route registers a pending
+ * request (`ask`) and awaits it while the SSE stream emits a `permission`
+ * event; the console answers by POSTing to `/api/permissions/:id`, which calls
+ * `decide`. Requests that nobody answers expire to `false` (deny).
+ *
+ * @param {object} [opts]
+ * @param {number} [opts.timeoutMs] - how long to wait before denying
+ */
+export function createApprovalBroker({ timeoutMs = 300000 } = {}) {
+  const pending = new Map();
+
+  function settle(id, allow) {
+    const entry = pending.get(id);
+    if (!entry) return false;
+    clearTimeout(entry.timer);
+    pending.delete(id);
+    entry.resolve(Boolean(allow));
+    return true;
+  }
+
+  return {
+    /** Register a pending request; resolves to a boolean decision. */
+    ask(id) {
+      return new Promise((resolve) => {
+        const timer = setTimeout(() => settle(id, false), timeoutMs);
+        timer.unref?.();
+        pending.set(id, { resolve, timer });
+      });
+    },
+
+    /** Resolve a pending request. Returns false if it expired or is unknown. */
+    decide(id, allow) {
+      return settle(id, allow);
+    },
+
+    /** Deny every pending request in `ids` (used when the client disconnects). */
+    cancel(ids) {
+      for (const id of ids) settle(id, false);
+    },
+
+    /** Deny everything still pending (used on shutdown). */
+    cancelAll() {
+      for (const id of [...pending.keys()]) settle(id, false);
+    },
+
+    get pending() {
+      return pending.size;
+    },
+  };
+}

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

@@ -0,0 +1,2 @@
+// Re-export the harness core so the server has a single import point.
+export * from '../../../core/src/index.js';

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

@@ -0,0 +1,74 @@
+// Small HTTP helpers: JSON bodies/responses and Server-Sent Events.
+
+export function sendJson(res, status, body) {
+  const payload = JSON.stringify(body);
+  res.writeHead(status, {
+    'Content-Type': 'application/json; charset=utf-8',
+    'Content-Length': Buffer.byteLength(payload),
+  });
+  res.end(payload);
+}
+
+export function sendError(res, status, message) {
+  sendJson(res, status, { error: message });
+}
+
+/** Read and parse a JSON request body (with a size cap). */
+export async function readJson(req, { limit = 8 * 1024 * 1024 } = {}) {
+  const chunks = [];
+  let size = 0;
+  for await (const chunk of req) {
+    size += chunk.length;
+    if (size > limit) throw new Error('El cuerpo de la petición es demasiado grande.');
+    chunks.push(chunk);
+  }
+  if (!chunks.length) return {};
+  const text = Buffer.concat(chunks).toString('utf8');
+  try {
+    return JSON.parse(text);
+  } catch {
+    throw new Error('JSON inválido en el cuerpo de la petición.');
+  }
+}
+
+/**
+ * Start an SSE response and return helpers to emit events.
+ * Sends heartbeat comments so proxies/timeouts do not close the stream.
+ */
+export function openSse(req, res) {
+  res.writeHead(200, {
+    'Content-Type': 'text/event-stream; charset=utf-8',
+    'Cache-Control': 'no-cache, no-transform',
+    Connection: 'keep-alive',
+    'X-Accel-Buffering': 'no',
+  });
+  res.flushHeaders?.();
+
+  let closed = false;
+  const heartbeat = setInterval(() => {
+    if (!closed && !res.writableEnded) res.write(': ping\n\n');
+  }, 15000);
+  heartbeat.unref?.();
+  req.on('close', () => {
+    closed = true;
+    clearInterval(heartbeat);
+  });
+
+  return {
+    event(name, data) {
+      if (closed || res.writableEnded) return;
+      res.write(`event: ${name}\ndata: ${JSON.stringify(data ?? {})}\n\n`);
+    },
+    comment(text) {
+      if (closed || res.writableEnded) return;
+      res.write(`: ${text}\n\n`);
+    },
+    close() {
+      clearInterval(heartbeat);
+      if (!res.writableEnded) res.end();
+    },
+    get closed() {
+      return closed || res.writableEnded;
+    },
+  };
+}

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

@@ -0,0 +1,32 @@
+/**
+ * Last-good model catalog cache (openbridge pattern): a provider listing that
+ * fails or comes back empty must never wipe the last known catalog. Fresh
+ * entries are served from memory for `ttlMs`; after that a refresh is attempted
+ * and only replaced when it succeeds with data.
+ */
+export function createModelCache({ ttlMs = 30 * 60 * 1000, now = Date.now } = {}) {
+  const cache = new Map();
+
+  return {
+    async get(key, fetcher) {
+      const hit = cache.get(key);
+      if (hit && now() - hit.at < ttlMs) return { models: hit.models, cached: true };
+      try {
+        const models = await fetcher();
+        if (Array.isArray(models) && models.length) {
+          cache.set(key, { at: now(), models });
+          return { models, cached: false };
+        }
+        if (hit) return { models: hit.models, cached: true, stale: 'respuesta vacía' };
+        return { models: [], cached: false };
+      } catch (error) {
+        const message = error?.message ?? String(error);
+        if (hit) return { models: hit.models, cached: true, stale: message };
+        throw error;
+      }
+    },
+    clear() {
+      cache.clear();
+    },
+  };
+}

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

@@ -0,0 +1,48 @@
+import { loadInstructions } from './core.js';
+
+export const DEFAULT_SYSTEM_PROMPT =
+  'Eres Tamnora, un asistente útil. Responde en el idioma del usuario y usa las herramientas cuando aporten valor.';
+
+function workspacePreamble(cwd) {
+  return [
+    'Eres Tamnora, un agente de código local que trabaja sobre una carpeta de trabajo.',
+    '',
+    `Carpeta de trabajo: ${cwd}`,
+    '',
+    'Reglas:',
+    '- Tus herramientas (read, list, glob, grep, write, edit) usan rutas relativas a esa carpeta; bash se ejecuta ahí.',
+    '- No podés salir de la carpeta de trabajo.',
+    '- Antes de afirmar algo sobre el proyecto, inspeccionalo con las herramientas (list, glob, grep, read). No inventes archivos ni contenido.',
+    '- write, edit y bash pueden requerir aprobación del usuario; si una llamada se deniega, explicá qué querías hacer en vez de reintentar en bucle.',
+    '- Respondé en el idioma del usuario, de forma concisa.',
+  ].join('\n');
+}
+
+/**
+ * Build a `systemPromptFor(cwd)` function that composes a workspace-aware
+ * system prompt: a preamble naming the working directory plus that directory's
+ * own instruction files (AGENTS.md by default). Results are cached per path.
+ *
+ * The server previously baked a single prompt from its own cwd, so chatting in
+ * another folder still described the server's project. This keeps instructions
+ * scoped to the folder the session actually works in.
+ *
+ * @param {object} opts
+ * @param {string} opts.cwd - server default workspace
+ * @param {string[]} opts.files - instruction file names (e.g. ['AGENTS.md'])
+ */
+export function createPromptBuilder({ cwd, files }) {
+  const cache = new Map();
+
+  async function buildFor(workspace) {
+    const instructions = (await loadInstructions(workspace, files)).trim();
+    const base = workspacePreamble(workspace);
+    return instructions ? `${base}\n\n---\n\n${instructions}` : base;
+  }
+
+  return function systemPromptFor(workspace = cwd) {
+    const key = workspace || cwd;
+    if (!cache.has(key)) cache.set(key, buildFor(key));
+    return cache.get(key);
+  };
+}

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

@@ -0,0 +1,74 @@
+import fs from 'node:fs';
+import path from 'node:path';
+
+/** True for 127.x / ::1 / ::ffff:127.x addresses. */
+export function isLoopback(address) {
+  const addr = String(address ?? '');
+  return addr === '::1' || addr === '0:0:0:0:0:0:0:1' || addr.startsWith('127.') || addr === '::ffff:127.0.0.1';
+}
+
+/** Filesystem roots (drive letters on Windows, `/` elsewhere). */
+export function rootDirs() {
+  if (process.platform !== 'win32') return ['/'];
+  const roots = [];
+  for (let code = 65; code <= 90; code++) {
+    const drive = `${String.fromCharCode(code)}:\\`;
+    try {
+      if (fs.statSync(drive).isDirectory()) roots.push(drive);
+    } catch {
+      // unit not present
+    }
+  }
+  return roots;
+}
+
+/**
+ * Resolve a user-supplied workspace directory: must be an absolute (or
+ * resolvable) path to an existing directory.
+ */
+export function resolveExistingDir(input) {
+  const raw = String(input ?? '').trim();
+  if (!raw) throw new Error('Falta la carpeta de trabajo.');
+  const target = path.resolve(raw);
+  let stat;
+  try {
+    stat = fs.statSync(target);
+  } catch {
+    throw new Error(`La carpeta no existe: "${target}"`);
+  }
+  if (!stat.isDirectory()) throw new Error(`No es una carpeta: "${target}"`);
+  return target;
+}
+
+/**
+ * Workspace for an HTTP request: the requested `cwd` (loopback-only) or the
+ * server's default. Throws on invalid input.
+ */
+export function workspaceForRequest({ req, raw, fallback }) {
+  const value = String(raw ?? '').trim();
+  if (!value) return fallback;
+  if (!isLoopback(req.socket.localAddress)) {
+    throw new Error('Cambiar la carpeta de trabajo solo está permitido en conexiones locales.');
+  }
+  return resolveExistingDir(value);
+}
+
+/** List the subdirectories of a directory, sorted by name. */
+export function listSubdirs(dir) {
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+  const dirs = [];
+  for (const entry of entries) {
+    const full = path.join(dir, entry.name);
+    let isDir = entry.isDirectory();
+    if (!isDir && entry.isSymbolicLink()) {
+      try {
+        isDir = fs.statSync(full).isDirectory();
+      } catch {
+        isDir = false;
+      }
+    }
+    if (isDir) dirs.push({ name: entry.name, path: full });
+  }
+  dirs.sort((a, b) => a.name.localeCompare(b.name, 'es'));
+  return dirs;
+}

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

@@ -0,0 +1,56 @@
+import { verifyPassword } from '../lib/core.js';
+import { readJson, sendJson, sendError } from '../lib/http.js';
+import {
+  startSession,
+  endSession,
+  readSession,
+  loginLockRemaining,
+  loginRecordFailure,
+  loginClear,
+} from '../auth.js';
+
+export function registerAuth(route, ctx) {
+  route('GET', '/api/auth/me', ({ req, res }) => {
+    const enabled = ctx.authEnabled;
+    const session = enabled ? readSession(ctx.app, req) : null;
+    sendJson(res, 200, {
+      enabled,
+      authenticated: enabled ? Boolean(session) : true,
+      user: enabled && session ? { name: ctx.app.user.name } : null,
+      csrf: session?.c || '',
+    });
+  });
+
+  route('POST', '/api/auth/login', async ({ req, res }) => {
+    if (!ctx.authEnabled) {
+      sendJson(res, 200, { ok: true, enabled: false });
+      return;
+    }
+    const body = await readJson(req);
+    const name = String(body.username ?? body.name ?? '').trim();
+    const password = String(body.password ?? '');
+    const user = ctx.app.user;
+
+    const left = loginLockRemaining(req, name);
+    if (left > 0) {
+      sendError(res, 429, `Demasiados intentos. Espera ${left}s.`);
+      return;
+    }
+
+    const ok = name.toLowerCase() === String(user.name).toLowerCase() && verifyPassword(password, user.password);
+    if (!ok) {
+      loginRecordFailure(req, name);
+      sendError(res, 401, 'Usuario o contrasena incorrectos');
+      return;
+    }
+
+    loginClear(req, name);
+    const csrf = startSession(ctx.app, req, res);
+    sendJson(res, 200, { ok: true, enabled: true, user: { name: user.name }, csrf });
+  });
+
+  route('POST', '/api/auth/logout', ({ req, res }) => {
+    endSession(req, res);
+    sendJson(res, 200, { ok: true });
+  });
+}