@portel/photon 1.4.0 → 1.5.1

package/dist/daemon/client.js

@@ -3,18 +3,40 @@
  *
  * CLI client for communicating with daemon servers
  * Sends commands via Unix socket / named pipe and receives results
+ * Supports bidirectional prompts - daemon can request user input
  */
 import * as net from 'net';
 import * as crypto from 'crypto';
-import { getSocketPath } from './manager.js';
+import * as readline from 'readline';
+import { getGlobalSocketPath } 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
+ */
+async function promptUser(message, defaultValue) {
+    return new Promise((resolve) => {
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout,
+        });
+        const prompt = defaultValue ? `${message} [${defaultValue}]: ` : `${message}: `;
+        rl.question(prompt, (answer) => {
+            rl.close();
+            resolve(answer || defaultValue || null);
+        });
+    });
+}
 /**
  * Send command to daemon and wait for response
+ * Handles bidirectional prompts - if daemon requests input, uses readline
  */
 export async function sendCommand(photonName, method, args) {
-    const socketPath = getSocketPath(photonName);
+    const socketPath = getGlobalSocketPath();
     const requestId = `req_${Date.now()}_${Math.random()}`;
     return new Promise((resolve, reject) => {
         const client = net.createConnection(socketPath);
@@ -25,11 +47,12 @@ export async function sendCommand(photonName, method, args) {
                 client.destroy();
                 reject(new Error('Request timeout'));
             }
-        }, 30000); // 30 second timeout
+        }, 120000); // 2 minute timeout (longer for interactive prompts)
         client.on('connect', () => {
             const request = {
                 type: 'command',
                 id: requestId,
+                photonName,
                 sessionId: SESSION_ID,
                 clientType: 'cli',
                 method,
@@ -37,7 +60,7 @@ export async function sendCommand(photonName, method, args) {
             };
             client.write(JSON.stringify(request) + '\n');
         });
-        client.on('data', (chunk) => {
+        client.on('data', async (chunk) => {
             buffer += chunk.toString();
             // Process complete JSON messages (newline-delimited)
             const lines = buffer.split('\n');
@@ -48,27 +71,52 @@ export async function sendCommand(photonName, method, args) {
                 try {
                     const response = JSON.parse(line);
                     if (response.id === requestId) {
-                        responseReceived = true;
-                        clearTimeout(timeout);
-                        if (response.type === 'error') {
-                            client.destroy();
-                            reject(new Error(response.error || 'Unknown error'));
+                        // 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);
                         }
-                        else {
+                        // 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'));
+                        }
                     }
                 }
                 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);
@@ -79,11 +127,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);
@@ -95,6 +612,7 @@ export async function pingDaemon(photonName) {
             const request = {
                 type: 'ping',
                 id: requestId,
+                photonName,
             };
             client.write(JSON.stringify(request) + '\n');
         });
@@ -123,4 +641,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