nio-cat 0.6.1 → 0.8.1

package/README.md

@@ -1,14 +1,47 @@
 # nio
 
-Fes servir els agents d’IA del teu ordinador (Claude Code, Codex, Grok, Antigravity i Ollama) des del mòbil. Segueix-los en directe i aprova cada acció.
+Els teus agents (Claude Code i Codex) als teus ordinadors, controlats des del mòbil. Personal i gratuït: fas servir els teus comptes i les teves claus.
+
+## Instal·lació (una ordre)
 
 ```sh
-npx nio-cat
+curl -fsSL https://www.nio.cat/install.sh | sh
 ```
 
-Executa-ho a la carpeta dels teus projectes i escaneja el codi QR que apareix amb la càmera del mòbil.
+Instal·la nio i `cloudflared` al teu usuari, el deixa com a servei (systemd o launchd) i mostra un codi QR. Escaneja’l amb el mòbil a [nio.cat/app](https://www.nio.cat/app). Per provar-lo sense instal·lar res: `npx nio-cat`.
+
+## Què fa
+
+- **Sessions** de Claude Code i Codex en directe, a qualsevol dels teus ordinadors.
+- **Aprovacions** amb el motiu, al mòbil, al push o a Telegram, i **registre** de totes les accions (`~/.nio/audit.jsonl`).
+- **Feines**: cua, cadenes («quan acabi, que Codex ho revisi») i programació (cron).
+- **Memòria compartida** a `~/.nio/memory`, amb un servidor MCP (`nio mcp`) registrat a Claude Code i Codex.
+- **Telegram** (el teu bot) i **veu** (ElevenLabs o OpenAI), amb les claus a l’ordinador.
+- **Navegador i escriptori** amb agent-browser i agent-desktop: mirar passa sol, actuar sempre demana permís.
+
+## Arquitectura
+
+```
+ Mòbil (nio.cat/app) ──┐            Telegram (long polling, sortida)
+                       ▼                         │
+  nio.cat: l’app i l’adreça signada de cada ordinador (res més)
+                       │
+      túnel de Cloudflare (ràpid, o amb nom: nio tunnel setup)
+                       ▼
+  ┌──────────── nio, a cada ordinador ────────────┐
+  │ agents: Claude Code · Codex (· altres)        │
+  │ aprovacions · registre · avisos (Web Push)    │
+  │ feines: cua · cadenes · cron · regles         │
+  │ memòria ~/.nio/memory + servidor MCP          │
+  │ veu · Telegram · agent-browser/agent-desktop  │
+  └───────────────────────────────────────────────┘
+```
+
+- Cada mòbil s’aparella amb un codi d’un sol ús i en rep una clau pròpia, revocable (`nio devices`).
+- Si el túnel canvia d’adreça, el mòbil la retroba a nio.cat, signada amb la clau Ed25519 de l’ordinador.
+
+## Ordres
 
-- Sense `cloudflared`, et connectes per la wifi de casa.
-- Amb `cloudflared` (a macOS: `brew install cloudflared`), des de qualsevol lloc.
+`nio [carpetes…]` · `nio pair` · `nio devices` · `nio service install` · `nio tunnel setup <host>` · `nio memory` · `nio directory on|off` · `nio doctor` · `nio help`
 
-Opcions: `npx nio-cat help`. Més informació a [nio.cat](https://www.nio.cat).
+Privadesa: [nio.cat/privadesa](https://www.nio.cat/privadesa) · Contacte: hola@nio.cat · nio // un projecte de [f.cat](https://f.cat)

package/bin/nio.js

@@ -16,6 +16,9 @@ const { Audit } = require('../src/audit');
 const memory = require('../src/memory');
 const mcp = require('../src/mcp');
 const directory = require('../src/directory');
+const voice = require('../src/voice');
+const { Telegram } = require('../src/telegram');
+const { Control } = require('../src/control');
 const { Jobs } = require('../src/jobs');
 const { addServer } = require('../src/ssh');
 const { pairLink, terminalQr, writePairPage, makeCode, codeLink, terminalQrSize } = require('../src/pair');
@@ -208,8 +211,13 @@ async function start() {
   const jobs = new Jobs({ cfg, hub, audit, available: () => require('../src/agents').AGENTS.filter((a) => a.id === 'demo' || require('../src/agents').binPath(cfg, a.id)).map((a) => a.id) });
   jobs.hookUrl = () => `http://127.0.0.1:${cfg.port}/internal/approval`;
   jobs.startTimer();
-  const routes = [...memory.routes(), ...jobs.routes()];
-  const server = createServer({ cfg, hub, auth, audit, routes, getPublicUrl: () => publicUrl, getApp: () => flags.app || cfg.app });
+  const tg = new Telegram({ cfg, hub, audit, available: jobs.available });
+  tg.hookUrl = jobs.hookUrl;
+  tg.start();
+  if (cfg.telegram?.token) console.log(`  ${c.dim('Telegram:')} actiu ${c.dim(`(${(cfg.telegram.allowed || []).length} xats autoritzats)`)}`);
+  const control = new Control({ cfg, hub, audit });
+  const routes = [...memory.routes(), ...jobs.routes(), ...voice.routes(cfg), ...tg.routes(), ...control.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) => {
     if (e.code === 'EADDRINUSE') console.error(c.warn(`\n  El port ${cfg.port} ja el fa servir un altre programa. Tria\'n un altre: nio --port 7718\n`));

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "nio-cat",
-  "version": "0.6.1",
+  "version": "0.8.1",
   "description": "nio: fes servir Claude Code, Codex, Grok, Antigravity i Ollama del teu ordinador des del mòbil.",
-  "license": "MIT",
+  "license": "UNLICENSED",
   "author": "f.cat",
   "homepage": "https://www.nio.cat",
   "bin": {

package/src/agents/claude.js

@@ -25,10 +25,18 @@ module.exports = {
     }
 
     const env = {};
+    const gate = (extra = {}) => {
+      // Hook PreToolUse: envia al mòbil el que cal aprovar.
+      args.push('--settings', JSON.stringify({ hooks: { PreToolUse: [{ matcher: '*', hooks: [{ type: 'command', command: `node "${HOOK}"`, timeout: 900 }] }] } }));
+      Object.assign(env, { NIO_HOOK_URL: ctx.hook.url, NIO_HOOK_KEY: ctx.hook.key, NIO_SESSION: session.id }, extra);
+    };
+    const control = cfg.control?.navegador || cfg.control?.escriptori;
     if (session.mode === 'llegir') {
       args.push('--permission-mode', 'plan');
     } else if (session.mode === 'tot') {
       args.push('--permission-mode', 'bypassPermissions');
+      // Amb el control del navegador o l'escriptori actiu, les ordres que hi actuen sempre es pregunten.
+      if (control) gate({ NIO_GATE: 'tot' });
     } else {
       // "preguntar": el hook envia cada acció que no sigui de lectura al mòbil.
       const settings = {

package/src/claude-hook.js

@@ -30,7 +30,13 @@ process.stdin.on('end', async () => {
     /* entrada buida */
   }
   const tool = input.tool_name || 'Eina';
+  // Navegador i escriptori (agent-browser, agent-desktop): mirar passa sol; actuar sempre demana permís,
+  // fins i tot en «Via lliure» (NIO_GATE=tot), on la resta d'eines passen soles.
+  let c = null;
+  try { c = tool === 'Bash' ? require('./control').classify(input.tool_input?.command) : null; } catch { c = null; }
+  if (process.env.NIO_GATE === 'tot' && !(c && c.act)) return reply('allow', 'nio: via lliure');
   if (READ_ONLY.has(tool)) return reply('allow', 'nio: només llegeix');
+  if (c && !c.act) return reply('allow', `nio: ${c.tool} només mira`);
 
   const url = process.env.NIO_HOOK_URL;
   if (!url) return reply('deny', 'nio no està configurat en aquesta sessió');

package/src/control.js

@@ -0,0 +1,238 @@
+'use strict';
+// Control del navegador i de l'escriptori. nio no el construeix: Claude Code i Codex fan servir
+// agent-browser (web) i agent-desktop (apps) per shell. nio s'encarrega de:
+// · saber què hi ha instal·lat i activar-ho per ordinador (desactivat per defecte),
+// · posar les guies oficials a l'abast dels agents (skill de Claude Code i AGENTS.md de Codex),
+// · classificar les ordres: les de mirar passen soles; les que actuen demanen aprovació (amb captura),
+// · fer captures sota demanda i l'aturada d'emergència.
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const crypto = require('crypto');
+const { execFile } = require('child_process');
+const { which, childEnv } = require('./proc');
+const config = require('./config');
+const { HOME } = config;
+
+const SHOTS = path.join(HOME, 'shots');
+const httpErr = (status, message) => Object.assign(new Error(message), { status });
+
+// Subordres que només miren. Qualsevol altra cosa actua (clicar, escriure, omplir, pujar fitxers…).
+const READ = {
+  'agent-browser': new Set(['snapshot', 'screenshot', 'status', 'wait', 'open', 'goto', 'navigate', 'get', 'is', 'skills', 'help', '--help', 'version', '--version', 'tabs', 'title', 'url']),
+  'agent-desktop': new Set(['snapshot', 'find', 'get', 'is', 'screenshot', 'list-surfaces', 'list-apps', 'list-windows', 'list-displays', 'list-notifications', 'status', 'version', 'skills', 'wait', 'permissions', 'help', '--help', '--version']),
+};
+const KIND = { 'agent-browser': 'navegador', 'agent-desktop': 'escriptori' };
+const META = /[;&|`$<>(){}\n\r\\]/; // res de redireccions, subordres ni cadenes
+
+// Classifica una ordre de shell. null si no és d'aquestes eines (o si és composta: llavors no ens en refiem).
+function classify(command) {
+  const cmd = String(command || '').trim();
+  const m = cmd.match(/^(?:npx\s+(?:-y\s+)?)?(agent-browser|agent-desktop)(?:\s+(.*))?$/s);
+  if (!m) {
+    const k = cmd.match(/\b(agent-browser|agent-desktop)\b/);
+    return k ? { tool: k[1], kind: KIND[k[1]], act: true, composite: true } : null;
+  }
+  const tool = m[1];
+  const rest = (m[2] || '').trim();
+  if (META.test(rest)) return { tool, kind: KIND[tool], act: true, composite: true };
+  // Saltem opcions globals (--session x, --headed…) per trobar la subordre.
+  const words = rest.match(/"[^"]*"|'[^']*'|\S+/g) || [];
+  let i = 0;
+  while (i < words.length && words[i].startsWith('-') && !READ[tool].has(words[i])) i += /^--(session|session-name|profile|state|executable-path|app|window-id)$/.test(words[i]) ? 2 : 1;
+  const sub = words[i] || 'help';
+  let read = READ[tool].has(sub);
+  if (tool === 'agent-browser' && sub === 'stream') read = words[i + 1] === 'status';
+  return { tool, kind: KIND[tool], sub, act: !read };
+}
+
+function run(bin, args, timeout = 15000) {
+  return new Promise((resolve) => {
+    execFile(bin, args, { timeout, env: childEnv(), maxBuffer: 8 * 1024 * 1024 }, (err, stdout, stderr) => resolve({ ok: !err, out: String(stdout || ''), err: String(stderr || err?.message || '') }));
+  });
+}
+
+class Control {
+  constructor({ cfg, hub, audit }) {
+    this.cfg = cfg;
+    this.hub = hub;
+    this.audit = audit || { add() {} };
+    this.capsAt = 0;
+    fs.mkdirSync(SHOTS, { recursive: true, mode: 0o700 });
+  }
+
+  enabled(kind) {
+    return !!this.cfg.control?.[kind];
+  }
+  any() {
+    return this.enabled('navegador') || this.enabled('escriptori');
+  }
+
+  async caps(force) {
+    if (!force && this.capsCache && Date.now() - this.capsAt < 60000) return this.capsCache;
+    const ab = which('agent-browser'), ad = which('agent-desktop');
+    let desk = { installed: !!ad, ready: false, why: ad ? '' : 'No hi és' };
+    if (ad) {
+      const r = await run(ad, ['status'], 8000);
+      let j = null;
+      try { j = JSON.parse(r.out); } catch { /* text */ }
+      desk.ready = j ? j.ok !== false : r.ok;
+      desk.why = desk.ready ? '' : (j?.error?.message || r.err || r.out).split('\n')[0].slice(0, 200);
+    }
+    const shotTool = process.platform === 'darwin' ? which('screencapture') : which('grim') || which('scrot') || which('gnome-screenshot');
+    this.capsCache = {
+      navegador: { installed: !!ab, ready: !!ab, enabled: this.enabled('navegador') },
+      escriptori: { ...desk, enabled: this.enabled('escriptori'), screenshot: !!shotTool },
+      platform: process.platform,
+    };
+    this.capsAt = Date.now();
+    return this.capsCache;
+  }
+
+  // ---------- guies per als agents
+  async installGuides(kind) {
+    const tool = kind === 'navegador' ? 'agent-browser' : 'agent-desktop';
+    const bin = which(tool);
+    if (!bin) throw httpErr(400, `${tool} no està instal·lat en aquest ordinador`);
+    const parts = [];
+    const tries = kind === 'navegador' ? [['skills', 'get', 'core'], ['skills', 'get', 'agent-browser']] : [['skills', 'get', 'desktop'], ['skills', 'get', 'platform']];
+    for (const args of tries) {
+      const r = await run(bin, args, 20000);
+      if (r.ok && r.out.trim()) {
+        parts.push(r.out.trim().replace(/^---[\s\S]*?\n---\s*/, ''));
+        if (kind === 'navegador') break;
+      }
+    }
+    if (!parts.length) parts.push(`Fes servir \`${tool}\`. Abans de començar, executa \`${tool} skills get ${kind === 'navegador' ? 'core' : 'desktop'}\` i segueix-ne les instruccions.`);
+    const rules = `## Normes de nio (obligatòries)
+
+- Cada ordre de \`${tool}\` que actua (clicar, escriure, omplir, pujar fitxers, enviar formularis…) l'ha d'aprovar la persona des del mòbil. Les de mirar (snapshot, screenshot, status, wait, open) passen soles.
+- Mai no facis compres, pagaments, transferències, canvis de contrasenya ni esborrats sense que la persona t'ho hagi demanat explícitament i ho aprovi.
+- No escriguis contrasenyes ni dades de targetes. Si cal iniciar sessió, demana-ho.
+- Executa \`${tool}\` sempre com a ordre sola (sense \`&&\`, \`|\`, \`;\` ni redireccions), una per pas, perquè nio la pugui revisar.`;
+    const title = kind === 'navegador' ? 'Navegador web (agent-browser)' : 'Apps de l’escriptori (agent-desktop)';
+    const body = `# ${title}\n\n${rules}\n\n${parts.join('\n\n')}\n`;
+    const name = `nio-${kind}`;
+    // Claude Code: skill d'usuari.
+    const sdir = path.join(os.homedir(), '.claude', 'skills', name);
+    fs.mkdirSync(sdir, { recursive: true });
+    fs.writeFileSync(path.join(sdir, 'SKILL.md'), `---\nname: ${name}\ndescription: Controla ${kind === 'navegador' ? 'el navegador web' : 'les apps de l’escriptori'} d'aquest ordinador amb ${tool}, amb les normes d'aprovació de nio. Fes-la servir quan calgui ${kind === 'navegador' ? 'obrir webs, llegir-les o actuar-hi' : 'mirar o fer servir apps de l’ordinador'}.\n---\n\n${body}`);
+    // Codex: bloc dins de ~/.codex/AGENTS.md entre marques (es reescriu, no es duplica).
+    const cdir = process.env.CODEX_HOME || path.join(os.homedir(), '.codex');
+    const af = path.join(cdir, 'AGENTS.md');
+    let txt = '';
+    try { txt = fs.readFileSync(af, 'utf8'); } catch { /* nou */ }
+    const start = `<!-- nio:${kind} -->`, end = `<!-- /nio:${kind} -->`;
+    const block = `${start}\n${body}${end}`;
+    const re = new RegExp(`${start}[\\s\\S]*?${end}`);
+    txt = re.test(txt) ? txt.replace(re, block) : `${txt}${txt && !txt.endsWith('\n') ? '\n' : ''}\n${block}\n`;
+    fs.mkdirSync(cdir, { recursive: true });
+    fs.writeFileSync(af, txt);
+    return { claude: path.join(sdir, 'SKILL.md'), codex: af };
+  }
+
+  removeGuides(kind) {
+    fs.rmSync(path.join(os.homedir(), '.claude', 'skills', `nio-${kind}`), { recursive: true, force: true });
+    const af = path.join(process.env.CODEX_HOME || path.join(os.homedir(), '.codex'), 'AGENTS.md');
+    try {
+      const txt = fs.readFileSync(af, 'utf8').replace(new RegExp(`\\n?<!-- nio:${kind} -->[\\s\\S]*?<!-- /nio:${kind} -->\\n?`), '\n');
+      fs.writeFileSync(af, txt);
+    } catch { /* no hi era */ }
+  }
+
+  // ---------- captures
+  shotPath(id) {
+    if (!/^[\w-]{8,40}$/.test(String(id))) throw httpErr(400, 'Captura no vàlida');
+    return path.join(SHOTS, `${id}.png`);
+  }
+  async screenshot(prefer) {
+    const id = `${Date.now().toString(36)}-${crypto.randomBytes(4).toString('hex')}`;
+    const file = this.shotPath(id);
+    let ok = false, from = null;
+    const browser = which('agent-browser');
+    if ((prefer !== 'escriptori') && this.enabled('navegador') && browser) {
+      ok = (await run(browser, ['screenshot', file], 15000)).ok && fs.existsSync(file);
+      from = 'navegador';
+    }
+    if (!ok && this.enabled('escriptori')) {
+      const tool = process.platform === 'darwin' ? ['screencapture', ['-x', file]] : which('grim') ? ['grim', [file]] : which('scrot') ? ['scrot', ['-o', file]] : ['gnome-screenshot', ['-f', file]];
+      const bin = which(tool[0]);
+      if (bin) ok = (await run(bin, tool[1], 15000)).ok && fs.existsSync(file);
+      from = 'escriptori';
+    }
+    if (!ok) throw httpErr(409, this.any() ? 'No he pogut fer la captura (no hi ha navegador obert ni pantalla accessible).' : 'Activa primer el control del navegador o de l’escriptori en aquest ordinador.');
+    this.prune();
+    this.last = { id, t: Date.now(), from };
+    this.hub.emit('out', { type: 'screen', shot: this.last });
+    return this.last;
+  }
+  prune() {
+    const files = fs.readdirSync(SHOTS).filter((f) => f.endsWith('.png')).sort();
+    for (const f of files.slice(0, Math.max(0, files.length - 200))) fs.rmSync(path.join(SHOTS, f), { force: true });
+  }
+
+  // Abans d'una aprovació d'una ordre que actua: captura (si es pot) per veure-ho al mòbil.
+  async beforeApproval(tool, input) {
+    if (tool !== 'Bash' || !this.any()) return {};
+    const c = classify(input?.command);
+    if (!c || !c.act) return {};
+    const extra = { control: c.kind };
+    try {
+      const shot = await Promise.race([this.screenshot(c.kind), new Promise((_, rej) => setTimeout(() => rej(new Error('temps')), 9000))]);
+      extra.shot = shot.id;
+    } catch { /* sense captura */ }
+    return extra;
+  }
+
+  async panic(by) {
+    let stopped = 0;
+    for (const [sid] of this.hub.runs) if (this.hub.stop(sid)) stopped++;
+    for (const a of [...this.hub.approvals.values()]) if (a.state === 'pending') this.hub.decide(a.id, 'deny', 'Aturada d’emergència', by);
+    const ab = which('agent-browser');
+    if (ab) await run(ab, ['close', '--all'], 10000);
+    this.audit.add({ type: 'control', what: `Aturada d’emergència: ${stopped} agents aturats i navegador tancat`, by });
+    return { stopped };
+  }
+
+  routes() {
+    return [
+      { method: 'GET', path: '/api/control', handler: async ({ url }) => this.caps(url.searchParams.has('refresh')) },
+      {
+        method: 'PUT',
+        path: '/api/control',
+        handler: async ({ body, device }) => {
+          const caps = await this.caps(true);
+          this.cfg.control = this.cfg.control || {};
+          const notes = [];
+          for (const kind of ['navegador', 'escriptori']) {
+            if (typeof body[kind] !== 'boolean' || body[kind] === this.enabled(kind)) continue;
+            if (body[kind]) {
+              if (!caps[kind].installed) throw httpErr(400, kind === 'navegador' ? 'agent-browser no està instal·lat. A l’ordinador: npm i -g agent-browser && agent-browser install' : 'agent-desktop no està instal·lat. A l’ordinador: npm i -g agent-desktop');
+              await this.installGuides(kind).catch((e) => notes.push(e.message));
+            } else this.removeGuides(kind);
+            this.cfg.control[kind] = body[kind];
+            this.audit.add({ type: 'control', what: `${kind === 'navegador' ? 'Control del navegador' : 'Control de l’escriptori'} ${body[kind] ? 'activat' : 'desactivat'}`, by: device?.name });
+          }
+          config.save(this.cfg);
+          return { ...(await this.caps(true)), notes };
+        },
+      },
+      { method: 'POST', path: '/api/screen', handler: ({ body }) => this.screenshot(body?.from) },
+      { method: 'GET', path: '/api/screen', handler: () => ({ last: this.last || null, enabled: this.any() }) },
+      {
+        method: 'GET',
+        path: /^\/api\/screen\/shot\/([\w-]+)$/,
+        handler: ({ res, params }) => {
+          const f = this.shotPath(params[0]);
+          if (!fs.existsSync(f)) throw httpErr(404, 'Aquesta captura ja no hi és');
+          const buf = fs.readFileSync(f);
+          res.writeHead(200, { 'content-type': 'image/png', 'content-length': buf.length, 'cache-control': 'private, max-age=3600' });
+          res.end(buf);
+        },
+      },
+      { method: 'POST', path: '/api/panic', handler: ({ device }) => this.panic(device?.name) },
+    ];
+  }
+}
+
+module.exports = { Control, classify };

package/src/hub.js

@@ -99,7 +99,10 @@ class Hub extends EventEmitter {
 
   push(s, kind, data = {}) {
     const last = s.events[s.events.length - 1];
-    if (last && last.open && kind !== 'text-chunk') delete last.open;
+    if (last && last.open && kind !== 'text-chunk') {
+      delete last.open;
+      this.emit('out', { type: 'event', session: s.id, event: last });
+    }
     const ev = { seq: ++s.seq, t: Date.now(), kind, ...data };
     s.events.push(ev);
     if (s.events.length > MAX_EVENTS) s.events.splice(0, s.events.length - MAX_EVENTS);

package/src/server.js

@@ -149,7 +149,7 @@ function matchRoute(routes, method, p) {
   return null;
 }
 
-function createServer({ cfg, hub, auth, audit, getPublicUrl, getApp, routes = [], info = () => ({}) }) {
+function createServer({ cfg, hub, auth, audit, getPublicUrl, getApp, routes = [], info = () => ({}), beforeApproval = null }) {
   const streams = new Map(); // res -> id del dispositiu
   auth.onRevoke((d) => {
     for (const [res, dev] of streams) if (dev === d.id) { res.end(); streams.delete(res); }
@@ -361,7 +361,7 @@ function createServer({ cfg, hub, auth, audit, getPublicUrl, getApp, routes = []
     throw httpErr(404, 'Aquesta ruta no existeix');
   }
 
-  const PUBLIC = /^\/(?:$|index\.html$|app(?:\/|$)|test(?:\/|$)|[\w.-]+\.(?:css|js|svg|png|webmanifest|json|ico|txt|html)$)/;
+  const PUBLIC = /^\/(?:$|index\.html$|app(?:\/|$)|privadesa$|[\w.-]+\.(?:css|js|svg|png|webmanifest|json|ico|txt|html)$)/;
   function serveStatic(req, res, url) {
     let rel = decodeURIComponent(url.pathname);
     if (!PUBLIC.test(rel) || rel.split('/').some((p) => p.startsWith('.')) || /^\/(daemon|node_modules)\b/.test(rel)) {
@@ -408,7 +408,9 @@ function createServer({ cfg, hub, auth, audit, getPublicUrl, getApp, routes = []
         if (!isLoopbackDirect(req)) throw httpErr(403, 'Només s’accepta des d’aquest ordinador');
         const b = await readBody(req);
         if (!hub.checkHookKey(b.session, req.headers['x-nio-key'])) throw httpErr(403, 'La clau no és correcta');
-        const decision = await hub.requestApproval({ session: b.session, tool: b.tool, input: b.input });
+        // Si l'ordre actua sobre el navegador o l'escriptori, hi afegim una captura de la pantalla.
+        const extra = beforeApproval ? await beforeApproval(b.tool, b.input).catch(() => ({})) : {};
+        const decision = await hub.requestApproval({ session: b.session, tool: b.tool, input: b.input, extra });
         res.writeHead(200, { 'content-type': 'application/json' });
         return res.end(JSON.stringify({ decision }));
       } catch (e) {