@portel/photon 1.32.2 → 1.32.4

package/dist/daemon/server.js

@@ -49,36 +49,43 @@ const ownerFile = getOwnerFilePath(socketPath);
 let daemonOwnershipConfirmed = false;
 async function isSocketResponsive(target) {
     // Windows named pipes have no filesystem entry; skip the FS gate on
-    // win32 and let net.createConnection probe the pipe directly. The
-    // 'error' handler below resolves false on failure; the try/catch
-    // wrapper guards against sync throws.
+    // win32 and let the socket probe the pipe directly. Register the
+    // error handler before connect() so Bun cannot surface ENOENT before
+    // listeners exist.
     const isPipe = process.platform === 'win32' && target.startsWith('\\\\.\\pipe\\');
     if (!isPipe && !fs.existsSync(target))
         return false;
     return new Promise((resolve) => {
-        let client;
-        try {
-            // Bun can throw synchronously on a missing/unreachable unix socket
-            // before the 'error' listener attaches — TOCTOU vs. existsSync above.
-            client = net.createConnection(target);
-        }
-        catch {
-            resolve(false);
-            return;
-        }
+        const client = new net.Socket();
+        let done = false;
+        const finish = (alive) => {
+            if (done)
+                return;
+            done = true;
+            clearTimeout(timer);
+            if (alive) {
+                client.end();
+            }
+            else {
+                client.destroy();
+            }
+            resolve(alive);
+        };
         const timer = setTimeout(() => {
-            client.destroy();
-            resolve(false);
+            finish(false);
         }, 1000);
-        client.on('connect', () => {
-            clearTimeout(timer);
-            client.destroy();
-            resolve(true);
-        });
         client.on('error', () => {
-            clearTimeout(timer);
-            resolve(false);
+            finish(false);
+        });
+        client.on('connect', () => {
+            finish(true);
         });
+        try {
+            client.connect(target);
+        }
+        catch {
+            finish(false);
+        }
     });
 }
 // ════════════════════════════════════════════════════════════════════════════════
@@ -193,6 +200,13 @@ const workingDirs = new Map(); // compositeKey -> workingDir
 // Keyed by resolved file path (realpathSync), not composite key.
 const fileWatchers = new Map();
 const watchDebounce = new Map(); // keyed by base:filename, not photon
+const activeFileWatcherReloads = new Set(); // resolved file paths currently being reloaded
+const HOT_RELOAD_DEBOUNCE_MS = parseNonNegativeEnvInt('PHOTON_DAEMON_HOT_RELOAD_DEBOUNCE_MS', 1000);
+const PROACTIVE_METADATA_DEBOUNCE_MS = parseNonNegativeEnvInt('PHOTON_PROACTIVE_METADATA_DEBOUNCE_MS', 1000);
+function parseNonNegativeEnvInt(name, fallback) {
+    const parsed = Number(process.env[name]);
+    return Number.isFinite(parsed) && parsed >= 0 ? parsed : fallback;
+}
 const photonSourceStats = new Map();
 /** Snapshot the stat fields we use as change signal. Null on ENOENT etc. */
 function statOrNull(filePath) {
@@ -212,6 +226,21 @@ function recordPhotonSourceStat(key, photonPath) {
     if (s)
         photonSourceStats.set(key, s);
 }
+function samePhotonSourceStat(a, b) {
+    return !!a && a.mtimeMs === b.mtimeMs && a.size === b.size && a.ino === b.ino;
+}
+function photonSourceAlreadyLoaded(photonName, photonPath) {
+    const current = statOrNull(photonPath);
+    if (!current)
+        return false;
+    for (const [key, storedPath] of photonPaths.entries()) {
+        if (!key.endsWith(`::${photonName}`) || storedPath !== photonPath)
+            continue;
+        if (samePhotonSourceStat(photonSourceStats.get(key), current))
+            return true;
+    }
+    return false;
+}
 /**
  * Compare the current file stat against the last-recorded stat. If the
  * file has changed since the cached photon was loaded, trigger a
@@ -232,9 +261,7 @@ async function statGate(key, photonName, photonPath, workingDir) {
     const current = statOrNull(photonPath);
     if (!current)
         return;
-    if (current.mtimeMs === cached.mtimeMs &&
-        current.size === cached.size &&
-        current.ino === cached.ino) {
+    if (samePhotonSourceStat(cached, current)) {
         return;
     }
     logger.info('stat-gate: source changed since last load, syncing reload', {
@@ -266,6 +293,9 @@ const stateDirWatchers = new Map();
 // @scheduled cron changes and @webhook additions reach the declared-set
 // without a daemon restart. See watchBaseForProactiveMetadata().
 const baseDirWatchers = new Map();
+// photonDir -> SafeWatcher: startup watcher for new .photon.ts files in each
+// active base. Tracked separately so Bun poll timers are closed on shutdown.
+const startupPhotonDirWatchers = new Map();
 import { compositeKey as _compositeKey, declaredKey as _declaredKey, webhookKey as _webhookKey, locationKey as _locationKey, findByPhoton, asScheduleKey, } from './registry-keys.js';
 /**
  * Create a composite key from photonName + workingDir for map lookups.
@@ -1572,7 +1602,7 @@ async function discoverProactiveMetadataAtBoot() {
  * `@scheduled` cron expressions or `@webhook` additions only reached
  * the daemon at restart.
  *
- * Deduped by filename via the existing watchDebounce map (~150 ms) so
+ * Deduped by filename via the existing watchDebounce map so
  * editors that save-twice don't trigger two scans. Skips files that
  * aren't `.photon.ts`.
  */
@@ -1640,7 +1670,7 @@ function watchBaseForProactiveMetadata(basePath, _isDefaultBase) {
                     });
                 }
             })();
