@danieltmn/tamnora 0.9.3 → 0.9.5

package/harness/packages/server/test/update.test.js

@@ -0,0 +1,94 @@
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtemp } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { createTamnoraServer } from '../src/index.js';
+import { setHome } from '../../core/src/index.js';
+import { clearUpdateCache } from '../src/lib/update.js';
+
+async function startServer() {
+  const cwd = await mkdtemp(path.join(tmpdir(), 'tamnora-update-'));
+  setHome(cwd);
+  const instance = await createTamnoraServer({
+    cwd,
+    dbPath: path.join(cwd, 'tamnora.db'),
+    loadMcp: false,
+    resolveProvider: () => ({ provider: { id: 'fake' }, config: {} }),
+  });
+  const info = await instance.listen({ port: 0 });
+  return { instance, base: info.url };
+}
+
+/** `fetch` que solo intercepta el registro npm; el resto va al server real. */
+function fakeRegistry(version, original) {
+  return async (url, opts) => {
+    if (String(url).includes('registry.npmjs.org')) {
+      return { ok: true, json: async () => ({ 'dist-tags': { latest: version } }) };
+    }
+    return original(url, opts);
+  };
+}
+
+test('GET /api/update informa cuando hay version nueva', async () => {
+  clearUpdateCache();
+  const { instance, base } = await startServer();
+  const original = global.fetch;
+  global.fetch = fakeRegistry('99.0.0', original);
+  try {
+    const data = await (await fetch(`${base}/api/update`)).json();
+    assert.equal(data.latest, '99.0.0');
+    assert.equal(data.updateAvailable, true);
+    assert.match(data.current, /^\d+\.\d+\.\d+/);
+  } finally {
+    global.fetch = original;
+    await instance.close();
+  }
+});
+
+test('GET /api/update no rompe si no hay red', async () => {
+  clearUpdateCache();
+  const { instance, base } = await startServer();
+  const original = global.fetch;
+  global.fetch = async (url, opts) => {
+    if (String(url).includes('registry.npmjs.org')) throw new Error('offline');
+    return original(url, opts);
+  };
+  try {
+    const data = await (await fetch(`${base}/api/update`)).json();
+    assert.equal(data.updateAvailable, false);
+    assert.equal(data.latest, '');
+    assert.ok(data.error);
+  } finally {
+    global.fetch = original;
+    await instance.close();
+  }
+});
+
+test('POST /api/update dispara el actualizador y responde 202', async () => {
+  clearUpdateCache();
+  const { instance, base } = await startServer();
+  const original = global.fetch;
+  global.fetch = fakeRegistry('99.0.0', original);
+  let called = null;
+  instance.ctx.spawnUpdater = (options) => {
+    called = options;
+    return { ok: true, pid: 1234 };
+  };
+  instance.ctx.shutdown = async () => {};
+  try {
+    const res = await fetch(`${base}/api/update`, { method: 'POST' });
+    assert.equal(res.status, 202);
+    const data = await res.json();
+    assert.equal(data.updating, true);
+    assert.match(data.from, /^\d+\.\d+\.\d+/);
+    assert.equal(data.to, '99.0.0');
+    assert.ok(called);
+    assert.equal(called.target, '99.0.0');
+    assert.equal(called.pid, process.pid);
+    assert.equal(typeof called.cwd, 'string');
+  } finally {
+    global.fetch = original;
+    await instance.close();
+  }
+});

package/harness/scripts/self-update.mjs

