om-memory-system 5.9.0 → 5.9.1

package/bin/omms-launch.mjs

@@ -5,8 +5,8 @@
 //
 //   node omms-launch.mjs [--at-least-own-version] <om-memory-system arguments>
 //
-// Candidates: the copy named in ~/.omms/runtime.json, the global install beside
-// the running Node.js, and the copy that holds this file. With
+// Candidates: the global install beside the running Node.js, the copy named in
+// ~/.omms/runtime.json, and the copy that holds this file. On a tie the first wins. With
 // `--at-least-own-version`, the version in the `package.json` beside this file is
 // the minimum. When no candidate reaches it, the launcher runs
 // `npx --yes om-memory-system@<that version>`.
@@ -96,7 +96,11 @@ export function globalPackageRoots(execPath, platform = process.platform) {
   return brew ? [direct, join(brew[1], "lib", "node_modules", "om-memory-system")] : [direct];
 }
 
-/** The record's copy, the global installs, and the own copy, in that order. Invalid ones are null. */
+/**
+ * The global installs, the record's copy, and the own copy, in that order. Invalid
+ * ones are null. On a tie the global install wins, so a host's cache copy does not
+ * keep serving after the global install catches up.
+ */
 export function findCandidates({ dir, execPath, ownRoot }) {
   let recorded = null;
   try {
@@ -106,7 +110,7 @@ export function findCandidates({ dir, execPath, ownRoot }) {
     /* No record, or an unreadable one: the other candidates still work. */
   }
   const globals = globalPackageRoots(execPath).map((root) => readCopy(root));
-  return [recorded, ...globals, ownRoot ? readCopy(ownRoot) : null];
+  return [...globals, recorded, ownRoot ? readCopy(ownRoot) : null];
 }
 
 /**

package/dist/cli/web-command.js

@@ -130,6 +130,17 @@ export async function runWebCommand(args, options = {}, online, handover = {}, u
     process.once("SIGTERM", stop);
     // The page's Stop and Restart buttons reach the same process through this callback.
     const { createPowerAction } = await import("./web-power.js");
+    // A restart whose copy failed serves again from this process.
+    // Safe to call twice: it replaces the keeper and the signal handlers instead of adding more.
+    const resumeServer = async () => {
+        clearInterval(keeper);
+        keeper = setInterval(() => { }, 60_000);
+        process.off("SIGINT", stop);
+        process.off("SIGTERM", stop);
+        process.once("SIGINT", stop);
+        process.once("SIGTERM", stop);
+        await server.start();
+    };
     const powerAction = createPowerAction({
         stopServer: async () => {
             clearInterval(keeper);
@@ -137,13 +148,7 @@ export async function runWebCommand(args, options = {}, online, handover = {}, u
             process.off("SIGTERM", stop);
             await server.stop();
         },
-        // A restart whose copy failed serves again from this process.
-        resumeServer: async () => {
-            keeper = setInterval(() => { }, 60_000);
-            process.once("SIGINT", stop);
-            process.once("SIGTERM", stop);
-            await server.start();
-        },
+        resumeServer,
         baseUrl: server.getUrl(),
         loginItem: action === "--login-item",
         autostart: options,
@@ -157,11 +162,22 @@ export async function runWebCommand(args, options = {}, online, handover = {}, u
     // Every restart onto the new copy runs the launcher, the login item's included.
     const canRestart = () => existsSync(launcherPath(ommsDir()));
     server.setWebUpdate(startWebUpdate(() => powerAction("update"), canRestart, () => server.powerActionRunning));
-    // A newer `web install` asked this web app to give up the port.
+    // A newer caller asked this web app to give up the port. If the caller's copy
+    // never takes it, restart onto the newest copy instead of leaving it empty.
+    const { leaveAfterStepAside } = await import("./web-step-aside.js");
+    const { log } = await import("../services/logger.js");
     server.setOnStepAside(async () => {
         clearInterval(keeper);
         await server.stop();
-        process.exit(0);
+        await leaveAfterStepAside({
+            ownerAnswers: () => server.checkServerAvailable(),
+            restartNewest: () => powerAction("update"),
+            resume: resumeServer,
+            sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
+            now: () => Date.now(),
+            exit: (code) => process.exit(code),
+            log,
+        });
     });
     return 0;
 }

package/dist/cli/web-step-aside.d.ts

@@ -0,0 +1,17 @@
+import type { LogLevel } from "../services/logger.js";
+/** How long the old web app waits for the caller's copy to answer. */
+export declare const NEW_OWNER_WAIT_MS = 30000;
+export interface StepAsideDeps {
+    /** True when an OMMS web app answers on the configured port. */
+    ownerAnswers: () => Promise<boolean>;
+    /** Restart onto the newest copy through the launcher. Returns a failure code when it did not. */
+    restartNewest: () => Promise<string | undefined>;
+    /** Serve again from this process. */
+    resume: () => Promise<void>;
+    sleep: (ms: number) => Promise<void>;
+    now: () => number;
+    exit: (code: number) => void;
+    log: (message: string, data: Record<string, unknown>, level?: LogLevel) => void;
+}
+/** Call after this web app stopped serving. It never leaves the port empty when it can help it. */
+export declare function leaveAfterStepAside(deps: StepAsideDeps): Promise<void>;

package/dist/cli/web-step-aside.js

@@ -0,0 +1,34 @@
+// What a standalone web app does after it stops serving for a newer caller. The
+// caller starts the newer copy, but a caller can quit first (a host that restarts
+// for its own update), which left the port empty until some other host started a
+// web app. So the old web app waits for a new owner, and restarts onto the newest
+// copy itself when none comes.
+/** How long the old web app waits for the caller's copy to answer. */
+export const NEW_OWNER_WAIT_MS = 30_000;
+const POLL_MS = 500;
+/** Call after this web app stopped serving. It never leaves the port empty when it can help it. */
+export async function leaveAfterStepAside(deps) {
+    const began = deps.now();
+    while (deps.now() - began < NEW_OWNER_WAIT_MS) {
+        if (await deps.ownerAnswers()) {
+            deps.exit(0);
+            return;
+        }
+        await deps.sleep(POLL_MS);
+    }
+    deps.log("Web app step-aside", { code: "no-new-owner" }, "warn");
+    // A successful restart exits this process.
+    const code = await deps.restartNewest();
+    if (code === undefined)
+        return;
+    // A failed restart can already serve again from this process.
+    if (await deps.ownerAnswers())
+        return;
+    try {
+        await deps.resume();
+    }
+    catch {
+        deps.log("Web app step-aside", { code: "resume-failed" }, "error");
+        deps.exit(1);
+    }
+}

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

@@ -37,7 +37,7 @@ export interface WebUpdateDeps {
         shell: boolean;
         path?: string;
     }) => InstallChild;
