openzoo 0.37.0 → 0.38.0

package/bin/openzoo.js

@@ -23,6 +23,9 @@ usage:
                                           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 grokbot         point Grok Bot / the grok CLI at the zoo — GROK MODELS ONLY,
+                              paid per call by x402 instead of xAI first-party billing,
+                              then launch it. --no-launch just writes the config.
   npx openzoo mcp        stdio MCP server (tools: zoo_ask, zoo_bind, zoo_models, zoo_wallet, zoo_contexts)
   npx openzoo unblock    restore the editor's own backend in the hosts file
   npx openzoo tunnel     public-url-only mode (everything key-gated, no keyless localhost)
@@ -68,6 +71,13 @@ async function main() {
       // GUI editors read config files, not env vars — see lib/setup.js.
       await (await import('../lib/setup.js')).setupEditor(cmd === 'editor' ? undefined : cmd, process.argv[3]);
       break;
+    case 'grokbot':
+    case 'grok':
+      // Grok Bot (com.anysphere.sand) fronts the `grok` CLI, and the CLI reads
+      // ~/.grok/config.toml — so pointing that model table at the local proxy
+      // is enough; no patching of the app bundle.
+      await (await import('../lib/grokbot.js')).setupGrokBot(process.argv.slice(3));
+      break;
     case 'mcp':
       await (await import('../lib/mcp.js')).startMcp();
       break;

package/lib/grokbot.js

@@ -0,0 +1,153 @@
+// `npx openzoo grokbot` — Grok Bot (xAI's agent app) on the zoo, Grok-only.
+//
+// WHAT GROK BOT IS: an Electron app, bundle id `com.anysphere.sand` (Anysphere,
+// the Cursor company) shipped as "Grok Bot". It fronts the `grok` CLI, and the
+// CLI is what reads ~/.grok/config.toml — which is why pointing the CLI's model
+// table at the local proxy is enough, with no patching of the app bundle.
+//
+// WHY GROK-ONLY: the point of running it on the zoo is x402 per-call billing
+// instead of first-party xAI billing, while keeping the product it is — a Grok
+// agent. So every model written here is an x-ai/* id and nothing else is
+// reachable from the picker.
+//
+// WHY THE LOCAL PROXY AND NOT x402-tokens.fly.dev: the gateway answers 402 on
+// every call by design. The proxy is the thing that builds and signs the
+// payment. Pointing base_url at the gateway makes every request fail
+// "payment required".
+
+import { spawn } from 'node:child_process';
+import { existsSync, readFileSync, writeFileSync, copyFileSync, mkdirSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+
+import { config } from './config.js';
+
+const GROK_HOME = process.env.GROK_HOME || join(homedir(), '.grok');
+const CONFIG_PATH = join(GROK_HOME, 'config.toml');
+const APP = '/Applications/Grok Bot.app';
+
+/** Grok ids as the zoo serves them. Verified against GET /v1/models at write
+ *  time so a renamed/retired model never lands in the picker as a dead row. */
+const FALLBACK_MODELS = [
+  { key: 'openzoo-grok-46', id: 'x-ai/grok-4.6', name: 'Grok 4.6 (openzoo)' },
+  { key: 'openzoo-grok-45', id: 'x-ai/grok-4.5', name: 'Grok 4.5 (openzoo)' },
+];
+
+/**
+ * TOML table keys cannot contain a bare dot — `[model.openzoo-grok-4.6]` parses
+ * as model -> "openzoo-grok-4" -> "6", silently producing a malformed entry
+ * with no `model` field. Slugify to keep the key flat.
+ */
+function slug(id) {
+  return 'openzoo-' + id.replace(/^x-ai\//, '').replace(/[^a-zA-Z0-9]+/g, '-').replace(/-+$/, '');
+}
+
+async function grokModels(base) {
+  try {
+    const r = await fetch(`${base}/models`, { signal: AbortSignal.timeout(8000) });
+    if (!r.ok) throw new Error(`models ${r.status}`);
+    const j = await r.json();
+    const rows = (j.data || [])
+      // VENDOR-PREFIXED IDS ONLY. The local proxy augments /v1/models with
+      // harness aliases ("grok-4", "openzoo-grok-4.6") so editors that validate
+      // a configured id upfront do not refuse to start. Those are routing
+      // conveniences, not catalog rows — writing them here would produce
+      // duplicate picker entries that all resolve to the same model.
+      .filter((m) => typeof m.id === 'string' && m.id.startsWith('x-ai/') && !m.kind)
+      .map((m) => ({ key: slug(m.id), id: m.id, name: `${m.id.replace(/^x-ai\//, 'Grok ')} (openzoo)` }));
+    return rows.length ? rows : FALLBACK_MODELS;
+  } catch {
+    // never write an empty picker because the catalog blipped
+    return FALLBACK_MODELS;
+  }
+}
+
+/** Strip the blocks we own so a re-run is idempotent, keeping everything else
+ *  (mcp_servers, plugins, marketplace, privacy, ui) exactly as the user had it. */
+function stripOurs(toml) {
+  const lines = toml.split('\n');
+  const out = [];
+  let skipping = false;
+  for (const line of lines) {
+    const header = line.match(/^\s*\[([^\]]+)\]\s*$/);
+    if (header) {
+      const name = header[1];
+      skipping = name === 'models' || name.startsWith('model.');
+    }
+    if (!skipping) out.push(line);
+  }
+  return out.join('\n').replace(/\n{3,}/g, '\n\n').trimEnd();
+}
+
+function renderModels(models, base) {
+  const def = models[0].key;
+  const body = models.map((m) => `[model.${m.key}]
+model = "${m.id}"
+base_url = "${base}"
+api_key = "openzoo"
+name = "${m.name}"`).join('\n\n');
+  return `
+# --- openzoo: Grok-only, paid per call by x402 -------------------------------
+# Written by \`npx openzoo grokbot\`. Re-running rewrites ONLY this block.
+# base_url is the LOCAL proxy: the public gateway 402s every call by design,
+# and the proxy is what signs the payment.
+[models]
+default = "${def}"
+
+${body}
+`;
+}
+
+export async function setupGrokBot(argv = []) {
+  const base = `http://localhost:${config.port}/v1`;
+  const launch = !argv.includes('--no-launch');
+
+  // 1. proxy up, or nothing can pay
+  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...');
+    const { startProxy } = await import('./proxy.js');
+    await startProxy({ silent: true, autoTunnel: true });
+    for (let i = 0; i < 25 && !up; i++) {
+      await new Promise((r) => setTimeout(r, 300));
+      try { up = (await fetch(`${base}/models`, { signal: AbortSignal.timeout(2000) })).ok; } catch { /* wait */ }
+    }
+    if (!up) { console.error(`openzoo: proxy did not come up on ${base}`); process.exit(1); }
+  }
+
+  const models = await grokModels(base);
+
+  // 2. rewrite ONLY our block, after a timestamped backup
+  if (!existsSync(GROK_HOME)) mkdirSync(GROK_HOME, { recursive: true });
+  let existing = '';
+  if (existsSync(CONFIG_PATH)) {
+    const backup = `${CONFIG_PATH}.bak-${Date.now()}`;
+    copyFileSync(CONFIG_PATH, backup);
+    existing = readFileSync(CONFIG_PATH, 'utf8');
+    console.error(`openzoo: backed up ${CONFIG_PATH} -> ${backup}`);
+  }
+  let next = stripOurs(existing);
+  // the fork/secondary model must ride the zoo too, or forks quietly bill xAI
+  // first-party while the main model is on openzoo
+  if (/^\s*fork_secondary_model\s*=/m.test(next)) {
+    next = next.replace(/^\s*fork_secondary_model\s*=.*$/m, `fork_secondary_model = "${models[0].key}"`);
+  }
+  writeFileSync(CONFIG_PATH, `${next}\n${renderModels(models, base)}`, 'utf8');
+
+  console.error(`openzoo: wrote ${models.length} Grok model(s) to ${CONFIG_PATH}`);
+  for (const m of models) console.error(`         ${m.key}  ->  ${m.id}`);
+  console.error(`openzoo: default = ${models[0].key} · all calls paid by x402 from your burner wallet`);
+
+  if (!launch) return;
+
+  // 3. launch the app if it exists, else the CLI
+  if (existsSync(APP)) {
+    console.error('openzoo: launching Grok Bot...');
+    spawn('open', ['-a', APP], { stdio: 'ignore', detached: true }).unref();
+  } else {
+    console.error('openzoo: Grok Bot.app not found — starting the `grok` CLI instead');
+    const p = spawn('grok', argv.filter((a) => a !== '--no-launch'), { stdio: 'inherit' });
+    p.on('exit', (c) => process.exit(c ?? 0));
+  }
+}

package/package.json

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