@@ -0,0 +1,123 @@
+#!/usr/bin/env node
+// Auto-actualizacion disparada desde el server (POST /api/update).
+//
+// Corre detached: espera a que el server viejo muera (en Windows eso libera los
+// archivos que npm necesita reemplazar), instala la ultima version y vuelve a
+// levantar el server con el codigo nuevo. Todo se loguea en el log del server
+// para poder diagnosticar desde Ajustes o `tamnora server --logs`.
+
+import { spawn, spawnSync } from 'node:child_process';
+import { appendFileSync, existsSync } from 'node:fs';
+import path from 'node:path';
+
+const PACKAGE = '@danieltmn/tamnora';
+const IS_WIN = process.platform === 'win32';
+const NPM = IS_WIN ? 'npm.cmd' : 'npm';
+
+function arg(name) {
+  const i = process.argv.indexOf(`--${name}`);
+  return i >= 0 ? process.argv[i + 1] : '';
+}
+
+const pid = Number(arg('pid')) || 0;
+const port = arg('port');
+const host = arg('host');
+const cwd = arg('cwd');
+const target = arg('target') || 'latest';
+const home = arg('home') || process.env.TAMNORA_HOME || '';
+
+function defaultHome() {
+  if (process.env.APPDATA) return path.join(process.env.APPDATA, 'tamnora');
+  if (process.platform === 'darwin') {
+    return path.join(process.env.HOME || '', 'Library', 'Application Support', 'tamnora');
+  }
+  return path.join(process.env.HOME || process.env.USERPROFILE || '', '.config', 'tamnora');
+}
+
+function log(line) {
+  const text = `[${new Date().toISOString()}] self-update: ${line}`;
+  try {
+    appendFileSync(path.join(home || defaultHome(), 'logs', 'server.log'), `${text}\n`);
+  } catch {
+    /* sin log seguimos: la instalacion es lo importante */
+  }
+  try {
+    process.stdout.write(`${text}\n`);
+  } catch {
+    /* stdout cerrado */
+  }
+}
+
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
+function alive(p) {
+  if (!p) return false;
+  try {
+    process.kill(p, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function waitDead(p, ms = 15000) {
+  const start = Date.now();
+  while (alive(p)) {
+    if (Date.now() - start > ms) {
+      try {
+        process.kill(p);
+      } catch {
+        /* ya murio */
+      }
+      await sleep(1500);
+      return !alive(p);
+    }
+    await sleep(300);
+  }
+  return true;
+}
+
+function runNpm(args) {
+  return spawnSync(NPM, args, { encoding: 'utf8', windowsHide: true, shell: IS_WIN, timeout: 180000 });
+}
+
+async function main() {
+  log(`esperando que muera el server (pid ${pid})`);
+  await waitDead(pid);
+  await sleep(800);
+
+  log(`instalando ${PACKAGE}@${target}`);
+  const install = runNpm(['i', '-g', `${PACKAGE}@${target}`]);
+  if (install.status !== 0) {
+    log(`FALLO la instalacion: ${(install.stderr || install.stdout || '').trim()}`);
+    log('Podes reintentar a mano: npm i -g ' + `${PACKAGE}@${target}`);
+    return;
+  }
+
+  const rootOut = runNpm(['root', '-g']).stdout?.trim();
+  const pkgDir = rootOut ? path.join(rootOut, ...PACKAGE.split('/')) : '';
+  const bin = pkgDir ? path.join(pkgDir, 'harness', 'packages', 'cli', 'bin', 'tamnora.mjs') : '';
+  if (!bin || !existsSync(bin)) {
+    log(`instale pero no encontre el binario nuevo en ${pkgDir || '(npm root -g vacio)'}`);
+    log('Levantalo a mano: tamnora server --start');
+    return;
+  }
+
+  const args = [bin, 'server', '--stream', '--no-open'];
+  if (port) args.push('--port', port);
+  if (host) args.push('--host', host);
+  if (cwd) args.push('--dir', cwd);
+  log(`reiniciando: ${args.join(' ')}`);
+  const env = { ...process.env, TAMNORA_DETACHED: '1' };
+  if (home) env.TAMNORA_HOME = home;
+  const child = spawn(process.execPath, args, {
+    detached: true,
+    stdio: 'ignore',
+    windowsHide: true,
+    env,
+  });
+  child.unref();
+  log(`server reiniciado (pid ${child.pid}).`);
+}
+
+main().catch((error) => log(`error: ${error?.stack ?? error}`));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@danieltmn/tamnora",
-  "version": "0.9.3",
+  "version": "0.9.5",
   "description": "Harness local para IAs: agente CLI-first con TUI, consola web y evaluacion. Node puro, sin dependencias.",
   "type": "module",
   "packageManager": "pnpm@11.25.0",