openzoo 0.50.21 → 0.50.23

package/lib/cursorbackend.js

@@ -289,7 +289,34 @@ const RESP_DROP = new Set([
 ]);
 
 const SNIFF_FILE = path.join(os.homedir(), '.openzoo', 'grokbot-sniff.jsonl');
-let realPod = null; // { agent, vnc, token, p1340, p6081, region, accountId, podId }
+const POD_FILE = path.join(os.homedir(), '.openzoo', 'grokbot-pod.json');
+function loadPod() {
+  try { return JSON.parse(fs.readFileSync(POD_FILE, 'utf8')); } catch { return 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 { /* */ }
+}
+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'));
+    return Array.isArray(a) ? a : null;
+  } catch { return null; }
+}
+function saveAgents(a) {
+  if (!Array.isArray(a) || !a.length) return;
+  try { fs.writeFileSync(AGENTS_FILE, JSON.stringify(a)); } catch { /* */ }
+}
+function cachedAgentList() {
+  const a = loadAgents();
+  if (a?.length) return a;
+  return null;
+}
 
 function sniffOn() { return process.env.OPENZOO_SNIFF === '1'; }
 function sniffSelf() { return process.env.OZ_SNIFF_SELF || 'https://127.0.0.1:8443'; }
@@ -446,6 +473,7 @@ function rememberPod(fields, log) {
     podId: String(fields[3] || ''),
   };
   sniffDump({ kind: 'pod', fields, realPod });
+  savePod(realPod);
   log(`cursor-backend:      SNIFF real pod ${realPod.agent}`);
   return realPod;
 }
@@ -470,7 +498,7 @@ async function sniffEnsureSandBox(req, res, body, host, full, log) {
   const upstream = cursorUpstream(host);
   const headers = copyReqHeaders(req, upstream);
   const cap = await upstreamUnary({
-    host: upstream, path: full, method: req.method, headers, body, timeoutMs: 30000,
+    host: upstream, path: full, method: req.method, headers, body, timeoutMs: 60000,
   });
   const raw = inflateBody(cap.buf, cap.respHeaders);
   const proto = unwrapConnect(raw);
@@ -564,6 +592,26 @@ async function proxyPodHttp(req, res, full, body, log) {
       body,
       timeoutMs: path0 === '/health' ? 8000 : 120000,
     });
