@danieltmn/tamnora 0.1.0

package/harness/packages/cli/src/lib/runtime.js

@@ -0,0 +1,110 @@
+import { runAgent, resolveProviderRuntime, composeProviderSettings, resolveApiKey } from './core.js';
+
+/**
+ * Resolve provider/model/apiKey/baseUrl for CLI commands, merging the active
+ * settings and stored providers (SQLite) over `tamnora.json`.
+ */
+export function resolveCliProvider(store, config, { provider, model } = {}) {
+  const providerId = provider || store.getSetting('activeProvider') || config.provider;
+  const activeModel = model || store.getSetting('activeModel') || config.model;
+  const customProviders = store
+    .listProviders()
+    .filter((p) => p.custom)
+    .map((p) => ({ id: p.id, label: p.label, baseUrl: p.baseUrl, models: p.models }));
+  const settings = composeProviderSettings({
+    providerId,
+    stored: store.getProvider(providerId) ?? {},
+    config,
+    customProviders,
+  });
+  return {
+    providerId,
+    model: activeModel,
+    baseUrl: settings.baseUrl,
+    apiKey: resolveApiKey(settings.apiKey, process.env),
+    settings,
+  };
+}
+
+/**
+ * Build the system prompt from instruction files plus an optional extra block.
+ */
+export function buildSystemPrompt(instructions, extra) {
+  const parts = [];
+  if (instructions?.trim()) parts.push(instructions.trim());
+  if (extra?.trim()) parts.push(extra.trim());
+  return parts.join('\n\n') || 'Eres un asistente útil. Responde en el idioma del usuario.';
+}
+
+/**
+ * Run a single agent turn over a history.
+ * Returns the agent result plus only the newly produced messages (user + assistant/tool),
+ * so callers can persist them without duplicating prior history.
+ */
+export async function runTurn({
+  providerId,
+  model,
+  baseUrl,
+  apiKey,
+  systemPrompt,
+  history = [],
+  input,
+  maxRounds,
+  stallWarnMs,
+  signal,
+  execute,
+  tools = [],
+  toolContext = {},
+  onEvent,
+}) {
+  const { provider, config } = resolveProviderRuntime({ providerId, apiKey, baseUrl });
+
+  const messages = [
+    { role: 'system', content: systemPrompt },
+    ...history,
+    { role: 'user', content: input },
+  ];
+
+  const result = await runAgent({
+    provider,
+    config,
+    model,
+    messages,
+    tools,
+    execute,
+    toolContext,
+    maxRounds,
+    stallWarnMs,
+    signal,
+    onEvent,
+  });
+
+  const newMessages = result.messages.slice(1 + history.length);
+  return { result, newMessages, providerId: provider.id };
+}
+
+/**
+ * Streaming printer for the CLI. Suppressed when `json` is true so stdout
+ * stays machine-readable.
+ */
+export function createPrinter({ json = false } = {}) {
+  let wroteText = false;
+  return {
+    onEvent(event) {
+      if (json) return;
+      if (event.type === 'text') {
+        process.stdout.write(event.delta);
+        wroteText = true;
+      } else if (event.type === 'stall') {
+        process.stderr.write(`\n[aviso] ${event.seconds} s sin respuesta del modelo (proveedor caído o muy lento). Sigo esperando...\n`);
+      } else if (event.type === 'tool_call') {
+        process.stderr.write(`\n[tool] ${event.name} ${JSON.stringify(event.args)}\n`);
+      } else if (event.type === 'tool_result') {
+        process.stderr.write(`[tool] → ${String(event.result).slice(0, 300)}\n`);
+      }
+    },
+    finish() {
+      if (!json && wroteText) process.stdout.write('\n');
+    },
+  };
+}

package/harness/packages/cli/src/lib/tunnel.js

