centaurus-cli 3.0.0 → 3.1.0

package/dist/services/shell-input-agent.js

@@ -1,361 +1,326 @@
-/**
- * Shell Input Agent Service
- *
- * An isolated AI agent that handles shell input prompts during Agent Control Mode.
- * Completely separate from the main chat agent - has its own conversation history,
- * tools, and lifecycle. Terminates immediately when the shell command completes.
- */
-import { aiServiceClient } from './ai-service-client.js';
-import { sessionQuotaManager } from './session-quota-manager.js';
-import { quickLog } from '../utils/conversation-logger.js';
-// ==================== Constants ====================
-const MAX_TURNS_PER_SESSION = 20; // Max AI turns per shell session
-const MODEL = 'gemini-3-flash-preview'; // Fast model for quick responses
-// ==================== Helper Functions ====================
-/**
- * Convert literal escape sequences (like \n, \r, \t) to actual control characters.
- * The AI often returns "1\n" where \n is meant to be a newline but arrives as literal chars.
- */
+import { aiServiceClient } from "./ai-service-client.js";
+import { sessionQuotaManager } from "./session-quota-manager.js";
+import { quickLog } from "../utils/conversation-logger.js";
+const MAX_TURNS_PER_SESSION = 20;
+const MODEL = "gemini-3-flash-preview";
 function convertEscapeSequences(input) {
-    return input
-        .replace(/\\n/g, '\n') // newline
-        .replace(/\\r/g, '\r') // carriage return
-        .replace(/\\t/g, '\t') // tab
-        .replace(/\\x1b/gi, '\x1b') // escape for arrow keys etc
-        .replace(/\\e/g, '\x1b'); // alternative escape notation
+  return input.replace(/\\n/g, "\n").replace(/\\r/g, "\r").replace(/\\t/g, "	").replace(/\\x1b/gi, "\x1B").replace(/\\e/g, "\x1B");
 }
