@portel/photon 1.4.1 → 1.6.0

package/dist/daemon/client.js

@@ -8,10 +8,13 @@
 import * as net from 'net';
 import * as crypto from 'crypto';
 import * as readline from 'readline';
-import { getSocketPath } from './manager.js';
+import { getGlobalSocketPath, restartGlobalDaemon } from './manager.js';
+import { createLogger } from '../shared/logger.js';
+import { getErrorMessage } from '../shared/error-handler.js';
 // Generate session ID for this process
 // This ensures all commands from the same terminal session share the same photon instance
 const SESSION_ID = process.env.PHOTON_SESSION_ID || `cli-${process.pid}-${crypto.randomBytes(4).toString('hex')}`;
+const logger = createLogger({ component: 'daemon-client', minimal: true });
 /**
  * Prompt user for input using readline
  */
@@ -21,9 +24,7 @@ async function promptUser(message, defaultValue) {
             input: process.stdin,
             output: process.stdout,
         });
-        const prompt = defaultValue
-            ? `${message} [${defaultValue}]: `
-            : `${message}: `;
+        const prompt = defaultValue ? `${message} [${defaultValue}]: ` : `${message}: `;
         rl.question(prompt, (answer) => {
             rl.close();
             resolve(answer || defaultValue || null);
@@ -31,11 +32,37 @@ async function promptUser(message, defaultValue) {
     });
 }
 /**
- * Send command to daemon and wait for response
- * Handles bidirectional prompts - if daemon requests input, uses readline
+ * Check if an error indicates the daemon is unreachable (crashed or not started)
  */
-export async function sendCommand(photonName, method, args) {
-    const socketPath = getSocketPath(photonName);
+function isDaemonConnectionError(error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    return msg.includes('ENOENT') || msg.includes('ECONNREFUSED') || msg.includes('Connection error');
+}
+/**
+ * Send command to daemon with auto-restart on connection failure.
+ * If the daemon is unreachable, restarts it and retries once.
+ */
+export async function sendCommand(photonName, method, args, options) {
+    const maxRetries = options?.maxRetries ?? 1;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+        try {
+            return await sendCommandDirect(photonName, method, args);
+        }
+        catch (error) {
+            if (isDaemonConnectionError(error) && attempt < maxRetries) {
+                logger.info('Daemon unreachable, auto-restarting...');
+                await restartGlobalDaemon();
+                continue;
+            }
+            throw error;
+        }
+    }
+}
+/**
+ * Send command directly to daemon (no retry logic)
+ */
+async function sendCommandDirect(photonName, method, args) {
+    const socketPath = getGlobalSocketPath();
     const requestId = `req_${Date.now()}_${Math.random()}`;
     return new Promise((resolve, reject) => {
         const client = net.createConnection(socketPath);
@@ -51,6 +78,7 @@ export async function sendCommand(photonName, method, args) {
             const request = {
                 type: 'command',
                 id: requestId,
+                photonName,
                 sessionId: SESSION_ID,
                 clientType: 'cli',
                 method,
@@ -107,14 +135,14 @@ export async function sendCommand(photonName, method, args) {
                     }
                 }
                 catch (error) {
-                    console.error(`[daemon-client] Error parsing response: ${error.message}`);
+                    logger.warn('Failed to parse daemon response', { error: getErrorMessage(error) });
                 }
             }
         });
         client.on('error', (error) => {
             clearTimeout(timeout);
             client.destroy();
-            reject(new Error(`Connection error: ${error.message}`));
+            reject(new Error(`Connection error: ${getErrorMessage(error)}`));
         });
         client.on('end', () => {
             clearTimeout(timeout);
@@ -125,11 +153,480 @@ export async function sendCommand(photonName, method, args) {
         });
     });
 }
