@elvatis_com/openclaw-cli-bridge-elvatis 3.3.1 → 3.4.1

package/CLAUDE.md

@@ -30,6 +30,8 @@ OpenClaw Gateway ──(HTTP)──> proxy-server.ts ──(spawn)──> claude
 - **Smart fallback** — Sonnet tries first (better tool selection), 30s stale timeout kills it fast, Haiku takes over (~10s, reliable but picks wrong tools sometimes)
 - **Compact tool schema** — when >8 tools, only send name+params (skip descriptions/full JSON schema), cuts prompt ~60%
 - **Exit 143 = our SIGTERM** — not OOM, not crash. The bridge's timeout/stale-output detector sends SIGTERM, Claude CLI exits 143
+- **Consecutive timeout rotation** — after 3 timeouts in a row on the same session, auto-expire it and create a fresh one. Prevents poisoned sessions from blocking all requests
+- **Workspace project auto-detection** — scans `~/.openclaw/workspace/` for project directories; when the prompt contains an exact match of a project name, auto-sets `workdir` and injects `[Context: Working directory is ...]` into the prompt
 
 ## Build & Test
 
@@ -69,6 +71,8 @@ All magic numbers live here. Key values:
 | `TOOL_HEAVY_THRESHOLD` | 10 | Reduce MAX_MESSAGES from 20 to 12 when tools exceed this |
 | `COMPACT_TOOL_THRESHOLD` | 8 | Switch to compact tool schema (name+params only) |
 | `TOOL_ROUTING_THRESHOLD` | 8 | (in proxy-server) Was used for Haiku routing, now Sonnet-first with fast fallback |
+| `CONSECUTIVE_TIMEOUT_LIMIT` | 3 | (in cli-runner) Auto-expire session after N consecutive timeouts |
+| `WORKSPACE_DIR` | `~/.openclaw/workspace` | Project directory scanned for auto-detection |
 
 ## Tool Protocol (src/tool-protocol.ts)
 

package/README.md

@@ -2,7 +2,7 @@
 
 > OpenClaw plugin that bridges locally installed AI CLIs (Codex, Gemini, Claude Code, OpenCode, Pi) as model providers — with slash commands for instant model switching, restore, health testing, and model listing.
 
-**Current version:** `3.3.1`
+**Current version:** `3.4.1`
 
 ---
 

package/SKILL.md

@@ -68,4 +68,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:** 3.3.1
+**Version:** 3.4.1

package/openclaw.plugin.json

@@ -2,7 +2,7 @@
   "id": "openclaw-cli-bridge-elvatis",
   "slug": "openclaw-cli-bridge-elvatis",
   "name": "OpenClaw CLI Bridge",
-  "version": "3.3.1",
+  "version": "3.4.1",
   "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": "3.3.1",
