nio-cat 0.0.0-stage → 0.1.0

package/README.md

@@ -1,3 +1,14 @@
-# Temporary Holding Version
+# nio
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+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ó.
+
+```sh
+npx nio-cat
+```
+
+Executa-ho a la carpeta dels teus projectes i escaneja el codi QR que apareix amb la càmera del mòbil.
+
+- Sense `cloudflared`, et connectes per la wifi de casa.
+- Amb `cloudflared` (a macOS: `brew install cloudflared`), des de qualsevol lloc.
+
+Opcions: `npx nio-cat help`. Més informació a [nio.cat](https://www.nio.cat).

package/bin/nio.js

@@ -0,0 +1,191 @@
+#!/usr/bin/env node
+'use strict';
+const os = require('os');
+const path = require('path');
+const fs = require('fs');
+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 { detectAll } = require('../src/agents');
+const { startTunnel } = require('../src/tunnel');
+const { pairLink, terminalQr, writePairPage } = require('../src/pair');
+const { which } = require('../src/proc');
+
+const argv = process.argv.slice(2);
+const flags = {};
+const pos = [];
+for (let i = 0; i < argv.length; i++) {
+  const a = argv[i];
+  if (a.startsWith('--')) {
+    const [k, v] = a.slice(2).split('=');
+    if (v !== undefined) flags[k] = v;
+    else if (['port', 'url', 'app'].includes(k)) flags[k] = argv[++i];
+    else flags[k] = true;
+  } else pos.push(a);
+}
+const cmd = ['start', 'pair', 'doctor', 'reset-token', 'help'].includes(pos[0]) ? pos.shift() : 'start';
+
+const c = {
+  dim: (s) => `\x1b[2m${s}\x1b[0m`,
+  b: (s) => `\x1b[1m${s}\x1b[0m`,
+  ok: (s) => `\x1b[32m${s}\x1b[0m`,
+  warn: (s) => `\x1b[33m${s}\x1b[0m`,
+};
+
+const cfg = config.load();
+
+async function doctor() {
+  const agents = await detectAll(cfg, true);
+  console.log(c.b('\n  Agents instal·lats\n'));
+  for (const a of agents) {
+    const mark = a.available ? c.ok('✓') : c.dim('·');
+    const v = a.available ? c.dim(a.version || '') : c.dim(`no hi és · ${a.login}`);
+    console.log(`  ${mark} ${a.name.padEnd(12)} ${v}${a.beta ? c.warn('  beta') : ''}`);
+  }
+  console.log('');
+  return agents;
+}
+
+function lanIps() {
+  return Object.values(os.networkInterfaces())
+    .flat()
+    .filter((i) => i && i.family === 'IPv4' && !i.internal)
+    .map((i) => i.address);
+}
+
+function showPair(publicUrl) {
+  const link = pairLink(flags.app || cfg.app, publicUrl, cfg.token);
+  const file = writePairPage(link);
+  console.log(`\n  ${c.b('Escaneja aquest codi amb el mòbil')} ${c.dim('(o obre ' + file + ')')}\n`);
+  console.log(terminalQr(link));
+  console.log(`\n  ${c.dim('Enllaç:')} ${link}\n`);
+  console.log(c.dim('  Aquest enllaç dona accés als teus agents. Guarda\'l com una contrasenya.\n'));
+  if (flags.open) {
+    const opener = process.platform === 'darwin' ? 'open' : process.platform === 'win32' ? 'start' : 'xdg-open';
+    try {
+      spawn(opener, [file], { stdio: 'ignore', detached: true }).unref();
+    } catch {
+      /* sense navegador */
+    }
+  }
+}
+
+async function start() {
+  if (flags.port) cfg.port = Number(flags.port);
+  if (flags.app) cfg.app = flags.app;
+  // Sense carpetes a la línia d'ordres, es comparteix la carpeta on s'ha engegat.
+  cfg.roots = pos.length ? pos.map((p) => path.resolve(p)) : [process.cwd()];
+  cfg.roots = cfg.roots.filter((r) => fs.existsSync(r));
+  config.save(cfg);
+
+  console.log(`\n  ${c.b('nio')} ${c.dim('· agents d’IA al teu ordinador, des del mòbil')}`);
+  await doctor();
+  console.log(`  ${c.dim('Carpetes compartides:')} ${cfg.roots.join(', ')}`);
+
+  // Sense cloudflared no hi ha túnel: en lloc de quedar-nos sense codi QR, connectem per la wifi.
+  if (!flags.lan && !flags.url && !flags['no-tunnel'] && !which('cloudflared')) {
+    flags.lan = true;
+    console.log(c.warn('\n  No tinc cloudflared, així que et connecto per la wifi: el mòbil ha d’estar a la mateixa xarxa.'));
+    console.log(c.dim('  Per connectar-t’hi des de qualsevol lloc, instal·la’l (a macOS: brew install cloudflared) i torna a engegar nio.'));
+  }
+
+  const hub = new Hub(cfg);
+  let publicUrl = flags.url || null;
+  const host = flags.lan ? '0.0.0.0' : '127.0.0.1';
+  const server = createServer({ cfg, hub, getPublicUrl: () => publicUrl });
+
+  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`));
+    else console.error(e);
+    process.exit(1);
+  });
+
+  server.listen(cfg.port, host, () => {
+    console.log(`  ${c.dim('Local:')}    http://127.0.0.1:${cfg.port}`);
+
+    if (flags.lan) {
+      const ip = lanIps()[0];
+      if (ip) {
+        publicUrl = publicUrl || `http://${ip}:${cfg.port}`;
+        console.log(`  ${c.dim('Xarxa:')}    ${publicUrl}  ${c.dim('(només la mateixa wifi)')}`);
+        if (!flags.url) {
+          // A la xarxa local, l'app es carrega des del mateix daemon (mateix origen).
+          flags.app = publicUrl;
+        }
+      }
+    }
+
+    if (publicUrl) return showPair(publicUrl);
+
+    if (flags['no-tunnel']) {
+      publicUrl = `http://127.0.0.1:${cfg.port}`;
+      flags.app = flags.app || publicUrl;
+      return showPair(publicUrl);
+    }
+
+    const t = startTunnel(cfg.port, (url) => {
+      publicUrl = url;
+      console.log(`  ${c.dim('Túnel:')}    ${url}  ${c.dim('(Cloudflare, sense cost)')}`);
+      cfg.lastUrl = url;
+      config.save(cfg);
+      showPair(url);
+    });
+    if (!t) {
+      console.log(c.warn('\n  Falta cloudflared, el túnel que permet connectar-s\'hi des de qualsevol xarxa.'));
+      console.log(c.dim('  Instal·la\'l (a macOS: brew install cloudflared) o tria una alternativa:'));
+      console.log(c.dim('    nio --lan              només dins la mateixa wifi'));
+      console.log(c.dim('    nio --url https://…    una adreça teva (Tailscale o similar)\n'));
+    } else {
+      console.log(c.dim('  Obrint el túnel…'));
+    }
+  });
+
+  const bye = () => {
+    for (const [sid] of hub.runs) hub.stop(sid);
+    process.exit(0);
+  };
+  process.on('SIGINT', bye);
+  process.on('SIGTERM', bye);
+}
+
+(async () => {
+  switch (cmd) {
+    case 'doctor':
+      await doctor();
+      break;
+    case 'pair':
+      if (!flags.url && !cfg.lastUrl) {
+        console.log('  Encara no hi ha cap adreça desada. Engega nio primer.');
+        break;
+      }
+      showPair(flags.url || cfg.lastUrl);
+      break;
+    case 'reset-token':
+      cfg.token = crypto.randomBytes(24).toString('base64url');
+      cfg.pushSubs = [];
+      config.save(cfg);
+      console.log('  Clau nova creada. Cap mòbil aparellat abans no hi té accés.');
+      break;
+    case 'help':
+      console.log(`
+  ${c.b('nio')} · agents d’IA al teu ordinador, des del mòbil
+
+  nio [carpetes…]       Engega nio amb aquestes carpetes (si no n'hi poses, la carpeta actual)
+    --lan               Connexió dins la mateixa wifi
+    --url <adreça>      Una adreça pública teva (Tailscale o similar)
+    --no-tunnel         Només des d'aquest ordinador
+    --port <n>          Port local (7717 si no dius res)
+    --open              Obre al navegador la pàgina del codi QR
+  nio pair              Mostra el codi QR una altra vegada
+  nio doctor            Llista els agents instal·lats
+  nio reset-token       Crea una clau nova i desconnecta tots els mòbils
+
+  Configuració: ${config.FILE}
+`);
+      break;
+    default:
+      await start();
+  }
+})();

