mobygate 0.3.0

package/launchd/ai.mobygate.auth-refresh.plist

@@ -0,0 +1,83 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<!--
+  Proactive Claude Max OAuth refresh cron.
+
+  Runs scripts/auth-refresh.js every 4 hours via launchd. Anthropic's OAuth
+  access tokens last ~8 hours, so a 4h cadence keeps us well inside the
+  valid window even if one run fails (then we have another ~4h of buffer).
+
+  Install:
+    cp launchd/ai.mobygate.auth-refresh.plist ~/Library/LaunchAgents/
+    launchctl load ~/Library/LaunchAgents/ai.mobygate.auth-refresh.plist
+
+  Uninstall:
+    launchctl unload ~/Library/LaunchAgents/ai.mobygate.auth-refresh.plist
+    rm ~/Library/LaunchAgents/ai.mobygate.auth-refresh.plist
+
+  Before installing, edit WorkingDirectory below to match your checkout path
+  if it's not /Users/farhan/openclaude/claude-max-sdk-proxy.
+
+  Logs go to logs/auth-refresh.log inside the project directory.
+-->
+<plist version="1.0">
+<dict>
+    <key>Label</key>
+    <string>ai.mobygate.auth-refresh</string>
+
+    <!--
+      launchd does not source your shell's rc files, so it does NOT see the
+      PATH set up by fnm/nvm/volta/asdf. Options:
+        (a) hardcode an absolute path to node here (simplest, fragile to
+            node upgrades that move the binary)
+        (b) use `/bin/sh -lc "node scripts/auth-refresh.js"` so a login
+            shell sources your profile and sets up fnm/nvm (below, commented)
+
+      Default uses fnm's stable "default" alias symlink. If you use a
+      different node manager or a system install, change the first string
+      in ProgramArguments to wherever `which node` resolves to for you.
+    -->
+    <key>ProgramArguments</key>
+    <array>
+        <string>/Users/farhan/.local/share/fnm/aliases/default/bin/node</string>
+        <string>scripts/auth-refresh.js</string>
+    </array>
+    <!-- Alternative: let your login shell set up fnm/nvm first.
+    <key>ProgramArguments</key>
+    <array>
+        <string>/bin/sh</string>
+        <string>-lc</string>
+        <string>node scripts/auth-refresh.js</string>
+    </array>
+    -->
+
+
+    <key>WorkingDirectory</key>
+    <string>/Users/farhan/openclaude/claude-max-sdk-proxy</string>
+
+    <key>EnvironmentVariables</key>
+    <dict>
+        <key>PATH</key>
+        <string>/Users/farhan/.local/share/fnm/aliases/default/bin:/usr/local/bin:/usr/bin:/bin:/opt/homebrew/bin:/Users/farhan/.local/bin</string>
+        <key>HOME</key>
+        <string>/Users/farhan</string>
+    </dict>
+
+    <!-- Every 4 hours (14400 seconds) -->
+    <key>StartInterval</key>
+    <integer>14400</integer>
+
+    <!-- Also run 60 seconds after load so we get an immediate probe -->
+    <key>RunAtLoad</key>
+    <true/>
+
+    <key>StandardOutPath</key>
+    <string>/Users/farhan/openclaude/claude-max-sdk-proxy/logs/auth-refresh.log</string>
+    <key>StandardErrorPath</key>
+    <string>/Users/farhan/openclaude/claude-max-sdk-proxy/logs/auth-refresh.err.log</string>
+
+    <!-- Don't restart on failure — one run per interval is enough. -->
+    <key>KeepAlive</key>
+    <false/>
+</dict>
+</plist>

package/lib/ascii.js

