@yu_robotics/remote-cli 1.0.0

package/dist/executor/ClaudePersistentExecutor.js

@@ -0,0 +1,958 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClaudePersistentExecutor = void 0;
+const child_process_1 = require("child_process");
+const ClaudeCodeHooks_1 = require("../hooks/ClaudeCodeHooks");
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const os_1 = __importDefault(require("os"));
+const events_1 = require("events");
+/**
+ * Get Claude's global sessions directory
+ */
+function getClaudeSessionsDir() {
+    const homeDir = os_1.default.homedir();
+    const possiblePaths = [
+        path_1.default.join(homeDir, '.claude', 'sessions'),
+        path_1.default.join(homeDir, '.config', 'claude', 'sessions'),
+        path_1.default.join(homeDir, 'Library', 'Application Support', 'Claude', 'sessions'),
+    ];
+    for (const dir of possiblePaths) {
+        if (fs_1.default.existsSync(dir)) {
+            return dir;
+        }
+    }
+    return null;
+}
+/**
+ * Claude Persistent Executor
+ *
+ * Maintains a long-running Claude process and communicates via stdin/stdout
+ * using stream-json format for real-time bidirectional communication.
+ */
+class ClaudePersistentExecutor extends events_1.EventEmitter {
+    directoryGuard;
+    currentWorkingDirectory;
+    isDestroyed = false;
+    defaultTimeout = 600000; // 10 minutes default, but will extend on activity
+    sessionId = null;
+    sessionFilePath;
+    // Persistent process
+    claudeProcess = null;
+    isStarting = false;
+    isStopping = false; // Flag to indicate intentional process stop
+    commandQueue = [];
+    isProcessing = false;
+    // Output handling
+    currentOutputBuffer = [];
+    currentStreamCallback;
+    currentToolUseCallback;
+    currentToolResultCallback;
+    currentCommandResolve;
+    currentCommandReject;
+    currentTimeoutTimer;
+    // Structured content collection for rich formatting
+    structuredContentBlocks = [];
+    currentStructuredCallback;
+    // Current task context for hooks
+    currentTaskId = null;
+    currentTaskStartTime = 0;
+    // Interactive input handling
+    isWaitingForInput = false;
+    inputRequestCallbacks = [];
+    inputDetectionTimer;
+    lastOutputTime = 0;
+    // Activity tracking for timeout extension (optional, can be disabled)
+    activityTrackingEnabled = false;
+    constructor(directoryGuard) {
+        super();
+        this.directoryGuard = directoryGuard;
+        this.currentWorkingDirectory = process.cwd();
+        this.sessionFilePath = path_1.default.join(this.currentWorkingDirectory, '.claude-session');
+        this.loadSessionId();
+    }
+    /**
+     * Load session ID from file if exists
+     */
+    loadSessionId() {
+        try {
+            if (fs_1.default.existsSync(this.sessionFilePath)) {
+                const data = fs_1.default.readFileSync(this.sessionFilePath, 'utf-8');
+                const session = JSON.parse(data);
+                if (session.id) {
+                    this.sessionId = session.id;
+                    console.log(`[ClaudePersistent] Loaded session ID: ${this.sessionId}`);
+                }
+            }
+        }
+        catch (error) {
+            console.error('[ClaudePersistent] Failed to load session ID:', error);
+            this.sessionId = null;
+        }
+    }
+    /**
+     * Save session ID to file
+     */
+    saveSessionId(sessionId) {
+        try {
+            const data = JSON.stringify({
+                id: sessionId,
+                savedAt: new Date().toISOString(),
+            });
+            fs_1.default.writeFileSync(this.sessionFilePath, data, 'utf-8');
+            console.log(`[ClaudePersistent] Saved session ID: ${sessionId}`);
+        }
+        catch (error) {
+            console.error('[ClaudePersistent] Failed to save session ID:', error);
+        }
+    }
+    /**
+     * Get recent session ID from Claude's sessions directory
+     */
+    async getRecentSessionId() {
+        try {
+            const sessionsDir = getClaudeSessionsDir();
+            if (!sessionsDir) {
+                return null;
+            }
+            const entries = fs_1.default.readdirSync(sessionsDir, { withFileTypes: true });
+            const sessionDirs = entries
+                .filter(entry => entry.isDirectory())
+                .map(entry => {
+                const sessionPath = path_1.default.join(sessionsDir, entry.name);
+                const stats = fs_1.default.statSync(sessionPath);
+                return {
+                    id: entry.name,
+                    mtime: stats.mtime,
+                };
+            })
+                .filter(session => {
+                const uuidPattern = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+                return uuidPattern.test(session.id);
+            })
+                .sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
+            if (sessionDirs.length === 0) {
+                return null;
+            }
+            return sessionDirs[0].id;
+        }
+        catch (error) {
+            console.error('[ClaudePersistent] Failed to get recent session ID:', error);
+            return null;
+        }
+    }
+    /**
+     * Get current working directory
+     */
+    getCurrentWorkingDirectory() {
+        return this.currentWorkingDirectory;
+    }
+    /**
+     * Set working directory
+     */
+    setWorkingDirectory(targetPath) {
+        const resolvedPath = this.directoryGuard.resolveWorkingDirectory(targetPath, this.currentWorkingDirectory);
+        // If directory changes, we need to restart the process
+        const needsRestart = this.currentWorkingDirectory !== resolvedPath && this.claudeProcess !== null;
+        this.currentWorkingDirectory = resolvedPath;
+        this.sessionFilePath = path_1.default.join(this.currentWorkingDirectory, '.claude-session');
+        this.loadSessionId();
+        if (needsRestart) {
+            console.log('[ClaudePersistent] Working directory changed, restarting process...');
+            this.stopProcess().then(() => this.startProcess());
+        }
+    }
+    /**
+     * Start the persistent Claude process
+     */
+    async startProcess() {
+        if (this.claudeProcess || this.isStarting) {
+            return;
+        }
+        this.isStarting = true;
+        try {
+            // If no session ID, try to get recent one
+            if (!this.sessionId) {
+                console.log('[ClaudePersistent] No session ID, checking for recent sessions...');
+                this.sessionId = await this.getRecentSessionId();
+                if (this.sessionId) {
+                    this.saveSessionId(this.sessionId);
+                }
+            }
+            // Build arguments
+            // Note: --output-format=stream-json requires --verbose
+            const args = [
+                '--input-format=stream-json',
+                '--output-format=stream-json',
+                '--include-partial-messages',
+                '--verbose',
+                '--dangerously-skip-permissions'
+            ];
+            if (this.sessionId) {
+                args.push('--resume', this.sessionId);
+                console.log(`[ClaudePersistent] Resuming session: ${this.sessionId}`);
+            }
+            else {
+                console.log('[ClaudePersistent] Starting new session');
+            }
+            console.log(`[ClaudePersistent] Starting: claude ${args.join(' ')}`);
+            console.log(`[ClaudePersistent] Working directory: ${this.currentWorkingDirectory}`);
+            // Spawn the process
+            const child = (0, child_process_1.spawn)('claude', args, {
+                cwd: this.currentWorkingDirectory,
+                stdio: ['pipe', 'pipe', 'pipe'],
+                env: {
+                    ...process.env,
+                    FORCE_COLOR: '0',
+                    // Prevent nested session error
+                    CLAUDECODE: '',
+                },
+            });
+            this.claudeProcess = child;
+            // Buffer for collecting stderr on startup (for error reporting)
+            let stderrBuffer = [];
+            let isStartupPhase = true;
+            // Handle stdout (JSON stream)
+            let buffer = '';
+            child.stdout?.on('data', (data) => {
+                buffer += data.toString();
+                // Process complete JSON lines
+                const lines = buffer.split('\n');
+                buffer = lines.pop() || ''; // Keep incomplete line in buffer
+                for (const line of lines) {
+                    if (line.trim()) {
+                        this.handleOutputLine(line.trim());
+                    }
+                }
+            });
+            // Handle stderr
+            child.stderr?.on('data', (data) => {
+                const text = data.toString();
+                // Collect stderr during startup for error reporting
+                if (isStartupPhase) {
+                    stderrBuffer.push(text);
+                    // Keep only last 20 lines to avoid memory issues
+                    if (stderrBuffer.length > 20) {
+                        stderrBuffer.shift();
+                    }
+                }
+                console.error('[ClaudePersistent stderr]', text);
+                // Forward to current stream callback if available
+                if (this.currentStreamCallback) {
+                    this.currentStreamCallback(text);
+                }
+                this.currentOutputBuffer.push(text);
+            });
+            // Handle process exit
+            child.on('exit', (code, signal) => {
+                isStartupPhase = false;
+                const stderrOutput = stderrBuffer.join('');
+                stderrBuffer = []; // Clear buffer
+                if (code !== 0 && code !== null) {
+                    console.error(`[ClaudePersistent] Process exited with code ${code}, signal ${signal}`);
+                    if (stderrOutput) {
+                        console.error('[ClaudePersistent] stderr output:\n', stderrOutput);
+                    }
+                }
+                else {
+                    console.log(`[ClaudePersistent] Process exited with code ${code}, signal ${signal}`);
+                }
+                this.claudeProcess = null;
+                // Check if this was an intentional stop (abort/reset)
+                const wasIntentionalStop = this.isStopping;
+                this.isStopping = false; // Reset the flag
+                // Reject current command if any (only for unexpected exits)
+                if (this.currentCommandReject && !wasIntentionalStop) {
+                    let errorMsg = `Claude process exited unexpectedly (code: ${code})`;
+                    if (stderrOutput) {
+                        errorMsg += `\nstderr: ${stderrOutput.substring(0, 500)}`;
+                    }
+                    this.currentCommandReject(new Error(errorMsg));
+                    this.resetCurrentCommand();
+                }
+                // Emit event for external handling
+                this.emit('processExit', { code, signal, intentional: wasIntentionalStop });
+                // Auto-restart if not destroyed and there are pending commands
+                // Don't auto-restart if this was an intentional stop (let processQueue handle it)
+                if (!this.isDestroyed && !wasIntentionalStop && this.commandQueue.length > 0) {
+                    console.log('[ClaudePersistent] Auto-restarting process...');
+                    setTimeout(() => this.startProcess(), 1000);
+                }
+            });
+            // Handle process error
+            child.on('error', (error) => {
+                console.error('[ClaudePersistent] Process error:', error);
+                this.claudeProcess = null;
+                this.isStarting = false;
+                if (this.currentCommandReject) {
+                    if (error.message.includes('ENOENT')) {
+                        this.currentCommandReject(new Error('Claude Code CLI not found. Please ensure Claude Code is installed and available in PATH.'));
+                    }
+                    else {
+                        this.currentCommandReject(error);
+                    }
+                    this.resetCurrentCommand();
+                }
+            });
+            // Wait a bit for process to be ready
+            await new Promise(resolve => setTimeout(resolve, 1000));
+            // Clear startup phase after a few seconds (stderr won't be buffered anymore)
+            setTimeout(() => {
+                isStartupPhase = false;
+                stderrBuffer = [];
+            }, 5000);
+            console.log(`[ClaudePersistent] Process started with PID: ${child.pid}`);
+            this.isStarting = false;
+            // Process any pending commands
+            this.processQueue();
+        }
+        catch (error) {
+            this.isStarting = false;
+            throw error;
+        }
+    }
+    /**
+     * Stop the persistent Claude process
+     */
+    async stopProcess() {
+        if (!this.claudeProcess) {
+            return;
+        }
+        console.log('[ClaudePersistent] Stopping process...');
+        this.isStopping = true;
+        // Send EOF to stdin to gracefully close
+        this.claudeProcess.stdin?.end();
+        // Kill after timeout
+        const killTimeout = setTimeout(() => {
+            if (this.claudeProcess) {
+                console.log('[ClaudePersistent] Force killing process...');
+                this.claudeProcess.kill('SIGTERM');
+            }
+        }, 5000);
+        // Wait for process to exit
+        await new Promise(resolve => {
+            if (!this.claudeProcess) {
+                resolve();
+                return;
+            }
+            this.claudeProcess.on('exit', () => {
+                clearTimeout(killTimeout);
+                resolve();
+            });
+        });
+        this.claudeProcess = null;
+        console.log('[ClaudePersistent] Process stopped');
+    }
+    /**
+     * Reset the command timeout timer when activity is detected
+     * This prevents timeout during long-running tasks with continuous output
+     *
+     * NOTE: This method is currently disabled because inactivity timeout can cause
+     * state inconsistency - the executor may timeout while Claude process is still
+     * running, leading to confusing behavior where user sees timeout error but
+     * Claude is still working. Users can use /abort to cancel long-running tasks.
+     */
+    resetActivityTimeout() {
+        // Activity-based timeout is disabled to prevent state inconsistency.
+        // If a command hangs, users can manually abort with /abort.
+        if (!this.activityTrackingEnabled) {
+            return;
+        }
+        if (!this.isProcessing || !this.currentTimeoutTimer) {
+            return;
+        }
+        // Clear existing timer and set a new one
+        clearTimeout(this.currentTimeoutTimer);
+        this.currentTimeoutTimer = setTimeout(() => {
+            console.error('[ClaudePersistent] Command timeout due to inactivity');
+            this.completeCurrentCommand(false, 'Execution timeout: No response from Claude for 10 minutes');
+        }, this.defaultTimeout);
+    }
+    /**
+     * Handle a line of JSON output from Claude
+     */
+    handleOutputLine(line) {
+        try {
+            // Parse message first to check type
+            const parsedMessage = JSON.parse(line);
+            // Skip logging for stream_event messages to avoid console spam
+            // These are internal protocol messages (content_block_start, content_block_delta, etc.)
+            if (parsedMessage.type !== 'stream_event') {
+                const timestamp = new Date().toISOString();
+                console.log(`[ClaudePersistent RAW ${timestamp}] ${line}`);
+            }
+            const message = parsedMessage;
+            // Reset timeout on any activity to prevent timeout during long tasks
+            this.resetActivityTimeout();
+            switch (message.type) {
+                case 'message':
+                case 'thinking':
+                    const contentLength = typeof message.content === 'string' ? message.content.length : JSON.stringify(message.content).length;
+                    console.log(`[ClaudePersistent] Received ${message.type} message, partial=${message.partial}, content length=${contentLength}`);
+                    if (message.content) {
+                        const contentStr = typeof message.content === 'string' ? message.content : JSON.stringify(message.content);
+                        this.currentOutputBuffer.push(contentStr);
+                        if (this.currentStreamCallback) {
+                            this.currentStreamCallback(contentStr);
+                        }
+                        // Note: Don't complete on partial=false here
+                        // The command completion should be handled by the 'result' message
+                        // which is the definitive end-of-response signal
+                    }
+                    break;
+                case 'error':
+                    console.error('[ClaudePersistent] Error from Claude:', message.content);
+                    this.completeCurrentCommand(false, typeof message.content === 'string' ? message.content : 'Unknown error from Claude');
+                    break;
+                case 'usage':
+                    // Usage info, can be logged or ignored
+                    if (message.usage) {
+                        console.log(`[ClaudePersistent] Usage: ${message.usage.input_tokens} in / ${message.usage.output_tokens} out`);
+                    }
+                    break;
+                case 'system':
+                    // System messages (e.g., init)
+                    if (message.subtype === 'init' && message.session_id) {
+                        console.log(`[ClaudePersistent] Session initialized: ${message.session_id}`);
+                        this.sessionId = message.session_id;
+                        this.saveSessionId(message.session_id);
+                    }
+                    break;
+                case 'stream_event':
+                    // Stream events are internal protocol messages, silently ignore
+                    // These include content_block_start, content_block_delta, etc.
+                    break;
+                case 'result':
+                    // Result messages contain the final response and completion status
+                    console.log(`[ClaudePersistent] Result received, subtype=${message.subtype}, has result=${!!message.result}, has error=${message.is_error}`);
+                    console.log(`[ClaudePersistent] Result message FULL: ${JSON.stringify(message)}`);
+                    // NOTE: Do NOT send message.result to stream callback here!
+                    // The result content has already been sent via 'assistant' messages (type: 'text' blocks)
+                    // Sending it again would cause duplicate display in the UI
+                    // Only complete if we're not waiting for user input
+                    // The command completion should happen after all content is processed
+                    if (!this.isWaitingForInput) {
+                        // Complete the command with success or error based on is_error flag
+                        if (message.is_error) {
+                            this.completeCurrentCommand(false, message.result || 'Command failed');
+                        }
+                        else {
+                            this.completeCurrentCommand(true);
+                        }
+                    }
+                    else {
+                        console.log('[ClaudePersistent] Result received but waiting for input, not completing yet');
+                    }
+                    break;
+                case 'assistant':
+                    // Assistant messages contain the actual response content
+                    // They can be partial (streaming) or complete
+                    // partial=true: streaming chunk, partial=false or undefined: complete message
+                    const isPartial = message.partial === true;
+                    console.log(`[ClaudePersistent] Assistant message, partial=${isPartial}`);
+                    // Check for tool_use in the nested message.content array
+                    const contentBlocks = message.message?.content || (Array.isArray(message.content) ? message.content : null);
+                    if (contentBlocks && contentBlocks.length > 0) {
+                        for (const block of contentBlocks) {
+                            if (block.type === 'tool_use') {
+                                console.log(`[ClaudePersistent] Tool use detected: ${block.name}, id=${block.id}`);
+                                // Send structured tool use event if callback is available
+                                if (this.currentToolUseCallback) {
+                                    this.currentToolUseCallback({
+                                        name: block.name || 'unknown',
+                                        id: block.id || 'unknown',
+                                        input: block.input || {}
+                                    });
+                                }
+                                // Note: We no longer send text-based tool use separators.
+                                // Tool use is now communicated via structured events (onToolUse callback)
+                                // which are converted to Feishu Card 2.0 elements by the router.
+                                // NOTE: Do NOT emit tool:afterExecution hook here!
+                                // tool_use is just a REQUEST to execute the tool, not the actual execution result.
+                                // The tool will be executed by Claude CLI, and we'll receive the result in a 'user' message
+                                // with tool_result content. We should emit the hook when we receive tool_result.
+                            }
+                            else if (block.type === 'text' && block.text) {
+                                // Stream text content to callback for real-time display
+                                this.currentOutputBuffer.push(block.text);
+                                if (this.currentStreamCallback) {
+                                    this.currentStreamCallback(block.text);
+                                }
+                            }
+                        }
+                    }
+                    // Also handle simple string content (fallback)
+                    if (typeof message.content === 'string' && message.content) {
+                        this.currentOutputBuffer.push(message.content);
+                        if (this.currentStreamCallback) {
+                            this.currentStreamCallback(message.content);
+                        }
+                        this.startInputDetectionTimer(message.content);
+                    }
+                    // Check if this is the final message (stop_reason indicates completion)
+                    const isComplete = message.message?.stop_reason !== null && message.message?.stop_reason !== undefined;
+                    if (isComplete) {
+                        console.log(`[ClaudePersistent] Assistant message complete, stop_reason=${message.message?.stop_reason}`);
+                    }
+                    break;
+                case 'user':
+                    // User messages can contain tool_result blocks - need to process these
+                    const userTimestamp = new Date().toISOString();
+                    console.log(`[ClaudePersistent] User message at ${userTimestamp}, checking for tool_result...`);
+                    // Check if this message contains tool results
+                    const userContentBlocks = message.message?.content || (Array.isArray(message.content) ? message.content : null);
+                    if (userContentBlocks && Array.isArray(userContentBlocks)) {
+                        for (const block of userContentBlocks) {
+                            if (block.type === 'tool_result') {
+                                const isError = block.is_error === true;
+                                console.log(`[ClaudePersistent] Tool result received: tool_use_id=${block.id}, is_error=${isError}`);
+                                console.log(`[ClaudePersistent] Tool result full: ${JSON.stringify(message).substring(0, 500)}`);
+                                // Send structured tool result event if callback is available
+                                if (this.currentToolResultCallback) {
+                                    this.currentToolResultCallback({
+                                        tool_use_id: block.id || 'unknown',
+                                        content: block.content || '(no content)',
+                                        is_error: isError
+                                    });
+                                }
+                                // Note: We no longer send text-based tool result messages.
+                                // Tool results are now communicated via structured events (onToolResult callback)
+                                // which are converted to Feishu Card 2.0 elements by the router.
+                                // Emit hook for tool execution completion (this is the ACTUAL execution result)
+                                // Note: We don't have the original tool name here, but we have the tool_use_id
+                                ClaudeCodeHooks_1.claudeCodeHooks.notifyToolExecuted({
+                                    toolName: block.id || 'unknown', // Use tool_use_id as identifier
+                                    params: {}, // Original params not available in tool_result
+                                    timestamp: Date.now(),
+                                    taskId: this.currentTaskId || undefined,
+                                }, {
+                                    success: !isError,
+                                    result: block.content || '',
+                                    error: isError ? (block.content || 'Tool execution failed') : undefined,
+                                    duration: 0, // Duration not available
+                                });
+                            }
+                        }
+                    }
+                    break;
+                default:
+                    // Log unknown message types for debugging
+                    console.log('[ClaudePersistent] Unknown message type:', message.type, 'Full message:', JSON.stringify(message).substring(0, 200));
+            }
+        }
+        catch (error) {
+            // Not valid JSON, treat as plain text output
+            this.currentOutputBuffer.push(line);
+            if (this.currentStreamCallback) {
+                this.currentStreamCallback(line + '\n');
+            }
+        }
+    }
+    /**
+     * Start a timer to detect if user input is requested
+     * If no new output arrives within the timeout, check if the last output contains input request patterns
+     */
+    startInputDetectionTimer(content) {
+        // Clear any existing timer
+        if (this.inputDetectionTimer) {
+            clearTimeout(this.inputDetectionTimer);
+        }
+        this.lastOutputTime = Date.now();
+        // Set a timer to check for input request after a short delay
+        this.inputDetectionTimer = setTimeout(() => {
+            if (this.isWaitingForInput || !this.isProcessing) {
+                return;
+            }
+            const output = this.currentOutputBuffer.join('');
+            if (this.isInputRequest(output)) {
+                console.log('[ClaudePersistent] Detected input request in output');
+                this.handleInputRequest(output);
+            }
+        }, 2000); // 2 second delay to wait for more output
+    }
+    /**
+     * Handle input request by notifying user and waiting for response
+     */
+    async handleInputRequest(output) {
+        // Extract the last line or prompt from output
+        const lines = output.trim().split('\n');
+        const lastLine = lines[lines.length - 1] || 'Please provide your response';
+        // Pause processing state
+        this.isWaitingForInput = true;
+        // Notify through hooks
+        const userInput = await this.requestInteractiveInput(lastLine);
+        if (userInput !== null) {
+            this.sendInput(userInput);
+        }
+        else {
+            // User cancelled or timed out
+            console.log('[ClaudePersistent] Input request cancelled or timed out');
+            this.isWaitingForInput = false;
+        }
+    }
+    /**
+     * Check if the output indicates a request for user input
+     * This detects patterns like "Press Enter to continue", "(y/n)", etc.
+     */
+    isInputRequest(output) {
+        const inputPatterns = [
+            /\(y\/n\?*\)/i, // (y/n) or (y/n?)
+            /\[y\/n\]/i, // [y/n]
+            /press enter to continue/i, // Press Enter to continue
+            /type 'yes' to continue/i, // Type 'yes' to continue
+            /waiting for your (response|input)/i, // Waiting for response/input
+            /please confirm/i, // Please confirm
+            /do you want to/i, // Do you want to...
+            /would you like to/i, // Would you like to...
+            />\s*$/, // Prompt ending with >
+            /:\s*$/, // Prompt ending with :
+        ];
+        return inputPatterns.some(pattern => pattern.test(output));
+    }
+    /**
+     * Request user input through hooks
+     * Returns a promise that resolves when user provides input via sendInput()
+     */
+    async requestInteractiveInput(prompt) {
+        console.log('[ClaudePersistent] Requesting interactive input:', prompt);
+        this.isWaitingForInput = true;
+        // Emit hook to notify user (fire and forget)
+        ClaudeCodeHooks_1.claudeCodeHooks.requestUserInput({
+            prompt,
+            type: 'text',
+            timeout: 300000, // 5 minutes timeout for input
+        }).catch(() => {
+            // Ignore errors from notification
+        });
+        // Wait for input via sendInput() or timeout
+        return new Promise((resolve) => {
+            const timeoutId = setTimeout(() => {
+                console.log('[ClaudePersistent] Input request timed out');
+                this.isWaitingForInput = false;
+                resolve(null);
+            }, 300000); // 5 minutes timeout
+            // Store callback to be called when sendInput is invoked
+            this.inputRequestCallbacks.push((input) => {
+                clearTimeout(timeoutId);
+                resolve(input);
+            });
+        });
+    }
+    /**
+     * Send user input to the Claude process
+     * This is called by MessageHandler when user sends a message while waiting for input
+     */
+    sendInput(input) {
+        if (!this.claudeProcess || !this.isWaitingForInput) {
+            console.log('[ClaudePersistent] Cannot send input - process not running or not waiting for input');
+            return false;
+        }
+        const inputMessage = {
+            type: 'user',
+            message: {
+                role: 'user',
+                content: input,
+            },
+        };
+        const inputLine = JSON.stringify(inputMessage);
+        console.log(`[ClaudePersistent] Sending user input: ${input}`);
+        this.claudeProcess.stdin?.write(inputLine + '\n');
+        this.isWaitingForInput = false;
+        // Notify any waiting callbacks (for requestInteractiveInput)
+        for (const callback of this.inputRequestCallbacks) {
+            callback(input);
+        }
+        this.inputRequestCallbacks = [];
+        return true;
+    }
+    /**
+     * Check if currently waiting for user input
+     */
+    isWaitingInput() {
+        return this.isWaitingForInput;
+    }
+    /**
+     * Complete the current command
+     */
+    completeCurrentCommand(success, errorMessage) {
+        // Guard against double completion
+        if (!this.currentCommandResolve && !this.currentCommandReject) {
+            console.log('[ClaudePersistent] Command already completed, ignoring duplicate completion');
+            return;
+        }
+        if (this.currentTimeoutTimer) {
+            clearTimeout(this.currentTimeoutTimer);
+            this.currentTimeoutTimer = undefined;
+        }
+        const output = this.currentOutputBuffer.join('');
+        console.log(`[ClaudePersistent] Completing command, success=${success}, output length=${output.length}, output preview: ${output.substring(0, 100)}...`);
+        // Emit task completion hooks
+        if (this.currentTaskId) {
+            const endTime = Date.now();
+            const duration = endTime - this.currentTaskStartTime;
+            if (success) {
+                ClaudeCodeHooks_1.claudeCodeHooks.notifyTaskCompleted({
+                    taskId: this.currentTaskId,
+                    description: '', // Will be populated from queue if needed
+                    workingDirectory: this.currentWorkingDirectory,
+                    sessionId: this.sessionId || undefined,
+                    startTime: this.currentTaskStartTime,
+                }, {
+                    success: true,
+                    output: output.trim(),
+                    endTime,
+                    duration,
+                });
+            }
+            else {
+                ClaudeCodeHooks_1.claudeCodeHooks.notifyTaskFailed({
+                    taskId: this.currentTaskId,
+                    description: '',
+                    workingDirectory: this.currentWorkingDirectory,
+                    sessionId: this.sessionId || undefined,
+                    startTime: this.currentTaskStartTime,
+                }, new Error(errorMessage || 'Command failed'));
+            }
+        }
+        if (success && this.currentCommandResolve) {
+            // Get session abbreviation (last 8 characters of session ID)
+            const sessionAbbr = this.sessionId ? this.sessionId.slice(-8) : undefined;
+            this.currentCommandResolve({
+                success: true,
+                output: output.trim(),
+                sessionAbbr,
+            });
+        }
+        else if (this.currentCommandReject) {
+            this.currentCommandReject(new Error(errorMessage || 'Command failed'));
+        }
+        this.resetCurrentCommand();
+        // Process next command in queue
+        this.isProcessing = false;
+        this.processQueue();
+    }
+    /**
+     * Reset current command state
+     */
+    resetCurrentCommand() {
+        this.currentOutputBuffer = [];
+        this.currentStreamCallback = undefined;
+        this.currentToolUseCallback = undefined;
+        this.currentToolResultCallback = undefined;
+        this.currentCommandResolve = undefined;
+        this.currentCommandReject = undefined;
+        if (this.currentTimeoutTimer) {
+            clearTimeout(this.currentTimeoutTimer);
+            this.currentTimeoutTimer = undefined;
+        }
+        if (this.inputDetectionTimer) {
+            clearTimeout(this.inputDetectionTimer);
+            this.inputDetectionTimer = undefined;
+        }
+        this.isWaitingForInput = false;
+        // Note: currentTaskId and currentTaskStartTime are cleared separately after hooks
+    }
+    /**
+     * Process the command queue
+     */
+    processQueue() {
+        if (this.isProcessing || this.commandQueue.length === 0) {
+            return;
+        }
+        // Ensure process is running
+        if (!this.claudeProcess) {
+            this.startProcess();
+            return;
+        }
+        const command = this.commandQueue.shift();
+        if (!command) {
+            return;
+        }
+        this.isProcessing = true;
+        this.currentStreamCallback = command.options.onStream;
+        this.currentStructuredCallback = command.options.onStructuredContent;
+        this.currentToolUseCallback = command.options.onToolUse;
+        this.currentToolResultCallback = command.options.onToolResult;
+        this.currentCommandResolve = command.resolve;
+        this.currentCommandReject = command.reject;
+        // Reset structured content collection
+        this.structuredContentBlocks = [];
+        // Generate task ID and track start time for hooks
+        this.currentTaskId = `task_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+        this.currentTaskStartTime = Date.now();
+        // Emit task started hook
+        ClaudeCodeHooks_1.claudeCodeHooks.notifyTaskStarted({
+            taskId: this.currentTaskId,
+            description: command.prompt,
+            workingDirectory: this.currentWorkingDirectory,
+            sessionId: this.sessionId || undefined,
+            startTime: this.currentTaskStartTime,
+        });
+        // Set timeout (only if explicitly requested via options.timeout)
+        // Note: We don't set a default timeout because it can cause state inconsistency
+        // - the executor times out but Claude process keeps running
+        // Users can cancel long-running tasks with /abort
+        if (command.options.timeout) {
+            this.currentTimeoutTimer = setTimeout(() => {
+                console.error('[ClaudePersistent] Command timeout');
+                this.completeCurrentCommand(false, 'Execution timeout exceeded');
+            }, command.options.timeout);
+        }
+        // Send the command
+        const inputMessage = {
+            type: 'user',
+            message: {
+                role: 'user',
+                content: command.prompt,
+            },
+        };
+        const inputLine = JSON.stringify(inputMessage);
+        console.log(`[ClaudePersistent] Sending command: ${command.prompt.substring(0, 100)}...`);
+        this.claudeProcess.stdin?.write(inputLine + '\n');
+    }
+    /**
+     * Execute a command through the persistent Claude process
+     */
+    async execute(prompt, options = {}) {
+        if (this.isDestroyed) {
+            return {
+                success: false,
+                error: 'Executor has been destroyed',
+            };
+        }
+        return new Promise((resolve, reject) => {
+            // Add to queue
+            this.commandQueue.push({
+                prompt,
+                options,
+                resolve: (result) => {
+                    // Extract and save session ID if it's a new session
+                    if (!this.sessionId && result.success) {
+                        const uuidPattern = /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/gi;
+                        const matches = result.output?.match(uuidPattern);
+                        if (matches && matches.length > 0) {
+                            this.sessionId = matches[0];
+                            this.saveSessionId(this.sessionId);
+                        }
+                    }
+                    resolve(result);
+                },
+                reject,
+            });
+            // Try to process queue
+            this.processQueue();
+        });
+    }
+    /**
+     * Abort current command execution
+     * Stops the current process and rejects the pending command
+     */
+    async abort() {
+        if (!this.isProcessing && !this.isWaitingForInput) {
+            console.log('[ClaudePersistent] No command is currently executing');
+            return false;
+        }
+        // If waiting for input, cancel the input request
+        if (this.isWaitingForInput) {
+            console.log('[ClaudePersistent] Cancelling input request...');
+            this.isWaitingForInput = false;
+            if (this.inputDetectionTimer) {
+                clearTimeout(this.inputDetectionTimer);
+                this.inputDetectionTimer = undefined;
+            }
+        }
+        console.log('[ClaudePersistent] Aborting current command...');
+        // Emit task aborted hook before stopping
+        if (this.currentTaskId) {
+            ClaudeCodeHooks_1.claudeCodeHooks.notifyTaskAborted({
+                taskId: this.currentTaskId,
+                description: '',
+                workingDirectory: this.currentWorkingDirectory,
+                sessionId: this.sessionId || undefined,
+                startTime: this.currentTaskStartTime,
+            }, 'Command aborted by user via /abort');
+        }
+        // Mark as intentional stop before rejecting and stopping
+        this.isStopping = true;
+        // Reject current command if any
+        if (this.currentCommandReject) {
+            this.currentCommandReject(new Error('Command aborted by user'));
+        }
+        // Reset command state
+        this.resetCurrentCommand();
+        this.isProcessing = false;
+        this.currentTaskId = null;
+        this.currentTaskStartTime = 0;
+        // Stop the process to ensure clean state
+        await this.stopProcess();
+        console.log('[ClaudePersistent] Process stopped after abort');
+        // Clear any pending commands in queue
+        if (this.commandQueue.length > 0) {
+            console.log(`[ClaudePersistent] Clearing ${this.commandQueue.length} pending commands from queue`);
+            for (const command of this.commandQueue) {
+                command.reject(new Error('Command aborted by user'));
+            }
+            this.commandQueue = [];
+        }
+        return true;
+    }
+    /**
+     * Reset execution context
+     */
+    resetContext() {
+        console.log('[ClaudePersistent] Resetting session context');
+        this.sessionId = null;
+        // Stop current process
+        this.stopProcess();
+        // Clear queue
+        this.commandQueue = [];
+        this.resetCurrentCommand();
+        this.isProcessing = false;
+        // Remove session file
+        try {
+            if (fs_1.default.existsSync(this.sessionFilePath)) {
+                fs_1.default.unlinkSync(this.sessionFilePath);
+                console.log('[ClaudePersistent] Session file removed');
+            }
+        }
+        catch (error) {
+            console.error('[ClaudePersistent] Failed to remove session file:', error);
+        }
+    }
+    /**
+     * Destroy executor and cleanup
+     */
+    async destroy() {
+        this.isDestroyed = true;
+        // Clear queue and reject pending commands
+        for (const command of this.commandQueue) {
+            command.reject(new Error('Executor has been destroyed'));
+        }
+        this.commandQueue = [];
+        if (this.currentCommandReject) {
+            this.currentCommandReject(new Error('Executor has been destroyed'));
+            this.resetCurrentCommand();
+        }
+        // Stop process
+        await this.stopProcess();
+        // Remove all listeners
+        this.removeAllListeners();
+    }
+    /**
+     * Check if process is running
+     */
+    isProcessRunning() {
+        return this.claudeProcess !== null && !this.claudeProcess.killed;
+    }
+    /**
+     * Get current session ID
+     */
+    getSessionId() {
+        return this.sessionId;
+    }
+}
+exports.ClaudePersistentExecutor = ClaudePersistentExecutor;
+//# sourceMappingURL=ClaudePersistentExecutor.js.map