@portel/photon 1.28.2 → 1.31.0

package/dist/daemon/server.js

@@ -144,8 +144,10 @@ setBroker(inProcessBroker);
 const workerManager = new WorkerManager(logger);
 // Wire worker manager pub/sub bridge to main broker
 workerManager.onPublish = (channel, message) => {
+    // Worker pub/sub bridge: the worker emits a ChannelMessage-shaped envelope;
+    // unknown → ChannelMessage cast is the trust boundary between the worker
+    // protocol and the in-process broker.
     void inProcessBroker.publish(message);
-    // Also forward to other workers
     workerManager.dispatchToWorkers(channel, message);
 };
 // Track connected sockets for graceful shutdown broadcast
@@ -311,6 +313,8 @@ const pendingPrompts = new Map();
 const channelSubscriptions = new Map();
 /** Buffer retention window — events older than this are purged */
 const EVENT_BUFFER_DURATION_MS = 5 * 60 * 1000; // 5 minutes
+/** Hard cap per channel — prevents unbounded growth on high-frequency channels */
+const MAX_BUFFER_EVENTS_PER_CHANNEL = 500;
 const channelEventBuffers = new Map();
 function bufferEvent(channel, message) {
     let buffer = channelEventBuffers.get(channel);
@@ -338,6 +342,13 @@ function bufferEvent(channel, message) {
             buffer.events.splice(0, firstValid);
         }
     }
