@danieltmn/tamnora 0.7.1 → 0.8.0

package/CHANGELOG.md

@@ -5,6 +5,18 @@ Todos los cambios relevantes de este proyecto se documentan en este archivo.
 El formato sigue [Keep a Changelog](https://keepachangelog.com/es-ES/1.1.0/)
 y el proyecto usa [Versionado Semantico](https://semver.org/lang/es/).
 
+## [0.8.0] - 2026-10-06
+
+### Documentacion
+
+- **Revision de docs y sitio**: se audito cada afirmacion contra el codigo y se
+  corrigieron varias inexactas (las API keys **no** se cifran —van en texto plano
+  en SQLite—; `--max-steps` no tiene default `8`; "nada se sube a terceros" es
+  falso si se elige un proveedor remoto). Se sumaron al sitio y a la guia las
+  features de 0.7.1 (tablas markdown, saltos de scroll, agente autonomo y MCP
+  con entorno confinado/redaccion). Actualiza `README.md`, `document.md`,
+  `AGENTS.md`, `SECURITY.md`, `website/` y la landing.
+
 ## [0.7.1] - 2026-10-06
 
 ### Agregado

package/README.md

@@ -84,6 +84,10 @@ menu "mas" (los tres puntitos). En el chat:
 - **Actividad colapsable**: las tools de lectura (`read`, `list`, `glob`, `grep`,
   `fetch_url`, `git_*`) salen **plegadas** y al hacer click se ve el detalle
   (args + resultado); el volcado completo se pide bajo demanda.
+- **Markdown con tablas**: las respuestas renderizan tablas (`|`, con alineacion
+  y celdas saneadas) y botones flotantes para saltar al inicio/final del turno.
+- **Acciones por mensaje**: copiar, editar, regenerar y borrar se agrupan en un
+  menu `⋮`; el indicador de "pensando/trabajando" vive en el pie (`#sb-activity`).
 - **Runs durables**: cerrar el celular o cortar la red **no cancela** el turno; al
   volver, la consola **reconecta** y reconstruye el progreso. Para cortarlo se usa
   el boton de detener (o `POST /api/sessions/:id/stop`).
@@ -149,6 +153,11 @@ stdio. Las tools se exponen como `mcp__<servidor>__<tool>` y, si el servidor los
 anuncia, tambien sus **recursos** y **prompts** (`list_resources`,
 `read_resource`, `list_prompts`, `get_prompt`).
 
+Los MCP stdio **no heredan `process.env`**: reciben un baseline minimo mas el
+`env` declarado (`"KEY": "env:VAR"`), y sus resultados pasan por `redactSecrets`
+(ver [`SECURITY.md`](SECURITY.md)). Para un servidor de confianza que necesite el
+entorno completo, `"inheritEnv": true`.
+
 ## Tools
 
 Tools locales confinadas al workspace (`read`, `list`, `glob`, `grep`, `write`,

package/SECURITY.md

@@ -15,12 +15,17 @@ asi que se lo debe tratar como codigo con acceso a tu usuario.
 - **Local (loopback)**: quien ya tiene tu sesion de usuario ya puede correr
   comandos; el server no agrega una barrera adicional mas alla del login.
 - **Acceso remoto por tunel (tunnelmole)**: la URL publica es accesible desde
-  Internet. Es obligatorio (a) una passphrase fuerte, (b) login real en toda la
-  API, (c) limite de intentos y (d) restringir el picker de carpetas a roots
-  permitidos. Nunca expongas un server sin passphrase.
-- **Credenciales**: las API keys de proveedores se guardan en la casa local del
-  usuario (fuera del repo) y se cifran con una clave derivada de la passphrase.
-  Nunca se commitean y se devuelven enmascaradas al cliente.
+  Internet. Configura un **usuario** (asi toda `/api/*` pide sesion) con una
+  **contrasena fuerte**; nunca expongas un server sin login. El tunnel reenvia
+  por loopback, de modo que una vez autenticado se alcanza toda la consola
+  (incluidos el explorador de archivos y el selector de carpetas): tratalo como
+  acceso completo a tu maquina. Cierra el tunnel (`tamnora bridge --stop`) cuando
+  no lo uses.
+- **Credenciales**: las API keys de proveedores se guardan en la base SQLite de
+  la casa local (fuera del repo) **en texto plano**; protege el archivo con los
+  permisos del sistema. Para no persistirlas, usa `"apiKey": "env:VAR"` y
+  define la variable en el entorno. Nunca se commitean y se devuelven
+  enmascaradas al cliente (`apiKeyHint`).
 - **Servidores MCP**: tratalos como codigo de terceros. Los MCP stdio **no heredan
   `process.env`** por defecto: solo reciben un baseline minimo mas el `env` que
   declares (`"env": { "TOKEN": "env:TOKEN" }`); `inheritEnv: true` es solo para

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

@@ -160,7 +160,7 @@ Opciones:
   --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)
+  --max-steps <n>    Techo de rondas de herramientas (0 = sin límite, default)
   --tools <lista>    Tools habilitadas (coma), ej. read,list,grep
   --no-tools         Deshabilitar todas las tools
   -y, --yes          Aprobar automáticamente los permisos "ask"

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

@@ -113,7 +113,7 @@ Opciones:
   --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
+  --max-steps <n>   Techo de rondas de herramientas (0 = sin límite, default)
   --tools <lista>   Tools habilitadas (coma)   --no-tools
   -y, --yes         Auto-aprobar tools con permiso "ask"`);
 }

package/harness/packages/core/src/agent/runAgent.js

@@ -150,6 +150,9 @@ export async function runAgent({
     }
 
     const tokens = accumulateUsage(result.usage ?? null);
+    // Uso de la ronda para el medidor de contexto en vivo (last_prompt_tokens
+    // es el tamano real de contexto de esta ronda).
+    if (result.usage) onEvent?.({ type: 'usage', usage: { ...usageTotal } });
 
     const calls = result.toolCalls ?? [];
     if (calls.length === 0) {

package/harness/packages/core/src/git/index.js

@@ -0,0 +1,177 @@
+import { spawn } from 'node:child_process';
+import fs from 'node:fs';
+import fsp from 'node:fs/promises';
+import path from 'node:path';
+
+const GIT_TIMEOUT_MS = 8000;
+const MAX_DIFF_CHARS = 200_000;
+const MAX_STDERR_CHARS = 20_000;
+
+/** Run `git <args>` in `root`. Never rejects; resolves `{ code, stdout, stderr }`. */
+function runGit(root, args, { timeout = GIT_TIMEOUT_MS } = {}) {
+  return new Promise((resolve) => {
+    let child;
+    try {
+      child = spawn('git', args, { cwd: root, windowsHide: true });
+    } catch (error) {
+      resolve({ code: -1, stdout: '', stderr: `Error ejecutando git: ${error.message}` });
+      return;
+    }
+    let stdout = '';
+    let stderr = '';
+    let settled = false;
+    const finish = (result) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      resolve(result);
+    };
+    const timer = setTimeout(() => {
+      try {
+        child.kill();
+      } catch {
+        // already gone
+      }
+      finish({ code: -1, stdout, stderr: stderr || 'git: tiempo de espera agotado' });
+    }, timeout);
+    child.stdout?.on('data', (chunk) => {
+      if (stdout.length < MAX_DIFF_CHARS) stdout += chunk.toString();
+    });
+    child.stderr?.on('data', (chunk) => {
+      if (stderr.length < MAX_STDERR_CHARS) stderr += chunk.toString();
+    });
+    child.on('error', (error) => {
+      finish({ code: -1, stdout, stderr: `Error ejecutando git: ${error.message}` });
+    });
+    child.on('close', (code) => finish({ code: code ?? -1, stdout, stderr }));
+  });
+}
+
+/** Fast synchronous check for a `.git` entry in the workspace root. */
+export function isGitRepo(root) {
+  return Boolean(root) && fs.existsSync(path.join(root, '.git'));
+}
+
+function parseBranch(text) {
+  let value = String(text ?? '').trim();
+  let ahead = 0;
+  let behind = 0;
+  const flags = value.match(/\[(.+?)\]\s*$/);
+  if (flags) {
+    const a = flags[1].match(/ahead (\d+)/);
+    const b = flags[1].match(/behind (\d+)/);
+    if (a) ahead = Number(a[1]);
+    if (b) behind = Number(b[1]);
+    value = value.slice(0, flags.index).trim();
+  }
+  const dots = value.indexOf('...');
+  if (dots !== -1) value = value.slice(0, dots);
+  value = value.replace(/^No commits yet on /, '').trim();
+  return { branch: value || '(sin rama)', ahead, behind };
+}
+
+function classify(index, worktree) {
+  const pair = `${index}${worktree}`;
+  if (pair === '??') return 'untracked';
+  if (pair === '!!') return 'ignored';
+  if (index === 'U' || worktree === 'U' || pair === 'AA' || pair === 'DD') return 'conflicted';
+  if (index === 'R' || worktree === 'R') return 'renamed';
+  if (index === 'A' || worktree === 'A') return 'added';
+  if (index === 'D' || worktree === 'D') return 'deleted';
+  if (index === 'M' || worktree === 'M') return 'modified';
+  return 'modified';
+}
+
+/** Parse `git status --porcelain=v1 -z --branch` output. */
+function parseStatus(raw) {
+  const tokens = String(raw ?? '').split('\0').filter((token) => token.length > 0);
+  let branch = null;
+  let ahead = 0;
+  let behind = 0;
+  const entries = [];
+  for (let i = 0; i < tokens.length; i++) {
+    const token = tokens[i];
+    if (token.startsWith('## ')) {
+      ({ branch, ahead, behind } = parseBranch(token.slice(3)));
+      continue;
+    }
+    const index = token[0] ?? ' ';
+    const worktree = token[1] ?? ' ';
+    let origPath = null;
+    if (index === 'R' || worktree === 'R') {
+      origPath = tokens[i + 1] ?? null;
+      i++;
+    }
+    entries.push({
+      path: token.slice(3),
+      origPath,
+      index,
+      worktree,
+      status: classify(index, worktree),
+    });
+  }
+  return { isRepo: true, branch, ahead, behind, entries };
+}
+
+/**
+ * Working-tree status as structured data.
+ * @returns {Promise<{isRepo:boolean,branch:string|null,ahead:number,behind:number,entries:Array}>}
+ */
+export async function gitStatus(root) {
+  const result = await runGit(root, ['status', '--porcelain=v1', '-z', '--branch']);
+  if (result.code !== 0) {
+    return { isRepo: false, branch: null, ahead: 0, behind: 0, entries: [] };
+  }
+  return parseStatus(result.stdout);
+}
+
+/** Build a `new file` unified diff for an untracked path (no `--no-index` needed). */
+async function untrackedDiff(root, target) {
+  let stat;
+  try {
+    stat = await fsp.stat(path.resolve(root, target));
+  } catch {
+    return `# ${target}: no se pudo leer el archivo.\n`;
+  }
+  if (stat.isDirectory()) return `# ${target}: carpeta sin seguimiento (sin diff)\n`;
+  if (stat.size > MAX_DIFF_CHARS) return `# ${target}: archivo demasiado grande para mostrar el diff.\n`;
+  let buffer;
+  try {
+    buffer = await fsp.readFile(path.resolve(root, target));
+  } catch (error) {
+    return `# ${target}: ${error.message}\n`;
+  }
+  if (buffer.includes(0)) return `# ${target}: archivo binario (sin diff).\n`;
+  const lines = buffer.toString('utf8').replace(/\r\n/g, '\n').split('\n');
+  if (lines[lines.length - 1] === '') lines.pop();
+  const header =
+    `diff --git a/${target} b/${target}\n` +
+    `new file mode 100644\n--- /dev/null\n+++ b/${target}\n` +
+    `@@ -0,0 +1,${lines.length} @@\n`;
+  return header + lines.map((line) => `+${line}`).join('\n') + '\n';
+}
+
+/**
+ * Unified diff for a single path (or the whole tree if `path` is empty).
+ * @returns {Promise<{ok:boolean,diff:string,staged:boolean,untracked:boolean,error?:string}>}
+ */
+export async function gitDiff(root, { path: filePath, staged = false } = {}) {
+  const target = String(filePath ?? '').trim();
+  const args = ['diff', '--no-color'];
+  if (staged) args.push('--staged');
+  if (target) {
+    const status = await gitStatus(root);
+    if (!status.isRepo) return { ok: false, error: 'No es un repositorio git.' };
+    const entry = status.entries.find((e) => e.path === target || e.origPath === target);
+    if (entry?.status === 'untracked') {
+      const diff = (await untrackedDiff(root, target)).slice(0, MAX_DIFF_CHARS);
+      return { ok: true, diff, staged: false, untracked: true };
+    }
+  }
+  if (target) args.push('--', target);
+  const result = await runGit(root, args);
+  if (result.code !== 0 && !result.stdout) {
+    return { ok: false, error: result.stderr.trim() || 'git diff falló.' };
+  }
+  return { ok: true, diff: result.stdout.slice(0, MAX_DIFF_CHARS), staged, untracked: false };
+}

