@tensor.chat/companion 0.4.4 → 0.5.0

package/bin/tensor-companion.js

@@ -70,11 +70,11 @@ function run() {
   });
   daemon.events.on('call', (c) => out(`[${stamp()}] ${c.tool}: ${summarize(c.args)}`));
   daemon.events.on('approval', (a) => out(`[${stamp()}] approval requested for ${a.tool}: ${a.summary || ''} — answer it in the chat`));
-  daemon.events.on('unauthorized', () => { out('the server rejected this device — pair again with "npx @tensor.chat/companion pair"'); process.exit(2); });
-  daemon.events.on('removed', () => { out('this device was removed in the account settings — exiting'); process.exit(3); });
+  daemon.events.on('unauthorized', async () => { out('the server rejected this device — pair again with "npx @tensor.chat/companion pair"'); await daemon.stop(); process.exit(2); });
+  daemon.events.on('removed', async () => { out('this device was removed in the account settings — exiting'); await daemon.stop(); process.exit(3); });
   daemon.events.on('local_approval_request', (a) => out(`[${stamp()}] local approval requested: run npx @tensor.chat/companion allow ${a.code}`));
   daemon.start();
-  const stop = () => { daemon.stop(); setTimeout(() => process.exit(0), 200); };
+  const stop = async () => { await daemon.stop(); process.exit(0); };
   process.on('SIGINT', stop);
   process.on('SIGTERM', stop);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tensor.chat/companion",
-  "version": "0.4.4",
+  "version": "0.5.0",
   "description": "Lets your tensor.chat AI use this machine: files, shell and internet through your own connection.",
   "license": "MIT",
   "homepage": "https://tensor.chat",

package/src/daemon.js

@@ -10,19 +10,16 @@ const EventEmitter = require('events');
 const WebSocket = require('ws');
 const { Roots } = require('./paths');
 const bash = require('./tools/bash');
-const files = require('./tools/files');
-const { fetchUrl } = require('./tools/fetch');
-const { extractTouched } = require('./tools/touched');
-const { outsideFolders } = require('./tools/outside');
-const { Jobs } = require('./tools/jobs');
+const { ToolRunner } = require('./toolRunner');
 const { createStallWatch } = require('./stalls');
 
 const VERSION = require('../package.json').version;
 const RECONNECT_MIN_MS = 1000;
 const RECONNECT_MAX_MS = 60000;
 const MAX_CONCURRENT_CALLS = 4;
-const BACKGROUND_FIRST_LOOK_MS = 1500; // a background start still reports the first lines
-const FOREGROUND_DEFAULT_MS = 600000;
+// A Codex turn holds no call slot: it waits on the server most of the time, and the
+// tools its model calls may need the slots on this very computer.
+const MAX_CODEX_TURNS = 2;
 const SLOW_SPAWN_MS = 2000;
 
 // What a call works on, for the log: the command, the path or the address
@@ -68,6 +65,9 @@ function systemInfo(shell, localAuthority = false, approver = null) {
     cwd: process.cwd(),
     localAuthority: localAuthority ? 1 : null,
     approver: approver === 'app' || approver === 'terminal' ? approver : null,
+    // which version of the codex tool (tools/codex.js) this app answers; absent = none
+    // 2: also runs chat turns (action "turn")
+    codex: 2,
   };
 }
 
@@ -108,7 +108,7 @@ function authorizeRequestedRoots(requestedRoots, labels, approvedRoots) {
   return { roots, labels: keptLabels, rejected };
 }
 
