mobygate 0.8.4 → 0.9.4

package/lib/openai-translation.js

@@ -0,0 +1,146 @@
+/**
+ * OpenAI Chat Completions translation layer.
+ *
+ * Mirrors lib/anthropic.js but for the OpenAI shape on POST /v1/chat/completions.
+ * Translates between the OpenAI Chat Completions wire format and the
+ * Claude Agent SDK's `query()` shape used internally by mobygate.
+ *
+ * Surface differences vs Anthropic (lib/anthropic.js):
+ *   - tools: OpenAI uses `tools[].function.{name, description, parameters}`;
+ *     Anthropic uses `tools[].{name, description, input_schema}`.
+ *   - tool results: OpenAI uses message.role === 'tool'; Anthropic uses
+ *     a `tool_result` content block on a user message.
+ *   - response shape: OpenAI uses `{choices: [{message: {role, content}}]}`;
+ *     Anthropic uses `{content: [{type: 'text', text}]}` (or tool_use blocks).
+ *
+ * Both surfaces ultimately drive the same SDK query() — see
+ * lib/inference-runner.js for the unified inference loop.
+ */
+
+import { toolMessagesToText } from './tool-bridge.js';
+
+// ---------------------------------------------------------------------------
+// Content extraction
+// ---------------------------------------------------------------------------
+
+export function extractContent(content) {
+  if (typeof content === 'string') return content;
+  if (Array.isArray(content)) {
+    return content
+      .map((part) => {
+        if (typeof part === 'string') return part;
+        if (part.type === 'text') return part.text;
+        if (part.type === 'image_url') return ''; // images carried separately; drop from text
+        return JSON.stringify(part);
+      })
+      .filter(Boolean)
+      .join('\n');
+  }
+  if (content && typeof content === 'object') return JSON.stringify(content);
+  return String(content || '');
+}
+
+// Convert an OpenAI message.content array into Anthropic image content blocks.
+// Supports both data: URLs (base64) and remote https URLs.
+export function extractImageBlocks(content) {
+  if (!Array.isArray(content)) return [];
+  const blocks = [];
+  for (const part of content) {
+    if (!part || part.type !== 'image_url') continue;
+    const url = typeof part.image_url === 'string' ? part.image_url : part.image_url?.url;
+    if (!url) continue;
+    const dataMatch = /^data:([^;]+);base64,(.+)$/.exec(url);
+    if (dataMatch) {
+      blocks.push({ type: 'image', source: { type: 'base64', media_type: dataMatch[1], data: dataMatch[2] } });
+    } else {
+      blocks.push({ type: 'image', source: { type: 'url', url } });
+    }
+  }
+  return blocks;
+}
+
+// Collect images from the LAST user message (OpenAI only attaches images
+// to the latest turn).
+export function collectImages(messages) {
+  for (let i = messages.length - 1; i >= 0; i--) {
+    if (messages[i].role === 'user') return extractImageBlocks(messages[i].content);
+  }
+  return [];
+}
+
+export function hasTools(body) {
+  return Array.isArray(body?.tools) && body.tools.length > 0;
+}
+
+// ---------------------------------------------------------------------------
+// Request translation: OpenAI messages → SDK prompt string
+// ---------------------------------------------------------------------------
+// Mirrors lib/anthropic.js#anthropicMessagesToPrompt — see that doc for
+// why tool definitions are NOT injected into the prompt (the runner
+// registers them with the SDK as MCP tools instead).
+
+export function messagesToPrompt(messages, { resuming = false } = {}) {
+  if (resuming) {
+    // Walk backwards from the end, collecting trailing tool messages and
+    // the most recent user text.
+    const trailingToolMessages = [];
+    let userText = '';
+    for (let i = messages.length - 1; i >= 0; i--) {
+      const msg = messages[i];
+      if (msg.role === 'tool') {
+        trailingToolMessages.unshift(msg);
+      } else if (msg.role === 'user') {
+        userText = extractContent(msg.content);
+        break;
+      } else {
+        break;
+      }
+    }
+    const toolResultsText = toolMessagesToText(trailingToolMessages);
+    if (!userText && !toolResultsText) {
+      return {
+        promptText: '',
+        error: 'Resume mode requires the request to end with a user message or tool result. Last message has role "' + (messages[messages.length - 1]?.role || 'unknown') + '".',
+      };
+    }
+    const parts = [];
+    if (toolResultsText) parts.push(toolResultsText);
+    if (userText) parts.push(userText);
+    return { promptText: parts.join('\n\n') };
+  }
+
+  // Fresh request: serialize visible history as XML-wrapped text.
+  const parts = [];
+  for (const msg of messages) {
+    switch (msg.role) {
+      case 'system':
+        parts.push(`<system>\n${extractContent(msg.content)}\n</system>\n`);
+        break;
+      case 'user':
+        parts.push(extractContent(msg.content));
+        break;
+      case 'assistant': {
+        const text = extractContent(msg.content);
+        if (text) parts.push(`<previous_response>\n${text}\n</previous_response>\n`);
+        break;
+      }
+      case 'tool': {
+        const text = toolMessagesToText([msg]);
+        if (text) parts.push(text);
+        break;
+      }
+    }
+  }
+  return { promptText: parts.join('\n').trim() };
+}
+
+// ---------------------------------------------------------------------------
+// Normalize model name for OpenAI response format
+// ---------------------------------------------------------------------------
+
+export function normalizeModelName(model) {
+  if (model?.includes('opus')) return 'claude-opus-4';
+  if (model?.includes('sonnet')) return 'claude-sonnet-4';
+  if (model?.includes('haiku')) return 'claude-haiku-4';
+  return model || 'claude-sonnet-4';
+}

