nio-cat 0.5.1 → 0.6.1

package/src/jobs.js

@@ -0,0 +1,287 @@
+'use strict';
+// Orquestrador lleuger: cua de feines, cadenes i programació. No fa la feina: obre sessions de
+// Claude Code o Codex (via el hub) i les va seguint. Tot es desa a ~/.nio/jobs.json.
+//
+// Estats: pendent → en curs → feta | fallada (o cancel·lada).
+// · Cadena: `after` = id d'una altra feina. Comença quan aquella acaba bé (o sempre, amb `always`).
+//   El text «{{anterior}}» del missatge es canvia per l'última resposta de la feina anterior.
+// · Programació: `at` (una vegada) o `cron` (periòdica, 5 camps). Una programació periòdica és una
+//   plantilla: cada vegada que toca, crea una feina nova a la cua.
+// · Encaminament: amb agent «auto», la primera regla de cfg.routing que coincideix tria l'agent.
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const { HOME } = require('./config');
+
+const FILE = path.join(HOME, 'jobs.json');
+const ACTIVE = new Set(['pendent', 'en curs']);
+const rid = () => crypto.randomBytes(6).toString('base64url');
+const httpErr = (status, message) => Object.assign(new Error(message), { status });
+
+// ---------- cron (minut hora dia-del-mes mes dia-de-la-setmana)
+function field(spec, min, max) {
+  const out = new Set();
+  for (const part of String(spec).split(',')) {
+    const m = part.match(/^(\*|(\d+)(?:-(\d+))?)(?:\/(\d+))?$/);
+    if (!m) throw httpErr(400, `Programació no vàlida: «${part}»`);
+    let lo = m[1] === '*' ? min : Number(m[2]);
+    let hi = m[1] === '*' ? max : m[3] != null ? Number(m[3]) : m[4] ? max : lo;
+    const step = m[4] ? Number(m[4]) : 1;
+    if (lo < min || hi > max || lo > hi || step < 1) throw httpErr(400, `Programació fora de límits: «${part}»`);
+    for (let v = lo; v <= hi; v += step) out.add(v);
+  }
+  return out;
+}
+function parseCron(expr) {
+  const f = String(expr || '').trim().split(/\s+/);
+  if (f.length !== 5) throw httpErr(400, 'La programació ha de tenir 5 camps: minut hora dia mes dia-de-la-setmana');
+  const dow = field(f[4], 0, 7);
+  if (dow.has(7)) dow.add(0);
+  return { min: field(f[0], 0, 59), hour: field(f[1], 0, 23), dom: field(f[2], 1, 31), mon: field(f[3], 1, 12), dow, domAny: f[2] === '*', dowAny: f[4] === '*' };
+}
+// Pròxima hora (hora local de l'ordinador) estrictament posterior a `from`.
+function nextCron(expr, from = Date.now()) {
+  const c = typeof expr === 'string' ? parseCron(expr) : expr;
+  const d = new Date(from);
+  d.setSeconds(0, 0);
+  d.setMinutes(d.getMinutes() + 1);
+  for (let i = 0; i < 60 * 24 * 366; i++) {
+    const dayOk = c.domAny && c.dowAny ? true : c.domAny ? c.dow.has(d.getDay()) : c.dowAny ? c.dom.has(d.getDate()) : c.dom.has(d.getDate()) || c.dow.has(d.getDay());
+    if (!c.mon.has(d.getMonth() + 1) || !dayOk) { d.setHours(24, 0, 0, 0); continue; }
+    if (!c.hour.has(d.getHours())) { d.setHours(d.getHours() + 1, 0, 0, 0); continue; }
+    if (c.min.has(d.getMinutes())) return d.getTime();
+    d.setMinutes(d.getMinutes() + 1);
+  }
+  return null;
+}
+
+// ---------- encaminament
+function route(cfg, prompt, available) {
+  for (const r of cfg.routing || []) {
+    try {
+      if (r.agent && available.includes(r.agent) && new RegExp(r.match, 'i').test(prompt)) return { agent: r.agent, cwd: r.cwd, rule: r.match };
+    } catch {
+      /* regla mal escrita: la saltem */
+    }
+  }
+  const def = ['claude', 'codex'].find((a) => available.includes(a)) || available[0];
+  return { agent: def, rule: null };
+}
+
+class Jobs {
+  constructor({ cfg, hub, audit, available = () => ['claude', 'codex'], file = FILE }) {
+    this.cfg = cfg;
+    this.hub = hub;
+    this.audit = audit || { add() {} };
+    this.available = available;
+    this.file = file;
+    this.jobs = [];
+    try {
+      this.jobs = JSON.parse(fs.readFileSync(file, 'utf8'));
+    } catch {
+      /* primer cop */
+    }
+    // Si nio s'ha reiniciat amb feines en curs, la sessió ja no corre: les donem per fallades.
+    for (const j of this.jobs) if (j.state === 'en curs') this.finish(j, 'fallada', 'nio s’ha reiniciat mentre treballava', true);
+    hub.on('out', (m) => this.onHub(m));
+  }
+
+  save() {
+    const tmp = `${this.file}.tmp`;
+    fs.writeFileSync(tmp, JSON.stringify(this.jobs.slice(-500), null, 2), { mode: 0o600 });
+    fs.renameSync(tmp, this.file);
+  }
+
+  emit(j) {
+    this.hub.emit('out', { type: 'job', job: j });
+  }
+
+  list() {
+    return [...this.jobs].sort((a, b) => b.created - a.created);
+  }
+
+  get(id) {
+    return this.jobs.find((j) => j.id === id);
+  }
+
+  add(b) {
+    const prompt = String(b.prompt || '').trim();
+    if (!prompt) throw httpErr(400, 'Explica què ha de fer la feina');
+    const avail = this.available();
+    let agent = b.agent || 'auto', cwd = b.cwd, rule = null;
+    if (agent === 'auto') {
+      const r = route(this.cfg, prompt, avail);
+      agent = r.agent;
+      cwd = cwd || r.cwd;
+      rule = r.rule;
+    }
+    if (!['claude', 'codex', 'demo', 'grok', 'antigravity', 'ollama'].includes(agent)) throw httpErr(400, 'Tria Claude Code, Codex o «automàtic»');
+    if (!cwd) cwd = this.cfg.roots?.[0];
+    if (!cwd || !fs.existsSync(cwd)) throw httpErr(400, 'Aquesta carpeta no existeix');
+    if (b.after && !this.get(b.after)) throw httpErr(400, 'La feina anterior no existeix');
+    let at = b.at ? Number(new Date(b.at)) : null;
+    if (b.at && !Number.isFinite(at)) throw httpErr(400, 'La data no és vàlida');
+    if (b.cron) parseCron(b.cron);
+    const j = {
+      id: rid(),
+      title: String(b.title || prompt.replace(/\s+/g, ' ').slice(0, 70)),
+      prompt: prompt.slice(0, 20000),
+      agent,
+      cwd: path.resolve(cwd),
+      mode: ['llegir', 'preguntar', 'tot'].includes(b.mode) ? b.mode : 'preguntar',
+      model: String(b.model || '').slice(0, 80),
+      rule,
+      after: b.after || null,
+      always: !!b.always,
+      cron: b.cron || null,
+      state: b.cron ? 'programada' : 'pendent',
+      runAt: b.cron ? nextCron(b.cron) : at,
+      created: Date.now(),
+    };
+    this.jobs.push(j);
+    this.save();
+    this.emit(j);
+    this.audit.add({ type: 'job', what: `Feina ${j.cron ? 'programada' : 'a la cua'}: ${j.title}`, agent: j.agent, why: rule ? `Regla «${rule}»` : undefined, job: j.id });
+    this.tick();
+    return j;
+  }
+
+  cancel(id) {
+    const j = this.get(id);
+    if (!j) throw httpErr(404, 'Aquesta feina no existeix');
+    if (j.state === 'en curs' && j.session) this.hub.stop(j.session);
+    if (j.state === 'programada' || ACTIVE.has(j.state)) this.finish(j, 'cancel·lada', 'L’has cancel·lada');
+    return j;
+  }
+
+  remove(id) {
+    const j = this.get(id);
+    if (!j) throw httpErr(404, 'Aquesta feina no existeix');
+    if (ACTIVE.has(j.state) || j.state === 'programada') this.cancel(id);
+    this.jobs = this.jobs.filter((x) => x.id !== id);
+    this.save();
+    this.hub.emit('out', { type: 'job', removed: id });
+    return { ok: true };
+  }
+
+  runNow(id) {
+    const j = this.get(id);
+    if (!j) throw httpErr(404, 'Aquesta feina no existeix');
+    if (j.state === 'programada') return this.spawnFrom(j);
+    if (j.state !== 'pendent') throw httpErr(409, 'Aquesta feina ja ha començat');
+    j.runAt = null;
+    j.after = null;
+    this.tick();
+    return j;
+  }
+
+  // Una programació periòdica crea una feina nova cada vegada que toca.
+  spawnFrom(t) {
+    const j = { ...t, id: rid(), cron: null, from: t.id, state: 'pendent', runAt: null, created: Date.now() };
+    this.jobs.push(j);
+    this.emit(j);
+    this.save();
+    this.tick();
+    return j;
+  }
+
+  tick(now = Date.now()) {
+    let changed = false;
+    for (const t of this.jobs) {
+      if (t.state === 'programada' && t.runAt && t.runAt <= now) {
+        t.runAt = nextCron(t.cron, now);
+        t.lastFired = now;
+        this.spawnFrom(t);
+        changed = true;
+      }
+    }
+    const running = this.jobs.filter((j) => j.state === 'en curs').length;
+    let free = Math.max(0, (this.cfg.jobs?.max || 2) - running);
+    for (const j of this.jobs) {
+      if (j.state !== 'pendent' || free <= 0) continue;
+      if (j.runAt && j.runAt > now) continue;
+      if (j.after) {
+        const p = this.get(j.after);
+        if (!p || p.state === 'cancel·lada' || (p.state === 'fallada' && !j.always)) {
+          this.finish(j, 'cancel·lada', p ? `La feina anterior (${p.title}) no ha acabat bé` : 'La feina anterior ja no hi és');
+          changed = true;
+          continue;
+        }
+        if (p.state !== 'feta' && p.state !== 'fallada') continue;
+      }
+      this.start(j);
+      free--;
+      changed = true;
+    }
+    if (changed) this.save();
+  }
+
+  start(j) {
+    const prev = j.after ? this.get(j.after) : null;
+    const text = j.prompt.replace(/\{\{\s*anterior\s*\}\}/g, prev?.result || '(la feina anterior no ha deixat cap resposta)');
+    try {
+      const s = this.hub.create({ agent: j.agent, cwd: j.cwd, title: `⚙ ${j.title}`, mode: j.mode, model: j.model });
+      j.session = s.id;
+      j.state = 'en curs';
+      j.started = Date.now();
+      this.emit(j);
+      this.hub.send(s.id, text, this.hookUrl ? this.hookUrl() : undefined);
+    } catch (e) {
+      this.finish(j, 'fallada', e.message);
+    }
+  }
+
+  onHub(m) {
+    if (m.type !== 'event' || m.event?.kind !== 'status') return;
+    const j = this.jobs.find((x) => x.session === m.session && x.state === 'en curs');
+    if (!j || m.event.state === 'running') return;
+    const s = this.hub.get(m.session);
+    const last = s ? [...s.events].reverse().find((e) => e.kind === 'text') : null;
+    j.result = last ? String(last.text).slice(0, 8000) : '';
+    if (m.event.state === 'error') this.finish(j, 'fallada', s ? [...s.events].reverse().find((e) => e.kind === 'error')?.text : 'Error');
+    else if (m.event.code === 130 || m.event.code === 143) this.finish(j, 'cancel·lada', 'L’has aturat');
+    else this.finish(j, 'feta');
+    setImmediate(() => this.tick());
+  }
+
+  finish(j, state, error, quiet) {
+    j.state = state;
+    j.finished = Date.now();
+    if (error) j.error = String(error).slice(0, 500);
+    this.emit(j);
+    this.save();
+    if (quiet) return;
+    this.audit.add({ type: 'job', what: `${state === 'feta' ? 'Feina feta' : state === 'fallada' ? 'Feina fallada' : 'Feina cancel·lada'}: ${j.title}`, agent: j.agent, why: j.error, session: j.session, job: j.id });
+    if (state !== 'cancel·lada') this.hub.notice(this.hub.get(j.session), state === 'feta' ? 'Feina feta' : 'Una feina ha fallat', j.title, { job: j.id });
+  }
+
+  routes() {
+    return [
+      { method: 'GET', path: '/api/jobs', handler: () => ({ jobs: this.list(), routing: this.cfg.routing || [], max: this.cfg.jobs?.max || 2 }) },
+      { method: 'POST', path: '/api/jobs', handler: ({ body }) => this.add(body) },
+      { method: 'POST', path: /^\/api\/jobs\/([\w-]+)\/run$/, handler: ({ params }) => this.runNow(params[0]) },
+      { method: 'POST', path: /^\/api\/jobs\/([\w-]+)\/cancel$/, handler: ({ params }) => this.cancel(params[0]) },
+      { method: 'DELETE', path: /^\/api\/jobs\/([\w-]+)$/, handler: ({ params }) => this.remove(params[0]) },
+      {
+        method: 'PUT',
+        path: '/api/jobs/routing',
+        handler: ({ body }) => {
+          const rules = (Array.isArray(body.rules) ? body.rules : []).slice(0, 50).map((r) => ({ match: String(r.match || '').slice(0, 200), agent: String(r.agent || ''), cwd: r.cwd ? String(r.cwd) : undefined }));
+          for (const r of rules) {
+            try { new RegExp(r.match, 'i'); } catch { throw httpErr(400, `Regla no vàlida: «${r.match}»`); }
+          }
+          this.cfg.routing = rules;
+          require('./config').save(this.cfg);
+          return { routing: rules };
+        },
+      },
+    ];
+  }
+
+  startTimer() {
+    this.timer = setInterval(() => this.tick(), 15000);
+    this.timer.unref();
+  }
+}
+
+module.exports = { Jobs, parseCron, nextCron, route };