+  "version": "3.4.1",
   "description": "Bridges gemini, claude, and codex CLI tools as OpenClaw model providers. Reads existing CLI auth without re-login.",
   "type": "module",
   "openclaw": {

package/src/cli-runner.ts

@@ -18,7 +18,7 @@
 
 import { spawn, execSync } from "node:child_process";
 import { tmpdir, homedir } from "node:os";
-import { existsSync, writeFileSync, unlinkSync, mkdirSync, readFileSync } from "node:fs";
+import { existsSync, writeFileSync, unlinkSync, mkdirSync, readFileSync, readdirSync, statSync } from "node:fs";
 import { join } from "node:path";
 import { randomBytes, randomUUID } from "node:crypto";
 import { ensureClaudeToken, refreshClaudeToken } from "./claude-auth.js";
@@ -37,6 +37,7 @@ import {
   TIMEOUT_GRACE_MS,
   MEDIA_TMP_DIR,
   STALE_OUTPUT_TIMEOUT_MS,
+  WORKSPACE_DIR,
 } from "./config.js";
 import { debugLog } from "./debug-log.js";
 
@@ -567,8 +568,11 @@ interface CliSessionEntry {
   createdAt: number;
   lastUsedAt: number;
   requestCount: number;
+  consecutiveTimeouts: number;
 }
 
+const CONSECUTIVE_TIMEOUT_LIMIT = 3;
+
 const cliSessions = new Map<string, CliSessionEntry>();
 let sessionsLoaded = false;
 
@@ -609,6 +613,7 @@ function getOrCreateSession(provider: string, model: string): CliSessionEntry {
     createdAt: Date.now(),
     lastUsedAt: Date.now(),
     requestCount: 0,
+    consecutiveTimeouts: 0,
   };
   cliSessions.set(model, entry);
   saveCliSessions();
@@ -617,7 +622,21 @@ function getOrCreateSession(provider: string, model: string): CliSessionEntry {
 
 function recordSessionSuccess(model: string): void {
   const s = cliSessions.get(model);
-  if (s) { s.requestCount++; s.lastUsedAt = Date.now(); saveCliSessions(); }
+  if (s) { s.requestCount++; s.lastUsedAt = Date.now(); s.consecutiveTimeouts = 0; saveCliSessions(); }
+}
+
+function recordSessionTimeout(model: string): void {
+  const s = cliSessions.get(model);
+  if (!s) return;
+  s.consecutiveTimeouts++;
+  s.lastUsedAt = Date.now();
+  if (s.consecutiveTimeouts >= CONSECUTIVE_TIMEOUT_LIMIT) {
+    debugLog("SESSION", `${s.provider} session ${s.sessionId.slice(0, 8)} expired`, {
+      reason: "consecutive_timeouts", consecutiveTimeouts: s.consecutiveTimeouts, requestCount: s.requestCount,
+    });
+    cliSessions.delete(model);
+  }
+  saveCliSessions();
 }
 
 function invalidateSession(model: string): void {
@@ -682,15 +701,15 @@ export async function runClaude(
 
   // Session failed — check if it's a timeout or auth issue
   if (result.timedOut) {
-    // Don't invalidate session on timeout — it's still valid, just slow
-    recordSessionSuccess(model); // keep session alive
+    // Track consecutive timeouts — after 3 in a row, expire the session
+    recordSessionTimeout(model);
     throw new Error(`claude exited ${result.exitCode}: ${annotateExitError(result.exitCode, result.stderr, true, modelId)}`);
   }
 
   const stderr = result.stderr || "(no output)";
 
-  // Session might be corrupted or expired — invalidate and retry with a fresh session
-  if (stderr.includes("session") || stderr.includes("resume") || stderr.includes("not found")) {
+  // Session might be corrupted, expired, or locked by a zombie process — invalidate and retry
+  if (stderr.includes("session") || stderr.includes("resume") || stderr.includes("not found") || stderr.includes("already in use")) {
     debugLog("CLAUDE", `session ${session.sessionId.slice(0, 8)} invalid, creating fresh`, { error: stderr.slice(0, 100) });
     invalidateSession(model);
     // Retry once with a fresh session
@@ -705,6 +724,8 @@ export async function runClaude(
       recordSessionSuccess(model);
       return retry.stdout;
     }
+    // Retry also failed — invalidate the fresh session so the next request doesn't reuse it
+    invalidateSession(model);
     throw new Error(`claude exited ${retry.exitCode}: ${annotateExitError(retry.exitCode, retry.stderr || "(no output)", false, modelId)}`);
   }
 
@@ -920,6 +941,63 @@ export interface RouteOptions {
   log?: (msg: string) => void;
 }
 
+// ── Workspace project detection ──────────────────────────────────────────────
+// Scans WORKSPACE_DIR for project directories. When the user's prompt contains
+// an exact match of a project name, auto-sets workdir and injects context.
+
+let _workspaceProjects: string[] | null = null;
+let _workspaceProjectsRefreshedAt = 0;
+const WORKSPACE_CACHE_TTL = 60_000; // refresh project list every 60s
+
+function getWorkspaceProjects(): string[] {
+  const now = Date.now();
+  if (_workspaceProjects && (now - _workspaceProjectsRefreshedAt) < WORKSPACE_CACHE_TTL) {
+    return _workspaceProjects;
+  }
+  try {
+    // Find all .openclaw/workspace dirs — default location + any custom ones
+    const candidates = [WORKSPACE_DIR];
+    _workspaceProjects = [];
+    for (const wsDir of candidates) {
+      if (!existsSync(wsDir)) continue;
+      const entries = readdirSync(wsDir);
+      for (const name of entries) {
+        try {
+          if (statSync(join(wsDir, name)).isDirectory()) {
+            _workspaceProjects.push(name);
+          }
+        } catch { /* skip unreadable entries */ }
+      }
+    }
+    _workspaceProjectsRefreshedAt = now;
+  } catch {
+    _workspaceProjects = [];
+  }
+  return _workspaceProjects;
+}
+
+function detectProjectFromPrompt(prompt: string): { name: string; path: string } | null {
+  const projects = getWorkspaceProjects();
+  if (!projects.length) return null;
+
+  // Sort by name length descending — match longest project name first
+  // (e.g. "openclaw-cli-bridge-elvatis" before "openclaw-cli-bridge")
+  const sorted = [...projects].sort((a, b) => b.length - a.length);
+
+  for (const name of sorted) {
+    // Case-insensitive exact word match — the project name must appear as a
+    // distinct token in the prompt (not a substring of a longer word)
+    const regex = new RegExp(`\\b${name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\b`, "i");
+    if (regex.test(prompt)) {
+      const projectPath = join(WORKSPACE_DIR, name);
+      if (existsSync(projectPath)) {
+        return { name, path: projectPath };
+      }
+    }
+  }
+  return null;
+}
+
 /**
  * Route a chat completion to the correct CLI based on model prefix.
  *   cli-gemini/<id>      → gemini CLI
@@ -941,9 +1019,19 @@ export async function routeToCliRunner(
   opts: RouteOptions = {}
 ): Promise<CliToolResult> {
   const toolCount = opts.tools?.length ?? 0;
-  const prompt = formatPrompt(messages, toolCount);
+  let prompt = formatPrompt(messages, toolCount);
   const hasTools = toolCount > 0;
 
+  // Auto-detect project from prompt and set workdir + inject context
+  if (!opts.workdir) {
+    const detected = detectProjectFromPrompt(prompt);
+    if (detected) {
+      opts = { ...opts, workdir: detected.path };
+      prompt = `[Context: Working directory is ${detected.path}]\n\n${prompt}`;
+      debugLog("WORKSPACE", `auto-detected project "${detected.name}"`, { path: detected.path });
+    }
+  }
+
   // Strip "vllm/" prefix if present — OpenClaw sends the full provider path
   // (e.g. "vllm/cli-claude/claude-sonnet-4-6") but the router only needs the
   // "cli-<type>/<model>" portion.

package/src/config.ts

@@ -162,6 +162,9 @@ export const DEFAULT_MODEL_FALLBACKS: Record<string, string[]> = {
 /** Base directory for all CLI bridge state files. */
 export const OPENCLAW_DIR = join(homedir(), ".openclaw");
 
+/** Workspace directory containing all projects. */
+export const WORKSPACE_DIR = join(OPENCLAW_DIR, "workspace");
+
 /** State file — persists the model active before the last /cli-* switch. */
 export const STATE_FILE = join(OPENCLAW_DIR, "cli-bridge-state.json");