@bike4mind/cli 0.2.29-feat-cli-sandbox.18843 → 0.2.29-feat-cli-websocket-streaming.18841

package/dist/index.js

@@ -1,22 +1,21 @@
 #!/usr/bin/env node
-import "./chunk-ELTTBWAQ.js";
 import "./chunk-BPFEGDC7.js";
 import "./chunk-BDQBOLYG.js";
 import {
   getEffectiveApiKey,
   getOpenWeatherKey,
   getSerperKey
-} from "./chunk-BCOGDPUB.js";
+} from "./chunk-QQL3OBKL.js";
 import {
   ConfigStore,
   logger
-} from "./chunk-JWEG53NG.js";
+} from "./chunk-LBTTUQJM.js";
 import {
   selectActiveBackgroundAgents,
   useCliStore
 } from "./chunk-TVW4ZESU.js";
-import "./chunk-W4TCH4ZT.js";
-import "./chunk-PKKJ44C5.js";
+import "./chunk-BXCARBUQ.js";
+import "./chunk-EC2VEDD2.js";
 import {
   BFLImageService,
   BaseStorage,
@@ -28,7 +27,7 @@ import {
   OpenAIBackend,
   OpenAIImageService,
   XAIImageService
-} from "./chunk-S7BPPS33.js";
+} from "./chunk-TY6Z2UV2.js";
 import {
   AiEvents,
   ApiKeyEvents,
@@ -84,7 +83,7 @@ import {
   XAI_IMAGE_MODELS,
   b4mLLMTools,
   getMcpProviderMetadata
-} from "./chunk-5GSDPBTM.js";
+} from "./chunk-KPOK6V6E.js";
 import {
   Logger
 } from "./chunk-OCYRD7D6.js";
