@omnitron-dev/omnitron 0.3.5 → 0.4.6

package/dist/orchestrator/orchestrator.service.js

@@ -35,6 +35,7 @@ import { stackExecutionKey, executionScopeKey, executionScopeOwns } from '../sha
  *     → Two Netron instances: PM management plane + app HTTP data plane
  */
 import { ReadinessMonitor } from '../health/readiness.js';
+import { FileWatcher } from './file-watcher.js';
 import fs from 'node:fs';
 import { readDeclaredConfig, withDeclaredConfig } from '../project/declared-config.js';
 import path from 'node:path';
@@ -210,6 +211,7 @@ export class OrchestratorService extends EventEmitter {
     devMode = false;
     /** esbuild bundling pipeline — pre-bundles TS entry points for child processes */
     buildService = null;
+    fileWatcher = null;
     watchDisabled = false;
     watchSelection = null;
     bootstrapSources = new Map();
@@ -226,11 +228,42 @@ export class OrchestratorService extends EventEmitter {
             if (!enabled || !this.handles.get(name) || !this.allowsWatch(this.handles.get(name).entry))
                 state.watchSerial = 0;
         }
+        this.syncClassicWatches();
         await Promise.all([...this.bootstrapSources.keys()].map((name) => this.syncBootstrapWatch(name)));
     }
-    getBuildWatchedApps() {
-        return [...this.bootstrapSources].filter(([name]) => this.buildService?.isWatching(name))
-            .map(([name, source]) => ({ name, directory: path.dirname(source.path) }));
+    getWatchedApps() {
+        const registrations = [...(this.fileWatcher?.getWatchedApps() ?? []),
+            ...[...this.bootstrapSources].filter(([name]) => this.buildService?.isWatching(name))
+                .map(([name, source]) => ({ name, directory: path.dirname(source.path) }))];
+        return registrations.flatMap(watch => {
+            const handle = this.handles.get(watch.name);
+            return handle ? [{ ...watch, generation: handle.generation, definitionRevision: handle.definitionRevision }] : [];
+        });
+    }
+    /** Native subscriptions follow the same owned handles and policy as esbuild. */
+    syncClassicWatches() {
+        if (!this.devMode || this.watchDisabled || this.stoppingApps || !this.config) {
+            this.fileWatcher?.stop();
+            this.fileWatcher = null;
+            return;
+        }
+        const apps = [...this.handles.values()].filter(handle => {
+            if (handle.entry.bootstrap || !this.allowsWatch(handle.entry) || this.executionBusy(handle.name))
+                return false;
+            if (handle.status === 'online' && !this.appStopIntents.get(handle.name)?.stopped)
+                return true;
+            // An internal restart keeps its existing source subscription and pending
+            // edits. Re-arming fs.watch on every child generation loses macOS events.
+            return !['crashed', 'errored'].includes(handle.status) &&
+                Boolean(this.restartCoalescer.get(handle.name)?.inFlight) && this.fileWatcher?.isWatching(handle.entry);
+        }).map(handle => handle.entry);
+        const config = { ...this.config, apps };
+        if (this.fileWatcher)
+            this.fileWatcher.applyConfig(config);
+        else {
+            this.fileWatcher = new FileWatcher(this.logger, this, config, this.cwd);
+            this.fileWatcher.start();
+        }
     }
     async syncBootstrapWatch(name) {
         const source = this.bootstrapSources.get(name);
@@ -254,12 +287,42 @@ export class OrchestratorService extends EventEmitter {
         }, this.devMode);
     }
     /** Automatic triggers remain revocable while queued; manual restart is independent. */