@@ -0,0 +1,108 @@
+/**
+ * Terminal ASCII art for mobygate.
+ *
+ * The whale character-art and color palette are lifted directly from the
+ * Paper design file (01KPFE5G6MJGMT5E5MGA94DQRF, artboard C1-0) — the
+ * same source of truth as the web dashboard. Whale-in-terminal and
+ * whale-in-browser should feel like the same product.
+ *
+ * Palette — 24-bit truecolor ANSI, exact hex match with the web side:
+ *   #B7E56D  primary green  (whale, healthy state, title)
+ *   #E89B2E  orange         (stars, warning, CTA)
+ *   #4EA4C4  blue           (waterline, stream)
+ *   #8A9A6A  muted olive    (tagline, tertiary text)
+ *   #5A5F54  dim            (labels, version)
+ *   #F3EFE4  warm white     (primary text)
+ *
+ * Fallback: NO_COLOR env var or non-TTY stdout strips all escape codes.
+ */
+
+const C = {
+  reset:  '\x1b[0m',
+  bold:   '\x1b[1m',
+  // 24-bit truecolor — matches the Paper palette and web dashboard exactly
+  green:  '\x1b[38;2;183;229;109m',   // #B7E56D
+  orange: '\x1b[38;2;232;155;46m',    // #E89B2E
+  blue:   '\x1b[38;2;78;164;196m',    // #4EA4C4
+  olive:  '\x1b[38;2;138;154;106m',   // #8A9A6A
+  dim:    '\x1b[38;2;90;95;84m',      // #5A5F54
+  text:   '\x1b[38;2;243;239;228m',   // #F3EFE4
+};
+
+// Exact 6-line whale transcribed from Paper C1-0 header. Barnacle cluster
+// (##), spout (.), motion lines (==), mouth (/"""""""\__/), eye (o), tail.
+const WHALE = [
+  "        ##       .",
+  "   ## ## ##     ==",
+  " ##  ## ## ##  ===",
+  ' /"""""""""""\\__/ ==',
+  " \\______ o     __/",
+  "  \\______\\___,/",
+];
+
+// Sparse starfield above the whale — staggered asterisks and dots so it
+// reads as night sky, not noise.
+const STARS = [
+  "           .    *    .      *    .    .",
+  "              *      .         .     *",
+  "         .      .    *    .    *    .",
+];
+
+// One-line waterline under the whale. The ∞∾ alternation nods to the
+// Möbius-loop concept baked into the name without being heavy-handed.
+const WAVES = " ∞∾∞∾∞∾∞∾∞∾∞∾∞∾∞∾∞∾∞∾∞∾∞∾∞";
+
+const TITLE = "mobygate";
+const TAG   = "OpenAI → Claude Max · local gateway";
+
+function useColor() {
+  return process.stdout.isTTY && !process.env.NO_COLOR;
+}
+
+function paint(s, ...codes) {
+  if (!useColor()) return s;
+  return `${codes.join('')}${s}${C.reset}`;
+}
+
+function padBlock(lines) {
+  const w = Math.max(...lines.map((l) => [...l].length));
+  return lines.map((l) => l + ' '.repeat(w - [...l].length));
+}
+
+/**
+ * Full banner — stars / whale / waterline / title / tagline.
+ * Used by `mobygate init` and the server startup log.
+ *
+ *   version?  appends a dim "v0.X.Y" next to the title.
+ */
+export function banner({ version } = {}) {
+  const whale = padBlock(WHALE);
+  const out = [
+    '',
+    ...STARS.map((s) => '  ' + paint(s, C.orange)),
+    '',
+    ...whale.map((l) => '  ' + paint(l, C.green)),
+    '  ' + paint(WAVES, C.blue),
+    '',
+    '  ' + paint(TITLE, C.bold, C.green) + (version ? '  ' + paint('v' + version, C.dim) : ''),
+    '  ' + paint(TAG, C.olive),
+    '',
+  ];
+  return out.join('\n');
+}
+
+/**
+ * Compact one-liner — whale-spout-flanked title. For `mobygate status`
+ * and other short CLI surfaces where the full whale is overkill.
+ */
+export function compactBanner({ version } = {}) {
+  const v = version ? '  ' + paint('v' + version, C.dim) : '';
+  return [
+    '',
+    '  ' + paint('∞∾∞∾', C.blue) + '  ' + paint(TITLE, C.bold, C.green) + '  ' + paint('∾∞∾∞', C.blue) + v,
+    '  ' + paint(TAG, C.olive),
+    '',
+  ].join('\n');
+}
+
+export const colors = C;

package/lib/config.js