package/package.json

@@ -1,6 +1,42 @@
 {
   "name": "nio-cat",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "nio: fes servir Claude Code, Codex, Grok, Antigravity i Ollama del teu ordinador des del mòbil.",
+  "license": "MIT",
+  "author": "f.cat",
+  "homepage": "https://www.nio.cat",
+  "bin": {
+    "nio": "bin/nio.js"
+  },
+  "files": [
+    "bin",
+    "src",
+    "web",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=18.17"
+  },
+  "scripts": {
+    "start": "node bin/nio.js",
+    "demo": "node bin/nio.js --lan",
+    "prepack": "node scripts/copy-web.js"
+  },
+  "keywords": [
+    "claude-code",
+    "codex",
+    "grok",
+    "antigravity",
+    "ollama",
+    "agents",
+    "mobile"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/cescps/nio.git",
+    "directory": "daemon"
+  },
+  "bugs": {
+    "url": "https://github.com/cescps/nio/issues"
+  }
+}

package/src/agents/antigravity.js

@@ -0,0 +1,43 @@
+'use strict';
+// Google Antigravity CLI (`agy`). Només escriu si té un terminal, així que
+// s'executa dins d'un pseudo-terminal amb `script`.
+const { run } = require('../proc');
+const { handleLine } = require('./generic');
+
+module.exports = {
+  id: 'antigravity',
+  name: 'Antigravity',
+  bin: 'agy',
+  beta: true,
+  login: 'agy  (i entra amb el compte de Google)',
+  approvals: false,
+
+  start(ctx) {
+    const { session, cfg } = ctx;
+    // agy no té "resume" documentat: hi afegim un resum curt de la conversa.
+    const prev = ctx
+      .history()
+      .slice(-8)
+      .map((m) => `${m.role === 'user' ? 'Usuari' : 'Assistent'}: ${m.text.slice(0, 600)}`)
+      .join('\n');
+    const prompt = prev
+      ? `Context de la conversa:\n${prev}\n\nMissatge nou de l'usuari:\n${ctx.prompt}`
+      : ctx.prompt;
+
+    const args = ['-p', prompt, '--output-format', 'stream-json'];
+    if (session.mode === 'tot') args.push('--dangerously-skip-permissions');
+    if (session.model) args.push('--model', session.model);
+    for (const a of (cfg.agents?.antigravity?.extraArgs || [])) args.push(a);
+
+    const state = { n: 0 };
+    return run({
+      bin: ctx.binPath,
+      args,
+      cwd: session.cwd,
+      tty: true,
+      onLine: (line) => handleLine(ctx, line, state),
+      onErr: (line) => ctx.log(line),
+      onExit: (code, err) => ctx.done(code, err),
+    });
+  },
+};

