@danieltmn/tamnora 0.1.0

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

@@ -0,0 +1,172 @@
+import path from 'node:path';
+import readline from 'node:readline';
+import {
+  loadConfig,
+  loadInstructions,
+  Store,
+  createTools,
+  buildMcpRegistry,
+} from '../lib/core.js';
+import { parse, databasePath, num } from '../lib/util.js';
+import { buildSystemPrompt, runTurn, createPrinter, resolveCliProvider } from '../lib/runtime.js';
+import { color } from '../ui/color.js';
+
+const OPTIONS = {
+  provider: { type: 'string' },
+  model: { type: 'string' },
+  dir: { type: 'string' },
+  'max-steps': { type: 'string' },
+  tools: { type: 'string' },
+  'no-tools': { type: 'boolean' },
+  yes: { type: 'boolean', short: 'y' },
+};
+
+export async function replCommand(argv) {
+  const { values } = parse(argv, OPTIONS);
+  const cwd = values.dir ? path.resolve(values.dir) : process.cwd();
+  const config = await loadConfig(cwd);
+
+  let systemPrompt = buildSystemPrompt(await loadInstructions(cwd, config.instructions));
+  const maxRounds = num(values['max-steps'], config.maxRounds);
+  const store = new Store(databasePath(cwd));
+  const resolved = resolveCliProvider(store, config, { provider: values.provider, model: values.model });
+  let providerId = resolved.providerId;
+  let model = resolved.model;
+  const baseUrl = resolved.baseUrl;
+  const apiKey = resolved.apiKey;
+  if (!model) {
+    console.error(color.red('Falta el modelo (usá --model, Ajustes o "model" en tamnora.json).'));
+    store.close();
+    return 1;
+  }
+  const sessionId = store.createSession({ title: 'REPL', provider: providerId, model, cwd });
+  let history = [];
+  let busy = false;
+
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+    prompt: color.cyan('tamnora> '),
+    historySize: 200,
+  });
+
+  // Interactive permission prompt for 'ask' tools.
+  const onAsk = (name, args) =>
+    new Promise((resolve) => {
+      const detail = args?.command ?? args?.path ?? '';
+      rl.question(
+        color.yellow(`\npermitir ${name}${detail ? ` (${detail})` : ''}? [y/N] `),
+        (answer) => resolve(/^y(es)?$/i.test(answer.trim()))
+      );
+    });
+
+  let mcp = null;
+  if (Array.isArray(config.mcp) && config.mcp.length) {
+    try {
+      mcp = await buildMcpRegistry(config.mcp);
+    } catch (err) {
+      process.stdout.write(color.yellow(`MCP: ${err.message}\n`));
+    }
+  }
+  const enabled = 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 { definitions: toolDefs, execute } = createTools({
+    root: cwd,
+    enabled,
+    permissions: config.permissions,
+    yes: Boolean(values.yes),
+    onAsk,
+    mcp,
+  });
+
+  process.stdout.write(color.dim(`Tamnora REPL · ${providerId}/${model}\n`));
+  process.stdout.write(color.dim(`workspace ${cwd}\n`));
+  process.stdout.write(color.dim(`session ${sessionId} · /help para comandos · Ctrl+C para salir\n\n`));
+  rl.prompt();
+
+  rl.on('line', async (line) => {
+    if (busy) return;
+    const text = line.trim();
+    if (!text) {
+      rl.prompt();
+      return;
+    }
+
+    if (text.startsWith('/')) {
+      const [rawCmd, ...rest] = text.slice(1).split(/\s+/);
+      const cmd = rawCmd.toLowerCase();
+      const arg = rest.join(' ').trim();
+      if (cmd === 'exit' || cmd === 'quit') {
+        rl.close();
+        return;
+      } else if (cmd === 'help') {
+        process.stdout.write(
+          `${color.dim(
+            '/model <id>  /provider <id>  /system <texto>  /clear  /session  /exit'
+          )}\n`
+        );
+      } else if (cmd === 'model') {
+        if (arg) model = arg;
+        process.stdout.write(color.dim(`modelo: ${model}\n`));
+      } else if (cmd === 'provider') {
+        if (arg) providerId = arg;
+        process.stdout.write(color.dim(`proveedor: ${providerId}\n`));
+      } else if (cmd === 'system') {
+        if (arg) systemPrompt = arg;
+        process.stdout.write(color.dim(`system prompt (${systemPrompt.length} chars)\n`));
+      } else if (cmd === 'clear') {
+        history = [];
+        process.stdout.write(color.dim('historial limpiado\n'));
+      } else if (cmd === 'session') {
+        process.stdout.write(color.dim(`session ${sessionId}\n`));
+      } else {
+        process.stdout.write(color.red(`comando desconocido: /${cmd}\n`));
+      }
+      rl.prompt();
+      return;
+    }
+
+    busy = true;
+    const printer = createPrinter();
+    process.stdout.write(color.magenta('assistant: '));
+    try {
+      const { newMessages } = await runTurn({
+        providerId,
+        model,
+        baseUrl,
+        apiKey,
+        systemPrompt,
+        history,
+        input: text,
+        maxRounds,
+        tools: toolDefs,
+        execute,
+        onEvent: printer.onEvent,
+      });
+      printer.finish();
+      history = history.concat(newMessages);
+      store.addMessages(sessionId, newMessages);
+      store.touchSession(sessionId, { provider: providerId, model });
+    } catch (err) {
+      process.stdout.write('\n');
+      console.error(color.red(`Error: ${err.message}`));
+    } finally {
+      busy = false;
+      rl.prompt();
+    }
+  });
+
+  return new Promise((resolve) => {
+    rl.on('close', () => {
+      store.close();
+      mcp?.close?.();
+      process.stdout.write('\n');
+      resolve(0);
+    });
+  });
+}

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

