@elvatis_com/openclaw-cli-bridge-elvatis 0.2.0 → 0.2.2

package/.clawhubignore

@@ -0,0 +1,7 @@
+node_modules/
+.git/
+dist/
+*.tgz
+npm-debug.log*
+.vscode/
+.idea/

package/SKILL.md

@@ -0,0 +1,24 @@
+---
+name: openclaw-cli-bridge-elvatis
+description: Bridge local Codex, Gemini, and Claude Code CLIs into OpenClaw (Codex OAuth auth bridge + Gemini/Claude OpenAI-compatible local proxy via vllm).
+homepage: https://github.com/elvatis/openclaw-cli-bridge-elvatis
+metadata:
+  {
+    "openclaw":
+      {
+        "emoji": "🌉",
+        "requires": { "bins": ["openclaw", "codex", "gemini", "claude"] }
+      }
+  }
+---
+
+# OpenClaw CLI Bridge Elvatis
+
+This project provides two layers:
+
+1. **Codex auth bridge** for `openai-codex/*` by reading existing Codex CLI OAuth tokens from `~/.codex/auth.json`
+2. **Local OpenAI-compatible proxy** (default `127.0.0.1:31337`) for Gemini/Claude CLI execution via OpenClaw `vllm` provider models:
+   - `vllm/cli-gemini/*`
+   - `vllm/cli-claude/*`
+
+See `README.md` for setup and architecture.

package/index.ts

@@ -8,6 +8,14 @@
  *   and configures OpenClaw's vllm provider to route through it. Model calls
  *   are handled by the Gemini CLI and Claude Code CLI subprocesses.
  *
+ * Phase 3 (slash commands): registers /cli-* commands for instant model switching.
+ *   /cli-sonnet       → vllm/cli-claude/claude-sonnet-4-6
+ *   /cli-opus         → vllm/cli-claude/claude-opus-4-6
+ *   /cli-haiku        → vllm/cli-claude/claude-haiku-4-5
+ *   /cli-gemini       → vllm/cli-gemini/gemini-2.5-pro
+ *   /cli-gemini-flash → vllm/cli-gemini/gemini-2.5-flash
+ *   /cli-gemini3      → vllm/cli-gemini/gemini-3-pro
+ *
  * Provider / model naming:
  *   vllm/cli-gemini/gemini-2.5-pro  → `gemini -m gemini-2.5-pro -p "<prompt>"`
  *   vllm/cli-claude/claude-opus-4-6 → `claude -p -m claude-opus-4-6 --output-format text "<prompt>"`
@@ -18,6 +26,12 @@ import type {
   ProviderAuthContext,
   ProviderAuthResult,
 } from "openclaw/plugin-sdk";