package/src/agents/claude.js

@@ -0,0 +1,96 @@
+'use strict';
+// Claude Code en mode headless (`claude -p … --output-format stream-json`).
+// Les aprovacions arriben al mòbil gràcies a un hook PreToolUse.
+const path = require('path');
+const { run, tryJson } = require('../proc');
+
+const HOOK = path.join(__dirname, '..', 'claude-hook.js');
+
+module.exports = {
+  id: 'claude',
+  name: 'Claude Code',
+  bin: 'claude',
+  login: 'claude  (i entra amb el teu compte)',
+  approvals: true,
+
+  start(ctx) {
+    const { session, prompt, cfg } = ctx;
+    const args = ['-p', prompt, '--output-format', 'stream-json', '--verbose'];
+    if (session.nativeId) args.push('--resume', session.nativeId);
+    if (session.model) args.push('--model', session.model);
+
+    const env = {};
+    if (session.mode === 'llegir') {
+      args.push('--permission-mode', 'plan');
+    } else if (session.mode === 'tot') {
+      args.push('--permission-mode', 'bypassPermissions');
+    } else {
+      // "preguntar": el hook envia cada acció que no sigui de lectura al mòbil.
+      const settings = {
+        hooks: {
+          PreToolUse: [
+            {
+              matcher: '*',
+              hooks: [{ type: 'command', command: `node "${HOOK}"`, timeout: 900 }],
+            },
+          ],
+        },
+      };
+      args.push('--settings', JSON.stringify(settings));
+      env.NIO_HOOK_URL = ctx.hook.url;
+      env.NIO_HOOK_KEY = ctx.hook.key;
+      env.NIO_SESSION = session.id;
+    }
+    for (const a of (cfg.agents?.claude?.extraArgs || [])) args.push(a);
+
+    return run({
+      bin: ctx.binPath,
+      args,
+      cwd: session.cwd,
+      env,
+      onLine: (line) => handle(ctx, line),
+      onErr: (line) => ctx.log(line),
+      onExit: (code, err) => ctx.done(code, err),
+    });
+  },
+};
+
+function handle(ctx, line) {
+  const ev = tryJson(line);
+  if (!ev) return ctx.log(line);
+  switch (ev.type) {
+    case 'system':
+      if (ev.subtype === 'init') {
+        if (ev.session_id) ctx.setNative(ev.session_id);
+        if (ev.model) ctx.meta({ model: ev.model });
+      }
+      break;
+    case 'assistant':
+      for (const b of ev.message?.content || []) {
+        if (b.type === 'text' && b.text) ctx.text(b.text);
+        else if (b.type === 'tool_use') ctx.tool({ id: b.id, name: b.name, input: b.input });
+      }
+      break;
+    case 'user':
+      for (const b of ev.message?.content || []) {
+        if (b.type === 'tool_result') {
+          const out = Array.isArray(b.content)
+            ? b.content.map((c) => c.text || '').join('\n')
+            : String(b.content ?? '');
+          ctx.toolResult({ id: b.tool_use_id, output: out, error: !!b.is_error });
+        }
+      }
+      break;
+    case 'result':
+      if (ev.session_id) ctx.setNative(ev.session_id);
+      ctx.result({
+        cost: ev.total_cost_usd,
+        ms: ev.duration_ms,
+        turns: ev.num_turns,
+        error: ev.is_error ? ev.result || ev.subtype : null,
+      });
+      break;
+    default:
+      break; // stream_event, rate_limit_event, etc.
+  }
+}

