openzoo 0.50.98 → 0.50.99

package/lib/cursorbackend.js

@@ -1088,28 +1088,30 @@ function handleLocalExecFrames(frames, log) {
     } else if (f.kind === 'file-error' || f.kind === 'messages-error') {
       w.reject(new Error(f.error || 'local-exec error'));
       localExecWaiters.delete(id);
-    } else if (f.kind === 'output' || f.kind === 'stdout' || f.kind === 'stderr') {
-      const norm = normalizeExecFrame(f);
-      const chunk = norm.stdout || norm.message
-        || (typeof f.data === 'string' ? f.data : '')
-        || (typeof f.chunk === 'string' ? f.chunk : '');
-      if (f.kind === 'stderr') w.stderr += toolResultText(chunk);
-      else w.chunks += toolResultText(chunk);
     } else if (shellStreamOf(f)) {
       // The real Grok Bot lane: stdout/stderr arrive as many `kind:"client"`
       // frames and the turn is only over on `exit`. Resolving on the first one
       // (what the old client/control branch did) truncated every command to its
       // first chunk.
       const ss = shellStreamOf(f);
-      if (typeof ss.stdout?.data === 'string') w.chunks += ss.stdout.data;
-      if (typeof ss.stderr?.data === 'string') w.stderr += ss.stderr.data;
-      if (ss.exit) {
+      // ShellStreamStdout/Stderr carry exactly one field, `data`.
+      const so = oneofCase(ss, 'stdout');
+      const se = oneofCase(ss, 'stderr');
+      if (typeof so?.data === 'string') w.chunks += so.data;
+      if (typeof se?.data === 'string') w.stderr += se.data;
+      const exit = oneofCase(ss, 'exit');
+      if (exit) {
         w.resolve({
           kind: 'exit',
           message: w.chunks || w.stderr,
           stdout: w.chunks,
           stderr: w.stderr,
-          exitCode: Number(ss.exit.code || 0),
+          exitCode: Number(exit.code || 0),
+          // The daemon spools a command's output to a terminal .txt under the
+          // hello frame's terminalsFolder and only names it here. Big or
+          // fast-finishing commands stream NO chunks at all, which is how
+          // `echo hi; pwd` came back as a bare `(exit 0)`.
+          outputPath: exitOutputPath(exit),
         });
         localExecWaiters.delete(id);
       }
@@ -1118,8 +1120,11 @@ function handleLocalExecFrames(frames, log) {
       // any other, so the generic branch below used to resolve the call with an
       // empty body the moment the daemon first breathed.
       continue;
-    } else if (f.kind === 'client' || f.kind === 'control' || f.kind === 'result'
-      || f.kind === 'exec-result' || f.kind === 'exit') {
+    } else if (f.kind === 'client' || f.kind === 'control') {
+      // The daemon's response schema is exactly: hello, client, control, file,
+      // file-error, messages-result, messages-error, ping. `result`,
+      // `exec-result`, `output`, `exit` were never wire kinds — reverse-
+      // engineered from dist/local-exec-daemon/main.cjs, 0.36.0.
       const norm = normalizeExecFrame(f);
       const stdout = w.chunks + (norm.stdout || '');
       const stderr = w.stderr + (norm.stderr || '');
@@ -1190,9 +1195,25 @@ function extractLocalPaths(text) {
   }
   return [...new Set(out)];
 }
+/**
+ * `~` is a path, not just a prefix.
+ *
+ * This matched `~/` ONLY, so a BARE `~` fell through untouched and every
+ * caller then hit the literal directory named "~". MEASURED 2026-09-03 from a
+ * user typing `ls -lha ~`: the model called `list_dir "~"` and the canvas
+ * answered `"~": No such file or directory (os error 2)`, twice, before
+ * giving up and running `ls -lha` in /Users instead — so the user asked for
+ * their home directory and was shown someone else's.
+ *
+ * Handles `~`, `~/x`, and (on Windows, where the model still emits unix-ish
+ * paths) `~\x`. A `~user` form is deliberately NOT expanded: guessing another
+ * account's home is worse than leaving the path alone.
+ */
 function expandUserPath(p) {
-  if (p.startsWith('~/')) return path.join(os.homedir(), p.slice(2));
-  return p;
+  const s = String(p ?? '');
+  if (s === '~') return os.homedir();
+  if (s.startsWith('~/') || s.startsWith('~\\')) return path.join(os.homedir(), s.slice(2));
+  return s;
 }
 
 /** Per-agent transcript. sendPrompt is async: accept immediately, zooComplete
@@ -1446,10 +1467,23 @@ export function restoreAgentWakeups(log = () => {}) {
   return ids.length;
 }
 
+/**
+ * What to call the machine the bot is driving.
+ *
+ * Both progress strings said "your Mac" unconditionally, so a Windows or Linux
+ * user watched the canvas narrate work on a Mac they do not own. The bot runs
+ * wherever node runs; the noun has to follow `process.platform`.
+ */
+export function hostNoun(platform = process.platform) {
+  if (platform === 'darwin') return 'Mac';
+  if (platform === 'win32') return 'PC';
+  return 'machine';
+}
+
 export function formatZooProgress({ step, maxSteps, names, command } = {}) {
   const tools = Array.isArray(names) ? names.filter(Boolean).join(', ') : String(names || 'tools');
   const cmd = command ? ` ${JSON.stringify(String(command).slice(0, 80))}` : '';
-  return `Working on your Mac (step ${Number(step) + 1}/${maxSteps || '?'}): ${tools}${cmd}`;
+  return `Working on your ${hostNoun()} (step ${Number(step) + 1}/${maxSteps || '?'}): ${tools}${cmd}`;
 }
 
 /** One canvas line per tool. Asar ingest is append-only — mutating a working
@@ -2275,11 +2309,27 @@ export function localExecFrame(command, cwd, timeoutMs = 120_000) {
 /** `agent.v1.ShellStream` off an ExecClientMessage: `{stdout:{data}}`,
  *  `{stderr:{data}}`, `{exit:{code, cwd}}`. `data` is a proto string (T=9), not
  *  bytes — no base64 decode. */
+/** protobuf-es serializes a oneof either as its field name (`{stdout:{…}}`,
+ *  what `toJson` emits) or as the runtime pair (`{case:"stdout",value:{…}}`)
+ *  when the object is passed straight to JSON.stringify. The daemon declares
+ *  `message` as an opaque any, so accept both at either level. */
+function oneofCase(node, name) {
+  if (!node || typeof node !== 'object') return null;
+  if (node[name] && typeof node[name] === 'object') return node[name];
+  if (node.case === name && node.value && typeof node.value === 'object') return node.value;
+  return null;
+}
+
 export function shellStreamOf(frame) {
-  const m = frame && frame.message;
-  if (!m || typeof m !== 'object') return null;
-  const ss = m.shellStream;
-  return ss && typeof ss === 'object' ? ss : null;
+  return oneofCase(frame && frame.message, 'shellStream');
+}
+
+/** `agent.v1.OutputLocation { file_path, size_bytes, line_count }`. protobuf-es
+ *  JSON is camelCase, but snake_case survives a raw passthrough. */
+export function exitOutputPath(exit) {
+  const loc = exit && (exit.outputLocation || exit.output_location);
+  const p = loc && (loc.filePath || loc.file_path);
+  return typeof p === 'string' && p ? p : '';
 }
 
 /** exec used to hardcode `/bin/zsh -lc`: on Linux that is usually ENOENT and on
@@ -2296,6 +2346,20 @@ export function execShell(command, platform = process.platform) {
   return { file: '/bin/sh', args: ['-c', command] };
 }
 
+/** Pull a command's spooled output back over the same SSE. The file sits under
+ *  the daemon's own terminalsFolder, so it is inside the local-exec root and
+ *  the download is not refused; a failure here is never fatal — the caller
+ *  still has the exit code. */
+async function localExecSpooledOutput(filePath, log = () => {}) {
+  try {
+    const got = await localExecAsk({ kind: 'download', path: filePath }, 20000);
+    return toolResultText(got.text || got.message || '');
+  } catch (e) {
+    log(`cursor-backend:      local-exec output spool ${filePath}: ${e.message}`);
+    return '';
+  }
+}
+
 async function execLocal(command, cwd, log) {
   let dir = cwd ? expandUserPath(cwd) : os.homedir();
   try {
@@ -2309,7 +2373,8 @@ async function execLocal(command, cwd, log) {
     // Daemon-side budget stays under our own wait so a slow command reports the
     // shell's error, not our generic "is Grok Bot Helper connected?".
     const got = await localExecAsk(localExecFrame(command, dir, 55_000), 60000);
-    const out = toolResultText(got.stdout || got.message || '');
+    let out = toolResultText(got.stdout || got.message || '');
+    if (!out && got.outputPath) out = await localExecSpooledOutput(got.outputPath, log);
     const errText = toolResultText(got.stderr);
     const err = errText ? `\nstderr:\n${errText}` : '';
     return `${out}${err}`.trim() || `(exit ${got.exitCode ?? 0})`;
@@ -2848,12 +2913,10 @@ async function runLocalTool(name, args, log, ctx = {}) {
       const abs = expandUserPath(args.path || os.homedir());
       try {
         if (localExecSse.size > 0) {
-          const got = await localExecAsk(localExecFrame(`ls -la ${JSON.stringify(abs)}`, os.homedir(), 40_000));
-          // `|| got` used to dump the whole resolved frame onto the canvas as
-          // JSON ({"kind":"exit","stdout":"", …}) whenever the listing came back
-          // empty. Fall back to the local read instead — it is the same answer.
-          const text = toolResultText(got.stdout || got.stderr || got.message).trim();
-          if (text) return text;
+          // Route through execLocal so a listing that the daemon spooled to a
+          // terminal file is fetched too, instead of painting an empty frame.
+          const text = String(await execLocal(`ls -la ${JSON.stringify(abs)}`, os.homedir(), log)).trim();
+          if (text && !/^\(exit \d+\)$/.test(text)) return text;
         }
         const rows = fs.readdirSync(abs, { withFileTypes: true })
           .map((e) => `${e.isDirectory() ? 'd' : '-'} ${e.name}`);
@@ -3160,7 +3223,7 @@ async function zooComplete(prompt, log, agentId, parsed = {}, opts = {}) {
     if (mediaKind) return await mediaTurn({ model, kind: mediaKind, prompt: spoken, log, onProgress: opts.onProgress, signal: opts.signal });
   }
   log(`cursor-backend:      zoo POST :8402 model=${model} helper=${helper ? localExecSse.size : 0} hist=${historyMessages(agentId, spoken).length}${chatOnly ? ` visitor=${visitor.shortname} chat-only` : ''} ${JSON.stringify((spoken || '').slice(0, 60))}`);
-  if (typeof opts.onProgress === 'function') opts.onProgress('Working on your Mac…');
+  if (typeof opts.onProgress === 'function') opts.onProgress(`Working on your ${hostNoun()}…`);
 
   const images = [];
   const textFiles = [];

package/package.json

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