openzoo 0.29.9 → 0.30.1

package/bin/openzoo.js

@@ -19,6 +19,8 @@ usage:
                                          only "Auto". Undo: npx openzoo unblock
   npx openzoo vscode [path]   same, for VS Code
   npx openzoo editor [path]   whichever is installed (Cursor wins if both)
+  npx openzoo claude [dir] [--terminal]   launch Claude on the zoo — desktop app
+                                          by default, --terminal for the Claude Code CLI
   npx openzoo launch <cmd> [args]   launch a TERMINAL Messages API client
                                     (claude, aider...) already pointed at the zoo
   npx openzoo mcp        stdio MCP server (tools: zoo_ask, zoo_bind, zoo_models, zoo_wallet, zoo_contexts)
@@ -69,6 +71,9 @@ async function main() {
     case 'mcp':
       await (await import('../lib/mcp.js')).startMcp();
       break;
+    case 'claude':
+      await (await import('../lib/launch.js')).launchClaude(process.argv.slice(3));
+      break;
     case 'launch': {
       const rest = process.argv.slice(3);
       const [harness, hargs] = [rest[0], rest.slice(1)];

package/lib/cursorapi.js

@@ -92,6 +92,59 @@ export function encodeAvailableModels(models) {
   return b.done();
 }
 
+/**
+ * ENTITLEMENT RESPONSES. Measured from the backend log: once the transport works
+ * (NODE_TLS_REJECT_UNAUTHORIZED=0), the editor calls a set of DashboardService/
+ * AiService gRPC methods to decide the plan. Returning EMPTY reads as free tier —
+ * the "upgrade" prompt. These populate the exact protobuf shapes (read from the
+ * editor's own bundle) with an active pro plan and a real identity.
+ */
+
+// GetPlanInfoResponse{ 1 plan_info: PlanInfo{ 1 plan_name, 2 included_amount_cents, 5 plan_owner } }
+export function encodeGetPlanInfo() {
+  const planInfo = new Buf()
+    .str(1, 'pro')          // plan_name
+    .int(2, 99999900)       // included_amount_cents (huge headroom)
+    .int(5, 1);             // plan_owner = PLAN_OWNER_STRIPE
+  return new Buf().msg(1, planInfo).done();
+}
+
+// GetMeResponse{ 1 auth_id, 2 user_id, 3 email, 9 is_enterprise_user }
+export function encodeGetMe() {
+  return new Buf()
+    .str(1, 'openzoo-user')
+    .int(2, 1)
+    .str(3, 'user@openzoo.local')
+    .bool(9, false)
+    .done();
+}
+
+// GetDefaultModelResponse{ 1 model, 2 thinking_model, 3 max_mode, 4 next_default_set_date }
+export function encodeGetDefaultModel(models) {
+  const m = (models && models[0] && models[0].name) || 'gpt-4o';
+  return new Buf().str(1, m).str(2, m).bool(3, false).str(4, '').done();
+}
+
+// IsOnNewPricingResponse{ 1 is_on_new_pricing, 2 is_opted_out, 3 has_auto_spillover, 5 ... }
+export function encodeIsOnNewPricing() {
+  return new Buf().bool(1, false).bool(2, false).bool(3, false).bool(5, false).done();
+}
+
+/**
+ * The bare proto body for a method, or null to fall through to empty-ok.
+ * Only the methods that gate entitlement or the model list are populated.
+ */
+export function encodeForMethod(method, models) {
+  switch (method) {
+    case 'AvailableModels': return encodeAvailableModels(models);
+    case 'GetPlanInfo': return encodeGetPlanInfo();
+    case 'GetMe': return encodeGetMe();
+    case 'GetDefaultModel': return encodeGetDefaultModel(models);
+    case 'IsOnNewPricing': return encodeIsOnNewPricing();
+    default: return null;
+  }
+}
+
 /** Connect unary framing: 5-byte prefix (flags + big-endian length) + payload. */
 export function connectFrame(payload) {
   const head = Buffer.alloc(5);

package/lib/cursorbackend.js

@@ -31,7 +31,7 @@ import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
 import { execFileSync } from 'node:child_process';
-import { encodeAvailableModels } from './cursorapi.js';
+import { encodeAvailableModels, encodeForMethod } from './cursorapi.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'];
@@ -134,7 +134,7 @@ function respond(req, res, method, models) {
     return;
   }
 
-  const bodyProto = method === 'AvailableModels' ? encodeAvailableModels(models) : Buffer.alloc(0);
+  const bodyProto = encodeForMethod(method, models) || Buffer.alloc(0);
 
   if (isJson) {
     // Connect unary JSON. AvailableModels as JSON; everything else an empty object.
@@ -196,8 +196,10 @@ export function startCursorBackend({ port = 8443, models, log = () => {} } = {})
       log(`cursor-backend: #${conns} ${req.method} ${full}  ct=${ct}  body=${body.length}b`);
       try {
         respond(req, res, method, models);
+        const populated = ['GetPlanInfo', 'GetMe', 'GetDefaultModel', 'IsOnNewPricing'];
         const what = /stripe|membership|subscription/i.test(full) ? 'ENTITLED stripe profile'
           : method === 'AvailableModels' ? `AvailableModels (${models.length} models, gates open)`
+          : populated.includes(method) ? `${method} (PRO/entitled)`
           : req.method === 'OPTIONS' ? 'CORS preflight 204'
           : 'empty-ok';
         log(`cursor-backend:      -> ${what}`);

package/lib/launch.js

@@ -10,8 +10,90 @@
  * (`npx openzoo` in another terminal); we check first and say so if not.
  */
 import { spawn } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
 import { config } from './config.js';
 
+/** Resolve the Claude DESKTOP app binary, platform-agnostically. Spawn the
+ *  binary directly (not `open -a`) so the env — ANTHROPIC_BASE_URL — survives;
+ *  macOS `open` hands off to launchd and drops it. */
+function resolveClaudeDesktop() {
+  const bundles = [
+    '/Applications/Claude.app/Contents/MacOS/Claude',
+    path.join(os.homedir(), 'Applications', 'Claude.app', 'Contents', 'MacOS', 'Claude'),
+  ];
+  for (const b of bundles) { try { fs.accessSync(b, fs.constants.X_OK); return b; } catch { /* next */ } }
+  // Linux/Windows or PATH install.
+  for (const dir of (process.env.PATH || '').split(path.delimiter)) {
+    for (const n of ['claude-desktop', 'Claude']) {
+      const f = path.join(dir, n + (process.platform === 'win32' ? '.exe' : ''));
+      try { fs.accessSync(f, fs.constants.X_OK); return f; } catch { /* next */ }
+    }
+  }
+  return null;
+}
+
+/** Resolve the Claude Code TERMINAL CLI. */
+function resolveClaudeCli() {
+  for (const dir of (process.env.PATH || '').split(path.delimiter)) {
+    const f = path.join(dir, 'claude' + (process.platform === 'win32' ? '.cmd' : ''));
+    try { fs.accessSync(f, fs.constants.X_OK); return f; } catch { /* next */ }
+  }
+  return null;
+}
+
+/**
+ * `npx openzoo claude [dir] [--terminal]` — launch Claude on the zoo.
+ * DEFAULT is the desktop app; `--terminal` (or `-t`) runs the Claude Code CLI.
+ * Both get ANTHROPIC_BASE_URL so inference pays x402.
+ */
+export async function launchClaude(argv) {
+  const base = `http://localhost:${config.port}/v1`;
+  // AUTO-START THE PROXY. One command should just work — if nothing is listening,
+  // boot the proxy in THIS process (it stays alive because claude runs in the
+  // foreground below), rather than making the user run `npx openzoo` first.
+  let up = false;
+  try { up = (await fetch(`${base}/models`, { signal: AbortSignal.timeout(3000) })).ok; } catch { up = false; }
+  if (!up) {
+    console.error('openzoo: starting the proxy in the background...');
+    const { startProxy } = await import('./proxy.js');
+    await startProxy({ silent: true, autoTunnel: true });
+    for (let i = 0; i < 20 && !up; i++) {
+      await new Promise((r) => setTimeout(r, 300));
+      try { up = (await fetch(`${base}/models`, { signal: AbortSignal.timeout(2000) })).ok; } catch { /* keep waiting */ }
+    }
+    if (!up) { console.error(`openzoo: proxy did not come up on ${base}`); process.exit(1); }
+  }
+  const terminal = argv.includes('--terminal') || argv.includes('-t');
+  const rest = argv.filter((a) => a !== '--terminal' && a !== '-t');
+  const env = {
+    ...process.env,
+    ANTHROPIC_BASE_URL: base,
+    ANTHROPIC_API_KEY: process.env.ANTHROPIC_API_KEY || 'sk-openzoo',
+    ANTHROPIC_AUTH_TOKEN: process.env.ANTHROPIC_AUTH_TOKEN || 'sk-openzoo',
+  };
+
+  if (terminal) {
+    const cli = resolveClaudeCli();
+    if (!cli) { console.error('openzoo: `claude` CLI not found on PATH — install Claude Code, or drop --terminal for the desktop app'); process.exit(1); }
+    console.error(`openzoo: Claude Code (terminal) on the zoo — every turn pays x402`);
+    const child = spawn(cli, rest, { stdio: 'inherit', env });
+    child.on('exit', (c) => process.exit(c ?? 0));
+    child.on('error', (e) => { console.error(`openzoo: could not launch claude: ${e.message}`); process.exit(1); });
+    return;
+  }
+
+  const app = resolveClaudeDesktop();
+  if (!app) { console.error('openzoo: Claude desktop app not found — use `npx openzoo claude --terminal` for the CLI'); process.exit(1); }
+  console.error(`openzoo: Claude desktop on the zoo (ANTHROPIC_BASE_URL=${base})`);
+  console.error('         note: the desktop app routes through the zoo only if it honours ANTHROPIC_BASE_URL;');
+  console.error('         --terminal (Claude Code CLI) is the guaranteed-x402 path.');
+  const child = spawn(app, rest, { stdio: 'ignore', env, detached: true });
+  child.on('error', (e) => console.error(`openzoo: could not launch Claude desktop: ${e.message}`));
+  child.unref();
+}
+
 export async function launchHarness(cmd, args) {
   const base = `http://localhost:${config.port}/v1`;
   // Fail early with a clear message rather than letting the harness spew

package/package.json

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