package/harness/packages/core/src/index.js

@@ -13,6 +13,7 @@ export { ensureUtf8Console } from './console.js';
 export { MAX_TOOL_ROUNDS, runAgent, parseToolArguments } from './agent/runAgent.js';
 export { estimateTokens, trimContext } from './agent/context.js';
 export { diffLines } from './tools/diff.js';
+export { isGitRepo, gitStatus, gitDiff } from './git/index.js';
 export { summarizeToolCall, previewToolResult } from './tools/labels.js';
 export { MODES, MODE_IDS, resolveMode } from './agent/modes.js';
 export { withRetry, isRetryableError, isAbortError } from './providers/resilience.js';
@@ -94,4 +95,5 @@ export {
 } from './mcp/registry.js';
 export { parseTunnelmoleUrls, startTunnelmole, startTunnel } from './tunnel.js';
 export { detectProcs, packageManager, DEFAULT_PROCESS_ALLOW, staticServerChip } from './procs/detect.js';
+export { killPort } from './procs/kill.js';
 export { readPackageVersion } from './version.js';

package/harness/packages/core/src/procs/kill.js

@@ -0,0 +1,95 @@
+import { spawn } from 'node:child_process';
+
+const RUN_TIMEOUT_MS = 8000;
+
+/** Run a command, resolving `{ code, stdout }` (never rejects). */
+function run(command, args, { timeout = RUN_TIMEOUT_MS } = {}) {
+  return new Promise((resolve) => {
+    let child;
+    try {
+      child = spawn(command, args, { windowsHide: true });
+    } catch {
+      resolve({ code: -1, stdout: '' });
+      return;
+    }
+    let stdout = '';
+    let settled = false;
+    const finish = (result) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      resolve(result);
+    };
+    const timer = setTimeout(() => {
+      try {
+        child.kill();
+      } catch {
+        // already gone
+      }
+      finish({ code: -1, stdout });
+    }, timeout);
+    child.stdout?.on('data', (chunk) => {
+      if (stdout.length < 20000) stdout += chunk.toString();
+    });
+    child.on('error', () => finish({ code: -1, stdout }));
+    child.on('close', (code) => finish({ code: code ?? -1, stdout }));
+  });
+}
+
+function uniquePids(values) {
+  return [...new Set(values.map(Number).filter((pid) => Number.isInteger(pid) && pid > 0))];
+}
+
+/** Find PIDs listening on a TCP/UDP port (Windows `netstat`). */
+async function pidsOnWindows(port) {
+  const { stdout } = await run('netstat', ['-ano']);
+  const pids = [];
+  for (const line of stdout.split(/\r?\n/)) {
+    const fields = line.trim().split(/\s+/);
+    if (fields.length < 4) continue;
+    if (fields[0].toUpperCase() !== 'TCP' && fields[0].toUpperCase() !== 'UDP') continue;
+    if (!fields[1].endsWith(`:${port}`)) continue;
+    pids.push(fields[fields.length - 1]);
+  }
+  return uniquePids(pids);
+}
+
+/** Find PIDs listening on a port (Unix: lsof, fuser or ss). */
+async function pidsOnUnix(port) {
+  const lsof = await run('lsof', ['-ti', `tcp:${port}`]);
+  if (lsof.code === 0 && lsof.stdout.trim()) {
+    return uniquePids(lsof.stdout.split(/\s+/));
+  }
+  const fuser = await run('fuser', [`${port}/tcp`]);
+  if (fuser.code === 0 && fuser.stdout.trim()) {
+    return uniquePids(fuser.stdout.match(/\d+/g) ?? []);
+  }
+  const ss = await run('ss', ['-ltnp', `sport = :${port}`]);
+  if (ss.code === 0 && ss.stdout.trim()) {
+    return uniquePids([...ss.stdout.matchAll(/pid=(\d+)/g)].map((match) => match[1]));
+  }
+  return [];
+}
+
+/**
+ * Kill every process listening on `port`.
+ * @returns {Promise<{port:number,pids:number[],killed:number[],errors:string[]}>}
+ */
+export async function killPort(port) {
+  const value = Number(port);
+  if (!Number.isInteger(value) || value < 1 || value > 65535) {
+    throw new Error('Puerto inválido (usá 1-65535).');
+  }
+  const pids = process.platform === 'win32' ? await pidsOnWindows(value) : await pidsOnUnix(value);
+  const killed = [];
+  const errors = [];
+  for (const pid of pids) {
+    const result =
+      process.platform === 'win32'
+        ? await run('taskkill', ['/PID', String(pid), '/T', '/F'])
+        : await run('kill', ['-9', String(pid)]);
+    if (result.code === 0) killed.push(pid);
+    else errors.push(String(pid));
+  }
+  return { port: value, pids, killed, errors };
+}

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

