@danieltmn/tamnora 0.9.4 → 0.9.5

package/CHANGELOG.md

@@ -5,6 +5,30 @@ 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.9.5] - 2026-10-08
+
+### Agregado
+
+- **Actualizacion desde la consola**: `GET /api/update` consulta el registro npm
+  y un banner ofrece **actualizar con un click**; `POST /api/update` (solo
+  loopback) apaga el server, instala la version nueva con un script detached y lo
+  vuelve a levantar. Un click en la version del topbar fuerza el chequeo.
+  `tamnora update` detiene el server antes de instalar (Windows bloquea los
+  archivos), detecta drift entre instalaciones y lo reinicia; `tamnora doctor`
+  avisa si hay una version nueva.
+- **Asesor**: una capa de comentario sobre el run activo que interpreta lo que
+  hizo el agente y, si aporta algo, alerta un problema real de codigo, explica un
+  proceso o da un consejo. No lee la respuesta del agente. Tarjeta en el chat,
+  evento `advice` y voz opcional. Ajustes en la pestana **Asesor** (`app.json` ->
+  `advisor`).
+- **Voz: leer la respuesta final**: `tts.announce.answer` lee la respuesta del
+  agente limpiando bloques de codigo, tablas y marcas de markdown.
+
+### Corregido
+
+- El asesor y la respuesta final ya no se descartan de la cola de audio cuando
+  quedan detras de una narracion larga (`maxAgeMs: 0`).
+
 ## [0.9.4] - 2026-10-07
 
 ### Cambios

package/README.md

@@ -10,8 +10,14 @@ con TUI, consola web, tools locales, MCP y evaluacion de modelos.
   Cerebras, Perplexity) y Ollama.
 - **Navegador headless**: tools `screenshot` y `console_errors` (renderiza JS y
   saca una captura PNG o lista los errores de consola) y `preview_url`.
-- **Voz**: el agente narra su progreso y puede mandar audio bajo pedido
-  (`speak`, `/audioresumen`).
+- **Voz**: el agente narra su progreso, puede **leer la respuesta final** (sin
+  bloques de codigo ni tablas) y mandar audio bajo pedido (`speak`,
+  `/audioresumen`).
+- **Asesor**: una capa de comentario sobre el run que interpreta lo que hizo el
+  agente y, si aporta algo, avisa de un problema en el codigo, explica un proceso
+  o da un consejo (con tarjeta en el chat y voz opcional). No lee la respuesta.
+- **Actualizar desde la consola**: la consola avisa cuando hay una version nueva
+  y la instala con un click (el server se reinicia solo).
 
 ## Instalacion
 
@@ -56,8 +62,8 @@ tamnora server --reload       # reinicia aplicando config/codigo
 tamnora server --stop
 tamnora server --status
 tamnora server --logs --follow
-tamnora doctor                # verifica Node, casa, puerto y base
-tamnora update                # busca/instala una version nueva
+tamnora doctor                # verifica Node, casa, puerto, base y version nueva
+tamnora update                # busca/instala una version nueva (reinicia el server)
 tamnora autostart install     # arranque automatico del server
 ```
 
@@ -69,10 +75,14 @@ Tamnora (override con `--home` o `TAMNORA_HOME`):
 - macOS: `~/Library/Application Support/tamnora`
 - Linux: `~/.config/tamnora`
 
-> **Actualizar**: en `0.4.1+` alcanza con `tamnora update` (o `--yes`). Si venis de
-> **`0.4.0` o anterior**, `tamnora update` fallaba en Windows, asi que hace una vez
-> `npm i -g @danieltmn/tamnora@latest` (agrega `--prefer-online` si el cache de npm
-> devuelve la version vieja) o corre con `npx @danieltmn/tamnora@latest`.
+> **Actualizar**: en `0.9.5+` la consola avisa cuando hay una version nueva y la
+> instala con un click (el server se reinicia solo); un click en la version del
+> topbar fuerza el chequeo. Por CLI, `tamnora update --yes` ahora **detiene el
+> server antes de instalar** (en Windows libera los archivos) y lo reinicia. Si
+> venis de **`0.8.0` o anterior** y "dice que actualizo pero sigue igual", hace una
+> vez: `tamnora server --stop`, `npm i -g @danieltmn/tamnora@latest` y
+> `tamnora server --start`. Verifica que `where tamnora` coincida con
+> `npm root -g` (si no, hay dos instalaciones y el update toca la otra).
 
 ### Consola web
 
@@ -97,8 +107,13 @@ menu "mas" (los tres puntitos). En el chat:
 - **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`).
