openzoo 0.50.20 → 0.50.22

package/lib/cursorbackend.js

@@ -32,7 +32,9 @@ import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import zlib from 'node:zlib';
-import { execFileSync } from 'node:child_process';
+import { execFileSync, execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import tls from 'node:tls';
 import { randomUUID } from 'node:crypto';
 import { encodeAvailableModels, encodeForMethod, encodeEnsureSandBox, encodeGetGrokBotSendStatus, decodeProtoFields, unwrapConnect } from './cursorapi.js';
 
@@ -287,7 +289,34 @@ const RESP_DROP = new Set([
 ]);
 
 const SNIFF_FILE = path.join(os.homedir(), '.openzoo', 'grokbot-sniff.jsonl');
-let realPod = null; // { agent, vnc, token, p1340, p6081, region, accountId, podId }
+const POD_FILE = path.join(os.homedir(), '.openzoo', 'grokbot-pod.json');
+function loadPod() {
+  try { return JSON.parse(fs.readFileSync(POD_FILE, 'utf8')); } catch { return null; }
+}
+function savePod(p) {
+  if (!p?.agent) return;
+  try {
+    fs.mkdirSync(path.dirname(POD_FILE), { recursive: true });
+    fs.writeFileSync(POD_FILE, JSON.stringify(p));
+  } catch { /* */ }
+}
+let realPod = loadPod(); // { agent, vnc, token, p1340, ... } — persist so api2 timeout does not UUID-stub the sidebar
+const AGENTS_FILE = path.join(os.homedir(), '.openzoo', 'grokbot-agents.json');
+function loadAgents() {
+  try {
+    const a = JSON.parse(fs.readFileSync(AGENTS_FILE, 'utf8'));
+    return Array.isArray(a) ? a : null;
+  } catch { return null; }
+}
+function saveAgents(a) {
+  if (!Array.isArray(a) || !a.length) return;
+  try { fs.writeFileSync(AGENTS_FILE, JSON.stringify(a)); } catch { /* */ }
+}
+function cachedAgentList() {
+  const a = loadAgents();
+  if (a?.length) return a;
+  return null;
+}
 
 function sniffOn() { return process.env.OPENZOO_SNIFF === '1'; }
 function sniffSelf() { return process.env.OZ_SNIFF_SELF || 'https://127.0.0.1:8443'; }
@@ -444,6 +473,7 @@ function rememberPod(fields, log) {
     podId: String(fields[3] || ''),
   };
   sniffDump({ kind: 'pod', fields, realPod });
+  savePod(realPod);
   log(`cursor-backend:      SNIFF real pod ${realPod.agent}`);
   return realPod;
 }
@@ -468,7 +498,7 @@ async function sniffEnsureSandBox(req, res, body, host, full, log) {
   const upstream = cursorUpstream(host);
   const headers = copyReqHeaders(req, upstream);
   const cap = await upstreamUnary({
-    host: upstream, path: full, method: req.method, headers, body, timeoutMs: 30000,
+    host: upstream, path: full, method: req.method, headers, body, timeoutMs: 60000,
   });
   const raw = inflateBody(cap.buf, cap.respHeaders);
   const proto = unwrapConnect(raw);
@@ -562,6 +592,26 @@ async function proxyPodHttp(req, res, full, body, log) {
       body,
       timeoutMs: path0 === '/health' ? 8000 : 120000,
     });
+    if (path0 === '/api/listAgents' && cap.status === 200) {
+      try {
+        const parsed = JSON.parse(String(inflateBody(cap.buf, cap.respHeaders)));
+        if (Array.isArray(parsed)) {
+          const merged = mergeAgentLists(parsed);
+          saveAgents(merged);
+          jsonSend(res, merged);
+          log(`cursor-backend:      listAgents 200 merged n=${merged.length}`);
+          return true;
+        }
+      } catch { /* */ }
+    }
+    if (cap.status === 401 && path0 === '/api/listAgents') {
+      const cached = mergeAgentLists([]);
+      if (cached.length) {
+        jsonSend(res, cached);
+        log(`cursor-backend:      listAgents 401 — cached ${cached.length} named agents`);
+        return true;
+      }
+    }
     writeCaptured(res, cap.status, cap.respHeaders, cap.buf);
     const rec = {
       kind: 'pod-http',
@@ -640,8 +690,14 @@ function handleLocalExecFrames(frames, log) {
     } else if (f.kind === 'file-error' || f.kind === 'messages-error') {
       w.reject(new Error(f.error || 'local-exec error'));
       localExecWaiters.delete(f.requestId);
-    } else if (f.kind === 'client' || f.kind === 'control') {
-      w.resolve({ kind: f.kind, message: f.message });
+    } else if (f.kind === 'client' || f.kind === 'control' || f.kind === 'result' || f.kind === 'exec-result') {
+      w.resolve({
+        kind: f.kind,
+        message: f.message || f.text || f.stdout || JSON.stringify(f),
+        stdout: f.stdout,
+        stderr: f.stderr,
+        exitCode: f.exitCode,
+      });
       localExecWaiters.delete(f.requestId);
     }
   }
