@elvatis_com/openclaw-cli-bridge-elvatis 1.6.4 → 1.7.0

package/README.md

@@ -2,7 +2,7 @@
 
 > OpenClaw plugin that bridges locally installed AI CLIs (Codex, Gemini, Claude Code) as model providers — with slash commands for instant model switching, restore, health testing, and model listing.
 
-**Current version:** `1.6.4`
+**Current version:** `1.7.0`
 
 ---
 
@@ -362,6 +362,15 @@ npm test            # vitest run (83 tests)
 
 ## Changelog
 
+### v1.7.0
+- **fix:** Startup restore timeout 3s → 6s with one retry, eliminates false "not logged in" for slow-loading pages (Grok)
+- **feat:** Auto-relogin on startup — if cookies truly expired, attempt headless relogin before sending WhatsApp alert
+- **feat:** Keep-alive (20h) now verifies session after touch and attempts auto-relogin if expired
+- **feat:** Tests (vitest) — proxy tool rejection, models endpoint, auth, cookie expiry formatters
+
+### v1.6.5
+- **feat:** Automatic session keep-alive — every 20h, active browser sessions are silently refreshed by navigating to the provider home page. Prevents cookie expiry on providers like ChatGPT (7-day sessions) without storing credentials.
+
 ### v1.6.4
 - **chore:** version bump (1.6.3 was already published on npm with partial changes)
 

package/SKILL.md

@@ -64,4 +64,4 @@ On gateway restart, if any session has expired, a **WhatsApp alert** is sent aut
 
 See `README.md` for full configuration reference and architecture diagram.
 
-**Version:** 1.6.4
+**Version:** 1.7.0

package/index.ts

@@ -56,6 +56,12 @@ import {
   createContextFromSession,
   DEFAULT_SESSION_PATH,
 } from "./src/grok-session.js";
+import {
+  formatExpiryInfo,
+  formatGeminiExpiry,
+  formatClaudeExpiry,
+  formatChatGPTExpiry,
+} from "./src/expiry-helpers.js";
 import type { BrowserContext, Browser } from "playwright";
 
 // ──────────────────────────────────────────────────────────────────────────────
