@danieltmn/tamnora 0.7.1 → 0.9.0

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

@@ -0,0 +1,245 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { streamSse, followRun, backoffDelay, linkSignals, delay } from '../public/runStream.js';
+
+/** Arma una `fetch` falsa que devuelve los chunks indicados y despues se cuelga. */
+function stubFetch(chunks, { status = 200, hang = true } = {}) {
+  const queue = [...chunks];
+  const enqueue = (controller) => {
+    // Sin chunks pendientes el stream queda abierto y mudo: eso es justo lo que
+    // el watchdog tiene que detectar, asi que no cerramos nada. Con `hang:false`
+    // se cierra. `queueMicrotask` y no `setTimeout`: no deja timers colgados
+    // entre tests.
+    if (!queue.length) {
+      if (!hang) controller.close();
+      return;
+    }
+    controller.enqueue(new TextEncoder().encode(queue.shift()));
+    queueMicrotask(() => enqueue(controller));
+  };
+  return async (_url, options = {}) => {
+    if (status !== 200) {
+      return {
+        ok: false,
+        status,
+        statusText: 'Error',
+        json: async () => ({ error: 'no autorizado' }),
+      };
+    }
+    // Un fetch real aborta el body cuando se dispara la senal: hay que
+    // reproducirlo o el watchdog no puede cortar el `reader.read()`.
+    const body = new ReadableStream({
+      start(controller) {
+        const stop = () => controller.error(new DOMException('Aborted', 'AbortError'));
+        if (options.signal?.aborted) return stop();
+        options.signal?.addEventListener('abort', stop, { once: true });
+        enqueue(controller);
+      },
+    });
+    return { ok: true, status: 200, body };
+  };
+}
+
+test('entrega los frames parseados y recuerda el ultimo id', async () => {
+  const frames = [];
+  await streamSse('/x', { fetchImpl: stubFetch(['event: start\ndata: {"a":1}\nid: 7\n\n: ping\n\nevent: done\ndata: {}\nid: 9\n\n'], { hang: false }) }, (event, data, id) => {
+    frames.push([event, data, id]);
+  });
+  assert.deepEqual(frames, [
+    ['start', { a: 1 }, '7'],
+    ['done', {}, '9'],
+  ]);
+});
+
+test('usa el fetch global cuando no se pasa fetchImpl', async () => {
+  // La consola nunca pasa fetchImpl. Si el default se rompe, todos los streams
+  // fallan con TypeError y followRun los reintenta para siempre.
+  const original = globalThis.fetch;
+  let called = false;
+  globalThis.fetch = async (url) => {
+    called = true;
+    assert.equal(url, '/api/events');
+    return { ok: true, status: 200, body: new ReadableStream({ start: (c) => c.close() }) };
+  };
+  try {
+    const frames = [];
+    await streamSse('/api/events', {}, (event, data) => frames.push([event, data]));
+    assert.equal(called, true);
+    assert.deepEqual(frames, []);
+  } finally {
+    globalThis.fetch = original;
+  }
+});
+
+test('tolera frames partidas entre varios chunks', async () => {
+  const frames = [];
+  await streamSse('/x', { fetchImpl: stubFetch(['event: te', 'xt\ndata: {"b', '":2}\nid: 3\n\n'], { hang: false }) }, (event, data, id) => {
+    frames.push([event, data, id]);
+  });
+  assert.deepEqual(frames, [['text', { b: 2 }, '3']]);
+});
+
+test('los comentarios de heartbeat no producen eventos', async () => {
+  const frames = [];
+  await streamSse('/x', { fetchImpl: stubFetch([': ping\n\n: ping\n\nevent: done\ndata: {}\n\n'], { hang: false }) }, (event) => {
+    frames.push(event);
+  });
+  assert.deepEqual(frames, ['done']);
+});
+
+test('corta cuando el stream queda mudo y reporta el cursor', async () => {
+  await assert.rejects(
+    streamSse('/x', { silenceMs: 40, fetchImpl: stubFetch(['event: start\ndata: {}\nid: 12\n\n']) }, () => {}),
+    (error) => {
+      assert.equal(error.name, 'SilentStream');
+      assert.equal(error.resumable, true);
+      assert.equal(error.from, '12');
+      return true;
+    }
+  );
+});
+
+test('propaga el status HTTP para distinguir un 409', async () => {
+  await assert.rejects(
+    streamSse('/x', { fetchImpl: stubFetch([], { status: 409 }) }, () => {}),
+    (error) => {
+      assert.equal(error.status, 409);
+      assert.equal(error.message, 'no autorizado');
+      return true;
+    }
+  );
+});
+
+test('el AbortError del caller no se reporta como stream mudo', async () => {
+  const controller = new AbortController();
+  controller.abort();
+  await assert.rejects(
+    streamSse('/x', { signal: controller.signal, fetchImpl: stubFetch([]) }, () => {}),
+    (error) => error.name === 'AbortError'
+  );
+});
+
+test('followRun reintenta con backoff creciente hasta terminar', async () => {
+  const slept = [];
+  let calls = 0;
+  const result = await followRun({
+    open: async (cursor) => {
+      calls += 1;
+      if (calls < 4) {
+        const error = new Error('se corto');
+        error.name = 'SilentStream';
+        error.from = String(cursor + 10);
+        throw error;
+      }
+      return { finished: true, cursor: 99 };
+    },
+    sleep: async (ms) => {
+      slept.push(ms);
+    },
+  });
+  assert.equal(calls, 4);
+  assert.deepEqual(slept, [1000, 2000, 4000]);
+  assert.equal(result.finished, true);
+  assert.equal(result.cursor, 99);
+});
+
+test('followRun no reintenta un AbortError', async () => {
+  let calls = 0;
+  await assert.rejects(
+    followRun({
+      open: async () => {
+        calls += 1;
+        throw new DOMException('Aborted', 'AbortError');
+      },
+      sleep: async () => {},
+    }),
+    (error) => error.name === 'AbortError'
+  );
+  assert.equal(calls, 1);
+});
+
+test('followRun respeta el limite de intentos', async () => {
+  let calls = 0;
+  await assert.rejects(
+    followRun({
+      attempts: 2,
+      open: async () => {
+        calls += 1;
+        throw new Error('siempre falla');
+      },
+      sleep: async () => {},
+    }),
+    /siempre falla/
+  );
+  assert.equal(calls, 3);
+});
+
+test('followRun avisa el cursor que va a reanudar', async () => {
+  const retries = [];
+  await followRun({
+    open: async (cursor) => {
+      if (cursor === 0) {
+        const error = new Error('murio');
+        error.name = 'SilentStream';
+        error.from = '55';
+        throw error;
+      }
+      return { finished: true };
+    },
+    onRetry: (info) => retries.push([info.cursor, info.attempt]),
+    sleep: async () => {},
+  });
+  assert.deepEqual(retries, [[55, 1]]);
+});
+
+test('un error del handler no se reintenta en bucle', async () => {
+  // Si se confundiera con una caida del transporte, el sintoma seria un
+  // "reconectando..." eterno que no dice nada del bug real.
+  let calls = 0;
+  const boom = await followRun({
+    attempts: Infinity,
+    open: async () => {
+      calls += 1;
+      const error = new Error('handler roto');
+      error.eventHandler = true;
+      throw error;
+    },
+    sleep: async () => {},
+  }).catch((error) => error);
+  assert.equal(calls, 1, 'no debe reintentar');
+  assert.ok(boom.eventHandler, 'debe marcar el error como del handler');
+});
+
+test('un error del handler se propaga marcado', async () => {
+  await assert.rejects(
+    streamSse('/x', { fetchImpl: stubFetch(['event: text\ndata: {}\n\n'], { hang: false }) }, () => {
+      throw new Error('se rompio el render');
+    }),
+    (error) => {
+      assert.equal(error.message, 'se rompio el render');
+      assert.equal(error.eventHandler, true);
+      return true;
+    }
+  );
+});
+
+test('backoffDelay acota en el ultimo paso', () => {
+  assert.equal(backoffDelay(0), 1000);
+  assert.equal(backoffDelay(3), 8000);
+  assert.equal(backoffDelay(99), 10000);
+});
+
+test('linkSignals aborta si cualquiera de las senales dispara', () => {
+  const a = new AbortController();
+  const b = new AbortController();
+  const linked = linkSignals([a.signal, b.signal]);
+  assert.equal(linked.signal.aborted, false);
+  b.abort();
+  assert.equal(linked.signal.aborted, true);
+});
+
+test('delay se corta cuando abortan', async () => {
+  const controller = new AbortController();
+  setTimeout(() => controller.abort(), 5);
+  await assert.rejects(delay(5000, controller.signal), (error) => error.name === 'AbortError');
+});

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

