@tensor.chat/companion 0.4.0 → 0.4.2

package/package.json

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

@@ -15,6 +15,7 @@ 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;
@@ -22,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);
@@ -83,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 : () => {};
@@ -93,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;
@@ -122,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); };
@@ -196,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 {
@@ -209,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 });
@@ -248,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;
@@ -270,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();
@@ -277,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})`);
@@ -290,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();
@@ -302,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();
@@ -315,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

@@ -24,17 +24,32 @@ 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 }) {
+// A variable that holds a list of folders (PATH and its kind) stays as written too: a
+// list names no one place, and most commands only add to it - put in, every folder on
+// the list read as named, and a test run was asked about ten folders. Its entries go to
+// `lists`, under the name the command wrote.
+function expand(command, { env, home, platform }, lists = []) {
   const keys = Object.keys(env);
+  const sep = platform === 'win32' ? ';' : ':';
+  const absolute = platform === 'win32' ? path.win32.isAbsolute : path.posix.isAbsolute;
   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;
   };
+  const put = (m, name) => {
+    const value = get(name);
+    if (value == null) return m;
+    // A list holds at least two paths of this system ("C:\x" is no list where ":" separates)
+    const entries = value.split(sep).filter(Boolean);
+    if (entries.filter(absolute).length < 2) return value;
+    if (!lists.some((l) => l.name === name)) lists.push({ name, entries });
+    return m;
+  };
   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(/\$\{env:([A-Za-z_][\w()]*)\}|\$env:([A-Za-z_]\w*)/gi, (m, a, b) => put(m, a || b))
+    .replace(/%([A-Za-z_][\w()]*)%/g, (m, n) => put(m, n))
+    .replace(/\$\{([A-Za-z_]\w*)\}|\$([A-Za-z_]\w*)/g, (m, a, b) => put(m, a || b))
     .replace(/(^|[\s"'=(])~(?=[\\/]|$|[\s"')])/g, (m, pre) => pre + home);
 }
 
@@ -78,22 +93,36 @@ function folderOf(word, cwd) {
 
 function outsideFolders(roots, command, { cwd, env = process.env, home = os.homedir(), platform = process.platform } = {}) {
   const shared = roots.okRoots().map((r) => r.real);
+  const outside = (folder) => !shared.some((r) => isInside(realExisting(folder) || folder, r));
+  const same = (a, b) => isInside(a, b) && isInside(b, a);
   const found = [];
-  for (const word of words(expand(command, { env, home, platform }), platform)) {
+  const lists = [];
+  for (const word of words(expand(command, { env, home, platform }, lists), 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);
+    if (!folder || !outside(folder)) continue;
+    if (!found.some((f) => same(folder, f))) 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 named = found.filter((f) => !found.some((g) => g !== f && isInside(f, g) && !isInside(g, f)));
+  // A list's folders come after the named ones and cover none of them: whatever the
+  // server makes of the list, a folder the command names is asked for by itself
+  const listed = [];
+  for (const { name, entries } of lists) {
+    for (const entry of entries) {
+      const st = path.isAbsolute(entry) ? statOf(entry) : null;
+      if (!st || !st.isDirectory() || !outside(entry)) continue;
+      if (![...named, ...listed.map((l) => l.path)].some((f) => same(entry, f))) listed.push({ path: entry, from: name });
+    }
+  }
+  // A whole drive, the home folder or what holds it is too much to share in one click
+  const broad = (f) => path.parse(f).root === f || isInside(home, f);
+  const folders = [
+    ...named.map((f) => ({ path: f, broad: broad(f) })),
+    ...listed.map((l) => ({ path: l.path, broad: broad(l.path), from: l.from })),
+  ].slice(0, MAX_FOLDERS);
+  const said = (f) => (f.from ? `${f.path} (from ${f.from})` : f.path);
   const text = folders.length
-    ? `(outside the shared folders: ${folders.map((f) => f.path).join(', ')})`
+    ? `(outside the shared folders: ${folders.map(said).join(', ')})`
     : '(nothing outside the shared folders)';
   return { ok: true, text, folders };
 }