@@ -94,7 +93,7 @@ import React21, { useState as useState9, useEffect as useEffect6, useCallback as
 import { render, Box as Box20, Text as Text20, useApp, useInput as useInput9 } from "ink";
 import { execSync } from "child_process";
 import { randomBytes as randomBytes5 } from "crypto";
-import { v4 as uuidv411 } from "uuid";
+import { v4 as uuidv413 } from "uuid";
 
 // src/components/App.tsx
 import React15, { useState as useState5, useEffect as useEffect4 } from "react";
@@ -646,24 +645,6 @@ var COMMANDS = [
     name: "compact",
     description: "Compact conversation into new session",
     args: "[instructions]"
-  },
-  // Sandbox commands
-  {
-    name: "sandbox",
-    description: "Show sandbox status and configuration"
-  },
-  {
-    name: "sandbox:enable",
-    description: "Enable OS-level sandbox for bash commands"
-  },
-  {
-    name: "sandbox:disable",
-    description: "Disable sandbox mode"
-  },
-  {
-    name: "sandbox:mode",
-    description: "Set sandbox mode (auto-allow or permissions)",
-    args: "<auto-allow|permissions>"
   }
 ];
 function getAllCommandNames() {
@@ -3711,9 +3692,6 @@ EXAMPLES:
 Remember: Use context from previous messages to understand follow-up questions.${contextSection}`;
 }
 
-// src/utils/toolsAdapter.ts
-import { rmSync } from "fs";
-
 // ../../b4m-core/packages/services/dist/src/referService/generateCodes.js
 import { randomBytes } from "crypto";
 import range from "lodash/range.js";
@@ -11460,6 +11438,10 @@ var ServerToolExecutor = class {
 };
 
 // src/llm/ToolRouter.ts
+var wsToolExecutor = null;
+function setWebSocketToolExecutor(executor) {
+  wsToolExecutor = executor;
+}
 var SERVER_TOOLS = ["weather_info", "web_search", "web_fetch"];
 var LOCAL_TOOLS = [
   "file_read",
@@ -11482,7 +11464,15 @@ function isLocalTool(toolName) {
 }
 async function executeTool(toolName, input, apiClient, localToolFn) {
   if (isServerTool(toolName)) {
-    logger.debug(`[ToolRouter] Routing ${toolName} to server`);
+    if (wsToolExecutor) {
+      logger.debug(`[ToolRouter] Routing ${toolName} to server via WebSocket`);
+      const result = await wsToolExecutor.execute(toolName, input);
+      if (!result.success) {
+        return `Error executing ${toolName}: ${result.error || "Tool execution failed"}`;
+      }
+      return typeof result.content === "string" ? result.content : JSON.stringify(result.content ?? "");
+    }
+    logger.debug(`[ToolRouter] Routing ${toolName} to server via HTTP`);
     const executor = new ServerToolExecutor(apiClient);
     return await executor.executeTool(toolName, input);
   } else if (isLocalTool(toolName)) {
@@ -11732,60 +11722,20 @@ var CliLogger = class extends Logger {
   log(...args) {
   }
 };
-function wrapToolWithPermission(tool, permissionManager, showPermissionPrompt, agentContext, configStore, apiClient, sandboxOrchestrator) {
+function wrapToolWithPermission(tool, permissionManager, showPermissionPrompt, agentContext, configStore, apiClient) {
   const originalFn = tool.toolFn;
   const toolName = tool.toolSchema.name;
   return {
     ...tool,
     toolFn: async (args) => {
-      let isSandboxed = false;
-      let sandboxedArgs = args;
-      if (toolName === "bash_execute" && args?.command && sandboxOrchestrator) {
-        const pathMod = await import("path");
-        const cwd = args.cwd ? pathMod.resolve(process.cwd(), args.cwd) : process.cwd();
-        const decision = sandboxOrchestrator.shouldSandbox(args.command, cwd);
-        if (decision.type === "blocked") {
-          return `Command blocked by sandbox: ${decision.reason}`;
-        }
-        if (decision.type === "sandbox") {
-          isSandboxed = true;
-          sandboxedArgs = {
-            ...args,
-            command: decision.wrappedCommand.commandString,
-            // Store cleanup paths for post-execution cleanup
-            _sandboxCleanup: decision.wrappedCommand.cleanupPaths
-          };
-        }
-      }
-      const effectiveArgs = isSandboxed ? sandboxedArgs : args;
-      if (!permissionManager.needsPermission(toolName, { isSandboxed })) {
-        let result2 = await executeTool(toolName, effectiveArgs, apiClient, originalFn);
-        cleanupSandboxFiles(effectiveArgs?._sandboxCleanup);
-        result2 = await retrySandboxFailure(
-          isSandboxed,
-          result2,
-          toolName,
-          args,
-          apiClient,
-          originalFn,
-          showPermissionPrompt
-        );
+      if (!permissionManager.needsPermission(toolName)) {
+        const result2 = await executeTool(toolName, args, apiClient, originalFn);
         agentContext.observationQueue.push({ toolName, result: result2 });
         return result2;
       }
       const { useCliStore: useCliStore2 } = await import("./store-FU6NDC2W.js");
       if (useCliStore2.getState().autoAcceptEdits) {
-        let result2 = await executeTool(toolName, effectiveArgs, apiClient, originalFn);
-        cleanupSandboxFiles(effectiveArgs?._sandboxCleanup);
-        result2 = await retrySandboxFailure(
-          isSandboxed,
-          result2,
-          toolName,
-          args,
-          apiClient,
-          originalFn,
-          showPermissionPrompt
-        );
+        const result2 = await executeTool(toolName, args, apiClient, originalFn);
         agentContext.observationQueue.push({ toolName, result: result2 });
         return result2;
       }
@@ -11820,10 +11770,9 @@ function wrapToolWithPermission(tool, permissionManager, showPermissionPrompt, a
       } else if (toolName === "bash_execute" && args?.command) {
         const cwd = args.cwd ? ` (in ${args.cwd})` : "";
         const timeout = args.timeout ? ` [timeout: ${args.timeout}ms]` : "";
-        const sandboxLabel = isSandboxed ? " [sandboxed]" : "";
-        preview = `$ ${args.command}${cwd}${timeout}${sandboxLabel}`;
+        preview = `$ ${args.command}${cwd}${timeout}`;
       }
-      const response = await showPermissionPrompt(toolName, effectiveArgs, preview);
+      const response = await showPermissionPrompt(toolName, args, preview);
       if (response.action === "deny") {
         throw new PermissionDeniedError(toolName, args);
       }
@@ -11848,50 +11797,12 @@ function wrapToolWithPermission(tool, permissionManager, showPermissionPrompt, a
           }
         }
       }
-      let result = await executeTool(toolName, effectiveArgs, apiClient, originalFn);
-      cleanupSandboxFiles(effectiveArgs?._sandboxCleanup);
-      result = await retrySandboxFailure(
-        isSandboxed,
-        result,
-        toolName,
-        args,
-        apiClient,
-        originalFn,
-        showPermissionPrompt
-      );
+      const result = await executeTool(toolName, args, apiClient, originalFn);
       agentContext.observationQueue.push({ toolName, result });
       return result;
     }
   };
 }
-function isSandboxFailure(isSandboxed, result) {
-  if (!isSandboxed) return false;
-  return result.includes("sandbox-exec:") || result.includes("bwrap:") || result.includes("Operation not permitted");
-}
-async function retrySandboxFailure(isSandboxed, result, toolName, originalArgs, apiClient, originalFn, showPermissionPrompt) {
-  if (!isSandboxFailure(isSandboxed, result)) return result;
-  const errorSnippet = result.slice(0, 200);
-  const retryResponse = await showPermissionPrompt(
-    toolName,
-    originalArgs,
-    `Sandbox execution failed. Retry without sandbox?
-
-Error: ${errorSnippet}`
-  );
-  if (retryResponse.action !== "deny") {
-    return executeTool(toolName, originalArgs, apiClient, originalFn);
-  }
-  return result;
-}
-function cleanupSandboxFiles(paths) {
-  if (!paths || paths.length === 0) return;
-  for (const p of paths) {
-    try {
-      rmSync(p, { recursive: true, force: true });
-    } catch {
-    }
-  }
-}
 function wrapToolWithHooks(tool, hooks, hookContext) {
   const hasToolHooks = hooks?.PreToolUse || hooks?.PostToolUse || hooks?.PostToolUseFailure;
   if (!hasToolHooks) {
@@ -11985,7 +11896,7 @@ function normalizeToolName(toolName) {
   }
   return TOOL_NAME_MAPPING[toolName] || toolName;
 }
-function generateCliTools(userId, llm, model, permissionManager, showPermissionPrompt, agentContext, configStore, apiClient, toolFilter, sandboxOrchestrator) {
+function generateCliTools(userId, llm, model, permissionManager, showPermissionPrompt, agentContext, configStore, apiClient, toolFilter) {
   const logger2 = new CliLogger();
   const storage = new NoOpStorage();
   const user = {
@@ -12045,15 +11956,7 @@ function generateCliTools(userId, llm, model, permissionManager, showPermissionP
     tools_to_generate
   );
   let tools = Object.entries(toolsMap).map(
-    ([_, tool]) => wrapToolWithPermission(
-      tool,
-      permissionManager,
-      showPermissionPrompt,
-      agentContext,
-      configStore,
-      apiClient,
-      sandboxOrchestrator
-    )
+    ([_, tool]) => wrapToolWithPermission(tool, permissionManager, showPermissionPrompt, agentContext, configStore, apiClient)
   );
   if (toolFilter) {
     const { allowedTools, deniedTools } = toolFilter;
@@ -12078,21 +11981,10 @@ var PermissionManager = class {
   constructor(trustedTools = [], customCategories, deniedTools) {
     this.trustedTools = /* @__PURE__ */ new Set();
     this.deniedTools = /* @__PURE__ */ new Set();
-    this._sandboxMode = "disabled";
-    this._sandboxActive = false;
     this.trustedTools = new Set(trustedTools);
     this.customCategories = new Map(Object.entries(customCategories || {}));
     this.deniedTools = new Set(deniedTools || []);
   }
-  /** Update sandbox state from the orchestrator */
-  setSandboxState(mode, active) {
-    this._sandboxMode = mode;
-    this._sandboxActive = active;
-  }
-  /** Check if sandbox auto-allow is active */
-  isSandboxAutoAllow() {
-    return this._sandboxMode === "auto-allow" && this._sandboxActive;
-  }
   /**
    * Check if a tool needs permission before execution
    *
@@ -12103,13 +11995,8 @@ var PermissionManager = class {
    *
    * Note: prompt_always tools CANNOT be trusted, so they always need permission
    * Note: denied tools from project config ALWAYS need permission (cannot be overridden locally)
-   *
-   * @param toolName - The tool being checked
-   * @param options.isSandboxed - If true, the command will run inside the OS-level sandbox.
-   *   In auto-allow mode, sandboxed bash_execute commands skip the permission prompt
-   *   because the sandbox provides the security boundary.
    */
-  needsPermission(toolName, options) {
+  needsPermission(toolName) {
     const categoryMap = Object.fromEntries(this.customCategories);
     const category = getToolCategory(toolName, categoryMap);
     if (this.deniedTools.has(toolName)) {
@@ -12118,9 +12005,6 @@ var PermissionManager = class {
     if (category === "auto_approve") {
       return false;
     }
-    if (options?.isSandboxed && toolName === "bash_execute" && this.isSandboxAutoAllow()) {
-      return false;
-    }
     if (category === "prompt_always") {
       return true;
     }
@@ -13518,6 +13402,186 @@ var ServerLlmBackend = class {
   }
 };
 
+// src/llm/WebSocketLlmBackend.ts
+import { v4 as uuidv411 } from "uuid";
+function stripThinkingBlocks2(text) {
+  return text.replace(/<think>[\s\S]*?<\/think>/g, "").trim();
+}
+var WebSocketLlmBackend = class {
+  constructor(options) {
+    this.wsManager = options.wsManager;
+    this.apiClient = options.apiClient;
+    this.currentModel = options.model;
+    this.tokenGetter = options.tokenGetter;
+  }
+  /**
+   * Make LLM completion request via WebSocket.
+   * Mirrors ServerLlmBackend accumulation logic — collects all chunks,
+   * calls callback once at completion with full accumulated content.
+   */
+  async complete(model, messages, options, callback) {
+    logger.debug(`[WebSocketLlmBackend] Starting complete() with model: ${model}`);
+    if (options.abortSignal?.aborted) {
+      logger.debug("[WebSocketLlmBackend] Request aborted before start");
+      return;
+    }
+    if (!this.wsManager.isConnected) {
+      throw new Error("WebSocket is not connected");
+    }
+    const requestId = uuidv411();
+    const token = await this.tokenGetter();
+    if (!token) {
+      throw new Error("No access token available");
+    }
+    return new Promise((resolve3, reject) => {
+      const isVerbose = process.env.B4M_VERBOSE === "1";
+      const isUltraVerbose = process.env.B4M_DEBUG_STREAM === "1";
+      const streamLogger = new StreamLogger(logger, "WebSocketLlmBackend", isVerbose, isUltraVerbose);
+      streamLogger.streamStart();
+      let eventCount = 0;
+      let accumulatedText = "";
+      let lastUsageInfo = {};
+      let toolsUsed = [];
+      let thinkingBlocks = [];
+      let settled = false;
+      const cleanup = () => {
+        this.wsManager.offRequest(requestId);
+      };
+      const settleResolve = () => {
+        if (settled) return;
+        settled = true;
+        cleanup();
+        resolve3();
+      };
+      const settleReject = (err) => {
+        if (settled) return;
+        settled = true;
+        cleanup();
+        reject(err);
+      };
+      if (options.abortSignal) {
+        const abortHandler = () => {
+          logger.debug("[WebSocketLlmBackend] Abort signal received");
+          settleResolve();
+        };
+        if (options.abortSignal.aborted) {
+          settleResolve();
+          return;
+        }
+        options.abortSignal.addEventListener("abort", abortHandler, { once: true });
+      }
+      this.wsManager.onRequest(requestId, (message) => {
+        if (options.abortSignal?.aborted) return;
+        const action = message.action;
+        if (action === "cli_completion_chunk") {
+          eventCount++;
+          const chunk = message.chunk;
+          streamLogger.onEvent(eventCount, JSON.stringify(chunk));
+          if (chunk.type === "content") {
+            const textChunk = chunk.text || "";
+            accumulatedText += textChunk;
+            streamLogger.onContent(eventCount, textChunk, accumulatedText);
+            if (chunk.usage) {
+              lastUsageInfo = {
+                inputTokens: chunk.usage.inputTokens,
+                outputTokens: chunk.usage.outputTokens
+              };
+            }
+          } else if (chunk.type === "tool_use") {
+            streamLogger.onCriticalEvent(eventCount, "TOOL_USE", `tools: ${chunk.tools?.length}`);
+            const textChunk = chunk.text || "";
+            if (textChunk) accumulatedText += textChunk;
+            if (chunk.tools && chunk.tools.length > 0) {
+              toolsUsed = chunk.tools;
+            }
+            if (chunk.thinking && chunk.thinking.length > 0) {
+              thinkingBlocks = chunk.thinking;
+            }
+            if (chunk.usage) {
+              lastUsageInfo = {
+                inputTokens: chunk.usage.inputTokens,
+                outputTokens: chunk.usage.outputTokens
+              };
+            }
+          }
+        } else if (action === "cli_completion_done") {
+          streamLogger.streamComplete(accumulatedText);
+          const cleanedText = stripThinkingBlocks2(accumulatedText);
+          if (toolsUsed.length > 0) {
+            const info = {
+              toolsUsed,
+              thinking: thinkingBlocks.length > 0 ? thinkingBlocks : void 0,
+              ...lastUsageInfo
+            };
+            callback([cleanedText], info).then(() => settleResolve()).catch((err) => settleReject(err));
+          } else if (cleanedText) {
+            callback([cleanedText], lastUsageInfo).then(() => settleResolve()).catch((err) => settleReject(err));
+          } else {
+            settleResolve();
+          }
+        } else if (action === "cli_completion_error") {
+          const errorMsg = message.error || "Server error";
+          streamLogger.onCriticalEvent(eventCount, "ERROR", errorMsg);
+          settleReject(new Error(errorMsg));
+        }
+      });
+      try {
+        this.wsManager.send({
+          action: "cli_completion_request",
+          accessToken: token,
+          requestId,
+          model,
+          messages,
+          options: {
+            temperature: options.temperature,
+            maxTokens: options.maxTokens,
+            stream: true,
+            tools: options.tools || []
+          }
+        });
+      } catch (err) {
+        settleReject(err instanceof Error ? err : new Error(String(err)));
+      }
+    });
+  }
+  /**
+   * Get available models from server (REST call, not streaming).
+   * Delegates to ApiClient — same as ServerLlmBackend.
+   */
+  async getModelInfo() {
+    try {
+      logger.debug("[WebSocketLlmBackend] Fetching models from /api/models");
+      const response = await this.apiClient.get("/api/models");
+      if (!response || typeof response !== "object" || !Array.isArray(response.models)) {
+        logger.warn("[WebSocketLlmBackend] Invalid API response format, using fallback models");
+        return this.getFallbackModels();
+      }
+      const filteredModels = response.models.filter(
+        (model) => model.type === "text" && model.supportsTools === true
+      );
+      if (filteredModels.length === 0) {
+        logger.warn("[WebSocketLlmBackend] No CLI-compatible models found, using fallback");
+        return this.getFallbackModels();
+      }
+      logger.debug(`[WebSocketLlmBackend] Loaded ${filteredModels.length} models`);
+      return filteredModels;
+    } catch (error) {
+      logger.warn(
+        `[WebSocketLlmBackend] Failed to fetch models: ${error instanceof Error ? error.message : String(error)}`
+      );
+      return this.getFallbackModels();
+    }
+  }
+  getFallbackModels() {
+    return [
+      { id: "claude-sonnet-4-5-20250929", name: "Claude 4.5 Sonnet" },
+      { id: "claude-3-5-haiku-20241022", name: "Claude 3.5 Haiku" },
+      { id: "gpt-4o", name: "GPT-4o" },
+      { id: "gpt-4o-mini", name: "GPT-4o Mini" }
+    ];
+  }
+};
+
 // src/llm/NotifyingLlmBackend.ts
 var NotifyingLlmBackend = class {
   constructor(inner, backgroundManager) {
@@ -13552,6 +13616,223 @@ Please acknowledge these background agent results and incorporate them into your
   }
 };
 
+// src/ws/WebSocketConnectionManager.ts
+var WebSocketConnectionManager = class {
+  constructor(wsUrl, getToken) {
+    this.ws = null;
+    this.heartbeatInterval = null;
+    this.reconnectAttempts = 0;
+    this.maxReconnectDelay = 3e4;
+    this.handlers = /* @__PURE__ */ new Map();
+    this.connected = false;
+    this.connecting = false;
+    this.closed = false;
+    this.wsUrl = wsUrl;
+    this.getToken = getToken;
+  }
+  /**
+   * Connect to the WebSocket server.
+   * Resolves when connection is established, rejects on failure.
+   */
+  async connect() {
+    if (this.connected || this.connecting) return;
+    this.connecting = true;
+    const token = await this.getToken();
+    if (!token) {
+      this.connecting = false;
+      throw new Error("No access token available for WebSocket connection");
+    }
+    return new Promise((resolve3, reject) => {
+      const url = `${this.wsUrl}?token=${token}`;
+      logger.debug(`[WS] Connecting to ${this.wsUrl}...`);
+      this.ws = new WebSocket(url);
+      this.ws.onopen = () => {
+        logger.debug("[WS] Connected");
+        this.connected = true;
+        this.connecting = false;
+        this.reconnectAttempts = 0;
+        this.startHeartbeat();
+        resolve3();
+      };
+      this.ws.onmessage = (event) => {
+        try {
+          const data = typeof event.data === "string" ? event.data : event.data.toString();
+          const message = JSON.parse(data);
+          const requestId = message.requestId;
+          if (requestId && this.handlers.has(requestId)) {
+            this.handlers.get(requestId)(message);
+          } else {
+            logger.debug(`[WS] Unhandled message: ${message.action || "unknown"}`);
+          }
+        } catch (err) {
+          logger.debug(`[WS] Failed to parse message: ${err}`);
+        }
+      };
+      this.ws.onclose = () => {
+        logger.debug("[WS] Connection closed");
+        this.cleanup();
+        if (!this.closed) {
+          this.scheduleReconnect();
+        }
+      };
+      this.ws.onerror = (err) => {
+        logger.debug(`[WS] Error: ${err}`);
+        if (this.connecting) {
+          this.connecting = false;
+          this.connected = false;
+          reject(new Error("WebSocket connection failed"));
+        }
+      };
+    });
+  }
+  /** Whether the connection is currently established */
+  get isConnected() {
+    return this.connected;
+  }
+  /**
+   * Send a JSON message over the WebSocket connection.
+   */
+  send(data) {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+      throw new Error("WebSocket is not connected");
+    }
+    this.ws.send(JSON.stringify(data));
+  }
+  /**
+   * Register a handler for messages matching a specific requestId.
+   */
+  onRequest(requestId, handler) {
+    this.handlers.set(requestId, handler);
+  }
+  /**
+   * Remove a handler for a specific requestId.
+   */
+  offRequest(requestId) {
+    this.handlers.delete(requestId);
+  }
+  /**
+   * Close the connection and stop all heartbeat/reconnect logic.
+   */
+  disconnect() {
+    this.closed = true;
+    this.cleanup();
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+    this.handlers.clear();
+  }
+  startHeartbeat() {
+    this.stopHeartbeat();
+    this.heartbeatInterval = setInterval(
+      () => {
+        if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+          this.ws.send(JSON.stringify({ action: "heartbeat" }));
+          logger.debug("[WS] Heartbeat sent");
+        }
+      },
+      5 * 60 * 1e3
+    );
+  }
+  stopHeartbeat() {
+    if (this.heartbeatInterval) {
+      clearInterval(this.heartbeatInterval);
+      this.heartbeatInterval = null;
+    }
+  }
+  cleanup() {
+    this.connected = false;
+    this.connecting = false;
+    this.stopHeartbeat();
+  }
+  scheduleReconnect() {
+    if (this.closed) return;
+    this.reconnectAttempts++;
+    const delay = Math.min(1e3 * Math.pow(2, this.reconnectAttempts - 1), this.maxReconnectDelay);
+    logger.debug(`[WS] Reconnecting in ${delay}ms (attempt ${this.reconnectAttempts})`);
+    setTimeout(async () => {
+      if (this.closed) return;
+      try {
+        await this.connect();
+      } catch {
+        logger.debug("[WS] Reconnection failed");
+      }
+    }, delay);
+  }
+};
+
+// src/ws/WebSocketToolExecutor.ts
+import { v4 as uuidv412 } from "uuid";
+var WebSocketToolExecutor = class {
+  constructor(wsManager, tokenGetter) {
+    this.wsManager = wsManager;
+    this.tokenGetter = tokenGetter;
+  }
+  /**
+   * Execute a server-side tool via WebSocket.
+   * Returns the tool result or throws on error.
+   */
+  async execute(toolName, input, abortSignal) {
+    if (!this.wsManager.isConnected) {
+      throw new Error("WebSocket is not connected");
+    }
+    const token = await this.tokenGetter();
+    if (!token) {
+      throw new Error("No access token available");
+    }
+    const requestId = uuidv412();
+    return new Promise((resolve3, reject) => {
+      let settled = false;
+      const cleanup = () => {
+        this.wsManager.offRequest(requestId);
+      };
+      const settleResolve = (result) => {
+        if (settled) return;
+        settled = true;
+        cleanup();
+        resolve3(result);
+      };
+      const settleReject = (err) => {
+        if (settled) return;
+        settled = true;
+        cleanup();
+        reject(err);
+      };
+      if (abortSignal) {
+        const abortHandler = () => {
+          settleReject(new Error("Tool execution aborted"));
+        };
+        if (abortSignal.aborted) {
+          settleReject(new Error("Tool execution aborted"));
+          return;
+        }
+        abortSignal.addEventListener("abort", abortHandler, { once: true });
+      }
+      this.wsManager.onRequest(requestId, (message) => {
+        const action = message.action;
+        if (action === "cli_tool_response") {
+          settleResolve({
+            success: message.success,
+            content: message.content,
+            error: message.error
+          });
+        }
+      });
+      try {
+        this.wsManager.send({
+          action: "cli_tool_request",
+          accessToken: token,
+          requestId,
+          toolName,
+          input
+        });
+      } catch (err) {
+        settleReject(err instanceof Error ? err : new Error(String(err)));
+      }
+    });
+  }
+};
+
 // src/auth/ApiClient.ts
 import axios11 from "axios";
 var ApiClient = class {
@@ -13689,7 +13970,7 @@ import { isAxiosError as isAxiosError2 } from "axios";
 // package.json
 var package_default = {
   name: "@bike4mind/cli",
-  version: "0.2.29-feat-cli-sandbox.18843+467f137bc",
+  version: "0.2.29-feat-cli-websocket-streaming.18841+5c940d031",
   type: "module",
   description: "Interactive CLI tool for Bike4Mind with ReAct agents",
   license: "UNLICENSED",
@@ -13799,10 +14080,10 @@ var package_default = {
   },
   devDependencies: {
     "@bike4mind/agents": "0.1.0",
-    "@bike4mind/common": "2.50.1-feat-cli-sandbox.18843+467f137bc",
-    "@bike4mind/mcp": "1.29.1-feat-cli-sandbox.18843+467f137bc",
-    "@bike4mind/services": "2.48.1-feat-cli-sandbox.18843+467f137bc",
-    "@bike4mind/utils": "2.5.1-feat-cli-sandbox.18843+467f137bc",
+    "@bike4mind/common": "2.50.1-feat-cli-websocket-streaming.18841+5c940d031",
+    "@bike4mind/mcp": "1.29.1-feat-cli-websocket-streaming.18841+5c940d031",
+    "@bike4mind/services": "2.48.1-feat-cli-websocket-streaming.18841+5c940d031",
+    "@bike4mind/utils": "2.5.1-feat-cli-websocket-streaming.18841+5c940d031",
     "@types/better-sqlite3": "^7.6.13",
     "@types/diff": "^5.0.9",
     "@types/jsonwebtoken": "^9.0.4",
@@ -13819,7 +14100,7 @@ var package_default = {
   optionalDependencies: {
     "@vscode/ripgrep": "^1.17.0"
   },
-  gitHead: "467f137bcb738020d1665b78bc7d34de7d846df5"
+  gitHead: "5c940d031610617c76d3c12cc611b71db8bb4caf"
 };
 
 // src/config/constants.ts
@@ -15628,7 +15909,7 @@ function CliApp() {
     abortController: null,
     contextContent: "",
     backgroundManager: null,
-    sandboxOrchestrator: null
+    wsManager: null
   });
   const [isInitialized, setIsInitialized] = useState9(false);
   const [initError, setInitError] = useState9(null);
@@ -15656,6 +15937,10 @@ function CliApp() {
         })
       );
     }
+    if (state.wsManager) {
+      state.wsManager.disconnect();
+      setWebSocketToolExecutor(null);
+    }
     if (state.agent) {
       state.agent.removeAllListeners();
     }
@@ -15674,7 +15959,7 @@ function CliApp() {
     setTimeout(() => {
       process.exit(0);
     }, 100);
-  }, [state.session, state.sessionStore, state.mcpManager, state.agent, state.imageStore]);
+  }, [state.session, state.sessionStore, state.mcpManager, state.agent, state.imageStore, state.wsManager]);
   useInput9((input, key) => {
     if (key.escape) {
       if (state.abortController) {
@@ -15744,7 +16029,7 @@ function CliApp() {
       if (!isAuthenticated) {
         console.log("\u2139\uFE0F  AI features disabled. Available commands: /login, /help, /config\n");
         const minimalSession = {
-          id: uuidv411(),
+          id: uuidv413(),
           name: `Session ${(/* @__PURE__ */ new Date()).toLocaleString()}`,
           createdAt: (/* @__PURE__ */ new Date()).toISOString(),
           updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -15772,10 +16057,41 @@ function CliApp() {
         console.log(`\u{1F30D} API Environment: ${envName} (${apiBaseURL})`);
       }
       const apiClient = new ApiClient(apiBaseURL, state.configStore);
-      const llm = new ServerLlmBackend({
-        apiClient,
-        model: config.defaultModel
-      });
+      const tokenGetter = async () => {
+        const tokens = await state.configStore.getAuthTokens();
+        return tokens?.accessToken ?? null;
+      };
+      let wsManager = null;
+      let llm;
+      try {
+        const serverConfig = await apiClient.get("/api/settings/serverConfig");
+        const wsUrl = serverConfig?.websocketUrl;
+        if (wsUrl) {
+          wsManager = new WebSocketConnectionManager(wsUrl, tokenGetter);
+          await wsManager.connect();
+          const wsToolExecutor2 = new WebSocketToolExecutor(wsManager, tokenGetter);
+          setWebSocketToolExecutor(wsToolExecutor2);
+          llm = new WebSocketLlmBackend({
+            wsManager,
+            apiClient,
+            model: config.defaultModel,
+            tokenGetter
+          });
+          logger.debug("\u{1F50C} Using WebSocket transport (bypasses CloudFront timeout)");
+        } else {
+          throw new Error("No websocketUrl in server config");
+        }
+      } catch (wsError) {
+        logger.debug(
+          `[WS] WebSocket unavailable, using SSE fallback: ${wsError instanceof Error ? wsError.message : String(wsError)}`
+        );
+        wsManager = null;
+        setWebSocketToolExecutor(null);
+        llm = new ServerLlmBackend({
+          apiClient,
+          model: config.defaultModel
+        });
+      }
       const models = await llm.getModelInfo();
       if (models.length === 0) {
         throw new Error("No models available from server.");
@@ -15788,7 +16104,7 @@ function CliApp() {
       }
       llm.currentModel = modelInfo.id;
       const newSession = {
-        id: uuidv411(),
+        id: uuidv413(),
         name: `Session ${(/* @__PURE__ */ new Date()).toLocaleString()}`,
         createdAt: (/* @__PURE__ */ new Date()).toISOString(),
         updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -15825,20 +16141,6 @@ function CliApp() {
         config.tools.disabled || []
         // denied tools from project config
       );
-      const { createSandboxRuntime } = await import("./SandboxRuntimeAdapter-5ZMU25Q3.js");
-      const { SandboxOrchestrator } = await import("./SandboxOrchestrator-Z36SFJ7X.js");
-      const { DEFAULT_SANDBOX_CONFIG } = await import("./types-SMQKWHQK.js");
-      const sandboxRuntime = await createSandboxRuntime();
-      const sandboxConfig = config.sandbox ?? DEFAULT_SANDBOX_CONFIG;
-      const sandboxOrchestrator = new SandboxOrchestrator(sandboxConfig, sandboxRuntime);
-      permissionManager.setSandboxState(sandboxConfig.mode, sandboxOrchestrator.isActive());
-      if (sandboxConfig.enabled && sandboxConfig.mode !== "disabled") {
-        if (sandboxRuntime) {
-          console.log(`\u{1F512} Sandbox: ${sandboxConfig.mode} (${sandboxRuntime.name})`);
-        } else {
-          console.log("\u26A0\uFE0F  Sandbox: enabled but runtime not available on this platform");
-        }
-      }
       let permissionPromptCounter = 0;
       const promptFn = (toolName, args, preview) => {
         return new Promise((resolve3) => {
@@ -15864,10 +16166,7 @@ function CliApp() {
         promptFn,
         agentContext,
         state.configStore,
-        apiClient,
-        void 0,
-        // toolFilter
-        sandboxOrchestrator
+        apiClient
       );
       startupLog.push(`\u{1F6E0}\uFE0F Loaded ${b4mTools2.length} B4M tool(s)`);
       const mcpManager = new McpManager(config);
@@ -16027,8 +16326,8 @@ ${contextResult.mergedContent}` : "";
         // Store raw context for compact instructions
         backgroundManager,
         // Store for grouped notification turn tracking
-        sandboxOrchestrator
-        // Store sandbox orchestrator for /sandbox commands
+        wsManager
+        // WebSocket connection manager (null if using SSE fallback)
       }));
       setStoreSession(newSession);
       const bannerLines = [
@@ -16123,13 +16422,13 @@ ${contextResult.mergedContent}` : "";
         messageContent = multimodalMessage.content;
       }
       const userMessage = {
-        id: uuidv411(),
+        id: uuidv413(),
         role: "user",
         content: userMessageContent,
         timestamp: (/* @__PURE__ */ new Date()).toISOString()
       };
       const pendingAssistantMessage = {
-        id: uuidv411(),
+        id: uuidv413(),
         role: "assistant",
         content: "...",
         timestamp: (/* @__PURE__ */ new Date()).toISOString(),
@@ -16335,13 +16634,13 @@ ${contextResult.mergedContent}` : "";
         userMessageContent = message;
       }
       const userMessage = {
-        id: uuidv411(),
+        id: uuidv413(),
         role: "user",
         content: userMessageContent,
         timestamp: (/* @__PURE__ */ new Date()).toISOString()
       };
       const pendingAssistantMessage = {
-        id: uuidv411(),
+        id: uuidv413(),
         role: "assistant",
         content: "...",
         timestamp: (/* @__PURE__ */ new Date()).toISOString(),
@@ -16419,7 +16718,7 @@ ${contextResult.mergedContent}` : "";
         const currentSession = useCliStore.getState().session;
         if (currentSession) {
           const cancelMessage = {
-            id: uuidv411(),
+            id: uuidv413(),
             role: "assistant",
             content: "\u26A0\uFE0F Operation cancelled by user",
             timestamp: (/* @__PURE__ */ new Date()).toISOString(),
@@ -16464,7 +16763,7 @@ ${contextResult.mergedContent}` : "";
     setState((prev) => ({ ...prev, abortController }));
     try {
       const pendingAssistantMessage = {
-        id: uuidv411(),
+        id: uuidv413(),
         role: "assistant",
         content: "...",
         timestamp: (/* @__PURE__ */ new Date()).toISOString(),
@@ -16492,7 +16791,7 @@ ${contextResult.mergedContent}` : "";
       const currentSession = useCliStore.getState().session;
       if (!currentSession) return;
       const continuationMessage = {
-        id: uuidv411(),
+        id: uuidv413(),
         role: "assistant",
         content: "---\n\n**Background Agent Results:**\n\n" + result.finalAnswer,
         timestamp: (/* @__PURE__ */ new Date()).toISOString(),
@@ -16551,13 +16850,13 @@ ${contextResult.mergedContent}` : "";
         isError = true;
       }
       const userMessage = {
-        id: uuidv411(),
+        id: uuidv413(),
         role: "user",
         content: `$ ${command}`,
         timestamp: (/* @__PURE__ */ new Date()).toISOString()
       };
       const assistantMessage = {
-        id: uuidv411(),
+        id: uuidv413(),
         role: "assistant",
         content: isError ? `\u274C Error:
 ${output}` : output.trim() || "(no output)",
@@ -17026,7 +17325,7 @@ Keyboard Shortcuts:
         console.clear();
         const model = state.session?.model || state.config?.defaultModel || "claude-sonnet";
         const newSession = {
-          id: uuidv411(),
+          id: uuidv413(),
           name: `Session ${(/* @__PURE__ */ new Date()).toLocaleString()}`,
           createdAt: (/* @__PURE__ */ new Date()).toISOString(),
           updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -17497,86 +17796,6 @@ No usage data available for the last ${USAGE_DAYS} days.`);
         }
         break;
       }
-      // --- Sandbox commands ---
-      case "sandbox": {
-        if (!state.sandboxOrchestrator) {
-          console.log("\nSandbox: Not initialized");
-          break;
-        }
-        const status = state.sandboxOrchestrator.getStatus();
-        console.log("\nSandbox Status:");
-        console.log(`  Enabled:   ${status.enabled ? "Yes" : "No"}`);
-        console.log(`  Mode:      ${status.mode}`);
-        console.log(`  Platform:  ${status.platform ?? "N/A"}`);
-        console.log(`  Runtime:   ${status.runtimeName ?? "N/A"}`);
-        console.log(`  Available: ${status.runtimeAvailable ? "Yes" : "No"}`);
-        console.log("");
-        console.log("Filesystem Config:");
-        console.log(`  Write only to CWD: ${status.config.filesystem.writeOnlyToWorkingDir}`);
-        console.log(`  Allowed reads: ${status.config.filesystem.allowedReadPaths.join(", ") || "(none)"}`);
-        console.log(`  Denied paths:  ${status.config.filesystem.deniedPaths.join(", ") || "(none)"}`);
-        console.log(`  Excluded cmds: ${status.config.excludedCommands.join(", ") || "(none)"}`);
-        console.log("");
-        break;
-      }
-      case "sandbox:enable": {
-        if (!state.sandboxOrchestrator) {
-          console.log("Sandbox not initialized");
-          break;
-        }
-        if (!state.sandboxOrchestrator.isAvailable()) {
-          console.log("Sandbox runtime not available on this platform");
-          break;
-        }
-        state.sandboxOrchestrator.setMode("auto-allow");
-        state.permissionManager?.setSandboxState("auto-allow", true);
-        const config = await state.configStore.get();
-        await state.configStore.save({
-          ...config,
-          sandbox: { ...state.sandboxOrchestrator.getConfig() }
-        });
-        console.log("Sandbox enabled (auto-allow mode)");
-        break;
-      }
-      case "sandbox:disable": {
-        if (!state.sandboxOrchestrator) {
-          console.log("Sandbox not initialized");
-          break;
-        }
-        state.sandboxOrchestrator.setMode("disabled");
-        state.permissionManager?.setSandboxState("disabled", false);
-        const disableConfig = await state.configStore.get();
-        await state.configStore.save({
-          ...disableConfig,
-          sandbox: { ...state.sandboxOrchestrator.getConfig() }
-        });
-        console.log("Sandbox disabled");
-        break;
-      }
-      case "sandbox:mode": {
-        if (!state.sandboxOrchestrator) {
-          console.log("Sandbox not initialized");
-          break;
-        }
-        const modeArg = args[0];
-        if (modeArg !== "auto-allow" && modeArg !== "permissions") {
-          console.log("Usage: /sandbox:mode <auto-allow|permissions>");
-          break;
-        }
-        if (!state.sandboxOrchestrator.isAvailable()) {
-          console.log("Sandbox runtime not available on this platform");
-          break;
-        }
-        state.sandboxOrchestrator.setMode(modeArg);
-        state.permissionManager?.setSandboxState(modeArg, state.sandboxOrchestrator.isActive());
-        const modeConfig = await state.configStore.get();
-        await state.configStore.save({
-          ...modeConfig,
-          sandbox: { ...state.sandboxOrchestrator.getConfig() }
-        });
-        console.log(`Sandbox mode set to: ${modeArg}`);
-        break;
-      }
       default:
         console.log(`Unknown command: /${command}`);
         console.log("Type /help for available commands");
@@ -17601,9 +17820,9 @@ No usage data available for the last ${USAGE_DAYS} days.`);
       return { ...prev, config: updatedConfig };
     });
     if (modelChanged && state.agent) {
-      const llm = state.agent.context.llm;
-      if (llm) {
-        llm.currentModel = updatedConfig.defaultModel;
+      const backend = state.agent.context.llm;
+      if (backend) {
+        backend.currentModel = updatedConfig.defaultModel;
       }
     }
   };