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

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/openclaw.plugin.json

@@ -1,9 +1,11 @@
 {
   "id": "openclaw-cli-bridge-elvatis",
   "name": "OpenClaw CLI Bridge",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "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.1",
   "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");
+  });
+});