@7ots/cli 0.1.5 → 0.1.7

package/cli/lib/card-shot.mjs

@@ -0,0 +1,84 @@
+/**
+ * The ot's card as a high-res PNG. Headless Chrome renders /card?shot=1 and the DevTools protocol (over
+ * --remote-debugging-pipe: fd 3 in, fd 4 out, no WebSocket needed) captures exactly the card's box at the
+ * asked scale, on a transparent background. Blend modes, glitter and the 3D ot come out as on screen.
+ */
+
+import { spawn } from 'node:child_process';
+import { existsSync, mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+export function findChrome() {
+  const names = ['google-chrome', 'google-chrome-stable', 'chromium', 'chromium-browser', 'microsoft-edge'];
+  const dirs = ['/usr/bin', '/usr/local/bin', '/snap/bin', '/opt/google/chrome'];
+  const mac = ['/Applications/Google Chrome.app/Contents/MacOS/Google Chrome', '/Applications/Chromium.app/Contents/MacOS/Chromium'];
+  return [...names.flatMap((n) => dirs.map((d) => join(d, n))), ...mac].find(existsSync) || null;
+}
+
+/** → Buffer (png). url: the card page with ?shot=1; scale: device pixels per CSS pixel. */
+export async function cardShot(url, { scale = 4, gl = false, timeout = 45000 } = {}) {
+  const chrome = findChrome();
+  if (!chrome) throw Object.assign(new Error('needs Google Chrome or Chromium'), { status: 501 });
+  const dir = mkdtempSync(join(tmpdir(), '7ots-card-'));
+  const args = ['--headless=new', '--remote-debugging-pipe', '--no-first-run', '--no-default-browser-check', '--hide-scrollbars', `--user-data-dir=${dir}`,
+    ...(gl ? ['--use-angle=swiftshader', '--enable-unsafe-swiftshader'] : ['--disable-gpu']), 'about:blank'];
+  const p = spawn(chrome, args, { stdio: ['ignore', 'ignore', 'ignore', 'pipe', 'pipe'] });
+  const [toChrome, fromChrome] = [p.stdio[3], p.stdio[4]];
+  let seq = 0;
+  const waiting = new Map();
+  const events = new Map();
+  let buf = '';
+  fromChrome.on('data', (d) => {
+    buf += d;
+    let i;
+    while ((i = buf.indexOf('\0')) >= 0) {
+      const m = JSON.parse(buf.slice(0, i));
+      buf = buf.slice(i + 1);
+      if (m.method) events.get(m.method)?.(m.params);
+      const w = waiting.get(m.id);
+      if (!w) continue;
+      waiting.delete(m.id);
+      m.error ? w.rej(new Error(m.error.message)) : w.res(m.result);
+    }
+  });
+  const send = (method, params = {}, sessionId) =>
+    new Promise((res, rej) => {
+      const id = ++seq;
+      waiting.set(id, { res, rej });
+      toChrome.write(JSON.stringify({ id, method, params, ...(sessionId && { sessionId }) }) + '\0');
+    });
+  // Chrome gone (crashed, or killed on timeout): whatever was waiting fails instead of hanging the request
+  const gone = (e) => {
+    for (const w of waiting.values()) w.rej(Object.assign(new Error(e?.message || 'chrome closed'), { status: 504 }));
+    waiting.clear();
+  };
+  p.on('exit', gone);
+  p.on('error', gone);
+  fromChrome.on('error', () => {});
+  toChrome.on('error', () => {});
+  const killer = setTimeout(() => p.kill('SIGKILL'), timeout);
+  try {
+    const { targetId } = await send('Target.createTarget', { url: 'about:blank' });
+    const { sessionId } = await send('Target.attachToTarget', { targetId, flatten: true });
+    const s = (m, prm) => send(m, prm, sessionId);
+    await s('Emulation.setDeviceMetricsOverride', { width: 460, height: 640, deviceScaleFactor: scale, mobile: false });
+    await s('Emulation.setDefaultBackgroundColorOverride', { color: { r: 0, g: 0, b: 0, a: 0 } });
+    // The page calls __cardReady(box) once the ot is drawn (a binding: no polling competing with the 3D
+    // render, which takes seconds per frame on a software GPU); then a moment for it to settle.
+    const ready = new Promise((ok) => events.set('Runtime.bindingCalled', (e) => e.name === '__cardReady' && ok(JSON.parse(e.payload))));
+    await s('Runtime.enable');
+    await s('Runtime.addBinding', { name: '__cardReady' });
+    await s('Page.navigate', { url });
+    const box = await Promise.race([ready, new Promise((ok) => setTimeout(ok, timeout - 8000, null))]);
+    if (box) await new Promise((ok) => setTimeout(ok, 400));
+    if (!box) throw Object.assign(new Error('the card did not render'), { status: 504 });
+    const pad = 2; // the rounded corners' anti-aliasing
+    const { data } = await s('Page.captureScreenshot', { format: 'png', clip: { x: box.x - pad, y: box.y - pad, width: box.w + pad * 2, height: box.h + pad * 2, scale: 1 } });
+    return Buffer.from(data, 'base64');
+  } finally {
+    clearTimeout(killer);
+    p.kill();
+    setTimeout(() => rmSync(dir, { recursive: true, force: true }), 1500).unref();
+  }
+}

package/cli/lib/config.mjs

@@ -12,21 +12,35 @@
  *                                { kind: 'api', provider: 'anthropic'|'openai', model?, baseUrl? }
  *                                { kind: '7ots' }                                        the home's /chat (7ots or own server)
  *                                { kind: 'batuta', model? }                              Orquesta's Batuta LLM
- *   voice  how it speaks:        { kind: 'none'|'browser'|'apuchat'|'elevenlabs'|'grok'|'fish'|'openai', voiceId? }
+ *   voice  how it speaks:        { kind: 'none'|'browser'|'local'|'apuchat'|'elevenlabs'|'grok'|'fish'|'openai', voiceId? }
  *   pet    { mode: 'ask'|'desktop'|'terminal'|'browser', annoy: 0..3, view?: '2d'|'3d' }
  *   access what the pet may see and do (the settings page, /settings):
  *          { agent: true,   the details of your coding agent / terminal (prompts, commands, tools) go to the brain
  *            memory: true,  it keeps notes about you and uses them when answering
  *            open: true,    it may open sites in your browser (reminders, "open my mail")
- *            notify: true } desktop notifications when a reminder fires
+ *            notify: true,  desktop notifications when a reminder fires
+ *            sites: true,   for sites you mention, it reads their usage guide on Prowl.world (only the domain is sent; prowl.mjs)
+ *            screen: false, it looks at the active window and, every screen.every minutes, a screenshot (screen.mjs)
+ *            processes: false, it sees which programs run (name, cpu, memory) and can wait for one to finish
+ *            logs: false,   it may read the logs of running processes (journal, pm2, docker, a log file) when asked
+ *            inbox: false,  it may read your email (apumail inbox) when asked
+            vm: false,     it may send long jobs to its worker on your own server (vm.mjs; context filtered by the above)
+            vmKinds: ['research','browse','long'] }  which kinds (code and shell only if you add them)
+ *   integrations { orquesta: { on, projectId?, projectName? }   talk to your Orquesta agents
+ *                  apumail: { on, inbox }                         email (APUMAIL_TOKEN)
+ *                  custom: [{ id, name, instructions, url?, command?, envVar?, on }] }  told to the brain
+ *   character { backstory, style, quirks, examples, scenario, greeting,   the character sheet (chara_card_v2)
+ *               letta?: { on, agentId } }                                   persona memory on Letta (LETTA_API_KEY)
+ *   screen { every: 5 }  minutes between screenshots
  *
