@portel/photon 1.32.2 → 1.32.4

package/dist/daemon/client.js

@@ -18,6 +18,12 @@ import { ProgressRenderer } from '@portel/photon-core';
 const SESSION_ID = process.env.PHOTON_SESSION_ID || `cli-${process.pid}-${crypto.randomBytes(4).toString('hex')}`;
 const logger = createLogger({ component: 'daemon-client', minimal: true });
 const cliProgress = new ProgressRenderer();
+const DEFAULT_DAEMON_READY_TIMEOUT_MS = 30_000;
+const DEFAULT_DAEMON_COMMAND_RETRIES = 3;
+function getDaemonReadyTimeoutMs() {
+    const parsed = Number(process.env.PHOTON_DAEMON_READY_TIMEOUT_MS);
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : DEFAULT_DAEMON_READY_TIMEOUT_MS;
+}
 /**
  * Render a generator emit yield in the CLI (mirrors loader's createOutputHandler)
  */
@@ -154,16 +160,19 @@ function connectToDaemon(socketPath) {
         process.nextTick(() => dummy.emit('error', err));
         return dummy;
     }
-    try {
-        return net.createConnection(socketPath);
-    }
-    catch (syncErr) {
-        // TOCTOU: file vanished between existsSync and createConnection.
-        // Emit asynchronously for the same reason as above.
-        const dummy = new net.Socket();
-        process.nextTick(() => dummy.emit('error', syncErr));
-        return dummy;
-    }
+    const socket = new net.Socket();
+    // Give callers one tick to attach error/data/connect handlers before
+    // Bun can report ENOENT/ECONNREFUSED for a socket that vanished after
+    // the existsSync guard.
+    process.nextTick(() => {
+        try {
+            socket.connect(socketPath);
+        }
+        catch (syncErr) {
+            socket.emit('error', syncErr);
+        }
+    });
+    return socket;
 }
 /**
  * connectToDaemon variant for the best-effort health-check helpers
@@ -206,7 +215,7 @@ const RETRYABLE_METHODS = new Set(['_instances', '_use', '_settings', '_runs', '
  * Called after ensureDaemon() so sendCommand retries land on a ready socket,
  * not on a socket that exists on disk but the daemon hasn't bound yet.
  */
