nio-cat 0.9.5 → 0.9.7

package/README.md

@@ -8,15 +8,16 @@ Els teus agents (Claude Code i Codex) als teus ordinadors, controlats des del m
 curl -fsSL https://www.nio.cat/install.sh | sh
 ```
 
-Instal·la nio i `cloudflared` al teu usuari, el deixa com a servei (systemd o launchd) i mostra un codi QR. Escaneja’l amb el mòbil a [nio.cat/app](https://www.nio.cat/app). Per provar-lo sense instal·lar res: `npx nio-cat`.
+Instal·la nio i `cloudflared` al teu usuari, el deixa com a servei (systemd o launchd) i obre nio al navegador amb un codi QR. Escaneja’l amb el mòbil. Per provar-lo sense instal·lar res: `npx nio-cat`, o la demo de [nio.cat/app](https://www.nio.cat/app), amb un ordinador simulat.
 
 ## Què fa
 
 - **Sessions** de Claude Code i Codex en directe, a qualsevol dels teus ordinadors.
 - **Aprovacions** amb el motiu, al mòbil, al push o a Telegram, i **registre** de totes les accions (`~/.nio/audit.jsonl`).
+- **Notes** com Google Keep: targetes, llistes, colors i etiquetes. Grava amb el mòbil i Whisper les transcriu a l’ordinador. Un model local (Ollama), Claude Code o Codex les resumeix i les organitza. Es desen a `~/.nio/notes`.
 - **Feines**: cua, cadenes («quan acabi, que Codex ho revisi») i programació (cron).
 - **Memòria compartida** a `~/.nio/memory`, amb un servidor MCP (`nio mcp`) registrat a Claude Code i Codex.
-- **Telegram** (el teu bot) i **veu** (ElevenLabs o OpenAI), amb les claus a l’ordinador.
+- **Telegram** (el teu bot) i **veu**: dictat gratis amb Whisper a l’ordinador (whisper.cpp + ffmpeg; l’àudio no en surt), o ElevenLabs i OpenAI amb les teves claus.
 - **Navegador i escriptori** amb agent-browser i agent-desktop: mirar passa sol, actuar sempre demana permís.
 
 ## Arquitectura

package/bin/nio.js

@@ -14,6 +14,7 @@ const service = require('../src/service');
 const { Auth } = require('../src/auth');
 const { Audit } = require('../src/audit');
 const memory = require('../src/memory');
+const { Notes } = require('../src/notes');
 const mcp = require('../src/mcp');
 const directory = require('../src/directory');
 const voice = require('../src/voice');
@@ -22,7 +23,7 @@ const { Control } = require('../src/control');
 const { Remote } = require('../src/remote');
 const { Jobs } = require('../src/jobs');
 const { addServer } = require('../src/ssh');
-const { pairLink, terminalQr, writePairPage, makeCode, codeLink, terminalQrSize } = require('../src/pair');
+const { pairLink, writePairPage, makeCode, codeLink } = require('../src/pair');
 const { which } = require('../src/proc');
 
 const argv = process.argv.slice(2);
@@ -111,17 +112,10 @@ async function showPair(publicUrl) {
   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 sempre al terminal, el més gran que hi càpiga: gran (2 caràcters per mòdul), compacte (mig bloc) i,
-  // si ni així hi cap d'ample, cap QR i només el codi. Amb poques files, el marge passa de 2 a 1 mòdul.
-  const rows = process.stdout.rows || 999, cols = process.stdout.columns || 999;
-  const fits = (m, big) => { const z = terminalQrSize(qrLink, m, big); return z.rows + 4 <= rows && z.cols <= cols; };
-  const opt = [[2, true], [2, false], [1, false]].find(([m, big]) => fits(m, big)) || (terminalQrSize(qrLink, 1).cols <= cols ? [1, false] : null);
+  // El QR no surt al terminal (no s'hi veu bé): és al panell que s'obre al navegador.
   console.log(`\n  ${c.b('Connecta el mòbil')}\n`);
-  if (opt) {
-    console.log(`  Escaneja aquest codi amb la càmera${panelOpened ? ' (també el tens al navegador)' : ''}:\n`);
-    console.log(terminalQr(qrLink, { margin: opt[0], big: opt[1] }));
-  } else console.log(`  La finestra és massa estreta per al QR${panelOpened ? '; el tens al navegador' : '. Fes-la més ampla i torna-ho a provar: nio pair'}.`);
-  console.log(`\n  ${opt ? 'O copia' : 'Copia'} aquest codi i enganxa'l a Sessions → Tria un ordinador:\n`);
+  if (panelOpened) console.log('  He obert nio al navegador: escaneja el QR que hi surt amb la càmera del mòbil.\n  O, al mòbil, obre nio.cat/app → Ordinadors → Afegeix i enganxa aquest codi:\n');
+  else console.log('  Al mòbil, obre nio.cat/app → Ordinadors → Afegeix i enganxa aquest codi:\n');
   console.log(`  ${code}\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) {
@@ -220,7 +214,8 @@ async function start() {
   if (cfg.telegram?.token) row('Telegram', 'actiu', `(${(cfg.telegram.allowed || []).length} xats autoritzats)`);
   const control = new Control({ cfg, hub, audit });
   const remote = new Remote({ cfg, audit });
-  const routes = [...memory.routes(), ...jobs.routes(), ...voice.routes(cfg), ...tg.routes(), ...control.routes(), ...remote.routes()];
+  const notes = new Notes({ cfg, hub });
+  const routes = [...memory.routes(), ...notes.routes(), ...jobs.routes(), ...voice.routes(cfg), ...tg.routes(), ...control.routes(), ...remote.routes()];
   const server = createServer({ cfg, hub, auth, audit, routes, beforeApproval: (t, i) => control.beforeApproval(t, i), info: async () => ({ control: await control.caps().catch(() => null) }), getPublicUrl: () => publicUrl, getApp: () => flags.app || cfg.app });
 
   server.on('error', (e) => {
@@ -414,7 +409,7 @@ async function start() {
     --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
+  nio pair              Obre el navegador amb el QR per connectar el mòbil (i mostra el codi)
 
   nio ssh usuari@servidor   Afegeix un servidor (VPS) per SSH: hi engega nio amb un túnel i el pots fer servir des del mòbil.
     --port <n>          Port de nio al servidor (7717)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nio-cat",
-  "version": "0.9.5",
+  "version": "0.9.7",
   "description": "nio: fes servir Claude Code, Codex, Grok, Antigravity i Ollama del teu ordinador des del mòbil.",
   "license": "UNLICENSED",
   "author": "f.cat",

package/src/agents/claude.js

@@ -110,7 +110,10 @@ function handle(ctx, line) {
         error: ev.is_error ? ev.result || ev.subtype : null,
       });
       break;
+    case 'rate_limit_event':
+      ctx.limits?.(ev.rate_limit_info);
+      break;
     default:
-      break; // rate_limit_event, etc.
+      break;
   }
 }

package/src/agents/ollama.js

@@ -70,11 +70,12 @@ async function pull(name, onProgress, signal) {
 }
 
 // Una resposta d'un sol cop (sense flux), per exemple per a la pissarra.
-async function chat({ model, messages, format }) {
+async function chat({ model, messages, format, think, maxTokens, signal }) {
   const res = await fetch(`${base()}/api/chat`, {
     method: 'POST',
     headers: { 'content-type': 'application/json' },
-    body: JSON.stringify({ model, messages, stream: false, ...(format ? { format } : {}), options: { temperature: 0.2 } }),
+    body: JSON.stringify({ model, messages, stream: false, ...(format ? { format } : {}), ...(think === false ? { think: false } : {}), options: { temperature: 0.2, ...(maxTokens ? { num_predict: maxTokens } : {}) } }),
+    ...(signal ? { signal } : {}),
   });
   if (!res.ok) throw new Error(`Ollama ha tornat un error ${res.status}: ${await res.text()}`);
   const data = await res.json();

package/src/hub.js

@@ -7,6 +7,7 @@ const { EventEmitter } = require('events');
 const { byId, binPath } = require('./agents');
 const { HOME, save } = require('./config');
 const push = require('./push');
+const usage = require('./usage');
 
 const MAX_EVENTS = 3000;
 const MAX_OUT = 4000;
@@ -269,6 +270,7 @@ class Hub extends EventEmitter {
       },
       toolResult: ({ id: tid, output, error }) =>
         this.push(s, 'tool_result', { id: tid, name: toolNames.get(tid), output: clip(output), error: !!error }),
+      limits: (info) => { if (usage.setClaude(info)) this.emit('out', { type: 'usage', usage: usage.all() }); },
       result: (r) => {
         if (typeof r.cost === 'number') s.cost = (s.cost || 0) + r.cost;
         this.push(s, 'result', r);

package/src/notes.js

@@ -0,0 +1,293 @@
+'use strict';
+// Notes: com Google Keep, però a l'ordinador. Es desen a ~/.nio/notes/notes.json i l'àudio a ~/.nio/notes/audio.
+// · Transcripció: el mòbil (o el navegador) grava i l'ordinador transcriu amb Whisper (gratis i local).
+// · Resums i ordre: amb un model local d'Ollama, o amb Claude Code o Codex d'aquest ordinador.
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const crypto = require('crypto');
+const { spawn } = require('child_process');
+const { HOME } = require('./config');
+const { childEnv } = require('./proc');
+const voice = require('./voice');
+const ollama = require('./agents/ollama');
+
+const DIR = path.join(HOME, 'notes');
+const FILE = path.join(DIR, 'notes.json');
+const AUDIO = path.join(DIR, 'audio');
+const MAX_AUDIO = 25 * 1024 * 1024;
+const TRASH_DAYS = 30;
+const COLORS = ['', 'lemon', 'peach', 'moss', 'sky', 'lilac', 'rose', 'sand'];
+const rid = () => crypto.randomBytes(6).toString('base64url');
+const httpErr = (status, message) => Object.assign(new Error(message), { status });
+const extOf = (mime) => (/ogg/.test(mime) ? 'ogg' : /mp4|m4a|aac/.test(mime) ? 'm4a' : /mpeg|mp3/.test(mime) ? 'mp3' : /wav/.test(mime) ? 'wav' : 'webm');
+// «751.63M» → 0,75 · «8.2B» → 8,2 (mil milions de paràmetres)
+const billions = (p) => { const m = String(p || '').match(/([\d.]+)\s*([MB])/i); return m ? parseFloat(m[1]) / (m[2].toUpperCase() === 'M' ? 1000 : 1) : 0; };
+const str = (v, max) => String(v ?? '').slice(0, max);
+
+// Només es deixen passar els camps coneguts, amb límits.
+function clean(b = {}) {
+  const o = {};
+  if ('title' in b) o.title = str(b.title, 200);
+  if ('text' in b) o.text = str(b.text, 200000);
+  if ('items' in b) {
+    o.items = b.items === null ? null : (Array.isArray(b.items) ? b.items : []).slice(0, 500).map((i) => ({ id: str(i?.id, 20) || rid(), text: str(i?.text, 500), done: !!i?.done }));
+  }
+  if ('color' in b) o.color = COLORS.includes(b.color) ? b.color : '';
+  for (const k of ['pinned', 'archived']) if (k in b) o[k] = !!b[k];
+  if ('labels' in b) o.labels = [...new Set((Array.isArray(b.labels) ? b.labels : []).map((l) => str(l, 30).trim()).filter(Boolean))].slice(0, 12);
+  if ('trashed' in b) o.trashed = b.trashed ? Date.now() : 0;
+  return o;
+}
+
+class Notes {
+  constructor({ cfg, hub }) {
+    this.cfg = cfg;
+    this.hub = hub;
+    this.notes = [];
+    this.timer = null;
+    try { this.notes = JSON.parse(fs.readFileSync(FILE, 'utf8')); } catch { /* encara no n'hi ha */ }
+    const old = Date.now() - TRASH_DAYS * 864e5;
+    this.notes = this.notes.filter((n) => !n.trashed || n.trashed > old);
+  }
+
+  save() {
+    clearTimeout(this.timer);
+    this.timer = setTimeout(() => {
+      fs.mkdirSync(DIR, { recursive: true, mode: 0o700 });
+      const tmp = `${FILE}.tmp`;
+      fs.writeFile(tmp, JSON.stringify(this.notes), (e) => { if (!e) fs.rename(tmp, FILE, () => {}); });
+    }, 250);
+    this.timer.unref?.();
+  }
+
+  emit(note) { this.hub.emit('out', { type: 'note', note }); }
+  get(id) { const n = this.notes.find((x) => x.id === id); if (!n) throw httpErr(404, 'Aquesta nota no existeix'); return n; }
+
+  create(body) {
+    const now = Date.now();
+    const n = { id: rid(), title: '', text: '', items: null, color: '', pinned: false, archived: false, trashed: 0, labels: [], audio: [], created: now, updated: now, ...clean(body) };
+    this.notes.unshift(n);
+    this.save();
+    this.emit(n);
+    return n;
+  }
+
+  patch(id, body) {
+    const n = this.get(id);
+    Object.assign(n, clean(body), { updated: Date.now() });
+    this.save();
+    this.emit(n);
+    return n;
+  }
+
+  remove(id, forever) {
+    const n = this.get(id);
+    if (!n.trashed && !forever) return this.patch(id, { trashed: true });
+    for (const a of n.audio) fs.rm(this.audioFile(n, a), { force: true }, () => {});
+    this.notes = this.notes.filter((x) => x !== n);
+    this.save();
+    this.hub.emit('out', { type: 'note-gone', id });
+    return { ok: true };
+  }
+
+  audioFile(n, a) { return path.join(AUDIO, `${n.id}-${a.id}.${extOf(a.mime)}`); }
+
+  // Desa l'àudio i el transcriu en segon pla; el resultat arriba per «note» (flux d'esdeveniments).
+  addAudio(id, buf, mime, dur) {
+    const n = this.get(id);
+    if (!buf?.length || buf.length < 1500) throw httpErr(400, 'No he sentit res. Prova-ho una altra vegada.');
+    const a = { id: rid(), mime, size: buf.length, dur: Number(dur) > 0 ? Math.round(Number(dur)) : 0, at: Date.now(), state: 'transcribing', text: '', error: '' };
+    fs.mkdirSync(AUDIO, { recursive: true, mode: 0o700 });
+    fs.writeFileSync(this.audioFile(n, a), buf);
+    n.audio.push(a);
+    n.updated = Date.now();
+    this.save();
+    this.emit(n);
+    this.transcribe(n, a, buf);
+    return n;
+  }
+
+  retry(id, aid) {
+    const n = this.get(id), a = n.audio.find((x) => x.id === aid);
+    if (!a) throw httpErr(404, 'Aquest àudio no existeix');
+    if (a.state === 'transcribing') return n;
+    a.state = 'transcribing'; a.error = '';
+    this.emit(n);
+    this.transcribe(n, a, fs.readFileSync(this.audioFile(n, a)));
+    return n;
+  }
+
+  async transcribe(n, a, buf) {
+    try {
+      const { text } = await voice.transcribe(this.cfg, buf, a.mime);
+      const t = String(text || '').trim();
+      if (!t) throw new Error('No he entès res en aquest àudio.');
+      a.text = t; a.state = 'ok'; a.error = '';
+      if (n.items) {
+        const parts = t.split(/(?<=[.!?])\s+/).map((s) => s.trim()).filter(Boolean);
+        n.items.push(...parts.map((s) => ({ id: rid(), text: s.slice(0, 500), done: false })));
+      } else {
+        n.text = n.text ? `${n.text.trimEnd()}\n\n${t}` : t;
+      }
+    } catch (e) {
+      a.state = 'error'; a.error = String(e.message || e).slice(0, 300);
+    }
+    if (this.notes.includes(n)) { n.updated = Date.now(); this.save(); this.emit(n); }
+  }
+
+  // ---------- Motors per resumir i organitzar
+  async engines() {
+    const { binPath } = require('./agents');
+    const out = [];
+    const models = await ollama.listModels();
+    // Un model «:cloud» d'Ollama s'executa als seus servidors: no compta com a local. Els locals, de petit a gran.
+    for (const m of [...(models || [])].sort((a, b) => (/cloud/.test(a.name) || !a.size) - (/cloud/.test(b.name) || !b.size) || a.size - b.size)) {
+      const cloud = /:cloud$|-cloud$/.test(m.name) || !m.size;
+      out.push({ id: `ollama:${m.name}`, label: `${m.name}${m.params ? ` · ${m.params}` : ''}${cloud ? ' · núvol' : ''}`, local: !cloud, group: cloud ? 'Ollama (núvol)' : 'Local (Ollama)', size: m.size, params: billions(m.params) });
+    }
+    if (binPath(this.cfg, 'claude')) out.push({ id: 'claude:haiku', label: 'Claude Code · ràpid', local: false, group: 'Claude Code' }, { id: 'claude', label: 'Claude Code · model per defecte', local: false, group: 'Claude Code' });
+    if (binPath(this.cfg, 'codex')) out.push({ id: 'codex', label: 'Codex', local: false, group: 'Codex' });
+    return out;
+  }
+
+  async ai({ id, action, engine, prompt }) {
+    const n = this.get(id);
+    const body = n.items ? `${n.text ? `${n.text}\n\n` : ''}${n.items.map((i) => `- [${i.done ? 'x' : ' '}] ${i.text}`).join('\n')}` : n.text;
+    if (!`${n.title}${body}`.trim()) throw httpErr(400, 'La nota és buida');
+    const spec = ACTIONS[action];
+    if (!spec) throw httpErr(400, 'Acció desconeguda');
+    if (action === 'custom' && !String(prompt || '').trim()) throw httpErr(400, 'Escriu què vols que faci');
+    const list = await this.engines();
+    // Per defecte: el model local més petit de 3 mil milions de paràmetres o més; si no, Claude ràpid; si no, el primer.
+    const auto = list.filter((e) => e.local && e.id.startsWith('ollama:') && e.params >= 3)[0] || list.find((e) => e.id === 'claude:haiku') || list[0];
+    const pick = list.find((e) => e.id === engine) || auto;
+    if (!pick) throw httpErr(400, 'No hi ha cap model en aquest ordinador. Instal·la Ollama amb un model (ollama pull qwen3:4b) o Claude Code.');
+    // La nota va primer i la instrucció al final: els models petits segueixen millor l'última cosa que llegeixen.
+    const user = `--- NOTA ---\nTítol: ${n.title || '(sense títol)'}\n\n${body.slice(0, 40000)}\n--- FI DE LA NOTA ---\n\n${spec.task(String(prompt || '').slice(0, 1000))}`;
+    // Els models locals petits «pensen» en veu alta quan responen en text lliure (minuts). En mode JSON surten directes.
+    const local = pick.id.startsWith('ollama:'), wrap = !spec.json && local;
+    const raw = await runModel(this.cfg, pick.id, SYSTEM, wrap ? `${user}\n\nTorna només JSON amb aquest format: {"text":"…"}. El text pot tenir salts de línia.` : user, spec.json || wrap);
+    const result = spec.json ? parseJson(raw) : wrap ? { text: String(parseJson(raw).text ?? '').trim() } : { text: raw.trim() };
+    if (typeof result.text === 'string' && /--- (FI DE LA )?NOTA ---|Torna només JSON/.test(result.text)) throw httpErr(502, 'El model ha respost malament. Torna-ho a provar o tria un model més gran.');
+    if (typeof result.text === 'string') result.text = result.text.replace(/^\s*T[ií]tol:[^\n]*\n+/i, '').trim(); // els models petits repeteixen el títol
+    return { engine: pick.id, local: pick.local, action, result: spec.shape(result, n) };
+  }
+
+  routes() {
+    const R = (method, path, handler, extra = {}) => ({ method, path, handler, ...extra });
+    return [
+      R('GET', '/api/notes', () => ({ notes: this.notes })),
+      R('POST', '/api/notes', ({ body }) => this.create(body), { limit: 1024 * 1024 }),
+      R('GET', '/api/notes/engines', () => this.engines().then((engines) => ({ engines }))),
+      R('POST', '/api/notes/ai', ({ body }) => this.ai(body || {})),
+      R('PATCH', /^\/api\/notes\/([\w-]+)$/, ({ params, body }) => this.patch(params[0], body), { limit: 1024 * 1024 }),
+      R('DELETE', /^\/api\/notes\/([\w-]+)$/, ({ params, url }) => this.remove(params[0], url.searchParams.get('forever') === '1')),
+      R('POST', /^\/api\/notes\/([\w-]+)\/audio$/, async ({ req, params, url }) => this.addAudio(params[0], await readRaw(req), String(req.headers['content-type'] || 'audio/webm').split(';')[0], url.searchParams.get('dur')), { raw: true }),
+      R('POST', /^\/api\/notes\/([\w-]+)\/audio\/([\w-]+)\/retry$/, ({ params }) => this.retry(params[0], params[1])),
+      R('GET', /^\/api\/notes\/([\w-]+)\/audio\/([\w-]+)$/, ({ res, params }) => {
+        const n = this.get(params[0]), a = n.audio.find((x) => x.id === params[1]);
+        if (!a) throw httpErr(404, 'Aquest àudio no existeix');
+        const buf = fs.readFileSync(this.audioFile(n, a));
+        res.writeHead(200, { 'content-type': a.mime, 'content-length': buf.length, 'cache-control': 'no-store' });
+        res.end(buf);
+      }),
+    ];
+  }
+}
+
+function readRaw(req, limit = MAX_AUDIO) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    let size = 0;
+    req.on('data', (c) => { size += c.length; if (size > limit) { reject(httpErr(413, 'L’àudio és massa llarg')); req.destroy(); } else chunks.push(c); });
+    req.on('end', () => resolve(Buffer.concat(chunks)));
+    req.on('error', reject);
+  });
+}
+
+// ---------- Instruccions per a cada acció
+const SYSTEM = 'Ets l’assistent de notes de nio. Treballes només amb el text de la nota que et donen. No hi afegeixes res que no hi sigui. Respon en l’idioma de la nota (si dubtes, en català). No facis servir cap eina.';
+const ACTIONS = {
+  summary: {
+    json: false,
+    task: () => 'Escriu un resum de 3 a 5 punts curts amb les idees principals de la nota, amb altres paraules (no copiïs el text). Cada punt comença amb «- ». Només els punts, sense introducció ni títol.',
+    shape: (r) => ({ text: r.text }),
+  },
+  clean: {
+    json: false,
+    task: () => 'La nota és una transcripció de veu. Posa-hi puntuació i majúscules, divideix-la en paràgrafs i treu els «eh», repeticions i falsos començaments. No canviïs el sentit ni resumeixis. Torna només el text net, sense el títol.',
+    shape: (r) => ({ text: r.text }),
+  },
+  tasks: {
+    json: true,
+    task: () => 'Extreu les tasques pendents de la nota. Torna només JSON amb aquest format: {"items":["tasca 1","tasca 2"]}. Cada tasca és una frase curta i en forma d’acció. Si no n’hi ha cap, {"items":[]}.',
+    shape: (r) => ({ items: (Array.isArray(r.items) ? r.items : []).map((s) => str(s, 300).trim()).filter(Boolean).slice(0, 50) }),
+  },
+  organize: {
+    json: true,
+    task: () => 'Organitza la nota: dona-li un títol curt, ordena el contingut en paràgrafs o llistes amb Markdown senzill i proposa 1 a 3 etiquetes d’una paraula en minúscula. Conserva tot el contingut important. Torna només JSON amb aquest format: {"title":"…","text":"…","labels":["…"]}.',
+    shape: (r, n) => ({ title: str(r.title, 200).trim() || n.title, text: str(r.text, 200000).trim(), labels: (Array.isArray(r.labels) ? r.labels : []).map((l) => str(l, 30).trim().toLowerCase()).filter(Boolean).slice(0, 3) }),
+  },
+  title: {
+    json: true,
+    task: () => 'Proposa un títol de menys de 8 paraules per a la nota. Torna només JSON amb aquest format: {"title":"…"}.',
+    shape: (r) => ({ title: str(r.title, 200).trim() }),
+  },
+  custom: {
+    json: false,
+    task: (p) => `Fes això amb la nota: ${p}\nTorna només el resultat, en text.`,
+    shape: (r) => ({ text: r.text }),
+  },
+};
+
+function parseJson(raw) {
+  const t = String(raw || '').replace(/^```(?:json)?\s*|\s*```$/g, '').trim();
+  try { return JSON.parse(t); } catch { /* potser hi ha text al voltant */ }
+  const i = t.indexOf('{'), j = t.lastIndexOf('}');
+  if (i >= 0 && j > i) { try { return JSON.parse(t.slice(i, j + 1)); } catch { /* res */ } }
+  throw httpErr(502, 'El model no ha tornat una resposta que pugui entendre. Prova-ho amb un altre model.');
+}
+
+// ---------- Execució d'un model, d'un sol cop
+function runCli(bin, args, input, { cwd, timeout = 180000 } = {}) {
+  return new Promise((resolve, reject) => {
+    const p = spawn(bin, args, { cwd, env: childEnv(), stdio: ['pipe', 'pipe', 'pipe'] });
+    let out = '', err = '';
+    const t = setTimeout(() => { p.kill('SIGKILL'); reject(httpErr(504, 'El model ha trigat massa. Prova-ho amb un de més petit o ràpid.')); }, timeout);
+    p.stdout.on('data', (d) => { out += d; });
+    p.stderr.on('data', (d) => { err += d; });
+    p.on('error', (e) => { clearTimeout(t); reject(httpErr(500, `No he pogut engegar ${path.basename(bin)}: ${e.message}`)); });
+    p.on('close', (code) => { clearTimeout(t); code === 0 ? resolve(out) : reject(httpErr(502, (err || out || `Error ${code}`).trim().slice(-300))); });
+    p.stdin.on('error', () => {});
+    p.stdin.end(input);
+  });
+}
+
+async function runModel(cfg, engine, system, user, json) {
+  const { binPath } = require('./agents');
+  const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'nio-nota-'));
+  try {
+    if (engine.startsWith('ollama:')) {
+      // Qwen3 «pensa» abans de respondre (minuts en un model petit): «/no_think» ho desactiva. Si la resposta porta un bloc <think>, es treu.
+      const model = engine.slice(7), soft = /qwen3/i.test(model) ? '\n\n/no_think' : '';
+      const out = await ollama.chat({ model, messages: [{ role: 'system', content: system }, { role: 'user', content: user + soft }], format: json ? 'json' : undefined, think: false, maxTokens: 3000, signal: AbortSignal.timeout(150000) }).catch((e) => { throw e.name === 'TimeoutError' ? httpErr(504, 'El model ha trigat massa. Prova-ho amb un de més petit o ràpid.') : e; });
+      return out.replace(/^[\s\S]*?<\/think>\s*/i, '').trim();
+    }
+    if (engine === 'claude' || engine.startsWith('claude:')) {
+      const args = ['-p', '--tools', '', '--no-session-persistence', '--output-format', 'text', '--system-prompt', system];
+      if (engine.startsWith('claude:')) args.push('--model', engine.slice(7));
+      return await runCli(binPath(cfg, 'claude'), args, user, { cwd: tmp });
+    }
+    if (engine === 'codex') {
+      const outFile = path.join(tmp, 'resposta.txt');
+      await runCli(binPath(cfg, 'codex'), ['exec', '--skip-git-repo-check', '--ephemeral', '-s', 'read-only', '-C', tmp, '-o', outFile, '-'], `${system}\n\n${user}`, { cwd: tmp });
+      return fs.readFileSync(outFile, 'utf8');
+    }
+    throw httpErr(400, 'Motor desconegut');
+  } finally {
+    fs.rm(tmp, { recursive: true, force: true }, () => {});
+  }
+}
+
+module.exports = { Notes, DIR, clean, parseJson, ACTIONS, COLORS };

package/src/pair.js

@@ -25,7 +25,7 @@ function makeCode(url, token) {
   else bytes = Buffer.concat([Buffer.from([0]), Buffer.from(`${url}\n${token}`)]);
   return `nio-${bytes.toString('base64url')}`;
 }
-// Enllaç curt per al QR: una adreça de l'app amb el codi al fragment. Un QR més petit cap millor al terminal.
+// Enllaç curt per al QR: una adreça de l'app amb el codi al fragment. Com més curt, més fàcil d'escanejar.
 const codeLink = (app, code) => `${app.replace(/\/$/, '')}/app#${code}`;
 
 function qr(text) {
@@ -35,47 +35,6 @@ function qr(text) {
   return q;
 }
 
-// QR per al terminal, compacte: cada caràcter «▀» pinta dos mòduls (dalt amb el color de la lletra, baix amb el del fons).
-// Ocupa la meitat d'alt i d'ample que amb dos espais per mòdul. Sempre negre sobre blanc, amb tema clar o fosc.
-function terminalQr(text, { color = !process.env.NO_COLOR, margin = 2, big = false } = {}) {
-  if (big) return terminalQrBig(text, { color, margin });
-  const q = qr(text);
-  const n = q.getModuleCount();
-  const M = margin;
-  const dark = (r, c) => r >= 0 && c >= 0 && r < n && c < n && q.isDark(r, c);
-  const lines = [];
-  for (let r = -M; r < n + M; r += 2) {
-    let line = '';
-    for (let c = -M; c < n + M; c++) {
-      const t = dark(r, c), b = r + 1 < n + M ? dark(r + 1, c) : false;
-      if (color) line += `\x1b[${t ? 30 : 97};${b ? 40 : 107}m▀`;
-      else line += t && b ? ' ' : t ? '▄' : b ? '▀' : '█';
-    }
-    lines.push(`  ${line}${color ? '\x1b[0m' : ''}`);
-  }
-  return lines.join('\n');
-}
-
-// QR gran: dos espais amb color de fons per mòdul. Quadrat i molt fàcil d'escanejar, però ocupa el doble.
-function terminalQrBig(text, { color, margin: M }) {
-  const q = qr(text), n = q.getModuleCount();
-  const dark = (r, c) => r >= 0 && c >= 0 && r < n && c < n && q.isDark(r, c);
-  const lines = [];
-  for (let r = -M; r < n + M; r++) {
-    let line = '', prev = null;
-    for (let c = -M; c < n + M; c++) {
-      const d = dark(r, c);
-      if (color) { if (d !== prev) line += d ? '\x1b[40m' : '\x1b[107m'; line += '  '; }
-      else line += d ? '  ' : '██';
-      prev = d;
-    }
-    lines.push(`  ${line}${color ? '\x1b[0m' : ''}`);
-  }
-  return lines.join('\n');
-}
-
-// SVG propi: una sola forma amb tires horitzontals de mòduls, vora de 4 mòduls i vores nítides.
-// (El de la llibreria dibuixa cada mòdul per separat i, en escalar-lo, deixa línies fines entre mòduls.)
 function qrSvg(text) {
   const q = qr(text), n = q.getModuleCount(), M = 4;
   let d = '';
@@ -102,17 +61,11 @@ main{width:min(420px,100% - 40px);padding:40px 0}h1{font-size:30px;font-weight:5
 .qr{background:#fffefd;border:1px solid #cec7bd;padding:18px;border-radius:16px;margin:24px 0}.qr svg{width:100%;height:auto;display:block}
 code{display:block;word-break:break-all;font:12px/1.5 ui-monospace,Menlo,monospace;background:#e6e1d8;padding:12px 14px;border-radius:12px;color:#272224}small{display:block;margin-top:20px;font-size:13px;color:#69615c}</style></head>
 <body><main><h1>Connecta el mòbil</h1><p>Escaneja el codi amb la càmera. S’obrirà nio ja connectat a aquest ordinador.</p><div class="qr">${svg}</div>
-<p>O copia aquest codi i enganxa'l a <b>Sessions → Tria un ordinador</b>:</p><code>${code}</code><small>Aquest codi dona accés als teus agents. Guarda'l com una contrasenya.</small></main></body></html>`;
+<p>O copia aquest codi i enganxa'l a <b>nio.cat/app → Ordinadors → Afegeix</b>:</p><code>${code}</code><small>Aquest codi dona accés als teus agents. Guarda'l com una contrasenya.</small></main></body></html>`;
   const file = path.join(HOME, 'pair.html');
   fs.writeFileSync(file, html, { mode: 0o600 });
   return file;
 }
 
-module.exports = { pairLink, terminalQr, writePairPage, qrSvg, makeCode, codeLink };
+module.exports = { pairLink, writePairPage, qrSvg, makeCode, codeLink };
 
-// Mida del QR al terminal: files i columnes que ocupa amb un marge donat.
-function terminalQrSize(text, margin = 2, big = false) {
-  const n = qr(text).getModuleCount() + margin * 2;
-  return big ? { rows: n, cols: n * 2 + 2 } : { rows: Math.ceil(n / 2), cols: n + 2 };
-}
-module.exports.terminalQrSize = terminalQrSize;

package/src/server.js

@@ -14,6 +14,7 @@ const { addServer, knownHosts } = require('./ssh');
 const { agentCommands } = require('./commands');
 const { pairLink, qrSvg, makeCode, codeLink } = require('./pair');
 const directory = require('./directory');
+const usage = require('./usage');
 
 // L'app web: copiada dins del paquet en publicar-lo, o l'arrel del repositori en desenvolupament.
 const WEB_DIRS = [path.join(__dirname, '..', 'web'), path.join(__dirname, '..', '..')];
@@ -160,9 +161,24 @@ function createServer({ cfg, hub, auth, audit, getPublicUrl, getApp, routes = []
   const seenDevices = new Map(); // mòbils que s'han connectat (per avisar l'ordinador que mostra el QR)
   const pulls = new Map(); // descàrregues de models d'Ollama en curs
 
-  hub.on('out', (msg) => {
+  // Els trossos de text surten de seguida el primer cop i després s'agrupen cada 40 ms: menys paquets i menys repintats al mòbil.
+  const writeOut = (msg) => {
     const data = `data: ${JSON.stringify(msg)}\n\n`;
     for (const res of streams.keys()) res.write(data);
+  };
+  let pendDelta = null, deltaWin = 0;
+  const flushDelta = () => { if (pendDelta) { const d = pendDelta; pendDelta = null; writeOut(d); } };
+  hub.on('out', (msg) => {
+    if (msg.type === 'delta') {
+      if (pendDelta && (pendDelta.session !== msg.session || pendDelta.seq !== msg.seq)) flushDelta();
+      if (deltaWin) { if (pendDelta) pendDelta.text += msg.text; else pendDelta = { ...msg }; return; }
+      writeOut(msg);
+      deltaWin = setTimeout(() => { deltaWin = 0; flushDelta(); }, 40);
+      deltaWin.unref?.();
+      return;
+    }
+    flushDelta();
+    writeOut(msg);
   });
   setInterval(() => {
     for (const res of streams.keys()) res.write(': ping\n\n');
@@ -181,6 +197,7 @@ function createServer({ cfg, hub, auth, audit, getPublicUrl, getApp, routes = []
       return hit.r.handler({ req, res, url, params: hit.params, body, device });
     }
 
+    if (p === '/api/usage' && method === 'GET') return usage.all();
     if (p === '/api/info' && method === 'GET') {
       return {
         name: 'nio',
@@ -453,7 +470,7 @@ function createServer({ cfg, hub, auth, audit, getPublicUrl, getApp, routes = []
           connection: 'keep-alive',
         });
         req.socket?.setNoDelay(true);
-        res.write(`data: ${JSON.stringify({ type: 'hello', sessions: hub.list(), approvals: hub.pendingApprovals() })}\n\n`);
+        res.write(`data: ${JSON.stringify({ type: 'hello', sessions: hub.list(), approvals: hub.pendingApprovals(), usage: usage.all() })}\n\n`);
         const dev = String(url.searchParams.get('d') || '').slice(0, 40), kind = url.searchParams.get('k') === 'phone' ? 'phone' : 'desktop';
         if (dev && kind === 'phone' && Date.now() - (seenDevices.get(dev) || 0) > 10 * 60 * 1000) {
           const data = `data: ${JSON.stringify({ type: 'device', device: dev, kind })}\n\n`;

package/src/usage.js

@@ -0,0 +1,79 @@
+'use strict';
+// Ús de la subscripció (finestra de 5 h i de la setmana). Claude el diu al flux (rate_limit_event);
+// Codex el desa als seus registres (~/.codex/sessions). No es llegeix cap clau ni cap compte.
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { HOME } = require('./config');
+
+const FILE = path.join(HOME, 'usage.json');
+const CODEX_DIR = path.join(os.homedir(), '.codex', 'sessions');
+const saved = {}; // agent -> { windows: [{ label, used, resetsAt }], at }
+try { Object.assign(saved, JSON.parse(fs.readFileSync(FILE, 'utf8'))); } catch { /* encara res */ }
+
+const LABELS = { five_hour: '5 h', seven_day: 'setmana' };
+const num = (v) => (typeof v === 'number' && Number.isFinite(v) ? v : null);
+const label = (min) => (min === 300 ? '5 h' : min === 10080 ? 'setmana' : min % 60 === 0 ? `${min / 60} h` : `${min} min`);
+
+// Claude: { unifiedWindows: { five_hour: { utilization: 0..1, resetsAt: segons }, seven_day: … } }
+function setClaude(info) {
+  const windows = [];
+  for (const [k, w] of Object.entries(info?.unifiedWindows || {})) {
+    const used = num(w?.utilization);
+    if (used === null || !LABELS[k]) continue;
+    windows.push({ label: LABELS[k], used: Math.min(1, Math.max(0, used)), resetsAt: num(w.resetsAt) });
+  }
+  if (!windows.length) return false;
+  windows.sort((a, b) => (a.label === '5 h' ? -1 : 1) - (b.label === '5 h' ? -1 : 1));
+  const prev = JSON.stringify(saved.claude?.windows);
+  saved.claude = { windows, at: Date.now() };
+  if (JSON.stringify(windows) === prev) return false;
+  fs.writeFile(FILE, JSON.stringify({ claude: saved.claude }), () => {});
+  return true;
+}
+
+// Codex: l'últim `token_count` de l'últim registre porta rate_limits.{primary,secondary}.
+const desc = (dir) => { try { return fs.readdirSync(dir).sort().reverse(); } catch { return []; } };
+function codexFiles(max = 3) {
+  const out = [];
+  for (const y of desc(CODEX_DIR)) for (const m of desc(path.join(CODEX_DIR, y))) for (const d of desc(path.join(CODEX_DIR, y, m))) {
+    for (const f of desc(path.join(CODEX_DIR, y, m, d))) { if (f.endsWith('.jsonl')) out.push(path.join(CODEX_DIR, y, m, d, f)); if (out.length >= max) return out; }
+  }
+  return out;
+}
+function tailLimits(file) {
+  let fd;
+  try {
+    fd = fs.openSync(file, 'r');
+    const size = fs.fstatSync(fd).size, len = Math.min(size, 256 * 1024), buf = Buffer.alloc(len);
+    fs.readSync(fd, buf, 0, len, size - len);
+    const lines = buf.toString('utf8').split('\n');
+    for (let i = lines.length - 1; i >= 0; i--) {
+      if (!lines[i].includes('"rate_limits"')) continue;
+      let o; try { o = JSON.parse(lines[i]); } catch { continue; }
+      const rl = o?.payload?.rate_limits; if (!rl) continue;
+      const windows = ['primary', 'secondary'].map((k) => rl[k]).filter(Boolean).map((w) => ({ label: label(w.window_minutes), used: Math.min(1, Math.max(0, (num(w.used_percent) || 0) / 100)), resetsAt: num(w.resets_at) }));
+      if (windows.length) return { windows, at: Date.parse(o.timestamp) || Date.now() };
+    }
+  } catch { /* sense registre */ } finally { if (fd !== undefined) fs.closeSync(fd); }
+  return null;
+}
+let codexCache = { t: 0, v: null };
+function codex() {
+  if (Date.now() - codexCache.t < 5000) return codexCache.v;
+  let v = null;
+  for (const f of codexFiles()) if ((v = tailLimits(f))) break;
+  codexCache = { t: Date.now(), v };
+  return v;
+}
+
+// Una finestra que ja s'ha reiniciat torna a 0 fins que l'agent n'informi de nou.
+const fresh = (u) => u && { windows: u.windows.map((w) => (w.resetsAt && w.resetsAt * 1000 <= Date.now() ? { label: w.label, used: 0, resetsAt: null } : w)), at: u.at };
+function all() {
+  const out = {}, c = fresh(saved.claude), x = fresh(codex());
+  if (c) out.claude = c;
+  if (x) out.codex = x;
+  return out;
+}
+
+module.exports = { setClaude, all };