@@ -0,0 +1,252 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import http from 'node:http';
+import { mkdtemp, writeFile, unlink, mkdir } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { createTamnoraServer } from '../src/index.js';
+import { setHome, ensureApp, writeApp, makeUser, bridgeStatePath } from '../../core/src/index.js';
+import { isLoopback, localOk } from '../src/lib/workspace.js';
+import { loginClear } from '../src/auth.js';
+
+const fakeProvider = {
+  id: 'fake',
+  async streamChat(_config, { onEvent }) {
+    onEvent?.({ type: 'text', delta: 'hola', full: 'hola' });
+    return { content: 'hola', reasoning: '', toolCalls: [] };
+  },
+};
+
+async function startServer(overrides = {}) {
+  const cwd = overrides.cwd ?? (await mkdtemp(path.join(tmpdir(), 'tamnora-sec-')));
+  setHome(cwd);
+  const instance = await createTamnoraServer({
+    cwd,
+    dbPath: path.join(cwd, 'tamnora.db'),
+    loadMcp: false,
+    resolveProvider: () => ({ provider: fakeProvider, config: {} }),
+    ...overrides,
+  });
+  const info = await instance.listen({ port: 0 });
+  return { instance, base: info.url, cwd, home: cwd };
+}
+
+/** Deja un bridge.json apuntando a un supervisor vivo (este proceso). */
+async function fakeTunnel() {
+  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('isLoopback solo acepta direcciones de loopback', () => {
+  for (const good of ['127.0.0.1', '127.9.9.9', '::1', '0:0:0:0:0:0:0:1', '::ffff:127.0.0.1']) {
+    assert.ok(isLoopback(good), good);
+  }
+  for (const bad of ['192.168.1.5', '::ffff:192.168.1.5', '', null, 'fe80::1']) {
+    assert.ok(!isLoopback(bad), String(bad));
+  }
+});
+
+test('localOk exige loopback en remoteAddress y sin tunel activo', async () => {
+  const fake = (remote) => ({ socket: { remoteAddress: remote } });
+  assert.ok(localOk(fake('127.0.0.1')));
+  assert.ok(!localOk(fake('192.168.1.5')));
+  // localAddress (la direccion de bind) ya no engana.
+  assert.ok(!localOk({ socket: { remoteAddress: '10.0.0.8', localAddress: '127.0.0.1' } }));
+
+  const { instance, home } = await startServer();
+  try {
+    // Con tunel activo, hasta una conexion loopback deja de ser local.
+    await fakeTunnel();
+    // El cache de tunnelState vive 1 s.
+    await new Promise((r) => setTimeout(r, 1100));
+    assert.ok(!localOk({ socket: { remoteAddress: '127.0.0.1' } }));
+    assert.equal(home, path.dirname(bridgeStatePath()));
+  } finally {
+    await clearTunnel();
+    await instance.close();
+  }
+});
+
+test('POST /api/shell responde 403 mientras el tunel esta activo', async () => {
+  const { instance, base } = await startServer();
+  try {
+    const shell = (extraHeaders = {}) =>
+      fetch(`${base}/api/shell`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', ...extraHeaders },
+        body: JSON.stringify({ command: 'echo tamnora-ok' }),
+      });
+
+    const ok = await shell();
+    assert.equal(ok.status, 200);
+    const body = await ok.json();
+    assert.match(String(body.output), /tamnora-ok/);
+
+    await fakeTunnel();
+    await new Promise((r) => setTimeout(r, 1100));
+    const blocked = await shell();
+    assert.equal(blocked.status, 403);
+
+    // Con header falsificado tampoco pasa: remoteAddress manda.
+    const spoofed = await shell({ 'x-forwarded-for': '203.0.113.9' });
+    assert.equal(spoofed.status, 403);
+  } finally {
+    await clearTunnel();
+    await instance.close();
+  }
+});
+
+test('GET /api/files: sin tunel acepta ?root; con tunel y sin auth responde 403', async () => {
+  const { instance, base } = await startServer();
+  try {
+    // Sin tunel y desde loopback el request es local: cualquier raiz va.
+    const outside = await mkdtemp(path.join(tmpdir(), 'tamnora-fuera-'));
+    mkdir(path.join(outside, 'sub'));
+    const free = await (await fetch(`${base}/api/files?root=${encodeURIComponent(outside)}`)).json();
+    assert.equal(free.root, outside, 'conexion local puede explorar otra raiz');
+
+    const escape = await fetch(`${base}/api/files?path=..%2F..&root=${encodeURIComponent(outside)}`);
+    assert.equal(escape.status, 400);
+
+    await fakeTunnel();
+    await new Promise((r) => setTimeout(r, 1100));
+    const viaTunnel = await fetch(`${base}/api/files`);
+    assert.equal(viaTunnel.status, 403);
+  } finally {
+    await clearTunnel();
+    await instance.close();
+  }
+});
+
+test('con auth, git/files quedan usables por el tunel y confinados al workspace', async () => {
+  const cwd = await mkdtemp(path.join(tmpdir(), 'tamnora-sec-auth-'));
+  setHome(cwd);
+  const app = ensureApp();
+  app.user = makeUser('admin', 'secreto123');
+  writeApp(app);
+
+  const instance = await createTamnoraServer({
+    cwd,
+    dbPath: path.join(cwd, 'tamnora.db'),
+    loadMcp: false,
+    resolveProvider: () => ({ provider: fakeProvider, config: {} }),
+  });
+  const info = await instance.listen({ port: 0 });
+  const base = info.url;
+  try {
+    const login = await fetch(`${base}/api/auth/login`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ username: 'admin', password: 'secreto123' }),
+    });
+    assert.equal(login.status, 200);
+    const cookie = login.headers.get('set-cookie');
+    const { csrf } = await login.json();
+
+    await fakeTunnel();
+    await new Promise((r) => setTimeout(r, 1100));
+
+    const files = await fetch(`${base}/api/files`, { headers: { cookie } });
+    assert.equal(files.status, 200);
+    const listing = await files.json();
+    assert.equal(listing.root, cwd, 'por el tunel la raiz es el workspace');
+
+    const shell = await fetch(`${base}/api/shell`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json', cookie, 'x-csrf': csrf },
+      body: JSON.stringify({ command: 'echo nope' }),
+    });
+    assert.equal(shell.status, 403, 'el shell directo sigue cerrado por el tunel');
+  } finally {
+    await clearTunnel();
+    await instance.close();
+  }
+});
+
+test('el lockout de login no se esquiva falsificando X-Forwarded-For', async () => {
+  const cwd = await mkdtemp(path.join(tmpdir(), 'tamnora-sec-lock-'));
+  setHome(cwd);
+  const app = ensureApp();
+  app.user = makeUser('locktest', 'secreto123');
+  writeApp(app);
+
+  const instance = await createTamnoraServer({
+    cwd,
+    dbPath: path.join(cwd, 'tamnora.db'),
+    loadMcp: false,
+    resolveProvider: () => ({ provider: fakeProvider, config: {} }),
+  });
+  const info = await instance.listen({ port: 0 });
+  const base = info.url;
+  try {
+    const attempt = (xff) =>
+      fetch(`${base}/api/auth/login`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', ...(xff ? { 'x-forwarded-for': xff } : {}) },
+        body: JSON.stringify({ username: 'locktest', password: 'mala' }),
+      });
+
+    for (let i = 0; i < 5; i++) {
+      await attempt(i % 2 ? '203.0.113.1' : '203.0.113.2');
+    }
+    const lockedPlain = await attempt();
+    assert.equal(lockedPlain.status, 429);
+
+    const lockedSpoof = await attempt('198.51.100.7');
+    assert.equal(lockedSpoof.status, 429, 'XFF falsificado no resetea el contador');
+  } finally {
+    loginClear({ socket: { remoteAddress: '127.0.0.1' } }, 'locktest');
+    await instance.close();
+  }
+});
+
+test('la cookie va con Secure cuando hay tunel y el Host es publico', async () => {
+  const cwd = await mkdtemp(path.join(tmpdir(), 'tamnora-sec-cookie-'));
+  setHome(cwd);
+  const app = ensureApp();
+  app.user = makeUser('admin', 'secreto123');
+  writeApp(app);
+
+  const instance = await createTamnoraServer({
+    cwd,
+    dbPath: path.join(cwd, 'tamnora.db'),
+    loadMcp: false,
+    resolveProvider: () => ({ provider: fakeProvider, config: {} }),
+  });
+  const info = await instance.listen({ port: 0 });
+  try {
+    await fakeTunnel();
+    await new Promise((r) => setTimeout(r, 1100));
+
+    const rawLogin = (host) =>
+      new Promise((resolve, reject) => {
+        const body = JSON.stringify({ username: 'admin', password: 'secreto123' });
+        const req = http.request(
+          { host: '127.0.0.1', port: info.port, path: '/api/auth/login', method: 'POST', headers: { Host: host, 'Content-Type': 'application/json', 'Content-Length': Buffer.byteLength(body) } },
+          (res) => {
+            let out = '';
+            res.on('data', (c) => (out += c));
+            res.on('end', () => resolve({ status: res.statusCode, setCookie: res.headers['set-cookie']?.[0] ?? '' }));
+          }
+        );
+        req.on('error', reject);
+        req.end(body);
+      });
+
+    const viaTunnel = await rawLogin('algo.tunnelmole.net');
+    assert.match(String(viaTunnel.setCookie), /Secure/, 'por el tunel la cookie es Secure');
+
+    const local = await rawLogin('localhost:4517');
+    assert.ok(!/Secure/i.test(String(local.setCookie)), 'local http no fuerza Secure');
+  } finally {
+    await clearTunnel();
+    await instance.close();
+  }
+});