@7ots/cli 0.1.7 → 0.1.9

package/cli/lib/pet-server.mjs

@@ -26,6 +26,7 @@
  *   POST /config                       { brain?, pet?, access?, keys? } → saved to ~/.7ots and applied live
  *   POST /config/test                  one line from the current brain → { ok, text, ms }
  *   POST /notes/forget                 { at | 'all' }
+ *   POST /conversation/forget          drop the conversation memory (turns + summary)
  *   POST /quit    X-7ots-Token
  *
  * Only listens on 127.0.0.1 and only answers to Host 127.0.0.1/localhost (no DNS rebinding).
@@ -33,28 +34,39 @@
  */
 
 import { createServer } from 'node:http';
-import { randomBytes, timingSafeEqual } from 'node:crypto';
+import { createHash, randomBytes, timingSafeEqual } from 'node:crypto';
 import { readFileSync, existsSync, writeFileSync, chmodSync, mkdirSync, symlinkSync } from 'node:fs';
 import { cardShot } from './card-shot.mjs';
 import { join } from 'node:path';
 import { createAssistant, notify, tr } from './assistant.mjs';
 import { createWatchers, processes, processSummary } from './watchers.mjs';
-import { createInferenceLog } from './inferences.mjs';
+import { createInferenceLog, otherInferences } from './inferences.mjs';
+
+const MAX_INF = 300;
 import { AI_CLIS, createBrain, detectClis, petSystem } from './brain.mjs';
 import { env, loadConfig, saveConfig, saveKey } from './config.mjs';
 import { loadIdentity } from './identity.mjs';
+import { readJson, writeJson } from './paths.mjs';
 import { sttProvider, transcribe } from './stt.mjs';
 import { localVoices, synthesizeLocal, warmLocal } from './tts-local.mjs';
 import { createScreenWatcher } from './screen.mjs';
 import { createSiteContext } from './prowl.mjs';
-import { SEVENOTS_URL, logout as accountLogout, me as accountMe, pull as pullOt, signedIn, startLogin, use as useOt } from './account.mjs';
+import { SEVENOTS_URL, community, sync as syncOt, logout as accountLogout, me as accountMe, pull as pullOt, signedIn, startLogin, use as useOt } from './account.mjs';
 import { openUrl } from './open.mjs';
 import { VM_KINDS } from './vm.mjs';
 import { cloudStatus, createExtras, lettaSync, normalizeCharacter, normalizeIntegrations } from './integrations.mjs';
 import { spawn } from 'node:child_process';
 import { openSync } from 'node:fs';
 import { line } from './lines.mjs';
-import { defineIdentity } from '../../src/identity/schema.js';
+import { defineIdentity, GROK_VOICES, OPENAI_VOICES } from '../../src/identity/schema.js';
+import { normalizeMod, normalizeMods, MAX_MODS } from '../../src/character/mods.js';
+import { MOD_CATALOG } from '../../src/character/mods/index.js';
+
+/** Mods importados en este pet (~/.7ots/mods/library.json), normalizados. */
+// scenes between ots on the same desktop (pet/electron/director.cjs plays them)
+const SCENE_NAMES = ['rocky', 'sf', 'dbz', 'matrix', 'duel', 'sw', 'fight', 'twist'];
+const SCENE_EVERY = ['rare', 'normal', 'often'];
+const modLibrary = () => (readJson(homeFile('mods/library.json')) || []).map(normalizeMod).filter(Boolean);
 import { ensureHome, homeFile, PET_PORT, PKG_ROOT } from './paths.mjs';
 import { applyEvent, loadPet, need, savePet, tick, view } from './pet-core.mjs';
 
@@ -96,6 +108,7 @@ export async function postPet(path, body, port = PET_PORT) {
   }
 }
 
+const VOICE_PROVIDERS = ['elevenlabs', 'openai', 'apuchat', 'grok', 'fish'];
 const SETTABLE_KEYS = ['ANTHROPIC_API_KEY', 'OPENAI_API_KEY', 'ORQUESTA_TOKEN', 'ELEVENLABS_API_KEY', 'APUCHAT_VOICE_TOKEN', 'XAI_API_KEY', 'FISH_API_KEY', 'LETTA_API_KEY', 'APUMAIL_TOKEN'];
 // The settings page speaks the human's language: SEVENOTS_LANG, config.lang, the system's, then the ot's.
 const uiLangOf = (c, fallback) => [process.env.SEVENOTS_LANG, c.lang, String(process.env.LC_ALL || process.env.LC_MESSAGES || process.env.LANG || '').slice(0, 2).toLowerCase(), fallback].find((l) => ['en', 'es', 'pt'].includes(l)) || 'en';