@@ -120,14 +126,7 @@ function saveGeminiExpiry(info: GeminiExpiryInfo): void {
 function loadGeminiExpiry(): GeminiExpiryInfo | null {
   try { return JSON.parse(readFileSync(GEMINI_EXPIRY_FILE, "utf-8")) as GeminiExpiryInfo; } catch { return null; }
 }
-function formatGeminiExpiry(info: GeminiExpiryInfo): string {
-  const daysLeft = Math.floor((info.expiresAt - Date.now()) / 86_400_000);
-  const dateStr = new Date(info.expiresAt).toISOString().substring(0, 10);
-  if (daysLeft < 0)   return `⚠️ EXPIRED (${dateStr}) — run /gemini-login`;
-  if (daysLeft <= 7)  return `🚨 expires in ${daysLeft}d (${dateStr}) — run /gemini-login NOW`;
-  if (daysLeft <= 14) return `⚠️ expires in ${daysLeft}d (${dateStr}) — run /gemini-login soon`;
-  return `✅ valid for ${daysLeft} more days (expires ${dateStr})`;
-}
+// formatGeminiExpiry imported from ./src/expiry-helpers.js
 async function scanGeminiCookieExpiry(ctx: BrowserContext): Promise<GeminiExpiryInfo | null> {
   try {
     const cookies = await ctx.cookies(["https://gemini.google.com", "https://accounts.google.com"]);
@@ -146,14 +145,7 @@ function saveClaudeExpiry(info: ClaudeExpiryInfo): void {
 function loadClaudeExpiry(): ClaudeExpiryInfo | null {
   try { return JSON.parse(readFileSync(CLAUDE_EXPIRY_FILE, "utf-8")) as ClaudeExpiryInfo; } catch { return null; }
 }
-function formatClaudeExpiry(info: ClaudeExpiryInfo): string {
-  const daysLeft = Math.floor((info.expiresAt - Date.now()) / 86_400_000);
-  const dateStr = new Date(info.expiresAt).toISOString().substring(0, 10);
-  if (daysLeft < 0)   return `⚠️ EXPIRED (${dateStr}) — run /claude-login`;
-  if (daysLeft <= 7)  return `🚨 expires in ${daysLeft}d (${dateStr}) — run /claude-login NOW`;
-  if (daysLeft <= 14) return `⚠️ expires in ${daysLeft}d (${dateStr}) — run /claude-login soon`;
-  return `✅ valid for ${daysLeft} more days (expires ${dateStr})`;
-}
+// formatClaudeExpiry imported from ./src/expiry-helpers.js
 async function scanClaudeCookieExpiry(ctx: BrowserContext): Promise<ClaudeExpiryInfo | null> {
   try {
     const cookies = await ctx.cookies(["https://claude.ai"]);
@@ -173,14 +165,7 @@ function saveChatGPTExpiry(info: ChatGPTExpiryInfo): void {
 function loadChatGPTExpiry(): ChatGPTExpiryInfo | null {
   try { return JSON.parse(readFileSync(CHATGPT_EXPIRY_FILE, "utf-8")) as ChatGPTExpiryInfo; } catch { return null; }
 }
-function formatChatGPTExpiry(info: ChatGPTExpiryInfo): string {
-  const daysLeft = Math.floor((info.expiresAt - Date.now()) / 86_400_000);
-  const dateStr = new Date(info.expiresAt).toISOString().substring(0, 10);
-  if (daysLeft < 0)   return `⚠️ EXPIRED (${dateStr}) — run /chatgpt-login`;
-  if (daysLeft <= 7)  return `🚨 expires in ${daysLeft}d (${dateStr}) — run /chatgpt-login NOW`;
-  if (daysLeft <= 14) return `⚠️ expires in ${daysLeft}d (${dateStr}) — run /chatgpt-login soon`;
-  return `✅ valid for ${daysLeft} more days (expires ${dateStr})`;
-}
+// formatChatGPTExpiry imported from ./src/expiry-helpers.js
 async function scanChatGPTCookieExpiry(ctx: BrowserContext): Promise<ChatGPTExpiryInfo | null> {
   try {
     const cookies = await ctx.cookies(["https://chatgpt.com", "https://auth0.openai.com"]);
@@ -216,15 +201,7 @@ function loadGrokExpiry(): GrokExpiryInfo | null {
   } catch { return null; }
 }
 
-/** Returns human-readable expiry summary e.g. "179 days (2026-09-07)" */
-function formatExpiryInfo(info: GrokExpiryInfo): string {
-  const daysLeft = Math.ceil((info.expiresAt - Date.now()) / 86_400_000);
-  const dateStr = new Date(info.expiresAt).toISOString().split("T")[0];
-  if (daysLeft <= 0) return `⚠️ EXPIRED (was ${dateStr})`;
-  if (daysLeft <= 7) return `🚨 expires in ${daysLeft}d (${dateStr}) — run /grok-login NOW`;
-  if (daysLeft <= 14) return `⚠️ expires in ${daysLeft}d (${dateStr}) — run /grok-login soon`;
-  return `✅ valid for ${daysLeft} more days (expires ${dateStr})`;
-}
+// formatExpiryInfo imported from ./src/expiry-helpers.js
 
 /** Scan context cookies and return earliest auth cookie expiry */
 async function scanCookieExpiry(ctx: import("playwright").BrowserContext): Promise<GrokExpiryInfo | null> {
@@ -249,6 +226,9 @@ let _cdpBrowserLaunchPromise: Promise<import("playwright").BrowserContext | null
 // Set to true after first run; hot-reloads see true and skip the restore loop.
 let _startupRestoreDone = false;
 
+// Session keep-alive interval — refreshes browser cookies every 20h
+let _keepAliveInterval: ReturnType<typeof setInterval> | null = null;
+
 /**
  * Connect to the OpenClaw managed browser (CDP port 18800).
  * Singleton: reuses the same connection. Falls back to persistent Chromium for Grok only.
@@ -435,8 +415,86 @@ async function getOrLaunchChatGPTContext(
   return _chatgptLaunchPromise;
 }
 
+/** Session keep-alive — navigate to provider home pages to refresh cookies.
+ *  After each touch, verifies the session is still valid. If expired, attempts
+ *  a full relogin. Returns provider login commands that need manual attention. */
+async function sessionKeepAlive(log: (msg: string) => void): Promise<string[]> {
+  const providers: Array<{
+    name: string;
+    homeUrl: string;
+    verifySelector: string;
+    loginCmd: string;
+    getCtx: () => BrowserContext | null;
+    setCtx: (c: BrowserContext | null) => void;
+    scanExpiry: (ctx: BrowserContext) => Promise<{ expiresAt: number; loginAt: number; cookieName: string } | null>;
+    saveExpiry: (info: { expiresAt: number; loginAt: number; cookieName: string }) => void;
+  }> = [
+    { name: "grok", homeUrl: "https://grok.com", verifySelector: "textarea", loginCmd: "/grok-login", getCtx: () => grokContext, setCtx: (c) => { grokContext = c; }, scanExpiry: scanCookieExpiry, saveExpiry: saveGrokExpiry },
+    { name: "gemini", homeUrl: "https://gemini.google.com/app", verifySelector: ".ql-editor", loginCmd: "/gemini-login", getCtx: () => geminiContext, setCtx: (c) => { geminiContext = c; }, scanExpiry: scanGeminiCookieExpiry, saveExpiry: saveGeminiExpiry },
+    { name: "claude-web", homeUrl: "https://claude.ai/new", verifySelector: ".ProseMirror", loginCmd: "/claude-login", getCtx: () => claudeWebContext, setCtx: (c) => { claudeWebContext = c; }, scanExpiry: scanClaudeCookieExpiry, saveExpiry: saveClaudeExpiry },
+    { name: "chatgpt", homeUrl: "https://chatgpt.com", verifySelector: "#prompt-textarea", loginCmd: "/chatgpt-login", getCtx: () => chatgptContext, setCtx: (c) => { chatgptContext = c; }, scanExpiry: scanChatGPTCookieExpiry, saveExpiry: saveChatGPTExpiry },
+  ];
+
+  const needsLogin: string[] = [];
+
+  for (const p of providers) {
+    const ctx = p.getCtx();
+    if (!ctx) continue;
+    try {
+      const page = await ctx.newPage();
+      await page.goto(p.homeUrl, { waitUntil: "domcontentloaded", timeout: 15_000 });
+      await new Promise(r => setTimeout(r, 4000));
+
+      // Verify session is still valid after touch
+      let valid = await page.locator(p.verifySelector).isVisible().catch(() => false);
+      if (!valid) {
+        // Retry once
+        await new Promise(r => setTimeout(r, 3000));
+        valid = await page.locator(p.verifySelector).isVisible().catch(() => false);
+      }
+      await page.close();
+
+      if (valid) {
+        const expiry = await p.scanExpiry(ctx);
+        if (expiry) p.saveExpiry(expiry);
+        log(`[cli-bridge:${p.name}] session keep-alive touch ✅`);
+      } else {
+        // Session expired — attempt relogin in same persistent context
+        log(`[cli-bridge:${p.name}] session expired after keep-alive — attempting auto-relogin…`);
+        const reloginPage = await ctx.newPage();
+        await reloginPage.goto(p.homeUrl, { waitUntil: "domcontentloaded", timeout: 20_000 });
+        await new Promise(r => setTimeout(r, 6000));
+        let reloginOk = await reloginPage.locator(p.verifySelector).isVisible().catch(() => false);
+        if (!reloginOk) {
+          await new Promise(r => setTimeout(r, 3000));
+          reloginOk = await reloginPage.locator(p.verifySelector).isVisible().catch(() => false);
+        }
+        await reloginPage.close().catch(() => {});
+        if (reloginOk) {
+          const expiry = await p.scanExpiry(ctx);
+          if (expiry) p.saveExpiry(expiry);
+          log(`[cli-bridge:${p.name}] auto-relogin successful ✅`);
+        } else {
+          log(`[cli-bridge:${p.name}] auto-relogin failed, needs manual ${p.loginCmd}`);
+          needsLogin.push(p.loginCmd);
+        }
+      }
+    } catch (err) {
+      log(`[cli-bridge:${p.name}] session keep-alive failed: ${(err as Error).message}`);
+    }
+    // Sequential — avoid spawning multiple pages at once
+    await new Promise(r => setTimeout(r, 2000));
+  }
+
+  return needsLogin;
+}
+
 /** Clean up all browser resources — call on plugin teardown */
 async function cleanupBrowsers(log: (msg: string) => void): Promise<void> {
+  if (_keepAliveInterval) {
+    clearInterval(_keepAliveInterval);
+    _keepAliveInterval = null;
+  }
   if (grokContext) {
     try { await grokContext.close(); } catch { /* ignore */ }
     grokContext = null;
@@ -854,7 +912,7 @@ function proxyTestRequest(
 const plugin = {
   id: "openclaw-cli-bridge-elvatis",
   name: "OpenClaw CLI Bridge",
-  version: "1.6.4",
+  version: "1.7.0",
   description:
     "Phase 1: openai-codex auth bridge. " +
     "Phase 2: HTTP proxy for gemini/claude CLIs. " +
@@ -955,17 +1013,47 @@ const plugin = {
             });
             const page = await ctx.newPage();
             await page.goto(p.homeUrl, { waitUntil: "domcontentloaded", timeout: 20_000 });
-            await new Promise(r => setTimeout(r, 3000));
-            const ok = await page.locator(p.verifySelector).isVisible().catch(() => false);
+            await new Promise(r => setTimeout(r, 6000));
+            let ok = await page.locator(p.verifySelector).isVisible().catch(() => false);
+            // Retry once — some pages (Grok) load slowly
+            if (!ok) {
+              api.logger.info(`[cli-bridge:${p.name}] verifySelector not visible after 6s, retrying (3s)…`);
+              await new Promise(r => setTimeout(r, 3000));
+              ok = await page.locator(p.verifySelector).isVisible().catch(() => false);
+            }
             await page.close().catch(() => {});
             if (ok) {
               p.setCtx(ctx);
               ctx.on("close", () => { p.setCtx(null as unknown as BrowserContext); });
               api.logger.info(`[cli-bridge:${p.name}] session restored from profile ✅`);
             } else {
-              await ctx.close().catch(() => {});
-              api.logger.info(`[cli-bridge:${p.name}] profile exists but not logged in — needs ${p.loginCmd}`);
-              needsLogin.push(p.loginCmd);
+              // Session may be truly expired or just slow — attempt auto-relogin:
+              // re-navigate in the same context and check once more
+              api.logger.info(`[cli-bridge:${p.name}] not logged in after restore — attempting auto-relogin…`);
+              try {
+                const reloginPage = await ctx.newPage();
+                await reloginPage.goto(p.homeUrl, { waitUntil: "domcontentloaded", timeout: 20_000 });
+                await new Promise(r => setTimeout(r, 6000));
+                let reloginOk = await reloginPage.locator(p.verifySelector).isVisible().catch(() => false);
+                if (!reloginOk) {
+                  await new Promise(r => setTimeout(r, 3000));
+                  reloginOk = await reloginPage.locator(p.verifySelector).isVisible().catch(() => false);
+                }
+                await reloginPage.close().catch(() => {});
+                if (reloginOk) {
+                  p.setCtx(ctx);
+                  ctx.on("close", () => { p.setCtx(null as unknown as BrowserContext); });
+                  api.logger.info(`[cli-bridge:${p.name}] session restored (slow load) ✅`);
+                } else {
+                  await ctx.close().catch(() => {});
+                  api.logger.info(`[cli-bridge:${p.name}] auto-relogin failed, needs manual ${p.loginCmd}`);
+                  needsLogin.push(p.loginCmd);
+                }
+              } catch (reloginErr) {
+                await ctx.close().catch(() => {});
+                api.logger.warn(`[cli-bridge:${p.name}] auto-relogin error: ${(reloginErr as Error).message}`);
+                needsLogin.push(p.loginCmd);
+              }
             }
           } catch (err) {
             api.logger.warn(`[cli-bridge:${p.name}] startup restore failed: ${(err as Error).message}`);
@@ -991,6 +1079,28 @@ const plugin = {
           }
         }
       })();
+
+      // Start session keep-alive interval (every 20h)
+      if (!_keepAliveInterval) {
+        _keepAliveInterval = setInterval(() => {
+          void (async () => {
+            const failed = await sessionKeepAlive((msg) => api.logger.info(msg));
+            if (failed.length > 0) {
+              const cmds = failed.map(cmd => `• ${cmd}`).join("\n");
+              const msg = `🔐 *cli-bridge keep-alive:* Session expired for ${failed.length} provider(s). Run to re-login:\n\n${cmds}`;
+              try {
+                await api.runtime.system.runCommandWithTimeout(
+                  ["openclaw", "message", "send", "--channel", "whatsapp", "--to", "+4915170113694", "--message", msg],
+                  { timeoutMs: 10_000 }
+                );
+                api.logger.info(`[cli-bridge] keep-alive: sent re-login notification for: ${failed.join(", ")}`);
+              } catch (err) {
+                api.logger.warn(`[cli-bridge] keep-alive: failed to send notification: ${(err as Error).message}`);
+              }
+            }
+          })();
+        }, 72_000_000);
+      }
     }
 
     // ── Phase 1: openai-codex auth bridge ─────────────────────────────────────

package/openclaw.plugin.json

@@ -1,7 +1,7 @@
 {
   "id": "openclaw-cli-bridge-elvatis",
   "name": "OpenClaw CLI Bridge",
-  "version": "1.6.4",
+  "version": "1.7.0",
   "license": "MIT",
   "description": "Phase 1: openai-codex auth bridge. Phase 2: local HTTP proxy routing model calls through gemini/claude CLIs (vllm provider).",
   "providers": [

package/package.json

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

package/src/expiry-helpers.ts

@@ -0,0 +1,52 @@
+/**
+ * expiry-helpers.ts
+ *
+ * Pure functions for formatting cookie expiry info.
+ * Extracted from index.ts for testability.
+ */
+
+export interface ExpiryInfo {
+  expiresAt: number;   // epoch ms
+  loginAt: number;     // epoch ms
+  cookieName: string;
+}
+
+/** Grok cookie expiry — uses Math.ceil for daysLeft */
+export function formatExpiryInfo(info: ExpiryInfo): string {
+  const daysLeft = Math.ceil((info.expiresAt - Date.now()) / 86_400_000);
+  const dateStr = new Date(info.expiresAt).toISOString().split("T")[0];
+  if (daysLeft <= 0) return `⚠️ EXPIRED (was ${dateStr})`;
+  if (daysLeft <= 7) return `🚨 expires in ${daysLeft}d (${dateStr}) — run /grok-login NOW`;
+  if (daysLeft <= 14) return `⚠️ expires in ${daysLeft}d (${dateStr}) — run /grok-login soon`;
+  return `✅ valid for ${daysLeft} more days (expires ${dateStr})`;
+}
+
+/** Gemini cookie expiry — uses Math.floor for daysLeft */
+export function formatGeminiExpiry(info: ExpiryInfo): string {
+  const daysLeft = Math.floor((info.expiresAt - Date.now()) / 86_400_000);
+  const dateStr = new Date(info.expiresAt).toISOString().substring(0, 10);
+  if (daysLeft < 0)   return `⚠️ EXPIRED (${dateStr}) — run /gemini-login`;
+  if (daysLeft <= 7)  return `🚨 expires in ${daysLeft}d (${dateStr}) — run /gemini-login NOW`;
+  if (daysLeft <= 14) return `⚠️ expires in ${daysLeft}d (${dateStr}) — run /gemini-login soon`;
+  return `✅ valid for ${daysLeft} more days (expires ${dateStr})`;
+}
+
+/** Claude cookie expiry — uses Math.floor for daysLeft */
+export function formatClaudeExpiry(info: ExpiryInfo): string {
+  const daysLeft = Math.floor((info.expiresAt - Date.now()) / 86_400_000);
+  const dateStr = new Date(info.expiresAt).toISOString().substring(0, 10);
+  if (daysLeft < 0)   return `⚠️ EXPIRED (${dateStr}) — run /claude-login`;
+  if (daysLeft <= 7)  return `🚨 expires in ${daysLeft}d (${dateStr}) — run /claude-login NOW`;
+  if (daysLeft <= 14) return `⚠️ expires in ${daysLeft}d (${dateStr}) — run /claude-login soon`;
+  return `✅ valid for ${daysLeft} more days (expires ${dateStr})`;
+}
+
+/** ChatGPT cookie expiry — uses Math.floor for daysLeft */
+export function formatChatGPTExpiry(info: ExpiryInfo): string {
+  const daysLeft = Math.floor((info.expiresAt - Date.now()) / 86_400_000);
+  const dateStr = new Date(info.expiresAt).toISOString().substring(0, 10);
+  if (daysLeft < 0)   return `⚠️ EXPIRED (${dateStr}) — run /chatgpt-login`;
+  if (daysLeft <= 7)  return `🚨 expires in ${daysLeft}d (${dateStr}) — run /chatgpt-login NOW`;
+  if (daysLeft <= 14) return `⚠️ expires in ${daysLeft}d (${dateStr}) — run /chatgpt-login soon`;
+  return `✅ valid for ${daysLeft} more days (expires ${dateStr})`;
+}

package/test/expiry-helpers.test.ts

@@ -0,0 +1,134 @@
+/**
+ * Tests for cookie expiry formatting helpers.
+ */
+
+import { describe, it, expect, vi, afterEach } from "vitest";
+import {
+  formatExpiryInfo,
+  formatGeminiExpiry,
+  formatClaudeExpiry,
+  formatChatGPTExpiry,
+  type ExpiryInfo,
+} from "../src/expiry-helpers.js";
+
+// Fix Date.now() for deterministic tests
+const NOW = new Date("2026-03-13T12:00:00Z").getTime();
+
+afterEach(() => {
+  vi.restoreAllMocks();
+});
+
+function makeExpiry(daysFromNow: number): ExpiryInfo {
+  return {
+    expiresAt: NOW + daysFromNow * 86_400_000,
+    loginAt: NOW - 86_400_000,
+    cookieName: "test-cookie",
+  };
+}
+
+// ──────────────────────────────────────────────────────────────────────────────
+// formatExpiryInfo (Grok)
+// ──────────────────────────────────────────────────────────────────────────────
+
+describe("formatExpiryInfo (Grok)", () => {
+  it("expired → contains EXPIRED", () => {
+    vi.spyOn(Date, "now").mockReturnValue(NOW);
+    const result = formatExpiryInfo(makeExpiry(-5));
+    expect(result).toContain("EXPIRED");
+  });
+
+  it("3 days → contains 🚨", () => {
+    vi.spyOn(Date, "now").mockReturnValue(NOW);
+    const result = formatExpiryInfo(makeExpiry(3));
+    expect(result).toContain("🚨");
+    expect(result).toContain("3d");
+  });
+
+  it("20 days → contains ✅", () => {
+    vi.spyOn(Date, "now").mockReturnValue(NOW);
+    const result = formatExpiryInfo(makeExpiry(20));
+    expect(result).toContain("✅");
+    expect(result).toContain("20");
+  });
+
+  it("10 days → contains ⚠️ (warning zone 7-14d)", () => {
+    vi.spyOn(Date, "now").mockReturnValue(NOW);
+    const result = formatExpiryInfo(makeExpiry(10));
+    expect(result).toContain("⚠️");
+  });
+});
+
+// ──────────────────────────────────────────────────────────────────────────────
+// formatGeminiExpiry
+// ──────────────────────────────────────────────────────────────────────────────
+
+describe("formatGeminiExpiry", () => {
+  it("expired → contains EXPIRED", () => {
+    vi.spyOn(Date, "now").mockReturnValue(NOW);
+    const result = formatGeminiExpiry(makeExpiry(-2));
+    expect(result).toContain("EXPIRED");
+    expect(result).toContain("/gemini-login");
+  });
+
+  it("3 days → contains 🚨", () => {
+    vi.spyOn(Date, "now").mockReturnValue(NOW);
+    const result = formatGeminiExpiry(makeExpiry(3));
+    expect(result).toContain("🚨");
+  });
+
+  it("20 days → contains ✅", () => {
+    vi.spyOn(Date, "now").mockReturnValue(NOW);
+    const result = formatGeminiExpiry(makeExpiry(20));
+    expect(result).toContain("✅");
+  });
+});
+
+// ──────────────────────────────────────────────────────────────────────────────
+// formatClaudeExpiry
+// ──────────────────────────────────────────────────────────────────────────────
+
+describe("formatClaudeExpiry", () => {
+  it("expired → contains EXPIRED", () => {
+    vi.spyOn(Date, "now").mockReturnValue(NOW);
+    const result = formatClaudeExpiry(makeExpiry(-1));
+    expect(result).toContain("EXPIRED");
+    expect(result).toContain("/claude-login");
+  });
+
+  it("3 days → contains 🚨", () => {
+    vi.spyOn(Date, "now").mockReturnValue(NOW);
+    const result = formatClaudeExpiry(makeExpiry(3));
+    expect(result).toContain("🚨");
+  });
+
+  it("20 days → contains ✅", () => {
+    vi.spyOn(Date, "now").mockReturnValue(NOW);
+    const result = formatClaudeExpiry(makeExpiry(20));
+    expect(result).toContain("✅");
+  });
+});
+
+// ──────────────────────────────────────────────────────────────────────────────
+// formatChatGPTExpiry
+// ──────────────────────────────────────────────────────────────────────────────
+
+describe("formatChatGPTExpiry", () => {
+  it("expired → contains EXPIRED", () => {
+    vi.spyOn(Date, "now").mockReturnValue(NOW);
+    const result = formatChatGPTExpiry(makeExpiry(-3));
+    expect(result).toContain("EXPIRED");
+    expect(result).toContain("/chatgpt-login");
+  });
+
+  it("3 days → contains 🚨", () => {
+    vi.spyOn(Date, "now").mockReturnValue(NOW);
+    const result = formatChatGPTExpiry(makeExpiry(3));
+    expect(result).toContain("🚨");
+  });
+
+  it("20 days → contains ✅", () => {
+    vi.spyOn(Date, "now").mockReturnValue(NOW);
+    const result = formatChatGPTExpiry(makeExpiry(20));
+    expect(result).toContain("✅");
+  });
+});

package/test/proxy-e2e.test.ts

@@ -395,3 +395,83 @@ describe("Error handling", () => {
     expect(JSON.parse(res.body).error.type).toBe("not_found");
   });
 });
+
+// ──────────────────────────────────────────────────────────────────────────────
+// Tool/function call rejection for CLI-proxy models
+// ──────────────────────────────────────────────────────────────────────────────
+
+describe("Tool call rejection", () => {
+  it("rejects tools for cli-gemini models with tools_not_supported", async () => {
+    const res = await json("/v1/chat/completions", {
+      model: "cli-gemini/gemini-2.5-pro",
+      messages: [{ role: "user", content: "hi" }],
+      tools: [{ type: "function", function: { name: "test", parameters: {} } }],
+    });
+
+    expect(res.status).toBe(400);
+    const body = JSON.parse(res.body);
+    expect(body.error.code).toBe("tools_not_supported");
+  });
+
+  it("rejects tools for cli-claude models with tools_not_supported", async () => {
+    const res = await json("/v1/chat/completions", {
+      model: "cli-claude/claude-sonnet-4-6",
+      messages: [{ role: "user", content: "hi" }],
+      tools: [{ type: "function", function: { name: "test", parameters: {} } }],
+    });
+
+    expect(res.status).toBe(400);
+    const body = JSON.parse(res.body);
+    expect(body.error.code).toBe("tools_not_supported");
+  });
+
+  it("does NOT reject tools for web-grok models (returns 503 no session)", async () => {
+    const res = await json("/v1/chat/completions", {
+      model: "web-grok/grok-3",
+      messages: [{ role: "user", content: "hi" }],
+      tools: [{ type: "function", function: { name: "test", parameters: {} } }],
+    });
+
+    // Should NOT be 400 tools_not_supported — reaches provider logic, gets 503 (no session)
+    expect(res.status).not.toBe(400);
+    expect(res.status).toBe(503);
+    const body = JSON.parse(res.body);
+    expect(body.error.code).toBe("no_grok_session");
+  });
+});
+
+// ──────────────────────────────────────────────────────────────────────────────
+// Model capabilities
+// ──────────────────────────────────────────────────────────────────────────────
+
+describe("Model capabilities", () => {
+  it("cli-gemini models have capabilities.tools===false", async () => {
+    const res = await fetch("/v1/models");
+    const body = JSON.parse(res.body);
+    const cliGeminiModels = body.data.filter((m: { id: string }) => m.id.startsWith("cli-gemini/"));
+    expect(cliGeminiModels.length).toBeGreaterThan(0);
+    for (const m of cliGeminiModels) {
+      expect(m.capabilities.tools).toBe(false);
+    }
+  });
+
+  it("cli-claude models have capabilities.tools===false", async () => {
+    const res = await fetch("/v1/models");
+    const body = JSON.parse(res.body);
+    const cliClaudeModels = body.data.filter((m: { id: string }) => m.id.startsWith("cli-claude/"));
+    expect(cliClaudeModels.length).toBeGreaterThan(0);
+    for (const m of cliClaudeModels) {
+      expect(m.capabilities.tools).toBe(false);
+    }
+  });
+
+  it("web-grok models have capabilities.tools===true", async () => {
+    const res = await fetch("/v1/models");
+    const body = JSON.parse(res.body);
+    const webGrokModels = body.data.filter((m: { id: string }) => m.id.startsWith("web-grok/"));
+    expect(webGrokModels.length).toBeGreaterThan(0);
+    for (const m of webGrokModels) {
+      expect(m.capabilities.tools).toBe(true);
+    }
+  });
+});