@@ -0,0 +1,131 @@
+/**
+ * mobygate config loader.
+ *
+ * Reads ~/.mobygate/config.yaml if present, merges with env-var overrides
+ * and built-in defaults. Written by `mobygate init`, but also editable by
+ * hand. Missing file → all defaults (so the proxy works without ever
+ * running init, matching the old behavior).
+ *
+ * Precedence (highest → lowest):
+ *   1. Process env vars (PORT, DEFAULT_MODEL, etc.)
+ *   2. ~/.mobygate/config.yaml
+ *   3. Built-in defaults
+ */
+
+import { readFileSync, existsSync, mkdirSync, writeFileSync } from 'fs';
+import { homedir } from 'os';
+import { join } from 'path';
+import yaml from 'js-yaml';
+
+export const CONFIG_DIR = process.env.MOBYGATE_HOME || join(homedir(), '.mobygate');
+export const CONFIG_PATH = join(CONFIG_DIR, 'config.yaml');
+export const STATE_PATH = join(CONFIG_DIR, 'state.json');
+// Logs live alongside config — same across git-clone, npm-global, and
+// per-user installs. Never inside the install dir (npm global installs
+// may be root-owned, and `npm update` wipes non-tarball files).
+export const LOGS_DIR = join(CONFIG_DIR, 'logs');
+
+const DEFAULTS = {
+  port: 3456,
+  default_model: 'claude-opus-4-7[1m]',
+  session_ttl_minutes: 60,
+  max_concurrent: null,       // reserved for future (per-session throttling)
+  claude_bin: '',             // empty → PATH lookup
+  log_level: 'info',
+  auth_refresh_interval_hours: 4,
+};
+
+/**
+ * Parse the config file and merge with defaults. Returns a frozen object.
+ * Never throws for a missing file; does throw for invalid YAML.
+ */
+export function loadConfig() {
+  let fileConfig = {};
+  if (existsSync(CONFIG_PATH)) {
+    try {
+      const raw = readFileSync(CONFIG_PATH, 'utf8');
+      fileConfig = yaml.load(raw) || {};
+      if (typeof fileConfig !== 'object' || Array.isArray(fileConfig)) {
+        console.warn(`[config] ${CONFIG_PATH} did not parse to an object — ignoring`);
+        fileConfig = {};
+      }
+    } catch (e) {
+      console.warn(`[config] failed to parse ${CONFIG_PATH}: ${e.message}`);
+      fileConfig = {};
+    }
+  }
+
+  const merged = {
+    port: parseInt(process.env.PORT || String(fileConfig.port ?? DEFAULTS.port), 10),
+    default_model: process.env.DEFAULT_MODEL || fileConfig.default_model || DEFAULTS.default_model,
+    session_ttl_minutes: parseInt(
+      process.env.SESSION_TTL_MINUTES
+        || String(fileConfig.session_ttl_minutes ?? DEFAULTS.session_ttl_minutes),
+      10,
+    ),
+    claude_bin: process.env.CLAUDE_BIN || fileConfig.claude_bin || DEFAULTS.claude_bin,
+    log_level: process.env.LOG_LEVEL || fileConfig.log_level || DEFAULTS.log_level,
+    auth_refresh_interval_hours: parseInt(
+      process.env.AUTH_REFRESH_INTERVAL_HOURS
+        || String(fileConfig.auth_refresh_interval_hours ?? DEFAULTS.auth_refresh_interval_hours),
+      10,
+    ),
+    source: existsSync(CONFIG_PATH) ? CONFIG_PATH : '(defaults)',
+  };
+  return Object.freeze(merged);
+}
+
+/**
+ * Write a config file with the given values merged on top of DEFAULTS.
+ * Creates the directory if needed. Produces a commented YAML file so
+ * users who open it can see what's tunable.
+ */
+export function writeConfig(values = {}) {
+  if (!existsSync(CONFIG_DIR)) mkdirSync(CONFIG_DIR, { recursive: true });
+  const merged = { ...DEFAULTS, ...values };
+  const content = [
+    '# mobygate config — generated by `mobygate init`.',
+    '# Env vars (PORT, DEFAULT_MODEL, SESSION_TTL_MINUTES, CLAUDE_BIN, etc.)',
+    '# override any field here. Safe to hand-edit.',
+    '',
+    `# HTTP port the proxy listens on.`,
+    `port: ${merged.port}`,
+    '',
+    `# Default Claude model when the client does not specify one.`,
+    `# Other aliases (opus, sonnet, haiku) resolve per MODEL_MAP in server.js.`,
+    `default_model: ${JSON.stringify(merged.default_model)}`,
+    '',
+    `# How long a client-provided session key maps to an SDK session.`,
+    `session_ttl_minutes: ${merged.session_ttl_minutes}`,
+    '',
+    `# Explicit path to the \`claude\` CLI binary.`,
+    `# Empty string = resolve via PATH. Set this if claude is not on PATH,`,
+    `# or if you use a node manager (fnm/nvm) that puts binaries in`,
+    `# session-specific directories.`,
+    `claude_bin: ${JSON.stringify(merged.claude_bin)}`,
+    '',
+    `# Log verbosity.`,
+    `log_level: ${merged.log_level}`,
+    '',
+    `# How often the proactive auth-refresh cron runs (hours).`,
+    `# Anthropic tokens last ~8h, so 4h cadence keeps you well inside the window.`,
+    `auth_refresh_interval_hours: ${merged.auth_refresh_interval_hours}`,
+    '',
+  ].join('\n');
+  writeFileSync(CONFIG_PATH, content);
+  return CONFIG_PATH;
+}
+
+/** Read the install-metadata sidecar (or null if not yet written). */
+export function readState() {
+  if (!existsSync(STATE_PATH)) return null;
+  try { return JSON.parse(readFileSync(STATE_PATH, 'utf8')); } catch { return null; }
+}
+
+export function writeState(patch) {
+  if (!existsSync(CONFIG_DIR)) mkdirSync(CONFIG_DIR, { recursive: true });
+  const current = readState() || {};
+  const merged = { ...current, ...patch, updated_at: new Date().toISOString() };
+  writeFileSync(STATE_PATH, JSON.stringify(merged, null, 2));
+  return merged;
+}

