openzoo 0.39.3 → 0.40.0

package/lib/boxes.js

@@ -173,7 +173,39 @@ export async function reapExpired() {
   return { reaped };
 }
 
-export async function spawnBox({ name = 'bot', days = 1, vcpu = 2, walletJson, pubkey } = {}) {
+/**
+ * MACHINE TIERS — a menu, not one size.
+ *
+ * A box that only runs a shell is fine on 2 vCPU, but a grokbot agent that
+ * builds a site, runs a dev server, or compiles wants real muscle — and some
+ * tasks want a GPU. So the orchestrator quotes SEVERAL tiers per timeframe and
+ * the user picks. GPU is a DELIBERATE tier here, never an accident: the guard
+ * below refuses GPU fields on a CPU tier, so a cpu tier can't silently 100x the
+ * bill, while a gpu tier carries them on purpose.
+ *
+ * $/hr are approximate RunPod secure-cloud rates for sizing the quote; the real
+ * charge is whatever RunPod bills. estUsdHr is labelled approximate for that.
+ */
+export const BOX_TIERS = {
+  'cpu-sm':  { label: 'CPU · 2 vCPU',       compute: 'CPU', vcpu: 2, disk: 20,  estUsdHr: 0.06 },
+  'cpu-md':  { label: 'CPU · 4 vCPU',       compute: 'CPU', vcpu: 4, disk: 40,  estUsdHr: 0.12 },
+  'cpu-lg':  { label: 'CPU · 8 vCPU',       compute: 'CPU', vcpu: 8, disk: 60,  estUsdHr: 0.24 },
+  'gpu-4090':{ label: 'GPU · 1× RTX 4090',  compute: 'GPU', gpuTypeIds: ['NVIDIA GeForce RTX 4090'], gpuCount: 1, disk: 60,  estUsdHr: 0.44 },
+  'gpu-a100':{ label: 'GPU · 1× A100 80GB', compute: 'GPU', gpuTypeIds: ['NVIDIA A100 80GB PCIe'],   gpuCount: 1, disk: 80,  estUsdHr: 1.64 },
+};
+export const DEFAULT_TIER = 'cpu-sm';
+
+/** The quote menu the orchestrator shows: every tier priced for `days`. */
+export function quoteTiers(days = 1) {
+  const hrs = ttlHours(days);
+  return Object.entries(BOX_TIERS).map(([key, t]) => ({
+    tier: key, label: t.label, days: Math.round(hrs / 24 * 10) / 10,
+    estUsd: Math.round(t.estUsdHr * hrs * 100) / 100, estUsdHr: t.estUsdHr, gpu: t.compute === 'GPU',
+  }));
+}
+
+export async function spawnBox({ name = 'bot', days = 1, tier = DEFAULT_TIER, walletJson, pubkey } = {}) {
+  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);
   const rand = Math.random().toString(36).slice(2, 6);
@@ -181,19 +213,20 @@ export async function spawnBox({ name = 'bot', days = 1, vcpu = 2, walletJson, p
 
   const body = {
     name: full,
-    computeType: 'CPU',
+    computeType: spec.compute,
     cloudType: 'SECURE',
-    vcpuCount: Math.max(1, Math.min(Number(vcpu) || 2, 4)),
-    cpuFlavorIds: CPU_FLAVORS,
-    cpuFlavorPriority: 'availability',
     imageName: BOX_IMAGE,
-    containerDiskInGb: 20,
+    containerDiskInGb: spec.disk,
     volumeInGb: 10,
     volumeMountPath: '/workspace',
     ports: BOX_PORTS,
     dockerStartCmd: ENTRYPOINT,
+    ...(spec.compute === 'CPU'
+      ? { vcpuCount: spec.vcpu, cpuFlavorIds: CPU_FLAVORS, cpuFlavorPriority: 'availability' }
+      : { gpuCount: spec.gpuCount, gpuTypeIds: spec.gpuTypeIds }),
     env: {
       OPENZOO_BOX: '1',
+      OPENZOO_TIER: tier,
       OPENZOO_EXPIRES_UNIX: String(unix),
       OPENZOO_NO_TUNNEL: '1',           // the runpod proxy already fronts it
       OPENZOO_BIND: '0.0.0.0',          // else the runpod proxy can't reach :8402
@@ -203,13 +236,16 @@ export async function spawnBox({ name = 'bot', days = 1, vcpu = 2, walletJson, p
       OZ_PODAGENT_B64: podAgentB64(),
     },
   };
-  // ENFORCE on the actual payload, not on a literal we just wrote.
+  // GPU ONLY ON A GPU TIER. A cpu tier must never carry GPU fields — that would
+  // be a silent 100x. Enforced on the serialized payload, not a literal.
   const wire = JSON.stringify(body);
-  if (/"gpu(Count|TypeIds)"/.test(wire)) throw new Error('refusing to spawn: GPU fields present');
+  if (spec.compute === 'CPU' && /"gpu(Count|TypeIds)"/.test(wire)) {
+    throw new Error('refusing to spawn: GPU fields on a CPU tier');
+  }
 
   const created = await rp('/pods', { method: 'POST', body: wire });
   if (!created.ok) return { ok: false, error: created.data?.error || `spawn ${created.status}` };
-  return { ok: true, box: serializeBox(created.data), expiresAt: expiresAt.toISOString() };
+  return { ok: true, tier, box: serializeBox(created.data), expiresAt: expiresAt.toISOString() };
 }
 
 /** Poll until the box answers on its proxy — npx has to fetch the shim first. */

package/lib/podagent.mjs

@@ -1,14 +1,23 @@
-// Pod capture agent — runs INSIDE our box, on the ports Grok Bot expects a
-// Cursor sandbox to answer (1337 agent, 6080 vnc, 1340, 6081).
+// Pod agent — runs INSIDE our box, on the ports Grok Bot expects a Cursor
+// sandbox to answer (1337 agent, 6080 vnc, 1340 local-exec, 6081).
 //
-// THIS IS THE PROBE THAT ANSWERS THE WALL. Once EnsureSandBox is rewritten to
-// point Grok Bot at our box, the app speaks Cursor's in-pod agent protocol to
-// port 1337 and expects a VNC/websockify desktop on 6080. We do not know that
-// protocol. This server logs EVERY request — method, path, headers, body
-// (hex + utf8) — to /var/log/openzoo/agent.jsonl and stdout, and answers a
-// benign 200/101 so the app keeps talking and reveals more. Read the log and
-// you have the spec; until then, "serve our VMs into their UI" is a capture,
-// not a working hijack, and this file is honest about which.
+// THE PROTOCOL, DECODED FROM A LIVE CAPTURE (2026-08-16). Grok Bot's sandbox
+// speaks plain HTTP JSON, not a proprietary binary:
+//   GET  /local-exec/requests   <- the local-exec-daemon opens an SSE stream to
+//                                  RECEIVE exec requests from the pod.
+//   POST /local-exec/responses  <- the daemon SENDS frames back:
+//        {"frames":[{"kind":"hello","localRoot":"/Users/…","variant":"sand",…}]}
+//        {"frames":[{"kind":"ping","supervised":true}]}
+//   auth: Bearer <network_token> / x-anyrun-network-token: nto-…
+//
+// So the box is the ORCHESTRATOR: it holds the SSE open and pushes exec frames
+// down it; the daemon runs them and posts results to /local-exec/responses.
+// This file (a) answers the handshake so the daemon stays connected, (b) can
+// PUSH a probe command down the SSE to capture what an exec frame + its output
+// frame look like (OZ_PROBE_CMD), and (c) logs every frame to agent.jsonl.
+//
+// STILL A CAPTURE until we've seen one real exec/output frame — then the
+// openzoo agent brain can drive this for real. Honest about which.
 
 import http from 'node:http';
 import { appendFileSync } from 'node:fs';
@@ -16,53 +25,86 @@ import { appendFileSync } from 'node:fs';
 const PORTS = (process.env.OZ_AGENT_PORTS || '1337,6080,1340,6081')
   .split(',').map((s) => Number(s.trim())).filter(Boolean);
 const LOG = process.env.OZ_AGENT_LOG || '/var/log/openzoo/agent.jsonl';
+// A shell command to push down the SSE the first time a daemon connects, to
+// capture the exec-request AND its result frame. Default probes harmlessly.
+const PROBE = process.env.OZ_PROBE_CMD || 'echo openzoo-probe && uname -a';
 
 function record(entry) {
-  const line = JSON.stringify(entry);
-  try { appendFileSync(LOG, line + '\n'); } catch { /* best effort */ }
-  console.log(`[agent:${entry.port}] ${entry.method} ${entry.path} ${entry.bodyBytes}b` +
-    (entry.upgrade ? ` (UPGRADE ${entry.upgrade})` : ''));
+  try { appendFileSync(LOG, JSON.stringify(entry) + '\n'); } catch { /* best effort */ }
+  const tag = entry.frames ? ` frames=${entry.frames}` : '';
+  console.log(`[agent:${entry.port}] ${entry.method} ${entry.path} ${entry.bodyBytes}b${tag}`);
+}
+
+// SSE clients currently holding /local-exec/requests open, so we can push.
+const execStreams = new Set();
+let probedOnce = false;
+
+/** Push one exec frame down every open request stream. Frame shape is our best
+ *  guess from the response frames; the daemon's reply (accept or error) TEACHES
+ *  us the real schema, which is the whole point. */
+function pushExec(cmd) {
+  const id = `oz-${Date.now().toString(36)}`;
+  // THE COMMAND FRAME IS kind:"shell", NOT "exec". Decoded from the app bundle:
+  // the daemon's receive-union has kind "shell" (run), "sequence", "abort"; the
+  // proto is {command: scalar, args, cwd, env}. Our first probe used "exec"
+  // (which appears once in the bundle) and the daemon silently ignored it,
+  // sending only pings. "shell" is what it actually runs.
+  const frame = { frames: [{ kind: 'shell', id, command: cmd, cwd: '/tmp', supervised: true }] };
+  const payload = `data: ${JSON.stringify(frame)}\n\n`;
+  for (const res of execStreams) { try { res.write(payload); } catch { /* dead stream */ } }
+  record({ t: new Date().toISOString(), port: 1340, method: 'SSE-PUSH', path: '/local-exec/requests',
+    bodyBytes: payload.length, pushed: frame });
 }
 
 for (const port of PORTS) {
   const server = http.createServer((req, res) => {
+    // SSE receive-channel: hold it open, let us push exec frames.
+    if (req.method === 'GET' && req.url && req.url.startsWith('/local-exec/requests')) {
+      record({ t: new Date().toISOString(), port, method: 'GET', path: req.url,
+        headers: req.headers, bodyBytes: 0, note: 'SSE stream opened' });
+      res.writeHead(200, {
+        'content-type': 'text/event-stream',
+        'cache-control': 'no-cache',
+        connection: 'keep-alive',
+      });
+      res.write(':ok\n\n');
+      execStreams.add(res);
+      req.on('close', () => execStreams.delete(res));
+      // once a stream is open, push the probe command to capture the exec loop
+      if (!probedOnce) { probedOnce = true; setTimeout(() => pushExec(PROBE), 1500); }
+      return;
+    }
+
     const chunks = [];
     req.on('data', (d) => chunks.push(d));
     req.on('end', () => {
       const body = Buffer.concat(chunks);
+      let frames;
+      try { frames = JSON.parse(body.toString('utf8')).frames?.map((f) => f.kind).join(','); } catch { /* not json */ }
       record({
         t: new Date().toISOString(), port,
-        method: req.method, path: req.url,
-        headers: req.headers,
-        bodyBytes: body.length,
-        bodyHex: body.slice(0, 512).toString('hex'),
-        bodyUtf8: body.slice(0, 512).toString('utf8').replace(/[^\x20-\x7e]/g, '.'),
+        method: req.method, path: req.url, headers: req.headers,
+        bodyBytes: body.length, frames,
+        bodyHex: body.slice(0, 256).toString('hex'),
+        bodyUtf8: body.slice(0, 1024).toString('utf8').replace(/[^\x20-\x7e]/g, '.'),
       });
-      // Benign answers so the client does not give up immediately.
       if (req.url && req.url.includes('/vnc')) {
         res.writeHead(200, { 'content-type': 'text/html' });
         res.end('<!doctype html><title>openzoo box</title><body>capture</body>');
       } else {
+        // /local-exec/responses and everything else: accept it so the daemon
+        // keeps its session and keeps sending frames.
         res.writeHead(200, { 'content-type': 'application/json' });
-        res.end('{}');
+        res.end('{"ok":true}');
       }
     });
   });
-  // Capture websocket upgrades too — VNC/websockify is a WS, and the agent
-  // channel may be one; log the handshake even though we don't speak it yet.
   server.on('upgrade', (req, socket) => {
-    record({
-      t: new Date().toISOString(), port,
-      method: req.method, path: req.url, upgrade: req.headers.upgrade,
-      headers: req.headers, bodyBytes: 0,
-    });
-    // 101 with no real protocol; the client will close, which is fine — we
-    // only needed the handshake headers.
+    record({ t: new Date().toISOString(), port, method: 'UPGRADE', path: req.url,
+      upgrade: req.headers.upgrade, headers: req.headers, bodyBytes: 0 });
     socket.write('HTTP/1.1 101 Switching Protocols\r\nUpgrade: websocket\r\nConnection: Upgrade\r\n\r\n');
-    socket.on('data', (d) => record({
-      t: new Date().toISOString(), port, method: 'WS-DATA', path: req.url,
-      bodyBytes: d.length, bodyHex: d.slice(0, 256).toString('hex'),
-    }));
+    socket.on('data', (d) => record({ t: new Date().toISOString(), port, method: 'WS-DATA', path: req.url,
+      bodyBytes: d.length, bodyHex: d.slice(0, 256).toString('hex') }));
   });
   server.listen(port, '0.0.0.0', () => console.log(`[agent] capturing on :${port}`));
 }

package/package.json

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