centaurus-cli 2.9.4 → 2.9.6

package/dist/cli-adapter.js

@@ -46,6 +46,7 @@ import { BackgroundTaskManager } from './services/background-task-manager.js';
 import { sessionQuotaManager } from './services/session-quota-manager.js';
 import { ollamaService, OllamaService } from './services/ollama-service.js';
 import { workflowStorage } from './services/workflow-storage.js';
+import { CheckpointManager } from './services/checkpoint-manager.js';
 export class CentaurusCLI {
     configManager;
     toolRegistry;
@@ -94,7 +95,7 @@ export class CentaurusCLI {
     onRestoreMessagesCallback;
     uiMessageHistory = []; // Mirror of App.tsx's messageHistory for saving
     cwdStack = []; // Stack of CWDs for nested sessions (pushed when entering, popped when exiting)
-    lastConnectionCommand = null; // Track the command used to connect to remote
+    connectionCommandStack = []; // Stack of commands used to connect (for nested sessions like SSH>SSH, SSH>Docker)
     onBackgroundModeChange;
     onBackgroundTaskCountChange;
     onSetAutoMode;
@@ -116,9 +117,16 @@ export class CentaurusCLI {
     onPromptAnswered; // Callback when AI answers a shell prompt
     onShowWorkflowCreatorCallback; // Callback to show workflow creator screen with optional initial steps
     onWorkflowSaveCallback; // Callback when workflow is saved
+    onAiAutoSuggestChange; // Callback for AI auto-suggest setting changes
+    onRevertToCheckpointCallback; // Callback for revert UI update
+    // Checkpoint manager for revert functionality
+    checkpointManager;
+    currentCheckpointId; // Track current checkpoint being created
     // Workflow learning mode state
     workflowLearningActive = false;
     learnedWorkflowSteps = [];
+    // Callback to set input value (e.g., for revert)
+    onSetInputCallback = null;
     constructor() {
         this.configManager = new ConfigManager();
         this.toolRegistry = new ToolRegistry();
@@ -233,6 +241,24 @@ export class CentaurusCLI {
     setOnWorkflowSave(callback) {
         this.onWorkflowSaveCallback = callback;
     }
+    setOnAiAutoSuggestChange(callback) {
+        this.onAiAutoSuggestChange = callback;
+    }
+    setOnRevertToCheckpoint(callback) {
+        this.onRevertToCheckpointCallback = callback;
+    }
+    /**
+     * Get checkpoints for autocomplete dropdown
+     */
+    getCheckpointsForAutocomplete() {
+        if (!this.checkpointManager)
+            return [];
+        return this.checkpointManager.list().map(cp => ({
+            id: cp.id,
+            prompt: cp.prompt,
+            timestamp: new Date(cp.createdAt)
+        }));
+    }
     /**
      * Save a workflow from the workflow creator UI
      */
@@ -395,9 +421,12 @@ Begin executing now, starting with Step 1.`;
                 // starting 'fresh' in the remote user's home/default dir is safer for 'warpify' semantics regardless of type.
                 // However, to avoid regression for WSL/Docker usage where inheritance is expected, we restricts this fix to SSH.
                 const initialCwd = type === 'ssh' ? undefined : this.cwd;
-                context = await detection.handler.connect(command, initialCwd);
+                // Use factory method to create a new handler instance for this session
+                // This prevents state issues where the singleton handler's client is overwritten by nested sessions
+                const newHandler = detection.handler.createNew();
+                context = await newHandler.connect(command, initialCwd);
             }
-            this.lastConnectionCommand = command;
+            this.connectionCommandStack.push(command);
             this.contextManager.pushContext(context);
             // Explicitly sync this.cwd with the new context's CWD to ensure consistency immediately
             if (context.metadata.workingDirectory) {
@@ -481,7 +510,7 @@ Begin executing now, starting with Step 1.`;
         }
         this.contextManager.updateWorkingDirectory(this.cwd);
         if (newContext.type === 'local') {
-            this.lastConnectionCommand = null;
+            this.connectionCommandStack.pop();
         }
         // Notify CWD change
         if (this.onCwdChange) {
@@ -530,7 +559,7 @@ Begin executing now, starting with Step 1.`;
         }
         this.contextManager.updateWorkingDirectory(this.cwd);
         if (currentContext.type === 'local') {
-            this.lastConnectionCommand = null;
+            this.connectionCommandStack.pop();
         }
         // Notify CWD change
         if (this.onCwdChange) {
@@ -1279,12 +1308,104 @@ DO NOT use write_to_file, edit_file, or execute_command until the plan is approv
         // Start logging session and log user message
         conversationLogger.startSession();
         conversationLogger.logUserMessage(message);
+        // Initialize and start checkpoint for revert functionality
+        if (!this.checkpointManager) {
+            this.checkpointManager = new CheckpointManager();
+        }
+        // Ensure we have a chat ID for checkpoints (even for the first message)
+        if (!this.currentChatId) {
+            this.currentChatId = localChatStorage.generateChatId();
+        }
+        if (this.currentChatId) {
+            this.checkpointManager.setCurrentChatId(this.currentChatId);
+            this.currentCheckpointId = undefined;
+            // Start checkpoint snapshot for this user message
+            const currentContext = this.contextManager.getCurrentContext();
+            // Build remote session info and handler for non-local contexts
+            let remoteSessionInfo;
+            let remoteHandler;
+            if (currentContext.type !== 'local' && currentContext.handler) {
+                const metadata = currentContext.metadata;
+                remoteSessionInfo = {
+                    hostname: metadata.hostname,
+                    username: metadata.username,
+                    sessionId: currentContext.sessionId,
+                    connectionString: metadata.hostname
+                        ? `${metadata.username || 'user'}@${metadata.hostname}`
+                        : metadata.distroName || metadata.containerId || undefined,
+                };
+                // Use the handler if it implements the RemoteFileHandler interface
+                if (typeof currentContext.handler.readFile === 'function' &&
+                    typeof currentContext.handler.writeFile === 'function' &&
+                    typeof currentContext.handler.executeCommand === 'function' &&
+                    typeof currentContext.handler.isConnected === 'function') {
+                    remoteHandler = currentContext.handler;
+                }
+            }
+            try {
+                const checkpointStartPromise = this.checkpointManager.startCheckpoint({
+                    prompt: message,
+                    cwd: this.cwd,
+                    contextType: currentContext.type,
+                    conversationIndex: this.conversationHistory.length - 1,
+                    uiMessageIndex: this.uiMessageHistory.length,
+                    remoteSessionInfo,
+                    handler: remoteHandler,
+                });
+                let checkpoint = null;
+                if (currentContext.type !== 'local') {
+                    const remoteCheckpointTimeoutMs = 2000;
+                    const timeoutMarker = '__checkpoint_timeout__';
+                    let timeoutHandle = null;
+                    const timeoutPromise = new Promise((resolve) => {
+                        timeoutHandle = setTimeout(() => resolve(timeoutMarker), remoteCheckpointTimeoutMs);
+                    });
+                    const checkpointOrTimeout = await Promise.race([
+                        checkpointStartPromise,
+                        timeoutPromise,
+                    ]);
+                    if (timeoutHandle) {
+                        clearTimeout(timeoutHandle);
+                    }
+                    if (checkpointOrTimeout === timeoutMarker) {
+                        quickLog(`[${new Date().toISOString()}] [Checkpoint] Remote checkpoint start exceeded ${remoteCheckpointTimeoutMs}ms (${currentContext.type}); continuing without blocking AI turn\n`);
+                        void checkpointStartPromise
+                            .then((lateCheckpoint) => {
+                            if (!lateCheckpoint || !this.checkpointManager) {
+                                return;
+                            }
+                            this.checkpointManager.discardCheckpointById(lateCheckpoint.id);
+                            quickLog(`[${new Date().toISOString()}] [Checkpoint] Discarded late checkpoint ${lateCheckpoint.id} created after timeout\n`);
+                        })
+                            .catch((lateError) => {
+                            quickLog(`[${new Date().toISOString()}] [Checkpoint] Late checkpoint creation failed after timeout: ${lateError?.message || lateError}\n`);
+                        });
+                    }
+                    else {
+                        checkpoint = checkpointOrTimeout;
+                    }
+                }
+                else {
+                    checkpoint = await checkpointStartPromise;
+                }
+                if (checkpoint) {
+                    this.currentCheckpointId = checkpoint.id;
+                    quickLog(`[${new Date().toISOString()}] [Checkpoint] Started checkpoint ${checkpoint.id} (${currentContext.type}) for: "${message.slice(0, 50)}..."\n`);
+                }
+            }
+            catch (error) {
+                quickLog(`[${new Date().toISOString()}] [Checkpoint] Failed to start checkpoint: ${error.message}\n`);
+            }
+        }
         try {
             const tools = this.toolRegistry.getSchemas();
             const context = {
                 cwd: this.cwd,
                 contextManager: this.contextManager,
                 cliAdapter: this, // Pass CLI adapter reference for interactive process management
+                checkpointManager: this.checkpointManager, // For session-aware diff tool
+                currentCheckpointId: this.currentCheckpointId, // Active checkpoint for this request
+                currentChatId: this.currentChatId || undefined, // Current chat session ID (for session-wide diffs)
                 requireApproval: async (message, risky, preview, operationType, operationDetails) => {
                     // Special bypass for shell input to running processes:
                     // If the AI is sending input to an existing shell (via shell_input), we bypass the separate approval step.
@@ -2391,6 +2512,17 @@ DO NOT use write_to_file, edit_file, or execute_command until the plan is approv
             throw new Error(`AI Error: ${error.message}`);
         }
         finally {
+            // Finalize checkpoint if one was created for this message
+            if (this.currentCheckpointId && this.checkpointManager) {
+                try {
+                    await this.checkpointManager.finalizeCheckpoint(this.currentCheckpointId);
+                    quickLog(`[${new Date().toISOString()}] [Checkpoint] Finalized checkpoint ${this.currentCheckpointId}\n`);
+                }
+                catch (error) {
+                    quickLog(`[${new Date().toISOString()}] [Checkpoint] Failed to finalize checkpoint: ${error.message}\n`);
+                }
+                this.currentCheckpointId = undefined;
+            }
             // Clean up abort controller
             this.currentAbortController = undefined;
         }
@@ -2813,12 +2945,18 @@ Start by listing the directory structure to understand what you're working with.
                     const value = args[1].toLowerCase();
                     if (value === 'on') {
                         this.configManager.set('aiAutoSuggest', true);
+                        if (this.onAiAutoSuggestChange) {
+                            this.onAiAutoSuggestChange(true);
+                        }
                         responseMessage = '✅ **AI Auto-Suggestions Enabled**\n\n' +
                             'From now on, I will suggest commands after 5 seconds of inactivity.\n' +
                             'Suggestions will appear in grey text. Use the **Right Arrow** key to accept them.';
                     }
                     else if (value === 'off') {
                         this.configManager.set('aiAutoSuggest', false);
+                        if (this.onAiAutoSuggestChange) {
+                            this.onAiAutoSuggestChange(false);
+                        }
                         responseMessage = '✅ **AI Auto-Suggestions Disabled**\n\n' +
                             'I will no longer provide AI-powered command suggestions.';
                     }
@@ -3075,6 +3213,189 @@ Then try /models local again.`;
             case 'exit':
                 process.exit(0);
                 break;
+            case 'revert': {
+                const checkpointArg = args[0];
+                if (!checkpointArg) {
+                    responseMessage = '❌ Usage: `/revert <checkpoint-id>`\nType `/revert ` and use autocomplete to select a checkpoint.';
+                    break;
+                }
+                if (!this.checkpointManager) {
+                    responseMessage = '❌ No checkpoints available in this session.';
+                    break;
+                }
+                try {
+                    // Smart context matching: determine if we can revert based on current vs checkpoint context
+                    const currentContext = this.contextManager.getCurrentContext();
+                    const allCheckpoints = this.checkpointManager.list();
+                    const targetCheckpoint = allCheckpoints.find(c => c.id === checkpointArg);
+                    if (!targetCheckpoint) {
+                        responseMessage = `❌ Checkpoint "${checkpointArg}" not found.`;
+                        break;
+                    }
+                    // Context validation for revert
+                    const cpContextType = targetCheckpoint.contextType;
+                    const currentContextType = currentContext.type;
+                    if (cpContextType !== 'local' && currentContextType === 'local') {
+                        // Remote checkpoint but we're local — can't reconnect to SSH to revert files
+                        const sessionType = cpContextType.toUpperCase();
+                        const sessionInfo = targetCheckpoint.remoteSessionInfo;
+                        const target = sessionInfo?.connectionString || sessionInfo?.hostname || 'the remote machine';
+                        responseMessage = `❌ This checkpoint was created during a ${sessionType} session (${target}).\n` +
+                            `You are not currently connected to that session.\n\n` +
+                            `Please reconnect to the ${sessionType} session first, then retry /revert.`;
+                        break;
+                    }
+                    if (cpContextType === 'local' && currentContextType !== 'local') {
+                        // Local checkpoint but we're in a remote session — wrong context
+                        responseMessage = `❌ This checkpoint was created in a local session.\n` +
+                            `You are currently in a ${currentContextType.toUpperCase()} session.\n\n` +
+                            `Please exit your remote session first, then retry /revert.`;
+                        break;
+                    }
+                    if (cpContextType !== 'local' && currentContextType !== 'local' && cpContextType !== currentContextType) {
+                        // Both remote but different types (e.g., SSH checkpoint but in Docker now)
+                        responseMessage = `❌ This checkpoint was created in a ${cpContextType.toUpperCase()} session, ` +
+                            `but you are currently in a ${currentContextType.toUpperCase()} session.\n\n` +
+                            `Please connect to the correct ${cpContextType.toUpperCase()} session first.`;
+                        break;
+                    }
+                    // For remote checkpoints with mismatched hosts, validate the connection target
+                    if (cpContextType !== 'local' && targetCheckpoint.remoteSessionInfo) {
+                        const cpHost = targetCheckpoint.remoteSessionInfo.hostname;
+                        const currentHost = currentContext.metadata.hostname;
+                        if (cpHost && currentHost && cpHost !== currentHost) {
+                            responseMessage = `❌ This checkpoint was created on ${cpHost}, ` +
+                                `but you are currently connected to ${currentHost}.\n\n` +
+                                `Please connect to ${cpHost} first, then retry /revert.`;
+                            break;
+                        }
+                    }
+                    // Build handler for remote revert if needed
+                    let revertHandler;
+                    if (cpContextType !== 'local' && currentContext.handler) {
+                        if (typeof currentContext.handler.readFile === 'function' &&
+                            typeof currentContext.handler.writeFile === 'function' &&
+                            typeof currentContext.handler.executeCommand === 'function' &&
+                            typeof currentContext.handler.isConnected === 'function') {
+                            revertHandler = currentContext.handler;
+                        }
+                    }
+                    const result = await this.checkpointManager.revertToCheckpoint(checkpointArg, revertHandler);
+                    // Find checkpoint index for UI truncation
+                    const checkpoints = this.checkpointManager.list();
+                    const checkpointIndex = checkpoints.findIndex(c => c.id === checkpointArg);
+                    // Truncate conversation history to the checkpoint
+                    if (checkpointIndex >= 0) {
+                        const checkpoint = result.checkpoint;
+                        // Populate the input bar with the reverted prompt
+                        if (this.onSetInputCallback) {
+                            this.onSetInputCallback(checkpoint.prompt);
+                        }
+                        // Use conversationIndex from metadata if available (robust)
+                        // This avoids issues with duplicate prompts getting truncated at the wrong occurrence
+                        if (typeof checkpoint.conversationIndex === 'number' &&
+                            checkpoint.conversationIndex >= 0 &&
+                            checkpoint.conversationIndex < this.conversationHistory.length) {
+                            // Truncate to index (exclusive) to remove the message from history
+                            // This allows the user to "edit" the message in the input bar
+                            this.conversationHistory = this.conversationHistory.slice(0, checkpoint.conversationIndex);
+                            quickLog(`[${new Date().toISOString()}] [Revert] Truncated conversation history to index ${checkpoint.conversationIndex} (exclusive)\n`);
+                        }
+                        else {
+                            // Fallback to string matching (legacy or missing index)
+                            const targetPrompt = checkpoint.prompt;
+                            // Find the user message with this prompt in conversationHistory
+                            let foundIndex = -1;
+                            // Use a broader search to find the matching message
+                            // The prompt might be a substring or exact match
+                            const searchPrompt = targetPrompt.slice(0, 50);
+                            for (let i = 0; i < this.conversationHistory.length; i++) {
+                                const msg = this.conversationHistory[i];
+                                if (msg.role === 'user' && msg.content && msg.content.includes(searchPrompt)) {
+                                    foundIndex = i;
+                                    break;
+                                }
+                            }
+                            if (foundIndex >= 0) {
+                                // Keep messages up to but NOT including this user message
+                                this.conversationHistory = this.conversationHistory.slice(0, foundIndex);
+                                quickLog(`[${new Date().toISOString()}] [Revert] Truncated conversation history to index ${foundIndex} (exclusive, using string match)\n`);
+                            }
+                        }
+                        // Fix: Also truncate UI message history to ensure consistency
+                        // Use uiMessageIndex from metadata if available (robust)
+                        if (typeof checkpoint.uiMessageIndex === 'number' &&
+                            checkpoint.uiMessageIndex >= 0 &&
+                            checkpoint.uiMessageIndex < this.uiMessageHistory.length) {
+                            // Truncate to index (exclusive)
+                            this.uiMessageHistory = this.uiMessageHistory.slice(0, checkpoint.uiMessageIndex);
+                            quickLog(`[${new Date().toISOString()}] [Revert] Truncated UI message history to index ${checkpoint.uiMessageIndex} (exclusive)\n`);
+                        }
+                        else {
+                            // Fallback to string matching (legacy or missing index)
+                            const targetPrompt = checkpoint.prompt;
+                            const searchPrompt = targetPrompt.slice(0, 50);
+                            let foundUiIndex = -1;
+                            for (let i = 0; i < this.uiMessageHistory.length; i++) {
+                                const msg = this.uiMessageHistory[i];
+                                if (msg.role === 'user' && msg.content && msg.content.includes(searchPrompt)) {
+                                    foundUiIndex = i;
+                                    break;
+                                }
+                            }
+                            if (foundUiIndex >= 0) {
+                                // Keep messages up to but NOT including this user message
+                                this.uiMessageHistory = this.uiMessageHistory.slice(0, foundUiIndex);
+                                quickLog(`[${new Date().toISOString()}] [Revert] Truncated UI message history to index ${foundUiIndex} (exclusive, using string match)\n`);
+                            }
+                        }
+                        // Remove the reverted checkpoint AND all checkpoints created after it
+                        // They should not appear in autocomplete anymore
+                        this.checkpointManager.removeCheckpointsFrom(checkpointArg);
+                        // Build the success message BEFORE calling handleChatPickerSelection
+                        // This will be passed as a parameter and included in the same React setState call
+                        quickLog(`[${new Date().toISOString()}] [Revert] Building success message for checkpoint "${checkpointArg}"\n`);
+                        const truncatedPrompt = result.checkpoint.prompt.length > 50
+                            ? result.checkpoint.prompt.slice(0, 50) + '...'
+                            : result.checkpoint.prompt;
+                        let revertSuccessMessage = `✅ Reverted to: "${truncatedPrompt}"\n` +
+                            `Restored ${result.restored} files, removed ${result.removed} files.`;
+                        if (result.errors.length > 0) {
+                            revertSuccessMessage += `\n⚠️ Warnings: ${result.errors.join(', ')}`;
+                        }
+                        // Save the truncated state to disk
+                        if (this.currentChatId) {
+                            quickLog(`[${new Date().toISOString()}] [Revert] Saving truncated chat to disk (chatId: ${this.currentChatId})\n`);
+                            quickLog(`[${new Date().toISOString()}] [Revert] uiMessageHistory.length BEFORE save: ${this.uiMessageHistory.length}\n`);
+                            this.saveCurrentChat();
+                            // Reload the chat to force UI update ensures consistency
+                            // This simulates a /chat resume command which correctly populates the UI
+                            // Pass skipLoadedMessage=true and the revert success message
+                            // The success message is appended to restoredMessages in handleChatPickerSelection
+                            // This ensures it's part of the same React setState call, avoiding race conditions
+                            quickLog(`[${new Date().toISOString()}] [Revert] Calling handleChatPickerSelection with revertSuccessMessage="${revertSuccessMessage.substring(0, 50)}..."\n`);
+                            const currentContext = this.contextManager.getCurrentContext();
+                            const preserveRemote = currentContext.type !== 'local' && typeof currentContext.handler?.isConnected === 'function'
+                                ? currentContext.handler.isConnected()
+                                : currentContext.type !== 'local';
+                            await this.handleChatPickerSelection(this.currentChatId, true, revertSuccessMessage, preserveRemote);
+                            // Clear responseMessage so it doesn't get sent via onDirectMessageCallback
+                            // (the message was already included in the restored messages above)
+                            quickLog(`[${new Date().toISOString()}] [Revert] handleChatPickerSelection completed, clearing responseMessage\n`);
+                            responseMessage = '';
+                        }
+                        else {
+                            // Fallback: if no current chat, show the message via normal callback
+                            quickLog(`[${new Date().toISOString()}] [Revert] No currentChatId, using fallback responseMessage\n`);
+                            responseMessage = revertSuccessMessage;
+                        }
+                    }
+                }
+                catch (error) {
+                    responseMessage = `❌ Failed to revert: ${error.message}`;
+                }
+                break;
+            }
             case 'add-command':
             case 'add-command-auto-detect':
                 // Handle custom command auto-detect management
@@ -3769,12 +4090,32 @@ Create once, run many times across different machines.`;
                     }
                     return;
                 }
+                // Check if Docker is nested inside SSH
+                const parentContext = this.contextManager.getParentContext();
                 // Start remote task first to get callbacks
                 const remoteTask = BackgroundTaskManager.startRemoteTask(command, effectiveCwd, remoteContextDisplay || 'docker');
                 taskId = remoteTask.id;
-                // Create Docker PTY with the callbacks from BackgroundTaskManager
-                const dockerPty = runDockerCommand(containerId, command, effectiveCwd, remoteTask.onData, remoteTask.onExit);
-                remoteTask.setRemotePty(dockerPty);
+                if (parentContext && parentContext.type === 'ssh') {
+                    // Nested Docker inside SSH: route docker exec command through SSH
+                    const sshClient = parentContext.handler?.client;
+                    if (!sshClient) {
+                        if (this.onResponseCallback) {
+                            this.onResponseCallback('❌ SSH client not available for nested Docker background task');
+                        }
+                        return;
+                    }
+                    // Build docker exec command to run via SSH
+                    const escapedCommand = command.replace(/"/g, '\\"');
+                    const dockerCommand = `docker exec -w "${effectiveCwd}" ${containerId} sh -c "${escapedCommand}"`;
+                    // Create SSH PTY to run the docker command
+                    const sshPty = runSSHCommand(sshClient, dockerCommand, parentContext.metadata.workingDirectory || '~', remoteTask.onData, remoteTask.onExit);
+                    remoteTask.setRemotePty(sshPty);
+                }
+                else {
+                    // Local Docker: use standard runDockerCommand
+                    const dockerPty = runDockerCommand(containerId, command, effectiveCwd, remoteTask.onData, remoteTask.onExit);
+                    remoteTask.setRemotePty(dockerPty);
+                }
             }
             else {
                 // Unknown remote type - fall back to local
@@ -3860,28 +4201,57 @@ Create once, run many times across different machines.`;
         // Capture remote context if in remote environment (SSH/WSL/Docker)
         // Use null to explicitly clear remote context when not in remote (so resuming won't reconnect)
         let remoteContext = null;
+        let remoteContextStack = null;
         const currentContext = this.contextManager.getCurrentContext();
-        if (currentContext.type !== 'local' && this.lastConnectionCommand) {
-            remoteContext = {
-                type: currentContext.type,
-                connectionCommand: this.lastConnectionCommand,
-                remoteCwd: currentContext.metadata.workingDirectory,
-                localCwdBeforeRemote: this.cwdStack.length > 0 ? this.cwdStack[0] : process.cwd(),
-                metadata: {
-                    hostname: currentContext.metadata.hostname,
-                    username: currentContext.metadata.username,
-                    distroName: currentContext.metadata.distroName,
-                    containerId: currentContext.metadata.containerId,
-                    port: currentContext.metadata.port,
+        // Build remoteContextStack for nested sessions
+        if (currentContext.type !== 'local' && this.connectionCommandStack.length > 0) {
+            remoteContextStack = [];
+            // Build stack of contexts from the connectionCommandStack and cwdStack
+            // cwdStack[0] = local CWD before first remote
+            // cwdStack[1] = first remote CWD before second remote (if nested)
+            // connectionCommandStack[0] = first connection command
+            // connectionCommandStack[1] = second connection command (if nested)
+            for (let i = 0; i < this.connectionCommandStack.length; i++) {
+                const connCmd = this.connectionCommandStack[i];
+                // Detect the type from the command
+                let ctxType = 'ssh';
+                if (connCmd.startsWith('docker ') || connCmd.startsWith('docker-compose ')) {
+                    ctxType = 'docker';
                 }
-            };
+                else if (connCmd.startsWith('wsl')) {
+                    ctxType = 'wsl';
+                }
+                // Get the CWD before this remote connection
+                const cwdBefore = i < this.cwdStack.length ? this.cwdStack[i] : process.cwd();
+                // For the last (current) context, use the actual metadata
+                const isLastContext = i === this.connectionCommandStack.length - 1;
+                const remoteCwd = isLastContext ? currentContext.metadata.workingDirectory : (this.cwdStack[i + 1] || '~');
+                const storedCtx = {
+                    type: ctxType,
+                    connectionCommand: connCmd,
+                    remoteCwd: remoteCwd,
+                    localCwdBeforeRemote: cwdBefore,
+                    metadata: isLastContext ? {
+                        hostname: currentContext.metadata.hostname,
+                        username: currentContext.metadata.username,
+                        distroName: currentContext.metadata.distroName,
+                        containerId: currentContext.metadata.containerId,
+                        port: currentContext.metadata.port,
+                    } : {}
+                };
+                remoteContextStack.push(storedCtx);
+            }
+            // For backward compatibility, also set remoteContext to the last (current) context
+            if (remoteContextStack.length > 0) {
+                remoteContext = remoteContextStack[remoteContextStack.length - 1];
+            }
         }
         // Determine the local CWD to save (use base of cwdStack if in remote, otherwise current cwd)
         const cwdToSave = currentContext.type !== 'local' && this.cwdStack.length > 0
             ? this.cwdStack[0]
             : this.cwd;
         try {
-            localChatStorage.saveChat(this.currentChatId, storedMessages, storedUIMessages, cwdToSave, remoteContext);
+            localChatStorage.saveChat(this.currentChatId, storedMessages, storedUIMessages, cwdToSave, remoteContext, remoteContextStack);
             // Also store the backend conversation ID (UUID) for file deletion
             // This is the ID used for GCS file storage, not the local chat ID
             const backendId = conversationManager.getCurrentConversationId();
@@ -3896,7 +4266,7 @@ Create once, run many times across different machines.`;
     /**
      * Load a chat from local storage and restore it
      */
-    loadChat(chatId) {
+    loadChat(chatId, options) {
         const chat = localChatStorage.loadChat(chatId);
         if (!chat) {
             return false;
@@ -3908,11 +4278,32 @@ Create once, run many times across different machines.`;
             tool_calls: msg.tool_calls,
             tool_call_id: msg.tool_call_id,
         }));
+        // IMPORTANT: Also restore UI message history from saved chat
+        // This ensures that when the chat is saved again (e.g., after revert), 
+        // the correct UI messages are preserved
+        if (chat.uiMessages && chat.uiMessages.length > 0) {
+            this.uiMessageHistory = chat.uiMessages.map(msg => ({
+                id: msg.id,
+                role: msg.role,
+                content: msg.content,
+                timestamp: msg.timestamp ? new Date(msg.timestamp) : undefined,
+                toolExecution: msg.toolExecution,
+                shouldStream: false,
+                isCommandMode: msg.isCommandMode,
+                tool_call_id: msg.tool_call_id,
+                tool_calls: msg.tool_calls,
+                thinkingDuration: msg.thinkingDuration,
+                taskCompletion: msg.taskCompletion,
+                planAccepted: msg.planAccepted,
+                connectionStatus: msg.connectionStatus,
+            }));
+        }
         // Set the current chat ID to continue the conversation
         this.currentChatId = chatId;
         this.conversationStarted = true;
         // Restore CWD if saved (important for commands to run in correct directory)
-        if (chat.cwd) {
+        // Allow skipping when preserving an active remote session
+        if (chat.cwd && !options?.preserveCwd) {
             this.cwd = chat.cwd;
             // Update context manager if available
             if (this.contextManager) {
@@ -3944,8 +4335,12 @@ Create once, run many times across different machines.`;
     }
     /**
      * Handle chat picker selection
+     * @param chatId The ID of the chat to load
+     * @param skipLoadedMessage If true, skip showing the "Loaded chat" message (used during revert to avoid React setState race condition)
+     * @param revertSuccessMessage If provided, this message will be appended to restoredMessages before calling onRestoreMessagesCallback (used during revert to include success message in the same React setState call, avoiding race conditions)
+     * @param preserveRemoteSession If true, keep current SSH/WSL/Docker connection and skip reconnect logic (used during revert in a live remote session)
      */
-    async handleChatPickerSelection(chatId) {
+    async handleChatPickerSelection(chatId, skipLoadedMessage = false, revertSuccessMessage, preserveRemoteSession = false) {
         const chat = localChatStorage.loadChat(chatId);
         if (!chat) {
             if (this.onResponseCallback) {
@@ -3956,7 +4351,8 @@ Create once, run many times across different machines.`;
         // IMPORTANT: Clean up current remote session before loading new chat
         // This ensures that switching from a remote chat to a local chat properly resets the state
         const currentContext = this.contextManager.getCurrentContext();
-        if (currentContext.type !== 'local') {
+        const shouldPreserveRemote = preserveRemoteSession && currentContext.type !== 'local';
+        if (!shouldPreserveRemote && currentContext.type !== 'local') {
             // Disconnect from current remote session
             if (currentContext.handler) {
                 try {
@@ -3970,11 +4366,21 @@ Create once, run many times across different machines.`;
             this.contextManager.popContext();
             // Clear remote context tracking
             this.cwdStack = [];
-            this.lastConnectionCommand = null;
+            this.connectionCommandStack = [];
         }
         // Load AI context
-        this.loadChat(chatId);
+        this.loadChat(chatId, shouldPreserveRemote ? { preserveCwd: true } : undefined);
+        // If we're preserving a live remote session (revert case), restore the current remote CWD
+        if (shouldPreserveRemote) {
+            this.cwd = currentContext.metadata.workingDirectory;
+            this.contextManager.updateWorkingDirectory(this.cwd);
+            if (this.onCwdChange) {
+                this.onCwdChange(this.cwd);
+            }
+        }
         // Restore UI messages if available
+        quickLog(`[${new Date().toISOString()}] [handleChatPickerSelection] chat.uiMessages exists: ${!!chat.uiMessages}, length: ${chat.uiMessages?.length ?? 0}\n`);
+        quickLog(`[${new Date().toISOString()}] [handleChatPickerSelection] onRestoreMessagesCallback exists: ${!!this.onRestoreMessagesCallback}\n`);
         if (chat.uiMessages && chat.uiMessages.length > 0 && this.onRestoreMessagesCallback) {
             // Convert StoredUIMessage back to Message format
             const restoredMessages = chat.uiMessages.map(msg => ({
@@ -3992,31 +4398,88 @@ Create once, run many times across different machines.`;
                 planAccepted: msg.planAccepted,
                 connectionStatus: msg.connectionStatus, // For SSH/WSL/Docker connection status boxes
             }));
+            // If a revert success message was provided, append it to the restored messages
+            // This ensures the message is part of the same React setState call, avoiding race conditions
+            quickLog(`[${new Date().toISOString()}] [handleChatPickerSelection] revertSuccessMessage provided: ${!!revertSuccessMessage}\n`);
+            if (revertSuccessMessage) {
+                const revertSystemMessage = {
+                    id: `revert-success-${Date.now()}-${Math.random().toString(36).substring(2, 11)}`,
+                    role: 'assistant',
+                    content: revertSuccessMessage,
+                    timestamp: new Date(),
+                    shouldStream: false,
+                };
+                restoredMessages.push(revertSystemMessage);
+                quickLog(`[${new Date().toISOString()}] [handleChatPickerSelection] Appended revert success message, restoredMessages.length: ${restoredMessages.length}\n`);
+            }
+            quickLog(`[${new Date().toISOString()}] [handleChatPickerSelection] Calling onRestoreMessagesCallback with ${restoredMessages.length} messages\n`);
             this.onRestoreMessagesCallback(restoredMessages);
+            quickLog(`[${new Date().toISOString()}] [handleChatPickerSelection] onRestoreMessagesCallback completed\n`);
         }
         // Attempt to restore remote context if chat was saved while in remote environment
-        if (chat.remoteContext) {
-            const { type, connectionCommand, remoteCwd, localCwdBeforeRemote } = chat.remoteContext;
-            // Store local CWD for when user exits remote (as base of stack)
-            this.cwdStack = [localCwdBeforeRemote];
-            this.lastConnectionCommand = connectionCommand;
-            // Show reconnection notification
+        // Support both remoteContextStack (for nested sessions) and single remoteContext (backward compat)
+        const contextStackToRestore = shouldPreserveRemote
+            ? null
+            : (chat.remoteContextStack ?? (chat.remoteContext ? [chat.remoteContext] : null));
+        if (contextStackToRestore && contextStackToRestore.length > 0) {
+            // Get the base local CWD from the first context's localCwdBeforeRemote
+            const baseLocalCwd = contextStackToRestore[0].localCwdBeforeRemote;
+            // Initialize stacks
+            this.cwdStack = [baseLocalCwd];
+            this.connectionCommandStack = [];
+            // Show initial reconnection notification
+            const nestingInfo = contextStackToRestore.length > 1
+                ? ` (${contextStackToRestore.length} levels: ${contextStackToRestore.map(c => c.type).join(' > ')})`
+                : '';
             if (this.onDirectMessageCallback) {
-                this.onDirectMessageCallback(`🔄 Reconnecting to ${type.toUpperCase()} session...`);
-            }
-            // Show connecting status
-            if (this.onConnectionStatusUpdate) {
-                this.onConnectionStatusUpdate({
-                    type: type,
-                    status: 'connecting',
-                    connectionString: this.buildConnectionString(type, chat.remoteContext.metadata)
-                });
+                this.onDirectMessageCallback(`🔄 Reconnecting to session${nestingInfo}...`);
             }
-            try {
-                // Detect and connect using the saved command
-                const detection = this.commandDetector.detect(connectionCommand);
-                if (detection) {
-                    const context = await detection.handler.connect(connectionCommand, localCwdBeforeRemote);
+            // Sequential reconnection through the stack
+            let previousCwd = baseLocalCwd;
+            for (let i = 0; i < contextStackToRestore.length; i++) {
+                const remoteCtx = contextStackToRestore[i];
+                const { type, connectionCommand, remoteCwd } = remoteCtx;
+                const levelInfo = contextStackToRestore.length > 1 ? ` [${i + 1}/${contextStackToRestore.length}]` : '';
+                // Show connecting status for this level
+                if (this.onDirectMessageCallback) {
+                    this.onDirectMessageCallback(`🔄${levelInfo} Connecting to ${type.toUpperCase()}...`);
+                }
+                if (this.onConnectionStatusUpdate) {
+                    this.onConnectionStatusUpdate({
+                        type: type,
+                        status: 'connecting',
+                        connectionString: this.buildConnectionString(type, remoteCtx.metadata)
+                    });
+                }
+                try {
+                    // Detect and connect using the saved command
+                    const detection = this.commandDetector.detect(connectionCommand);
+                    if (!detection) {
+                        throw new Error(`Could not detect handler for: ${connectionCommand}`);
+                    }
+                    // Create a new instance of the handler to ensure each level of the connection
+                    // has its own state (client, stream, etc.), critical for nested sessions of the same type
+                    const handler = detection.handler.createNew();
+                    let context;
+                    // Check if this is a nested connection (i > 0 means we're inside a remote session)
+                    if (i > 0) {
+                        const currentContext = this.contextManager.getCurrentContext();
+                        if (handler.connectFromRemote) {
+                            context = await handler.connectFromRemote(connectionCommand, previousCwd, currentContext);
+                        }
+                        else {
+                            throw new Error(`Nested connections not supported by ${type} handler`);
+                        }
+                    }
+                    else {
+                        // First level: connect from local
+                        context = await handler.connect(connectionCommand, previousCwd);
+                    }
+                    // Push to stacks
+                    this.connectionCommandStack.push(connectionCommand);
+                    if (i > 0) {
+                        this.cwdStack.push(previousCwd); // Save the previous remote CWD for nested exits
+                    }
                     this.contextManager.pushContext(context);
                     // Navigate to saved remote CWD
                     if (remoteCwd && remoteCwd !== context.metadata.workingDirectory) {
@@ -4026,42 +4489,64 @@ Create once, run many times across different machines.`;
                         catch (cdError) {
                             // Failed to cd to saved path - warn but continue
                             if (this.onDirectMessageCallback) {
-                                this.onDirectMessageCallback(`⚠️ Could not restore remote directory: ${remoteCwd}`);
+                                this.onDirectMessageCallback(`⚠️ Could not restore ${type} directory: ${remoteCwd}`);
                             }
                         }
                     }
-                    // Show success
+                    // Update previousCwd for next iteration
+                    previousCwd = this.contextManager.getCurrentContext().metadata.workingDirectory;
+                    // Show success for this level
                     if (this.onConnectionStatusUpdate) {
                         this.onConnectionStatusUpdate({
                             type: type,
                             status: 'connected',
-                            connectionString: this.buildConnectionString(type, chat.remoteContext.metadata)
+                            connectionString: this.buildConnectionString(type, remoteCtx.metadata)
                         });
                     }
+                }
+                catch (error) {
+                    // Connection failed at this level - fall back to local mode
+                    // If we partially connected, disconnect all and reset
+                    while (this.contextManager.getCurrentContext().type !== 'local') {
+                        const ctx = this.contextManager.getCurrentContext();
+                        if (ctx.handler) {
+                            try {
+                                await ctx.handler.disconnect();
+                            }
+                            catch (e) { /* ignore */ }
+                        }
+                        this.contextManager.popContext();
+                    }
+                    this.cwdStack = [];
+                    this.connectionCommandStack = [];
+                    if (this.onConnectionStatusUpdate) {
+                        this.onConnectionStatusUpdate({
+                            type: type,
+                            status: 'error',
+                            connectionString: this.buildConnectionString(type, remoteCtx.metadata),
+                            error: error.message
+                        });
+                    }
+                    const failedAt = contextStackToRestore.length > 1 ? ` at level ${i + 1} (${type})` : '';
+                    if (this.onDirectMessageCallback) {
+                        this.onDirectMessageCallback(`⚠️ Loaded chat: "${chat.title}"\n\n❌ Could not reconnect${failedAt}: ${error.message}\n\n📁 Restored to local directory: ${baseLocalCwd}`);
+                    }
                     return;
                 }
             }
-            catch (error) {
-                // Connection failed - fall back to local mode
-                this.cwdStack = [];
-                this.lastConnectionCommand = null;
-                if (this.onConnectionStatusUpdate) {
-                    this.onConnectionStatusUpdate({
-                        type: type,
-                        status: 'error',
-                        connectionString: this.buildConnectionString(type, chat.remoteContext.metadata),
-                        error: error.message
-                    });
-                }
-                if (this.onDirectMessageCallback) {
-                    this.onDirectMessageCallback(`⚠️ Loaded chat: "${chat.title}"\n\n❌ Could not reconnect to ${type.toUpperCase()}: ${error.message}\n\n📁 Restored to local directory: ${localCwdBeforeRemote}`);
+            // All levels connected successfully
+            if (this.onDirectMessageCallback) {
+                const successInfo = contextStackToRestore.length > 1
+                    ? `🔗 Reconnected through ${contextStackToRestore.length} levels`
+                    : '';
+                if (successInfo) {
+                    this.onDirectMessageCallback(successInfo);
                 }
-                return;
             }
+            return;
         }
-        // No remote context - show regular confirmation
         // No remote context - show regular confirmation and restore CWD
-        if (chat.cwd && !chat.remoteContext) {
+        if (!shouldPreserveRemote && chat.cwd && !chat.remoteContext) {
             if (fs.existsSync(chat.cwd)) {
                 this.cwd = chat.cwd;
                 this.contextManager.updateWorkingDirectory(chat.cwd);
@@ -4070,7 +4555,8 @@ Create once, run many times across different machines.`;
                 }
             }
         }
-        if (this.onDirectMessageCallback) {
+        // Skip loaded message if called from revert (to avoid React setState race condition)
+        if (this.onDirectMessageCallback && !skipLoadedMessage) {
             const responseMessage = `✅ Loaded chat: "${chat.title}"\n\nYou have ${chat.messageCount} messages in AI context. Continue your conversation!`;
             this.onDirectMessageCallback(responseMessage);
         }
@@ -4102,12 +4588,19 @@ Create once, run many times across different machines.`;
      * Start a new chat session
      */
     startNewChat() {
+        const currentContext = this.contextManager.getCurrentContext();
         this.conversationHistory = [];
         this.currentChatId = null;
         this.conversationStarted = false;
         this.uiMessageHistory = [];
-        this.cwdStack = [];
-        this.lastConnectionCommand = null;
+        // Only clear stacks if we're in local context
+        // If we're in a remote context (SSH/WSL/Docker), we want to PRESERVE the connection state
+        // so the new chat continues in the same environment
+        if (currentContext.type === 'local') {
+            this.cwdStack = [];
+            this.connectionCommandStack = [];
+        }
+        // Else: Preserve cwdStack and connectionCommandStack for remote sessions
         // Reset context limit state
         if (this.contextLimitReached) {
             this.contextLimitReached = false;
@@ -4148,6 +4641,12 @@ Create once, run many times across different machines.`;
     setOnRestoreMessagesCallback(callback) {
         this.onRestoreMessagesCallback = callback;
     }
+    /**
+     * Set callback for setting input value (e.g., for revert)
+     */
+    setOnSetInput(callback) {
+        this.onSetInputCallback = callback;
+    }
     /**
      * Get environment context for backend
      * Returns structured environment information to be sent to backend
@@ -4270,7 +4769,8 @@ Once the user approves the plan:
                     // Remote context (SSH, WSL, Docker) - pass remote context to App
                     // Use the remote context's working directory, not the local Windows CWD
                     const remoteCwd = currentContextForEditor.metadata?.workingDirectory || '~';
-                    this.onInteractiveEditorMode(true, command, remoteCwd, currentContextForEditor);
+                    const parentContext = this.contextManager.getParentContext() || undefined; // Convert null to undefined
+                    this.onInteractiveEditorMode(true, command, remoteCwd, currentContextForEditor, parentContext);
                 }
                 return;
             }
@@ -4307,7 +4807,7 @@ Once the user approves the plan:
                     }
                     if (newContext.type === 'local') {
                         // Clear tracking when back to local
-                        this.lastConnectionCommand = null;
+                        this.connectionCommandStack.pop();
                     }
                     // Save chat - include remote context info if still in remote
                     this.saveCurrentChat();
@@ -4331,12 +4831,18 @@ Once the user approves the plan:
             }
             */
             // Special handling for cd command - change the actual working directory
-            const cdMatch = command.match(/^cd\s+(.+)$/);
+            // Check for chained commands: cd path && cmd or cd path ; cmd
+            const chainedCdMatch = command.match(/^cd\s+([^;&]+?)\s*(&&|;)\s*(.+)$/);
+            const simpleCdMatch = command.match(/^cd\s+(.+)$/);
+            // Determine if this starts with cd
+            const cdMatch = chainedCdMatch || simpleCdMatch;
             if (cdMatch) {
                 const currentContext = this.contextManager.getCurrentContext();
+                const targetDir = (chainedCdMatch ? chainedCdMatch[1] : cdMatch[1]).trim();
+                const hasChainedCommand = !!chainedCdMatch;
+                const chainedCommand = chainedCdMatch ? chainedCdMatch[3] : null;
                 if (currentContext.type === 'local') {
                     // Local cd handling
-                    const targetDir = cdMatch[1].trim();
                     const newCwd = path.resolve(this.cwd, targetDir);
                     if (!fs.existsSync(newCwd)) {
                         if (this.onResponseCallback) {
@@ -4350,19 +4856,31 @@ Once the user approves the plan:
                         }
                         return;
                     }
+                    this.cwd = newCwd;
                     this.contextManager.updateWorkingDirectory(newCwd);
                     if (this.onResponseCallback) {
                         this.onResponseCallback(`Changed directory to: ${newCwd}`);
                     }
+                    // If there's a chained command, execute it in the new directory
+                    if (hasChainedCommand && chainedCommand) {
+                        // Recursively handle the next command
+                        await this.handleCommandModeExecution(chainedCommand);
+                    }
                     return;
                 }
                 else {
-                    // Subshell cd handling - execute via handler
-                    const result = await this.contextManager.executeCommand(command);
+                    // Subshell cd handling - execute just the cd command via handler
+                    const cdOnlyCommand = `cd ${targetDir}`;
+                    const result = await this.contextManager.executeCommand(cdOnlyCommand);
                     if (result.exitCode === 0) {
                         if (this.onResponseCallback) {
                             this.onResponseCallback(`Changed directory to: ${currentContext.metadata.workingDirectory}`);
                         }
+                        // If there's a chained command, execute it in the new directory
+                        if (hasChainedCommand && chainedCommand) {
+                            // Recursively handle the next command
+                            await this.handleCommandModeExecution(chainedCommand);
+                        }
                     }
                     else {
                         if (this.onResponseCallback) {
@@ -4492,57 +5010,118 @@ Once the user approves the plan:
                 });
             }
             else if (currentContext.type === 'docker') {
-                // Docker execution with PTY for proper TTY handling
+                // Docker execution - check if nested inside SSH
+                const parentContext = this.contextManager.getParentContext();
                 const remoteCwd = currentContext.metadata?.workingDirectory || '~';
                 const containerId = currentContext.metadata?.containerId || '';
                 let output = '';
-                await new Promise((resolve) => {
-                    const dockerPty = runDockerCommand(containerId, command, remoteCwd, (data) => {
-                        // Stream output to UI
-                        output += data;
-                        if (this.onToolStreamingOutput) {
-                            this.onToolStreamingOutput({ toolName: 'execute_command', chunk: data, type: 'stdout' });
-                        }
-                    }, (exitCode) => {
-                        // Notify UI of completion
-                        if (this.onToolExecutionUpdate) {
-                            if (exitCode !== 0) {
-                                this.onToolExecutionUpdate({
-                                    toolName: 'execute_command',
-                                    status: 'error',
-                                    result: output,
-                                    error: `Exit Code: ${exitCode}`,
-                                    arguments: { command, cwd: remoteCwd, remoteContext }
-                                });
+                if (parentContext && parentContext.type === 'ssh') {
+                    // Nested Docker inside SSH: route docker exec command through SSH
+                    const sshClient = parentContext.handler?.client;
+                    if (!sshClient) {
+                        throw new Error('SSH client not available for nested Docker session');
+                    }
+                    // Build docker exec command to run via SSH
+                    const escapedCommand = command.replace(/"/g, '\\"');
+                    const dockerCommand = `docker exec -w "${remoteCwd}" ${containerId} sh -c "${escapedCommand}"`;
+                    await new Promise((resolve) => {
+                        const sshPty = runSSHCommand(sshClient, dockerCommand, parentContext.metadata.workingDirectory || '~', (data) => {
+                            // Stream output to UI
+                            output += data;
+                            if (this.onToolStreamingOutput) {
+                                this.onToolStreamingOutput({ toolName: 'execute_command', chunk: data, type: 'stdout' });
                             }
-                            else {
-                                this.onToolExecutionUpdate({
-                                    toolName: 'execute_command',
-                                    status: 'completed',
-                                    result: output || 'Command executed successfully',
-                                    arguments: { command, cwd: remoteCwd, remoteContext }
-                                });
+                        }, (exitCode) => {
+                            // Notify UI of completion
+                            if (this.onToolExecutionUpdate) {
+                                if (exitCode !== 0) {
+                                    this.onToolExecutionUpdate({
+                                        toolName: 'execute_command',
+                                        status: 'error',
+                                        result: output,
+                                        error: `Exit Code: ${exitCode}`,
+                                        arguments: { command, cwd: remoteCwd, remoteContext }
+                                    });
+                                }
+                                else {
+                                    this.onToolExecutionUpdate({
+                                        toolName: 'execute_command',
+                                        status: 'completed',
+                                        result: output || 'Command executed successfully',
+                                        arguments: { command, cwd: remoteCwd, remoteContext }
+                                    });
+                                }
                             }
-                        }
-                        // Record shell command to AI conversation history
-                        this.recordShellCommandToHistory(command, output, remoteCwd, exitCode);
-                        this.currentInteractiveProcess = undefined;
-                        resolve();
+                            // Record shell command to AI conversation history
+                            this.recordShellCommandToHistory(command, output, remoteCwd, exitCode);
+                            this.currentInteractiveProcess = undefined;
+                            resolve();
+                        });
+                        // Set up interactive process for stdin
+                        this.currentInteractiveProcess = {
+                            process: null,
+                            write: (data) => sshPty.write(data),
+                            kill: () => sshPty.kill(),
+                            signal: (sig) => {
+                                if (sig === 'SIGINT') {
+                                    sshPty.write('\x03'); // Ctrl+C
+                                }
+                            },
+                            resize: (cols, rows) => sshPty.resize(cols, rows),
+                            isPty: true
+                        };
                     });
-                    // Set up interactive process for stdin
-                    this.currentInteractiveProcess = {
-                        process: null,
-                        write: (data) => dockerPty.write(data),
-                        kill: () => dockerPty.kill(),
-                        signal: (sig) => {
-                            if (sig === 'SIGINT') {
-                                dockerPty.write('\x03'); // Ctrl+C
+                }
+                else {
+                    // Local Docker: use standard runDockerCommand
+                    await new Promise((resolve) => {
+                        const dockerPty = runDockerCommand(containerId, command, remoteCwd, (data) => {
+                            // Stream output to UI
+                            output += data;
+                            if (this.onToolStreamingOutput) {
+                                this.onToolStreamingOutput({ toolName: 'execute_command', chunk: data, type: 'stdout' });
                             }
-                        },
-                        resize: (cols, rows) => dockerPty.resize(cols, rows),
-                        isPty: true
-                    };
-                });
+                        }, (exitCode) => {
+                            // Notify UI of completion
+                            if (this.onToolExecutionUpdate) {
+                                if (exitCode !== 0) {
+                                    this.onToolExecutionUpdate({
+                                        toolName: 'execute_command',
+                                        status: 'error',
+                                        result: output,
+                                        error: `Exit Code: ${exitCode}`,
+                                        arguments: { command, cwd: remoteCwd, remoteContext }
+                                    });
+                                }
+                                else {
+                                    this.onToolExecutionUpdate({
+                                        toolName: 'execute_command',
+                                        status: 'completed',
+                                        result: output || 'Command executed successfully',
+                                        arguments: { command, cwd: remoteCwd, remoteContext }
+                                    });
+                                }
+                            }
+                            // Record shell command to AI conversation history
+                            this.recordShellCommandToHistory(command, output, remoteCwd, exitCode);
+                            this.currentInteractiveProcess = undefined;
+                            resolve();
+                        });
+                        // Set up interactive process for stdin
+                        this.currentInteractiveProcess = {
+                            process: null,
+                            write: (data) => dockerPty.write(data),
+                            kill: () => dockerPty.kill(),
+                            signal: (sig) => {
+                                if (sig === 'SIGINT') {
+                                    dockerPty.write('\x03'); // Ctrl+C
+                                }
+                            },
+                            resize: (cols, rows) => dockerPty.resize(cols, rows),
+                            isPty: true
+                        };
+                    });
+                }
             }
             else if (currentContext.type === 'ssh') {
                 // SSH execution with PTY for proper TTY handling