+    // Hard cap: trim oldest when a high-frequency channel exceeds the count limit.
+    // A reconnecting subscriber whose lastEventId predates the oldest buffered event
+    // will receive refreshNeeded:true via getEventsSince — same handling as the
+    // time-based purge above.
+    if (buffer.events.length > MAX_BUFFER_EVENTS_PER_CHANNEL) {
+        buffer.events.splice(0, buffer.events.length - MAX_BUFFER_EVENTS_PER_CHANNEL);
+    }
     return now;
 }
 function getEventsSince(channel, lastTimestamp) {
@@ -1346,6 +1357,8 @@ async function scanOneForProactiveMetadata(photonName, filePath, workingDir) {
         return dropProactiveMetadataFor(photonName, workingDir);
     }
     let changed = false;
+    // ExtractedMetadata isn't part of photon-core's public surface; type the
+    // bits we read structurally so we get checking without re-exporting.
     let meta;
     try {
         const extractor = new SchemaExtractor();
@@ -1366,8 +1379,7 @@ async function scanOneForProactiveMetadata(photonName, filePath, workingDir) {
     // See src/daemon/registry-keys.ts for the branded-key rationale.
     const nextSchedules = new Map();
     const nextRoutes = new Map(); // routePath → methodName
-    for (const rawTool of meta.tools) {
-        const tool = rawTool;
+    for (const tool of meta.tools) {
         if (tool.scheduled) {
             nextSchedules.set(declaredKey(photonName, tool.name, workingDir), {
                 photon: photonName,
@@ -3703,7 +3715,8 @@ async function handleRequest(request, socket) {
             // Worker photons don't have a session manager — handle runtime tools directly
             if (workerManager.has(cmdKey) && runtimeTools.includes(request.method)) {
                 if (request.method === '_use') {
-                    const instanceName = String(request.args?.name ?? '');
+                    const rawName = request.args?.name;
+                    const instanceName = typeof rawName === 'string' ? rawName : '';
                     const label = instanceName || 'default';
                     return {
                         type: 'result',
@@ -3760,7 +3773,8 @@ async function handleRequest(request, socket) {
             }
             // ── Runtime-injected instance tools ──────────────────────────
             if (request.method === '_use') {
-                const instanceName = String(request.args?.name ?? '');
+                const rawName = request.args?.name;
+                const instanceName = typeof rawName === 'string' ? rawName : '';
                 await sessionManager.switchInstance(session.id, instanceName);
                 const label = instanceName || 'default';
                 // Ensure a state file exists so _instances can discover this instance
@@ -4252,7 +4266,10 @@ async function appendEventLog(photonName, instanceName, entry, workingDir) {
             const stat = await fsPromises.stat(logPath);
             if (stat.size >= EVENT_LOG_MAX_SIZE) {
                 const rotatedPath = logPath + '.1';
-                await fsPromises.rename(logPath, rotatedPath).catch(() => { });
+                await fsPromises.rename(logPath, rotatedPath).catch((err) => logger.debug('Event log rotation rename failed', {
+                    photon: photonName,
+                    error: String(err),
+                }));
                 logger.debug('Rotated event log', { photon: photonName, instance: instanceName });
             }
         }
@@ -4559,7 +4576,7 @@ function watchPhotonFile(photonName, photonPath) {
             }, 100);
             watchDebounce.set(watchPath, timer);
         });
-        if ('on' in watcher && typeof watcher.on === 'function') {
+        if (typeof watcher.on === 'function') {
             watcher.on('error', (err) => {
                 logger.warn('File watcher error', { photonName, error: getErrorMessage(err) });
                 unwatchPhotonFile(watchPath);
@@ -4723,7 +4740,7 @@ function watchWorkingDir(workingDir) {
             }, 150);
             watchDebounce.set(debounceKey, timer);
         });
-        if ('on' in watcher && typeof watcher.on === 'function') {
+        if (typeof watcher.on === 'function') {
             watcher.on('error', (err) => {
                 logger.warn('workingDir parent watcher error', { parentDir, error: getErrorMessage(err) });
                 parentDirWatchers.delete(parentDir);
@@ -4785,7 +4802,7 @@ function watchStateDir(workingDir) {
             }, 150);
             watchDebounce.set(debounceKey, timer);
         });
-        if ('on' in watcher && typeof watcher.on === 'function') {
+        if (typeof watcher.on === 'function') {
             watcher.on('error', (err) => {
                 logger.warn('State dir watcher error', { stateDir, error: getErrorMessage(err) });
                 stateDirWatchers.delete(workingDir);
@@ -5188,7 +5205,7 @@ function startupWatchPhotons() {
                 });
                 return;
             }
-            eagerLoad().catch(() => { });
+            eagerLoad().catch((err) => logger.debug('Eager load failed', { error: String(err) }));
         }, 1000);
     }
     // Watch the directory itself for new photon files added after startup
@@ -5220,7 +5237,7 @@ function startupWatchPhotons() {
                 logger.info('Photon file removed', { photonName, path: filePath });
             }
         });
-        if ('on' in dirWatcher && typeof dirWatcher.on === 'function') {
+        if (typeof dirWatcher.on === 'function') {
             dirWatcher.on('error', () => { }); // Non-fatal
         }
     }
@@ -5345,6 +5362,47 @@ function startServer() {
             stack: reason instanceof Error ? reason.stack : undefined,
         });
     });
+    // Periodic self-check: log once when the daemon binary on disk is newer
+    // than this running daemon. The DaemonManager.isBinaryStale path already
+    // restarts the daemon when a CLI command runs after `npm install`, so
+    // the staleness window for interactive users is short. This nudge
+    // covers the *non-interactive* case: a developer who upgrades photon
+    // and then walks away leaving only scheduled jobs running. The daemon
+    // does NOT auto-exit — schedules need continuity, and the next CLI
+    // invocation triggers the same restart anyway. The warning is logged
+    // at most once per detected upgrade so it doesn't spam the log when
+    // running for hours after an upgrade.
+    // Default 60s interval; tests can override via env var to assert the
+    // log warning fires without waiting a full minute.
+    const STALE_CHECK_INTERVAL_MS = Math.max(100, Number.parseInt(process.env.PHOTON_STALE_CHECK_INTERVAL_MS || '', 10) || 60_000);
+    const daemonStartedAtMs = Date.now();
+    let lastWarnedBinaryMtimeMs = 0;
+    const myScript = process.argv[1];
+    if (myScript) {
+        const staleCheckTimer = setInterval(() => {
+            try {
+                const mtime = fs.statSync(myScript).mtimeMs;
+                if (mtime > daemonStartedAtMs && mtime !== lastWarnedBinaryMtimeMs) {
+                    lastWarnedBinaryMtimeMs = mtime;
+                    logger.warn('Daemon binary on disk is newer than this running daemon. ' +
+                        'Run any photon CLI command (e.g. `photon ps`) to bounce the daemon to the new build, ' +
+                        'or restart it manually with `pkill -9 -f daemon/server.js`.', {
+                        pid: process.pid,
+                        scriptPath: myScript,
+                        binaryMtimeMs: mtime,
+                        daemonStartedAtMs,
+                        ageSec: Math.round((mtime - daemonStartedAtMs) / 1000),
+                    });
+                }
+            }
+            catch {
+                // stat raced with a write — try again next tick.
+            }
+        }, STALE_CHECK_INTERVAL_MS);
+        // Don't keep the event loop alive on this watchdog alone — the
+        // listening socket is the canonical liveness anchor.
+        staleCheckTimer.unref?.();
+    }
 }
 /**
  * Scan the OS process table for any other process whose argv looks like