@elvatis_com/openclaw-cli-bridge-elvatis 0.2.23 → 0.2.26

package/src/proxy-server.ts

@@ -11,7 +11,13 @@
 import http from "node:http";
 import { randomBytes } from "node:crypto";
 import { type ChatMessage, routeToCliRunner } from "./cli-runner.js";
-import { scheduleTokenRefresh, setAuthLogger } from "./claude-auth.js";
+import { scheduleTokenRefresh, setAuthLogger, stopTokenRefresh } from "./claude-auth.js";
+import { grokComplete, grokCompleteStream, type ChatMessage as GrokChatMessage } from "./grok-client.js";
+import type { BrowserContext } from "playwright";
+
+export type GrokCompleteOptions = Parameters<typeof grokComplete>[1];
+export type GrokCompleteStreamOptions = Parameters<typeof grokCompleteStream>[1];
+export type GrokCompleteResult = Awaited<ReturnType<typeof grokComplete>>;
 
 export interface ProxyServerOptions {
   port: number;
@@ -19,6 +25,12 @@ export interface ProxyServerOptions {
   timeoutMs?: number;
   log: (msg: string) => void;
   warn: (msg: string) => void;
+  /** Returns the current authenticated Grok BrowserContext (null if not logged in) */
+  getGrokContext?: () => BrowserContext | null;
+  /** Override for testing — replaces grokComplete */
+  _grokComplete?: typeof grokComplete;
+  /** Override for testing — replaces grokCompleteStream */
+  _grokCompleteStream?: typeof grokCompleteStream;
 }
 
 /** Available CLI bridge models for GET /v1/models */
@@ -59,6 +71,11 @@ export const CLI_MODELS = [
     contextWindow: 200_000,
     maxTokens: 8192,
   },
+  // Grok web-session models (requires /grok-login)
+  { id: "web-grok/grok-3",           name: "Grok 3 (web session)",           contextWindow: 131_072, maxTokens: 131_072 },
+  { id: "web-grok/grok-3-fast",      name: "Grok 3 Fast (web session)",      contextWindow: 131_072, maxTokens: 131_072 },
+  { id: "web-grok/grok-3-mini",      name: "Grok 3 Mini (web session)",      contextWindow: 131_072, maxTokens: 131_072 },
+  { id: "web-grok/grok-3-mini-fast", name: "Grok 3 Mini Fast (web session)", contextWindow: 131_072, maxTokens: 131_072 },
 ];
 
 // ──────────────────────────────────────────────────────────────────────────────
@@ -77,6 +94,11 @@ export function startProxyServer(opts: ProxyServerOptions): Promise<http.Server>
       });
     });
 