package/src/mcp.js

@@ -0,0 +1,142 @@
+'use strict';
+// Servidor MCP (stdio) de nio: la memòria compartida per a Claude Code i Codex.
+// Claude Code i Codex l'engeguen amb `nio mcp`; parla JSON-RPC 2.0, un missatge per línia.
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawnSync } = require('child_process');
+const memory = require('./memory');
+
+const TOOLS = [
+  {
+    name: 'memoria_llista',
+    description: 'Llista els fitxers de la memòria compartida de nio (markdown). Fes-la servir per saber què hi ha abans de llegir o escriure.',
+    inputSchema: { type: 'object', properties: {}, additionalProperties: false },
+    run: () => {
+      const files = memory.list();
+      return files.length ? files.map((f) => `${f.path}  (${f.size} B)`).join('\n') : 'La memòria és buida.';
+    },
+  },
+  {
+    name: 'memoria_llegeix',
+    description: 'Llegeix un fitxer de la memòria compartida, p. ex. «preferencies.md» o «projectes/web.md».',
+    inputSchema: { type: 'object', properties: { fitxer: { type: 'string', description: 'Ruta relativa, acabada en .md' } }, required: ['fitxer'], additionalProperties: false },
+    run: ({ fitxer }) => memory.read(fitxer).content,
+  },
+  {
+    name: 'memoria_cerca',
+    description: 'Busca text a tota la memòria compartida (no distingeix majúscules ni accents). Retorna fitxer, línia i text.',
+    inputSchema: { type: 'object', properties: { text: { type: 'string' } }, required: ['text'], additionalProperties: false },
+    run: ({ text }) => {
+      const hits = memory.search(text);
+      return hits.length ? hits.map((h) => `${h.path}:${h.line}: ${h.text}`).join('\n') : 'Cap resultat.';
+    },
+  },
+  {
+    name: 'memoria_escriu',
+    description: 'Desa informació útil per a més endavant a la memòria compartida (la llegiran també els altres agents). Per defecte afegeix al final; amb mode «substitueix» reescriu el fitxer sencer. Desa-hi fets durables (preferències, decisions, context de projectes), no converses.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        fitxer: { type: 'string', description: 'Ruta relativa acabada en .md, p. ex. «projectes/botiga.md»' },
+        text: { type: 'string' },
+        mode: { type: 'string', enum: ['afegeix', 'substitueix'], default: 'afegeix' },
+      },
+      required: ['fitxer', 'text'],
+      additionalProperties: false,
+    },
+    run: ({ fitxer, text, mode }) => {
+      const r = memory.write(fitxer, text, { append: mode !== 'substitueix' });
+      return `Desat a ${r.path} (${r.size} B).`;
+    },
+  },
+];
+
+function serve({ input = process.stdin, output = process.stdout } = {}) {
+  const send = (msg) => output.write(`${JSON.stringify({ jsonrpc: '2.0', ...msg })}\n`);
+  const handle = (msg) => {
+    const { id, method, params } = msg;
+    const reply = (result) => id !== undefined && send({ id, result });
+    const fail = (code, message) => id !== undefined && send({ id, error: { code, message } });
+    switch (method) {
+      case 'initialize':
+        return reply({
+          protocolVersion: params?.protocolVersion || '2025-06-18',
+          capabilities: { tools: {} },
+          serverInfo: { name: 'nio', version: require('../package.json').version },
+          instructions: 'Memòria compartida de nio (fitxers markdown en aquest ordinador). Consulta-la a l’inici d’una tasca (memoria_cerca o memoria_llegeix preferencies.md) i desa-hi el que valgui la pena recordar.',
+        });
+      case 'ping':
+        return reply({});
+      case 'tools/list':
+        return reply({ tools: TOOLS.map(({ run, ...t }) => t) });
+      case 'tools/call': {
+        const tool = TOOLS.find((t) => t.name === params?.name);
+        if (!tool) return fail(-32602, `Eina desconeguda: ${params?.name}`);
+        try {
+          return reply({ content: [{ type: 'text', text: String(tool.run(params.arguments || {})) }] });
+        } catch (e) {
+          return reply({ content: [{ type: 'text', text: e.message }], isError: true });
+        }
+      }
+      default:
+        if (method && method.startsWith('notifications/')) return undefined;
+        return fail(-32601, `Mètode desconegut: ${method}`);
+    }
+  };
+  let buf = '';
+  input.setEncoding('utf8');
+  input.on('data', (d) => {
+    buf += d;
+    let i;
+    while ((i = buf.indexOf('\n')) >= 0) {
+      const line = buf.slice(0, i).trim();
+      buf = buf.slice(i + 1);
+      if (!line) continue;
+      let msg;
+      try {
+        msg = JSON.parse(line);
+      } catch {
+        send({ id: null, error: { code: -32700, message: 'JSON no vàlid' } });
+        continue;
+      }
+      for (const m of Array.isArray(msg) ? msg : [msg]) handle(m);
+    }
+  });
+}
+
+// ---------- registre a Claude Code i Codex (un sol cop, sense duplicar)
+function command() {
+  const entry = fs.realpathSync(path.join(__dirname, '..', 'bin', 'nio.js'));
+  return { cmd: process.execPath, args: [entry, 'mcp'], unstable: entry.includes(`${path.sep}_npx${path.sep}`) };
+}
+
+function registerClaude(bin, { force } = {}) {
+  if (!bin) return 'Claude Code no hi és';
+  const { cmd, args } = command();
+  if (!force && spawnSync(bin, ['mcp', 'get', 'nio'], { encoding: 'utf8', timeout: 15000 }).status === 0) return 'ja hi era';
+  spawnSync(bin, ['mcp', 'remove', '--scope', 'user', 'nio'], { timeout: 15000 });
+  const env = process.env.NIO_HOME ? ['-e', `NIO_HOME=${process.env.NIO_HOME}`] : [];
+  const r = spawnSync(bin, ['mcp', 'add', 'nio', '--scope', 'user', ...env, '--', cmd, ...args], { encoding: 'utf8', timeout: 15000 });
+  return r.status === 0 ? 'afegit' : `no s’ha pogut afegir: ${(r.stderr || r.stdout || '').trim().split('\n').pop()}`;
+}
+
+function registerCodex() {
+  const dir = path.join(process.env.CODEX_HOME || path.join(os.homedir(), '.codex'));
+  const file = path.join(dir, 'config.toml');
+  let txt = '';
+  try {
+    txt = fs.readFileSync(file, 'utf8');
+  } catch {
+    /* encara no hi és */
+  }
+  if (/^\s*\[mcp_servers\.nio\]/m.test(txt)) return 'ja hi era';
+  const { cmd, args } = command();
+  const q = (s) => JSON.stringify(s);
+  const block = `\n# Memòria compartida de nio (afegit per nio; ho pots treure quan vulguis)\n[mcp_servers.nio]\ncommand = ${q(cmd)}\nargs = [${args.map(q).join(', ')}]\n${process.env.NIO_HOME ? `env = { NIO_HOME = ${q(process.env.NIO_HOME)} }\n` : ''}`;
+  fs.mkdirSync(dir, { recursive: true });
+  fs.appendFileSync(file, `${txt && !txt.endsWith('\n') ? '\n' : ''}${block}`);
+  return 'afegit';
+}
+
+module.exports = { serve, TOOLS, registerClaude, registerCodex, command };