package/src/agents/codex.js

@@ -0,0 +1,102 @@
+'use strict';
+// Codex CLI en mode headless (`codex exec --json`).
+// `codex exec` no pot fer preguntes: el mode decideix el sandbox.
+const { run, tryJson } = require('../proc');
+
+module.exports = {
+  id: 'codex',
+  name: 'Codex',
+  bin: 'codex',
+  login: 'codex login  (amb el compte de ChatGPT)',
+  approvals: false,
+
+  start(ctx) {
+    const { session, prompt, cfg } = ctx;
+    const args = ['exec', '--json', '--skip-git-repo-check'];
+    if (session.mode === 'llegir') args.push('--sandbox', 'read-only');
+    else if (session.mode === 'tot') args.push('--dangerously-bypass-approvals-and-sandbox');
+    else args.push('--sandbox', 'workspace-write');
+    if (session.model) args.push('--model', session.model);
+    for (const a of (cfg.agents?.codex?.extraArgs || [])) args.push(a);
+    if (session.nativeId) args.push('resume', session.nativeId);
+    args.push(prompt);
+
+    const started = new Set();
+    return run({
+      bin: ctx.binPath,
+      args,
+      cwd: session.cwd,
+      onLine: (line) => handle(ctx, line, started),
+      onErr: (line) => ctx.log(line),
+      onExit: (code, err) => ctx.done(code, err),
+    });
+  },
+};
+
+function toolOf(item) {
+  switch (item.type) {
+    case 'command_execution':
+      return { name: 'Shell', input: { command: item.command } };
+    case 'file_change':
+      return { name: 'Edita', input: { fitxers: (item.changes || []).map((c) => `${c.kind || ''} ${c.path}`.trim()) } };
+    case 'mcp_tool_call':
+      return { name: `${item.server || 'mcp'}.${item.tool || ''}`, input: item.arguments || {} };
+    case 'web_search':
+      return { name: 'Cerca web', input: { query: item.query } };
+    default:
+      return null;
+  }
+}
+
+function handle(ctx, line, started) {
+  const ev = tryJson(line);
+  if (!ev) return ctx.log(line);
+  const item = ev.item || {};
+  switch (ev.type) {
+    case 'thread.started':
+      if (ev.thread_id) ctx.setNative(ev.thread_id);
+      break;
+    case 'item.started': {
+      const t = toolOf(item);
+      if (t) {
+        started.add(item.id);
+        ctx.tool({ id: item.id, ...t });
+      }
+      break;
+    }
+    case 'item.completed': {
+      if (item.type === 'agent_message' && item.text) {
+        ctx.text(item.text);
+        break;
+      }
+      if (item.type === 'error') {
+        ctx.error(item.message || 'Codex ha donat un error');
+        break;
+      }
+      const t = toolOf(item);
+      if (!t) break;
+      if (!started.has(item.id)) ctx.tool({ id: item.id, ...t });
+      const out =
+        item.aggregated_output ??
+        (item.status ? `estat: ${item.status}` : '') ??
+        '';
+      ctx.toolResult({
+        id: item.id,
+        output: String(out),
+        error: item.status === 'failed' || (item.exit_code != null && item.exit_code !== 0),
+      });
+      break;
+    }
+    case 'turn.completed':
+      ctx.result({ tokens: ev.usage });
+      break;
+    case 'turn.failed':
+      ctx.error(ev.error?.message || 'Codex no ha pogut acabar la tasca');
+      break;
+    case 'error':
+      ctx.error(ev.message || 'Codex ha donat un error');
+      break;
+    default:
+      break;
+  }
+}

