@7ots/cli 0.1.0

package/cli/lib/pet-server.mjs

@@ -0,0 +1,296 @@
+/**
+ * The pet daemon on http://127.0.0.1:7717 (SEVENOTS_PET_PORT).
+ *
+ *   GET  /health                       { ok, name }               (no token)
+ *   GET  /pet?token=…[&desktop=1]      the pet page (browser and desktop modes)
+ *   GET  /dist/7ots.esm.js             the 7ots bundle (createCharacter)
+ *   GET  /state?token=…                identity + state
+ *   GET  /events?token=…               SSE: { state, say?, gesture?, effect?, morph?, activity? }
+ *   POST /event   X-7ots-Token         { type: tool|shell|prompt|stop|notify|start|feed|play|sleep|wake|say, … }
+ *   POST /tts     X-7ots-Token         { text } → audio with the configured voice
+ *   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).
+ * The token lives in ~/.7ots/pet.token (0600): other users of the machine can't drive the pet.
+ */
+
+import { createServer } from 'node:http';
+import { randomBytes, timingSafeEqual } from 'node:crypto';
+import { readFileSync, existsSync, writeFileSync, chmodSync } from 'node:fs';
+import { join } from 'node:path';
+import { createBrain, petSystem } from './brain.mjs';
+import { loadConfig, env } from './config.mjs';
+import { loadIdentity } from './identity.mjs';
+import { line } from './lines.mjs';
+import { ensureHome, homeFile, PET_PORT, PKG_ROOT } from './paths.mjs';
+import { applyEvent, loadPet, need, savePet, tick, view } from './pet-core.mjs';
+
+export function petToken() {
+  ensureHome();
+  const f = homeFile('pet.token');
+  if (existsSync(f)) {
+    const t = readFileSync(f, 'utf8').trim();
+    if (t.length >= 32) return t;
+  }
+  const t = randomBytes(24).toString('hex');
+  writeFileSync(f, t + '\n', { mode: 0o600 });
+  chmodSync(f, 0o600);
+  return t;
+}
+
+/** Is a daemon already running? */
+export async function petAlive(port = PET_PORT) {
+  try {
+    const r = await fetch(`http://127.0.0.1:${port}/health`, { signal: AbortSignal.timeout(600) });
+    return r.ok ? await r.json() : null;
+  } catch {
+    return null;
+  }
+}
+
+/** Sends an event to the daemon; false if it isn't running. */
+export async function postPet(path, body, port = PET_PORT) {
+  try {
+    const r = await fetch(`http://127.0.0.1:${port}${path}`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json', 'X-7ots-Token': petToken() },
+      body: JSON.stringify(body || {}),
+      signal: AbortSignal.timeout(1500),
+    });
+    return r.ok;
+  } catch {
+    return false;
+  }
+}
+
+const brainLabel = (b = {}) => (b.kind === 'cli' ? `${b.cli}${b.model ? ` · ${b.model}` : ''}` : b.kind === 'api' ? `${b.provider || 'api'}${b.model ? ` · ${b.model}` : ''}` : b.kind || 'lines');
+
+const GAP = { 0: Infinity, 1: 10 * 60_000, 2: 90_000, 3: 20_000 }; // minimum silence between spontaneous lines
+const CHATTY = { 0: 0, 1: 0.02, 2: 0.12, 3: 0.35 }; // chance to comment a routine event (tool, ok, prompt)
+const IDLE = { 0: Infinity, 1: 60 * 60_000, 2: 20 * 60_000, 3: 5 * 60_000 }; // idle chatter every…
+
+export function startPetServer({ port = PET_PORT, log = () => {} } = {}) {
+  const token = petToken();
+  const config = loadConfig();
+  const annoy = Math.max(0, Math.min(3, Number(config.pet.annoy ?? 2)));
+  const { identity } = loadIdentity();
+  if (!identity) throw Object.assign(new Error('no identity'), { code: 'NO_IDENTITY' });
+  const lang = identity.language || 'en';
+  const brain = createBrain(config.brain, config.home);
+  const pet = tick(loadPet());
+  const clients = new Set();
+  const history = []; // last lines (so the AI doesn't repeat itself)
+  const activity = []; // what happened lately, for the window's feed
+  let thinking = false;
+  let lastSpoke = 0;
+  let lastIdle = Date.now();
+
+  const broadcast = (msg) => {
+    const data = `data: ${JSON.stringify({ state: view(pet), ...msg })}\n\n`;
+    for (const res of clients) res.write(data);
+  };
+
+  async function speak(kind, vars = {}, situation = '', { force = false, gesture = null } = {}) {
+    const now = Date.now();
+    if (!force && (pet.asleep || now - lastSpoke < GAP[annoy])) {
+      broadcast({ gesture });
+      return;
+    }
+    lastSpoke = now;
+    let text = '';
+    if (brain.kind !== 'lines' && situation && !thinking) {
+      thinking = true;
+      broadcast({ thinking: true, gesture });
+      try {
+        text = await brain.think({
+          system: petSystem(identity, { lang }),
+          messages: [{ role: 'user', content: `${situation}${history.length ? `\n(Things you already said: ${history.join(' | ')})` : ''}` }],
+          timeoutMs: 30000,
+        });
+      } catch (e) {
+        log(`brain: ${e.message}`);
+      }
+      thinking = false;
+    }
+    if (!text) text = line(kind, lang, { name: identity.name, level: pet.level, ...vars });
+    if (!text) return;
+    history.push(text);
+    if (history.length > 6) history.shift();
+    pet.lastTalk = now;
+    broadcast({ say: text, gesture, thinking: false });
+  }
+
+  const SITUATION = {
+    tool: (e) => `Your human's coding agent just used the tool ${e.tool}${e.detail ? ` (${e.detail})` : ''}.`,
+    toolFail: (e) => `Your human's coding agent tried the tool ${e.tool} and it FAILED${e.detail ? `: ${e.detail}` : ''}.`,
+    ok: (e) => `In the terminal, the command \`${e.cmd || '?'}\` just succeeded.`,
+    fail: (e) => `In the terminal, the command \`${e.cmd || '?'}\` just failed with exit code ${e.code}.`,
+    prompt: (e) => `Your human just asked their coding agent: "${String(e.text || '').slice(0, 300)}".`,
+    stop: () => `Your human's coding agent just finished its turn. Encourage them to check the result.`,
+    waiting: (e) => `Your human's coding agent is waiting for them (permission or an answer)${e.message ? `: ${e.message}` : ''}. Get their attention.`,
+    hello: () => `You just woke up on your human's desktop. Say hi.`,
+    levelUp: () => `You just reached level ${pet.level}. Celebrate.`,
+    fed: () => `Your human just fed you.`,
+    played: () => `Your human just played with you.`,
+    slept: () => `You are going to sleep now.`,
+    woke: () => `You just woke up.`,
+    hungry: () => `You are hungry (food ${Math.round(pet.food)}/100). Ask for food; the command is "7ots feed".`,
+    bored: () => `You are bored (fun ${Math.round(pet.fun)}/100). Ask to play; the command is "7ots play".`,
+    sleepy: () => `You are very tired. Ask for a nap; the command is "7ots sleep".`,
+    idle: () => `Nothing happened for a while. Say something in character about keeping them company, their work or their wellbeing.`,
+  };
+
+  /** Event → one feed row: { kind, ok, text, at }. Care actions and `say` are not activity. */
+  function track(ev) {
+    const text = {
+      tool: () => `${ev.tool || 'tool'}${ev.detail ? ` · ${ev.detail}` : ''}`,
+      shell: () => ev.cmd || `exit ${ev.code}`,
+      prompt: () => ev.text || '',
+      stop: () => ev.detail || '',
+      notify: () => ev.message || '',
+      start: () => '',
+    }[ev.type];
+    if (!text || (ev.type === 'shell' && Number(ev.code) === 130)) return null;
+    const row = { kind: ev.type, ok: ev.type === 'tool' ? ev.ok !== false : ev.type === 'shell' ? Number(ev.code) === 0 : true, text: String(text()).slice(0, 140), at: Date.now() };
+    activity.push(row);
+    if (activity.length > 30) activity.shift();
+    return row;
+  }
+
+  function onEvent(ev) {
+    const act = track(ev);
+    if (act) broadcast({ activity: act });
+    const r = applyEvent(pet, ev);
+    if (r.effect || r.morph) broadcast({ effect: r.effect, morph: r.morph });
+    if (ev.type === 'say' && ev.text) {
+      lastSpoke = Date.now();
+      broadcast({ say: String(ev.text).slice(0, 300), gesture: 'wave' });
+      return;
+    }
+    const kind = r.line;
+    if (!kind) return broadcast({ gesture: r.gesture });
+    const routine = !r.important && !['fail', 'toolFail'].includes(kind);
+    if (routine && Math.random() >= CHATTY[annoy]) return broadcast({ gesture: r.gesture });
+    const sit = SITUATION[kind]?.(ev) || '';
+    speak(kind, { cmd: ev.cmd || '', tool: ev.tool || '' }, sit, { force: r.important && ev.type !== 'tool', gesture: r.gesture });
+  }
+
+  // Needs and idle chatter, once a minute.
+  const timer = setInterval(() => {
+    tick(pet);
+    savePet(pet);
+    const n = need(pet);
+    const now = Date.now();
+    if (n && now - pet.lastTalk > Math.max(GAP[annoy], 5 * 60_000)) speak(n, {}, SITUATION[n]());
+    else if (now - lastIdle > IDLE[annoy] && now - pet.lastTalk > IDLE[annoy] / 2) {
+      lastIdle = now;
+      speak('idle', {}, SITUATION.idle());
+    }
+    broadcast({});
+  }, 60_000);
+
+  // Home on getorquesta.com: comment on what the project's agent does.
+  let stopWatch = () => {};
+  if (config.home.kind === 'orquesta' && config.home.projectId && env().ORQUESTA_TOKEN) {
+    import('./orquesta.mjs').then(({ watchLogs }) => {
+      stopWatch = watchLogs(
+        config.home.projectId,
+        (l) => {
+          const detail = String(l.message || '').slice(0, 200);
+          if (l.level === 'error') onEvent({ type: 'tool', ok: false, tool: 'Orquesta', detail });
+          else if (/complet|finish|done|success/i.test(`${l.category} ${l.message}`)) onEvent({ type: 'stop', detail });
+          else onEvent({ type: 'tool', ok: true, tool: 'Orquesta', detail });
+        },
+        { onError: (e) => log(`orquesta: ${e.message}`) },
+      );
+    });
+  }
+
+  const okToken = (t) => {
+    const a = Buffer.from(String(t || ''));
+    const b = Buffer.from(token);
+    return a.length === b.length && timingSafeEqual(a, b);
+  };
+
+  const page = () =>
+    readFileSync(join(PKG_ROOT, 'cli', 'pet', 'pet.html'), 'utf8')
+      .replace('__BOOT__', JSON.stringify({ token, identity, voice: config.voice, lang, annoy, brain: brainLabel(config.brain), activity }).replace(/</g, '\\u003c'));
+
+  const server = createServer(async (req, res) => {
+    const url = new URL(req.url, 'http://127.0.0.1');
+    const host = String(req.headers.host || '').replace(/:\d+$/, '');
+    if (!['127.0.0.1', 'localhost'].includes(host)) return res.writeHead(403).end();
+    const json = (code, data) => res.writeHead(code, { 'Content-Type': 'application/json' }).end(JSON.stringify(data));
+    const p = url.pathname;
+
+    if (p === '/health') return json(200, { ok: true, name: identity.name, pid: process.pid });
+    if (req.method === 'GET' && p === '/dist/7ots.esm.js') {
+      const f = join(PKG_ROOT, 'dist', '7ots.esm.js');
+      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));
+    }
+    const authed = okToken(url.searchParams.get('token') || req.headers['x-7ots-token']);
+    if (!authed) return json(401, { error: 'token' });
+
+    if (req.method === 'GET' && p === '/pet') {
+      return res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8', 'Cache-Control': 'no-store', 'Referrer-Policy': 'no-referrer' }).end(page());
+    }
+    if (req.method === 'GET' && p === '/state') return json(200, { identity, state: view(pet), config: { voice: config.voice, pet: config.pet, brain: config.brain.kind } });
+    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) })}\n\n`);
+      clients.add(res);
+      req.on('close', () => clients.delete(res));
+      return;
+    }
+    if (req.method !== 'POST') return json(405, { error: 'method' });
+    let body = '';
+    for await (const c of req) if ((body += c).length > 64 * 1024) return json(413, { error: 'too large' });
+    let data = {};
+    try {
+      data = body ? JSON.parse(body) : {};
+    } catch {
+      return json(400, { error: 'json' });
+    }
+    if (p === '/event') {
+      onEvent(data);
+      savePet(pet);
+      return json(200, { ok: true, state: view(pet) });
+    }
+    if (p === '/tts') {
+      const kind = config.voice.kind;
+      if (['none', 'browser'].includes(kind)) return json(501, { error: 'browser voice' });
+      try {
+        const { synthesize } = await import('../../server/tts.mjs');
+        const voice = { ...identity.voice, provider: kind, ...(config.voice.voiceId ? { voiceId: config.voice.voiceId } : {}) };
+        const { audio, contentType } = await synthesize({ text: String(data.text || '').slice(0, 600), voice, env: env() });
+        return res.writeHead(200, { 'Content-Type': contentType }).end(audio);
+      } catch (e) {
+        return json(e.status || 502, { error: e.message });
+      }
+    }
+    if (p === '/quit') {
+      json(200, { ok: true });
+      return stop();
+    }
+    return json(404, { error: 'not found' });
+  });
+
+  function stop() {
+    clearInterval(timer);
+    stopWatch();
+    savePet(pet);
+    for (const c of clients) c.end();
+    server.close();
+    setTimeout(() => process.exit(0), 200).unref();
+  }
+
+  return new Promise((resolve, reject) => {
+    server.once('error', reject);
+    server.listen(port, '127.0.0.1', () => {
+      log(`pet ${identity.name} on http://127.0.0.1:${port}`);
+      setTimeout(() => onEvent({ type: 'start' }), 1500);
+      resolve({ port, token, identity, stop, onEvent });
+    });
+  });
+}