package/src/memory.js

@@ -0,0 +1,131 @@
+'use strict';
+// Memòria compartida: fitxers markdown a ~/.nio/memory, només en aquest ordinador.
+// Claude Code i Codex hi accedeixen pel servidor MCP de nio (`nio mcp`), i tu des de l'app.
+const fs = require('fs');
+const path = require('path');
+const { HOME } = require('./config');
+
+const DIR = process.env.NIO_MEMORY || path.join(HOME, 'memory');
+const MAX = 512 * 1024; // mida màxima d'un fitxer
+
+const SEED = {
+  'LLEGEIX-ME.md': `# Memòria de nio
+
+Aquesta carpeta és la memòria que comparteixen els teus agents (Claude Code i Codex) en aquest ordinador.
+Són fitxers markdown normals: els pots editar aquí, des de l'app (Memòria) o amb qualsevol editor.
+
+- \`preferencies.md\`: com t'agrada treballar (idioma, estil, eines…).
+- \`projectes/\`: un fitxer per projecte, amb context que val la pena recordar.
+- \`persones/\`: gent amb qui treballes i el que cal saber-ne.
+
+nio no envia mai aquests fitxers enlloc.
+`,
+  'preferencies.md': '# Preferències\n\n- Respon en català.\n',
+  'projectes/.keep': '',
+  'persones/.keep': '',
+};
+
+function httpErr(status, message) {
+  return Object.assign(new Error(message), { status });
+}
+
+function ensure() {
+  if (fs.existsSync(DIR)) return;
+  fs.mkdirSync(DIR, { recursive: true, mode: 0o700 });
+  for (const [rel, txt] of Object.entries(SEED)) {
+    const f = path.join(DIR, rel);
+    fs.mkdirSync(path.dirname(f), { recursive: true });
+    fs.writeFileSync(f, txt);
+  }
+}
+
+// Ruta relativa segura: només .md dins de la carpeta de memòria, sense «..» ni fitxers ocults.
+function safe(rel) {
+  const r = String(rel || '').replace(/\\/g, '/').trim();
+  if (!r || r.length > 200) throw httpErr(400, 'Falta el nom del fitxer');
+  if (r.startsWith('/')) throw httpErr(400, 'Fes servir una ruta relativa a la memòria');
+  const parts = r.split('/');
+  if (parts.some((p) => !p || p === '.' || p === '..' || p.startsWith('.'))) throw httpErr(400, 'Aquest nom de fitxer no és vàlid');
+  if (!/\.md$/i.test(r)) throw httpErr(400, 'Els fitxers de memòria han d’acabar en .md');
+  if (!/^[\p{L}\p{N} _.,()'’-]+$/u.test(parts.join(''))) throw httpErr(400, 'Fes servir lletres, xifres, espais, guions i punts');
+  const abs = path.resolve(DIR, r);
+  if (!abs.startsWith(path.resolve(DIR) + path.sep)) throw httpErr(400, 'Aquest nom de fitxer no és vàlid');
+  return { rel: parts.join('/'), abs };
+}
+
+function list() {
+  ensure();
+  const out = [];
+  const walk = (dir, pre) => {
+    for (const e of fs.readdirSync(dir, { withFileTypes: true })) {
+      if (e.name.startsWith('.')) continue;
+      const rel = pre ? `${pre}/${e.name}` : e.name;
+      const abs = path.join(dir, e.name);
+      if (e.isDirectory()) walk(abs, rel);
+      else if (e.isFile() && /\.md$/i.test(e.name)) {
+        const st = fs.statSync(abs);
+        out.push({ path: rel, size: st.size, updated: st.mtimeMs });
+      }
+    }
+  };
+  walk(DIR, '');
+  return out.sort((a, b) => a.path.localeCompare(b.path, 'ca'));
+}
+
+function read(rel) {
+  ensure();
+  const { rel: r, abs } = safe(rel);
+  if (!fs.existsSync(abs)) throw httpErr(404, `No hi ha cap fitxer «${r}» a la memòria`);
+  return { path: r, content: fs.readFileSync(abs, 'utf8'), updated: fs.statSync(abs).mtimeMs };
+}
+
+function write(rel, content, { append = false } = {}) {
+  ensure();
+  const { rel: r, abs } = safe(rel);
+  const text = String(content ?? '');
+  const prev = append && fs.existsSync(abs) ? fs.readFileSync(abs, 'utf8') : '';
+  const next = append ? `${prev}${prev && !prev.endsWith('\n') ? '\n' : ''}${text}` : text;
+  if (Buffer.byteLength(next) > MAX) throw httpErr(413, 'El fitxer seria massa gran (màxim 512 kB)');
+  fs.mkdirSync(path.dirname(abs), { recursive: true, mode: 0o700 });
+  fs.writeFileSync(abs, next.endsWith('\n') ? next : `${next}\n`, { mode: 0o600 });
+  return { path: r, size: Buffer.byteLength(next) };
+}
+
+function remove(rel) {
+  ensure();
+  const { rel: r, abs } = safe(rel);
+  if (!fs.existsSync(abs)) throw httpErr(404, `No hi ha cap fitxer «${r}» a la memòria`);
+  fs.rmSync(abs);
+  return { path: r };
+}
+
+// Cerca de text (sense majúscules ni accents) amb la línia on surt.
+function search(q, limit = 40) {
+  const norm = (s) => String(s).toLowerCase().normalize('NFD').replace(/[̀-ͯ]/g, '');
+  const terms = norm(q).split(/\s+/).filter(Boolean);
+  if (!terms.length) throw httpErr(400, 'Escriu què vols buscar');
+  const hits = [];
+  for (const f of list()) {
+    const lines = fs.readFileSync(path.join(DIR, f.path), 'utf8').split('\n');
+    const nameHit = terms.every((t) => norm(f.path).includes(t));
+    lines.forEach((line, i) => {
+      if (hits.length >= limit) return;
+      const n = norm(line);
+      if (terms.every((t) => n.includes(t)) || (nameHit && i === 0)) hits.push({ path: f.path, line: i + 1, text: line.slice(0, 300) });
+    });
+  }
+  return hits;
+}
+
+function routes() {
+  const wrap = (fn) => fn;
+  return [
+    { method: 'GET', path: '/api/memory', handler: wrap(() => ({ dir: DIR, files: list() })) },
+    { method: 'GET', path: '/api/memory/search', handler: wrap(({ url }) => search(url.searchParams.get('q') || '')) },
+    { method: 'GET', path: /^\/api\/memory\/f\/(.+)$/, handler: wrap(({ params }) => read(params[0])) },
+    { method: 'PUT', path: /^\/api\/memory\/f\/(.+)$/, limit: MAX + 4096, handler: wrap(({ params, body }) => write(params[0], body.content)) },
+    { method: 'DELETE', path: /^\/api\/memory\/f\/(.+)$/, handler: wrap(({ params }) => remove(params[0])) },
+  ];
+}
+
+module.exports = { DIR, ensure, safe, list, read, write, remove, search, routes };

package/src/proc.js

@@ -141,4 +141,4 @@ function tryJson(line) {
   }
 }
 
-module.exports = { which, version, run, childEnv, tryJson, stripAnsi };
+module.exports = { which, version, run, childEnv, tryJson, stripAnsi, searchPath, shQuote };

package/src/push.js

@@ -1,12 +1,14 @@
 'use strict';
-// Web Push sense dependències ni servidors de tercers: només VAPID.
-// Enviem pushes buits (sense payload xifrat); el service worker del mòbil
-// demana els detalls directament a aquest daemon.
+// Web Push sense dependències ni servidors de tercers: VAPID (RFC 8292) i, si el navegador
+// ens ha donat les claus de la subscripció, contingut xifrat de punta a punta (RFC 8291,
+// aes128gcm). El servei de push d'Apple o Google només veu bytes xifrats.
+// Sense claus (subscripcions antigues), s'envia un avís buit i el service worker
+// demana el detall directament a aquest ordinador.
 const crypto = require('crypto');
 
-function b64(buf) {
-  return Buffer.from(buf).toString('base64url');
-}
+const b64 = (buf) => Buffer.from(buf).toString('base64url');
+const unb64 = (s) => Buffer.from(String(s || ''), 'base64url');
+const hmac = (key, data) => crypto.createHmac('sha256', key).update(data).digest();
 
 function vapidHeader(vapid, endpoint) {
   const aud = new URL(endpoint).origin;
@@ -20,21 +22,53 @@ function vapidHeader(vapid, endpoint) {
   return `vapid t=${data}.${b64(sig)}, k=${vapid.publicKey}`;
 }
 
-// Envia un push a totes les subscripcions. Retorna les que ja no són vàlides.
-async function notifyAll(cfg) {
+// RFC 8291. `test` permet fixar la clau efímera i la sal per comprovar-ho amb els vectors de l'RFC.
+function encrypt(payload, { p256dh, auth }, test = {}) {
+  const uaPublic = unb64(p256dh);
+  const authSecret = unb64(auth);
+  if (uaPublic.length !== 65 || authSecret.length !== 16) throw new Error('Claus de subscripció no vàlides');
+  const ecdh = crypto.createECDH('prime256v1');
+  if (test.privateKey) ecdh.setPrivateKey(unb64(test.privateKey));
+  else ecdh.generateKeys();
+  const asPublic = ecdh.getPublicKey();
+  const shared = ecdh.computeSecret(uaPublic);
+  const salt = test.salt ? unb64(test.salt) : crypto.randomBytes(16);
+
+  const prkKey = hmac(authSecret, shared);
+  const keyInfo = Buffer.concat([Buffer.from('WebPush: info\0'), uaPublic, asPublic, Buffer.from([1])]);
+  const ikm = hmac(prkKey, keyInfo);
+  const prk = hmac(salt, ikm);
+  const cek = hmac(prk, Buffer.from('Content-Encoding: aes128gcm\0\x01')).subarray(0, 16);
+  const nonce = hmac(prk, Buffer.from('Content-Encoding: nonce\0\x01')).subarray(0, 12);
+
+  const plain = Buffer.concat([Buffer.from(payload), Buffer.from([2])]); // un sol registre, sense farciment
+  const cipher = crypto.createCipheriv('aes-128-gcm', cek, nonce);
+  const body = Buffer.concat([cipher.update(plain), cipher.final(), cipher.getAuthTag()]);
+  const rs = Buffer.alloc(4);
+  rs.writeUInt32BE(4096);
+  return Buffer.concat([salt, rs, Buffer.from([asPublic.length]), asPublic, body]);
+}
+
+// Envia l'avís a totes les subscripcions. Retorna els endpoints que ja no són vàlids.
+async function notifyAll(cfg, message) {
   const dead = [];
+  const json = message ? JSON.stringify(message).slice(0, 3000) : null;
   await Promise.all(
     (cfg.pushSubs || []).map(async (sub) => {
       try {
-        const res = await fetch(sub.endpoint, {
-          method: 'POST',
-          headers: {
-            Authorization: vapidHeader(cfg.vapid, sub.endpoint),
-            TTL: '3600',
-            Urgency: 'high',
-            'Content-Length': '0',
-          },
-        });
+        const headers = {
+          Authorization: vapidHeader(cfg.vapid, sub.endpoint),
+          TTL: '3600',
+          Urgency: 'high',
+        };
+        let body = null;
+        if (json && sub.keys?.p256dh && sub.keys?.auth) {
+          body = encrypt(json, sub.keys);
+          headers['Content-Encoding'] = 'aes128gcm';
+          headers['Content-Type'] = 'application/octet-stream';
+        }
+        headers['Content-Length'] = String(body ? body.length : 0);
+        const res = await fetch(sub.endpoint, { method: 'POST', headers, body });
         if (res.status === 404 || res.status === 410) dead.push(sub.endpoint);
       } catch {
         /* sense xarxa: ho tornarem a provar al següent avís */
@@ -44,4 +78,4 @@ async function notifyAll(cfg) {
   return dead;
 }
 
-module.exports = { notifyAll, vapidHeader };
+module.exports = { notifyAll, vapidHeader, encrypt };