+    if (path0 === '/api/listAgents' && cap.status === 200) {
+      try {
+        const parsed = JSON.parse(String(inflateBody(cap.buf, cap.respHeaders)));
+        if (Array.isArray(parsed)) {
+          const merged = mergeAgentLists(parsed);
+          saveAgents(merged);
+          jsonSend(res, merged);
+          log(`cursor-backend:      listAgents 200 merged n=${merged.length}`);
+          return true;
+        }
+      } catch { /* */ }
+    }
+    if (cap.status === 401 && path0 === '/api/listAgents') {
+      const cached = mergeAgentLists([]);
+      if (cached.length) {
+        jsonSend(res, cached);
+        log(`cursor-backend:      listAgents 401 — cached ${cached.length} named agents`);
+        return true;
+      }
+    }
     writeCaptured(res, cap.status, cap.respHeaders, cap.buf);
     const rec = {
       kind: 'pod-http',
@@ -723,9 +771,33 @@ function expandUserPath(p) {
 const transcripts = new Map();
 const tailedAgents = new Set();
 let lastSendEchoId = `oz-${Date.now()}`;
+const TX_FILE = path.join(os.homedir(), '.openzoo', 'grokbot-transcripts.json');
+function loadTranscripts() {
+  try {
+    const o = JSON.parse(fs.readFileSync(TX_FILE, 'utf8'));
+    for (const [id, t] of Object.entries(o || {})) {
+      transcripts.set(id, {
+        seq: Number(t.seq) || (t.entries || []).length,
+        entries: Array.isArray(t.entries) ? t.entries : [],
+        pulledRemote: false,
+      });
+    }
+  } catch { /* first run */ }
+}
+function saveTranscripts() {
+  try {
+    const o = {};
+    for (const [id, t] of transcripts) {
+      o[id] = { seq: t.seq, entries: t.entries.slice(-200) };
+    }
+    fs.mkdirSync(path.dirname(TX_FILE), { recursive: true });
+    fs.writeFileSync(TX_FILE, JSON.stringify(o));
+  } catch { /* */ }
+}
+loadTranscripts();
 function agentTranscript(id) {
   let t = transcripts.get(id);
-  if (!t) { t = { seq: 0, entries: [] }; transcripts.set(id, t); }
+  if (!t) { t = { seq: 0, entries: [], pulledRemote: false }; transcripts.set(id, t); }
   return t;
 }
 function appendLine(agentId, role, text, extra = {}) {
@@ -761,18 +833,108 @@ function appendLine(agentId, role, text, extra = {}) {
     };
   }
   t.entries.push(e);
+  saveTranscripts();
   return e;
 }
 function fanoutLine(primaryId, role, text, extra = {}) {
-  const ids = new Set([primaryId, ...tailedAgents]);
-  let last = null;
-  for (const id of ids) last = appendLine(id, role, text, extra);
-  return last;
+  // Only the addressed agent. Writing to every tailedAgents id mixed canvases
+  // so a new/empty chat showed someone else's thread.
+  return appendLine(primaryId, role, text, extra);
+}
+function mintLocalAgent(parsed = {}) {
+  const id = String(parsed.id || randomUUID());
+  const name = String(parsed.name || parsed.title || 'new chat');
+  const agent = {
+    id,
+    name,
+    description: String(parsed.description || ''),
+    title: String(parsed.title || name),
+    origin: parsed.origin || 'user',
+    createdAt: Date.now(),
+    updatedAt: Date.now(),
+    avatarShape: parsed.avatarShape || null,
+    avatarColor: parsed.avatarColor || null,
+    path: `/local/${id}`,
+  };
+  const list = cachedAgentList() || [];
+  if (!list.some((a) => a.id === id)) list.unshift(agent);
+  else {
+    const i = list.findIndex((a) => a.id === id);
+    list[i] = { ...list[i], ...agent };
+  }
+  saveAgents(list);
+  agentTranscript(id);
+  return agent;
+}
+function mergeAgentLists(remote) {
+  const local = cachedAgentList() || [];
+  const seen = new Set();
+  const out = [];
+  for (const a of [...local, ...(Array.isArray(remote) ? remote : [])]) {
+    if (!a?.id || seen.has(a.id)) continue;
+    seen.add(a.id);
+    out.push(a);
+  }
+  return out;
 }
 function gatewayEntry(e) {
-  const { seq, ...rest } = e;
+  const { seq, pulledRemote, ...rest } = e;
   return rest;
 }
+async function podJson(path0, bodyObj, log) {
+  if (!realPod?.agent) return null;
+  let agent;
+  try { agent = new URL(realPod.agent); } catch { return null; }
+  const headers = {
+    'content-type': 'application/json',
+    accept: 'application/json',
+    authorization: `Bearer ${realPod.accessToken || realPod.token || ''}`,
+    'x-anyrun-network-token': realPod.token || '',
+    'x-sand-slim-avatars': '1',
+  };
+  try {
+    const cap = await upstreamUnary({
+      host: agent.hostname,
+      path: path0,
+      method: 'POST',
+      headers,
+      body: Buffer.from(JSON.stringify(bodyObj || {})),
+      timeoutMs: 20000,
+    });
+    if (cap.status !== 200) {
+      log(`cursor-backend:      podJson ${path0} ${cap.status}`);
+      return null;
+    }
+    const raw = inflateBody(cap.buf, cap.respHeaders);
+    return JSON.parse(String(raw));
+  } catch (e) {
+    log(`cursor-backend:      podJson ${path0} ${e.message}`);
+    return null;
+  }
+}
+function ingestRemoteEntries(agentId, entries) {
+  if (!Array.isArray(entries) || !entries.length) return 0;
+  const t = agentTranscript(agentId);
+  const have = new Set(t.entries.map((e) => e.id || e.clientNonce || '').filter(Boolean));
+  const incoming = [];
+  for (const e of entries) {
+    if (!e || typeof e !== 'object') continue;
+    const k = e.id || e.clientNonce || '';
+    if (k && have.has(k)) continue;
+    incoming.push(e);
+  }
+  if (!incoming.length) return 0;
+  const local = t.entries;
+  t.entries = [];
+  t.seq = 0;
+  for (const e of [...incoming, ...local]) {
+    t.seq += 1;
+    const { seq: _s, ...rest } = e;
+    t.entries.push({ ...rest, seq: t.seq });
+  }
+  saveTranscripts();
+  return incoming.length;
+}
 
 function promptFromSendBody(raw) {
   let obj = raw;
@@ -1223,12 +1385,56 @@ async function handleHijackedPodHttp(req, res, full, body, log) {
     'getBotTemplateExportPolicy', 'getTeachRecordingStatus', 'isGlobalSearchEnabled',
     'isEgressTunnelAvailable', 'listBoxMcpServers', 'getHostStatus',
     'setWindowFocused', 'getAgentAutomations',
-    'createAgent', 'createAgentFromTemplate', 'createGroup', 'setGroupMembers',
-    'updateAgent', 'deleteAgents', 'duplicateAgent', 'kickstartAgent',
+    'createGroup', 'setGroupMembers',
     'interruptAgentRun', 'requestDiskSaverAudit', 'broadcastToAgents',
     'setAgentUnread', 'setAgentHiddenFromSidebar', 'setAgentNotificationsEnabled',
     'setAgentNotifyOnUpdates', 'setAgentAvatarBytes', 'getAgentAvatar',
   ]);
+  // create/delete stay LOCAL — 1340 createAgent 401s on a stale cached token
+  // and the UI then never grows a sidebar row or clears the canvas.
+  if (name === 'createAgent' || name === 'createAgentFromTemplate' || name === 'duplicateAgent') {
+    let parsed = {};
+    try { parsed = JSON.parse(String(body || '{}')); } catch { parsed = {}; }
+    if (name === 'duplicateAgent' && parsed.id) {
+      const src = (cachedAgentList() || []).find((a) => a.id === parsed.id) || {};
+      parsed = { ...src, id: undefined, name: `${src.name || 'chat'} copy` };
+    }
+    const agent = mintLocalAgent(parsed);
+    jsonSend(res, { agent, id: agent.id, ...agent });
+    ssePush('agents', { action: 'created', agent });
+    log(`cursor-backend:      createAgent local id=${agent.id} name=${JSON.stringify(agent.name)}`);
+    return true;
+  }
+  if (name === 'updateAgent') {
+    let parsed = {};
+    try { parsed = JSON.parse(String(body || '{}')); } catch { parsed = {}; }
+    const agent = mintLocalAgent(parsed);
+    jsonSend(res, { agent, ...agent });
+    log(`cursor-backend:      updateAgent local id=${agent.id}`);
+    return true;
+  }
+  if (name === 'deleteAgents') {
+    let parsed = {};
+    try { parsed = JSON.parse(String(body || '{}')); } catch { parsed = {}; }
+    const ids = new Set([].concat(parsed.ids || parsed.id || []).map(String));
+    const next = (cachedAgentList() || []).filter((a) => !ids.has(a.id));
+    saveAgents(next);
+    for (const id of ids) transcripts.delete(id);
+    jsonSend(res, { ok: true, deleted: [...ids] });
+    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;
+    }
+    const list = mergeAgentLists([]);
+    jsonSend(res, list);
+    log(`cursor-backend:      listAgents local n=${list.length}`);
+    return true;
+  }
+
   if (!sniffOn() && realPod?.agent && roster.has(name)) {
     return proxyPodHttp(req, res, full, body, log);
   }