-    /** The version of the global install after npm ran, or null. */
+    /** The version of the global install (also read before npm runs), or null. */
     globalVersion: () => string | null;
     /** False when no restart could serve the new copy, such as a missing launcher. Checked before npm runs. */
     canRestart: () => boolean;
@@ -80,6 +80,11 @@ export declare class WebUpdate {
     /** Read npm `latest`. A failed read keeps the last result. Calls during a read share it. */
     check(): Promise<void>;
     private read;
+    /**
+     * The older of the running copy and the global install. A web app can run from a
+     * host's cache copy that is already current while the global install stays behind.
+     */
+    private installedVersion;
     /** Start the install the Update button starts, once a check found a release. */
     private maybeAutoInstall;
     status(): UpdateStatus;

package/dist/services/web-update.js

@@ -1,5 +1,6 @@
 import { posix, win32 } from "node:path";
 import { availableUpdate, latestNpmVersion } from "./update-check.js";
+import { compareVersions } from "./version-compare.js";
 // The web app's npm release check. It reads npm `latest` at start, every 10
 // minutes, and when an open page reads the status and the last check is over a
 // minute old. It keeps the result in memory for `GET /api/web/status`. It imports
@@ -58,9 +59,19 @@ export class WebUpdate {
             this.deps.log("Web app update check failed", { code: "unreachable" }, "error");
             return;
         }
-        this.available = availableUpdate(this.deps.version, latest);
+        this.available = availableUpdate(this.installedVersion(), latest);
         this.maybeAutoInstall();
     }
+    /**
+     * The older of the running copy and the global install. A web app can run from a
+     * host's cache copy that is already current while the global install stays behind.
+     */
+    installedVersion() {
+        const global = this.deps.globalVersion();
+        return global !== null && compareVersions(global, this.deps.version) === -1
+            ? global
+            : this.deps.version;
+    }
     /** Start the install the Update button starts, once a check found a release. */
     maybeAutoInstall() {
         if (this.state === "installing" || this.state === "restarting")