- * ~/.7ots/keys.json (0600) keeps the keys typed in the wizard under their usual env-var names.
+ * ~/.7ots/keys.json (0600) keeps the keys typed in the wizard under their usual env-var names
+ * (and, on a server enrolled with `7ots vm enroll`, its worker token SEVENOTS_VM_TOKEN).
  * Variables already set in the environment always win over the file.
  */
 
 import { homeFile, readJson, writeJson } from './paths.mjs';
 
-export const KEY_NAMES = ['ANTHROPIC_API_KEY', 'OPENAI_API_KEY', 'ORQUESTA_TOKEN', 'APUCHAT_VOICE_TOKEN', 'ELEVENLABS_API_KEY', 'XAI_API_KEY', 'FISH_API_KEY'];
+export const KEY_NAMES = ['SEVENOTS_TOKEN', 'ANTHROPIC_API_KEY', 'OPENAI_API_KEY', 'ORQUESTA_TOKEN', 'APUCHAT_VOICE_TOKEN', 'ELEVENLABS_API_KEY', 'XAI_API_KEY', 'FISH_API_KEY', 'LETTA_API_KEY', 'APUMAIL_TOKEN', 'SEVENOTS_VM_TOKEN'];
 export const ORQUESTA_URL = (process.env.ORQUESTA_URL || 'https://getorquesta.com').replace(/\/+$/, '');
 
 export const CONFIG_DEFAULTS = Object.freeze({
@@ -35,7 +49,10 @@ export const CONFIG_DEFAULTS = Object.freeze({
   brain: { kind: 'lines' },
   voice: { kind: 'browser' },
   pet: { mode: 'ask', annoy: 2 },
-  access: { agent: true, memory: true, open: true, notify: true },
+  access: { agent: true, memory: true, open: true, notify: true, sites: true, screen: false, processes: false, logs: false, inbox: false, vm: false, vmKinds: ['research', 'browse', 'long'] },
+  screen: { every: 5 },
+  integrations: { orquesta: { on: false }, apumail: { on: false, inbox: '' }, custom: [] },
+  character: {},
 });
 
 export function loadConfig() {
@@ -48,6 +65,13 @@ export function loadConfig() {
     voice: { ...CONFIG_DEFAULTS.voice, ...c.voice },
     pet: { ...CONFIG_DEFAULTS.pet, ...c.pet },
     access: { ...CONFIG_DEFAULTS.access, ...c.access },
+    screen: { ...CONFIG_DEFAULTS.screen, ...c.screen },
+    integrations: {
+      orquesta: { ...CONFIG_DEFAULTS.integrations.orquesta, ...c.integrations?.orquesta },
+      apumail: { ...CONFIG_DEFAULTS.integrations.apumail, ...c.integrations?.apumail },
+      custom: Array.isArray(c.integrations?.custom) ? c.integrations.custom : [],
+    },
+    character: { ...(c.character && typeof c.character === 'object' ? c.character : {}) },
   };
 }
 

package/cli/lib/i18n.mjs

@@ -24,6 +24,8 @@ const M = {
   7ots prompt [identity|install|pet|meet|all] prompts for coding agents
   7ots docs                                  everything for coding agents (same as https://7ots.com/llms.txt)
   7ots login orquesta                        connect a getorquesta.com account
+  7ots vm enroll --server <url> --code 7ve_… [--systemd]   make this server your ot's cloud worker
+  7ots vm worker                             run that worker (jobs from your desktop pet)
   7ots server                                run the 7ots proxy (/api/agent) next to your site
 
 Identities are reproducible: the same seed gives the same ot everywhere (web, CLI, pet, meet).
@@ -81,6 +83,23 @@ Docs: https://7ots.com/llms.txt`,
     'meet.noBrain': 'Note: without a brain the ot can only say stock phrases. Run "7ots setup" to give it one.',
     'login.open': 'Authorize 7ots in your browser:\n  {url}',
     'login.ok': 'Connected to Orquesta ({org}).',
+    'acct.ok': 'Connected to 7ots.com as {who}.',
+    'acct.none': 'Not connected. Run: 7ots login',
+    'acct.empty': 'No ots in your account yet. Create one at {url}/app/',
+    'acct.used': 'Now using {name}. Restart the pet to see it: 7ots pet',
+    'vm.usage': '7ots vm enroll --server <url> --code 7ve_… [--systemd]  ·  7ots vm worker',
+    'vm.enrolled': 'This server is now the worker of {name} ({id}). Token saved in {file} (0600).',
+    'vm.run': 'Start it with: 7ots vm worker',
+    'vm.systemd': 'Service 7ots-vm (systemd --user) installed and started. To keep it running after you log out: loginctl enable-linger $USER',
+    'vm.systemdManual': 'Unit written to {file}. Start it with: systemctl --user daemon-reload && systemctl --user enable --now 7ots-vm',
+    'vm.root': 'Not writing a service as root: run the worker as a normal user (it never needs sudo).',
+    'vm.npx': 'Tip: install it for good with npm i -g @7ots/cli (the npx cache can be cleaned).',
+    'vm.none': 'This computer is not enrolled. Get a command in 7ots.com → your ot → Assistant.',
+    'vm.revoked': 'This server was revoked on 7ots.com. Enroll it again to keep working.',
+    'vm.ready': 'Worker of {name} online ({server}). Kinds: {kinds}. Waiting for jobs…',
+    'vm.job': 'job {id} · {kind}',
+    'vm.jobDone': 'job {id} → {status}',
+    'acct.out': 'Disconnected from 7ots.com.',
     'err.unknown': 'Unknown command "{cmd}". Try: 7ots help',
     'err.noPet': 'The pet is not awake. Start it with: 7ots pet',
     'pet.settings': 'Opening the settings in your browser.',
@@ -195,6 +214,8 @@ Docs: https://7ots.com/llms.txt`,
   7ots prompt [identity|install|pet|meet|all] prompts para agentes de código
   7ots docs                                  todo para agentes de código (igual que https://7ots.com/llms.txt)
   7ots login orquesta                        conecta una cuenta de getorquesta.com
+  7ots vm enroll --server <url> --code 7ve_… [--systemd]   convierte este servidor en el worker de tu ot
+  7ots vm worker                             corre ese worker (trabajos de tu mascota)
   7ots server                                levanta el proxy 7ots (/api/agent) junto a tu web
 
 Las identidades son reproducibles: la misma semilla da el mismo ot en todas partes (web, CLI, mascota, meet).
@@ -252,6 +273,23 @@ Docs: https://7ots.com/llms.txt`,
     'meet.noBrain': 'Ojo: sin cerebro el ot solo dice frases de serie. Corre «7ots setup» para darle uno.',
     'login.open': 'Autoriza 7ots en tu navegador:\n  {url}',
     'login.ok': 'Conectado a Orquesta ({org}).',
+    'acct.ok': 'Conectado a 7ots.com como {who}.',
+    'acct.none': 'No estás conectado. Corre: 7ots login',
+    'acct.empty': 'Todavía no hay ots en tu cuenta. Crea uno en {url}/app/',
+    'acct.used': 'Ahora usas a {name}. Reinicia la mascota para verlo: 7ots pet',
+    'vm.usage': '7ots vm enroll --server <url> --code 7ve_… [--systemd]  ·  7ots vm worker',
+    'vm.enrolled': 'Este servidor ahora es el worker de {name} ({id}). Token guardado en {file} (0600).',
+    'vm.run': 'Arráncalo con: 7ots vm worker',
+    'vm.systemd': 'Servicio 7ots-vm (systemd --user) instalado y en marcha. Para que siga al cerrar sesión: loginctl enable-linger $USER',
+    'vm.systemdManual': 'Unidad escrita en {file}. Arráncala con: systemctl --user daemon-reload && systemctl --user enable --now 7ots-vm',
+    'vm.root': 'No escribo un servicio como root: corre el worker como usuario normal (nunca necesita sudo).',
+    'vm.npx': 'Consejo: instálalo de forma fija con npm i -g @7ots/cli (la caché de npx se puede borrar).',
+    'vm.none': 'Este equipo no está enrolado. Saca un comando en 7ots.com → tu ot → Asistente.',
+    'vm.revoked': 'Este servidor fue revocado en 7ots.com. Vuelve a enrolarlo para seguir.',
+    'vm.ready': 'Worker de {name} en línea ({server}). Tipos: {kinds}. Esperando trabajos…',
+    'vm.job': 'trabajo {id} · {kind}',
+    'vm.jobDone': 'trabajo {id} → {status}',
+    'acct.out': 'Desconectado de 7ots.com.',
     'err.unknown': 'Comando desconocido «{cmd}». Prueba: 7ots help',
     'err.noPet': 'La mascota no está despierta. Iníciala con: 7ots pet',
     'pet.settings': 'Abriendo los ajustes en tu navegador.',
@@ -366,6 +404,8 @@ Docs: https://7ots.com/llms.txt`,
   7ots prompt [identity|install|pet|meet|all] prompts para agentes de código
   7ots docs                                  tudo para agentes de código (igual a https://7ots.com/llms.txt)
   7ots login orquesta                        conecta uma conta do getorquesta.com
+  7ots vm enroll --server <url> --code 7ve_… [--systemd]   faz deste servidor o worker do seu ot
+  7ots vm worker                             roda esse worker (trabalhos do seu pet)
   7ots server                                sobe o proxy 7ots (/api/agent) junto do seu site
 
 As identidades são reproduzíveis: a mesma semente dá o mesmo ot em todo lugar (web, CLI, bichinho, meet).
@@ -423,6 +463,23 @@ Docs: https://7ots.com/llms.txt`,
     'meet.noBrain': 'Obs.: sem cérebro o ot só diz frases prontas. Rode «7ots setup» para dar um.',
     'login.open': 'Autorize o 7ots no navegador:\n  {url}',
     'login.ok': 'Conectado ao Orquesta ({org}).',
+    'acct.ok': 'Conectado ao 7ots.com como {who}.',
+    'acct.none': 'Não conectado. Rode: 7ots login',
+    'acct.empty': 'Ainda não há ots na sua conta. Crie um em {url}/app/',
+    'acct.used': 'Agora usando {name}. Reinicie o pet para ver: 7ots pet',
+    'vm.usage': '7ots vm enroll --server <url> --code 7ve_… [--systemd]  ·  7ots vm worker',
+    'vm.enrolled': 'Este servidor agora é o worker de {name} ({id}). Token salvo em {file} (0600).',
+    'vm.run': 'Inicie com: 7ots vm worker',
+    'vm.systemd': 'Serviço 7ots-vm (systemd --user) instalado e rodando. Para continuar após sair: loginctl enable-linger $USER',
+    'vm.systemdManual': 'Unidade escrita em {file}. Inicie com: systemctl --user daemon-reload && systemctl --user enable --now 7ots-vm',
+    'vm.root': 'Não escrevo um serviço como root: rode o worker como usuário normal (nunca precisa de sudo).',
+    'vm.npx': 'Dica: instale de vez com npm i -g @7ots/cli (o cache do npx pode ser limpo).',
+    'vm.none': 'Este computador não está registrado. Pegue um comando em 7ots.com → seu ot → Assistente.',
+    'vm.revoked': 'Este servidor foi revogado no 7ots.com. Registre de novo para continuar.',
+    'vm.ready': 'Worker de {name} online ({server}). Tipos: {kinds}. Esperando trabalhos…',
+    'vm.job': 'trabalho {id} · {kind}',
+    'vm.jobDone': 'trabalho {id} → {status}',
+    'acct.out': 'Desconectado do 7ots.com.',
     'err.unknown': 'Comando desconhecido «{cmd}». Tente: 7ots help',
     'err.noPet': 'O bichinho não está acordado. Inicie com: 7ots pet',
     'pet.settings': 'Abrindo os ajustes no seu navegador.',

package/cli/lib/inferences.mjs

@@ -0,0 +1,76 @@
+/**
+ * Inference history: every call to the brain, with exactly what was sent (system + messages, so you can see
+ * the data it used) and what came back. Kept in ~/.7ots/inferences.jsonl (0600, last 300) and shown on /settings.
+ */
+
+import { appendFileSync, existsSync, readFileSync, writeFileSync, chmodSync } from 'node:fs';
+import { homeFile } from './paths.mjs';
+
+const MAX = 300;
+const FILE = () => homeFile('inferences.jsonl');
+const cut = (s, n) => (String(s ?? '').length > n ? `${String(s).slice(0, n)}…` : String(s ?? ''));
+
+export function createInferenceLog() {
+  let rows = [];
+  try {
+    if (existsSync(FILE())) rows = readFileSync(FILE(), 'utf8').trim().split('\n').filter(Boolean).slice(-MAX).map((l) => JSON.parse(l));
+  } catch {
+    rows = [];
+  }
+  let since = 0;
+  const add = (row) => {
+    rows.push(row);
+    if (rows.length > MAX) rows.shift();
+    try {
+      if (++since > 50) {
+        // compact now and then so the file stays small
+        since = 0;
+        writeFileSync(FILE(), rows.map((r) => JSON.stringify(r)).join('\n') + '\n', { mode: 0o600 });
+      } else appendFileSync(FILE(), JSON.stringify(row) + '\n', { mode: 0o600 });
+      chmodSync(FILE(), 0o600);
+    } catch {}
+  };
+
+  /** Wraps a brain: think({ purpose, … }) is logged. `label()` names the brain (cli · claude · model). */
+  function wrap(getBrain, label) {
+    return {
+      get kind() {
+        return getBrain().kind;
+      },
+      get vision() {
+        return Boolean(getBrain().vision);
+      },
+      async think(o) {
+        const t0 = Date.now();
+        const row = {
+          at: t0,
+          purpose: o.purpose || 'chat',
+          brain: label(),
+          system: cut(o.system, 6000),
+          input: (o.messages || []).map((m) => ({ role: m.role, content: cut(typeof m.content === 'string' ? m.content : JSON.stringify(m.content), 8000) })),
+          files: o.files || undefined,
+        };
+        try {
+          let usage;
+          const text = await getBrain().think({ ...o, onUsage: (u) => (usage = u) });
+          add({ ...row, ok: true, output: cut(text, 4000), ms: Date.now() - t0, usage });
+          return text;
+        } catch (e) {
+          add({ ...row, ok: false, error: cut(e.message, 300), ms: Date.now() - t0 });
+          throw e;
+        }
+      },
+    };
+  }
+
+  return {
+    wrap,
+    list: (n = 100) => rows.slice(-n).reverse(),
+    clear() {
+      rows = [];
+      try {
+        writeFileSync(FILE(), '', { mode: 0o600 });
+      } catch {}
+    },
+  };
+}