-- **Audio**: un unico reproductor encola la narracion, el tool `speak` y
-  `/audioresumen`, y reproduce de a uno con pausa y detener.
+- **Audio**: un unico reproductor encola la narracion, el tool `speak`, la
+  respuesta final y los consejos del asesor, y reproduce de a uno con pausa y
+  detener (Ajustes -> Voz).
+- **Asesor**: en Ajustes -> Asesor se activa una capa que comenta el turno
+  (problemas de codigo / explicaciones / consejos) con proveedor y modelo activos.
+- **Actualizar**: cuando npm tiene una version nueva aparece un banner para
+  actualizar con un click; el server se reinicia solo.
 - **Comandos**: el input muestra un menu al escribir `/` (`/new`, `/init`, `/goal`,
   `/resumen`, `/audioresumen`, `/compact`, `/clear`, `/cwd`, `/kill`, `/help`).
 - **Capturas**: el tool `screenshot` muestra la imagen inline en su tarjeta.

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

@@ -7,6 +7,9 @@ import {
   databasePath,
   serverLogPath,
   Store,
+  readPackageVersion,
+  compareVersions,
+  fetchLatestVersion,
 } from '../../../core/src/index.js';
 import { parse } from '../lib/util.js';
 import { pidAlive, readRuntime } from '../lib/daemon.js';
@@ -52,6 +55,17 @@ export async function doctorCommand(argv) {
   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)']);
 
+  const current = readPackageVersion();
+  let versionHint = '';
+  try {
+    const latest = await fetchLatestVersion();
+    versionHint =
+      compareVersions(latest, current) > 0 ? `hay v${latest}: corre tamnora update --yes` : 'al dia';
+  } catch (error) {
+    versionHint = `no pude verificar (${error?.message ?? error})`;
+  }
+  checks.push([`version (v${current})`, true, versionHint]);
+
   if (serverLive) checks.push([`server (pid ${rt.pid})`, true, rt.url || '']);
   checks.push([`logs`, true, serverLogPath()]);
 

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

@@ -1,16 +1,26 @@
 import { spawnSync } from 'node:child_process';
-import { readPackageVersion } from '../lib/core.js';
+import path from 'node:path';
+import { fetchLatestVersion, compareVersions, packageRoot, readPackageVersion, readApp } from '../lib/core.js';
 import { parse } from '../lib/util.js';
+import { readRuntime, pidAlive, stopRunningServer, spawnDetached, portHint } from '../lib/daemon.js';
 
 const PACKAGE = '@danieltmn/tamnora';
 const IS_WIN = process.platform === 'win32';
 const NPM = IS_WIN ? 'npm.cmd' : 'npm';
-const OPTIONS = { yes: { type: 'boolean', short: 'y' }, check: { type: 'boolean' }, tag: { type: 'string' }, help: { type: 'boolean', short: 'h' } };
+const OPTIONS = {
+  yes: { type: 'boolean', short: 'y' },
+  check: { type: 'boolean' },
+  restart: { type: 'boolean' },
+  'no-restart': { type: 'boolean' },
+  tag: { type: 'string' },
+  help: { type: 'boolean', short: 'h' },
+};
 
 function npm(args) {
-  return spawnSync(NPM, args, { encoding: 'utf8', windowsHide: true, shell: IS_WIN });
+  return spawnSync(NPM, args, { encoding: 'utf8', windowsHide: true, shell: IS_WIN, timeout: 180000 });
 }
 