@@ -1,9 +1,59 @@
 import { test } from 'node:test';
 import assert from 'node:assert/strict';
+import { spawn } from 'node:child_process';
+import net from 'node:net';
 import { mkdtemp, mkdir, writeFile } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import path from 'node:path';
 import { detectProcs, packageManager, DEFAULT_PROCESS_ALLOW } from '../src/procs/detect.js';
+import { killPort } from '../src/procs/kill.js';
+
+async function waitForPort(port, attempts = 50) {
+  for (let i = 0; i < attempts; i++) {
+    const ok = await new Promise((resolve) => {
+      const socket = net.connect({ port, host: '127.0.0.1' });
+      socket.once('connect', () => {
+        socket.destroy();
+        resolve(true);
+      });
+      socket.once('error', () => resolve(false));
+    });
+    if (ok) return;
+    await new Promise((resolve) => setTimeout(resolve, 100));
+  }
+  throw new Error('el puerto no abrió');
+}
+
+test('killPort rejects invalid ports', async () => {
+  await assert.rejects(() => killPort(0), /Puerto inválido/);
+  await assert.rejects(() => killPort(70000), /Puerto inválido/);
+  await assert.rejects(() => killPort('abc'), /Puerto inválido/);
+});
+
+test('killPort terminates the process listening on a port', async (t) => {
+  const port = 47000 + Math.floor(Math.random() * 1000);
+  const script = `const http=require('node:http');http.createServer((q,r)=>r.end('ok')).listen(${port},'127.0.0.1');setInterval(()=>{},1000);`;
+  const child = spawn(process.execPath, ['-e', script], { stdio: 'ignore', windowsHide: true });
+  t.after(() => {
+    try {
+      child.kill('SIGKILL');
+    } catch {
+      // already gone
+    }
+  });
+  await waitForPort(port);
+
+  const result = await killPort(port);
+  assert.ok(result.pids.length >= 1, 'debería encontrar el PID');
+  assert.ok(result.killed.length >= 1, 'debería matar el proceso');
+
+  await new Promise((resolve) => {
+    if (child.exitCode !== null || child.signalCode) return resolve();
+    child.once('exit', resolve);
+    setTimeout(resolve, 3000);
+  });
+  assert.ok(child.exitCode !== null || child.signalCode, 'el hijo debería haber terminado');
+});
 
 test('detectProcs finds node dev scripts with the right package manager', async () => {
   const dir = await mkdtemp(path.join(tmpdir(), 'tamnora-proc-'));