package/lib/dashboard-bus.js

@@ -0,0 +1,158 @@
+/**
+ * In-process event bus for the live dashboard.
+ *
+ * Handlers emit events as requests flow through; the HTTP SSE endpoint
+ * (/events) subscribes and pipes each event to connected browsers. A
+ * bounded ring buffer keeps the most recent N events so the dashboard
+ * can render a populated table on first page load without waiting for
+ * new traffic.
+ *
+ * Intentionally simple — no persistence, no cross-process fan-out, no
+ * metrics library. Everything resets when the server restarts. That's
+ * appropriate for a local-first dev proxy. If you want historical
+ * analytics, scrape /events or the log file.
+ */
+
+import { EventEmitter } from 'events';
+
+const DEFAULT_RING_SIZE = 200;
+
+const LATENCY_SAMPLES = 50;        // rolling window per variant (stream/sync)
+const TRAFFIC_WINDOW_MIN = 15;     // minutes retained for the traffic chart
+
+function percentile(sorted, p) {
+  if (!sorted.length) return null;
+  const idx = Math.min(sorted.length - 1, Math.floor((p / 100) * sorted.length));
+  return sorted[idx];
+}
+
+function minuteKey(d = new Date()) {
+  return new Date(d).toISOString().slice(0, 16) + ':00Z'; // YYYY-MM-DDTHH:MM:00Z
+}
+
+class DashboardBus extends EventEmitter {
+  constructor(ringSize = DEFAULT_RING_SIZE) {
+    super();
+    this.setMaxListeners(50);
+    this.ringSize = ringSize;
+    this.recent = [];
+    this.startedAt = Date.now();
+    this.stats = {
+      totalRequests: 0,
+      succeeded: 0,
+      failed: 0,
+      streamingRequests: 0,
+      toolRequests: 0,
+      multimodalRequests: 0,
+      authRefreshes: 0,
+    };
+    // Rolling latency samples, keyed by stream|sync
+    this.latency = { stream: [], sync: [] };
+    // Per-minute traffic bucket map: key → count
+    this.trafficByMinute = new Map();
+    // Track each request's type at start-time so the end-event can route to
+    // the right latency bucket.
+    this.inflightType = new Map();
+  }
+
+  /**
+   * Emit an event to subscribers and store in the ring buffer.
+   * Accepted types:
+   *   'request.start'   { id, method, path, model, session, stream, tools, images, messages }
+   *   'request.end'     { id, durationMs, status, finishReason, inputTokens, outputTokens, error }
+   *   'auth.refresh'    { ok, durationMs, error }
+   *   'server.boot'     { port, defaultModel }
+   */
+  emitEvent(ev) {
+    const event = { ...ev, ts: ev.ts || new Date().toISOString() };
+    this.emit('event', event);
+
+    this.recent.push(event);
+    if (this.recent.length > this.ringSize) this.recent.shift();
+
+    // Stats updates
+    if (event.type === 'request.start') {
+      this.stats.totalRequests++;
+      if (event.stream) this.stats.streamingRequests++;
+      if (event.tools) this.stats.toolRequests++;
+      if (event.images > 0) this.stats.multimodalRequests++;
+
+      // Remember each request's kind so end-event routing knows which bucket
+      this.inflightType.set(event.id, event.stream ? 'stream' : 'sync');
+
+      // Traffic bucket — count by the request.start minute
+      const k = minuteKey(event.ts);
+      this.trafficByMinute.set(k, (this.trafficByMinute.get(k) || 0) + 1);
+      this._trimTraffic();
+    } else if (event.type === 'request.end') {
+      if (event.status === 'ok') this.stats.succeeded++;
+      else this.stats.failed++;
+
+      // Latency sample → rolling window for the right variant
+      const kind = this.inflightType.get(event.id) || 'sync';
+      this.inflightType.delete(event.id);
+      if (typeof event.durationMs === 'number' && event.durationMs >= 0) {
+        const arr = this.latency[kind];
+        arr.push(event.durationMs);
+        if (arr.length > LATENCY_SAMPLES) arr.shift();
+      }
+    } else if (event.type === 'auth.refresh') {
+      this.stats.authRefreshes++;
+    }
+  }
+
+  /** Drop traffic buckets older than TRAFFIC_WINDOW_MIN minutes. */
+  _trimTraffic() {
+    const cutoff = new Date(Date.now() - TRAFFIC_WINDOW_MIN * 60 * 1000);
+    for (const k of this.trafficByMinute.keys()) {
+      if (new Date(k) < cutoff) this.trafficByMinute.delete(k);
+    }
+  }
+
+  /** Compute { p50, p95, recent[], count } for a latency variant. */
+  _latencyMetrics(kind) {
+    const recent = this.latency[kind];
+    const sorted = [...recent].sort((a, b) => a - b);
+    return {
+      count: recent.length,
+      p50: percentile(sorted, 50),
+      p95: percentile(sorted, 95),
+      recent: [...recent], // chronological order, for sparkline rendering
+    };
+  }
+
+  /** Fill-in zeros for missing minutes in the traffic window. */
+  _trafficSeries() {
+    this._trimTraffic();
+    const now = new Date();
+    const series = [];
+    for (let i = TRAFFIC_WINDOW_MIN - 1; i >= 0; i--) {
+      const t = new Date(now.getTime() - i * 60 * 1000);
+      const k = minuteKey(t);
+      series.push({ minute: k, count: this.trafficByMinute.get(k) || 0 });
+    }
+    return series;
+  }
+
+  getRecent({ limit = 100 } = {}) {
+    const slice = this.recent.slice(-limit);
+    return slice.reverse(); // newest first
+  }
+
+  getStats() {
+    return {
+      ...this.stats,
+      uptimeSec: Math.floor((Date.now() - this.startedAt) / 1000),
+      startedAt: new Date(this.startedAt).toISOString(),
+      ringSize: this.ringSize,
+      recentCount: this.recent.length,
+      latency: {
+        stream: this._latencyMetrics('stream'),
+        sync: this._latencyMetrics('sync'),
+      },
+      traffic: this._trafficSeries(),
+    };
+  }
+}
+
+export const bus = new DashboardBus();