@tensor.chat/companion 0.4.4 → 0.4.6

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.4.6",
   "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,13 @@ 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;
 const SLOW_SPAWN_MS = 2000;
 
 // What a call works on, for the log: the command, the path or the address
@@ -108,7 +102,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 +110,8 @@ 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 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 +155,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 || '');
@@ -258,7 +180,7 @@ 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);
+      r = await tools.run(tool, msg.args, ctrl.signal, Number(msg.timeoutMs) || undefined, callRoots);
     } catch (e) {
       r = { ok: false, text: `(tool error on the companion device: ${e && e.message ? e.message : e})` };
     }
@@ -275,7 +197,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();
@@ -376,11 +298,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,85 @@
+'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 BACKGROUND_FIRST_LOOK_MS = 1500;
+const FOREGROUND_DEFAULT_MS = 600000;
+
+function createToolExecutor({ shell, say = () => {}, slowSpawnMs = 2000 } = {}) {
+  const jobs = new Jobs();
+
+  async function runTool(tool, args, signal, timeoutMs, callRoots, requestedAt = Date.now(), cancelled = () => false) {
+    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 });
+      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,85 @@
+'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;
+    const worker = new Worker(this.workerPath, { 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 === '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`));
+    });
+  }
+
+  async run(tool, args, signal, timeoutMs, roots) {
+    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 });
+        try {
+          this.worker.postMessage({ t: 'call', id, tool, args, timeoutMs, entries: roots.entries, requestedAt: Date.now(), cancelled: cancelled.buffer });
+        } 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,47 @@
+'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();
+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;
+  }
+  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;
+    result = await executor.runTool(msg.tool, msg.args, ctrl.signal, msg.timeoutMs, roots, msg.requestedAt, isCancelled);
+  } catch (e) {
+    result = { ok: false, text: `(tool error on the companion device: ${e.message})` };
+  } finally {
+    running.delete(msg.id);
+  }
+  parentPort.postMessage({ t: 'result', id: msg.id, result });
+});