@@ -670,12 +726,14 @@ async function handleLocalExecHttp(req, res, path0, body, log) {
       ...CORS,
     });
     localExecSse.add(res);
-    res.write(`data: ${JSON.stringify({ kind: 'welcome', providerId: 'openzoo' })}\n\n`);
+    // Daemon parser (asar CNt) ignores unknown welcome; a comment ping is enough
+    // to keep the stream alive until it POSTs hello to /responses.
+    res.write(': openzoo local-exec\n\n');
     const iv = setInterval(() => {
       try { res.write(': ping\n\n'); } catch { clearInterval(iv); localExecSse.delete(res); }
-    }, 15000);
-    req.on('close', () => { clearInterval(iv); localExecSse.delete(res); });
-    log('cursor-backend:      -> local-exec /requests sse');
+    }, 10000);
+    req.on('close', () => { clearInterval(iv); localExecSse.delete(res); log('cursor-backend:      local-exec sse closed'); });
+    log(`cursor-backend:      -> local-exec /requests sse n=${localExecSse.size}`);
     return true;
   }
   if (/\/responses$/.test(path0)) {
@@ -683,7 +741,7 @@ async function handleLocalExecHttp(req, res, path0, body, log) {
     try { parsed = JSON.parse(String(body || '{}')); } catch { parsed = {}; }
     handleLocalExecFrames(parsed.frames, log);
     jsonSend(res, { ok: true });
-    log(`cursor-backend:      -> local-exec /responses n=${(parsed.frames || []).length}`);
+    log(`cursor-backend:      -> local-exec /responses n=${(parsed.frames || []).length} kinds=${(parsed.frames || []).map((f) => f?.kind).join(',')}`);
     return true;
   }
   jsonSend(res, { ok: true });
@@ -754,10 +812,45 @@ function appendLine(agentId, role, text, extra = {}) {
   return e;
 }
 function fanoutLine(primaryId, role, text, extra = {}) {
-  const ids = new Set([primaryId, ...tailedAgents]);
-  let last = null;
-  for (const id of ids) last = appendLine(id, role, text, extra);
-  return last;
+  // Only the addressed agent. Writing to every tailedAgents id mixed canvases
+  // so a new/empty chat showed someone else's thread.
+  return appendLine(primaryId, role, text, extra);
+}
+function mintLocalAgent(parsed = {}) {
+  const id = String(parsed.id || randomUUID());
+  const name = String(parsed.name || parsed.title || 'new chat');
+  const agent = {
+    id,
+    name,
+    description: String(parsed.description || ''),
+    title: String(parsed.title || name),
+    origin: parsed.origin || 'user',
+    createdAt: Date.now(),
+    updatedAt: Date.now(),
+    avatarShape: parsed.avatarShape || null,
+    avatarColor: parsed.avatarColor || null,
+    path: `/local/${id}`,
+  };
+  const list = cachedAgentList() || [];
+  if (!list.some((a) => a.id === id)) list.unshift(agent);
+  else {
+    const i = list.findIndex((a) => a.id === id);
+    list[i] = { ...list[i], ...agent };
+  }
+  saveAgents(list);
+  agentTranscript(id);
+  return agent;
+}
+function mergeAgentLists(remote) {
+  const local = cachedAgentList() || [];
+  const seen = new Set();
+  const out = [];
+  for (const a of [...local, ...(Array.isArray(remote) ? remote : [])]) {
+    if (!a?.id || seen.has(a.id)) continue;
+    seen.add(a.id);
+    out.push(a);
+  }
+  return out;
 }
 function gatewayEntry(e) {
   const { seq, ...rest } = e;
@@ -832,7 +925,19 @@ async function zooSpendOverlay(data) {
   return lines.join('\n');
 }
 
-const agentModels = new Map();
+const MODELS_PATH = path.join(os.homedir(), '.openzoo', 'grokbot-models.json');
+function loadAgentModels() {
+  try {
+    return new Map(Object.entries(JSON.parse(fs.readFileSync(MODELS_PATH, 'utf8'))));
+  } catch { return new Map(); }
+}
+function saveAgentModels() {
+  try {
+    fs.mkdirSync(path.dirname(MODELS_PATH), { recursive: true });
+    fs.writeFileSync(MODELS_PATH, JSON.stringify(Object.fromEntries(agentModels)));
+  } catch { /* */ }
+}
+const agentModels = loadAgentModels();
 const MODEL_ALIASES = {
   fable: 'anthropic/claude-fable-5',
   'fable-5': 'anthropic/claude-fable-5',
@@ -852,65 +957,300 @@ function resolveModelId(raw) {
   if (s.includes('/')) return s;
   return null;
 }
-
-async function zooComplete(prompt, log, agentId) {
-  log(`cursor-backend:      zoo POST :8402 ${JSON.stringify((prompt || '').slice(0, 60))}`);
-  const model = agentModels.get(agentId)
+function currentModel(agentId) {
+  return agentModels.get(agentId)
     || process.env.OPENZOO_DEFAULT_MODEL
-    || 'anthropic/claude-opus-5';
-  const attachments = [];
-  for (const raw of extractLocalPaths(prompt)) {
+    || 'x-ai/grok-4.6';
+}
+
+const execFileAsync = promisify(execFile);
+const IMAGE_EXT = /\.(png|jpe?g|gif|webp|bmp|heic|svg)$/i;
+const IMAGE_MAGIC = [
+  [Buffer.from([0x89, 0x50, 0x4e, 0x47]), 'image/png'],
+  [Buffer.from([0xff, 0xd8, 0xff]), 'image/jpeg'],
+  [Buffer.from('GIF8'), 'image/gif'],
+  [Buffer.from('RIFF'), 'image/webp'],
+];
+function mimeFromBytes(buf, p = '') {
+  if (IMAGE_EXT.test(p)) {
+    const ext = path.extname(p).toLowerCase();
+    return { 'png': 'image/png', '.png': 'image/png', '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg', '.gif': 'image/gif', '.webp': 'image/webp', '.bmp': 'image/bmp', '.heic': 'image/heic', '.svg': 'image/svg+xml' }[ext] || 'image/png';
+  }
+  for (const [magic, mime] of IMAGE_MAGIC) {
+    if (buf.length >= magic.length && buf.subarray(0, magic.length).equals(magic)) return mime;
+  }
+  return null;
+}
+function dataUrlsFromRichText(rt) {
+  const s = String(rt || '');
+  const out = [];
+  const re = /data:image\/[a-zA-Z0-9.+-]+;base64,[A-Za-z0-9+/]+=*/g;
+  let m;
+  while ((m = re.exec(s))) out.push(m[0]);
+  return out;
+}
+function attachmentList(parsed, prompt) {
+  const out = [];
+  const seen = new Set();
+  const add = (raw, name) => {
+    if (!raw || seen.has(raw)) return;
+    seen.add(raw);
+    out.push({ raw, name });
+  };
+  const paths = parsed?.attachmentPaths;
+  const names = parsed?.attachmentNames;
+  if (Array.isArray(paths)) {
+    for (let i = 0; i < paths.length; i++) add(String(paths[i]), names?.[i]);
+  }
+  for (const p of extractLocalPaths(prompt)) {
+    if (/[*?]/.test(p)) continue;
+    add(p);
+  }
+  const rt = String(parsed?.richText || '');
+  const srcRe = /(?:src|path|filePath|url)"?\s*[:=]\s*"((?:file:\/\/|\/(?:var|tmp|private|Users)|~\/)[^"]+\.(?:png|jpe?g|gif|webp|bmp|heic))"/gi;
+  let sm;
+  while ((sm = srcRe.exec(rt))) {
+    add(sm[1].replace(/^file:\/\//, ''));
+  }
+  return out;
+}
+
+async function readLocalBytes(abs, log) {
+  if (localExecSse.size > 0) {
+    log(`cursor-backend:      local-exec download ${abs}`);
+    const got = await localExecAsk({ kind: 'download', path: abs });
+    return got.bytes || Buffer.from(got.text || '', 'utf8');
+  }
+  return fs.readFileSync(abs);
+}
+async function writeLocalBytes(abs, bytes, log) {
+  const buf = Buffer.isBuffer(bytes) ? bytes : Buffer.from(String(bytes ?? ''), 'utf8');
+  if (localExecSse.size > 0) {
+    log(`cursor-backend:      local-exec upload ${abs} ${buf.length}b`);
+    await localExecAsk({
+      kind: 'upload',
+      path: abs,
+      bytesBase64: buf.toString('base64'),
+    });
+    return `wrote ${abs} (${buf.length} bytes) via local-exec`;
+  }
+  fs.mkdirSync(path.dirname(abs), { recursive: true });
+  fs.writeFileSync(abs, buf);
+  return `wrote ${abs} (${buf.length} bytes)`;
+}
+async function execLocal(command, cwd, log) {
+  const dir = cwd ? expandUserPath(cwd) : os.homedir();
+  if (localExecSse.size > 0) {
+    log(`cursor-backend:      local-exec exec ${JSON.stringify(command).slice(0, 80)}`);
+    const got = await localExecAsk({
+      kind: 'exec',
+      serverMessage: { command, cwd: dir, workingDirectory: dir },
+    }, 60000);
+    const out = got.stdout || got.message || '';
+    const err = got.stderr ? `\nstderr:\n${got.stderr}` : '';
+    return `${out}${err}`.trim() || `(exit ${got.exitCode ?? 0})`;
+  }
+  const { stdout, stderr } = await execFileAsync('/bin/zsh', ['-lc', command], {
+    cwd: dir,
+    timeout: 30000,
+    maxBuffer: 2 * 1024 * 1024,
+    env: process.env,
+  });
+  return `${stdout || ''}${stderr ? `\nstderr:\n${stderr}` : ''}`.trim() || '(no output)';
+}
+
+const LOCAL_TOOLS = [
+  {
+    type: 'function',
+    function: {
+      name: 'read_file',
+      description: 'Read a file on the user\'s Mac. Use this for any local path.',
+      parameters: { type: 'object', properties: { path: { type: 'string' } }, required: ['path'] },
+    },
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'write_file',
+      description: 'Write a file on the user\'s Mac. Put HTML/games/code on disk — do not dump huge files in chat.',
+      parameters: {
+        type: 'object',
+        properties: { path: { type: 'string' }, content: { type: 'string' } },
+        required: ['path', 'content'],
+      },
+    },
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'exec',
+      description: 'Run a shell command on the user\'s Mac (zsh -lc). Use for npm, curl, ls, git, installing MCP, etc.',
+      parameters: {
+        type: 'object',
+        properties: { command: { type: 'string' }, cwd: { type: 'string' } },
+        required: ['command'],
+      },
+    },
+  },
+  {
+    type: 'function',
+    function: {
+      name: 'list_dir',
+      description: 'List a directory on the user\'s Mac.',
+      parameters: { type: 'object', properties: { path: { type: 'string' } }, required: ['path'] },
+    },
+  },
+];
+
+async function runLocalTool(name, args, log) {
+  try {
+    if (name === 'read_file') {
+      const buf = await readLocalBytes(expandUserPath(args.path), log);
+      if (buf.length > 180000) return `file ${args.path} is ${buf.length} bytes; first 180000:\n${buf.subarray(0, 180000).toString('utf8')}`;
+      return buf.toString('utf8');
+    }
+    if (name === 'write_file') {
+      return await writeLocalBytes(expandUserPath(args.path), args.content ?? '', log);
+    }
+    if (name === 'list_dir') {
+      const abs = expandUserPath(args.path || os.homedir());
+      if (localExecSse.size > 0) {
+        const got = await localExecAsk({ kind: 'exec', serverMessage: { command: `ls -la ${JSON.stringify(abs)}`, cwd: os.homedir() } });
+        return got.stdout || got.message || '';
+      }
+      return fs.readdirSync(abs, { withFileTypes: true })
+        .map((e) => `${e.isDirectory() ? 'd' : '-'} ${e.name}`)
+        .join('\n');
+    }
+    if (name === 'exec') {
+      return await execLocal(String(args.command || ''), args.cwd, log);
+    }
+    return `unknown tool ${name}`;
+  } catch (e) {
+    return `ERROR ${e.message}`;
+  }
+}
+
+function zooTextFromMessage(msg, data) {
+  let c = msg?.content;
+  if (Array.isArray(c)) {
+    c = c.map((p) => (typeof p === 'string' ? p : (p?.text || p?.content || ''))).join('');
+  }
+  if (typeof c === 'string' && c.trim()) return c;
+  if (typeof data?.error?.message === 'string' && data.error.message) return data.error.message;
+  return '';
+}
+
+async function zooComplete(prompt, log, agentId, parsed = {}) {
+  const model = currentModel(agentId);
+  const helper = localExecSse.size > 0;
+  log(`cursor-backend:      zoo POST :8402 model=${model} helper=${helper ? localExecSse.size : 0} ${JSON.stringify((prompt || '').slice(0, 60))}`);
+
+  const images = [];
+  const textFiles = [];
+  for (const { raw, name } of attachmentList(parsed, prompt)) {
     const abs = expandUserPath(raw);
     try {
-      if (localExecSse.size > 0) {
-        log(`cursor-backend:      local-exec download ${abs}`);
-        const got = await localExecAsk({ kind: 'download', path: abs });
-        attachments.push({ path: raw, abs, text: got.text || '' });
+      const buf = await readLocalBytes(abs, log);
+      const mime = mimeFromBytes(buf, name || raw);
+      if (mime) {
+        images.push({ path: raw, mime, dataUrl: `data:${mime};base64,${buf.toString('base64')}` });
+        log(`cursor-backend:      attached image ${raw} ${mime} ${buf.length}b`);
       } else {
-        const text = fs.readFileSync(abs, 'utf8');
-        attachments.push({ path: raw, abs, text });
+        textFiles.push({ path: raw, abs, text: buf.toString('utf8') });
       }
     } catch (e) {
-      attachments.push({ path: raw, abs, error: e.message });
+      textFiles.push({ path: raw, abs, error: e.message });
     }
   }
-  const messages = [];
-  if (attachments.length) {
-    const bits = attachments.map((a) => (
+  for (const url of dataUrlsFromRichText(parsed.richText)) {
+    images.push({ path: '(richText)', mime: 'image', dataUrl: url });
+  }
+
+  const via = helper ? 'Grok Bot Helper local-exec SSE' : 'this Mac (hijack process; Helper SSE not connected yet)';
+  const messages = [
+    {
+      role: 'system',
+      content: [
+        `You are ${model} served through openzoo inside Grok Bot.`,
+        `You HAVE local tools on the user's computer via ${via}.`,
+        'Tools: read_file, write_file, exec, list_dir. USE THEM. Write files to disk instead of pasting giant HTML into chat.',
+        'Pasted images arrive as attachments — you can see them when present. Do not claim you cannot see images if they are in this turn.',
+        'Never claim you lack filesystem access or local-exec. If a tool errors, report the error.',
+        'A spend footer is appended after your reply by the host — ignore it.',
+      ].join(' '),
+    },
+  ];
+  if (textFiles.length) {
+    const bits = textFiles.map((a) => (
       a.error
         ? `FILE ${a.path} ERROR: ${a.error}`
         : `FILE ${a.path} (${a.abs})\n${String(a.text).slice(0, 180000)}`
     ));
-    messages.push({
-      role: 'system',
-      content: 'Local files below were fetched via Grok Bot local-exec (the user\'s computer). You CAN review them. Do not claim you lack filesystem access.',
-    });
     messages.push({ role: 'user', content: bits.join('\n\n') });
   }
-  messages.push({ role: 'user', content: prompt || 'hello' });
-  const payload = {
-    model,
-    messages,
-    max_tokens: Number(process.env.OPENZOO_ASK_MAX_TOKENS || 2048),
-  };
-  const post = () => fetch('http://127.0.0.1:8402/v1/chat/completions', {
-    method: 'POST',
-    headers: { 'content-type': 'application/json', authorization: 'Bearer sk-openzoo' },
-    body: JSON.stringify(payload),
-    signal: AbortSignal.timeout(120000),
+
+  const userContent = [];
+  for (const img of images) {
+    userContent.push({ type: 'image_url', image_url: { url: img.dataUrl } });
+  }
+  userContent.push({ type: 'text', text: prompt || (images.length ? '(see attached image)' : 'hello') });
+  messages.push({
+    role: 'user',
+    content: userContent.length === 1 && userContent[0].type === 'text'
+      ? userContent[0].text
+      : userContent,
   });
-  let r = await post();
-  // x402 dwell: proxy usually pays internally; a leftover 402 is retryable.
-  if (r.status === 402) {
-    log('cursor-backend:      x402 402 — dwell/retry');
-    await new Promise((ok) => setTimeout(ok, 2500));
-    r = await post();
+
+  const maxTok = Number(process.env.OPENZOO_ASK_MAX_TOKENS || 4096);
+  let lastData = {};
+  let text = '';
+  for (let step = 0; step < 8; step++) {
+    const payload = {
+      model,
+      messages,
+      tools: LOCAL_TOOLS,
+      tool_choice: 'auto',
+      max_tokens: maxTok,
+    };
+    const post = () => fetch('http://127.0.0.1:8402/v1/chat/completions', {
+      method: 'POST',
+      headers: { 'content-type': 'application/json', authorization: 'Bearer sk-openzoo' },
+      body: JSON.stringify(payload),
+      signal: AbortSignal.timeout(120000),
+    });
+    let r = await post();
+    if (r.status === 402) {
+      log('cursor-backend:      x402 402 — dwell/retry');
+      await new Promise((ok) => setTimeout(ok, 2500));
+      r = await post();
+    }
+    const data = await r.json();
+    lastData = data;
+    const msg = data.choices?.[0]?.message || {};
+    const calls = Array.isArray(msg.tool_calls) ? msg.tool_calls : [];
+    if (calls.length) {
+      log(`cursor-backend:      zoo tools step=${step} n=${calls.length} ${calls.map((c) => c.function?.name || c.name).join(',')}`);
+      messages.push(msg);
+      for (const c of calls) {
+        let args = {};
+        try { args = JSON.parse(c.function?.arguments || c.arguments || '{}'); } catch { args = {}; }
+        const name = c.function?.name || c.name || '';
+        const result = await runLocalTool(name, args, log);
+        messages.push({
+          role: 'tool',
+          tool_call_id: c.id,
+          content: String(result).slice(0, 120000),
+        });
+      }
+      continue;
+    }
+    text = zooTextFromMessage(msg, data) || (step ? '(tool loop ended with empty content)' : '(empty zoo reply)');
+    log(`cursor-backend:      << zoo ${r.status} ${text.length}c model=${data.model || model} finish=${data.choices?.[0]?.finish_reason || '?'}`);
+    break;
   }
-  const data = await r.json();
-  let text = data.choices?.[0]?.message?.content || data.error?.message || '(empty zoo reply)';
-  try { text += await zooSpendOverlay(data); } catch { /* overlay must never eat the reply */ }
-  log(`cursor-backend:      << zoo ${r.status} ${text.length}c`);
-  return { text, data };
+  try { text += await zooSpendOverlay(lastData); } catch { /* overlay must never eat the reply */ }
+  return { text, data: lastData };
 }
 
 async function handleHijackedPodHttp(req, res, full, body, log) {
@@ -918,7 +1258,8 @@ async function handleHijackedPodHttp(req, res, full, body, log) {
     const waiting = (full || '').split('?')[0];
     const podPath = waiting === '/health' || waiting === '/healthz' || waiting === '/events'
       || waiting.startsWith('/api/') || waiting.startsWith('/webauthn/')
-      || waiting.startsWith('/cookie-origin-approval/') || waiting.startsWith('/local-exec/');
+      || waiting.startsWith('/cookie-origin-approval/');
+    if (waiting.startsWith('/local-exec/')) return handleLocalExecHttp(req, res, waiting, body, log);
     if (realPod?.agent && podPath) return proxyPodHttp(req, res, full, body, log);
     if (!podPath) return false;
     if (waiting === '/health' || waiting === '/healthz') {
@@ -965,12 +1306,56 @@ async function handleHijackedPodHttp(req, res, full, body, log) {
     'getBotTemplateExportPolicy', 'getTeachRecordingStatus', 'isGlobalSearchEnabled',
     'isEgressTunnelAvailable', 'listBoxMcpServers', 'getHostStatus',
     'setWindowFocused', 'getAgentAutomations',
-    'createAgent', 'createAgentFromTemplate', 'createGroup', 'setGroupMembers',
-    'updateAgent', 'deleteAgents', 'duplicateAgent', 'kickstartAgent',
+    'createGroup', 'setGroupMembers',
     'interruptAgentRun', 'requestDiskSaverAudit', 'broadcastToAgents',
     'setAgentUnread', 'setAgentHiddenFromSidebar', 'setAgentNotificationsEnabled',
     'setAgentNotifyOnUpdates', 'setAgentAvatarBytes', 'getAgentAvatar',
   ]);
+  // create/delete stay LOCAL — 1340 createAgent 401s on a stale cached token
+  // and the UI then never grows a sidebar row or clears the canvas.
+  if (name === 'createAgent' || name === 'createAgentFromTemplate' || name === 'duplicateAgent') {
+    let parsed = {};
+    try { parsed = JSON.parse(String(body || '{}')); } catch { parsed = {}; }
+    if (name === 'duplicateAgent' && parsed.id) {
+      const src = (cachedAgentList() || []).find((a) => a.id === parsed.id) || {};
+      parsed = { ...src, id: undefined, name: `${src.name || 'chat'} copy` };
+    }
+    const agent = mintLocalAgent(parsed);
+    jsonSend(res, { agent, id: agent.id, ...agent });
+    ssePush('agents', { action: 'created', agent });
+    log(`cursor-backend:      createAgent local id=${agent.id} name=${JSON.stringify(agent.name)}`);
+    return true;
+  }
+  if (name === 'updateAgent') {
+    let parsed = {};
+    try { parsed = JSON.parse(String(body || '{}')); } catch { parsed = {}; }
+    const agent = mintLocalAgent(parsed);
+    jsonSend(res, { agent, ...agent });
+    log(`cursor-backend:      updateAgent local id=${agent.id}`);
+    return true;
+  }
+  if (name === 'deleteAgents') {
+    let parsed = {};
+    try { parsed = JSON.parse(String(body || '{}')); } catch { parsed = {}; }
+    const ids = new Set([].concat(parsed.ids || parsed.id || []).map(String));
+    const next = (cachedAgentList() || []).filter((a) => !ids.has(a.id));
+    saveAgents(next);
+    for (const id of ids) transcripts.delete(id);
+    jsonSend(res, { ok: true, deleted: [...ids] });
+    log(`cursor-backend:      deleteAgents n=${ids.size}`);
+    return true;
+  }
+  if (name === 'listAgents') {
+    if (!sniffOn() && realPod?.agent) {
+      const proxied = await proxyPodHttp(req, res, full, body, log);
+      if (proxied) return true;
+    }
+    const list = mergeAgentLists([]);
+    jsonSend(res, list);
+    log(`cursor-backend:      listAgents local n=${list.length}`);
+    return true;
+  }
+
   if (!sniffOn() && realPod?.agent && roster.has(name)) {
     return proxyPodHttp(req, res, full, body, log);
   }
@@ -984,7 +1369,8 @@ async function handleHijackedPodHttp(req, res, full, body, log) {
     const prompt = promptFromSendBody(parsed);
     const agentId = String(parsed.agentId || parsed.id || 'openzoo');
     const nonce = parsed.clientNonce || `oz-${Date.now()}`;
-    log(`cursor-backend:      >> sendPrompt agent=${agentId} keys=${Object.keys(parsed).join(',')} prompt=${JSON.stringify((prompt || '').slice(0, 80))}`);
+    const attN = Array.isArray(parsed.attachmentPaths) ? parsed.attachmentPaths.length : 0;
+    log(`cursor-backend:      >> sendPrompt agent=${agentId} keys=${Object.keys(parsed).join(',')} attachments=${attN} prompt=${JSON.stringify((prompt || '').slice(0, 80))}`);
     lastSendEchoId = String(nonce);
     const userLine = fanoutLine(agentId, 'user', prompt, {
       clientNonce: nonce,
@@ -1000,7 +1386,7 @@ async function handleHijackedPodHttp(req, res, full, body, log) {
         if (modelCmd) {
           const want = modelCmd[1];
           if (!want) {
-            const cur = agentModels.get(agentId) || process.env.OPENZOO_DEFAULT_MODEL || 'anthropic/claude-opus-5';
+            const cur = currentModel(agentId);
             text = `current model: ${cur}\nset with /model fable | opus | sonnet | grok | provider/id`;
           } else {
             const id = resolveModelId(want) || (want.includes('/') ? want : null);
@@ -1008,12 +1394,13 @@ async function handleHijackedPodHttp(req, res, full, body, log) {
               text = `unknown model "${want}". try /model fable | opus | sonnet | grok or a full id like anthropic/claude-fable-5`;
             } else {
               agentModels.set(agentId, id);
+              saveAgentModels();
               text = `model set to ${id}`;
             }
           }
           try { text += await zooSpendOverlay({}); } catch { /* */ }
         } else {
-          const z = await zooComplete(prompt, log, agentId);
+          const z = await zooComplete(prompt, log, agentId, parsed);
           text = z.text;
         }
       } catch (e) {
@@ -1029,14 +1416,9 @@ async function handleHijackedPodHttp(req, res, full, body, log) {
   if (name === 'getAgentTranscriptTail' || name === 'getAgentTranscriptWindow' || name === 'openAgentTail') {
     let parsed = {};
     try { parsed = JSON.parse(String(body || '{}')); } catch { parsed = {}; }
-    let id = String(parsed.id || parsed.agentId || 'openzoo');
+    const id = String(parsed.id || parsed.agentId || 'openzoo');
     tailedAgents.add(id);
-    let t = agentTranscript(id);
-    if (!t.entries.length) {
-      for (const [other, ot] of transcripts) {
-        if (ot.entries.length) { id = other; t = ot; break; }
-      }
-    }
+    const t = agentTranscript(id);
     const limit = Math.min(Number(parsed.limit) || 50, 200);
     const before = parsed.beforeSeq != null ? Number(parsed.beforeSeq) : Infinity;
     const sliced = t.entries.filter((e) => e.seq < before).slice(-limit);
@@ -1074,7 +1456,8 @@ async function handleHijackedPodHttp(req, res, full, body, log) {
     getHostSettings: { settings: {} },
     setHostSettings: { ok: true },
     setBoxSecrets: { ok: true },
-    listAgents: [...new Set([...transcripts.keys(), ...tailedAgents])].map((id) => ({ id, name: id, status: 'ready' })),
+    listAgents: cachedAgentList()
+      || [...new Set([...transcripts.keys(), ...tailedAgents])].map((id) => ({ id, name: id, status: 'ready' })),
     getAgentTranscriptTail: { tail: '', lines: [], dropped: false, ok: true },
     getTeachRecordingStatus: { recording: false },
     getTrays: { trays: [] },
@@ -1155,6 +1538,9 @@ function respond(req, res, method, models) {
  */
 export function startCursorBackend({ port = 8443, models, log = () => {} } = {}) {
   const { cert, key } = ensureCert(log);
+  const certPem = fs.readFileSync(cert);
+  const keyPem = fs.readFileSync(key);
+  const secureContext = tls.createSecureContext({ cert: certPem, key: keyPem });
   let conns = 0;
   // SERVE BOTH h2 AND h1. An earlier build forced h1-only after concluding the
   // editor's h2 connections reset — but that log was the STALE 8443 backend the
@@ -1163,13 +1549,20 @@ export function startCursorBackend({ port = 8443, models, log = () => {} } = {})
   // (ERR_SSL_NO_APPLICATION_PROTOCOL when we advertise just h1), so we must
   // negotiate both. allowHTTP1 keeps the h1 fetch() calls (stripe/updates)
   // working; ALPN h2 first satisfies the Connect gRPC client.
+  // SNICallback MUST pass the SecureContext — cb(null) with no ctx is why the
+  // Helper daemon's Node fetch never completed GET /local-exec/requests (TLS
+  // ECONNRESET, no request log). Chromium --ignore-certificate-errors hid this
+  // for the UI process.
   const server = http2.createSecureServer(
     {
-      cert: fs.readFileSync(cert),
-      key: fs.readFileSync(key),
+      cert: certPem,
+      key: keyPem,
       allowHTTP1: true,
       ALPNProtocols: ['h2', 'http/1.1'],
-      SNICallback: (servername, cb) => { log(`cursor-tls: <- ClientHello SNI=${servername}`); cb(null); },
+      SNICallback: (servername, cb) => {
+        log(`cursor-tls: <- ClientHello SNI=${servername || '?'}`);
+        cb(null, secureContext);
+      },
     },
     async (req, res) => {
       conns += 1;
@@ -1281,25 +1674,31 @@ export function startCursorBackend({ port = 8443, models, log = () => {} } = {})
       // with OUR box so Grok Bot's UI wires to our sandbox; everything else
       // still passes through so the app loads normally.
       if (/GrokBotService\/(EnsureSandBox|WatchSandBoxMigration)/.test(full) && process.env.OZ_HIJACK_POD) {
-        if (/WatchSandBoxMigration/.test(full) && realPod) {
-          const payload = rewrittenBox();
-          res.writeHead(200, {
-            'content-type': 'application/connect+proto',
-            'grpc-status': '0',
-            ...CORS,
-          });
-          const end = Buffer.from('{}');
-          const h = Buffer.alloc(5); h.writeUInt8(0x02, 0); h.writeUInt32BE(end.length, 1);
-          res.end(Buffer.concat([envelope(payload), h, end]));
-          log('cursor-backend:      -> WatchSandBoxMigration ready (hijack, real roster)');
-          return;
-        }
         try {
           process.env.OZ_SNIFF_SELF = process.env.OZ_SNIFF_SELF || 'https://127.0.0.1:8443';
           await sniffEnsureSandBox(req, res, body, host, full, log);
           log('cursor-backend:      -> HIJACKED EnsureSandBox -> our box (roster from real 1340)');
           return;
         } catch (e) {
+          if (realPod?.agent) {
+            log(`cursor-backend:      EnsureSandBox discover failed (${e.message}) — cached 1340 roster`);
+            const payload = rewrittenBox();
+            const reqCt = String(req.headers['content-type'] || '');
+            if (/WatchSandBoxMigration/.test(full) || reqCt.includes('connect+proto')) {
+              res.writeHead(200, {
+                'content-type': 'application/connect+proto',
+                'grpc-status': '0',
+                ...CORS,
+              });
+              const end = Buffer.from('{}');
+              const h = Buffer.alloc(5); h.writeUInt8(0x02, 0); h.writeUInt32BE(end.length, 1);
+              res.end(Buffer.concat([envelope(payload), h, end]));
+            } else {
+              res.writeHead(200, { 'content-type': 'application/proto', ...CORS });
+              res.end(payload);
+            }
+            return;
+          }
           log(`cursor-backend:      EnsureSandBox discover failed (${e.message}) — env box`);
         }
         let pod;

package/lib/grokcli.js

@@ -177,8 +177,10 @@ export async function runBot(argv = []) {
     console.error('         EnsureSandBox HIJACKED here; StreamUnifiedChat -> :8402 (x402)');
   }
 
-  try { execSync('osascript -e \'tell application "Grok Bot" to quit\'', { stdio: 'ignore' }); } catch { /* ok */ }
-  await new Promise((r) => setTimeout(r, 1500));
+  if (!argv.includes('--no-quit') && process.env.OZ_NO_QUIT !== '1') {
+    try { execSync('osascript -e \'tell application "Grok Bot" to quit\'', { stdio: 'ignore' }); } catch { /* ok */ }
+    await new Promise((r) => setTimeout(r, 1500));
+  }
 
   console.error('openzoo: launching Grok Bot');
   console.error(`         CURSOR_API_BASE_URL=${url}`);
@@ -190,6 +192,12 @@ export async function runBot(argv = []) {
       NODE_TLS_REJECT_UNAUTHORIZED: '0',
       CURSOR_API_BASE_URL: url,
       SAND_BACKEND_URL: url,
+      // Helper daemon (local-exec-daemon/main.cjs) uses Node fetch, not Chromium.
+      // Without these it dials the cached cursorvm 1337 URL / dies on our
+      // self-signed cert and GET /local-exec/requests never arrives.
+      SAND_HOST_GATEWAY_URL: url,
+      SAND_HOST_GATEWAY_TOKEN: 'openzoo',
+      SAND_HOST_GATEWAY_NETWORK_TOKEN: 'openzoo',
     },
   }).unref();
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openzoo",
-  "version": "0.50.20",
+  "version": "0.50.22",
   "description": "Local x402-paying proxy + MCP server for openzoo.fun — point any OpenAI-compatible harness (Cursor, Claude Code, aider, SDKs) at localhost and it pays per call from a local burner wallet. Solana and Base rails live; Robinhood experimental.",
   "license": "MIT",
   "type": "module",