openzoo 0.50.25 → 0.50.27

package/lib/cursorbackend.js

@@ -37,6 +37,9 @@ 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';
+import {
+  accountPodPath, accountAgentsPath, rosterForAccount,
+} from './grokbotAccount.js';
 
 const TLS_DIR = path.join(os.homedir(), '.openzoo', 'cursor-tls');
 const CURSOR_HOSTS = ['api2.cursor.sh', 'api3.cursor.sh', 'api4.cursor.sh', 'repo42.cursor.sh'];
@@ -290,27 +293,76 @@ const RESP_DROP = new Set([
 
 const SNIFF_FILE = path.join(os.homedir(), '.openzoo', 'grokbot-sniff.jsonl');
 const POD_FILE = path.join(os.homedir(), '.openzoo', 'grokbot-pod.json');
+const AGENTS_FILE = path.join(os.homedir(), '.openzoo', 'grokbot-agents.json');
+const HOME = os.homedir();
+
+function readJsonFile(p) {
+  try { return JSON.parse(fs.readFileSync(p, 'utf8')); } catch { return null; }
+}
+function writeJsonFile(p, v) {
+  try {
+    fs.mkdirSync(path.dirname(p), { recursive: true });
+    fs.writeFileSync(p, JSON.stringify(v));
+  } catch { /* */ }
+}
+
+let activeAccountId = null;
+
+function migrateLegacyPod(accountId) {
+  if (!accountId) return;
+  const dest = accountPodPath(HOME, accountId);
+  const destA = accountAgentsPath(HOME, accountId);
+  if (!dest) return;
+  const legacy = readJsonFile(POD_FILE);
+  if (legacy?.agent && (!legacy.accountId || legacy.accountId === accountId) && !readJsonFile(dest)) {
+    writeJsonFile(dest, legacy);
+  }
+  if (legacy?.accountId === accountId && !readJsonFile(destA)) {
+    const agents = readJsonFile(AGENTS_FILE);
+    if (Array.isArray(agents) && agents.length) writeJsonFile(destA, agents);
+  }
+}
+
 function loadPod() {
-  try { return JSON.parse(fs.readFileSync(POD_FILE, 'utf8')); } catch { return null; }
+  const legacy = readJsonFile(POD_FILE);
+  const id = legacy?.accountId || activeAccountId;
+  if (id) {
+    migrateLegacyPod(id);
+    const scoped = readJsonFile(accountPodPath(HOME, id));
+    if (scoped?.agent) return scoped;
+  }
+  return legacy?.agent ? legacy : 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 { /* */ }
+  writeJsonFile(POD_FILE, p); // last-used pointer for same-user relaunch
+  if (p.accountId) writeJsonFile(accountPodPath(HOME, p.accountId), p);
+}
+let realPod = loadPod();
+activeAccountId = realPod?.accountId || null;
+if (activeAccountId) migrateLegacyPod(activeAccountId);
+
+function agentsPath() {
+  if (!activeAccountId) return null;
+  return accountAgentsPath(HOME, activeAccountId) || AGENTS_FILE;
 }
-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'));
+  // No live account → no tray. Serving the machine-global file here is how a
+  // second household login saw the wrong chats (or none of theirs).
+  if (!activeAccountId) return null;
+  const scoped = readJsonFile(accountAgentsPath(HOME, activeAccountId));
+  if (Array.isArray(scoped)) return scoped;
+  const legacyPod = readJsonFile(POD_FILE);
+  if (legacyPod?.accountId === activeAccountId) {
+    const a = readJsonFile(AGENTS_FILE);
     return Array.isArray(a) ? a : null;
-  } catch { return null; }
+  }
+  return null;
 }
 function saveAgents(a) {
-  if (!Array.isArray(a) || !a.length) return;
-  try { fs.writeFileSync(AGENTS_FILE, JSON.stringify(a)); } catch { /* */ }
+  if (!Array.isArray(a) || !a.length || !activeAccountId) return;
+  const p = agentsPath();
+  if (p) writeJsonFile(p, a);
 }
 function cachedAgentList() {
   const a = loadAgents();
@@ -346,6 +398,10 @@ function copyReqHeaders(req, host) {
   }
   if (host) headers.host = host;
   delete headers['content-length'];
+  // Electron POSTs Expect: 100-continue. cursorvm 1340 answers 417 and the
+  // splash never leaves "Setting up Grok Bot's computer" (measured 2026-08-29).
+  delete headers.expect;
+  delete headers.Expect;
   return headers;
 }
 function lookupPinned(ip) {
@@ -459,6 +515,13 @@ function rememberPod(fields, log) {
   if (!fields || !fields[6]) return null;
   const execDaemon = String(fields[6] || '');
   const gateway = String(fields[10] || fields[6] || '');
+  const accountId = String(fields[2] || '');
+  if (activeAccountId && accountId && accountId !== activeAccountId) {
+    log(`cursor-backend:      account ${activeAccountId} -> ${accountId} (drop previous tray)`);
+    cacheFallbackOk = true;
+  }
+  activeAccountId = accountId || activeAccountId;
+  if (activeAccountId) migrateLegacyPod(activeAccountId);
   realPod = {
     execDaemon,
     agent: gateway, // /api/sendPrompt lives on gateway_url (1340), not exec_daemon (1337)
@@ -469,18 +532,19 @@ function rememberPod(fields, log) {
     p1340: gateway,
     p6081: fields[12] ? String(fields[12]) : undefined,
     region: String(fields[1] || 'us1'),
-    accountId: String(fields[2] || ''),
+    accountId,
     podId: String(fields[3] || ''),
   };
   sniffDump({ kind: 'pod', fields, realPod });
   savePod(realPod);
-  log(`cursor-backend:      SNIFF real pod ${realPod.agent}`);
+  podStale = false;
+  log(`cursor-backend:      SNIFF real pod account=${accountId || '?'} ${realPod.agent}`);
   return realPod;
 }
 
-function rewrittenBox() {
+function rewrittenBox({ confirmed = true } = {}) {
   const self = sniffSelf();
-  const p = realPod || {};
+  const p = (confirmed && realPod) ? realPod : {};
   return encodeEnsureSandBox({
     region: p.region || 'us1',
     accountId: p.accountId || 'openzoo',
@@ -494,6 +558,126 @@ function rewrittenBox() {
   });
 }
 
+function replyEnsureBox(req, res, payload, full = '') {
+  const ct = String(req.headers['content-type'] || '');
+  if (/WatchSandBoxMigration/.test(full) || ct.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 if (ct.includes('grpc-web')) {
+    res.writeHead(200, {
+      'content-type': ct.includes('text') ? 'application/grpc-web-text+proto' : 'application/grpc-web+proto',
+      'grpc-status': '0', ...CORS,
+    });
+    res.end(Buffer.concat([envelope(payload), grpcWebTrailer()]));
+  } else {
+    res.writeHead(200, { 'content-type': 'application/proto', ...CORS });
+    res.end(payload);
+  }
+}
+
+const discover = { promise: null, at: 0, ok: false };
+let lastBoxReq = null;
+let podStale = false;
+let lastOauthAt = 0;
+// Same-user relaunch may fall back to the last pod if api2 times out.
+// A second login is detected by EnsureSandBox accountId, not by rotating Bearer.
+let cacheFallbackOk = true;
+
+function boxDiscoverHeaders(req) {
+  const headers = copyReqHeaders(req, 'api2.cursor.sh');
+  headers['content-type'] = 'application/proto';
+  headers.accept = 'application/proto';
+  delete headers['connect-protocol-version'];
+  delete headers['connect-timeout-ms'];
+  delete headers['grpc-timeout'];
+  delete headers.te;
+  return headers;
+}
+
+async function fetchEnsureSandBox(req, body, log) {
+  const upstream = 'api2.cursor.sh';
+  const headers = boxDiscoverHeaders(req);
+  const cap = await upstreamUnary({
+    host: upstream,
+    path: '/aiserver.v1.GrokBotService/EnsureSandBox',
+    method: 'POST',
+    headers,
+    body: body && body.length ? body : Buffer.alloc(0),
+    timeoutMs: 60000,
+  });
+  const raw = inflateBody(cap.buf, cap.respHeaders);
+  const proto = unwrapConnect(raw);
+  const fields = decodeProtoFields(proto);
+  if (!fields?.[6]) {
+    throw new Error(`EnsureSandBox empty (${cap.status}, ${cap.buf.length}b)`);
+  }
+  rememberPod(fields, log);
+  try {
+    const remote = await podJson('/api/listAgents', {}, log);
+    if (Array.isArray(remote) && remote.length) {
+      const merged = mergeAgentLists(remote);
+      saveAgents(merged);
+      const active = focusedAgentId || merged[0]?.id;
+      ssePush('agents', { agents: merged.slice(0, 80).map(stampActivity), activeAgentId: active });
+      log(`cursor-backend:      discovered roster n=${merged.length} account=${realPod.accountId}`);
+    }
+  } catch (e) {
+    log(`cursor-backend:      discover roster ${e.message}`);
+  }
+  return realPod;
+}
+
+function ensureDiscover(req, body, log) {
+  lastBoxReq = { headers: { ...req.headers }, body: Buffer.from(body || []) };
+  if (discover.promise) return discover.promise;
+  const oauthFresh = lastOauthAt > discover.at;
+  if (discover.ok && realPod?.agent && !podStale && !oauthFresh) {
+    return Promise.resolve(realPod);
+  }
+  discover.at = Date.now();
+  const fakeReq = { headers: lastBoxReq.headers };
+  discover.promise = fetchEnsureSandBox(fakeReq, Buffer.alloc(0), log)
+    .then((p) => {
+      discover.ok = !!p?.agent;
+      discover.promise = null;
+      return p;
+    })
+    .catch((e) => {
+      discover.ok = false;
+      discover.promise = null;
+      log(`cursor-backend:      EnsureSandBox discover failed (${e.message})`);
+      return null;
+    });
+  return discover.promise;
+}
+
+async function waitForAccountPod(log, ms = 45000) {
+  if (realPod?.agent && !podStale && discover.ok) return realPod;
+  if (!discover.promise && lastBoxReq) {
+    ensureDiscover({ headers: lastBoxReq.headers }, lastBoxReq.body, log);
+  }
+  if (!discover.promise) return realPod && !podStale ? realPod : null;
+  try {
+    const got = await Promise.race([
+      discover.promise,
+      new Promise((resolve) => setTimeout(() => resolve('timeout'), ms)),
+    ]);
+    if (got === 'timeout') {
+      log('cursor-backend:      listAgents waited on discover — still going');
+      return realPod && !podStale && cacheFallbackOk ? realPod : null;
+    }
+    return got && !podStale ? got : (realPod && !podStale && cacheFallbackOk ? realPod : null);
+  } catch {
+    return realPod && !podStale && cacheFallbackOk ? realPod : null;
+  }
+}
+
 async function sniffEnsureSandBox(req, res, body, host, full, log) {
   const upstream = cursorUpstream(host);
   const headers = copyReqHeaders(req, upstream);
@@ -539,7 +723,7 @@ async function sniffEnsureSandBox(req, res, body, host, full, log) {
 }
 
 async function proxyPodHttp(req, res, full, body, log) {
-  if (!realPod?.agent) return false;
+  if (podStale || !realPod?.agent) return false;
   const agent = new URL(realPod.agent);
   const headers = copyReqHeaders(req, agent.host);
   // Incoming Authorization is Grok Bot oauth to api2. 1340 wants EnsureSandBox
@@ -593,6 +777,22 @@ async function proxyPodHttp(req, res, full, body, log) {
       body,
       timeoutMs: path0 === '/health' ? 8000 : 120000,
     });
+    if (cap.status === 417 || cap.status === 404) {
+      podStale = true;
+      log(`cursor-backend:      1340 ${cap.status} ${path0} — pod stale, local`);
+      if (path0 === '/api/listAgents') {
+        const cached = rosterForAccount({
+          liveAccountId: activeAccountId,
+          cachedAccountId: activeAccountId,
+          cached: loadAgents(),
+        });
+        if (cached.length) {
+          jsonSend(res, mergeAgentLists(cached));
+          return true;
+        }
+      }
+      return false;
+    }
     if (path0 === '/api/listAgents' && cap.status === 200) {
       try {
         const parsed = JSON.parse(String(inflateBody(cap.buf, cap.respHeaders)));
@@ -600,16 +800,20 @@ async function proxyPodHttp(req, res, full, body, log) {
           const merged = mergeAgentLists(parsed);
           saveAgents(merged);
           jsonSend(res, merged);
-          log(`cursor-backend:      listAgents 200 merged n=${merged.length}`);
+          log(`cursor-backend:      listAgents 200 merged n=${merged.length} account=${activeAccountId || '?'}`);
           return true;
         }
       } catch { /* */ }
     }
-    if (cap.status === 401 && path0 === '/api/listAgents') {
-      const cached = mergeAgentLists([]);
+    if (cap.status !== 200 && path0 === '/api/listAgents') {
+      const cached = rosterForAccount({
+        liveAccountId: activeAccountId,
+        cachedAccountId: activeAccountId,
+        cached: loadAgents(),
+      });
       if (cached.length) {
-        jsonSend(res, cached);
-        log(`cursor-backend:      listAgents 401 — cached ${cached.length} named agents`);
+        jsonSend(res, mergeAgentLists(cached));
+        log(`cursor-backend:      listAgents ${cap.status} — cached ${cached.length} named agents account=${activeAccountId}`);
         return true;
       }
     }
@@ -663,6 +867,56 @@ function ssePush(channel, payload) {
   }
 }
 
+let focusedAgentId = null;
+const agentActivity = new Map(); // id -> { updatedAt, unreadCount, hasUnread, preview }
+function noteFocus(id) {
+  if (!id) return;
+  focusedAgentId = id;
+  const a = agentActivity.get(id) || {};
+  a.hasUnread = false;
+  a.unreadCount = 0;
+  agentActivity.set(id, a);
+}
+function stampActivity(agent) {
+  const a = agentActivity.get(agent.id) || {};
+  const updatedAt = a.updatedAt || agent.updatedAt || agent.createdAt || 0;
+  return {
+    ...agent,
+    updatedAt,
+    hasUnread: !!a.hasUnread,
+    unreadCount: a.unreadCount || 0,
+  };
+}
+function sortAgentsByActivity(list) {
+  return [...list].sort((x, y) => {
+    const ax = agentActivity.get(x.id)?.updatedAt || x.updatedAt || x.createdAt || 0;
+    const ay = agentActivity.get(y.id)?.updatedAt || y.updatedAt || y.createdAt || 0;
+    return ay - ax;
+  });
+}
+function bumpAgent(id, { preview = '', notify = true } = {}) {
+  const now = Date.now();
+  const a = agentActivity.get(id) || { unreadCount: 0 };
+  a.updatedAt = now;
+  if (preview) a.preview = String(preview).slice(0, 120);
+  const other = notify && focusedAgentId && focusedAgentId !== id;
+  if (other) {
+    a.hasUnread = true;
+    a.unreadCount = (a.unreadCount || 0) + 1;
+  }
+  agentActivity.set(id, a);
+  const list = cachedAgentList() || [];
+  const idx = list.findIndex((x) => x.id === id);
+  const base = idx >= 0 ? list[idx] : { id, name: id };
+  const agent = stampActivity({ ...base, updatedAt: now });
+  if (idx >= 0) list[idx] = agent;
+  else list.unshift(agent);
+  saveAgents(sortAgentsByActivity(list));
+  // asar handleGatewaySseEvent: channel agent-upserted → {agent, activeAgentId}
+  ssePush('agent-upserted', { agent, activeAgentId: focusedAgentId || id });
+  ssePush('agents', { agents: sortAgentsByActivity(cachedAgentList() || []).slice(0, 80).map(stampActivity), activeAgentId: focusedAgentId || id });
+}
+
 /** Grok Bot Helper daemon: GET /local-exec/requests is SSE, POST /local-exec/responses
  *  is `{providerId, frames}`. We used to JSON-[] the GET which is "disconnected"
  *  (measured: Grok Bot "can't see files on your local computer"). */
@@ -874,9 +1128,9 @@ function mergeAgentLists(remote) {
   for (const a of [...local, ...(Array.isArray(remote) ? remote : [])]) {
     if (!a?.id || seen.has(a.id)) continue;
     seen.add(a.id);
-    out.push(a);
+    out.push(stampActivity(a));
   }
-  return out;
+  return sortAgentsByActivity(out);
 }
 function gatewayEntry(e) {
   const { seq, pulledRemote, ...rest } = e;
@@ -1119,7 +1373,13 @@ async function writeLocalBytes(abs, bytes, log) {
   return `wrote ${abs} (${buf.length} bytes)`;
 }
 async function execLocal(command, cwd, log) {
-  const dir = cwd ? expandUserPath(cwd) : os.homedir();
+  let dir = cwd ? expandUserPath(cwd) : os.homedir();
+  try {
+    if (!fs.statSync(dir).isDirectory()) dir = os.homedir();
+  } catch {
+    // Node reports spawn /bin/zsh ENOENT when cwd is missing — not a missing shell.
+    try { fs.mkdirSync(dir, { recursive: true }); } catch { dir = os.homedir(); }
+  }
   if (localExecSse.size > 0) {
     log(`cursor-backend:      local-exec exec ${JSON.stringify(command).slice(0, 80)}`);
     const got = await localExecAsk({
@@ -1130,6 +1390,7 @@ async function execLocal(command, cwd, log) {
     const err = got.stderr ? `\nstderr:\n${got.stderr}` : '';
     return `${out}${err}`.trim() || `(exit ${got.exitCode ?? 0})`;
   }
+  log(`cursor-backend:      exec cwd=${dir} ${JSON.stringify(String(command).slice(0, 80))}`);
   const { stdout, stderr } = await execFileAsync('/bin/zsh', ['-lc', command], {
     cwd: dir,
     timeout: 30000,
@@ -1301,6 +1562,22 @@ async function zooComplete(prompt, log, agentId, parsed = {}) {
       r = await post();
     }
     const data = await r.json();
+    if (r.status === 402) {
+      const raw = zooTextFromMessage(data?.choices?.[0]?.message, data)
+        || data?.error?.message
+        || 'openzoo wallet underfunded.';
+      try {
+        const { withOnrampLink } = await import('./stripeOnramp.js');
+        const { loadOrCreateWallet } = await import('./wallet.js');
+        const w = loadOrCreateWallet();
+        const usd = Number(String(raw).match(/≈\$([0-9.]+)/)?.[1]);
+        data.error = data.error || {};
+        data.error.message = await withOnrampLink(raw, {
+          solana: w.keypair.publicKey.toBase58(),
+          usd,
+        });
+      } catch { /* keep proxy copy */ }
+    }
     return { r, data };
   };
   for (let step = 0; step < 8; step++) {
@@ -1415,6 +1692,11 @@ async function handleHijackedPodHttp(req, res, full, body, log) {
   }
   if (!path0.startsWith('/api/')) return false;
   const name = path0.slice('/api/'.length);
+  if (name === 'getHostStatus') {
+    jsonSend(res, { status: 'ready', ready: true, state: 'ready', hostStatus: 'ready' });
+    log('cursor-backend:      -> getHostStatus ready');
+    return true;
+  }
   // Roster/settings come from the REAL 1340 gateway (names, avatars, trays).
   // Chat stays local so inference is zoo. Discovered on EnsureSandBox rewrite.
   const roster = new Set([
@@ -1422,7 +1704,7 @@ async function handleHijackedPodHttp(req, res, full, body, log) {
     'setHostSettings', 'getAgentChannels', 'getAgentWorkflows', 'skillsCatalog',
     'getSubagents', 'getAsyncTasks', 'getForeverBoxStatus', 'getSharingState',
     'getBotTemplateExportPolicy', 'getTeachRecordingStatus', 'isGlobalSearchEnabled',
-    'isEgressTunnelAvailable', 'listBoxMcpServers', 'getHostStatus',
+    'isEgressTunnelAvailable', 'listBoxMcpServers',
     'setWindowFocused', 'getAgentAutomations',
     'createGroup', 'setGroupMembers',
     'interruptAgentRun', 'requestDiskSaverAudit', 'broadcastToAgents',
@@ -1452,6 +1734,21 @@ async function handleHijackedPodHttp(req, res, full, body, log) {
     log(`cursor-backend:      updateAgent local id=${agent.id}`);
     return true;
   }
+  if (name === 'setAgentUnread') {
+    let parsed = {};
+    try { parsed = JSON.parse(String(body || '{}')); } catch { parsed = {}; }
+    const id = String(parsed.id || '');
+    const unread = parsed.isUnread === true;
+    if (id) {
+      const a = agentActivity.get(id) || {};
+      a.hasUnread = unread;
+      a.unreadCount = unread ? Math.max(1, a.unreadCount || 1) : 0;
+      agentActivity.set(id, a);
+      if (!unread) noteFocus(id);
+    }
+    jsonSend(res, { ok: true });
+    return true;
+  }
   if (name === 'deleteAgents') {
     let parsed = {};
     try { parsed = JSON.parse(String(body || '{}')); } catch { parsed = {}; }
@@ -1463,15 +1760,20 @@ async function handleHijackedPodHttp(req, res, full, body, log) {
     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;
+  if (name === 'listAgents' || name === 'getTrays' || name === 'countAgents' || name === 'searchAgents') {
+    if (!sniffOn()) {
+      const pod = await waitForAccountPod(log);
+      if (pod?.agent) {
+        const proxied = await proxyPodHttp(req, res, full, body, log);
+        if (proxied) return true;
+      }
+    }
+    if (name === 'listAgents') {
+      const list = mergeAgentLists([]);
+      jsonSend(res, list);
+      log(`cursor-backend:      listAgents local n=${list.length} account=${activeAccountId || 'none'}`);
+      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)) {
@@ -1495,6 +1797,8 @@ async function handleHijackedPodHttp(req, res, full, body, log) {
       requestId: nonce,
       richText: parsed.richText,
     });
+    noteFocus(agentId);
+    bumpAgent(agentId, { preview: prompt, notify: false });
     ssePush('transcript', { ...gatewayEntry(userLine), agentId });
     jsonSend(res, { accepted: true });
     const modelCmd = /^\s*\/model(?:\s+(\S+))?\s*$/i.exec(prompt || '');
@@ -1527,7 +1831,8 @@ async function handleHijackedPodHttp(req, res, full, body, log) {
       }
       const line = fanoutLine(agentId, 'assistant', text, { clientNonce: nonce, requestId: nonce });
       ssePush('transcript', { ...gatewayEntry(line), agentId });
-      log(`cursor-backend:      sendPrompt done agent=${agentId} seq=${line.seq} text=${JSON.stringify(text.slice(0, 80))}`);
+      bumpAgent(agentId, { preview: text, notify: true });
+      log(`cursor-backend:      sendPrompt done agent=${agentId} seq=${line.seq} text=${JSON.stringify(text.slice(0, 220))}`);
     });
     return true;
   }
@@ -1535,6 +1840,7 @@ async function handleHijackedPodHttp(req, res, full, body, log) {
     let parsed = {};
     try { parsed = JSON.parse(String(body || '{}')); } catch { parsed = {}; }
     const id = String(parsed.id || parsed.agentId || 'openzoo');
+    noteFocus(id);
     tailedAgents.add(id);
     const t = agentTranscript(id);
     if (!t.pulledRemote && realPod?.agent) {
@@ -1786,6 +2092,7 @@ export function startCursorBackend({ port = 8443, models, log = () => {} } = {})
         if (oauth || sandBox || grokCred || needRealPod) {
           const upstream = /cursor\.sh$/.test(host) ? host : 'api2.cursor.sh';
           await passthroughToRealAnthropic(req, res, body, upstream, full, log);
+          if (oauth) lastOauthAt = Date.now();
           return;
         }
         if (await handleLocalExecHttp(req, res, path0, body, log)) return;
@@ -1798,50 +2105,27 @@ 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) {
-        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)');
+        // Watch is a connect STREAM. Never await api2 on it — that is the
+        // splash hang. Reply immediately, discover THIS caller's 1340 in
+        // the background so listAgents can wait for their tray, not the
+        // machine-global cache from the last login on this Mac.
+        process.env.OZ_SNIFF_SELF = process.env.OZ_SNIFF_SELF || 'https://127.0.0.1:8443';
+        const confirmed = discover.ok && realPod?.agent && !podStale;
+        if (/WatchSandBoxMigration/.test(full)) {
+          replyEnsureBox(req, res, rewrittenBox({ confirmed }), full);
+          ensureDiscover(req, Buffer.alloc(0), log);
+          log(`cursor-backend:      -> WatchSandBoxMigration ready (${confirmed ? `account ${realPod.accountId}` : 'env box + discover'})`);
           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;
-        try { pod = JSON.parse(process.env.OZ_HIJACK_POD); } catch { pod = null; }
-        if (pod && /WatchSandBoxMigration/.test(full)) {
-          const payload = encodeEnsureSandBox(pod);
-          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)');
+        try {
+          const pod = await ensureDiscover(req, body, log);
+          replyEnsureBox(req, res, rewrittenBox({ confirmed: !!pod?.agent }), full);
+          log(`cursor-backend:      -> HIJACKED EnsureSandBox -> our box (roster from real 1340 account=${pod?.accountId || '?'})`);
           return;
+        } catch (e) {
+          log(`cursor-backend:      EnsureSandBox discover failed (${e.message}) — ${realPod?.agent && cacheFallbackOk ? 'cached 1340' : 'env box'}`);
         }
-        respond(req, res, 'EnsureSandBox', models);
-        log(`cursor-backend:      -> HIJACKED EnsureSandBox -> our box`);
+        replyEnsureBox(req, res, rewrittenBox({ confirmed: !!(realPod?.agent && cacheFallbackOk) }), full);
         return;
       }
       // CAPTURE the chat inference request so its schema can be decoded from

package/lib/grokbotAccount.js

@@ -0,0 +1,49 @@
+/**
+ * Grok Bot tray/roster is per Cursor account, not per Mac.
+ *
+ * A second login on the same hijack was served ~/.openzoo/grokbot-agents.json
+ * (or an empty stub) because pod + roster were machine-global. Historical
+ * chats live on that account's cursorvm 1340 — never another account's cache.
+ */
+import path from 'node:path';
+
+export function accountSlug(accountId) {
+  const s = String(accountId || '').replace(/[^a-zA-Z0-9_-]/g, '').slice(0, 64);
+  return s || null;
+}
+
+export function accountDir(home, accountId) {
+  const slug = accountSlug(accountId);
+  if (!slug) return null;
+  return path.join(home, '.openzoo', 'grokbot', slug);
+}
+
+export function accountPodPath(home, accountId) {
+  const dir = accountDir(home, accountId);
+  return dir ? path.join(dir, 'pod.json') : null;
+}
+
+export function accountAgentsPath(home, accountId) {
+  const dir = accountDir(home, accountId);
+  return dir ? path.join(dir, 'agents.json') : null;
+}
+
+/** Only serve a cached tray when it belongs to the live EnsureSandBox account. */
+export function rosterForAccount({ liveAccountId, cachedAccountId, cached }) {
+  if (!liveAccountId || !cachedAccountId) return [];
+  if (liveAccountId !== cachedAccountId) return [];
+  return Array.isArray(cached) ? cached : [];
+}
+
+export function callerKeyFromAuth(authorization) {
+  const a = String(authorization || '').trim();
+  if (!a) return '';
+  // Not a secret store — a session-scoped equality key so a second oauth
+  // does not inherit the previous account's 1340 / tray cache.
+  let h = 2166136261;
+  for (let i = 0; i < a.length; i++) {
+    h ^= a.charCodeAt(i);
+    h = Math.imul(h, 16777619);
+  }
+  return (h >>> 0).toString(16);
+}

package/lib/pay.js

@@ -9,6 +9,7 @@ import { buildEvmPayment, evmTokenBalance } from './evm.js';
 import { privateKeyToAccount } from 'viem/accounts';
 import { withNamespace } from './namespace.js';
 import { fetchHeaders } from './fetch.js';
+import { withOnrampLink } from './stripeOnramp.js';
 
 /** Drop any inherited bearer — see the call site: x402 is the only pay lane. */
 function stripAuthorization(headers = {}) {
@@ -222,7 +223,14 @@ export class PayClient {
       // to convert and no pool to walk: the wallet either holds the asset or it
       // does not. This branch used to run resolvePool + poolState + a wrap
       // (~4.5s) to mint a Token-2022 twin the gateway no longer accepts.
-      if (bal.raw < need) throw new UnderfundedError(accept, bal.ui, this.address);
+      if (bal.raw < need) {
+        const usd = Number(accept?.extra?.billedUsd);
+        const line = await withOnrampLink(
+          `Send USDC (or TOKEN/LEOS) on Solana to ${this.address}.`,
+          { solana: this.address, usd },
+        );
+        throw new UnderfundedError(accept, bal.ui, this.address, { line });
+      }
       const built = await buildPaymentOnline(this.connection, this.keypair, accept);
       return { ...built, header: encodeEnvelope(paymentEnvelope(challenge, accept, built.payload)) };
     }
@@ -244,7 +252,10 @@ export class PayClient {
           const sym = accept?.extra?.symbol || 'the quoted asset';
           const where = rail === 'robinhood' ? 'Robinhood Chain' : rail === 'base' ? 'Base' : accept.network;
           throw new UnderfundedError(accept, null, owner, {
-            line: `Send a few cents of ${sym} on ${where} to ${owner}.`,
+            line: await withOnrampLink(
+              `Send a few cents of ${sym} on ${where} to ${owner}.`,
+              { solana: this.address, usd: Number(accept?.extra?.billedUsd) },
+            ),
           });
         }
       }
@@ -334,8 +345,11 @@ export class PayClient {
       if (!fundErrs.length && tooHigh) throw tooHigh;
       if (fundErrs.length === 1) throw fundErrs[0].err;
       throw new UnderfundedError(candidates[0], null, this.address, {
-        line: `No offered payment row is affordable from this wallet (tried ${fundErrs.length}):\n`
-          + fundErrs.map(({ sym, err }) => `  · ${sym}: ${err.message.replace(/^openzoo wallet underfunded: /, '')}`).join('\n'),
+        line: await withOnrampLink(
+          `No offered payment row is affordable from this wallet (tried ${fundErrs.length}):\n`
+            + fundErrs.map(({ sym, err }) => `  · ${sym}: ${err.message.replace(/^openzoo wallet underfunded: /, '')}`).join('\n'),
+          { solana: this.address, usd: Number(candidates[0]?.extra?.billedUsd) },
+        ),
       });
     }
     onStage?.('paying');

package/lib/proxy.js

@@ -8,6 +8,7 @@ import {
   config, FUNDING_ASSETS, EVM_FUNDING_ASSETS, evmRpcFor, fundingLine, liveRails, railFundingHint, railFundingAddresses, unfundableRails, RAIL_FUNDING,
 } from './config.js';
 import { PayClient, QuoteTooHighError, UnderfundedError } from './pay.js';
+import { withOnrampLink } from './stripeOnramp.js';
 import { tokenBalance } from './x402.js';
 import { evmTokenBalance } from './evm.js';
 import { autoContext } from './autobind.js';
@@ -760,15 +761,20 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
       // need: the price, what the wallet holds, and where to send funds.
       if (response.status === 402) {
         let quoted = '';
+        let usd;
         try {
           const q = await response.clone().json();
-          const usd = Number(q?.accepts?.[0]?.extra?.billedUsd);
+          usd = Number(q?.accepts?.[0]?.extra?.billedUsd);
           if (Number.isFinite(usd)) quoted = ` This call needs ≈$${usd.toFixed(4)}.`;
         } catch { /* body was not the quote after all */ }
-        jsonErr(res, 402,
+        const msg = await withOnrampLink(
           `openzoo wallet underfunded — payment did not settle.${quoted} `
           + `Fund it and retry: send USDC (or TOKEN/LEOS for half price) to ${client.address} on Solana, `
-          + `or USDC to ${client.evmAddress} on Base. Check with: openzoo balance`);
+          + `or USDC to ${client.evmAddress} on Base. Check with: openzoo balance`,
+          { solana: client.address, usd },
+        );
+        log(msg.includes('crypto.link.com') ? 'onramp: attached crypto.link.com' : 'onramp: no hosted URL');
+        jsonErr(res, 402, msg);
         return;
       }
       await relay(res, response, meterStreamed);
@@ -777,8 +783,11 @@ export async function startProxy({ silent = false, requireToken = null, sessionM
         log(err.message);
         jsonErr(res, 402, err.message, { quote: err.quote });
       } else if (err instanceof UnderfundedError) {
-        log(err.message);
-        jsonErr(res, 402, err.message);
+        const msg = await withOnrampLink(err.message, {
+          solana: client.address, usd: Number(err.accept?.extra?.billedUsd),
+        });
+        log(msg);
+        jsonErr(res, 402, msg);
       } else {
         // "fetch failed" alone is undiagnosable — undici hides the real
         // network error in `cause`. Surface it or every transport hiccup looks

package/lib/stripeOnramp.js

@@ -0,0 +1,92 @@
+/**
+ * Stripe-hosted fiat→USDC onramp (crypto.link.com) for the x402 402 path.
+ *
+ * Secret is NEVER in the repo: STRIPE_SECRET_KEY, else STRIPE_SECRET_FILE,
+ * else ~/stripey.key. Onramp sessions lock the destination to the local
+ * Solana burner so a card checkout lands USDC where PayClient spends.
+ *
+ * Solana-only: Stripe 400s `wallet_addresses[base]` (parameter_unknown),
+ * which silently dropped the hosted URL from live Grok 402 replies.
+ */
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+const STRIPE_VERSION = '2026-06-24.dahlia';
+const TTL_MS = 10 * 60 * 1000;
+const cache = new Map(); // key -> { url, at }
+
+function stripeSecret() {
+  const env = String(process.env.STRIPE_SECRET_KEY || '').trim();
+  if (env) return env;
+  const file = process.env.STRIPE_SECRET_FILE || path.join(os.homedir(), 'stripey.key');
+  return fs.readFileSync(file, 'utf8').trim();
+}
+
+function dollars(usd) {
+  const n = Number(usd);
+  if (!Number.isFinite(n) || n <= 0) return 10;
+  return Math.max(5, Math.ceil(n));
+}
+
+/** Test seam. */
+export function resetOnrampCache() { cache.clear(); }
+
+/**
+ * Mint (or reuse) a Stripe-hosted onramp URL that sends USDC to `solana`.
+ * Returns null if the key is missing or Stripe refuses — caller keeps the
+ * existing send-to-address copy. `evm` is ignored: Stripe does not accept
+ * `wallet_addresses[base]` on this API.
+ */
+export async function stripeUsdcOnrampLink({ solana, usd } = {}) {
+  const addr = String(solana || '').trim();
+  if (!addr) return null;
+  const amt = dollars(usd);
+  const key = `${addr}|${amt}`;
+  const hit = cache.get(key);
+  if (hit && Date.now() - hit.at < TTL_MS && hit.url) return hit.url;
+  let secret;
+  try { secret = stripeSecret(); } catch { return null; }
+  if (!secret) return null;
+  const body = new URLSearchParams();
+  body.set('destination_currency', 'usdc');
+  body.set('destination_network', 'solana');
+  body.append('destination_currencies[]', 'usdc');
+  body.append('destination_networks[]', 'solana');
+  body.set('source_currency', 'usd');
+  body.set('source_amount', String(amt));
+  body.set('lock_wallet_address', 'true');
+  body.set('wallet_addresses[solana]', addr);
+  try {
+    const r = await fetch('https://api.stripe.com/v1/crypto/onramp_sessions', {
+      method: 'POST',
+      headers: {
+        authorization: `Bearer ${secret}`,
+        'content-type': 'application/x-www-form-urlencoded',
+        'Stripe-Version': STRIPE_VERSION,
+      },
+      body,
+      signal: AbortSignal.timeout(15000),
+    });
+    const data = await r.json();
+    const url = data?.redirect_url;
+    if (!r.ok || !url) {
+      const err = data?.error;
+      console.error(`openzoo onramp: stripe ${r.status} ${err?.code || err?.type || 'no-url'} ${(err?.message || '').slice(0, 160)}`);
+      return null;
+    }
+    cache.set(key, { url, at: Date.now() });
+    return url;
+  } catch (e) {
+    console.error(`openzoo onramp: ${e.message}`);
+    return null;
+  }
+}
+
+export async function withOnrampLink(text, dest) {
+  const url = await stripeUsdcOnrampLink(dest);
+  const body = String(text || '').trim();
+  if (!url) return body;
+  if (body.includes(url) || /crypto\.link\.com/i.test(body)) return body;
+  return `Buy USDC: ${url}\n\n${body}`;
+}

package/package.json

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