package/lib/quiet.js

@@ -0,0 +1,249 @@
+/**
+ * Quiet mode — scrubs identifying terms (third-party agent harness names,
+ * proxy names, etc.) from outbound request payloads before the SDK forwards
+ * them to Anthropic. Used by the /quiet/v1/messages route.
+ *
+ * Why: community reports (X) show that Anthropic appears to scan request
+ * bodies for known third-party agent harness names (e.g. having "openclaw"
+ * in package.json triggers "extra usage" billing flags even when the harness
+ * isn't actually invoked). Quiet mode strips those substrings so the request
+ * body looks like a vanilla Anthropic-shape call.
+ *
+ * This is best-effort. Tool results / file content can still leak names —
+ * see CHANGELOG and README for the limits.
+ *
+ * Configurable via ~/.mobygate/quiet-words.txt (one term:replacement per
+ * line, separated by `=`). Falls back to DEFAULT_MAP.
+ */
+import { readFileSync, existsSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+
+const QUIET_WORDS_FILE = join(homedir(), '.mobygate', 'quiet-words.txt');
+
+// Defaults. Each key is a brand/identifier we expect Anthropic might match;
+// each value is a neutral replacement that preserves grammar/structure so
+// the model's understanding isn't broken.
+const DEFAULT_MAP = {
+  'openclaw': 'orchestrator',
+  'open-claw': 'orchestrator',
+  'hermes': 'assistant',
+  'mobius': 'bot',
+  'möbius': 'bot',
+  'mobygate': 'proxy',
+  'moby-gate': 'proxy',
+  'moby': 'proxy',
+  'nous': 'lab',
+  'nousresearch': 'lab',
+  'claude-max-proxy': 'proxy',
+};
+
+let cachedMap = null;
+let cachedRegex = null;
+
+function loadMap() {
+  if (cachedMap) return cachedMap;
+  const map = { ...DEFAULT_MAP };
+  if (existsSync(QUIET_WORDS_FILE)) {
+    try {
+      const text = readFileSync(QUIET_WORDS_FILE, 'utf8');
+      for (const raw of text.split('\n')) {
+        const line = raw.trim();
+        if (!line || line.startsWith('#')) continue;
+        const eq = line.indexOf('=');
+        if (eq > 0) {
+          const k = line.slice(0, eq).trim().toLowerCase();
+          const v = line.slice(eq + 1).trim();
+          if (k) map[k] = v;
+        } else {
+          map[line.toLowerCase()] = 'redacted';
+        }
+      }
+    } catch (e) {
+      console.warn(`[quiet] could not read ${QUIET_WORDS_FILE}: ${e.message}`);
+    }
+  }
+  cachedMap = map;
+  return map;
+}
+
+function buildRegex() {
+  if (cachedRegex) return cachedRegex;
+  const map = loadMap();
+  const keys = Object.keys(map).sort((a, b) => b.length - a.length);
+  if (!keys.length) return null;
+  // Word-boundary-aware on the right (don't match `claude-max-proxy` inside
+  // a longer hyphenated word), but lenient on the left to catch
+  // package.json-style "openclaw":"..." entries. Case-insensitive.
+  const escaped = keys.map((k) => k.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'));
+  cachedRegex = new RegExp(`(${escaped.join('|')})`, 'gi');
+  return cachedRegex;
+}
+
+/**
+ * Reset internal caches. Useful for tests or when the words file changes.
+ */
+export function resetQuietCache() {
+  cachedMap = null;
+  cachedRegex = null;
+}
+
+/**
+ * Scrub a single string. Returns the scrubbed string, or the input unchanged
+ * if no matches (so callers can detect dirty/clean cheaply).
+ */
+export function scrubString(input) {
+  if (typeof input !== 'string' || !input) return input;
+  const regex = buildRegex();
+  if (!regex) return input;
+  const map = loadMap();
+  return input.replace(regex, (match) => map[match.toLowerCase()] ?? match);
+}
+
+/**
+ * Scrub a single content block (Anthropic shape: { type, text, ... }).
+ */
+function scrubBlock(block) {
+  if (!block || typeof block !== 'object') return block;
+  if (block.type === 'text' && typeof block.text === 'string') {
+    return { ...block, text: scrubString(block.text) };
+  }
+  if (block.type === 'tool_result' && block.content) {
+    if (typeof block.content === 'string') {
+      return { ...block, content: scrubString(block.content) };
+    }
+    if (Array.isArray(block.content)) {
+      return { ...block, content: block.content.map(scrubBlock) };
+    }
+  }
+  return block;
+}
+
+/**
+ * Scrub the body of an Anthropic-shape `/v1/messages` request in place.
+ * Mutates and returns the same body for ergonomic chaining at the call site.
+ *
+ * Scrubs: system (string or block array), messages[].content (string or
+ * blocks), and metadata.user_id. Does NOT touch tool definitions (rename
+ * is a future feature) or model name.
+ */
+export function scrubAnthropicBody(body) {
+  if (!body || typeof body !== 'object') return body;
+
+  // system can be a string or an array of {type:'text', text} blocks.
+  if (typeof body.system === 'string') {
+    body.system = scrubString(body.system);
+  } else if (Array.isArray(body.system)) {
+    body.system = body.system.map(scrubBlock);
+  }
+
+  if (Array.isArray(body.messages)) {
+    body.messages = body.messages.map((m) => {
+      if (!m || typeof m !== 'object') return m;
+      if (typeof m.content === 'string') {
+        return { ...m, content: scrubString(m.content) };
+      }
+      if (Array.isArray(m.content)) {
+        return { ...m, content: m.content.map(scrubBlock) };
+      }
+      return m;
+    });
+  }
+
+  // Strip identifying metadata.user_id (it's the most common detection
+  // vector after content matching).
+  if (body.metadata && typeof body.metadata === 'object') {
+    if (body.metadata.user_id) {
+      body.metadata = { ...body.metadata, user_id: undefined };
+      delete body.metadata.user_id;
+    }
+  }
+
+  // Tool definitions: scrub description fields (free text the model reads
+  // but doesn't echo in tool_use blocks). Recurse into input_schema to
+  // catch nested property descriptions. Tool *names* are NOT renamed —
+  // that requires bidirectional mapping for tool_use responses, which is
+  // a future feature. Rename your tool names client-side if they include
+  // brand strings.
+  if (Array.isArray(body.tools)) {
+    body.tools = body.tools.map((t) => {
+      if (!t || typeof t !== 'object') return t;
+      const out = { ...t };
+      if (typeof out.description === 'string') {
+        out.description = scrubString(out.description);
+      }
+      if (out.input_schema && typeof out.input_schema === 'object') {
+        out.input_schema = scrubSchemaDescriptions(out.input_schema);
+      }
+      return out;
+    });
+  }
+
+  return body;
+}
+
+/**
+ * Recursively scrub `description` string fields anywhere in a JSON Schema.
+ * Leaves `type`, `enum`, `properties.<name>` keys, etc. alone — only
+ * touches fields named `description` whose value is a string.
+ */
+function scrubSchemaDescriptions(node) {
+  if (Array.isArray(node)) return node.map(scrubSchemaDescriptions);
+  if (!node || typeof node !== 'object') return node;
+  const out = {};
+  for (const [k, v] of Object.entries(node)) {
+    if (k === 'description' && typeof v === 'string') {
+      out[k] = scrubString(v);
+    } else {
+      out[k] = scrubSchemaDescriptions(v);
+    }
+  }
+  return out;
+}
+
+/**
+ * Diagnostic — returns counts of substitutions a scrub would make,
+ * without actually mutating. Useful for capture summaries.
+ */
+export function quietDiagnose(body) {
+  const regex = buildRegex();
+  if (!regex) return { matches: 0, words: [] };
+  const seen = new Map();
+  const visit = (s) => {
+    if (typeof s !== 'string') return;
+    for (const m of s.matchAll(regex)) {
+      const k = m[0].toLowerCase();
+      seen.set(k, (seen.get(k) || 0) + 1);
+    }
+  };
+  if (typeof body?.system === 'string') visit(body.system);
+  if (Array.isArray(body?.system)) for (const b of body.system) if (b?.text) visit(b.text);
+  if (Array.isArray(body?.messages)) {
+    for (const msg of body.messages) {
+      if (typeof msg?.content === 'string') visit(msg.content);
+      if (Array.isArray(msg?.content)) for (const b of msg.content) {
+        if (b?.text) visit(b.text);
+        if (typeof b?.content === 'string') visit(b.content);
+      }
+    }
+  }
+  // Tool descriptions + nested schema descriptions
+  if (Array.isArray(body?.tools)) {
+    for (const t of body.tools) {
+      if (typeof t?.description === 'string') visit(t.description);
+      const walk = (n) => {
+        if (Array.isArray(n)) n.forEach(walk);
+        else if (n && typeof n === 'object') {
+          for (const [k, v] of Object.entries(n)) {
+            if (k === 'description' && typeof v === 'string') visit(v);
+            else walk(v);
+          }
+        }
+      };
+      walk(t?.input_schema);
+    }
+  }
+  let total = 0;
+  for (const n of seen.values()) total += n;
+  return { matches: total, words: [...seen.entries()].map(([w, n]) => ({ word: w, count: n })) };
+}

package/lib/request-capture.js

@@ -30,6 +30,7 @@
  */
 
 import { writeFile, mkdir, appendFile, readdir, unlink, stat } from 'fs/promises';
+import { indexCapture, updateCaptureResponse } from './captures-index.js';
 import { existsSync } from 'fs';
 import { join } from 'path';
 import { homedir } from 'os';
@@ -241,6 +242,19 @@ export async function captureRequest({ path, body, requestId, sessionKey, sessio
     // Remember the summary path so captureResponse() can append to it.
     inFlightSummaries.set(requestId, summaryPath);
 
+    // Mirror to SQLite index for `mobygate captures query`. Best-effort
+    // — swallows errors internally so a broken index never breaks proxying.
+    indexCapture({
+      requestId,
+      ts: new Date().toISOString(),
+      path,
+      body,
+      sessionKey,
+      sessionSource: sessionKeySource,
+      jsonPath,
+      summaryPath,
+    }).catch(() => {});
+
     // Best-effort prune to stay under the cap. Don't await — let it run
     // alongside the next request.
     pruneOldCaptures().catch(() => {});
@@ -310,6 +324,16 @@ export async function captureResponse({ requestId, usage, durationMs, status, st
     }
 
     await appendFile(summaryPath, lines.join('\n') + '\n', 'utf8');
+
+    // Mirror response-side fields to the SQLite index.
+    updateCaptureResponse({
+      requestId,
+      usage,
+      durationMs,
+      status,
+      stopReason,
+      model,
+    }).catch(() => {});
   } catch (e) {
     console.warn(`[capture] response append failed for ${requestId}: ${e.message}`);
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mobygate",
-  "version": "0.8.4",
+  "version": "0.9.4",
   "description": "OpenAI-compatible local proxy for Claude Max. The Möbius-strip gateway: OpenAI shape in, Claude Max out.",
   "type": "module",
   "main": "server.js",
@@ -11,6 +11,7 @@
     "start": "node server.js",
     "dev": "node --watch server.js",
     "up": "npm install && node server.js",
+    "test:smoke": "node --test test/smoke.test.mjs",
     "auth:status": "node scripts/auth-status.js",
     "auth:status:quick": "node scripts/auth-status.js --quick",
     "auth:refresh": "node scripts/auth-refresh.js",
@@ -18,6 +19,7 @@
   },
   "dependencies": {
     "@anthropic-ai/claude-agent-sdk": "^0.2.112",
+    "better-sqlite3": "^12.9.0",
     "express": "^5.1.0",
     "js-yaml": "^4.1.1",
     "uuid": "^11.1.0"
@@ -58,6 +60,7 @@
     "launchd",
     "server.js",
     "index.html",
+    "dashboard.css",
     "inspector.html",
     "mcp-inspect.mjs",
     "README.md",