@trops/dash-core 0.1.48 → 0.1.50

package/dist/electron/index.js

@@ -22,7 +22,8 @@ var require$$2$4 = require('algoliasearch');
 var require$$3$2 = require('node:path');
 var require$$0$3 = require('openai');
 require('live-plugin-manager');
-var require$$0$4 = require('@anthropic-ai/sdk');
+var require$$0$5 = require('@anthropic-ai/sdk');
+var require$$0$4 = require('child_process');
 var require$$2$6 = require('os');
 var require$$3$3 = require('adm-zip');
 var require$$4$1 = require('url');
@@ -525,23 +526,31 @@ var openaiEvents$1 = {
 const LLM_SEND_MESSAGE$1 = "llm-send-message";
 const LLM_ABORT_REQUEST$1 = "llm-abort-request";
 const LLM_LIST_CONNECTED_TOOLS$1 = "llm-list-connected-tools";
+const LLM_CHECK_CLI_AVAILABLE$1 = "llm-check-cli-available";
+const LLM_CLEAR_CLI_SESSION$1 = "llm-clear-cli-session";
+const LLM_CLI_SESSION_STATUS$1 = "llm-cli-session-status";
+const LLM_CLI_END_SESSION$1 = "llm-cli-end-session";
 
 // --- Main → Renderer (send) ---
-const LLM_STREAM_DELTA$2 = "llm-stream-delta";
-const LLM_STREAM_TOOL_CALL$2 = "llm-stream-tool-call";
-const LLM_STREAM_TOOL_RESULT$2 = "llm-stream-tool-result";
-const LLM_STREAM_COMPLETE$2 = "llm-stream-complete";
-const LLM_STREAM_ERROR$2 = "llm-stream-error";
+const LLM_STREAM_DELTA$3 = "llm-stream-delta";
+const LLM_STREAM_TOOL_CALL$3 = "llm-stream-tool-call";
+const LLM_STREAM_TOOL_RESULT$3 = "llm-stream-tool-result";
+const LLM_STREAM_COMPLETE$3 = "llm-stream-complete";
+const LLM_STREAM_ERROR$3 = "llm-stream-error";
 
 var llmEvents$1 = {
   LLM_SEND_MESSAGE: LLM_SEND_MESSAGE$1,
   LLM_ABORT_REQUEST: LLM_ABORT_REQUEST$1,
   LLM_LIST_CONNECTED_TOOLS: LLM_LIST_CONNECTED_TOOLS$1,
-  LLM_STREAM_DELTA: LLM_STREAM_DELTA$2,
-  LLM_STREAM_TOOL_CALL: LLM_STREAM_TOOL_CALL$2,
-  LLM_STREAM_TOOL_RESULT: LLM_STREAM_TOOL_RESULT$2,
-  LLM_STREAM_COMPLETE: LLM_STREAM_COMPLETE$2,
-  LLM_STREAM_ERROR: LLM_STREAM_ERROR$2,
+  LLM_CHECK_CLI_AVAILABLE: LLM_CHECK_CLI_AVAILABLE$1,
+  LLM_CLEAR_CLI_SESSION: LLM_CLEAR_CLI_SESSION$1,
+  LLM_STREAM_DELTA: LLM_STREAM_DELTA$3,
+  LLM_STREAM_TOOL_CALL: LLM_STREAM_TOOL_CALL$3,
+  LLM_STREAM_TOOL_RESULT: LLM_STREAM_TOOL_RESULT$3,
+  LLM_STREAM_COMPLETE: LLM_STREAM_COMPLETE$3,
+  LLM_STREAM_ERROR: LLM_STREAM_ERROR$3,
+  LLM_CLI_SESSION_STATUS: LLM_CLI_SESSION_STATUS$1,
+  LLM_CLI_END_SESSION: LLM_CLI_END_SESSION$1,
 };
 
 /**
@@ -4809,28 +4818,28 @@ const fs$5 = require$$2;
 /**
  * Cached shell PATH result (resolved once, reused for all spawns).
  */
-let _shellPath = null;
+let _shellPath$1 = null;
 
 /**
  * Get the user's full shell PATH (including nvm, homebrew, volta, etc.).
  * Electron GUI apps on macOS don't inherit the shell PATH, so we
  * resolve it once by invoking a login shell.
  */
-function getShellPath() {
-  if (_shellPath !== null) return _shellPath;
+function getShellPath$1() {
+  if (_shellPath$1 !== null) return _shellPath$1;
 
   try {
     const { execSync } = require("child_process");
     const shell = process.env.SHELL || "/bin/bash";
-    _shellPath = execSync(`${shell} -ilc 'echo -n "$PATH"'`, {
+    _shellPath$1 = execSync(`${shell} -ilc 'echo -n "$PATH"'`, {
       encoding: "utf8",
       timeout: 5000,
     });
   } catch {
-    _shellPath = process.env.PATH || "";
+    _shellPath$1 = process.env.PATH || "";
   }
 
-  return _shellPath;
+  return _shellPath$1;
 }
 
 /**
@@ -4948,7 +4957,7 @@ const mcpController$2 = {
           const env = { ...process.env };
           // Ensure full shell PATH is available (Electron GUI apps
           // on macOS don't inherit nvm/homebrew paths)
-          env.PATH = getShellPath();
+          env.PATH = getShellPath$1();
           if (mcpConfig.envMapping && credentials) {
             Object.entries(mcpConfig.envMapping).forEach(
               ([envVar, credentialKey]) => {
@@ -6317,6 +6326,438 @@ const pluginController$1 = {
 
 var pluginController_1 = pluginController$1;
 
+/**
+ * cliController.js
+ *
+ * Manages Claude Code CLI (`claude -p`) as an alternative LLM backend.
+ * Spawns the CLI subprocess, parses stream-json NDJSON output, and emits
+ * the same LLM_STREAM_* events as the Anthropic SDK path.
+ *
+ * Users with a Claude Pro/Max subscription and Claude Code installed
+ * can use the Chat widget without a separate API key.
+ */
+
+const { spawn, execSync } = require$$0$4;
+const {
+  LLM_STREAM_DELTA: LLM_STREAM_DELTA$2,
+  LLM_STREAM_TOOL_CALL: LLM_STREAM_TOOL_CALL$2,
+  LLM_STREAM_TOOL_RESULT: LLM_STREAM_TOOL_RESULT$2,
+  LLM_STREAM_COMPLETE: LLM_STREAM_COMPLETE$2,
+  LLM_STREAM_ERROR: LLM_STREAM_ERROR$2,
+} = llmEvents$1;
+
+/**
+ * Cached shell PATH result (resolved once, reused for all spawns).
+ * Same pattern as mcpController.js.
+ */
+let _shellPath = null;
+
+function getShellPath() {
+  if (_shellPath !== null) return _shellPath;
+
+  try {
+    const shell = process.env.SHELL || "/bin/bash";
+    _shellPath = execSync(`${shell} -ilc 'echo -n "$PATH"'`, {
+      encoding: "utf8",
+      timeout: 5000,
+    });
+  } catch {
+    _shellPath = process.env.PATH || "";
+  }
+
+  return _shellPath;
+}
+
+/**
+ * Cached CLI binary path (resolved once via `which claude`).
+ */
+let _cliBinaryPath = undefined; // undefined = not yet checked
+
+function resolveCliBinary() {
+  if (_cliBinaryPath !== undefined) return _cliBinaryPath;
+
+  try {
+    const fullPath = getShellPath();
+    _cliBinaryPath = execSync("which claude", {
+      encoding: "utf8",
+      timeout: 5000,
+      env: { ...process.env, PATH: fullPath },
+    }).trim();
+  } catch {
+    _cliBinaryPath = null;
+  }
+
+  return _cliBinaryPath;
+}
+
+/**
+ * Active CLI processes for abort support.
+ * Map<requestId, ChildProcess>
+ */
+const activeProcesses = new Map();
+
+/**
+ * Session IDs for conversation continuity.
+ * Map<widgetUuid, sessionId>
+ */
+const sessions = new Map();
+
+/**
+ * Send events safely to a window.
+ */
+function safeSend(win, channel, data) {
+  if (win && !win.isDestroyed()) {
+    win.webContents.send(channel, data);
+  }
+}
+
+const cliController$2 = {
+  /**
+   * isAvailable
+   * Check if the Claude Code CLI is installed and accessible.
+   *
+   * @returns {{ available: boolean, path?: string }}
+   */
+  isAvailable: () => {
+    const binaryPath = resolveCliBinary();
+    if (binaryPath) {
+      return { available: true, path: binaryPath };
+    }
+    return { available: false };
+  },
+
+  /**
+   * sendMessage
+   * Stream a response from the Claude Code CLI with NDJSON parsing.
+   *
+   * @param {BrowserWindow} win - the window to send stream events to
+   * @param {string} requestId - unique ID for this request
+   * @param {object} params - { model, messages, systemPrompt, maxToolRounds, widgetUuid }
+   */
+  sendMessage: async (win, requestId, params) => {
+    const { model, messages, systemPrompt, widgetUuid } = params;
+
+    const binaryPath = resolveCliBinary();
+    if (!binaryPath) {
+      safeSend(win, LLM_STREAM_ERROR$2, {
+        requestId,
+        error:
+          "Claude Code CLI not found. Install from https://claude.ai/download",
+        code: "CLI_NOT_FOUND",
+      });
+      return;
+    }
+
+    // Build CLI args
+    const args = ["-p", "--output-format", "stream-json", "--verbose"];
+
+    if (model) {
+      args.push("--model", model);
+    }
+
+    if (systemPrompt) {
+      args.push("--append-system-prompt", systemPrompt);
+    }
+
+    // Resume existing session for conversation continuity
+    const sessionId = widgetUuid ? sessions.get(widgetUuid) : null;
+    if (sessionId) {
+      args.push("--resume", sessionId);
+    }
+
+    // Extract the user message (last user message in the array)
+    const lastUserMsg = [...messages].reverse().find((m) => m.role === "user");
+    const userText =
+      typeof lastUserMsg?.content === "string"
+        ? lastUserMsg.content
+        : Array.isArray(lastUserMsg?.content)
+          ? lastUserMsg.content
+              .filter((b) => b.type === "text")
+              .map((b) => b.text)
+              .join("\n")
+          : "";
+
+    if (!userText) {
+      safeSend(win, LLM_STREAM_ERROR$2, {
+        requestId,
+        error: "No user message to send.",
+        code: "CLI_ERROR",
+      });
+      return;
+    }
+
+    try {
+      const fullPath = getShellPath();
+      const child = spawn(binaryPath, args, {
+        env: { ...process.env, PATH: fullPath },
+        stdio: ["pipe", "pipe", "pipe"],
+      });
+
+      activeProcesses.set(requestId, child);
+
+      // Pipe user message via stdin (not visible in ps)
+      child.stdin.write(userText);
+      child.stdin.end();
+
+      let stdoutBuffer = "";
+      let stderrBuffer = "";
+      let capturedSessionId = null;
+      let retried = false;
+
+      // Track active tool calls for mapping results
+      const activeToolCalls = new Map();
+
+      child.stdout.on("data", (chunk) => {
+        stdoutBuffer += chunk.toString();
+
+        // Process complete lines
+        const lines = stdoutBuffer.split("\n");
+        stdoutBuffer = lines.pop(); // keep incomplete line in buffer
+
+        for (const line of lines) {
+          if (!line.trim()) continue;
+
+          let parsed;
+          try {
+            parsed = JSON.parse(line);
+          } catch {
+            console.warn("[cliController] Skipping invalid JSON line:", line);
+            continue;
+          }
+
+          // Capture session ID from any message that has it
+          if (parsed.session_id && widgetUuid) {
+            capturedSessionId = parsed.session_id;
+            sessions.set(widgetUuid, capturedSessionId);
+          }
+
+          // Map CLI stream-json events to IPC events
+          if (parsed.type === "content_block_delta") {
+            if (parsed.delta?.type === "text_delta" && parsed.delta.text) {
+              safeSend(win, LLM_STREAM_DELTA$2, {
+                requestId,
+                text: parsed.delta.text,
+              });
+            } else if (parsed.delta?.type === "input_json_delta") {
+              // Update tool input incrementally
+              const tc = activeToolCalls.get(parsed.index);
+              if (tc) {
+                tc.partialInput =
+                  (tc.partialInput || "") + (parsed.delta.partial_json || "");
+              }
+            }
+          } else if (parsed.type === "content_block_start") {
+            if (parsed.content_block?.type === "tool_use") {
+              const toolBlock = parsed.content_block;
+              activeToolCalls.set(parsed.index, {
+                toolUseId: toolBlock.id,
+                toolName: toolBlock.name,
+                partialInput: "",
+              });
+              safeSend(win, LLM_STREAM_TOOL_CALL$2, {
+                requestId,
+                toolUseId: toolBlock.id,
+                toolName: toolBlock.name,
+                serverName: "Claude Code",
+                input: toolBlock.input || {},
+              });
+            }
+          } else if (parsed.type === "content_block_stop") {
+            // Tool call completed — try to parse the accumulated input
+            const tc = activeToolCalls.get(parsed.index);
+            if (tc && tc.partialInput) {
+              try {
+                tc.finalInput = JSON.parse(tc.partialInput);
+              } catch {
+                tc.finalInput = tc.partialInput;
+              }
+            }
+          } else if (parsed.type === "message_stop") {
+            // Individual message completed (may be followed by more in tool-use loops)
+          } else if (parsed.type === "result") {
+            // Final result — conversation complete
+            const content = [];
+            if (parsed.result) {
+              content.push({ type: "text", text: parsed.result });
+            }
+
+            safeSend(win, LLM_STREAM_COMPLETE$2, {
+              requestId,
+              content,
+              stopReason: parsed.stop_reason || "end_turn",
+              usage: parsed.usage || {},
+            });
+          }
+        }
+      });
+
+      child.stderr.on("data", (chunk) => {
+        stderrBuffer += chunk.toString();
+      });
+
+      child.on("error", (err) => {
+        activeProcesses.delete(requestId);
+        safeSend(win, LLM_STREAM_ERROR$2, {
+          requestId,
+          error: `Failed to start Claude CLI: ${err.message}`,
+          code: "CLI_SPAWN_ERROR",
+        });
+      });
+
+      child.on("close", (code) => {
+        activeProcesses.delete(requestId);
+
+        // Process any remaining buffer
+        if (stdoutBuffer.trim()) {
+          try {
+            const parsed = JSON.parse(stdoutBuffer);
+            if (parsed.session_id && widgetUuid) {
+              sessions.set(widgetUuid, parsed.session_id);
+            }
+            if (parsed.type === "result") {
+              const content = [];
+              if (parsed.result) {
+                content.push({ type: "text", text: parsed.result });
+              }
+              safeSend(win, LLM_STREAM_COMPLETE$2, {
+                requestId,
+                content,
+                stopReason: parsed.stop_reason || "end_turn",
+                usage: parsed.usage || {},
+              });
+              return;
+            }
+          } catch {
+            // ignore
+          }
+        }
+
+        if (code !== 0 && code !== null) {
+          // Check if resume failed and retry without it
+          if (sessionId && !retried && stderrBuffer.includes("session")) {
+            retried = true;
+            if (widgetUuid) sessions.delete(widgetUuid);
+            // Retry without --resume
+            cliController$2.sendMessage(win, requestId, {
+              ...params,
+              _retryWithoutResume: true,
+            });
+            return;
+          }
+
+          // Check for auth errors
+          if (
+            stderrBuffer.includes("auth") ||
+            stderrBuffer.includes("login") ||
+            stderrBuffer.includes("not authenticated")
+          ) {
+            safeSend(win, LLM_STREAM_ERROR$2, {
+              requestId,
+              error:
+                "Claude Code CLI is not authenticated. Run `claude auth login` in your terminal.",
+              code: "CLI_AUTH_ERROR",
+            });
+            return;
+          }
+
+          safeSend(win, LLM_STREAM_ERROR$2, {
+            requestId,
+            error: `Claude CLI exited with code ${code}${stderrBuffer ? ": " + stderrBuffer.slice(0, 500) : ""}`,
+            code: "CLI_ERROR",
+          });
+        }
+      });
+    } catch (err) {
+      activeProcesses.delete(requestId);
+      safeSend(win, LLM_STREAM_ERROR$2, {
+        requestId,
+        error: `Failed to start Claude CLI: ${err.message}`,
+        code: "CLI_SPAWN_ERROR",
+      });
+    }
+  },
+
+  /**
+   * abortRequest
+   * Kill an in-flight CLI process.
+   *
+   * @param {string} requestId - the request to cancel
+   * @returns {{ success: boolean }}
+   */
+  abortRequest: (requestId) => {
+    const child = activeProcesses.get(requestId);
+    if (child) {
+      child.kill("SIGTERM");
+      activeProcesses.delete(requestId);
+      return { success: true };
+    }
+    return { success: false, message: "Request not found" };
+  },
+
+  /**
+   * clearSession
+   * Remove the stored session ID for a widget (called on "New Chat").
+   *
+   * @param {string} widgetUuid - the widget whose session to clear
+   * @returns {{ success: boolean }}
+   */
+  clearSession: (widgetUuid) => {
+    if (widgetUuid && sessions.has(widgetUuid)) {
+      sessions.delete(widgetUuid);
+      return { success: true };
+    }
+    return { success: false };
+  },
+
+  /**
+   * getSessionStatus
+   * Check if a CLI session exists and whether a process is active for a widget.
+   *
+   * @param {string} widgetUuid - the widget to check
+   * @returns {{ hasSession: boolean, sessionId?: string, isProcessActive: boolean }}
+   */
+  getSessionStatus: (widgetUuid) => {
+    const sessionId = widgetUuid ? sessions.get(widgetUuid) : null;
+    // Check if any active process belongs to this widget
+    let isProcessActive = false;
+    for (const [, child] of activeProcesses) {
+      if (!child.killed) {
+        isProcessActive = true;
+        break;
+      }
+    }
+    return {
+      hasSession: !!sessionId,
+      sessionId: sessionId || undefined,
+      isProcessActive,
+    };
+  },
+
+  /**
+   * endSession
+   * Kill any active CLI process AND clear the session for a widget.
+   *
+   * @param {string} widgetUuid - the widget whose session to end
+   * @returns {{ success: boolean }}
+   */
+  endSession: (widgetUuid) => {
+    // Kill any active processes for this widget
+    for (const [reqId, child] of activeProcesses) {
+      if (reqId.startsWith(widgetUuid)) {
+        child.kill("SIGTERM");
+        activeProcesses.delete(reqId);
+      }
+    }
+    // Clear the session
+    if (widgetUuid && sessions.has(widgetUuid)) {
+      sessions.delete(widgetUuid);
+    }
+    return { success: true };
+  },
+};
+
+var cliController_1 = cliController$2;
+
 /**
  * llmController.js
  *
@@ -6328,8 +6769,9 @@ var pluginController_1 = pluginController$1;
  * per-request, receiving the full messages array each time.
  */
 
-const Anthropic = require$$0$4;
+const Anthropic = require$$0$5;
 const mcpController$1 = mcpController_1;
+const cliController$1 = cliController_1;
 const {
   LLM_STREAM_DELTA: LLM_STREAM_DELTA$1,
   LLM_STREAM_TOOL_CALL: LLM_STREAM_TOOL_CALL$1,
@@ -6398,6 +6840,11 @@ const llmController$1 = {
    * @param {object} params - { apiKey, model, messages, tools, toolServerMap, systemPrompt, maxToolRounds }
    */
   sendMessage: async (win, requestId, params) => {
+    // Route to CLI backend if specified
+    if (params.backend === "claude-code") {
+      return cliController$1.sendMessage(win, requestId, params);
+    }
+
     const {
       apiKey,
       model = "claude-sonnet-4-20250514",
@@ -6621,7 +7068,8 @@ const llmController$1 = {
       activeRequests.delete(requestId);
       return { success: true };
     }
-    return { success: false, message: "Request not found" };
+    // Fallback to CLI controller
+    return cliController$1.abortRequest(requestId);
   },
 };
 
@@ -7889,6 +8337,10 @@ const {
   LLM_SEND_MESSAGE,
   LLM_ABORT_REQUEST,
   LLM_LIST_CONNECTED_TOOLS,
+  LLM_CHECK_CLI_AVAILABLE,
+  LLM_CLEAR_CLI_SESSION,
+  LLM_CLI_SESSION_STATUS,
+  LLM_CLI_END_SESSION,
   LLM_STREAM_DELTA,
   LLM_STREAM_TOOL_CALL,
   LLM_STREAM_TOOL_RESULT,
@@ -7926,51 +8378,129 @@ const llmApi$2 = {
    */
   listConnectedTools: () => ipcRenderer$2.invoke(LLM_LIST_CONNECTED_TOOLS),
 
+  /**
+   * checkCliAvailable
+   * Check if the Claude Code CLI is installed and accessible.
+   *
+   * @returns {Promise<{ available: boolean, path?: string }>}
+   */
+  checkCliAvailable: () => ipcRenderer$2.invoke(LLM_CHECK_CLI_AVAILABLE),
+
+  /**
+   * clearCliSession
+   * Clear the CLI conversation session for a widget (for "New Chat").
+   *
+   * @param {string} widgetUuid - the widget whose session to clear
+   * @returns {Promise<{ success: boolean }>}
+   */
+  clearCliSession: (widgetUuid) =>
+    ipcRenderer$2.invoke(LLM_CLEAR_CLI_SESSION, { widgetUuid }),
+
+  /**
+   * getCliSessionStatus
+   * Check if a CLI session is active for a widget.
+   *
+   * @param {string} widgetUuid - the widget to check
+   * @returns {Promise<{ hasSession: boolean, sessionId?: string, isProcessActive: boolean }>}
+   */
+  getCliSessionStatus: (widgetUuid) =>
+    ipcRenderer$2.invoke(LLM_CLI_SESSION_STATUS, { widgetUuid }),
+
+  /**
+   * endCliSession
+   * Kill any active CLI process AND clear the session for a widget.
+   *
+   * @param {string} widgetUuid - the widget whose session to end
+   * @returns {Promise<{ success: boolean }>}
+   */
+  endCliSession: (widgetUuid) =>
+    ipcRenderer$2.invoke(LLM_CLI_END_SESSION, { widgetUuid }),
+
   // --- Stream event listeners ---
+  // Each on* method returns the wrapped callback so callers can remove
+  // their own listener without nuking listeners from other widgets.
 
   /**
    * onStreamDelta
    * Listen for text chunks as they stream in.
+   * @returns {Function} wrapped callback for use with removeStreamListener
    */
   onStreamDelta: (callback) => {
-    ipcRenderer$2.on(LLM_STREAM_DELTA, (_event, data) => callback(data));
+    const wrapped = (_event, data) => callback(data);
+    ipcRenderer$2.on(LLM_STREAM_DELTA, wrapped);
+    return wrapped;
   },
 
   /**
    * onStreamToolCall
    * Listen for tool call notifications.
+   * @returns {Function} wrapped callback for use with removeStreamListener
    */
   onStreamToolCall: (callback) => {
-    ipcRenderer$2.on(LLM_STREAM_TOOL_CALL, (_event, data) => callback(data));
+    const wrapped = (_event, data) => callback(data);
+    ipcRenderer$2.on(LLM_STREAM_TOOL_CALL, wrapped);
+    return wrapped;
   },
 
   /**
    * onStreamToolResult
    * Listen for tool result notifications.
+   * @returns {Function} wrapped callback for use with removeStreamListener
    */
   onStreamToolResult: (callback) => {
-    ipcRenderer$2.on(LLM_STREAM_TOOL_RESULT, (_event, data) => callback(data));
+    const wrapped = (_event, data) => callback(data);
+    ipcRenderer$2.on(LLM_STREAM_TOOL_RESULT, wrapped);
+    return wrapped;
   },
 
   /**
    * onStreamComplete
    * Listen for stream completion (final response).
+   * @returns {Function} wrapped callback for use with removeStreamListener
    */
   onStreamComplete: (callback) => {
-    ipcRenderer$2.on(LLM_STREAM_COMPLETE, (_event, data) => callback(data));
+    const wrapped = (_event, data) => callback(data);
+    ipcRenderer$2.on(LLM_STREAM_COMPLETE, wrapped);
+    return wrapped;
   },
 
   /**
    * onStreamError
    * Listen for stream errors.
+   * @returns {Function} wrapped callback for use with removeStreamListener
    */
   onStreamError: (callback) => {
-    ipcRenderer$2.on(LLM_STREAM_ERROR, (_event, data) => callback(data));
+    const wrapped = (_event, data) => callback(data);
+    ipcRenderer$2.on(LLM_STREAM_ERROR, wrapped);
+    return wrapped;
+  },
+
+  /**
+   * removeStreamListener
+   * Remove a specific stream listener by channel and callback reference.
+   *
+   * @param {string} channel - the IPC channel name
+   * @param {Function} wrapped - the callback returned by on*
+   */
+  removeStreamListener: (channel, wrapped) => {
+    ipcRenderer$2.removeListener(channel, wrapped);
+  },
+
+  /**
+   * Stream channel constants for use with removeStreamListener.
+   */
+  streamChannels: {
+    delta: LLM_STREAM_DELTA,
+    toolCall: LLM_STREAM_TOOL_CALL,
+    toolResult: LLM_STREAM_TOOL_RESULT,
+    complete: LLM_STREAM_COMPLETE,
+    error: LLM_STREAM_ERROR,
   },
 
   /**
    * removeAllStreamListeners
-   * Clean up all LLM stream listeners.
+   * Clean up ALL LLM stream listeners (global).
+   * Prefer removeStreamListener for scoped cleanup.
    */
   removeAllStreamListeners: () => {
     ipcRenderer$2.removeAllListeners(LLM_STREAM_DELTA);
@@ -9553,6 +10083,7 @@ const openaiController = openaiController_1;
 const menuItemsController = menuItemsController_1;
 const pluginController = pluginController_1;
 const llmController = llmController_1;
+const cliController = cliController_1;
 
 // --- Utils ---
 const clientCache = requireClientCache();
@@ -9609,6 +10140,7 @@ var electron = {
   menuItemsController,
   pluginController,
   llmController,
+  cliController,
 
   // Controller functions (flat) — spread for convenient destructuring
   ...controllers,