-// ==================== Shell Input System Prompt ====================
-const SHELL_INPUT_SYSTEM_PROMPT = `You are a specialized AI agent that ONLY provides input to an interactive shell command.
-
-CRITICAL RULES:
-1. You may ONLY use the execute_command tool with shell_input parameter
-2. NEVER try to start a new command - only send input to the EXISTING running shell
-3. Respond with ONLY the tool call - no explanations needed
-4. Set SafeToAutoRun: true to avoid approval prompts
-5. For password prompts, DO NOT provide passwords - skip with a neutral response
-6. IMPORTANT: The shell_input value will automatically have Enter pressed after it
-   - Just provide the text you want to type, the system will press Enter
-   - For example: shell_input="1" NOT shell_input="1\\n"
-
+const SHELL_INPUT_SYSTEM_PROMPT = `You are a specialized AI agent that ONLY provides input to an interactive shell command.
+
+CRITICAL RULES:
+1. You may ONLY use the execute_command tool with shell_input parameter
+2. NEVER try to start a new command - only send input to the EXISTING running shell
+3. Respond with ONLY the tool call - no explanations needed
+4. Set SafeToAutoRun: true to avoid approval prompts
+5. For password prompts, DO NOT provide passwords - skip with a neutral response
+6. IMPORTANT: The shell_input value will automatically have Enter pressed after it
+   - Just provide the text you want to type, the system will press Enter
+   - For example: shell_input="1" NOT shell_input="1\\n"
+
 Your ONLY job is to analyze shell output and provide appropriate input when prompted.`;
-// ==================== ShellInputAgent Class ====================
 class ShellInputAgentClass {
-    sessions = new Map();
-    toolRegistry;
-    onShellInput;
-    onToolExecutionUpdate;
-    onPromptAnswered; // Callback when a prompt has been answered
-    processingLock = new Map(); // Prevent concurrent AI calls per shell
-    /**
-     * Initialize the agent with a tool registry
-     */
-    initialize(toolRegistry) {
-        this.toolRegistry = toolRegistry;
-        quickLog(`[${new Date().toISOString()}] [ShellInputAgent] Initialized with tool registry\n`);
+  sessions = /* @__PURE__ */ new Map();
+  toolRegistry;
+  onShellInput;
+  onToolExecutionUpdate;
+  onPromptAnswered;
+  // Callback when a prompt has been answered
+  processingLock = /* @__PURE__ */ new Map();
+  // Prevent concurrent AI calls per shell
+  /**
+   * Initialize the agent with a tool registry
+   */
+  initialize(toolRegistry) {
+    this.toolRegistry = toolRegistry;
+    quickLog(`[${(/* @__PURE__ */ new Date()).toISOString()}] [ShellInputAgent] Initialized with tool registry
+`);
+  }
+  /**
+   * Set callback for sending input to shell (bridges to App.tsx's onShellInput)
+   */
+  setOnShellInput(callback) {
+    this.onShellInput = callback;
+  }
+  /**
+   * Set callback for tool execution updates (for UI feedback)
+   */
+  setOnToolExecutionUpdate(callback) {
+    this.onToolExecutionUpdate = callback;
+  }
+  /**
+   * Set callback for when a prompt has been answered
+   * This is used to update the UI to show a tick instead of spinner
+   */
+  setOnPromptAnswered(callback) {
+    this.onPromptAnswered = callback;
+  }
+  /**
+   * Start a new shell input session
+   * @param shellId Unique identifier for this shell session
+   * @param command The command being run
+   * @param cwd Current working directory  
+   * @param mainConversation Optional main agent conversation history for context
+   */
+  startSession(shellId, command, cwd, mainConversation) {
+    this.terminateSession(shellId);
+    const session = {
+      shellId,
+      command,
+      cwd,
+      isActive: true,
+      abortController: new AbortController(),
+      conversationHistory: [],
+      mainConversationContext: mainConversation,
+      turnCount: 0,
+      startTime: /* @__PURE__ */ new Date()
+    };
+    this.sessions.set(shellId, session);
+    this.processingLock.set(shellId, false);
+    const contextInfo = mainConversation ? ` (with ${mainConversation.length} context messages)` : "";
+    quickLog(`[${(/* @__PURE__ */ new Date()).toISOString()}] [ShellInputAgent] Started session for ${shellId}: ${command}${contextInfo}
+`);
+  }
+  /**
+   * Handle an input prompt detected in shell output
+   * Returns quickly - AI call runs in background
+   */
+  async handleInputPrompt(shellId, shellOutput, promptContext, inputType, confidence) {
+    quickLog(`[${(/* @__PURE__ */ new Date()).toISOString()}] [ShellInputAgent] handleInputPrompt called for ${shellId}, sessions count: ${this.sessions.size}
+`);
+    const session = this.sessions.get(shellId);
+    if (!session || !session.isActive) {
+      quickLog(`[${(/* @__PURE__ */ new Date()).toISOString()}] [ShellInputAgent] No active session for ${shellId}, ignoring prompt
+`);
+      return;
     }
-    /**
-     * Set callback for sending input to shell (bridges to App.tsx's onShellInput)
-     */
-    setOnShellInput(callback) {
-        this.onShellInput = callback;
+    if (this.processingLock.get(shellId)) {
+      quickLog(`[${(/* @__PURE__ */ new Date()).toISOString()}] [ShellInputAgent] Already processing for ${shellId}, ignoring duplicate
+`);
+      return;
     }
-    /**
-     * Set callback for tool execution updates (for UI feedback)
-     */
-    setOnToolExecutionUpdate(callback) {
-        this.onToolExecutionUpdate = callback;
+    this.processingLock.set(shellId, true);
+    this.processInputPrompt(session, shellOutput, promptContext, inputType, confidence).catch((error) => {
+      quickLog(`[${(/* @__PURE__ */ new Date()).toISOString()}] [ShellInputAgent] Error processing prompt for ${shellId}: ${error.message}
+`);
+    }).finally(() => {
+      this.processingLock.set(shellId, false);
+    });
+  }
+  /**
+   * Process an input prompt with AI
+   */
+  async processInputPrompt(session, shellOutput, promptContext, inputType, confidence) {
+    quickLog(`[${(/* @__PURE__ */ new Date()).toISOString()}] [ShellInputAgent] processInputPrompt entry for ${session.shellId}, isActive=${session.isActive}, turnCount=${session.turnCount}
+`);
+    if (!session.isActive) {
+      quickLog(`[${(/* @__PURE__ */ new Date()).toISOString()}] [ShellInputAgent] Session not active, returning
+`);
+      return;
     }
-    /**
-     * Set callback for when a prompt has been answered
-     * This is used to update the UI to show a tick instead of spinner
-     */
-    setOnPromptAnswered(callback) {
-        this.onPromptAnswered = callback;
+    if (session.turnCount >= MAX_TURNS_PER_SESSION) {
+      quickLog(`[${(/* @__PURE__ */ new Date()).toISOString()}] [ShellInputAgent] Session ${session.shellId} hit max turns
+`);
+      return;
     }
-    /**
-     * Start a new shell input session
-     * @param shellId Unique identifier for this shell session
-     * @param command The command being run
-     * @param cwd Current working directory
-     * @param mainConversation Optional main agent conversation history for context
-     */
-    startSession(shellId, command, cwd, mainConversation) {
-        // Terminate any existing session for this shell
-        this.terminateSession(shellId);
-        const session = {
-            shellId,
-            command,
-            cwd,
-            isActive: true,
-            abortController: new AbortController(),
-            conversationHistory: [],
-            mainConversationContext: mainConversation,
-            turnCount: 0,
-            startTime: new Date()
-        };
-        this.sessions.set(shellId, session);
-        this.processingLock.set(shellId, false);
-        const contextInfo = mainConversation ? ` (with ${mainConversation.length} context messages)` : '';
-        quickLog(`[${new Date().toISOString()}] [ShellInputAgent] Started session for ${shellId}: ${command}${contextInfo}\n`);
+    if (!sessionQuotaManager.canSendMessage()) {
+      quickLog(`[${(/* @__PURE__ */ new Date()).toISOString()}] [ShellInputAgent] Session quota exhausted
+`);
+      return;
     }
-    /**
-     * Handle an input prompt detected in shell output
-     * Returns quickly - AI call runs in background
-     */
-    async handleInputPrompt(shellId, shellOutput, promptContext, inputType, confidence) {
-        quickLog(`[${new Date().toISOString()}] [ShellInputAgent] handleInputPrompt called for ${shellId}, sessions count: ${this.sessions.size}\n`);
-        const session = this.sessions.get(shellId);
-        if (!session || !session.isActive) {
-            quickLog(`[${new Date().toISOString()}] [ShellInputAgent] No active session for ${shellId}, ignoring prompt\n`);
-            return;
-        }
-        // Check if already processing a prompt for this shell
-        if (this.processingLock.get(shellId)) {
-            quickLog(`[${new Date().toISOString()}] [ShellInputAgent] Already processing for ${shellId}, ignoring duplicate\n`);
-            return;
-        }
-        // Set lock
-        this.processingLock.set(shellId, true);
-        // Run AI call in background (don't await)
-        this.processInputPrompt(session, shellOutput, promptContext, inputType, confidence)
-            .catch(error => {
-            quickLog(`[${new Date().toISOString()}] [ShellInputAgent] Error processing prompt for ${shellId}: ${error.message}\n`);
-        })
-            .finally(() => {
-            this.processingLock.set(shellId, false);
-        });
+    if (!this.toolRegistry) {
+      quickLog(`[${(/* @__PURE__ */ new Date()).toISOString()}] [ShellInputAgent] Tool registry not initialized
+`);
+      return;
     }
-    /**
-     * Process an input prompt with AI
-     */
-    async processInputPrompt(session, shellOutput, promptContext, inputType, confidence) {
-        quickLog(`[${new Date().toISOString()}] [ShellInputAgent] processInputPrompt entry for ${session.shellId}, isActive=${session.isActive}, turnCount=${session.turnCount}\n`);
+    session.turnCount++;
+    session.lastInputTime = /* @__PURE__ */ new Date();
+    const userPrompt = this.buildInputPrompt(session, shellOutput, promptContext, inputType, confidence);
+    if (session.conversationHistory.length === 0) {
+      session.conversationHistory.push({
+        role: "user",
+        content: SHELL_INPUT_SYSTEM_PROMPT + "\n\n" + userPrompt
+      });
+    } else {
+      session.conversationHistory.push({
+        role: "user",
+        content: userPrompt
+      });
+    }
+    const executeCommandSchema = this.toolRegistry.getSchemas().filter((t) => t.name === "execute_command");
+    try {
+      let assistantMessage = "";
+      let toolCalls = [];
+      sessionQuotaManager.incrementMessageCount();
+      for await (const chunk of aiServiceClient.streamChat(
+        MODEL,
+        session.conversationHistory,
+        executeCommandSchema,
+        {
+          cwd: session.cwd,
+          platform: process.platform,
+          shell: process.env.SHELL || "cmd.exe",
+          os: "windows",
+          homeDir: process.env.USERPROFILE || ""
+        },
+        void 0,
+        void 0,
+        session.abortController.signal
+      )) {
         if (!session.isActive) {
-            quickLog(`[${new Date().toISOString()}] [ShellInputAgent] Session not active, returning\n`);
-            return;
+          quickLog(`[${(/* @__PURE__ */ new Date()).toISOString()}] [ShellInputAgent] Session ${session.shellId} terminated during streaming
+`);
+          return;
         }
-        // Check turn limit
-        if (session.turnCount >= MAX_TURNS_PER_SESSION) {
-            quickLog(`[${new Date().toISOString()}] [ShellInputAgent] Session ${session.shellId} hit max turns\n`);
-            return;
+        if (chunk.type === "error") {
+          throw new Error(chunk.message);
         }
-        // Check quota
-        if (!sessionQuotaManager.canSendMessage()) {
-            quickLog(`[${new Date().toISOString()}] [ShellInputAgent] Session quota exhausted\n`);
-            return;
+        if (chunk.type === "text") {
+          assistantMessage += chunk.content;
         }
-        // Check if tool registry is available
-        if (!this.toolRegistry) {
-            quickLog(`[${new Date().toISOString()}] [ShellInputAgent] Tool registry not initialized\n`);
-            return;
+        if (chunk.type === "tool_call") {
+          const toolCall = chunk.toolCall;
+          if (toolCall.arguments && typeof toolCall.arguments === "string") {
+            try {
+              toolCall.arguments = JSON.parse(toolCall.arguments);
+            } catch (e) {
+            }
+          }
+          toolCalls.push(toolCall);
+        }
+        if (chunk.type === "done") {
+          break;
         }
-        session.turnCount++;
-        session.lastInputTime = new Date();
-        // Build the prompt for this input
-        const userPrompt = this.buildInputPrompt(session, shellOutput, promptContext, inputType, confidence);
-        // Add to session's isolated conversation history
-        if (session.conversationHistory.length === 0) {
-            // First message includes system context
+      }
+      if (!session.isActive) {
+        return;
+      }
+      for (const toolCall of toolCalls) {
+        if (toolCall.name === "execute_command" && toolCall.arguments?.shell_input) {
+          const rawShellInput = toolCall.arguments.shell_input;
+          let shellInput = convertEscapeSequences(rawShellInput);
+          if (!shellInput.endsWith("\n") && !shellInput.endsWith("\r")) {
+            shellInput += "\r";
+          }
+          if (this.onShellInput) {
+            quickLog(`[${(/* @__PURE__ */ new Date()).toISOString()}] [ShellInputAgent] Sending input to ${session.shellId}: "${rawShellInput}" + Enter
+`);
+            this.onShellInput(session.shellId, shellInput);
+            if (this.onPromptAnswered) {
+              this.onPromptAnswered(session.shellId);
+            }
             session.conversationHistory.push({
-                role: 'user',
-                content: SHELL_INPUT_SYSTEM_PROMPT + '\n\n' + userPrompt
+              role: "assistant",
+              content: "",
+              tool_calls: [toolCall]
             });
-        }
-        else {
             session.conversationHistory.push({
-                role: 'user',
-                content: userPrompt
+              role: "tool",
+              tool_call_id: toolCall.id,
+              content: `Sent input to shell: ${shellInput}`
             });
+          }
         }
-        // Get only execute_command tool schema
-        const executeCommandSchema = this.toolRegistry.getSchemas().filter(t => t.name === 'execute_command');
-        try {
-            let assistantMessage = '';
-            let toolCalls = [];
-            // Increment quota
-            sessionQuotaManager.incrementMessageCount();
-            // Stream AI response with abort signal
-            for await (const chunk of aiServiceClient.streamChat(MODEL, session.conversationHistory, executeCommandSchema, {
-                cwd: session.cwd,
-                platform: process.platform,
-                shell: process.env.SHELL || 'cmd.exe',
-                os: 'windows',
-                homeDir: process.env.USERPROFILE || ''
-            }, undefined, undefined, session.abortController.signal)) {
-                // Check if session was terminated
-                if (!session.isActive) {
-                    quickLog(`[${new Date().toISOString()}] [ShellInputAgent] Session ${session.shellId} terminated during streaming\n`);
-                    return;
-                }
-                if (chunk.type === 'error') {
-                    throw new Error(chunk.message);
-                }
-                if (chunk.type === 'text') {
-                    assistantMessage += chunk.content;
-                }
-                if (chunk.type === 'tool_call') {
-                    const toolCall = chunk.toolCall;
-                    // Parse string arguments if needed
-                    if (toolCall.arguments && typeof toolCall.arguments === 'string') {
-                        try {
-                            toolCall.arguments = JSON.parse(toolCall.arguments);
-                        }
-                        catch (e) {
-                            // Ignore parsing error
-                        }
-                    }
-                    toolCalls.push(toolCall);
-                }
-                if (chunk.type === 'done') {
-                    break;
-                }
-            }
-            // Check again if session is still active
-            if (!session.isActive) {
-                return;
-            }
-            // Process tool calls
-            for (const toolCall of toolCalls) {
-                if (toolCall.name === 'execute_command' && toolCall.arguments?.shell_input) {
-                    const rawShellInput = toolCall.arguments.shell_input;
-                    // Convert escape sequences like \n to actual newlines
-                    let shellInput = convertEscapeSequences(rawShellInput);
-                    // Automatically append Enter (carriage return) if not already present
-                    // This ensures the input is actually submitted to the shell
-                    if (!shellInput.endsWith('\n') && !shellInput.endsWith('\r')) {
-                        shellInput += '\r';
-                    }
-                    // Send input to shell via callback
-                    if (this.onShellInput) {
-                        quickLog(`[${new Date().toISOString()}] [ShellInputAgent] Sending input to ${session.shellId}: "${rawShellInput}" + Enter\n`);
-                        this.onShellInput(session.shellId, shellInput);
-                        // Notify that a prompt has been answered (to update UI spinner -> tick)
-                        if (this.onPromptAnswered) {
-                            this.onPromptAnswered(session.shellId);
-                        }
-                        // Add to conversation history
-                        session.conversationHistory.push({
-                            role: 'assistant',
-                            content: '',
-                            tool_calls: [toolCall]
-                        });
-                        session.conversationHistory.push({
-                            role: 'tool',
-                            tool_call_id: toolCall.id,
-                            content: `Sent input to shell: ${shellInput}`
-                        });
-                    }
-                }
-            }
-        }
-        catch (error) {
-            if (error.name === 'AbortError') {
-                quickLog(`[${new Date().toISOString()}] [ShellInputAgent] Session ${session.shellId} aborted\n`);
-                return;
-            }
-            throw error;
-        }
+      }
+    } catch (error) {
+      if (error.name === "AbortError") {
+        quickLog(`[${(/* @__PURE__ */ new Date()).toISOString()}] [ShellInputAgent] Session ${session.shellId} aborted
+`);
+        return;
+      }
+      throw error;
     }
-    /**
-     * Build the input prompt for AI
-     */
-    buildInputPrompt(session, shellOutput, promptContext, inputType, confidence) {
-        // Get last 30 lines of output
-        const lastLines = shellOutput.split('\n').slice(-30).join('\n');
-        // Build context from main conversation if available
-        let conversationContext = '';
-        if (session.mainConversationContext && session.mainConversationContext.length > 0) {
-            // Extract user messages for context (most relevant for understanding intent)
-            const userMessages = session.mainConversationContext
-                .filter(msg => msg.role === 'user' && typeof msg.content === 'string')
-                .map(msg => msg.content)
-                .slice(-3) // Last 3 user messages for context
-                .join('\n---\n');
-            if (userMessages) {
-                conversationContext = `
-**User's Original Intent (from main conversation):**
-\`\`\`
-${userMessages.substring(0, 1000)}${userMessages.length > 1000 ? '...[truncated]' : ''}
-\`\`\`
-
-Consider the user's original intent when providing input. If the user mentioned specific values to use, prefer those.
+  }
+  /**
+   * Build the input prompt for AI
+   */
+  buildInputPrompt(session, shellOutput, promptContext, inputType, confidence) {
+    const lastLines = shellOutput.split("\n").slice(-30).join("\n");
+    let conversationContext = "";
+    if (session.mainConversationContext && session.mainConversationContext.length > 0) {
+      const userMessages = session.mainConversationContext.filter((msg) => msg.role === "user" && typeof msg.content === "string").map((msg) => msg.content).slice(-3).join("\n---\n");
+      if (userMessages) {
+        conversationContext = `
+**User's Original Intent (from main conversation):**
+\`\`\`
+${userMessages.substring(0, 1e3)}${userMessages.length > 1e3 ? "...[truncated]" : ""}
+\`\`\`
+
+Consider the user's original intent when providing input. If the user mentioned specific values to use, prefer those.
 `;