@@ -0,0 +1,113 @@
+import { spawn } from 'node:child_process';
+
+/**
+ * Tuneles publicos. v1 soporta tunnelmole (gratis, sin cuenta; URL aleatoria)
+ * via `npx --yes tunnelmole <puerto>`.
+ */
+
+function killTree(child) {
+  if (!child || child.killed) return;
+  const pid = child.pid;
+  try {
+    if (process.platform === 'win32' && pid) {
+      spawn('taskkill', ['/PID', String(pid), '/T', '/F'], { windowsHide: true });
+    } else {
+      if (pid) {
+        try {
+          process.kill(-pid, 'SIGTERM');
+        } catch {
+          /* sin grupo */
+        }
+      }
+      try {
+        child.kill('SIGTERM');
+      } catch {
+        /* ya murio */
+      }
+    }
+  } catch {
+    /* ya murio */
+  }
+}
+
+export function parseTunnelmoleUrls(text) {
+  const urls = [...new Set(String(text).match(/https?:\/\/[a-z0-9-]+\.tunnelmole\.net/gi) || [])];
+  return {
+    https: urls.find((u) => u.startsWith('https')) || '',
+    http: urls.find((u) => u.startsWith('http:')) || '',
+  };
+}
+
+function spawnTunnel(bin, args, opts = {}) {
+  const log = opts.log || (() => {});
+  const parse = opts.parse || (() => ({ https: '', http: '' }));
+  const timeoutMs = opts.timeoutMs || 90000;
+  const label = opts.label || bin;
+  return new Promise((resolve, reject) => {
+    let child;
+    try {
+      child = spawn(bin, args, {
+        stdio: ['ignore', 'pipe', 'pipe'],
+        windowsHide: true,
+        shell: process.platform === 'win32',
+        detached: process.platform !== 'win32',
+      });
+    } catch (err) {
+      reject(new Error(`no se pudo iniciar ${label}: ${err.message}`));
+      return;
+    }
+    let buf = '';
+    let settled = false;
+    const timer = setTimeout(() => {
+      if (settled) return;
+      settled = true;
+      killTree(child);
+      reject(new Error(`${label} no devolvio URL (${Math.round(timeoutMs / 1000)} s).`));
+    }, timeoutMs);
+    const feed = (data) => {
+      buf += String(data);
+      if (opts.verbose) process.stdout.write(String(data));
+      const urls = parse(buf);
+      const url = urls.https || urls.http;
+      if (url) {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer);
+        log(`${label}: ${url} -> localhost:${opts.port}`);
+        resolve({ url, provider: opts.provider, pid: child.pid, stop: () => killTree(child) });
+      }
+    };
+    child.stdout.on('data', feed);
+    child.stderr.on('data', feed);
+    child.on('error', (err) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      reject(new Error(`${label}: ${err.message}`));
+    });
+    child.on('exit', (code) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      reject(new Error(`${label} termino (codigo ${code})${buf ? `: ${buf.slice(0, 200).trim()}` : ''}`));
+    });
+  });
+}
+
+export function startTunnelmole(port, opts = {}) {
+  return spawnTunnel('npx', ['--yes', 'tunnelmole', String(port)], {
+    ...opts,
+    port,
+    provider: 'tunnelmole',
+    label: 'tunnelmole',
+    parse: parseTunnelmoleUrls,
+  });
+}
+
+/** Devuelve { url, provider, pid, stop }. provider 'none' no abre nada. */
+export async function startTunnel(port, provider = 'tunnelmole', opts = {}) {
+  const p = String(provider || 'tunnelmole').toLowerCase();
+  if (p === 'none' || p === 'off' || p === '') return { url: '', provider: 'none', pid: 0, stop: () => {} };
+  if (p === 'tunnelmole' || p === 'tmole') return startTunnelmole(port, opts);
+  throw new Error(`proveedor de tunel no soportado: ${provider}`);
+}

package/harness/packages/cli/src/lib/util.js

@@ -0,0 +1,24 @@
+import { parseArgs } from 'node:util';
+
+/**
+ * Parse CLI arguments. Unknown flags are tolerated (strict: false).
+ * @param {string[]} argv
+ * @param {Record<string, import('node:util').ParseArgsOptionDescriptor>} options
+ */
+export function parse(argv, options) {
+  const { values, positionals } = parseArgs({
+    args: argv,
+    options,
+    allowPositionals: true,
+    strict: false,
+  });
+  return { values, positionals };
+}
+
+/** Re-exportados desde el core: la base es global (casa de Tamnora). */
+export { STATE_DIR, databasePath } from '../../../core/src/index.js';
+
+export function num(value, fallback) {
+  const n = Number(value);
+  return Number.isFinite(n) ? n : fallback;
+}

package/harness/packages/cli/src/tui/app.js

