@portel/photon 1.19.0 → 1.20.1

package/dist/daemon/server.js

@@ -267,7 +267,7 @@ function cleanupStaleMaps() {
     }
     // Remove empty channel subscription sets and prune destroyed sockets
     for (const [channel, subs] of channelSubscriptions.entries()) {
-        for (const socket of subs) {
+        for (const socket of [...subs]) {
             if (socket.destroyed)
                 subs.delete(socket);
         }
@@ -288,8 +288,10 @@ function cleanupStaleMaps() {
         }
     }
 }
-setInterval(cleanupExpiredLocks, 10000);
-setInterval(cleanupStaleMaps, 60000);
+const lockCleanupInterval = setInterval(cleanupExpiredLocks, 10000);
+const staleMapCleanupInterval = setInterval(cleanupStaleMaps, 60000);
+lockCleanupInterval.unref();
+staleMapCleanupInterval.unref();
 // ════════════════════════════════════════════════════════════════════════════════
 // SCHEDULED JOBS
 // ════════════════════════════════════════════════════════════════════════════════
@@ -711,7 +713,7 @@ function publishToChannel(channel, message, excludeSocket) {
     // Send to exact channel subscribers
     const exactSubscribers = channelSubscriptions.get(channel);
     if (exactSubscribers) {
-        for (const socket of exactSubscribers) {
+        for (const socket of [...exactSubscribers]) {
             if (socket !== excludeSocket && !socket.destroyed && !sentSockets.has(socket)) {
                 try {
                     socket.write(payload);
@@ -730,7 +732,7 @@ function publishToChannel(channel, message, excludeSocket) {
         const wildcardChannel = `${channelPrefix}:*`;
         const wildcardSubscribers = channelSubscriptions.get(wildcardChannel);
         if (wildcardSubscribers) {
-            for (const socket of wildcardSubscribers) {
+            for (const socket of [...wildcardSubscribers]) {
                 if (socket !== excludeSocket && !socket.destroyed && !sentSockets.has(socket)) {
                     try {
                         socket.write(payload);
@@ -803,15 +805,8 @@ async function getOrCreateSessionManager(photonName, photonPath, workingDir) {
     // If @worker tagged, spawn in a worker thread instead of in-process
     if (shouldRunInWorker(pathToUse) && !workerManager.has(key)) {
         try {
-            logger.info('Spawning worker thread for @worker photon', { photonName, key });
-            const info = await workerManager.spawn(key, photonName, pathToUse, workingDir);
-            photonPaths.set(key, pathToUse);
-            if (!photonPaths.has(photonName))
-                photonPaths.set(photonName, pathToUse);
-            if (workingDir)
-                workingDirs.set(key, workingDir);
-            watchPhotonFile(photonName, pathToUse);
-            // Wire dep resolver to go through main thread's getOrCreateSessionManager
+            // Wire dep resolver BEFORE spawn so the worker can resolve @photon deps
+            // during initialization (loadFile triggers dep resolution before 'ready').
             if (!workerManager.depResolver) {
                 workerManager.depResolver = async (depName, depPath, _consumerPhoton) => {
                     const depManager = await getOrCreateSessionManager(depName, depPath, workingDir);
@@ -830,6 +825,14 @@ async function getOrCreateSessionManager(photonName, photonPath, workingDir) {
                     return depManager.loader.executeTool(loaded, method, args);
                 };
             }
+            logger.info('Spawning worker thread for @worker photon', { photonName, key });
+            const info = await workerManager.spawn(key, photonName, pathToUse, workingDir);
+            photonPaths.set(key, pathToUse);
+            if (!photonPaths.has(photonName))
+                photonPaths.set(photonName, pathToUse);
+            if (workingDir)
+                workingDirs.set(key, workingDir);
+            watchPhotonFile(photonName, pathToUse);
             // Return null — caller should check workerManager.has(key) for routing
             // We store a marker so callers know this is a worker photon
             logger.info('Worker photon ready', { photonName, tools: info.tools.length });
@@ -938,39 +941,6 @@ async function getOrCreateSessionManager(photonName, photonPath, workingDir) {
         // Auto-register scheduled jobs and webhook routes from tool metadata
         // Do this lazily on first session creation
         void autoRegisterFromMetadata(key, manager);
-        // Auto-symlink: if this photon was resolved from a @photon dependency path
-        // (e.g. ./chat.photon.ts relative to consumer), ensure it's accessible by bare
-        // name from ~/.photon/local/ so CLI can reach it without manual symlinking.
-        try {
-            const localDir = path.join(os.homedir(), '.photon', 'local');
-            const symlinkName = `${photonName}.photon.ts`;
-            const symlinkPath = path.join(localDir, symlinkName);
-            const resolvedSource = fs.realpathSync(pathToUse);
-            if (!fs.existsSync(symlinkPath)) {
-                fs.mkdirSync(localDir, { recursive: true });
-                fs.symlinkSync(resolvedSource, symlinkPath);
-                logger.info('Auto-created symlink for CLI access', {
-                    photonName,
-                    symlink: symlinkPath,
-                    target: resolvedSource,
-                });
-            }
-            // Also symlink the UI directory if it exists alongside the photon
-            const photonDir = path.dirname(resolvedSource);
-            const uiDir = path.join(photonDir, photonName);
-            const symlinkUiDir = path.join(localDir, photonName);
-            if (fs.existsSync(uiDir) && !fs.existsSync(symlinkUiDir)) {
-                fs.symlinkSync(uiDir, symlinkUiDir);
-                logger.info('Auto-created UI directory symlink', {
-                    photonName,
-                    symlink: symlinkUiDir,
-                    target: uiDir,
-                });
-            }
-        }
-        catch {
-            // Non-critical — CLI access via full path still works
-        }
         return manager;
     }
     catch (error) {
@@ -1433,13 +1403,14 @@ async function handleRequest(request, socket) {
                 suggestion: 'Include photonName in the request payload',
             };
         }
+        const existing = scheduledJobs.get(request.jobId);
         const job = {
             id: request.jobId,
             method: request.method,
             args: request.args,
             cron: request.cron,
-            runCount: 0,
-            createdAt: Date.now(),
+            runCount: existing?.runCount ?? 0,
+            createdAt: existing?.createdAt ?? Date.now(),
             createdBy: request.sessionId,
             photonName,
             workingDir: request.workingDir,
@@ -1488,7 +1459,8 @@ async function handleRequest(request, socket) {
         // not forwarded to worker threads (workers don't know about _use etc.)
         const runtimeTools = ['_use', '_instances', '_undo', '_redo'];
         const cmdKey = compositeKey(photonName, request.workingDir);
-        if (workerManager.has(cmdKey) && !runtimeTools.includes(request.method)) {
+        const readyWorker = workerManager.get(cmdKey);
+        if (readyWorker?.ready && !runtimeTools.includes(request.method)) {
             const startMs = Date.now();
             const result = await workerManager.call(cmdKey, request.method, request.args || {}, request.sessionId || 'default', request.instanceName || '');
             return {
@@ -1500,10 +1472,28 @@ async function handleRequest(request, socket) {
                 durationMs: result.durationMs ?? Date.now() - startMs,
             };
         }
-        // Trigger worker spawn if needed (getOrCreateSessionManager returns null for workers)
-        const sessionManager = await getOrCreateSessionManager(photonName, request.photonPath, request.workingDir);
+        // Trigger worker spawn if needed (getOrCreateSessionManager returns null for workers).
+        // Bound the wait so a slow worker spawn (cascading deps) doesn't block the CLI indefinitely.
+        let sessionManager = null;
+        try {
+            const initPromise = getOrCreateSessionManager(photonName, request.photonPath, request.workingDir);
+            const INIT_TIMEOUT_MS = 60_000;
+            sessionManager = await Promise.race([
+                initPromise,
+                new Promise((_, reject) => setTimeout(() => reject(new Error(`Photon ${photonName} initialization timed out (${INIT_TIMEOUT_MS / 1000}s)`)), INIT_TIMEOUT_MS)),
+            ]);
+        }
+        catch (initErr) {
+            return {
+                type: 'error',
+                id: request.id,
+                error: getErrorMessage(initErr),
+                suggestion: `The photon may still be loading. Try again shortly, or check: cat ${getDefaultContext().logFile}`,
+            };
+        }
         // Re-check: might have spawned a worker
-        if (workerManager.has(cmdKey) && !runtimeTools.includes(request.method)) {
+        const readyWorkerAfterInit = workerManager.get(cmdKey);
+        if (readyWorkerAfterInit?.ready && !runtimeTools.includes(request.method)) {
             const startMs = Date.now();
             const result = await workerManager.call(cmdKey, request.method, request.args || {}, request.sessionId || 'default', request.instanceName || '');
             return {
@@ -2294,9 +2284,11 @@ function watchPhotonFile(photonName, photonPath) {
             const existing = watchDebounce.get(watchPath);
             if (existing)
                 clearTimeout(existing);
-            watchDebounce.set(watchPath, setTimeout(() => {
+            const timer = setTimeout(() => {
                 void (async () => {
-                    watchDebounce.delete(watchPath);
+                    const currentTimer = watchDebounce.get(watchPath);
+                    if (currentTimer === timer)
+                        watchDebounce.delete(watchPath);
                     // On macOS, editors like sed -i and some IDEs replace the file (new inode),
                     // which kills the watcher. Re-watch via original path (symlink) so we
                     // re-resolve to the new real path. Don't return — fall through to reload,
@@ -2345,7 +2337,8 @@ function watchPhotonFile(photonName, photonPath) {
                         });
                     }
                 })();
-            }, 100));
+            }, 100);
+            watchDebounce.set(watchPath, timer);
         });
         if ('on' in watcher && typeof watcher.on === 'function') {
             watcher.on('error', (err) => {
@@ -2451,9 +2444,11 @@ function watchWorkingDir(workingDir) {
             const existing = watchDebounce.get(debounceKey);
             if (existing)
                 clearTimeout(existing);
-            watchDebounce.set(debounceKey, setTimeout(() => {
+            const timer = setTimeout(() => {
                 void (async () => {
-                    watchDebounce.delete(debounceKey);
+                    const currentTimer = watchDebounce.get(debounceKey);
+                    if (currentTimer === timer)
+                        watchDebounce.delete(debounceKey);
                     if (fs.existsSync(workingDir)) {
                         // Still exists — record updated inode in case it was recreated
                         try {
@@ -2506,7 +2501,8 @@ function watchWorkingDir(workingDir) {
                         workingDirInodes.delete(workingDir);
                     }
                 })();
-            }, 150));
+            }, 150);
+            watchDebounce.set(debounceKey, timer);
         });
         if ('on' in watcher && typeof watcher.on === 'function') {
             watcher.on('error', (err) => {
@@ -2548,9 +2544,11 @@ function watchStateDir(workingDir) {
             const existing = watchDebounce.get(debounceKey);
             if (existing)
                 clearTimeout(existing);
-            watchDebounce.set(debounceKey, setTimeout(() => {
+            const timer = setTimeout(() => {
                 void (async () => {
-                    watchDebounce.delete(debounceKey);
+                    const currentTimer = watchDebounce.get(debounceKey);
+                    if (currentTimer === timer)
+                        watchDebounce.delete(debounceKey);
                     const photonStateDir = path.join(stateDir, filename);
                     if (fs.existsSync(photonStateDir))
                         return; // Still there — not a deletion
@@ -2565,7 +2563,8 @@ function watchStateDir(workingDir) {
                         await manager.clearInstances();
                     }
                 })();
-            }, 150));
+            }, 150);
+            watchDebounce.set(debounceKey, timer);
         });
         if ('on' in watcher && typeof watcher.on === 'function') {
             watcher.on('error', (err) => {
@@ -3014,6 +3013,8 @@ function shutdown() {
     if (idleTimer) {
         clearTimeout(idleTimer);
     }
+    clearInterval(lockCleanupInterval);
+    clearInterval(staleMapCleanupInterval);
     for (const timer of jobTimers.values()) {
         clearTimeout(timer);
     }
@@ -3049,12 +3050,36 @@ function shutdown() {
     if (webhookServer) {
         webhookServer.close();
     }
+    // Only delete the socket if we still own it.
+    // After `daemon stop` + `daemon start`, a new daemon may have already created
+    // a new socket at this path. Deleting it would orphan the new daemon's listener.
     if (fs.existsSync(socketPath) && process.platform !== 'win32') {
+        let weOwnSocket = true;
         try {
-            fs.unlinkSync(socketPath);
+            const pidFile = getDefaultContext().pidFile;
+            const pidContent = fs.readFileSync(pidFile, 'utf-8').trim();
+            const filePid = parseInt(pidContent, 10);
+            if (!isNaN(filePid) && filePid !== process.pid) {
+                // PID file points to a different process — new daemon already started
+                weOwnSocket = false;
+                logger.info('Socket belongs to new daemon, skipping cleanup', {
+                    ourPid: process.pid,
+                    newPid: filePid,
+                });
+            }
         }
         catch {
-            // Ignore cleanup errors
+            // PID file missing (deleted by stop) — another process may own the socket now.
+            // If the socket still exists, it likely belongs to a new daemon. Don't delete.
+            weOwnSocket = false;
+        }
+        if (weOwnSocket) {
+            try {
+                fs.unlinkSync(socketPath);
+            }
+            catch {
+                // Ignore cleanup errors
+            }
         }
     }
     process.exit(0);