nio-cat 0.9.6 → 0.9.9

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/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',
@@ -294,12 +311,19 @@ function createServer({ cfg, hub, auth, audit, getPublicUrl, getApp, routes = []
       return r;
     }
 
+    if (p === '/api/claude-sessions' && method === 'GET') {
+      const { binPath } = require('./agents');
+      const { childEnv } = require('./proc');
+      return { sessions: await require('./terminal').listSessions(binPath(cfg, 'claude'), childEnv()) };
+    }
+
     if (p === '/api/sessions' && method === 'GET') return hub.list();
     if (p === '/api/sessions' && method === 'POST') {
       const b = await readBody(req);
       const cwd = path.resolve(b.cwd || cfg.roots[0]);
       if (!isDir(cwd)) throw httpErr(400, 'Aquesta carpeta no existeix');
       const s = hub.create({ agent: b.agent, cwd, title: b.title, mode: b.mode, model: b.model });
+      if (b.resumeId) hub.resumeTerminal(s, String(b.resumeId));
       if (b.text) hub.send(s.id, b.text, hookUrl());
       return hub.summary(s);
     }
@@ -453,7 +477,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`;
@@ -498,4 +522,4 @@ function createServer({ cfg, hub, auth, audit, getPublicUrl, getApp, routes = []
   return server;
 }
 
-module.exports = { createServer, originAllowed, readBody };
+module.exports = { createServer, originAllowed, readBody, listProjects };

package/src/terminal.js

@@ -0,0 +1,147 @@
+'use strict';
+// Sessions de Claude Code obertes al terminal: quines hi ha, en quin terminal corren
+// i què s'hi ha dit, per poder-les continuar des del mòbil.
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { execFile } = require('child_process');
+
+const exec = (bin, args, opts = {}) => new Promise((resolve) => {
+  execFile(bin, args, { timeout: 8000, maxBuffer: 4 << 20, ...opts }, (err, out) => resolve(err && !out ? '' : String(out || '')));
+});
+
+const alive = (pid) => { try { process.kill(pid, 0); return true; } catch (e) { return e.code === 'EPERM'; } };
+
+// ---------------------------------------------------------------- en quin terminal corre
+const PROGRAMS = {
+  Apple_Terminal: 'Terminal', 'iTerm.app': 'iTerm', vscode: 'VS Code', WarpTerminal: 'Warp', ghostty: 'Ghostty',
+  WezTerm: 'WezTerm', Hyper: 'Hyper', Tabby: 'Tabby', 'rio': 'Rio', zed: 'Zed', kitty: 'kitty', alacritty: 'Alacritty',
+};
+// Noms de procés (pares) que delaten el terminal quan l'entorn no ho diu.
+const PARENTS = [
+  [/^(Cursor|cursor)/, 'Cursor'], [/Code Helper|^code$|\/code$/, 'VS Code'], [/iTerm/, 'iTerm'], [/^Terminal$|Terminal\.app/, 'Terminal'],
+  [/[Ww]arp/, 'Warp'], [/ghostty/i, 'Ghostty'], [/wezterm/i, 'WezTerm'], [/kitty/, 'kitty'], [/alacritty/i, 'Alacritty'],
+  [/gnome-terminal/, 'GNOME Terminal'], [/konsole/, 'Konsole'], [/xfce4-terminal/, 'Xfce Terminal'], [/tilix/, 'Tilix'],
+  [/terminator/, 'Terminator'], [/xterm/, 'xterm'], [/foot$/, 'foot'], [/^zed|Zed/, 'Zed'], [/idea|pycharm|webstorm|goland|jetbrains/i, 'JetBrains'],
+];
+
+async function procEnv(pid) {
+  if (process.platform === 'linux') {
+    try { return Object.fromEntries(fs.readFileSync(`/proc/${pid}/environ`, 'utf8').split('\0').filter(Boolean).map((l) => { const i = l.indexOf('='); return [l.slice(0, i), l.slice(i + 1)]; })); } catch { return {}; }
+  }
+  if (process.platform === 'darwin') {
+    // `ps eww` afegeix l'entorn a l'ordre (només per a processos del mateix usuari).
+    const out = await exec('ps', ['eww', '-o', 'command=', '-p', String(pid)]);
+    const env = {};
+    for (const m of out.matchAll(/(?:^|\s)([A-Z_][A-Z0-9_]*)=(\S*)/g)) env[m[1]] = m[2];
+    return env;
+  }
+  return {};
+}
+async function parents(pid) {
+  const names = [];
+  for (let p = pid, i = 0; p > 1 && i < 12; i++) {
+    let ppid = 0, comm = '';
+    if (process.platform === 'linux') {
+      try {
+        const st = fs.readFileSync(`/proc/${p}/stat`, 'utf8'), close = st.lastIndexOf(')');
+        comm = st.slice(st.indexOf('(') + 1, close); ppid = Number(st.slice(close + 2).split(' ')[1]);
+      } catch { break; }
+    } else {
+      const out = (await exec('ps', ['-o', 'ppid=,comm=', '-p', String(p)])).trim();
+      const m = out.match(/^(\d+)\s+(.*)$/); if (!m) break;
+      ppid = Number(m[1]); comm = m[2];
+    }
+    if (p !== pid) names.push(comm);
+    p = ppid;
+  }
+  return names;
+}
+async function detectTerminal(pid) {
+  const env = await procEnv(pid), chain = await parents(pid);
+  let app = '';
+  if (env.CURSOR_TRACE_ID || chain.some((c) => /Cursor/i.test(c))) app = 'Cursor';
+  else if (env.TERM_PROGRAM && PROGRAMS[env.TERM_PROGRAM]) app = PROGRAMS[env.TERM_PROGRAM];
+  else if (env.TERMINAL_EMULATOR?.includes('JetBrains')) app = 'JetBrains';
+  else if (env.KITTY_WINDOW_ID) app = 'kitty';
+  else if (env.ALACRITTY_WINDOW_ID || env.ALACRITTY_SOCKET) app = 'Alacritty';
+  else if (env.WT_SESSION) app = 'Windows Terminal';
+  else if (env.TERM_PROGRAM && env.TERM_PROGRAM !== 'tmux') app = env.TERM_PROGRAM;
+  if (!app) for (const c of chain) { const hit = PARENTS.find(([re]) => re.test(c)); if (hit) { app = hit[1]; break; } }
+  const tmux = !!env.TMUX || chain.some((c) => /^tmux/.test(c)), screen = !!env.STY;
+  const ssh = !!(env.SSH_CONNECTION || env.SSH_TTY) || chain.some((c) => /sshd/.test(c));
+  return { app: app || (ssh ? 'SSH' : 'Terminal'), tmux, screen, ssh: ssh && app !== 'SSH' };
+}
+
+// ---------------------------------------------------------------- què s'hi ha dit
+const projDir = (cwd) => path.join(os.homedir(), '.claude', 'projects', String(cwd || '').replace(/[^a-zA-Z0-9]/g, '-'));
+function findTranscript(id, cwd) {
+  const direct = path.join(projDir(cwd), `${id}.jsonl`);
+  if (fs.existsSync(direct)) return direct;
+  try {
+    const base = path.join(os.homedir(), '.claude', 'projects');
+    for (const d of fs.readdirSync(base)) { const f = path.join(base, d, `${id}.jsonl`); if (fs.existsSync(f)) return f; }
+  } catch { /* sense carpeta */ }
+  return null;
+}
+// Llegeix només el final del fitxer: les converses llargues pesen megues.
+function tailLines(file, bytes) {
+  let fd;
+  try {
+    fd = fs.openSync(file, 'r');
+    const size = fs.fstatSync(fd).size, start = Math.max(0, size - bytes), buf = Buffer.alloc(size - start);
+    fs.readSync(fd, buf, 0, buf.length, start);
+    const lines = buf.toString('utf8').split('\n');
+    if (start > 0) lines.shift();
+    return lines.filter(Boolean);
+  } catch { return []; } finally { if (fd !== undefined) fs.closeSync(fd); }
+}
+const clean = (t) => String(t || '').replace(/<system-reminder>[\s\S]*?<\/system-reminder>/g, '').trim();
+// Missatges de la conversa (persona i Claude), sense metadades, ordres locals ni resultats d'eines.
+function readTranscript(file, bytes = 3 << 20) {
+  const msgs = []; let title = '', prompt = '';
+  for (const l of tailLines(file, bytes)) {
+    let d; try { d = JSON.parse(l); } catch { continue; }
+    if (d.type === 'ai-title' && (d.aiTitle || d.title)) title = d.aiTitle || d.title;
+    else if (d.type === 'custom-title' && d.customTitle) title = d.customTitle;
+    else if (d.type === 'last-prompt' && d.lastPrompt) prompt = d.lastPrompt;
+    else if (d.type === 'summary' && d.summary && !title) title = d.summary;
+    if (d.isMeta || d.isSidechain || (d.type !== 'user' && d.type !== 'assistant')) continue;
+    const c = d.message?.content, t = Date.parse(d.timestamp) || 0;
+    if (d.type === 'user') {
+      const text = clean(typeof c === 'string' ? c : Array.isArray(c) ? c.filter((b) => b.type === 'text').map((b) => b.text).join('\n') : '');
+      if (text && !text.startsWith('<')) msgs.push({ role: 'user', text, t });
+    } else if (Array.isArray(c)) {
+      const text = clean(c.filter((b) => b.type === 'text').map((b) => b.text).join('\n\n'));
+      if (!text) continue;
+      const last = msgs[msgs.length - 1];
+      if (last?.role === 'assistant') { last.text += `\n\n${text}`; last.t = t; } else msgs.push({ role: 'assistant', text, t });
+    }
+  }
+  return { title, msgs, prompt };
+}
+
+// ---------------------------------------------------------------- llista
+async function listSessions(bin, env) {
+  if (!bin) return [];
+  let list;
+  try { list = JSON.parse(await exec(bin, ['agents', '--json'], { env })); } catch { return []; }
+  if (!Array.isArray(list)) return [];
+  const out = [];
+  for (const s of list) {
+    if (!s?.sessionId || (s.pid && !alive(s.pid))) continue;
+    const file = findTranscript(s.sessionId, s.cwd);
+    const tr = file ? readTranscript(file, 512 << 10) : { title: '', msgs: [], prompt: '' };
+    const lastUser = [...tr.msgs].reverse().find((m) => m.role === 'user'), last = tr.msgs[tr.msgs.length - 1];
+    out.push({
+      sessionId: s.sessionId, pid: s.pid || null, cwd: s.cwd || '', kind: s.kind || 'interactive', status: s.status || 'idle',
+      name: s.name || '', title: tr.title || '', startedAt: s.startedAt || null, updated: last?.t || s.startedAt || null,
+      ask: (lastUser?.text || tr.prompt).slice(0, 200), last: last ? last.text.slice(0, 200) : '',
+      terminal: s.kind === 'background' ? { app: 'En segon pla' } : s.pid ? await detectTerminal(s.pid) : { app: 'Terminal' },
+      transcript: !!file,
+    });
+  }
+  return out.sort((a, b) => (b.status === 'busy') - (a.status === 'busy') || (b.updated || 0) - (a.updated || 0));
+}
+
+module.exports = { listSessions, readTranscript, findTranscript, detectTerminal, alive };

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 };