+/**
+ * Subscribe to a channel on a daemon
+ * Returns an unsubscribe function
+ */
+export async function subscribeChannel(photonName, channel, handler, options) {
+    const socketPath = getGlobalSocketPath();
+    const subscribeId = `sub_${Date.now()}_${Math.random().toString(36).slice(2)}`;
+    return new Promise((resolve, reject) => {
+        const client = net.createConnection(socketPath);
+        let subscribed = false;
+        let buffer = '';
+        client.on('connect', () => {
+            // Send subscribe request
+            const request = {
+                type: 'subscribe',
+                id: subscribeId,
+                photonName,
+                channel,
+                clientType: 'beam',
+                lastEventId: options?.lastEventId,
+            };
+            client.write(JSON.stringify(request) + '\n');
+        });
+        client.on('data', (chunk) => {
+            buffer += chunk.toString();
+            // Process complete JSON messages (newline-delimited)
+            const lines = buffer.split('\n');
+            buffer = lines.pop() || '';
+            for (const line of lines) {
+                if (!line.trim())
+                    continue;
+                try {
+                    const response = JSON.parse(line);
+                    // Handle subscription confirmation
+                    if (response.id === subscribeId && response.type === 'result') {
+                        subscribed = true;
+                        // Return unsubscribe function
+                        resolve(() => {
+                            if (!client.destroyed) {
+                                const unsubRequest = {
+                                    type: 'unsubscribe',
+                                    id: `unsub_${Date.now()}`,
+                                    photonName,
+                                    channel,
+                                };
+                                client.write(JSON.stringify(unsubRequest) + '\n');
+                                client.end();
+                            }
+                        });
+                    }
+                    // Handle refresh-needed signal (lastEventId too old)
+                    if (response.type === 'refresh_needed') {
+                        if (options?.onRefreshNeeded) {
+                            options.onRefreshNeeded();
+                        }
+                    }
+                    // Handle channel messages (supports wildcard subscriptions)
+                    if (response.type === 'channel_message' && response.channel) {
+                        const isMatch = channel.endsWith(':*')
+                            ? response.channel.startsWith(channel.slice(0, -1)) // "kanban:*" matches "kanban:anything"
+                            : response.channel === channel; // exact match
+                        if (isMatch) {
+                            handler(response.message, response.eventId);
+                        }
+                    }
+                    // Handle errors
+                    if (response.type === 'error' && response.id === subscribeId) {
+                        reject(new Error(response.error || 'Subscription failed'));
+                    }
+                }
+                catch {
+                    // Ignore parse errors for partial messages
+                }
+            }
+        });
+        client.on('error', (error) => {
+            if (!subscribed) {
+                reject(new Error(`Connection error: ${getErrorMessage(error)}`));
+            }
+        });
+        client.on('end', () => {
+            if (!subscribed) {
+                reject(new Error('Connection closed before subscription confirmed'));
+            }
+        });
+    });
+}
+/**
+ * Publish a message to a channel on a daemon
+ */
+export async function publishToChannel(photonName, channel, message) {
+    const socketPath = getGlobalSocketPath();
+    const requestId = `pub_${Date.now()}_${Math.random().toString(36).slice(2)}`;
+    return new Promise((resolve, reject) => {
+        const client = net.createConnection(socketPath);
+        const timeout = setTimeout(() => {
+            client.destroy();
+            reject(new Error('Publish timeout'));
+        }, 5000);
+        client.on('connect', () => {
+            const request = {
+                type: 'publish',
+                id: requestId,
+                photonName,
+                channel,
+                message,
+            };
+            client.write(JSON.stringify(request) + '\n');
+        });
+        client.on('data', (chunk) => {
+            try {
+                const response = JSON.parse(chunk.toString().trim());
+                if (response.id === requestId) {
+                    clearTimeout(timeout);
+                    client.destroy();
+                    if (response.type === 'result') {
+                        resolve();
+                    }
+                    else {
+                        reject(new Error(response.error || 'Publish failed'));
+                    }
+                }
+            }
+            catch {
+                // Ignore parse errors
+            }
+        });
+        client.on('error', (error) => {
+            clearTimeout(timeout);
+            client.destroy();
+            reject(new Error(`Connection error: ${getErrorMessage(error)}`));
+        });
+    });
+}
+/**
+ * Acquire a distributed lock
+ * Returns true if lock acquired, false if already held
+ */
+export async function acquireLock(photonName, lockName, timeout) {
+    const socketPath = getGlobalSocketPath();
+    const requestId = `lock_${Date.now()}_${Math.random().toString(36).slice(2)}`;
+    return new Promise((resolve, reject) => {
+        const client = net.createConnection(socketPath);
+        const requestTimeout = setTimeout(() => {
+            client.destroy();
+            reject(new Error('Lock request timeout'));
+        }, 10000);
+        client.on('connect', () => {
+            const request = {
+                type: 'lock',
+                id: requestId,
+                photonName,
+                sessionId: SESSION_ID,
+                lockName,
+                lockTimeout: timeout,
+            };
+            client.write(JSON.stringify(request) + '\n');
+        });
+        client.on('data', (chunk) => {
+            try {
+                const response = JSON.parse(chunk.toString().trim());
+                if (response.id === requestId) {
+                    clearTimeout(requestTimeout);
+                    client.destroy();
+                    if (response.type === 'result') {
+                        resolve(response.data.acquired);
+                    }
+                    else {
+                        reject(new Error(response.error || 'Lock failed'));
+                    }
+                }
+            }
+            catch {
+                // Ignore parse errors
+            }
+        });
+        client.on('error', (error) => {
+            clearTimeout(requestTimeout);
+            client.destroy();
+            reject(new Error(`Connection error: ${getErrorMessage(error)}`));
+        });
+    });
+}
+/**
+ * Release a distributed lock
+ * Returns true if lock released, false if not held by this session
+ */
+export async function releaseLock(photonName, lockName) {
+    const socketPath = getGlobalSocketPath();
+    const requestId = `unlock_${Date.now()}_${Math.random().toString(36).slice(2)}`;
+    return new Promise((resolve, reject) => {
+        const client = net.createConnection(socketPath);
+        const timeout = setTimeout(() => {
+            client.destroy();
+            reject(new Error('Unlock request timeout'));
+        }, 5000);
+        client.on('connect', () => {
+            const request = {
+                type: 'unlock',
+                id: requestId,
+                photonName,
+                sessionId: SESSION_ID,
+                lockName,
+            };
+            client.write(JSON.stringify(request) + '\n');
+        });
+        client.on('data', (chunk) => {
+            try {
+                const response = JSON.parse(chunk.toString().trim());
+                if (response.id === requestId) {
+                    clearTimeout(timeout);
+                    client.destroy();
+                    if (response.type === 'result') {
+                        resolve(response.data.released);
+                    }
+                    else {
+                        reject(new Error(response.error || 'Unlock failed'));
+                    }
+                }
+            }
+            catch {
+                // Ignore parse errors
+            }
+        });
+        client.on('error', (error) => {
+            clearTimeout(timeout);
+            client.destroy();
+            reject(new Error(`Connection error: ${getErrorMessage(error)}`));
+        });
+    });
+}
+/**
+ * List all active locks
+ */
+export async function listLocks(photonName) {
+    const socketPath = getGlobalSocketPath();
+    const requestId = `listlocks_${Date.now()}_${Math.random().toString(36).slice(2)}`;
+    return new Promise((resolve, reject) => {
+        const client = net.createConnection(socketPath);
+        const timeout = setTimeout(() => {
+            client.destroy();
+            reject(new Error('List locks request timeout'));
+        }, 5000);
+        client.on('connect', () => {
+            const request = {
+                type: 'list_locks',
+                id: requestId,
+                photonName,
+            };
+            client.write(JSON.stringify(request) + '\n');
+        });
+        client.on('data', (chunk) => {
+            try {
+                const response = JSON.parse(chunk.toString().trim());
+                if (response.id === requestId) {
+                    clearTimeout(timeout);
+                    client.destroy();
+                    if (response.type === 'result') {
+                        resolve(response.data.locks || []);
+                    }
+                    else {
+                        reject(new Error(response.error || 'List locks failed'));
+                    }
+                }
+            }
+            catch {
+                // Ignore parse errors
+            }
+        });
+        client.on('error', (error) => {
+            clearTimeout(timeout);
+            client.destroy();
+            reject(new Error(`Connection error: ${getErrorMessage(error)}`));
+        });
+    });
+}
+/**
+ * Schedule a recurring job
+ */
+export async function scheduleJob(photonName, jobId, method, cron, args) {
+    const socketPath = getGlobalSocketPath();
+    const requestId = `schedule_${Date.now()}_${Math.random().toString(36).slice(2)}`;
+    return new Promise((resolve, reject) => {
+        const client = net.createConnection(socketPath);
+        const timeout = setTimeout(() => {
+            client.destroy();
+            reject(new Error('Schedule request timeout'));
+        }, 5000);
+        client.on('connect', () => {
+            const request = {
+                type: 'schedule',
+                id: requestId,
+                photonName,
+                sessionId: SESSION_ID,
+                jobId,
+                method,
+                cron,
+                args,
+            };
+            client.write(JSON.stringify(request) + '\n');
+        });
+        client.on('data', (chunk) => {
+            try {
+                const response = JSON.parse(chunk.toString().trim());
+                if (response.id === requestId) {
+                    clearTimeout(timeout);
+                    client.destroy();
+                    if (response.type === 'result') {
+                        resolve(response.data);
+                    }
+                    else {
+                        reject(new Error(response.error || 'Schedule failed'));
+                    }
+                }
+            }
+            catch {
+                // Ignore parse errors
+            }
+        });
+        client.on('error', (error) => {
+            clearTimeout(timeout);
+            client.destroy();
+            reject(new Error(`Connection error: ${getErrorMessage(error)}`));
+        });
+    });
+}
+/**
+ * Unschedule a job
+ */
+export async function unscheduleJob(photonName, jobId) {
+    const socketPath = getGlobalSocketPath();
+    const requestId = `unschedule_${Date.now()}_${Math.random().toString(36).slice(2)}`;
+    return new Promise((resolve, reject) => {
+        const client = net.createConnection(socketPath);
+        const timeout = setTimeout(() => {
+            client.destroy();
+            reject(new Error('Unschedule request timeout'));
+        }, 5000);
+        client.on('connect', () => {
+            const request = {
+                type: 'unschedule',
+                id: requestId,
+                photonName,
+                jobId,
+            };
+            client.write(JSON.stringify(request) + '\n');
+        });
+        client.on('data', (chunk) => {
+            try {
+                const response = JSON.parse(chunk.toString().trim());
+                if (response.id === requestId) {
+                    clearTimeout(timeout);
+                    client.destroy();
+                    if (response.type === 'result') {
+                        resolve(response.data.unscheduled);
+                    }
+                    else {
+                        reject(new Error(response.error || 'Unschedule failed'));
+                    }
+                }
+            }
+            catch {
+                // Ignore parse errors
+            }
+        });
+        client.on('error', (error) => {
+            clearTimeout(timeout);
+            client.destroy();
+            reject(new Error(`Connection error: ${getErrorMessage(error)}`));
+        });
+    });
+}
+/**
+ * List all scheduled jobs
+ */
+export async function listJobs(photonName) {
+    const socketPath = getGlobalSocketPath();
+    const requestId = `listjobs_${Date.now()}_${Math.random().toString(36).slice(2)}`;
+    return new Promise((resolve, reject) => {
+        const client = net.createConnection(socketPath);
+        const timeout = setTimeout(() => {
+            client.destroy();
+            reject(new Error('List jobs request timeout'));
+        }, 5000);
+        client.on('connect', () => {
+            const request = {
+                type: 'list_jobs',
+                id: requestId,
+                photonName,
+            };
+            client.write(JSON.stringify(request) + '\n');
+        });
+        client.on('data', (chunk) => {
+            try {
+                const response = JSON.parse(chunk.toString().trim());
+                if (response.id === requestId) {
+                    clearTimeout(timeout);
+                    client.destroy();
+                    if (response.type === 'result') {
+                        resolve(response.data.jobs || []);
+                    }
+                    else {
+                        reject(new Error(response.error || 'List jobs failed'));
+                    }
+                }
+            }
+            catch {
+                // Ignore parse errors
+            }
+        });
+        client.on('error', (error) => {
+            clearTimeout(timeout);
+            client.destroy();
+            reject(new Error(`Connection error: ${getErrorMessage(error)}`));
+        });
+    });
+}
+/**
+ * Reload the daemon's photon code without losing state
+ * Called by dev server after hot-reload to sync daemon
+ */
+export async function reloadDaemon(photonName, photonPath) {
+    const socketPath = getGlobalSocketPath();
+    const requestId = `reload_${Date.now()}_${Math.random().toString(36).slice(2)}`;
+    return new Promise((resolve, reject) => {
+        const client = net.createConnection(socketPath);
+        const timeout = setTimeout(() => {
+            client.destroy();
+            reject(new Error('Reload request timeout'));
+        }, 30000); // 30 second timeout for reload
+        client.on('connect', () => {
+            const request = {
+                type: 'reload',
+                id: requestId,
+                photonName,
+                photonPath,
+            };
+            client.write(JSON.stringify(request) + '\n');
+        });
+        client.on('data', (chunk) => {
+            try {
+                const response = JSON.parse(chunk.toString().trim());
+                if (response.id === requestId) {
+                    clearTimeout(timeout);
+                    client.destroy();
+                    if (response.type === 'result') {
+                        const data = response.data;
+                        resolve({
+                            success: response.success ?? true,
+                            error: data?.error,
+                            sessionsUpdated: data?.sessionsUpdated,
+                        });
+                    }
+                    else {
+                        resolve({ success: false, error: response.error || 'Reload failed' });
+                    }
+                }
+            }
+            catch {
+                // Ignore parse errors
+            }
+        });
+        client.on('error', (error) => {
+            clearTimeout(timeout);
+            client.destroy();
+            reject(new Error(`Connection error: ${getErrorMessage(error)}`));
+        });
+    });
+}
 /**
  * Ping daemon to check if it's responsive
  */
 export async function pingDaemon(photonName) {
-    const socketPath = getSocketPath(photonName);
+    const socketPath = getGlobalSocketPath();
     const requestId = `ping_${Date.now()}`;
     return new Promise((resolve) => {
         const client = net.createConnection(socketPath);
@@ -141,6 +638,7 @@ export async function pingDaemon(photonName) {
             const request = {
                 type: 'ping',
                 id: requestId,
+                photonName,
             };
             client.write(JSON.stringify(request) + '\n');
         });
@@ -169,4 +667,56 @@ export async function pingDaemon(photonName) {
         });
     });
 }