+
+// Types derived from the plugin SDK (PluginCommandContext / PluginCommandResult are
+// not re-exported from the package, so we infer them from the registerCommand signature).
+type RegisterCommandParam = Parameters<OpenClawPluginApi["registerCommand"]>[0];
+type PluginCommandContext = Parameters<RegisterCommandParam["handler"]>[0];
+type PluginCommandResult = Awaited<ReturnType<RegisterCommandParam["handler"]>>;
 import { buildOauthProviderAuthResult } from "openclaw/plugin-sdk";
 import {
   DEFAULT_CODEX_AUTH_PATH,
@@ -44,16 +58,94 @@ interface CliPluginConfig {
 const DEFAULT_PROXY_PORT = 31337;
 const DEFAULT_PROXY_API_KEY = "cli-bridge";
 
+// ──────────────────────────────────────────────────────────────────────────────
+// Phase 3: slash-command model table
+// ──────────────────────────────────────────────────────────────────────────────
+
+/** CLI bridge models available via /cli-* slash commands. */
+const CLI_MODEL_COMMANDS = [
+  {
+    name: "cli-sonnet",
+    model: "vllm/cli-claude/claude-sonnet-4-6",
+    description: "Switch to Claude Sonnet 4.6 (CLI bridge)",
+    label: "Claude Sonnet 4.6 (CLI)",
+  },
+  {
+    name: "cli-opus",
+    model: "vllm/cli-claude/claude-opus-4-6",
+    description: "Switch to Claude Opus 4.6 (CLI bridge)",
+    label: "Claude Opus 4.6 (CLI)",
+  },
+  {
+    name: "cli-haiku",
+    model: "vllm/cli-claude/claude-haiku-4-5",
+    description: "Switch to Claude Haiku 4.5 (CLI bridge)",
+    label: "Claude Haiku 4.5 (CLI)",
+  },
+  {
+    name: "cli-gemini",
+    model: "vllm/cli-gemini/gemini-2.5-pro",
+    description: "Switch to Gemini 2.5 Pro (CLI bridge)",
+    label: "Gemini 2.5 Pro (CLI)",
+  },
+  {
+    name: "cli-gemini-flash",
+    model: "vllm/cli-gemini/gemini-2.5-flash",
+    description: "Switch to Gemini 2.5 Flash (CLI bridge)",
+    label: "Gemini 2.5 Flash (CLI)",
+  },
+  {
+    name: "cli-gemini3",
+    model: "vllm/cli-gemini/gemini-3-pro",
+    description: "Switch to Gemini 3 Pro (CLI bridge)",
+    label: "Gemini 3 Pro (CLI)",
+  },
+] as const;
+
+// ──────────────────────────────────────────────────────────────────────────────
+// Helper: run `openclaw models set <model>` and return result text
+// ──────────────────────────────────────────────────────────────────────────────
+
+async function switchModel(
+  api: OpenClawPluginApi,
+  model: string,
+  label: string,
+  _ctx: PluginCommandContext
+): Promise<PluginCommandResult> {
+  try {
+    const result = await api.runtime.system.runCommandWithTimeout(
+      ["openclaw", "models", "set", model],
+      { timeoutMs: 8_000 }
+    );
+
+    if (result.code !== 0) {
+      const err = (result.stderr || result.stdout || "unknown error").trim();
+      api.logger.warn(`[cli-bridge] models set failed (code ${result.code}): ${err}`);
+      return { text: `❌ Failed to switch to ${label}: ${err}` };
+    }
+
+    api.logger.info(`[cli-bridge] switched model → ${model}`);
+    return {
+      text: `✅ Switched to ${label}\n\`${model}\``,
+    };
+  } catch (err) {
+    const msg = (err as Error).message;
+    api.logger.warn(`[cli-bridge] models set error: ${msg}`);
+    return { text: `❌ Error switching model: ${msg}` };
+  }
+}
+
 // ──────────────────────────────────────────────────────────────────────────────
 // Plugin definition
 // ──────────────────────────────────────────────────────────────────────────────
 const plugin = {
   id: "openclaw-cli-bridge-elvatis",
   name: "OpenClaw CLI Bridge",
-  version: "0.2.0",
+  version: "0.2.1",
   description:
     "Phase 1: openai-codex auth bridge (reads ~/.codex/auth.json). " +
-    "Phase 2: HTTP proxy server routing model calls through gemini/claude CLIs.",
+    "Phase 2: HTTP proxy server routing model calls through gemini/claude CLIs. " +
+    "Phase 3: /cli-* slash commands for instant model switching.",
 
   register(api: OpenClawPluginApi) {
     const cfg = (api.pluginConfig ?? {}) as CliPluginConfig;
@@ -154,6 +246,27 @@ const plugin = {
           );
         });
     }
+
+    // ── Phase 3: /cli-* slash commands ────────────────────────────────────────
+    for (const entry of CLI_MODEL_COMMANDS) {
+      // Capture entry in closure (const iteration variable is stable in TS/ESM)
+      const { name, model, description, label } = entry;
+
+      api.registerCommand({
+        name,
+        description,
+        requireAuth: true, // only authorized senders
+        handler: async (ctx: PluginCommandContext): Promise<PluginCommandResult> => {
+          api.logger.info(`[cli-bridge] /${name} triggered by ${ctx.senderId ?? "unknown"} (authorized=${ctx.isAuthorizedSender})`);
+          return switchModel(api, model, label, ctx);
+        },
+      });
+    }
+
+    api.logger.info(
+      `[cli-bridge] registered ${CLI_MODEL_COMMANDS.length} slash commands: ` +
+        CLI_MODEL_COMMANDS.map((c) => `/${c.name}`).join(", ")
+    );
   },
 };
 

package/openclaw.plugin.json