-function createDaemon({ serverUrl, token, shell, log, approvedRoots, approvedShell, approver = null, slowSpawnMs = SLOW_SPAWN_MS } = {}) {
+function createDaemon({ serverUrl, token, shell, log, approvedRoots, approvedShell, approver = null, slowSpawnMs = SLOW_SPAWN_MS, toolWorkerPath } = {}) {
   if (!serverUrl || !token) throw new Error('serverUrl and token are required');
   const emitter = new EventEmitter();
   const say = typeof log === 'function' ? log : () => {};
@@ -116,7 +116,9 @@ function createDaemon({ serverUrl, token, shell, log, approvedRoots, approvedShe
   const localApprovals = typeof approvedRoots === 'function' ? approvedRoots : null;
   const localShellApproval = typeof approvedShell === 'function' ? approvedShell : null;
   const running = new Map(); // call id → AbortController
-  const jobs = new Jobs();
+  const turns = new Map(); // call id of a Codex turn → answer(key, value)
+  const tools = new ToolRunner({ shell, slowSpawnMs, workerPath: toolWorkerPath });
+  tools.on('log', say);
   const unsentExits = []; // job endings the server has not heard yet (offline at the time)
   const state = { connected: false, deviceId: null, name: null, mode: null, roots: [], labels: [], reconnectMs: RECONNECT_MIN_MS, stopped: false, ws: null, timer: null, connectedAt: null, lastPingAt: null };
   const stalls = createStallWatch({ say });
@@ -160,79 +162,6 @@ function createDaemon({ serverUrl, token, shell, log, approvedRoots, approvedShe
     emitter.emit('config', { roots: [...roots.status(), ...authorized.rejected], mode: state.mode, name: state.name });
   }
 
-  async function runTool(tool, args, signal, timeoutMs, callRoots = roots) {
-    const a = args && typeof args === 'object' ? args : {};
-    switch (tool) {
-      case 'bash': {
-        const cwdRes = a.cwd ? callRoots.resolve(a.cwd) : null;
-        if (cwdRes && cwdRes.error) return { ok: false, text: `(cannot run there — ${cwdRes.error})` };
-        const cwd = cwdRes ? cwdRes.abs : callRoots.primary();
-        if (!cwd) return { ok: false, text: '(no shared folder is available on this device — the user has to add one in the device settings)' };
-        // Starting a process holds this whole process until Windows has it running. A
-        // scanner that inspects the program first can make that last long enough for
-        // the server to stop hearing from this computer.
-        const spawnAt = Date.now();
-        const job = jobs.start(String(a.command || ''), { cwd, shell });
-        const spawnMs = Date.now() - spawnAt;
-        if (spawnMs >= slowSpawnMs) say(`starting the shell took ${Math.round(spawnMs / 1000)} s`);
-        // A cancelled call (turn aborted, server timeout) takes its foreground job with
-        // it; a background job belongs to the chat, not to the call, and lives on.
-        const onAbort = () => { if (!a.background) jobs.kill(job.id); };
-        if (signal) signal.addEventListener('abort', onAbort, { once: true });
-        // The server cancels a call at timeoutMs; answering a little earlier keeps the job
-        // alive as a background job instead of letting the cancel kill it.
-        const limit = timeoutMs || FOREGROUND_DEFAULT_MS;
-        const waitMs = a.background ? BACKGROUND_FIRST_LOOK_MS : Math.max(1000, limit - Math.min(5000, Math.floor(limit / 4)));
-        const ended = await jobs.wait(job, waitMs);
-        if (signal) signal.removeEventListener('abort', onAbort);
-        if (ended) {
-          const r = jobs.result(job);
-          r.touched = extractTouched(callRoots, a.command, r.stdout, r.stderr);
-          delete r.stdout;
-          delete r.stderr;
-          jobs.poll(job.id); // the one-shot result already carried every line
-          return r;
-        }
-        // Still running: it becomes (or already was) a background job.
-        const p = jobs.poll(job.id);
-        return { ok: true, running: true, jobId: job.id, text: p.text, exitCode: null, truncated: false, timedOut: false, touched: [] };
-      }
-      case 'job': {
-        const job = jobs.get(a.jobId);
-        if (!job) return { ok: false, text: '(no such job on this device — it may have been forgotten after many newer ones)' };
-        if (a.action === 'kill') {
-          jobs.kill(job.id);
-          await jobs.wait(job, 3000);
-        }
-        const p = jobs.poll(job.id);
-        return { ok: true, jobId: job.id, running: p.status === 'running', status: p.status, exitCode: p.exitCode, jobMs: p.ms, text: p.text, skipped: p.skipped };
-      }
-      case 'read': return files.read(callRoots, a.path, { lines: a.lines });
-      case 'write': return files.write(callRoots, a.path, a.content, { overwrite: a.overwrite === true });
-      case 'edit': return files.edit(callRoots, a.path, a.edits);
-      case 'glob': return files.glob(callRoots, a.pattern);
-      // The server asks before it judges a shell command: what of it lies outside
-      // the shared folders, read with this machine's own variables. Nothing runs.
-      case 'outside': {
-        const at = a.cwd ? callRoots.resolve(a.cwd) : null;
-        return outsideFolders(callRoots, a.command, { cwd: at && !at.error ? at.abs : callRoots.primary() || os.homedir() });
-      }
-      case 'grep': return files.grep(callRoots, a.command);
-      case 'ls': return files.ls(callRoots, a.path, { max: a.max });
-      case 'fetchfile': return files.fetchfile(callRoots, a.path, { maxBytes: a.maxBytes });
-      case 'fetchpart': return files.fetchpart(callRoots, a.path, { offset: a.offset, length: a.length });
-      // Das eingehaengte Laufwerk schreibt ueber diese vier zurueck. Sie stehen der KI
-      // NICHT offen - sie kommen nur aus dem Adapter, der das Laufwerk bedient.
-      case 'writepart': return files.writepart(callRoots, a.path, { offset: a.offset, base64: a.base64, truncate: a.truncate });
-      case 'mkdirpath': return files.mkdirpath(callRoots, a.path);
-      case 'removepath': return await files.removepath(callRoots, a.path, { endgueltig: a.endgueltig === true });
-      case 'renamepath': return files.renamepath(callRoots, a.from, a.to);
-      case 'statpath': return files.statpath(callRoots, a.path);
-      case 'fetch': return fetchUrl(a.url, { signal, raw: a.raw === true });
-      default: return { ok: false, text: `(unknown tool "${tool}" on the companion device)` };
-    }
-  }
-
   async function onCall(msg) {
     const id = String(msg.id);
     const tool = String(msg.tool || '');
@@ -242,12 +171,14 @@ function createDaemon({ serverUrl, token, shell, log, approvedRoots, approvedShe
       emitter.emit('result', { id, tool, ok: false });
       return;
     }
-    if (running.size >= MAX_CONCURRENT_CALLS) {
+    const turn = tool === 'codex' && msg.args && msg.args.action === 'turn';
+    if (turn ? turns.size >= MAX_CODEX_TURNS : running.size - turns.size >= MAX_CONCURRENT_CALLS) {
       send({ t: 'result', id, ok: false, text: '(the companion device is busy with other calls — try again in a moment)' });
       return;
     }
     const ctrl = new AbortController();
     running.set(id, ctrl);
+    if (turn) turns.set(id, null);
     const finished = stalls.started(tool, callSubject(tool, msg.args));
     emitter.emit('call', { id, tool: msg.tool, args: msg.args });
     let r;
@@ -258,12 +189,17 @@ function createDaemon({ serverUrl, token, shell, log, approvedRoots, approvedShe
         const scoped = authorizeRequestedRoots(msg.roots, msg.labels, approved);
         callRoots = new Roots(scoped.roots, scoped.labels);
       }
-      r = await runTool(tool, msg.args, ctrl.signal, Number(msg.timeoutMs) || undefined, callRoots);
+      const talk = turn ? {
+        onEvent: (ev) => send({ t: 'call_event', id, ev }),
+        ready: (answer) => turns.set(id, answer),
+      } : null;
+      r = await tools.run(tool, msg.args, ctrl.signal, Number(msg.timeoutMs) || undefined, callRoots, talk);
     } catch (e) {
       r = { ok: false, text: `(tool error on the companion device: ${e && e.message ? e.message : e})` };
     }
     finished();
     running.delete(id);
+    turns.delete(id);
     send({ t: 'result', id, ...r });
     emitter.emit('result', { id, tool: msg.tool, ok: r.ok });
   }
@@ -275,7 +211,7 @@ function createDaemon({ serverUrl, token, shell, log, approvedRoots, approvedShe
       unsentExits.shift();
     }
   }
-  jobs.on('exit', (r) => {
+  tools.on('exit', (r) => {
     const m = { t: 'job_exit', jobId: r.jobId, status: r.status, exitCode: r.exitCode, ms: r.ms, tail: r.tail };
     unsentExits.push(m);
     flushExits();
@@ -295,6 +231,7 @@ function createDaemon({ serverUrl, token, shell, log, approvedRoots, approvedShe
       case 'config': applyConfig(msg); break;
       case 'call': onCall(msg); break;
       case 'cancel': { const c = running.get(String(msg.id)); if (c) c.abort(); break; }
+      case 'call_input': { const answer = turns.get(String(msg.id)); if (answer) answer(String(msg.key), msg.value); break; }
       case 'approval': emitter.emit('approval', msg); break;
       case 'approval_resolved': emitter.emit('approval_resolved', msg); break;
       case 'local_approval_request': confirmIfCovered(msg); break;
@@ -376,11 +313,11 @@ function createDaemon({ serverUrl, token, shell, log, approvedRoots, approvedShe
       stalls.stop();
       if (state.timer) { clearTimeout(state.timer); state.timer = null; }
       for (const c of running.values()) c.abort();
-      jobs.killAll();
+      const stopped = tools.stop();
       if (state.ws) { try { state.ws.close(1000, 'daemon stopped'); } catch (_) {} try { state.ws.terminate(); } catch (_) {} state.ws = null; }
+      return stopped;
     },
     replyApproval(approvalId, decision) { return send({ t: 'approval_reply', approvalId, decision }); },
-    jobs,
   };
 }
 

package/src/toolExecutor.js

@@ -0,0 +1,95 @@
+'use strict';
+
+const os = require('os');
+const files = require('./tools/files');
+const { fetchUrl } = require('./tools/fetch');
+const { extractTouched } = require('./tools/touched');
+const { outsideFolders } = require('./tools/outside');
+const { Jobs } = require('./tools/jobs');
+const codex = require('./tools/codex');
+const codexTurn = require('./tools/codexTurn');
+
+const BACKGROUND_FIRST_LOOK_MS = 1500;
+const FOREGROUND_DEFAULT_MS = 600000;
+
+function createToolExecutor({ shell, say = () => {}, slowSpawnMs = 2000 } = {}) {
+  const jobs = new Jobs();
+
+  // io: what a call that talks with the server while it runs (a Codex turn) needs -
+  // emit(ev) sends an event, input(key) waits for the server's answer to one.
+  async function runTool(tool, args, signal, timeoutMs, callRoots, requestedAt = Date.now(), cancelled = () => false, io = null) {
+    const a = args && typeof args === 'object' ? args : {};
+    if (signal.aborted || cancelled()) throw new Error('call cancelled before execution');
+    switch (tool) {
+      case 'bash': {
+        const cwdRes = a.cwd ? callRoots.resolve(a.cwd) : null;
+        if (cwdRes && cwdRes.error) return { ok: false, text: `(cannot run there — ${cwdRes.error})` };
+        const cwd = cwdRes ? cwdRes.abs : callRoots.primary();
+        if (!cwd) return { ok: false, text: '(no shared folder is available on this device — the user has to add one in the device settings)' };
+        const spawnAt = Date.now();
+        const job = jobs.start(String(a.command || ''), { cwd, shell });
+        const spawnMs = Date.now() - spawnAt;
+        if (spawnMs >= slowSpawnMs) say(`starting the shell took ${Math.round(spawnMs / 1000)} s`);
+        // A background job belongs to the chat, not to the call that started it.
+        const onAbort = () => { if (!a.background) jobs.kill(job.id); };
+        signal.addEventListener('abort', onAbort, { once: true });
+        if (signal.aborted || cancelled()) onAbort();
+        const limit = timeoutMs || FOREGROUND_DEFAULT_MS;
+        const waitMs = a.background ? BACKGROUND_FIRST_LOOK_MS : Math.max(1000, limit - Math.min(5000, Math.floor(limit / 4)));
+        // The server's deadline includes time queued in the worker and time in spawn.
+        const ended = await jobs.wait(job, a.background ? waitMs : Math.max(0, waitMs - (Date.now() - requestedAt)));
+        signal.removeEventListener('abort', onAbort);
+        if (ended) {
+          const r = jobs.result(job);
+          r.touched = extractTouched(callRoots, a.command, r.stdout, r.stderr);
+          delete r.stdout;
+          delete r.stderr;
+          jobs.poll(job.id);
+          return r;
+        }
+        const p = jobs.poll(job.id);
+        return { ok: true, running: true, jobId: job.id, text: p.text, exitCode: null, truncated: false, timedOut: false, touched: [] };
+      }
+      case 'job': {
+        const job = jobs.get(a.jobId);
+        if (!job) return { ok: false, text: '(no such job on this device — it may have been forgotten after many newer ones)' };
+        if (a.action === 'kill') {
+          jobs.kill(job.id);
+          await jobs.wait(job, 3000);
+        }
+        const p = jobs.poll(job.id);
+        return { ok: true, jobId: job.id, running: p.status === 'running', status: p.status, exitCode: p.exitCode, jobMs: p.ms, text: p.text, skipped: p.skipped };
+      }
+      case 'read': return files.read(callRoots, a.path, { lines: a.lines });
+      case 'write': return files.write(callRoots, a.path, a.content, { overwrite: a.overwrite === true });
+      case 'edit': return files.edit(callRoots, a.path, a.edits);
+      case 'glob': return files.glob(callRoots, a.pattern);
+      case 'outside': {
+        const at = a.cwd ? callRoots.resolve(a.cwd) : null;
+        return outsideFolders(callRoots, a.command, { cwd: at && !at.error ? at.abs : callRoots.primary() || os.homedir() });
+      }
+      case 'grep': return files.grep(callRoots, a.command);
+      case 'ls': return files.ls(callRoots, a.path, { max: a.max });
+      case 'fetchfile': return files.fetchfile(callRoots, a.path, { maxBytes: a.maxBytes });
+      case 'fetchpart': return files.fetchpart(callRoots, a.path, { offset: a.offset, length: a.length });
+      // These operations are private to the mounted-drive adapter.
+      case 'writepart': return files.writepart(callRoots, a.path, { offset: a.offset, base64: a.base64, truncate: a.truncate });
+      case 'mkdirpath': return files.mkdirpath(callRoots, a.path);
+      case 'removepath': return files.removepath(callRoots, a.path, { endgueltig: a.endgueltig === true });
+      case 'renamepath': return files.renamepath(callRoots, a.from, a.to);
+      case 'statpath': return files.statpath(callRoots, a.path);
+      case 'fetch': return fetchUrl(a.url, { signal, raw: a.raw === true });
+      case 'codex':
+        if (a.action === 'turn') {
+          if (!io) return { ok: false, text: '(a Codex turn needs a connection to the server)' };
+          return codexTurn.runTurn(a, { emit: io.emit, toolResult: io.input, signal });
+        }
+        return codex.run(a, { signal, timeoutMs });
+      default: return { ok: false, text: `(unknown tool "${tool}" on the companion device)` };
+    }
+  }
+
+  return { runTool, jobs };
+}
+
+module.exports = { createToolExecutor };

package/src/toolRunner.js

@@ -0,0 +1,95 @@
+'use strict';
+
+const path = require('path');
+const { Worker } = require('worker_threads');
+const EventEmitter = require('events');
+
+// Even asynchronous spawn can block its calling thread inside Windows. Neither it
+// nor synchronous filesystem walks may share the WebSocket's event loop.
+class ToolRunner extends EventEmitter {
+  constructor({ shell, slowSpawnMs, workerPath = path.join(__dirname, 'toolWorker.js') } = {}) {
+    super();
+    this.options = { shell, slowSpawnMs };
+    this.workerPath = workerPath;
+    this.worker = null;
+    this.pending = new Map();
+    this.nextId = 1;
+    this.stopping = new Int32Array(new SharedArrayBuffer(4));
+    this.failure = null;
+    this.closed = null;
+  }
+
+  start() {
+    if (this.failure) throw this.failure;
+    if (Atomics.load(this.stopping, 0)) throw new Error('tool worker is stopped');
+    if (this.worker) return;
+    // The worker's env is named for the same reason as in tools/codex.js: by default it
+    // copies the env of the Node process, which under jest is not this module's.
+    const worker = new Worker(this.workerPath, { env: process.env, workerData: { ...this.options, stopping: this.stopping.buffer } });
+    this.worker = worker;
+    this.closed = new Promise((resolve) => worker.once('exit', resolve));
+    const fail = (error) => {
+      this.failure = error;
+      for (const p of this.pending.values()) p.reject(error);
+      this.pending.clear();
+    };
+    worker.on('message', (msg) => {
+      if (msg.t === 'log') this.emit('log', msg.line);
+      else if (msg.t === 'job_exit') this.emit('exit', msg.report);
+      else if (msg.t === 'event') {
+        const p = this.pending.get(msg.id);
+        if (p && p.onEvent) p.onEvent(msg.ev);
+      }
+      else if (msg.t === 'result') {
+        const p = this.pending.get(msg.id);
+        if (!p) return;
+        this.pending.delete(msg.id);
+        p.resolve(msg.result);
+      }
+    });
+    worker.on('error', fail);
+    worker.on('exit', (code) => {
+      // Never replay calls or reset job IDs after a crash: their side effects may exist.
+      fail(new Error(`tool worker exited (code ${code}); commands were not retried`));
+    });
+  }
+
+  // talk: for a call that talks with the server while it runs. onEvent(ev) gets what
+  // the call sends out; answer(key, value) - handed over through talk.ready - sends it
+  // what the server answered.
+  async run(tool, args, signal, timeoutMs, roots, talk = null) {
+    this.start();
+    const id = this.nextId++;
+    const cancelled = new Int32Array(new SharedArrayBuffer(4));
+    const abort = () => {
+      Atomics.store(cancelled, 0, 1);
+      this.worker.postMessage({ t: 'cancel', id });
+    };
+    signal.addEventListener('abort', abort, { once: true });
+    try {
+      if (signal.aborted) {
+        Atomics.store(cancelled, 0, 1);
+        throw new Error('call cancelled before execution');
+      }
+      return await new Promise((resolve, reject) => {
+        this.pending.set(id, { resolve, reject, onEvent: talk && talk.onEvent });
+        if (talk && talk.ready) talk.ready((key, value) => this.worker.postMessage({ t: 'input', id, key, value }));
+        try {
+          this.worker.postMessage({ t: 'call', id, tool, args, timeoutMs, entries: roots.entries, requestedAt: Date.now(), cancelled: cancelled.buffer, talks: !!talk });
+        } catch (e) {
+          this.pending.delete(id);
+          reject(e);
+        }
+      });
+    } finally {
+      signal.removeEventListener('abort', abort);
+    }
+  }
+
+  stop() {
+    if (!Atomics.exchange(this.stopping, 0, 1) && this.worker) this.worker.postMessage({ t: 'stop' });
+    return this.closed || Promise.resolve();
+  }
+}
+
+module.exports = { ToolRunner };

package/src/toolWorker.js

@@ -0,0 +1,83 @@
+'use strict';
+
+const { parentPort, workerData } = require('worker_threads');
+const { Roots } = require('./paths');
+const { createToolExecutor } = require('./toolExecutor');
+
+const stopping = new Int32Array(workerData.stopping);
+const executor = createToolExecutor({
+  shell: workerData.shell,
+  slowSpawnMs: workerData.slowSpawnMs,
+  say: (line) => parentPort.postMessage({ t: 'log', line }),
+});
+const running = new Map();
+// coverage:host-only this file runs only as the tool worker thread, which coverage does not see; _codexLocalTurn.js drives every Codex turn through this worker for real (daemon -> worker -> codexTurn) and runs the same executor call in its own process
+// A call that talks with the server while it runs (a Codex turn): the answers it
+// waits for, by key, and those that came before it asked.
+const inputs = new Map();
+
+function ioFor(id, signal) {
+  const box = { waiting: new Map(), early: new Map() };
+  inputs.set(id, box);
+  signal.addEventListener('abort', () => {
+    for (const done of box.waiting.values()) done({ ok: false, text: '(cancelled)' });
+    box.waiting.clear();
+  }, { once: true });
+  return {
+    emit: (ev) => parentPort.postMessage({ t: 'event', id, ev }),
+    input: (key) => new Promise((resolve) => {
+      if (box.early.has(key)) { resolve(box.early.get(key)); box.early.delete(key); return; }
+      if (signal.aborted) { resolve({ ok: false, text: '(cancelled)' }); return; }
+      box.waiting.set(key, resolve);
+    }),
+  };
+}
+// coverage:host-only-end
+executor.jobs.on('exit', (report) => parentPort.postMessage({ t: 'job_exit', report }));
+
+parentPort.on('message', async (msg) => {
+  if (msg.t === 'cancel') {
+    const ctrl = running.get(msg.id);
+    if (ctrl) ctrl.abort();
+    return;
+  }
+  // coverage:host-only the tool worker thread (see above): the server's answers to a running Codex turn
+  if (msg.t === 'input') {
+    const box = inputs.get(msg.id);
+    if (!box) return;
+    const done = box.waiting.get(msg.key);
+    if (done) { box.waiting.delete(msg.key); done(msg.value); } else box.early.set(msg.key, msg.value);
+    return;
+  }
+  // coverage:host-only-end
+  if (msg.t === 'stop') {
+    for (const ctrl of running.values()) ctrl.abort();
+    executor.jobs.killAll();
+    await Promise.all(executor.jobs.running().map((job) => executor.jobs.wait(job, 5000)));
+    parentPort.close();
+    return;
+  }
+  if (msg.t !== 'call') return;
+  const ctrl = new AbortController();
+  const cancelled = new Int32Array(msg.cancelled);
+  const isCancelled = () => !!Atomics.load(cancelled, 0) || !!Atomics.load(stopping, 0);
+  running.set(msg.id, ctrl);
+  let result;
+  try {
+    if (isCancelled()) throw new Error('call cancelled before execution');
+    const roots = new Roots([]);
+    // This is the authorized per-call snapshot, never the worker's previous roots.
+    roots.entries = msg.entries;
+    // coverage:host-only the tool worker thread (see above): a Codex turn gets its line to the server
+    result = await executor.runTool(msg.tool, msg.args, ctrl.signal, msg.timeoutMs, roots, msg.requestedAt, isCancelled, msg.talks ? ioFor(msg.id, ctrl.signal) : null);
+    // coverage:host-only-end
+  } catch (e) {
+    result = { ok: false, text: `(tool error on the companion device: ${e.message})` };
+  } finally {
+    running.delete(msg.id);
+    // coverage:host-only the tool worker thread (see above)
+    inputs.delete(msg.id);
+    // coverage:host-only-end
+  }
+  parentPort.postMessage({ t: 'result', id: msg.id, result });
+});

package/src/tools/codex.js

@@ -0,0 +1,218 @@
+'use strict';
+// Codex on this computer: is it installed, is it signed in, and how much of the
+// ChatGPT plan's Codex usage is used. The answer comes from the Codex app-server, the
+// interface Codex offers its own clients (https://learn.chatgpt.com/docs/app-server).
+// This only reads: no thread, no turn, no login, no change to Codex's own settings.
+
+const { spawn } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const { killTree } = require('./bash');
+
+const VERSION = require('../../package.json').version;
+const WIN = process.platform === 'win32';
+const STATUS_TIMEOUT_MS = 20000;
+// How this client names itself to Codex and, through Codex, to OpenAI.
+const CLIENT_NAME = 'tensor.chat';
+
+// The codex command on PATH: the npm shim (codex.cmd) or a native codex.exe on
+// Windows, an executable `codex` elsewhere. TENSOR_CODEX_BIN names another one
+// (a .js file runs with this Node).
+function findCodex(env = process.env) {
+  if (env.TENSOR_CODEX_BIN) return fs.existsSync(env.TENSOR_CODEX_BIN) ? env.TENSOR_CODEX_BIN : null;
+  const names = WIN ? ['codex.exe', 'codex.cmd'] : ['codex'];
+  for (const dir of String(env.PATH || env.Path || '').split(path.delimiter)) {
+    if (!dir) continue;
+    for (const name of names) {
+      const file = path.join(dir, name);
+      try {
+        fs.accessSync(file, WIN ? fs.constants.F_OK : fs.constants.X_OK);
+        if (fs.statSync(file).isFile()) return file;
+      } catch (_) {}
+    }
+  }
+  return null;
+}
+
+// How to start `<bin> app-server`. A .cmd shim needs cmd.exe; the arguments are fixed,
+// so nothing from the server reaches that command line.
+function commandFor(bin) {
+  if (/\.js$/i.test(bin)) return { cmd: process.execPath, args: [bin, 'app-server'] };
+  if (WIN && /\.cmd$/i.test(bin)) return { cmd: process.env.ComSpec || 'cmd.exe', args: ['/d', '/s', '/c', `"${bin}" app-server`], verbatim: true };
+  return { cmd: bin, args: ['app-server'] };
+}
+
+const NOT_SUPPORTED = { code: -32601, message: 'not supported by this client' };
+
+/**
+ * One app-server process and its line protocol (JSON-RPC, one message per line).
+ * Throws when the process cannot be started.
+ * @param {string} bin
+ * @param {object} [o]
+ * @param {boolean} [o.experimental]  ask for Codex's experimental methods and fields;
+ *   a chat turn needs them for dynamicTools, the status does not
+ * @param {(m: object) => (object|undefined|Promise<object|undefined>)} [o.onRequest]
+ *   answers a request from Codex with a result; undefined answers "not supported"
+ * @param {(m: object) => void} [o.onNotification]
+ * @returns {{request: Function, ready: Promise<object>, ended: Promise<Error>, kill: Function}}
+ *   ready: the initialize result, once Codex took the client; ended: why the process stopped
+ */
+function openSession(bin, { experimental = false, onRequest, onNotification } = {}) {
+  const { cmd, args, verbatim } = commandFor(bin);
+  // env named, not inherited: a spawn without it takes the env of the Node process,
+  // and under jest that is not the one this module sees. The originator is set at
+  // start too: Codex fetches its model list before initialize, and that request
+  // would otherwise go out under the plain CLI's name.
+  const env = { CODEX_INTERNAL_ORIGINATOR_OVERRIDE: CLIENT_NAME, ...process.env };
+  const child = spawn(cmd, args, { env, stdio: ['pipe', 'pipe', 'pipe'], windowsHide: true, windowsVerbatimArguments: !!verbatim, detached: !WIN });
+  const waiting = new Map();
+  let nextId = 1;
+  let buf = '';
+  let stderr = '';
+  let endedWith = null;
+  let onEnd;
+  const ended = new Promise((resolve) => { onEnd = resolve; });
+  const end = (err) => {
+    if (endedWith) return;
+    endedWith = err;
+    for (const done of waiting.values()) done({ error: { code: -32000, message: err.message } });
+    waiting.clear();
+    onEnd(err);
+  };
+  const send = (m) => { try { child.stdin.write(JSON.stringify(m) + '\n'); } catch (_) {} };
+  const request = (method, params) => new Promise((done) => {
+    if (endedWith) { done({ error: { code: -32000, message: endedWith.message } }); return; }
+    const id = nextId++;
+    waiting.set(id, done);
+    send({ id, method, params });
+  });
+  const answer = async (m) => {
+    let result;
+    try { result = onRequest ? await onRequest(m) : undefined; } catch (e) {
+      send({ id: m.id, error: { code: -32000, message: String(e && e.message ? e.message : e) } });
+      return;
+    }
+    send(result === undefined ? { id: m.id, error: NOT_SUPPORTED } : { id: m.id, result });
+  };
+  // A write after Codex stopped reading fails on the stream (EPIPE), not in send():
+  // without a listener that error would take the whole worker down. 'close' says why.
+  child.stdin.on('error', () => {});
+  child.on('error', (e) => end(e));
+  child.on('close', (code) => end(new Error(`Codex app-server ended (exit ${code})${stderr.trim() ? `: ${stderr.trim().slice(-300)}` : ''}`)));
+  child.stderr.on('data', (d) => { stderr = (stderr + d).slice(-4000); });
+  child.stdout.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 m;
+      try { m = JSON.parse(line); } catch (_) { continue; }
+      if (m.id != null && m.method) { answer(m); continue; }
+      if (m.id != null) {
+        const done = waiting.get(m.id);
+        if (done) { waiting.delete(m.id); done(m); }
+        continue;
+      }
+      if (m.method && onNotification) onNotification(m);
+    }
+  });
+  const ready = (async () => {
+    const init = await request('initialize', {
+      clientInfo: { name: CLIENT_NAME, title: CLIENT_NAME, version: VERSION },
+      capabilities: { experimentalApi: !!experimental, requestAttestation: false },
+    });
+    if (init.error) throw new Error(`Codex refused the connection: ${init.error.message || 'unknown error'}`);
+    send({ method: 'initialized' });
+    return init.result || {};
+  })();
+  ready.catch(() => {});
+  return { request, ready, ended, kill: () => killTree(child) };
+}
+
+// One short conversation with the app-server: initialize, then the questions, then
+// the process ends. Resolves with the answers by method; rejects on a broken start.
+function ask(bin, questions, { signal, timeoutMs = STATUS_TIMEOUT_MS } = {}) {
+  return new Promise((resolve, reject) => {
+    let session;
+    try { session = openSession(bin); } catch (e) { reject(e); return; }
+    let settled = false;
+    const finish = (err, value) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      if (signal) signal.removeEventListener('abort', onAbort);
+      session.kill();
+      if (err) reject(err); else resolve(value);
+    };
+    const timer = setTimeout(() => finish(new Error(`Codex did not answer within ${Math.round(timeoutMs / 1000)} s`)), timeoutMs);
+    const onAbort = () => finish(new Error('cancelled'));
+    if (signal) {
+      if (signal.aborted) { finish(new Error('cancelled')); return; }
+      signal.addEventListener('abort', onAbort, { once: true });
+    }
+    session.ended.then((e) => finish(e));
+    (async () => {
+      const answers = { initialize: await session.ready };
+      for (const [method, params] of questions) {
+        const r = await session.request(method, params);
+        answers[method] = r.error ? { error: r.error } : (r.result || {});
+      }
+      finish(null, answers);
+    })().catch((e) => finish(e));
+  });
+}
+
+const toWindow = (w) => (w && typeof w.usedPercent === 'number'
+  ? { usedPercent: w.usedPercent, windowMins: Number.isFinite(w.windowDurationMins) ? w.windowDurationMins : null, resetsAt: Number.isFinite(w.resetsAt) ? w.resetsAt : null }
+  : null);
+
+// The models this Codex offers its user, with the reasoning levels each takes: the
+// server sends a GPT turn here only for a model on this list.
+function modelsOf(list) {
+  const data = list && !list.error && Array.isArray(list.data) ? list.data : [];
+  return data.filter((m) => m && typeof m.id === 'string' && m.id).slice(0, 50).map((m) => ({
+    id: m.id,
+    efforts: (Array.isArray(m.supportedReasoningEfforts) ? m.supportedReasoningEfforts : [])
+      .map((e) => (e && typeof e === 'object' ? e.reasoningEffort : e)).filter((e) => typeof e === 'string'),
+    images: Array.isArray(m.inputModalities) ? m.inputModalities.includes('image') : true,
+  }));
+}
+
+// What the server is told. The account's e-mail stays on this computer.
+async function status({ signal, timeoutMs, env } = {}) {
+  const bin = findCodex(env);
+  if (!bin) return { ok: true, text: 'Codex is not installed on this computer', codex: { installed: false } };
+  let a;
+  try {
+    a = await ask(bin, [['account/read', {}], ['account/rateLimits/read', {}], ['model/list', { includeHidden: false }]], { signal, timeoutMs });
+  } catch (e) {
+    return { ok: false, text: `(Codex did not answer: ${e.message})`, codex: { installed: true, error: e.message } };
+  }
+  const ua = String(a.initialize.userAgent || '');
+  const version = (/\/(\d+\.\d+\.\d+[\w.-]*)/.exec(ua) || [])[1] || null;
+  const account = a['account/read'] && a['account/read'].account;
+  const signedIn = !!(account && account.type);
+  const rl = a['account/rateLimits/read'];
+  const snap = rl && !rl.error ? rl.rateLimits : null;
+  const codex = {
+    installed: true,
+    version,
+    signedIn,
+    authMode: signedIn ? String(account.type) : null,
+    planType: signedIn && account.planType ? String(account.planType) : null,
+    usageAllowed: rl && !rl.error && typeof rl.ordinaryUsageAllowed === 'boolean' ? rl.ordinaryUsageAllowed : null,
+    limits: snap ? { primary: toWindow(snap.primary), secondary: toWindow(snap.secondary) } : null,
+    models: modelsOf(a['model/list']),
+  };
+  return { ok: true, text: signedIn ? `Codex ${version || ''} is signed in (${codex.planType || codex.authMode})`.replace('  ', ' ') : 'Codex is installed but not signed in', codex };
+}
+
+async function run(args, opts = {}) {
+  const action = String((args && args.action) || 'status');
+  if (action === 'status') return status(opts);
+  return { ok: false, text: `(unknown codex action "${action}")` };
+}
+
+module.exports = { run, status, findCodex, commandFor, openSession };

package/src/tools/codexTurn.js

@@ -0,0 +1,171 @@
+'use strict';
+// One chat turn of tensor.chat through Codex on this computer, signed in with the
+// user's own ChatGPT account. tensor.chat sends the conversation and its tools; Codex
+// runs the model; every tool the model calls goes back to tensor.chat and runs there,
+// with the same executor as on every other route. Codex itself gets no tool of its
+// own: no shell, no file access, no web search, no sub-agents, nothing about this
+// computer. The settings for that are fixed here - the server cannot change them.
+//
+// Measured 02.11.2026 with Codex 0.164 against a local stand-in for the model API:
+// with LOCKED below the request carries our base instructions, the history we
+// inject and our tools, and nothing else. dynamicTools need experimentalApi
+// ("thread/start.dynamicTools requires experimentalApi capability").
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { findCodex, openSession } = require('./codex');
+
+// A folder with nothing in it, as Codex's working folder: it is never shown to the
+// model (include_environment_context is off), and nothing can be read in it anyway.
+function emptyDir() {
+  const dir = path.join(os.tmpdir(), 'tensor-codex-turn');
+  fs.mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+const OFF = {
+  shell_tool: false, unified_exec: false, view_image: false, multi_agent: false, goals: false,
+  apps: false, plugins: false, image_generation: false, sleep_tool: false, skill_search: false,
+  tool_suggest: false, memories: false, hooks: false, computer_use: false, browser_use: false,
+  in_app_browser: false,
+};
+const LOCKED = {
+  ephemeral: true,
+  approvalPolicy: 'never',
+  sandbox: 'read-only',
+  config: {
+    features: OFF,
+    web_search: 'disabled',
+    include_environment_context: false,
+    include_permissions_instructions: false,
+    include_apps_instructions: false,
+    include_skills_usage_instructions: false,
+    include_plugin_usage_instructions: false,
+    skills: { include_instructions: false },
+    tools: { experimental_request_user_input: { enabled: false } },
+  },
+};
+
+const EFFORTS = new Set(['none', 'low', 'medium', 'high', 'xhigh', 'max', 'ultra']);
+const ITEM_TYPES = new Set(['message', 'function_call', 'function_call_output']);
+const MAX_TOOLS = 200;
+const MAX_ITEMS = 5000;
+
+const str = (v, max) => (typeof v === 'string' ? v.slice(0, max) : '');
+
+// What the server sent, in the shapes Codex takes - anything else is dropped.
+function checkTurn(a) {
+  const model = str(a && a.model, 100);
+  if (!/^[\w.:-]+$/.test(model)) throw new Error('no valid model');
+  const tools = (Array.isArray(a.tools) ? a.tools : []).slice(0, MAX_TOOLS)
+    .filter((t) => t && /^[\w.-]{1,128}$/.test(String(t.name || '')))
+    .map((t) => ({ name: String(t.name), description: str(t.description, 20000), inputSchema: t.inputSchema && typeof t.inputSchema === 'object' ? t.inputSchema : { type: 'object', properties: {} } }));
+  const items = (Array.isArray(a.items) ? a.items : []).slice(-MAX_ITEMS)
+    .filter((i) => i && typeof i === 'object' && ITEM_TYPES.has(i.type));
+  if (!items.length) throw new Error('nothing to answer');
+  return {
+    model,
+    effort: EFFORTS.has(a.effort) ? a.effort : null,
+    instructions: str(a.instructions, 4 * 1024 * 1024),
+    tools,
+    items,
+  };
+}
+
+// A tool result from the server, as Codex wants it back.
+function contentItems(r) {
+  const out = [{ type: 'inputText', text: str(r && r.text, 4 * 1024 * 1024) || '(no output)' }];
+  for (const url of (r && Array.isArray(r.images) ? r.images : []).slice(0, 20)) {
+    if (typeof url === 'string' && /^data:image\//.test(url)) out.push({ type: 'inputImage', imageUrl: url });
+  }
+  return out;
+}
+
+/**
+ * Run the turn.
+ * @param {object} args            from the server: model, effort, instructions, tools, items
+ * @param {object} io
+ * @param {(ev: object) => void} io.emit  an event for the server: {k:'text'|'reasoning', d},
+ *   {k:'tool', callId, tool, args}, {k:'usage', usage}, {k:'error', message, willRetry}
+ * @param {(callId: string) => Promise<object>} io.toolResult  waits for the server's
+ *   answer to a tool call: {ok, text, images?}
+ * @param {AbortSignal} [io.signal]
+ * @param {object} [io.env]
+ * @returns {Promise<{ok: boolean, text: string, turn?: {status: string, usage: object}}>}
+ */
+async function runTurn(args, { emit, toolResult, signal, env } = {}) {
+  let turn;
+  try { turn = checkTurn(args || {}); } catch (e) { return { ok: false, text: `(${e.message})` }; }
+  const bin = findCodex(env);
+  if (!bin) return { ok: false, text: '(Codex is not installed on this computer)', codex: { installed: false } };
+  let threadId = null;
+  let turnId = null;
+  let usage = null;
+  let finished;
+  const done = new Promise((resolve) => { finished = resolve; });
+  const onNotification = (m) => {
+    const p = m.params || {};
+    if (threadId && p.threadId && p.threadId !== threadId) return;
+    switch (m.method) {
+      case 'turn/started': turnId = (p.turn && p.turn.id) || turnId; break;
+      case 'item/agentMessage/delta': if (p.delta) emit({ k: 'text', d: String(p.delta) }); break;
+      case 'item/reasoning/summaryTextDelta':
+      case 'item/reasoning/textDelta': if (p.delta) emit({ k: 'reasoning', d: String(p.delta) }); break;
+      case 'item/reasoning/summaryPartAdded': emit({ k: 'reasoning', d: '\n\n' }); break;
+      case 'thread/tokenUsage/updated': usage = p.tokenUsage || usage; if (usage) emit({ k: 'usage', usage }); break;
+      case 'error': emit({ k: 'error', message: str(p.error && p.error.message, 2000), willRetry: !!p.willRetry }); break;
+      case 'turn/completed': finished({ status: String((p.turn && p.turn.status) || 'completed'), error: p.turn && p.turn.error ? str(p.turn.error.message, 2000) : null }); break;
+      default: break;
+    }
+  };
+  // Codex asks the client only for what the model wants: our tools. Everything else
+  // - approvals, questions to the user, logins - this client never takes.
+  const onRequest = async (m) => {
+    if (m.method !== 'item/tool/call') return undefined;
+    const p = m.params || {};
+    const callId = String(p.callId || '');
+    emit({ k: 'tool', callId, tool: String(p.tool || ''), args: p.arguments == null ? {} : p.arguments });
+    const r = await toolResult(callId);
+    return { success: !!(r && r.ok), contentItems: contentItems(r) };
+  };
+  const session = openSession(bin, { experimental: true, onRequest, onNotification });
+  const onAbort = () => {
+    if (threadId && turnId) session.request('turn/interrupt', { threadId, turnId });
+    // Codex answers an interrupt with turn/completed; one that does not is not waited for.
+    setTimeout(() => finished({ status: 'interrupted' }), 3000).unref();
+  };
+  if (signal) signal.addEventListener('abort', onAbort, { once: true });
+  try {
+    const stopped = session.ended.then((e) => ({ status: 'failed', error: e.message }));
+    const step = async (method, params) => {
+      const r = await Promise.race([session.request(method, params), stopped.then((s) => ({ error: { message: s.error } }))]);
+      if (r.error) throw new Error(`${method}: ${r.error.message || 'failed'}`);
+      return r.result || {};
+    };
+    await Promise.race([session.ready, stopped.then((s) => { throw new Error(s.error); })]);
+    if (signal && signal.aborted) return { ok: false, text: '(cancelled)', turn: { status: 'interrupted', usage } };
+    const thread = await step('thread/start', {
+      ...LOCKED,
+      cwd: emptyDir(),
+      model: turn.model,
+      baseInstructions: turn.instructions,
+      dynamicTools: turn.tools.map((t) => ({ type: 'function', ...t })),
+    });
+    threadId = thread.thread && thread.thread.id;
+    if (!threadId) throw new Error('thread/start: no thread');
+    await step('thread/inject_items', { threadId, items: turn.items });
+    // The question is the last injected item: the turn starts with nothing new.
+    const started = await step('turn/start', { threadId, input: [], ...(turn.effort ? { effort: turn.effort } : {}) });
+    turnId = (started.turn && started.turn.id) || turnId;
+    const end = await Promise.race([done, stopped]);
+    const ok = end.status === 'completed';
+    return { ok, text: ok ? 'Codex finished the turn' : `(Codex ${end.status}${end.error ? `: ${end.error}` : ''})`, turn: { status: end.status, usage } };
+  } catch (e) {
+    return { ok: false, text: `(Codex: ${e.message})`, turn: { status: 'failed', usage } };
+  } finally {
+    if (signal) signal.removeEventListener('abort', onAbort);
+    session.kill();
+  }
+}
+
+module.exports = { runTurn, checkTurn, contentItems, LOCKED };