@elvatis_com/openclaw-cli-bridge-elvatis 1.5.1 → 1.6.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elvatis_com/openclaw-cli-bridge-elvatis",
-  "version": "1.5.1",
+  "version": "1.6.2",
   "description": "Bridges gemini, claude, and codex CLI tools as OpenClaw model providers. Reads existing CLI auth without re-login.",
   "type": "module",
   "openclaw": {

package/src/proxy-server.ts

@@ -14,6 +14,8 @@ 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 { geminiComplete, geminiCompleteStream, type ChatMessage as GeminiBrowserChatMessage } from "./gemini-browser.js";
+import { claudeComplete, claudeCompleteStream, type ChatMessage as ClaudeBrowserChatMessage } from "./claude-browser.js";
+import { chatgptComplete, chatgptCompleteStream, type ChatMessage as ChatGPTBrowserChatMessage } from "./chatgpt-browser.js";
 import type { BrowserContext } from "playwright";
 
 export type GrokCompleteOptions = Parameters<typeof grokComplete>[1];
@@ -42,6 +44,22 @@ export interface ProxyServerOptions {
   _geminiComplete?: typeof geminiComplete;
   /** Override for testing — replaces geminiCompleteStream */
   _geminiCompleteStream?: typeof geminiCompleteStream;
+  /** Returns the current authenticated Claude BrowserContext (null if not logged in) */
+  getClaudeContext?: () => BrowserContext | null;
+  /** Async lazy connect — called when getClaudeContext returns null */
+  connectClaudeContext?: () => Promise<BrowserContext | null>;
+  /** Override for testing — replaces claudeComplete */
+  _claudeComplete?: typeof claudeComplete;
+  /** Override for testing — replaces claudeCompleteStream */
+  _claudeCompleteStream?: typeof claudeCompleteStream;
+  /** Returns the current authenticated ChatGPT BrowserContext (null if not logged in) */
+  getChatGPTContext?: () => BrowserContext | null;
+  /** Async lazy connect — called when getChatGPTContext returns null */
+  connectChatGPTContext?: () => Promise<BrowserContext | null>;
+  /** Override for testing — replaces chatgptComplete */
+  _chatgptComplete?: typeof chatgptComplete;
+  /** Override for testing — replaces chatgptCompleteStream */
+  _chatgptCompleteStream?: typeof chatgptCompleteStream;
 }
 
 /** Available CLI bridge models for GET /v1/models */
@@ -64,6 +82,16 @@ export const CLI_MODELS = [
   { id: "web-gemini/gemini-2-5-flash", name: "Gemini 2.5 Flash (web session)", contextWindow: 1_000_000, maxTokens: 8192 },
   { id: "web-gemini/gemini-3-pro",     name: "Gemini 3 Pro (web session)",     contextWindow: 1_000_000, maxTokens: 8192 },
   { id: "web-gemini/gemini-3-flash",   name: "Gemini 3 Flash (web session)",   contextWindow: 1_000_000, maxTokens: 8192 },
+  // Claude web-session models (requires /claude-login)
+  { id: "web-claude/claude-sonnet",     name: "Claude Sonnet (web session)",     contextWindow: 200_000, maxTokens: 8192 },
+  { id: "web-claude/claude-opus",       name: "Claude Opus (web session)",       contextWindow: 200_000, maxTokens: 8192 },
+  { id: "web-claude/claude-haiku",      name: "Claude Haiku (web session)",      contextWindow: 200_000, maxTokens: 8192 },
+  // ChatGPT web-session models (requires /chatgpt-login)
+  { id: "web-chatgpt/gpt-4o",           name: "GPT-4o (web session)",            contextWindow: 128_000, maxTokens: 8192 },
+  { id: "web-chatgpt/gpt-4o-mini",      name: "GPT-4o Mini (web session)",       contextWindow: 128_000, maxTokens: 8192 },
+  { id: "web-chatgpt/gpt-o3",           name: "GPT o3 (web session)",            contextWindow: 200_000, maxTokens: 8192 },
+  { id: "web-chatgpt/gpt-o4-mini",      name: "GPT o4-mini (web session)",       contextWindow: 200_000, maxTokens: 8192 },
+  { id: "web-chatgpt/gpt-5",            name: "GPT-5 (web session)",             contextWindow: 200_000, maxTokens: 8192 },
 ];
 
 // ──────────────────────────────────────────────────────────────────────────────
@@ -284,6 +312,105 @@ async function handleRequest(
     }
     // ─────────────────────────────────────────────────────────────────────────
 
+    // ── Claude web-session routing ────────────────────────────────────────────
+    if (model.startsWith("web-claude/")) {
+      let claudeCtx = opts.getClaudeContext?.() ?? null;
+      if (!claudeCtx && opts.connectClaudeContext) {
+        claudeCtx = await opts.connectClaudeContext();
+      }
+      if (!claudeCtx) {
+        res.writeHead(503, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: { message: "No active claude.ai session. Use /claude-login to authenticate.", code: "no_claude_session" } }));
+        return;
+      }
+      const timeoutMs = opts.timeoutMs ?? 120_000;
+      const claudeMessages = messages as ClaudeBrowserChatMessage[];
+      const doClaudeComplete = opts._claudeComplete ?? claudeComplete;
+      const doClaudeCompleteStream = opts._claudeCompleteStream ?? claudeCompleteStream;
+      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 doClaudeCompleteStream(
+            claudeCtx,
+            { messages: claudeMessages, model, 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 doClaudeComplete(claudeCtx, { messages: claudeMessages, model, 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: 0, completion_tokens: 0, total_tokens: 0 },
+          }));
+        }
+      } catch (err) {
+        const msg = (err as Error).message;
+        opts.warn(`[cli-bridge] Claude browser error for ${model}: ${msg}`);
+        if (!res.headersSent) {
+          res.writeHead(500, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: { message: msg, type: "claude_browser_error" } }));
+        }
+      }
+      return;
+    }
+    // ─────────────────────────────────────────────────────────────────────────
+
+    // ── ChatGPT web-session routing ──────────────────────────────────────────
+    if (model.startsWith("web-chatgpt/")) {
+      let chatgptCtx = opts.getChatGPTContext?.() ?? null;
+      if (!chatgptCtx && opts.connectChatGPTContext) {
+        chatgptCtx = await opts.connectChatGPTContext();
+      }
+      if (!chatgptCtx) {
+        res.writeHead(503, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: { message: "No active chatgpt.com session. Use /chatgpt-login to authenticate.", code: "no_chatgpt_session" } }));
+        return;
+      }
+      const chatgptModel = model.replace("web-chatgpt/", "");
+      const timeoutMs = opts.timeoutMs ?? 120_000;
+      const chatgptMessages = messages as ChatGPTBrowserChatMessage[];
+      const doChatGPTComplete = opts._chatgptComplete ?? chatgptComplete;
+      const doChatGPTCompleteStream = opts._chatgptCompleteStream ?? chatgptCompleteStream;
+      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 doChatGPTCompleteStream(
+            chatgptCtx,
+            { messages: chatgptMessages, model: chatgptModel, 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 doChatGPTComplete(chatgptCtx, { messages: chatgptMessages, model: chatgptModel, 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: 0, completion_tokens: 0, total_tokens: 0 },
+          }));
+        }
+      } catch (err) {
+        const msg = (err as Error).message;
+        opts.warn(`[cli-bridge] ChatGPT browser error for ${model}: ${msg}`);
+        if (!res.headersSent) {
+          res.writeHead(500, { "Content-Type": "application/json" });
+          res.end(JSON.stringify({ error: { message: msg, type: "chatgpt_browser_error" } }));
+        }
+      }
+      return;
+    }
+    // ─────────────────────────────────────────────────────────────────────────
+
     // ── CLI runner routing (Gemini / Claude Code) ─────────────────────────────
     let content: string;
     try {

package/test/chatgpt-proxy.test.ts

@@ -0,0 +1,153 @@
+/**
+ * test/chatgpt-proxy.test.ts
+ *
+ * Tests for ChatGPT web-session routing in the cli-bridge proxy.
+ * Uses _chatgptComplete/_chatgptCompleteStream DI overrides (no real browser).
+ */
+
+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";
+
+type ChatGPTCompleteOptions = { messages: { role: string; content: string }[]; model?: string; timeoutMs?: number };
+type ChatGPTCompleteResult = { content: string; model: string; finishReason: string };
+
+const stubChatGPTComplete = vi.fn(async (
+  _ctx: BrowserContext,
+  opts: ChatGPTCompleteOptions,
+  _log: (msg: string) => void
+): Promise<ChatGPTCompleteResult> => ({
+  content: `chatgpt mock: ${opts.messages[opts.messages.length - 1]?.content ?? ""}`,
+  model: opts.model ?? "gpt-4o",
+  finishReason: "stop",
+}));
+
+const stubChatGPTCompleteStream = vi.fn(async (
+  _ctx: BrowserContext,
+  opts: ChatGPTCompleteOptions,
+  onToken: (t: string) => void,
+  _log: (msg: string) => void
+): Promise<ChatGPTCompleteResult> => {
+  const tokens = ["chatgpt ", "stream ", "mock"];
+  for (const t of tokens) onToken(t);
+  return { content: tokens.join(""), model: opts.model ?? "gpt-4o", finishReason: "stop" };
+});
+
+async function httpPost(url: string, body: unknown): Promise<{ status: number; body: unknown }> {
+  return new Promise((resolve, reject) => {
+    const data = JSON.stringify(body);
+    const u = new URL(url);
+    const req = http.request(
+      { hostname: u.hostname, port: Number(u.port), path: u.pathname, method: "POST",
+        headers: { "Content-Type": "application/json", "Content-Length": Buffer.byteLength(data) } },
+      (res) => { let raw = ""; res.on("data", c => raw += c); res.on("end", () => { try { resolve({ status: res.statusCode ?? 0, body: JSON.parse(raw) }); } catch { resolve({ status: res.statusCode ?? 0, body: raw }); } }); }
+    );
+    req.on("error", reject); req.write(data); req.end();
+  });
+}
+async function httpGet(url: string): Promise<{ status: number; body: unknown }> {
+  return new Promise((resolve, reject) => {
+    const u = new URL(url);
+    const req = http.request({ hostname: u.hostname, port: Number(u.port), path: u.pathname, method: "GET" },
+      (res) => { let raw = ""; res.on("data", c => raw += c); res.on("end", () => { try { resolve({ status: res.statusCode ?? 0, body: JSON.parse(raw) }); } catch { resolve({ status: res.statusCode ?? 0, body: raw }); } }); }
+    );
+    req.on("error", reject); req.end();
+  });
+}
+
+const fakeCtx = {} as BrowserContext;
+let server: http.Server;
+let baseUrl: string;
+
+beforeAll(async () => {
+  server = await startProxyServer({
+    port: 0, log: () => {}, warn: () => {},
+    getChatGPTContext: () => fakeCtx,
+    // @ts-expect-error — stub types close enough for testing
+    _chatgptComplete: stubChatGPTComplete,
+    // @ts-expect-error — stub types close enough for testing
+    _chatgptCompleteStream: stubChatGPTCompleteStream,
+  });
+  baseUrl = `http://127.0.0.1:${(server.address() as AddressInfo).port}`;
+});
+afterAll(() => server.close());
+
+describe("ChatGPT web-session routing — model list", () => {
+  it("includes web-chatgpt/* models in /v1/models", async () => {
+    const res = await httpGet(`${baseUrl}/v1/models`);
+    expect(res.status).toBe(200);
+    const ids = (res.body as { data: { id: string }[] }).data.map(m => m.id);
+    expect(ids).toContain("web-chatgpt/gpt-4o");
+    expect(ids).toContain("web-chatgpt/gpt-4o-mini");
+    expect(ids).toContain("web-chatgpt/gpt-o3");
+    expect(ids).toContain("web-chatgpt/gpt-o4-mini");
+    expect(ids).toContain("web-chatgpt/gpt-5");
+  });
+
+  it("web-chatgpt/* models listed in CLI_MODELS constant", () => {
+    const chatgpt = CLI_MODELS.filter(m => m.id.startsWith("web-chatgpt/"));
+    expect(chatgpt).toHaveLength(5);
+  });
+});
+
+describe("ChatGPT web-session routing — non-streaming", () => {
+  it("returns assistant message for web-chatgpt/gpt-4o", async () => {
+    const res = await httpPost(`${baseUrl}/v1/chat/completions`, {
+      model: "web-chatgpt/gpt-4o",
+      messages: [{ role: "user", content: "hello chatgpt" }],
+      stream: false,
+    });
+    expect(res.status).toBe(200);
+    const body = res.body as { choices: { message: { content: string } }[] };
+    expect(body.choices[0].message.content).toContain("chatgpt mock");
+    expect(body.choices[0].message.content).toContain("hello chatgpt");
+  });
+
+  it("strips web-chatgpt/ prefix before passing to chatgptComplete", async () => {
+    stubChatGPTComplete.mockClear();
+    await httpPost(`${baseUrl}/v1/chat/completions`, {
+      model: "web-chatgpt/gpt-o3",
+      messages: [{ role: "user", content: "test" }],
+    });
+    expect(stubChatGPTComplete).toHaveBeenCalledOnce();
+    expect(stubChatGPTComplete.mock.calls[0][1].model).toBe("gpt-o3");
+  });
+
+  it("response model preserves web-chatgpt/ prefix", async () => {
+    const res = await httpPost(`${baseUrl}/v1/chat/completions`, {
+      model: "web-chatgpt/gpt-5",
+      messages: [{ role: "user", content: "hi" }],
+    });
+    expect(res.status).toBe(200);
+    const body = res.body as { model: string };
+    expect(body.model).toBe("web-chatgpt/gpt-5");
+  });
+
+  it("returns 503 when no chatgpt context", async () => {
+    const s = await startProxyServer({ port: 0, log: () => {}, warn: () => {}, getChatGPTContext: () => null });
+    const url = `http://127.0.0.1:${(s.address() as AddressInfo).port}`;
+    const res = await httpPost(`${url}/v1/chat/completions`, {
+      model: "web-chatgpt/gpt-4o",
+      messages: [{ role: "user", content: "hi" }],
+    });
+    expect(res.status).toBe(503);
+    expect((res.body as { error: { code: string } }).error.code).toBe("no_chatgpt_session");
+    s.close();
+  });
+});
+
+describe("ChatGPT web-session routing — streaming", () => {
+  it("returns SSE stream", async () => {
+    return new Promise<void>((resolve, reject) => {
+      const body = JSON.stringify({ model: "web-chatgpt/gpt-4o", messages: [{ role: "user", content: "stream" }], stream: true });
+      const u = new URL(`${baseUrl}/v1/chat/completions`);
+      const req = http.request({ hostname: u.hostname, port: Number(u.port), path: u.pathname, method: "POST",
+        headers: { "Content-Type": "application/json", "Content-Length": Buffer.byteLength(body) } },
+        (res) => { expect(res.statusCode).toBe(200); let raw = ""; res.on("data", c => raw += c); res.on("end", () => { expect(raw).toContain("[DONE]"); resolve(); }); }
+      );
+      req.on("error", reject); req.write(body); req.end();
+    });
+  });
+});

package/test/claude-proxy.test.ts

@@ -0,0 +1,140 @@
+/**
+ * test/claude-proxy.test.ts
+ *
+ * Tests for Claude web-session routing in the cli-bridge proxy.
+ * Uses _claudeComplete/_claudeCompleteStream DI overrides (no real browser).
+ */
+
+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";
+
+type ClaudeCompleteOptions = { messages: { role: string; content: string }[]; model?: string; timeoutMs?: number };
+type ClaudeCompleteResult = { content: string; model: string; finishReason: string };
+
+const stubClaudeComplete = vi.fn(async (
+  _ctx: BrowserContext,
+  opts: ClaudeCompleteOptions,
+  _log: (msg: string) => void
+): Promise<ClaudeCompleteResult> => ({
+  content: `claude mock: ${opts.messages[opts.messages.length - 1]?.content ?? ""}`,
+  model: opts.model ?? "web-claude/claude-sonnet",
+  finishReason: "stop",
+}));
+
+const stubClaudeCompleteStream = vi.fn(async (
+  _ctx: BrowserContext,
+  opts: ClaudeCompleteOptions,
+  onToken: (t: string) => void,
+  _log: (msg: string) => void
+): Promise<ClaudeCompleteResult> => {
+  const tokens = ["claude ", "stream ", "mock"];
+  for (const t of tokens) onToken(t);
+  return { content: tokens.join(""), model: opts.model ?? "web-claude/claude-sonnet", finishReason: "stop" };
+});
+
+async function httpPost(url: string, body: unknown): Promise<{ status: number; body: unknown }> {
+  return new Promise((resolve, reject) => {
+    const data = JSON.stringify(body);
+    const u = new URL(url);
+    const req = http.request(
+      { hostname: u.hostname, port: Number(u.port), path: u.pathname, method: "POST",
+        headers: { "Content-Type": "application/json", "Content-Length": Buffer.byteLength(data) } },
+      (res) => { let raw = ""; res.on("data", c => raw += c); res.on("end", () => { try { resolve({ status: res.statusCode ?? 0, body: JSON.parse(raw) }); } catch { resolve({ status: res.statusCode ?? 0, body: raw }); } }); }
+    );
+    req.on("error", reject); req.write(data); req.end();
+  });
+}
+async function httpGet(url: string): Promise<{ status: number; body: unknown }> {
+  return new Promise((resolve, reject) => {
+    const u = new URL(url);
+    const req = http.request({ hostname: u.hostname, port: Number(u.port), path: u.pathname, method: "GET" },
+      (res) => { let raw = ""; res.on("data", c => raw += c); res.on("end", () => { try { resolve({ status: res.statusCode ?? 0, body: JSON.parse(raw) }); } catch { resolve({ status: res.statusCode ?? 0, body: raw }); } }); }
+    );
+    req.on("error", reject); req.end();
+  });
+}
+
+const fakeCtx = {} as BrowserContext;
+let server: http.Server;
+let baseUrl: string;
+
+beforeAll(async () => {
+  server = await startProxyServer({
+    port: 0, log: () => {}, warn: () => {},
+    getClaudeContext: () => fakeCtx,
+    // @ts-expect-error — stub types close enough for testing
+    _claudeComplete: stubClaudeComplete,
+    // @ts-expect-error — stub types close enough for testing
+    _claudeCompleteStream: stubClaudeCompleteStream,
+  });
+  baseUrl = `http://127.0.0.1:${(server.address() as AddressInfo).port}`;
+});
+afterAll(() => server.close());
+
+describe("Claude web-session routing — model list", () => {
+  it("includes web-claude/* models in /v1/models", async () => {
+    const res = await httpGet(`${baseUrl}/v1/models`);
+    expect(res.status).toBe(200);
+    const ids = (res.body as { data: { id: string }[] }).data.map(m => m.id);
+    expect(ids).toContain("web-claude/claude-sonnet");
+    expect(ids).toContain("web-claude/claude-opus");
+    expect(ids).toContain("web-claude/claude-haiku");
+  });
+
+  it("web-claude/* models listed in CLI_MODELS constant", () => {
+    expect(CLI_MODELS.some(m => m.id.startsWith("web-claude/"))).toBe(true);
+  });
+});
+
+describe("Claude web-session routing — non-streaming", () => {
+  it("returns assistant message for web-claude/claude-sonnet", async () => {
+    const res = await httpPost(`${baseUrl}/v1/chat/completions`, {
+      model: "web-claude/claude-sonnet",
+      messages: [{ role: "user", content: "hello claude" }],
+      stream: false,
+    });
+    expect(res.status).toBe(200);
+    const body = res.body as { choices: { message: { content: string } }[] };
+    expect(body.choices[0].message.content).toContain("claude mock");
+    expect(body.choices[0].message.content).toContain("hello claude");
+  });
+
+  it("passes model to stub unchanged", async () => {
+    stubClaudeComplete.mockClear();
+    await httpPost(`${baseUrl}/v1/chat/completions`, {
+      model: "web-claude/claude-opus",
+      messages: [{ role: "user", content: "test" }],
+    });
+    expect(stubClaudeComplete).toHaveBeenCalledOnce();
+    expect(stubClaudeComplete.mock.calls[0][1].model).toBe("web-claude/claude-opus");
+  });
+
+  it("returns 503 when no claude context", async () => {
+    const s = await startProxyServer({ port: 0, log: () => {}, warn: () => {}, getClaudeContext: () => null });
+    const url = `http://127.0.0.1:${(s.address() as AddressInfo).port}`;
+    const res = await httpPost(`${url}/v1/chat/completions`, {
+      model: "web-claude/claude-sonnet",
+      messages: [{ role: "user", content: "hi" }],
+    });
+    expect(res.status).toBe(503);
+    expect((res.body as { error: { code: string } }).error.code).toBe("no_claude_session");
+    s.close();
+  });
+});
+
+describe("Claude web-session routing — streaming", () => {
+  it("returns SSE stream", async () => {
+    return new Promise<void>((resolve, reject) => {
+      const body = JSON.stringify({ model: "web-claude/claude-sonnet", messages: [{ role: "user", content: "stream" }], stream: true });
+      const u = new URL(`${baseUrl}/v1/chat/completions`);
+      const req = http.request({ hostname: u.hostname, port: Number(u.port), path: u.pathname, method: "POST",
+        headers: { "Content-Type": "application/json", "Content-Length": Buffer.byteLength(body) } },
+        (res) => { expect(res.statusCode).toBe(200); let raw = ""; res.on("data", c => raw += c); res.on("end", () => { expect(raw).toContain("[DONE]"); resolve(); }); }
+      );
+      req.on("error", reject); req.write(body); req.end();
+    });
+  });
+});