@tensor.chat/companion 0.3.1 → 0.4.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tensor.chat/companion",
-  "version": "0.3.1",
+  "version": "0.4.1",
   "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

@@ -13,7 +13,9 @@ 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 { createStallWatch } = require('./stalls');
 
 const VERSION = require('../package.json').version;
 const RECONNECT_MIN_MS = 1000;
@@ -21,6 +23,17 @@ 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
+function callSubject(tool, args) {
+  const a = args && typeof args === 'object' ? args : {};
+  if (tool === 'bash' || tool === 'grep') return a.command;
+  if (tool === 'glob') return a.pattern;
+  if (tool === 'fetch') return a.url;
+  if (tool === 'renamepath') return a.from;
+  return a.path;
+}
 
 function wsUrlFor(serverUrl) {
   const u = new URL(serverUrl);
@@ -82,7 +95,7 @@ function authorizeRequestedRoots(requestedRoots, labels, approvedRoots) {
   return { roots, labels: keptLabels, rejected };
 }
 
-function createDaemon({ serverUrl, token, shell, log, approvedRoots, approvedShell } = {}) {
+function createDaemon({ serverUrl, token, shell, log, approvedRoots, approvedShell, slowSpawnMs = SLOW_SPAWN_MS } = {}) {
   if (!serverUrl || !token) throw new Error('serverUrl and token are required');
   const emitter = new EventEmitter();
   const say = typeof log === 'function' ? log : () => {};
@@ -92,7 +105,8 @@ function createDaemon({ serverUrl, token, shell, log, approvedRoots, approvedShe
   const running = new Map(); // call id → AbortController
   const jobs = new Jobs();
   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 };
+  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 });
 
   function send(msg) {
     if (!state.ws || state.ws.readyState !== WebSocket.OPEN) return false;
@@ -121,7 +135,13 @@ function createDaemon({ serverUrl, token, shell, log, approvedRoots, approvedShe
         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); };
@@ -158,6 +178,12 @@ function createDaemon({ serverUrl, token, shell, log, approvedRoots, approvedShe
       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 });
@@ -189,6 +215,7 @@ function createDaemon({ serverUrl, token, shell, log, approvedRoots, approvedShe
     }
     const ctrl = new AbortController();
     running.set(id, ctrl);
+    const finished = stalls.started(tool, callSubject(tool, msg.args));
     emitter.emit('call', { id, tool: msg.tool, args: msg.args });
     let r;
     try {
@@ -202,6 +229,7 @@ function createDaemon({ serverUrl, token, shell, log, approvedRoots, approvedShe
     } catch (e) {
       r = { ok: false, text: `(tool error on the companion device: ${e && e.message ? e.message : e})` };
     }
+    finished();
     running.delete(id);
     send({ t: 'result', id, ...r });
     emitter.emit('result', { id, tool: msg.tool, ok: r.ok });
@@ -241,6 +269,16 @@ function createDaemon({ serverUrl, token, shell, log, approvedRoots, approvedShe
     }
   }
 
+  // 1006 without a reason is a connection that just ended: the server stopped hearing
+  // pings, or the network went. The last ping says which side went quiet first.
+  function closeLine(code, reason, at = Date.now()) {
+    const why = String(reason).trim();
+    const secs = (ms) => `${Math.round(ms / 1000)} s`;
+    return `disconnected: code ${code}${why ? ` "${why}"` : ''}, connected for ${secs(at - state.connectedAt)}`
+      + `, last ping from the server ${state.lastPingAt ? `${secs(at - state.lastPingAt)} ago` : 'never'}`
+      + (running.size ? `, ${running.size} call(s) running` : '');
+  }
+
   function scheduleReconnect() {
     if (state.stopped || state.timer) return;
     const wait = state.reconnectMs;
@@ -263,6 +301,8 @@ function createDaemon({ serverUrl, token, shell, log, approvedRoots, approvedShe
     state.ws = ws;
     ws.on('open', () => {
       state.connected = true;
+      state.connectedAt = Date.now();
+      state.lastPingAt = null;
       state.reconnectMs = RECONNECT_MIN_MS;
       send(systemInfo(shell, !!localApprovals && !!localShellApproval));
       flushExits();
@@ -270,6 +310,7 @@ function createDaemon({ serverUrl, token, shell, log, approvedRoots, approvedShe
       emitter.emit('connected');
     });
     ws.on('message', onMessage);
+    ws.on('ping', () => { state.lastPingAt = Date.now(); });
     ws.on('unexpected-response', (_req, res) => {
       const code = res && res.statusCode;
       say(`server refused the connection (HTTP ${code})`);
@@ -283,6 +324,7 @@ function createDaemon({ serverUrl, token, shell, log, approvedRoots, approvedShe
     ws.on('error', (e) => { say(`socket error: ${e.message}`); });
     ws.on('close', (code, reason) => {
       const was = state.connected;
+      if (was) say(closeLine(code, reason));
       state.connected = false;
       state.ws = null;
       for (const c of running.values()) c.abort();
@@ -295,9 +337,10 @@ function createDaemon({ serverUrl, token, shell, log, approvedRoots, approvedShe
   return {
     events: emitter,
     state,
-    start() { state.stopped = false; connect(); return this; },
+    start() { state.stopped = false; stalls.start(); connect(); return this; },
     stop() {
       state.stopped = true;
+      stalls.stop();
       if (state.timer) { clearTimeout(state.timer); state.timer = null; }
       for (const c of running.values()) c.abort();
       jobs.killAll();
@@ -308,4 +351,4 @@ function createDaemon({ serverUrl, token, shell, log, approvedRoots, approvedShe
   };
 }
 
-module.exports = { createDaemon, wsUrlFor, systemInfo, authorizeRequestedRoots, VERSION };
+module.exports = { createDaemon, wsUrlFor, systemInfo, authorizeRequestedRoots, callSubject, VERSION };

package/src/stalls.js

@@ -0,0 +1,53 @@
+'use strict';
+// A process that is stuck answers no ping, and the server drops the computer as gone.
+// Nothing in the process can say so while it is stuck, so this says it afterwards: how
+// long, and which calls were under way in that time. A computer asleep stops the process
+// the same way; the words leave both open (the desktop app logs the sleep itself).
+
+const TICK_MS = 1000;
+const STUCK_MS = 5000;
+const KEEP = 30;
+
+function createStallWatch({ say, tickMs = TICK_MS, stuckMs = STUCK_MS, now = Date.now } = {}) {
+  const calls = []; // the last KEEP calls, finished or not
+  let last = now();
+  let timer = null;
+
+  function started(tool, what) {
+    const call = { tool: String(tool), what: String(what || '').replace(/\s+/g, ' ').trim().slice(0, 80), start: now(), end: null };
+    calls.push(call);
+    if (calls.length > KEEP) calls.shift();
+    return () => { call.end = now(); };
+  }
+
+  // A call that finished during the stall counts too: the work that held the process
+  // usually is that call, and it is done by the time the timer can run again.
+  function during(from, to) {
+    return calls
+      .filter((c) => c.start <= to && (c.end == null || c.end >= from))
+      .map((c) => `${c.tool}${c.what ? ` "${c.what}"` : ''} (${c.end == null ? 'still running' : `took ${Math.round((c.end - c.start) / 1000)} s`})`);
+  }
+
+  function tick() {
+    const t = now();
+    const gap = t - last;
+    last = t;
+    if (gap - tickMs < stuckMs) return;
+    const what = during(t - gap, t);
+    say(`this process did not run for ${Math.round(gap / 1000)} s (busy, or the computer slept)${what.length ? ` - calls in that time: ${what.join('; ')}` : ''}`);
+  }
+
+  return {
+    started,
+    tick,
+    start() {
+      if (timer) return;
+      last = now();
+      timer = setInterval(tick, tickMs);
+      if (timer.unref) timer.unref();
+    },
+    stop() { if (timer) { clearInterval(timer); timer = null; } },
+  };
+}
+
+module.exports = { createStallWatch, TICK_MS, STUCK_MS };

package/src/tools/files.js

@@ -114,20 +114,30 @@ function edit(roots, p, edits) {
   const original = fs.readFileSync(r.abs, 'utf8');
   if (original.includes('\u0000')) return err(`(cannot edit ${roots.display(r.abs)} — binary content)`);
   const eol = original.includes('\r\n') ? '\r\n' : '\n';
+  // All edits or none: every edit is checked, and every failing one is named, so
+  // the model can fix them in one retry and knows nothing was written.
+  const problems = [];
+  let notFound = false;
   let next = original;
   let i = 0;
   for (const e of edits) {
     i++;
+    const label = edits.length === 1 ? '' : `Edit ${i}: `;
     const search = String(e && e.search != null ? e.search : '');
     const replace = String(e && e.replace != null ? e.replace : '');
     const searchN = eol === '\r\n' ? search.replace(/\r?\n/g, '\r\n') : search;
     const replaceN = eol === '\r\n' ? replace.replace(/\r?\n/g, '\r\n') : replace;
-    if (!searchN) return err(`(edit ${i}: empty search text)`);
+    if (!searchN) { problems.push(`${label}search text is empty`); continue; }
     const n = countOccurrences(next, searchN);
-    if (n === 0) return err(`(edit ${i}: search text not found in ${roots.display(r.abs)} — Read the file and copy the current text exactly)`);
-    if (n > 1) return err(`(edit ${i}: search text occurs ${n} times in ${roots.display(r.abs)} — include more context so it is unique)`);
+    if (n === 0) { problems.push(`${label}search text not found`); notFound = true; continue; }
+    if (n > 1) { problems.push(`${label}search text occurs ${n} times — include more context so it is unique`); continue; }
     next = next.replace(searchN, () => replaceN);
   }
+  if (problems.length) {
+    const shown = roots.display(r.abs);
+    const head = edits.length === 1 ? `The edit was not applied to ${shown}: ` : `None of the ${edits.length} edits were applied to ${shown}. `;
+    return err(`(${head}${problems.join('; ')}.${notFound ? ' Read the file and copy the current text exactly.' : ''})`);
+  }
   fs.writeFileSync(r.abs, next, 'utf8');
   return ok(`(edited ${roots.display(r.abs)}: ${edits.length} replacement${edits.length === 1 ? '' : 's'})`, { touched: [r.abs] });
 }

package/src/tools/outside.js

@@ -0,0 +1,101 @@
+'use strict';
+// Which folders outside the shared ones does a shell command name? The safety check on
+// the server can only guess what "$env:USERPROFILE\.voicetype" means - this computer
+// knows (03.10.2026: four commands like that left it "not sure"). Every path-looking
+// word of the command, with this machine's variables put in, that names an existing
+// file or folder - or a new file in an existing folder - and lies outside every shared
+// folder counts, as the folder that holds it. A command can reach further than its
+// words (a script reads what it likes): this helps the question, it is no fence.
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { isInside, realExisting } = require('../paths');
+
+const MAX_FOLDERS = 10;
+const MAX_WORDS = 2000;
+// What ends a path written without quotes
+const STOP = '\\s"\'<>|*?;,`()';
+const WIN_ABS = new RegExp(`(?<![\\w\\\\/])[A-Za-z]:[\\\\/][^${STOP}]*`, 'g');
+const UNC = new RegExp(`(?<![\\w\\\\])\\\\\\\\[^${STOP}\\\\]+\\\\[^${STOP}]+`, 'g');
+const DOTDOT = new RegExp(`(?<![\\w.\\\\/])\\.\\.(?:[\\\\/][^${STOP}]*)?(?![\\w.])`, 'g');
+const POSIX_ABS = new RegExp(`(?<![\\w.~\\\\/:])/[^${STOP}]+`, 'g');
+const WHOLE_PATH = /^(?:[A-Za-z]:[\\/]|\\\\|\.\.(?:[\\/]|$)|\/)/;
+
+// The command as this machine reads it: PowerShell's $env:NAME, cmd's %NAME%, the
+// POSIX $NAME and ${NAME}, and ~ for the home folder. A name it does not know stays.
+function expand(command, { env, home, platform }) {
+  const keys = Object.keys(env);
+  const get = (name) => {
+    const key = platform === 'win32' ? keys.find((k) => k.toLowerCase() === name.toLowerCase()) : (name in env ? name : null);
+    if (key != null && env[key] != null) return String(env[key]);
+    return /^(home|userprofile)$/i.test(name) ? home : null;
+  };
+  return String(command == null ? '' : command)
+    .replace(/\$\{env:([A-Za-z_][\w()]*)\}|\$env:([A-Za-z_]\w*)/gi, (m, a, b) => get(a || b) ?? m)
+    .replace(/%([A-Za-z_][\w()]*)%/g, (m, n) => get(n) ?? m)
+    .replace(/\$\{([A-Za-z_]\w*)\}|\$([A-Za-z_]\w*)/g, (m, a, b) => get(a || b) ?? m)
+    .replace(/(^|[\s"'=(])~(?=[\\/]|$|[\s"')])/g, (m, pre) => pre + home);
+}
+
+// The words that may be paths: a quoted one that starts like a path is one path,
+// spaces and all - cut at a space, "R:\Projekte\Open Chat Pal\x" named a stray file
+// "R:\Projekte\Open". Other quoted text (a -Command "...") and the rest are searched.
+function words(text, platform) {
+  const out = [];
+  const scan = (s) => {
+    for (const re of platform === 'win32' ? [WIN_ABS, UNC, DOTDOT] : [WIN_ABS, UNC, DOTDOT, POSIX_ABS]) {
+      re.lastIndex = 0;
+      let m;
+      while ((m = re.exec(s)) && out.length < MAX_WORDS) out.push(m[0]);
+    }
+  };
+  const rest = text.replace(/"([^"]*)"|'([^']*)'/g, (m, a, b) => {
+    const inner = a != null ? a : b;
+    if (WHOLE_PATH.test(inner)) out.push(inner); else scan(inner);
+    return ' ';
+  });
+  scan(rest);
+  // A full stop or comma after a path belongs to the sentence; ".." stays itself
+  return out.map((w) => w.replace(/[,;:\]}]+$/, '').replace(/([^.])\.$/, '$1')).filter(Boolean);
+}
+
+function statOf(p) {
+  try { return fs.statSync(p); } catch (_) { return null; }
+}
+
+// The folder a word stands for: the folder itself, the folder of a file, or the folder
+// a new file would go into. Anything else is not a path on this machine.
+function folderOf(word, cwd) {
+  const abs = path.resolve(cwd, word);
+  const st = statOf(abs);
+  if (st) return st.isDirectory() ? abs : path.dirname(abs);
+  if (!/\.[A-Za-z0-9]{1,8}$/.test(path.basename(abs))) return null;
+  const parent = path.dirname(abs);
+  const ps = statOf(parent);
+  return ps && ps.isDirectory() && path.parse(parent).root !== parent ? parent : null;
+}
+
+function outsideFolders(roots, command, { cwd, env = process.env, home = os.homedir(), platform = process.platform } = {}) {
+  const shared = roots.okRoots().map((r) => r.real);
+  const found = [];
+  for (const word of words(expand(command, { env, home, platform }), platform)) {
+    const folder = folderOf(word, cwd || home);
+    if (!folder) continue;
+    const real = realExisting(folder) || folder;
+    if (shared.some((r) => isInside(real, r))) continue;
+    if (!found.some((f) => isInside(folder, f) && isInside(f, folder))) found.push(folder);
+  }
+  // A folder inside another one found is covered by it
+  const folders = found
+    .filter((f) => !found.some((g) => g !== f && isInside(f, g) && !isInside(g, f)))
+    .slice(0, MAX_FOLDERS)
+    // A whole drive, the home folder or what holds it is too much to share in one click
+    .map((f) => ({ path: f, broad: path.parse(f).root === f || isInside(home, f) }));
+  const text = folders.length
+    ? `(outside the shared folders: ${folders.map((f) => f.path).join(', ')})`
+    : '(nothing outside the shared folders)';
+  return { ok: true, text, folders };
+}
+
+module.exports = { outsideFolders, expand, words };