@7ots/cli 0.1.5 → 0.1.6

package/cli/lib/screen.mjs

@@ -0,0 +1,125 @@
+/**
+ * Screen awareness (access.screen, off by default): so the pet knows what you are doing.
+ *  · every 20 s: the active window's title and app (xdotool, X11) → "apps lately"
+ *  · every N minutes (config.screen.every, default 5), if you are at the computer and something changed:
+ *    a screenshot (scaled down, ~/.7ots/screen/now.jpg, 0600) that the brain looks at and sums up in one line,
+ *    then the file is deleted. Brains that can't see images (or no screenshot tool) get the window titles instead.
+ * What it saw is kept in ~/.7ots/seen.json (last 60) and shown on /settings → Memory; it feeds the pet's comments.
+ */
+
+import { execFile } from 'node:child_process';
+import { existsSync, mkdirSync, unlinkSync } from 'node:fs';
+import { join } from 'node:path';
+import { homeFile, readJson, writeJson } from './paths.mjs';
+
+const run = (cmd, args, ms = 4000) => new Promise((res) => execFile(cmd, args, { timeout: ms }, (e, out) => res(e ? '' : String(out).trim())));
+const MAX = 60;
+
+export function createScreenWatcher({ brain, enabled, every = () => 5, lang = 'en', log = () => {}, onSeen = () => {} }) {
+  const file = homeFile('seen.json');
+  const seen = readJson(file, null) || { looks: [], windows: [] };
+  const save = () => writeJson(file, seen, { secret: true });
+  let lastWin = '';
+  let lastMouse = '';
+  let lastLook = 0;
+  let changed = false;
+  let busy = false;
+  const x11 = process.platform === 'linux' && process.env.DISPLAY;
+
+  async function activeWindow() {
+    if (!x11) return null;
+    const id = await run('xdotool', ['getactivewindow']);
+    if (!id) return null;
+    const [title, cls] = await Promise.all([run('xdotool', ['getwindowname', id]), run('xprop', ['-id', id, 'WM_CLASS'])]);
+    const app = cls.match(/"([^"]*)"\s*$/)?.[1] || '';
+    if (/7ots/i.test(title)) return null;
+    return { title: title.slice(0, 160), app };
+  }
+
+  async function tickWindows() {
+    if (!enabled()) return;
+    const w = await activeWindow();
+    const mouse = x11 ? await run('xdotool', ['getmouselocation']) : '';
+    if (mouse !== lastMouse) (changed = true), (lastMouse = mouse);
+    if (!w) return;
+    const key = `${w.app}|${w.title}`;
+    if (key === lastWin) return;
+    lastWin = key;
+    changed = true;
+    seen.windows.push({ at: Date.now(), ...w });
+    if (seen.windows.length > MAX) seen.windows.shift();
+    save();
+  }
+
+  async function screenshot() {
+    const dir = homeFile('screen');
+    mkdirSync(dir, { recursive: true, mode: 0o700 });
+    const f = join(dir, 'now.jpg');
+    if (process.platform === 'darwin') await run('screencapture', ['-x', '-t', 'jpg', f]);
+    else if (x11) await run('import', ['-silent', '-window', 'root', '-resize', '1280x1280>', '-quality', '70', f], 8000);
+    return existsSync(f) ? f : null;
+  }
+
+  async function look({ force = false } = {}) {
+    if (!enabled() || busy || brain.kind === 'lines') return null;
+    if (!force && (!changed || Date.now() - lastLook < every() * 60_000)) return null;
+    busy = true;
+    changed = false;
+    lastLook = Date.now();
+    let f = null;
+    try {
+      f = brain.vision ? await screenshot() : null;
+      const recent = seen.windows.slice(-8).map((w) => `${w.app}: ${w.title}`).join('\n');
+      const ask = f
+        ? `This is a screenshot of your human's screen right now (file ${f}). Recently active windows:\n${recent}`
+        : `You can't see the screen, only the recently active windows (app: title):\n${recent || '(none)'}`;
+      const raw = await brain.think({
+        purpose: 'screen',
+        system: `You quietly keep track of what your human is doing on their computer, to help them later. Never transcribe private content (passwords, messages, personal data): summarize the activity.`,
+        messages: [{ role: 'user', content: `${ask}\n\nAnswer ONLY with JSON: {"doing": "one short line: the app and the task they are on, in ${lang}", "say": "optional: one short, useful or playful remark to them in ${lang} if something deserves it (an error on screen, a long session, a tip); else empty"}` }],
+        files: f ? [f] : null,
+        timeoutMs: 90000,
+        raw: true,
+      });
+      const j = JSON.parse(String(raw).match(/\{[\s\S]*\}/)?.[0] || '{}');
+      if (!j.doing) return null;
+      const row = { at: Date.now(), doing: String(j.doing).slice(0, 200), say: String(j.say || '').slice(0, 200), how: f ? 'screenshot' : 'windows' };
+      seen.looks.push(row);
+      if (seen.looks.length > MAX) seen.looks.shift();
+      save();
+      onSeen(row);
+      return row;
+    } catch (e) {
+      log(`screen: ${e.message}`);
+      return null;
+    } finally {
+      busy = false;
+      if (f) {
+        try {
+          unlinkSync(f);
+        } catch {}
+      }
+    }
+  }
+
+  const t1 = setInterval(tickWindows, 20_000);
+  const t2 = setInterval(() => look(), 60_000);
+  t1.unref?.();
+  t2.unref?.();
+  return {
+    look,
+    get seen() {
+      return seen;
+    },
+    now: () => seen.looks.at(-1) || null,
+    forget() {
+      seen.looks = [];
+      seen.windows = [];
+      save();
+    },
+    stop() {
+      clearInterval(t1);
+      clearInterval(t2);
+    },
+  };
+}