@@ -1,9 +1,11 @@
 {
   "id": "openclaw-cli-bridge-elvatis",
   "name": "OpenClaw CLI Bridge",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "description": "Phase 1: openai-codex auth bridge. Phase 2: local HTTP proxy routing model calls through gemini/claude CLIs (vllm provider).",
-  "providers": ["openai-codex"],
+  "providers": [
+    "openai-codex"
+  ],
   "configSchema": {
     "type": "object",
     "additionalProperties": false,

package/package.json

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

package/src/cli-runner.ts

@@ -2,10 +2,22 @@
  * cli-runner.ts
  *
  * Spawns CLI subprocesses (gemini, claude) and captures their output.
- * Input: OpenAI-format messages → formatted prompt string → CLI stdout.
+ * Input: OpenAI-format messages → formatted prompt string → CLI stdin.
+ *
+ * IMPORTANT: Prompt is always passed via stdin (not as a CLI argument) to
+ * avoid E2BIG ("Argument list too long") when conversation history is large.
  */
 
 import { spawn } from "node:child_process";
+import { writeFileSync, unlinkSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { randomBytes } from "node:crypto";
+
+/** Max messages to include in the prompt sent to the CLI. */
+const MAX_MESSAGES = 20;
+/** Max characters per message content before truncation. */
+const MAX_MSG_CHARS = 4000;
 
 // ──────────────────────────────────────────────────────────────────────────────
 // Message formatting
@@ -18,31 +30,44 @@ export interface ChatMessage {
 
 /**
  * Convert OpenAI messages to a single flat prompt string.
- * Both Gemini and Claude CLIs accept a plain text prompt.
+ * Truncates to MAX_MESSAGES (keeping the most recent) and MAX_MSG_CHARS per
+ * message to avoid E2BIG when conversation history is very large.
  */
 export function formatPrompt(messages: ChatMessage[]): string {
   if (messages.length === 0) return "";
 
-  // If it's just a single user message, send it directly — no wrapping.
-  if (messages.length === 1 && messages[0].role === "user") {
-    return messages[0].content;
+  // Keep system message (if any) + last N non-system messages
+  const system = messages.find((m) => m.role === "system");
+  const nonSystem = messages.filter((m) => m.role !== "system");
+  const recent = nonSystem.slice(-MAX_MESSAGES);
+  const truncated = system ? [system, ...recent] : recent;
+
+  // If single user message with short content, send directly — no wrapping.
+  if (truncated.length === 1 && truncated[0].role === "user") {
+    return truncateContent(truncated[0].content);
   }
 
-  return messages
+  return truncated
     .map((m) => {
+      const content = truncateContent(m.content);
       switch (m.role) {
         case "system":
-          return `[System]\n${m.content}`;
+          return `[System]\n${content}`;
         case "assistant":
-          return `[Assistant]\n${m.content}`;
+          return `[Assistant]\n${content}`;
         case "user":
         default:
-          return `[User]\n${m.content}`;
+          return `[User]\n${content}`;
       }
     })
     .join("\n\n");
 }
 
+function truncateContent(s: string): string {
+  if (s.length <= MAX_MSG_CHARS) return s;
+  return s.slice(0, MAX_MSG_CHARS) + `\n...[truncated ${s.length - MAX_MSG_CHARS} chars]`;
+}
+
 // ──────────────────────────────────────────────────────────────────────────────
 // Core subprocess runner
 // ──────────────────────────────────────────────────────────────────────────────
@@ -53,23 +78,72 @@ export interface CliRunResult {
   exitCode: number;
 }
 
+/**
+ * Build a minimal, safe environment for spawning CLI subprocesses.
+ *
+ * WHY: The OpenClaw gateway may inject large values into process.env at
+ * runtime (system prompts, session data, OPENCLAW_* vars, etc.). Spreading
+ * the full process.env into spawn() can push the combined argv+envp over
+ * ARG_MAX (~2 MB on Linux), causing "spawn E2BIG". Using only the vars that
+ * the CLI tools actually need keeps us well under the limit regardless of
+ * what the parent process environment contains.
+ */
+function buildMinimalEnv(): Record<string, string> {
+  const pick = (key: string): string | undefined => process.env[key];
+
+  const env: Record<string, string> = {
+    NO_COLOR: "1",
+    TERM: "dumb",
+  };
+
+  // Essential path/identity vars — always include when present.
+  for (const key of ["HOME", "PATH", "USER", "LOGNAME", "SHELL", "TMPDIR", "TMP", "TEMP"]) {
+    const v = pick(key);
+    if (v) env[key] = v;
+  }
+
+  // Allow google-auth / claude auth paths to be inherited.
+  for (const key of [
+    "GOOGLE_APPLICATION_CREDENTIALS",
+    "ANTHROPIC_API_KEY",
+    "CLAUDE_API_KEY",
+    "CODEX_API_KEY",
+    "OPENAI_API_KEY",
+    "XDG_CONFIG_HOME",
+    "XDG_DATA_HOME",
+    "XDG_CACHE_HOME",
+  ]) {
+    const v = pick(key);
+    if (v) env[key] = v;
+  }
+
+  return env;
+}
+
+/**
+ * Spawn a CLI and deliver the prompt via stdin (not as an argument).
+ * This avoids E2BIG ("Argument list too long") for large conversation histories
+ * or when the parent process has a large runtime environment.
+ */
 export function runCli(
   cmd: string,
   args: string[],
+  prompt: string,
   timeoutMs = 120_000
 ): Promise<CliRunResult> {
   return new Promise((resolve, reject) => {
     const proc = spawn(cmd, args, {
       timeout: timeoutMs,
-      env: { ...process.env, NO_COLOR: "1" }, // strip ANSI codes from output
+      env: buildMinimalEnv(),
     });
 
     let stdout = "";
     let stderr = "";
 
-    // Important: some CLIs (notably Claude Code) keep waiting for stdin EOF
-    // even when prompt is provided as an argument. Close stdin immediately.
-    proc.stdin.end();
+    // Write prompt to stdin then close — prevents the CLI from waiting for more input.
+    proc.stdin.write(prompt, "utf8", () => {
+      proc.stdin.end();
+    });
 
     proc.stdout.on("data", (d: Buffer) => {
       stdout += d.toString();
@@ -102,16 +176,24 @@ export async function runGemini(
   timeoutMs: number
 ): Promise<string> {
   const model = stripPrefix(modelId);
-  const args = ["-m", model, "-p", prompt];
-  const result = await runCli("gemini", args, timeoutMs);
+  // Gemini CLI doesn't support stdin — write prompt to a temp file and read it via @file syntax
+  const tmpFile = join(tmpdir(), `cli-bridge-${randomBytes(6).toString("hex")}.txt`);
+  writeFileSync(tmpFile, prompt, "utf8");
+  try {
+    // Use @<file> to pass prompt from file (avoids ARG_MAX limit)
+    const args = ["-m", model, "-p", `@${tmpFile}`];
+    const result = await runCli("gemini", args, "", timeoutMs);
 
-  if (result.exitCode !== 0 && result.stdout.length === 0) {
-    throw new Error(
-      `gemini exited ${result.exitCode}: ${result.stderr || "(no output)"}`
-    );
-  }
+    if (result.exitCode !== 0 && result.stdout.length === 0) {
+      throw new Error(
+        `gemini exited ${result.exitCode}: ${result.stderr || "(no output)"}`
+      );
+    }
 
-  return result.stdout || result.stderr; // gemini sometimes writes to stderr
+    return result.stdout || result.stderr;
+  } finally {
+    try { unlinkSync(tmpFile); } catch { /* ignore */ }
+  }
 }
 
 // ──────────────────────────────────────────────────────────────────────────────
@@ -128,6 +210,7 @@ export async function runClaude(
   timeoutMs: number
 ): Promise<string> {
   const model = stripPrefix(modelId);
+  // No prompt argument — deliver via stdin to avoid E2BIG
   const args = [
     "-p",
     "--output-format",
@@ -138,9 +221,8 @@ export async function runClaude(
     "",
     "--model",
     model,
-    prompt,
   ];
-  const result = await runCli("claude", args, timeoutMs);
+  const result = await runCli("claude", args, prompt, timeoutMs);
 
   if (result.exitCode !== 0 && result.stdout.length === 0) {
     throw new Error(

package/test/cli-runner.test.ts

@@ -0,0 +1,46 @@
+import { describe, it, expect } from "vitest";
+import { formatPrompt } from "../src/cli-runner.js";
+
+describe("formatPrompt", () => {
+  it("returns empty string for empty messages", () => {
+    expect(formatPrompt([])).toBe("");
+  });
+
+  it("returns bare user text for a single short user message", () => {
+    const result = formatPrompt([{ role: "user", content: "hello" }]);
+    expect(result).toBe("hello");
+  });
+
+  it("truncates to MAX_MESSAGES (20) non-system messages", () => {
+    const messages = Array.from({ length: 30 }, (_, i) => ({
+      role: "user" as const,
+      content: `msg ${i}`,
+    }));
+    const result = formatPrompt(messages);
+    // Should contain last 20 messages, not first 10
+    expect(result).toContain("msg 29");
+    expect(result).not.toContain("msg 0\n");
+    // Single-turn mode doesn't apply when there are multiple messages
+    expect(result).toContain("[User]");
+  });
+
+  it("keeps system message + last 20 non-system messages", () => {
+    const sys = { role: "system" as const, content: "You are helpful" };
+    const msgs = Array.from({ length: 25 }, (_, i) => ({
+      role: "user" as const,
+      content: `msg ${i}`,
+    }));
+    const result = formatPrompt([sys, ...msgs]);
+    expect(result).toContain("[System]");
+    expect(result).toContain("You are helpful");
+    expect(result).toContain("msg 24"); // last
+    expect(result).not.toContain("msg 0\n"); // first (truncated)
+  });
+
+  it("truncates individual message content at MAX_MSG_CHARS (4000)", () => {
+    const longContent = "x".repeat(5000);
+    const result = formatPrompt([{ role: "user", content: longContent }]);
+    expect(result.length).toBeLessThan(5000);
+    expect(result).toContain("truncated");
+  });
+});