openzoo 0.50.20 → 0.50.21

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';
 
@@ -640,8 +642,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 +678,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 +693,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 });
@@ -832,7 +842,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 +874,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 +1175,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') {
@@ -984,7 +1242,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 +1259,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 +1267,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) {
@@ -1155,6 +1415,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 +1426,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;

package/lib/grokcli.js

@@ -190,6 +190,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.21",
   "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",