@danieltmn/tamnora 0.1.0

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

@@ -0,0 +1,110 @@
+import path from 'node:path';
+import { loadConfig, loadInstructions, Store, buildMcpRegistry, resolveMode } from '../lib/core.js';
+import { parse, databasePath, num } from '../lib/util.js';
+import { buildSystemPrompt, resolveCliProvider } from '../lib/runtime.js';
+import { runTui } from '../tui/app.js';
+import { color } from '../ui/color.js';
+
+const OPTIONS = {
+  provider: { type: 'string' },
+  model: { type: 'string' },
+  dir: { type: 'string' },
+  'max-steps': { type: 'string' },
+  mode: { 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 tuiCommand(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 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;
+  }
+  if (!process.stdin.isTTY || !process.stdout.isTTY) {
+    console.error(color.red('La consola requiere una terminal interactiva. Usá "tamnora repl" o "tamnora run".'));
+    store.close();
+    return 1;
+  }
+
+  const instructions = await loadInstructions(cwd, config.instructions);
+  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 baseEnabled = 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 mode = resolveMode(values.mode || store.getSetting('activeMode') || 'agent');
+  const enabled = mode.tools
+    ? baseEnabled
+      ? baseEnabled.filter((tool) => mode.tools.includes(tool))
+      : mode.tools
+    : baseEnabled;
+
+  const sessionId = store.createSession({ title: 'Consola', provider: providerId, model, cwd });
+
+  return runTui({
+    providerId,
+    model,
+    baseUrl,
+    apiKey,
+    systemPrompt: buildSystemPrompt(instructions, [values.system, mode.systemPrompt].filter(Boolean).join('\n\n')),
+    maxRounds: num(values['max-steps'], config.maxRounds),
+    toolOptions: {
+      root: cwd,
+      enabled,
+      permissions: config.permissions,
+      mcp,
+      yes: Boolean(values.yes),
+    },
+    store,
+    sessionId,
+  });
+}
+
+function printHelp() {
+  console.log(`Uso: tamnora [--model <id>] [opciones]
+
+Consola full-screen (estilo opencode/codex). Atajos:
+  enter      enviar        ↑ / ↓     historial
+  ← →        mover cursor  home/end  inicio / fin
+  pgup/pgdn  scroll        ctrl+l    limpiar
+  ctrl+c     cancelar / salir        /salir  /limpiar
+
+Opciones:
+  --provider <id>   Proveedor (por defecto: el activo)
+  --model <id>      Modelo (por defecto: el activo)
+  --mode <id>       Modo de agente: agent | plan
+  --dir <path>      Directorio del proyecto
+  --max-steps <n>   Máximo de rondas de herramientas
+  --tools <lista>   Tools habilitadas (coma)   --no-tools
+  -y, --yes         Auto-aprobar tools con permiso "ask"`);
+}

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

@@ -0,0 +1,76 @@
+import { spawnSync } from 'node:child_process';
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import path from 'node:path';
+import { parse } from '../lib/util.js';
+
+const PACKAGE = '@danieltmn/tamnora';
+const NPM = process.platform === 'win32' ? 'npm.cmd' : 'npm';
+const OPTIONS = { yes: { type: 'boolean', short: 'y' }, check: { type: 'boolean' }, tag: { type: 'string' }, help: { type: 'boolean', short: 'h' } };
+
+function currentVersion() {
+  try {
+    const pkg = JSON.parse(
+      readFileSync(path.join(path.dirname(fileURLToPath(import.meta.url)), '../../../../package.json'), 'utf8')
+    );
+    return pkg.version || '0.0.0';
+  } catch {
+    return '0.0.0';
+  }
+}
+
+function npm(args) {
+  return spawnSync(NPM, args, { encoding: 'utf8', windowsHide: true });
+}
+
+export async function updateCommand(argv) {
+  const { values } = parse(argv, OPTIONS);
+  if (values.help) {
+    console.log('Uso: tamnora update [--check] [--yes]\n\nBusca una version nueva en npm y actualiza la instalacion global.');
+    return 0;
+  }
+
+  const tag = typeof values.tag === 'string' && values.tag ? values.tag : 'latest';
+  const spec = `${PACKAGE}@${tag}`;
+  const version = currentVersion();
+  console.log(`Version actual: ${version}`);
+
+  const view = npm(['view', spec, 'version', '--json']);
+  let latest = '';
+  try {
+    latest = String(JSON.parse(view.stdout)).trim();
+  } catch {
+    latest = String(view.stdout || '').trim().replace(/"/g, '');
+  }
+  if (view.status !== 0 || !/^\d+\.\d+\.\d+/.test(latest)) {
+    console.error(`No se pudo consultar npm (${tag}): ${(view.stderr || '').trim() || 'revisa tu conexion'}`);
+    return 1;
+  }
+  console.log(`Disponible (${tag}): ${latest}`);
+  if (latest === version) {
+    console.log('Ya estas en la ultima version.');
+    return 0;
+  }
+  if (values.check) {
+    console.log(`Hay una version nueva. Corre: tamnora update --yes`);
+    return 0;
+  }
+  if (!values.yes) {
+    console.log('');
+    console.log('Para actualizar ahora:');
+    console.log(`  tamnora update --yes        (o)  npm i -g ${spec}`);
+    return 0;
+  }
+
+  console.log(`Actualizando a ${spec}...`);
+  const result = spawnSync(NPM, ['i', '-g', spec], {
+    stdio: 'inherit',
+    windowsHide: true,
+  });
+  if (result.status !== 0) {
+    console.error(`La actualizacion fallo. Proba a mano: npm i -g ${spec}`);
+    return 1;
+  }
+  console.log('Listo. Reinicia el server: tamnora server --reload');
+  return 0;
+}

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

@@ -0,0 +1,135 @@
+import {
+  setHome,
+  readApp,
+  writeApp,
+  ensureApp,
+  makeUser,
+  userValidName,
+  randomToken,
+} from '../../../core/src/index.js';
+import { parse } from '../lib/util.js';
+import { stopRunningServer } from '../lib/daemon.js';
+
+const OPTIONS = {
+  name: { type: 'string' },
+  password: { type: 'string' },
+  home: { type: 'string' },
+  yes: { type: 'boolean', short: 'y' },
+  help: { type: 'boolean', short: 'h' },
+};
+
+export async function userCommand(argv) {
+  const { values, positionals } = parse(argv, OPTIONS);
+  if (values.help) {
+    printHelp();
+    return 0;
+  }
+  if (values.home) setHome(values.home);
+
+  ensureApp();
+  const app = readApp();
+  const sub = (positionals[0] || (values.name || values.password ? 'set' : 'show')).toLowerCase();
+
+  if (sub === 'show' || sub === 'list') {
+    if (!app.user) {
+      console.log('Sin usuario configurado (el server no pide login).');
+      return 0;
+    }
+    console.log(`usuario: ${app.user.name}`);
+    console.log(`creado : ${app.user.created}`);
+    return 0;
+  }
+
+  if (sub === 'remove' || sub === 'del' || sub === 'rm') {
+    if (!app.user) {
+      console.log('No hay usuario configurado.');
+      return 0;
+    }
+    app.user = null;
+    persist(app, 'Usuario eliminado (el server deja de pedir login).');
+    return 0;
+  }
+
+  if (sub === 'set' || sub === 'add' || sub === 'passwd' || sub === 'password') {
+    const name = String(values.name || app.user?.name || '').trim();
+    if (!userValidName(name)) {
+      console.error('Nombre invalido (letras, numeros, . _ -; 1-32). Usa --name <nombre>.');
+      return 1;
+    }
+    let password = values.password || '';
+    let generated = false;
+    if (!password && process.stdin.isTTY) {
+      password = await askHidden(`Contrasena para "${name}" (enter = generar): `);
+    }
+    if (!password) {
+      password = randomToken(12);
+      generated = true;
+    }
+    const prev = app.user && app.user.name === name ? app.user : null;
+    app.user = makeUser(name, password, prev);
+    persist(app, `Usuario "${name}" configurado.`);
+    if (generated) console.log(`  contrasena: ${password}  (generada)`);
+    return 0;
+  }
+
+  printHelp();
+  return 1;
+}
+
+function persist(app, message) {
+  if (stopRunningServer()) console.log('Habia un server corriendo; lo detuve para aplicar el cambio.');
+  writeApp(app);
+  console.log(message);
+  console.log('  volve a arrancar: tamnora server --start');
+}
+
+function askHidden(question) {
+  return new Promise((resolve) => {
+    const stdin = process.stdin;
+    process.stdout.write(question);
+    const wasRaw = stdin.isRaw;
+    if (stdin.isTTY) stdin.setRawMode(true);
+    stdin.resume();
+    let value = '';
+    const cleanup = () => {
+      stdin.off('data', onData);
+      if (stdin.isTTY) stdin.setRawMode(Boolean(wasRaw));
+      stdin.pause();
+    };
+    const onData = (chunk) => {
+      for (const ch of chunk.toString('utf8')) {
+        if (ch === '\r' || ch === '\n') {
+          cleanup();
+          process.stdout.write('\n');
+          resolve(value);
+          return;
+        }
+        if (ch === '\u0003') {
+          cleanup();
+          process.stdout.write('\n');
+          process.exit(130);
+        }
+        if (ch === '\u007f' || ch === '\b') {
+          value = value.slice(0, -1);
+          continue;
+        }
+        if (ch >= ' ') value += ch;
+      }
+    };
+    stdin.on('data', onData);
+  });
+}
+
+function printHelp() {
+  console.log(`Uso: tamnora user [show|set|passwd|remove] [--name <n>] [--password <p>]
+
+Administra el usuario local (v1: uno solo). Al cambiar el usuario se detiene el
+server; volve a arrancarlo con \`tamnora server --start\`.
+
+  (sin args)         Muestra el usuario actual
+  set | passwd       Crea/cambia el usuario (--name, --password)
+  remove             Elimina el usuario (el server deja de pedir login)
+
+Opciones:
+  --home <path>      Casa de Tamnora (default: TAMNORA_HOME o datos del sistema)`);
+}

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

@@ -0,0 +1,2 @@
+// Re-export the harness core so the CLI has a single import point.
+export * from '../../../core/src/index.js';

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

@@ -0,0 +1,153 @@
+import { spawn, spawnSync } from 'node:child_process';
+import { readFileSync, writeFileSync, unlinkSync } from 'node:fs';
+import {
+  runtimePath,
+  pidPath,
+  bridgeLogPath,
+  serverLogPath,
+} from '../../../core/src/index.js';
+
+/** Mata un proceso y su arbol de hijos (taskkill en Windows; grupo en POSIX). */
+export function killPid(pid) {
+  if (!pid) return;
+  try {
+    if (process.platform === 'win32') {
+      spawn('taskkill', ['/PID', String(pid), '/T', '/F'], { windowsHide: true });
+    } else {
+      try {
+        process.kill(-pid, 'SIGTERM');
+      } catch {
+        /* sin grupo propio */
+      }
+      try {
+        process.kill(pid, 'SIGTERM');
+      } catch {
+        /* ya no esta */
+      }
+    }
+  } catch {
+    /* ya no esta */
+  }
+}
+
+export function pidAlive(pid) {
+  if (!pid) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function readRuntime() {
+  try {
+    return JSON.parse(readFileSync(runtimePath(), 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+export function writeRuntime(data) {
+  try {
+    writeFileSync(runtimePath(), `${JSON.stringify(data, null, 2)}\n`);
+  } catch {
+    /* sin runtime no detenemos nada */
+  }
+}
+
+export function clearRuntime() {
+  for (const file of [runtimePath(), pidPath()]) {
+    try {
+      unlinkSync(file);
+    } catch {
+      /* nada */
+    }
+  }
+}
+
+/** PIDs escuchando en un puerto TCP (netstat en Windows; lsof en el resto). */
+export function portOwnerPids(port) {
+  try {
+    const win = process.platform === 'win32';
+    const r = spawnSync(
+      win ? 'netstat' : 'lsof',
+      win ? ['-ano', '-p', 'tcp'] : ['-t', '-i', `tcp:${port}`, '-s', 'tcp:listen'],
+      { encoding: 'utf8', windowsHide: true, timeout: 15000 }
+    );
+    if (r.error || !r.stdout) return [];
+    if (!win) {
+      return String(r.stdout)
+        .split(/\s+/)
+        .map((n) => parseInt(n, 10))
+        .filter((p) => p > 0);
+    }
+    const re = new RegExp(`:${port}\\s`);
+    const pids = new Set();
+    for (const line of String(r.stdout).split(/\r?\n/)) {
+      if (!re.test(line) || !/LISTENING/i.test(line)) continue;
+      const parts = line.trim().split(/\s+/);
+      const pid = parseInt(parts[parts.length - 1], 10);
+      if (pid > 0) pids.add(pid);
+    }
+    return [...pids];
+  } catch {
+    return [];
+  }
+}
+
+export function describePid(pid) {
+  try {
+    if (process.platform === 'win32') {
+      const r = spawnSync('tasklist', ['/FI', `PID eq ${pid}`, '/FO', 'CSV', '/NH'], {
+        encoding: 'utf8',
+        windowsHide: true,
+        timeout: 8000,
+      });
+      const m = String(r.stdout || '').match(/^"([^"]+)"/m);
+      return m ? m[1] : '';
+    }
+    const r = spawnSync('ps', ['-p', String(pid), '-o', 'comm='], {
+      encoding: 'utf8',
+      windowsHide: true,
+      timeout: 8000,
+    });
+    return String(r.stdout || '').trim();
+  } catch {
+    return '';
+  }
+}
+
+export function portHint(port) {
+  const pids = portOwnerPids(port);
+  if (!pids.length) return '';
+  return pids.map((p) => `PID ${p}${describePid(p) ? ` (${describePid(p)})` : ''}`).join(', ');
+}
+
+/** Detiene el server en ejecucion (si lo hay). Devuelve true si habia uno. */
+export function stopRunningServer() {
+  const rt = readRuntime();
+  if (!rt || !pidAlive(rt.pid)) {
+    clearRuntime();
+    return false;
+  }
+  killPid(rt.pid);
+  if (Array.isArray(rt.children)) {
+    for (const c of rt.children) killPid(c);
+  }
+  clearRuntime();
+  return true;
+}
+
+export function tailLines(file, n) {
+  try {
+    const lines = readFileSync(file, 'utf8')
+      .split(/\r?\n/)
+      .filter((l) => l.trim() !== '');
+    return lines.slice(-n).join('\n');
+  } catch {
+    return '';
+  }
+}
+
+export { serverLogPath, bridgeLogPath };

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

@@ -0,0 +1,203 @@
+/**
+ * Generador de QR minimo (ISO/IEC 18004, Model 2) sin dependencias.
+ *
+ * Modo byte (UTF-8) con correccion de errores nivel L, versiones 1 a 5 (hasta
+ * 106 bytes: de sobra para una URL de tunel) y un solo bloque RS. La mascara es
+ * fija (0): cualquier mascara es valida y la info de formato la declara.
+ */
+
+const VERSIONS = {
+  1: { data: 19, ecc: 7, align: [] },
+  2: { data: 34, ecc: 10, align: [6, 18] },
+  3: { data: 55, ecc: 15, align: [6, 22] },
+  4: { data: 80, ecc: 20, align: [6, 26] },
+  5: { data: 108, ecc: 26, align: [6, 30] },
+};
+
+const MASK = 0;
+const ECC_FORMAT_BITS = 1; // nivel L -> 01
+
+function gfMul(x, y) {
+  let z = 0;
+  for (let i = 7; i >= 0; i--) {
+    z = (z << 1) ^ ((z >>> 7) * 0x11d);
+    z ^= ((y >>> i) & 1) * x;
+  }
+  return z & 0xff;
+}
+
+function rsDivisor(degree) {
+  const result = new Array(degree).fill(0);
+  result[degree - 1] = 1;
+  let root = 1;
+  for (let i = 0; i < degree; i++) {
+    for (let j = 0; j < result.length; j++) {
+      result[j] = gfMul(result[j], root);
+      if (j + 1 < result.length) result[j] ^= result[j + 1];
+    }
+    root = gfMul(root, 0x02);
+  }
+  return result;
+}
+
+function rsRemainder(data, divisor) {
+  const result = divisor.map(() => 0);
+  for (const b of data) {
+    const factor = b ^ result.shift();
+    result.push(0);
+    for (let i = 0; i < divisor.length; i++) result[i] ^= gfMul(divisor[i], factor);
+  }
+  return result;
+}
+
+function getBit(x, i) {
+  return ((x >>> i) & 1) !== 0;
+}
+
+function chooseVersion(byteLen) {
+  for (let v = 1; v <= 5; v++) {
+    if (byteLen <= VERSIONS[v].data - 2) return v;
+  }
+  return 0;
+}
+
+function dataCodewords(bytes, version) {
+  const cap = VERSIONS[version].data;
+  const bits = [];
+  const push = (val, len) => {
+    for (let i = len - 1; i >= 0; i--) bits.push((val >>> i) & 1);
+  };
+  push(0b0100, 4); // modo byte
+  push(bytes.length, 8); // conteo (v1-9: 8 bits)
+  for (const b of bytes) push(b, 8);
+  for (let i = 0; i < 4 && bits.length < cap * 8; i++) bits.push(0);
+  while (bits.length % 8 !== 0) bits.push(0);
+  const out = [];
+  for (let i = 0; i < bits.length; i += 8) {
+    let b = 0;
+    for (let j = 0; j < 8; j++) b = (b << 1) | bits[i + j];
+    out.push(b);
+  }
+  const pad = [0xec, 0x11];
+  let k = 0;
+  while (out.length < cap) out.push(pad[k++ % 2]);
+  return out;
+}
+
+function drawFormatBits(size, modules, isFn, mask) {
+  const data = (ECC_FORMAT_BITS << 3) | mask;
+  let rem = data;
+  for (let i = 0; i < 10; i++) rem = (rem << 1) ^ ((rem >>> 9) * 0x537);
+  const bits = ((data << 10) | rem) ^ 0x5412;
+  const put = (x, y, dark) => {
+    modules[y][x] = dark;
+    isFn[y][x] = true;
+  };
+
+  for (let i = 0; i <= 5; i++) put(8, i, getBit(bits, i));
+  put(8, 7, getBit(bits, 6));
+  put(8, 8, getBit(bits, 7));
+  put(7, 8, getBit(bits, 8));
+  for (let i = 9; i < 15; i++) put(14 - i, 8, getBit(bits, i));
+
+  for (let i = 0; i < 8; i++) put(size - 1 - i, 8, getBit(bits, i));
+  for (let i = 8; i < 15; i++) put(8, size - 15 + i, getBit(bits, i));
+  put(8, size - 8, true);
+}
+
+function buildMatrix(version, codewords) {
+  const size = version * 4 + 17;
+  const modules = Array.from({ length: size }, () => new Array(size).fill(false));
+  const isFn = Array.from({ length: size }, () => new Array(size).fill(false));
+  const set = (x, y, dark) => {
+    modules[y][x] = dark;
+    isFn[y][x] = true;
+  };
+
+  for (let i = 0; i < size; i++) {
+    set(6, i, i % 2 === 0);
+    set(i, 6, i % 2 === 0);
+  }
+
+  const drawFinder = (cx, cy) => {
+    for (let dy = -4; dy <= 4; dy++) {
+      for (let dx = -4; dx <= 4; dx++) {
+        const x = cx + dx;
+        const y = cy + dy;
+        if (x < 0 || x >= size || y < 0 || y >= size) continue;
+        const dist = Math.max(Math.abs(dx), Math.abs(dy));
+        set(x, y, dist !== 2 && dist !== 4);
+      }
+    }
+  };
+  drawFinder(3, 3);
+  drawFinder(size - 4, 3);
+  drawFinder(3, size - 4);
+
+  const pos = VERSIONS[version].align;
+  for (const cy of pos) {
+    for (const cx of pos) {
+      if ((cx === 6 && cy === 6) || (cx === 6 && cy === size - 7) || (cx === size - 7 && cy === 6)) continue;
+      for (let dy = -2; dy <= 2; dy++) {
+        for (let dx = -2; dx <= 2; dx++) {
+          set(cx + dx, cy + dy, Math.max(Math.abs(dx), Math.abs(dy)) !== 1);
+        }
+      }
+    }
+  }
+
+  drawFormatBits(size, modules, isFn, 0);
+
+  let i = 0;
+  for (let right = size - 1; right >= 1; right -= 2) {
+    if (right === 6) right = 5;
+    for (let vert = 0; vert < size; vert++) {
+      for (let j = 0; j < 2; j++) {
+        const x = right - j;
+        const upward = ((right + 1) & 2) === 0;
+        const y = upward ? size - 1 - vert : vert;
+        if (isFn[y][x] || i >= codewords.length * 8) continue;
+        modules[y][x] = getBit(codewords[i >>> 3], 7 - (i & 7));
+        i++;
+      }
+    }
+  }
+
+  for (let y = 0; y < size; y++) {
+    for (let x = 0; x < size; x++) {
+      if (!isFn[y][x] && (x + y) % 2 === 0) modules[y][x] = !modules[y][x];
+    }
+  }
+
+  drawFormatBits(size, modules, isFn, MASK);
+  return { size, modules };
+}
+
+function qrMatrix(text) {
+  const bytes = Buffer.from(String(text), 'utf8');
+  const version = chooseVersion(bytes.length);
+  if (!version) return null;
+  const data = dataCodewords(bytes, version);
+  const ecc = rsRemainder(data, rsDivisor(VERSIONS[version].ecc));
+  return buildMatrix(version, data.concat(ecc));
+}
+
+/** QR para terminal con medios bloques. Devuelve '' si el texto no entra. */
+export function qrTerminal(text, quiet) {
+  const qr = qrMatrix(text);
+  if (!qr) return '';
+  const q = quiet === undefined ? 2 : quiet;
+  const size = qr.size;
+  const at = (x, y) => x >= 0 && x < size && y >= 0 && y < size && qr.modules[y][x];
+  const lines = [];
+  for (let y = -q; y < size + q; y += 2) {
+    let line = '';
+    for (let x = -q; x < size + q; x++) {
+      const top = at(x, y);
+      const bot = at(x, y + 1);
+      line += top && bot ? '\u2588' : top ? '\u2580' : bot ? '\u2584' : ' ';
+    }
+    lines.push(line);
+  }
+  return lines.join('\n');
+}