@portel/photon 1.9.0 → 1.10.0

package/dist/daemon/client.js

@@ -8,7 +8,7 @@
 import * as net from 'net';
 import * as crypto from 'crypto';
 import * as readline from 'readline';
-import { getGlobalSocketPath, restartGlobalDaemon } from './manager.js';
+import { getGlobalSocketPath, ensureDaemon } from './manager.js';
 import { createLogger } from '../shared/logger.js';
 import { getErrorMessage } from '../shared/error-handler.js';
 // Generate session ID for this process
@@ -46,12 +46,12 @@ 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, options?.photonPath, options?.sessionId, options?.instanceName);
+            return await sendCommandDirect(photonName, method, args, options?.photonPath, options?.sessionId, options?.instanceName, options?.workingDir, options?.targetInstance, options?.clientType);
         }
         catch (error) {
             if (isDaemonConnectionError(error) && attempt < maxRetries) {
-                logger.info('Daemon unreachable, auto-restarting...');
-                await restartGlobalDaemon();
+                logger.info(`Daemon unreachable (${photonName}/${method}), retrying...`);
+                await ensureDaemon();
                 continue;
             }
             throw error;
@@ -61,14 +61,14 @@ export async function sendCommand(photonName, method, args, options) {
 /**
  * Send command directly to daemon (no retry logic)
  */
-async function sendCommandDirect(photonName, method, args, photonPath, sessionId, instanceName) {
+async function sendCommandDirect(photonName, method, args, photonPath, sessionId, instanceName, workingDir, targetInstance, clientType) {
     const socketPath = getGlobalSocketPath();
     const requestId = `req_${Date.now()}_${Math.random()}`;
     return new Promise((resolve, reject) => {
         const client = net.createConnection(socketPath);
         let buffer = '';
         let responseReceived = false;
-        const timeout = setTimeout(() => {
+        let currentTimeout = setTimeout(() => {
             if (!responseReceived) {
                 client.destroy();
                 reject(new Error('Request timeout'));
@@ -81,73 +81,77 @@ async function sendCommandDirect(photonName, method, args, photonPath, sessionId
                 photonName,
                 photonPath,
                 sessionId: sessionId || SESSION_ID,
-                clientType: 'cli',
+                clientType: clientType || 'cli',
                 method,
                 args,
                 instanceName,
+                targetInstance,
+                workingDir,
             };
             client.write(JSON.stringify(request) + '\n');
         });
-        client.on('data', async (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);
-                    if (response.id === requestId) {
-                        // Handle prompt request from daemon
-                        if (response.type === 'prompt' && response.prompt) {
-                            // Reset timeout while waiting for user input
-                            clearTimeout(timeout);
-                            // Get user input via readline
-                            const userInput = await promptUser(response.prompt.message, response.prompt.default);
-                            // Send prompt response back to daemon
-                            const promptResponse = {
-                                type: 'prompt_response',
-                                id: requestId,
-                                promptValue: userInput,
-                            };
-                            client.write(JSON.stringify(promptResponse) + '\n');
-                            // Restart timeout for next response
-                            setTimeout(() => {
-                                if (!responseReceived) {
-                                    client.destroy();
-                                    reject(new Error('Request timeout'));
-                                }
-                            }, 120000);
-                        }
-                        // Handle final result
-                        else if (response.type === 'result') {
-                            responseReceived = true;
-                            clearTimeout(timeout);
-                            client.destroy();
-                            resolve(response.data);
-                        }
-                        // Handle error
-                        else if (response.type === 'error') {
-                            responseReceived = true;
-                            clearTimeout(timeout);
-                            client.destroy();
-                            reject(new Error(response.error || 'Unknown error'));
+        client.on('data', (chunk) => {
+            void (async () => {
+                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);
+                        if (response.id === requestId) {
+                            // Handle prompt request from daemon
+                            if (response.type === 'prompt' && response.prompt) {
+                                // Reset timeout while waiting for user input
+                                clearTimeout(currentTimeout);
+                                // Get user input via readline
+                                const userInput = await promptUser(response.prompt.message, response.prompt.default);
+                                // Send prompt response back to daemon
+                                const promptResponse = {
+                                    type: 'prompt_response',
+                                    id: requestId,
+                                    promptValue: userInput,
+                                };
+                                client.write(JSON.stringify(promptResponse) + '\n');
+                                // Restart timeout for next response — store handle so it can be cleared
+                                currentTimeout = setTimeout(() => {
+                                    if (!responseReceived) {
+                                        client.destroy();
+                                        reject(new Error('Request timeout'));
+                                    }
+                                }, 120000);
+                            }
+                            // Handle final result
+                            else if (response.type === 'result') {
+                                responseReceived = true;
+                                clearTimeout(currentTimeout);
+                                client.destroy();
+                                resolve(response.data);
+                            }
+                            // Handle error
+                            else if (response.type === 'error') {
+                                responseReceived = true;
+                                clearTimeout(currentTimeout);
+                                client.destroy();
+                                reject(new Error(response.error || 'Unknown error'));
+                            }
                         }
                     }
+                    catch (error) {
+                        logger.warn('Failed to parse daemon response', { error: getErrorMessage(error) });
+                    }
                 }
-                catch (error) {
-                    logger.warn('Failed to parse daemon response', { error: getErrorMessage(error) });
-                }
-            }
+            })();
         });
         client.on('error', (error) => {
-            clearTimeout(timeout);
+            clearTimeout(currentTimeout);
             client.destroy();
             reject(new Error(`Connection error: ${getErrorMessage(error)}`));
         });
         client.on('end', () => {
-            clearTimeout(timeout);
+            clearTimeout(currentTimeout);
             client.destroy();
             if (!responseReceived) {
                 reject(new Error('Connection closed before receiving response'));
@@ -179,6 +183,7 @@ export async function subscribeChannel(photonName, channel, handler, options) {
                     channel,
                     clientType: 'beam',
                     lastEventId: lastSeenEventId,
+                    workingDir: options?.workingDir,
                 };
                 client.write(JSON.stringify(request) + '\n');
             });
@@ -228,8 +233,10 @@ export async function subscribeChannel(photonName, channel, handler, options) {
                             reject(new Error(response.error || 'Subscription failed'));
                         }
                     }
-                    catch {
-                        // Ignore parse errors for partial messages
+                    catch (e) {
+                        // Lines are fully buffered (split on '\n'), so a parse error here
+                        // indicates actual protocol corruption — log it.
+                        logger.warn('Failed to parse daemon channel message', { error: getErrorMessage(e) });
                     }
                 }
             });
@@ -237,9 +244,9 @@ export async function subscribeChannel(photonName, channel, handler, options) {
                 if (!subscribed) {
                     if (options?.reconnect && !cancelled) {
                         // Initial connection failed — retry (e.g. daemon not running yet)
-                        resolve((() => {
+                        resolve(() => {
                             cancelled = true;
-                        }));
+                        });
                         scheduleReconnect();
                     }
                     else {
@@ -253,9 +260,9 @@ export async function subscribeChannel(photonName, channel, handler, options) {
             client.on('end', () => {
                 if (!subscribed) {
                     if (options?.reconnect && !cancelled) {
-                        resolve((() => {
+                        resolve(() => {
                             cancelled = true;
-                        }));
+                        });
                         scheduleReconnect();
                     }
                     else {
@@ -276,27 +283,31 @@ export async function subscribeChannel(photonName, channel, handler, options) {
         reconnectAttempts++;
         const delay = Math.min(1000 * Math.pow(2, reconnectAttempts - 1), 30000);
         if (reconnectAttempts === 1) {
-            logger.info(`Subscription lost for ${channel}, reconnecting...`);
+            logger.debug(`Subscription lost for ${channel}, reconnecting...`);
         }
         else {
             logger.debug(`Reconnecting ${channel} in ${delay}ms (attempt ${reconnectAttempts})`);
         }
-        setTimeout(async () => {
-            if (cancelled)
-                return;
-            try {
-                // Restart daemon if needed
-                await restartGlobalDaemon();
-                await new Promise((r) => setTimeout(r, 500));
-                await connect();
-                reconnectAttempts = 0;
-                logger.info(`Reconnected subscription for ${channel}`);
-                options?.onReconnect?.();
-            }
-            catch {
-                if (!cancelled)
-                    scheduleReconnect();
-            }
+        setTimeout(() => {
+            void (async () => {
+                if (cancelled)
+                    return;
+                try {
+                    // Try reconnecting to existing daemon first; only start if it's down
+                    await ensureDaemon();
+                    await connect();
+                    reconnectAttempts = 0;
+                    logger.debug(`Reconnected subscription for ${channel}`);
+                    options?.onReconnect?.();
+                }
+                catch (e) {
+                    logger.debug(`Reconnect attempt ${reconnectAttempts} failed for ${channel}`, {
+                        error: getErrorMessage(e),
+                    });
+                    if (!cancelled)
+                        scheduleReconnect();
+                }
+            })();
         }, delay);
     };
     return connect();
@@ -304,7 +315,7 @@ export async function subscribeChannel(photonName, channel, handler, options) {
 /**
  * Publish a message to a channel on a daemon
  */
-export async function publishToChannel(photonName, channel, message) {
+export async function publishToChannel(photonName, channel, message, workingDir) {
     const socketPath = getGlobalSocketPath();
     const requestId = `pub_${Date.now()}_${Math.random().toString(36).slice(2)}`;
     return new Promise((resolve, reject) => {
@@ -320,6 +331,7 @@ export async function publishToChannel(photonName, channel, message) {
                 photonName,
                 channel,
                 message,
+                workingDir,
             };
             client.write(JSON.stringify(request) + '\n');
         });
@@ -337,8 +349,8 @@ export async function publishToChannel(photonName, channel, message) {
                     }
                 }
             }
-            catch {
-                // Ignore parse errors
+            catch (e) {
+                logger.warn('Failed to parse daemon response', { error: getErrorMessage(e) });
             }
         });
         client.on('error', (error) => {
@@ -352,7 +364,7 @@ export async function publishToChannel(photonName, channel, message) {
  * Acquire a distributed lock
  * Returns true if lock acquired, false if already held
  */
-export async function acquireLock(photonName, lockName, timeout) {
+export async function acquireLock(photonName, lockName, timeout, workingDir) {
     const socketPath = getGlobalSocketPath();
     const requestId = `lock_${Date.now()}_${Math.random().toString(36).slice(2)}`;
     return new Promise((resolve, reject) => {
@@ -369,6 +381,7 @@ export async function acquireLock(photonName, lockName, timeout) {
                 sessionId: SESSION_ID,
                 lockName,
                 lockTimeout: timeout,
+                workingDir,
             };
             client.write(JSON.stringify(request) + '\n');
         });
@@ -386,8 +399,8 @@ export async function acquireLock(photonName, lockName, timeout) {
                     }
                 }
             }
-            catch {
-                // Ignore parse errors
+            catch (e) {
+                logger.warn('Failed to parse daemon response', { error: getErrorMessage(e) });
             }
         });
         client.on('error', (error) => {
@@ -401,7 +414,7 @@ export async function acquireLock(photonName, lockName, timeout) {
  * Release a distributed lock
  * Returns true if lock released, false if not held by this session
  */
-export async function releaseLock(photonName, lockName) {
+export async function releaseLock(photonName, lockName, workingDir) {
     const socketPath = getGlobalSocketPath();
     const requestId = `unlock_${Date.now()}_${Math.random().toString(36).slice(2)}`;
     return new Promise((resolve, reject) => {
@@ -417,6 +430,7 @@ export async function releaseLock(photonName, lockName) {
                 photonName,
                 sessionId: SESSION_ID,
                 lockName,
+                workingDir,
             };
             client.write(JSON.stringify(request) + '\n');
         });
@@ -434,8 +448,8 @@ export async function releaseLock(photonName, lockName) {
                     }
                 }
             }
-            catch {
-                // Ignore parse errors
+            catch (e) {
+                logger.warn('Failed to parse daemon response', { error: getErrorMessage(e) });
             }
         });
         client.on('error', (error) => {
@@ -479,8 +493,8 @@ export async function listLocks(photonName) {
                     }
                 }
             }
-            catch {
-                // Ignore parse errors
+            catch (e) {
+                logger.warn('Failed to parse daemon response', { error: getErrorMessage(e) });
             }
         });
         client.on('error', (error) => {
@@ -529,8 +543,8 @@ export async function scheduleJob(photonName, jobId, method, cron, args) {
                     }
                 }
             }
-            catch {
-                // Ignore parse errors
+            catch (e) {
+                logger.warn('Failed to parse daemon response', { error: getErrorMessage(e) });
             }
         });
         client.on('error', (error) => {
@@ -575,8 +589,8 @@ export async function unscheduleJob(photonName, jobId) {
                     }
                 }
             }
-            catch {
-                // Ignore parse errors
+            catch (e) {
+                logger.warn('Failed to parse daemon response', { error: getErrorMessage(e) });
             }
         });
         client.on('error', (error) => {
@@ -620,8 +634,8 @@ export async function listJobs(photonName) {
                     }
                 }
             }
-            catch {
-                // Ignore parse errors
+            catch (e) {
+                logger.warn('Failed to parse daemon response', { error: getErrorMessage(e) });
             }
         });
         client.on('error', (error) => {
@@ -632,99 +646,91 @@ export async function listJobs(photonName) {
     });
 }
 /**
- * Reload the daemon's photon code without losing state
- * Called by dev server after hot-reload to sync daemon
+ * Ping daemon to check if it's responsive
  */
-export async function reloadDaemon(photonName, photonPath) {
+export async function pingDaemon(photonName) {
     const socketPath = getGlobalSocketPath();
-    const requestId = `reload_${Date.now()}_${Math.random().toString(36).slice(2)}`;
-    return new Promise((resolve, reject) => {
+    const requestId = `ping_${Date.now()}`;
+    return new Promise((resolve) => {
         const client = net.createConnection(socketPath);
         const timeout = setTimeout(() => {
             client.destroy();
-            reject(new Error('Reload request timeout'));
-        }, 30000); // 30 second timeout for reload
+            resolve(false);
+        }, 5000);
         client.on('connect', () => {
             const request = {
-                type: 'reload',
+                type: 'ping',
                 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) {
+                if (response.id === requestId && response.type === 'pong') {
                     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' });
-                    }
+                    resolve(true);
                 }
             }
-            catch {
+            catch (error) {
                 // Ignore parse errors
             }
         });
-        client.on('error', (error) => {
+        client.on('error', () => {
             clearTimeout(timeout);
             client.destroy();
-            reject(new Error(`Connection error: ${getErrorMessage(error)}`));
+            resolve(false);
+        });
+        client.on('end', () => {
+            clearTimeout(timeout);
+            client.destroy();
+            resolve(false);
         });
     });
 }
 /**
- * Ping daemon to check if it's responsive
+ * Query daemon health status (uptime, memory, sessions, etc.)
  */
-export async function pingDaemon(photonName) {
+export async function queryDaemonStatus() {
     const socketPath = getGlobalSocketPath();
-    const requestId = `ping_${Date.now()}`;
+    const requestId = `status_${Date.now()}`;
     return new Promise((resolve) => {
         const client = net.createConnection(socketPath);
         const timeout = setTimeout(() => {
             client.destroy();
-            resolve(false);
+            resolve(null);
         }, 5000);
         client.on('connect', () => {
             const request = {
-                type: 'ping',
+                type: 'status',
                 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 && response.type === 'pong') {
+                if (response.id === requestId && response.type === 'result' && response.data) {
                     clearTimeout(timeout);
                     client.destroy();
-                    resolve(true);
+                    resolve(response.data);
                 }
             }
-            catch (error) {
+            catch {
                 // Ignore parse errors
             }
         });
         client.on('error', () => {
             clearTimeout(timeout);
             client.destroy();
-            resolve(false);
+            resolve(null);
         });
         client.on('end', () => {
             clearTimeout(timeout);
             client.destroy();
-            resolve(false);
+            resolve(null);
         });
     });
 }
@@ -732,6 +738,48 @@ export async function pingDaemon(photonName) {
  * Get events since a specific timestamp for a channel
  * Used for explicit delta sync when client has missed events
  */
+/**
+ * Clear cached instances for a photon in a given workingDir.
+ * Called by Beam when starting with a fresh workingDir to avoid stale in-memory state.
+ */
+export async function clearInstances(photonName, workingDir) {
+    const socketPath = getGlobalSocketPath();
+    const requestId = `clearinst_${Date.now()}_${Math.random().toString(36).slice(2)}`;
+    return new Promise((resolve) => {
+        const client = net.createConnection(socketPath);
+        const timeout = setTimeout(() => {
+            client.destroy();
+            resolve(false);
+        }, 5000);
+        client.on('connect', () => {
+            const request = {
+                type: 'clear_instances',
+                id: requestId,
+                photonName,
+                workingDir,
+            };
+            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();
+                    resolve(response.success ?? true);
+                }
+            }
+            catch (e) {
+                logger.warn('Failed to parse daemon response', { error: getErrorMessage(e) });
+            }
+        });
+        client.on('error', () => {
+            clearTimeout(timeout);
+            client.destroy();
+            resolve(false); // Daemon not running — nothing to clear
+        });
+    });
+}
 export async function getEventsSince(photonName, channel, lastEventId) {
     const socketPath = getGlobalSocketPath();
     const requestId = `getevents_${Date.now()}_${Math.random().toString(36).slice(2)}`;
@@ -769,8 +817,8 @@ export async function getEventsSince(photonName, channel, lastEventId) {
                     }
                 }
             }
-            catch {
-                // Ignore parse errors
+            catch (e) {
+                logger.warn('Failed to parse daemon response', { error: getErrorMessage(e) });
             }
         });
         client.on('error', (error) => {