package/src/agents/demo.js

@@ -0,0 +1,60 @@
+'use strict';
+// Agent de prova: no necessita cap compte. Serveix per veure com funciona nio
+// (missatges, eines, aprovacions) abans d'instal·lar res.
+
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
+module.exports = {
+  id: 'demo',
+  name: 'Demo',
+  bin: null,
+  login: 'No cal instal·lar res',
+  approvals: true,
+
+  async detect() {
+    return { available: true, version: 'simulat' };
+  },
+
+  start(ctx) {
+    let stopped = false;
+    (async () => {
+      const words = `Entesos. Faig una ullada al projecte per a «${ctx.prompt.slice(0, 80)}».`.split(' ');
+      for (const w of words) {
+        if (stopped) return;
+        ctx.stream(w + ' ');
+        await sleep(60);
+      }
+      ctx.tool({ id: 't1', name: 'Read', input: { file_path: 'README.md' } });
+      await sleep(500);
+      ctx.toolResult({ id: 't1', output: '# Projecte de prova\nAixò és un README d’exemple.' });
+      if (stopped) return;
+
+      const input = { command: 'npm test' };
+      if (ctx.session.mode === 'llegir') {
+        ctx.text('Treballo en mode només lectura, així que no executo res. El següent pas seria `npm test`.');
+      } else {
+        let ok = true;
+        if (ctx.session.mode !== 'tot') {
+          ok = (await ctx.ask({ tool: 'Bash', input })) === 'allow';
+        }
+        if (stopped) return;
+        ctx.tool({ id: 't2', name: 'Bash', input });
+        await sleep(400);
+        if (ok) {
+          ctx.toolResult({ id: 't2', output: '✓ 12 tests passen' });
+          ctx.text('Fet. Tots els tests passen.');
+        } else {
+          ctx.toolResult({ id: 't2', output: 'Rebutjat des de nio', error: true });
+          ctx.text('D’acord, no l’executo. Què vols que faci?');
+        }
+      }
+      ctx.result({ cost: 0, ms: 2400, turns: 1 });
+    })()
+      .then(() => ctx.done(stopped ? 130 : 0))
+      .catch((e) => {
+        ctx.error(e.message);
+        ctx.done(1);
+      });
+    return { kill: () => (stopped = true) };
+  },
+};

package/src/agents/generic.js