-            }
-        }
-        return `[SHELL INPUT REQUIRED]
-
-**Running command:** ${session.command}
-**Working directory:** ${session.cwd}
-${conversationContext}
-**Current shell output (last 30 lines):**
-\`\`\`
-${lastLines}
-\`\`\`
-
-**Detected prompt:** ${promptContext}
-**Input type needed:** ${inputType}
-**Confidence:** ${confidence}
-
-Use execute_command with shell_input to respond. Example:
-{
-  "tool": "execute_command",
-  "arguments": {
-    "shell_input": "YOUR_INPUT_HERE",
-    "SafeToAutoRun": true,
-    "CommandLine": "${session.command}",
-    "Cwd": "${session.cwd}"
-  }
-}`;
-    }
-    /**
-     * Terminate a shell input session immediately
-     */
-    terminateSession(shellId) {
-        const session = this.sessions.get(shellId);
-        if (session) {
-            quickLog(`[${new Date().toISOString()}] [ShellInputAgent] Terminating session ${shellId}\n`);
-            // Mark as inactive first
-            session.isActive = false;
-            // Abort any running AI call
-            try {
-                session.abortController.abort();
-            }
-            catch (e) {
-                // Ignore abort errors
-            }
-            // Clean up
-            this.sessions.delete(shellId);
-            this.processingLock.delete(shellId);
-        }
+      }
     }