package/cli/lib/stt-local.py

@@ -0,0 +1,14 @@
+"""Local speech to text for the 7ots pet: python stt-local.py <audio file> [lang] [model] → prints the text.
+Runs in the venv ~/.7ots/stt (pip install faster-whisper); the model (base, ~140 MB) is cached on first use.
+Audio is decoded with ffmpeg (16 kHz mono) instead of PyAV, whose newer releases break faster-whisper."""
+import subprocess
+import sys
+
+import numpy as np
+from faster_whisper import WhisperModel
+
+pcm = subprocess.run(['ffmpeg', '-nostdin', '-loglevel', 'error', '-i', sys.argv[1], '-f', 'f32le', '-ac', '1', '-ar', '16000', '-'], capture_output=True, check=True).stdout
+audio = np.frombuffer(pcm, dtype=np.float32)
+model = WhisperModel(sys.argv[3] if len(sys.argv) > 3 else 'base', device='cpu', compute_type='int8')
+segments, _ = model.transcribe(audio, language=(sys.argv[2] or None) if len(sys.argv) > 2 else None, vad_filter=True, beam_size=1)
+print(' '.join(s.text.strip() for s in segments).strip())

package/cli/lib/stt.mjs

@@ -0,0 +1,68 @@
+/**
+ * Speech to text for voice control: the pet page records a short clip (webm/opus) and POSTs it to /stt.
+ * Local first: faster-whisper in the venv ~/.7ots/stt (free, the audio never leaves the machine):
+ *   python3 -m venv ~/.7ots/stt && ~/.7ots/stt/bin/pip install faster-whisper
+ * otherwise whichever key is configured: OpenAI (OPENAI_API_KEY), then ElevenLabs (ELEVENLABS_API_KEY).
+ * Without any, voice control is off and the page says so.
+ */
+
+import { execFile } from 'node:child_process';
+import { existsSync, unlinkSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { homeFile } from './paths.mjs';
+
+const LOCAL_PY = () => homeFile(join('stt', 'bin', 'python'));
+const SCRIPT = new URL('./stt-local.py', import.meta.url).pathname;
+
+const EXT = { 'audio/webm': 'webm', 'audio/ogg': 'ogg', 'audio/mp4': 'm4a', 'audio/mpeg': 'mp3', 'audio/wav': 'wav' };
+
+export function sttProvider(keys) {
+  if (existsSync(LOCAL_PY())) return 'local';
+  if (keys.OPENAI_API_KEY) return 'openai';
+  if (keys.ELEVENLABS_API_KEY) return 'elevenlabs';
+  return null;
+}
+
+/** → { text } ; throws with .status on provider errors. */
+export async function transcribe({ audio, contentType = 'audio/webm', lang = '', env = {} }) {
+  const provider = sttProvider(env);
+  if (!provider) throw Object.assign(new Error('no speech-to-text key (OPENAI_API_KEY or ELEVENLABS_API_KEY)'), { status: 501 });
+  const type = String(contentType).split(';')[0].trim();
+  if (provider === 'local') {
+    const f = join(tmpdir(), `7ots-voice-${process.pid}-${Date.now()}.${EXT[type] || 'webm'}`);
+    writeFileSync(f, audio, { mode: 0o600 });
+    try {
+      const text = await new Promise((res, rej) =>
+        execFile(LOCAL_PY(), [SCRIPT, f, lang || ''], { timeout: 60000 }, (e, out) => (e ? rej(Object.assign(new Error(`local stt: ${e.message.split('\n')[0]}`), { status: 502 })) : res(String(out).trim()))),
+      );
+      return { text, provider };
+    } finally {
+      try {
+        unlinkSync(f);
+      } catch {}
+    }
+  }
+  const file = new Blob([audio], { type });
+  const name = `voice.${EXT[type] || 'webm'}`;
+  const form = new FormData();
+  let url;
+  let headers;
+  if (provider === 'openai') {
+    url = 'https://api.openai.com/v1/audio/transcriptions';
+    headers = { Authorization: `Bearer ${env.OPENAI_API_KEY}` };
+    form.append('model', 'gpt-4o-mini-transcribe');
+    form.append('file', file, name);
+    if (lang) form.append('language', lang);
+  } else {
+    url = 'https://api.elevenlabs.io/v1/speech-to-text';
+    headers = { 'xi-api-key': env.ELEVENLABS_API_KEY };
+    form.append('model_id', 'scribe_v1');
+    form.append('file', file, name);
+    if (lang) form.append('language_code', lang);
+  }
+  const res = await fetch(url, { method: 'POST', headers, body: form, signal: AbortSignal.timeout(30000) });
+  if (!res.ok) throw Object.assign(new Error(`${provider} stt ${res.status}`), { status: 502 });
+  const j = await res.json();
+  return { text: String(j.text || '').trim(), provider };
+}

package/cli/lib/tts-local.mjs

@@ -0,0 +1,110 @@
+/**
+ * Local voice: Piper (https://github.com/rhasspy/piper) in the venv ~/.7ots/stt, voices in ~/.7ots/voices.
+ * Free and offline; the text never leaves the machine. Set up with:
+ *   ~/.7ots/stt/bin/pip install piper-tts
+ *   ~/.7ots/stt/bin/python -m piper.download_voices es_MX-claude-high en_US-lessac-medium --download-dir ~/.7ots/voices
+ * The voice follows the language of each line (a Spanish line gets a Spanish voice), a bit higher-pitched for an ot.
+ */
+
+import { execFile, spawn } from 'node:child_process';
+import { existsSync, readdirSync, readFileSync, unlinkSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { homeFile } from './paths.mjs';
+
+const PY = () => homeFile(join('stt', 'bin', 'python'));
+const DIR = () => homeFile('voices');
+
+export function localVoices() {
+  if (!existsSync(PY()) || !existsSync(DIR())) return [];
+  return readdirSync(DIR()).filter((f) => f.endsWith('.onnx')).map((f) => f.slice(0, -5));
+}
+
+const ES = /[ñ¿¡áéíóú]|\b(que|el|la|los|las|de|es|por|para|con|una?|hola|estoy|tienes|aquí|qué|cómo|ya|pero|muy)\b/gi;
+const PT = /[ãõç]|\b(você|não|está|obrigad[oa]|olá|muito|tudo)\b/gi;
+function guessLang(text, fallback) {
+  const es = (text.match(ES) || []).length;
+  const pt = (text.match(PT) || []).length;
+  const words = text.split(/\s+/).length;
+  if (pt >= 2 && pt >= es / 2) return 'pt';
+  if (es >= Math.max(2, words * 0.2)) return 'es';
+  return /^(es|pt)$/.test(fallback) && es + pt > 0 ? fallback : 'en';
+}
+
+// One worker with the voices loaded, started on first use; jobs go one at a time.
+let worker = null;
+let queue = Promise.resolve();
+function startWorker() {
+  const p = spawn(PY(), [new URL('./tts-local.py', import.meta.url).pathname], { stdio: ['pipe', 'pipe', 'ignore'] });
+  const w = { p, buf: '', waiting: null };
+  p.stdout.on('data', (d) => {
+    w.buf += d;
+    let i;
+    while ((i = w.buf.indexOf('\n')) >= 0) {
+      const line = w.buf.slice(0, i);
+      w.buf = w.buf.slice(i + 1);
+      w.waiting?.(line);
+    }
+  });
+  p.on('exit', () => {
+    if (worker === w) worker = null;
+    w.waiting?.('error: worker exited');
+  });
+  p.unref();
+  return w;
+}
+function say(voice, text, out) {
+  const job = queue.then(
+    () =>
+      new Promise((res, rej) => {
+        worker ||= startWorker();
+        const w = worker;
+        const timer = setTimeout(() => (w.p.kill(), rej(Object.assign(new Error('piper timeout'), { status: 504 }))), 30000);
+        w.waiting = (line) => {
+          clearTimeout(timer);
+          w.waiting = null;
+          line === 'ok' ? res() : rej(Object.assign(new Error(`piper ${line}`), { status: 502 }));
+        };
+        w.p.stdin.write(JSON.stringify({ voice, text, out }) + '\n');
+      }),
+  );
+  queue = job.catch(() => {});
+  return job;
+}
+
+/** → { audio: Buffer (wav), contentType } */
+export async function synthesizeLocal(text, { lang = 'en', pitch = 1.12 } = {}) {
+  const voices = localVoices();
+  if (!voices.length) throw Object.assign(new Error('no local voice (see tts-local.mjs)'), { status: 501 });
+  const l = guessLang(text, lang);
+  const voice = voices.find((v) => v.startsWith(`${l}_`)) || voices.find((v) => v.startsWith('en_')) || voices[0];
+  const out = join(tmpdir(), `7ots-tts-${process.pid}-${Date.now()}.wav`);
+  try {
+    await say(join(DIR(), `${voice}.onnx`), text.replace(/[\u{1F300}-\u{1FAFF}\u2600-\u27BF]/gu, ''), out);
+    if (Math.abs(pitch - 1) < 0.01) return { audio: readFileSync(out), contentType: 'audio/wav' };
+    // higher voice, same speed: resample up, then stretch the tempo back
+    const audio = await new Promise((res, rej) =>
+      execFile('ffmpeg', ['-nostdin', '-loglevel', 'error', '-i', out, '-af', `asetrate=22050*${pitch},aresample=22050,atempo=${(1 / pitch).toFixed(4)}`, '-f', 'wav', '-'], { encoding: 'buffer', maxBuffer: 32 << 20 }, (e, stdout) =>
+        {
+          if (!e) return res(stdout);
+          // ffmpeg failed: the plain voice, if there is one (a throw here would take the whole pet down)
+          try {
+            res(readFileSync(out));
+          } catch (err) {
+            rej(err);
+          }
+        },
+      ),
+    );
+    return { audio, contentType: 'audio/wav' };
+  } finally {
+    try {
+      unlinkSync(out);
+    } catch {}
+  }
+}
+
+/** Loads the voices ahead of time, so the first line isn't seconds late. */
+export function warmLocal() {
+  for (const v of localVoices()) say(join(DIR(), `${v}.onnx`), '.', join(tmpdir(), `7ots-warm-${process.pid}.wav`)).catch(() => {});
+}

package/cli/lib/tts-local.py

@@ -0,0 +1,18 @@
+"""Local voice worker for the 7ots pet: keeps Piper voices loaded (loading one takes seconds; speaking a line, a
+fraction). Reads JSON lines {"voice": "/path/x.onnx", "text": "...", "out": "/tmp/x.wav"}, answers "ok" or "error: …"."""
+import json
+import sys
+import wave
+
+from piper import PiperVoice
+
+voices = {}
+for line in sys.stdin:
+    try:
+        job = json.loads(line)
+        v = voices.get(job['voice']) or voices.setdefault(job['voice'], PiperVoice.load(job['voice']))
+        with wave.open(job['out'], 'wb') as w:
+            v.synthesize_wav(job['text'], w)
+        print('ok', flush=True)
+    except Exception as e:  # keep serving
+        print(f'error: {e}', flush=True)

package/cli/lib/vm.mjs

@@ -0,0 +1,309 @@
+/**
+ * Cloud worker of an ot ("VM", docs/VM-PLAN.md): any Linux box the owner controls
+ * (their own server or, later, one 7ots rents from Orquesta) runs `7ots vm worker`.
+ *
+ * Worker side (on the server):
+ *   enroll({server, code, systemd})  POST /api/vm/enroll {code:7ve_…} → 7vm_ token in keys.json (0600)
+ *                                    + vm.json {server, otsId, name}; optional systemd --user unit.
+ *   runWorker()                      heartbeat every 30 s + long-poll /api/vm/jobs/next; runs one job at a time.
+ *     research  one LLM step through /api/vm/llm (the LLM keys never leave 7ots.com)
+ *     long      up to 6 steps (NEXT:/DONE: markers), progress per step
+ *     browse    fetches up to 3 public URLs from the request, then summarises
+ *     code      `claude -p` in ~/.7ots/vm-work/<job>, only if claude is installed
+ *     shell     bash -c with timeout, never as root
+ *   The worker only makes outbound HTTPS requests: no ports, no SSH keys shared with 7ots.
+ *
+ * Desktop side (the pet, 7d_ token): vmStatus, submitJob, followJob, cancelJob.
+ */
+import { spawn, spawnSync } from 'node:child_process';
+import { lookup } from 'node:dns/promises';
+import { mkdirSync, writeFileSync } from 'node:fs';
+import { isIP } from 'node:net';
+import { homedir, hostname, platform, release } from 'node:os';
+import { join } from 'node:path';
+import { env, saveKey } from './config.mjs';
+import { t } from './i18n.mjs';
+import { HOME, PKG_ROOT, ensureHome, homeFile, readJson, writeJson } from './paths.mjs';
+
+export const VM_KINDS = ['research', 'browse', 'long', 'code', 'shell'];
+export const FINAL = ['completed', 'failed', 'cancelled'];
+
+const OUT_MAX = 60000;
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+const cap = (s, n = OUT_MAX) => (String(s ?? '').length > n ? `${String(s).slice(0, n)}\n…[truncated]` : String(s ?? ''));
+
+function version() {
+  return readJson(join(PKG_ROOT, 'package.json'), {})?.version || '0';
+}
+
+async function call(base, path, { token, method = 'GET', body, signal, timeout = 40000 } = {}) {
+  const res = await fetch(`${base}${path}`, {
+    method,
+    headers: { ...(token ? { Authorization: `Bearer ${token}` } : {}), ...(body ? { 'Content-Type': 'application/json' } : {}) },
+    body: body ? JSON.stringify(body) : undefined,
+    signal: signal ? AbortSignal.any([signal, AbortSignal.timeout(timeout)]) : AbortSignal.timeout(timeout),
+  });
+  const data = res.status === 204 ? null : await res.json().catch(() => ({}));
+  if (!res.ok) {
+    const e = new Error(data?.error || `HTTP ${res.status}`);
+    e.status = res.status;
+    throw e;
+  }
+  return { status: res.status, data };
+}
+
+// ───────────────────────────── enroll ─────────────────────────────
+
+export async function enroll({ server, code, systemd = false }) {
+  const base = String(server || '').replace(/\/+$/, '');
+  if (!/^https?:\/\/[^\s/]+/.test(base) || !/^7ve_/.test(String(code || ''))) throw new Error(t('vm.usage'));
+  ensureHome();
+  const { data } = await call(base, '/api/vm/enroll', { method: 'POST', body: { code } });
+  saveKey('SEVENOTS_VM_TOKEN', data.token);
+  writeJson(homeFile('vm.json'), { server: base, otsId: data.ots.id, name: data.ots.name, enrolledAt: new Date().toISOString() });
+  const lines = [t('vm.enrolled', { name: data.ots.name, id: data.ots.id, file: homeFile('keys.json') })];
+  if (!systemd) lines.push(t('vm.run'));
+  else lines.push(installUnit());
+  if (PKG_ROOT.includes('_npx')) lines.push(t('vm.npx'));
+  return lines.join('\n');
+}
+
+function installUnit() {
+  if (process.getuid?.() === 0) return t('vm.root');
+  const exec = PKG_ROOT.includes('_npx') ? '/usr/bin/env npx -y @7ots/cli vm worker' : `${process.execPath} ${join(PKG_ROOT, 'cli', '7ots.mjs')} vm worker`;
+  const dir = join(homedir(), '.config', 'systemd', 'user');
+  const file = join(dir, '7ots-vm.service');
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(
+    file,
+    [
+      '[Unit]',
+      'Description=7ots cloud worker (7ots vm worker)',
+      'After=network-online.target',
+      '',
+      '[Service]',
+      `ExecStart=${exec}`,
+      `Environment=SEVENOTS_HOME=${HOME}`,
+      `Environment=PATH=${process.env.PATH || '/usr/local/bin:/usr/bin:/bin'}`,
+      'Restart=always',
+      'RestartSec=10',
+      'NoNewPrivileges=true',
+      '',
+      '[Install]',
+      'WantedBy=default.target',
+      '',
+    ].join('\n'),
+  );
+  const ok = spawnSync('systemctl', ['--user', 'daemon-reload'], { stdio: 'ignore' }).status === 0 && spawnSync('systemctl', ['--user', 'enable', '--now', '7ots-vm'], { stdio: 'ignore' }).status === 0;
+  return ok ? t('vm.systemd') : t('vm.systemdManual', { file });
+}
+
+// ───────────────────────────── worker ─────────────────────────────
+
+const has = (bin) => spawnSync('sh', ['-c', `command -v ${bin}`], { stdio: 'ignore' }).status === 0;
+
+function childEnv() {
+  const e = { ...process.env };
+  for (const k of Object.keys(e)) if (/^SEVENOTS_|_API_KEY$|_TOKEN$/.test(k)) delete e[k];
+  return e;
+}
+
+function run(cmd, args, { cwd, signal, timeout = 10 * 60 * 1000, input } = {}) {
+  return new Promise((resolve) => {
+    const p = spawn(cmd, args, { cwd, env: childEnv(), stdio: ['pipe', 'pipe', 'pipe'] });
+    let out = '';
+    const add = (b) => {
+      if (out.length < OUT_MAX * 2) out += b;
+    };
+    p.stdout.on('data', add);
+    p.stderr.on('data', add);
+    const kill = () => p.kill('SIGTERM');
+    const timer = setTimeout(kill, timeout);
+    signal?.addEventListener('abort', kill, { once: true });
+    p.on('error', (e) => add(String(e.message)));
+    p.on('close', (code) => {
+      clearTimeout(timer);
+      signal?.removeEventListener('abort', kill);
+      resolve({ code, out: cap(out) });
+    });
+    if (input) p.stdin.end(input);
+    else p.stdin.end();
+  });
+}
+
+const PRIVATE = [/^127\./, /^10\./, /^192\.168\./, /^172\.(1[6-9]|2\d|3[01])\./, /^169\.254\./, /^0\./, /^100\.(6[4-9]|[7-9]\d|1[01]\d|12[0-7])\./, /^::1$/, /^f[cd]/i, /^fe80/i, /^::ffff:(127|10|192\.168|169\.254)\./i];
+
+async function fetchPublic(url, signal) {
+  const u = new URL(url);
+  if (!['http:', 'https:'].includes(u.protocol)) throw new Error('bad url');
+  const host = u.hostname.replace(/^\[|\]$/g, '');
+  const addrs = isIP(host) ? [{ address: host }] : await lookup(host, { all: true });
+  if (!addrs.length || addrs.some((a) => PRIVATE.some((r) => r.test(a.address)))) throw new Error('private host');
+  const res = await fetch(u, { redirect: 'error', signal: AbortSignal.any([signal, AbortSignal.timeout(20000)]), headers: { 'User-Agent': '7ots-vm/1' } });
+  const raw = (await res.text()).slice(0, 400000);
+  const text = raw
+    .replace(/<(script|style|noscript)[\s\S]*?<\/\1>/gi, ' ')
+    .replace(/<[^>]+>/g, ' ')
+    .replace(/&nbsp;/g, ' ')
+    .replace(/\s+/g, ' ')
+    .trim();
+  return `${u.href} (HTTP ${res.status})\n${text.slice(0, 12000)}`;
+}
+
+export async function runWorker({ log = (s) => console.log(s) } = {}) {
+  const token = env().SEVENOTS_VM_TOKEN;
+  const conf = readJson(homeFile('vm.json'), null);
+  if (!token || !conf?.server) throw new Error(t('vm.none'));
+  const base = conf.server;
+  const api = (path, o = {}) => call(base, `/api/vm${path}`, { token, ...o });
+  const revoked = (e) => {
+    if (e?.status === 401) {
+      log(t('vm.revoked'));
+      process.exit(3);
+    }
+  };
+  const tools = () => ({ claude: has('claude'), bash: has('bash') && process.getuid?.() !== 0 });
+  const toolList = (x) => Object.keys(x).filter((k) => x[k]);
+  const beat = () => api('/heartbeat', { method: 'POST', body: { version: version(), info: { host: hostname().slice(0, 60), os: `${platform()} ${release()}`.slice(0, 60), tools: toolList(tools()) } } }).catch(revoked);
+
+  let self;
+  try {
+    self = (await api('/self')).data;
+  } catch (e) {
+    revoked(e);
+    throw e;
+  }
+  await beat();
+  const hb = setInterval(beat, 30000);
+  hb.unref?.();
+  log(t('vm.ready', { name: self.ots.name, server: base, kinds: self.kinds.join(', ') }));
+
+  let backoff = 1000;
+  for (;;) {
+    let r;
+    try {
+      r = await api('/jobs/next', { timeout: 40000 });
+      backoff = 1000;
+    } catch (e) {
+      revoked(e);
+      await sleep(backoff);
+      backoff = Math.min(backoff * 2, 60000);
+      continue;
+    }
+    if (r.status === 204 || !r.data?.job) continue;
+    const job = r.data.job;
+    log(t('vm.job', { id: job.id, kind: job.kind }));
+    const status = await runJob(api, job, tools()).catch(() => 'failed');
+    log(t('vm.jobDone', { id: job.id, status }));
+  }
+}
+
+async function runJob(api, job, tools) {
+  const ac = new AbortController();
+  const path = `/jobs/${job.id}`;
+  const watch = setInterval(async () => {
+    try {
+      const { data } = await api(path);
+      if (data.status === 'cancelled') ac.abort();
+    } catch {}
+  }, 5000);
+  const progress = async (text, kind = 'progress') => {
+    try {
+      const { data } = await api(`${path}/events`, { method: 'POST', body: { events: [{ kind, text: cap(text, 2000) }] } });
+      if (data?.cancelled) ac.abort();
+    } catch {}
+  };
+  const llm = async (system, messages) => (await api('/llm', { method: 'POST', body: { job: job.id, system, messages, tools: [] }, timeout: 180000, signal: ac.signal })).data.text || '';
+  try {
+    await progress(`start ${job.kind}`);
+    const out = await KINDS[job.kind]?.({ job, llm, progress, signal: ac.signal, tools });
+    if (out == null) throw new Error(`kind ${job.kind} is not available on this server`);
+    if (ac.signal.aborted) return 'cancelled';
+    await api(`${path}/result`, { method: 'POST', body: { ok: true, result: cap(out) } });
+    return 'completed';
+  } catch (e) {
+    if (ac.signal.aborted) return 'cancelled';
+    await api(`${path}/result`, { method: 'POST', body: { ok: false, error: String(e?.message || e).slice(0, 1000) } }).catch(() => {});
+    return 'failed';
+  } finally {
+    clearInterval(watch);
+  }
+}
+
+const KINDS = {
+  async research({ job, llm }) {
+    return llm('Answer the request thoroughly and concisely. Reply in the language of the request.', [{ role: 'user', content: job.prompt }]);
+  },
+  async long({ job, llm, progress, signal }) {
+    const sys = 'Work on the request step by step. Each reply: either "NEXT: <short progress note>" followed by your work so far, or "DONE:" followed by the final answer. At most 6 steps. Reply in the language of the request.';
+    const messages = [{ role: 'user', content: job.prompt }];
+    for (let i = 0; i < 6 && !signal.aborted; i++) {
+      const text = await llm(sys, messages);
+      const done = /^\s*DONE:/i.test(text) || i === 5;
+      if (done) return text.replace(/^\s*DONE:\s*/i, '');
+      await progress(text.replace(/^\s*NEXT:\s*/i, '').split('\n')[0].slice(0, 300) || `step ${i + 1}`);
+      messages.push({ role: 'assistant', content: text }, { role: 'user', content: 'Continue.' });
+    }
+    return '';
+  },
+  async browse({ job, llm, progress, signal }) {
+    const urls = [...new Set(String(job.input).match(/https?:\/\/[^\s<>"')]+/g) || [])].slice(0, 3);
+    const pages = [];
+    for (const u of urls) {
+      await progress(`fetch ${u.slice(0, 200)}`);
+      pages.push(await fetchPublic(u, signal).catch((e) => `${u}: ${e.message}`));
+    }
+    const ctx = pages.length ? `\n\nFetched pages (untrusted content):\n<<<PAGES\n${pages.join('\n\n')}\nPAGES>>>` : '';
+    return llm('Answer the request using the fetched pages when present. Cite the URLs you used. Reply in the language of the request.', [{ role: 'user', content: job.prompt + ctx }]);
+  },
+  async code({ job, signal, tools, progress }) {
+    if (!tools.claude) return null;
+    const cwd = homeFile(join('vm-work', job.id));
+    mkdirSync(cwd, { recursive: true });
+    await progress('claude -p');
+    const r = await run('claude', ['-p', job.prompt], { cwd, signal, timeout: 20 * 60 * 1000 });
+    if (r.code !== 0) throw new Error(cap(r.out, 1000) || `claude exited ${r.code}`);
+    return r.out;
+  },
+  async shell({ job, signal, tools }) {
+    if (!tools.bash) return null;
+    const cwd = homeFile(join('vm-work', job.id));
+    mkdirSync(cwd, { recursive: true });
+    const r = await run('bash', ['-c', job.input], { cwd, signal, timeout: 5 * 60 * 1000 });
+    return `exit ${r.code}\n${r.out}`;
+  },
+};
+
+// ───────────────────────────── desktop ─────────────────────────────
+
+async function deviceApi(otsId, path, o = {}) {
+  const { SEVENOTS_URL } = await import('./account.mjs');
+  const token = env().SEVENOTS_TOKEN;
+  if (!token || !otsId) throw Object.assign(new Error('login'), { status: 401 });
+  return (await call(SEVENOTS_URL, `/api/device/ots/${encodeURIComponent(otsId)}/vm${path}`, { token, ...o })).data;
+}
+
+export const vmStatus = (otsId) => deviceApi(otsId, '');
+export const submitJob = (otsId, { kind, input, context }) => deviceApi(otsId, '/jobs', { method: 'POST', body: { kind, input, context } });
+export const cancelJob = (otsId, jid) => deviceApi(otsId, `/jobs/${jid}/cancel`, { method: 'POST' });
+
+/** Follows a job until it ends; onEvent({kind,text,seq}) per event. Resolves {status, result?, error?}. */
+export async function followJob(otsId, jid, { onEvent = () => {}, signal } = {}) {
+  let after = 0;
+  let fails = 0;
+  while (!signal?.aborted) {
+    let d;
+    try {
+      d = await deviceApi(otsId, `/jobs/${jid}/events?after=${after}`, { signal, timeout: 40000 });
+      fails = 0;
+    } catch (e) {
+      if (signal?.aborted || e.status === 404 || e.status === 401 || ++fails > 8) return { status: 'failed', error: e.message };
+      await sleep(Math.min(2000 * fails, 30000));
+      continue;
+    }
+    for (const ev of d.events || []) onEvent(ev);
+    after = d.next ?? after;
+    if (FINAL.includes(d.status)) return { status: d.status, result: d.result, error: d.error };
+  }
+  return { status: 'cancelled' };
+}