om-memory-system 4.11.0-next.96 → 4.11.1

package/dist/cli/web-update-command.d.ts

@@ -20,7 +20,9 @@ export interface WebUpdateCommandDeps {
     restartLoginItem: () => boolean;
     /** Start a detached web app through the launcher. False when there is nothing to start. */
     startDetached: () => boolean;
-    writeStartLock: () => void;
+    /** Take the start lock. False when another caller holds a fresh one. */
+    takeStartLock: () => boolean;
+    /** Remove the start lock, only when this process holds it. */
     removeStartLock: () => void;
     writeRetireMarker: (before: number) => void;
     print: (line: string) => void;

package/dist/cli/web-update-command.js

@@ -91,7 +91,11 @@ export async function runWebUpdate(deps) {
         deps.print(`Global install is up to date (${before}).`);
     }
     // 2. Replace every standalone web app. Hosts wait while no web app serves.
-    deps.writeStartLock();
+    // A fresh lock of another caller is left alone, and so is that caller's start.
+    if (!deps.takeStartLock()) {
+        deps.print("Another start is running (a host start or another web update). Wait a few seconds, then run om-memory-system web update again.");
+        return finish(1, "lock-held", "lock-held");
+    }
     try {
         deps.writeRetireMarker(deps.now());
         const owner = await readOwner(deps);
@@ -114,13 +118,11 @@ export async function runWebUpdate(deps) {
         const deadline = deps.now() + FRESH_WAIT_MS;
         while (deps.now() < deadline) {
             const current = await readOwner(deps);
-            if (current && !askedAside.has(current.instance)) {
-                const older = current.version !== null && (compareVersions(current.version, deps.version) ?? 0) < 0;
-                if (!older) {
+            // A web app that hides its version cannot be told from an old waiter, so keep waiting.
+            if (current?.version && !askedAside.has(current.instance)) {
+                if ((compareVersions(current.version, deps.version) ?? 0) >= 0) {
                     record.served = current.version;
-                    deps.print(current.version
-                        ? `OMMS web app: ${deps.url} (version ${current.version})`
-                        : `OMMS web app: ${deps.url}`);
+                    deps.print(`OMMS web app: ${deps.url} (version ${current.version})`);
                     return finish(0, "replaced");
                 }
                 // An older web app that waited for the port took it before the fresh one.
@@ -138,7 +140,7 @@ export async function runWebUpdate(deps) {
 }
 /** The real network, npm, login item, and launcher. */
 export async function productionWebUpdateDeps(options) {
-    const [{ spawn }, { existsSync }, { join }, { AUTH_HEADER, getOrCreateAuthToken }, { packageVersion }, { latestNpmVersion }, { globalCommandVersion }, { runGlobalInstall }, { nodeInstallDeps }, { restartWebAutostart, webAutostartStatus }, { launcherPath, recordedCopy }, { ommsDir }, { nodeLockFs, removeStartLockFor, startLockPath }, { writeRetireMarker }, { log },] = await Promise.all([
+    const [{ spawn }, { existsSync }, { join }, { AUTH_HEADER, getOrCreateAuthToken }, { packageVersion }, { latestNpmVersion }, { globalCommandVersion }, { runGlobalInstall }, { nodeInstallDeps }, { restartWebAutostart, webAutostartStatus }, { launcherPath, recordedCopy }, { ommsDir }, { nodeLockFs, processAlive, removeStartLockFor, startLockPath, takeStartLock }, { writeRetireMarker }, { log },] = await Promise.all([
         import("node:child_process"),
         import("node:fs"),
         import("node:path"),
@@ -194,7 +196,13 @@ export async function productionWebUpdateDeps(options) {
                 return false;
             }
         },
-        writeStartLock: () => nodeLockFs.replace(lockPath, JSON.stringify({ pid: process.pid, at: Date.now() })),
+        takeStartLock: () => takeStartLock({
+            lockPath,
+            lockFs: nodeLockFs,
+            pid: process.pid,
+            now: () => Date.now(),
+            pidAlive: processAlive,
+        }),
         removeStartLock: () => removeStartLockFor(process.pid, lockPath),
         writeRetireMarker: (before) => writeRetireMarker(before, { home: options.home }),
         print: (line) => console.log(line),

package/dist/services/web-ensure.d.ts

@@ -74,6 +74,7 @@ export declare const nodeLockFs: LockFs;
 export declare function renameRetrying(from: string, to: string, rename?: (from: string, to: string) => void, platform?: NodeJS.Platform, wait?: (ms: number) => void): void;
 /** Remove the start lock when it names `pid`. A restart copy calls this once it owns the port. */
 export declare function removeStartLockFor(pid: number, path?: string, lockFs?: LockFs): void;
+export declare function processAlive(pid: number): boolean;
 /** What taking the start lock needs; a test drives two callers through it step by step. */
 export type LockDeps = Pick<EnsureDeps, "lockPath" | "lockFs" | "pid" | "now" | "pidAlive">;
 /**

package/dist/services/web-ensure.js

@@ -111,7 +111,7 @@ export function removeStartLockFor(pid, path = startLockPath(), lockFs = nodeLoc
         /* An unreadable lock is stale and the next caller replaces it. */
     }
 }
-function processAlive(pid) {
+export function processAlive(pid) {
     try {
         process.kill(pid, 0);
         return true;