browser-debugger-cli 0.0.1-alpha.0 → 0.1.0-alpha.1

package/dist/daemon/ipcServer.js

@@ -0,0 +1,670 @@
+/**
+ * Daemon IPC Server - Minimal JSONL handshake MVP
+ *
+ * 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
+ */
+import { readFileSync, writeFileSync, unlinkSync } from 'fs';
+import { createServer } from 'net';
+import { launchSessionInWorker, WorkerStartError } from './startSession.js';
+import { getCommandName, isCommandRequest, isCommandResponse, } from '../ipc/commands.js';
+import { IPCErrorCode } from '../ipc/types.js';
+import { cleanupSession } from '../session/cleanup.js';
+import { releaseDaemonLock } from '../session/lock.js';
+import { readSessionMetadata } from '../session/metadata.js';
+import { ensureSessionDir, getSessionFilePath } from '../session/paths.js';
+import { readPid } from '../session/pid.js';
+import { isProcessAlive } from '../session/process.js';
+import { getErrorMessage } from '../utils/errors.js';
+import { fetchCDPTargets } from '../utils/http.js';
+import { filterDefined } from '../utils/objects.js';
+/**
+ * Simple JSONL IPC server for daemon communication.
+ */
+export class IPCServer {
+    server = null;
+    clients = new Set();
+    startTime = Date.now();
+    workerProcess = null;
+    pendingDomRequests = new Map(); // requestId -> pending request
+    /**
+     * Start the IPC server on Unix domain socket.
+     */
+    async start() {
+        // Ensure ~/.bdg directory exists
+        ensureSessionDir();
+        // Clean up stale socket if exists
+        const socketPath = getSessionFilePath('DAEMON_SOCKET');
+        try {
+            unlinkSync(socketPath);
+        }
+        catch {
+            // Ignore if socket doesn't exist
+        }
+        this.server = createServer((socket) => {
+            this.handleConnection(socket);
+        });
+        await new Promise((resolve, reject) => {
+            if (!this.server) {
+                reject(new Error('Server not initialized'));
+                return;
+            }
+            this.server.listen(socketPath, () => {
+                console.error(`[daemon] IPC server listening on ${socketPath}`);
+                this.writePidFile();
+                resolve();
+            });
+            this.server.on('error', (err) => {
+                console.error('[daemon] Server error:', err);
+                reject(err);
+            });
+        });
+    }
+    /**
+     * Handle new client connection.
+     */
+    handleConnection(socket) {
+        console.error('[daemon] Client connected');
+        this.clients.add(socket);
+        let buffer = '';
+        socket.on('data', (chunk) => {
+            buffer += chunk.toString('utf-8');
+            // Process complete JSONL frames (separated by newlines)
+            const lines = buffer.split('\n');
+            buffer = lines.pop() ?? ''; // Keep incomplete line in buffer
+            for (const line of lines) {
+                if (line.trim()) {
+                    this.handleMessage(socket, line);
+                }
+            }
+        });
+        socket.on('end', () => {
+            console.error('[daemon] Client disconnected');
+            this.clients.delete(socket);
+        });
+        socket.on('error', (err) => {
+            console.error('[daemon] Socket error:', err);
+            this.clients.delete(socket);
+        });
+    }
+    /**
+     * Handle incoming JSONL message.
+     */
+    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);
+            // Check if this is a command request
+            if (isCommandRequest(message.type)) {
+                this.handleCommandRequest(socket, message);
+                return;
+            }
+            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');
+                    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');
+                    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');
+                    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');
+                    break;
+                case 'stop_session_request':
+                    this.handleStopSessionRequest(socket, message);
+                    break;
+                case 'stop_session_response':
+                    // Response messages are sent by daemon, not received
+                    console.error('[daemon] Unexpected stop session response from client');
+                    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,
+                        activeCollectors: metadata.activeCollectors,
+                    });
+                }
+            }
+            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.workerProcess?.stdin) {
+            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 });
+        // Forward to worker
+        const workerRequest = {
+            type: 'worker_peek_request',
+            requestId,
+            lastN: 10, // TODO: Extract from PeekRequest if needed
+        };
+        this.workerProcess.stdin.write(JSON.stringify(workerRequest) + '\n');
+        console.error(`[daemon] Forwarded worker_peek_request to worker (requestId: ${requestId})`);
+    }
+    /**
+     * 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 launchSessionInWorker(request.url, filterDefined({
+                    port: request.port,
+                    timeout: request.timeout,
+                    collectors: request.collectors,
+                    includeAll: request.includeAll,
+                    userDataDir: request.userDataDir,
+                    maxBodySize: request.maxBodySize,
+                }));
+                console.error('[daemon] Worker launched successfully');
+                // Store worker process for IPC
+                this.workerProcess = metadata.workerProcess;
+                // Set up worker stdout listener for DOM responses
+                this.setupWorkerListener(metadata.workerProcess);
+                // 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.workerProcess = null;
+            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');
+        }
+        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');
+        }
+    }
+    /**
+     * Set up worker stdout listener for IPC responses.
+     */
+    setupWorkerListener(worker) {
+        let buffer = '';
+        if (!worker.stdout) {
+            console.error('[daemon] Warning: Worker stdout not available');
+            return;
+        }
+        worker.stdout.on('data', (chunk) => {
+            buffer += chunk.toString('utf-8');
+            // Process complete JSONL frames (separated by newlines)
+            const lines = buffer.split('\n');
+            buffer = lines.pop() ?? ''; // Keep incomplete line in buffer
+            for (const line of lines) {
+                if (!line.trim())
+                    continue;
+                try {
+                    // Parse message - could be either lifecycle signal or command response
+                    const message = JSON.parse(line);
+                    this.handleWorkerResponse(message);
+                }
+                catch (error) {
+                    // Ignore parse errors, may be log messages
+                    console.error(`[daemon] Failed to parse worker stdout line: ${getErrorMessage(error)}`);
+                }
+            }
+        });
+        console.error('[daemon] Worker stdout listener set up');
+    }
+    /**
+     * 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
+            this.forwardCommandResponse(pending.socket, pending.sessionId, message);
+        }
+    }
+    /**
+     * Generic forwarder for all command responses.
+     */
+    forwardCommandResponse(socket, sessionId, workerResponse) {
+        const commandName = getCommandName(workerResponse.type);
+        if (!commandName) {
+            console.error(`[daemon] Invalid worker response type: ${workerResponse.type}`);
+            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`);
+    }
+    /**
+     * 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.workerProcess?.stdin) {
+            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 });
+        // 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,
+        };
+        this.workerProcess.stdin.write(JSON.stringify(workerRequest) + '\n');
+        console.error(`[daemon] Forwarded ${commandName}_request to worker (requestId: ${requestId})`);
+    }
+    /**
+     * Stop the IPC server and cleanup.
+     */
+    async stop() {
+        // Close all client connections
+        for (const socket of this.clients) {
+            socket.destroy();
+        }
+        this.clients.clear();
+        // Close server
+        if (this.server) {
+            await new Promise((resolve) => {
+                this.server?.close(() => {
+                    console.error('[daemon] IPC server stopped');
+                    resolve();
+                });
+            });
+            this.server = null;
+        }
+        // Cleanup files
+        const socketPath = getSessionFilePath('DAEMON_SOCKET');
+        try {
+            unlinkSync(socketPath);
+        }
+        catch {
+            // Ignore if already deleted
+        }
+        const pidPath = getSessionFilePath('DAEMON_PID');
+        try {
+            unlinkSync(pidPath);
+        }
+        catch {
+            // Ignore if already deleted
+        }
+    }
+    /**
+     * Write daemon PID to file for tracking.
+     */
+    writePidFile() {
+        const pidPath = getSessionFilePath('DAEMON_PID');
+        try {
+            writeFileSync(pidPath, process.pid.toString(), 'utf-8');
+            releaseDaemonLock(); // Release lock after PID is written (P0 Fix #1)
+            console.error(`[daemon] PID file written: ${pidPath}`);
+        }
+        catch (error) {
+            console.error('[daemon] Failed to write PID file:', error);
+        }
+    }
+    /**
+     * Check if daemon is already running.
+     */
+    static isRunning() {
+        const pidPath = getSessionFilePath('DAEMON_PID');
+        try {
+            const pid = parseInt(readFileSync(pidPath, 'utf-8').trim(), 10);
+            // Check if process is alive
+            process.kill(pid, 0);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Get socket path for client connections.
+     */
+    static getSocketPath() {
+        return getSessionFilePath('DAEMON_SOCKET');
+    }
+}
+//# sourceMappingURL=ipcServer.js.map