-        }, 150);
+        }, PROACTIVE_METADATA_DEBOUNCE_MS);
         timer.unref();
         watchDebounce.set(debounceKey, timer);
     };
@@ -4320,7 +4350,7 @@ async function applyPatchToInstance(instance, photonName, ops, workingDir) {
     if (keys.length === 0)
         return;
     // Get current state as plain JSON
-    const snapshot = await snapshotState(instance, photonName);
+    const snapshot = await snapshotState(instance, photonName, workingDir);
     if (!snapshot)
         return;
     // Apply patch operations
@@ -4515,7 +4545,7 @@ function watchPhotonFile(photonName, photonPath) {
         return;
     try {
         const watcher = safeWatchFile(watchPath, (eventType) => {
-            // Debounce: 100ms (same as Beam)
+            // Trailing debounce: wait for write bursts to settle before reloading.
             const existing = watchDebounce.get(watchPath);
             if (existing)
                 clearTimeout(existing);
@@ -4554,10 +4584,25 @@ function watchPhotonFile(photonName, photonPath) {
                     }
                     if (!fs.existsSync(photonPath))
                         return;
+                    if (activeFileWatcherReloads.has(watchPath)) {
+                        logger.debug('Coalescing file watcher event during active reload', {
+                            photonName,
+                            path: photonPath,
+                        });
+                        return;
+                    }
+                    if (photonSourceAlreadyLoaded(photonName, photonPath)) {
+                        logger.debug('Ignoring file watcher event for already-loaded source', {
+                            photonName,
+                            path: photonPath,
+                        });
+                        return;
+                    }
                     logger.info('File changed, auto-reloading', { photonName, path: photonPath });
                     // Invalidate cached state keys so they're re-extracted from fresh source
                     stateKeysCache.delete(photonName);
                     try {
+                        activeFileWatcherReloads.add(watchPath);
                         await reloadPhoton(photonName, photonPath);
                     }
                     catch (err) {
@@ -4571,8 +4616,11 @@ function watchPhotonFile(photonName, photonPath) {
                             error: getErrorMessage(err),
                         });
                     }
+                    finally {
+                        activeFileWatcherReloads.delete(watchPath);
+                    }
                 })();
-            }, 100);
+            }, HOT_RELOAD_DEBOUNCE_MS);
             watchDebounce.set(watchPath, timer);
         });
         if (typeof watcher.on === 'function') {
@@ -5117,15 +5165,33 @@ function startupWatchPhotons() {
     const defaultBase = getDefaultContext().baseDir;
     const bases = new Set([defaultBase]);
     for (const base of listActiveBases()) {
+        if (!shouldStartupWatchBase(base.path, defaultBase))
+            continue;
         bases.add(base.path);
     }
     for (const photonDir of bases) {
         startupWatchPhotonDir(photonDir, defaultBase);
     }
 }
+function shouldStartupWatchBase(basePath, defaultBase) {
+    const resolved = path.resolve(basePath);
+    if (resolved === path.resolve(defaultBase))
+        return true;
+    // Temporary directories are common in Beam and daemon regression tests. The
+    // bases registry keeps them while the OS temp cleaner has not removed them,
+    // but a production daemon should not spend long-lived watchers on them at
+    // every startup. If a user actively invokes a temp photon later, the normal
+    // request path still loads it and registers on-demand watchers.
+    const tmpRoot = path.resolve(os.tmpdir());
+    if (resolved === tmpRoot || resolved.startsWith(tmpRoot + path.sep))
+        return false;
+    return true;
+}
 function startupWatchPhotonDir(photonDir, defaultBase) {
     if (!fs.existsSync(photonDir))
         return;
+    if (startupPhotonDirWatchers.has(photonDir))
+        return;
     // Host mode: when the default base is host-disabled, skip the file
     // watcher, the eager onInitialize loader, and the directory watcher
     // entirely. They all activate background work that the marker is
@@ -5250,6 +5316,7 @@ function startupWatchPhotonDir(photonDir, defaultBase) {
         if (typeof dirWatcher.on === 'function') {
             dirWatcher.on('error', () => { }); // Non-fatal
         }
+        startupPhotonDirWatchers.set(photonDir, dirWatcher);
     }
     catch {
         logger.warn('Failed to watch photon directory for new files', { dir: photonDir });
@@ -5297,7 +5364,13 @@ function startServer() {
             cleanupSocketSubscriptions(socket);
         });
         socket.on('error', (error) => {
-            logger.warn('Socket error', { error: getErrorMessage(error) });
+            const code = error?.code;
+            if (code === 'ECONNRESET' || code === 'EPIPE') {
+                logger.debug('Socket closed by client', { error: getErrorMessage(error) });
+            }
+            else {
+                logger.warn('Socket error', { error: getErrorMessage(error) });
+            }
             connectedSockets.delete(socket);
             cleanupSocketSubscriptions(socket);
         });
@@ -5632,6 +5705,22 @@ function shutdown() {
         for (const photonPath of fileWatchers.keys()) {
             unwatchPhotonFile(photonPath);
         }
+        for (const watcher of startupPhotonDirWatchers.values()) {
+            watcher.close();
+        }
+        startupPhotonDirWatchers.clear();
+        for (const watcher of baseDirWatchers.values()) {
+            watcher.close();
+        }
+        baseDirWatchers.clear();
+        for (const watcher of parentDirWatchers.values()) {
+            watcher.close();
+        }
+        parentDirWatchers.clear();
+        for (const watcher of stateDirWatchers.values()) {
+            watcher.close();
+        }
+        stateDirWatchers.clear();
         // Clean up poll-based watchers (bun fallback)
         for (const timer of pollTimers) {
             clearInterval(timer);