-    /**
-     * Check if a session is active
-     */
-    isSessionActive(shellId) {
-        const session = this.sessions.get(shellId);
-        return session?.isActive ?? false;
-    }
-    /**
-     * Get session info (for debugging)
-     */
-    getSessionInfo(shellId) {
-        const session = this.sessions.get(shellId);
-        if (!session)
-            return undefined;
-        return {
-            turnCount: session.turnCount,
-            isActive: session.isActive
-        };
+    return `[SHELL INPUT REQUIRED]
+
+**Running command:** ${session.command}
+**Working directory:** ${session.cwd}
+${conversationContext}
+**Current shell output (last 30 lines):**
+\`\`\`
+${lastLines}
+\`\`\`
+
+**Detected prompt:** ${promptContext}
+**Input type needed:** ${inputType}
+**Confidence:** ${confidence}
+
+Use execute_command with shell_input to respond. Example:
+{
+  "tool": "execute_command",
+  "arguments": {
+    "shell_input": "YOUR_INPUT_HERE",
+    "SafeToAutoRun": true,
+    "CommandLine": "${session.command}",
+    "Cwd": "${session.cwd}"
+  }
+}`;
+  }
+  /**
+   * Terminate a shell input session immediately
+   */
+  terminateSession(shellId) {
+    const session = this.sessions.get(shellId);
+    if (session) {
+      quickLog(`[${(/* @__PURE__ */ new Date()).toISOString()}] [ShellInputAgent] Terminating session ${shellId}
+`);
+      session.isActive = false;
+      try {
+        session.abortController.abort();
+      } catch (e) {
+      }
+      this.sessions.delete(shellId);
+      this.processingLock.delete(shellId);
     }
-    /**
-     * Terminate all active sessions
-     */
-    terminateAllSessions() {
-        for (const shellId of this.sessions.keys()) {
-            this.terminateSession(shellId);
-        }
+  }
+  /**
+   * Check if a session is active
+   */
+  isSessionActive(shellId) {
+    const session = this.sessions.get(shellId);
+    return session?.isActive ?? false;
+  }
+  /**
+   * Get session info (for debugging)
+   */
+  getSessionInfo(shellId) {
+    const session = this.sessions.get(shellId);
+    if (!session) return void 0;
+    return {
+      turnCount: session.turnCount,
+      isActive: session.isActive
+    };
+  }
+  /**
+   * Terminate all active sessions
+   */
+  terminateAllSessions() {
+    for (const shellId of this.sessions.keys()) {
+      this.terminateSession(shellId);
     }
+  }
 }
-// Export singleton
-export const ShellInputAgent = new ShellInputAgentClass();
+const ShellInputAgent = new ShellInputAgentClass();
+export {
+  ShellInputAgent
+};
 //# sourceMappingURL=shell-input-agent.js.map