package/cli/lib/prompts.mjs

@@ -0,0 +1,75 @@
+/**
+ * Prompts for coding agents (Claude Code, Codex, Gemini CLI, Cursor…). `7ots prompt <topic>`
+ * prints them and the proxy serves them all at https://7ots.com/llms.txt.
+ */
+
+export const PROMPTS = {
+  identity: `## Create a random 7ots identity
+When the user says "use 7ots, create a random identity" (or similar):
+1. Run \`npx -y @7ots/cli new\` (add \`--name <Name>\` if they gave a name, \`--lang en|es|pt\` for the language,
+   \`--seed <seed>\` to reproduce a specific ot, \`--global\` for one shared by every project).
+2. It writes \`.7ots/identity.json\` and prints the ot's name, role, personality, voice and its seed.
+   The seed reproduces exactly the same ot anywhere (web, CLI, pet, meet): tell the user the seed.
+3. Show the user who their ot is. If they don't like it, run \`npx -y @7ots/cli new --force\` for another one.
+Never invent identity fields by hand: the CLI validates them.`,
+
+  install: `## Install the identity in this project
+When the user says "install it here":
+1. Make sure there is an identity (\`npx -y @7ots/cli show\`; if none, create one as above).
+2. Run \`npx -y @7ots/cli install\`. It detects the project:
+   - plain HTML site → inserts the 7ots widget before </body> (between <!-- 7ots --> markers, idempotent);
+   - other projects → prints the snippet: put it in the root layout/template, before </body>;
+   - \`--target self\` → prepares the identity for the user's own 7ots server (IDENTITY_FILE=… npx -p 7ots 7ots-server);
+   - it also prints a 7ots.com link that hosts this same identity (no server needed).
+3. The widget needs an AI endpoint: a 7ots proxy (/api/agent) or the ot hosted on 7ots.com. Tell the user which.`,
+
+  pet: `## Wake up the desktop pet (tamagotchi)
+The ot can live on the user's computer as a virtual pet that watches the terminal and the coding agent,
+comments on what happens and has needs (food, energy, fun, levels).
+1. If the user hasn't configured it, suggest \`npx -y @7ots/cli setup\` (an interactive wizard: where the ot lives,
+   which brain — their own AI CLI, an API key, 7ots or Orquesta Batuta —, voice, pet mode, chattiness, hooks).
+   It is interactive: ask the user to run it themselves with \`! npx -y @7ots/cli setup\` in Claude Code.
+2. Pick the mode, or ask the user if it's not obvious:
+   - desktop: \`npx -y @7ots/cli pet --mode desktop --detach\` (a small always-on-top window that walks along the screen; downloads Electron once)
+   - browser: \`npx -y @7ots/cli pet --mode browser --detach\`
+   - terminal: \`npx -y @7ots/cli pet --mode terminal\` (needs its own terminal: ask the user to run it)
+   Always use --detach from an agent so the command returns.
+3. To let it react to your work: \`npx -y @7ots/cli hooks install --claude\` (Claude Code hooks in this project) and/or
+   \`--shell\` (bash/zsh). Remove with \`npx -y @7ots/cli hooks remove\`.
+4. Care: \`7ots feed\`, \`7ots play\`, \`7ots sleep\`, \`7ots status\`, \`7ots say "<text>"\`, \`7ots stop\`.`,
+
+  meet: `## Join an apuchat meet video call with this identity
+The ot joins meet.apuchat.com with its own meet avatar, scene and personality, and talks using the configured brain.
+- New call: \`npx -y @7ots/cli meet --new\` prints a private link for the user (it carries keys and PIN: give it only to them),
+  then the ot waits in the call. It runs until the call ends, so start it in the background or ask the user to run it.
+- Existing call: \`npx -y @7ots/cli meet "<invite text or https://meet.apuchat.com/call#c=…&t=…&p=… link>"\`.
+- The brain comes from \`7ots setup\`; without one the ot only says stock phrases.
+- Protocol details for agents that want to join directly: https://meet.apuchat.com/llms.txt
+  (create a free identity: POST https://apuchat.com/api/account → session_token; POST /api/account/identities with
+  Bearer session → callsign + identity_key; join with {identity_key}; send a kind:"status" line, then "[avatar]<name>"
+  and optionally "[scene]<scene>"; reply with /send {to:"all"}; ignore status lines, your own callsign and lines starting with "[").`,
+};
+
+export function promptText(topic = 'all') {
+  if (topic === 'all' || !PROMPTS[topic]) return Object.values(PROMPTS).join('\n\n');
+  return PROMPTS[topic];
+}
+
+/** https://7ots.com/llms.txt */
+export function llmsTxt(base = 'https://7ots.com') {
+  return `# 7ots
+
+> Open-source embeddable web agent: it sees the page, speaks and acts for your visitor. One HTML tag, your server, your brand.
+> Every ot has an identity (face, personality, voice, meet avatar) reproducible from a short seed, and can also live on
+> your computer as a virtual pet and join apuchat meet video calls.
+
+- Site: ${base}/
+- Create an identity in the browser: ${base}/#create
+- Hosted ots (dashboard): ${base}/app/
+- npm: https://www.npmjs.com/package/7ots (CLI: \`npx @7ots/cli help\`)
+
+# Recipes for coding agents
+
+${promptText('all')}
+`;
+}

