openzoo 0.41.1 → 0.43.0

package/lib/cursorbackend.js

@@ -175,11 +175,14 @@ function encodeChatResponse(text) {
 }
 
 /**
- * ROUTE AUTO THROUGH THE ZOO. Cursor's chat inference is ChatService/
- * StreamUnifiedChat to the agent host (now impersonated). Parse the prompt, pay
- * the zoo via the local proxy, stream the answer back as StreamUnifiedChatResponse
- * frames. Legitimate: Auto is free-allowed; we redirect the operator's OWN
- * inference to their OWN paid proxy.
+ * THE TRIGGER. Cursor's chat inference is ChatService/StreamUnifiedChat to the
+ * agent host (now impersonated). Whatever the user typed into Grok Bot's UI is
+ * in this request — pull it out and hand it to OUR box (OZ_BOX_AGENT, set by
+ * grokbot.js to the box's :1337 podagent). The box's own openzoo brain drives
+ * the local-exec loop against the daemon running on this Mac (approval-gated),
+ * and its DONE: answer is what streams back into the UI. If no box is wired
+ * (OZ_BOX_AGENT unset — e.g. running the backend standalone), fall back to a
+ * plain one-shot zoo call so the app still gets a reply.
  */
 async function handleStreamChat(req, res, body, log) {
   const ct = String(req.headers['content-type'] || '');
@@ -187,20 +190,34 @@ async function handleStreamChat(req, res, body, log) {
   const prompt = extractPromptText(body) || 'hello';
   log(`cursor-backend:      >> StreamUnifiedChat prompt: ${JSON.stringify(prompt.slice(0, 80))}`);
   let text = '';
+  const boxAgent = process.env.OZ_BOX_AGENT;
   try {
-    const zoo = await fetch('http://127.0.0.1:8402/v1/chat/completions', {
-      method: 'POST',
-      headers: { 'content-type': 'application/json', authorization: 'Bearer sk-openzoo' },
-      body: JSON.stringify({
-        model: process.env.OPENZOO_DEFAULT_MODEL || 'anthropic/claude-opus-5',
-        messages: [{ role: 'user', content: prompt }],
-        max_tokens: Number(process.env.OPENZOO_ASK_MAX_TOKENS || 2048),
-      }),
-    });
-    const data = await zoo.json();
-    text = data.choices?.[0]?.message?.content || '(no content)';
-    log(`cursor-backend:      << zoo replied ${text.length} chars (paid x402)`);
-  } catch (e) { text = `openzoo error: ${e.message}`; log(`cursor-backend:      zoo call failed: ${e.message}`); }
+    if (boxAgent) {
+      const drive = await fetch(`${boxAgent}/drive`, {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({ task: prompt }),
+        // worst case: MAX_STEPS(10) x 60s exec waits + brain latency headroom
+        signal: AbortSignal.timeout(11 * 60_000),
+      });
+      const data = await drive.json();
+      text = data.text || '(box returned nothing)';
+      log(`cursor-backend:      << box drove task -> ${text.length} chars`);
+    } else {
+      const zoo = await fetch('http://127.0.0.1:8402/v1/chat/completions', {
+        method: 'POST',
+        headers: { 'content-type': 'application/json', authorization: 'Bearer sk-openzoo' },
+        body: JSON.stringify({
+          model: process.env.OPENZOO_DEFAULT_MODEL || 'anthropic/claude-opus-5',
+          messages: [{ role: 'user', content: prompt }],
+          max_tokens: Number(process.env.OPENZOO_ASK_MAX_TOKENS || 2048),
+        }),
+      });
+      const data = await zoo.json();
+      text = data.choices?.[0]?.message?.content || '(no content)';
+      log(`cursor-backend:      << zoo replied ${text.length} chars (paid x402, no box wired)`);
+    }
+  } catch (e) { text = `openzoo error: ${e.message}`; log(`cursor-backend:      drive call failed: ${e.message}`); }
 
   res.writeHead(200, {
     'content-type': isGrpcWeb ? 'application/grpc-web+proto' : 'application/connect+proto',

package/lib/grokbot.js

@@ -20,10 +20,10 @@ import { existsSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 
-import { config } from './config.js';
+import { config, USDC_MINT, TOKEN_MINT } from './config.js';
 import { PayClient } from './pay.js';
 import {
-  podEndpoints, readyBox, runpodConfigured, spawnBox, listBoxes,
+  podEndpoints, readyBox, runpodConfigured, spawnBox, listBoxes, execInBox,
 } from './boxes.js';
 
 const APP = '/Applications/Grok Bot.app';
@@ -46,19 +46,15 @@ export async function runGrokBot(argv = []) {
   }
 
   const days = Number((argv.find((a) => /^--days=/.test(a)) || '').split('=')[1]) || 1;
-  const shareWallet = argv.includes('--share-wallet');
-  const client = new PayClient();
 
   // 1) a box, ready, BEFORE we touch the app — so the first EnsureSandBox we
-  //    hijack already has a live pod to point at.
+  //    hijack already has a live pod to point at. The box mints its OWN wallet
+  //    (never the operator's secret key — that never leaves this Mac). There is
+  //    NO --task and NO --share-wallet: the task is whatever the user types
+  //    into the Grok Bot UI, captured from the MITM'd chat request and driven
+  //    through to the box over POST /drive.
   console.error('openzoo grokbot: spawning your box (CPU, x402-funded)…');
-  const taskArg = (argv.find((a) => a.startsWith('--task=')) || '').slice('--task='.length)
-    || (argv.includes('--task') ? argv[argv.indexOf('--task') + 1] : '');
-  const spawned = await spawnBox({
-    name: 'grokbot', days,
-    ...(shareWallet ? { walletJson: JSON.stringify([...client.keypair.secretKey]) } : {}),
-    ...(taskArg ? { task: taskArg } : {}),
-  });
+  const spawned = await spawnBox({ name: 'grokbot', days });
   if (!spawned.ok) { console.error(`  spawn failed: ${spawned.error}`); process.exit(1); }
   const box = spawned.box;
   console.error(`  ${box.name}  ${box.id}  expires ${spawned.expiresAt.slice(0, 16)}`);
@@ -66,6 +62,18 @@ export async function runGrokBot(argv = []) {
   if (!ready.ok) console.error(`  ${ready.error} — continuing; the capture agent may still bind`);
   else console.error(`  box ready in ${ready.seconds}s`);
 
+  // the box minted its OWN wallet on boot — print its funding address so it
+  // can be topped up directly. Its brain pays per call from THIS wallet, not
+  // the operator's; a fresh box starts at $0 until funded.
+  if (box.ssh) {
+    const addr = await execInBox(box, 'npx --yes openzoo address 2>/dev/null');
+    if (addr.ok && addr.stdout.trim()) {
+      console.error('  box wallet (top up to give it inference budget):');
+      console.error(addr.stdout.trim().split('\n').map((l) => `    ${l}`).join('\n'));
+    }
+    console.error(`  mints: USDC ${USDC_MINT} · TOKEN ${TOKEN_MINT} (Solana)`);
+  }
+
   const ep = podEndpoints(box.id);
   process.env.OZ_HIJACK_POD = JSON.stringify({
     region: 'us1',
@@ -74,6 +82,8 @@ export async function runGrokBot(argv = []) {
     token: `nto-${Math.random().toString(36).slice(2, 12)}`,
     agent: ep.agent, vnc: ep.vnc, p1340: ep.p1340, p6081: ep.p6081,
   });
+  // the backend (handleStreamChat) forwards each UI prompt here to be driven
+  process.env.OZ_BOX_AGENT = ep.agent;
   // other methods must still reach the REAL backend, or the app can't load
   process.env.OPENZOO_PASSTHRU = '1';
   process.env.OPENZOO_FORCE_BLOCK = '1';

package/lib/podagent.mjs

@@ -30,6 +30,109 @@ const PROXY = process.env.OZ_PROXY || 'http://127.0.0.1:8402/v1';
 const MODEL = process.env.OZ_BRAIN_MODEL || 'x-ai/grok-4.6';
 const MAX_STEPS = Number(process.env.OZ_MAX_STEPS || 10);
 
+// Matches the Grok Bot chat surface itself (dark canvas, right-aligned grey
+// user pills, pink-avatar left-aligned replies, pill input bar with + / mic) —
+// this renders INSIDE Grok Bot's own sandbox panel (its sidebar/titlebar are
+// the app's own chrome, not ours), so only the message canvas needs to match.
+const VNC_CHAT_HTML = `<!doctype html>
+<html><head><meta charset="utf-8"><title>openzoo box</title>
+<meta name="viewport" content="width=device-width,initial-scale=1">
+<style>
+  :root { color-scheme: dark; }
+  * { box-sizing: border-box; }
+  html, body { margin: 0; height: 100%; background: #000; }
+  body { color: #ececec; font: 15px/1.5 -apple-system, BlinkMacSystemFont, "Segoe UI", Helvetica, Arial, sans-serif;
+         display: flex; flex-direction: column; }
+  #log { flex: 1; overflow-y: auto; padding: 28px 24px 12px; display: flex; flex-direction: column; gap: 18px; }
+  .row { display: flex; align-items: flex-start; gap: 10px; max-width: 78%; }
+  .row.user { align-self: flex-end; flex-direction: row-reverse; }
+  .row.bot { align-self: flex-start; }
+  .avatar { width: 30px; height: 30px; border-radius: 8px; flex: 0 0 30px; background: #e91e8c;
+            display: flex; align-items: center; justify-content: center; }
+  .avatar svg { width: 16px; height: 16px; }
+  .bubble { padding: 11px 15px; border-radius: 18px; white-space: pre-wrap; word-break: break-word; }
+  .row.user .bubble { background: #3a3a3c; border-bottom-right-radius: 5px; }
+  .row.bot .bubble { background: transparent; padding: 6px 0; color: #ececec; }
+  .row.bot.pending .bubble { color: #8e8e93; }
+  .dots span { display: inline-block; width: 5px; height: 5px; margin-right: 3px; border-radius: 50%;
+               background: #8e8e93; animation: blink 1.2s infinite ease-in-out; }
+  .dots span:nth-child(2) { animation-delay: .2s; } .dots span:nth-child(3) { animation-delay: .4s; }
+  @keyframes blink { 0%, 80%, 100% { opacity: .25; } 40% { opacity: 1; } }
+  #bar { padding: 10px 16px 18px; }
+  #pill { display: flex; align-items: center; gap: 10px; background: #2c2c2e; border-radius: 26px;
+          padding: 8px 10px 8px 14px; }
+  .icon-btn { width: 32px; height: 32px; border-radius: 50%; border: none; background: transparent;
+              color: #ececec; display: flex; align-items: center; justify-content: center; cursor: pointer;
+              flex: 0 0 32px; }
+  .icon-btn:hover { background: #3a3a3c; }
+  .icon-btn svg { width: 18px; height: 18px; }
+  #inp { flex: 1; background: transparent; border: none; color: #ececec; font: inherit;
+         padding: 6px 0; min-width: 0; }
+  #inp::placeholder { color: #8e8e93; }
+  #inp:focus { outline: none; }
+</style></head>
+<body>
+  <div id="log"></div>
+  <div id="bar">
+    <div id="pill">
+      <button class="icon-btn" tabindex="-1">
+        <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round"><line x1="12" y1="5" x2="12" y2="19"/><line x1="5" y1="12" x2="19" y2="12"/></svg>
+      </button>
+      <input id="inp" placeholder="Message pods" autofocus>
+      <button class="icon-btn" id="send">
+        <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"><path d="M12 19V5"/><path d="M6 11l6-6 6 6"/></svg>
+      </button>
+    </div>
+  </div>
+<script>
+  const log = document.getElementById('log');
+  const inp = document.getElementById('inp');
+  const send = document.getElementById('send');
+  const AVATAR = '<svg viewBox="0 0 24 24" fill="none"><path d="M6 10c0-1 1-2 2-1l2 2 2-2c1-1 2 0 2 1v2c0 2-2 3-4 3s-4-1-4-3v-2z" fill="#fff"/></svg>';
+  function addRow(who, text) {
+    const row = document.createElement('div');
+    row.className = 'row ' + who + (text === null ? ' pending' : '');
+    if (who === 'bot') {
+      const av = document.createElement('div');
+      av.className = 'avatar';
+      av.innerHTML = AVATAR;
+      row.appendChild(av);
+    }
+    const bubble = document.createElement('div');
+    bubble.className = 'bubble';
+    bubble.innerHTML = text === null ? '<span class="dots"><span></span><span></span><span></span></span>' : '';
+    if (text !== null) bubble.textContent = text;
+    row.appendChild(bubble);
+    log.appendChild(row);
+    log.scrollTop = log.scrollHeight;
+    return { row, bubble };
+  }
+  async function submit() {
+    const task = inp.value.trim();
+    if (!task) return;
+    inp.value = '';
+    inp.disabled = true; send.disabled = true;
+    addRow('user', task);
+    const pending = addRow('bot', null);
+    try {
+      const r = await fetch('/drive', {
+        method: 'POST', headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({ task }),
+      });
+      const j = await r.json();
+      pending.row.classList.remove('pending');
+      pending.bubble.textContent = j.text || '(no response)';
+    } catch (e) {
+      pending.row.classList.remove('pending');
+      pending.bubble.textContent = 'error: ' + e.message;
+    }
+    inp.disabled = false; send.disabled = false; inp.focus();
+  }
+  send.addEventListener('click', submit);
+  inp.addEventListener('keydown', (e) => { if (e.key === 'Enter') submit(); });
+</script>
+</body></html>`;
+
 function record(entry) {
   try { appendFileSync(LOG, JSON.stringify(entry) + '\n'); } catch { /* best effort */ }
   console.log(`[agent:${entry.port ?? '-'}] ${entry.method || entry.ev} ${entry.path || ''} ${entry.bodyBytes ?? ''}${entry.frames ? ' frames=' + entry.frames : ''}`);
@@ -70,25 +173,42 @@ async function brain(messages) {
   return j?.choices?.[0]?.message?.content ?? '';
 }
 
-const SYSTEM = `You drive a Linux/macOS shell to accomplish a task. Reply with EXACTLY one line:
-either  RUN: <a single shell command>
-or      DONE: <one-line summary>  when the task is complete.
-No prose, no fences. You are given each command's output before your next line.`;
+const SYSTEM = `You are the brain of a Grok-Bot-style coding/ops agent. The polished chat UI
+the user sees is Grok Bot (Anysphere's app); its "sandbox" has been pointed at THIS box, and
+your reasoning is served by openzoo (pay-per-call access to ~435 models over x402 — no API key,
+no account, each call paid from a burner wallet). You are the substitute agent server.
+
+WHERE YOUR COMMANDS RUN: each shell command you emit is pushed to a local-exec daemon running on
+the USER'S OWN Mac (a supervised "sand" sandbox rooted at their home dir). Every command is
+APPROVAL-GATED — the user sees and approves it before it runs. So: act on the user's real machine,
+be careful, never destructive, prefer read-before-write, and explain nothing to the shell.
+
+PROTOCOL — reply with EXACTLY one line, no prose, no code fences:
+  RUN: <a single shell command>          to execute a step
+  DONE: <a short natural-language answer> when the task is complete (this text is shown in the UI)
+You are given each command's output before your next line. If the task needs no shell (a question,
+an explanation), answer it directly with a single DONE: line. Keep DONE summaries human and useful —
+they are the assistant's reply to the user, not a log.`;
 
 /** The agent loop for one task, executed through the connected daemon. Each
  *  RUN is pushed as an exec frame; the daemon's result frames (captured in
  *  `pendingResults`) feed the next turn. */
 async function runTask(task, stream, ctx) {
   const messages = [{ role: 'system', content: SYSTEM }, { role: 'user', content: task }];
+  let answer = '';
   for (let step = 0; step < MAX_STEPS; step++) {
     const line = (await brain(messages)).trim();
     record({ ev: 'brain', step, line });
+    const done = /^DONE:\s*([\s\S]+)/.exec(line);
+    if (done) { answer = done[1].trim(); record({ ev: 'task-done', step, answer }); return answer; }
     const run = /^RUN:\s*([\s\S]+)/.exec(line);
-    if (!run) { record({ ev: 'task-done', step, line }); return; }
+    // no RUN and no DONE — treat the whole line as a direct answer to the user
+    if (!run) { answer = line.replace(/^DONE:\s*/i, ''); record({ ev: 'task-freeform', step, answer }); return answer; }
     const cmd = run[1].trim();
     const frame = execFrame(cmd);
     ctx.awaiting = frame.requestId;
     ctx.output = '';
+    ctx.done = false;
     sseSend(stream, frame);
     record({ ev: 'exec-push', step, requestId: frame.requestId, cmd });
     // wait for the daemon's result frames for this requestId (or timeout)
@@ -96,6 +216,7 @@ async function runTask(task, stream, ctx) {
     messages.push({ role: 'assistant', content: line });
     messages.push({ role: 'user', content: `output:\n${out || '(none)'}` });
   }
+  return answer || '(reached step limit without finishing)';
 }
 
 function waitResult(ctx, timeoutMs) {
@@ -113,36 +234,70 @@ function waitResult(ctx, timeoutMs) {
 
 // per-connection context so a result frame can be matched to its exec
 const ctxByToken = new Map();
+// the single live daemon (Grok Bot's local-exec on the user's Mac). Set when it
+// opens its SSE; the /drive endpoint pushes exec frames down THIS stream.
+let activeDaemon = null;
+// one exec loop at a time against the shared daemon ctx — two concurrent
+// runTask calls would interleave result frames onto the same ctx.output.
+let driveQueue = Promise.resolve();
+function queueDrive(fn) {
+  const next = driveQueue.then(fn, fn);
+  driveQueue = next.catch(() => {});
+  return next;
+}
 
 for (const port of PORTS) {
   const server = http.createServer((req, res) => {
-    // The daemon's receive-channel: hold the SSE open; when it connects, if a
-    // task is queued (OZ_TASK) run the agent loop against it.
+    // The daemon's receive-channel: hold the SSE open. The TASK does NOT come
+    // from here or from any env var — it arrives via POST /drive, forwarded by
+    // the backend from whatever the user typed into the Grok Bot UI.
     if (req.method === 'GET' && req.url && req.url.startsWith('/local-exec/requests')) {
       const token = (req.headers['x-anyrun-network-token'] || 'default');
       const ctx = { awaiting: null, output: '', done: false };
       ctxByToken.set(token, ctx);
-      record({ port, method: 'GET', path: req.url, note: 'SSE opened', bodyBytes: 0 });
+      activeDaemon = { stream: res, ctx };
+      record({ port, method: 'GET', path: req.url, note: 'SSE opened — daemon connected', bodyBytes: 0 });
       res.writeHead(200, { 'content-type': 'text/event-stream', 'cache-control': 'no-cache', connection: 'keep-alive' });
       res.write(':ok\n\n');
-      // announce ourselves, then drive the task
+      // announce ourselves; then wait for the UI to drive us
       sseSend(res, { kind: 'welcome', providerId: 'openzoo' });
-      req.on('close', () => ctxByToken.delete(token));
-      if (process.env.OZ_TASK) {
-        setTimeout(() => runTask(process.env.OZ_TASK, res, ctx).catch((e) => record({ ev: 'task-error', err: String(e) })), 1200);
-      }
+      req.on('close', () => {
+        ctxByToken.delete(token);
+        if (activeDaemon && activeDaemon.stream === res) activeDaemon = null;
+      });
       return;
     }
 
     const chunks = [];
     req.on('data', (d) => chunks.push(d));
-    req.on('end', () => {
+    req.on('end', async () => {
       const body = Buffer.concat(chunks);
       let parsed, kinds;
       try { parsed = JSON.parse(body.toString('utf8')); kinds = parsed.frames?.map((f) => f.kind).join(','); } catch { /* not json */ }
       record({ port, method: req.method, path: req.url, bodyBytes: body.length, frames: kinds,
         bodyUtf8: body.slice(0, 1024).toString('utf8').replace(/[^\x20-\x7e]/g, '.') });
 
+      // THE TRIGGER: the backend forwards the user's Grok Bot prompt here. Drive
+      // the agent loop against the connected daemon and return the answer text.
+      if (req.method === 'POST' && req.url && req.url.startsWith('/drive')) {
+        let task = '';
+        try { task = (JSON.parse(body.toString('utf8')).task || '').toString(); }
+        catch { task = body.toString('utf8'); }
+        record({ ev: 'drive', task: task.slice(0, 160) });
+        if (!activeDaemon) {
+          res.writeHead(200, { 'content-type': 'application/json' });
+          res.end(JSON.stringify({ ok: false, text: '(sandbox not connected yet — give the app a moment and retry)' }));
+          return;
+        }
+        let text;
+        try {
+          text = await queueDrive(() => runTask(task, activeDaemon.stream, activeDaemon.ctx));
+        } catch (e) { text = `agent error: ${e.message}`; record({ ev: 'drive-error', err: String(e) }); }
+        res.writeHead(200, { 'content-type': 'application/json' });
+        res.end(JSON.stringify({ ok: true, text }));
+        return;
+      }
+
       // the daemon posts result frames here — accumulate output for the loop
       if (parsed?.frames && req.url?.includes('/local-exec/responses')) {
         const token = (req.headers['x-anyrun-network-token'] || 'default');
@@ -153,9 +308,16 @@ for (const port of PORTS) {
         }
       }
 
+      // THE REAL TRIGGER. Grok Bot's own chat (StreamUnifiedChat) never reaches
+      // us — inference happens server-side inside whatever pod EnsureSandBox
+      // named, and since we hijacked that to a pod that doesn't exist on
+      // Cursor's side, the UI's chat box just sits silent forever. But the app
+      // ALSO opens this vnc.html URL — OUR box — inside its own sandbox panel.
+      // Serve a real chat page here instead of a stub: the user types inside
+      // Grok Bot's own window, it POSTs straight to /drive on this box.
       if (req.url && req.url.includes('/vnc')) {
         res.writeHead(200, { 'content-type': 'text/html' });
-        res.end('<!doctype html><title>openzoo box</title>');
+        res.end(VNC_CHAT_HTML);
       } else {
         res.writeHead(200, { 'content-type': 'application/json' });
         res.end('{"ok":true}');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openzoo",
-  "version": "0.41.1",
+  "version": "0.43.0",
   "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",