@tensor.chat/companion 0.4.3 → 0.4.6

package/src/setup/wizard.js

@@ -70,40 +70,55 @@ function runSetup({
       const { rows } = screen.size();
       const w = contentWidth();
       const step = STEP[st.screen];
-      const steps = t('steps').map((name, i) => (i < step ? S.green(`✔ ${name}`) : i === step ? S.bold(S.cyan(`● ${name}`)) : S.dim(`○ ${name}`))).join(S.dim('  ─  '));
-      const top = [
-        '',
-        '  ' + spread(`${S.cyan('◆')} ${S.bold('Tensor.Chat Companion')}  ${S.dim(t('setup'))}`, S.dim([device, user].filter(Boolean).join(' · ')), w),
-        '  ' + steps,
-        '',
-        '  ' + spread(S.bold(title), right, w),
-        '',
-      ];
-      // the status, or the help for the line under the cursor; two lines at most
-      const note = st.message ? wrap(st.message.text, w).slice(0, 2).map((l) => '  ' + S[st.message.tone](l)) : wrap(help, w).slice(0, 2).map((l) => '  ' + S.dim(l));
-      const bottom = [
-        ...(note.length ? note : ['']),
-        '  ' + S.dim('─'.repeat(w)),
-        ...keyLines(keys, w),
-      ];
-      const space = Math.max(3, rows - top.length - bottom.length - 1);
+      // A narrow screen names only the current step, and puts what does not fit beside
+      // the brand or the title on a line of its own
+      const stepLine = (named) => t('steps').map((name, i) => {
+        const label = (mark) => (named || i === step ? `${mark} ${name}` : mark);
+        return i < step ? S.green(label('✔')) : i === step ? S.bold(S.cyan(label('●'))) : S.dim(label('○'));
+      }).join(S.dim('  ─  '));
+      const steps = width(stepLine(true)) <= w ? stepLine(true) : stepLine(false);
+      const besides = (left, rightPart) => (!rightPart || width(left) + 1 + width(rightPart) <= w ? [spread(left, rightPart, w)] : [left, rightPart]);
+      const heading = width(title) <= w ? [S.bold(title)] : wrap(title, w).map((l) => S.bold(l));
+      const parts = layout.squeeze({
+        rows,
+        width: w,
+        brand: besides(`${S.cyan('◆')} ${S.bold('Tensor.Chat Companion')}  ${S.dim(t('setup'))}`, S.dim([device, user].filter(Boolean).join(' · '))),
+        steps,
+        heading: [...heading.slice(0, -1), ...besides(heading[heading.length - 1], right)],
+        // the status, or the help for the line under the cursor
+        note: st.message ? wrap(st.message.text, w).map((l) => S[st.message.tone](l)) : wrap(help, w).map((l) => S.dim(l)),
+        rule: S.dim('─'.repeat(w)),
+        keys: keyLines(keys, w),
+      });
+      const { top, bottom, gap } = parts;
+      const space = Math.max(3, rows - top.length - bottom.length - gap);
       let start = 0;
       if (body.length > space) start = Math.min(Math.max(0, focus - Math.floor(space / 2)), body.length - space);
       const shown = body.slice(start, start + space);
       if (start > 0) shown[0] = '      ' + S.dim('↑');
       if (start + space < body.length) shown[shown.length - 1] = '      ' + S.dim('↓');
       while (shown.length < space) shown.push('');
-      return [...top, ...shown, '', ...bottom];
+      return [...top, ...shown, ...(gap ? [''] : []), ...bottom];
     }
 
     const pointer = (on) => (on ? S.cyan('❯') : ' ');
+    // One line per choice, its note beside it; when one note does not fit there, every
+    // note goes under its choice. `at` is the line of the choice under the cursor.
     function radio(options, cursor) {
+      const w = contentWidth();
       const col = Math.min(LABEL_MAX, Math.max(...options.map((o) => width(o.label))) + 3);
-      return options.map((o, i) => {
+      const below = options.some((o) => o.note && 4 + col + width(o.note) > w);
+      const lines = [];
+      options.forEach((o, i) => {
         const on = i === cursor;
-        const note = o.note ? (o.tone ? S[o.tone](o.note) : S.dim(o.note)) : '';
-        return `  ${pointer(on)} ${on ? S.cyan('●') : S.dim('○')} ${cell(on ? S.bold(o.label) : o.label, col)}${note}`;
+        const tone = (s) => (o.tone ? S[o.tone](s) : S.dim(s));
+        const head = `  ${pointer(on)} ${on ? S.cyan('●') : S.dim('○')} `;
+        if (on) lines.at = lines.length;
+        if (!o.note) lines.push(head + (on ? S.bold(o.label) : o.label));
+        else if (!below) lines.push(head + cell(on ? S.bold(o.label) : o.label, col) + tone(o.note));
+        else lines.push(head + (on ? S.bold(o.label) : o.label), ...wrap(o.note, w - 4).map((l) => '      ' + tone(l)));
       });
+      return lines;
     }
 
     function box(state) {
@@ -128,11 +143,13 @@ function runSetup({
         { label: t('start.nothing'), note: t('start.nothingNote') },
         { label: t('start.everything'), note: t('start.everythingNote'), tone: 'yellow' },
       ];
-      const { cols } = screen.size();
-      const body = [...radio(opts, st.cursor.start), '', ...wrap(t('start.help'), Math.min(cols - 6, CONTENT_MAX)).map((l) => '  ' + S.dim(l))];
+      const w = contentWidth();
+      const choices = radio(opts, st.cursor.start);
+      const body = [...choices, '', ...wrap(t('start.help'), w).map((l) => '  ' + S.dim(l))];
       if (initial.length) body.push('', '  ' + S.dim(t('start.now')), ...initial.slice(0, 4).map((r) => `    ${S.green('◼')} ${show(r)}`), ...(initial.length > 4 ? ['    …'] : []));
-      body.push('', '  ' + S.dim(t('start.later')) + ' ' + S.cyan('npx @tensor.chat/companion setup'));
-      return frame({ title: t('start.title'), body, focus: st.cursor.start, keys: [['↑↓', K.move], [N.enter, K.select], [N.esc, K.quit]] });
+      const again = 'npx @tensor.chat/companion setup';
+      body.push('', ...(width(t('start.later')) + 1 + again.length <= w ? ['  ' + S.dim(t('start.later')) + ' ' + S.cyan(again)] : ['  ' + S.dim(t('start.later')), '  ' + S.cyan(again)]));
+      return frame({ title: t('start.title'), body, focus: choices.at, keys: [['↑↓', K.move], [N.enter, K.select], [N.esc, K.quit]] });
     }
 
     function placeRows() {
@@ -168,7 +185,8 @@ function runSetup({
     function placesView() {
       const rows = placeRows();
       const cur = Math.min(st.cursor.places, rows.length - 1);
-      const labels = rows.filter((r) => r.type === 'place').map((r) => width(show(r.path)));
+      const name = (r) => layout.shorten(show(r.path), contentWidth() - 4);
+      const labels = rows.filter((r) => r.type === 'place').map((r) => width(name(r)));
       const col = Math.min(LABEL_MAX, Math.max(12, ...labels) + 3);
       const body = [];
       let focus = 0;
@@ -180,8 +198,10 @@ function runSetup({
         if (on) focus = body.length;
         if (r.type === 'place') {
           const state = tickState(r.path, st.selected, platform);
-          const label = on ? S.bold(show(r.path)) : show(r.path);
-          body.push(`  ${pointer(on)} ${box(state)} ${cell(label, col)}${placeNote(r, state)}`);
+          const label = on ? S.bold(name(r)) : name(r);
+          const note = placeNote(r, state);
+          if (4 + Math.max(col, width(label) + 2) + width(note) <= contentWidth()) body.push(`  ${pointer(on)} ${box(state)} ${cell(label, col)}${note}`);
+          else body.push(`  ${pointer(on)} ${box(state)} ${label}`, ...wrap(note, contentWidth() - 4).map((l) => '      ' + l));
         } else if (r.type === 'continue') {
           body.push(`  ${pointer(on)} ${on ? S.bold(S.cyan(t('places.continue') + ' →')) : S.cyan(t('places.continue') + ' →')}`);
         } else {
@@ -240,21 +260,26 @@ function runSetup({
       if (isRoot) text.push(S.red(t('everything.root')));
       text.push('', S.yellow(t('everything.free')));
       const body = [...panel(text, 'yellow'), ''];
-      body.push(...radio([{ label: t('everything.no') }, { label: t('everything.yes'), tone: 'yellow' }], st.cursor.everything));
-      return frame({ title: `${S.yellow('▲')}  ${t('everything.title')}`, body, focus: body.length - 1, keys: [['↑↓', K.move], [N.enter, K.select], [N.esc, K.back]] });
+      const choices = radio([{ label: t('everything.no') }, { label: t('everything.yes'), tone: 'yellow' }], st.cursor.everything);
+      const focus = body.length + choices.at;
+      body.push(...choices);
+      return frame({ title: `${S.yellow('▲')}  ${t('everything.title')}`, body, focus, keys: [['↑↓', K.move], [N.enter, K.select], [N.esc, K.back]] });
     }
 
     function shellOptions() {
       const quiet = t('shell.noNote');
       const list = shellUntil
-        ? [{ id: 'keep', label: t('shell.keep'), note: t('shell.keepNote', { date: t.date(shellUntil) }) }, { id: 'off', label: t('shell.off'), note: quiet }]
+        ? [{ id: 'keep', label: t('shell.keep'), note: t('shell.keepNote', { date: t.date(shellUntil) }) }, { id: 'off', label: t('shell.off'), note: t('shell.offNote') }]
         : [{ id: 'no', label: t('shell.no'), note: quiet }];
       return [...list, { id: 7, label: t('shell.d7') }, { id: 30, label: t('shell.d30') }, { id: 365, label: t('shell.d365'), tone: 'yellow' }];
     }
 
     function shellView() {
-      const body = [...panel([t('shell.body', { user: user || '?' })]), '', ...radio(shellOptions(), st.cursor.shell)];
-      return frame({ title: t('shell.title'), body, focus: body.length - 1, keys: [['↑↓', K.move], [N.enter, K.select], [N.esc, K.back]] });
+      const body = [...panel([t('shell.body', { user: user || '?' })]), ''];
+      const choices = radio(shellOptions(), st.cursor.shell);
+      const focus = body.length + choices.at;
+      body.push(...choices);
+      return frame({ title: t('shell.title'), body, focus, keys: [['↑↓', K.move], [N.enter, K.select], [N.esc, K.back]] });
     }
 
     function changes() {

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 });
+});