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

package/src/grok-session.ts

@@ -0,0 +1,195 @@
+/**
+ * grok-session.ts
+ *
+ * Manages a persistent grok.com browser session using Playwright.
+ *
+ * Auth flow:
+ *  1. First run: open Chromium, navigate to grok.com → user logs in manually via X.com OAuth
+ *  2. On success: save cookies + localStorage to SESSION_PATH
+ *  3. Subsequent runs: restore session from file, verify still valid
+ *  4. If session expired: repeat step 1
+ *
+ * The saved session file is stored at ~/.openclaw/grok-session.json
+ */
+
+import { existsSync, readFileSync, writeFileSync, mkdirSync, unlinkSync } from "node:fs";
+import { homedir } from "node:os";
+import { join, dirname } from "node:path";
+import type { Browser, BrowserContext, Cookie } from "playwright";
+
+export const DEFAULT_SESSION_PATH = join(
+  homedir(),
+  ".openclaw",
+  "grok-session.json"
+);
+
+export const GROK_HOME = "https://grok.com";
+export const GROK_API_BASE = "https://grok.com/api";
+
+/** Stored session data */
+export interface GrokSession {
+  cookies: Cookie[];
+  savedAt: number; // epoch ms
+  userAgent?: string;
+}
+
+/** Result of a session check */
+export interface SessionCheckResult {
+  valid: boolean;
+  reason?: string;
+}
+
+// ──────────────────────────────────────────────────────────────────────────────
+// Persistence helpers
+// ──────────────────────────────────────────────────────────────────────────────
+
+export function loadSession(sessionPath: string): GrokSession | null {
+  if (!existsSync(sessionPath)) return null;
+  try {
+    const raw = readFileSync(sessionPath, "utf-8");
+    const parsed = JSON.parse(raw) as GrokSession;
+    if (!parsed.cookies || !Array.isArray(parsed.cookies)) return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+
+export function saveSession(
+  sessionPath: string,
+  session: GrokSession
+): void {
+  mkdirSync(dirname(sessionPath), { recursive: true });
+  writeFileSync(sessionPath, JSON.stringify(session, null, 2), "utf-8");
+}
+
+export function deleteSession(sessionPath: string): void {
+  if (existsSync(sessionPath)) {
+    unlinkSync(sessionPath);
+  }
+}
+
+// ──────────────────────────────────────────────────────────────────────────────
+// Session validation
+// ──────────────────────────────────────────────────────────────────────────────
+
+const SESSION_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1000; // 7 days
+
+export function isSessionExpiredByAge(session: GrokSession): boolean {
+  return Date.now() - session.savedAt > SESSION_MAX_AGE_MS;
+}
+
+/**
+ * Verify the session is still valid by making a lightweight API call.
+ * Returns {valid: true} if the session works, {valid: false, reason} otherwise.
+ */
+export async function verifySession(
+  context: BrowserContext,
+  log: (msg: string) => void
+): Promise<SessionCheckResult> {
+  const page = await context.newPage();
+  try {
+    log("verifying grok session...");
+    await page.goto(GROK_HOME, { waitUntil: "domcontentloaded", timeout: 15_000 });
+
+    // If we see Sign In link → not logged in
+    const signIn = page.locator('a[href*="sign-in"], a[href*="/login"]');
+    const signInVisible = await signIn.isVisible().catch(() => false);
+    if (signInVisible) {
+      return { valid: false, reason: "sign-in link visible — session expired" };
+    }
+
+    // If we see the chat input → logged in
+    const chatInput = page.locator('textarea, [placeholder*="mind"], [aria-label*="message"]');
+    const chatVisible = await chatInput.isVisible().catch(() => false);
+    if (chatVisible) {
+      log("session valid ✅");
+      return { valid: true };
+    }
+
+    // Ambiguous — try API endpoint
+    const resp = await page.evaluate(async () => {
+      try {
+        const r = await fetch("https://grok.com/rest/app-chat/conversations", {
+          method: "GET",
+          credentials: "include",
+        });
+        return { status: r.status };
+      } catch (e: unknown) {
+        return { status: 0, error: String(e) };
+      }
+    });
+
+    if (resp.status === 200 || resp.status === 204) {
+      log("session valid via API check ✅");
+      return { valid: true };
+    }
+    if (resp.status === 401 || resp.status === 403) {
+      return { valid: false, reason: `API returned ${resp.status}` };
+    }
+
+    log(`session check ambiguous (status ${resp.status}) — assuming valid`);
+    return { valid: true };
+  } finally {
+    await page.close();
+  }
+}
+
+// ──────────────────────────────────────────────────────────────────────────────
+// Interactive login (opens visible browser window)
+// ──────────────────────────────────────────────────────────────────────────────
+
+export async function runInteractiveLogin(
+  browser: Browser,
+  sessionPath: string,
+  log: (msg: string) => void,
+  timeoutMs = 5 * 60 * 1000
+): Promise<GrokSession> {
+  log("opening browser for grok.com login — please sign in with your X account...");
+
+  const context = await browser.newContext({
+    viewport: { width: 1280, height: 800 },
+  });
+  const page = await context.newPage();
+
+  await page.goto(GROK_HOME, { waitUntil: "domcontentloaded", timeout: 15_000 });
+
+  // Wait for sign-in to complete: look for chat textarea to appear
+  log(`waiting for login (timeout: ${timeoutMs / 1000}s)...`);
+  await page.waitForSelector(
+    'textarea, [placeholder*="mind"], [aria-label*="message"]',
+    { timeout: timeoutMs }
+  );
+
+  log("login detected — saving session...");
+  const cookies = await context.cookies();
+  const userAgent = await page.evaluate(() => navigator.userAgent);
+
+  const session: GrokSession = {
+    cookies,
+    savedAt: Date.now(),
+    userAgent,
+  };
+
+  saveSession(sessionPath, session);
+  log(`session saved to ${sessionPath}`);
+
+  await context.close();
+  return session;
+}
+
+// ──────────────────────────────────────────────────────────────────────────────
+// Context factory: create a BrowserContext with restored cookies
+// ──────────────────────────────────────────────────────────────────────────────
+
+export async function createContextFromSession(
+  browser: Browser,
+  session: GrokSession
+): Promise<BrowserContext> {
+  const context = await browser.newContext({
+    userAgent: session.userAgent,
+    viewport: { width: 1280, height: 800 },
+  });
+  await context.addCookies(session.cookies);
+  return context;
+}

package/src/proxy-server.ts

@@ -12,6 +12,12 @@ import http from "node:http";
 import { randomBytes } from "node:crypto";
 import { type ChatMessage, routeToCliRunner } from "./cli-runner.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 },
 ];
 
 // ──────────────────────────────────────────────────────────────────────────────
@@ -176,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);
@@ -187,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);
+});