+    // Stop the token refresh interval when the server closes (timer-leak prevention)
+    server.on("close", () => {
+      stopTokenRefresh();
+    });
+
     server.on("error", (err) => reject(err));
     server.listen(opts.port, "127.0.0.1", () => {
       opts.log(
@@ -171,6 +193,57 @@ async function handleRequest(
 
     opts.log(`[cli-bridge] ${model} · ${messages.length} msg(s) · stream=${stream}`);
 
+    const id = `chatcmpl-cli-${randomBytes(6).toString("hex")}`;
+    const created = Math.floor(Date.now() / 1000);
+
+    // ── Grok web-session routing ──────────────────────────────────────────────
+    if (model.startsWith("web-grok/")) {
+      const grokCtx = opts.getGrokContext?.() ?? null;
+      if (!grokCtx) {
+        res.writeHead(503, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: { message: "No active grok.com session. Use /grok-login to authenticate.", code: "no_grok_session" } }));
+        return;
+      }
+      const grokModel = model.replace("web-grok/", "");
+      const timeoutMs = opts.timeoutMs ?? 120_000;
+      const grokMessages = messages as GrokChatMessage[];
+      const doGrokComplete = opts._grokComplete ?? grokComplete;
+      const doGrokCompleteStream = opts._grokCompleteStream ?? grokCompleteStream;
+      try {
+        if (stream) {
+          res.writeHead(200, { "Content-Type": "text/event-stream", "Cache-Control": "no-cache", Connection: "keep-alive", ...corsHeaders() });
+          sendSseChunk(res, { id, created, model, delta: { role: "assistant" }, finish_reason: null });
+          const result = await doGrokCompleteStream(
+            grokCtx,
+            { messages: grokMessages, model: grokModel, timeoutMs },
+            (token) => sendSseChunk(res, { id, created, model, delta: { content: token }, finish_reason: null }),
+            opts.log
+          );
+          sendSseChunk(res, { id, created, model, delta: {}, finish_reason: result.finishReason });
+          res.write("data: [DONE]\n\n");
+          res.end();
+        } else {
+          const result = await doGrokComplete(grokCtx, { messages: grokMessages, model: grokModel, timeoutMs }, opts.log);
+          res.writeHead(200, { "Content-Type": "application/json", ...corsHeaders() });
+          res.end(JSON.stringify({
+            id, object: "chat.completion", created, model,
+            choices: [{ index: 0, message: { role: "assistant", content: result.content }, finish_reason: result.finishReason }],
+            usage: { prompt_tokens: result.promptTokens ?? 0, completion_tokens: result.completionTokens ?? 0, total_tokens: (result.promptTokens ?? 0) + (result.completionTokens ?? 0) },
+          }));
+        }
+      } catch (err) {
+        const msg = (err as Error).message;
+        opts.warn(`[cli-bridge] Grok error for ${model}: ${msg}`);
+        if (!res.headersSent) {
+          res.writeHead(500, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: { message: msg, type: "grok_error" } }));
+        }
+      }
+      return;
+    }
+    // ─────────────────────────────────────────────────────────────────────────
+
+    // ── CLI runner routing (Gemini / Claude Code) ─────────────────────────────
     let content: string;
     try {
       content = await routeToCliRunner(model, messages, opts.timeoutMs ?? 120_000);
@@ -182,9 +255,6 @@ async function handleRequest(
       return;
     }
 
-    const id = `chatcmpl-cli-${randomBytes(6).toString("hex")}`;
-    const created = Math.floor(Date.now() / 1000);
-
     if (stream) {
       res.writeHead(200, {
         "Content-Type": "text/event-stream",

package/test/grok-proxy.test.ts

@@ -0,0 +1,301 @@
+/**
+ * test/grok-proxy.test.ts
+ *
+ * Tests for Grok web-session routing integrated into the cli-bridge proxy.
+ * Uses _grokComplete/_grokCompleteStream overrides (DI) instead of vi.mock,
+ * which avoids ESM hoisting issues entirely.
+ */
+
+import { describe, it, expect, beforeAll, afterAll, vi } from "vitest";
+import http from "node:http";
+import type { AddressInfo } from "node:net";
+import { startProxyServer, CLI_MODELS } from "../src/proxy-server.js";
+import type { BrowserContext } from "playwright";
+import type { GrokCompleteOptions, GrokCompleteResult } from "../src/proxy-server.js";
+
+// ──────────────────────────────────────────────────────────────────────────────
+// Stub implementations (no browser needed)
+// ──────────────────────────────────────────────────────────────────────────────
+
+const stubGrokComplete = vi.fn(async (
+  _ctx: BrowserContext,
+  opts: GrokCompleteOptions,
+  _log: (msg: string) => void
+): Promise<GrokCompleteResult> => ({
+  content: `grok mock: ${opts.messages[opts.messages.length - 1]?.content ?? ""}`,
+  model: opts.model ?? "grok-3",
+  finishReason: "stop",
+  promptTokens: 8,
+  completionTokens: 4,
+}));
+
+const stubGrokCompleteStream = vi.fn(async (
+  _ctx: BrowserContext,
+  opts: GrokCompleteOptions,
+  onToken: (t: string) => void,
+  _log: (msg: string) => void
+): Promise<GrokCompleteResult> => {
+  const tokens = ["grok ", "stream ", "mock"];
+  for (const t of tokens) onToken(t);
+  return {
+    content: tokens.join(""),
+    model: opts.model ?? "grok-3",
+    finishReason: "stop",
+    promptTokens: 8,
+    completionTokens: 3,
+  };
+});
+
+// ──────────────────────────────────────────────────────────────────────────────
+// Helpers
+// ──────────────────────────────────────────────────────────────────────────────
+
+async function httpPost(
+  url: string,
+  body: unknown,
+  headers: Record<string, string> = {}
+): Promise<{ status: number; body: unknown }> {
+  return new Promise((resolve, reject) => {
+    const data = JSON.stringify(body);
+    const urlObj = new URL(url);
+    const req = http.request(
+      {
+        hostname: urlObj.hostname,
+        port: parseInt(urlObj.port),
+        path: urlObj.pathname,
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Content-Length": Buffer.byteLength(data),
+          ...headers,
+        },
+      },
+      (res) => {
+        let resp = "";
+        res.on("data", (c) => (resp += c));
+        res.on("end", () => {
+          try { resolve({ status: res.statusCode ?? 0, body: JSON.parse(resp) }); }
+          catch { resolve({ status: res.statusCode ?? 0, body: resp }); }
+        });
+      }
+    );
+    req.on("error", reject);
+    req.write(data);
+    req.end();
+  });
+}
+
+async function httpGet(
+  url: string,
+  headers: Record<string, string> = {}
+): Promise<{ status: number; body: unknown }> {
+  return new Promise((resolve, reject) => {
+    const req = http.get(url, { headers }, (res) => {
+      let data = "";
+      res.on("data", (c) => (data += c));
+      res.on("end", () => {
+        try { resolve({ status: res.statusCode ?? 0, body: JSON.parse(data) }); }
+        catch { resolve({ status: res.statusCode ?? 0, body: data }); }
+      });
+    });
+    req.on("error", reject);
+  });
+}
+
+// ──────────────────────────────────────────────────────────────────────────────
+// Setup: three servers
+//  - withCtx: has mock BrowserContext + stub overrides
+//  - noCtx: no BrowserContext (returns null)
+//  - noCtxNoOverride: no context, no overrides (tests 503)
+// ──────────────────────────────────────────────────────────────────────────────
+
+const TEST_KEY = "test-grok-key";
+const MOCK_CONTEXT = {} as BrowserContext;
+
+let serverWithCtx: http.Server;
+let serverNoCtx: http.Server;
+let urlWith: string;
+let urlNo: string;
+
+beforeAll(async () => {
+  serverWithCtx = await startProxyServer({
+    port: 0,
+    apiKey: TEST_KEY,
+    log: () => {},
+    warn: () => {},
+    getGrokContext: () => MOCK_CONTEXT,
+    _grokComplete: stubGrokComplete,
+    _grokCompleteStream: stubGrokCompleteStream,
+  });
+  const addrWith = serverWithCtx.address() as AddressInfo;
+  urlWith = `http://127.0.0.1:${addrWith.port}`;
+
+  serverNoCtx = await startProxyServer({
+    port: 0,
+    apiKey: TEST_KEY,
+    log: () => {},
+    warn: () => {},
+    getGrokContext: () => null,
+    _grokComplete: stubGrokComplete,
+    _grokCompleteStream: stubGrokCompleteStream,
+  });
+  const addrNo = serverNoCtx.address() as AddressInfo;
+  urlNo = `http://127.0.0.1:${addrNo.port}`;
+});
+
+afterAll(async () => {
+  await new Promise<void>((r) => serverWithCtx.close(() => r()));
+  await new Promise<void>((r) => serverNoCtx.close(() => r()));
+});
+
+// ──────────────────────────────────────────────────────────────────────────────
+// Tests
+// ──────────────────────────────────────────────────────────────────────────────
+
+describe("GET /v1/models includes Grok web-session models", () => {
+  it("lists web-grok/* models", async () => {
+    const { status, body } = await httpGet(`${urlWith}/v1/models`, {
+      Authorization: `Bearer ${TEST_KEY}`,
+    });
+    expect(status).toBe(200);
+    const b = body as { data: Array<{ id: string }> };
+    const grokModels = b.data.filter((m) => m.id.startsWith("web-grok/"));
+    expect(grokModels.length).toBe(4);
+    expect(grokModels.map((m) => m.id)).toContain("web-grok/grok-3");
+    expect(grokModels.map((m) => m.id)).toContain("web-grok/grok-3-mini");
+  });
+
+  it("CLI_MODELS exports 4 grok models", () => {
+    const grok = CLI_MODELS.filter((m) => m.id.startsWith("web-grok/"));
+    expect(grok).toHaveLength(4);
+  });
+});
+
+describe("POST /v1/chat/completions — Grok routing", () => {
+  const auth = { Authorization: `Bearer ${TEST_KEY}` };
+
+  it("returns 503 when no Grok session", async () => {
+    const { status, body } = await httpPost(
+      `${urlNo}/v1/chat/completions`,
+      { model: "web-grok/grok-3", messages: [{ role: "user", content: "Hi" }] },
+      auth
+    );
+    expect(status).toBe(503);
+    const b = body as { error: { code: string } };
+    expect(b.error.code).toBe("no_grok_session");
+  });
+
+  it("returns 200 with mock context (non-streaming)", async () => {
+    stubGrokComplete.mockClear();
+    const { status, body } = await httpPost(
+      `${urlWith}/v1/chat/completions`,
+      { model: "web-grok/grok-3", messages: [{ role: "user", content: "Hello Grok" }], stream: false },
+      auth
+    );
+    expect(status).toBe(200);
+    const b = body as {
+      object: string;
+      model: string;
+      choices: Array<{ message: { content: string }; finish_reason: string }>;
+      usage: { prompt_tokens: number; completion_tokens: number };
+    };
+    expect(b.object).toBe("chat.completion");
+    expect(b.model).toBe("web-grok/grok-3");
+    expect(b.choices[0].message.content).toContain("Hello Grok");
+    expect(b.choices[0].finish_reason).toBe("stop");
+    expect(b.usage.prompt_tokens).toBe(8);
+    expect(b.usage.completion_tokens).toBe(4);
+    expect(stubGrokComplete).toHaveBeenCalledOnce();
+    // stub receives stripped model name
+    expect(stubGrokComplete.mock.calls[0][1].model).toBe("grok-3");
+  });
+
+  it("strips web-grok/ prefix before passing to grokComplete", async () => {
+    stubGrokComplete.mockClear();
+    const { status, body } = await httpPost(
+      `${urlWith}/v1/chat/completions`,
+      { model: "web-grok/grok-3-mini", messages: [{ role: "user", content: "test" }] },
+      auth
+    );
+    expect(status).toBe(200);
+    // response model should still have web-grok/ prefix
+    const b = body as { model: string };
+    expect(b.model).toBe("web-grok/grok-3-mini");
+    // stub receives stripped model
+    expect(stubGrokComplete.mock.calls[0][1].model).toBe("grok-3-mini");
+  });
+
+  it("returns SSE stream for web-grok models", async () => {
+    return new Promise<void>((resolve, reject) => {
+      const data = JSON.stringify({
+        model: "web-grok/grok-3",
+        messages: [{ role: "user", content: "stream test" }],
+        stream: true,
+      });
+      const urlObj = new URL(`${urlWith}/v1/chat/completions`);
+      const req = http.request(
+        {
+          hostname: urlObj.hostname,
+          port: parseInt(urlObj.port),
+          path: urlObj.pathname,
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            "Content-Length": Buffer.byteLength(data),
+            Authorization: `Bearer ${TEST_KEY}`,
+          },
+        },
+        (res) => {
+          expect(res.statusCode).toBe(200);
+          expect(res.headers["content-type"]).toContain("text/event-stream");
+          let raw = "";
+          res.on("data", (c) => (raw += c));
+          res.on("end", () => {
+            const lines = raw.split("\n").filter((l) => l.startsWith("data: "));
+            expect(lines[lines.length - 1]).toBe("data: [DONE]");
+            const tokens = lines
+              .filter((l) => l !== "data: [DONE]")
+              .map((l) => { try { return JSON.parse(l.slice(6)); } catch { return null; } })
+              .filter(Boolean)
+              .flatMap((c) => c.choices?.[0]?.delta?.content ?? []);
+            expect(tokens.join("")).toBe("grok stream mock");
+            resolve();
+          });
+        }
+      );
+      req.on("error", reject);
+      req.write(data);
+      req.end();
+    });
+  });
+
+  it("non-web-grok models bypass Grok routing (go to CLI runner)", async () => {
+    stubGrokComplete.mockClear();
+
+    // Use a separate server with very short CLI timeout so this test finishes quickly
+    const fastSrv = await startProxyServer({
+      port: 0,
+      apiKey: TEST_KEY,
+      timeoutMs: 500, // fail fast — gemini CLI won't be available in test
+      log: () => {},
+      warn: () => {},
+      getGrokContext: () => MOCK_CONTEXT,
+      _grokComplete: stubGrokComplete,
+      _grokCompleteStream: stubGrokCompleteStream,
+    });
+    const addr = fastSrv.address() as AddressInfo;
+    const fastUrl = `http://127.0.0.1:${addr.port}`;
+
+    try {
+      const { status } = await httpPost(
+        `${fastUrl}/v1/chat/completions`,
+        { model: "cli-gemini/gemini-2.5-pro", messages: [{ role: "user", content: "test" }] },
+        auth
+      );
+      expect(status).not.toBe(503); // must NOT be "no_grok_session" — routing is different
+      expect(stubGrokComplete).not.toHaveBeenCalled(); // grokComplete never called for non-grok models
+    } finally {
+      await new Promise<void>((r) => fastSrv.close(() => r()));
+    }
+  }, 10_000);
+});

package/test/grok-session.test.ts

@@ -0,0 +1,133 @@
+/**
+ * test/session.test.ts
+ *
+ * Unit tests for grok-session.ts — persistence, age check, cookie handling.
+ * No browser needed (mocked).
+ */
+
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import { existsSync, unlinkSync, readFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import {
+  loadSession,
+  saveSession,
+  isSessionExpiredByAge,
+  type GrokSession,
+} from "../src/grok-session.js";
+
+const TMP_SESSION = join(tmpdir(), `grok-test-session-${process.pid}.json`);
+
+const MOCK_SESSION: GrokSession = {
+  cookies: [
+    {
+      name: "auth_token",
+      value: "test-token-123",
+      domain: ".grok.com",
+      path: "/",
+      expires: Date.now() / 1000 + 86400,
+      httpOnly: true,
+      secure: true,
+      sameSite: "Lax",
+    },
+    {
+      name: "ct0",
+      value: "csrf-token-abc",
+      domain: ".x.com",
+      path: "/",
+      expires: Date.now() / 1000 + 86400,
+      httpOnly: false,
+      secure: true,
+      sameSite: "Lax",
+    },
+  ],
+  savedAt: Date.now(),
+  userAgent: "Mozilla/5.0 (test)",
+};
+
+describe("grok-session persistence", () => {
+  afterEach(() => {
+    if (existsSync(TMP_SESSION)) unlinkSync(TMP_SESSION);
+  });
+
+  it("returns null when file does not exist", () => {
+    const result = loadSession(TMP_SESSION);
+    expect(result).toBeNull();
+  });
+
+  it("saves and loads a session round-trip", () => {
+    saveSession(TMP_SESSION, MOCK_SESSION);
+    expect(existsSync(TMP_SESSION)).toBe(true);
+
+    const loaded = loadSession(TMP_SESSION);
+    expect(loaded).not.toBeNull();
+    expect(loaded!.cookies).toHaveLength(2);
+    expect(loaded!.cookies[0].name).toBe("auth_token");
+    expect(loaded!.cookies[0].value).toBe("test-token-123");
+    expect(loaded!.userAgent).toBe("Mozilla/5.0 (test)");
+  });
+
+  it("returns null for corrupted JSON", () => {
+    const { writeFileSync } = require("node:fs");
+    writeFileSync(TMP_SESSION, "{ bad json }", "utf-8");
+    const result = loadSession(TMP_SESSION);
+    expect(result).toBeNull();
+  });
+
+  it("returns null for missing cookies field", () => {
+    const { writeFileSync } = require("node:fs");
+    writeFileSync(TMP_SESSION, JSON.stringify({ savedAt: Date.now() }), "utf-8");
+    const result = loadSession(TMP_SESSION);
+    expect(result).toBeNull();
+  });
+
+  it("returns null for cookies field not being array", () => {
+    const { writeFileSync } = require("node:fs");
+    writeFileSync(TMP_SESSION, JSON.stringify({ cookies: "not-array", savedAt: Date.now() }), "utf-8");
+    const result = loadSession(TMP_SESSION);
+    expect(result).toBeNull();
+  });
+
+  it("saves valid JSON that can be parsed independently", () => {
+    saveSession(TMP_SESSION, MOCK_SESSION);
+    const raw = readFileSync(TMP_SESSION, "utf-8");
+    expect(() => JSON.parse(raw)).not.toThrow();
+    const parsed = JSON.parse(raw);
+    expect(parsed.savedAt).toBeTypeOf("number");
+  });
+
+  it("overwrites existing session file", () => {
+    saveSession(TMP_SESSION, MOCK_SESSION);
+
+    const updated: GrokSession = { ...MOCK_SESSION, userAgent: "updated-ua", savedAt: Date.now() };
+    saveSession(TMP_SESSION, updated);
+
+    const loaded = loadSession(TMP_SESSION);
+    expect(loaded!.userAgent).toBe("updated-ua");
+  });
+});
+
+describe("session age check", () => {
+  it("fresh session is not expired", () => {
+    const session: GrokSession = { ...MOCK_SESSION, savedAt: Date.now() };
+    expect(isSessionExpiredByAge(session)).toBe(false);
+  });
+
+  it("session saved 6 days ago is not expired", () => {
+    const sixDaysAgo = Date.now() - 6 * 24 * 60 * 60 * 1000;
+    const session: GrokSession = { ...MOCK_SESSION, savedAt: sixDaysAgo };
+    expect(isSessionExpiredByAge(session)).toBe(false);
+  });
+
+  it("session saved 8 days ago is expired", () => {
+    const eightDaysAgo = Date.now() - 8 * 24 * 60 * 60 * 1000;
+    const session: GrokSession = { ...MOCK_SESSION, savedAt: eightDaysAgo };
+    expect(isSessionExpiredByAge(session)).toBe(true);
+  });
+
+  it("session saved exactly 7 days ago is expired", () => {
+    const sevenDaysAgo = Date.now() - 7 * 24 * 60 * 60 * 1000 - 1;
+    const session: GrokSession = { ...MOCK_SESSION, savedAt: sevenDaysAgo };
+    expect(isSessionExpiredByAge(session)).toBe(true);
+  });
+});