-    async restartAfterChange(name) {
+    async restartAfterChange(name, expected) {
         const canonical = this.resolveAppName(name) ?? name;
+        if (expected && canonical !== name)
+            throw Errors.badRequest(`Source refresh requires the observed canonical application name '${canonical}'`);
         const handle = this.handles.get(canonical);
-        if (!handle || !this.allowsWatch(handle.entry))
-            return handle;
-        return this.restartAppCoalesced(canonical, true, 'watch');
+        if (expected && (!handle || handle.generation !== expected.generation || handle.definitionRevision !== expected.definitionRevision))
+            throw Errors.conflict(`Application '${canonical}' source binding changed; observe its watch status before retrying`);
+        if (!handle || !this.allowsWatch(handle.entry)) {
+            if (expected)
+                throw Errors.conflict(`Source refresh of '${canonical}' is excluded by the current watch policy`);
+            return undefined;
+        }
+        if (expected && !this.getWatchedApps().some(app => app.name === canonical &&
+            app.generation === expected.generation && app.definitionRevision === expected.definitionRevision))
+            throw Errors.conflict(`Source watcher for '${canonical}' is unavailable; SDK refresh was not started`);
+        const entry = handle.entry;
+        const definitionRevision = handle.definitionRevision;
+        const generation = handle.generation;
+        const result = await this.restartAppCoalesced(canonical, true, 'watch');
+        if (handle.definitionRevision !== definitionRevision || result.entry !== entry ||
+            result.generation === generation || result.status !== 'online') {
+            if (expected)
+                throw Errors.conflict(`Source refresh of '${canonical}' was cancelled or its source binding changed`);
+            return undefined;
+        }
+        const source = this.getWatchedApps().find(app => app.name === canonical &&
+            app.generation === result.generation && app.definitionRevision === result.definitionRevision);
+        if (expected && !source)
+            throw Errors.conflict(`Source watcher for '${canonical}' is unavailable after restart; SDK readiness is not confirmed`);
+        const process = this.getApp(canonical);
+        if (!source || !process || process.status !== 'online' || process.generation !== source.generation) {
+            if (expected)
+                throw Errors.conflict(`Source refresh of '${canonical}' has no matching online observation`);
+            return undefined;
+        }
+        return { process, source };
     }
     /** Cached build results per app name */
     buildResults = new Map();
@@ -411,6 +474,7 @@ export class OrchestratorService extends EventEmitter {
      */
     setConfig(config) {
         this.config = config;
+        this.syncClassicWatches();
         // Metrics polling is armed here rather than in `startAll` alone.
         //
         // It used to run only from `startAll`, which is the `omnitron start`
@@ -777,6 +841,7 @@ export class OrchestratorService extends EventEmitter {
                         throw new Error(`Cannot replace '${key}' with '${entry.name}': the previous application did not stop`, { cause: err });
                     }
                     this.handles.delete(key);
+                    this.syncClassicWatches();
                     if (key !== entry.name)
                         this.metricsBridge?.evictApp(key);
                     continue;
@@ -794,6 +859,7 @@ export class OrchestratorService extends EventEmitter {
             // processes still run: an errored app's other children and its pools.
             await this.tearDownApp(h);
             this.handles.delete(key);
+            this.syncClassicWatches();
             // Drop any metrics that were collected under the stale alias so it
             // doesn't haunt future snapshots as a ghost offline app.
             if (key !== entry.name)
@@ -830,6 +896,7 @@ export class OrchestratorService extends EventEmitter {
             handle.restartWindow = existing.restartWindow;
         }
         this.handles.set(entry.name, handle);
+        this.syncClassicWatches();
         // Arm metrics sampling here — the one place an app enters the registry.
         //
         // It used to be armed only from `startAll` (the `omnitron start` path).
@@ -902,6 +969,9 @@ export class OrchestratorService extends EventEmitter {
                 this.scheduleRecovery(entry, handle, cfg);
             throw failure;
         }
+        finally {
+            this.syncClassicWatches();
+        }
     }
     /**
      * Everything a handle still runs, stopped: its supervisor's children (or its
@@ -992,8 +1062,12 @@ export class OrchestratorService extends EventEmitter {
             return active.promise;
         this.assertExecutionIdle(scope);
         // Reserve before invoking work, including its synchronous checks and first write.
-        const promise = Promise.resolve().then(work).finally(() => this.executionOperations.delete(key));
+        const promise = Promise.resolve().then(work).finally(() => {
+            this.executionOperations.delete(key);
+            this.syncClassicWatches();
+        });
         this.executionOperations.set(key, { id: operationId, fingerprint, promise });
+        this.syncClassicWatches();
         return promise;
     }
     /**
@@ -1068,6 +1142,7 @@ export class OrchestratorService extends EventEmitter {
                 }
             }
             this.persistState();
+            this.syncClassicWatches();
             for (const name of retired) {
                 this.emit('app:retired', name);
                 this.metricsBridge?.evictApp(name);
@@ -1351,7 +1426,12 @@ export class OrchestratorService extends EventEmitter {
         }
     }
     async stopApp(name, force = false, timeout = 10_000) {
+        return this.stopAppQueued(name, force, timeout);
+    }
+    async stopAppQueued(name, force = false, timeout = 10_000, preserveWatch = false) {
         const canonical = this.resolveAppName(name) ?? name;
+        if (!preserveWatch)
+            this.fileWatcher?.removeApp(canonical);
         // Outside the queue on purpose: the operator's intent lands the
         // moment the command arrives, not whenever the queue drains.
         // Unknown names need no retained intent. Start admission registers its
@@ -1388,6 +1468,7 @@ export class OrchestratorService extends EventEmitter {
             this.clearCoolDown(name);
         const operation = Promise.resolve().then(() => this.stopAllOnce(force));
         this.stoppingApps = operation;
+        this.syncClassicWatches();
         const settled = () => { if (this.stoppingApps === operation)
             this.stoppingApps = null; };
         void operation.then(settled, settled);
@@ -1482,11 +1563,13 @@ export class OrchestratorService extends EventEmitter {
             throw new Error('An installed stack start is active; its application entry cannot be changed');
         }
         handle.redefine(entry);
-        if (!this.allowsWatch(entry)) {
-            const state = this.restartCoalescer.get(handle.name);
-            if (state)
-                state.watchSerial = 0;
-        }
+        this.fileWatcher?.revokePending(handle.name);
+        // A pending source event belongs to the previous definition, even when
+        // the replacement also enables watching or restores the original path.
+        const state = this.restartCoalescer.get(handle.name);
+        if (state)
+            state.watchSerial = 0;
+        this.syncClassicWatches();
         await this.syncBootstrapWatch(handle.name);
         return true;
     }
@@ -1527,6 +1610,10 @@ export class OrchestratorService extends EventEmitter {
         const canonical = this.resolveAppName(name) ?? name;
         const handle = this.handles.get(canonical);
         if (!handle) {
+            // A queued source event cannot resurrect a registration removed while
+            // awaiting a cooldown or another lifecycle operation.
+            if (!fromExternal || cause === 'watch')
+                throw new Error(`Application '${canonical}' was removed before restart`);
             // A PROJECT-QUALIFIED name with no live handle is not this daemon's to
             // start, and matching it against the daemon's own config starts the
             // WRONG APP.
@@ -1562,12 +1649,17 @@ export class OrchestratorService extends EventEmitter {
         const state = this.getCoalescerState(name);
         if (fromExternal) {
             state.triggerSerial += 1;
-            if (cause === 'watch')
+            if (cause === 'watch') {
                 state.watchSerial = state.triggerSerial;
+                state.watchBinding = { handle, entry: handle.entry, definitionRevision: handle.definitionRevision };
+            }
             else
                 state.manualSerial = state.triggerSerial;
         }
-        if (!this.allowsWatch(handle.entry) || ['errored', 'crashed', 'stopped', 'stopping'].includes(handle.status)) {
+        if (!this.allowsWatch(handle.entry) || ['errored', 'crashed'].includes(handle.status) ||
+            (!state.inFlight && ['stopped', 'stopping'].includes(handle.status)) ||
+            !state.watchBinding || state.watchBinding.entry !== handle.entry ||
+            state.watchBinding.handle.definitionRevision !== state.watchBinding.definitionRevision) {
             state.watchSerial = 0;
         }
         const observedSerial = Math.max(state.manualSerial, state.watchSerial);
@@ -1669,7 +1761,7 @@ export class OrchestratorService extends EventEmitter {
         if (this.devMode && entry.bootstrap) {
             clearCacheFor(path.resolve(entry.cwd ?? this.cwd, entry.bootstrap));
         }
-        const stopped = this.stopApp(name);
+        const stopped = this.stopAppQueued(name, false, 10_000, true);
         const intent = this.appStopIntents.get(name);
         const generation = this.stopGeneration;
         await stopped;
@@ -1684,7 +1776,7 @@ export class OrchestratorService extends EventEmitter {
     getCoalescerState(name) {
         let state = this.restartCoalescer.get(name);
         if (!state) {
-            state = { inFlight: null, triggerSerial: 0, firedSerial: 0, manualSerial: 0, watchSerial: 0, cooldownUntil: 0 };
+            state = { inFlight: null, triggerSerial: 0, firedSerial: 0, manualSerial: 0, watchSerial: 0, watchBinding: null, cooldownUntil: 0 };
             this.restartCoalescer.set(name, state);
         }
         return state;
@@ -2134,6 +2226,7 @@ export class OrchestratorService extends EventEmitter {
                 this.scheduleRecovery(entry, handle, config);
             }
             this.persistState();
+            this.syncClassicWatches();
         });
         return launch;
     }
@@ -2158,7 +2251,7 @@ export class OrchestratorService extends EventEmitter {
         let topology;
         let definition;
         try {
-            const captured = await readBootstrapMetadata(bootstrapAbsPath, this.devMode && !entry.releaseRoot, 60_000);
+            const captured = await readBootstrapMetadata(bootstrapAbsPath, this.devMode && !entry.releaseRoot, 60_000, entry.releaseRoot);
             definition = captured.definition;
             handle.bootstrapMetadata = captured.metadata;
             topology = definition.processes;
@@ -2251,6 +2344,7 @@ export class OrchestratorService extends EventEmitter {
         return launch;
     }
     async discardSourceBuild(name) {
+        this.fileWatcher?.removeApp(name);
         const state = this.restartCoalescer.get(name);
         if (state)
             state.watchSerial = 0;
@@ -2310,7 +2404,8 @@ export class OrchestratorService extends EventEmitter {
         // application generation. Resolve before allocating topology resources.
         const runtime = await this.bootstrapRuntime(bootstrapAbsPath);
         const policy = buildRestartPolicy(entry, config);
-        const spawnEnv = withClosureLibraryPath(entry.env, [entry.releaseRoot, entry.cwd, bootstrapAbsPath]);
+        const spawnEnv = withClosureLibraryPath(entry.env, entry.releaseRoot
+            ? { verifiedRoot: entry.releaseRoot } : [entry.cwd, bootstrapAbsPath]);
         const needsRouting = topology.some(proc => proc.topology?.expose === true || proc.topology?.access?.length);
         handle.deferStartup();
         if (needsRouting) {
@@ -2552,7 +2647,8 @@ export class OrchestratorService extends EventEmitter {
     async launchSingleProcess(entry, handle, config, bootstrapAbsPath, buildResult) {
         const instances = entry.instances ?? 1;
         const policy = buildRestartPolicy(entry, config);
-        const spawnEnv = withClosureLibraryPath(entry.env, [entry.releaseRoot, entry.cwd, bootstrapAbsPath]);
+        const spawnEnv = withClosureLibraryPath(entry.env, entry.releaseRoot
+            ? { verifiedRoot: entry.releaseRoot } : [entry.cwd, bootstrapAbsPath]);
         // For single-process apps, use the first (only) process entry's bundled module
         const firstProcessName = buildResult?.modulePaths.keys().next().value;
         const bundledModulePath = firstProcessName
@@ -2672,6 +2768,7 @@ export class OrchestratorService extends EventEmitter {
         handle.clearLastExit();
         this.startPostOnlineCooldown(name);
         this.persistState();
+        this.syncClassicWatches();
         this.emit('app:online', name);
     }
     /**