centaurus-cli 2.9.5 → 2.9.7

package/dist/ui/components/App.js

@@ -4,6 +4,7 @@ import SelectInput from 'ink-select-input';
 import { CircularSelectInput } from './CircularSelectInput.js';
 import stripAnsi from 'strip-ansi';
 import TextInput from 'ink-text-input';
+import * as path from 'path';
 import { quickLog } from '../../utils/conversation-logger.js';
 import { WelcomeBanner } from './WelcomeBanner.js';
 import { InputBox } from './InputBox.js';
@@ -41,6 +42,26 @@ import { conversationManager } from '../../services/conversation-manager.js';
 import { logDebug, logError } from '../../utils/logger.js';
 import { getTerminalDimensions } from '../../hooks/useTerminalDimensions.js';
 import { ConfigManager } from '../../config/manager.js';
+/**
+ * Check if a file path is outside the current working directory.
+ * Returns true if the path is NOT within the CWD or its subdirectories.
+ */
+function isOutsideCwd(filePath, cwd) {
+    if (!filePath || !cwd)
+        return false;
+    try {
+        // Normalize paths for cross-platform comparison
+        // IMPORTANT: Resolve filePath against cwd to handle relative paths correctly
+        // This ensures remote paths (SSH/Docker) are resolved against their session CWD, not local process.cwd()
+        const normalizedFilePath = path.resolve(cwd, filePath).toLowerCase();
+        const normalizedCwd = path.resolve(cwd).toLowerCase();
+        // Check if the file path starts with the CWD (meaning it's inside or a subdirectory)
+        return !normalizedFilePath.startsWith(normalizedCwd);
+    }
+    catch {
+        return false;
+    }
+}
 // Banner item with stable timestamp - created once outside component
 const BANNER_ITEM = { id: '__banner__', role: '__banner__', content: '', timestamp: new Date(0) };
 const MessageList = React.memo(({ history, current, showBanner }) => {
@@ -117,13 +138,18 @@ const ApprovalSection = React.memo(({ approvalRequest, onApprove }) => {
     // Memoize callbacks to prevent re-renders
     const handleYes = React.useCallback(() => onApprove(true), [onApprove]);
     const handleNo = React.useCallback(() => onApprove(false), [onApprove]);
+    // Generate warning message if operation is outside CWD
+    const warningMessage = approvalRequest.isOutsideCwd
+        ? 'This operation targets a location OUTSIDE your current working directory!'
+        : undefined;
     return (React.createElement(Box, { flexDirection: "column", marginY: 1 },
         approvalRequest.preview && approvalRequest.preview.type === 'code' && (React.createElement(FileCreationPreview, { content: approvalRequest.preview.content, filePath: approvalRequest.operationDetails?.file_path || 'New File' })),
         approvalRequest.preview && approvalRequest.preview.type === 'diff' && (React.createElement(DiffViewer, { diff: approvalRequest.preview.content, filePath: approvalRequest.operationDetails?.file_path || 'Modified File', fullDiff: approvalRequest.preview.fullDiff })),
-        React.createElement(ConfirmPrompt, { message: approvalRequest.message, onYes: handleYes, onNo: handleNo })));
+        React.createElement(ConfirmPrompt, { message: approvalRequest.message, onYes: handleYes, onNo: handleNo, warningMessage: warningMessage })));
 }, (prevProps, nextProps) => {
-    // Only re-render if the approval request message changes
-    return prevProps.approvalRequest.message === nextProps.approvalRequest.message;
+    // Only re-render if the approval request message or isOutsideCwd changes
+    return prevProps.approvalRequest.message === nextProps.approvalRequest.message &&
+        prevProps.approvalRequest.isOutsideCwd === nextProps.approvalRequest.isOutsideCwd;
 });
 // Simple rename input screen component
 const RenameInputScreen = ({ currentTitle, onRename, onCancel }) => {
@@ -149,11 +175,12 @@ const RenameInputScreen = ({ currentTitle, onRename, onCancel }) => {
         React.createElement(Box, { marginTop: 1 },
             React.createElement(Text, { dimColor: true }, "Press Enter to save, ESC to cancel"))));
 };
