browser-debugger-cli 0.6.0 → 0.6.2

package/dist/daemon/ipcServer.js

@@ -1,26 +1,36 @@
 /**
- * Daemon IPC Server - Minimal JSONL handshake MVP
+ * Daemon IPC Server
  *
- * Starts a Unix domain socket server that:
- * 1. Listens for JSONL frames (newline-delimited JSON messages)
- * 2. Responds only to handshake requests
- * 3. Logs all incoming frames for debugging
+ * Coordinates socket server, worker manager, and request/response handlers.
+ * Responsibilities:
+ * - Socket lifecycle management
+ * - Message routing
+ * - Delegation to specialized handlers
  */
-import { readFileSync, writeFileSync, unlinkSync } from 'fs';
+import { unlinkSync } from 'fs';
+import { getErrorMessage } from '../connection/errors.js';
+import { PendingRequestManager } from '../daemon/handlers/pendingRequests.js';
+import { RequestHandlers } from '../daemon/handlers/requestHandlers.js';
+import { ResponseHandler } from '../daemon/handlers/responseHandler.js';
 import { SocketServer } from '../daemon/server/SocketServer.js';
 import { WorkerManager } from '../daemon/server/WorkerManager.js';
-import { WorkerStartError } from '../daemon/startSession.js';
-import { getCommandName, isCommandRequest, isCommandResponse, } from '../ipc/commands.js';
-import { IPCErrorCode } from '../ipc/types.js';
-import { cleanupSession } from '../session/cleanup.js';
+import { SessionService } from '../daemon/services/SessionService.js';
+import { isCommandRequest } from '../ipc/index.js';
 import { releaseDaemonLock } from '../session/lock.js';
-import { readSessionMetadata } from '../session/metadata.js';
 import { ensureSessionDir, getSessionFilePath, getDaemonSocketPath } from '../session/paths.js';
-import { readPid } from '../session/pid.js';
-import { isProcessAlive } from '../session/process.js';
-import { getErrorMessage } from '../ui/errors/index.js';
-import { fetchCDPTargets } from '../utils/http.js';
-import { filterDefined } from '../utils/objects.js';
+import { readPidFromFile } from '../session/pid.js';
+import { createLogger } from '../ui/logging/index.js';
+import { AtomicFileWriter } from '../utils/atomicFile.js';
+const log = createLogger('daemon');
+/**
+ * Type guard to validate parsed JSON has expected message structure.
+ */
+function isValidIPCMessage(obj) {
+    if (typeof obj !== 'object' || obj === null) {
+        return false;
+    }
+    return 'type' in obj && typeof obj.type === 'string' && 'sessionId' in obj;
+}
 /**
  * Simple JSONL IPC server for daemon communication.
  */