@@ -0,0 +1,165 @@
+import path from 'node:path';
+import { loadConfig, loadInstructions, Store, createTools, buildMcpRegistry } from '../lib/core.js';
+import { parse, databasePath, num } from '../lib/util.js';
+import { buildSystemPrompt, runTurn, createPrinter, resolveCliProvider } from '../lib/runtime.js';
+import { color } from '../ui/color.js';
+
+const OPTIONS = {
+  provider: { type: 'string' },
+  model: { type: 'string' },
+  dir: { type: 'string' },
+  session: { type: 'string' },
+  continue: { type: 'boolean', short: 'c' },
+  json: { type: 'boolean' },
+  'max-steps': { type: 'string' },
+  system: { type: 'string' },
+  tools: { type: 'string' },
+  'no-tools': { type: 'boolean' },
+  yes: { type: 'boolean', short: 'y' },
+  help: { type: 'boolean', short: 'h' },
+};
+
+export async function runCommand(argv) {
+  const { values, positionals } = parse(argv, OPTIONS);
+  if (values.help) {
+    printHelp();
+    return 0;
+  }
+
+  const prompt = positionals.join(' ').trim();
+  if (!prompt) {
+    console.error(color.red('Falta el prompt. Uso: tamnora run "<prompt>"'));
+    return 1;
+  }
+
+  const cwd = values.dir ? path.resolve(values.dir) : process.cwd();
+  const config = await loadConfig(cwd);
+  const instructions = await loadInstructions(cwd, config.instructions);
+  const store = new Store(databasePath(cwd));
+  const { providerId, model, baseUrl, apiKey } = resolveCliProvider(store, config, {
+    provider: values.provider,
+    model: values.model,
+  });
+  if (!model) {
+    console.error(color.red('Falta el modelo (usá --model, Ajustes o "model" en tamnora.json).'));
+    store.close();
+    return 1;
+  }
+
+  // Local, workspace-scoped tools (combined with any configured MCP servers).
+  let mcp = null;
+  if (Array.isArray(config.mcp) && config.mcp.length) {
+    try {
+      mcp = await buildMcpRegistry(config.mcp);
+    } catch (err) {
+      process.stderr.write(color.yellow(`MCP: ${err.message}\n`));
+    }
+  }
+  const enabled = 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 { definitions: toolDefs, execute } = createTools({
+    root: cwd,
+    enabled,
+    permissions: config.permissions,
+    yes: Boolean(values.yes),
+    mcp,
+  });
+
+  let sessionId = values.session;
+  let history = [];
+  if (sessionId) {
+    if (!store.getSession(sessionId)) {
+      console.error(color.red(`Sesión no encontrada: ${sessionId}`));
+      store.close();
+      return 1;
+    }
+    history = store.getMessages(sessionId);
+  } else if (values.continue) {
+    const latest = store.latestSession();
+    if (latest) {
+      sessionId = latest.id;
+      history = store.getMessages(sessionId);
+    }
+  }
+  if (!sessionId) {
+    sessionId = store.createSession({ title: prompt.slice(0, 60), provider: providerId, model, cwd });
+  }
+
+  const printer = createPrinter({ json: values.json });
+  const controller = new AbortController();
+  const onSigint = () => controller.abort();
+  process.once('SIGINT', onSigint);
+
+  try {
+    const { result, newMessages } = await runTurn({
+      providerId,
+      model,
+      baseUrl,
+      apiKey,
+      systemPrompt: buildSystemPrompt(instructions, values.system),
+      history,
+      input: prompt,
+      maxRounds: num(values['max-steps'], config.maxRounds),
+      signal: controller.signal,
+      tools: toolDefs,
+      execute,
+      onEvent: printer.onEvent,
+    });
+    printer.finish();
+    store.addMessages(sessionId, newMessages);
+    store.touchSession(sessionId, { provider: providerId, model });
+
+    if (values.json) {
+      process.stdout.write(
+        `${JSON.stringify(
+          {
+            output: result.content,
+            stopReason: result.stopReason,
+            rounds: result.rounds,
+            sessionId,
+            provider: providerId,
+            model,
+          },
+          null,
+          2
+        )}\n`
+      );
+    } else {
+      process.stderr.write(color.dim(`\nsession ${sessionId}\n`));
+    }
+    return 0;
+  } catch (err) {
+    if (err.name === 'AbortError') {
+      process.stderr.write('\n');
+      return 130;
+    }
+    console.error(color.red(`\nError: ${err.message}`));
+    return 1;
+  } finally {
+    process.removeListener('SIGINT', onSigint);
+    mcp?.close?.();
+    store.close();
+  }
+}
+
+function printHelp() {
+  console.log(`Uso: tamnora run "<prompt>" [opciones]
+
+Opciones:
+  --provider <id>    Proveedor (openrouter, deepseek, groq, ollama, ...)
+  --model <id>       Modelo a usar
+  --dir <path>       Directorio del proyecto (tamnora.json / AGENTS.md)
+  --session <id>     Continuar una sesión existente
+  -c, --continue     Continuar la última sesión
+  --system <texto>   Instrucciones extra de sistema
+  --max-steps <n>    Máximo de rondas de herramientas (default: 8)
+  --tools <lista>    Tools habilitadas (coma), ej. read,list,grep
+  --no-tools         Deshabilitar todas las tools
+  -y, --yes          Aprobar automáticamente los permisos "ask"
+  --json             Salida JSON (sin streaming)`);
+}

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

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

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

