episoda 0.2.5 → 0.2.7

package/dist/daemon/daemon-process.js

@@ -1,662 +0,0 @@
-"use strict";
-/**
- * Episoda Daemon Process
- *
- * Main entry point for the persistent daemon that:
- * - Maintains WebSocket connections to multiple projects
- * - Listens for IPC commands from CLI
- * - Handles graceful shutdown
- * - Survives terminal close
- *
- * This file is spawned by daemon-manager.ts in detached mode.
- */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-const machine_id_1 = require("./machine-id");
-const project_tracker_1 = require("./project-tracker");
-const daemon_manager_1 = require("./daemon-manager");
-const ipc_server_1 = require("../ipc/ipc-server");
-const core_1 = require("@episoda/core");
-const update_checker_1 = require("../utils/update-checker");
-const identity_server_1 = require("./identity-server");
-const fs = __importStar(require("fs"));
-const os = __importStar(require("os"));
-const path = __importStar(require("path"));
-// EP783: Get current version for update checking
-const packageJson = require('../../package.json');
-/**
- * Daemon state
- */
-class Daemon {
-    constructor() {
-        this.machineId = '';
-        this.deviceId = null; // EP726: Cached device UUID from server
-        this.deviceName = null; // EP661: Cached device name from server
-        this.flyMachineId = null; // EP735: Fly.io machine ID for sticky session routing
-        this.identityServer = null; // EP803: Local identity server for browser detection
-        this.connections = new Map(); // projectPath -> connection
-        // EP701: Track which connections are currently live (WebSocket open)
-        // Updated by 'auth_success' (add) and 'disconnected' (remove) events
-        this.liveConnections = new Set(); // projectPath
-        this.shuttingDown = false;
-        this.ipcServer = new ipc_server_1.IPCServer();
-    }
-    /**
-     * Start the daemon
-     */
-    async start() {
-        console.log('[Daemon] Starting Episoda daemon...');
-        // Get machine ID
-        this.machineId = await (0, machine_id_1.getMachineId)();
-        console.log(`[Daemon] Machine ID: ${this.machineId}`);
-        // EP726: Load cached device ID from config if available
-        const config = await (0, core_1.loadConfig)();
-        if (config?.device_id) {
-            this.deviceId = config.device_id;
-            console.log(`[Daemon] Loaded cached Device ID (UUID): ${this.deviceId}`);
-        }
-        // Start IPC server
-        await this.ipcServer.start();
-        console.log('[Daemon] IPC server started');
-        // EP803: Start identity server for browser machine detection
-        this.identityServer = new identity_server_1.IdentityServer(this.machineId);
-        await this.identityServer.start();
-        // Register IPC command handlers
-        this.registerIPCHandlers();
-        // Restore connections for tracked projects
-        await this.restoreConnections();
-        // Setup graceful shutdown
-        this.setupShutdownHandlers();
-        console.log('[Daemon] Daemon started successfully');
-        // EP783: Check for updates in background (non-blocking)
-        this.checkAndNotifyUpdates();
-    }
-    /**
-     * EP783: Check for CLI updates and auto-update in background
-     * Non-blocking - runs after daemon starts, fails silently on errors
-     */
-    async checkAndNotifyUpdates() {
-        try {
-            const result = await (0, update_checker_1.checkForUpdates)(packageJson.version);
-            if (result.updateAvailable) {
-                console.log(`\n⬆️  Update available: ${result.currentVersion} → ${result.latestVersion}`);
-                console.log('   Updating in background...\n');
-                (0, update_checker_1.performBackgroundUpdate)();
-            }
-        }
-        catch (error) {
-            // Silently ignore - update check is non-critical
-        }
-    }
-    // EP738: Removed startHttpServer - device info now flows through WebSocket broadcast + database
-    /**
-     * Register IPC command handlers
-     */
-    registerIPCHandlers() {
-        // Ping - health check
-        this.ipcServer.on('ping', async () => {
-            return { status: 'ok' };
-        });
-        // Status - get daemon status
-        // EP726: Now includes deviceId (UUID) for unified device identification
-        // EP738: Added hostname, platform, arch for status command (HTTP server removed)
-        // EP776: Use liveConnections (actual WebSocket state) instead of connections Map
-        this.ipcServer.on('status', async () => {
-            const projects = (0, project_tracker_1.getAllProjects)().map(p => ({
-                id: p.id,
-                path: p.path,
-                name: p.name,
-                connected: this.liveConnections.has(p.path),
-            }));
-            return {
-                running: true,
-                machineId: this.machineId,
-                deviceId: this.deviceId, // EP726: UUID for unified device identification
-                hostname: os.hostname(),
-                platform: os.platform(),
-                arch: os.arch(),
-                projects,
-            };
-        });
-        // EP734: Add project - now blocking, waits for connection to complete
-        // This eliminates the need for polling from the client side
-        this.ipcServer.on('add-project', async (params) => {
-            const { projectId, projectPath } = params;
-            (0, project_tracker_1.addProject)(projectId, projectPath);
-            try {
-                // Await connection - blocks until connected or fails
-                await this.connectProject(projectId, projectPath);
-                // EP805: Verify connection is actually healthy before returning success
-                const isHealthy = this.isConnectionHealthy(projectPath);
-                if (!isHealthy) {
-                    console.warn(`[Daemon] Connection completed but not healthy for ${projectPath}`);
-                    return { success: false, connected: false, error: 'Connection established but not healthy' };
-                }
-                return { success: true, connected: true };
-            }
-            catch (error) {
-                const errorMessage = error instanceof Error ? error.message : String(error);
-                return { success: false, connected: false, error: errorMessage };
-            }
-        });
-        // EP734: Removed connection-status handler - no longer needed with blocking add-project
-        // Remove project
-        this.ipcServer.on('remove-project', async (params) => {
-            const { projectPath } = params;
-            await this.disconnectProject(projectPath);
-            (0, project_tracker_1.removeProject)(projectPath);
-            return { success: true };
-        });
-        // Connect project
-        this.ipcServer.on('connect-project', async (params) => {
-            const { projectPath } = params;
-            const project = (0, project_tracker_1.getAllProjects)().find(p => p.path === projectPath);
-            if (!project) {
-                throw new Error('Project not tracked');
-            }
-            await this.connectProject(project.id, projectPath);
-            return { success: true };
-        });
-        // Disconnect project
-        this.ipcServer.on('disconnect-project', async (params) => {
-            const { projectPath } = params;
-            await this.disconnectProject(projectPath);
-            return { success: true };
-        });
-        // Shutdown
-        this.ipcServer.on('shutdown', async () => {
-            console.log('[Daemon] Shutdown requested via IPC');
-            await this.shutdown();
-            return { success: true };
-        });
-        // EP805: Verify connection health - checks both Map and liveConnections Set
-        this.ipcServer.on('verify-health', async () => {
-            const projects = (0, project_tracker_1.getAllProjects)().map(p => ({
-                id: p.id,
-                path: p.path,
-                name: p.name,
-                inConnectionsMap: this.connections.has(p.path),
-                inLiveConnections: this.liveConnections.has(p.path),
-                isHealthy: this.isConnectionHealthy(p.path),
-            }));
-            const healthyCount = projects.filter(p => p.isHealthy).length;
-            const staleCount = projects.filter(p => p.inConnectionsMap && !p.inLiveConnections).length;
-            return {
-                totalProjects: projects.length,
-                healthyConnections: healthyCount,
-                staleConnections: staleCount,
-                projects,
-            };
-        });
-    }
-    /**
-     * Restore WebSocket connections for tracked projects
-     */
-    async restoreConnections() {
-        const projects = (0, project_tracker_1.getAllProjects)();
-        for (const project of projects) {
-            try {
-                await this.connectProject(project.id, project.path);
-            }
-            catch (error) {
-                console.error(`[Daemon] Failed to restore connection for ${project.name}:`, error);
-            }
-        }
-    }
-    /**
-     * EP805: Check if a connection is healthy (exists AND is live)
-     * A connection can exist in the Map but be dead if WebSocket disconnected
-     */
-    isConnectionHealthy(projectPath) {
-        return this.connections.has(projectPath) && this.liveConnections.has(projectPath);
-    }
-    /**
-     * Connect to a project's WebSocket
-     */
-    async connectProject(projectId, projectPath) {
-        // EP805: Check BOTH connections Map AND liveConnections Set
-        // A stale connection (in Map but not in Set) means WebSocket died
-        if (this.connections.has(projectPath)) {
-            if (this.liveConnections.has(projectPath)) {
-                console.log(`[Daemon] Already connected to ${projectPath}`);
-                return;
-            }
-            // EP805: Stale connection detected - clean up and reconnect
-            console.warn(`[Daemon] Stale connection detected for ${projectPath}, forcing reconnection`);
-            await this.disconnectProject(projectPath);
-        }
-        // Load auth token from config
-        const config = await (0, core_1.loadConfig)();
-        if (!config || !config.access_token) {
-            throw new Error('No access token found. Please run: episoda auth');
-        }
-        // EP734: Removed pre-flight health check - WebSocket will fail naturally if server is down
-        // This saves ~200-500ms on every connection attempt
-        // EP734: Determine server URL using cached settings (avoids network call)
-        // Priority: 1. Cached local_server_url, 2. Global config api_url, 3. Default production
-        let serverUrl = config.api_url || process.env.EPISODA_API_URL || 'https://episoda.dev';
-        // Use cached local_server_url if available
-        if (config.project_settings?.local_server_url) {
-            serverUrl = config.project_settings.local_server_url;
-            console.log(`[Daemon] Using cached server URL: ${serverUrl}`);
-        }
-        // EP593: Connect to WebSocket server on port 3001 (standalone WebSocket server)
-        const serverUrlObj = new URL(serverUrl);
-        const wsProtocol = serverUrlObj.protocol === 'https:' ? 'wss:' : 'ws:';
-        const wsPort = process.env.EPISODA_WS_PORT || '3001';
-        const wsUrl = `${wsProtocol}//${serverUrlObj.hostname}:${wsPort}`;
-        console.log(`[Daemon] Connecting to ${wsUrl} for project ${projectId}...`);
-        // Create EpisodaClient (handles auth, reconnection, heartbeat)
-        const client = new core_1.EpisodaClient();
-        // Create GitExecutor for this project
-        const gitExecutor = new core_1.GitExecutor();
-        // Store connection
-        const connection = {
-            projectId,
-            projectPath,
-            client,
-            gitExecutor,
-        };
-        this.connections.set(projectPath, connection);
-        // Register command handler
-        client.on('command', async (message) => {
-            if (message.type === 'command' && message.command) {
-                console.log(`[Daemon] Received command for ${projectId}:`, message.command);
-                // EP605: Update activity timestamp to reset idle detection
-                client.updateActivity();
-                try {
-                    // Execute git command with working directory
-                    const result = await gitExecutor.execute(message.command, {
-                        cwd: projectPath
-                    });
-                    // Send result back
-                    await client.send({
-                        type: 'result',
-                        commandId: message.id,
-                        result
-                    });
-                    console.log(`[Daemon] Command completed for ${projectId}:`, result.success ? 'success' : 'failed');
-                }
-                catch (error) {
-                    // Send error result
-                    await client.send({
-                        type: 'result',
-                        commandId: message.id,
-                        result: {
-                            success: false,
-                            error: 'UNKNOWN_ERROR',
-                            output: error instanceof Error ? error.message : String(error)
-                        }
-                    });
-                    console.error(`[Daemon] Command execution error for ${projectId}:`, error);
-                }
-            }
-        });
-        // Register shutdown handler - allows server to request graceful shutdown
-        // EP613: Only exit on user-requested shutdowns, reconnect for server restarts
-        client.on('shutdown', async (message) => {
-            const shutdownMessage = message;
-            const reason = shutdownMessage.reason || 'unknown';
-            console.log(`[Daemon] Received shutdown request from server for ${projectId}`);
-            console.log(`[Daemon] Reason: ${reason} - ${shutdownMessage.message || 'No message'}`);
-            if (reason === 'user_requested') {
-                // User explicitly requested disconnect - exit cleanly
-                console.log(`[Daemon] User requested disconnect, shutting down...`);
-                await this.cleanupAndExit();
-            }
-            else {
-                // Server restart or deployment - don't exit, let WebSocket reconnection handle it
-                console.log(`[Daemon] Server shutdown (${reason}), will reconnect automatically...`);
-                // The WebSocket close event will trigger reconnection via EpisodaClient
-                // We don't call process.exit() here - just let the connection close naturally
-            }
-        });
-        // Register auth success handler
-        client.on('auth_success', async (message) => {
-            console.log(`[Daemon] Authenticated for project ${projectId}`);
-            (0, project_tracker_1.touchProject)(projectPath);
-            // EP701: Mark connection as live (for /device-info endpoint)
-            this.liveConnections.add(projectPath);
-            // EP803: Update identity server connection status
-            if (this.identityServer) {
-                this.identityServer.setConnected(true);
-            }
-            // EP595: Configure git with userId and workspaceId for post-checkout hook
-            // EP655: Also configure machineId for device isolation
-            // EP661: Cache deviceName for browser identification
-            // EP726: Cache deviceId (UUID) for unified device identification
-            // EP735: Cache flyMachineId for sticky session routing
-            const authMessage = message;
-            if (authMessage.userId && authMessage.workspaceId) {
-                // EP726: Pass deviceId to configureGitUser so it's stored in git config
-                await this.configureGitUser(projectPath, authMessage.userId, authMessage.workspaceId, this.machineId, projectId, authMessage.deviceId);
-                // EP610: Install git hooks after configuring git user
-                await this.installGitHooks(projectPath);
-            }
-            // EP661: Store device name for logging and config
-            if (authMessage.deviceName) {
-                this.deviceName = authMessage.deviceName;
-                console.log(`[Daemon] Device name: ${this.deviceName}`);
-            }
-            // EP726: Cache device UUID for unified device identification
-            // Persist to config for future use
-            if (authMessage.deviceId) {
-                this.deviceId = authMessage.deviceId;
-                console.log(`[Daemon] Device ID (UUID): ${this.deviceId}`);
-                // Persist deviceId to config file so it's available on daemon restart
-                await this.cacheDeviceId(authMessage.deviceId);
-            }
-            // EP735: Cache Fly.io machine ID for sticky session routing
-            // Only set when server is running on Fly.io, null otherwise
-            if (authMessage.flyMachineId) {
-                this.flyMachineId = authMessage.flyMachineId;
-                console.log(`[Daemon] Fly Machine ID: ${this.flyMachineId}`);
-            }
-        });
-        // Register error handler
-        client.on('error', (message) => {
-            console.error(`[Daemon] Server error for ${projectId}:`, message);
-        });
-        // EP701: Register disconnected handler to track connection state
-        // Removes from liveConnections immediately so /device-info returns accurate state
-        // Keeps entry in connections map for potential reconnection (client handles reconnect internally)
-        client.on('disconnected', (event) => {
-            const disconnectEvent = event;
-            console.log(`[Daemon] Connection closed for ${projectId}: code=${disconnectEvent.code}, willReconnect=${disconnectEvent.willReconnect}`);
-            // Always remove from liveConnections - connection is dead until reconnected
-            this.liveConnections.delete(projectPath);
-            // EP803: Update identity server connection status
-            // Only mark as disconnected if no other connections are live
-            if (this.identityServer && this.liveConnections.size === 0) {
-                this.identityServer.setConnected(false);
-            }
-            // Only remove from connections map if we won't reconnect (intentional disconnect)
-            if (!disconnectEvent.willReconnect) {
-                this.connections.delete(projectPath);
-                console.log(`[Daemon] Removed connection for ${projectPath} from map`);
-            }
-        });
-        try {
-            // EP601: Read daemon PID from file
-            let daemonPid;
-            try {
-                const pidPath = (0, daemon_manager_1.getPidFilePath)();
-                if (fs.existsSync(pidPath)) {
-                    const pidStr = fs.readFileSync(pidPath, 'utf-8').trim();
-                    daemonPid = parseInt(pidStr, 10);
-                }
-            }
-            catch (pidError) {
-                console.warn(`[Daemon] Could not read daemon PID:`, pidError instanceof Error ? pidError.message : pidError);
-            }
-            // Connect with OAuth token, machine ID, and device info (EP596, EP601: includes daemonPid)
-            await client.connect(wsUrl, config.access_token, this.machineId, {
-                hostname: os.hostname(),
-                osPlatform: os.platform(),
-                osArch: os.arch(),
-                daemonPid
-            });
-            console.log(`[Daemon] Successfully connected to project ${projectId}`);
-        }
-        catch (error) {
-            console.error(`[Daemon] Failed to connect to ${projectId}:`, error);
-            this.connections.delete(projectPath);
-            throw error;
-        }
-    }
-    /**
-     * Disconnect from a project's WebSocket
-     */
-    async disconnectProject(projectPath) {
-        const connection = this.connections.get(projectPath);
-        if (!connection) {
-            return;
-        }
-        // Clear reconnect timer
-        if (connection.reconnectTimer) {
-            clearTimeout(connection.reconnectTimer);
-        }
-        // Disconnect client (handles WebSocket close gracefully)
-        await connection.client.disconnect();
-        this.connections.delete(projectPath);
-        this.liveConnections.delete(projectPath); // EP701: Also clean up liveConnections
-        console.log(`[Daemon] Disconnected from ${projectPath}`);
-    }
-    /**
-     * Setup graceful shutdown handlers
-     * EP613: Now uses cleanupAndExit to ensure PID file is removed
-     */
-    setupShutdownHandlers() {
-        const shutdownHandler = async (signal) => {
-            console.log(`[Daemon] Received ${signal}, shutting down...`);
-            await this.cleanupAndExit();
-        };
-        process.on('SIGTERM', () => shutdownHandler('SIGTERM'));
-        process.on('SIGINT', () => shutdownHandler('SIGINT'));
-    }
-    /**
-     * EP595: Configure git with user and workspace ID for post-checkout hook
-     * EP655: Added machineId for device isolation in multi-device environments
-     * EP725: Added projectId for main branch badge tracking
-     * EP726: Added deviceId (UUID) for unified device identification
-     *
-     * This stores the IDs in .git/config so the post-checkout hook can
-     * update module.checkout_* fields when git operations happen from terminal.
-     */
-    async configureGitUser(projectPath, userId, workspaceId, machineId, projectId, deviceId) {
-        try {
-            const { execSync } = await Promise.resolve().then(() => __importStar(require('child_process')));
-            // Set git config values in the project's .git/config
-            execSync(`git config episoda.userId ${userId}`, {
-                cwd: projectPath,
-                encoding: 'utf8',
-                stdio: 'pipe'
-            });
-            execSync(`git config episoda.workspaceId ${workspaceId}`, {
-                cwd: projectPath,
-                encoding: 'utf8',
-                stdio: 'pipe'
-            });
-            // EP655: Set machineId for device isolation in post-checkout hook
-            execSync(`git config episoda.machineId ${machineId}`, {
-                cwd: projectPath,
-                encoding: 'utf8',
-                stdio: 'pipe'
-            });
-            // EP725: Set projectId for main branch badge tracking
-            // This ensures main branch checkouts are recorded with project_id
-            execSync(`git config episoda.projectId ${projectId}`, {
-                cwd: projectPath,
-                encoding: 'utf8',
-                stdio: 'pipe'
-            });
-            // EP726: Set deviceId (UUID) for unified device identification
-            // This allows the post-checkout hook to pass the UUID to the database
-            if (deviceId) {
-                execSync(`git config episoda.deviceId ${deviceId}`, {
-                    cwd: projectPath,
-                    encoding: 'utf8',
-                    stdio: 'pipe'
-                });
-            }
-            console.log(`[Daemon] Configured git for project: episoda.userId=${userId}, machineId=${machineId}, projectId=${projectId}${deviceId ? `, deviceId=${deviceId}` : ''}`);
-        }
-        catch (error) {
-            // Non-fatal error - git hook just won't work
-            console.warn(`[Daemon] Failed to configure git user for ${projectPath}:`, error instanceof Error ? error.message : error);
-        }
-    }
-    /**
-     * EP610: Install git hooks from bundled files
-     *
-     * Installs post-checkout and pre-commit hooks to enable:
-     * - Branch tracking (post-checkout updates module.checkout_* fields)
-     * - Main branch protection (pre-commit blocks direct commits to main)
-     */
-    async installGitHooks(projectPath) {
-        const hooks = ['post-checkout', 'pre-commit'];
-        const hooksDir = path.join(projectPath, '.git', 'hooks');
-        // Ensure hooks directory exists
-        if (!fs.existsSync(hooksDir)) {
-            console.warn(`[Daemon] Hooks directory not found: ${hooksDir}`);
-            return;
-        }
-        for (const hookName of hooks) {
-            try {
-                const hookPath = path.join(hooksDir, hookName);
-                // Read bundled hook content
-                // __dirname in compiled code points to dist/daemon/, hooks are in dist/hooks/
-                const bundledHookPath = path.join(__dirname, '..', 'hooks', hookName);
-                if (!fs.existsSync(bundledHookPath)) {
-                    console.warn(`[Daemon] Bundled hook not found: ${bundledHookPath}`);
-                    continue;
-                }
-                const hookContent = fs.readFileSync(bundledHookPath, 'utf-8');
-                // Check if hook already exists with same content
-                if (fs.existsSync(hookPath)) {
-                    const existingContent = fs.readFileSync(hookPath, 'utf-8');
-                    if (existingContent === hookContent) {
-                        // Hook is up to date
-                        continue;
-                    }
-                }
-                // Write hook file
-                fs.writeFileSync(hookPath, hookContent, { mode: 0o755 });
-                console.log(`[Daemon] Installed git hook: ${hookName}`);
-            }
-            catch (error) {
-                // Non-fatal - just log warning
-                console.warn(`[Daemon] Failed to install ${hookName} hook:`, error instanceof Error ? error.message : error);
-            }
-        }
-    }
-    /**
-     * EP726: Cache device UUID to config file
-     *
-     * Persists the device_id (UUID) received from the server so it's available
-     * on daemon restart without needing to re-register the device.
-     */
-    async cacheDeviceId(deviceId) {
-        try {
-            const config = await (0, core_1.loadConfig)();
-            if (!config) {
-                console.warn('[Daemon] Cannot cache device ID - no config found');
-                return;
-            }
-            // Only update if device_id has changed
-            if (config.device_id === deviceId) {
-                return;
-            }
-            // Update config with device_id and machine_id
-            const updatedConfig = {
-                ...config,
-                device_id: deviceId,
-                machine_id: this.machineId
-            };
-            await (0, core_1.saveConfig)(updatedConfig);
-            console.log(`[Daemon] Cached device ID to config: ${deviceId}`);
-        }
-        catch (error) {
-            console.warn('[Daemon] Failed to cache device ID:', error instanceof Error ? error.message : error);
-        }
-    }
-    /**
-     * Gracefully shutdown daemon
-     */
-    async shutdown() {
-        if (this.shuttingDown)
-            return;
-        this.shuttingDown = true;
-        console.log('[Daemon] Shutting down...');
-        // Close all WebSocket connections
-        for (const [projectPath, connection] of this.connections) {
-            if (connection.reconnectTimer) {
-                clearTimeout(connection.reconnectTimer);
-            }
-            await connection.client.disconnect();
-        }
-        this.connections.clear();
-        // EP803: Stop identity server
-        if (this.identityServer) {
-            await this.identityServer.stop();
-            this.identityServer = null;
-        }
-        // Stop IPC server
-        await this.ipcServer.stop();
-        console.log('[Daemon] Shutdown complete');
-    }
-    /**
-     * EP613: Clean up PID file and exit gracefully
-     * Called when user explicitly requests disconnect
-     */
-    async cleanupAndExit() {
-        await this.shutdown();
-        // Clean up PID file
-        try {
-            const pidPath = (0, daemon_manager_1.getPidFilePath)();
-            if (fs.existsSync(pidPath)) {
-                fs.unlinkSync(pidPath);
-                console.log('[Daemon] PID file cleaned up');
-            }
-        }
-        catch (error) {
-            console.error('[Daemon] Failed to clean up PID file:', error);
-        }
-        console.log('[Daemon] Exiting...');
-        process.exit(0);
-    }
-}
-/**
- * Main entry point
- */
-async function main() {
-    // Only run if explicitly in daemon mode
-    if (!process.env.EPISODA_DAEMON_MODE) {
-        console.error('This script should only be run by daemon-manager');
-        process.exit(1);
-    }
-    const daemon = new Daemon();
-    await daemon.start();
-    // Keep process alive
-    await new Promise(() => {
-        // Never resolves - daemon runs until killed
-    });
-}
-// Run daemon
-main().catch(error => {
-    console.error('[Daemon] Fatal error:', error);
-    process.exit(1);
-});
-//# sourceMappingURL=daemon-process.js.map