@@ -0,0 +1,302 @@
+// Full-screen terminal console (opencode/codex-like), zero dependencies.
+// Alt-screen + raw input + incremental rendering; reuses the harness engine.
+
+import { createTools } from '../lib/core.js';
+import { runTurn } from '../lib/runtime.js';
+import { parseKeys } from './keys.js';
+import { render } from './layout.js';
+import * as screen from './screen.js';
+
+export function runTui({
+  providerId,
+  model,
+  baseUrl,
+  apiKey,
+  systemPrompt,
+  maxRounds,
+  toolOptions,
+  store,
+  sessionId,
+}) {
+  const state = {
+    header: { provider: providerId, model, cwd: toolOptions.root },
+    messages: [],
+    input: '',
+    inputCursor: 0,
+    streaming: false,
+    pendingAsk: null,
+    scroll: 0,
+    follow: true,
+    tokens: null,
+  };
+
+  const history = [];
+  let historyIndex = -1;
+  let conv = [];
+  let controller = null;
+  let closed = false;
+  let resolveExit = () => {};
+
+  if (sessionId) {
+    for (const message of store.getMessages(sessionId)) {
+      if (message.role === 'user') {
+        state.messages.push({ role: 'user', text: typeof message.content === 'string' ? message.content : '', tools: [] });
+      } else if (message.role === 'assistant' && message.content) {
+        state.messages.push({ role: 'assistant', text: String(message.content), tools: [] });
+      }
+    }
+    conv = store.getMessages(sessionId);
+  }
+  state.messages.push({
+    role: 'assistant',
+    text: `Consola Tamnora · ${providerId}/${model}\nEscribí un mensaje o /salir. Ctrl+C cancela la generación.`,
+    tools: [],
+  });
+
+  const onAsk = (name, args) =>
+    new Promise((resolve) => {
+      state.pendingAsk = { name, detail: args?.command ?? args?.path ?? '', resolve };
+      draw();
+    });
+
+  const { definitions, execute } = createTools({ ...toolOptions, onAsk });
+
+  function draw() {
+    if (closed) return;
+    const { frame, cursor } = render(state, {
+      cols: process.stdout.columns || 80,
+      rows: process.stdout.rows || 24,
+    });
+    process.stdout.write(frame);
+    process.stdout.write(screen.moveTo(cursor.row, cursor.col));
+  }
+
+  function addMessage(role, text) {
+    const message = { role, text, tools: [] };
+    state.messages.push(message);
+    return message;
+  }
+
+  function setInput(value, cursor) {
+    state.input = value;
+    state.inputCursor = cursor == null ? Array.from(value).length : cursor;
+  }
+
+  function insertText(text) {
+    const value = String(text).replace(/\r\n?/g, '\n').replace(/\n/g, ' ');
+    const chars = Array.from(state.input);
+    chars.splice(state.inputCursor, 0, ...Array.from(value));
+    setInput(chars.join(''), state.inputCursor + Array.from(value).length);
+  }
+
+  function pageSize() {
+    return Math.max(1, (process.stdout.rows || 24) - 5);
+  }
+
+  function resolveAsk(answer) {
+    const pending = state.pendingAsk;
+    state.pendingAsk = null;
+    pending?.resolve(answer);
+  }
+
+  async function submit() {
+    if (state.streaming) return;
+    const text = state.input.trim();
+    if (!text) return;
+    if (text === '/salir' || text === '/exit' || text === '/quit') return shutdown(0);
+    if (text === '/limpiar' || text === '/clear') {
+      state.input = '';
+      state.messages = [];
+      return;
+    }
+
+    setInput('');
+    state.scroll = 0;
+    state.follow = true;
+    history.push(text);
+    historyIndex = -1;
+    addMessage('user', text);
+    const assistant = addMessage('assistant', '');
+    state.streaming = true;
+    controller = new AbortController();
+    let sawText = false;
+    draw();
+
+    try {
+      const { result, newMessages } = await runTurn({
+        providerId,
+        model,
+        baseUrl,
+        apiKey,
+        systemPrompt,
+        history: conv,
+        input: text,
+        maxRounds,
+        signal: controller.signal,
+        tools: definitions,
+        execute,
+        onEvent(event) {
+          if (event.type === 'text') {
+            sawText = true;
+            assistant.text = event.full;
+          } else if (event.type === 'reasoning') {
+            if (!sawText) assistant.reasoning = event.full;
+          } else if (event.type === 'stall') {
+            if (!sawText) assistant.text = `⚠ ${event.seconds} s sin respuesta del modelo (proveedor caído o muy lento). Sigo esperando...`;
+          } else if (event.type === 'tool_call') {
+            assistant.tools.push({ name: event.name, args: JSON.stringify(event.args) });
+          } else if (event.type === 'tool_result') {
+            const tool = assistant.tools[assistant.tools.length - 1];
+            if (tool) tool.result = String(event.result).slice(0, 2000);
+          }
+          draw();
+        },
+      });
+      conv = conv.concat(newMessages);
+      store.addMessages(sessionId, newMessages);
+      store.touchSession(sessionId, { provider: providerId, model });
+      if (result?.usage) {
+        state.tokens = {
+          prompt: result.usage.last_prompt_tokens ?? result.usage.prompt_tokens,
+          completion: result.usage.last_completion_tokens ?? result.usage.completion_tokens,
+        };
+      }
+      if (!assistant.text && !sawText) assistant.text = '(sin texto)';
+    } catch (error) {
+      if (error?.name === 'AbortError') {
+        assistant.text = assistant.text ? `${assistant.text}\n[cancelado]` : '[cancelado]';
+      } else {
+        assistant.text = `Error: ${error?.message ?? error}`;
+      }
+    } finally {
+      state.streaming = false;
+      controller = null;
+      draw();
+    }
+  }
+
+  function handleAction(action) {
+    if (state.pendingAsk) {
+      if (action.type === 'char' && /[yYsS]/.test(action.value)) resolveAsk(true);
+      else if (action.type === 'interrupt' || action.type === 'enter' || (action.type === 'char' && /[nN]/.test(action.value)))
+        resolveAsk(false);
+      draw();
+      return;
+    }
+
+    switch (action.type) {
+      case 'char':
+      case 'paste':
+        insertText(action.value);
+        break;
+      case 'backspace': {
+        const chars = Array.from(state.input);
+        if (state.inputCursor > 0) {
+          chars.splice(state.inputCursor - 1, 1);
+          setInput(chars.join(''), state.inputCursor - 1);
+        }
+        break;
+      }
+      case 'delete': {
+        const chars = Array.from(state.input);
+        if (state.inputCursor < chars.length) {
+          chars.splice(state.inputCursor, 1);
+          setInput(chars.join(''), state.inputCursor);
+        }
+        break;
+      }
+      case 'left':
+        setInput(state.input, Math.max(0, state.inputCursor - 1));
+        break;
+      case 'right':
+        setInput(state.input, Math.min(Array.from(state.input).length, state.inputCursor + 1));
+        break;
+      case 'home':
+        setInput(state.input, 0);
+        break;
+      case 'end':
+        setInput(state.input, Array.from(state.input).length);
+        break;
+      case 'kill-line':
+        setInput('');
+        break;
+      case 'pageup':
+        state.follow = false;
+        state.scroll = Math.max(0, (state.scroll ?? 0) + pageSize());
+        break;
+      case 'pagedown':
+        state.scroll = Math.max(0, (state.scroll ?? 0) - pageSize());
+        if (state.scroll === 0) state.follow = true;
+        break;
+      case 'up':
+        if (history.length) {
+          historyIndex = historyIndex <= 0 ? history.length - 1 : historyIndex - 1;
+          setInput(history[historyIndex] ?? '');
+        }
+        break;
+      case 'down':
+        if (history.length && historyIndex !== -1) {
+          historyIndex += 1;
+          setInput(historyIndex >= history.length ? ((historyIndex = -1), '') : history[historyIndex]);
+        }
+        break;
+      case 'clear':
+        state.messages = [];
+        break;
+      case 'enter':
+        submit();
+        return;
+      case 'interrupt':
+      case 'eof':
+        if (state.streaming) controller?.abort();
+        else shutdown(0);
+        return;
+      default:
+        break;
+    }
+    draw();
+  }
+
+  function onData(chunk) {
+    for (const action of parseKeys(String(chunk))) handleAction(action);
+  }
+
+  function shutdown(code) {
+    if (closed) return;
+    closed = true;
+    try {
+      process.stdin.setRawMode(false);
+    } catch {
+      // stdin may not be a TTY (tests)
+    }
+    process.stdin.off('data', onData);
+    process.stdout.off('resize', draw);
+    process.stdin.pause();
+    toolOptions.mcp?.close?.();
+    store.close?.();
+    process.stdout.write(screen.disableBracketedPaste + screen.showCursor + screen.leaveAltScreen);
+    resolveExit(code);
+  }
+
+  // Restaura la terminal aunque el proceso muera por una señal o excepcion.
+  process.once('exit', () => {
+    try {
+      process.stdout.write(screen.disableBracketedPaste + screen.showCursor + screen.leaveAltScreen);
+    } catch {
+      /* nada */
+    }
+  });
+  process.once('SIGTERM', () => shutdown(0));
+
+  process.stdout.write(screen.enterAltScreen + screen.hideCursor + screen.enableBracketedPaste);
+  if (process.stdin.setRawMode) process.stdin.setRawMode(true);
+  process.stdin.setEncoding('utf8');
+  process.stdin.resume();
+  process.stdin.on('data', onData);
+  process.stdout.on('resize', draw);
+  draw();
+
+  return new Promise((resolve) => {
+    resolveExit = resolve;
+  });
+}