@@ -28,10 +38,24 @@ export class IPCServer {
     startTime = Date.now();
     socketServer = new SocketServer();
     workerManager = new WorkerManager();
-    pendingDomRequests = new Map(); // requestId -> pending request
+    pendingRequests = new PendingRequestManager();
+    sessionService = new SessionService();
+    // Delegate handlers
+    requestHandlers;
+    responseHandler;
     constructor() {
-        this.workerManager.on('message', (message) => this.handleWorkerResponse(message));
-        this.workerManager.on('exit', (code, signal) => this.handleWorkerExit(code, signal));
+        // Initialize handlers with dependencies
+        this.requestHandlers = new RequestHandlers(this.workerManager, this.pendingRequests, this.sessionService, (socket, response) => this.sendResponse(socket, response), this.startTime);
+        this.responseHandler = new ResponseHandler(this.pendingRequests, this.sessionService, (socket, response) => this.sendResponse(socket, response));
+        // Wire up worker events
+        this.workerManager.on('message', (message) => this.responseHandler.handleWorkerResponse(message));
+        this.workerManager.on('exit', (code, signal) => this.responseHandler.handleWorkerExit(code, signal));
+    }
+    /**
+     * Send a JSONL response to client socket.
+     */
+    sendResponse(socket, response) {
+        socket.write(JSON.stringify(response) + '\n');
     }
     /**
      * Start the IPC server on Unix domain socket.
@@ -68,662 +92,59 @@ export class IPCServer {
         });
     }
     /**
-     * Handle incoming JSONL message.
+     * Handle incoming JSONL message - route to appropriate handler.
      */
     handleMessage(socket, line) {
         console.error('[daemon] Raw frame:', line);
         try {
             // Parse message - could be either IPC message or command request
-            const message = JSON.parse(line);
+            const parsed = JSON.parse(line);
+            if (!isValidIPCMessage(parsed)) {
+                console.error('[daemon] Invalid message structure:', parsed);
+                return;
+            }
+            const message = parsed;
             // Check if this is a command request
             if (isCommandRequest(message.type)) {
-                this.handleCommandRequest(socket, message);
+                this.requestHandlers.handleCommandRequest(socket, message);
                 return;
             }
+            // Filter out response messages (should never be received from client)
+            if (message.type.endsWith('_response')) {
+                console.error(`[daemon] Unexpected response message from client: ${message.type}`);
+                return;
+            }
+            // Route to appropriate handler
             switch (message.type) {
                 case 'handshake_request':
-                    this.handleHandshake(socket, message);
-                    break;
-                case 'handshake_response':
-                    // Response messages are sent by daemon, not received
-                    console.error('[daemon] Unexpected handshake response from client');
+                    this.requestHandlers.handleHandshake(socket, message);
                     break;
                 case 'status_request':
-                    this.handleStatusRequest(socket, message);
-                    break;
-                case 'status_response':
-                    // Response messages are sent by daemon, not received
-                    console.error('[daemon] Unexpected status response from client');
+                    this.requestHandlers.handleStatusRequest(socket, message);
                     break;
                 case 'peek_request':
-                    this.handlePeekRequest(socket, message);
-                    break;
-                case 'peek_response':
-                    // Response messages are sent by daemon, not received
-                    console.error('[daemon] Unexpected peek response from client');
+                    this.requestHandlers.handlePeekRequest(socket, message);
                     break;
                 case 'start_session_request':
-                    void this.handleStartSessionRequest(socket, message);
-                    break;
-                case 'start_session_response':
-                    // Response messages are sent by daemon, not received
-                    console.error('[daemon] Unexpected start session response from client');
+                    void this.requestHandlers.handleStartSessionRequest(socket, message);
                     break;
                 case 'stop_session_request':
-                    this.handleStopSessionRequest(socket, message);
+                    this.requestHandlers.handleStopSessionRequest(socket, message);
                     break;
+                case 'handshake_response':
+                case 'status_response':
+                case 'peek_response':
+                case 'start_session_response':
                 case 'stop_session_response':
-                    // Response messages are sent by daemon, not received
-                    console.error('[daemon] Unexpected stop session response from client');
+                    // Already filtered above, but keeping cases for exhaustiveness check
+                    console.error('[daemon] Unexpected response message (should have been filtered)');
                     break;
-                // NOTE: DOM command responses are now handled via command system (see commands.ts)
             }
         }
         catch (error) {
             console.error('[daemon] Failed to parse message:', error);
         }
     }
-    /**
-     * Handle handshake request.
-     */
-    handleHandshake(socket, request) {
-        console.error(`[daemon] Handshake request received (sessionId: ${request.sessionId})`);
-        const response = {
-            type: 'handshake_response',
-            sessionId: request.sessionId,
-            status: 'ok',
-            message: 'Handshake successful',
-        };
-        // Send JSONL response (JSON + newline)
-        socket.write(JSON.stringify(response) + '\n');
-        console.error('[daemon] Handshake response sent');
-    }
-    /**
-     * Handle status request.
-     */
-    handleStatusRequest(socket, request) {
-        console.error(`[daemon] Status request received (sessionId: ${request.sessionId})`);
-        try {
-            // Gather daemon metadata
-            const data = {
-                daemonPid: process.pid,
-                daemonStartTime: this.startTime,
-                socketPath: getSessionFilePath('DAEMON_SOCKET'),
-            };
-            // Check for active session
-            const sessionPid = readPid();
-            if (sessionPid && isProcessAlive(sessionPid)) {
-                data.sessionPid = sessionPid;
-                // Try to read session metadata
-                const metadata = readSessionMetadata({ warnOnCorruption: true });
-                if (metadata) {
-                    data.sessionMetadata = filterDefined({
-                        bdgPid: metadata.bdgPid,
-                        chromePid: metadata.chromePid,
-                        startTime: metadata.startTime,
-                        port: metadata.port,
-                        targetId: metadata.targetId,
-                        webSocketDebuggerUrl: metadata.webSocketDebuggerUrl,
-                        activeTelemetry: metadata.activeTelemetry,
-                    });
-                }
-                // Query worker for live activity data if worker is available
-                if (this.workerManager.hasActiveWorker()) {
-                    const requestId = `worker_status_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
-                    // Set timeout for worker response
-                    const timeout = setTimeout(() => {
-                        this.pendingDomRequests.delete(requestId);
-                        // Send response without activity data if worker times out
-                        const response = {
-                            type: 'status_response',
-                            sessionId: request.sessionId,
-                            status: 'ok',
-                            data,
-                        };
-                        socket.write(JSON.stringify(response) + '\n');
-                        console.error('[daemon] Status response sent (worker timeout)');
-                    }, 5000);
-                    // Track pending request with special handling for status
-                    this.pendingDomRequests.set(requestId, {
-                        socket,
-                        sessionId: request.sessionId,
-                        timeout,
-                        statusData: data, // Store base status data
-                        commandName: 'worker_status',
-                    });
-                    // Forward to worker
-                    const workerRequest = {
-                        type: 'worker_status_request',
-                        requestId,
-                    };
-                    try {
-                        this.workerManager.send(workerRequest);
-                        console.error(`[daemon] Forwarded worker_status_request to worker (requestId: ${requestId})`);
-                        return; // Will send response when worker responds
-                    }
-                    catch (error) {
-                        clearTimeout(timeout);
-                        this.pendingDomRequests.delete(requestId);
-                        console.error(`[daemon] Failed to forward worker_status_request: ${getErrorMessage(error)}`);
-                    }
-                }
-            }
-            // Send response immediately if no worker
-            const response = {
-                type: 'status_response',
-                sessionId: request.sessionId,
-                status: 'ok',
-                data,
-            };
-            socket.write(JSON.stringify(response) + '\n');
-            console.error('[daemon] Status response sent');
-        }
-        catch (error) {
-            const response = {
-                type: 'status_response',
-                sessionId: request.sessionId,
-                status: 'error',
-                error: `Failed to gather status: ${getErrorMessage(error)}`,
-            };
-            socket.write(JSON.stringify(response) + '\n');
-            console.error('[daemon] Status error response sent');
-        }
-    }
-    /**
-     * Handle peek request - forward to worker via IPC.
-     */
-    handlePeekRequest(socket, request) {
-        console.error(`[daemon] Peek request received (sessionId: ${request.sessionId})`);
-        // Check for active worker process
-        if (!this.workerManager.hasActiveWorker()) {
-            const response = {
-                type: 'peek_response',
-                sessionId: request.sessionId,
-                status: 'error',
-                error: 'No active worker process',
-            };
-            socket.write(JSON.stringify(response) + '\n');
-            console.error('[daemon] Peek error response sent (no worker)');
-            return;
-        }
-        // Generate unique request ID
-        const requestId = `worker_peek_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
-        // Set timeout for worker response
-        const timeout = setTimeout(() => {
-            this.pendingDomRequests.delete(requestId);
-            const response = {
-                type: 'peek_response',
-                sessionId: request.sessionId,
-                status: 'error',
-                error: 'Worker response timeout (5s)',
-            };
-            socket.write(JSON.stringify(response) + '\n');
-            console.error('[daemon] Peek timeout response sent');
-        }, 5000);
-        // Track pending request
-        this.pendingDomRequests.set(requestId, {
-            socket,
-            sessionId: request.sessionId,
-            timeout,
-            commandName: 'worker_peek',
-        });
-        // Forward to worker
-        const workerRequest = {
-            type: 'worker_peek_request',
-            requestId,
-            lastN: 10, // Default limit for preview items (PeekRequest doesn't include lastN)
-        };
-        try {
-            this.workerManager.send(workerRequest);
-            console.error(`[daemon] Forwarded worker_peek_request to worker (requestId: ${requestId})`);
-        }
-        catch (error) {
-            clearTimeout(timeout);
-            this.pendingDomRequests.delete(requestId);
-            const response = {
-                type: 'peek_response',
-                sessionId: request.sessionId,
-                status: 'error',
-                error: getErrorMessage(error),
-            };
-            socket.write(JSON.stringify(response) + '\n');
-            console.error(`[daemon] Failed to forward worker_peek_request: ${getErrorMessage(error)}`);
-        }
-    }
-    /**
-     * Handle start session request.
-     */
-    async handleStartSessionRequest(socket, request) {
-        console.error(`[daemon] Start session request received (sessionId: ${request.sessionId}, url: ${request.url})`);
-        try {
-            // Check for existing session (concurrency guard)
-            const sessionPid = readPid();
-            if (sessionPid && isProcessAlive(sessionPid)) {
-                // Read session metadata to provide helpful error context
-                const metadata = readSessionMetadata({ warnOnCorruption: false });
-                const startTime = metadata?.startTime;
-                const duration = startTime ? Math.floor((Date.now() - startTime) / 1000) : undefined;
-                // Try to get target URL from CDP
-                let targetUrl;
-                if (metadata?.port && metadata?.targetId) {
-                    try {
-                        const targets = await fetchCDPTargets(metadata.port);
-                        const target = targets.find((t) => t.id === metadata.targetId);
-                        if (target) {
-                            targetUrl = target.url;
-                        }
-                    }
-                    catch {
-                        // Ignore CDP fetch errors
-                    }
-                }
-                const response = {
-                    type: 'start_session_response',
-                    sessionId: request.sessionId,
-                    status: 'error',
-                    message: `Session already running (PID ${sessionPid}). Stop it first with stop_session_request.`,
-                    errorCode: IPCErrorCode.SESSION_ALREADY_RUNNING,
-                    existingSession: {
-                        pid: sessionPid,
-                        ...(targetUrl && { targetUrl }),
-                        ...(startTime && { startTime }),
-                        ...(duration !== undefined && { duration }),
-                    },
-                };
-                socket.write(JSON.stringify(response) + '\n');
-                console.error('[daemon] Start session error response sent (session already running)');
-                return;
-            }
-            // Launch worker
-            console.error('[daemon] Launching worker...');
-            try {
-                const metadata = await this.workerManager.launch(request.url, filterDefined({
-                    port: request.port,
-                    timeout: request.timeout,
-                    telemetry: request.telemetry,
-                    includeAll: request.includeAll,
-                    userDataDir: request.userDataDir,
-                    maxBodySize: request.maxBodySize,
-                    headless: request.headless,
-                    chromeWsUrl: request.chromeWsUrl,
-                }));
-                console.error('[daemon] Worker launched successfully');
-                // Build response data
-                const data = {
-                    workerPid: metadata.workerPid,
-                    chromePid: metadata.chromePid,
-                    port: metadata.port,
-                    targetUrl: metadata.targetUrl,
-                    ...(metadata.targetTitle !== undefined && { targetTitle: metadata.targetTitle }),
-                };
-                const response = {
-                    type: 'start_session_response',
-                    sessionId: request.sessionId,
-                    status: 'ok',
-                    data,
-                    message: 'Session started successfully',
-                };
-                socket.write(JSON.stringify(response) + '\n');
-                console.error('[daemon] Start session response sent');
-            }
-            catch (error) {
-                // Map worker errors to IPC error codes
-                let errorCode = IPCErrorCode.WORKER_START_FAILED;
-                let errorMessage = 'Failed to start worker';
-                if (error instanceof WorkerStartError) {
-                    // Include error details (contains worker stderr) for debugging
-                    errorMessage = error.details ? `${error.message}\n${error.details}` : error.message;
-                    switch (error.code) {
-                        case 'SPAWN_FAILED':
-                        case 'WORKER_CRASH':
-                        case 'INVALID_READY_MESSAGE':
-                            errorCode = IPCErrorCode.WORKER_START_FAILED;
-                            break;
-                        case 'READY_TIMEOUT':
-                            errorCode = IPCErrorCode.CDP_TIMEOUT;
-                            break;
-                    }
-                }
-                else {
-                    errorMessage = getErrorMessage(error);
-                }
-                const response = {
-                    type: 'start_session_response',
-                    sessionId: request.sessionId,
-                    status: 'error',
-                    message: errorMessage,
-                    errorCode,
-                };
-                socket.write(JSON.stringify(response) + '\n');
-                console.error(`[daemon] Start session error response sent (${errorCode})`);
-            }
-        }
-        catch (error) {
-            const response = {
-                type: 'start_session_response',
-                sessionId: request.sessionId,
-                status: 'error',
-                message: `Daemon error: ${getErrorMessage(error)}`,
-                errorCode: IPCErrorCode.DAEMON_ERROR,
-            };
-            socket.write(JSON.stringify(response) + '\n');
-            console.error('[daemon] Start session error response sent (daemon error)');
-        }
-    }
-    /**
-     * Handle stop session request.
-     */
-    handleStopSessionRequest(socket, request) {
-        console.error(`[daemon] Stop session request received (sessionId: ${request.sessionId})`);
-        try {
-            // Check for active session
-            const sessionPid = readPid();
-            if (!sessionPid || !isProcessAlive(sessionPid)) {
-                const response = {
-                    type: 'stop_session_response',
-                    sessionId: request.sessionId,
-                    status: 'error',
-                    message: 'No active session found',
-                    errorCode: IPCErrorCode.NO_SESSION,
-                };
-                socket.write(JSON.stringify(response) + '\n');
-                console.error('[daemon] Stop session error response sent (no session)');
-                return;
-            }
-            // Capture Chrome PID BEFORE cleanup (so CLI can kill Chrome if needed)
-            const metadata = readSessionMetadata({ warnOnCorruption: true });
-            const chromePid = metadata?.chromePid;
-            if (chromePid) {
-                console.error(`[daemon] Captured Chrome PID ${chromePid} before cleanup`);
-            }
-            // Kill the session process (use SIGTERM for graceful shutdown)
-            try {
-                process.kill(sessionPid, 'SIGTERM');
-                console.error(`[daemon] Sent SIGTERM to session process (PID ${sessionPid})`);
-            }
-            catch (killError) {
-                const errorMessage = killError instanceof Error ? killError.message : String(killError);
-                const response = {
-                    type: 'stop_session_response',
-                    sessionId: request.sessionId,
-                    status: 'error',
-                    message: `Failed to kill session process: ${errorMessage}`,
-                    errorCode: IPCErrorCode.SESSION_KILL_FAILED,
-                };
-                socket.write(JSON.stringify(response) + '\n');
-                console.error('[daemon] Stop session error response sent (kill failed)');
-                return;
-            }
-            // Clean up session files
-            cleanupSession();
-            console.error('[daemon] Cleaned up session files');
-            // Clear worker process reference
-            this.workerManager.dispose();
-            console.error('[daemon] Cleared worker process reference');
-            const response = {
-                type: 'stop_session_response',
-                sessionId: request.sessionId,
-                status: 'ok',
-                message: 'Session stopped successfully',
-                ...(chromePid !== undefined && { chromePid }),
-            };
-            socket.write(JSON.stringify(response) + '\n');
-            console.error('[daemon] Stop session response sent');
-            // Release lock immediately so new sessions can start
-            releaseDaemonLock();
-            console.error('[daemon] Daemon lock released');
-            // Shutdown daemon after successful stop
-            // Give socket time to flush response, then exit gracefully
-            setTimeout(() => {
-                console.error('[daemon] Shutting down daemon after successful stop');
-                process.exit(0);
-            }, 100);
-        }
-        catch (error) {
-            const response = {
-                type: 'stop_session_response',
-                sessionId: request.sessionId,
-                status: 'error',
-                message: `Failed to stop session: ${getErrorMessage(error)}`,
-                errorCode: IPCErrorCode.DAEMON_ERROR,
-            };
-            socket.write(JSON.stringify(response) + '\n');
-            console.error('[daemon] Stop session error response sent');
-        }
-    }
-    /**
-     * Handle response from worker (lifecycle signals or command responses).
-     */
-    handleWorkerResponse(message) {
-        console.error(`[daemon] Received worker response: ${message.type} (requestId: ${message.requestId})`);
-        // Check for ready signal (not a command response)
-        if (message.type === 'worker_ready') {
-            console.error('[daemon] Worker ready signal (already processed during launch)');
-            return;
-        }
-        // Check if this is a command response
-        if (isCommandResponse(message.type)) {
-            // Look up pending request
-            const pending = this.pendingDomRequests.get(message.requestId);
-            if (!pending) {
-                console.error(`[daemon] No pending request found for requestId: ${message.requestId}`);
-                return;
-            }
-            // Clear timeout and remove from pending
-            clearTimeout(pending.timeout);
-            this.pendingDomRequests.delete(message.requestId);
-            // Forward response to client (pass pending data for special handling)
-            this.forwardCommandResponse(pending.socket, pending.sessionId, message, pending);
-        }
-    }
-    handleWorkerExit(code, signal) {
-        console.error(`[daemon] Worker exit detected (code: ${code ?? 'null'}, signal: ${signal ?? 'null'})`);
-        if (this.pendingDomRequests.size === 0) {
-            return;
-        }
-        const errorMessage = 'Worker process exited before responding';
-        for (const [requestId, pending] of this.pendingDomRequests.entries()) {
-            clearTimeout(pending.timeout);
-            this.pendingDomRequests.delete(requestId);
-            if (pending.commandName === 'worker_status') {
-                const statusResponse = {
-                    type: 'status_response',
-                    sessionId: pending.sessionId,
-                    status: 'error',
-                    ...(pending.statusData && { data: pending.statusData }),
-                    error: errorMessage,
-                };
-                pending.socket.write(JSON.stringify(statusResponse) + '\n');
-                continue;
-            }
-            if (pending.commandName === 'worker_peek') {
-                const peekResponse = {
-                    type: 'peek_response',
-                    sessionId: pending.sessionId,
-                    status: 'error',
-                    error: errorMessage,
-                };
-                pending.socket.write(JSON.stringify(peekResponse) + '\n');
-                continue;
-            }
-            if (pending.commandName) {
-                const response = {
-                    type: `${pending.commandName}_response`,
-                    sessionId: pending.sessionId,
-                    status: 'error',
-                    error: errorMessage,
-                };
-                pending.socket.write(JSON.stringify(response) + '\n');
-                continue;
-            }
-            const fallback = {
-                type: 'status_response',
-                sessionId: pending.sessionId,
-                status: 'error',
-                error: errorMessage,
-            };
-            pending.socket.write(JSON.stringify(fallback) + '\n');
-        }
-    }
-    /**
-     * Generic forwarder for all command responses.
-     */
-    forwardCommandResponse(socket, sessionId, workerResponse, pendingRequest) {
-        const commandName = getCommandName(workerResponse.type);
-        if (!commandName) {
-            console.error(`[daemon] Invalid worker response type: ${workerResponse.type}`);
-            return;
-        }
-        // Special handling for worker_status - merge with base status data
-        if (commandName === 'worker_status') {
-            this.forwardWorkerStatusResponse(socket, sessionId, workerResponse, pendingRequest);
-            return;
-        }
-        // Special handling for worker_peek - transform to PeekResponse format
-        if (commandName === 'worker_peek') {
-            const { requestId: _requestId, success, data, error, } = workerResponse;
-            const peekResponse = {
-                type: 'peek_response',
-                sessionId,
-                status: success ? 'ok' : 'error',
-                ...(success &&
-                    data && {
-                    data: {
-                        sessionPid: readPid() ?? 0,
-                        preview: {
-                            version: data.version,
-                            success: true,
-                            timestamp: new Date(data.startTime).toISOString(),
-                            duration: data.duration,
-                            target: data.target,
-                            data: {
-                                network: data.network,
-                                console: data.console,
-                            },
-                            partial: true,
-                        },
-                    },
-                }),
-                ...(error && { error }),
-            };
-            socket.write(JSON.stringify(peekResponse) + '\n');
-            console.error('[daemon] Forwarded worker_peek_response to client (transformed to PeekResponse)');
-            return;
-        }
-        // Default handling for other commands
-        const { requestId: _requestId, success, ...rest } = workerResponse;
-        const response = {
-            ...rest,
-            type: `${commandName}_response`,
-            sessionId,
-            status: success ? 'ok' : 'error',
-        };
-        socket.write(JSON.stringify(response) + '\n');
-        console.error(`[daemon] Forwarded ${commandName}_response to client`);
-    }
-    forwardWorkerStatusResponse(socket, sessionId, workerResponse, pendingRequest) {
-        const { success, data, error } = workerResponse;
-        const baseStatusData = pendingRequest?.statusData;
-        if (success && data && baseStatusData) {
-            const enrichedData = {
-                ...baseStatusData,
-                activity: data.activity,
-                pageState: data.target,
-            };
-            const statusResponse = {
-                type: 'status_response',
-                sessionId,
-                status: 'ok',
-                data: enrichedData,
-            };
-            socket.write(JSON.stringify(statusResponse) + '\n');
-            console.error('[daemon] Forwarded worker_status_response to client (enriched with activity data)');
-            return;
-        }
-        if (baseStatusData) {
-            const statusResponse = {
-                type: 'status_response',
-                sessionId,
-                status: error ? 'error' : 'ok',
-                data: baseStatusData,
-                ...(error && { error }),
-            };
-            socket.write(JSON.stringify(statusResponse) + '\n');
-            console.error('[daemon] Forwarded status_response to client (worker query failed, using base data only)');
-            return;
-        }
-        const fallback = {
-            type: 'status_response',
-            sessionId,
-            status: 'error',
-            error: error ?? 'Failed to retrieve status data',
-        };
-        socket.write(JSON.stringify(fallback) + '\n');
-        console.error('[daemon] Forwarded status_response error (no base data available)');
-    }
-    /**
-     * Generic handler for all command requests.
-     */
-    handleCommandRequest(socket, request) {
-        const commandName = getCommandName(request.type);
-        if (!commandName) {
-            console.error(`[daemon] Invalid command type: ${request.type}`);
-            return;
-        }
-        console.error(`[daemon] ${commandName} request received (sessionId: ${request.sessionId})`);
-        if (!this.workerManager.hasActiveWorker()) {
-            const response = {
-                type: `${commandName}_response`,
-                sessionId: request.sessionId,
-                status: 'error',
-                error: 'No active worker process',
-            };
-            socket.write(JSON.stringify(response) + '\n');
-            console.error(`[daemon] ${commandName} error response sent (no worker)`);
-            return;
-        }
-        const requestId = `${commandName}_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
-        const timeout = setTimeout(() => {
-            this.pendingDomRequests.delete(requestId);
-            const response = {
-                type: `${commandName}_response`,
-                sessionId: request.sessionId,
-                status: 'error',
-                error: 'Worker response timeout (10s)',
-            };
-            socket.write(JSON.stringify(response) + '\n');
-            console.error(`[daemon] ${commandName} timeout response sent`);
-        }, 10000);
-        this.pendingDomRequests.set(requestId, {
-            socket,
-            sessionId: request.sessionId,
-            timeout,
-            commandName,
-        });
-        // Extract only sessionId, keep all other fields including 'type' param if it exists
-        const { sessionId: _sessionId, type: _ipcType, ...params } = request;
-        const workerRequest = {
-            type: `${commandName}_request`,
-            requestId,
-            ...params,
-        };
-        try {
-            this.workerManager.send(workerRequest);
-            console.error(`[daemon] Forwarded ${commandName}_request to worker (requestId: ${requestId})`);
-        }
-        catch (error) {
-            clearTimeout(timeout);
-            this.pendingDomRequests.delete(requestId);
-            const response = {
-                type: `${commandName}_response`,
-                sessionId: request.sessionId,
-                status: 'error',
-                error: getErrorMessage(error),
-            };
-            socket.write(JSON.stringify(response) + '\n');
-            console.error(`[daemon] Failed to forward ${commandName}_request to worker: ${getErrorMessage(error)}`);
-        }
-    }
     /**
      * Stop the IPC server and cleanup.
      */
@@ -735,24 +156,28 @@ export class IPCServer {
         try {
             unlinkSync(socketPath);
         }
-        catch {
-            // Ignore if already deleted
+        catch (error) {
+            log.debug(`Failed to remove socket file: ${getErrorMessage(error)}`);
         }
         const pidPath = getSessionFilePath('DAEMON_PID');
         try {
             unlinkSync(pidPath);
         }
-        catch {
-            // Ignore if already deleted
+        catch (error) {
+            log.debug(`Failed to remove PID file: ${getErrorMessage(error)}`);
         }
     }
     /**
      * Write daemon PID to file for tracking.
+     *
+     * Uses AtomicFileWriter to prevent corruption from crashes during write,
+     * ensuring daemon.pid is never left in a truncated/corrupt state that
+     * would cause parseInt errors during cleanup.
      */
     writePidFile() {
         const pidPath = getSessionFilePath('DAEMON_PID');
         try {
-            writeFileSync(pidPath, process.pid.toString(), 'utf-8');
+            AtomicFileWriter.writeSync(pidPath, process.pid.toString(), { encoding: 'utf-8' });
             releaseDaemonLock(); // Release lock after PID is written (P0 Fix #1)
             console.error(`[daemon] PID file written: ${pidPath}`);
         }
@@ -765,13 +190,16 @@ export class IPCServer {
      */
     static isRunning() {
         const pidPath = getSessionFilePath('DAEMON_PID');
+        const pid = readPidFromFile(pidPath);
+        if (pid === null) {
+            return false;
+        }
         try {
-            const pid = parseInt(readFileSync(pidPath, 'utf-8').trim(), 10);
-            // Check if process is alive
             process.kill(pid, 0);
             return true;
         }
-        catch {
+        catch (error) {
+            log.debug(`Process ${pid} not alive: ${getErrorMessage(error)}`);
             return false;
         }
     }