-export const App = ({ onMessage, onCancelRequest, initialModel, initialPlanMode, onResponseReceived, onDirectMessage, onResponseStream, onClearStreamedResponse, onThoughtStream, onThoughtComplete, onPickerSetup, onPickerSelection, onToolExecutionUpdate, onToolApprovalRequest, onToolStreamingOutput, onPlanModeChange, onPlanApprovalRequest, onPlanCreated, onTaskCompleted, onCommandModeChange, onToggleCommandMode, onBackgroundModeChange, onToggleBackgroundMode, onBackgroundTaskCountChange, onSubAgentCountChange, onSetAutoModeSetup, onCwdChange, onModelChange, onSubshellContextChange, onPasswordRequest, onShellInput, onShellSignal, onKillProcess, onInteractiveEditorMode, onConnectionStatusUpdate, onTokenCountUpdate, onContextLimitReached, onChatPickerSetup, onChatPickerSelection, onChatDeletePickerSetup, onChatDeletePickerSelection, onChatListSetup, onChatRenamePickerSetup, onChatRename, onRestoreMessagesSetup, onUIMessageHistoryUpdate, onBackgroundTaskListSetup, onBackgroundTaskSelection, onBackgroundTaskCancelSetup, onBackgroundTaskCancel, onBackgroundTaskViewSetup, onSessionQuotaUpdate, onMCPAddScreenSetup, onMCPRemoveScreenSetup, onMCPEnableScreenSetup, onMCPDisableScreenSetup, onMCPListScreenSetup, onMCPAddServer, onMCPRemoveServer, onMCPEnableServer, onMCPDisableServer, onMCPValidateConfig, onPromptAnswered, getMainConversation, onWarpifySession, onWorkflowCreatorSetup, onWorkflowSave }) => {
+export const App = ({ onMessage, onCancelRequest, initialModel, initialPlanMode, onResponseReceived, onDirectMessage, onResponseStream, onClearStreamedResponse, onThoughtStream, onThoughtComplete, onPickerSetup, onPickerSelection, onToolExecutionUpdate, onToolApprovalRequest, onToolStreamingOutput, onPlanModeChange, onPlanApprovalRequest, onPlanCreated, onTaskCompleted, onCommandModeChange, onToggleCommandMode, onBackgroundModeChange, onToggleBackgroundMode, onBackgroundTaskCountChange, onSubAgentCountChange, onSetAutoModeSetup, onCwdChange, onModelChange, onSubshellContextChange, onPasswordRequest, onShellInput, onShellSignal, onKillProcess, onInteractiveEditorMode, onConnectionStatusUpdate, onTokenCountUpdate, onContextLimitReached, onChatPickerSetup, onChatPickerSelection, onChatDeletePickerSetup, onChatDeletePickerSelection, onChatListSetup, onChatRenamePickerSetup, onChatRename, onRestoreMessagesSetup, onUIMessageHistoryUpdate, onBackgroundTaskListSetup, onBackgroundTaskSelection, onBackgroundTaskCancelSetup, onBackgroundTaskCancel, onBackgroundTaskViewSetup, onSessionQuotaUpdate, onMCPAddScreenSetup, onMCPRemoveScreenSetup, onMCPEnableScreenSetup, onMCPDisableScreenSetup, onMCPListScreenSetup, onMCPAddServer, onMCPRemoveServer, onMCPEnableServer, onMCPDisableServer, onMCPValidateConfig, onPromptAnswered, getMainConversation, onWarpifySession, onAiAutoSuggestChange, onWorkflowCreatorSetup, onWorkflowSave, getCheckpoints, onRevertToCheckpointSetup, onSetInputSetup }) => {
     const { exit } = useApp();
     // Calculate limit for paginated lists (75% of terminal height)
     const listLimit = Math.max(5, Math.floor((process.stdout.rows || 24) * 0.75));
     const autoAcceptRef = React.useRef(false);
+    const cwdRef = React.useRef(process.cwd()); // Track CWD for async callback access
     const setAutoModeCallbackRef = React.useRef(null);
     // Connectivity State
     const isConnected = useConnectivity();
@@ -367,6 +394,10 @@ export const App = ({ onMessage, onCancelRequest, initialModel, initialPlanMode,
     React.useEffect(() => {
         autoAcceptRef.current = state.autoAcceptMode;
     }, [state.autoAcceptMode]);
+    // Keep CWD ref in sync with state
+    React.useEffect(() => {
+        cwdRef.current = state.currentWorkingDirectory;
+    }, [state.currentWorkingDirectory]);
     // Push shell output updates to InputDetectionAgent when agent control is active
     // This ensures the detection agent always has the latest output for polling
     React.useEffect(() => {
@@ -378,6 +409,9 @@ export const App = ({ onMessage, onCancelRequest, initialModel, initialPlanMode,
     // This is set to true when an Agent-Controlled shell exits, essentially killing the "AI Agent"
     // associated with it from the UI perspective. It is reset when the user manually inputs a new message.
     const ignoreIncomingAIUpdatesRef = React.useRef(false);
+    // True only during Alt+E warpify transition, used to suppress expected shell termination noise.
+    const warpifyInProgressRef = React.useRef(false);
+    const warpifyTerminatingCommandRef = React.useRef(null);
     // NOTE: Token count is now updated via onTokenCountUpdate callback from cli-adapter
     // which tracks the actual AI conversation history including system prompt.
     // The old UI-based calculation has been removed to avoid overwriting correct values.
@@ -898,6 +932,14 @@ export const App = ({ onMessage, onCancelRequest, initialModel, initialPlanMode,
             }));
         });
     }, []); // Empty dependency array - only register once
+    React.useEffect(() => {
+        onAiAutoSuggestChange((enabled) => {
+            setState(prev => ({
+                ...prev,
+                aiAutoSuggest: enabled
+            }));
+        });
+    }, [onAiAutoSuggestChange]);
     // Set up callback for setting Auto mode (used after background task starts)
     React.useEffect(() => {
         onSetAutoModeSetup((enabled) => {
@@ -910,14 +952,82 @@ export const App = ({ onMessage, onCancelRequest, initialModel, initialPlanMode,
     // Set up callback for message restoration (when resuming a chat)
     React.useEffect(() => {
         onRestoreMessagesSetup((restoredMessages) => {
-            // Clear the screen and restore messages
+            // Use two-phase restore to work around Ink's Static component caching:
+            // 1. First, clear messageHistory to unmount the Static component
+            // 2. Then after a short delay, set the restored messages
+            // This ensures Static re-renders fresh with the new message list
+            quickLog(`[${new Date().toISOString()}] [App] onRestoreMessagesSetup callback invoked with ${restoredMessages.length} messages\n`);
+            quickLog(`[${new Date().toISOString()}] [App] First message: ${restoredMessages[0]?.role} - "${restoredMessages[0]?.content?.substring(0, 50)}..."\n`);
+            quickLog(`[${new Date().toISOString()}] [App] Last message: ${restoredMessages[restoredMessages.length - 1]?.role} - "${restoredMessages[restoredMessages.length - 1]?.content?.substring(0, 50)}..."\n`);
+            // Phase 1: Clear screen and empty message history to unmount Static
             clearScreen();
             setState(prev => ({
                 ...prev,
-                messageHistory: restoredMessages,
-                screen: 'chat',
+                messageHistory: [],
+                currentMessage: null,
+                screen: prev.screen === 'password-prompt' ? 'password-prompt' : 'chat',
                 isLoading: false
             }));
+            quickLog(`[${new Date().toISOString()}] [App] Phase 1: Cleared messageHistory to unmount Static\n`);
+            // Phase 2: After brief delay, restore the messages
+            setTimeout(() => {
+                clearScreen();
+                setState(prev => ({
+                    ...prev,
+                    messageHistory: restoredMessages,
+                    screen: prev.screen === 'password-prompt' ? 'password-prompt' : 'chat',
+                    isLoading: false
+                }));
+                quickLog(`[${new Date().toISOString()}] [App] Phase 2: Restored ${restoredMessages.length} messages to messageHistory\n`);
+            }, 50); // Short delay to allow React to unmount and remount Static
+        });
+    }, []); // Empty dependency array - only register once
+    // Set up callback for revert to checkpoint (truncates UI message history)
+    React.useEffect(() => {
+        onRevertToCheckpointSetup((checkpointIndex, prompt) => {
+            setState(prev => {
+                let truncateAtIndex = -1;
+                // Message history length check for safety
+                if (typeof checkpointIndex === 'number' && checkpointIndex >= 0 && checkpointIndex < prev.messageHistory.length) {
+                    // Use the explicit index provided by the checkpoint
+                    truncateAtIndex = checkpointIndex;
+                    quickLog(`[${new Date().toISOString()}] [App] Revert: using explicit checkpoint index ${checkpointIndex}\n`);
+                    // Verify it matches the prompt (sanity check)
+                    const targetMsg = prev.messageHistory[checkpointIndex];
+                    if (targetMsg.role === 'user' && (!targetMsg.content || !targetMsg.content.includes(prompt.slice(0, 20)))) {
+                        quickLog(`[${new Date().toISOString()}] [App] Revert WARNING: Message at index ${checkpointIndex} does not match prompt "${prompt.slice(0, 20)}..."\n`);
+                        // We still use the index as it's likely more reliable than string matching for duplicates
+                    }
+                }
+                else {
+                    // Fallback: Find the user message via prompt matching
+                    // Search BACKWARDS to find the most recent occurrence (handling duplicates better)
+                    for (let i = prev.messageHistory.length - 1; i >= 0; i--) {
+                        const msg = prev.messageHistory[i];
+                        if (msg.role === 'user' && msg.content && msg.content.includes(prompt.slice(0, 50))) {
+                            truncateAtIndex = i;
+                            quickLog(`[${new Date().toISOString()}] [App] Revert: found message by prompt at index ${i}\n`);
+                            break;
+                        }
+                    }
+                }
+                if (truncateAtIndex >= 0) {
+                    // Truncate EXCLUSIVELY (remove the target message and everything after)
+                    // This allows the user to edit and resubmit the reverted message
+                    const truncatedHistory = prev.messageHistory.slice(0, truncateAtIndex);
+                    quickLog(`[${new Date().toISOString()}] [App] Reverted UI: truncated message history from ${prev.messageHistory.length} to ${truncatedHistory.length} messages (exclusive)\n`);
+                    return {
+                        ...prev,
+                        messageHistory: truncatedHistory,
+                        currentMessage: null, // Clear any current message
+                        isLoading: false,
+                        isAiWorking: false
+                    };
+                }
+                // If we couldn't find the message, log but don't crash
+                quickLog(`[${new Date().toISOString()}] [App] Revert: could not find message matching prompt "${prompt.slice(0, 50)}"\n`);
+                return prev;
+            });
         });
     }, []); // Empty dependency array - only register once
     // Set up callback for background task list picker
@@ -1202,6 +1312,23 @@ export const App = ({ onMessage, onCancelRequest, initialModel, initialPlanMode,
                 }
                 // COMPLETION / ERROR
                 if (update.status === 'completed' || update.status === 'error') {
+                    const updateCommand = update.arguments?.command || update.arguments?.CommandLine || update.arguments?.commandLine || '';
+                    const terminatingCommand = warpifyTerminatingCommandRef.current || '';
+                    const isWarpifyTerminationUpdate = !terminatingCommand || !updateCommand || updateCommand === terminatingCommand;
+                    // During warpify, the PTY shell is intentionally terminated (SIGTERM).
+                    // Ignore the resulting execute_command completion/error update so we don't
+                    // show a false red shell card that can replace the tunneling status message.
+                    if (warpifyInProgressRef.current && isWarpifyTerminationUpdate) {
+                        if (pendingShellRef.current) {
+                            clearTimeout(pendingShellRef.current.timeoutId);
+                            pendingShellRef.current = null;
+                        }
+                        try {
+                            quickLog(`[${new Date().toISOString()}] [App] Suppressed execute_command ${update.status} during warpify transition\n`);
+                        }
+                        catch (e) { }
+                        return;
+                    }
                     // Check if we have a pending shell (fast command)
                     if (pendingShellRef.current) {
                         // Command finished VERY fast (within 50ms)
@@ -1505,8 +1632,31 @@ export const App = ({ onMessage, onCancelRequest, initialModel, initialPlanMode,
     // Set up callback for tool approval requests
     React.useEffect(() => {
         onToolApprovalRequest(async (request) => {
-            // Auto-approve if auto-accept mode is on
-            if (autoAcceptRef.current) {
+            // Determine if operation targets a path outside CWD
+            let operationOutsideCwd = false;
+            const currentCwd = cwdRef.current;
+            if (currentCwd) {
+                if (request.operationType === 'execute_command') {
+                    // For commands, check the Cwd parameter
+                    const commandCwd = request.operationDetails?.Cwd;
+                    if (commandCwd) {
+                        operationOutsideCwd = isOutsideCwd(commandCwd, currentCwd);
+                    }
+                }
+                else if (request.operationType === 'write_file' ||
+                    request.operationType === 'write_to_file' ||
+                    request.operationType === 'edit_file' ||
+                    request.operationType === 'multi_edit_file') {
+                    // For file operations, check the file_path
+                    const filePath = request.operationDetails?.file_path;
+                    if (filePath) {
+                        operationOutsideCwd = isOutsideCwd(filePath, currentCwd);
+                    }
+                }
+            }
+            // Auto-approve if auto-accept mode is on AND operation is NOT outside CWD
+            // Operations outside CWD always require explicit user approval for safety
+            if (autoAcceptRef.current && !operationOutsideCwd) {
                 return true;
             }
             // Check if this is a file operation with preview (write_file, write_to_file, edit_file, or multi_edit_file)
@@ -1527,6 +1677,7 @@ export const App = ({ onMessage, onCancelRequest, initialModel, initialPlanMode,
                             preview: request.preview,
                             operationType: request.operationType,
                             operationDetails: request.operationDetails,
+                            isOutsideCwd: operationOutsideCwd,
                             resolve: (approved) => {
                                 // First unmount the approval section to stop rendering
                                 setState(prev => ({
@@ -1560,6 +1711,7 @@ export const App = ({ onMessage, onCancelRequest, initialModel, initialPlanMode,
                             preview: request.preview,
                             operationType: request.operationType,
                             operationDetails: request.operationDetails,
+                            isOutsideCwd: operationOutsideCwd,
                             resolve: (approved) => {
                                 // Clear approval request
                                 setState(prev => ({
@@ -1645,19 +1797,43 @@ export const App = ({ onMessage, onCancelRequest, initialModel, initialPlanMode,
                         }
                     };
                 }
-                // Update current message if it's a tool with matching name
+                // Update tool in currentMessage if it matches
+                let updatedCurrentMessage = prev.currentMessage;
                 if (prev.currentMessage?.role === 'tool' &&
-                    prev.currentMessage.toolExecution?.toolName === update.toolName) {
+                    prev.currentMessage.toolExecution?.toolName === update.toolName &&
+                    prev.currentMessage.toolExecution?.status === 'executing') {
                     const existingOutput = prev.currentMessage.toolExecution.streamingOutput || '';
-                    return {
-                        ...prev,
-                        currentMessage: {
-                            ...prev.currentMessage,
+                    updatedCurrentMessage = {
+                        ...prev.currentMessage,
+                        toolExecution: {
+                            ...prev.currentMessage.toolExecution,
+                            streamingOutput: existingOutput + update.chunk
+                        }
+                    };
+                }
+                // Also update any matching executing tool in messageHistory
+                let messageHistoryChanged = false;
+                const updatedHistory = prev.messageHistory.map(msg => {
+                    if (msg.role === 'tool' &&
+                        msg.toolExecution?.toolName === update.toolName &&
+                        msg.toolExecution?.status === 'executing') {
+                        messageHistoryChanged = true;
+                        const existingOutput = msg.toolExecution.streamingOutput || '';
+                        return {
+                            ...msg,
                             toolExecution: {
-                                ...prev.currentMessage.toolExecution,
+                                ...msg.toolExecution,
                                 streamingOutput: existingOutput + update.chunk
                             }
-                        }
+                        };
+                    }
+                    return msg;
+                });
+                if (updatedCurrentMessage !== prev.currentMessage || messageHistoryChanged) {
+                    return {
+                        ...prev,
+                        currentMessage: updatedCurrentMessage,
+                        messageHistory: updatedHistory
                     };
                 }
                 return prev;
@@ -1837,23 +2013,25 @@ export const App = ({ onMessage, onCancelRequest, initialModel, initialPlanMode,
             return new Promise((resolve, reject) => {
                 setState(prev => ({
                     ...prev,
-                    screen: 'password-prompt',
+                    // Keep chat screen when possible so connection/tunneling status remains visible.
+                    // Use dedicated password screen only if we're currently in another modal screen.
+                    screen: prev.screen === 'chat' ? 'chat' : 'password-prompt',
                     passwordRequest: {
                         message,
                         resolve: (password) => {
-                            // Return to chat screen
+                            // Return to chat screen if we were in dedicated password screen mode
                             setState(prev2 => ({
                                 ...prev2,
-                                screen: 'chat',
+                                screen: prev2.screen === 'password-prompt' ? 'chat' : prev2.screen,
                                 passwordRequest: undefined
                             }));
                             resolve(password);
                         },
                         reject: () => {
-                            // Return to chat screen
+                            // Return to chat screen if we were in dedicated password screen mode
                             setState(prev2 => ({
                                 ...prev2,
-                                screen: 'chat',
+                                screen: prev2.screen === 'password-prompt' ? 'chat' : prev2.screen,
                                 passwordRequest: undefined
                             }));
                             reject(new Error('Password input cancelled'));
@@ -2097,24 +2275,29 @@ export const App = ({ onMessage, onCancelRequest, initialModel, initialPlanMode,
             return; // Don't submit empty values
         // Check if this is a slash command
         const isSlashCommand = trimmedValue.startsWith('/');
-        // Check if this is the /clear command
-        if (trimmedValue === '/clear' || trimmedValue === '/cls' || trimmedValue === '/reset') {
-            // Clear the screen and reset state
-            clearScreen();
+        // Check if this is the clear command (slash or no slash)
+        const lowerValue = trimmedValue.toLowerCase();
+        if (lowerValue === '/clear' || lowerValue === 'clear' || lowerValue === '/cls' || lowerValue === 'cls' || lowerValue === '/reset') {
+            // Soft Clear: Push history up by creating a blank space
+            // We do NOT use clearScreen() here because that wipes the scrollback buffer (\x1b[3J)
+            // Instead, we add a "spacer" message that pushes previous content up out of the viewport
+            const height = process.stdout.rows || 24;
+            // Use \u200B (Zero Width Space) to prevent trim() from emptying the string
+            // in MessageDisplay.tsx, which would cause it to not render.
+            const spacer = Array(height).fill('\u200B\n').join('');
+            const clearMessage = {
+                id: `clear-${Date.now()}`,
+                role: 'system',
+                content: spacer,
+                timestamp: new Date(),
+                isSpacer: true
+            };
             setState(prev => ({
                 ...prev,
-                messageHistory: [],
+                messageHistory: [...prev.messageHistory, clearMessage],
                 currentMessage: null,
-                isLoading: false,
-                currentTokens: 0
+                // We don't reset other state (tokens, loading) to preserve context
             }));
-            // Still call onMessage to clear backend history
-            try {
-                await onMessage(trimmedValue);
-            }
-            catch (error) {
-                // Ignore errors for clear command
-            }
             return;
         }
         // Check if this is the /clean-ui command (refresh UI without clearing history)
@@ -2486,7 +2669,7 @@ export const App = ({ onMessage, onCancelRequest, initialModel, initialPlanMode,
                         ShellInputAgent.terminateSession(shellId);
                         quickLog(`[${new Date().toISOString()}] [AgentControl] Terminated ShellInputAgent session for ${shellId}\n`);
                     }
-                }, onWarpifySession: async () => {
+                }, onWarpifySession: state.shellState?.isBackgroundTask ? undefined : async () => {
                     // Warpify: Detect if there's an active remote session and establish ssh2 connection
                     const shellCommand = state.shellState?.command || '';
                     const currentOutput = state.shellState?.output || '';
@@ -2513,54 +2696,66 @@ export const App = ({ onMessage, onCancelRequest, initialModel, initialPlanMode,
                     // Remote session detected - warpify it!
                     const description = getSessionDescription(session);
                     quickLog(`[${new Date().toISOString()}] [Warpify] Warpifying: ${description}\n`);
-                    // Terminate the PTY session (we'll use ssh2 handler instead)
-                    onShellSignal('SIGTERM');
-                    // Capture history commands
-                    const historyMessages = [];
-                    // 1. Add the command the user typed (e.g., "ssh user@host")
-                    if (shellCommand) {
-                        historyMessages.push({
-                            id: `warpify-cmd-${Date.now()}`,
-                            role: 'user',
-                            content: shellCommand,
-                            timestamp: new Date(),
-                            isCommandMode: false // Treat as a normal chat message for history
-                        });
-                    }
-                    // 2. Add the terminal output (e.g., login banner, password prompt output)
-                    if (currentOutput && currentOutput.trim().length > 0) {
-                        historyMessages.push({
-                            id: `warpify-out-${Date.now()}`,
-                            role: 'tool', // Use 'tool' role to mimic command execution output
-                            content: '',
-                            timestamp: new Date(),
-                            toolExecution: {
-                                toolName: 'execute_command',
-                                status: 'completed',
-                                result: currentOutput, // This contains the PTY output including ANSI codes
-                                arguments: {
-                                    command: shellCommand,
-                                    isPty: true
+                    warpifyInProgressRef.current = true;
+                    warpifyTerminatingCommandRef.current = shellCommand;
+                    try {
+                        // Terminate the PTY session (we'll use ssh2 handler instead)
+                        onShellSignal('SIGTERM');
+                        // Capture history commands
+                        const historyMessages = [];
+                        // 1. Add the command the user typed (e.g., "ssh user@host")
+                        if (shellCommand) {
+                            historyMessages.push({
+                                id: `warpify-cmd-${Date.now()}`,
+                                role: 'user',
+                                content: shellCommand,
+                                timestamp: new Date(),
+                                isCommandMode: false // Treat as a normal chat message for history
+                            });
+                        }
+                        // 2. Add the terminal output (e.g., login banner, password prompt output)
+                        if (currentOutput && currentOutput.trim().length > 0) {
+                            historyMessages.push({
+                                id: `warpify-out-${Date.now()}`,
+                                role: 'tool', // Use 'tool' role to mimic command execution output
+                                content: '',
+                                timestamp: new Date(),
+                                toolExecution: {
+                                    toolName: 'execute_command',
+                                    status: 'completed',
+                                    result: currentOutput, // This contains the PTY output including ANSI codes
+                                    arguments: {
+                                        command: shellCommand,
+                                        isPty: true
+                                    }
                                 }
-                            }
-                        });
+                            });
+                        }
+                        // Clear shell-related UI state and append captured history
+                        // Reset isAiWorking to prevent "Boosting..." spinner from appearing
+                        setState(prev => ({
+                            ...prev,
+                            messageHistory: [...prev.messageHistory, ...historyMessages],
+                            shellState: undefined,
+                            currentMessage: null,
+                            isAiWorking: false
+                        }));
+                        // Clear screen
+                        clearScreen();
+                        // Establish proper ssh2 connection via cli-adapter
+                        // This will prompt for password and set up full SSH functionality
+                        const success = await onWarpifySession(shellCommand, session.type, session.connectionString);
+                        if (!success) {
+                            // Connection failed - error already shown by cli.warpifySession
+                            quickLog(`[${new Date().toISOString()}] [Warpify] Failed to establish ssh2 connection\n`);
+                        }
                     }
-                    // Clear the shell state AND append the history messages
-                    // Also reset isAiWorking to prevent "Boosting..." spinner from appearing
-                    setState(prev => ({
-                        ...prev,
-                        messageHistory: [...prev.messageHistory, ...historyMessages],
-                        shellState: undefined,
-                        isAiWorking: false
-                    }));
-                    // Clear screen
-                    clearScreen();
-                    // Establish proper ssh2 connection via cli-adapter
-                    // This will prompt for password and set up full SSH functionality
-                    const success = await onWarpifySession(shellCommand, session.type, session.connectionString);
-                    if (!success) {
-                        // Connection failed - error already shown by cli.warpifySession
-                        quickLog(`[${new Date().toISOString()}] [Warpify] Failed to establish ssh2 connection\n`);
+                    finally {
+                        // Keep suppression active briefly so delayed shell completion events are ignored.
+                        setTimeout(() => {
+                            warpifyInProgressRef.current = false;
+                            warpifyTerminatingCommandRef.current = null;
+                        }, 400);
                     }
                 } })),
             state.shellState?.isAgentControlled && state.shellState?.isFocused && state.shellState?.isRunning && (React.createElement(MonitorModeAIPanel, { messages: [
@@ -2577,7 +2772,17 @@ export const App = ({ onMessage, onCancelRequest, initialModel, initialPlanMode,
                 !(state.currentMessage?.toolExecution?.status === 'executing') && (React.createElement(Box, { marginBottom: 1, paddingLeft: 1 },
                 React.createElement(LoadingIndicator, { key: "loading-indicator" }),
                 React.createElement(AgentTimer, { key: "agent-timer" }))),
-            !state.shellState?.isFocused && (state.approvalRequest ? (React.createElement(ApprovalSection, { key: `approval-${state.approvalRequest.message}`, approvalRequest: state.approvalRequest, onApprove: (approved) => {
+            !state.shellState?.isFocused && (state.passwordRequest ? (React.createElement(PasswordPrompt, { message: state.passwordRequest.message, onSubmit: (password) => {
+                    const resolve = state.passwordRequest?.resolve;
+                    if (resolve) {
+                        resolve(password);
+                    }
+                }, onCancel: () => {
+                    const reject = state.passwordRequest?.reject;
+                    if (reject) {
+                        reject();
+                    }
+                } })) : state.approvalRequest ? (React.createElement(ApprovalSection, { key: `approval-${state.approvalRequest.message}`, approvalRequest: state.approvalRequest, onApprove: (approved) => {
                     const resolve = state.approvalRequest?.resolve;
                     if (resolve) {
                         resolve(approved);
@@ -2590,7 +2795,7 @@ export const App = ({ onMessage, onCancelRequest, initialModel, initialPlanMode,
                     handleSubmit(value, clipboardImages);
                 }, autoAcceptMode: state.autoAcceptMode, model: state.currentModel, planMode: state.planMode, commandMode: state.commandMode, backgroundMode: state.backgroundMode, currentWorkingDirectory: state.currentWorkingDirectory, commandHistory: state.commandHistory, onToggleAutoAccept: handleToggleAutoAccept, onToggleCommandMode: onToggleCommandMode, onToggleBackgroundMode: onToggleBackgroundMode, isActive: true, subshellContext: state.subshellContext, subshellContextStack: state.subshellContextStack, currentTokens: state.currentTokens, maxTokens: state.maxTokens, contextLimitReached: state.contextLimitReached, isShellRunning: state.shellState?.isRunning, backgroundTaskCount: state.backgroundTaskCount, subAgentCount: state.subAgentCount, initialValue: preservedInputTextRef.current, onValueChange: handleInputValueChange, onSetAutoModeSetup: (callback) => {
                     setAutoModeCallbackRef.current = callback;
-                }, sessionQuotaExhausted: state.sessionQuotaExhausted, sessionQuotaTimeRemaining: state.sessionQuotaTimeRemaining, aiAutoSuggestEnabled: state.aiAutoSuggest, sessionCommands: sessionCommands }))),
+                }, sessionQuotaExhausted: state.sessionQuotaExhausted, sessionQuotaTimeRemaining: state.sessionQuotaTimeRemaining, aiAutoSuggestEnabled: state.aiAutoSuggest, sessionCommands: sessionCommands, getCheckpoints: getCheckpoints, onSetInputSetup: onSetInputSetup }))),
             state.showExitWarning && (React.createElement(Box, { marginTop: 1 },
                 React.createElement(Text, { color: "#ffaa00", bold: true }, "\u26A0\uFE0F  Press Ctrl+C again to exit"))),
             !isConnected && (React.createElement(Box, { marginTop: 0, marginLeft: state.showExitWarning ? 2 : 0 },