@@ -1289,24 +1495,25 @@ async function handleHijackedPodHttp(req, res, full, body, log) {
   if (name === 'getAgentTranscriptTail' || name === 'getAgentTranscriptWindow' || name === 'openAgentTail') {
     let parsed = {};
     try { parsed = JSON.parse(String(body || '{}')); } catch { parsed = {}; }
-    let id = String(parsed.id || parsed.agentId || 'openzoo');
+    const id = String(parsed.id || parsed.agentId || 'openzoo');
     tailedAgents.add(id);
-    let t = agentTranscript(id);
-    if (!t.entries.length) {
-      for (const [other, ot] of transcripts) {
-        if (ot.entries.length) { id = other; t = ot; break; }
-      }
+    const t = agentTranscript(id);
+    if (!t.pulledRemote && realPod?.agent) {
+      const remote = await podJson('/api/getAgentTranscriptTail', {
+        id, agentId: id, limit: 200, beforeSeq: parsed.beforeSeq,
+      }, log);
+      const n = ingestRemoteEntries(id, remote?.entries);
+      t.pulledRemote = true;
+      if (n) log(`cursor-backend:      hydrated ${id} +${n} from 1340`);
     }
+    const t2 = agentTranscript(id);
     const limit = Math.min(Number(parsed.limit) || 50, 200);
     const before = parsed.beforeSeq != null ? Number(parsed.beforeSeq) : Infinity;
-    const sliced = t.entries.filter((e) => e.seq < before).slice(-limit);
+    const sliced = t2.entries.filter((e) => e.seq < before).slice(-limit);
     const page = { entries: sliced.map(gatewayEntry) };
-    if (t.entries.length > sliced.length && sliced.length) page.nextBeforeSeq = sliced[0].seq;
-    // Live pod returns RAW {entries, nextBeforeSeq} — no CVr envelope
-    // (measured 1340 getAgentTranscriptTail 2026-08-29). Wrapping {status,value}
-    // made transcript-page validation fail and the canvas stayed empty.
+    if (t2.entries.length > sliced.length && sliced.length) page.nextBeforeSeq = sliced[0].seq;
     jsonSend(res, page);
-    log(`cursor-backend:      -> transcript ${id} n=${sliced.length}/${t.seq}`);
+    log(`cursor-backend:      -> transcript ${id} n=${sliced.length}/${t2.seq}`);
     return true;
   }
   if (name === 'promptAcceptanceStatus') {
@@ -1334,7 +1541,8 @@ async function handleHijackedPodHttp(req, res, full, body, log) {
     getHostSettings: { settings: {} },
     setHostSettings: { ok: true },
     setBoxSecrets: { ok: true },
-    listAgents: [...new Set([...transcripts.keys(), ...tailedAgents])].map((id) => ({ id, name: id, status: 'ready' })),
+    listAgents: cachedAgentList()
+      || [...new Set([...transcripts.keys(), ...tailedAgents])].map((id) => ({ id, name: id, status: 'ready' })),
     getAgentTranscriptTail: { tail: '', lines: [], dropped: false, ok: true },
     getTeachRecordingStatus: { recording: false },
     getTrays: { trays: [] },
@@ -1551,25 +1759,31 @@ 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) {
-        if (/WatchSandBoxMigration/.test(full) && realPod) {
-          const payload = rewrittenBox();
-          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, real roster)');
-          return;
-        }
         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)');
           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;

package/lib/grokcli.js

@@ -177,8 +177,10 @@ export async function runBot(argv = []) {
     console.error('         EnsureSandBox HIJACKED here; StreamUnifiedChat -> :8402 (x402)');
   }
 
-  try { execSync('osascript -e \'tell application "Grok Bot" to quit\'', { stdio: 'ignore' }); } catch { /* ok */ }
-  await new Promise((r) => setTimeout(r, 1500));
+  if (!argv.includes('--no-quit') && process.env.OZ_NO_QUIT !== '1') {
+    try { execSync('osascript -e \'tell application "Grok Bot" to quit\'', { stdio: 'ignore' }); } catch { /* ok */ }
+    await new Promise((r) => setTimeout(r, 1500));
+  }
 
   console.error('openzoo: launching Grok Bot');
   console.error(`         CURSOR_API_BASE_URL=${url}`);

package/package.json

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