openzoo 0.50.54 → 0.50.55

package/lib/cursorbackend.js

@@ -52,6 +52,7 @@ import {
 import {
   desktopAction, displayBounds, imageSize, noteShotMeta, resolveAppName,
 } from './grokbotDesktop.js';
+import { startHostMcps, hostMcpTools, hostMcpHas, callHostMcp, hostMcpServers } from './mcpbridge.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'];
@@ -2174,6 +2175,11 @@ const LOCAL_TOOLS = [
 
 export const LOCAL_TOOL_NAMES = LOCAL_TOOLS.map((t) => t.function.name);
 
+function liveTools() {
+  const extra = hostMcpTools();
+  return extra.length ? [...LOCAL_TOOLS, ...extra] : LOCAL_TOOLS;
+}
+
 async function captureScreenshot(log) {
   const dir = path.join(os.tmpdir(), 'openzoo-screens');
   fs.mkdirSync(dir, { recursive: true });
@@ -2361,6 +2367,9 @@ async function runLocalTool(name, args, log, ctx = {}) {
       if (!who) return 'ERROR no such agent';
       return JSON.stringify(cancelAgentWakeup(who.id));
     }
+    if (hostMcpHas(name)) {
+      return await callHostMcp(name, args);
+    }
     return `unknown tool ${name}`;
   } catch (e) {
     return `ERROR ${e.message}`;
@@ -2458,10 +2467,25 @@ async function zooComplete(prompt, log, agentId, parsed = {}, opts = {}) {
           })(),
           `You HAVE local tools on the user's computer via ${via}.`,
           'Tools: read_file, write_file, exec, list_dir, screenshot, click, type_text, key, ui_tree, focus_app, open_url, create_agent, set_brief, list_agents, message_agent, schedule_wakeup, cancel_wakeup.',
+          (() => {
+            const extra = hostMcpTools();
+            const names = extra.map((t) => t.function.name);
+            const servers = hostMcpServers();
+            if (!names.length) {
+              return 'Host MCP servers (Claude/Grok chrome-devtools, brave, …) are connecting. When chrome-devtools__* tools appear, use them for web pages.';
+            }
+            const chrome = names.filter((n) => /chrome|devtools|browser/i.test(n));
+            return [
+              `Host MCP tools from the user's local Claude/Grok config are attached (${servers.join(', ') || 'mcp'}): ${names.slice(0, 36).join(', ')}${names.length > 36 ? '…' : ''}.`,
+              chrome.length
+                ? 'For any web page or HTML form, use chrome-devtools tools (navigate_page / take_snapshot / fill / click). Do NOT use osascript, Quartz, Python Foundation, or AppleScript to read Brave. screenshot/click/type_text are for native Mac UI only.'
+                : 'Use matching MCP tools instead of inventing shell one-liners.',
+            ].join(' ');
+          })(),
           'create_agent mints a sidebar bot. ALWAYS pass brief so they keep the job across restart. set_brief updates it. list_agents + message_agent talk to other bots (one hop). Do not tell the human to copy-paste between canvases.',
           'NEVER STOP / cron / keep working between human messages: call schedule_wakeup every="5m". That is a host timer. There is no crontab. Do not spawn more bots for persistence. Do not re-read SITREP-NOW.md or STANDING-ORDERS.md every turn — do the next file or click. exec sysctl/uptime is not the job. If the tray already has named workers, answer "no" to spawning more.',
           'You CAN click the Mac and fill/submit browser forms. That is required when the user asks. Do not write a markdown briefing instead of clicking. Do not tell the user to click.',
-          'Form loop: focus_app Brave Browser → screenshot → click the field (query or x,y) → type_text → screenshot to confirm → click Submit / key enter. screenshot.screen is click coordinate space. Prefer click query="Submit".',
+          'Form loop: if chrome-devtools MCP tools exist, navigate_page + take_snapshot + fill the fields + click the submit button. Else fallback: focus_app Brave Browser → screenshot → click the field → type_text → screenshot → click Submit.',
           'screenshot captures the display and attaches the image. For any on-screen form, dashboard, or click target, screenshot first this turn. Do not guess at UI you have not seen.',
           'Pasted images arrive as attachments — you can see them when present. Do not claim you cannot see images if they are in this turn.',
           'Never claim you lack filesystem access or local-exec. If a tool errors, report the error.',
@@ -2560,7 +2584,7 @@ async function zooComplete(prompt, log, agentId, parsed = {}, opts = {}) {
     throwIfAborted();
     const payload = { model, messages, max_tokens: maxTok };
     if (!chatOnly) {
-      payload.tools = LOCAL_TOOLS;
+      payload.tools = liveTools();
       payload.tool_choice = 'auto';
     }
     const { r, data } = await zooPost(payload);
@@ -3463,6 +3487,7 @@ export function startCursorBackend({ port = 8443, models, log = () => {} } = {})
   // the platform refuses (v6 disabled), fall back to v4 so we still work.
   server.on('error', (e) => log(`cursor-backend: server error ${e.code || e.message}`));
   const onUp = (what) => log(`cursor-backend: listening on ${what}:${port} as ${CURSOR_HOSTS[0]}`);
+  startHostMcps({ log }).catch((e) => log(`cursor-backend:      mcp start ${e.message}`));
   try {
     server.listen({ port, host: '::', ipv6Only: false }, () => onUp('[::]+127.0.0.1'));
   } catch {

package/lib/mcpbridge.js

@@ -0,0 +1,350 @@
+/**
+ * Load the operator's local MCP servers (Grok / Claude / Cursor) and expose
+ * them as OpenAI function tools for Grok Bot zoo turns.
+ *
+ * chrome-devtools is always attached if missing — that is Claude-in-Chrome
+ * for this hijack: navigate / snapshot / fill the live page, not osascript.
+ */
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import net from 'node:net';
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StdioClientTransport, getDefaultEnvironment } from '@modelcontextprotocol/sdk/client/stdio.js';
+import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
+
+const SKIP = /^(openzoo|openzoo-mcp)$/i;
+const NAME_RE = /[^a-zA-Z0-9_-]/g;
+
+const registry = new Map();
+let openaiTools = [];
+let started = null;
+let serversUp = [];
+
+export function hostMcpTools() {
+  return openaiTools;
+}
+
+export function hostMcpHas(name) {
+  return registry.has(String(name || ''));
+}
+
+export function hostMcpServers() {
+  return [...serversUp];
+}
+
+export function toolOpenaiName(server, toolName) {
+  return `${String(server || 'mcp').replace(NAME_RE, '_') }__${String(toolName || 'tool').replace(NAME_RE, '_')}`.slice(0, 64);
+}
+
+export function flattenMcpResult(r) {
+  const parts = [];
+  const content = Array.isArray(r?.content) ? r.content : [];
+  for (const c of content) {
+    if (!c || typeof c !== 'object') continue;
+    if (c.type === 'text' && c.text) parts.push(String(c.text));
+    else if (c.type === 'image') parts.push(`[image ${c.mimeType || 'png'} ${(c.data || '').length}b]`);
+    else parts.push(JSON.stringify(c));
+  }
+  const body = parts.join('\n').trim() || JSON.stringify(r ?? {});
+  const out = r?.isError ? `ERROR ${body}` : body;
+  return out.slice(0, 20_000);
+}
+
+function stripJsonComments(s) {
+  return String(s || '').replace(/^\s*\/\/.*$/gm, '');
+}
+
+function readJsonFile(p) {
+  try { return JSON.parse(stripJsonComments(fs.readFileSync(p, 'utf8'))); } catch { return null; }
+}
+
+/** Enough TOML for ~/.grok/config.toml [mcp_servers.*] tables. */
+export function parseTomlMcpServers(text) {
+  const servers = {};
+  let cur = null;
+  let nested = null;
+  let arrayKey = null;
+  let arrayBuf = [];
+  const ensure = (name) => {
+    if (!servers[name]) servers[name] = { name };
+    return servers[name];
+  };
+  const flushArray = () => {
+    if (!cur || !arrayKey) return;
+    const vals = arrayBuf.map((x) => unquote(x)).filter((x) => x !== '');
+    cur[arrayKey] = vals;
+    arrayKey = null;
+    arrayBuf = [];
+  };
+  const unquote = (raw) => {
+    let s = String(raw || '').trim().replace(/,$/, '').trim();
+    if ((s.startsWith('"') && s.endsWith('"')) || (s.startsWith("'") && s.endsWith("'"))) {
+      s = s.slice(1, -1);
+    }
+    if (s === 'true') return true;
+    if (s === 'false') return false;
+    if (/^-?\d+(\.\d+)?$/.test(s)) return Number(s);
+    return s;
+  };
+  for (const rawLine of String(text || '').split(/\n/)) {
+    const line = rawLine.trim();
+    if (!line || line.startsWith('#')) continue;
+    if (arrayKey) {
+      if (line.startsWith(']')) {
+        flushArray();
+        continue;
+      }
+      arrayBuf.push(line.replace(/,$/, ''));
+      continue;
+    }
+    const nestedSec = line.match(/^\[mcp_servers\.([^\]]+?)\.([a-zA-Z0-9_-]+)\]$/);
+    if (nestedSec) {
+      cur = ensure(nestedSec[1]);
+      nested = nestedSec[2];
+      if (!cur[nested] || typeof cur[nested] !== 'object' || Array.isArray(cur[nested])) cur[nested] = {};
+      continue;
+    }
+    const sec = line.match(/^\[mcp_servers\.([^\]]+)\]$/);
+    if (sec) {
+      cur = ensure(sec[1]);
+      nested = null;
+      continue;
+    }
+    if (line.startsWith('[')) {
+      cur = null;
+      nested = null;
+      continue;
+    }
+    if (!cur) continue;
+    const kv = line.match(/^([a-zA-Z0-9_-]+)\s*=\s*(.*)$/);
+    if (!kv) continue;
+    const key = kv[1];
+    const rest = kv[2].trim();
+    if (rest === '[' || rest.startsWith('[')) {
+      arrayKey = key;
+      arrayBuf = [];
+      const inner = rest.replace(/^\[/, '').replace(/\]\s*$/, '').trim();
+      if (rest.includes(']') && rest !== '[') {
+        if (inner) arrayBuf = inner.split(',').map((x) => x.trim());
+        flushArray();
+      }
+      continue;
+    }
+    const val = unquote(rest);
+    if (nested) cur[nested][key] = val;
+    else cur[key] = val;
+  }
+  flushArray();
+  return Object.values(servers);
+}
+
+export function fromJsonMcpServers(obj, fallbackName) {
+  if (!obj || typeof obj !== 'object') return [];
+  const src = obj.mcpServers && typeof obj.mcpServers === 'object' ? obj.mcpServers : obj;
+  const out = [];
+  for (const [name, raw] of Object.entries(src)) {
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw)) continue;
+    out.push({
+      name: String(name || fallbackName || 'mcp'),
+      command: raw.command,
+      args: Array.isArray(raw.args) ? raw.args.map(String) : (Array.isArray(raw.command) ? raw.command.slice(1) : undefined),
+      url: raw.url,
+      type: raw.type,
+      env: raw.env && typeof raw.env === 'object' ? raw.env : undefined,
+      headers: raw.headers && typeof raw.headers === 'object' ? raw.headers : undefined,
+      enabled: raw.enabled !== false,
+    });
+  }
+  return out;
+}
+
+function shapeServer(raw) {
+  const name = String(raw?.name || '').trim();
+  if (!name || SKIP.test(name) || raw?.enabled === false) return null;
+  const command = Array.isArray(raw.command) ? raw.command[0] : raw.command;
+  const args = Array.isArray(raw.args)
+    ? raw.args.map(String)
+    : (Array.isArray(raw.command) ? raw.command.slice(1).map(String) : []);
+  const url = raw.url ? String(raw.url) : '';
+  if (!url && !command) return null;
+  return {
+    name,
+    command: command ? String(command) : '',
+    args,
+    url,
+    env: raw.env && typeof raw.env === 'object' ? Object.fromEntries(Object.entries(raw.env).map(([k, v]) => [k, String(v)])) : undefined,
+    headers: raw.headers && typeof raw.headers === 'object' ? raw.headers : undefined,
+  };
+}
+
+export function loadHostMcpConfigs(home = os.homedir()) {
+  const piles = [];
+  const grokToml = path.join(home, '.grok', 'config.toml');
+  try { piles.push(...parseTomlMcpServers(fs.readFileSync(grokToml, 'utf8'))); } catch { /* */ }
+  for (const p of [
+    path.join(home, '.claude', 'mcp.json'),
+    path.join(home, 'Library', 'Application Support', 'Claude', 'claude_desktop_config.json'),
+    path.join(home, '.cursor', 'mcp.json'),
+  ]) {
+    const j = readJsonFile(p);
+    if (j) piles.push(...fromJsonMcpServers(j));
+  }
+  const seen = new Set();
+  const out = [];
+  for (const raw of piles) {
+    const s = shapeServer(raw);
+    if (!s || seen.has(s.name)) continue;
+    seen.add(s.name);
+    out.push(s);
+  }
+  if (![...seen].some((n) => /chrome|devtools|browser/i.test(n))) {
+    out.push({
+      name: 'chrome-devtools',
+      command: 'npx',
+      args: ['-y', 'chrome-devtools-mcp@latest'],
+      url: '',
+    });
+  }
+  return out;
+}
+
+export function mcpToOpenAiTool(server, tool) {
+  const schema = tool?.inputSchema && typeof tool.inputSchema === 'object'
+    ? { ...tool.inputSchema }
+    : { type: 'object', properties: {} };
+  if (!schema.type) schema.type = 'object';
+  if (!schema.properties) schema.properties = {};
+  delete schema.$schema;
+  return {
+    type: 'function',
+    function: {
+      name: toolOpenaiName(server, tool.name),
+      description: `[MCP ${server}] ${String(tool.description || tool.name || '').slice(0, 900)}`,
+      parameters: schema,
+    },
+  };
+}
+
+function portOpen(port, host = '127.0.0.1', ms = 150) {
+  return new Promise((resolve) => {
+    const sock = net.connect({ port, host });
+    const done = (ok) => {
+      try { sock.destroy(); } catch { /* */ }
+      resolve(ok);
+    };
+    sock.setTimeout(ms);
+    sock.on('connect', () => done(true));
+    sock.on('timeout', () => done(false));
+    sock.on('error', () => done(false));
+  });
+}
+
+async function chromeArgs(baseArgs) {
+  const args = [...(baseArgs || ['-y', 'chrome-devtools-mcp@latest'])];
+  if (args.some((a) => String(a).includes('browserUrl') || String(a) === '--browserUrl')) return args;
+  for (const port of [9222, 9333]) {
+    if (await portOpen(port)) {
+      args.push('--browserUrl', `http://127.0.0.1:${port}`);
+      break;
+    }
+  }
+  return args;
+}
+
+async function connectOne(cfg, log) {
+  const client = new Client({ name: 'openzoo-grokbot', version: '0.50.55' });
+  let transport;
+  if (cfg.url) {
+    const headers = {};
+    for (const [k, v] of Object.entries(cfg.headers || {})) headers[k] = String(v);
+    transport = new StreamableHTTPClientTransport(new URL(cfg.url), {
+      requestInit: { headers },
+    });
+  } else {
+    let args = cfg.args || [];
+    if (cfg.name === 'chrome-devtools') args = await chromeArgs(args);
+    const env = { ...getDefaultEnvironment(), PATH: process.env.PATH || '', ...(cfg.env || {}) };
+    if (process.env.NVM_DIR) env.NVM_DIR = process.env.NVM_DIR;
+    transport = new StdioClientTransport({
+      command: cfg.command,
+      args,
+      env,
+      stderr: 'pipe',
+    });
+    try {
+      transport.stderr?.on?.('data', (buf) => {
+        const line = String(buf).trim().split('\n')[0];
+        if (line) log?.(`cursor-backend:      mcp ${cfg.name} ${line.slice(0, 160)}`);
+      });
+    } catch { /* */ }
+  }
+  const ms = cfg.name === 'chrome-devtools' ? 90_000 : 45_000;
+  await Promise.race([
+    client.connect(transport),
+    new Promise((_, rej) => setTimeout(() => rej(new Error(`timeout ${ms}ms`)), ms)),
+  ]);
+  const listed = await client.listTools();
+  const tools = Array.isArray(listed?.tools) ? listed.tools : [];
+  return { client, tools };
+}
+
+function rebuildOpenai() {
+  openaiTools = [];
+  for (const [name, rec] of registry) {
+    openaiTools.push(mcpToOpenAiTool(rec.server, { name: rec.tool, description: rec.description, inputSchema: rec.schema }));
+    void name;
+  }
+}
+
+export async function callHostMcp(name, args) {
+  const rec = registry.get(String(name || ''));
+  if (!rec) throw new Error(`no mcp tool ${name}`);
+  const r = await rec.client.callTool({ name: rec.tool, arguments: args && typeof args === 'object' ? args : {} });
+  return flattenMcpResult(r);
+}
+
+export function resetHostMcpForTests() {
+  registry.clear();
+  openaiTools = [];
+  serversUp = [];
+  started = null;
+}
+
+export async function startHostMcps({ log = () => {}, home = os.homedir() } = {}) {
+  if (started) return started;
+  if (process.env.OZ_GROKBOT_MCP === '0') {
+    started = { tools: [], servers: [] };
+    return started;
+  }
+  started = (async () => {
+    const configs = loadHostMcpConfigs(home);
+    log(`cursor-backend:      mcp loading n=${configs.length} ${configs.map((c) => c.name).join(',')}`);
+    const results = await Promise.allSettled(configs.map((cfg) => connectOne(cfg, log)));
+    for (let i = 0; i < results.length; i++) {
+      const cfg = configs[i];
+      const r = results[i];
+      if (r.status !== 'fulfilled') {
+        log(`cursor-backend:      mcp ${cfg.name} FAIL ${r.reason?.message || r.reason}`);
+        continue;
+      }
+      serversUp.push(cfg.name);
+      for (const tool of r.value.tools) {
+        const openaiName = toolOpenaiName(cfg.name, tool.name);
+        if (registry.has(openaiName)) continue;
+        registry.set(openaiName, {
+          client: r.value.client,
+          server: cfg.name,
+          tool: tool.name,
+          description: tool.description || tool.name,
+          schema: tool.inputSchema,
+        });
+      }
+      log(`cursor-backend:      mcp ${cfg.name} tools=${r.value.tools.length}`);
+    }
+    rebuildOpenai();
+    log(`cursor-backend:      mcp ready servers=${serversUp.join(',') || 'none'} tools=${openaiTools.length}`);
+    return { tools: openaiTools, servers: serversUp };
+  })();
+  return started;
+}

package/package.json

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