@danieltmn/tamnora 0.21.1 → 0.22.0

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

@@ -0,0 +1,586 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtemp, mkdir, writeFile, readFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { startServer } from './helpers.js';
+
+test('project memory is injected into the system prompt', async () => {
+  const cwd = await mkdtemp(path.join(tmpdir(), 'tamnora-mem-prompt-'));
+  await mkdir(path.join(cwd, '.tamnora', 'memory'), { recursive: true });
+  await writeFile(path.join(cwd, '.tamnora', 'memory', 'MEMORY.md'), '# Memoria\n\n- [Dato](dato.md) — clave\n');
+  let captured = '';
+  const provider = {
+    id: 'capture',
+    async streamChat(_config, { messages }) {
+      captured = messages?.[0]?.content ?? '';
+      return { content: 'ok', reasoning: '', toolCalls: [] };
+    },
+  };
+  const { instance, base } = await startServer({ cwd, resolveProvider: () => ({ provider, config: {} }) });
+  const json = { 'Content-Type': 'application/json' };
+  try {
+    const created = await (
+      await fetch(`${base}/api/sessions`, { method: 'POST', headers: json, body: JSON.stringify({ title: 't', model: 'm', cwd }) })
+    ).json();
+    await (
+      await fetch(`${base}/api/chat`, {
+        method: 'POST',
+        headers: json,
+        body: JSON.stringify({ sessionId: created.session.id, model: 'm', input: 'hola' }),
+      })
+    ).text();
+    assert.match(captured, /Memoria del proyecto/);
+    assert.match(captured, /dato\.md/);
+  } finally {
+    await instance.close();
+  }
+});
+
+test('the memory tool writes project memory', async () => {
+  const cwd = await mkdtemp(path.join(tmpdir(), 'tamnora-mem-tool-'));
+  await writeFile(path.join(cwd, 'tamnora.json'), JSON.stringify({ permissions: { memory: 'allow' } }));
+  const provider = {
+    id: 'memtool',
+    async streamChat(_config, { messages }) {
+      if (messages.some((m) => m.role === 'tool' && m.name === 'memory')) {
+        return { content: 'listo', reasoning: '', toolCalls: [] };
+      }
+      return {
+        content: '',
+        reasoning: '',
+        toolCalls: [
+          {
+            id: '1',
+            type: 'function',
+            function: { name: 'memory', arguments: JSON.stringify({ action: 'write', topic: 'nota', content: 'Hola memoria.' }) },
+          },
+        ],
+      };
+    },
+  };
+  const { instance, base } = await startServer({ cwd, resolveProvider: () => ({ provider, config: {} }) });
+  const json = { 'Content-Type': 'application/json' };
+  try {
+    const created = await (
+      await fetch(`${base}/api/sessions`, { method: 'POST', headers: json, body: JSON.stringify({ title: 't', model: 'm', cwd }) })
+    ).json();
+    await (
+      await fetch(`${base}/api/chat`, {
+        method: 'POST',
+        headers: json,
+        body: JSON.stringify({ sessionId: created.session.id, model: 'm', input: 'recordá esto' }),
+      })
+    ).text();
+    const file = await readFile(path.join(cwd, '.tamnora', 'memory', 'nota.md'), 'utf8');
+    assert.match(file, /Hola memoria/);
+  } finally {
+    await instance.close();
+  }
+});
+
+test('rules by path are injected (transiently) when a tool touches a matching file', async () => {
+  const cwd = await mkdtemp(path.join(tmpdir(), 'tamnora-rules-inject-'));
+  await mkdir(path.join(cwd, '.tamnora', 'rules'), { recursive: true });
+  await writeFile(path.join(cwd, '.tamnora', 'rules', 'estilo.md'), '---\npaths: src/**\n---\nMARCADOR_ESTILO: usá 2 espacios.');
+  await mkdir(path.join(cwd, 'src'), { recursive: true });
+  await writeFile(path.join(cwd, 'src', 'index.js'), 'export const x = 1;\n');
+  let captured = null;
+  const provider = {
+    id: 'rules',
+    async streamChat(_config, { messages }) {
+      if (messages.some((m) => m.role === 'tool' && m.name === 'read')) {
+        captured = messages;
+        return { content: 'ok', reasoning: '', toolCalls: [] };
+      }
+      return {
+        content: '',
+        reasoning: '',
+        toolCalls: [
+          { id: 'r1', type: 'function', function: { name: 'read', arguments: JSON.stringify({ path: 'src/index.js' }) } },
+        ],
+      };
+    },
+  };
+  const { instance, base } = await startServer({ cwd, resolveProvider: () => ({ provider, config: {} }) });
+  const json = { 'Content-Type': 'application/json' };
+  try {
+    const created = await (
+      await fetch(`${base}/api/sessions`, { method: 'POST', headers: json, body: JSON.stringify({ title: 't', model: 'm', cwd }) })
+    ).json();
+    await (
+      await fetch(`${base}/api/chat`, {
+        method: 'POST',
+        headers: json,
+        body: JSON.stringify({ sessionId: created.session.id, model: 'm', input: 'mirá src/index.js' }),
+      })
+    ).text();
+    assert.ok(captured, 'el provider no recibió una segunda ronda');
+    assert.ok(
+      captured.some((m) => m.role === 'system' && /MARCADOR_ESTILO/.test(m.content)),
+      'no se inyectó la regla por path'
+    );
+    // No se persiste: el historial guardado no incluye la regla efímera.
+    const session = await (await fetch(`${base}/api/sessions/${created.session.id}`)).json();
+    assert.ok(
+      session.messages.every((m) => !(m.role === 'system' && /MARCADOR_ESTILO/.test(String(m.content ?? '')))),
+      'la regla efímera se persistió en el historial'
+    );
+  } finally {
+    await instance.close();
+  }
+});
+
+test('hooks observe tool events and plugins add custom tools', async () => {
+  const cwd = await mkdtemp(path.join(tmpdir(), 'tamnora-hooks-plugins-'));
+  await mkdir(path.join(cwd, '.tamnora', 'hooks'), { recursive: true });
+  await mkdir(path.join(cwd, '.tamnora', 'plugins'), { recursive: true });
+  await writeFile(
+    path.join(cwd, '.tamnora', 'hooks', 'audit.mjs'),
+    "import { appendFileSync } from 'node:fs';\nimport path from 'node:path';\n" +
+      "export default { name: 'audit', events: { 'tool.after': (event, ctx) => { appendFileSync(path.join(ctx.cwd, 'hook.log'), `${event.type}:${event.name}\\n`); } } };\n"
+  );
+  await writeFile(
+    path.join(cwd, '.tamnora', 'plugins', 'demo.mjs'),
+    "export default { name: 'demo', tools: [{ name: 'saludar', description: 'saluda', parameters: { quien: { type: 'string' } }, handler: (args) => `Hola ${args.quien}` }] };\n"
+  );
+  await writeFile(
+    path.join(cwd, 'tamnora.json'),
+    JSON.stringify({
+      hooks: ['.tamnora/hooks/*.mjs'],
+      plugins: ['.tamnora/plugins/*.mjs'],
+      permissions: { plugin__demo__saludar: 'allow' },
+    })
+  );
+
+  let captured = null;
+  const provider = {
+    id: 'hp',
+    async streamChat(_config, { messages }) {
+      const toolMsg = messages.find((m) => m.role === 'tool' && String(m.name).startsWith('plugin__'));
+      if (toolMsg) {
+        captured = toolMsg.content;
+        return { content: 'ok', reasoning: '', toolCalls: [] };
+      }
+      return {
+        content: '',
+        reasoning: '',
+        toolCalls: [
+          {
+            id: 't1',
+            type: 'function',
+            function: { name: 'plugin__demo__saludar', arguments: JSON.stringify({ quien: 'mundo' }) },
+          },
+        ],
+      };
+    },
+  };
+  const { instance, base } = await startServer({ cwd, resolveProvider: () => ({ provider, config: {} }) });
+  const json = { 'Content-Type': 'application/json' };
+  try {
+    const hooks = await (await fetch(`${base}/api/hooks`)).json();
+    assert.ok(hooks.hooks.some((h) => h.id === 'audit'));
+
+    const plugins = await (await fetch(`${base}/api/plugins`)).json();
+    assert.ok(plugins.plugins.some((p) => p.name === 'plugin__demo__saludar'));
+
+    const created = await (
+      await fetch(`${base}/api/sessions`, { method: 'POST', headers: json, body: JSON.stringify({ title: 't', model: 'm', cwd }) })
+    ).json();
+    await (
+      await fetch(`${base}/api/chat`, {
+        method: 'POST',
+        headers: json,
+        body: JSON.stringify({ sessionId: created.session.id, model: 'm', input: 'saludá' }),
+      })
+    ).text();
+    assert.equal(captured, 'Hola mundo');
+
+    await new Promise((resolve) => setTimeout(resolve, 150));
+    const log = await readFile(path.join(cwd, 'hook.log'), 'utf8').catch(() => '');
+    assert.match(log, /tool\.after:plugin__demo__saludar/);
+  } finally {
+    await instance.close();
+  }
+});
+
+test('the agent can install a skill from chat (with approval)', async () => {
+  const calls = { n: 0 };
+  const toolProvider = {
+    id: 'tooly',
+    async streamChat() {
+      calls.n += 1;
+      if (calls.n === 1) {
+        return {
+          content: '',
+          reasoning: '',
+          toolCalls: [
+            {
+              id: 't1',
+              function: {
+                name: 'install_skill',
+                arguments: JSON.stringify({ id: 'demo-skill', content: '---\nname: Demo\n---\nCuerpo de prueba.' }),
+              },
+            },
+          ],
+        };
+      }
+      return { content: 'listo', reasoning: '', toolCalls: [] };
+    },
+  };
+  const { instance, base } = await startServer({ resolveProvider: () => ({ provider: toolProvider, config: {} }) });
+  const json = { 'Content-Type': 'application/json' };
+  try {
+    const created = await (
+      await fetch(`${base}/api/sessions`, { method: 'POST', headers: json, body: JSON.stringify({ title: 't', model: 'm' }) })
+    ).json();
+    const res = await fetch(`${base}/api/chat`, {
+      method: 'POST',
+      headers: json,
+      body: JSON.stringify({ sessionId: created.session.id, model: 'm', input: 'instalá una skill', yes: true }),
+    });
+    await res.text();
+
+    const skills = await (await fetch(`${base}/api/skills`)).json();
+    assert.ok(skills.skills.some((s) => s.id === 'demo-skill'));
+  } finally {
+    await instance.close();
+  }
+});
+
+test('the system prompt follows the session workspace, not the server cwd', async () => {
+  const serverCwd = await mkdtemp(path.join(tmpdir(), 'tamnora-srv-cwd-'));
+  const projectCwd = await mkdtemp(path.join(tmpdir(), 'tamnora-proj-cwd-'));
+  await writeFile(path.join(serverCwd, 'AGENTS.md'), 'REGLAS_DEL_SERVER');
+  await writeFile(path.join(projectCwd, 'AGENTS.md'), 'REGLAS_DEL_PROYECTO');
+
+  let captured = null;
+  const provider = {
+    id: 'capture',
+    async streamChat(_config, opts) {
+      captured = opts.messages.find((m) => m.role === 'system')?.content ?? '';
+      return { content: 'ok', reasoning: '', toolCalls: [] };
+    },
+  };
+
+  const { instance, base } = await startServer({
+    cwd: serverCwd,
+    resolveProvider: () => ({ provider, config: {} }),
+  });
+  try {
+    const res = await fetch(`${base}/api/chat`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ input: 'hola', model: 'm', cwd: projectCwd }),
+    });
+    await res.text();
+    assert.ok(captured.includes(path.resolve(projectCwd)), 'nombra la carpeta de la sesión');
+    assert.match(captured, /REGLAS_DEL_PROYECTO/);
+    assert.doesNotMatch(captured, /REGLAS_DEL_SERVER/);
+  } finally {
+    await instance.close();
+  }
+});
+
+test('asks for approval before running a gated tool and runs it once approved', async () => {
+  const cwd = await mkdtemp(path.join(tmpdir(), 'tamnora-ask-'));
+  let calls = 0;
+  const provider = {
+    id: 'tooly',
+    async streamChat() {
+      calls += 1;
+      if (calls === 1) {
+        return {
+          content: '',
+          reasoning: '',
+          toolCalls: [
+            { id: 'call_1', function: { name: 'write', arguments: JSON.stringify({ path: 'nota.txt', content: 'hi' }) } },
+          ],
+        };
+      }
+      return { content: 'listo', reasoning: '', toolCalls: [] };
+    },
+  };
+
+  const { instance, base } = await startServer({ cwd, resolveProvider: () => ({ provider, config: {} }) });
+  try {
+    const res = await fetch(`${base}/api/chat`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ input: 'creá nota.txt con hi', model: 'm' }),
+    });
+    const reader = res.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = '';
+    let askId = null;
+    let done = false;
+    while (!done) {
+      const { value } = await reader.read();
+      if (!value) break;
+      buffer += decoder.decode(value, { stream: true });
+      if (!askId) {
+        const match = buffer.match(/"askId":"([0-9a-f-]+)"/);
+        if (match && buffer.includes('event: permission')) {
+          askId = match[1];
+          const decision = await fetch(`${base}/api/permissions/${askId}`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ allow: true }),
+          });
+          assert.equal(decision.status, 200);
+        }
+      }
+      if (buffer.includes('event: done')) done = true;
+    }
+    assert.ok(askId, 'emitió el evento permission');
+    assert.equal(await readFile(path.join(cwd, 'nota.txt'), 'utf8'), 'hi');
+  } finally {
+    await instance.close();
+  }
+});
+
+test('rejects unknown permission requests', async () => {
+  const { instance, base } = await startServer();
+  try {
+    const res = await fetch(`${base}/api/permissions/does-not-exist`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ allow: true }),
+    });
+    assert.equal(res.status, 404);
+  } finally {
+    await instance.close();
+  }
+});
+
+test('ask_user muestra un formulario y recibe las respuestas', async () => {
+  const cwd = await mkdtemp(path.join(tmpdir(), 'tamnora-askuser-'));
+  let calls = 0;
+  let captured = null;
+  const provider = {
+    id: 'formy',
+    async streamChat(_config, opts) {
+      calls += 1;
+      if (calls === 1) {
+        return {
+          content: '',
+          reasoning: '',
+          toolCalls: [
+            {
+              id: 'q1',
+              function: {
+                name: 'ask_user',
+                arguments: JSON.stringify({
+                  questions: [
+                    { id: 'nombre', label: '¿Tu nombre?' },
+                    { id: 'color', label: 'Color', type: 'select', options: ['rojo', 'verde'] },
+                  ],
+                }),
+              },
+            },
+          ],
+        };
+      }
+      captured = opts.messages;
+      return { content: 'Gracias', reasoning: '', toolCalls: [] };
+    },
+  };
+  const { instance, base } = await startServer({ cwd, resolveProvider: () => ({ provider, config: {} }) });
+  try {
+    const res = await fetch(`${base}/api/chat`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ input: 'preguntame', model: 'm' }),
+    });
+    const reader = res.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = '';
+    let askId = null;
+    let done = false;
+    while (!done) {
+      const { value } = await reader.read();
+      if (!value) break;
+      buffer += decoder.decode(value, { stream: true });
+      if (!askId && buffer.includes('event: question')) {
+        const match = buffer.match(/"askId":"([0-9a-f-]+)"/);
+        if (match) {
+          askId = match[1];
+          const answer = await fetch(`${base}/api/questions/${askId}`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ answers: { nombre: 'Ana', color: 'verde' } }),
+          });
+          assert.equal(answer.status, 200);
+        }
+      }
+      if (buffer.includes('event: done')) done = true;
+    }
+    assert.ok(askId, 'emitió el evento question');
+    const toolMsg = (captured ?? []).find((m) => m.role === 'tool');
+    assert.match(String(toolMsg?.content ?? ''), /Ana/);
+    assert.match(String(toolMsg?.content ?? ''), /verde/);
+  } finally {
+    await instance.close();
+  }
+});
+
+test('exposes modes and persists the active mode', async () => {
+  const { instance, base } = await startServer();
+  const json = { 'Content-Type': 'application/json' };
+  try {
+    const modes = await (await fetch(`${base}/api/modes`)).json();
+    assert.deepEqual(
+      modes.modes.map((m) => m.id),
+      ['agent', 'plan', 'voice']
+    );
+    await fetch(`${base}/api/settings`, { method: 'PUT', headers: json, body: JSON.stringify({ mode: 'plan' }) });
+    const settings = await (await fetch(`${base}/api/settings`)).json();
+    assert.equal(settings.settings.mode, 'plan');
+  } finally {
+    await instance.close();
+  }
+});
+
+test('plan mode exposes only read-only tools and adds guidance', async () => {
+  const cwd = await mkdtemp(path.join(tmpdir(), 'tamnora-plan-'));
+  let captured = null;
+  const provider = {
+    id: 'plan',
+    async streamChat(_config, opts) {
+      captured = {
+        tools: (opts.tools ?? []).map((t) => t.function.name).sort(),
+        system: opts.messages.find((m) => m.role === 'system').content,
+      };
+      return { content: 'ok', reasoning: '', toolCalls: [] };
+    },
+  };
+  const { instance, base } = await startServer({ cwd, resolveProvider: () => ({ provider, config: {} }) });
+  try {
+    await (
+      await fetch(`${base}/api/chat`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ input: 'planificá', model: 'm', mode: 'plan' }),
+      })
+    ).text();
+    assert.deepEqual(captured.tools, [
+      'ask_user',
+      'console_errors',
+      'fetch_url',
+      'git_diff',
+      'git_log',
+      'git_status',
+      'glob',
+      'grep',
+      'list',
+      'list_mcp',
+      'list_skills',
+      'offer_choices',
+      'preview_url',
+      'read',
+      'screenshot',
+      'search_mcp',
+      'search_skills',
+      'show_plan',
+      'skill',
+      'speak',
+      'task',
+    ]);
+    assert.match(captured.system, /modo PLAN/);
+  } finally {
+    await instance.close();
+  }
+});
+
+test('voice mode expone write/edit pero solo para .md y .json', async () => {
+  const cwd = await mkdtemp(path.join(tmpdir(), 'tamnora-voice-'));
+  let seenTools = null;
+  let seenSystem = null;
+  let toolResult = null;
+  let round = 0;
+  const provider = {
+    id: 'voice',
+    async streamChat(_config, opts) {
+      round += 1;
+      seenTools = (opts.tools ?? []).map((t) => t.function.name).sort();
+      seenSystem = opts.messages.find((m) => m.role === 'system').content;
+      if (round === 1) {
+        return {
+          content: '',
+          reasoning: '',
+          toolCalls: [
+            {
+              id: 'w1',
+              type: 'function',
+              function: { name: 'write', arguments: JSON.stringify({ path: 'nota.txt', content: 'x' }) },
+            },
+          ],
+        };
+      }
+      toolResult = opts.messages.find((m) => m.role === 'tool')?.content ?? '';
+      return { content: 'ok', reasoning: '', toolCalls: [] };
+    },
+  };
+  const { instance, base } = await startServer({ cwd, resolveProvider: () => ({ provider, config: {} }) });
+  try {
+    await (
+      await fetch(`${base}/api/chat`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ input: 'tomá nota', model: 'm', mode: 'voice' }),
+      })
+    ).text();
+    assert.ok(seenTools.includes('write'));
+    assert.ok(seenTools.includes('edit'));
+    assert.match(seenSystem, /modo VOZ/);
+    assert.match(toolResult, /solo se permite crear o editar/);
+  } finally {
+    await instance.close();
+  }
+});
+
+test('the agent can delegate to a subagent with the task tool', async () => {
+  const cwd = await mkdtemp(path.join(tmpdir(), 'tamnora-task-'));
+  const provider = {
+    id: 'multi',
+    async streamChat(_config, { messages, onEvent }) {
+      const isSub = messages.some((m) => m.role === 'system' && /subagente/i.test(String(m.content)));
+      if (isSub) {
+        onEvent?.({ type: 'text', delta: 'resumen', full: 'resumen subagente' });
+        return { content: 'resumen subagente', reasoning: '', toolCalls: [] };
+      }
+      const done = messages.some((m) => m.role === 'tool' && m.name === 'task');
+      if (done) return { content: 'listo', reasoning: '', toolCalls: [] };
+      return {
+        content: '',
+        reasoning: '',
+        toolCalls: [
+          { id: 't1', function: { name: 'task', arguments: JSON.stringify({ description: 'explorar', prompt: 'leé el proyecto' }) } },
+        ],
+      };
+    },
+  };
+  const { instance, base } = await startServer({ cwd, resolveProvider: () => ({ provider, config: {} }) });
+  const json = { 'Content-Type': 'application/json' };
+  try {
+    const stream = await (
+      await fetch(`${base}/api/chat`, {
+        method: 'POST',
+        headers: json,
+        body: JSON.stringify({ input: 'delegá', model: 'm' }),
+      })
+    ).text();
+    assert.match(stream, /event: agent_start/);
+    assert.match(stream, /event: agent_end/);
+
+    const list = await (await fetch(`${base}/api/sessions`)).json();
+    const id = list.sessions[0].id;
+    const agents = await (await fetch(`${base}/api/sessions/${id}/agents`)).json();
+    assert.equal(agents.agents.length, 1);
+    assert.equal(agents.agents[0].status, 'done');
+    assert.match(agents.agents[0].summary, /resumen subagente/);
+  } finally {
+    await instance.close();
+  }
+});
+

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