package/cli/lib/terminal.mjs

@@ -0,0 +1,145 @@
+/**
+ * Terminal mode: the pet drawn with ANSI in the current terminal, fed by the daemon's SSE.
+ * Keys: f feed · p play · s sleep/wake · q quit (the daemon keeps running if --detach started it).
+ */
+
+import { PET_PORT } from './paths.mjs';
+import { petToken, postPet } from './pet-server.mjs';
+import { t } from './i18n.mjs';
+
+export const FACES = {
+  happy: ['◕', '‿', '◕'],
+  neutral: ['•', 'ᴗ', '•'],
+  sad: ['╥', '﹏', '╥'],
+  disgust: ['¬', '_', '¬'],
+  angry: ['ಠ', '益', 'ಠ'],
+  sleep: ['-', '‿', '-'],
+  love: ['♥', '‿', '♥'],
+  fear: ['°', 'o', '°'],
+};
+
+const rgb = (hex) => {
+  const n = parseInt(String(hex || '#6d5dfc').slice(1), 16);
+  return [(n >> 16) & 255, (n >> 8) & 255, n & 255];
+};
+const fg = (hex) => `\x1b[38;2;${rgb(hex).join(';')}m`;
+const RESET = '\x1b[0m';
+const BOLD = '\x1b[1m';
+const DIM = '\x1b[2m';
+
+function wrap(text, width) {
+  const out = [];
+  let cur = '';
+  for (const w of String(text).split(/\s+/)) {
+    if ((cur + ' ' + w).trim().length > width) {
+      if (cur) out.push(cur);
+      cur = w;
+    } else cur = (cur + ' ' + w).trim();
+  }
+  if (cur) out.push(cur);
+  return out;
+}
+
+function bar(v, width = 16) {
+  const n = Math.round((v / 100) * width);
+  const color = v < 25 ? '\x1b[31m' : v < 50 ? '\x1b[33m' : '\x1b[32m';
+  return `${color}${'█'.repeat(n)}${DIM}${'░'.repeat(width - n)}${RESET} ${String(v).padStart(3)}`;
+}
+
+export async function runTerminal({ identity, lang, port = PET_PORT, bell = false }) {
+  const out = process.stdout;
+  const color = identity.look.color;
+  let state = null;
+  let bubble = '';
+  let bubbleUntil = 0;
+  let thinking = false;
+  let blink = false;
+  let hop = 0;
+
+  const draw = () => {
+    if (!state) return;
+    const [l, m, r] = FACES[state.mood] || FACES.neutral;
+    const eyesL = blink && !state.asleep ? '-' : l;
+    const eyesR = blink && !state.asleep ? '-' : r;
+    const c = fg(color);
+    const lines = [];
+    const now = Date.now();
+    if (bubble && now < bubbleUntil) {
+      const w = wrap(bubble, 38);
+      const width = Math.max(...w.map((x) => x.length));
+      lines.push(`  ╭${'─'.repeat(width + 2)}╮`);
+      for (const x of w) lines.push(`  │ ${x.padEnd(width)} │`);
+      lines.push(`  ╰─┬${'─'.repeat(width)}╯`);
+      lines.push('    ╵');
+    } else lines.push('', '', '', thinking ? `  ${DIM}…${RESET}` : '');
+    const pad = ' '.repeat(hop ? 1 : 3);
+    lines.push(`${pad}${c}  ╭───────╮${RESET}`);
+    lines.push(`${pad}${c}  │ ${RESET}${BOLD}${eyesL}${RESET} ${m} ${BOLD}${eyesR}${RESET}${c} │${RESET}${state.asleep ? `${DIM} z z${RESET}` : ''}`);
+    lines.push(`${pad}${c}  ╰─┬───┬─╯${RESET}`);
+    lines.push(`${pad}${c}    ╹   ╹${RESET}`);
+    lines.push('');
+    lines.push(`  ${BOLD}${identity.name}${RESET} ${DIM}· ${identity.role}${RESET}`);
+    lines.push(`  ${t('pet.food', lang).padEnd(10)} ${bar(state.food)}`);
+    lines.push(`  ${t('pet.energy', lang).padEnd(10)} ${bar(state.energy)}`);
+    lines.push(`  ${t('pet.fun', lang).padEnd(10)} ${bar(state.fun)}`);
+    lines.push(`  ${DIM}${t('pet.level', lang, { level: state.level, xp: state.xp, next: state.next })}${RESET}`);
+    lines.push('');
+    lines.push(`  ${DIM}${t('pet.keys', lang)}${RESET}`);
+    out.write('\x1b[H\x1b[2J' + lines.join('\n') + '\n');
+  };
+
+  out.write('\x1b[?1049h\x1b[?25l');
+  const restore = () => out.write('\x1b[?25h\x1b[?1049l');
+  process.on('exit', restore);
+
+  if (process.stdin.isTTY) {
+    process.stdin.setRawMode(true);
+    process.stdin.resume();
+    process.stdin.on('data', async (d) => {
+      const k = d.toString();
+      if (k === 'q' || k === '\x03') process.exit(0);
+      if (k === 'f') postPet('/event', { type: 'feed' }, port);
+      if (k === 'p') postPet('/event', { type: 'play' }, port);
+      if (k === 's') postPet('/event', { type: state?.asleep ? 'wake' : 'sleep' }, port);
+    });
+  }
+  out.on('resize', draw);
+  setInterval(() => {
+    blink = Math.random() < 0.08;
+    if (hop) hop--;
+    draw();
+  }, 500);
+
+  // SSE over fetch (Node has no EventSource without flags).
+  for (;;) {
+    try {
+      const res = await fetch(`http://127.0.0.1:${port}/events?token=${encodeURIComponent(petToken())}`);
+      const reader = res.body.getReader();
+      const dec = new TextDecoder();
+      let buf = '';
+      for (;;) {
+        const { value, done } = await reader.read();
+        if (done) break;
+        buf += dec.decode(value, { stream: true });
+        let i;
+        while ((i = buf.indexOf('\n\n')) >= 0) {
+          const chunk = buf.slice(0, i);
+          buf = buf.slice(i + 2);
+          const data = chunk.split('\n').filter((x) => x.startsWith('data: ')).map((x) => x.slice(6)).join('');
+          if (!data) continue;
+          const msg = JSON.parse(data);
+          if (msg.state) state = msg.state;
+          thinking = !!msg.thinking;
+          if (msg.gesture) hop = 4;
+          if (msg.say) {
+            bubble = msg.say;
+            bubbleUntil = Date.now() + Math.max(5000, msg.say.length * 100);
+            if (bell) out.write('\x07'); // annoy level 3: a tiny bell
+          }
+          draw();
+        }
+      }
+    } catch {}
+    await new Promise((r) => setTimeout(r, 2000)); // daemon restarted or gone: retry
+  }
+}