@trops/dash-core 0.1.49 → 0.1.51

package/dist/electron/index.js

@@ -528,6 +528,8 @@ 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$3 = "llm-stream-delta";
@@ -547,6 +549,8 @@ var llmEvents$1 = {
   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,
 };
 
 /**
@@ -6704,6 +6708,52 @@ const cliController$2 = {
     }
     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;
@@ -8289,6 +8339,8 @@ const {
   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,
@@ -8296,6 +8348,17 @@ const {
   LLM_STREAM_ERROR,
 } = llmEvents$1;
 
+let _nextListenerId = 0;
+const _listenerMap = new Map();
+
+function _addListener(channel, callback) {
+    const id = String(++_nextListenerId);
+    const wrapped = (_event, data) => callback(data);
+    ipcRenderer$2.on(channel, wrapped);
+    _listenerMap.set(id, { channel, wrapped });
+    return id;
+}
+
 const llmApi$2 = {
   /**
    * sendMessage
@@ -8344,53 +8407,73 @@ const llmApi$2 = {
   clearCliSession: (widgetUuid) =>
     ipcRenderer$2.invoke(LLM_CLEAR_CLI_SESSION, { widgetUuid }),
 
-  // --- Stream event listeners ---
-
   /**
-   * onStreamDelta
-   * Listen for text chunks as they stream in.
+   * 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 }>}
    */
-  onStreamDelta: (callback) => {
-    ipcRenderer$2.on(LLM_STREAM_DELTA, (_event, data) => callback(data));
-  },
+  getCliSessionStatus: (widgetUuid) =>
+    ipcRenderer$2.invoke(LLM_CLI_SESSION_STATUS, { widgetUuid }),
 
   /**
-   * onStreamToolCall
-   * Listen for tool call notifications.
+   * 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 }>}
    */
-  onStreamToolCall: (callback) => {
-    ipcRenderer$2.on(LLM_STREAM_TOOL_CALL, (_event, data) => callback(data));
-  },
+  endCliSession: (widgetUuid) =>
+    ipcRenderer$2.invoke(LLM_CLI_END_SESSION, { widgetUuid }),
 
-  /**
-   * onStreamToolResult
-   * Listen for tool result notifications.
-   */
-  onStreamToolResult: (callback) => {
-    ipcRenderer$2.on(LLM_STREAM_TOOL_RESULT, (_event, data) => callback(data));
-  },
+  // --- Stream event listeners ---
+  // Each on* method returns an opaque string ID. Strings cross the
+  // contextBridge safely (unlike function refs which get proxied).
+  // Use removeStreamListener(id) to clean up.
 
-  /**
-   * onStreamComplete
-   * Listen for stream completion (final response).
-   */
-  onStreamComplete: (callback) => {
-    ipcRenderer$2.on(LLM_STREAM_COMPLETE, (_event, data) => callback(data));
-  },
+  /** @returns {string} listener ID */
+  onStreamDelta: (callback) => _addListener(LLM_STREAM_DELTA, callback),
+
+  /** @returns {string} listener ID */
+  onStreamToolCall: (callback) => _addListener(LLM_STREAM_TOOL_CALL, callback),
+
+  /** @returns {string} listener ID */
+  onStreamToolResult: (callback) =>
+    _addListener(LLM_STREAM_TOOL_RESULT, callback),
+
+  /** @returns {string} listener ID */
+  onStreamComplete: (callback) => _addListener(LLM_STREAM_COMPLETE, callback),
+
+  /** @returns {string} listener ID */
+  onStreamError: (callback) => _addListener(LLM_STREAM_ERROR, callback),
 
   /**
-   * onStreamError
-   * Listen for stream errors.
+   * removeStreamListener
+   * Remove a specific stream listener by its opaque ID.
+   *
+   * @param {string} idOrChannel - listener ID (or legacy channel name when second arg is provided)
+   * @param {string} [id] - listener ID when called with legacy (channel, id) signature
    */
-  onStreamError: (callback) => {
-    ipcRenderer$2.on(LLM_STREAM_ERROR, (_event, data) => callback(data));
+  removeStreamListener: (idOrChannel, id) => {
+    const listenerId = id !== undefined ? String(id) : String(idOrChannel);
+    const entry = _listenerMap.get(listenerId);
+    if (entry) {
+      ipcRenderer$2.removeListener(entry.channel, entry.wrapped);
+      _listenerMap.delete(listenerId);
+    }
   },
 
   /**
    * removeAllStreamListeners
-   * Clean up all LLM stream listeners.
+   * Clean up ALL LLM stream listeners (global).
+   * Prefer removeStreamListener for scoped cleanup.
    */
   removeAllStreamListeners: () => {
+    for (const [, entry] of _listenerMap) {
+      ipcRenderer$2.removeListener(entry.channel, entry.wrapped);
+    }
+    _listenerMap.clear();
     ipcRenderer$2.removeAllListeners(LLM_STREAM_DELTA);
     ipcRenderer$2.removeAllListeners(LLM_STREAM_TOOL_CALL);
     ipcRenderer$2.removeAllListeners(LLM_STREAM_TOOL_RESULT);