@@ -0,0 +1,345 @@
+import { spawn } from 'node:child_process';
+import { appendFileSync, writeFileSync, readFileSync } from 'node:fs';
+import path from 'node:path';
+import {
+  setHome,
+  homeDir,
+  ensureHome,
+  homeExists,
+  readApp,
+  writeApp,
+  ensureApp,
+  databasePath,
+  pidPath,
+  serverLogPath,
+} from '../../../core/src/index.js';
+import { createTamnoraServer } from '../../../server/src/index.js';
+import { parse, num } from '../lib/util.js';
+import {
+  killPid,
+  pidAlive,
+  readRuntime,
+  writeRuntime,
+  clearRuntime,
+  stopRunningServer,
+  portHint,
+  tailLines,
+} from '../lib/daemon.js';
+
+const OPTIONS = {
+  init: { type: 'boolean' },
+  start: { type: 'boolean' },
+  stop: { type: 'boolean' },
+  reload: { type: 'boolean' },
+  status: { type: 'boolean' },
+  logs: { type: 'boolean' },
+  follow: { type: 'boolean', short: 'f' },
+  stream: { type: 'boolean' },
+  foreground: { type: 'boolean' },
+  'no-tunnel': { type: 'boolean' },
+  port: { type: 'string' },
+  host: { type: 'string' },
+  dir: { type: 'string' },
+  home: { type: 'string' },
+  force: { type: 'boolean' },
+  yes: { type: 'boolean', short: 'y' },
+  help: { type: 'boolean', short: 'h' },
+};
+
+function applyHome(values) {
+  const override = values.home ? path.resolve(values.home) : process.env.TAMNORA_HOME || null;
+  if (values.home) {
+    setHome(values.home);
+    process.env.TAMNORA_HOME = override;
+  }
+  return override;
+}
+
+function log(line) {
+  const text = `[${new Date().toISOString()}] ${line}`;
+  try {
+    ensureHome();
+    appendFileSync(serverLogPath(), `${text}\n`);
+  } catch {
+    /* sin log no detenemos nada */
+  }
+  console.log(text);
+}
+
+export async function serverCommand(argv) {
+  const { values } = parse(argv, OPTIONS);
+  if (values.help) {
+    printHelp();
+    return 0;
+  }
+  applyHome(values);
+
+  if (values.init) return cmdInit(values);
+  if (values.stop) return cmdStop();
+  if (values.status) return cmdStatus();
+  if (values.logs) return cmdLogs(values);
+  if (values.reload) return cmdReload(values);
+  return cmdStart(values);
+}
+
+async function cmdInit(values) {
+  ensureHome();
+  const existed = homeExists();
+  if (existed && !values.force) {
+    console.log(`Ya existe configuracion en ${homeDir()}`);
+    console.log('Usa --force para reconfigurar (se pisa app.json).');
+  } else {
+    if (existed && stopRunningServer()) {
+      console.log('Habia un server corriendo; lo detuve para reconfigurar.');
+    }
+    const app = readApp();
+    if (values.port) app.port = num(values.port, app.port);
+    if (values.host) app.host = values.host;
+    if (values['no-tunnel']) app.tunnel = { ...app.tunnel, provider: 'none' };
+    writeApp(app);
+    ensureApp();
+    console.log(`Casa Tamnora creada en ${homeDir()}`);
+  }
+  return cmdStart(values);
+}
+
+async function cmdStart(values) {
+  ensureHome();
+  const app = ensureApp();
+  const port = num(values.port, app.port || 4517);
+  const host = values.host || app.host || '127.0.0.1';
+  if (app.port !== port || app.host !== host) {
+    app.port = port;
+    app.host = host;
+    writeApp(app);
+  }
+  const cwd = values.dir ? path.resolve(values.dir) : process.cwd();
+
+  const isChild = Boolean(process.env.TAMNORA_DETACHED);
+  const foreground = Boolean(values.stream || values.foreground) || isChild;
+
+  if (!isChild) {
+    const cur = readRuntime();
+    if (cur && pidAlive(cur.pid)) {
+      console.log(`Tamnora ya esta corriendo (pid ${cur.pid}).`);
+      printStatus(cur);
+      return 0;
+    }
+  }
+
+  if (!foreground) {
+    const bin = process.argv[1];
+    const args = [bin, 'server', '--stream', '--port', String(port), '--host', host];
+    if (values.dir) args.push('--dir', cwd);
+    if (process.env.TAMNORA_HOME) args.push('--home', process.env.TAMNORA_HOME);
+    if (values.yes) args.push('--yes');
+    const child = spawn(process.execPath, args, {
+      detached: true,
+      stdio: 'ignore',
+      windowsHide: true,
+      env: { ...process.env, TAMNORA_DETACHED: '1' },
+    });
+    child.unref();
+    let dead = false;
+    child.on('exit', () => {
+      dead = true;
+    });
+    console.log(`Tamnora arrancando en segundo plano (pid ${child.pid})...`);
+    const rt = await waitForRuntime(child.pid, () => dead, 30000);
+    const tail = rt ? '' : tailLines(serverLogPath(), 8);
+    if (tail) {
+      console.log('');
+      console.log(`Ultimas lineas de ${serverLogPath()}:`);
+      console.log(tail);
+    }
+    const current = rt || readRuntime();
+    if (current) printStatus(current);
+    else console.log('No pude confirmar el arranque. Revisa: tamnora server --logs');
+    return current ? 0 : 1;
+  }
+
+  return runForeground({ values, port, host, cwd });
+}
+
+async function runForeground({ values, port, host, cwd }) {
+  let instance;
+  try {
+    instance = await createTamnoraServer({ cwd, port, host, dbPath: databasePath(cwd), yes: Boolean(values.yes) });
+  } catch (err) {
+    log(`ERROR: ${err.message}`);
+    return 1;
+  }
+
+  let info;
+  try {
+    info = await instance.listen({ port, host });
+  } catch (err) {
+    if (err && err.code === 'EADDRINUSE') {
+      log(`ERROR: puerto ${port} ocupado (¿ya corre Tamnora?). Usa --port <otro> o \`tamnora server --stop\`.`);
+      const hint = portHint(port);
+      if (hint) log(`  lo esta usando: ${hint}`);
+      return 1;
+    }
+    log(`ERROR: ${err.message}`);
+    return 1;
+  }
+
+  const runtime = {
+    pid: process.pid,
+    port: info.port,
+    host: info.host,
+    url: info.url,
+    cwd,
+    provider: instance.config.provider,
+    model: instance.config.model || '',
+    tunnel: 'none',
+    startedAt: new Date().toISOString(),
+    children: [],
+  };
+  writeRuntime(runtime);
+  try {
+    writeFileSync(pidPath(), String(process.pid));
+  } catch {
+    /* nada */
+  }
+  log(`Tamnora escuchando en ${info.url} (workspace ${cwd})`);
+  if (!instance.ctx.authEnabled) {
+    log('aviso: sin usuario configurado; el server no pide login. Crea uno: tamnora user --name <n> --password <p>');
+  }
+
+  return new Promise((resolve) => {
+    let closing = false;
+    const shutdown = async () => {
+      if (closing) return;
+      closing = true;
+      log('Cerrando Tamnora...');
+      try {
+        await instance.close();
+      } catch {
+        /* nada */
+      }
+      clearRuntime();
+      resolve(0);
+    };
+    process.once('SIGINT', shutdown);
+    process.once('SIGTERM', shutdown);
+  });
+}
+
+async function cmdStop() {
+  const rt = readRuntime();
+  const pid = rt && rt.pid ? rt.pid : readPid();
+  const stopped = [];
+  if (pid && pidAlive(pid)) {
+    killPid(pid);
+    if (rt && Array.isArray(rt.children)) {
+      for (const c of rt.children) killPid(c);
+    }
+    stopped.push(`server ${pid}`);
+  }
+  clearRuntime();
+  if (!stopped.length) {
+    console.log('Tamnora no esta corriendo.');
+    return 0;
+  }
+  console.log(`Tamnora detenido (${stopped.join(', ')}).`);
+  return 0;
+}
+
+async function cmdReload(values) {
+  await cmdStop();
+  for (let i = 0; i < 25 && pidAlive(readPid()); i++) {
+    await new Promise((r) => setTimeout(r, 200));
+  }
+  return cmdStart(values);
+}
+
+async function cmdStatus() {
+  const rt = readRuntime();
+  if (!rt || !pidAlive(rt.pid)) {
+    console.log('Tamnora detenido.');
+    return 0;
+  }
+  printStatus(rt);
+  return 0;
+}
+
+async function cmdLogs(values) {
+  const file = serverLogPath();
+  const initial = tailLines(file, 40);
+  console.log(initial || `(sin logs en ${file})`);
+  if (!values.follow) return 0;
+  let offset = initial.length;
+  return new Promise((resolve) => {
+    const timer = setInterval(() => {
+      let text = '';
+      try {
+        text = readFileSync(file, 'utf8');
+      } catch {
+        return;
+      }
+      if (text.length > offset) {
+        process.stdout.write(text.slice(offset));
+        offset = text.length;
+      }
+    }, 1000);
+    const stop = () => {
+      clearInterval(timer);
+      resolve(0);
+    };
+    process.once('SIGINT', stop);
+  });
+}
+
+function printStatus(rt) {
+  console.log(`Tamnora corriendo (pid ${rt.pid})`);
+  console.log(`  url      : ${rt.url}`);
+  console.log(`  workspace: ${rt.cwd}`);
+  console.log(`  modelo   : ${rt.provider}${rt.model ? `/${rt.model}` : ''}`);
+  console.log(`  casa     : ${homeDir()}`);
+  console.log(`  logs     : ${serverLogPath()}`);
+}
+
+function readPid() {
+  try {
+    return parseInt(readFileSync(pidPath(), 'utf8'), 10);
+  } catch {
+    return 0;
+  }
+}
+
+function waitForRuntime(childPid, isDead, timeoutMs) {
+  return new Promise((resolve) => {
+    const start = Date.now();
+    const tick = () => {
+      if (isDead()) return resolve(null);
+      const rt = readRuntime();
+      if (rt && rt.pid && pidAlive(rt.pid) && (!childPid || rt.pid === childPid)) return resolve(rt);
+      if (Date.now() - start > timeoutMs) return resolve(null);
+      setTimeout(tick, 400);
+    };
+    tick();
+  });
+}
+
+function printHelp() {
+  console.log(`Uso: tamnora server [accion] [opciones]
+
+Arranca la consola del harness como servicio local (segundo plano por defecto).
+
+Acciones:
+  --init            Crea/valida la casa y arranca
+  --start           Arranca en segundo plano (default)
+  --reload          Reinicia (aplica config/codigo)
+  --stop            Detiene
+  --status          Estado del server
+  --logs [--follow] Ultimas lineas del log
+  --stream          Corre en primer plano (debug)
+
+Opciones:
+  --port <n>        Puerto (default: el de app.json, 4517)
+  --host <addr>     Interfaz (default: 127.0.0.1)
+  --dir <path>      Workspace del server
+  --home <path>     Casa de Tamnora (default: TAMNORA_HOME o datos del sistema)
+  -y, --yes         Auto-aprobar tools con permiso "ask"`);
+}