@portel/photon 1.4.1 → 1.6.0

package/dist/daemon/server.js

@@ -1,96 +1,432 @@
 #!/usr/bin/env node
 /**
- * Daemon Server
+ * Global Photon Daemon Server
  *
- * Runs as a background process for stateful photons
- * - Loads and initializes the photon
- * - Listens on Unix socket / named pipe
- * - Handles command requests
- * - Manages idle timeout and shutdown
+ * Single daemon process for all photons.
+ * - Listens on global Unix socket / named pipe (~/.photon/daemon.sock)
+ * - Handles requests for multiple photons via photonName field
+ * - Lazy-initializes SessionManagers per photon on first request
+ * - Provides pub/sub, locks, scheduled jobs, and webhooks
  */
 import * as net from 'net';
+import * as http from 'http';
 import * as fs from 'fs';
 import { SessionManager } from './session-manager.js';
-import { setPromptHandler, } from '@portel/photon-core';
-// Command line args: photonName photonPath socketPath
-const photonName = process.argv[2];
-const photonPath = process.argv[3];
-const socketPath = process.argv[4];
-if (!photonName || !photonPath || !socketPath) {
-    console.error('[daemon-server] Missing required arguments');
+import { isValidDaemonRequest, } from './protocol.js';
+import { setPromptHandler } from '@portel/photon-core';
+import { createLogger } from '../shared/logger.js';
+import { getErrorMessage } from '../shared/error-handler.js';
+// Command line args: socketPath (global daemon only needs socket path)
+const socketPath = process.argv[2];
+const logger = createLogger({
+    component: 'daemon-server',
+    scope: 'global',
+    minimal: true,
+});
+if (!socketPath) {
+    logger.error('Missing required argument: socketPath');
     process.exit(1);
 }
-let sessionManager = null;
+// Map of photonName -> SessionManager (lazy initialized)
+const sessionManagers = new Map();
+const photonPaths = new Map(); // photonName -> photonPath
 let idleTimeout = 600000; // 10 minutes default
 let idleTimer = null;
 // Track pending prompts waiting for user input
-// Map: requestId -> { resolve, reject } for resolving prompt responses
 const pendingPrompts = new Map();
-// Current socket for sending prompts (set per-request)
-let currentSocket = null;
-let currentRequestId = null;
-/**
- * Initialize session manager
- */
-async function initializeSessionManager() {
-    try {
-        console.error(`[daemon-server] Initializing session manager for: ${photonName}`);
-        sessionManager = new SessionManager(photonPath, photonName, idleTimeout);
-        console.error(`[daemon-server] Session manager initialized`);
-        console.error(`[daemon-server] Session timeout: ${idleTimeout}ms`);
-        // Start idle timer if timeout is set
-        if (idleTimeout > 0) {
-            startIdleTimer();
+// Channel subscriptions for pub/sub
+const channelSubscriptions = new Map();
+const EVENT_BUFFER_SIZE = 30;
+const channelEventBuffers = new Map();
+function bufferEvent(channel, message) {
+    let buffer = channelEventBuffers.get(channel);
+    if (!buffer) {
+        buffer = { events: [], nextId: 1 };
+        channelEventBuffers.set(channel, buffer);
+    }
+    const eventId = buffer.nextId++;
+    const event = {
+        id: eventId,
+        channel,
+        message,
+        timestamp: Date.now(),
+    };
+    buffer.events.push(event);
+    // Keep only last N events (circular buffer)
+    if (buffer.events.length > EVENT_BUFFER_SIZE) {
+        buffer.events.shift();
+    }
+    return eventId;
+}
+function getEventsSince(channel, lastEventId) {
+    const buffer = channelEventBuffers.get(channel);
+    if (!buffer || buffer.events.length === 0) {
+        return { events: [], refreshNeeded: false };
+    }
+    const oldestEvent = buffer.events[0];
+    // If lastEventId is older than our oldest buffered event, refresh needed
+    if (lastEventId < oldestEvent.id) {
+        return { events: [], refreshNeeded: true };
+    }
+    // Find events to replay
+    const events = buffer.events.filter((e) => e.id > lastEventId);
+    return { events, refreshNeeded: false };
+}
+// ════════════════════════════════════════════════════════════════════════════════
+// DISTRIBUTED LOCKS
+// ════════════════════════════════════════════════════════════════════════════════
+const activeLocks = new Map();
+const DEFAULT_LOCK_TIMEOUT = 30000;
+function acquireLock(lockName, holder, timeout = DEFAULT_LOCK_TIMEOUT) {
+    const now = Date.now();
+    const existing = activeLocks.get(lockName);
+    if (existing && existing.expiresAt > now) {
+        if (existing.holder !== holder) {
+            return false;
+        }
+        existing.expiresAt = now + timeout;
+        return true;
+    }
+    activeLocks.set(lockName, {
+        name: lockName,
+        holder,
+        acquiredAt: now,
+        expiresAt: now + timeout,
+    });
+    logger.info('Lock acquired', { lockName, holder, timeout });
+    return true;
+}
+function releaseLock(lockName, holder) {
+    const existing = activeLocks.get(lockName);
+    if (!existing)
+        return true;
+    if (existing.holder !== holder)
+        return false;
+    activeLocks.delete(lockName);
+    logger.info('Lock released', { lockName, holder });
+    return true;
+}
+function cleanupExpiredLocks() {
+    const now = Date.now();
+    for (const [name, lock] of activeLocks.entries()) {
+        if (lock.expiresAt <= now) {
+            activeLocks.delete(name);
+            logger.info('Lock expired', { lockName: name, holder: lock.holder });
+        }
+    }
+}
+setInterval(cleanupExpiredLocks, 10000);
+// ════════════════════════════════════════════════════════════════════════════════
+// SCHEDULED JOBS
+// ════════════════════════════════════════════════════════════════════════════════
+const scheduledJobs = new Map();
+const jobTimers = new Map();
+function parseCron(cron) {
+    const parts = cron.trim().split(/\s+/);
+    if (parts.length !== 5) {
+        return { isValid: false, nextRun: 0 };
+    }
+    const [minute, hour] = parts;
+    const now = new Date();
+    const nextDate = new Date(now);
+    nextDate.setSeconds(0);
+    nextDate.setMilliseconds(0);
+    if (minute === '*' && hour === '*') {
+        nextDate.setMinutes(nextDate.getMinutes() + 1);
+    }
+    else if (minute.startsWith('*/')) {
+        const interval = parseInt(minute.slice(2));
+        const currentMinute = nextDate.getMinutes();
+        const nextMinute = Math.ceil((currentMinute + 1) / interval) * interval;
+        nextDate.setMinutes(nextMinute);
+    }
+    else if (hour === '*') {
+        const targetMinute = parseInt(minute);
+        if (nextDate.getMinutes() >= targetMinute) {
+            nextDate.setHours(nextDate.getHours() + 1);
+        }
+        nextDate.setMinutes(targetMinute);
+    }
+    else {
+        const targetMinute = parseInt(minute);
+        const targetHour = parseInt(hour);
+        nextDate.setMinutes(targetMinute);
+        nextDate.setHours(targetHour);
+        if (nextDate <= now) {
+            nextDate.setDate(nextDate.getDate() + 1);
         }
     }
+    return { isValid: true, nextRun: nextDate.getTime() };
+}
+function scheduleJob(job) {
+    const { isValid, nextRun } = parseCron(job.cron);
+    if (!isValid) {
+        logger.error('Invalid cron expression', { jobId: job.id, cron: job.cron });
+        return false;
+    }
+    job.nextRun = nextRun;
+    scheduledJobs.set(job.id, job);
+    const existingTimer = jobTimers.get(job.id);
+    if (existingTimer) {
+        clearTimeout(existingTimer);
+    }
+    const delay = nextRun - Date.now();
+    const timer = setTimeout(() => runJob(job.id), delay);
+    jobTimers.set(job.id, timer);
+    logger.info('Job scheduled', {
+        jobId: job.id,
+        method: job.method,
+        photon: job.photonName,
+        nextRun: new Date(nextRun).toISOString(),
+    });
+    return true;
+}
+async function runJob(jobId) {
+    const job = scheduledJobs.get(jobId);
+    if (!job)
+        return;
+    const sessionManager = sessionManagers.get(job.photonName);
+    if (!sessionManager) {
+        logger.warn('Cannot run job - photon not initialized', { jobId, photon: job.photonName });
+        scheduleJob(job); // Reschedule anyway
+        return;
+    }
+    logger.info('Running scheduled job', { jobId, method: job.method, photon: job.photonName });
+    try {
+        const session = await sessionManager.getOrCreateSession('scheduler', 'scheduler');
+        await sessionManager.loader.executeTool(session.instance, job.method, job.args || {});
+        job.lastRun = Date.now();
+        job.runCount++;
+        publishToChannel(`jobs:${job.photonName}`, {
+            event: 'job-completed',
+            jobId,
+            method: job.method,
+            runCount: job.runCount,
+        });
+        logger.info('Job completed', { jobId, method: job.method, runCount: job.runCount });
+    }
     catch (error) {
-        console.error(`[daemon-server] Failed to initialize session manager: ${error.message}`);
-        process.exit(1);
+        logger.error('Job failed', { jobId, method: job.method, error: getErrorMessage(error) });
+        publishToChannel(`jobs:${job.photonName}`, {
+            event: 'job-failed',
+            jobId,
+            method: job.method,
+            error: getErrorMessage(error),
+        });
     }
+    scheduleJob(job);
 }
-/**
- * Start idle timer
- */
-function startIdleTimer() {
-    if (idleTimer) {
-        clearTimeout(idleTimer);
+function unscheduleJob(jobId) {
+    const timer = jobTimers.get(jobId);
+    if (timer) {
+        clearTimeout(timer);
+        jobTimers.delete(jobId);
     }
-    if (idleTimeout <= 0) {
-        return; // Idle timeout disabled
+    const existed = scheduledJobs.delete(jobId);
+    if (existed) {
+        logger.info('Job unscheduled', { jobId });
     }
-    idleTimer = setTimeout(() => {
-        if (!sessionManager)
+    return existed;
+}
+// ════════════════════════════════════════════════════════════════════════════════
+// WEBHOOK HTTP SERVER
+// ════════════════════════════════════════════════════════════════════════════════
+let webhookServer = null;
+const WEBHOOK_PORT = parseInt(process.env.PHOTON_WEBHOOK_PORT || '0');
+function startWebhookServer(port) {
+    if (port <= 0)
+        return;
+    webhookServer = http.createServer(async (req, res) => {
+        res.setHeader('Access-Control-Allow-Origin', '*');
+        res.setHeader('Access-Control-Allow-Methods', 'GET, POST, OPTIONS');
+        res.setHeader('Access-Control-Allow-Headers', 'Content-Type, X-Webhook-Secret, X-Photon-Name');
+        if (req.method === 'OPTIONS') {
+            res.writeHead(204);
+            res.end();
             return;
-        const lastActivity = sessionManager.getLastActivity();
-        const idleTime = Date.now() - lastActivity;
-        if (idleTime >= idleTimeout) {
-            console.error(`[daemon-server] Idle timeout reached (${idleTime}ms). Shutting down.`);
-            shutdown();
         }
-        else {
-            // Restart timer with remaining time
-            startIdleTimer();
+        // Parse URL: /webhook/{photonName}/{method}
+        const url = new URL(req.url || '/', `http://localhost:${port}`);
+        const pathParts = url.pathname.split('/').filter(Boolean);
+        if (pathParts[0] !== 'webhook' || !pathParts[1] || !pathParts[2]) {
+            res.writeHead(404, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify({ error: 'Not found. Use /webhook/{photonName}/{method}' }));
+            return;
         }
-    }, idleTimeout);
+        const photonName = pathParts[1];
+        const method = pathParts[2];
+        const expectedSecret = process.env.PHOTON_WEBHOOK_SECRET;
+        if (expectedSecret) {
+            const providedSecret = req.headers['x-webhook-secret'];
+            if (providedSecret !== expectedSecret) {
+                res.writeHead(401, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ error: 'Invalid webhook secret' }));
+                return;
+            }
+        }
+        let body = '';
+        req.on('data', (chunk) => {
+            body += chunk;
+        });
+        req.on('end', async () => {
+            let args = {};
+            try {
+                if (body) {
+                    args = JSON.parse(body);
+                }
+                args._webhook = {
+                    method: req.method,
+                    headers: req.headers,
+                    query: Object.fromEntries(url.searchParams),
+                    timestamp: Date.now(),
+                };
+            }
+            catch {
+                res.writeHead(400, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ error: 'Invalid JSON body' }));
+                return;
+            }
+            const sessionManager = sessionManagers.get(photonName);
+            if (!sessionManager) {
+                res.writeHead(503, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ error: `Photon '${photonName}' not initialized` }));
+                return;
+            }
+            try {
+                const session = await sessionManager.getOrCreateSession('webhook', 'webhook');
+                const result = await sessionManager.loader.executeTool(session.instance, method, args);
+                logger.info('Webhook executed', { photon: photonName, method });
+                publishToChannel(`webhooks:${photonName}`, {
+                    event: 'webhook-received',
+                    method,
+                    timestamp: Date.now(),
+                });
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ success: true, data: result }));
+            }
+            catch (error) {
+                logger.error('Webhook execution failed', {
+                    photon: photonName,
+                    method,
+                    error: getErrorMessage(error),
+                });
+                res.writeHead(500, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ error: getErrorMessage(error) }));
+            }
+        });
+    });
+    webhookServer.listen(port, () => {
+        logger.info('Webhook server started', { port });
+    });
+    webhookServer.on('error', (error) => {
+        logger.error('Webhook server error', { error: getErrorMessage(error) });
+    });
 }
