@elvatis_com/openclaw-cli-bridge-elvatis 0.2.28 → 0.2.30

package/test/claude-browser.test.ts

@@ -0,0 +1,93 @@
+/**
+ * test/claude-browser.test.ts
+ *
+ * Unit tests for claude-browser.ts helper functions.
+ * Does not require a real browser — tests the pure logic.
+ */
+
+import { describe, it, expect } from "vitest";
+
+// ─── Test the flatten + model resolution logic directly ──────────────────────
+// We import internal helpers by re-exporting them from a test shim, or we just
+// test the public surface via duck-typed mocks.
+
+describe("claude-browser — model resolution", () => {
+  // We can test via the exported functions indirectly through proxy tests.
+  // Direct unit tests use small isolated helpers copied here.
+
+  function resolveModel(m?: string): string {
+    const clean = (m ?? "claude-sonnet").replace("web-claude/", "");
+    const allowed = ["claude-sonnet","claude-opus","claude-haiku","claude-sonnet-4-5","claude-sonnet-4-6","claude-opus-4-5"];
+    return allowed.includes(clean) ? clean : "claude-sonnet";
+  }
+
+  it("strips web-claude/ prefix", () => {
+    expect(resolveModel("web-claude/claude-sonnet")).toBe("claude-sonnet");
+    expect(resolveModel("web-claude/claude-opus")).toBe("claude-opus");
+  });
+
+  it("falls back to claude-sonnet for unknown models", () => {
+    expect(resolveModel("web-claude/unknown-model")).toBe("claude-sonnet");
+    expect(resolveModel(undefined)).toBe("claude-sonnet");
+  });
+
+  it("accepts known models without prefix", () => {
+    expect(resolveModel("claude-sonnet-4-6")).toBe("claude-sonnet-4-6");
+    expect(resolveModel("claude-opus")).toBe("claude-opus");
+  });
+});
+
+describe("claude-browser — message flattening", () => {
+  function flattenMessages(messages: { role: string; content: string }[]): string {
+    if (messages.length === 1) return messages[0].content;
+    return messages.map((m) => {
+      if (m.role === "system") return `[System]: ${m.content}`;
+      if (m.role === "assistant") return `[Assistant]: ${m.content}`;
+      return m.content;
+    }).join("\n\n");
+  }
+
+  it("returns content directly for single user message", () => {
+    expect(flattenMessages([{ role: "user", content: "hello" }])).toBe("hello");
+  });
+
+  it("prefixes system messages", () => {
+    const result = flattenMessages([
+      { role: "system", content: "Be brief" },
+      { role: "user", content: "hi" },
+    ]);
+    expect(result).toContain("[System]: Be brief");
+    expect(result).toContain("hi");
+  });
+
+  it("prefixes assistant turns in multi-turn", () => {
+    const result = flattenMessages([
+      { role: "user", content: "Hello" },
+      { role: "assistant", content: "Hi there" },
+      { role: "user", content: "How are you?" },
+    ]);
+    expect(result).toContain("[Assistant]: Hi there");
+    expect(result).toContain("How are you?");
+  });
+});
+
+describe("claude-browser — proxy routing (DI override)", () => {
+  // Test that web-claude/* models route correctly through the proxy
+  // using the same DI pattern as grok-proxy.test.ts
+
+  it("web-claude/* model IDs follow naming convention", () => {
+    const validModels = [
+      "web-claude/claude-sonnet",
+      "web-claude/claude-opus",
+      "web-claude/claude-haiku",
+    ];
+    for (const m of validModels) {
+      expect(m.startsWith("web-claude/")).toBe(true);
+    }
+  });
+
+  it("distinguishes web-claude from web-grok", () => {
+    expect("web-claude/claude-sonnet".startsWith("web-claude/")).toBe(true);
+    expect("web-grok/grok-3".startsWith("web-claude/")).toBe(false);
+  });
+});

package/test/claude-proxy.test.ts