-async function waitForDaemon(timeoutMs = 10_000) {
+async function waitForDaemon(timeoutMs = getDaemonReadyTimeoutMs()) {
     const deadline = Date.now() + timeoutMs;
     let delay = 100;
     while (Date.now() < deadline) {
@@ -215,7 +224,15 @@ async function waitForDaemon(timeoutMs = 10_000) {
         await new Promise((r) => setTimeout(r, delay));
         delay = Math.min(delay * 2, 1000);
     }
-    throw new Error('Daemon did not become ready within timeout');
+    throw new Error(`Daemon did not become ready within ${Math.round(timeoutMs / 1000)}s`);
+}
+async function ensureDaemonReady() {
+    await ensureDaemon();
+    await waitForDaemon();
+}
+async function waitBeforeDaemonRetry(attempt) {
+    const delay = Math.min(100 * Math.pow(2, attempt), 1_000);
+    await new Promise((resolve) => setTimeout(resolve, delay));
 }
 /**
  * Send command to daemon with auto-restart on connection failure.
@@ -223,17 +240,18 @@ async function waitForDaemon(timeoutMs = 10_000) {
  * errors for read-only methods (retry without restart).
  */
 export async function sendCommand(photonName, method, args, options) {
-    const maxRetries = options?.maxRetries ?? 1;
+    const maxRetries = options?.maxRetries ?? DEFAULT_DAEMON_COMMAND_RETRIES;
     const isRetryable = RETRYABLE_METHODS.has(method);
     for (let attempt = 0; attempt <= maxRetries; attempt++) {
         try {
+            await ensureDaemonReady();
             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 (${photonName}/${method}), waiting for daemon...`);
-                await ensureDaemon();
-                await waitForDaemon();
+                await waitBeforeDaemonRetry(attempt);
+                await ensureDaemonReady();
                 continue;
             }
             // Retry transient errors for read-only methods only
@@ -252,6 +270,24 @@ export async function sendCommand(photonName, method, args, options) {
  * Called by Beam after hot-reload so the daemon's instance matches.
  */
 export async function reloadDaemonPhoton(photonName, photonPath, workingDir) {
+    const maxRetries = DEFAULT_DAEMON_COMMAND_RETRIES;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+        try {
+            await ensureDaemonReady();
+            return await reloadDaemonPhotonDirect(photonName, photonPath, workingDir);
+        }
+        catch (error) {
+            if (isDaemonConnectionError(error) && attempt < maxRetries) {
+                logger.info(`Daemon unreachable during reload (${photonName}), waiting for daemon...`);
+                await waitBeforeDaemonRetry(attempt);
+                await ensureDaemonReady();
+                continue;
+            }
+            throw error;
+        }
+    }
+}
+async function reloadDaemonPhotonDirect(photonName, photonPath, workingDir) {
     const socketPath = getGlobalSocketPath();
     return new Promise((resolve, reject) => {
         const client = connectToDaemon(socketPath);
@@ -413,7 +449,8 @@ async function sendCommandDirect(photonName, method, args, photonPath, sessionId
 export async function subscribeChannel(photonName, channel, handler, options) {
     let cancelled = false;
     let lastSeenEventId = options?.lastEventId;
-    const connect = () => {
+    const connect = async () => {
+        await ensureDaemonReady();
         const socketPath = getGlobalSocketPath();
         const subscribeId = `sub_${Date.now()}_${Math.random().toString(36).slice(2)}`;
         return new Promise((resolve, reject) => {
@@ -511,6 +548,8 @@ export async function subscribeChannel(photonName, channel, handler, options) {
                     }
                 }
                 else if (options?.reconnect && !cancelled) {
+                    if (!client.destroyed)
+                        client.destroy();
                     scheduleReconnect();
                 }
             });
@@ -527,6 +566,8 @@ export async function subscribeChannel(photonName, channel, handler, options) {
                     }
                 }
                 else if (options?.reconnect && !cancelled) {
+                    if (!client.destroyed)
+                        client.destroy();
                     scheduleReconnect();
                 }
             });
@@ -551,7 +592,7 @@ export async function subscribeChannel(photonName, channel, handler, options) {
                     return;
                 try {
                     // Try reconnecting to existing daemon first; only start if it's down
-                    await ensureDaemon();
+                    await ensureDaemonReady();
                     await connect();
                     reconnectAttempts = 0;
                     logger.debug(`Reconnected subscription for ${channel}`);
@@ -573,48 +614,12 @@ export async function subscribeChannel(photonName, channel, handler, options) {
  * Publish a message to a channel on a daemon
  */
 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) => {
-        const client = connectToDaemon(socketPath);
-        const timeout = setTimeout(() => {
-            client.destroy();
-            reject(new Error('Publish timeout'));
-        }, 5000);
-        client.on('connect', () => {
-            const request = {
-                type: 'publish',
-                id: requestId,
-                photonName,
-                channel,
-                message,
-                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();
-                    if (response.type === 'result') {
-                        resolve();
-                    }
-                    else {
-                        reject(new Error(response.error || 'Publish failed'));
-                    }
-                }
-            }
-            catch (e) {
-                logger.warn('Failed to parse daemon response', { error: getErrorMessage(e) });
-            }
-        });
-        client.on('error', (error) => {
-            clearTimeout(timeout);
-            client.destroy();
-            reject(new Error(`Connection error: ${getErrorMessage(error)}`));
-        });
+    await sendSimpleDaemonRequest({
+        type: 'publish',
+        photonName,
+        channel,
+        message,
+        workingDir,
     });
 }
 /**
@@ -622,485 +627,152 @@ export async function publishToChannel(photonName, channel, message, workingDir)
  * Returns true if lock acquired, false if already held
  */
 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) => {
-        const client = connectToDaemon(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,
-                workingDir,
-            };
-            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 (e) {
-                logger.warn('Failed to parse daemon response', { error: getErrorMessage(e) });
-            }
-        });
-        client.on('error', (error) => {
-            clearTimeout(requestTimeout);
-            client.destroy();
-            reject(new Error(`Connection error: ${getErrorMessage(error)}`));
-        });
+    const result = await sendSimpleDaemonRequest({
+        type: 'lock',
+        photonName,
+        sessionId: SESSION_ID,
+        lockName,
+        lockTimeout: timeout,
+        workingDir,
     });
+    return result.acquired;
 }
 /**
  * Release a distributed lock
  * Returns true if lock released, false if not held by this session
  */
 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) => {
-        const client = connectToDaemon(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,
-                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();
-                    if (response.type === 'result') {
-                        resolve(response.data.released);
-                    }
-                    else {
-                        reject(new Error(response.error || 'Unlock failed'));
-                    }
-                }
-            }
-            catch (e) {
-                logger.warn('Failed to parse daemon response', { error: getErrorMessage(e) });
-            }
-        });
-        client.on('error', (error) => {
-            clearTimeout(timeout);
-            client.destroy();
-            reject(new Error(`Connection error: ${getErrorMessage(error)}`));
-        });
+    const result = await sendSimpleDaemonRequest({
+        type: 'unlock',
+        photonName,
+        sessionId: SESSION_ID,
+        lockName,
+        workingDir,
     });
+    return result.released;
 }
 /**
  * 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 = connectToDaemon(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 (e) {
-                logger.warn('Failed to parse daemon response', { error: getErrorMessage(e) });
-            }
-        });
-        client.on('error', (error) => {
-            clearTimeout(timeout);
-            client.destroy();
-            reject(new Error(`Connection error: ${getErrorMessage(error)}`));
-        });
+    const result = await sendSimpleDaemonRequest({
+        type: 'list_locks',
+        photonName,
     });
+    return result.locks || [];
 }
 /**
  * Assign a lock to a specific caller (identity-aware)
  * Unlike acquireLock which uses the session ID, this sets an explicit holder.
  */
 export async function assignLock(photonName, lockName, holder, timeout, workingDir) {
-    const socketPath = getGlobalSocketPath();
-    const requestId = `assignlock_${Date.now()}_${Math.random().toString(36).slice(2)}`;
-    return new Promise((resolve, reject) => {
-        const client = connectToDaemon(socketPath);
-        const requestTimeout = setTimeout(() => {
-            client.destroy();
-            reject(new Error('Assign lock request timeout'));
-        }, 10000);
-        client.on('connect', () => {
-            const request = {
-                type: 'assign_lock',
-                id: requestId,
-                photonName,
-                sessionId: SESSION_ID,
-                lockName,
-                lockHolder: holder,
-                lockTimeout: timeout,
-                workingDir,
-            };
-            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 || 'Assign lock failed'));
-                    }
-                }
-            }
-            catch (e) {
-                logger.warn('Failed to parse daemon response', { error: getErrorMessage(e) });
-            }
-        });
-        client.on('error', (error) => {
-            clearTimeout(requestTimeout);
-            client.destroy();
-            reject(new Error(`Connection error: ${getErrorMessage(error)}`));
-        });
+    const result = await sendSimpleDaemonRequest({
+        type: 'assign_lock',
+        photonName,
+        sessionId: SESSION_ID,
+        lockName,
+        lockHolder: holder,
+        lockTimeout: timeout,
+        workingDir,
     });
+    return result.acquired;
 }
 /**
  * Transfer a lock from one holder to another
  */
 export async function transferLock(photonName, lockName, fromHolder, toHolder, timeout, workingDir) {
-    const socketPath = getGlobalSocketPath();
-    const requestId = `transferlock_${Date.now()}_${Math.random().toString(36).slice(2)}`;
-    return new Promise((resolve, reject) => {
-        const client = connectToDaemon(socketPath);
-        const requestTimeout = setTimeout(() => {
-            client.destroy();
-            reject(new Error('Transfer lock request timeout'));
-        }, 10000);
-        client.on('connect', () => {
-            const request = {
-                type: 'transfer_lock',
-                id: requestId,
-                photonName,
-                sessionId: SESSION_ID,
-                lockName,
-                lockHolder: fromHolder,
-                lockTransferTo: toHolder,
-                lockTimeout: timeout,
-                workingDir,
-            };
-            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.transferred);
-                    }
-                    else {
-                        reject(new Error(response.error || 'Transfer lock failed'));
-                    }
-                }
-            }
-            catch (e) {
-                logger.warn('Failed to parse daemon response', { error: getErrorMessage(e) });
-            }
-        });
-        client.on('error', (error) => {
-            clearTimeout(requestTimeout);
-            client.destroy();
-            reject(new Error(`Connection error: ${getErrorMessage(error)}`));
-        });
+    const result = await sendSimpleDaemonRequest({
+        type: 'transfer_lock',
+        photonName,
+        sessionId: SESSION_ID,
+        lockName,
+        lockHolder: fromHolder,
+        lockTransferTo: toHolder,
+        lockTimeout: timeout,
+        workingDir,
     });
+    return result.transferred;
 }
 /**
  * Release a lock held by a specific caller (identity-aware)
  */
 export async function releaseIdentityLock(photonName, lockName, holder, workingDir) {
-    const socketPath = getGlobalSocketPath();
-    const requestId = `releaselock_${Date.now()}_${Math.random().toString(36).slice(2)}`;
-    return new Promise((resolve, reject) => {
-        const client = connectToDaemon(socketPath);
-        const requestTimeout = setTimeout(() => {
-            client.destroy();
-            reject(new Error('Release lock request timeout'));
-        }, 5000);
-        client.on('connect', () => {
-            const request = {
-                type: 'unlock',
-                id: requestId,
-                photonName,
-                sessionId: SESSION_ID,
-                lockName,
-                lockHolder: holder,
-                workingDir,
-            };
-            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.released);
-                    }
-                    else {
-                        reject(new Error(response.error || 'Release lock failed'));
-                    }
-                }
-            }
-            catch (e) {
-                logger.warn('Failed to parse daemon response', { error: getErrorMessage(e) });
-            }
-        });
-        client.on('error', (error) => {
-            clearTimeout(requestTimeout);
-            client.destroy();
-            reject(new Error(`Connection error: ${getErrorMessage(error)}`));
-        });
+    const result = await sendSimpleDaemonRequest({
+        type: 'unlock',
+        photonName,
+        sessionId: SESSION_ID,
+        lockName,
+        lockHolder: holder,
+        workingDir,
     });
+    return result.released;
 }
 /**
  * Query who holds a specific lock
  */
 export async function queryLock(photonName, lockName) {
-    const socketPath = getGlobalSocketPath();
-    const requestId = `querylock_${Date.now()}_${Math.random().toString(36).slice(2)}`;
-    return new Promise((resolve, reject) => {
-        const client = connectToDaemon(socketPath);
-        const requestTimeout = setTimeout(() => {
-            client.destroy();
-            reject(new Error('Query lock request timeout'));
-        }, 5000);
-        client.on('connect', () => {
-            const request = {
-                type: 'query_lock',
-                id: requestId,
-                photonName,
-                lockName,
-            };
-            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);
-                    }
-                    else {
-                        reject(new Error(response.error || 'Query lock failed'));
-                    }
-                }
-            }
-            catch (e) {
-                logger.warn('Failed to parse daemon response', { error: getErrorMessage(e) });
-            }
-        });
-        client.on('error', (error) => {
-            clearTimeout(requestTimeout);
-            client.destroy();
-            reject(new Error(`Connection error: ${getErrorMessage(error)}`));
-        });
+    return sendSimpleDaemonRequest({
+        type: 'query_lock',
+        photonName,
+        lockName,
     });
 }
 /**
  * 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 = connectToDaemon(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 (e) {
-                logger.warn('Failed to parse daemon response', { error: getErrorMessage(e) });
-            }
-        });
-        client.on('error', (error) => {
-            clearTimeout(timeout);
-            client.destroy();
-            reject(new Error(`Connection error: ${getErrorMessage(error)}`));
-        });
+    return sendSimpleDaemonRequest({
+        type: 'schedule',
+        photonName,
+        sessionId: SESSION_ID,
+        jobId,
+        method,
+        cron,
+        args,
     });
 }
 /**
  * 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 = connectToDaemon(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 (e) {
-                logger.warn('Failed to parse daemon response', { error: getErrorMessage(e) });
-            }
-        });
-        client.on('error', (error) => {
-            clearTimeout(timeout);
-            client.destroy();
-            reject(new Error(`Connection error: ${getErrorMessage(error)}`));
-        });
+    const result = await sendSimpleDaemonRequest({
+        type: 'unschedule',
+        photonName,
+        jobId,
     });
+    return result.unscheduled;
 }
 /**
  * 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 = connectToDaemon(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 (e) {
-                logger.warn('Failed to parse daemon response', { error: getErrorMessage(e) });
-            }
-        });
-        client.on('error', (error) => {
-            clearTimeout(timeout);
-            client.destroy();
-            reject(new Error(`Connection error: ${getErrorMessage(error)}`));
-        });
+    const result = await sendSimpleDaemonRequest({
+        type: 'list_jobs',
+        photonName,
     });
+    return result.jobs || [];
 }
 /** Fire-and-forget helper for the new RPCs. Returns the parsed result.data. */
 async function sendSimpleDaemonRequest(req) {
+    const maxRetries = DEFAULT_DAEMON_COMMAND_RETRIES;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+        try {
+            await ensureDaemonReady();
+            return await sendSimpleDaemonRequestDirect(req);
+        }
+        catch (error) {
+            if (isDaemonConnectionError(error) && attempt < maxRetries) {
+                logger.info(`Daemon unreachable during ${req.type}, waiting for daemon...`);
+                await waitBeforeDaemonRetry(attempt);
+                await ensureDaemonReady();
+                continue;
+            }
+            throw error;
+        }
+    }
+    throw new Error(`${req.type} failed`);
+}
+async function sendSimpleDaemonRequestDirect(req) {
     const socketPath = getGlobalSocketPath();
     const requestId = req.id || `${req.type}_${Date.now()}_${Math.random().toString(36).slice(2)}`;
     return new Promise((resolve, reject) => {
@@ -1195,9 +867,22 @@ export async function pingDaemon(photonName) {
     const requestId = `ping_${Date.now()}`;
     return new Promise((resolve) => {
         const client = tryConnectToDaemon(socketPath);
+        let done = false;
+        const finish = (alive) => {
+            if (done)
+                return;
+            done = true;
+            clearTimeout(timeout);
+            if (alive) {
+                client.end();
+            }
+            else {
+                client.destroy();
+            }
+            resolve(alive);
+        };
         const timeout = setTimeout(() => {
-            client.destroy();
-            resolve(false);
+            finish(false);
         }, 5000);
         client.on('connect', () => {
             const request = {
@@ -1211,9 +896,7 @@ export async function pingDaemon(photonName) {
             try {
                 const response = JSON.parse(chunk.toString().trim());
                 if (response.id === requestId && response.type === 'pong') {
-                    clearTimeout(timeout);
-                    client.destroy();
-                    resolve(true);
+                    finish(true);
                 }
             }
             catch (error) {
@@ -1221,14 +904,10 @@ export async function pingDaemon(photonName) {
             }
         });
         client.on('error', () => {
-            clearTimeout(timeout);
-            client.destroy();
-            resolve(false);
+            finish(false);
         });
         client.on('end', () => {
-            clearTimeout(timeout);
-            client.destroy();
-            resolve(false);
+            finish(false);
         });
     });
 }
@@ -1331,6 +1010,25 @@ export async function clearInstances(photonName, workingDir) {
     });
 }
 export async function getEventsSince(photonName, channel, lastEventId) {
+    const maxRetries = DEFAULT_DAEMON_COMMAND_RETRIES;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+        try {
+            await ensureDaemonReady();
+            return await getEventsSinceDirect(photonName, channel, lastEventId);
+        }
+        catch (error) {
+            if (isDaemonConnectionError(error) && attempt < maxRetries) {
+                logger.info(`Daemon unreachable during get_events_since (${channel}), waiting for daemon...`);
+                await waitBeforeDaemonRetry(attempt);
+                await ensureDaemonReady();
+                continue;
+            }
+            throw error;
+        }
+    }
+    throw new Error('get_events_since failed');
+}
+async function getEventsSinceDirect(photonName, channel, lastEventId) {
     const socketPath = getGlobalSocketPath();
     const requestId = `getevents_${Date.now()}_${Math.random().toString(36).slice(2)}`;
     return new Promise((resolve, reject) => {