nio-cat 0.5.0 → 0.6.1

package/bin/nio.js

@@ -9,7 +9,14 @@ const config = require('../src/config');
 const { Hub } = require('../src/hub');
 const { createServer } = require('../src/server');
 const { detectAll } = require('../src/agents');
-const { startTunnel, startNamedTunnel } = require('../src/tunnel');
+const { startTunnel, startNamedTunnel, startConfiguredTunnel, setupNamedTunnel } = require('../src/tunnel');
+const service = require('../src/service');
+const { Auth } = require('../src/auth');
+const { Audit } = require('../src/audit');
+const memory = require('../src/memory');
+const mcp = require('../src/mcp');
+const directory = require('../src/directory');
+const { Jobs } = require('../src/jobs');
 const { addServer } = require('../src/ssh');
 const { pairLink, terminalQr, writePairPage, makeCode, codeLink, terminalQrSize } = require('../src/pair');
 const { which } = require('../src/proc');
@@ -22,11 +29,11 @@ for (let i = 0; i < argv.length; i++) {
   if (a.startsWith('--')) {
     const [k, v] = a.slice(2).split('=');
     if (v !== undefined) flags[k] = v;
-    else if (['port', 'url', 'app', 'local-port', 'dir', 'tunnel-token'].includes(k)) flags[k] = argv[++i];
+    else if (['port', 'url', 'app', 'local-port', 'dir', 'tunnel-token', 'name'].includes(k)) flags[k] = argv[++i];
     else flags[k] = true;
   } else pos.push(a);
 }