@@ -108,11 +121,20 @@ const IDLE = { 0: Infinity, 1: 60 * 60_000, 2: 20 * 60_000, 3: 5 * 60_000 }; //
 export function startPetServer({ port = PET_PORT, log = () => {} } = {}) {
   const token = petToken();
   let config = loadConfig();
+  let scenePlay = null; // { scene, at }: asked from settings, taken by the director on its next poll
+  const sceneConf = (c = config) => ({ on: true, every: 'normal', list: SCENE_NAMES, ...c.pet?.scenes });
   const annoyOf = (c) => Math.max(0, Math.min(3, Number(c.pet.annoy ?? 2)));
   let annoy = annoyOf(config);
   const { identity } = loadIdentity();
   if (!identity) throw Object.assign(new Error('no identity'), { code: 'NO_IDENTITY' });
   const lang = identity.language || 'en';
+  /** The voice for a provider: what its settings card saved, else the identity's (only if it is that provider's). */
+  const voiceFor = (kind) => {
+    const iv = identity.voice || {};
+    const own = config.voice.providers?.[kind] || {};
+    // the identity's voice id/model belong to its own provider: not sent to another (an ElevenLabs id means nothing to Fish)
+    return { ...iv, ...(iv.provider === kind ? {} : { voiceId: '', model: '' }), provider: kind, ...(config.voice.voiceId ? { voiceId: config.voice.voiceId } : {}), ...own };
+  };
   let brainImpl = createBrain(config.brain, config.home); // swapped live from the settings page
   const inferences = createInferenceLog();
   if (config.voice.kind === 'local') warmLocal();
@@ -131,6 +153,51 @@ export function startPetServer({ port = PET_PORT, log = () => {} } = {}) {
     for (const res of clients) res.write(data);
   };
 
+  // Approve / Reject in its bubble before acting for you (Orquesta…). Unanswered in 2 min = rejected.
+  const asks = new Map(); // id → { text, done }
+  function confirm(text, ms = 120_000) {
+    const id = randomBytes(6).toString('hex');
+    return new Promise((resolve) => {
+      const done = (ok) => {
+        if (!asks.delete(id)) return;
+        clearTimeout(timer);
+        log(`approval ${ok ? 'yes' : 'no'}: ${text.slice(0, 80)}`);
+        broadcast({ ask: { id, done: true }, thinking: ok });
+        resolve(ok);
+      };
+      const timer = setTimeout(() => done(false), ms);
+      asks.set(id, { text, done });
+      lastSpoke = Date.now();
+      if (config.access.notify !== false) notify(`${identity.name} · 7ots`, text);
+      broadcast({ ask: { id, text }, thinking: false, gesture: 'think', point: 'user', stir: true });
+    });
+  }
+  // Orquesta sign-in in the browser; once in, its integration is on
+  let connecting = null;
+  function connectOrquesta() {
+    return (connecting ||= import('./orquesta.mjs')
+      .then(async (o) => {
+        if (o.via() !== '7ots') return o.login({ open: openUrl });
+        // signed in to 7ots.com: connect it there (once for the ot everywhere); its token stays there
+        openUrl(`${SEVENOTS_URL}/app/#ots/${config.account.otsId}/orquesta`);
+        for (const end = Date.now() + 10 * 60_000; Date.now() < end; ) {
+          await new Promise((r) => setTimeout(r, 4000));
+          if ((await o.cloudOrquesta().catch(() => null))?.connected) return { organizationName: '' };
+        }
+        throw new Error('not connected on 7ots.com in time');
+      })
+      .then((r) => {
+        const next = loadConfig();
+        next.integrations = { ...next.integrations, orquesta: { ...next.integrations?.orquesta, on: true } };
+        saveConfig(next);
+        config = loadConfig();
+        log(`orquesta: connected${r.organizationName ? ` (${r.organizationName})` : ''}`);
+        broadcast({ orquesta: true });
+        return r;
+      })
+      .finally(() => (connecting = null)));
+  }
+
   async function speak(kind, vars = {}, situation = '', { force = false, gesture = null } = {}) {
     const now = Date.now();
     if (!force && (pet.asleep || now - lastSpoke < GAP[annoy])) {
@@ -238,6 +305,28 @@ export function startPetServer({ port = PET_PORT, log = () => {} } = {}) {
     broadcast({});
   }, 60_000);
 
+  // Sync with its ot on 7ots.com (account.mjs sync): same look, mods, personality and sheet on both sides.
+  let syncing = false;
+  let syncSoon = null;
+  let syncErr = '';
+  async function cloudSync() {
+    if (syncing) return;
+    syncing = true;
+    try {
+      const r = await syncOt();
+      syncErr = '';
+      if (r.action === 'push' || r.action === 'pull') log(`sync: ${r.action} 7ots.com`);
+      if (r.action === 'pull') restart(); // its new look/personality, everywhere
+    } catch (e) {
+      if (e.message !== syncErr) log(`sync: ${(syncErr = e.message)}`);
+    } finally {
+      syncing = false;
+    }
+  }
+  const syncTimer = setInterval(cloudSync, 60_000);
+  const syncFirst = setTimeout(cloudSync, 8000);
+  const syncLater = () => (clearTimeout(syncSoon), (syncSoon = setTimeout(cloudSync, 3000)));
+
   // Watchers: a price or a program it waits for, then it tells you (like a reminder, on a condition).
   const watchers = createWatchers({
     log,
@@ -254,6 +343,7 @@ export function startPetServer({ port = PET_PORT, log = () => {} } = {}) {
   const assistant = createAssistant({
     brain,
     access: () => config.access,
+    memoryTokens: () => config.memory.tokens,
     lang,
     name: identity.name,
     log,
@@ -280,6 +370,8 @@ export function startPetServer({ port = PET_PORT, log = () => {} } = {}) {
       brain,
       log,
       system: (said) => petSystem(identity, { lang: said || 'auto', role: 'assistant' }),
+      confirm,
+      connect: connectOrquesta,
       onLater: (text) => {
         lastSpoke = Date.now();
         pet.lastTalk = lastSpoke;
@@ -406,6 +498,12 @@ export function startPetServer({ port = PET_PORT, log = () => {} } = {}) {
       if (!existsSync(f)) return res.writeHead(404).end('run npm run build');
       return res.writeHead(200, { 'Content-Type': 'text/javascript; charset=utf-8', 'Cache-Control': 'no-cache' }).end(readFileSync(f));
     }
+    if (req.method === 'GET' && /^\/mods\/[a-f0-9]{16}\.(vrm|glb)$/.test(p)) {
+      // 3D models of full-body mods, uploaded from settings (content-addressed, so cacheable)
+      const f = homeFile(p.slice(1));
+      if (!existsSync(f)) return res.writeHead(404).end();
+      return res.writeHead(200, { 'Content-Type': 'model/gltf-binary', 'Cache-Control': 'max-age=31536000, immutable' }).end(readFileSync(f));
+    }
     if (req.method === 'GET' && p === '/favicon.svg') return res.writeHead(200, { 'Content-Type': 'image/svg+xml', 'Cache-Control': 'max-age=86400' }).end(readFileSync(join(PKG_ROOT, 'brand', 'favicon.svg')));
     const authed = okToken(url.searchParams.get('token') || req.headers['x-7ots-token']);
     if (!authed) return json(401, { error: 'token' });
@@ -448,12 +546,27 @@ export function startPetServer({ port = PET_PORT, log = () => {} } = {}) {
     if (req.method === 'GET' && p === '/events') {
       res.writeHead(200, { 'Content-Type': 'text/event-stream', 'Cache-Control': 'no-cache', Connection: 'keep-alive' });
       res.write(`data: ${JSON.stringify({ state: view(pet), ...(viewSet ? { view: viewSet } : {}) })}\n\n`);
+      for (const [id, a] of asks) res.write(`data: ${JSON.stringify({ ask: { id, text: a.text } })}\n\n`); // still waiting for you
       clients.add(res);
       req.on('close', () => clients.delete(res));
       return;
     }
-    if (req.method === 'GET' && p === '/inferences') return json(200, { inferences: inferences.list(Number(url.searchParams.get('n')) || 100) });
-    if (req.method === 'GET' && p === '/memory') return json(200, { notes: assistant.notes, reminders: assistant.reminders, seen: watcher.seen, said: history, activity, pet: view(pet) });
+    if (req.method === 'GET' && p === '/scenes') {
+      // polled by the desktop shell's director: how often ots play scenes, which ones, and a pending "play now"
+      const play = scenePlay;
+      scenePlay = null;
+      return json(200, { ...sceneConf(), play });
+    }
+    if (req.method === 'GET' && p === '/inferences') {
+      // this ot's calls plus those of the ots visiting this desktop (the host sees all), each tagged with its ot
+      const n = Number(url.searchParams.get('n')) || 100;
+      const me = { id: config.account?.otsId || 'local', name: identity.name || 'ot', self: true };
+      const all = [...inferences.list(MAX_INF).map((r) => ({ ...r, ot: me })), ...otherInferences()].sort((a, b) => b.at - a.at);
+      const ots = [...new Map(all.map((r) => [r.ot.id, r.ot])).values()];
+      const want = url.searchParams.get('ot');
+      return json(200, { ots, inferences: (want ? all.filter((r) => r.ot.id === want) : all).slice(0, n) });
+    }
+    if (req.method === 'GET' && p === '/memory') return json(200, { notes: assistant.notes, reminders: assistant.reminders, seen: watcher.seen, said: history, conversation: assistant.conversation, activity, pet: view(pet) });
     if (req.method === 'GET' && p === '/account') {
       const base = { url: SEVENOTS_URL, current: config.account || null, signedIn: signedIn() };
       if (!base.signedIn) return json(200, base);
@@ -473,13 +586,14 @@ export function startPetServer({ port = PET_PORT, log = () => {} } = {}) {
     if (req.method === 'GET' && p === '/reminders') return json(200, { reminders: assistant.reminders, notes: assistant.notes });
     if (req.method === 'GET' && p === '/cloud') return json(200, await cloudStatus(config));
     if (req.method === 'GET' && (p === '/orquesta/projects' || p === '/orquesta/prompt')) {
-      if (!env().ORQUESTA_TOKEN) return json(200, { connected: false });
+      const o = await import('./orquesta.mjs');
+      if (!o.via()) return json(200, { connected: false });
       try {
-        const o = await import('./orquesta.mjs');
         if (p === '/orquesta/projects') return json(200, { connected: true, projects: await o.agentProjects() });
         return json(200, { connected: true, ...(await o.agentTask(String(url.searchParams.get('id') || '').slice(0, 80))) });
       } catch (e) {
-        return json(e.status === 401 ? 200 : 502, { connected: e.status !== 401, error: e.message });
+        const off = [401, 409].includes(e.status); // no token / not connected on 7ots.com
+        return json(off ? 200 : 502, { connected: !off, error: off ? undefined : e.message });
       }
     }
     if (req.method !== 'POST') return json(405, { error: 'method' });
@@ -500,6 +614,23 @@ export function startPetServer({ port = PET_PORT, log = () => {} } = {}) {
         return json(e.status || 502, { error: e.message });
       }
     }
+    if (p === '/mods/upload') {
+      // a .vrm/.glb for a full-body mod: stored in ~/.7ots/mods/<sha256-16>.<ext>
+      const chunks = [];
+      let n = 0;
+      for await (const c of req) {
+        if ((n += c.length) > 60 * 1024 * 1024) return json(413, { error: 'too large' });
+        chunks.push(c);
+      }
+      const buf = Buffer.concat(chunks);
+      if (buf.length < 20 || buf.toString('latin1', 0, 4) !== 'glTF') return json(400, { error: 'model' });
+      const ext = url.searchParams.get('ext') === 'vrm' ? 'vrm' : 'glb';
+      const name = `${createHash('sha256').update(buf).digest('hex').slice(0, 16)}.${ext}`;
+      mkdirSync(homeFile('mods'), { recursive: true });
+      writeFileSync(homeFile(`mods/${name}`), buf);
+      log(`mods: model ${name} ${Math.round(buf.length / 1024)}KB`);
+      return json(200, { ok: true, url: `/mods/${name}` });
+    }
     let body = '';
     for await (const c of req) if ((body += c).length > 64 * 1024) return json(413, { error: 'too large' });
     let data = {};
@@ -508,6 +639,7 @@ export function startPetServer({ port = PET_PORT, log = () => {} } = {}) {
     } catch {
       return json(400, { error: 'json' });
     }
+    if (p.startsWith('/identity/') || p === '/config') syncLater(); // a local change goes up to 7ots.com
     if (p === '/event') {
       onEvent(data);
       savePet(pet);
@@ -524,7 +656,7 @@ export function startPetServer({ port = PET_PORT, log = () => {} } = {}) {
         const { synthesize } = await import('../../server/tts.mjs');
         // the identity's voice id/model belong to its own provider: not sent to another (an ElevenLabs id means nothing to Fish)
         const iv = identity.voice || {};
-        const voice = { ...iv, ...(iv.provider === kind ? {} : { voiceId: '', model: '' }), provider: kind, ...(config.voice.voiceId ? { voiceId: config.voice.voiceId } : {}) };
+        const voice = voiceFor(kind);
         // process.env too: XAI_TTS_VOICE, FISH_VOICE_ID, APUCHAT_VOICE_URL… (the keys still come from env())
         const { audio, contentType } = await synthesize({ text: String(data.text || '').slice(0, 600), voice, env: { ...process.env, ...env() } });
         return res.writeHead(200, { 'Content-Type': contentType }).end(audio);
@@ -532,6 +664,20 @@ export function startPetServer({ port = PET_PORT, log = () => {} } = {}) {
         return json(e.status || 502, { error: e.message });
       }
     }
+    if (p === '/voice/test') {
+      // try a provider's voice before saving it: { kind, voiceId, model, style, text }
+      const kind = String(data.kind || '');
+      if (!VOICE_PROVIDERS.includes(kind)) return json(400, { error: 'kind' });
+      try {
+        const { synthesize } = await import('../../server/tts.mjs');
+        const over = Object.fromEntries(['voiceId', 'model', 'style'].map((f) => [f, String(data[f] ?? '').trim().slice(0, 600)]));
+        const text = String(data.text || '').trim().slice(0, 300) || ({ es: `Hola, soy ${identity.name}. ¿Así me quieres oír?`, pt: `Oi, eu sou ${identity.name}. Quer me ouvir assim?` }[lang] || `Hi, I'm ${identity.name}. Is this how you want me to sound?`);
+        const { audio, contentType } = await synthesize({ text, voice: { ...voiceFor(kind), ...over }, env: { ...process.env, ...env() } });
+        return res.writeHead(200, { 'Content-Type': contentType }).end(audio);
+      } catch (e) {
+        return json(e.status || 502, { error: e.message });
+      }
+    }
     if (p === '/ask') {
       const text = String(data.text || '').trim().slice(0, 800);
       if (!text) return json(400, { error: 'text' });
@@ -603,10 +749,88 @@ export function startPetServer({ port = PET_PORT, log = () => {} } = {}) {
       }
       return restart(); // identity, language and name are read once at start
     }
+    if (p.startsWith('/community/')) {
+      // the 7ots.com gallery (server/platform/mods.mjs): browse without an account; share, rate and report with one
+      const act = p.slice('/community/'.length);
+      try {
+        if (act === 'list') return json(200, { signedIn: signedIn(), ...(await community.list(data)) });
+        if (!signedIn() && act !== 'install') return json(401, { error: 'login' });
+        if (act === 'mine') return json(200, await community.mine());
+        if (act === 'install') {
+          const mod = await community.install(data.id);
+          const [status, out] = changeMods({ mod });
+          return json(status, out);
+        }
+        if (act === 'rate') return json(200, await community.rate(data.id, data.stars));
+        if (act === 'report') return json(200, await community.report(data.id, data.reason));
+        if (act === 'remove') return json(200, await community.remove(data.id));
+        if (act === 'share') {
+          const mod = modLibrary().find((m) => m.id === data.id) || normalizeMods(identity.look?.character?.mods).find((m) => m.id === data.id);
+          if (!mod) return json(404, { error: 'mod' });
+          return json(200, await community.share(mod));
+        }
+      } catch (e) {
+        log(`community ${act}: ${e.message}`);
+        return json(e.status || 502, { error: e.message });
+      }
+      return json(404, { error: 'not found' });
+    }
+    if (p === '/identity/mods') {
+      const [status, out] = changeMods(data);
+      return json(status, out);
+    }
+    /** mods of the ot's look (a catalog one by id, or an imported .json); the pet reloads with them */
+    function changeMods(data) {
+      const { file } = loadIdentity();
+      const raw = readJson(file) || {};
+      const ch = raw.look?.character || {};
+      let mods = normalizeMods(ch.mods);
+      if (data.remove) mods = mods.filter((m) => m.id !== data.remove);
+      if (data.add || data.mod) {
+        const m = data.add ? MOD_CATALOG.find((c) => c.id === data.add) : data.mod;
+        const n = m && normalizeMod(m);
+        if (!n) return [400, { error: 'mod' }];
+        if (!mods.some((x) => x.id === n.id) && mods.length >= MAX_MODS) return [400, { error: 'maxMods' }];
+        // un muñeco completo reemplaza al ot entero: los accesorios 2D no se verían encima, así que
+        // poner uno quita el otro (si no, «poner orc» sobre un modelo no cambiaba nada)
+        mods = n.model ? [n] : [...mods.filter((x) => x.id !== n.id && !x.model), n];
+        // los importados quedan en la biblioteca local aunque después se quiten (o los reemplace otro)
+        if (data.mod) writeJson(homeFile('mods/library.json'), [...modLibrary().filter((x) => x.id !== n.id), n].slice(-60));
+      }
+      if (data.forget) writeJson(homeFile('mods/library.json'), modLibrary().filter((x) => x.id !== data.forget));
+      const look = { ...raw.look, character: { ...ch, mods } };
+      writeJson(file, { ...raw, look });
+      identity.look = defineIdentity({ ...raw, look }).look;
+      log(`identity: mods ${mods.map((m) => m.id).join(', ') || 'none'}`);
+      setTimeout(() => broadcast({ reload: true }), 100);
+      return [200, { ok: true, mods: mods.map((m) => m.id) }];
+    }
+    if (p === '/identity/lang') {
+      // the language the ot itself speaks (bubbles, brain, meet), kept in its identity file
+      if (!['en', 'es', 'pt'].includes(data.lang)) return json(400, { error: 'lang' });
+      const { file } = loadIdentity();
+      const raw = readJson(file) || {};
+      writeJson(file, { ...raw, language: data.lang, voice: { ...raw.voice, lang: { es: 'es-ES', en: 'en-US', pt: 'pt-BR' }[data.lang] } });
+      log(`identity: speaks ${data.lang}`);
+      json(200, { ok: true });
+      return restart();
+    }
     if (p === '/inferences/clear') return inferences.clear(), json(200, { ok: true });
+    if (p === '/conversation/forget') return json(200, { ok: assistant.forgetConversation() });
     if (p === '/notes/forget') return json(200, { ok: assistant.forget(data.at === 'all' ? 'all' : String(data.at ?? '')) });
     if (p === '/watchers/cancel') return json(200, { ok: watchers.cancel(String(data.id || '')) });
     if (p === '/reminders/cancel') return json(200, { ok: assistant.cancel(String(data.id || '')) });
+    if (p === '/approve') {
+      const a = asks.get(String(data.id || ''));
+      if (!a) return json(404, { error: 'gone' });
+      a.done(data.ok === true);
+      return json(200, { ok: true });
+    }
+    if (p === '/orquesta/connect') {
+      const r = connectOrquesta();
+      r.catch((e) => log(`orquesta: ${e.message}`));
+      return json(200, { ok: true });
+    }
     if (p === '/orquesta/send') {
       const projectId = String(data.projectId || '');
       const text = String(data.text || '').trim();
@@ -617,6 +841,78 @@ export function startPetServer({ port = PET_PORT, log = () => {} } = {}) {
         return json(e.status === 400 ? 400 : 502, { error: e.message });
       }
     }
+    if (p === '/voice/list') {
+      // the voices a provider offers with the saved key (ElevenLabs: yours + saved from the library; Fish: your models)
+      const kind = String(data.kind || '');
+      const keys = env();
+      try {
+        if (kind === 'elevenlabs') {
+          if (!keys.ELEVENLABS_API_KEY) return json(400, { error: 'key' });
+          const r = await fetch('https://api.elevenlabs.io/v1/voices', { headers: { 'xi-api-key': keys.ELEVENLABS_API_KEY }, signal: AbortSignal.timeout(15000) });
+          if (!r.ok) return json(502, { error: `ElevenLabs ${r.status}` });
+          const j = await r.json();
+          return json(200, { voices: (j.voices || []).map((v) => ({ id: v.voice_id, name: v.name, note: [v.category, v.labels?.accent, v.labels?.gender, v.labels?.age].filter(Boolean).join(' · '), preview: v.preview_url || '' })) });
+        }
+        if (kind === 'fish') {
+          if (!keys.FISH_API_KEY) return json(400, { error: 'key' });
+          const r = await fetch('https://api.fish.audio/model?self=true&page_size=50', { headers: { Authorization: `Bearer ${keys.FISH_API_KEY}` }, signal: AbortSignal.timeout(15000) });
+          if (!r.ok) return json(502, { error: `Fish Audio ${r.status}` });
+          const j = await r.json();
+          return json(200, { voices: (j.items || []).map((v) => ({ id: v._id, name: v.title, note: (v.languages || []).join(', ') })) });
+        }
+        if (kind === 'openai') return json(200, { voices: OPENAI_VOICES.map((v) => ({ id: v, name: v })) });
+        if (kind === 'grok') return json(200, { voices: GROK_VOICES.map((v) => ({ id: v, name: v })) });
+        return json(200, { voices: [] });
+      } catch (e) {
+        return json(502, { error: e.message });
+      }
+    }
+    if (p === '/character/draft') {
+      // the brain drafts the character sheet from the identity (+ an optional idea); nothing is saved
+      if (brain.kind === 'lines') return json(400, { error: 'brain' });
+      const cur = config.character || {};
+      const KEYS = ['backstory', 'style', 'quirks', 'scenario', 'greeting', 'examples'];
+      const who = { name: identity.name, role: identity.role, tagline: identity.tagline, bio: identity.bio, tone: identity.personality?.tone, traits: identity.personality?.traits, look: (identity.look?.character?.mods || []).map((m) => m.id) };
+      const L = ['es', 'en', 'pt'].includes(data.lang) ? data.lang : lang;
+      const LN = { es: 'Spanish (español)', pt: 'Brazilian Portuguese (português)', en: 'English' }[L];
+      const FIELDS = {
+        backstory: 'backstory (4-6 sentences: where it comes from, what it wants, what it fears)',
+        style: 'style (how it talks: rhythm, words it likes, what it never does)',
+        quirks: 'quirks (5-8 short habits, one per line)',
+        scenario: 'scenario (1-2 sentences: where it lives and what it does all day)',
+        greeting: 'greeting (one short line)',
+        examples: `examples (3-4 tiny exchanges, lines «Human: …» and «${identity.name}: …»)`,
+      };
+      const ask = (keys) => `Write a character sheet for a desktop pet called ${identity.name}.
+LANGUAGE: write every field entirely in ${LN}, even if the profile below is in another language (translate it).
+Who it is (from its profile): ${JSON.stringify(who)}
+${KEYS.some((k) => cur[k]) ? `Current sheet (keep what is good, improve the rest): ${JSON.stringify(Object.fromEntries(KEYS.map((k) => [k, cur[k] || ''])))}` : ''}
+${data.idea ? `The owner's idea for it: «${String(data.idea).slice(0, 600)}»` : ''}
+Make it varied and specific so it never gets stuck on one or two topics (it is a companion that comments on the owner's coding work, chats and keeps them company): many interests, opinions, running jokes, small habits.
+Answer ONLY a flat JSON object with exactly these keys, each a non-empty string in ${LN}:
+${keys.map((k) => FIELDS[k]).join('\n')}`;
+      // models drift: other casing, arrays, nested objects or a wrapper ({ sheet: {…} })
+      const textOf = (v) => (Array.isArray(v) ? v.map(textOf).join('\n') : v && typeof v === 'object' ? Object.entries(v).map(([k, x]) => (typeof x === 'object' ? textOf(x) : /^(human|user|q|a|\d+)$/i.test(k) ? x : `${k}: ${x}`)).join('\n') : String(v ?? ''));
+      const pick = (j) => {
+        const o = j && typeof j === 'object' ? (Object.keys(j).length === 1 && typeof Object.values(j)[0] === 'object' && !Array.isArray(Object.values(j)[0]) ? Object.values(j)[0] : j) : {};
+        const low = Object.fromEntries(Object.entries(o).map(([k, v]) => [k.toLowerCase().replace(/[^a-z]/g, ''), v]));
+        const alias = { backstory: ['backstory', 'history', 'background', 'story', 'description'], style: ['style', 'speakingstyle', 'voice'], quirks: ['quirks', 'habits'], scenario: ['scenario', 'setting'], greeting: ['greeting', 'firstmessage', 'hello'], examples: ['examples', 'exampledialogue', 'dialogues', 'exchanges'] };
+        return Object.fromEntries(KEYS.map((k) => [k, textOf(alias[k].map((a) => low[a]).find((v) => v != null && v !== '') ?? '').trim()]));
+      };
+      const run = async (keys) => {
+        const raw = String(await brain.think({ purpose: 'character', system: `You are a character writer. You write in ${LN}. Output strict JSON only.`, messages: [{ role: 'user', content: ask(keys) }], timeoutMs: 120000, raw: true }));
+        return pick(JSON.parse(raw.slice(raw.indexOf('{'), raw.lastIndexOf('}') + 1)));
+      };
+      try {
+        const out = await run(KEYS);
+        const missing = KEYS.filter((k) => !out[k]);
+        if (missing.length) Object.assign(out, Object.fromEntries(Object.entries(await run(missing).catch(() => ({}))).filter(([k, v]) => missing.includes(k) && v)));
+        const lim = { backstory: 3000, style: 1500, quirks: 1500, scenario: 1500, greeting: 600, examples: 4000 };
+        return json(200, { lang: L, sheet: Object.fromEntries(KEYS.map((k) => [k, (out[k] || '').slice(0, lim[k])])) });
+      } catch (e) {
+        return json(502, { error: e.message });
+      }
+    }
     if (p === '/character/letta') {
       try {
         const r = await lettaSync(identity, config.character);
@@ -631,6 +927,10 @@ export function startPetServer({ port = PET_PORT, log = () => {} } = {}) {
         return json(e.status === 400 ? 400 : 502, { error: e.message });
       }
     }
+    if (p === '/scenes/play') {
+      scenePlay = { scene: SCENE_NAMES.includes(data.scene) ? data.scene : '', at: Date.now() };
+      return json(200, { ok: true });
+    }
     if (p === '/quit') {
       json(200, { ok: true });
       await Promise.all(fullOnes().map(quitCompanion)); // the second ot leaves with it (a restart keeps it)
@@ -645,7 +945,8 @@ export function startPetServer({ port = PET_PORT, log = () => {} } = {}) {
     return {
       name: identity.name,
       lang,
-      config: { brain: config.brain, pet: config.pet, access: config.access, voice: config.voice, screen: config.screen },
+      visitor: !!process.env.SEVENOTS_COMPANION, // a visiting ot: the host's settings rule shared things (scenes)
+      config: { brain: config.brain, pet: { ...config.pet, scenes: sceneConf() }, access: config.access, voice: config.voice, screen: config.screen, memory: config.memory },
       brain: brainLabel(config.brain),
       clis: detectClis(),
       stt: sttProvider(keys),
@@ -653,6 +954,10 @@ export function startPetServer({ port = PET_PORT, log = () => {} } = {}) {
       voices: { local: localVoices(), keys: { elevenlabs: Boolean(keys.ELEVENLABS_API_KEY), openai: Boolean(keys.OPENAI_API_KEY), apuchat: Boolean(keys.APUCHAT_VOICE_TOKEN), grok: Boolean(keys.XAI_API_KEY), fish: Boolean(keys.FISH_API_KEY) } },
       uiLang: uiLangOf(config, lang),
       configLang: config.lang || '',
+      otLook: identity.look?.character || null,
+      // the catalog without its 3D models (the page only draws the 2D previews)
+      modLibrary: modLibrary(),
+      modCatalog: MOD_CATALOG.map((m) => normalizeMod(m)).map((m) => ({ ...m, parts: m.parts.map((x) => ({ ...x, glb: x.glb ? '3d' : '' })) })),
       integrations: config.integrations,
       character: config.character,
       account: config.account || null,
@@ -693,6 +998,14 @@ export function startPetServer({ port = PET_PORT, log = () => {} } = {}) {
     if (d.pet) {
       if (d.pet.annoy !== undefined) next.pet.annoy = Math.max(0, Math.min(3, Math.round(Number(d.pet.annoy)) || 0));
       if (['2d', '3d'].includes(d.pet.view)) next.pet.view = d.pet.view;
+      if (d.pet.scenes) {
+        const c = { ...sceneConf(next), ...d.pet.scenes };
+        next.pet.scenes = {
+          on: c.on !== false,
+          every: SCENE_EVERY.includes(c.every) ? c.every : 'normal',
+          list: Array.isArray(c.list) ? [...new Set(c.list.filter((n) => SCENE_NAMES.includes(n)))] : SCENE_NAMES,
+        };
+      }
     }
     if (d.access) for (const k of Object.keys(next.access)) if (typeof d.access[k] === 'boolean') next.access[k] = d.access[k];
     if (Array.isArray(d.access?.vmKinds)) next.access.vmKinds = [...new Set(d.access.vmKinds.filter((k) => VM_KINDS.includes(k)))];
@@ -706,12 +1019,29 @@ export function startPetServer({ port = PET_PORT, log = () => {} } = {}) {
     } catch (e) {
       return e.message;
     }
+    if (d.memory?.tokens !== undefined) {
+      const n = Math.round(Number(d.memory.tokens)) || 0;
+      next.memory.tokens = n <= 0 ? 0 : Math.max(2000, Math.min(200000, n));
+    }
     if (d.screen?.every !== undefined) next.screen.every = Math.max(1, Math.min(60, Math.round(Number(d.screen.every)) || 5));
     let reload = false;
     if (d.voice) {
       if (!['none', 'browser', 'local', 'elevenlabs', 'openai', 'apuchat', 'grok', 'fish'].includes(d.voice.kind)) return 'voice';
       reload = d.voice.kind !== next.voice.kind;
       next.voice = { ...next.voice, kind: d.voice.kind };
+      // each provider's own voice, model and style ({ elevenlabs: { voiceId, model }, openai: { voiceId, model, style } … })
+      const pv = d.voice.providers;
+      if (pv && typeof pv === 'object') {
+        const providers = { ...(next.voice.providers || {}) };
+        for (const [k, v] of Object.entries(pv)) {
+          if (!VOICE_PROVIDERS.includes(k) || !v || typeof v !== 'object') continue;
+          const clean = Object.fromEntries(['voiceId', 'model', 'style', 'name'].map((f) => [f, String(v[f] ?? '').replace(/[\u0000-\u001f]/g, '').trim().slice(0, f === 'style' ? 600 : 120)]).filter(([, x]) => x));
+          if (Object.keys(clean).length) providers[k] = clean;
+          else delete providers[k];
+        }
+        next.voice.providers = providers;
+        reload = true;
+      }
     }
     if (d.keys) {
       for (const [k, v] of Object.entries(d.keys)) {
@@ -744,6 +1074,9 @@ export function startPetServer({ port = PET_PORT, log = () => {} } = {}) {
 
   function stop(then) {
     clearInterval(timer);
+    clearInterval(syncTimer);
+    clearTimeout(syncFirst);
+    clearTimeout(syncSoon);
     assistant.stop();
     watchers.stop();
     stopWatch();

package/cli/pet/electron/director.cjs

@@ -98,12 +98,36 @@ const SCENES = {
 
 const GAP = 170; // how far apart they stand (their windows grow for what flies between them)
 
-exports.createDirector = ({ ots, lang = 'en' }) => {
+// minutes between scenes, per the "how often" setting
+const EVERY = { rare: [5, 10], normal: [1.5, 3.5], often: [0.5, 1] };
+
+exports.createDirector = ({ ots, lang = 'en', url, token }) => {
   const L = LINES[lang] || LINES.en;
   let running = false;
   const SOON = process.env.SEVENOTS_PET_SCENES_SOON === '1'; // testing: one scene after another
   let nextAt = Date.now() + (SOON ? 4000 : 25000);
   let last = '';
+  // settings (daemon GET /scenes): on/off, how often, which scenes; plus a "play one now" from settings
+  let conf = { on: true, every: 'normal', list: Object.keys(SCENES) };
+  let want = null; // scene asked for ('' = any), played as soon as two ots are free
+  const gap = () => {
+    const [lo, hi] = EVERY[conf.every] || EVERY.normal;
+    return (lo + Math.random() * (hi - lo)) * 60000;
+  };
+  // the host's daemon holds the settings; a "play now" may come from any ot's settings
+  const get = (u, tk) => fetch(new URL('/scenes', u), { headers: { 'X-7ots-Token': tk } }).then((x) => (x.ok ? x.json() : null), () => null);
+  if (url && token)
+    setInterval(async () => {
+      const others = [...ots.values()].map((o) => o.daemon).filter((d) => d?.token && d.url !== url);
+      const [r, ...rest] = await Promise.all([get(url, token), ...others.map((d) => get(d.url, d.token))]);
+      if (r) {
+        const changed = r.every !== conf.every;
+        conf = { on: r.on !== false, every: r.every, list: (r.list || []).filter((n) => SCENES[n]) };
+        if (changed) nextAt = Math.min(nextAt, Date.now() + gap()); // more often: don't wait out the old, longer gap
+      }
+      const asked = [r, ...rest].find((x) => x?.play)?.play;
+      if (asked) want = asked.scene || '';
+    }, 2000);
   const wait = (ms) => new Promise((r) => setTimeout(r, ms));
   // waits, but gives up as soon as the mouse is on either of them (to click or drag it): true = interrupted
   const pause = async (ms, ...pair) => {
@@ -111,7 +135,7 @@ exports.createDirector = ({ ots, lang = 'en' }) => {
     return pair.some((o) => o.interrupted());
   };
 
-  async function play(x, y) {
+  async function play(x, y, asked = null) {
     running = true;
     // they take turns: a line from one ends the other's (one speech bubble at a time)
     const turns = (o, other) => ({ ...o, say: (m) => (m?.line && other.say({ hush: true }), o.say(m)) });
@@ -132,8 +156,10 @@ exports.createDirector = ({ ots, lang = 'en' }) => {
       a.face(1);
       b.face(-1);
       if (await pause(500, a, b)) return;
-      const names = Object.keys(SCENES).filter((n) => n !== last);
-      const name = process.env.SEVENOTS_PET_SCENE || names[Math.floor(Math.random() * names.length)];
+      const pool = conf.list.length ? conf.list : Object.keys(SCENES);
+      const names = pool.length > 1 ? pool.filter((n) => n !== last) : pool;
+      if (asked !== null) want = null; // the request is served only once the scene really starts
+      const name = process.env.SEVENOTS_PET_SCENE || asked || names[Math.floor(Math.random() * names.length)];
       last = name;
       console.log(`[7ots director] ${name}`);
       // half the time the right one starts (scenes are written for the left one)
@@ -146,7 +172,7 @@ exports.createDirector = ({ ots, lang = 'en' }) => {
     } finally {
       for (const o of [x, y]) (o.hold(null), o.inScene() && o.release());
       running = false;
-      nextAt = Date.now() + (SOON ? 3000 : 90000 + Math.random() * 120000);
+      nextAt = Date.now() + (SOON ? 3000 : gap());
     }
   }
 
@@ -158,8 +184,14 @@ exports.createDirector = ({ ots, lang = 'en' }) => {
 
   setInterval(() => {
     if (running) return;
+    if (want !== null) {
+      const s = [...ots.values()].filter((o) => o.ready()).sort(() => Math.random() - 0.5);
+      if (s.length >= 2) play(s[0], s[1], want).catch((e) => console.log('[7ots director]', e.message));
+      return;
+    }
     const free = [...ots.values()].filter((o) => o.free());
     if (free.length < 2) return;
+    if (!conf.on || !conf.list.length) return;
     // two that wandered close start right away; otherwise now and then
     let pair = null;
     for (let i = 0; i < free.length && !pair; i++)