+/**
+ * Get events since a specific eventId for a channel
+ * Used for explicit replay when client has missed events
+ */
+export async function getEventsSince(photonName, channel, lastEventId) {
+    const socketPath = getGlobalSocketPath();
+    const requestId = `getevents_${Date.now()}_${Math.random().toString(36).slice(2)}`;
+    return new Promise((resolve, reject) => {
+        const client = net.createConnection(socketPath);
+        const timeout = setTimeout(() => {
+            client.destroy();
+            reject(new Error('Get events request timeout'));
+        }, 5000);
+        client.on('connect', () => {
+            const request = {
+                type: 'get_events_since',
+                id: requestId,
+                photonName,
+                channel,
+                lastEventId,
+            };
+            client.write(JSON.stringify(request) + '\n');
+        });
+        client.on('data', (chunk) => {
+            try {
+                const response = JSON.parse(chunk.toString().trim());
+                if (response.id === requestId) {
+                    clearTimeout(timeout);
+                    client.destroy();
+                    if (response.type === 'result') {
+                        const data = response.data;
+                        resolve({
+                            events: data.events || [],
+                            refreshNeeded: data.refreshNeeded || false,
+                        });
+                    }
+                    else {
+                        reject(new Error(response.error || 'Get events failed'));
+                    }
+                }
+            }
+            catch {
+                // Ignore parse errors
+            }
+        });
+        client.on('error', (error) => {
+            clearTimeout(timeout);
+            client.destroy();
+            reject(new Error(`Connection error: ${getErrorMessage(error)}`));
+        });
+    });
+}
 //# sourceMappingURL=client.js.map