@@ -0,0 +1,107 @@
+import { execFileSync } from 'node:child_process';
+import { mkdtemp } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { createTamnoraServer } from '../src/index.js';
+import { setHome } from '../../core/src/index.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-srv-')));
+  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 };
+}
+
+const HAS_GIT = (() => {
+  try {
+    execFileSync('git', ['--version'], { stdio: 'ignore' });
+    return true;
+  } catch {
+    return false;
+  }
+})();
+
+function gitInit(root) {
+  execFileSync('git', ['init', '-q'], { cwd: root });
+  execFileSync('git', ['config', 'user.email', 'test@tamnora.dev'], { cwd: root });
+  execFileSync('git', ['config', 'user.name', 'Test'], { cwd: root });
+}
+
+async function readSse(url, options, until, timeoutMs = 5000) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  const frames = [];
+  try {
+    const res = await fetch(url, { ...options, signal: controller.signal });
+    const reader = res.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = '';
+    for (;;) {
+      const { value, done } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      let index;
+      while ((index = buffer.indexOf('\n\n')) !== -1) {
+        const frame = buffer.slice(0, index);
+        buffer = buffer.slice(index + 2);
+        let event = null;
+        let data = '';
+        for (const line of frame.split('\n')) {
+          if (line.startsWith('event:')) event = line.slice(6).trim();
+          else if (line.startsWith('data:')) data += line.slice(5).trim();
+        }
+        if (!event) continue;
+        const parsed = data ? JSON.parse(data) : {};
+        frames.push({ event, data: parsed });
+        if (until(parsed, event)) return frames;
+      }
+    }
+  } catch (error) {
+    if (error?.name !== 'AbortError') throw error;
+  } finally {
+    clearTimeout(timer);
+  }
+  return frames;
+}
+
+async function waitIdle(base, id, attempts = 60) {
+  for (let i = 0; i < attempts; i += 1) {
+    const detail = await (await fetch(`${base}/api/sessions/${id}`)).json();
+    if (!detail.running) return true;
+    await fetch(`${base}/api/sessions/${id}/stop`, { method: 'POST' }).catch(() => {});
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  }
+  return false;
+}
+
+async function readEvents(res, onFrame) {
+  const reader = res.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = '';
+  let done = false;
+  while (!done) {
+    const { value } = await reader.read();
+    if (!value) break;
+    buffer += decoder.decode(value, { stream: true });
+    if (onFrame) await onFrame(buffer);
+    if (buffer.includes('event: done')) done = true;
+  }
+  return buffer;
+}
+
+export { fakeProvider, startServer, HAS_GIT, gitInit, readSse, waitIdle, readEvents };