openzoo 0.50.4 → 0.50.6

package/lib/autobind.js

@@ -0,0 +1,109 @@
+/**
+ * AUTO-BIND THE WORKING DIRECTORY.
+ *
+ * WHY THIS EXISTS, measured: a Claude Code session through the proxy reported
+ * `spilled 0/12 calls` and `0.67x vs direct` — i.e. it cost MORE than buying
+ * the same calls direct. That is not a pricing bug on its own. leCore only
+ * earns its markup when it removes context from the upstream request, and it
+ * can only remove context that was BOUND. Nothing was ever bound, so every call
+ * paid a multiple for a service that did no work.
+ *
+ * `bindPath()` and `collectFiles()` already existed. Nothing called them.
+ * `openzoo bind ./x` was a thing you had to know about and remember, which
+ * means in practice it never happened and the headline number stayed below 1.
+ *
+ * SO: bind the cwd on launch, in the background, and attach the resulting
+ * context to every forwarded call.
+ *
+ * NEVER $HOME. Binding a home directory means walking ~, dotfiles, caches,
+ * SSH keys and browser profiles into a corpus that leaves the machine. The
+ * home check is not a performance guard, it is the safety one — same for /, and
+ * for anywhere that is not actually a project.
+ *
+ * NON-BLOCKING BY CONSTRUCTION. The agent must start instantly; a bind of a
+ * large repo takes seconds to minutes. So this returns immediately, the bind
+ * runs in the background, and calls made before it lands simply go unbound —
+ * exactly what happens today. Nothing waits, nothing fails closed.
+ */
+import { existsSync, statSync } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+/** Set once the background bind lands. Read by the proxy on every forward. */
+let contextId = null;
+let state = 'idle';   // idle | binding | ready | skipped | failed
+let detail = '';
+
+export function autoContext() { return contextId; }
+export function autoBindState() { return { state, contextId, detail }; }
+
+/**
+ * Directories that must never be walked into a corpus.
+ *
+ * $HOME is the important one — see the module comment. The rest are the places
+ * where "bind the cwd" would mean "upload the machine".
+ */
+function refuseReason(dir) {
+  const home = os.homedir();
+  const resolved = path.resolve(dir);
+  if (resolved === path.resolve(home)) return 'cwd is $HOME';
+  if (resolved === path.parse(resolved).root) return 'cwd is the filesystem root';
+  if (resolved === '/tmp' || resolved === os.tmpdir()) return 'cwd is a temp dir';
+  // A project has SOMETHING that marks it. Without one of these, "the current
+  // directory" is just wherever the shell happened to be, and binding it is a
+  // surprise rather than a feature.
+  const marks = ['.git', 'package.json', 'Cargo.toml', 'go.mod', 'pyproject.toml',
+    'requirements.txt', 'Gemfile', 'pom.xml', 'build.gradle', 'CMakeLists.txt',
+    'composer.json', 'mix.exs', 'Makefile', 'CLAUDE.md', 'AGENTS.md'];
+  if (!marks.some((m) => existsSync(path.join(resolved, m)))) {
+    return 'no project marker (.git, package.json, …)';
+  }
+  return null;
+}
+
+/**
+ * Kick off a background bind of `dir`. Returns immediately.
+ *
+ * `log` is the caller's own writer so this never owns stdout — during a Claude
+ * Code session stdout belongs to the TUI, and a stray line corrupts it.
+ */
+export function startAutoBind(dir, { log = () => {} } = {}) {
+  if (process.env.OPENZOO_NO_AUTOBIND === '1') {
+    state = 'skipped'; detail = 'OPENZOO_NO_AUTOBIND=1';
+    return;
+  }
+  let target;
+  try {
+    target = path.resolve(dir || process.cwd());
+    if (!statSync(target).isDirectory()) { state = 'skipped'; detail = 'not a directory'; return; }
+  } catch { state = 'skipped'; detail = 'unreadable cwd'; return; }
+
+  const refuse = refuseReason(target);
+  if (refuse) { state = 'skipped'; detail = refuse; return; }
+
+  state = 'binding';
+  detail = target;
+
+  // Deliberately NOT awaited. See the module comment.
+  (async () => {
+    try {
+      const { bindPath } = await import('./bindpath.js');
+      const res = await bindPath(target, {});
+      const id = res?.contextId || res?.context_id || null;
+      if (id) {
+        contextId = id;
+        state = 'ready';
+        log(`auto-bound ${path.basename(target)} -> ${id}`);
+      } else {
+        state = 'failed';
+        detail = 'bind returned no context id';
+      }
+    } catch (err) {
+      // A failed bind must never take the session with it. Unbound calls are
+      // the status quo, not an outage.
+      state = 'failed';
+      detail = err?.message || String(err);
+      log(`auto-bind failed: ${detail}`);
+    }
+  })();
+}