+/** Version del paquete instalado globalmente (la que resuelve `npm ls -g`). */
 function installedVersion() {
   const out = npm(['ls', '-g', PACKAGE, '--json', '--depth=0']);
   try {
@@ -21,10 +31,49 @@ function installedVersion() {
   }
 }
 
+function globalRoot() {
+  const out = npm(['root', '-g']);
+  return out.status === 0 ? String(out.stdout || '').trim() : '';
+}
+
+const norm = (p) => path.resolve(String(p || '')).toLowerCase();
+
+/**
+ * Detiene el server gestionado (runtime.json) para que Windows libere los
+ * archivos bloqueados; sin esto `npm i -g` falla o queda a medias.
+ */
+async function stopServerIfRunning() {
+  const rt = readRuntime();
+  if (!rt || !pidAlive(rt.pid)) return null;
+  console.log(`Deteniendo el server (pid ${rt.pid}) para poder reemplazar los archivos...`);
+  stopRunningServer();
+  for (let i = 0; i < 25 && pidAlive(rt.pid); i++) await new Promise((r) => setTimeout(r, 200));
+  return rt;
+}
+
+function restartServer(rt) {
+  try {
+    const bin = process.argv[1];
+    const args = [bin, 'server', '--stream', '--no-open'];
+    if (rt?.port) args.push('--port', String(rt.port));
+    if (rt?.host) args.push('--host', rt.host);
+    if (rt?.cwd) args.push('--dir', rt.cwd);
+    const { child } = spawnDetached(args, { envFlag: 'TAMNORA_DETACHED' });
+    console.log(`Server reiniciado en segundo plano (pid ${child.pid}).`);
+  } catch (error) {
+    console.error(`No pude reiniciar el server solo: ${error?.message ?? error}`);
+    console.error('Reinicialo a mano: tamnora server --start');
+  }
+}
+
 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.');
+    console.log(
+      'Uso: tamnora update [--check] [--yes] [--no-restart]\n\n' +
+        'Busca una version nueva en npm y actualiza la instalacion global.\n' +
+        'Detiene el server antes de instalar (en Windows libera los archivos) y lo reinicia al terminar.'
+    );
     return 0;
   }
 
@@ -33,24 +82,20 @@ export async function updateCommand(argv) {
   const version = readPackageVersion();
   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'}`);
+    latest = await fetchLatestVersion({ pkg: PACKAGE, tag });
+  } catch (error) {
+    console.error(`No se pudo consultar npm (${tag}): ${error?.message ?? error}`);
     return 1;
   }
   console.log(`Disponible (${tag}): ${latest}`);
