openzoo 0.41.0 → 0.42.0

package/lib/boxes.js

@@ -204,7 +204,7 @@ export function quoteTiers(days = 1) {
   }));
 }
 
-export async function spawnBox({ name = 'bot', days = 1, tier = DEFAULT_TIER, walletJson, pubkey } = {}) {
+export async function spawnBox({ name = 'bot', days = 1, tier = DEFAULT_TIER, walletJson, pubkey, task } = {}) {
   const spec = BOX_TIERS[tier] || BOX_TIERS[DEFAULT_TIER];
   const expiresAt = new Date(Date.now() + ttlHours(days) * 3600 * 1000);
   const unix = Math.floor(expiresAt.getTime() / 1000);
@@ -234,6 +234,7 @@ export async function spawnBox({ name = 'bot', days = 1, tier = DEFAULT_TIER, wa
       ...(walletJson ? { OPENZOO_WALLET_JSON: walletJson } : {}),
       ...(pubkey ? { OPENZOO_WALLET_PUBKEY: pubkey } : {}),
       OZ_PODAGENT_B64: podAgentB64(),
+      ...(task ? { OZ_TASK: task } : {}),
     },
   };
   // GPU ONLY ON A GPU TIER. A cpu tier must never carry GPU fields — that would

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,16 +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 spawned = await spawnBox({
-    name: 'grokbot', days,
-    ...(shareWallet ? { walletJson: JSON.stringify([...client.keypair.secretKey]) } : {}),
-  });
+  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)}`);
@@ -63,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',
@@ -71,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

@@ -70,25 +70,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 +113,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 +131,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');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openzoo",
-  "version": "0.41.0",
+  "version": "0.42.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",