@danieltmn/tamnora 0.1.0

package/harness/packages/cli/src/commands/bridge.js

@@ -0,0 +1,274 @@
+import { spawn } from 'node:child_process';
+import { readFileSync, writeFileSync, unlinkSync, appendFileSync } from 'node:fs';
+import path from 'node:path';
+import {
+  setHome,
+  homeDir,
+  ensureHome,
+  ensureApp,
+  bridgeStatePath,
+  bridgeLogPath,
+} from '../../../core/src/index.js';
+import { parse, num } from '../lib/util.js';
+import { killPid, pidAlive } from '../lib/daemon.js';
+import { startTunnel } from '../lib/tunnel.js';
+import { qrTerminal } from '../lib/qr.js';
+
+const OPTIONS = {
+  start: { type: 'boolean' },
+  reload: { type: 'boolean' },
+  stop: { type: 'boolean' },
+  status: { type: 'boolean' },
+  foreground: { type: 'boolean' },
+  stream: { type: 'boolean' },
+  tunnel: { type: 'string' },
+  port: { type: 'string' },
+  home: { type: 'string' },
+  verbose: { type: 'boolean' },
+  help: { type: 'boolean', short: 'h' },
+};
+
+function readBridgeState() {
+  try {
+    return JSON.parse(readFileSync(bridgeStatePath(), 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function writeBridgeState(data) {
+  ensureHome();
+  writeFileSync(bridgeStatePath(), `${JSON.stringify(data, null, 2)}\n`);
+}
+
+function clearBridgeState() {
+  try {
+    unlinkSync(bridgeStatePath());
+  } catch {
+    /* nada */
+  }
+}
+
+export async function bridgeCommand(argv) {
+  const { values } = parse(argv, OPTIONS);
+  if (values.help) {
+    printHelp();
+    return 0;
+  }
+  if (values.home) {
+    setHome(values.home);
+    process.env.TAMNORA_HOME = path.resolve(values.home);
+  }
+
+  if (values.stop) return cmdStop();
+  if (values.status) return cmdStatus();
+
+  const isChild = Boolean(process.env.TAMNORA_BRIDGE_CHILD);
+  if (isChild || values.foreground || values.stream) return runForeground(values);
+  if (values.reload) return cmdReload(values);
+  return cmdStart(values);
+}
+
+function resolve(values) {
+  ensureHome();
+  const app = ensureApp();
+  return {
+    port: num(values.port, app.port || 4517),
+    provider: String(values.tunnel || app.tunnel?.provider || 'tunnelmole').toLowerCase(),
+  };
+}
+
+async function cmdStart(values) {
+  const { port, provider } = resolve(values);
+  if (provider === 'none') {
+    console.error('El tunel esta desactivado (provider "none"). Usa --tunnel tunnelmole.');
+    return 1;
+  }
+
+  const current = readBridgeState();
+  if (current && pidAlive(current.pid)) {
+    console.log(`Bridge ya esta corriendo (pid ${current.pid}).`);
+    printStatus(current);
+    return 0;
+  }
+
+  const bin = process.argv[1];
+  const args = [bin, 'bridge', '--foreground', '--port', String(port), '--tunnel', provider];
+  if (process.env.TAMNORA_HOME) args.push('--home', process.env.TAMNORA_HOME);
+  if (values.verbose) args.push('--verbose');
+  const child = spawn(process.execPath, args, {
+    detached: true,
+    stdio: 'ignore',
+    windowsHide: true,
+    env: { ...process.env, TAMNORA_BRIDGE_CHILD: '1' },
+  });
+  child.unref();
+  let dead = false;
+  child.on('exit', () => {
+    dead = true;
+  });
+  console.log(`Abriendo tunel (${provider}) en el puerto ${port}...`);
+
+  const state = await waitForBridge(child.pid, () => dead, 90000);
+  if (!state) {
+    const tail = tailBridgeLog(8);
+    if (tail) console.log(tail);
+    console.log('No pude abrir el tunel. Revisa: tamnora bridge --status');
+    return 1;
+  }
+  printStatus(state, true);
+  return 0;
+}
+
+async function runForeground(values) {
+  const { port, provider } = resolve(values);
+  const log = (line) => {
+    const text = `[${new Date().toISOString()}] ${line}`;
+    try {
+      ensureHome();
+      appendFileSync(bridgeLogPath(), `${text}\n`);
+    } catch {
+      /* nada */
+    }
+    console.log(text);
+  };
+
+  let tun;
+  try {
+    tun = await startTunnel(port, provider, { log, verbose: values.verbose });
+  } catch (err) {
+    log(`ERROR: ${err.message}`);
+    return 1;
+  }
+  if (!tun.url) {
+    log('ERROR: el tunel no devolvio URL.');
+    return 1;
+  }
+
+  writeBridgeState({
+    pid: process.pid,
+    url: tun.url,
+    provider: tun.provider,
+    port,
+    childPid: tun.pid,
+    startedAt: new Date().toISOString(),
+  });
+  printStatus(readBridgeState(), true);
+  log(`Tunel publico: ${tun.url}`);
+
+  return new Promise((resolve) => {
+    let closing = false;
+    const shutdown = () => {
+      if (closing) return;
+      closing = true;
+      try {
+        tun.stop();
+      } catch {
+        /* nada */
+      }
+      clearBridgeState();
+      resolve(0);
+    };
+    process.once('SIGINT', shutdown);
+    process.once('SIGTERM', shutdown);
+  });
+}
+
+async function cmdReload(values) {
+  await cmdStop();
+  const current = readBridgeState();
+  for (let i = 0; i < 25 && current && pidAlive(current.pid); i++) {
+    await new Promise((r) => setTimeout(r, 200));
+  }
+  return cmdStart(values);
+}
+
+async function cmdStop() {
+  const state = readBridgeState();
+  const stopped = [];
+  // Mata el supervisor y tambien el proceso del tunel (aunque el supervisor
+  // haya muerto y haya quedado huerfano).
+  if (state?.pid && pidAlive(state.pid)) {
+    killPid(state.pid);
+    stopped.push(`bridge ${state.pid}`);
+  }
+  if (state?.childPid && pidAlive(state.childPid)) {
+    killPid(state.childPid);
+    stopped.push(`tunel ${state.childPid}`);
+  }
+  clearBridgeState();
+  if (!stopped.length) {
+    console.log('El bridge no esta corriendo.');
+    return 0;
+  }
+  console.log(`Bridge detenido (${stopped.join(', ')}).`);
+  return 0;
+}
+
+async function cmdStatus() {
+  const state = readBridgeState();
+  if (!state || !pidAlive(state.pid)) {
+    console.log('Bridge detenido.');
+    return 0;
+  }
+  printStatus(state);
+  return 0;
+}
+
+function printStatus(state, withQr = false) {
+  console.log(`Bridge corriendo (pid ${state.pid})`);
+  console.log(`  url     : ${state.url}`);
+  console.log(`  proveedor: ${state.provider}   puerto local: ${state.port}`);
+  console.log(`  casa    : ${homeDir()}`);
+  if (withQr && state.url) {
+    const art = qrTerminal(state.url, 2);
+    if (art) {
+      console.log('');
+      console.log(art);
+      console.log(`  escanea para abrir ${state.url}`);
+    }
+  }
+}
+
+function tailBridgeLog(n) {
+  try {
+    const lines = readFileSync(bridgeLogPath(), 'utf8')
+      .split(/\r?\n/)
+      .filter((l) => l.trim() !== '');
+    return lines.slice(-n).join('\n');
+  } catch {
+    return '';
+  }
+}
+
+function waitForBridge(childPid, isDead, timeoutMs) {
+  return new Promise((resolve) => {
+    const start = Date.now();
+    const tick = () => {
+      if (isDead()) return resolve(null);
+      const state = readBridgeState();
+      if (state && state.pid && pidAlive(state.pid) && (!childPid || state.pid === childPid)) return resolve(state);
+      if (Date.now() - start > timeoutMs) return resolve(null);
+      setTimeout(tick, 500);
+    };
+    tick();
+  });
+}
+
+function printHelp() {
+  console.log(`Uso: tamnora bridge [accion] [opciones]
+
+Abre un tunel publico (tunnelmole) hacia el server local para trabajar remoto.
+
+Acciones:
+  --start           Abre el tunel en segundo plano + QR (default)
+  --reload          Reinicia el tunel
+  --stop            Cierra el tunel
+  --status          Estado y URL publica
+  --foreground      Corre en primer plano (debug)
+
+Opciones:
+  --tunnel <prov>   Proveedor (default: el de app.json; hoy: tunnelmole)
+  --port <n>        Puerto local a exponer (default: el del server)
+  --home <path>     Casa de Tamnora (default: TAMNORA_HOME o datos del sistema)`);
+}

package/harness/packages/cli/src/commands/doctor.js

@@ -0,0 +1,73 @@
+import { existsSync } from 'node:fs';
+import net from 'node:net';
+import {
+  homeDir,
+  homeExists,
+  readApp,
+  databasePath,
+  serverLogPath,
+  Store,
+} from '../../../core/src/index.js';
+import { parse } from '../lib/util.js';
+import { pidAlive, readRuntime } from '../lib/daemon.js';
+
+const OPTIONS = { home: { type: 'string' }, help: { type: 'boolean', short: 'h' } };
+
+export async function doctorCommand(argv) {
+  const { values } = parse(argv, OPTIONS);
+  if (values.help) {
+    console.log('Uso: tamnora doctor [--home <path>]\n\nVerifica Node, la casa, el puerto y la base.');
+    return 0;
+  }
+
+  const [maj, min] = process.versions.node.split('.').map((n) => parseInt(n, 10));
+  const nodeOk = maj > 22 || (maj === 22 && min >= 5);
+  const checks = [
+    [`Node ${process.versions.node}`, nodeOk, nodeOk ? '' : 'requiere Node >= 22.5 (node:sqlite)'],
+  ];
+
+  const cfgOk = homeExists();
+  checks.push([`casa (${homeDir()})`, cfgOk, cfgOk ? '' : 'corre: tamnora server --init']);
+
+  const app = readApp();
+  const rt = readRuntime();
+  const serverLive = Boolean(rt && pidAlive(rt.pid));
+  const port = serverLive && rt.port ? rt.port : app.port || 4517;
+  const host = serverLive && rt.host ? rt.host : app.host || '127.0.0.1';
+  const portFree = await isPortFree(port, host);
+  checks.push([`puerto ${port}`, portFree || serverLive, portFree ? '' : 'ocupado (¿ya corre Tamnora?)']);
+
+  const db = databasePath();
+  const dbOk = existsSync(db);
+  let provider = '';
+  if (dbOk) {
+    try {
+      const store = new Store(db);
+      provider = store.getSetting('activeProvider') || '';
+      store.close();
+    } catch {
+      /* base ilegible */
+    }
+  }
+  checks.push(['base de datos', dbOk, dbOk ? '' : 'se creara al primer uso']);
+  checks.push(['proveedor activo', Boolean(provider), provider || 'elegi uno en la consola (npm: tamnora serve)']);
+
+  if (serverLive) checks.push([`server (pid ${rt.pid})`, true, rt.url || '']);
+  checks.push([`logs`, true, serverLogPath()]);
+
+  let ok = true;
+  for (const [name, pass, hint] of checks) {
+    console.log(`${pass ? '  OK  ' : ' FALTA'}  ${name}${hint ? `  ->  ${hint}` : ''}`);
+    if (!pass && !name.startsWith('proveedor')) ok = false;
+  }
+  return ok ? 0 : 1;
+}
+
+function isPortFree(port, host) {
+  return new Promise((resolve) => {
+    const server = net.createServer();
+    server.once('error', () => resolve(false));
+    server.once('listening', () => server.close(() => resolve(true)));
+    server.listen(port, host);
+  });
+}

package/harness/packages/cli/src/commands/eval.js

@@ -0,0 +1,183 @@
+import path from 'node:path';
+import {
+  loadConfig,
+  loadInstructions,
+  loadDataset,
+  runDataset,
+  summarize,
+  createJudge,
+  Store,
+} from '../lib/core.js';
+import { parse, databasePath, num } from '../lib/util.js';
+import { buildSystemPrompt, resolveCliProvider } from '../lib/runtime.js';
+import { color } from '../ui/color.js';
+
+const OPTIONS = {
+  provider: { type: 'string' },
+  model: { type: 'string', multiple: true },
+  dir: { type: 'string' },
+  trials: { type: 'string' },
+  concurrency: { type: 'string' },
+  tools: { type: 'string' },
+  'no-tools': { type: 'boolean' },
+  'judge-model': { type: 'string' },
+  yes: { type: 'boolean', short: 'y' },
+  json: { type: 'boolean' },
+  help: { type: 'boolean', short: 'h' },
+};
+
+function pct(value) {
+  return `${Math.round(value * 100)}%`;
+}
+
+export async function evalCommand(argv) {
+  const { values, positionals } = parse(argv, OPTIONS);
+  if (values.help) {
+    printHelp();
+    return 0;
+  }
+
+  const datasetFile = positionals[0];
+  if (!datasetFile) {
+    console.error(color.red('Falta el dataset. Uso: tamnora eval <dataset.jsonl> [--model <id>]'));
+    return 1;
+  }
+
+  const cwd = values.dir ? path.resolve(values.dir) : process.cwd();
+  const config = await loadConfig(cwd);
+
+  const tasks = await loadDataset(path.resolve(cwd, datasetFile));
+  if (!tasks.length) {
+    console.error(color.red('El dataset está vacío.'));
+    return 1;
+  }
+
+  const instructions = await loadInstructions(cwd, config.instructions);
+  const systemPrompt = buildSystemPrompt(instructions);
+  const trials = num(values.trials, 1);
+  const concurrency = num(values.concurrency, 1);
+
+  const store = new Store(databasePath(cwd));
+  const resolved = resolveCliProvider(store, config, { provider: values.provider, model: values.model });
+  const providerId = resolved.providerId;
+  const baseUrl = resolved.baseUrl;
+  const apiKey = resolved.apiKey;
+  const models = (values.model?.length ? values.model : [resolved.model]).filter(Boolean);
+  if (!models.length) {
+    console.error(color.red('Falta el modelo (usá --model, Ajustes o "model" en tamnora.json).'));
+    store.close();
+    return 1;
+  }
+
+  const judge = createJudge({
+    providerId,
+    model: values['judge-model'] || config.judgeModel,
+    baseUrl,
+    apiKey,
+  });
+
+  const enabledTools = values['no-tools']
+    ? []
+    : values.tools
+      ? String(values.tools).split(',').map((s) => s.trim()).filter(Boolean)
+      : Array.isArray(config.tools) && config.tools.length
+        ? config.tools
+        : undefined;
+
+  const runId = store.createRun({
+    dataset: datasetFile,
+    config: { providerId, models, trials, concurrency, tools: enabledTools ?? 'all' },
+  });
+  const startedAt = Date.now();
+
+  if (!values.json) {
+    process.stderr.write(
+      color.dim(
+        `run ${runId} · ${tasks.length} tareas × ${models.length} modelos × ${trials} trials · concurrencia ${concurrency}\n`
+      )
+    );
+  }
+
+  const results = await runDataset({
+    tasks,
+    models,
+    providerId,
+    baseUrl,
+    apiKey,
+    systemPrompt,
+    rootDir: cwd,
+    trials,
+    concurrency,
+    enabledTools,
+    permissions: config.permissions,
+    yes: Boolean(values.yes),
+    judge,
+    store,
+    runId,
+    onProgress(entry) {
+      if (values.json) return;
+      const mark = entry.error ? color.red('✗') : entry.passed ? color.green('✓') : color.yellow('·');
+      const scorers = (entry.trace?.scorers ?? []).map((s) => `${s.scorer}:${s.passed ? 'ok' : 'no'}`).join(' ');
+      const suffix = entry.error ? ` — ${entry.error}` : scorers ? ` [${scorers}]` : '';
+      process.stdout.write(`${mark} ${entry.taskId} · ${entry.model}${suffix}\n`);
+    },
+  });
+
+  const summary = summarize(results);
+  summary.durationMs = Date.now() - startedAt;
+  const status = summary.errors && summary.passed === 0 ? 'failed' : summary.errors ? 'done_with_errors' : 'done';
+  store.finishRun(runId, { status, summary });
+  store.close();
+
+  if (values.json) {
+    process.stdout.write(`${JSON.stringify({ runId, summary }, null, 2)}\n`);
+  } else {
+    printReport(summary, runId);
+  }
+
+  return summary.passed === 0 && summary.errors > 0 ? 1 : summary.passed < summary.total ? 1 : 0;
+}
+
+function printReport(summary, runId) {
+  const lines = [];
+  lines.push('');
+  lines.push(color.bold(`Resultados (run ${runId})`));
+  lines.push(color.dim('modelo'.padEnd(34) + 'pasó  total  pass  errores'));
+  for (const m of summary.models) {
+    lines.push(
+      `${String(m.model).slice(0, 33).padEnd(34)}${String(m.passed).padStart(4)}${String(m.total).padStart(7)}${pct(m.passRate).padStart(6)}${String(m.errors).padStart(9)}`
+    );
+  }
+  if (summary.scorers.length) {
+    lines.push('');
+    lines.push(color.dim('scorer'.padEnd(34) + 'pasó  total  pass'));
+    for (const s of summary.scorers) {
+      lines.push(
+        `${String(s.scorer).slice(0, 33).padEnd(34)}${String(s.passed).padStart(4)}${String(s.total).padStart(7)}${pct(s.passRate).padStart(6)}`
+      );
+    }
+  }
+  lines.push('');
+  lines.push(
+    color.dim(
+      `total ${summary.total} · ${summary.passed} ok · ${summary.errors} errores · ${(summary.durationMs / 1000).toFixed(1)}s`
+    )
+  );
+  process.stderr.write(`${lines.join('\n')}\n`);
+}
+
+function printHelp() {
+  console.log(`Uso: tamnora eval <dataset.jsonl> [opciones]
+
+Opciones:
+  --provider <id>      Proveedor
+  --model <id>         Modelo (repetible para comparar varios)
+  --trials <n>         Repeticiones por tarea/modelo (default: 1)
+  --concurrency <n>    Tareas en paralelo (default: 1)
+  --judge-model <id>   Modelo para el scorer llmJudge
+  --dir <path>         Directorio del proyecto
+  --tools <lista>      Tools habilitadas (coma)
+  --no-tools           Deshabilitar tools
+  -y, --yes            Aprobar automáticamente permisos "ask"
+  --json               Salida JSON`);
+}

package/harness/packages/cli/src/commands/init.js

@@ -0,0 +1,31 @@
+import { writeFile, access } from 'node:fs/promises';
+import path from 'node:path';
+import { DEFAULT_CONFIG } from '../lib/core.js';
+import { parse } from '../lib/util.js';
+import { color } from '../ui/color.js';
+
+const OPTIONS = {
+  dir: { type: 'string' },
+  help: { type: 'boolean', short: 'h' },
+};
+
+export async function initCommand(argv) {
+  const { values } = parse(argv, OPTIONS);
+  if (values.help) {
+    console.log('Uso: tamnora init [--dir <path>]');
+    return 0;
+  }
+
+  const cwd = values.dir ? path.resolve(values.dir) : process.cwd();
+  const file = path.join(cwd, 'tamnora.json');
+  try {
+    await access(file);
+    console.log(color.yellow(`Ya existe ${file}`));
+    return 0;
+  } catch {
+    // create it
+  }
+  await writeFile(file, `${JSON.stringify(DEFAULT_CONFIG, null, 2)}\n`, 'utf8');
+  console.log(color.green(`Creado ${file}`));
+  return 0;
+}

package/harness/packages/cli/src/commands/mcp.js

@@ -0,0 +1,101 @@
+import path from 'node:path';
+import { loadConfig, buildMcpRegistry, mcpTransport } from '../lib/core.js';
+import { parse } from '../lib/util.js';
+import { color } from '../ui/color.js';
+
+const OPTIONS = {
+  dir: { type: 'string' },
+  json: { type: 'boolean' },
+  help: { type: 'boolean', short: 'h' },
+};
+
+export async function mcpCommand(argv) {
+  const { values } = parse(argv, OPTIONS);
+  if (values.help) {
+    printHelp();
+    return 0;
+  }
+
+  const cwd = values.dir ? path.resolve(values.dir) : process.cwd();
+  const config = await loadConfig(cwd);
+  const servers = Array.isArray(config.mcp) ? config.mcp : [];
+
+  if (!servers.length) {
+    if (values.json) process.stdout.write(`${JSON.stringify({ servers: [] }, null, 2)}\n`);
+    else process.stdout.write(color.dim('No hay servidores MCP configurados en tamnora.json.\n'));
+    return 0;
+  }
+
+  const registry = await buildMcpRegistry(servers);
+
+  if (values.json) {
+    process.stdout.write(
+      `${JSON.stringify(
+        {
+          servers: servers.map((server) => {
+            const session = registry.sessions.find((s) => s.server.id === server.id);
+            return {
+              id: server.id,
+              name: server.name,
+              transport: safeTransport(server),
+              tools: (session?.tools ?? []).map((t) => t.name),
+              resources: (session?.resources ?? []).map((r) => r.uri),
+              prompts: (session?.prompts ?? []).map((p) => p.name),
+              error: registry.errors.find((e) => e.server.id === server.id)?.error,
+            };
+          }),
+        },
+        null,
+        2
+      )}\n`
+    );
+    registry.close();
+    return 0;
+  }
+
+  let failed = false;
+  for (const server of servers) {
+    const transport = safeTransport(server);
+    const session = registry.sessions.find((s) => s.server.id === server.id);
+    const error = registry.errors.find((e) => e.server.id === server.id)?.error;
+    const label = `${server.id}${server.name ? ` (${server.name})` : ''}`;
+
+    if (error) {
+      failed = true;
+      process.stdout.write(`${color.red('✗')} ${label} ${color.dim(`[${transport}]`)}\n`);
+      process.stdout.write(`  ${color.red(error)}\n`);
+      continue;
+    }
+    process.stdout.write(`${color.green('✓')} ${label} ${color.dim(`[${transport}]`)}\n`);
+    for (const tool of session?.tools ?? []) {
+      process.stdout.write(`  ${color.cyan(tool.name)}${tool.description ? color.dim(` — ${tool.description}`) : ''}\n`);
+    }
+    for (const resource of session?.resources ?? []) {
+      process.stdout.write(`  ${color.dim('resource')} ${resource.uri}${resource.name ? color.dim(` (${resource.name})`) : ''}\n`);
+    }
+    for (const prompt of session?.prompts ?? []) {
+      process.stdout.write(`  ${color.dim('prompt')} ${prompt.name}\n`);
+    }
+  }
+
+  registry.close();
+  return failed ? 1 : 0;
+}
+
+function safeTransport(server) {
+  try {
+    return mcpTransport(server);
+  } catch {
+    return '?';
+  }
+}
+
+function printHelp() {
+  console.log(`Uso: tamnora mcp [opciones]
+
+Conecta a los servidores MCP de tamnora.json y lista sus herramientas.
+
+Opciones:
+  --dir <path>   Directorio del proyecto (tamnora.json)
+  --json         Salida JSON`);
+}