-  if (latest === version) {
+  if (compareVersions(latest, version) <= 0) {
     console.log('Ya estas en la ultima version.');
     return 0;
   }
   if (values.check) {
-    console.log(`Hay una version nueva. Corre: tamnora update --yes`);
+    console.log('Hay una version nueva. Corre: tamnora update --yes');
     return 0;
   }
   if (!values.yes) {
@@ -60,21 +105,46 @@ export async function updateCommand(argv) {
     return 0;
   }
 
+  const wasRunning = await stopServerIfRunning();
+  if (!wasRunning) {
+    // Un server no gestionado (ej. `pnpm serve` en primer plano) tambien
+    // bloquea los archivos. Avisamos en vez de matar un proceso ajeno.
+    const app = readApp();
+    const hint = app?.port ? portHint(app.port) : '';
+    if (hint) console.warn(`aviso: algo escucha en el puerto ${app.port} (${hint}); cerralo si la instalacion falla.`);
+  }
+
   console.log(`Actualizando a ${spec}...`);
-  const result = spawnSync(NPM, ['i', '-g', spec], {
-    stdio: 'inherit',
-    windowsHide: true,
-    shell: IS_WIN,
-  });
+  const result = spawnSync(NPM, ['i', '-g', spec], { stdio: 'inherit', windowsHide: true, shell: IS_WIN });
   if (result.status !== 0) {
     console.error(`La actualizacion fallo. Proba a mano: npm i -g ${spec}`);
+    if (wasRunning) restartServer(wasRunning);
     return 1;
   }
+
   const installed = installedVersion() || readPackageVersion();
   console.log(`Listo. Instalado: v${installed} (pediste ${latest}).`);
-  if (installed && installed !== latest) {
-    console.log('Ojo: la version instalada no coincide con la publicada. Cerra procesos que usen la carpeta y reintenta.');
+
+  // Drift: npm instala en un prefix distinto al de la copia que esta corriendo.
+  const runningRoot = packageRoot();
+  const expectedRoot = globalRoot();
+  const expectedPkg = expectedRoot ? path.join(expectedRoot, ...PACKAGE.split('/')) : '';
+  if (runningRoot && expectedPkg && norm(runningRoot) !== norm(expectedPkg)) {
+    console.warn('Ojo: la copia global quedo en un lugar distinto al de esta instalacion.');
+    console.warn(`  instalada: ${expectedPkg}`);
+    console.warn(`  en uso:    ${runningRoot}`);
+    console.warn('  puede que el update no afecte la copia que corre; revisa cual resuelve "tamnora".');
+  }
+  if (installed && compareVersions(installed, latest) < 0) {
+    console.warn('Ojo: la version instalada no coincide con la publicada. Cerra procesos que usen la carpeta y reintenta.');
+  }
+
+  if (values['no-restart']) {
+    console.log('Reinicia el server cuando quieras: tamnora server --reload');
+  } else if (wasRunning || values.restart) {
+    restartServer(wasRunning || { port: readApp().port });
+  } else {
+    console.log('Reinicia el server: tamnora server --reload');
   }
-  console.log('Reinicia el server: tamnora server --reload');
   return 0;
 }

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

@@ -111,4 +111,10 @@ export { pidAlive, killPidTree } from './pid.js';
 export { openBrowser, openerFor } from './open.js';
 export { detectProcs, packageManager, DEFAULT_PROCESS_ALLOW, staticServerChip } from './procs/detect.js';
 export { killPort } from './procs/kill.js';
-export { readPackageVersion } from './version.js';
+export {
+  ROOT_PACKAGE_NAME,
+  readPackageVersion,
+  packageRoot,
+  compareVersions,
+  fetchLatestVersion,
+} from './version.js';

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

@@ -2,19 +2,20 @@ import { readFileSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
 import path from 'node:path';
 
-const ROOT_PACKAGE_NAME = '@danieltmn/tamnora';
+export const ROOT_PACKAGE_NAME = '@danieltmn/tamnora';
+
+const DEFAULT_REGISTRY = 'https://registry.npmjs.org';
 
 /**
- * Resolve the published package version by walking up from `startUrl` until a
- * package.json named `@danieltmn/tamnora` is found. Robust to file depth so
- * callers don't have to count `../` levels.
+ * Resolve the harness package dir (where its package.json lives) by walking up
+ * from `startUrl`. Robust to file depth so callers don't count `../`.
  */
-export function readPackageVersion(startUrl = import.meta.url) {
+export function packageRoot(startUrl = import.meta.url) {
   let dir = path.dirname(fileURLToPath(startUrl));
   for (let i = 0; i < 10; i++) {
     try {
       const pkg = JSON.parse(readFileSync(path.join(dir, 'package.json'), 'utf8'));
-      if (pkg.name === ROOT_PACKAGE_NAME && pkg.version) return pkg.version;
+      if (pkg.name === ROOT_PACKAGE_NAME) return dir;
     } catch {
       /* no hay package.json acá: seguir subiendo */
     }
@@ -22,5 +23,78 @@ export function readPackageVersion(startUrl = import.meta.url) {
     if (parent === dir) break;
     dir = parent;
   }
-  return '0.0.0';
+  return null;
+}
+
+/** Version publicada del harness (`0.0.0` si no se puede leer). */
+export function readPackageVersion(startUrl = import.meta.url) {
+  const root = packageRoot(startUrl);
+  if (!root) return '0.0.0';
+  try {
+    const pkg = JSON.parse(readFileSync(path.join(root, 'package.json'), 'utf8'));
+    return pkg.version || '0.0.0';
+  } catch {
+    return '0.0.0';
+  }
+}
+
+function parseVersion(value) {
+  const match = /^v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/.exec(
+    String(value ?? '').trim()
+  );
+  if (!match) return null;
+  return { nums: [Number(match[1]), Number(match[2]), Number(match[3])], pre: match[4] ?? '' };
+}
+
+/**
+ * Semver minimo: devuelve -1 / 0 / 1. Una version sin prerelease ordena por
+ * encima de una con prerelease (1.0.0 > 1.0.0-beta). Si alguna no se entiende,
+ * las trata como iguales (no queremos gritar "actualizacion disponible" por un
+ * formato raro).
+ */
+export function compareVersions(a, b) {
+  const va = parseVersion(a);
+  const vb = parseVersion(b);
+  if (!va || !vb) return 0;
+  for (let i = 0; i < 3; i++) {
+    if (va.nums[i] > vb.nums[i]) return 1;
+    if (va.nums[i] < vb.nums[i]) return -1;
+  }
+  if (va.pre === vb.pre) return 0;
+  if (!va.pre) return 1;
+  if (!vb.pre) return -1;
+  return va.pre < vb.pre ? -1 : 1;
+}
+
+/**
+ * Ultima version publicada en el registro npm, sin depender de `npm` en el
+ * PATH. `fetchImpl` es inyectable para tests.
+ */
+export async function fetchLatestVersion({
+  pkg = ROOT_PACKAGE_NAME,
+  tag = 'latest',
+  registry = DEFAULT_REGISTRY,
+  fetchImpl = globalThis.fetch,
+  timeoutMs = 8000,
+} = {}) {
+  if (typeof fetchImpl !== 'function') throw new Error('fetch no disponible');
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  timer.unref?.();
+  try {
+    const res = await fetchImpl(`${registry}/${pkg}`, {
+      headers: { accept: 'application/json' },
+      signal: controller.signal,
+    });
+    if (!res.ok) throw new Error(`HTTP ${res.status}`);
+    const data = await res.json();
+    const distTags = data?.['dist-tags'] ?? {};
+    const version = distTags[tag] || distTags.latest;
+    if (!version || !/^\d+\.\d+\.\d+/.test(String(version))) {
+      throw new Error('respuesta sin version valida');
+    }
+    return String(version);
+  } finally {
+    clearTimeout(timer);
+  }
 }

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

@@ -0,0 +1,34 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { compareVersions, fetchLatestVersion } from '../src/index.js';
+
+test('compareVersions ordena semver (incluye prerelease)', () => {
+  assert.equal(compareVersions('1.2.3', '1.2.3'), 0);
+  assert.equal(compareVersions('1.2.4', '1.2.3'), 1);
+  assert.equal(compareVersions('1.3.0', '1.2.9'), 1);
+  assert.equal(compareVersions('2.0.0', '1.9.9'), 1);
+  assert.equal(compareVersions('1.0.0', '1.0.0-beta'), 1);
+  assert.equal(compareVersions('1.0.0-beta', '1.0.0'), -1);
+  assert.equal(compareVersions('v0.9.4', '0.9.4'), 0);
+  // Formato desconocido: no afirmamos que hay algo nuevo.
+  assert.equal(compareVersions('base', '1.0.0'), 0);
+});
+
+test('fetchLatestVersion resuelve el tag desde el registro', async () => {
+  const fetchImpl = async (url) => {
+    assert.match(String(url), /registry\.npmjs\.org\/@danieltmn\/tamnora$/);
+    return { ok: true, json: async () => ({ 'dist-tags': { latest: '9.9.9' } }) };
+  };
+  assert.equal(await fetchLatestVersion({ fetchImpl }), '9.9.9');
+});
+
+test('fetchLatestVersion falla claro con HTTP malo o sin version', async () => {
+  await assert.rejects(
+    fetchLatestVersion({ fetchImpl: async () => ({ ok: false, status: 500 }) }),
+    /HTTP 500/
+  );
+  await assert.rejects(
+    fetchLatestVersion({ fetchImpl: async () => ({ ok: true, json: async () => ({}) }) }),
+    /version/
+  );
+});