package/lib/launch.js

@@ -402,6 +402,25 @@ export async function launchClaude(argv) {
       };
     } catch { /* HUD is best-effort */ }
 
+    // BIND THE WORKING DIRECTORY, IN THE BACKGROUND, BEFORE THE TUI STARTS.
+    //
+    // Measured on a live session: `spilled 0/12 calls`, `0.67x vs direct` — the
+    // proxy cost MORE than buying the same calls direct, because leCore can only
+    // remove context that was bound and nothing ever was. `openzoo bind` existed
+    // but you had to know about it, so in practice it never ran.
+    //
+    // Returns immediately; the bind runs in the background and calls made before
+    // it lands go unbound, which is exactly today's behaviour. Refuses $HOME and
+    // any directory with no project marker — see autobind.js for why that is a
+    // safety check and not a performance one. OPENZOO_NO_AUTOBIND=1 opts out.
+    try {
+      const { startAutoBind, autoBindState } = await import('./autobind.js');
+      startAutoBind(process.cwd(), { log: (m) => console.error(`openzoo: ${m}`) });
+      const st = autoBindState();
+      if (st.state === 'binding') console.error(`openzoo: binding ${st.detail} in the background…`);
+      else if (st.state === 'skipped') console.error(`openzoo: not auto-binding (${st.detail})`);
+    } catch { /* best-effort: never block the agent on a bind */ }
+
     // SKIP CLAUDE CODE'S FIRST-RUN WIZARD. openzoo needs no account and no key,
     // so the one thing standing between `openzoo claude` and a prompt is Claude
     // Code's own onboarding: theme picker, then the trust-this-folder dialog,

package/lib/proxy.js

@@ -10,6 +10,7 @@ import {
 import { PayClient, QuoteTooHighError, UnderfundedError } from './pay.js';
 import { tokenBalance } from './x402.js';
 import { evmTokenBalance } from './evm.js';
+import { autoContext } from './autobind.js';
 import { modelsListForRequest, isHarnessAliasId } from './models.js';
 import { withNamespace } from './namespace.js';
 import { loadSessionSpend, saveSessionSpend } from './session.js';
@@ -62,6 +63,19 @@ function upstreamHeaders(req) {
   for (const [k, v] of Object.entries(req.headers)) {
     if (!HOP_BY_HOP.has(k.toLowerCase())) out[k] = v;
   }
+  // ATTACH THE AUTO-BOUND CWD, if there is one and the caller did not name a
+  // context itself. Claude Code has no idea x402 or leCore exist and will never
+  // send this header, so without an injection here a background bind is dead
+  // weight — bound, paid for, never referenced. That is the state that produced
+  // `spilled 0/12 calls` and a sub-1.0 savings multiple.
+  //
+  // An explicit x-hrr-context ALWAYS wins: a caller naming a corpus is stating
+  // intent, and silently retargeting it at the cwd would answer from the wrong
+  // corpus — the exact failure REPLAY_KEY_HEADERS exists to keep apart.
+  if (!Object.keys(out).some((k) => k.toLowerCase() === 'x-hrr-context')) {
+    const ctx = autoContext();
+    if (ctx) out['x-hrr-context'] = ctx;
+  }
   // EVERY forwarded request carries this wallet's context namespace — binds
   // and the chats that reference them must land in the same tenant.
   return withNamespace(out);

package/package.json

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