@@ -0,0 +1,235 @@
+/**
+ * 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";
+
+// ── Stub types matching claude-browser exports ────────────────────────────────
+type ClaudeCompleteOptions = {
+  messages: { role: string; content: string }[];
+  model?: string;
+  timeoutMs?: number;
+};
+type ClaudeCompleteResult = { content: string; model: string; finishReason: string };
+
+// ── Stubs ─────────────────────────────────────────────────────────────────────
+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" };
+});
+
+// ── HTTP helper ───────────────────────────────────────────────────────────────
+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: Number(urlObj.port), path: urlObj.pathname, method: "POST",
+        headers: { "Content-Type": "application/json", "Content-Length": Buffer.byteLength(data), ...headers } },
+      (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 urlObj = new URL(url);
+    const req = http.request(
+      { hostname: urlObj.hostname, port: Number(urlObj.port), path: urlObj.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();
+  });
+}
+
+// ── Fake context ──────────────────────────────────────────────────────────────
+const fakeClaudeCtx = {} as BrowserContext;
+
+// ── Server setup ──────────────────────────────────────────────────────────────
+let server: http.Server;
+let baseUrl: string;
+
+beforeAll(async () => {
+  server = await startProxyServer({
+    port: 0,
+    log: () => {},
+    warn: () => {},
+    getClaudeContext: () => fakeClaudeCtx,
+    // @ts-expect-error — stub types close enough for testing
+    _claudeComplete: stubClaudeComplete,
+    // @ts-expect-error — stub types close enough for testing
+    _claudeCompleteStream: stubClaudeCompleteStream,
+  });
+  const addr = server.address() as AddressInfo;
+  baseUrl = `http://127.0.0.1:${addr.port}`;
+});
+
+afterAll(() => server.close());
+
+// ── Tests ─────────────────────────────────────────────────────────────────────
+
+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 data = res.body as { data: { id: string }[] };
+    const ids = data.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", () => {
+    const ids = CLI_MODELS.map((m) => m.id);
+    expect(ids.some((id) => 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" }],
+      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");
+  });
+
+  it("calls stubClaudeComplete with correct model and messages", async () => {
+    stubClaudeComplete.mockClear();
+    await httpPost(`${baseUrl}/v1/chat/completions`, {
+      model: "web-claude/claude-opus",
+      messages: [{ role: "user", content: "test" }],
+      stream: false,
+    });
+    expect(stubClaudeComplete).toHaveBeenCalledOnce();
+    const call = stubClaudeComplete.mock.calls[0];
+    expect(call[0]).toBe(fakeClaudeCtx);
+    expect(call[1].model).toBe("web-claude/claude-opus");
+  });
+
+  it("returns 503 when no claude context is available", async () => {
+    const noCtxServer = await startProxyServer({
+      port: 0, log: () => {}, warn: () => {},
+      getClaudeContext: () => null,
+    });
+    const addr = noCtxServer.address() as AddressInfo;
+    const noCtxUrl = `http://127.0.0.1:${addr.port}`;
+    const res = await httpPost(`${noCtxUrl}/v1/chat/completions`, {
+      model: "web-claude/claude-sonnet",
+      messages: [{ role: "user", content: "hi" }],
+    });
+    expect(res.status).toBe(503);
+    const body = res.body as { error: { code: string } };
+    expect(body.error.code).toBe("no_claude_session");
+    noCtxServer.close();
+  });
+});
+
+describe("Claude web-session routing — streaming", () => {
+  it("returns SSE stream for web-claude/claude-sonnet", async () => {
+    return new Promise<void>((resolve, reject) => {
+      const body = JSON.stringify({
+        model: "web-claude/claude-sonnet",
+        messages: [{ role: "user", content: "stream test" }],
+        stream: true,
+      });
+      const urlObj = new URL(`${baseUrl}/v1/chat/completions`);
+      const req = http.request(
+        { hostname: urlObj.hostname, port: Number(urlObj.port), path: urlObj.pathname, method: "POST",
+          headers: { "Content-Type": "application/json", "Content-Length": Buffer.byteLength(body) } },
+        (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", () => {
+            expect(raw).toContain("data:");
+            expect(raw).toContain("[DONE]");
+            resolve();
+          });
+        }
+      );
+      req.on("error", reject);
+      req.write(body);
+      req.end();
+    });
+  });
+
+  it("streams tokens from stub", async () => {
+    stubClaudeCompleteStream.mockClear();
+    return new Promise<void>((resolve, reject) => {
+      const body = JSON.stringify({
+        model: "web-claude/claude-haiku",
+        messages: [{ role: "user", content: "tokens" }],
+        stream: true,
+      });
+      const urlObj = new URL(`${baseUrl}/v1/chat/completions`);
+      const req = http.request(
+        { hostname: urlObj.hostname, port: Number(urlObj.port), path: urlObj.pathname, method: "POST",
+          headers: { "Content-Type": "application/json", "Content-Length": Buffer.byteLength(body) } },
+        (res) => {
+          let raw = "";
+          res.on("data", (c) => (raw += c));
+          res.on("end", () => {
+            expect(stubClaudeCompleteStream).toHaveBeenCalledOnce();
+            // Verify stream contains token chunks
+            expect(raw).toContain("claude stream mock".split(" ")[0]);
+            resolve();
+          });
+        }
+      );
+      req.on("error", reject);
+      req.write(body);
+      req.end();
+    });
+  });
+});

package/test/cli-runner.test.ts

@@ -173,15 +173,26 @@ describe("routeToCliRunner — model normalization", () => {
   });
 
   it("accepts cli-claude/ without vllm prefix (calls runClaude path)", async () => {
-    await expect(
-      routeToCliRunner("cli-claude/claude-sonnet-4-6", [{ role: "user", content: "hi" }], 500)
-    ).rejects.not.toThrow("Unknown CLI bridge model");
+    // Claude CLI may resolve (empty) or reject — what matters is it doesn't throw "Unknown CLI bridge model"
+    let errorMsg = "";
+    try {
+      await routeToCliRunner("cli-claude/claude-sonnet-4-6", [{ role: "user", content: "hi" }], 500);
+    } catch (e: any) {
+      errorMsg = (e as Error).message ?? String(e);
+    }
+    expect(errorMsg).not.toContain("Unknown CLI bridge model");
+    expect(errorMsg).not.toContain("CLI bridge model not allowed");
   });
 
   it("accepts vllm/cli-claude/ — strips vllm prefix before routing", async () => {
-    await expect(
-      routeToCliRunner("vllm/cli-claude/claude-sonnet-4-6", [{ role: "user", content: "hi" }], 500)
-    ).rejects.not.toThrow("Unknown CLI bridge model");
+    let errorMsg = "";
+    try {
+      await routeToCliRunner("vllm/cli-claude/claude-sonnet-4-6", [{ role: "user", content: "hi" }], 500);
+    } catch (e: any) {
+      errorMsg = (e as Error).message ?? String(e);
+    }
+    expect(errorMsg).not.toContain("Unknown CLI bridge model");
+    expect(errorMsg).not.toContain("CLI bridge model not allowed");
   });
 
   // T-101: gemini routing paths
@@ -258,12 +269,17 @@ describe("routeToCliRunner — model allowlist (T-103)", () => {
   });
 
   it("allowedModels: null disables the check — only routing matters", async () => {
-    // With null allowlist, unknown-prefix models still throw "Unknown CLI bridge model"
-    await expect(
-      routeToCliRunner("vllm/cli-claude/any-model", [{ role: "user", content: "hi" }], 500, {
+    // With null allowlist, the allowlist check is skipped — routing still happens
+    // Claude CLI may resolve (empty) or reject for other reasons — should NOT throw "CLI bridge model not allowed"
+    let errorMsg = "";
+    try {
+      await routeToCliRunner("vllm/cli-claude/any-model", [{ role: "user", content: "hi" }], 500, {
         allowedModels: null,
-      })
-    ).rejects.not.toThrow("CLI bridge model not allowed");
+      });
+    } catch (e: any) {
+      errorMsg = (e as Error).message ?? String(e);
+    }
+    expect(errorMsg).not.toContain("CLI bridge model not allowed");
   });
 
   it("custom allowlist overrides defaults", async () => {

package/test/gemini-proxy.test.ts

@@ -0,0 +1,139 @@
+/**
+ * test/gemini-proxy.test.ts
+ *
+ * Tests for Gemini web-session routing in the cli-bridge proxy.
+ * Uses _geminiComplete/_geminiCompleteStream 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 GeminiCompleteOptions = { messages: { role: string; content: string }[]; model?: string; timeoutMs?: number };
+type GeminiCompleteResult = { content: string; model: string; finishReason: string };
+
+const stubGeminiComplete = vi.fn(async (
+  _ctx: BrowserContext,
+  opts: GeminiCompleteOptions,
+  _log: (msg: string) => void
+): Promise<GeminiCompleteResult> => ({
+  content: `gemini mock: ${opts.messages[opts.messages.length - 1]?.content ?? ""}`,
+  model: opts.model ?? "web-gemini/gemini-2-5-pro",
+  finishReason: "stop",
+}));
+
+const stubGeminiCompleteStream = vi.fn(async (
+  _ctx: BrowserContext,
+  opts: GeminiCompleteOptions,
+  onToken: (t: string) => void,
+  _log: (msg: string) => void
+): Promise<GeminiCompleteResult> => {
+  const tokens = ["gemini ", "stream ", "mock"];
+  for (const t of tokens) onToken(t);
+  return { content: tokens.join(""), model: opts.model ?? "web-gemini/gemini-2-5-pro", 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: () => {},
+    getGeminiContext: () => fakeCtx,
+    // @ts-expect-error — stub types close enough for testing
+    _geminiComplete: stubGeminiComplete,
+    // @ts-expect-error — stub types close enough for testing
+    _geminiCompleteStream: stubGeminiCompleteStream,
+  });
+  baseUrl = `http://127.0.0.1:${(server.address() as AddressInfo).port}`;
+});
+afterAll(() => server.close());
+
+describe("Gemini web-session routing — model list", () => {
+  it("includes web-gemini/* 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-gemini/gemini-2-5-pro");
+    expect(ids).toContain("web-gemini/gemini-3-pro");
+  });
+
+  it("web-gemini/* models listed in CLI_MODELS constant", () => {
+    expect(CLI_MODELS.some(m => m.id.startsWith("web-gemini/"))).toBe(true);
+  });
+});
+
+describe("Gemini web-session routing — non-streaming", () => {
+  it("returns assistant message for web-gemini/gemini-2-5-pro", async () => {
+    const res = await httpPost(`${baseUrl}/v1/chat/completions`, {
+      model: "web-gemini/gemini-2-5-pro",
+      messages: [{ role: "user", content: "hello gemini" }],
+      stream: false,
+    });
+    expect(res.status).toBe(200);
+    const body = res.body as { choices: { message: { content: string } }[] };
+    expect(body.choices[0].message.content).toContain("gemini mock");
+    expect(body.choices[0].message.content).toContain("hello gemini");
+  });
+
+  it("passes correct model to stub", async () => {
+    stubGeminiComplete.mockClear();
+    await httpPost(`${baseUrl}/v1/chat/completions`, {
+      model: "web-gemini/gemini-3-flash",
+      messages: [{ role: "user", content: "test" }],
+    });
+    expect(stubGeminiComplete).toHaveBeenCalledOnce();
+    expect(stubGeminiComplete.mock.calls[0][1].model).toBe("web-gemini/gemini-3-flash");
+  });
+
+  it("returns 503 when no gemini context", async () => {
+    const s = await startProxyServer({ port: 0, log: () => {}, warn: () => {}, getGeminiContext: () => null });
+    const url = `http://127.0.0.1:${(s.address() as AddressInfo).port}`;
+    const res = await httpPost(`${url}/v1/chat/completions`, {
+      model: "web-gemini/gemini-2-5-pro",
+      messages: [{ role: "user", content: "hi" }],
+    });
+    expect(res.status).toBe(503);
+    expect((res.body as { error: { code: string } }).error.code).toBe("no_gemini_session");
+    s.close();
+  });
+});
+
+describe("Gemini web-session routing — streaming", () => {
+  it("returns SSE stream", async () => {
+    return new Promise<void>((resolve, reject) => {
+      const body = JSON.stringify({ model: "web-gemini/gemini-2-5-pro", 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();
+    });
+  });
+});