package/harness/packages/cli/src/tui/keys.js

@@ -0,0 +1,78 @@
+// Parse raw terminal input into high-level actions (pure, testable).
+
+const ESCAPE_ACTIONS = {
+  '\x1b[A': 'up',
+  '\x1bOA': 'up',
+  '\x1b[B': 'down',
+  '\x1bOB': 'down',
+  '\x1b[C': 'right',
+  '\x1bOC': 'right',
+  '\x1b[D': 'left',
+  '\x1bOD': 'left',
+  '\x1b[H': 'home',
+  '\x1bOH': 'home',
+  '\x1b[1~': 'home',
+  '\x1b[F': 'end',
+  '\x1bOF': 'end',
+  '\x1b[4~': 'end',
+  '\x1b[3~': 'delete',
+  '\x1b[5~': 'pageup',
+  '\x1b[6~': 'pagedown',
+};
+
+const FINAL_BYTE = /[@-~]/;
+
+// Reads one escape sequence starting at `i` (chars is a code-point array).
+function readEscape(chars, i) {
+  if (chars[i + 1] === '[') {
+    let j = i + 2;
+    while (j < chars.length && !FINAL_BYTE.test(chars[j])) j += 1;
+    if (j < chars.length) j += 1;
+    return { seq: chars.slice(i, j).join(''), len: j - i };
+  }
+  if (chars[i + 1] === 'O' && i + 2 < chars.length) {
+    return { seq: chars.slice(i, i + 3).join(''), len: 3 };
+  }
+  return { seq: '\x1b', len: 1 };
+}
+
+export function parseKeys(input) {
+  const chars = Array.from(input);
+  const actions = [];
+  let i = 0;
+
+  while (i < chars.length) {
+    const ch = chars[i];
+
+    if (ch === '\x1b') {
+      const { seq, len } = readEscape(chars, i);
+      if (seq === '\x1b[200~') {
+        const remaining = chars.slice(i + len).join('');
+        const end = remaining.indexOf('\x1b[201~');
+        if (end !== -1) {
+          const value = remaining.slice(0, end);
+          actions.push({ type: 'paste', value });
+          i = i + len + Array.from(value).length + 6;
+          continue;
+        }
+      }
+      const mapped = ESCAPE_ACTIONS[seq];
+      if (mapped) actions.push({ type: mapped });
+      i += len;
+      continue;
+    }
+
+    if (ch === '\r' || ch === '\n') actions.push({ type: 'enter' });
+    else if (ch === '\x7f' || ch === '\b') actions.push({ type: 'backspace' });
+    else if (ch === '\x03') actions.push({ type: 'interrupt' });
+    else if (ch === '\x04') actions.push({ type: 'eof' });
+    else if (ch === '\x0c') actions.push({ type: 'clear' });
+    else if (ch === '\x15') actions.push({ type: 'kill-line' });
+    else if (ch === '\x01') actions.push({ type: 'home' });
+    else if (ch === '\x05') actions.push({ type: 'end' });
+    else if (ch >= ' ') actions.push({ type: 'char', value: ch });
+    i += 1;
+  }
+
+  return actions;
+}