lattice-orchestrator 0.7.0

package/dist/process-daemon/process-daemon.js

@@ -0,0 +1,846 @@
+/**
+ * Process Daemon - Long-running process that owns Claude CLI PTY processes
+ *
+ * This daemon runs independently of the web server and survives nodemon restarts.
+ * It communicates with cui-server via Unix socket IPC.
+ */
+import * as pty from 'node-pty';
+import * as net from 'net';
+import * as fs from 'fs';
+import { spawn } from 'child_process';
+import { EventEmitter } from 'events';
+import { v4 as uuidv4 } from 'uuid';
+import path from 'path';
+import os from 'os';
+import { existsSync } from 'fs';
+import { fileURLToPath } from 'url';
+// ESM equivalent of __dirname
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+import { JsonLinesParser } from '../services/process/json-lines-parser.js';
+import { LatticeError } from '../types/index.js';
+import { DEFAULT_SOCKET_PATH, } from './types.js';
+/**
+ * Expand tilde (~) in paths to the user's home directory.
+ */
+function expandTilde(filePath) {
+    if (filePath === '~' || filePath.startsWith('~/')) {
+        return path.join(os.homedir(), filePath.slice(1));
+    }
+    return filePath;
+}
+/**
+ * Simple console logger for daemon (avoids importing pino for standalone operation)
+ */
+const timestamp = () => new Date().toISOString();
+const logger = {
+    info: (msg, data) => {
+        console.warn(`[${timestamp()}] [DAEMON] ${msg}`, data ? JSON.stringify(data) : '');
+    },
+    debug: (msg, data) => {
+        if (process.env.LOG_LEVEL === 'debug') {
+            console.warn(`[${timestamp()}] [DAEMON:DEBUG] ${msg}`, data ? JSON.stringify(data) : '');
+        }
+    },
+    warn: (msg, data) => {
+        console.warn(`[${timestamp()}] [DAEMON:WARN] ${msg}`, data ? JSON.stringify(data) : '');
+    },
+    error: (msg, error, data) => {
+        console.error(`[${timestamp()}] [DAEMON:ERROR] ${msg}`, error, data ? JSON.stringify(data) : '');
+    },
+};
+/**
+ * Process Daemon - owns and manages Claude CLI PTY processes
+ */
+export class ProcessDaemon extends EventEmitter {
+    processes = new Map();
+    outputBuffers = new Map();
+    timeouts = new Map();
+    conversationConfigs = new Map();
+    sessionIds = new Map(); // streamingId -> claude session_id
+    killedProcesses = new Set();
+    ipcServer = null;
+    connectedClients = new Set();
+    socketPath;
+    claudeExecutablePath;
+    envOverrides;
+    // Pending system init resolvers (streamingId -> {resolve, reject})
+    pendingSystemInits = new Map();
+    constructor(config = { socketPath: DEFAULT_SOCKET_PATH }) {
+        super();
+        this.socketPath = config.socketPath;
+        this.claudeExecutablePath = config.claudeExecutablePath || this.findClaudeExecutable();
+        this.envOverrides = config.envOverrides || {};
+    }
+    /**
+     * Find the Claude executable
+     */
+    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;
+            }
+        }
+        const pathEnv = process.env.PATH || '';
+        const pathDirs = pathEnv.split(path.delimiter);
+        for (const dir of pathDirs) {
+            if (dir.includes('node_modules'))
+                continue;
+            const candidate = path.join(dir, 'claude');
+            if (existsSync(candidate)) {
+                return candidate;
+            }
+        }
+        throw new Error('Claude CLI not found.\n\n' +
+            'Claudia Orchestrator requires Claude Code CLI to be installed.\n' +
+            'Install it with: npm install -g @anthropic-ai/claude-code\n' +
+            'Then authenticate with: claude\n\n' +
+            'More info: https://docs.anthropic.com/en/docs/claude-code');
+    }
+    /**
+     * Check if another daemon is already running by attempting to connect to the socket.
+     * Returns true if a daemon is actively listening, false if socket is stale or missing.
+     */
+    async isExistingDaemonRunning() {
+        if (!fs.existsSync(this.socketPath)) {
+            return false;
+        }
+        return new Promise((resolve) => {
+            const testSocket = new net.Socket();
+            const timeout = setTimeout(() => {
+                testSocket.destroy();
+                resolve(false); // Timeout = no daemon responding
+            }, 1000);
+            testSocket.on('connect', () => {
+                clearTimeout(timeout);
+                testSocket.destroy();
+                resolve(true); // Connected = daemon is running
+            });
+            testSocket.on('error', () => {
+                clearTimeout(timeout);
+                testSocket.destroy();
+                resolve(false); // Error = socket is stale
+            });
+            testSocket.connect(this.socketPath);
+        });
+    }
+    /**
+     * Start the IPC server
+     */
+    async start() {
+        // Check if another daemon is already running
+        const existingDaemon = await this.isExistingDaemonRunning();
+        if (existingDaemon) {
+            logger.warn('Another daemon is already running on this socket', { socketPath: this.socketPath });
+            throw new Error(`Another daemon is already listening on ${this.socketPath}. Kill the existing daemon first or use a different socket path.`);
+        }
+        // Clean up stale socket file (we know no daemon is listening now)
+        if (fs.existsSync(this.socketPath)) {
+            logger.info('Removing stale socket file', { path: this.socketPath });
+            fs.unlinkSync(this.socketPath);
+        }
+        return new Promise((resolve, reject) => {
+            this.ipcServer = net.createServer((socket) => {
+                this.handleClientConnection(socket);
+            });
+            this.ipcServer.on('error', (err) => {
+                logger.error('IPC server error', err);
+                reject(err);
+            });
+            this.ipcServer.listen(this.socketPath, () => {
+                // Set socket permissions so any local user can connect
+                fs.chmodSync(this.socketPath, 0o777);
+                logger.info('Process daemon started', {
+                    socketPath: this.socketPath,
+                    claudePath: this.claudeExecutablePath,
+                });
+                resolve();
+            });
+        });
+    }
+    /**
+     * Stop the daemon gracefully
+     */
+    async stop() {
+        logger.info('Stopping process daemon...');
+        // Stop all active processes
+        const sessions = Array.from(this.processes.keys());
+        for (const streamingId of sessions) {
+            await this.stopConversation(streamingId);
+        }
+        // Close all client connections
+        for (const client of this.connectedClients) {
+            client.destroy();
+        }
+        this.connectedClients.clear();
+        // Close IPC server
+        if (this.ipcServer) {
+            await new Promise((resolve) => {
+                this.ipcServer.close(() => {
+                    logger.info('IPC server closed');
+                    resolve();
+                });
+            });
+        }
+        // Clean up socket file
+        if (fs.existsSync(this.socketPath)) {
+            fs.unlinkSync(this.socketPath);
+        }
+        logger.info('Process daemon stopped');
+    }
+    /**
+     * Handle a new client connection
+     */
+    handleClientConnection(socket) {
+        logger.info('Client connected');
+        this.connectedClients.add(socket);
+        let buffer = '';
+        socket.on('data', (data) => {
+            buffer += data.toString();
+            // Parse newline-delimited JSON messages
+            const lines = buffer.split('\n');
+            buffer = lines.pop() || '';
+            for (const line of lines) {
+                if (line.trim()) {
+                    try {
+                        const request = JSON.parse(line);
+                        this.handleRequest(socket, request);
+                    }
+                    catch (err) {
+                        logger.error('Failed to parse IPC message', err, { line });
+                    }
+                }
+            }
+        });
+        socket.on('close', () => {
+            logger.info('Client disconnected');
+            this.connectedClients.delete(socket);
+        });
+        socket.on('error', (err) => {
+            logger.error('Client socket error', err);
+            this.connectedClients.delete(socket);
+        });
+    }
+    /**
+     * Handle an IPC request
+     */
+    async handleRequest(socket, request) {
+        logger.debug('Received request', { method: request.method, id: request.id });
+        try {
+            let result;
+            switch (request.method) {
+                case 'spawn':
+                    result = await this.handleSpawn(request.params);
+                    break;
+                case 'stop':
+                    result = await this.handleStop(request.params);
+                    break;
+                case 'forceKill':
+                    result = this.handleForceKill(request.params);
+                    break;
+                case 'interrupt':
+                    result = this.handleInterrupt(request.params);
+                    break;
+                case 'write':
+                    result = this.handleWrite(request.params);
+                    break;
+                case 'sendQuestionAnswer':
+                    result = this.handleSendQuestionAnswer(request.params);
+                    break;
+                case 'list':
+                    result = { sessions: this.getActiveSessions() };
+                    break;
+                case 'isActive':
+                    result = { active: this.isSessionActive(request.params.streamingId) };
+                    break;
+                default:
+                    throw new Error(`Unknown method: ${request.method}`);
+            }
+            this.sendResponse(socket, { id: request.id, result });
+        }
+        catch (error) {
+            const err = error instanceof Error ? error : new Error(String(error));
+            this.sendResponse(socket, {
+                id: request.id,
+                error: {
+                    code: error instanceof LatticeError ? error.code : 'INTERNAL_ERROR',
+                    message: err.message,
+                },
+            });
+        }
+    }
+    /**
+     * Send a response to a specific client
+     */
+    sendResponse(socket, response) {
+        socket.write(JSON.stringify(response) + '\n');
+    }
+    /**
+     * Broadcast an event to all connected clients
+     */
+    broadcastEvent(event) {
+        const message = JSON.stringify(event) + '\n';
+        for (const client of this.connectedClients) {
+            try {
+                client.write(message);
+            }
+            catch (err) {
+                logger.error('Failed to broadcast to client', err);
+            }
+        }
+    }
+    // ============================================================================
+    // Process Management (extracted from ClaudeProcessManager)
+    // ============================================================================
+    async handleSpawn(params) {
+        const { config } = params;
+        const isResume = !!config.resumedSessionId;
+        const streamingId = uuidv4();
+        const spawnStartTime = Date.now();
+        logger.info('Spawning conversation', { streamingId, isResume });
+        // Store config
+        this.conversationConfigs.set(streamingId, config);
+        try {
+            const hasMultimodalContent = !!(config.initialContent && config.initialContent.length > 0);
+            // For multimodal, don't pass message as CLI arg - we'll send via stdin
+            const args = isResume && config.resumedSessionId
+                ? this.buildResumeArgs({ sessionId: config.resumedSessionId, message: config.initialPrompt, permissionMode: config.permissionMode, streamingId, hasMultimodalContent })
+                : this.buildStartArgs(config, streamingId);
+            const cwd = expandTilde(config.workingDirectory || process.cwd());
+            logger.info('Spawn cwd', { streamingId, configWorkingDirectory: config.workingDirectory, resolvedCwd: cwd, processCwd: process.cwd() });
+            // Clean environment - destructure to remove unwanted vars
+            const { NODE_OPTIONS: _NO, VSCODE_INSPECTOR_OPTIONS: _VIO, CLAUDECODE: _CC, CLAUDE_CODE_ENTRYPOINT: _CCE, ...cleanEnv } = process.env;
+            const env = {
+                ...cleanEnv,
+                ...this.envOverrides,
+                CUI_STREAMING_ID: streamingId,
+                PWD: cwd,
+                INIT_CWD: cwd,
+            };
+            let managedProcess;
+            if (hasMultimodalContent) {
+                // Use piped spawn for multimodal - stdin will be a pipe, not a TTY
+                // This allows CLI to block waiting for stdin input
+                logger.info('Using piped spawn for multimodal content', { streamingId });
+                const childProcess = spawn(this.claudeExecutablePath, args, {
+                    cwd,
+                    env: env,
+                    stdio: ['pipe', 'pipe', 'pipe'],
+                });
+                if (!childProcess.pid) {
+                    throw new LatticeError('PROCESS_SPAWN_FAILED', 'Failed to spawn Claude process - no PID assigned', 500);
+                }
+                managedProcess = {
+                    type: 'pipe',
+                    child: childProcess,
+                    pid: childProcess.pid,
+                    write: (data) => childProcess.stdin?.write(data),
+                    kill: (signal) => childProcess.kill(signal),
+                    endStdin: () => childProcess.stdin?.end(),
+                };
+                this.processes.set(streamingId, managedProcess);
+                this.setupPipedProcessHandlers(streamingId, childProcess);
+            }
+            else {
+                // Use PTY for regular text - provides better terminal experience
+                const ptyProcess = pty.spawn(this.claudeExecutablePath, args, {
+                    name: 'xterm-256color',
+                    cols: 200,
+                    rows: 50,
+                    cwd,
+                    env: env,
+                });
+                if (!ptyProcess.pid) {
+                    throw new LatticeError('PROCESS_SPAWN_FAILED', 'Failed to spawn Claude process - no PID assigned', 500);
+                }
+                managedProcess = {
+                    type: 'pty',
+                    pty: ptyProcess,
+                    pid: ptyProcess.pid,
+                    write: (data) => ptyProcess.write(data),
+                    kill: (signal) => ptyProcess.kill(signal),
+                };
+                this.processes.set(streamingId, managedProcess);
+                this.setupPtyProcessHandlers(streamingId, ptyProcess);
+            }
+            // Broadcast process-spawned event so clients can start buffering
+            this.broadcastEvent({
+                event: 'process-spawned',
+                data: { streamingId },
+            });
+            const spawnMs = Date.now() - spawnStartTime;
+            logger.info('Process spawned', { streamingId, pid: managedProcess.pid, spawnMs, type: managedProcess.type });
+            // For multimodal, send stdin message BEFORE waiting for init
+            // The CLI will process this and emit system init
+            if (hasMultimodalContent && config.initialContent) {
+                const contentBlocks = [
+                    ...config.initialContent,
+                    ...(config.initialPrompt ? [{ type: 'text', text: config.initialPrompt }] : [])
+                ];
+                const stdinMessage = JSON.stringify({
+                    type: 'user',
+                    message: {
+                        role: 'user',
+                        content: contentBlocks
+                    },
+                    session_id: config.resumedSessionId || ''
+                });
+                logger.info('Sending multimodal content via stdin', {
+                    streamingId,
+                    contentBlockCount: contentBlocks.length,
+                    messageLength: stdinMessage.length
+                });
+                managedProcess.write(stdinMessage + '\n');
+                // Close stdin to signal end of input - CLI will process and exit
+                managedProcess.endStdin?.();
+            }
+            // Wait for system init message
+            const systemInit = await this.waitForSystemInit(streamingId);
+            const totalSpawnMs = Date.now() - spawnStartTime;
+            logger.info('System init received', { streamingId, totalSpawnMs, waitForInitMs: totalSpawnMs - spawnMs });
+            // Store session ID mapping
+            this.sessionIds.set(streamingId, systemInit.session_id);
+            return { streamingId, systemInit };
+        }
+        catch (error) {
+            // Cleanup on failure
+            this.cleanup(streamingId);
+            throw error;
+        }
+    }
+    async handleStop(params) {
+        const success = await this.stopConversation(params.streamingId);
+        return { success };
+    }
+    handleForceKill(params) {
+        const success = this.forceKillConversation(params.streamingId);
+        return { success };
+    }
+    handleInterrupt(params) {
+        const success = this.interruptConversation(params.streamingId);
+        return { success };
+    }
+    handleWrite(params) {
+        const process = this.processes.get(params.streamingId);
+        if (!process) {
+            logger.warn('handleWrite: process not found', { streamingId: params.streamingId });
+            return { success: false };
+        }
+        logger.info('handleWrite: writing to PTY', {
+            streamingId: params.streamingId,
+            messageLength: params.message.length,
+            messagePreview: params.message.slice(0, 100)
+        });
+        process.write(params.message + '\n');
+        return { success: true };
+    }
+    handleSendQuestionAnswer(params) {
+        const process = this.processes.get(params.streamingId);
+        const sessionId = this.sessionIds.get(params.streamingId);
+        if (!process || !sessionId) {
+            return { success: false };
+        }
+        // Build the tool result content per SDK docs:
+        // { questions: [...], answers: { "Question text?": "Selected label" } }
+        const toolResultContent = JSON.stringify({
+            questions: params.questions,
+            answers: params.answers
+        });
+        // Format as a tool_result message per Claude CLI stream-json protocol
+        const stdinMessage = JSON.stringify({
+            type: 'user',
+            message: {
+                role: 'user',
+                content: [{
+                        type: 'tool_result',
+                        tool_use_id: params.toolUseId,
+                        content: toolResultContent
+                    }]
+            },
+            session_id: sessionId,
+        });
+        process.write(stdinMessage + '\n');
+        return { success: true };
+    }
+    async stopConversation(streamingId) {
+        const process = this.processes.get(streamingId);
+        if (!process) {
+            return false;
+        }
+        try {
+            if (!this.killedProcesses.has(streamingId)) {
+                logger.info('Sending SIGTERM to process', { streamingId, pid: process.pid });
+                process.kill('SIGTERM');
+                this.killedProcesses.add(streamingId);
+                // Force kill after 3s if process hasn't exited
+                const killTimeout = setTimeout(() => {
+                    try {
+                        if (this.processes.has(streamingId)) {
+                            logger.warn('Process not responding to SIGTERM, sending SIGKILL', { streamingId, pid: process.pid });
+                            process.kill('SIGKILL');
+                        }
+                    }
+                    catch {
+                        // Process may have already exited
+                    }
+                }, 3000);
+                const sessionTimeouts = this.timeouts.get(streamingId) || [];
+                sessionTimeouts.push(killTimeout);
+                this.timeouts.set(streamingId, sessionTimeouts);
+            }
+            // Note: cleanup happens in onExit handler, not here
+            logger.info('Stop signal sent', { streamingId });
+            return true;
+        }
+        catch (error) {
+            logger.error('Error stopping conversation', error, { streamingId });
+            return false;
+        }
+    }
+    forceKillConversation(streamingId) {
+        const process = this.processes.get(streamingId);
+        if (!process) {
+            return false;
+        }
+        try {
+            logger.warn('Force killing process with SIGKILL', { streamingId, pid: process.pid });
+            process.kill('SIGKILL');
+            this.killedProcesses.add(streamingId);
+            return true;
+        }
+        catch (error) {
+            logger.error('Error force killing conversation', error, { streamingId });
+            return false;
+        }
+    }
+    interruptConversation(streamingId) {
+        const process = this.processes.get(streamingId);
+        if (!process) {
+            return false;
+        }
+        try {
+            logger.info('Sending SIGINT to process', { streamingId, pid: process.pid });
+            process.kill('SIGINT');
+            return true;
+        }
+        catch (error) {
+            logger.error('Error interrupting conversation', error, { streamingId });
+            return false;
+        }
+    }
+    getActiveSessions() {
+        return Array.from(this.processes.keys()).map(streamingId => ({
+            streamingId,
+            sessionId: this.sessionIds.get(streamingId) || ''
+        })).filter(s => s.sessionId); // Only return sessions we have IDs for
+    }
+    isSessionActive(streamingId) {
+        return this.processes.has(streamingId);
+    }
+    cleanup(streamingId) {
+        const timeouts = this.timeouts.get(streamingId);
+        if (timeouts) {
+            timeouts.forEach((t) => clearTimeout(t));
+            this.timeouts.delete(streamingId);
+        }
+        this.processes.delete(streamingId);
+        this.outputBuffers.delete(streamingId);
+        this.conversationConfigs.delete(streamingId);
+        this.sessionIds.delete(streamingId);
+        this.killedProcesses.delete(streamingId);
+    }
+    // ============================================================================
+    // Process Handlers
+    // ============================================================================
+    /**
+     * Setup handlers for PTY-based processes (normal text conversations)
+     */
+    setupPtyProcessHandlers(streamingId, process) {
+        const parser = new JsonLinesParser();
+        this.outputBuffers.set(streamingId, '');
+        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;
+                if (!content) {
+                    return;
+                }
+                const isToolResult = Array.isArray(content) &&
+                    content.some((block) => block.type === 'tool_result');
+                if (!isToolResult) {
+                    // Filter non-tool-result user messages (echoed stdin)
+                    return;
+                }
+                // Fall through to emit tool_result messages
+                logger.debug('Allowing tool_result message through', {
+                    streamingId,
+                    toolResultCount: content.filter(b => b.type === 'tool_result').length
+                });
+            }
+            this.handleClaudeMessage(streamingId, message);
+        });
+        parser.on('error', (error) => {
+            this.handleProcessError(streamingId, error);
+        });
+        process.onData((data) => {
+            // Strip ANSI escape sequences
+            const cleanedData = data.replace(/\x1b\[[0-9;]*[a-zA-Z]|\x1b\][^\x07]*\x07/g, '');
+            if (cleanedData.trim()) {
+                // Debug: log first chunk to see if we're getting any output
+                if (!this.outputBuffers.get(streamingId)) {
+                    logger.debug('First PTY data received', {
+                        streamingId,
+                        dataLength: data.length,
+                        cleanedLength: cleanedData.length,
+                        preview: cleanedData.substring(0, 200)
+                    });
+                    this.outputBuffers.set(streamingId, 'received');
+                }
+                parser.write(cleanedData);
+            }
+        });
+        process.onExit(({ exitCode }) => {
+            this.handleProcessClose(streamingId, exitCode);
+        });
+    }
+    /**
+     * Setup handlers for piped child processes (multimodal with images)
+     * No stdin echo filtering needed since pipes don't echo
+     */
+    setupPipedProcessHandlers(streamingId, childProcess) {
+        const parser = new JsonLinesParser();
+        this.outputBuffers.set(streamingId, '');
+        parser.on('data', (message) => {
+            // Piped processes don't echo stdin, but still filter non-tool-result user messages
+            if (message?.type === 'user') {
+                const content = message.message?.content;
+                if (!content) {
+                    return;
+                }
+                const isToolResult = Array.isArray(content) &&
+                    content.some((block) => block.type === 'tool_result');
+                if (!isToolResult) {
+                    return;
+                }
+                logger.debug('Allowing tool_result message through (piped)', {
+                    streamingId,
+                    toolResultCount: content.filter(b => b.type === 'tool_result').length
+                });
+            }
+            this.handleClaudeMessage(streamingId, message);
+        });
+        parser.on('error', (error) => {
+            this.handleProcessError(streamingId, error);
+        });
+        childProcess.stdout?.on('data', (data) => {
+            const str = data.toString();
+            if (str.trim()) {
+                if (!this.outputBuffers.get(streamingId)) {
+                    logger.debug('First piped stdout data received', {
+                        streamingId,
+                        dataLength: str.length,
+                        preview: str.substring(0, 200)
+                    });
+                    this.outputBuffers.set(streamingId, 'received');
+                }
+                parser.write(str);
+            }
+        });
+        childProcess.stderr?.on('data', (data) => {
+            logger.warn('Claude CLI stderr (piped)', { streamingId, stderr: data.toString() });
+        });
+        childProcess.on('close', (code) => {
+            this.handleProcessClose(streamingId, code);
+        });
+        childProcess.on('error', (error) => {
+            this.handleProcessError(streamingId, error);
+        });
+    }
+    handleClaudeMessage(streamingId, message) {
+        // Check if this is the system init we're waiting for
+        if (message?.type === 'system' && 'subtype' in message && message.subtype === 'init') {
+            const initMessage = message;
+            logger.info('System init message received with MCP servers', {
+                streamingId,
+                mcpServerCount: initMessage.mcp_servers?.length || 0,
+                mcpServers: initMessage.mcp_servers,
+            });
+            const pending = this.pendingSystemInits.get(streamingId);
+            if (pending) {
+                clearTimeout(pending.timeout);
+                this.pendingSystemInits.delete(streamingId);
+                pending.resolve(initMessage);
+            }
+        }
+        // Broadcast to all connected clients
+        this.broadcastEvent({
+            event: 'claude-message',
+            data: { streamingId, message },
+        });
+        // Also emit locally for internal handlers
+        this.emit('claude-message', { streamingId, message });
+    }
+    handleProcessClose(streamingId, code) {
+        // Capture sessionId and pid BEFORE cleanup deletes them
+        const sessionId = this.sessionIds.get(streamingId);
+        const process = this.processes.get(streamingId);
+        const pid = process?.pid;
+        logger.info('Process closed', { streamingId, code, sessionId, pid });
+        // Reject any pending system init
+        const pending = this.pendingSystemInits.get(streamingId);
+        if (pending) {
+            clearTimeout(pending.timeout);
+            this.pendingSystemInits.delete(streamingId);
+            pending.reject(new LatticeError('CLAUDE_PROCESS_EXITED_EARLY', 'Claude CLI process exited before sending system init', 500));
+        }
+        this.cleanup(streamingId);
+        this.broadcastEvent({
+            event: 'process-closed',
+            data: { streamingId, code, sessionId, pid },
+        });
+        this.emit('process-closed', { streamingId, code, sessionId, pid });
+    }
+    handleProcessError(streamingId, error) {
+        logger.error('Process error', error, { streamingId });
+        this.broadcastEvent({
+            event: 'process-error',
+            data: { streamingId, error: error.message },
+        });
+        this.emit('process-error', { streamingId, error: error.message });
+    }
+    // ============================================================================
+    // Argument Building
+    // ============================================================================
+    buildBaseArgs() {
+        return ['-p'];
+    }
+    buildResumeArgs(config) {
+        const args = this.buildBaseArgs();
+        // For multimodal: no CLI arg message - full content sent via piped stdin
+        // For text-only: use the actual message as CLI arg (PTY spawn)
+        if (config.message && !config.hasMultimodalContent) {
+            args.push(config.message);
+        }
+        args.push('--resume', config.sessionId, '--output-format', 'stream-json', '--input-format', 'stream-json', '--verbose');
+        // Apply permission mode
+        this.applyPermissionMode(args, config.permissionMode, config.streamingId);
+        return args;
+    }
+    /**
+     * Apply permission mode flags to CLI args
+     * Modes:
+     * - "bypassPermissions" (default): Skip all permission prompts (--dangerously-skip-permissions)
+     * - "default": Delegate to MCP permission server via --permission-prompt-tool
+     * - "acceptEdits": Auto-accept file edits but prompt for other tools
+     * - "plan": Plan mode - research only, no edits
+     */
+    applyPermissionMode(args, permissionMode, streamingId) {
+        switch (permissionMode) {
+            case 'default':
+                // Delegate permission decisions to our MCP permission server
+                this.applyMcpPermissionPrompt(args, streamingId);
+                break;
+            case 'acceptEdits':
+                args.push('--permission-mode', 'acceptEdits');
+                break;
+            case 'plan':
+                args.push('--permission-mode', 'plan');
+                break;
+            case 'bypassPermissions':
+            default:
+                // Default to bypass for backwards compatibility
+                args.push('--dangerously-skip-permissions');
+                break;
+        }
+    }
+    /**
+     * Configure MCP permission prompt tool for interactive permission handling
+     */
+    applyMcpPermissionPrompt(args, streamingId) {
+        // Paths to our MCP servers
+        const mcpServerPath = path.join(__dirname, '..', 'mcp-server', 'index.js');
+        const claudiaToolsPath = path.join(__dirname, '..', 'mcp-server', 'claudia-tools.js');
+        // MCP server config - the server needs CUI_STREAMING_ID to associate permissions
+        const mcpConfig = {
+            mcpServers: {
+                'claudia-permissions': {
+                    command: 'node',
+                    args: [mcpServerPath],
+                    env: {
+                        CUI_STREAMING_ID: streamingId || 'unknown',
+                        CUI_SERVER_URL: `http://localhost:${process.env.PORT || 3001}`,
+                    },
+                },
+                'claudia-orchestrator': {
+                    command: 'node',
+                    args: [claudiaToolsPath],
+                    env: {
+                        CUI_STREAMING_ID: streamingId || 'unknown',
+                        CUI_SERVER_URL: `http://localhost:${process.env.PORT || 3001}`,
+                    },
+                },
+            },
+        };
+        args.push('--mcp-config', JSON.stringify(mcpConfig));
+        args.push('--permission-prompt-tool', 'mcp__claudia-permissions__permission_prompt');
+        logger.info('Applied MCP config', { streamingId, mcpServerPath, claudiaToolsPath });
+    }
+    buildStartArgs(config, streamingId) {
+        const args = this.buildBaseArgs();
+        // Add initial prompt as CLI arg - skip if multimodal content will be sent via stdin
+        const hasMultimodalContent = !!(config.initialContent && config.initialContent.length > 0);
+        if (config.initialPrompt && !hasMultimodalContent) {
+            args.push(config.initialPrompt);
+        }
+        args.push('--output-format', 'stream-json', '--input-format', 'stream-json', '--verbose');
+        if (config.model) {
+            args.push('--model', config.model);
+        }
+        if (config.allowedTools?.length) {
+            args.push('--allowedTools', config.allowedTools.join(','));
+        }
+        if (config.disallowedTools?.length) {
+            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);
+        // Apply permission mode
+        this.applyPermissionMode(args, config.permissionMode, streamingId);
+        return args;
+    }
+    // ============================================================================
+    // System Init Waiting
+    // ============================================================================
+    waitForSystemInit(streamingId) {
+        return new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => {
+                this.pendingSystemInits.delete(streamingId);
+                reject(new LatticeError('SYSTEM_INIT_TIMEOUT', 'Timeout waiting for system initialization from Claude CLI', 500));
+            }, 60000);
+            this.pendingSystemInits.set(streamingId, { resolve, reject, timeout });
+        });
+    }
+}
+//# sourceMappingURL=process-daemon.js.map