forkoff 1.0.0

package/dist/tools/claude-process.js

@@ -0,0 +1,931 @@
+"use strict";
+/**
+ * Claude Process Manager
+ * Spawns and manages Claude CLI processes for terminal sessions
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.claudeProcessManager = void 0;
+const cross_spawn_1 = __importDefault(require("cross-spawn"));
+const events_1 = require("events");
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+/**
+ * Regular expression patterns used to detect approval prompts in Claude CLI output.
+ * When any of these patterns match the output, an approval request is triggered
+ * and sent to the mobile app for user confirmation.
+ *
+ * Supported patterns include:
+ * - [y]es, [n]o, [p]lan format (bracketed option letters)
+ * - (y/n) format (parenthetical yes/no)
+ * - Various question phrases like "Do you want to proceed?", "Allow this action?", etc.
+ *
+ * @constant {RegExp[]}
+ */
+const APPROVAL_PATTERNS = [
+    /\[y\]es.*\[n\]o/i, // [y]es, [n]o, [p]lan format
+    /\(y\/n\)/i, // (y/n) format
+    /do you want to proceed/i, // Do you want to proceed?
+    /allow this action/i, // Allow this action?
+    /continue\?/i, // Continue?
+    /approve this/i, // Approve this?
+];
+/**
+ * Extracts available approval options from a prompt text.
+ *
+ * Parses the approval prompt to identify available response options.
+ * For bracketed format prompts like "[y]es, [n]o, [p]lan", it extracts
+ * each option as "key:label" pairs (e.g., "y:yes", "n:no", "p:plan").
+ *
+ * @param {string} text - The prompt text to parse for options
+ * @returns {string[]} Array of option strings in "key:label" format.
+ *                     Returns ['y:yes', 'n:no'] as default if no specific options are found.
+ *
+ * @example
+ * // Bracketed format
+ * extractApprovalOptions("[y]es, [n]o, [p]lan");
+ * // Returns: ['y:yes', 'n:no', 'p:plan']
+ *
+ * @example
+ * // Default fallback
+ * extractApprovalOptions("Continue? (y/n)");
+ * // Returns: ['y:yes', 'n:no']
+ */
+function extractApprovalOptions(text) {
+    // Skip JSON content - only parse plain text prompts
+    if (text.trim().startsWith('{') || text.trim().startsWith('[')) {
+        // For SDK JSON output, default to standard options
+        return ['y:yes', 'n:no', 'p:plan'];
+    }
+    // Check for [y]es, [n]o, [p]lan format in plain text
+    const bracketMatch = text.match(/\[([ynpae])\][a-z]+/gi);
+    if (bracketMatch && bracketMatch.length >= 2 && bracketMatch.length <= 4) {
+        return bracketMatch.map(m => {
+            const key = m.match(/\[([a-z])\]/i)?.[1]?.toLowerCase() || '';
+            const full = m.replace(/\[|\]/g, '');
+            return `${key}:${full}`;
+        });
+    }
+    // Default yes/no/plan
+    return ['y:yes', 'n:no', 'p:plan'];
+}
+class ClaudeProcessManager extends events_1.EventEmitter {
+    constructor() {
+        super(...arguments);
+        this.processes = new Map();
+        this.pendingApprovals = new Map();
+        this.APPROVAL_TIMEOUT_MS = 5 * 60 * 1000; // 5 minutes
+        this.MAX_OUTPUT_BUFFER_LINES = 20;
+        /** Track closed sessions for auto-restart */
+        this.closedSessions = new Map();
+        /** Maximum number of auto-restarts per session to prevent chaos */
+        this.MAX_AUTO_RESTARTS = 3;
+    }
+    /** Type-safe emit for known events */
+    emit(event, ...args) {
+        return super.emit(event, ...args);
+    }
+    /** Type-safe on for known events */
+    on(event, listener) {
+        return super.on(event, listener);
+    }
+    /**
+     * Start a new Claude session in the specified directory
+     */
+    async startSession(directory, terminalSessionId) {
+        const resolvedDir = this.resolvePath(directory);
+        // SDK flags for structured JSON communication
+        const args = [
+            '--output-format', 'stream-json', // JSONL output from Claude
+            '--input-format', 'stream-json', // JSONL input to Claude
+            '--verbose', // Complete messages
+            // '--permission-mode' removed - using default mode for tool execution
+        ];
+        // SECURITY: Using cross-spawn instead of shell: true to prevent command injection
+        const proc = (0, cross_spawn_1.default)('claude', args, {
+            cwd: resolvedDir,
+            env: { ...process.env, TERM: 'xterm-256color' },
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        this.setupProcessHandlers(terminalSessionId, proc, resolvedDir);
+        this.processes.set(terminalSessionId, { terminalSessionId, process: proc, directory: resolvedDir, outputBuffer: [], wasAutoRestarted: false });
+        return { cwd: resolvedDir };
+    }
+    /**
+     * Resume an existing Claude session
+     */
+    async resumeSession(sessionKey, directory, terminalSessionId) {
+        const resolvedDir = this.resolvePath(directory);
+        // SDK flags for structured JSON communication
+        // When resuming from mobile, use acceptEdits to auto-approve file operations
+        // This is necessary because SDK JSON streaming mode interprets raw 'y' input
+        // as a user message rather than a permission approval
+        const args = [
+            '--resume', sessionKey, // Pass session key to --resume!
+            '--output-format', 'stream-json', // JSONL output from Claude
+            '--input-format', 'stream-json', // JSONL input to Claude
+            '--verbose', // Complete messages
+            '--permission-mode', 'acceptEdits', // Auto-approve edits when controlled from mobile
+        ];
+        console.log(`[Claude Process] Spawning: claude ${args.join(' ')}`);
+        // SECURITY: Using cross-spawn instead of shell: true to prevent command injection
+        const proc = (0, cross_spawn_1.default)('claude', args, {
+            cwd: resolvedDir,
+            env: { ...process.env, TERM: 'xterm-256color' },
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        this.setupProcessHandlers(terminalSessionId, proc, resolvedDir, sessionKey);
+        this.processes.set(terminalSessionId, { terminalSessionId, process: proc, directory: resolvedDir, sessionKey, outputBuffer: [], wasAutoRestarted: false });
+        // Store session info for future message sends (needed since we spawn fresh process per message)
+        this.closedSessions.set(terminalSessionId, {
+            sessionKey,
+            directory: resolvedDir,
+            lastExitCode: 0,
+            lastExitTime: Date.now(),
+            restartCount: 0,
+        });
+        return { cwd: resolvedDir };
+    }
+    /**
+     * Send input to a Claude process in JSONL format
+     * Format: {"type":"user","message":{"role":"user","content":"..."}}
+     *
+     * IMPORTANT: Claude SDK with --resume and streaming JSON only supports ONE turn per process.
+     * So we kill any existing process and spawn a fresh one for each message.
+     * Since we use --resume, the conversation history is preserved.
+     */
+    async sendInput(terminalSessionId, input) {
+        let info = this.processes.get(terminalSessionId);
+        const restartInfo = this.closedSessions.get(terminalSessionId);
+        // If there's an existing process, kill it first (Claude SDK only supports 1 turn per process)
+        if (info?.process && info.process.exitCode === null) {
+            console.log(`[Claude Process] Killing existing process for new message (SDK limitation: 1 turn per process)`);
+            info.process.kill('SIGTERM');
+            // Wait for process to die
+            await new Promise(resolve => setTimeout(resolve, 200));
+            this.processes.delete(terminalSessionId);
+            info = undefined;
+        }
+        // Get session info from either current process or closed sessions
+        const sessionKey = info?.sessionKey || restartInfo?.sessionKey;
+        const directory = info?.directory || restartInfo?.directory;
+        if (!sessionKey || !directory) {
+            console.log(`[Claude Process] No session info found for ${terminalSessionId}`);
+            return false;
+        }
+        // Spawn a fresh Claude process for this message
+        // IMPORTANT: We must write to stdin immediately after spawn - Claude CLI with
+        // stream-json input format exits if it doesn't receive input quickly
+        console.log(`[Claude Process] Spawning fresh process for message (--resume preserves history)`);
+        // Format as JSONL user message (SDK format)
+        const message = {
+            type: 'user',
+            message: {
+                role: 'user',
+                content: input.replace(/\n$/, ''), // Remove trailing newline from input
+            },
+        };
+        const jsonLine = JSON.stringify(message) + '\n';
+        try {
+            await this.resumeSession(sessionKey, directory, terminalSessionId);
+            info = this.processes.get(terminalSessionId);
+        }
+        catch (err) {
+            console.error(`[Claude Process] Failed to spawn process:`, err.message);
+            return false;
+        }
+        if (!info?.process) {
+            console.log(`[Claude Process] Failed to get process after spawn for ${terminalSessionId}`);
+            return false;
+        }
+        if (!info.process.stdin || info.process.stdin.destroyed) {
+            console.log(`[Claude Process] stdin is closed or destroyed for ${terminalSessionId}`);
+            return false;
+        }
+        // Write message to stdin IMMEDIATELY - no waiting
+        console.log(`[Claude Process] Sending JSONL immediately: ${jsonLine.substring(0, 100)}...`);
+        return new Promise((resolve) => {
+            try {
+                info.process.stdin.write(jsonLine, (err) => {
+                    if (err) {
+                        console.error(`[Claude Process] Error writing to stdin for ${terminalSessionId}:`, err.message);
+                        resolve(false);
+                    }
+                    else {
+                        console.log(`[Claude Process] Message written to stdin successfully`);
+                        resolve(true);
+                    }
+                });
+            }
+            catch (err) {
+                console.error(`[Claude Process] Exception writing to stdin for ${terminalSessionId}:`, err.message);
+                resolve(false);
+            }
+        });
+    }
+    /**
+     * Check if a session is a Claude session (active or restartable)
+     */
+    isClaudeSession(terminalSessionId) {
+        return this.processes.has(terminalSessionId) || this.closedSessions.has(terminalSessionId);
+    }
+    /**
+     * Register session info without spawning a process.
+     * Used when mobile opens a session view - we store the info so we can spawn later on first message.
+     */
+    registerSession(sessionKey, directory, terminalSessionId) {
+        console.log(`[Claude Process] Registering session: ${sessionKey} in ${directory}`);
+        this.closedSessions.set(terminalSessionId, {
+            sessionKey,
+            directory,
+            lastExitCode: 0,
+            lastExitTime: Date.now(),
+            restartCount: 0,
+        });
+    }
+    /**
+     * Set up event handlers for the spawned process
+     */
+    setupProcessHandlers(terminalSessionId, proc, directory, sessionKey) {
+        // Buffer for incomplete JSONL lines
+        let jsonLineBuffer = '';
+        proc.stdout?.on('data', (data) => {
+            const rawOutput = data.toString();
+            jsonLineBuffer += rawOutput;
+            // Update output buffer for approval context
+            const processInfo = this.processes.get(terminalSessionId);
+            if (processInfo) {
+                // Add new lines to buffer, keeping last N lines
+                const newLines = rawOutput.split('\n').filter(l => l.trim());
+                processInfo.outputBuffer.push(...newLines);
+                if (processInfo.outputBuffer.length > this.MAX_OUTPUT_BUFFER_LINES) {
+                    processInfo.outputBuffer = processInfo.outputBuffer.slice(-this.MAX_OUTPUT_BUFFER_LINES);
+                }
+                // Check for approval patterns in the raw output
+                this.checkForApprovalPattern(terminalSessionId, rawOutput, processInfo);
+            }
+            // Process complete JSONL lines
+            const lines = jsonLineBuffer.split('\n');
+            jsonLineBuffer = lines.pop() || ''; // Keep incomplete line in buffer
+            for (const line of lines) {
+                if (line.trim()) {
+                    try {
+                        const message = JSON.parse(line);
+                        // Emit parsed SDK message for status tracking
+                        this.emit('sdk_message', { terminalSessionId, message });
+                        // Log SDK message type for debugging
+                        if (message.type) {
+                            console.log(`[Claude Process] SDK message: ${message.type}${message.subtype ? '/' + message.subtype : ''}`);
+                            // Log when we receive a result message (end of turn)
+                            if (message.type === 'result') {
+                                console.log(`[Claude Process] Received result message - turn complete. Subtype: ${message.subtype}, Cost: $${message.cost_usd || 'unknown'}`);
+                                if (message.is_error) {
+                                    console.log(`[Claude Process] Result indicates error: ${JSON.stringify(message.error || 'unknown')}`);
+                                }
+                            }
+                        }
+                        // Detect tool_use in SDK messages and emit approval request
+                        if (processInfo) {
+                            this.checkForToolUseInSdkMessage(terminalSessionId, message, processInfo);
+                        }
+                        // Parse thinking content from content_block_delta with thinking type
+                        this.parseThinkingContent(terminalSessionId, message, sessionKey);
+                        // Parse token usage from message_delta
+                        this.parseTokenUsage(terminalSessionId, message, sessionKey);
+                        // Parse task progress from TaskCreate/TaskUpdate/TaskList tool_use
+                        this.parseTaskProgress(terminalSessionId, message, sessionKey);
+                    }
+                    catch (e) {
+                        // Non-JSON output (shouldn't happen with SDK flags, but log it)
+                        console.log(`[Claude Process] Non-JSON stdout: ${line.substring(0, 50)}...`);
+                    }
+                }
+            }
+            // Keep raw output emission for terminal display
+            const output = {
+                terminalSessionId,
+                output: rawOutput,
+                type: 'stdout',
+            };
+            this.emit('output', output);
+        });
+        proc.stderr?.on('data', (data) => {
+            const output = {
+                terminalSessionId,
+                output: data.toString(),
+                type: 'stderr',
+            };
+            this.emit('output', output);
+        });
+        proc.on('close', (code) => {
+            const exitCode = code ?? 0;
+            console.log(`[Claude Process] Process closed for ${terminalSessionId}, exit code: ${exitCode}`);
+            // Store session info for potential restart
+            // Get process info before we delete it
+            const processInfo = this.processes.get(terminalSessionId);
+            const existingInfo = this.closedSessions.get(terminalSessionId);
+            // Only preserve restart count if this was an auto-restarted session
+            // Otherwise reset to 0 (user explicitly started a new session)
+            const restartCount = processInfo?.wasAutoRestarted
+                ? (existingInfo?.restartCount ?? 0)
+                : 0;
+            this.closedSessions.set(terminalSessionId, {
+                sessionKey,
+                directory,
+                lastExitCode: exitCode,
+                lastExitTime: Date.now(),
+                restartCount,
+            });
+            // Emit exit event
+            const exitOutput = {
+                terminalSessionId,
+                output: '',
+                type: 'exit',
+                exitCode,
+            };
+            this.emit('output', exitOutput);
+            // Emit session ended event
+            const endedEvent = {
+                terminalSessionId,
+                directory,
+                sessionKey,
+                exitCode,
+            };
+            this.emit('session_ended', endedEvent);
+            // Clean up
+            this.processes.delete(terminalSessionId);
+        });
+        proc.on('error', (error) => {
+            console.error(`[Claude Process] Error for ${terminalSessionId}:`, error.message);
+            const output = {
+                terminalSessionId,
+                output: `Error: ${error.message}\n`,
+                type: 'stderr',
+            };
+            this.emit('output', output);
+        });
+    }
+    /**
+     * Resolve path (handle ~ for home directory)
+     * SECURITY: Validates path doesn't contain dangerous characters
+     */
+    resolvePath(dir) {
+        // SECURITY: Reject paths with shell metacharacters that could be dangerous
+        if (/[;&|`$()<>]/.test(dir)) {
+            throw new Error('Invalid directory path: contains disallowed characters');
+        }
+        if (dir === '~' || dir.startsWith('~/')) {
+            return dir === '~' ? os.homedir() : dir.replace('~', os.homedir());
+        }
+        return path.resolve(dir);
+    }
+    /**
+     * Kill a Claude process
+     */
+    killProcess(terminalSessionId) {
+        const info = this.processes.get(terminalSessionId);
+        if (info?.process) {
+            info.process.kill('SIGTERM');
+        }
+    }
+    /**
+     * Get all active process IDs
+     */
+    getActiveProcessIds() {
+        return Array.from(this.processes.keys());
+    }
+    /**
+     * Get all active sessions with their details
+     */
+    getActiveSessions() {
+        return Array.from(this.processes.values()).map(info => ({
+            terminalSessionId: info.terminalSessionId,
+            sessionKey: info.sessionKey,
+            directory: info.directory,
+        }));
+    }
+    /**
+     * Clean up old closed session entries to prevent memory leaks.
+     * Sessions older than 1 hour are removed.
+     */
+    cleanupOldClosedSessions() {
+        const ONE_HOUR_MS = 60 * 60 * 1000;
+        const now = Date.now();
+        let cleanedCount = 0;
+        for (const [sessionId, info] of this.closedSessions.entries()) {
+            if (now - info.lastExitTime > ONE_HOUR_MS) {
+                this.closedSessions.delete(sessionId);
+                cleanedCount++;
+            }
+        }
+        if (cleanedCount > 0) {
+            console.log(`[Claude Process] Cleaned up ${cleanedCount} old closed session(s)`);
+        }
+    }
+    /**
+     * Clear restart counter for a session, allowing fresh restarts.
+     * Useful when user explicitly wants to reset.
+     */
+    clearRestartCounter(terminalSessionId) {
+        const info = this.closedSessions.get(terminalSessionId);
+        if (info) {
+            info.restartCount = 0;
+            console.log(`[Claude Process] Restart counter cleared for ${terminalSessionId}`);
+        }
+    }
+    /**
+     * Checks Claude CLI output for approval patterns and emits approval request events.
+     *
+     * Scans the output against all patterns in APPROVAL_PATTERNS. When a match is found,
+     * creates a unique approval ID, sets up a timeout for auto-denial, and emits a
+     * 'claude_approval_request' event with the approval details.
+     *
+     * Prevents duplicate approvals for the same terminal session.
+     *
+     * @param {string} terminalSessionId - The terminal session ID producing the output
+     * @param {string} output - Raw output text from the Claude CLI process
+     * @param {ClaudeProcessInfo} processInfo - Process information including output buffer
+     * @fires ClaudeProcessManager#claude_approval_request
+     * @private
+     */
+    checkForApprovalPattern(terminalSessionId, output, processInfo) {
+        // Check if output matches any approval pattern
+        const matchedPattern = APPROVAL_PATTERNS.find(pattern => pattern.test(output));
+        if (!matchedPattern)
+            return;
+        // Don't create duplicate approvals
+        for (const pending of this.pendingApprovals.values()) {
+            if (pending.terminalSessionId === terminalSessionId) {
+                console.log(`[Claude Process] Approval already pending for ${terminalSessionId}`);
+                return;
+            }
+        }
+        const approvalId = `approval-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+        const options = extractApprovalOptions(output);
+        console.log(`[Claude Process] Approval pattern detected: ${matchedPattern.toString()}`);
+        console.log(`[Claude Process] Options: ${options.join(', ')}`);
+        // Set up timeout for auto-deny
+        const timeoutId = setTimeout(() => {
+            this.handleApprovalTimeout(approvalId);
+        }, this.APPROVAL_TIMEOUT_MS);
+        // Track pending approval
+        this.pendingApprovals.set(approvalId, {
+            approvalId,
+            terminalSessionId,
+            createdAt: Date.now(),
+            timeoutId,
+        });
+        // Extract human-readable prompt from SDK JSON output
+        let promptText = output.trim();
+        let toolName = '';
+        let toolInput = '';
+        // Try to parse as JSON and extract meaningful content
+        try {
+            const lines = output.split('\n').filter(l => l.trim());
+            for (const line of lines) {
+                try {
+                    const json = JSON.parse(line);
+                    // Check for tool_use in message content
+                    if (json.message?.content) {
+                        const content = Array.isArray(json.message.content) ? json.message.content : [json.message.content];
+                        for (const block of content) {
+                            if (block.type === 'tool_use') {
+                                toolName = block.name || 'Unknown tool';
+                                toolInput = typeof block.input === 'string' ? block.input : JSON.stringify(block.input, null, 2);
+                                promptText = `Claude wants to use: ${toolName}`;
+                                break;
+                            }
+                            else if (typeof block === 'string' && block.includes('[y]es')) {
+                                promptText = block;
+                                break;
+                            }
+                            else if (block.text && block.text.includes('[y]es')) {
+                                promptText = block.text;
+                                break;
+                            }
+                        }
+                    }
+                }
+                catch (e) {
+                    // Not JSON, might be text prompt
+                    if (line.includes('[y]es') || line.includes('(y/n)')) {
+                        promptText = line;
+                        break;
+                    }
+                }
+            }
+        }
+        catch (e) {
+            // Keep original output
+        }
+        // Build context with tool details if available
+        const context = [...processInfo.outputBuffer];
+        if (toolInput && toolInput.length > 0) {
+            context.push(`Tool: ${toolName}`);
+            context.push(`Input: ${toolInput.substring(0, 500)}${toolInput.length > 500 ? '...' : ''}`);
+        }
+        // Emit approval request event
+        const approvalRequest = {
+            approvalId,
+            terminalSessionId,
+            sessionKey: processInfo.sessionKey,
+            context,
+            options,
+            promptText,
+        };
+        this.emit('claude_approval_request', approvalRequest);
+        console.log(`[Claude Process] Emitted claude_approval_request: ${approvalId}, promptText: ${promptText.substring(0, 50)}...`);
+    }
+    /**
+     * Checks SDK messages for tool_use content and emits approval notifications.
+     *
+     * In SDK mode, Claude doesn't emit text approval prompts. Instead, we detect
+     * tool_use in the SDK messages and emit approval notifications so the mobile
+     * app can display what Claude is doing. Note: This is a notification, not
+     * a blocking approval - the tool may already be executed by the time the
+     * user sees this.
+     *
+     * @param {string} terminalSessionId - The terminal session ID
+     * @param {any} message - The parsed SDK JSON message
+     * @param {ClaudeProcessInfo} processInfo - Process info for context
+     * @private
+     */
+    checkForToolUseInSdkMessage(terminalSessionId, message, processInfo) {
+        // Only check assistant messages with content
+        if (message.type !== 'assistant') {
+            return;
+        }
+        // Debug: log the message structure
+        console.log(`[Claude Process] Checking assistant message for tool_use...`);
+        if (!message.message?.content) {
+            console.log(`[Claude Process] No message.content found in assistant message`);
+            return;
+        }
+        const content = Array.isArray(message.message.content)
+            ? message.message.content
+            : [message.message.content];
+        // Find tool_use blocks
+        for (const block of content) {
+            if (block.type === 'tool_use') {
+                const toolName = block.name || 'Unknown tool';
+                const toolId = block.id || '';
+                const toolInput = block.input || {};
+                // Check if we already have a pending approval for this terminal
+                let alreadyPending = false;
+                for (const pending of this.pendingApprovals.values()) {
+                    if (pending.terminalSessionId === terminalSessionId) {
+                        alreadyPending = true;
+                        break;
+                    }
+                }
+                if (alreadyPending) {
+                    console.log(`[Claude Process] Tool use detected but approval already pending for ${terminalSessionId}`);
+                    continue;
+                }
+                // Create approval notification
+                const approvalId = `tool-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+                // Format input for display
+                let inputSummary = '';
+                if (typeof toolInput === 'object') {
+                    if (toolInput.file_path) {
+                        inputSummary = `File: ${toolInput.file_path}`;
+                    }
+                    else if (toolInput.command) {
+                        inputSummary = `Command: ${toolInput.command.substring(0, 100)}`;
+                    }
+                    else if (toolInput.pattern) {
+                        inputSummary = `Pattern: ${toolInput.pattern}`;
+                    }
+                    else {
+                        inputSummary = JSON.stringify(toolInput).substring(0, 200);
+                    }
+                }
+                const promptText = `Claude is using: ${toolName}`;
+                const context = inputSummary ? [inputSummary, ...processInfo.outputBuffer.slice(-5)] : processInfo.outputBuffer.slice(-10);
+                console.log(`[Claude Process] Tool use detected: ${toolName} (${toolId})`);
+                console.log(`[Claude Process] Input summary: ${inputSummary.substring(0, 100)}`);
+                // Set up timeout (5 minutes to match original plan)
+                const timeoutId = setTimeout(() => {
+                    console.log(`[Claude Process] Tool approval timeout: ${approvalId}`);
+                    this.pendingApprovals.delete(approvalId);
+                }, 300000); // 5 minute timeout for tool notifications
+                // Track this notification
+                this.pendingApprovals.set(approvalId, {
+                    approvalId,
+                    terminalSessionId,
+                    createdAt: Date.now(),
+                    timeoutId,
+                });
+                // Emit notification to mobile
+                const approvalRequest = {
+                    approvalId,
+                    terminalSessionId,
+                    sessionKey: processInfo.sessionKey,
+                    context,
+                    options: ['y:yes', 'n:no', 'p:plan'], // Standard options
+                    promptText,
+                };
+                this.emit('claude_approval_request', approvalRequest);
+                console.log(`[Claude Process] Emitted tool_use notification: ${approvalId}, tool: ${toolName}`);
+            }
+        }
+    }
+    /**
+     * Handles approval request timeout by automatically denying the request.
+     *
+     * Called when the approval timeout (APPROVAL_TIMEOUT_MS) expires without
+     * receiving a user response. Automatically sends 'n' (no/deny) to the
+     * Claude CLI process to prevent indefinite blocking.
+     *
+     * @param {string} approvalId - The unique identifier of the timed-out approval
+     * @private
+     */
+    handleApprovalTimeout(approvalId) {
+        const pending = this.pendingApprovals.get(approvalId);
+        if (!pending)
+            return;
+        console.log(`[Claude Process] Approval timeout for ${approvalId}, auto-denying`);
+        this.handleApprovalResponse(approvalId, 'n'); // Auto-deny with 'n'
+    }
+    /**
+     * Handles an approval response received from the mobile app.
+     *
+     * Processes the user's response to an approval request by:
+     * 1. Looking up the pending approval by ID
+     * 2. Clearing the auto-deny timeout
+     * 3. Writing the response character (e.g., 'y', 'n', 'p') to the Claude CLI stdin
+     *
+     * @param {string} approvalId - The unique identifier of the approval being responded to
+     * @param {string} response - The user's response (first character will be sent to stdin)
+     * @public
+     */
+    handleApprovalResponse(approvalId, response) {
+        const pending = this.pendingApprovals.get(approvalId);
+        if (!pending) {
+            console.log(`[Claude Process] No pending approval found for ${approvalId}`);
+            return;
+        }
+        // Clear timeout
+        clearTimeout(pending.timeoutId);
+        this.pendingApprovals.delete(approvalId);
+        // Get process and write response to stdin
+        const processInfo = this.processes.get(pending.terminalSessionId);
+        if (!processInfo?.process) {
+            console.log(`[Claude Process] No process for ${pending.terminalSessionId}`);
+            return;
+        }
+        // Check if process has exited
+        if (processInfo.process.exitCode !== null) {
+            console.log(`[Claude Process] Process already exited for ${pending.terminalSessionId} (exit code: ${processInfo.process.exitCode}), cannot send approval response`);
+            return;
+        }
+        if (!processInfo.process.stdin || processInfo.process.stdin.destroyed) {
+            console.log(`[Claude Process] stdin is closed or destroyed for ${pending.terminalSessionId}, cannot send approval response`);
+            return;
+        }
+        // Write the response character to stdin (e.g., 'y', 'n', 'p')
+        const char = response.charAt(0).toLowerCase();
+        console.log(`[Claude Process] Writing response '${char}' to stdin for ${pending.terminalSessionId}`);
+        try {
+            processInfo.process.stdin.write(char, (err) => {
+                if (err) {
+                    console.error(`[Claude Process] Error writing approval response to stdin for ${pending.terminalSessionId}:`, err.message);
+                }
+            });
+        }
+        catch (err) {
+            console.error(`[Claude Process] Exception writing approval response to stdin for ${pending.terminalSessionId}:`, err.message);
+        }
+    }
+    /**
+     * Retrieves a pending approval request for a specific terminal session.
+     *
+     * Searches through all pending approvals to find one matching the given
+     * terminal session ID. Useful for checking if there's an active approval
+     * request for a session before creating a new one.
+     *
+     * @param {string} terminalSessionId - The terminal session ID to search for
+     * @returns {PendingApproval | undefined} The pending approval if found, undefined otherwise
+     * @public
+     */
+    getPendingApproval(terminalSessionId) {
+        for (const pending of this.pendingApprovals.values()) {
+            if (pending.terminalSessionId === terminalSessionId) {
+                return pending;
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Parse thinking content from SDK messages.
+     * Claude SDK emits content_block_delta with type 'thinking' for extended thinking.
+     */
+    parseThinkingContent(terminalSessionId, message, sessionKey) {
+        // Check for content_block_delta with thinking type
+        if (message.type === 'content_block_delta' && message.delta?.type === 'thinking_delta') {
+            const thinkingId = message.index?.toString() || `thinking-${Date.now()}`;
+            const content = message.delta?.thinking || '';
+            this.emit('thinking_content', {
+                terminalSessionId,
+                sessionKey,
+                thinkingId,
+                content,
+                partial: true,
+            });
+            return;
+        }
+        // Check for content_block_stop to mark thinking complete
+        if (message.type === 'content_block_stop') {
+            const processInfo = this.processes.get(terminalSessionId);
+            // Check if this was a thinking block by looking at recent messages
+            // The SDK sends content_block_start before deltas, so we track by index
+            const thinkingId = message.index?.toString() || '';
+            if (thinkingId) {
+                this.emit('thinking_content', {
+                    terminalSessionId,
+                    sessionKey,
+                    thinkingId,
+                    content: '',
+                    partial: false,
+                });
+            }
+        }
+        // Also check for thinking in assistant message content array
+        if (message.type === 'assistant' && message.message?.content) {
+            const content = Array.isArray(message.message.content)
+                ? message.message.content
+                : [message.message.content];
+            for (const block of content) {
+                if (block.type === 'thinking' && block.thinking) {
+                    this.emit('thinking_content', {
+                        terminalSessionId,
+                        sessionKey,
+                        thinkingId: `msg-${message.message?.id || Date.now()}`,
+                        content: block.thinking,
+                        partial: false,
+                    });
+                }
+            }
+        }
+    }
+    /**
+     * Parse token usage from SDK messages.
+     * Claude SDK emits message_delta with usage field containing token counts.
+     */
+    parseTokenUsage(terminalSessionId, message, sessionKey) {
+        // Check for message_delta with usage
+        if (message.type === 'message_delta' && message.usage) {
+            const usage = message.usage;
+            if (usage.input_tokens !== undefined || usage.output_tokens !== undefined) {
+                this.emit('token_usage', {
+                    terminalSessionId,
+                    sessionKey,
+                    usage: {
+                        inputTokens: usage.input_tokens || 0,
+                        outputTokens: usage.output_tokens || 0,
+                    },
+                });
+            }
+            return;
+        }
+        // Also check for usage in result messages (end of conversation turn)
+        if (message.type === 'result' && message.usage) {
+            const usage = message.usage;
+            this.emit('token_usage', {
+                terminalSessionId,
+                sessionKey,
+                usage: {
+                    inputTokens: usage.input_tokens || 0,
+                    outputTokens: usage.output_tokens || 0,
+                },
+            });
+        }
+    }
+    /**
+     * Parse task progress from SDK messages.
+     * Detects TaskCreate, TaskUpdate, TaskList tool uses and extracts task data.
+     */
+    parseTaskProgress(terminalSessionId, message, sessionKey) {
+        // Only process assistant messages with tool_use
+        if (message.type !== 'assistant')
+            return;
+        const content = message.message?.content;
+        if (!content)
+            return;
+        const contentArray = Array.isArray(content) ? content : [content];
+        for (const block of contentArray) {
+            if (block.type !== 'tool_use')
+                continue;
+            const toolName = block.name?.toLowerCase();
+            if (!toolName)
+                continue;
+            // Handle TaskCreate
+            if (toolName === 'taskcreate') {
+                const input = block.input || {};
+                const task = {
+                    id: block.id || `task-${Date.now()}`,
+                    subject: input.subject || 'New Task',
+                    status: 'pending',
+                    activeForm: input.activeForm,
+                };
+                console.log(`[Claude Process] Task created: ${task.subject}`);
+                this.emit('task_progress', {
+                    terminalSessionId,
+                    sessionKey,
+                    type: 'created',
+                    task,
+                });
+            }
+            // Handle TaskUpdate
+            if (toolName === 'taskupdate') {
+                const input = block.input || {};
+                const task = {
+                    id: input.taskId || block.id || '',
+                    subject: input.subject || '',
+                    status: input.status || 'pending',
+                    activeForm: input.activeForm,
+                };
+                const eventType = task.status === 'completed' ? 'completed' : 'updated';
+                console.log(`[Claude Process] Task ${eventType}: ${task.id} -> ${task.status}`);
+                this.emit('task_progress', {
+                    terminalSessionId,
+                    sessionKey,
+                    type: eventType,
+                    task,
+                });
+            }
+            // Handle TaskList (tool result contains the list)
+            if (toolName === 'tasklist') {
+                console.log(`[Claude Process] Task list requested`);
+                // TaskList doesn't have task data in tool_use, only in tool_result
+                // We'll emit a list event when we see the result
+            }
+        }
+        // Also check for tool_result from TaskList
+        if (message.type === 'tool_result') {
+            const toolName = message.tool_name?.toLowerCase();
+            if (toolName === 'tasklist' && message.content) {
+                try {
+                    // TaskList result might be JSON array of tasks
+                    const tasks = typeof message.content === 'string'
+                        ? JSON.parse(message.content)
+                        : message.content;
+                    if (Array.isArray(tasks)) {
+                        this.emit('task_progress', {
+                            terminalSessionId,
+                            sessionKey,
+                            type: 'list',
+                            tasks: tasks.map((t) => ({
+                                id: t.id || '',
+                                subject: t.subject || '',
+                                status: t.status || 'pending',
+                                activeForm: t.activeForm,
+                            })),
+                        });
+                    }
+                }
+                catch (e) {
+                    // Not JSON, ignore
+                }
+            }
+        }
+    }
+}
+exports.claudeProcessManager = new ClaudeProcessManager();
+exports.default = exports.claudeProcessManager;
+//# sourceMappingURL=claude-process.js.map