claudia-orchestrator 0.1.0

package/dist/services/claude-process-manager.js

@@ -0,0 +1,909 @@
+import * as pty from 'node-pty';
+import { CUIError } from '../types/index.js';
+import { v4 as uuidv4 } from 'uuid';
+import { EventEmitter } from 'events';
+import { existsSync, readFileSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+import os from 'os';
+import { JsonLinesParser } from './json-lines-parser.js';
+import { createLogger } from './logger.js';
+import path from 'path';
+/**
+ * Expand tilde (~) in paths to the user's home directory.
+ * Node.js spawn doesn't expand ~ like shells do, causing ENOENT errors.
+ */
+function expandTilde(filePath) {
+    if (filePath === '~' || filePath.startsWith('~/')) {
+        return path.join(os.homedir(), filePath.slice(1));
+    }
+    return filePath;
+}
+// Get the directory of this module
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+/**
+ * Manages Claude CLI processes and their lifecycle
+ */
+export class ClaudeProcessManager extends EventEmitter {
+    processes = new Map();
+    outputBuffers = new Map();
+    timeouts = new Map();
+    conversationConfigs = new Map();
+    sessionIds = new Map(); // streamingId -> claude session_id
+    claudeExecutablePath;
+    logger;
+    envOverrides;
+    historyReader;
+    mcpConfigPath;
+    statusTracker;
+    conversationStatusManager;
+    toolMetricsService;
+    sessionInfoService;
+    fileSystemService;
+    notificationService;
+    routerService;
+    killedProcesses = new Set(); // Track which processes we've killed
+    constructor(historyReader, statusTracker, claudeExecutablePath, envOverrides, toolMetricsService, sessionInfoService, fileSystemService) {
+        super();
+        this.historyReader = historyReader;
+        this.statusTracker = statusTracker;
+        this.claudeExecutablePath = claudeExecutablePath || this.findClaudeExecutable();
+        this.logger = createLogger('ClaudeProcessManager');
+        this.envOverrides = envOverrides || {};
+        this.toolMetricsService = toolMetricsService;
+        this.sessionInfoService = sessionInfoService;
+        this.fileSystemService = fileSystemService;
+    }
+    setRouterService(service) {
+        this.routerService = service;
+    }
+    /**
+     * Find the Claude executable - check user-local and system paths
+     */
+    findClaudeExecutable() {
+        // Check common installation paths including user-local installs
+        const userLocalPath = path.join(os.homedir(), '.local', 'bin', 'claude');
+        const candidatePaths = [
+            userLocalPath, // ~/.local/bin/claude (common for user installs)
+            '/usr/local/bin/claude',
+            '/usr/bin/claude',
+        ];
+        for (const candidate of candidatePaths) {
+            if (existsSync(candidate)) {
+                return candidate;
+            }
+        }
+        // Fallback: try PATH, excluding node_modules
+        const pathEnv = process.env.PATH || '';
+        const pathDirs = pathEnv.split(path.delimiter);
+        for (const dir of pathDirs) {
+            if (dir.includes('node_modules'))
+                continue; // Skip node_modules
+            const candidate = path.join(dir, 'claude');
+            if (existsSync(candidate)) {
+                return candidate;
+            }
+        }
+        throw new Error('Claude executable not found. Ensure Claude CLI is installed.');
+    }
+    /**
+     * Set the MCP config path to be used for all conversations
+     */
+    setMCPConfigPath(path) {
+        this.mcpConfigPath = path;
+        this.logger.debug('MCP config path set', { path });
+    }
+    /**
+     * Set the optimistic conversation service
+     */
+    setConversationStatusManager(service) {
+        this.conversationStatusManager = service;
+        this.logger.debug('Conversation status manager set');
+    }
+    /**
+     * Set the notification service
+     */
+    setNotificationService(service) {
+        this.notificationService = service;
+        this.logger.debug('Notification service set');
+    }
+    /**
+     * Start a new Claude conversation (or resume if resumedSessionId is provided)
+     */
+    async startConversation(config) {
+        const isResume = !!config.resumedSessionId;
+        // Guard against duplicate spawns for the same session
+        if (isResume && config.resumedSessionId && this.statusTracker.isSessionActive(config.resumedSessionId)) {
+            this.logger.warn('Attempted to resume already-active session', {
+                sessionId: config.resumedSessionId
+            });
+            throw new CUIError('SESSION_ALREADY_ACTIVE', `Cannot resume session ${config.resumedSessionId}: already has an active Claude process`, 409 // Conflict
+            );
+        }
+        this.logger.debug('Start conversation requested', {
+            hasInitialPrompt: !!config.initialPrompt,
+            promptLength: config.initialPrompt?.length,
+            workingDirectory: config.workingDirectory,
+            model: config.model,
+            allowedTools: config.allowedTools,
+            disallowedTools: config.disallowedTools,
+            hasSystemPrompt: !!config.systemPrompt,
+            claudePath: config.claudeExecutablePath || this.claudeExecutablePath,
+            isResume,
+            resumedSessionId: config.resumedSessionId,
+            previousMessageCount: config.previousMessages?.length || 0
+        });
+        // If resuming and no working directory provided, fetch from original session
+        let workingDirectory = config.workingDirectory;
+        if (isResume && !workingDirectory && config.resumedSessionId) {
+            const fetchedWorkingDirectory = await this.historyReader.getConversationWorkingDirectory(config.resumedSessionId);
+            if (!fetchedWorkingDirectory) {
+                throw new CUIError('CONVERSATION_NOT_FOUND', `Could not find working directory for session ${config.resumedSessionId}`, 404);
+            }
+            workingDirectory = fetchedWorkingDirectory;
+            this.logger.debug('Found working directory for resume session', {
+                sessionId: config.resumedSessionId,
+                workingDirectory
+            });
+        }
+        const args = isResume && config.resumedSessionId
+            ? this.buildResumeArgs({ sessionId: config.resumedSessionId, message: config.initialPrompt, permissionMode: config.permissionMode })
+            : this.buildStartArgs(config);
+        const spawnConfig = {
+            executablePath: config.claudeExecutablePath || this.claudeExecutablePath,
+            cwd: workingDirectory || config.workingDirectory || process.cwd(),
+            env: { ...process.env, ...this.envOverrides }
+        };
+        this.logger.debug('Spawn config prepared', {
+            executablePath: spawnConfig.executablePath,
+            cwd: spawnConfig.cwd,
+            hasEnvOverrides: Object.keys(this.envOverrides).length > 0,
+            envOverrideKeys: Object.keys(this.envOverrides),
+            isResume
+        });
+        return this.executeConversationFlow(isResume ? 'resuming' : 'starting', isResume && config.resumedSessionId ? { resumeSessionId: config.resumedSessionId } : {}, config, args, spawnConfig, isResume ? 'PROCESS_RESUME_FAILED' : 'PROCESS_START_FAILED', isResume ? 'Failed to resume Claude process' : 'Failed to start Claude process');
+    }
+    /**
+     * Stop a conversation gracefully (SIGTERM, then SIGKILL after 3s)
+     */
+    async stopConversation(streamingId) {
+        this.logger.debug('Stopping conversation', { streamingId });
+        const process = this.processes.get(streamingId);
+        if (!process) {
+            this.logger.warn('No process found for conversation', { streamingId });
+            return false;
+        }
+        try {
+            // Force kill if not already killed
+            if (!this.killedProcesses.has(streamingId)) {
+                this.logger.info('Sending SIGTERM to process', { streamingId, pid: process.pid });
+                process.kill('SIGTERM');
+                this.killedProcesses.add(streamingId);
+                // If SIGTERM doesn't work, use SIGKILL after 3 seconds
+                const killTimeout = setTimeout(() => {
+                    try {
+                        if (this.processes.has(streamingId)) {
+                            this.logger.warn('Process not responding to SIGTERM, sending SIGKILL', { streamingId, pid: process.pid });
+                            process.kill('SIGKILL');
+                        }
+                    }
+                    catch {
+                        // Process may have already exited, ignore
+                    }
+                }, 3000);
+                // Track timeout for cleanup on process exit
+                const sessionTimeouts = this.timeouts.get(streamingId) || [];
+                sessionTimeouts.push(killTimeout);
+                this.timeouts.set(streamingId, sessionTimeouts);
+            }
+            // Note: Cleanup happens in handleProcessClose when process actually exits
+            // Don't clean up here - the process may still be running
+            this.logger.info('Stop signal sent to process', { streamingId });
+            return true;
+        }
+        catch (error) {
+            this.logger.error('Error stopping conversation', error, { streamingId });
+            return false;
+        }
+    }
+    /**
+     * Force kill a conversation immediately (SIGKILL)
+     */
+    forceKillConversation(streamingId) {
+        this.logger.info('Force killing conversation', { streamingId });
+        const process = this.processes.get(streamingId);
+        if (!process) {
+            this.logger.warn('No process found for force kill', { streamingId });
+            return false;
+        }
+        try {
+            this.logger.warn('Sending SIGKILL to process', { streamingId, pid: process.pid });
+            process.kill('SIGKILL');
+            this.killedProcesses.add(streamingId);
+            return true;
+        }
+        catch (error) {
+            this.logger.error('Error force killing conversation', error, { streamingId });
+            return false;
+        }
+    }
+    /**
+     * Get active sessions
+     */
+    getActiveSessions() {
+        const sessions = Array.from(this.processes.keys());
+        this.logger.debug('Getting active sessions', { sessionCount: sessions.length });
+        return sessions;
+    }
+    /**
+     * Check if a session is active
+     */
+    isSessionActive(streamingId) {
+        const active = this.processes.has(streamingId);
+        return active;
+    }
+    /**
+     * Wait for the system init message from Claude CLI
+     * This should always be the first message in the stream
+     */
+    async waitForSystemInit(streamingId) {
+        this.logger.debug('Waiting for system init message', { streamingId });
+        return new Promise((resolve, reject) => {
+            let isResolved = false;
+            let stderrOutput = '';
+            // Set up timeout (1 minute)
+            const timeout = setTimeout(() => {
+                if (!isResolved) {
+                    isResolved = true;
+                    cleanup();
+                    this.logger.error('Timeout waiting for system init message', {
+                        streamingId,
+                        stderrOutput: stderrOutput || '(no stderr output)'
+                    });
+                    // Include stderr output in error message if available
+                    let errorMessage = 'Timeout waiting for system initialization from Claude CLI';
+                    if (stderrOutput) {
+                        errorMessage += `. Error output: ${stderrOutput}`;
+                    }
+                    reject(new CUIError('SYSTEM_INIT_TIMEOUT', errorMessage, 500));
+                }
+            }, 60000);
+            // Cleanup function to remove all listeners
+            const cleanup = () => {
+                clearTimeout(timeout);
+                this.removeListener('claude-message', messageHandler);
+                this.removeListener('process-closed', processClosedHandler);
+                this.removeListener('process-error', processErrorHandler);
+            };
+            // Register timeout for cleanup on process termination
+            const existingTimeouts = this.timeouts.get(streamingId) || [];
+            existingTimeouts.push(timeout);
+            this.timeouts.set(streamingId, existingTimeouts);
+            // Listen for process exit before system init is received
+            const processClosedHandler = ({ streamingId: closedStreamingId, code }) => {
+                if (closedStreamingId !== streamingId || isResolved) {
+                    return; // Not our process or already resolved
+                }
+                isResolved = true;
+                cleanup();
+                this.logger.error('Claude process exited before system init message', {
+                    streamingId,
+                    exitCode: code,
+                    stderrOutput: stderrOutput || '(no stderr output)'
+                });
+                // Create error message with Claude CLI output if available
+                let errorMessage = 'Claude CLI process exited before sending system initialization message';
+                if (stderrOutput) {
+                    // Extract Claude CLI's actual output from parser errors
+                    const claudeOutputMatch = stderrOutput.match(/Invalid JSON: (.+)/);
+                    if (claudeOutputMatch) {
+                        errorMessage += `. Claude CLI said: "${claudeOutputMatch[1]}"`;
+                    }
+                    else {
+                        errorMessage += `. Error output: ${stderrOutput}`;
+                    }
+                }
+                if (code !== null) {
+                    errorMessage += `. Exit code: ${code}`;
+                }
+                reject(new CUIError('CLAUDE_PROCESS_EXITED_EARLY', errorMessage, 500));
+            };
+            // Listen for process errors (including stderr output)
+            const processErrorHandler = ({ streamingId: errorStreamingId, error }) => {
+                if (errorStreamingId !== streamingId) {
+                    return; // Not our process
+                }
+                // Capture stderr output for error context
+                stderrOutput += error;
+                this.logger.debug('Captured stderr output during system init wait', {
+                    streamingId,
+                    errorLength: error.length,
+                    totalStderrLength: stderrOutput.length
+                });
+            };
+            // Listen for the first claude-message event for this streamingId
+            const messageHandler = ({ streamingId: msgStreamingId, message }) => {
+                if (msgStreamingId !== streamingId) {
+                    return; // Not for our session
+                }
+                if (isResolved) {
+                    return; // Already resolved
+                }
+                this.logger.debug('Received message from Claude CLI during init wait', {
+                    streamingId,
+                    messageType: message?.type,
+                    messageSubtype: 'subtype' in message ? message.subtype : undefined,
+                    hasSessionId: 'session_id' in message ? !!message.session_id : false
+                });
+                // Skip hook_response messages (Claude v2 sends these before init)
+                // Cast to unknown string to compare - StreamEvent type doesn't include all system subtypes
+                if (message?.type === 'system' && 'subtype' in message && message.subtype === 'hook_response') {
+                    this.logger.debug('Skipping hook_response message, waiting for init', { streamingId });
+                    return; // Keep waiting for init message
+                }
+                // Now we have a non-hook message, mark as resolved
+                isResolved = true;
+                cleanup();
+                // Validate that this message is a system init message
+                if (!message || message.type !== 'system' || !('subtype' in message) || message.subtype !== 'init') {
+                    this.logger.error('Expected system init message', {
+                        streamingId,
+                        actualType: message?.type,
+                        actualSubtype: 'subtype' in message ? message.subtype : undefined,
+                        expectedType: 'system',
+                        expectedSubtype: 'init'
+                    });
+                    reject(new CUIError('INVALID_SYSTEM_INIT', `Expected system init message, but got: ${message?.type}/${'subtype' in message ? message.subtype : 'undefined'}`, 500));
+                    return;
+                }
+                // At this point, TypeScript knows message is SystemInitMessage
+                const systemInitMessage = message;
+                // Validate required fields
+                const requiredFields = ['session_id', 'cwd', 'tools', 'mcp_servers', 'model', 'permissionMode', 'apiKeySource'];
+                const missingFields = requiredFields.filter(field => systemInitMessage[field] === undefined);
+                if (missingFields.length > 0) {
+                    this.logger.error('System init message missing required fields', {
+                        streamingId,
+                        missingFields,
+                        availableFields: Object.keys(systemInitMessage)
+                    });
+                    reject(new CUIError('INCOMPLETE_SYSTEM_INIT', `System init message missing required fields: ${missingFields.join(', ')}`, 500));
+                    return;
+                }
+                this.logger.debug('Successfully received valid system init message', {
+                    streamingId,
+                    sessionId: systemInitMessage.session_id,
+                    cwd: systemInitMessage.cwd,
+                    model: systemInitMessage.model,
+                    toolCount: systemInitMessage.tools?.length || 0,
+                    mcpServerCount: systemInitMessage.mcp_servers?.length || 0
+                });
+                // Register active session immediately when we have the session_id
+                // Include optimistic context if available
+                const config = this.conversationConfigs.get(streamingId);
+                if (this.conversationStatusManager && config) {
+                    const optimisticContext = {
+                        initialPrompt: config.initialPrompt || '',
+                        workingDirectory: config.workingDirectory || process.cwd(),
+                        model: config.model || 'default',
+                        timestamp: new Date().toISOString(),
+                        inheritedMessages: config.previousMessages
+                    };
+                    this.conversationStatusManager.registerActiveSession(streamingId, systemInitMessage.session_id, optimisticContext);
+                    this.logger.debug('Registered conversation context', {
+                        streamingId,
+                        claudeSessionId: systemInitMessage.session_id,
+                        inheritedMessageCount: config.previousMessages?.length || 0
+                    });
+                }
+                else {
+                    // Fallback to old behavior if service not set
+                    this.statusTracker.registerActiveSession(streamingId, systemInitMessage.session_id);
+                    this.logger.debug('Registered active session with status tracker (no optimistic service)', {
+                        streamingId,
+                        claudeSessionId: systemInitMessage.session_id
+                    });
+                }
+                resolve(systemInitMessage);
+            };
+            // Set up all event listeners
+            this.on('claude-message', messageHandler);
+            this.on('process-closed', processClosedHandler);
+            this.on('process-error', processErrorHandler);
+        });
+    }
+    /**
+     * Execute common conversation flow for both start and resume operations
+     */
+    async executeConversationFlow(operation, loggerContext, config, args, spawnConfig, errorCode, errorPrefix) {
+        const streamingId = uuidv4(); // CUI's internal streaming identifier
+        // Store config for use in waitForSystemInit
+        this.conversationConfigs.set(streamingId, config);
+        try {
+            // Validate Claude executable before proceeding
+            if (this.fileSystemService) {
+                await this.fileSystemService.validateExecutable(spawnConfig.executablePath);
+            }
+            this.logger.debug(`${operation.charAt(0).toUpperCase() + operation.slice(1)} conversation`, {
+                streamingId,
+                operation,
+                configKeys: Object.keys(config),
+                argCount: args.length,
+                ...loggerContext
+            });
+            this.logger.debug(`Built Claude ${operation} args`, {
+                streamingId,
+                args,
+                argsString: args.join(' '),
+                ...loggerContext
+            });
+            // Set up system init promise before spawning process
+            const systemInitPromise = this.waitForSystemInit(streamingId);
+            // Add streamingId to environment for MCP server to use
+            // Filter out debugging-related environment variables that would cause
+            // the VSCode debugger to attach to the Claude CLI child process
+            // Also filter CLAUDECODE to prevent nested session detection issues
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            const { NODE_OPTIONS, VSCODE_INSPECTOR_OPTIONS, CLAUDECODE, CLAUDE_CODE_ENTRYPOINT, ...cleanEnv } = spawnConfig.env;
+            // Expand tilde to actual home directory path
+            const expandedCwd = expandTilde(spawnConfig.cwd);
+            const envWithStreamingId = {
+                ...cleanEnv,
+                CUI_STREAMING_ID: streamingId,
+                PWD: expandedCwd,
+                INIT_CWD: expandedCwd
+            };
+            const process = this.spawnProcess({ ...spawnConfig, env: envWithStreamingId }, args, streamingId);
+            this.processes.set(streamingId, process);
+            this.setupProcessHandlers(streamingId, process);
+            // Message is now passed as CLI arg (not via stdin)
+            // --input-format stream-json was removed because it causes Claude to wait for input
+            // without sending system init message first
+            // Handle spawn errors by listening for our custom event
+            const spawnErrorPromise = new Promise((_, reject) => {
+                this.once('spawn-error', (error) => {
+                    this.processes.delete(streamingId);
+                    reject(error);
+                });
+            });
+            // Wait a bit to see if spawn fails immediately
+            this.logger.debug('Waiting for spawn validation', { streamingId, ...loggerContext });
+            const delayPromise = new Promise(resolve => {
+                setTimeout(() => {
+                    this.logger.debug('Spawn validation period passed, process appears stable', { streamingId, ...loggerContext });
+                    this.removeAllListeners('spawn-error');
+                    resolve(streamingId);
+                }, 100);
+            });
+            await Promise.race([spawnErrorPromise, delayPromise]);
+            // Now wait for the system init message
+            this.logger.debug('Process spawned successfully, waiting for system init message', { streamingId, ...loggerContext });
+            const systemInit = await systemInitPromise;
+            // Check if cwd is a git repository and set initial_commit_head for new session
+            if (this.sessionInfoService && this.fileSystemService) {
+                try {
+                    if (await this.fileSystemService.isGitRepository(systemInit.cwd)) {
+                        const gitHead = await this.fileSystemService.getCurrentGitHead(systemInit.cwd);
+                        if (gitHead) {
+                            await this.sessionInfoService.updateSessionInfo(systemInit.session_id, {
+                                initial_commit_head: gitHead
+                            });
+                            this.logger.debug('Set initial commit head for new session', {
+                                sessionId: systemInit.session_id,
+                                gitHead
+                            });
+                        }
+                    }
+                }
+                catch (error) {
+                    this.logger.warn('Failed to set initial commit head for new session', {
+                        sessionId: systemInit.session_id,
+                        cwd: systemInit.cwd,
+                        error: error instanceof Error ? error.message : String(error)
+                    });
+                }
+            }
+            this.logger.debug(`${operation.charAt(0).toUpperCase() + operation.slice(1)} conversation successfully`, {
+                streamingId,
+                sessionId: systemInit.session_id,
+                model: systemInit.model,
+                cwd: systemInit.cwd,
+                processCount: this.processes.size,
+                ...loggerContext
+            });
+            return { streamingId, systemInit };
+        }
+        catch (error) {
+            this.logger.error(`Error ${operation} conversation`, error, {
+                streamingId,
+                errorName: error instanceof Error ? error.name : 'Unknown',
+                errorMessage: error instanceof Error ? error.message : String(error),
+                errorCode: error instanceof CUIError ? error.code : undefined,
+                ...loggerContext
+            });
+            // Clean up any resources if process fails
+            const timeouts = this.timeouts.get(streamingId);
+            if (timeouts) {
+                timeouts.forEach(timeout => clearTimeout(timeout));
+                this.timeouts.delete(streamingId);
+            }
+            this.processes.delete(streamingId);
+            this.outputBuffers.delete(streamingId);
+            this.conversationConfigs.delete(streamingId);
+            if (error instanceof CUIError) {
+                throw error;
+            }
+            throw new CUIError(errorCode, `${errorPrefix}: ${error}`, 500);
+        }
+    }
+    buildBaseArgs() {
+        return [
+            '-p', // Print mode - required for programmatic use
+        ];
+    }
+    buildResumeArgs(config) {
+        this.logger.debug('Building Claude resume args', {
+            sessionId: config.sessionId,
+            messagePreview: config.message.substring(0, 50) + (config.message.length > 50 ? '...' : '')
+        });
+        const args = this.buildBaseArgs();
+        // Add message as CLI arg - same as start
+        // NOTE: For very long messages, this may hit CLI arg length limits
+        args.push(config.message);
+        args.push('--resume', config.sessionId, '--output-format', 'stream-json', '--input-format', 'stream-json', // Enable stdin for AskUserQuestion responses
+        '--verbose');
+        // Always use dangerously bypass permissions
+        args.push('--dangerously-skip-permissions');
+        // NOTE: MCP config disabled for resume - it causes Claude to hang waiting for MCP server init
+        // The MCP permission server creates a circular dependency when spawned during resume
+        // Since we use --dangerously-skip-permissions, we don't need the permission prompt tool anyway
+        this.logger.debug('Built Claude resume args', { args, hasMCPConfig: !!this.mcpConfigPath });
+        return args;
+    }
+    buildStartArgs(config) {
+        this.logger.debug('Building Claude start args', {
+            hasInitialPrompt: !!config.initialPrompt,
+            promptPreview: config.initialPrompt ? config.initialPrompt.substring(0, 50) + (config.initialPrompt.length > 50 ? '...' : '') : null,
+            workingDirectory: config.workingDirectory,
+            model: config.model
+        });
+        const args = this.buildBaseArgs();
+        // Add initial prompt immediately after -p
+        if (config.initialPrompt) {
+            args.push(config.initialPrompt);
+        }
+        args.push('--output-format', 'stream-json', // JSONL output format
+        '--input-format', 'stream-json', // Enable stdin for AskUserQuestion responses
+        '--verbose' // Required when using stream-json with print mode
+        );
+        // Add working directory access
+        // if (config.workingDirectory) {
+        //   args.push('--add-dir', config.workingDirectory);
+        // }
+        // Add model specification
+        if (config.model) {
+            args.push('--model', config.model);
+        }
+        // Add allowed tools
+        if (config.allowedTools && config.allowedTools.length > 0) {
+            args.push('--allowedTools', config.allowedTools.join(','));
+        }
+        // Add disallowed tools
+        if (config.disallowedTools && config.disallowedTools.length > 0) {
+            args.push('--disallowedTools', config.disallowedTools.join(','));
+        }
+        // Add system prompt with Claudia environment info
+        const claudiaEnvInfo = `
+## Claudia Orchestrator Environment
+
+You are running inside the Claudia orchestrator dashboard.
+
+**Server logs** (for debugging issues):
+- \`~/.claudia/logs/server.log\` - Express server logs
+- \`~/.claudia/logs/daemon.log\` - Process daemon logs
+`;
+        const systemPrompt = config.systemPrompt
+            ? `${config.systemPrompt}\n${claudiaEnvInfo}`
+            : claudiaEnvInfo;
+        args.push('--system-prompt', systemPrompt);
+        // Add MCP config if available
+        if (this.mcpConfigPath) {
+            args.push('--mcp-config', this.mcpConfigPath);
+        }
+        // Always use dangerously bypass permissions
+        // Note: When using --dangerously-skip-permissions, we don't need the MCP permission prompt tool
+        // Adding --permission-prompt-tool with skip-permissions causes startup failures if MCP server is slow
+        args.push('--dangerously-skip-permissions');
+        this.logger.debug('Built Claude args', { args, hasMCPConfig: !!this.mcpConfigPath });
+        return args;
+    }
+    /**
+     * Consolidated method to spawn Claude processes for both start and resume operations
+     * Uses node-pty to provide a pseudo-terminal, which is required for Claude CLI -p mode
+     */
+    spawnProcess(spawnConfig, args, streamingId) {
+        const { executablePath } = spawnConfig;
+        // Expand tilde to actual home directory - Node.js spawn doesn't do shell expansion
+        const cwd = expandTilde(spawnConfig.cwd);
+        let { env } = spawnConfig;
+        // Inject router proxy if enabled
+        if (this.routerService?.isEnabled()) {
+            env = {
+                ...env,
+                ANTHROPIC_BASE_URL: this.routerService.getProxyUrl(),
+                ANTHROPIC_API_KEY: 'router-managed'
+            };
+            this.logger.info('Using router proxy', {
+                streamingId,
+                proxyUrl: this.routerService.getProxyUrl()
+            });
+        }
+        // Check if MCP config is in args and validate it
+        const mcpConfigIndex = args.indexOf('--mcp-config');
+        if (mcpConfigIndex !== -1 && mcpConfigIndex + 1 < args.length) {
+            const mcpConfigPath = args[mcpConfigIndex + 1];
+            this.logger.debug('MCP config specified', {
+                streamingId,
+                mcpConfigPath,
+                exists: existsSync(mcpConfigPath)
+            });
+            // Try to read and log the MCP config content
+            try {
+                const mcpConfigContent = readFileSync(mcpConfigPath, 'utf-8');
+                this.logger.debug('MCP config content', {
+                    streamingId,
+                    mcpConfig: JSON.parse(mcpConfigContent)
+                });
+            }
+            catch (error) {
+                this.logger.error('Failed to read MCP config', { streamingId, error });
+            }
+        }
+        this.logger.debug('Spawning Claude process with PTY', {
+            streamingId,
+            executablePath,
+            args,
+            cwd,
+            PATH: env.PATH,
+            nodeVersion: process.version,
+            platform: process.platform
+        });
+        try {
+            // Log the exact command for debugging
+            const fullCommand = `${executablePath} ${args.join(' ')}`;
+            this.logger.info('SPAWNING CLAUDE COMMAND (PTY): ' + fullCommand, {
+                streamingId,
+                fullCommand,
+                executablePath,
+                args,
+                cwd,
+                env: Object.entries(env).reduce((acc, [key, value]) => {
+                    acc[key] = value;
+                    return acc;
+                }, {})
+            });
+            // Use node-pty to spawn with a pseudo-terminal
+            // This is required because Claude CLI -p mode only outputs when connected to a TTY
+            const claudeProcess = pty.spawn(executablePath, args, {
+                name: 'xterm-256color',
+                cols: 200,
+                rows: 50,
+                cwd,
+                env: env
+            });
+            if (!claudeProcess.pid) {
+                this.logger.error('Failed to spawn Claude process - no PID assigned', {
+                    streamingId
+                });
+                throw new Error('Failed to spawn Claude process - no PID assigned');
+            }
+            this.logger.info('Claude process spawned successfully (PTY)', {
+                streamingId,
+                pid: claudeProcess.pid
+            });
+            return claudeProcess;
+        }
+        catch (error) {
+            this.logger.error('Error in spawnProcess', error, { streamingId });
+            if (error instanceof CUIError) {
+                throw error;
+            }
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            if (errorMessage.includes('ENOENT') || errorMessage.includes('not found')) {
+                throw new CUIError('CLAUDE_NOT_FOUND', 'Claude CLI not found. Please ensure Claude is installed and in PATH.', 500);
+            }
+            throw new CUIError('PROCESS_SPAWN_FAILED', `Failed to spawn Claude process: ${errorMessage}`, 500);
+        }
+    }
+    setupProcessHandlers(streamingId, process) {
+        this.logger.debug('Setting up PTY process handlers', { streamingId, pid: process.pid });
+        // Create JSONL parser for Claude output
+        const parser = new JsonLinesParser();
+        // Initialize output buffer for this session
+        this.outputBuffers.set(streamingId, '');
+        // Handle parsed JSONL messages from Claude
+        parser.on('data', (message) => {
+            // Skip echoed stdin messages - PTY echoes our input back
+            // BUT: tool_result messages are also type: 'user' (Claude API protocol:
+            // user = input TO Claude, assistant = output FROM Claude)
+            // We need to let tool_result messages through so the UI can update tool status
+            if (message?.type === 'user') {
+                const content = message.message?.content;
+                const isToolResult = Array.isArray(content) &&
+                    content.some((block) => block.type === 'tool_result');
+                if (!isToolResult) {
+                    this.logger.debug('Skipping echoed stdin message', {
+                        streamingId,
+                        messageType: message?.type
+                    });
+                    return;
+                }
+                // Fall through to emit tool_result messages
+                this.logger.debug('Allowing tool_result message through', {
+                    streamingId,
+                    toolResultCount: content.filter((b) => b.type === 'tool_result').length
+                });
+            }
+            this.logger.debug('Received Claude message', {
+                streamingId,
+                messageType: message?.type,
+                hasContent: !!message?.content,
+                contentLength: message?.content?.length,
+                messageKeys: message ? Object.keys(message) : [],
+                timestamp: new Date().toISOString()
+            });
+            this.handleClaudeMessage(streamingId, message);
+        });
+        parser.on('error', (error) => {
+            this.logger.error('Parser error', error, {
+                streamingId,
+                errorType: error.name,
+                errorMessage: error.message,
+                bufferState: this.outputBuffers.get(streamingId)?.length || 0
+            });
+            this.handleProcessError(streamingId, error);
+        });
+        // Handle PTY data output (combined stdout/stderr from the pseudo-terminal)
+        // PTY combines both streams, so we need to parse JSONL from the raw output
+        process.onData((data) => {
+            // Log raw PTY data for debugging
+            this.logger.info('RAW PTY DATA', {
+                streamingId,
+                dataLength: data.length,
+                dataPreview: data.substring(0, 200)
+            });
+            // Strip ANSI escape sequences that might interfere with JSON parsing
+            // Common PTY escape sequences: cursor control, colors, etc.
+            const cleanedData = data.replace(/\x1b\[[0-9;]*[a-zA-Z]|\x1b\][^\x07]*\x07/g, '');
+            // Feed cleaned data to the JSONL parser
+            if (cleanedData.trim()) {
+                parser.write(cleanedData);
+            }
+        });
+        // Handle PTY process exit (node-pty uses onExit, not EventEmitter 'exit')
+        process.onExit(({ exitCode, signal }) => {
+            this.logger.debug('PTY process exited', {
+                streamingId,
+                exitCode,
+                signal,
+                normalExit: exitCode === 0,
+                timestamp: new Date().toISOString(),
+                outputBuffer: this.outputBuffers.get(streamingId) || 'No output captured'
+            });
+            this.handleProcessClose(streamingId, exitCode);
+        });
+    }
+    handleClaudeMessage(streamingId, message) {
+        this.logger.debug('Handling Claude message', {
+            streamingId,
+            messageType: message?.type,
+            isError: message?.type === 'error',
+            isResult: message?.type === 'result'
+        });
+        this.emit('claude-message', { streamingId, message });
+        // When we receive a 'result' message, the conversation turn is complete.
+        // For PTY, we don't need to close stdin - the process will exit naturally after result.
+        // The PTY's onExit handler will clean up.
+        if (message?.type === 'result') {
+            this.logger.debug('Received result message, process will exit naturally', {
+                streamingId,
+                resultSubtype: 'subtype' in message ? message.subtype : undefined
+            });
+        }
+    }
+    handleProcessClose(streamingId, code) {
+        // Clear any pending timeouts for this session
+        const timeouts = this.timeouts.get(streamingId);
+        if (timeouts) {
+            timeouts.forEach(timeout => clearTimeout(timeout));
+            this.timeouts.delete(streamingId);
+        }
+        this.processes.delete(streamingId);
+        this.outputBuffers.delete(streamingId);
+        const config = this.conversationConfigs.get(streamingId);
+        this.conversationConfigs.delete(streamingId);
+        // Send notification if service is available
+        if (this.notificationService && config) {
+            // Get session ID from conversation status or config
+            const sessionId = this.statusTracker.getSessionId(streamingId) || 'unknown';
+            // Try to get conversation metadata for summary
+            this.historyReader.fetchConversationDirect(sessionId)
+                .then(({ metadata }) => {
+                if (this.notificationService && metadata) {
+                    return this.notificationService.sendConversationEndNotification(streamingId, sessionId, metadata.summary);
+                }
+            })
+                .catch((error) => {
+                this.logger.error('Failed to send conversation end notification', error);
+            });
+        }
+        this.emit('process-closed', { streamingId, code });
+    }
+    handleProcessError(streamingId, error) {
+        const errorMessage = error.toString();
+        const isBuffer = Buffer.isBuffer(error);
+        this.logger.error('Process error occurred', {
+            streamingId,
+            error: errorMessage,
+            errorType: isBuffer ? 'stderr-output' : error.constructor.name,
+            errorLength: errorMessage.length,
+            processStillActive: this.processes.has(streamingId),
+            timestamp: new Date().toISOString()
+        });
+        this.emit('process-error', { streamingId, error: errorMessage });
+    }
+    /**
+     * Send an answer to an AskUserQuestion tool via stdin.
+     * The Claude CLI with --input-format stream-json expects JSON messages on stdin.
+     */
+    sendQuestionAnswer(streamingId, answer) {
+        const process = this.processes.get(streamingId);
+        if (!process) {
+            this.logger.warn('Cannot send question answer: process not found', { streamingId });
+            return false;
+        }
+        const sessionId = this.sessionIds.get(streamingId);
+        if (!sessionId) {
+            this.logger.warn('Cannot send question answer: session ID not found', { streamingId });
+            return false;
+        }
+        // Format the stdin message per Claude CLI stream-json protocol
+        const stdinMessage = JSON.stringify({
+            type: 'user',
+            message: {
+                role: 'user',
+                content: answer
+            },
+            session_id: sessionId
+        });
+        this.logger.info('Sending question answer via stdin', {
+            streamingId,
+            sessionId,
+            answerLength: answer.length
+        });
+        // Write to PTY stdin with newline
+        process.write(stdinMessage + '\n');
+        return true;
+    }
+    /**
+     * Send a raw stdin message to a Claude process.
+     * Used by ClaudiaService for sending messages to Claudia's session.
+     * The message should already be formatted as a JSON string.
+     */
+    sendStdinMessage(streamingId, message) {
+        const process = this.processes.get(streamingId);
+        if (!process) {
+            this.logger.warn('Cannot send stdin message: process not found', { streamingId });
+            return false;
+        }
+        this.logger.info('Sending stdin message', {
+            streamingId,
+            messageLength: message.length
+        });
+        // Write to PTY stdin with newline
+        process.write(message + '\n');
+        return true;
+    }
+}
+//# sourceMappingURL=claude-process-manager.js.map