@danieltmn/tamnora 0.1.0

package/harness/packages/core/test/mcp.test.js

@@ -0,0 +1,158 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import http from 'node:http';
+import { mkdtemp, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import {
+  buildMcpRegistry,
+  connectMcpStdioServer,
+  mcpTransport,
+} from '../src/index.js';
+
+const STDIO_SERVER = `
+import readline from 'node:readline';
+const TOOLS = [
+  { name: 'echo', description: 'eco', inputSchema: { type: 'object', properties: { text: { type: 'string' } } } },
+];
+readline.createInterface({ input: process.stdin }).on('line', (line) => {
+  if (!line.trim()) return;
+  const m = JSON.parse(line);
+  let r = null;
+  if (m.method === 'initialize') r = { jsonrpc: '2.0', id: m.id, result: { protocolVersion: '2025-06-18', capabilities: { tools: {}, resources: {}, prompts: {} }, serverInfo: { name: 't', version: '1' } } };
+  else if (m.method === 'tools/list') r = { jsonrpc: '2.0', id: m.id, result: { tools: TOOLS } };
+  else if (m.method === 'tools/call') r = { jsonrpc: '2.0', id: m.id, result: { content: [{ type: 'text', text: 'echo: ' + (m.params.arguments?.text ?? '') }] } };
+  else if (m.method === 'resources/list') r = { jsonrpc: '2.0', id: m.id, result: { resources: [{ uri: 'mem://x', name: 'x' }] } };
+  else if (m.method === 'resources/read') r = { jsonrpc: '2.0', id: m.id, result: { contents: [{ uri: m.params.uri, text: 'contenido' }] } };
+  else if (m.method === 'prompts/list') r = { jsonrpc: '2.0', id: m.id, result: { prompts: [{ name: 'p' }] } };
+  else if (m.method === 'prompts/get') r = { jsonrpc: '2.0', id: m.id, result: { messages: [{ role: 'user', content: { type: 'text', text: 'prompt!' } }] } };
+  if (r) process.stdout.write(JSON.stringify(r) + '\\n');
+});
+`;
+
+async function makeStdioServer() {
+  const dir = await mkdtemp(path.join(tmpdir(), 'tamnora-mcp-'));
+  const file = path.join(dir, 'server.mjs');
+  await writeFile(file, STDIO_SERVER);
+  return { id: 'fake', command: process.execPath, args: [file] };
+}
+
+test('mcpTransport picks stdio vs http and rejects empty configs', () => {
+  assert.equal(mcpTransport({ command: 'node' }), 'stdio');
+  assert.equal(mcpTransport({ type: 'stdio', command: 'node' }), 'stdio');
+  assert.equal(mcpTransport({ url: 'https://x/mcp' }), 'http');
+  assert.equal(mcpTransport({ type: 'http', url: 'https://x/mcp' }), 'http');
+  assert.throws(() => mcpTransport({ id: 'x' }));
+});
+
+test('connectMcpStdioServer initializes and calls a tool', async () => {
+  const server = await makeStdioServer();
+  const session = await connectMcpStdioServer(server);
+  try {
+    assert.equal(session.transport, 'stdio');
+    assert.equal(session.tools.length, 1);
+    assert.equal(session.tools[0].name, 'echo');
+    assert.equal(await session.callTool('echo', { text: 'hola' }), 'echo: hola');
+  } finally {
+    session.close();
+  }
+});
+
+test('buildMcpRegistry exposes qualified stdio tools and routes calls', async () => {
+  const server = await makeStdioServer();
+  const registry = await buildMcpRegistry([server]);
+  try {
+    assert.equal(registry.errors.length, 0);
+    const names = registry.definitions.map((d) => d.function.name);
+    assert.ok(names.includes('mcp__fake__echo'));
+    assert.equal(registry.handles('mcp__fake__echo'), true);
+    assert.equal(await registry.call('mcp__fake__echo', { text: 'x' }), 'echo: x');
+  } finally {
+    registry.close();
+  }
+});
+
+test('buildMcpRegistry exposes resource and prompt tools', async () => {
+  const server = await makeStdioServer();
+  const registry = await buildMcpRegistry([server]);
+  try {
+    const names = registry.definitions.map((d) => d.function.name);
+    for (const name of [
+      'mcp__fake__echo',
+      'mcp__fake__list_resources',
+      'mcp__fake__read_resource',
+      'mcp__fake__list_prompts',
+      'mcp__fake__get_prompt',
+    ]) {
+      assert.ok(names.includes(name), `falta ${name}`);
+    }
+    assert.equal(registry.resources.length, 1);
+    assert.equal(registry.prompts.length, 1);
+    assert.match(await registry.call('mcp__fake__list_resources', {}), /mem:\/\/x/);
+    assert.equal(await registry.call('mcp__fake__read_resource', { uri: 'mem://x' }), 'contenido');
+    assert.match(await registry.call('mcp__fake__list_prompts', {}), /p\b/);
+    assert.match(await registry.call('mcp__fake__get_prompt', { name: 'p' }), /prompt!/);
+  } finally {
+    registry.close();
+  }
+});
+
+test('buildMcpRegistry reports a failing stdio server without throwing', async () => {
+  const registry = await buildMcpRegistry([
+    { id: 'bad', command: 'tamnora-command-that-does-not-exist-xyz' },
+  ]);
+  assert.equal(registry.definitions.length, 0);
+  assert.equal(registry.errors.length, 1);
+  assert.equal(registry.errors[0].server.id, 'bad');
+});
+
+test('buildMcpRegistry connects over HTTP (JSON responses)', async () => {
+  const server = http.createServer((req, res) => {
+    let body = '';
+    req.on('data', (c) => (body += c));
+    req.on('end', () => {
+      const message = JSON.parse(body);
+      if (message.method === 'notifications/initialized') {
+        res.statusCode = 202;
+        res.end();
+        return;
+      }
+      res.setHeader('Content-Type', 'application/json');
+      if (message.method === 'initialize') {
+        res.setHeader('Mcp-Session-Id', 'sess-1');
+        res.end(
+          JSON.stringify({ jsonrpc: '2.0', id: message.id, result: { protocolVersion: '2025-06-18', capabilities: {} } })
+        );
+      } else if (message.method === 'tools/list') {
+        res.end(
+          JSON.stringify({
+            jsonrpc: '2.0',
+            id: message.id,
+            result: { tools: [{ name: 'ping', inputSchema: { type: 'object' } }] },
+          })
+        );
+      } else if (message.method === 'tools/call') {
+        res.end(
+          JSON.stringify({ jsonrpc: '2.0', id: message.id, result: { content: [{ type: 'text', text: 'pong' }] } })
+        );
+      } else {
+        res.end('{}');
+      }
+    });
+  });
+  await new Promise((r) => server.listen(0, '127.0.0.1', r));
+  const { port } = server.address();
+
+  try {
+    const registry = await buildMcpRegistry([{ id: 'web', url: `http://127.0.0.1:${port}/mcp` }]);
+    try {
+      assert.equal(registry.errors.length, 0);
+      assert.equal(registry.definitions[0].function.name, 'mcp__web__ping');
+      assert.equal(await registry.call('mcp__web__ping', {}), 'pong');
+    } finally {
+      registry.close();
+    }
+  } finally {
+    server.close();
+  }
+});

package/harness/packages/core/test/providers.test.js

@@ -0,0 +1,80 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { Store } from '../src/storage/sqlite.js';
+import { composeProviderSettings } from '../src/config/providers.js';
+import { toOllamaMessages } from '../src/providers/ollama.js';
+
+test('Store persists providers and settings', () => {
+  const store = new Store(':memory:');
+  try {
+    assert.deepEqual(store.listProviders(), []);
+
+    store.saveProvider({
+      id: 'deepseek',
+      label: 'DeepSeek',
+      baseUrl: 'https://api.deepseek.com/v1',
+      apiKey: 'sk-123',
+      models: ['deepseek-chat'],
+    });
+    const saved = store.getProvider('deepseek');
+    assert.equal(saved.label, 'DeepSeek');
+    assert.deepEqual(saved.models, ['deepseek-chat']);
+    assert.equal(saved.custom, false);
+
+    store.saveProvider({ id: 'deepseek', models: ['deepseek-reasoner'], custom: true });
+    assert.deepEqual(store.getProvider('deepseek').models, ['deepseek-reasoner']);
+    assert.equal(store.listProviders().length, 1);
+
+    store.setSetting('activeProvider', 'deepseek');
+    store.setSetting('activeModel', 'deepseek-chat');
+    assert.equal(store.getSetting('activeProvider'), 'deepseek');
+    assert.deepEqual(store.allSettings(), { activeProvider: 'deepseek', activeModel: 'deepseek-chat' });
+
+    store.deleteProvider('deepseek');
+    assert.equal(store.getProvider('deepseek'), null);
+  } finally {
+    store.close();
+  }
+});
+
+test('toOllamaMessages converts OpenAI image parts to images array', () => {
+  const out = toOllamaMessages([
+    { role: 'system', content: 'sys' },
+    {
+      role: 'user',
+      content: [
+        { type: 'text', text: 'mirá esto' },
+        { type: 'image_url', image_url: { url: 'data:image/png;base64,AAAA' } },
+      ],
+    },
+  ]);
+  assert.equal(out[0].content, 'sys');
+  assert.equal(out[1].content, 'mirá esto');
+  assert.deepEqual(out[1].images, ['AAAA']);
+  assert.equal(out[1].image_url, undefined);
+});
+
+test('composeProviderSettings merges stored over config', () => {
+  const config = { apiKey: 'env:OPENROUTER_API_KEY', baseUrl: 'https://base', providerModels: { groq: ['x'] } };
+
+  const fromStore = composeProviderSettings({
+    providerId: 'deepseek',
+    stored: { apiKey: 'sk-9', baseUrl: 'https://ds', models: ['a', 'b'] },
+    config,
+  });
+  assert.equal(fromStore.apiKey, 'sk-9');
+  assert.equal(fromStore.baseUrl, 'https://ds');
+  assert.deepEqual(fromStore.providerModels, { deepseek: ['a', 'b'] });
+
+  const fallback = composeProviderSettings({ providerId: 'groq', stored: {}, config });
+  assert.equal(fallback.apiKey, 'env:OPENROUTER_API_KEY');
+  assert.equal(fallback.baseUrl, 'https://base');
+  assert.deepEqual(fallback.providerModels, { groq: ['x'] });
+
+  const custom = composeProviderSettings({
+    providerId: 'my-gw',
+    stored: { custom: true, label: 'Mi Gateway', baseUrl: 'https://gw', models: ['m1'] },
+    config,
+  });
+  assert.deepEqual(custom.customProviders, [{ id: 'my-gw', label: 'Mi Gateway', baseUrl: 'https://gw', models: ['m1'] }]);
+});

package/harness/packages/core/test/resilience.test.js

@@ -0,0 +1,61 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { withRetry, isRetryableError, isAbortError } from '../src/index.js';
+
+test('withRetry retries transient errors and then succeeds', async () => {
+  let attempts = 0;
+  const result = await withRetry(
+    async () => {
+      attempts += 1;
+      if (attempts < 3) {
+        const err = new Error('fetch failed');
+        err.code = 'ECONNRESET';
+        throw err;
+      }
+      return 'ok';
+    },
+    { retries: 3, baseDelayMs: 1, maxDelayMs: 2 }
+  );
+  assert.equal(result, 'ok');
+  assert.equal(attempts, 3);
+});
+
+test('withRetry does not retry non-retryable errors', async () => {
+  let attempts = 0;
+  await assert.rejects(
+    withRetry(
+      async () => {
+        attempts += 1;
+        const err = new Error('bad request');
+        err.status = 400;
+        throw err;
+      },
+      { retries: 3, baseDelayMs: 1 }
+    ),
+    /bad request/
+  );
+  assert.equal(attempts, 1);
+});
+
+test('withRetry stops on abort', async () => {
+  const controller = new AbortController();
+  controller.abort();
+  await assert.rejects(
+    withRetry(async () => {
+      throw new Error('network timeout');
+    }, { retries: 3, baseDelayMs: 1, signal: controller.signal })
+  );
+});
+
+test('isRetryableError classifies statuses and codes', () => {
+  assert.equal(isRetryableError({ status: 429 }), true);
+  assert.equal(isRetryableError({ status: 503 }), true);
+  assert.equal(isRetryableError({ status: 401 }), false);
+  assert.equal(isRetryableError({ code: 'ETIMEDOUT' }), true);
+  assert.equal(isRetryableError({ name: 'AbortError' }), false);
+});
+
+test('isAbortError detects abort signals', () => {
+  assert.equal(isAbortError({ name: 'AbortError' }), true);
+  assert.equal(isAbortError(new Error('x')), false);
+});

package/harness/packages/core/test/storage.test.js

@@ -0,0 +1,55 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { Store } from '../src/storage/sqlite.js';
+
+test('Store persists sessions, messages and runs', () => {
+  const store = new Store(':memory:');
+
+  const sessionId = store.createSession({ title: 'test', provider: 'openrouter', model: 'm' });
+  assert.ok(store.getSession(sessionId));
+
+  store.addMessages(sessionId, [
+    { role: 'user', content: 'hola' },
+    { role: 'assistant', content: 'qué tal' },
+    {
+      role: 'assistant',
+      content: null,
+      tool_calls: [{ id: 'c1', function: { name: 'x', arguments: '{}' } }],
+    },
+    { role: 'tool', tool_call_id: 'c1', name: 'x', content: 'ok' },
+  ]);
+
+  const messages = store.getMessages(sessionId);
+  assert.equal(messages.length, 4);
+  assert.equal(messages[0].content, 'hola');
+  assert.equal(messages[2].tool_calls[0].function.name, 'x');
+  assert.equal(messages[3].tool_call_id, 'c1');
+
+  assert.equal(store.latestSession().id, sessionId);
+
+  const runId = store.createRun({ dataset: 'd.jsonl', config: { models: ['m'] } });
+  store.addRunResult({ runId, taskId: 't1', model: 'm', passed: true, output: 'ok' });
+  store.finishRun(runId, { summary: { total: 1 } });
+
+  const run = store.getRun(runId);
+  assert.equal(run.status, 'done');
+  assert.equal(run.summary.total, 1);
+  const results = store.getRunResults(runId);
+  assert.equal(results.length, 1);
+  assert.equal(results[0].passed, 1);
+
+  store.close();
+});
+
+test('Store upserts MCP servers', () => {
+  const store = new Store(':memory:');
+  store.saveMcpServer({ id: 'srv', name: 'Srv', url: 'http://localhost/mcp', enabled: true });
+  store.saveMcpServer({ id: 'srv', name: 'Srv2', url: 'http://localhost/mcp', enabled: false });
+  const servers = store.listMcpServers();
+  assert.equal(servers.length, 1);
+  assert.equal(servers[0].name, 'Srv2');
+  assert.equal(servers[0].enabled, false);
+  store.deleteMcpServer('srv');
+  assert.equal(store.listMcpServers().length, 0);
+  store.close();
+});

package/harness/packages/core/test/stream.test.js

@@ -0,0 +1,91 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { readOpenAISSE, readNDJSON, providerErrorMessage } from '../src/providers/stream.js';
+
+test('readOpenAISSE parses content, reasoning and tool calls', async () => {
+  const sse = [
+    'data: {"choices":[{"delta":{"reasoning":"pienso "}}]}',
+    'data: {"choices":[{"delta":{"content":"Hola "}}]}',
+    'data: {"choices":[{"delta":{"content":"mundo"}}]}',
+    'data: {"choices":[{"delta":{"tool_calls":[{"index":0,"id":"c1","type":"function","function":{"name":"calc","arguments":"{\\"a\\""}}]}}]}',
+    'data: {"choices":[{"delta":{"tool_calls":[{"index":0,"function":{"arguments":":1}"}}]}}]}',
+    'data: [DONE]',
+    '',
+  ].join('\n');
+
+  const res = await readOpenAISSE(new Response(sse));
+  assert.equal(res.content, 'Hola mundo');
+  assert.equal(res.reasoning, 'pienso ');
+  assert.equal(res.toolCalls.length, 1);
+  assert.equal(res.toolCalls[0].function.name, 'calc');
+  assert.equal(res.toolCalls[0].function.arguments, '{"a":1}');
+});
+
+test('readNDJSON parses Ollama messages and tool calls', async () => {
+  const ndjson = [
+    '{"message":{"content":"Hola "},"done":false}',
+    '{"message":{"content":"mundo","tool_calls":[{"function":{"name":"echo","arguments":{"x":1}}}]},"done":false}',
+    '{"done":true}',
+    '',
+  ].join('\n');
+
+  const res = await readNDJSON(new Response(ndjson));
+  assert.equal(res.content, 'Hola mundo');
+  assert.equal(res.toolCalls.length, 1);
+  assert.deepEqual(JSON.parse(res.toolCalls[0].function.arguments), { x: 1 });
+});
+
+test('empty responses throw', async () => {
+  await assert.rejects(readOpenAISSE(new Response('data: [DONE]\n')), /vac/);
+});
+
+test('readOpenAISSE surfaces mid-stream error payloads', async () => {
+  const sse = ['data: {"error":{"message":"rate limit"}}', 'data: [DONE]', ''].join('\n');
+  await assert.rejects(readOpenAISSE(new Response(sse)), /rate limit/);
+});
+
+test('readOpenAISSE extracts nested error shapes', async () => {
+  const sse = ['data: {"error":{"data":{"message":"deep cause"}}}', ''].join('\n');
+  await assert.rejects(readOpenAISSE(new Response(sse)), /deep cause/);
+});
+
+test('readNDJSON surfaces object error payloads', async () => {
+  const ndjson = ['{"error":{"message":"modelo caído"}}', ''].join('\n');
+  await assert.rejects(readNDJSON(new Response(ndjson)), /modelo ca/);
+});
+
+test('providerErrorMessage tolerates strings and odd shapes', () => {
+  assert.equal(providerErrorMessage('plano'), 'plano');
+  assert.equal(providerErrorMessage({ error: 'suelto' }), 'suelto');
+  assert.equal(providerErrorMessage({ error: { message: 'msg' } }), 'msg');
+  assert.equal(providerErrorMessage({ error: { data: { message: 'd' } } }), 'd');
+  assert.equal(providerErrorMessage({ message: 'fallback' }), 'fallback');
+  assert.equal(providerErrorMessage({}), 'error');
+});
+
+test('readOpenAISSE captures usage from the stream', async () => {
+  const sse = [
+    'data: {"choices":[{"delta":{"content":"hola"}}]}',
+    'data: {"usage":{"prompt_tokens":12,"completion_tokens":4,"total_tokens":16}}',
+    'data: [DONE]',
+    '',
+  ].join('\n');
+  const res = await readOpenAISSE(new Response(sse));
+  assert.deepEqual(res.usage, { prompt_tokens: 12, completion_tokens: 4, total_tokens: 16 });
+});
+
+test('readNDJSON captures Ollama eval counts as usage', async () => {
+  const ndjson = [
+    '{"message":{"content":"hola"},"done":false}',
+    '{"done":true,"prompt_eval_count":7,"eval_count":3}',
+    '',
+  ].join('\n');
+  const res = await readNDJSON(new Response(ndjson));
+  assert.deepEqual(res.usage, { prompt_tokens: 7, completion_tokens: 3, total_tokens: 10 });
+});
+
+test('usage is null when the provider does not report it', async () => {
+  const sse = ['data: {"choices":[{"delta":{"content":"hola"}}]}', 'data: [DONE]', ''].join('\n');
+  const res = await readOpenAISSE(new Response(sse));
+  assert.equal(res.usage, null);
+});

package/harness/packages/core/test/tools.test.js

@@ -0,0 +1,96 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtemp, readFile, writeFile, mkdir } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { resolveInRoot, toRel } from '../src/tools/paths.js';
+import { evaluatePermission } from '../src/tools/permissions.js';
+import { createTools, createToolRegistry } from '../src/tools/index.js';
+
+async function makeWorkspace() {
+  const root = await mkdtemp(path.join(tmpdir(), 'tamnora-ws-'));
+  await mkdir(path.join(root, 'src'), { recursive: true });
+  await writeFile(path.join(root, 'src', 'a.js'), 'const a = 1;\nconst b = 2;\n');
+  await writeFile(path.join(root, 'README.md'), '# Hola\n');
+  return root;
+}
+
+test('resolveInRoot confines paths to the workspace', async () => {
+  const root = await makeWorkspace();
+  assert.equal(toRel(root, resolveInRoot(root, 'src/a.js')), 'src/a.js');
+  assert.throws(() => resolveInRoot(root, '../secret'), /fuera del workspace/);
+  assert.throws(() => resolveInRoot(root, path.join(root, '..', 'x')), /fuera del workspace/);
+});
+
+test('evaluatePermission applies defaults and pattern maps', () => {
+  assert.equal(evaluatePermission('read', {}, {}), 'allow');
+  assert.equal(evaluatePermission('write', {}, {}), 'ask');
+  assert.equal(
+    evaluatePermission('bash', { command: 'git status' }, { bash: { 'git *': 'allow', '*': 'deny' } }),
+    'allow'
+  );
+  assert.equal(
+    evaluatePermission('bash', { command: 'rm -rf /' }, { bash: { 'git *': 'allow', '*': 'deny' } }),
+    'deny'
+  );
+});
+
+test('local tools read, write, list, glob, grep and edit', async () => {
+  const root = await makeWorkspace();
+  const reg = createToolRegistry({ root, permissions: { write: 'allow', edit: 'allow' } });
+
+  assert.match(await reg.execute('read', { path: 'src/a.js' }), /const a = 1;/);
+  assert.match(await reg.execute('list', { path: 'src' }), /a\.js/);
+  assert.match(await reg.execute('glob', { pattern: '**/*.js' }), /src\/a\.js/);
+  assert.match(await reg.execute('grep', { pattern: 'const b', include: '*.js' }), /src\/a\.js:2/);
+
+  await reg.execute('write', { path: 'src/new.txt', content: 'nuevo' });
+  assert.equal(await readFile(path.join(root, 'src', 'new.txt'), 'utf8'), 'nuevo');
+
+  await reg.execute('edit', { path: 'src/a.js', oldString: 'const a = 1;', newString: 'const a = 42;' });
+  assert.match(await readFile(path.join(root, 'src', 'a.js'), 'utf8'), /const a = 42;/);
+});
+
+test('edit refuses ambiguous replacements without replaceAll', async () => {
+  const root = await makeWorkspace();
+  await writeFile(path.join(root, 'dup.txt'), 'x\nx\n');
+  const reg = createToolRegistry({ root, permissions: { edit: 'allow' } });
+  assert.match(
+    await reg.execute('edit', { path: 'dup.txt', oldString: 'x', newString: 'y' }),
+    /aparece 2 veces/
+  );
+  assert.match(
+    await reg.execute('edit', { path: 'dup.txt', oldString: 'x', newString: 'y', replaceAll: true }),
+    /Editado/
+  );
+});
+
+test('permission "ask" is denied by default and allowed with yes', async () => {
+  const root = await makeWorkspace();
+  const denied = createToolRegistry({ root });
+  assert.match(await denied.execute('write', { path: 'z.txt', content: 'z' }), /Permiso denegado/);
+
+  const allowed = createToolRegistry({ root, yes: true });
+    assert.match(await allowed.execute('write', { path: 'z.txt', content: 'z' }), /Creado|Escrito/);
+});
+
+test('createTools combines local and MCP tool routing', async () => {
+  const root = await makeWorkspace();
+  const mcp = {
+    definitions: [{ type: 'function', function: { name: 'mcp__x__ping', parameters: {} } }],
+    handles: (n) => n === 'mcp__x__ping',
+    call: async () => 'pong',
+  };
+  const { definitions, execute } = createTools({ root, mcp });
+  assert.ok(definitions.some((d) => d.function.name === 'mcp__x__ping'));
+  assert.equal(await execute('mcp__x__ping', {}), 'pong');
+  assert.match(await execute('nope', {}), /desconocida/);
+});
+
+test('bash runs inside the workspace root', async () => {
+  const root = await makeWorkspace();
+  const reg = createToolRegistry({ root, permissions: { bash: 'allow' } });
+  const out = await reg.execute('bash', { command: 'echo hola' });
+  assert.match(out, /hola/);
+  assert.match(out, /\[exit 0\]/);
+});

package/harness/packages/server/bin/tamnora-server.mjs

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+import { serveCommand } from '../src/cli.js';
+
+serveCommand(process.argv.slice(2))
+  .then((code) => {
+    process.exitCode = typeof code === 'number' ? code : 0;
+  })
+  .catch((err) => {
+    console.error(err?.stack ?? String(err));
+    process.exitCode = 1;
+  });

package/harness/packages/server/package.json

@@ -0,0 +1,10 @@
+{
+  "name": "@tamnora/server",
+  "version": "0.0.0",
+  "private": true,
+  "type": "module",
+  "description": "Tamnora harness server: dependency-free HTTP + SSE console.",
+  "bin": {
+    "tamnora-server": "bin/tamnora-server.mjs"
+  }
+}