@@ -0,0 +1,60 @@
+'use strict';
+// Lector tolerant per a CLI amb formats JSON poc documentats (Grok Build, Antigravity).
+// Si una línia no és JSON, es mostra com a text.
+const { tryJson } = require('../proc');
+
+function pickText(ev) {
+  if (typeof ev.delta === 'string') return { text: ev.delta, stream: true };
+  if (typeof ev.delta?.text === 'string') return { text: ev.delta.text, stream: true };
+  if (typeof ev.chunk === 'string') return { text: ev.chunk, stream: true };
+  if (typeof ev.text === 'string') return { text: ev.text, stream: /delta|chunk|update|partial/i.test(ev.type || '') };
+  if (typeof ev.content === 'string') return { text: ev.content, stream: /delta|chunk|update|partial/i.test(ev.type || '') };
+  if (typeof ev.message === 'string' && !/error/i.test(ev.type || '')) return { text: ev.message, stream: false };
+  if (typeof ev.response === 'string') return { text: ev.response, stream: false };
+  if (typeof ev.result === 'string') return { text: ev.result, stream: false, final: true };
+  return null;
+}
+
+function handleLine(ctx, line, state) {
+  const ev = tryJson(line);
+  if (!ev) {
+    // Text pla (format "plain" o sortida sense JSON).
+    ctx.stream(line + '\n');
+    return;
+  }
+  const type = String(ev.type || ev.event || ev.kind || '');
+  const sid = ev.session_id || ev.sessionId || ev.session?.id;
+  if (sid) ctx.setNative(sid);
+
+  if (/error/i.test(type) || ev.status === 'ERROR') {
+    ctx.error(ev.error?.message || ev.error || ev.message || 'Error');
+    return;
+  }
+  const toolName = ev.tool_name || ev.toolName || ev.tool?.name || ev.name;
+  if (/tool/i.test(type) && toolName) {
+    const id = ev.id || ev.tool_call_id || ev.tool?.id || `${toolName}-${state.n++}`;
+    if (/result|finish|end|complete|done/i.test(type)) {
+      ctx.toolResult({ id, output: String(ev.output ?? ev.result ?? ev.content ?? ''), error: !!ev.is_error });
+    } else {
+      ctx.tool({ id, name: toolName, input: ev.input || ev.args || ev.arguments || ev.tool?.input || {} });
+    }
+    return;
+  }
+  const t = pickText(ev);
+  if (t) {
+    if (t.final && state.sawText) {
+      // El resultat final repeteix el text ja rebut en trossos.
+    } else if (t.stream) {
+      state.sawText = true;
+      ctx.stream(t.text);
+    } else {
+      state.sawText = true;
+      ctx.text(t.text);
+    }
+  }
+  if (/result|done|complete|finish/i.test(type)) {
+    ctx.result({ cost: ev.total_cost_usd ?? ev.cost, tokens: ev.usage });
+  }
+}
+
+module.exports = { handleLine };

package/src/agents/grok.js

@@ -0,0 +1,40 @@
+'use strict';
+// Grok Build (CLI oficial d'xAI) en mode headless: `grok -p … --output-format streaming-json`.
+const crypto = require('crypto');
+const { run } = require('../proc');
+const { handleLine } = require('./generic');
+
+module.exports = {
+  id: 'grok',
+  name: 'Grok',
+  bin: 'grok',
+  beta: true,
+  login: 'grok login  (amb el compte d\'xAI)',
+  approvals: false,
+
+  start(ctx) {
+    const { session, prompt, cfg } = ctx;
+    // Sessió amb nom propi perquè els missatges següents continuïn la conversa.
+    if (!session.nativeId) ctx.setNative(`nio-${crypto.randomBytes(6).toString('hex')}`);
+    const args = [
+      '--no-auto-update',
+      '-p', prompt,
+      '--output-format', 'streaming-json',
+      '--cwd', session.cwd,
+      '-s', session.nativeId,
+    ];
+    if (session.mode === 'tot') args.push('--always-approve');
+    if (session.model) args.push('-m', session.model);
+    for (const a of (cfg.agents?.grok?.extraArgs || [])) args.push(a);
+
+    const state = { n: 0 };
+    return run({
+      bin: ctx.binPath,
+      args,
+      cwd: session.cwd,
+      onLine: (line) => handleLine(ctx, line, state),
+      onErr: (line) => ctx.log(line),
+      onExit: (code, err) => ctx.done(code, err),
+    });
+  },
+};