-/**
- * Reset idle timer (called on each activity)
- */
-function resetIdleTimer() {
-    startIdleTimer();
+// ════════════════════════════════════════════════════════════════════════════════
+// PUB/SUB
+// ════════════════════════════════════════════════════════════════════════════════
+function cleanupSocketSubscriptions(socket) {
+    for (const [channel, subs] of channelSubscriptions.entries()) {
+        subs.delete(socket);
+        if (subs.size === 0) {
+            channelSubscriptions.delete(channel);
+        }
+    }
 }
-/**
- * Create a prompt handler that sends prompts over the socket
- */
+function publishToChannel(channel, message, excludeSocket) {
+    // Buffer the event for replay
+    const eventId = bufferEvent(channel, message);
+    const payload = JSON.stringify({
+        type: 'channel_message',
+        id: `ch_${eventId}`,
+        eventId,
+        channel,
+        message,
+    }) + '\n';
+    const sentSockets = new Set();
+    // Send to exact channel subscribers
+    const exactSubscribers = channelSubscriptions.get(channel);
+    if (exactSubscribers) {
+        for (const socket of exactSubscribers) {
+            if (socket !== excludeSocket && !socket.destroyed && !sentSockets.has(socket)) {
+                try {
+                    socket.write(payload);
+                    sentSockets.add(socket);
+                }
+                catch {
+                    // Socket write failed
+                }
+            }
+        }
+    }
+    // Send to wildcard subscribers
+    const channelPrefix = channel.split(':')[0];
+    if (channelPrefix) {
+        const wildcardChannel = `${channelPrefix}:*`;
+        const wildcardSubscribers = channelSubscriptions.get(wildcardChannel);
+        if (wildcardSubscribers) {
+            for (const socket of wildcardSubscribers) {
+                if (socket !== excludeSocket && !socket.destroyed && !sentSockets.has(socket)) {
+                    try {
+                        socket.write(payload);
+                        sentSockets.add(socket);
+                    }
+                    catch {
+                        // Socket write failed
+                    }
+                }
+            }
+        }
+    }
+    logger.debug('Published to channel', {
+        channel,
+        eventId,
+        exactSubs: exactSubscribers?.size || 0,
+        wildcardSubs: channelSubscriptions.get(`${channelPrefix}:*`)?.size || 0,
+    });
+    return eventId;
+}
+// ════════════════════════════════════════════════════════════════════════════════
+// SESSION MANAGER (Lazy Initialization)
+// ════════════════════════════════════════════════════════════════════════════════
+async function getOrCreateSessionManager(photonName, photonPath) {
+    let manager = sessionManagers.get(photonName);
+    if (manager) {
+        return manager;
+    }
+    // Need photonPath to initialize
+    const storedPath = photonPaths.get(photonName);
+    const pathToUse = photonPath || storedPath;
+    if (!pathToUse) {
+        logger.warn('Cannot initialize photon - no path provided', { photonName });
+        return null;
+    }
+    try {
+        logger.info('Initializing session manager', { photonName, photonPath: pathToUse });
+        manager = new SessionManager(pathToUse, photonName, idleTimeout, logger.child({ scope: photonName }));
+        sessionManagers.set(photonName, manager);
+        photonPaths.set(photonName, pathToUse);
+        logger.info('Session manager initialized', { photonName });
+        return manager;
+    }
+    catch (error) {
+        logger.error('Failed to initialize session manager', {
+            photonName,
+            error: getErrorMessage(error),
+        });
+        return null;
+    }
+}
+// ════════════════════════════════════════════════════════════════════════════════
+// PROMPT HANDLER
+// ════════════════════════════════════════════════════════════════════════════════
 function createSocketPromptHandler(socket, requestId) {
     return async (message, defaultValue) => {
         return new Promise((resolve, reject) => {
-            // Store the resolver for when we get the response
             pendingPrompts.set(requestId, {
                 resolve: (value) => resolve(value),
                 reject,
             });
-            // Send prompt request to client
             const promptResponse = {
                 type: 'prompt',
                 id: requestId,
@@ -104,163 +440,437 @@ function createSocketPromptHandler(socket, requestId) {
         });
     };
 }
-/**
- * Handle incoming command request
- */
+// ════════════════════════════════════════════════════════════════════════════════
+// REQUEST HANDLER
+// ════════════════════════════════════════════════════════════════════════════════
 async function handleRequest(request, socket) {
     resetIdleTimer();
     if (request.type === 'ping') {
-        return {
-            type: 'pong',
-            id: request.id,
-        };
+        return { type: 'pong', id: request.id };
     }
     if (request.type === 'shutdown') {
         shutdown();
+        return { type: 'result', id: request.id, success: true, data: { message: 'Shutting down' } };
+    }
+    // Handle hot-reload request
+    if (request.type === 'reload') {
+        const photonName = request.photonName;
+        const photonPath = request.photonPath;
+        if (!photonName || !photonPath) {
+            return {
+                type: 'error',
+                id: request.id,
+                error: 'photonName and photonPath required for reload',
+            };
+        }
+        const result = await reloadPhoton(photonName, photonPath);
         return {
             type: 'result',
             id: request.id,
-            success: true,
-            data: { message: 'Shutting down' },
+            success: result.success,
+            data: result.success
+                ? { message: 'Reload complete', sessionsUpdated: result.sessionsUpdated }
+                : { error: result.error },
         };
     }
-    // Handle prompt response from client
+    // Handle prompt response
     if (request.type === 'prompt_response') {
         const pending = pendingPrompts.get(request.id);
         if (pending) {
             pendingPrompts.delete(request.id);
             pending.resolve(request.promptValue ?? null);
         }
-        // Don't send a response back - the original command handler will respond
         return null;
     }
+    // Handle channel subscribe
+    if (request.type === 'subscribe') {
+        const channel = request.channel;
+        const lastEventId = request.lastEventId;
+        let subs = channelSubscriptions.get(channel);
+        if (!subs) {
+            subs = new Set();
+            channelSubscriptions.set(channel, subs);
+        }
+        subs.add(socket);
+        logger.info('Client subscribed to channel', { channel, subscribers: subs.size });
+        // Replay missed events if lastEventId provided
+        if (lastEventId !== undefined) {
+            const parsedLastEventId = parseInt(String(lastEventId), 10) || 0;
+            const { events, refreshNeeded } = getEventsSince(channel, parsedLastEventId);
+            if (refreshNeeded) {
+                // Send refresh-needed signal
+                socket.write(JSON.stringify({
+                    type: 'refresh_needed',
+                    id: request.id,
+                    channel,
+                }) + '\n');
+                logger.info('Replay: refresh needed', { channel, lastEventId });
+            }
+            else if (events.length > 0) {
+                // Replay events
+                for (const event of events) {
+                    socket.write(JSON.stringify({
+                        type: 'channel_message',
+                        id: `replay_${event.id}`,
+                        eventId: event.id,
+                        channel: event.channel,
+                        message: event.message,
+                        replay: true,
+                    }) + '\n');
+                }
+                logger.info('Replayed events', { channel, count: events.length });
+            }
+        }
+        return {
+            type: 'result',
+            id: request.id,
+            success: true,
+            data: { subscribed: true, channel },
+        };
+    }
+    // Handle channel unsubscribe
+    if (request.type === 'unsubscribe') {
+        const channel = request.channel;
+        const subs = channelSubscriptions.get(channel);
+        if (subs) {
+            subs.delete(socket);
+            if (subs.size === 0) {
+                channelSubscriptions.delete(channel);
+            }
+        }
+        logger.info('Client unsubscribed from channel', { channel });
+        return { type: 'result', id: request.id, success: true, data: { unsubscribed: true, channel } };
+    }
+    // Handle channel publish
+    if (request.type === 'publish') {
+        const channel = request.channel;
+        const message = request.message;
+        const eventId = publishToChannel(channel, message, socket);
+        return {
+            type: 'result',
+            id: request.id,
+            success: true,
+            data: { published: true, channel, eventId },
+        };
+    }
+    // Handle get_events_since (for event replay)
+    if (request.type === 'get_events_since') {
+        const channel = request.channel;
+        const parsedLastEventId = parseInt(String(request.lastEventId || '0'), 10) || 0;
+        const { events, refreshNeeded } = getEventsSince(channel, parsedLastEventId);
+        return {
+            type: 'result',
+            id: request.id,
+            success: true,
+            data: { events, refreshNeeded },
+        };
+    }
+    // Handle lock acquisition
+    if (request.type === 'lock') {
+        const lockName = request.lockName;
+        const holder = request.sessionId || request.id;
+        const timeout = request.lockTimeout || DEFAULT_LOCK_TIMEOUT;
+        const acquired = acquireLock(lockName, holder, timeout);
+        return {
+            type: 'result',
+            id: request.id,
+            success: acquired,
+            data: {
+                acquired,
+                lockName,
+                holder,
+                ...(acquired ? {} : { reason: 'Lock held by another client' }),
+            },
+        };
+    }
+    // Handle lock release
+    if (request.type === 'unlock') {
+        const lockName = request.lockName;
+        const holder = request.sessionId || request.id;
+        const released = releaseLock(lockName, holder);
+        return {
+            type: 'result',
+            id: request.id,
+            success: released,
+            data: {
+                released,
+                lockName,
+                ...(released ? {} : { reason: 'Cannot release lock held by another client' }),
+            },
+        };
+    }
+    // Handle list locks
+    if (request.type === 'list_locks') {
+        const locks = Array.from(activeLocks.values());
+        return { type: 'result', id: request.id, success: true, data: { locks } };
+    }
+    // Handle job scheduling
+    if (request.type === 'schedule') {
+        const photonName = request.photonName;
+        if (!photonName) {
+            return { type: 'error', id: request.id, error: 'photonName required for scheduling' };
+        }
+        const job = {
+            id: request.jobId,
+            method: request.method,
+            args: request.args,
+            cron: request.cron,
+            runCount: 0,
+            createdAt: Date.now(),
+            createdBy: request.sessionId,
+            photonName,
+        };
+        const scheduled = scheduleJob(job);
+        return {
+            type: 'result',
+            id: request.id,
+            success: scheduled,
+            data: scheduled
+                ? { scheduled: true, jobId: job.id, nextRun: job.nextRun }
+                : { scheduled: false, reason: 'Invalid cron expression' },
+        };
+    }
+    // Handle job unscheduling
+    if (request.type === 'unschedule') {
+        const jobId = request.jobId;
+        const unscheduled = unscheduleJob(jobId);
+        return { type: 'result', id: request.id, success: true, data: { unscheduled, jobId } };
+    }
+    // Handle list jobs
+    if (request.type === 'list_jobs') {
+        const jobs = Array.from(scheduledJobs.values());
+        return { type: 'result', id: request.id, success: true, data: { jobs } };
+    }
+    // Handle command execution
     if (request.type === 'command') {
         if (!request.method) {
-            return {
-                type: 'error',
-                id: request.id,
-                error: 'Method name required',
-            };
+            return { type: 'error', id: request.id, error: 'Method name required' };
+        }
+        const photonName = request.photonName;
+        if (!photonName) {
+            return { type: 'error', id: request.id, error: 'photonName required for commands' };
         }
+        const sessionManager = await getOrCreateSessionManager(photonName, request.photonPath);
         if (!sessionManager) {
             return {
                 type: 'error',
                 id: request.id,
-                error: 'Session manager not initialized',
+                error: `Cannot initialize photon '${photonName}'. Provide photonPath in request.`,
             };
         }
         try {
-            // Get or create session for this client
             const session = await sessionManager.getOrCreateSession(request.sessionId, request.clientType);
-            console.error(`[daemon-server] Executing: ${request.method} (session: ${session.id})`);
-            // Set up socket-based prompt handler for this request
+            logger.info('Executing request', {
+                method: request.method,
+                photon: photonName,
+                sessionId: session.id,
+            });
             setPromptHandler(createSocketPromptHandler(socket, request.id));
-            // Execute method on session's photon instance using loader
-            const result = await sessionManager.loader.executeTool(session.instance, request.method, request.args || {});
-            // Clear prompt handler after execution
-            setPromptHandler(null);
-            return {
-                type: 'result',
-                id: request.id,
-                success: true,
-                data: result,
+            const outputHandler = (emit) => {
+                if (emit && typeof emit === 'object' && emit.channel) {
+                    publishToChannel(emit.channel, emit, socket);
+                    logger.debug('Published to channel', { channel: emit.channel });
+                }
             };
+            const result = await sessionManager.loader.executeTool(session.instance, request.method, request.args || {}, { outputHandler });
+            setPromptHandler(null);
+            return { type: 'result', id: request.id, success: true, data: result };
         }
         catch (error) {
-            console.error(`[daemon-server] Error executing ${request.method}: ${error.message}`);
-            // Clear prompt handler on error
+            logger.error('Error executing request', {
+                method: request.method,
+                error: getErrorMessage(error),
+            });
             setPromptHandler(null);
-            return {
-                type: 'error',
-                id: request.id,
-                error: error.message,
-            };
+            return { type: 'error', id: request.id, error: getErrorMessage(error) };
         }
     }
-    return {
-        type: 'error',
-        id: request.id,
-        error: `Unknown request type: ${request.type}`,
-    };
+    return { type: 'error', id: request.id, error: `Unknown request type: ${request.type}` };
 }
-/**
- * Start IPC server
- */
+// ════════════════════════════════════════════════════════════════════════════════
+// HOT RELOAD
+// ════════════════════════════════════════════════════════════════════════════════
+async function reloadPhoton(photonName, newPhotonPath) {
+    try {
+        logger.info('Hot-reloading photon', { photonName, path: newPhotonPath });
+        const sessionManager = sessionManagers.get(photonName);
+        if (!sessionManager) {
+            // First time - just register the path
+            photonPaths.set(photonName, newPhotonPath);
+            return { success: true, sessionsUpdated: 0 };
+        }
+        await sessionManager.loader.reloadFile(newPhotonPath);
+        const sessions = sessionManager.getSessions();
+        let updatedCount = 0;
+        for (const session of sessions) {
+            try {
+                const newInstance = await sessionManager.loader.loadFile(newPhotonPath);
+                const oldInstance = session.instance;
+                if (oldInstance && typeof oldInstance === 'object') {
+                    for (const key of Object.keys(oldInstance)) {
+                        const value = oldInstance[key];
+                        if (typeof value !== 'function' && key !== 'constructor') {
+                            try {
+                                newInstance[key] = value;
+                            }
+                            catch {
+                                // Some properties may be read-only
+                            }
+                        }
+                    }
+                }
+                if (sessionManager.updateSessionInstance(session.id, newInstance)) {
+                    updatedCount++;
+                }
+            }
+            catch (err) {
+                logger.error('Failed to update session instance', {
+                    sessionId: session.id,
+                    error: getErrorMessage(err),
+                });
+            }
+        }
+        publishToChannel(`system:${photonName}`, {
+            event: 'photon-reloaded',
+            timestamp: Date.now(),
+            sessionsUpdated: updatedCount,
+        });
+        logger.info('Photon reloaded successfully', { photonName, sessionsUpdated: updatedCount });
+        return { success: true, sessionsUpdated: updatedCount };
+    }
+    catch (error) {
+        const errorMessage = getErrorMessage(error);
+        logger.error('Photon reload failed', { photonName, error: errorMessage });
+        return { success: false, error: errorMessage };
+    }
+}
+// ════════════════════════════════════════════════════════════════════════════════
+// IDLE TIMER
+// ════════════════════════════════════════════════════════════════════════════════
+function startIdleTimer() {
+    if (idleTimer) {
+        clearTimeout(idleTimer);
+    }
+    if (idleTimeout <= 0)
+        return;
+    idleTimer = setTimeout(() => {
+        let activeSubscribers = 0;
+        for (const subs of channelSubscriptions.values()) {
+            activeSubscribers += subs.size;
+        }
+        if (activeSubscribers > 0) {
+            logger.debug('Active channel subscribers, staying alive', { activeSubscribers });
+            startIdleTimer();
+            return;
+        }
+        // Check if any session manager has recent activity
+        let lastActivity = 0;
+        for (const manager of sessionManagers.values()) {
+            const activity = manager.getLastActivity();
+            if (activity > lastActivity) {
+                lastActivity = activity;
+            }
+        }
+        const idleTime = Date.now() - lastActivity;
+        if (idleTime >= idleTimeout && sessionManagers.size > 0) {
+            logger.warn('Idle timeout reached, shutting down', { idleTime });
+            shutdown();
+        }
+        else {
+            startIdleTimer();
+        }
+    }, idleTimeout);
+}
+function resetIdleTimer() {
+    startIdleTimer();
+}
+// ════════════════════════════════════════════════════════════════════════════════
+// SERVER
+// ════════════════════════════════════════════════════════════════════════════════
 function startServer() {
     const server = net.createServer((socket) => {
-        console.error('[daemon-server] Client connected');
+        logger.info('Client connected');
         let buffer = '';
         socket.on('data', async (chunk) => {
             buffer += chunk.toString();
-            // Process complete JSON messages (newline-delimited)
             const lines = buffer.split('\n');
-            buffer = lines.pop() || ''; // Keep incomplete line in buffer
+            buffer = lines.pop() || '';
             for (const line of lines) {
                 if (!line.trim())
                     continue;
                 try {
-                    const request = JSON.parse(line);
+                    const parsed = JSON.parse(line);
+                    if (!isValidDaemonRequest(parsed)) {
+                        socket.write(JSON.stringify({ type: 'error', id: 'unknown', error: 'Invalid request format' }) +
+                            '\n');
+                        continue;
+                    }
+                    const request = parsed;
                     const response = await handleRequest(request, socket);
-                    // Only send response if handler returned one (null for prompt_response)
                     if (response !== null) {
                         socket.write(JSON.stringify(response) + '\n');
                     }
                 }
                 catch (error) {
-                    console.error(`[daemon-server] Error processing request: ${error.message}`);
-                    socket.write(JSON.stringify({
-                        type: 'error',
-                        id: 'unknown',
-                        error: error.message,
-                    }) + '\n');
+                    logger.error('Error processing request', { error: getErrorMessage(error) });
+                    socket.write(JSON.stringify({ type: 'error', id: 'unknown', error: getErrorMessage(error) }) + '\n');
                 }
             }
         });
         socket.on('end', () => {
-            console.error('[daemon-server] Client disconnected');
+            logger.info('Client disconnected');
+            cleanupSocketSubscriptions(socket);
         });
         socket.on('error', (error) => {
-            console.error(`[daemon-server] Socket error: ${error.message}`);
+            logger.warn('Socket error', { error: getErrorMessage(error) });
+            cleanupSocketSubscriptions(socket);
+        });
+        socket.on('close', () => {
+            cleanupSocketSubscriptions(socket);
         });
     });
     server.listen(socketPath, () => {
-        console.error(`[daemon-server] Listening on ${socketPath}`);
-        console.error(`[daemon-server] PID: ${process.pid}`);
+        logger.info('Global Photon daemon listening', { socketPath, pid: process.pid });
     });
     server.on('error', (error) => {
-        console.error(`[daemon-server] Server error: ${error.message}`);
+        logger.error('Server error', { error: getErrorMessage(error) });
         process.exit(1);
     });
-    // Graceful shutdown handlers
     process.on('SIGTERM', shutdown);
     process.on('SIGINT', shutdown);
 }
-/**
- * Shutdown daemon
- */
 function shutdown() {
-    console.error('[daemon-server] Shutting down...');
+    logger.info('Shutting down global daemon');
     if (idleTimer) {
         clearTimeout(idleTimer);
     }
-    // Destroy session manager
-    if (sessionManager) {
-        sessionManager.destroy();
+    for (const timer of jobTimers.values()) {
+        clearTimeout(timer);
+    }
+    jobTimers.clear();
+    scheduledJobs.clear();
+    activeLocks.clear();
+    for (const manager of sessionManagers.values()) {
+        manager.destroy();
+    }
+    sessionManagers.clear();
+    if (webhookServer) {
+        webhookServer.close();
     }
-    // Clean up socket file (Unix only)
     if (fs.existsSync(socketPath) && process.platform !== 'win32') {
         try {
             fs.unlinkSync(socketPath);
         }
-        catch (error) {
+        catch {
             // Ignore cleanup errors
         }
     }
     process.exit(0);
 }
 // Main execution
-(async () => {
-    await initializeSessionManager();
+(() => {
     startServer();
+    startWebhookServer(WEBHOOK_PORT);
+    startIdleTimer();
 })();
 //# sourceMappingURL=server.js.map