-const cmd = ['start', 'pair', 'doctor', 'reset-token', 'help', 'ssh'].includes(pos[0]) ? pos.shift() : 'start';
+const cmd = ['start', 'pair', 'doctor', 'reset-token', 'help', 'ssh', 'tunnel', 'service', 'version', 'devices', 'mcp', 'memory', 'directory'].includes(pos[0]) ? pos.shift() : 'start';
 
 const c = {
   dim: (s) => `\x1b[2m${s}\x1b[0m`,
@@ -36,6 +43,7 @@ const c = {
 };
 
 const cfg = config.load();
+const auth = new Auth(undefined, cfg);
 
 async function doctor() {
   const agents = await detectAll(cfg, true);
@@ -87,7 +95,15 @@ function openDashboard() {
 
 async function showPair(publicUrl) {
   const app = flags.app || cfg.app;
-  const link = pairLink(app, publicUrl, cfg.token), code = makeCode(publicUrl, cfg.token), qrLink = codeLink(app, code);
+  if (cfg.lastUrl !== publicUrl) {
+    cfg.lastUrl = publicUrl;
+    config.save(cfg);
+  }
+  // L'adreça es desa (signada) a nio.cat: si canvia, el mòbil la torna a trobar sol.
+  if (cmd === 'start') directory.publish(cfg, publicUrl, (t) => console.log(c.dim(`  ${t}`)));
+  // Un secret d'un sol ús (no la clau principal): el mòbil el canvia per una clau pròpia i revocable.
+  const { code: secret } = auth.createCode({ secret: true });
+  const link = pairLink(app, publicUrl, secret), code = makeCode(publicUrl, secret), qrLink = codeLink(app, code);
   const file = writePairPage(link, code, qrLink);
   // El QR ha de cabre al terminal: marge normal, marge d'1 mòdul i, si no hi cap, la pàgina del navegador.
   const rows = process.stdout.rows || 999, cols = process.stdout.columns || 999;
@@ -101,7 +117,7 @@ async function showPair(publicUrl) {
   }
   console.log(`\n  ${c.b('Codi:')} ${code}`);
   console.log(c.dim('  Copia\'l i enganxa\'l a Sessions → Tria un ordinador.'));
-  console.log(c.dim('  Aquest codi dona accés als teus agents. Guarda\'l com una contrasenya.\n'));
+  console.log(c.dim('  Serveix per a un sol dispositiu i caduca en 15 minuts. Per a un altre: nio pair.\n'));
   if (flags.open) {
     const opener = process.platform === 'darwin' ? 'open' : process.platform === 'win32' ? 'start' : 'xdg-open';
     try {
@@ -134,6 +150,23 @@ async function sshStart() {
   if (canOpenBrowser() && openUrl(link)) console.log(c.dim('  He obert nio.cat amb el servidor ja afegit.\n'));
 }
 
+// La memòria compartida (servidor MCP de nio) es registra sola a Claude Code i Codex.
+function registerMemory(force) {
+  memory.ensure();
+  if (cfg.memory?.register === false && !force) return;
+  if (mcp.command().unstable && !force) {
+    console.log(c.dim('  Memòria: per registrar-la a Claude Code i Codex, instal·la nio (npm i -g nio-cat) i fes «nio memory register».'));
+    return;
+  }
+  const out = [];
+  const claude = which(cfg.agents?.claude?.bin || 'claude');
+  if (claude) out.push(`Claude Code ${mcp.registerClaude(claude, { force })}`);
+  if (which(cfg.agents?.codex?.bin || 'codex')) {
+    try { out.push(`Codex ${mcp.registerCodex()}`); } catch (e) { out.push(`Codex: ${e.message}`); }
+  }
+  console.log(`  ${c.dim('Memòria:')}  ${memory.DIR}${out.length ? c.dim(`  (${out.join(' · ')})`) : ''}`);
+}
+
 async function start() {
   if (flags.port) cfg.port = Number(flags.port);
   if (flags.app) cfg.app = flags.app;
@@ -167,10 +200,16 @@ async function start() {
   }
   const fixed = cfg.tunnelToken && cfg.fixedUrl && !flags.url && !flags['no-tunnel'] && !flags.lan ? cfg : null;
 
-  const hub = new Hub(cfg);
+  const audit = new Audit();
+  const hub = new Hub(cfg, { audit });
   let publicUrl = flags.url || null;
   const host = flags.lan ? '0.0.0.0' : '127.0.0.1';
-  const server = createServer({ cfg, hub, getPublicUrl: () => publicUrl, getApp: () => flags.app || cfg.app });
+  registerMemory();
+  const jobs = new Jobs({ cfg, hub, audit, available: () => require('../src/agents').AGENTS.filter((a) => a.id === 'demo' || require('../src/agents').binPath(cfg, a.id)).map((a) => a.id) });
+  jobs.hookUrl = () => `http://127.0.0.1:${cfg.port}/internal/approval`;
+  jobs.startTimer();
+  const routes = [...memory.routes(), ...jobs.routes()];
+  const server = createServer({ cfg, hub, auth, audit, routes, getPublicUrl: () => publicUrl, getApp: () => flags.app || cfg.app });
 
   server.on('error', (e) => {
     if (e.code === 'EADDRINUSE') console.error(c.warn(`\n  El port ${cfg.port} ja el fa servir un altre programa. Tria\'n un altre: nio --port 7718\n`));
@@ -187,10 +226,6 @@ async function start() {
       if (ip) {
         publicUrl = publicUrl || `http://${ip}:${cfg.port}`;
         console.log(`  ${c.dim('Xarxa:')}    ${publicUrl}  ${c.dim('(només la mateixa wifi)')}`);
-        if (!flags.url) {
-          // A la xarxa local, l'app es carrega des del mateix daemon (mateix origen).
-          flags.app = publicUrl;
-        }
       }
     }
 
@@ -202,6 +237,20 @@ async function start() {
       return showPair(publicUrl);
     }
 
+    // Adreça fixa amb un túnel configurat amb «nio tunnel setup <host>».
+    const named = cfg.tunnel && cfg.tunnel.mode === 'named' && !flags.quick && !flags.url && !flags['no-tunnel'] && !flags.lan ? cfg.tunnel : null;
+    if (named) {
+      const t = startConfiguredTunnel(named, cfg.port, {
+        onReady: () => console.log(`  ${c.dim('Túnel:')}    https://${named.host}  ${c.ok('connectat')} ${c.dim('(adreça fixa)')}`),
+        onDown: (code, wait) => console.log(c.warn(`  El túnel s’ha tallat (codi ${code}). El torno a obrir d’aquí a ${Math.round(wait / 1000)} s.`)),
+      });
+      if (t) {
+        publicUrl = `https://${named.host}`;
+        console.log(c.dim(`  Obrint el túnel cap a ${publicUrl}…`));
+        return showPair(publicUrl);
+      }
+    }
+
     if (fixed) {
       const nt = startNamedTunnel(cfg.tunnelToken, () => {
         publicUrl = cfg.fixedUrl;
@@ -246,19 +295,97 @@ async function start() {
     case 'doctor':
       await doctor();
       break;
+    case 'mcp':
+      mcp.serve();
+      return;
+    case 'memory':
+      if (pos[0] === 'register') registerMemory(true);
+      else if (pos[0] === 'off') { cfg.memory = { ...(cfg.memory || {}), register: false }; config.save(cfg); console.log('  No registraré la memòria automàticament.'); }
+      else { memory.ensure(); console.log(`  ${memory.DIR}\n`); for (const f of memory.list()) console.log(`  ${f.path}`); console.log(c.dim('\n  nio memory register   ·   nio memory off')); }
+      break;
+    case 'directory':
+      if (pos[0] === 'off') { cfg.directory = false; config.save(cfg); console.log('  No desaré l’adreça a nio.cat. Si el túnel canvia, caldrà tornar a aparellar el mòbil.'); }
+      else if (pos[0] === 'on') { delete cfg.directory; config.save(cfg); console.log('  Desaré l’adreça (signada) a nio.cat perquè el mòbil la trobi si canvia.'); }
+      else console.log(`  Adreça recordada a nio.cat: ${cfg.directory === false ? 'desactivada' : 'activada'} (ordinador ${directory.identity(cfg).loc}).\n  nio directory on · nio directory off`);
+      break;
+    case 'version':
+      console.log(require('../package.json').version);
+      break;
     case 'pair':
+      if (flags.check) {
+        process.exitCode = cfg.lastUrl ? 0 : 1;
+        break;
+      }
       if (!flags.url && !cfg.lastUrl) {
         console.log('  Encara no hi ha cap adreça desada. Engega nio primer.');
         break;
       }
       await showPair(flags.url || cfg.lastUrl);
       break;
-    case 'reset-token':
+    case 'reset-token': {
       cfg.token = crypto.randomBytes(24).toString('base64url');
       cfg.pushSubs = [];
       config.save(cfg);
-      console.log('  Clau nova creada. Cap mòbil aparellat abans no hi té accés.');
+      const n = auth.revokeAll();
+      console.log(`  Clau principal nova i ${n} dispositius desconnectats. Reinicia nio i torna a aparellar els mòbils.`);
+      break;
+    }
+    case 'devices': {
+      const sub = pos.shift();
+      if (sub === 'revoke') {
+        const d = auth.devices.find((x) => x.id === pos[0]) ? auth.revoke(pos[0]) : null;
+        console.log(d ? `  Accés revocat: ${d.name}. Reinicia nio perquè es tanqui la connexió oberta.` : '  No hi ha cap dispositiu amb aquest identificador.');
+        break;
+      }
+      const list = auth.list().filter((d) => !d.primary);
+      if (!list.length) console.log('  Cap dispositiu aparellat amb codi. Fes «nio pair».');
+      for (const d of list) console.log(`  ${d.id.padEnd(14)} ${d.name.padEnd(28)} ${c.dim(d.lastSeen ? 'vist ' + new Date(d.lastSeen).toLocaleString('ca') : 'mai vist')}`);
+      console.log(c.dim('\n  nio devices revoke <id>   ·   també des de l’app, a Ordinadors'));
       break;
+    }
+    case 'tunnel': {
+      const sub = pos.shift();
+      if (sub === 'setup') {
+        try {
+          cfg.tunnel = setupNamedTunnel({ host: pos[0], name: flags.name });
+          config.save(cfg);
+          console.log(`\n  ${c.ok('Fet.')} Aquest ordinador serà a ${c.b('https://' + cfg.tunnel.host)}.`);
+          console.log(c.dim('  Reinicia nio (o el servei) perquè faci servir l’adreça fixa. El mòbil ja no s’haurà de tornar a aparellar.\n'));
+        } catch (e) {
+          console.error(c.warn(`\n  ${e.message}\n`));
+          process.exitCode = 1;
+        }
+      } else if (sub === 'off') {
+        delete cfg.tunnel;
+        config.save(cfg);
+        console.log('  Tornaré a fer servir el túnel ràpid (l’adreça canviarà a cada reinici).');
+      } else {
+        console.log(cfg.tunnel ? `  Túnel amb nom: ${cfg.tunnel.name} → https://${cfg.tunnel.host}` : '  Sense túnel amb nom: faig servir el túnel ràpid de Cloudflare.');
+        console.log(c.dim('  nio tunnel setup <host> [--name <nom>]   ·   nio tunnel off'));
+      }
+      break;
+    }
+    case 'service': {
+      const sub = pos.shift();
+      try {
+        if (sub === 'uninstall') {
+          console.log(`  Servei esborrat (${service.uninstall()}).`);
+        } else if (sub === 'install') {
+          const roots = (pos.length ? pos.map((p) => path.resolve(p)) : cfg.roots.length ? cfg.roots : [process.cwd()]).filter((r) => fs.existsSync(r));
+          const r = service.install({ roots });
+          console.log(`\n  ${c.ok('Fet.')} nio arrencarà sol amb l’ordinador. Carpetes: ${roots.join(', ')}`);
+          console.log(c.dim(`  Fitxer: ${r.file}`));
+          if (r.linger === false) console.log(c.warn('  Per arrencar sense iniciar sessió, executa: sudo loginctl enable-linger $USER'));
+          console.log(c.dim(`  Registre: ${r.logs}   ·   Codi per al mòbil: nio pair\n`));
+        } else {
+          console.log('  nio service install [carpetes…]   ·   nio service uninstall');
+        }
+      } catch (e) {
+        console.error(c.warn(`\n  ${e.message}\n`));
+        process.exitCode = 1;
+      }
+      break;
+    }
     case 'help':
       console.log(`
   ${c.b('nio')} · agents d’IA al teu ordinador, des del mòbil
@@ -271,6 +398,7 @@ async function start() {
     --forget-fixed      Oblida l'adreça fixa i torna al túnel temporal
     --port <n>          Port local (7717 si no dius res)
     --no-open           No obris el panell al navegador d'aquest ordinador
+    --quick             Túnel ràpid encara que n'hi hagi un amb nom
     --local             Obre la còpia del panell d'aquest ordinador (si el navegador bloqueja nio.cat, p. ex. Safari)
     --open              Obre al navegador la pàgina del codi QR
   nio pair              Mostra el codi QR una altra vegada
@@ -282,6 +410,15 @@ async function start() {
   Servidor amb adreça pública: nio --url https://la-teva-adreça --no-open
                         Deixa'l sota tmux, pm2 o systemd perquè no s'aturi.
 
+  nio tunnel setup <host> [--name <nom>]
+                        Adreça fixa amb un túnel de Cloudflare (la zona ha de ser a Cloudflare)
+  nio tunnel off        Torna al túnel ràpid
+  nio service install [carpetes…]
+                        Arrenca nio sol amb l'ordinador (systemd o launchd)
+  nio devices           Dispositius aparellats  ·  nio devices revoke <id>
+  nio memory            Memòria compartida (~/.nio/memory)  ·  register  ·  off
+  nio mcp               Servidor MCP de la memòria (l'engeguen Claude Code i Codex)
+  nio directory on|off  Adreça recordada a nio.cat (el mòbil retroba l'ordinador si el túnel canvia)
   nio doctor            Llista els agents instal·lats
   nio reset-token       Crea una clau nova i desconnecta tots els mòbils
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nio-cat",
-  "version": "0.5.0",
+  "version": "0.6.1",
   "description": "nio: fes servir Claude Code, Codex, Grok, Antigravity i Ollama del teu ordinador des del mòbil.",
   "license": "MIT",
   "author": "f.cat",
@@ -20,6 +20,7 @@
   "scripts": {
     "start": "node bin/nio.js",
     "demo": "node bin/nio.js --lan",
+    "test": "node --test test/*.test.js",
     "prepack": "node scripts/copy-web.js"
   },
   "keywords": [

package/src/agents/claude.js

@@ -77,7 +77,7 @@ function handle(ctx, line) {
     }
     case 'assistant':
       for (const b of ev.message?.content || []) {
-        if (b.type === 'text' && b.text) ctx.endStream(b.text);
+        if (b.type === 'text' && b.text) { ctx.said = true; ctx.endStream(b.text); }
         else if (b.type === 'tool_use') ctx.tool({ id: b.id, name: b.name, input: b.input });
       }
       break;
@@ -93,6 +93,8 @@ function handle(ctx, line) {
       break;
     case 'result':
       if (ev.session_id) ctx.setNative(ev.session_id);
+      // Les comandes locals (/cost, /context…) no passen pel model: la resposta només és aquí.
+      if (!ctx.said && !ev.is_error && !ev.num_turns) ctx.endStream(typeof ev.result === 'string' && ev.result.trim() ? ev.result : 'Fet.');
       ctx.result({
         cost: ev.total_cost_usd,
         ms: ev.duration_ms,

package/src/audit.js

@@ -0,0 +1,55 @@
+'use strict';
+// Registre d'accions: què, per què, quan i qui ho ha decidit. Es guarda només en aquest
+// ordinador (~/.nio/audit.jsonl), una línia JSON per entrada, i mai no s'esborra sol
+// (quan passa de 5 MB es mou a audit.1.jsonl).
+const fs = require('fs');
+const path = require('path');
+const { HOME } = require('./config');
+
+const MAX = 5 * 1024 * 1024;
+
+class Audit {
+  constructor(home = HOME) {
+    this.file = path.join(home, 'audit.jsonl');
+    this.listeners = new Set();
+  }
+
+  add(entry) {
+    const e = { t: Date.now(), ...entry };
+    try {
+      const st = fs.existsSync(this.file) ? fs.statSync(this.file) : null;
+      if (st && st.size > MAX) fs.renameSync(this.file, this.file.replace(/\.jsonl$/, '.1.jsonl'));
+      fs.appendFileSync(this.file, `${JSON.stringify(e)}\n`, { mode: 0o600 });
+    } catch {
+      /* disc ple o sense permís: no aturem l'agent per això */
+    }
+    for (const fn of this.listeners) fn(e);
+    return e;
+  }
+
+  // Les últimes entrades, de més nova a més antiga.
+  recent(limit = 200, filter) {
+    let lines = [];
+    try {
+      lines = fs.readFileSync(this.file, 'utf8').split('\n').filter(Boolean);
+    } catch {
+      return [];
+    }
+    const out = [];
+    for (let i = lines.length - 1; i >= 0 && out.length < limit; i--) {
+      try {
+        const e = JSON.parse(lines[i]);
+        if (!filter || filter(e)) out.push(e);
+      } catch {
+        /* línia malmesa */
+      }
+    }
+    return out;
+  }
+
+  on(fn) {
+    this.listeners.add(fn);
+  }
+}
+
+module.exports = { Audit };

package/src/auth.js

@@ -0,0 +1,175 @@
+'use strict';
+// Dispositius aparellats i codis d'aparellament.
+//
+// · La clau principal (cfg.token) és la del propietari: l'obre el panell local en engegar nio i
+//   la fa servir «nio ssh». Es canvia amb `nio reset-token`.
+// · Cada mòbil aparellat amb un codi té la seva clau. Al disc només en desem el hash (SHA-256).
+// · El codi (dins del «nio-…» i del QR) és un secret d'un sol ús que caduca als 15 minuts.
+//   Viatja al fragment (#) de l'enllaç, que el navegador no envia a cap servidor.
+// · Un dispositiu es pot revocar en qualsevol moment (des de l'app o amb `nio devices revoke`).
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const { HOME } = require('./config');
+
+const CODE_TTL = 15 * 60 * 1000;
+const ALPHA = 'abcdefghjkmnpqrstuvwxyz23456789'; // sense 0/o, 1/l/i
+const MAX_FAILS = 10;
+const FAIL_WINDOW = 10 * 60 * 1000;
+
+const sha = (s) => crypto.createHash('sha256').update(String(s)).digest('hex');
+const rid = (n = 9) => crypto.randomBytes(n).toString('base64url');
+
+function readJson(file, d) {
+  try {
+    return JSON.parse(fs.readFileSync(file, 'utf8'));
+  } catch {
+    return d;
+  }
+}
+function writeJson(file, v) {
+  fs.mkdirSync(path.dirname(file), { recursive: true, mode: 0o700 });
+  const tmp = `${file}.${process.pid}.tmp`;
+  fs.writeFileSync(tmp, JSON.stringify(v, null, 2), { mode: 0o600 });
+  fs.renameSync(tmp, file);
+}
+
+function newCode() {
+  const bytes = crypto.randomBytes(12);
+  let s = '';
+  for (const b of bytes) s += ALPHA[b % ALPHA.length];
+  return `nio-${s.slice(0, 4)}-${s.slice(4, 8)}-${s.slice(8, 12)}`;
+}
+// Els codis «nio-xxxx-xxxx-xxxx» no distingeixen majúscules; els secrets en base64url, sí.
+const normCode = (c) => { const t = String(c || '').replace(/\s+/g, ''); return /^nio-[a-z2-9]{4}-[a-z2-9]{4}-[a-z2-9]{4}$/i.test(t) ? t.toLowerCase() : t; };
+
+class Auth {
+  constructor(home = HOME, cfg = null) {
+    this.cfg = cfg; // per a la clau principal
+    this.devFile = path.join(home, 'devices.json');
+    this.codeFile = path.join(home, 'pairing.json');
+    this.devices = readJson(this.devFile, []);
+    this.fails = [];
+    this.seenDirty = false;
+    this.listeners = new Set();
+  }
+
+  persist() {
+    writeJson(this.devFile, this.devices);
+  }
+
+  list(currentId) {
+    const out = this.devices.map(({ hash, ...d }) => ({ ...d, current: d.id === currentId }));
+    if (this.cfg?.token) out.unshift({ id: 'principal', name: 'Clau principal (aquest ordinador i SSH)', primary: true, created: null, lastSeen: this.primarySeen || null, current: currentId === 'principal' });
+    return out;
+  }
+
+  // Retorna el dispositiu d'un testimoni o null.
+  check(token) {
+    if (!token || typeof token !== 'string' || token.length > 200) return null;
+    const h = Buffer.from(sha(token), 'hex');
+    if (this.cfg?.token) {
+      const p = Buffer.from(sha(this.cfg.token), 'hex');
+      if (crypto.timingSafeEqual(p, h)) {
+        this.primarySeen = Date.now();
+        return { id: 'principal', name: 'Clau principal', primary: true };
+      }
+    }
+    let found = null;
+    for (const d of this.devices) {
+      const b = Buffer.from(d.hash, 'hex');
+      if (b.length === h.length && crypto.timingSafeEqual(b, h)) found = d;
+    }
+    if (found) {
+      const now = Date.now();
+      if (!found.lastSeen || now - found.lastSeen > 60000) {
+        found.lastSeen = now;
+        this.seenDirty = true;
+        clearTimeout(this.seenT);
+        this.seenT = setTimeout(() => this.seenDirty && (this.persist(), (this.seenDirty = false)), 2000);
+        if (this.seenT.unref) this.seenT.unref();
+      }
+    }
+    return found;
+  }
+
+  fromRequest(req) {
+    const h = req.headers.authorization || '';
+    return this.check(h.startsWith('Bearer ') ? h.slice(7) : '');
+  }
+
+  // ---------- codis d'aparellament (fitxer compartit: `nio pair` i el daemon poden ser processos diferents)
+  // `secret: true` dona un secret de 24 bytes en base64url, que cap compacte dins del codi «nio-…».
+  createCode({ secret = false } = {}) {
+    const code = secret ? crypto.randomBytes(24).toString('base64url') : newCode();
+    const now = Date.now();
+    const list = readJson(this.codeFile, []).filter((c) => c.expires > now);
+    list.push({ hash: sha(code), expires: now + CODE_TTL });
+    writeJson(this.codeFile, list.slice(-5));
+    return { code, expires: now + CODE_TTL };
+  }
+
+  blocked() {
+    const now = Date.now();
+    this.fails = this.fails.filter((t) => now - t < FAIL_WINDOW);
+    return this.fails.length >= MAX_FAILS;
+  }
+
+  // Canvia un codi vàlid per un testimoni nou. Llença un error amb .status si no es pot.
+  redeem(code, name) {
+    if (this.blocked()) throw Object.assign(new Error('Massa intents. Espera uns minuts i torna-ho a provar.'), { status: 429 });
+    const now = Date.now();
+    const h = sha(normCode(code));
+    const list = readJson(this.codeFile, []).filter((c) => c.expires > now);
+    const i = list.findIndex((c) => c.hash === h);
+    if (i < 0) {
+      this.fails.push(now);
+      throw Object.assign(new Error('Aquest codi no és vàlid o ha caducat. Demana’n un de nou amb «nio pair».'), { status: 403 });
+    }
+    list.splice(i, 1);
+    writeJson(this.codeFile, list);
+    const token = crypto.randomBytes(32).toString('base64url');
+    const d = { id: rid(), name: cleanName(name), hash: sha(token), created: now, lastSeen: now };
+    this.devices.push(d);
+    this.persist();
+    return { token, device: { id: d.id, name: d.name, created: d.created } };
+  }
+
+  rename(id, name) {
+    const d = this.devices.find((x) => x.id === id);
+    if (!d) return null;
+    d.name = cleanName(name);
+    this.persist();
+    return { id: d.id, name: d.name };
+  }
+
+  revoke(id) {
+    if (id === 'principal') throw Object.assign(new Error('La clau principal es canvia a l’ordinador amb «nio reset-token».'), { status: 400 });
+    const d = this.devices.find((x) => x.id === id);
+    if (!d) return null;
+    this.devices = this.devices.filter((x) => x.id !== id);
+    this.persist();
+    for (const fn of this.listeners) fn(d);
+    return { id: d.id, name: d.name };
+  }
+
+  revokeAll() {
+    const all = this.devices;
+    this.devices = [];
+    this.persist();
+    writeJson(this.codeFile, []);
+    for (const d of all) for (const fn of this.listeners) fn(d);
+    return all.length;
+  }
+
+  onRevoke(fn) {
+    this.listeners.add(fn);
+  }
+}
+
+function cleanName(name) {
+  const n = String(name || '').replace(/[\u0000-\u001f<>]/g, '').trim().slice(0, 60);
+  return n || 'Dispositiu';
+}
+
+module.exports = { Auth, newCode, sha, CODE_TTL };

package/src/commands.js

@@ -23,8 +23,18 @@ function listDir(dir) {
   try { return fs.readdirSync(dir, { withFileTypes: true }); } catch { return []; }
 }
 
+// Comandes internes de Claude Code que també funcionen en mode headless (les altres, com /help o /status, no hi són).
+const CLAUDE_BUILTIN = [
+  { name: 'usage', hint: 'Ús de la subscripció i límits' },
+  { name: 'context', hint: 'Mostra com s’omple el context' },
+  { name: 'compact', hint: 'Resumeix la conversa per alliberar context' },
+  { name: 'init', hint: 'Crea un CLAUDE.md al projecte' },
+  { name: 'review', hint: 'Revisa els canvis de codi' },
+  { name: 'security-review', hint: 'Revisió de seguretat dels canvis' },
+];
+
 function claudeCommands(cwd) {
-  const out = new Map();
+  const out = new Map(CLAUDE_BUILTIN.map((c) => [c.name, { ...c, kind: 'comanda' }]));
   const bases = [path.join(os.homedir(), '.claude'), cwd && path.join(cwd, '.claude')].filter(Boolean);
   for (const base of bases) {
     // Comandes: commands/nom.md i commands/espai/nom.md (→ «espai:nom»)
@@ -45,6 +55,7 @@ function claudeCommands(cwd) {
 }
 
 function agentCommands(agent, cwd) {
+  if (agent === 'codex') return [{ name: 'status', hint: 'Compte, model i carpeta de la sessió', kind: 'comanda' }];
   return agent === 'claude' ? claudeCommands(cwd) : [];
 }
 

package/src/directory.js

@@ -0,0 +1,56 @@
+'use strict';
+// Adreça recordada a nio.cat: l'ordinador publica la seva adreça actual (la del túnel), signada
+// amb una clau Ed25519 pròpia. Si l'adreça canvia, el mòbil la troba allà i comprova la signatura.
+// nio.cat no rep cap altra dada. Es desactiva amb `nio directory off` (cfg.directory = false).
+const crypto = require('crypto');
+const config = require('./config');
+
+const b64u = (b) => Buffer.from(b).toString('base64url');
+
+function identity(cfg) {
+  if (!cfg.identity) {
+    const { publicKey, privateKey } = crypto.generateKeyPairSync('ed25519');
+    cfg.identity = { pub: publicKey.export({ format: 'jwk' }).x, priv: privateKey.export({ format: 'der', type: 'pkcs8' }).toString('base64url') };
+    config.save(cfg);
+  }
+  const pub = cfg.identity.pub;
+  const loc = b64u(crypto.createHash('sha256').update(Buffer.from(pub, 'base64url')).digest().subarray(0, 16));
+  return { pub, loc };
+}
+
+function sign(cfg, url, t = Date.now()) {
+  const { pub, loc } = identity(cfg);
+  const key = crypto.createPrivateKey({ key: Buffer.from(cfg.identity.priv, 'base64url'), format: 'der', type: 'pkcs8' });
+  const sig = b64u(crypto.sign(null, Buffer.from(`nio-node-v1\n${loc}\n${url}\n${t}`), key));
+  return { pub, url, t, sig };
+}
+
+const publicUrl = (u) => /^https:\/\//.test(u || '') && !/^https:\/\/(127\.|localhost|\[)/.test(u);
+
+let current = null;
+let timer = null;
+let retry = 0;
+
+async function publish(cfg, url, log = () => {}) {
+  if (cfg.directory === false || !publicUrl(url)) return false;
+  current = url.replace(/\/$/, '');
+  clearTimeout(timer);
+  const base = (cfg.directoryUrl || 'https://www.nio.cat').replace(/\/$/, '');
+  try {
+    const res = await fetch(`${base}/api/node`, { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify(sign(cfg, current)), signal: AbortSignal.timeout(10000) });
+    if (res.status === 503) return false; // nio.cat encara no té la llibreta configurada
+    if (!res.ok && res.status !== 409) throw new Error(`nio.cat ${res.status}`);
+    retry = 0;
+    timer = setTimeout(() => publish(cfg, current, log), 6 * 3600 * 1000); // renova abans que caduqui
+    if (timer.unref) timer.unref();
+    return true;
+  } catch (e) {
+    const wait = Math.min(30 * 60 * 1000, 5000 * 2 ** retry++);
+    if (retry === 1) log(`No he pogut desar l’adreça a nio.cat (${e.message}). Ho torno a provar.`);
+    timer = setTimeout(() => current === url.replace(/\/$/, '') && publish(cfg, current, log), wait);
+    if (timer.unref) timer.unref();
+    return false;
+  }
+}
+
+module.exports = { identity, sign, publish };