nio-cat 0.9.7 → 0.9.9

package/bin/nio.js

@@ -7,7 +7,7 @@ const crypto = require('crypto');
 const { spawn } = require('child_process');
 const config = require('../src/config');
 const { Hub } = require('../src/hub');
-const { createServer } = require('../src/server');
+const { createServer, listProjects } = require('../src/server');
 const { detectAll } = require('../src/agents');
 const { startTunnel, startNamedTunnel, startConfiguredTunnel, setupNamedTunnel } = require('../src/tunnel');
 const service = require('../src/service');
@@ -15,6 +15,7 @@ const { Auth } = require('../src/auth');
 const { Audit } = require('../src/audit');
 const memory = require('../src/memory');
 const { Notes } = require('../src/notes');
+const { Call } = require('../src/call');
 const mcp = require('../src/mcp');
 const directory = require('../src/directory');
 const voice = require('../src/voice');
@@ -215,7 +216,8 @@ async function start() {
   const control = new Control({ cfg, hub, audit });
   const remote = new Remote({ cfg, audit });
   const notes = new Notes({ cfg, hub });
-  const routes = [...memory.routes(), ...notes.routes(), ...jobs.routes(), ...voice.routes(cfg), ...tg.routes(), ...control.routes(), ...remote.routes()];
+  const call = new Call({ cfg, hub, audit, projects: () => listProjects(cfg), hookUrl: jobs.hookUrl, terminal: () => require('../src/terminal').listSessions(require('../src/agents').binPath(cfg, 'claude'), require('../src/proc').childEnv()) });
+  const routes = [...memory.routes(), ...notes.routes(), ...call.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) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nio-cat",
-  "version": "0.9.7",
+  "version": "0.9.9",
   "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

@@ -17,6 +17,8 @@ module.exports = {
     const { session, prompt, cfg } = ctx;
     const args = ['-p', prompt, '--output-format', 'stream-json', '--verbose', '--include-partial-messages'];
     if (session.nativeId) args.push('--resume', session.nativeId);
+    // Conversa del terminal: el primer missatge en fa una branca; després ja continua la pròpia.
+    if (session.nativeId && session.forkNative) { args.push('--fork-session'); delete session.forkNative; }
     if (session.model) args.push('--model', session.model);
 
     if (session.mode === 'tot' && process.getuid?.() === 0) {

package/src/call.js

@@ -0,0 +1,246 @@
+'use strict';
+// Trucada amb en Nio: una conversa de veu en temps real amb un agent d'ElevenLabs (Agents Platform).
+// · La clau d'ElevenLabs es queda en aquest ordinador: el mòbil només rep un URL signat que caduca.
+// · L'agent es crea sol al compte de l'usuari la primera vegada (i es refà si en canviem la definició).
+// · A cada trucada li passem l'estat d'aquest ordinador (agents, sessions, aprovacions) i unes eines
+//   que el navegador reenvia aquí: llegir una sessió, encarregar feina, enviar un missatge o aprovar.
+const os = require('os');
+const path = require('path');
+const config = require('./config');
+const { describe } = require('./hub');
+
+const API = 'https://api.elevenlabs.io/v1/convai';
+const AGENT_V = 1; // puja'l quan canviïn les eines o la configuració de l'agent
+const httpErr = (status, message) => Object.assign(new Error(message), { status });
+const clip = (s, n) => { s = String(s || '').replace(/\s+/g, ' ').trim(); return s.length > n ? `${s.slice(0, n - 1)}…` : s; };
+// «Café» → «cafe»: per trobar carpetes i sessions dites de paraula.
+const norm = (s) => String(s || '').normalize('NFD').replace(/[\u0300-\u036f]/g, '').toLowerCase().replace(/[^a-z0-9]+/g, ' ').trim();
+const ago = (t) => {
+  const m = Math.round((Date.now() - t) / 60000);
+  if (m < 1) return 'ara mateix';
+  if (m < 60) return `fa ${m} minut${m > 1 ? 's' : ''}`;
+  const h = Math.round(m / 60);
+  return h < 24 ? `fa ${h} hor${h > 1 ? 'es' : 'a'}` : `fa ${Math.round(h / 24)} dies`;
+};
+
+const TOOLS = [
+  { type: 'client', name: 'estat', description: 'Torna l’estat actual de l’ordinador: agents instal·lats, sessions i com van, aprovacions pendents i carpetes. Fes-la servir quan et preguntin com va tot o abans de respondre sobre una cosa que pot haver canviat.', expects_response: true, parameters: { type: 'object', properties: {} } },
+  { type: 'client', name: 'llegeix_sessio', description: 'Llegeix els últims missatges d’una sessió per explicar què ha fet o què diu l’agent.', expects_response: true, parameters: { type: 'object', properties: { sessio: { type: 'string', description: 'Títol, carpeta o agent de la sessió, tal com l’ha dit la persona.' } }, required: ['sessio'] } },
+  { type: 'client', name: 'nova_sessio', description: 'Encarrega una feina nova a un agent en una carpeta. Abans de cridar-la, repeteix agent, carpeta i tasca i espera que la persona digui que sí.', expects_response: true, parameters: { type: 'object', properties: { agent: { type: 'string', description: 'Agent: claude, codex, grok, antigravity o ollama.' }, carpeta: { type: 'string', description: 'Nom de la carpeta del projecte.' }, tasca: { type: 'string', description: 'La instrucció completa per a l’agent, ben redactada.' } }, required: ['agent', 'carpeta', 'tasca'] } },
+  { type: 'client', name: 'envia_missatge', description: 'Envia un missatge a una sessió que ja existeix (per continuar la feina). Confirma el text abans d’enviar-lo.', expects_response: true, parameters: { type: 'object', properties: { sessio: { type: 'string', description: 'Títol, carpeta o agent de la sessió.' }, text: { type: 'string', description: 'El missatge per a l’agent.' } }, required: ['sessio', 'text'] } },
+  { type: 'client', name: 'decideix_aprovacio', description: 'Aprova o rebutja una acció que un agent espera. Explica abans què vol fer l’agent i demana confirmació explícita.', expects_response: true, parameters: { type: 'object', properties: { decisio: { type: 'string', enum: ['aprova', 'rebutja'], description: 'aprova o rebutja' }, quina: { type: 'string', description: 'Si n’hi ha més d’una: l’agent, la carpeta o l’acció.' } }, required: ['decisio'] } },
+  { type: 'client', name: 'penja', description: 'Acaba la trucada quan la persona s’acomiada o diu que ja està.', expects_response: false, parameters: { type: 'object', properties: {} } },
+];
+
+const PROMPT = (ctx) => `Ets en Nio, l’assistent de veu de nio. Parles per telèfon amb la persona que fa servir nio: des del mòbil controla els agents d’IA del seu ordinador (Claude Code, Codex…).
+
+Com parles:
+- Sempre en català col·loquial i proper, amb frases curtes. Una o dues frases per torn, tres com a molt.
+- És una trucada: res de Markdown, llistes, emojis, rutes ni identificadors. Els noms de carpeta, dits com a paraules.
+- Si hi ha moltes coses, diu les dues o tres més importants i pregunta si en vol més.
+- No t’inventis res: si no ho saps, fes servir les eines.
+
+Què pots fer:
+- Explicar quins agents té, com van les sessions i què espera aprovació (eina «estat» per tenir-ho al dia, «llegeix_sessio» per als detalls).
+- Encarregar feina nova («nova_sessio»), continuar una sessió («envia_missatge») i aprovar o rebutjar accions («decideix_aprovacio»). Abans de fer qualsevol d’aquestes tres, repeteix en una frase què faràs i espera un sí clar.
+- Quan s’acomiadi, acomiada’t breument i fes servir «penja».
+
+Mentre dura la trucada et poden arribar avisos de context (una sessió acaba, un agent demana permís): explica’ls breument quan sigui oportú.
+
+Estat de l’ordinador ara mateix:
+${ctx}`;
+
+class Call {
+  constructor({ cfg, hub, audit, projects, hookUrl, terminal }) {
+    Object.assign(this, { cfg, hub, audit: audit || { add() {} }, projects, hookUrl, terminal });
+  }
+
+  key() { return this.cfg.voice?.keys?.elevenlabs || ''; }
+  status() { return { ready: !!this.key(), provider: 'elevenlabs', agent: !!this.cfg.voice?.call?.agentId }; }
+
+  async el(method, p, body) {
+    const r = await fetch(`${API}${p}`, { method, headers: { 'xi-api-key': this.key(), ...(body ? { 'content-type': 'application/json' } : {}) }, body: body ? JSON.stringify(body) : undefined, signal: AbortSignal.timeout(20000) });
+    const t = await r.text();
+    let j = null; try { j = JSON.parse(t); } catch { /* text */ }
+    if (!r.ok) {
+      const d = j?.detail;
+      const msg = (typeof d === 'string' ? d : d?.message || (Array.isArray(d) ? d.map((x) => x.msg).join('; ') : '') || j?.message || t || `Error ${r.status}`);
+      throw Object.assign(httpErr(r.status === 401 ? 400 : 502, `ElevenLabs: ${clip(msg, 220)}`), { upstream: r.status });
+    }
+    return j;
+  }
+
+  // L'agent viu al compte d'ElevenLabs de l'usuari. Si no hi és (o és d'una versió antiga), se'n fa un de nou.
+  async ensureAgent() {
+    const c = this.cfg.voice.call || {};
+    if (c.agentId && c.v === AGENT_V) return c;
+    if (c.agentId) this.el('DELETE', `/agents/${c.agentId}`).catch(() => {});
+    const overrides = { conversation_config_override: { agent: { prompt: { prompt: true }, first_message: true, language: true }, tts: { voice_id: true } } };
+    const make = (lang, model, tools) => ({
+      name: `nio · ${os.hostname()}`,
+      conversation_config: {
+        agent: { first_message: 'Hola!', language: lang, prompt: { prompt: 'Ets en Nio, l’assistent de veu de nio.', ...(tools ? { tools: TOOLS } : {}) } },
+        ...(model ? { tts: { model_id: model } } : {}),
+        conversation: { max_duration_seconds: 1200 },
+      },
+      platform_settings: { overrides },
+    });
+    // De més a menys exigent: si el compte o l'API no accepten alguna part, es prova sense.
+    const tries = [['ca', 'eleven_flash_v2_5', true], ['ca', null, true], ['es', 'eleven_flash_v2_5', true], ['ca', null, false], ['en', null, false]];
+    let last;
+    for (const [lang, model, tools] of tries) {
+      try {
+        const r = await this.el('POST', '/agents/create', make(lang, model, tools));
+        this.cfg.voice.call = { agentId: r.agent_id, v: AGENT_V, lang, tools };
+        config.save(this.cfg);
+        this.audit.add({ type: 'call', what: `Agent de veu creat a ElevenLabs (${lang}${tools ? '' : ', sense eines'})` });
+        return this.cfg.voice.call;
+      } catch (e) {
+        last = e;
+        if (e.upstream === 401 || e.upstream === 403) break; // clau dolenta o sense permís: no cal insistir
+      }
+    }
+    throw last.upstream === 401 ? httpErr(400, 'La clau d’ElevenLabs no és vàlida. Canvia-la a Ajustos → Veu.') : last;
+  }
+
+  // ---------------------------------------------------------------- què li expliquem
+  async snapshot() {
+    const { detectAll } = require('./agents');
+    const agents = (await detectAll(this.cfg).catch(() => [])).filter((a) => a.available && a.id !== 'demo');
+    const sessions = this.hub.list();
+    const approvals = this.hub.pendingApprovals();
+    let projects = [];
+    try { projects = this.projects().filter((p) => !p.root).map((p) => p.name); } catch { /* sense carpetes */ }
+    let term = [];
+    try { term = await this.terminal?.(); } catch { /* sense terminal */ }
+    return { agents, sessions, approvals, projects, term: term || [] };
+  }
+  stateLabel(s) {
+    if (s.pending || s.state === 'waiting') return 'espera el teu permís';
+    if (s.state === 'running') return 'treballant';
+    if (s.state === 'error') return `ha fallat${s.error ? ` (${clip(s.error, 80)})` : ''}`;
+    return `acabada ${ago(s.updated)}`;
+  }
+  agentName(id) { return require('./agents').byId?.[id]?.name || { claude: 'Claude Code', codex: 'Codex' }[id] || id; }
+  contextText(snap) {
+    const L = [];
+    L.push(`Ordinador: ${os.hostname()}.`);
+    L.push(snap.agents.length ? `Agents instal·lats: ${snap.agents.map((a) => a.name).join(', ')}.` : 'No hi ha cap agent instal·lat.');
+    const recent = snap.sessions.filter((s) => Date.now() - s.updated < 3 * 864e5 || s.state === 'running' || s.pending).slice(0, 10);
+    const running = snap.sessions.filter((s) => s.state === 'running').length;
+    L.push(`Sessions: ${snap.sessions.length} en total, ${running} treballant ara.`);
+    for (const s of recent) L.push(`- «${clip(s.title || 'sense títol', 70)}», ${this.agentName(s.agent)} a la carpeta ${path.basename(s.cwd)}: ${this.stateLabel(s)}.${s.last ? ` Últim: ${clip(s.last, 140)}` : ''}`);
+    if (snap.approvals.length) {
+      L.push(`Aprovacions pendents: ${snap.approvals.length}.`);
+      for (const a of snap.approvals.slice(0, 5)) L.push(`- ${a.agent ? this.agentName(a.agent) : 'Un agent'}${a.title ? ` («${clip(a.title, 50)}»)` : ''} vol ${clip(`${a.tool}: ${describe(a.tool, a.input)}`, 160)}.`);
+    } else L.push('Cap aprovació pendent.');
+    if (snap.term.length) L.push(`Al terminal hi ha ${snap.term.length} Claude Code obert${snap.term.length > 1 ? 's' : ''}: ${snap.term.slice(0, 4).map((t) => `«${clip(t.title || t.name || path.basename(t.cwd), 50)}» (${t.status === 'busy' ? 'treballant' : 'esperant'})`).join(', ')}.`);
+    if (snap.projects.length) L.push(`Carpetes de projectes: ${snap.projects.slice(0, 40).join(', ')}.`);
+    return L.join('\n');
+  }
+  greeting(snap) {
+    const n = snap.agents.map((a) => a.name);
+    const list = n.length > 1 ? `${n.slice(0, -1).join(', ')} i ${n[n.length - 1]}` : n[0];
+    const running = snap.sessions.filter((s) => s.state === 'running').length, ap = snap.approvals.length;
+    let s = `Hola! Sóc en Nio, et parlo des de l’ordinador ${os.hostname()}. ${n.length ? `Tens ${list}.` : 'Encara no tens cap agent instal·lat.'}`;
+    if (ap) s += ` ${ap === 1 ? 'Hi ha una acció' : `Hi ha ${ap} accions`} esperant el teu permís.`;
+    else if (running) s += ` ${running === 1 ? 'Una sessió està treballant' : `${running} sessions estan treballant`} ara mateix.`;
+    return `${s} Què vols fer?`;
+  }
+
+  async start() {
+    if (!this.key()) throw httpErr(400, 'Per trucar cal una clau d’ElevenLabs. Posa-la a Ajustos → Veu.');
+    this.cfg.voice = this.cfg.voice || {};
+    let a = await this.ensureAgent();
+    const url = async () => (await this.el('GET', `/conversation/get-signed-url?agent_id=${encodeURIComponent(a.agentId)}`)).signed_url;
+    let signed;
+    try { signed = await url(); } catch (e) {
+      if (e.upstream !== 404) throw e;
+      delete this.cfg.voice.call; a = await this.ensureAgent(); signed = await url(); // l'han esborrat al seu tauler
+    }
+    const snap = await this.snapshot();
+    const voiceId = this.cfg.voice.voice?.elevenlabs?.voice;
+    const agentOv = { prompt: { prompt: PROMPT(this.contextText(snap)) }, first_message: this.greeting(snap) };
+    if (a.lang === 'ca') agentOv.language = 'ca';
+    this.audit.add({ type: 'call', what: 'Trucada amb en Nio' });
+    return {
+      signedUrl: signed,
+      tools: !!a.tools,
+      host: os.hostname(),
+      init: { type: 'conversation_initiation_client_data', conversation_config_override: { agent: agentOv, ...(voiceId ? { tts: { voice_id: voiceId } } : {}) } },
+    };
+  }
+
+  // ---------------------------------------------------------------- eines (les crida el navegador)
+  findSession(q) {
+    const list = this.hub.list(), w = norm(q);
+    if (!list.length) return null;
+    if (!w) return list[0];
+    const score = (s) => {
+      const hay = `${norm(s.title)} ${norm(path.basename(s.cwd))} ${norm(this.agentName(s.agent))} ${norm(s.agent)}`;
+      return w.split(' ').filter((t) => t.length > 1 && hay.includes(t)).length * 10 + (s.state === 'running' || s.pending ? 2 : 0);
+    };
+    const best = list.map((s) => [score(s), s]).sort((a, b) => b[0] - a[0] || b[1].updated - a[1].updated)[0];
+    return best[0] > 0 ? best[1] : null;
+  }
+  findFolder(q) {
+    const list = this.projects(), w = norm(q);
+    const exact = list.find((p) => norm(p.name) === w);
+    if (exact) return exact.path;
+    const part = list.filter((p) => !p.root && (norm(p.name).includes(w) || w.includes(norm(p.name)))).sort((a, b) => a.name.length - b.name.length)[0];
+    return part?.path || null;
+  }
+  async tool(name, p = {}) {
+    if (name === 'estat') return this.contextText(await this.snapshot());
+    if (name === 'llegeix_sessio') {
+      const s = this.findSession(p.sessio);
+      if (!s) return 'No he trobat cap sessió amb aquest nom.';
+      const full = this.hub.get(s.id);
+      const msgs = full.events.filter((e) => e.kind === 'user' || e.kind === 'text' || e.kind === 'error').slice(-6)
+        .map((e) => `${e.kind === 'user' ? 'Persona' : e.kind === 'error' ? 'Error' : this.agentName(s.agent)}: ${clip(e.text, 500)}`);
+      return `Sessió «${s.title || 'sense títol'}», ${this.agentName(s.agent)} a ${path.basename(s.cwd)}, ${this.stateLabel(s)}.\n${msgs.join('\n') || 'Encara no hi ha missatges.'}`;
+    }
+    if (name === 'nova_sessio') {
+      const { detectAll } = require('./agents');
+      const avail = (await detectAll(this.cfg)).filter((a) => a.available && a.id !== 'demo');
+      const wa = norm(p.agent);
+      const agent = avail.find((a) => a.id === wa || norm(a.name).includes(wa) || wa.includes(a.id)) || (wa ? null : avail[0]);
+      if (!agent) return `No tinc l’agent «${p.agent}». Hi ha: ${avail.map((a) => a.name).join(', ')}.`;
+      const cwd = this.findFolder(p.carpeta);
+      if (!cwd) return `No trobo la carpeta «${p.carpeta}». Pregunta-li quina és de les que hi ha.`;
+      const task = String(p.tasca || '').trim();
+      if (!task) return 'Falta la tasca.';
+      const s = this.hub.create({ agent: agent.id, cwd, mode: 'preguntar' });
+      this.hub.send(s.id, task, this.hookUrl());
+      this.audit.add({ type: 'call', what: `Feina encarregada per veu a ${agent.name} (${path.basename(cwd)})` });
+      return `Fet: ${agent.name} ja treballa a ${path.basename(cwd)}, amb permisos de «demana permís».`;
+    }
+    if (name === 'envia_missatge') {
+      const s = this.findSession(p.sessio);
+      if (!s) return 'No he trobat aquesta sessió.';
+      try { this.hub.send(s.id, String(p.text || ''), this.hookUrl()); } catch (e) { return `No s’ha pogut enviar: ${e.message}`; }
+      return `Enviat a «${s.title || path.basename(s.cwd)}». ${this.agentName(s.agent)} s’hi posa.`;
+    }
+    if (name === 'decideix_aprovacio') {
+      const list = this.hub.pendingApprovals();
+      if (!list.length) return 'No hi ha cap aprovació pendent.';
+      const w = norm(p.quina);
+      const a = list.length === 1 || !w ? list[0] : list.find((x) => `${norm(x.title)} ${norm(x.agent)} ${norm(x.tool)} ${norm(describe(x.tool, x.input))}`.includes(w)) || null;
+      if (!a) return 'N’hi ha més d’una: pregunta quina.';
+      const allow = p.decisio === 'aprova';
+      this.hub.decide(a.id, allow ? 'allow' : 'deny', allow ? '' : 'Rebutjat per veu', 'Trucada');
+      return allow ? `Aprovat: ${clip(describe(a.tool, a.input), 100)}.` : 'Rebutjat.';
+    }
+    return `No conec l’eina «${name}».`;
+  }
+
+  routes() {
+    return [
+      { method: 'GET', path: '/api/call', handler: () => this.status() },
+      { method: 'POST', path: '/api/call/start', handler: () => this.start() },
+      { method: 'POST', path: '/api/call/tool', handler: async ({ body }) => ({ result: await this.tool(String(body?.name || ''), body?.parameters || {}) }) },
+    ];
+  }
+}
+
+module.exports = { Call, TOOLS, norm, AGENT_V };

package/src/hub.js

@@ -76,6 +76,8 @@ class Hub extends EventEmitter {
       last: lastText ? clip(lastText.text, 160) : '',
       error: s.state === 'error' ? clip([...s.events].reverse().find((e) => e.kind === 'error')?.text || '', 200) : '',
       pending: [...this.approvals.values()].filter((a) => a.session === s.id && a.state === 'pending').length,
+      nativeId: s.nativeId || null,
+      fromTerminal: s.fromTerminal || null,
     };
   }
 
@@ -161,6 +163,25 @@ class Hub extends EventEmitter {
     return s;
   }
 
+  // Continua una conversa de Claude Code oberta al terminal: n'importa els últims missatges i,
+  // la primera vegada en fa una branca (--fork-session) perquè el terminal i el mòbil no escriguin al mateix fitxer.
+  resumeTerminal(s, nativeId) {
+    const term = require('./terminal');
+    s.nativeId = nativeId; s.fromTerminal = nativeId;
+    const file = term.findTranscript(nativeId, s.cwd);
+    if (file) {
+      const { title, msgs } = term.readTranscript(file);
+      if (title && !s.title) s.title = title;
+      const keep = msgs.slice(-40);
+      if (msgs.length > keep.length) this.push(s, 'info', { text: `${msgs.length - keep.length} missatges anteriors al terminal` });
+      for (const m of keep) this.push(s, m.role === 'user' ? 'user' : 'text', { text: m.text.length > 20000 ? `${m.text.slice(0, 20000)}…` : m.text, t: m.t || Date.now() });
+    }
+    s.forkNative = true;
+    this.push(s, 'info', { text: file ? 'Continua la conversa del terminal. El terminal no es toca: el que facis aquí va per una branca pròpia.' : 'Continua la conversa del terminal.' });
+    this.persist(s);
+    return s;
+  }
+
   remove(sid) {
     this.stop(sid);
     this.sessions.delete(sid);

package/src/server.js

@@ -311,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);
     }
@@ -515,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 };