om-memory-system 5.8.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,
@@ -156,12 +161,23 @@ export async function runWebCommand(args, options = {}, online, handover = {}, u
     const { existsSync } = await import("node:fs");
     // 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));
-    // A newer `web install` asked this web app to give up the port.
+    server.setWebUpdate(startWebUpdate(() => powerAction("update"), canRestart, () => server.powerActionRunning));
+    // 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-server.d.ts

@@ -43,7 +43,7 @@ export declare class WebServer {
     private readonly startedAt;
     private onPowerActionCallback;
     private webUpdate;
-    private powerActionRunning;
+    powerActionRunning: boolean;
     private stepAsideTimer;
     private holdOffTimer;
     private portsExhaustedNotified;

package/dist/services/web-server.js

@@ -173,7 +173,7 @@ export class WebServer {
     startedAt = Date.now();
     onPowerActionCallback = null;
     webUpdate = null;
-    powerActionRunning = false;
+    powerActionRunning = false; // public: the automatic update stays quiet while one runs
     stepAsideTimer = null;
     holdOffTimer = null;
     portsExhaustedNotified = false;

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

@@ -1,5 +1,5 @@
 import { WebUpdate, type InstallDeps } from "./web-update.js";
 /** The npm check and installer of a standalone web app, with the real process, npm, and clock. */
-export declare function startWebUpdate(restart: () => Promise<string | undefined>, canRestart: () => boolean): WebUpdate;
+export declare function startWebUpdate(restart: () => Promise<string | undefined>, canRestart: () => boolean, autoBlocked?: () => boolean): WebUpdate;
 /** The real npm process, shared by the update button and `web update`. */
 export declare function nodeInstallDeps(): InstallDeps;

package/dist/services/web-update-runtime.js

@@ -5,7 +5,7 @@ import { log } from "./logger.js";
 import { packageVersion } from "./package-version.js";
 import { WebUpdate } from "./web-update.js";
 /** The npm check and installer of a standalone web app, with the real process, npm, and clock. */
-export function startWebUpdate(restart, canRestart) {
+export function startWebUpdate(restart, canRestart, autoBlocked) {
     const update = new WebUpdate({
         version: packageVersion(),
         enabled: process.env.OMMS_DISABLE_UPDATE_CHECK !== "1",
@@ -18,6 +18,7 @@ export function startWebUpdate(restart, canRestart) {
         globalVersion: () => globalCommandVersion({ find: () => null }).version,
         restart,
         canRestart,
+        autoBlocked,
         now: () => Date.now(),
     });
     update.start();

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

@@ -4,6 +4,8 @@ export declare const UPDATE_CHECK_INTERVAL_MS: number;
 export declare const STATUS_RECHECK_AFTER_MS: number;
 /** An install that takes longer is stopped, and the web app keeps serving. */
 export declare const INSTALL_TIMEOUT_MS: number;
+/** An automatic start waits this long after a failed automatic install. */
+export declare const AUTO_RETRY_AFTER_MS: number;
 export type UpdateState = "idle" | "installing" | "restarting" | "failed";
 /** The `update` field of `GET /api/web/status`. */
 export interface UpdateStatus {
@@ -35,10 +37,12 @@ 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;
+    /** True while a Stop or Restart runs; the automatic start stays quiet then. */
+    autoBlocked?: () => boolean;
     /** Stop npm and its children. On Windows the shell wrapper alone would leave npm running. */
     killTree: (child: InstallChild) => Promise<void>;
     /** Restart onto the newest copy. Returns a failure code when this web app keeps serving. */
@@ -68,12 +72,21 @@ export declare class WebUpdate {
     private started;
     private lastCheck;
     private checking;
+    private autoRetryAt;
+    private autoAttempt;
     constructor(deps: WebUpdateDeps);
     /** Check now, then every 10 minutes. A second call does nothing. */
     start(): void;
     /** 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;
     private canInstall;
     /** Start the install and the restart. A request while one runs joins it. */

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
@@ -9,6 +10,8 @@ export const UPDATE_CHECK_INTERVAL_MS = 10 * 60 * 1000;
 export const STATUS_RECHECK_AFTER_MS = 60 * 1000;
 /** An install that takes longer is stopped, and the web app keeps serving. */
 export const INSTALL_TIMEOUT_MS = 5 * 60 * 1000;
+/** An automatic start waits this long after a failed automatic install. */
+export const AUTO_RETRY_AFTER_MS = 30 * 60 * 1000;
 /** Only a plain release reaches the npm arguments; the value comes from the registry. */
 const PLAIN_VERSION = /^\d+\.\d+\.\d+$/;
 /** Enough of npm's error stream to find a code; the rest is dropped. */
@@ -29,6 +32,8 @@ export class WebUpdate {
     started = false;
     lastCheck = -Infinity;
     checking = null;
+    autoRetryAt = -Infinity;
+    autoAttempt = false;
     constructor(deps) {
         this.deps = deps;
     }
@@ -54,7 +59,36 @@ 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")
+            return;
+        if (!this.available)
+            return;
+        if (this.deps.now() < this.autoRetryAt)
+            return;
+        // A check can finish while a Stop or Restart runs; the manual route has the same gate.
+        if (this.deps.autoBlocked?.())
+            return;
+        if (!this.canInstall())
+            return;
+        if (this.requestInstall() !== "accepted")
+            return;
+        this.autoAttempt = true;
+        this.deps.log("Web app auto-update started", { from: this.deps.version, to: this.available });
     }
     status() {
         // An open page polls the status, so a release shows within about a minute.
@@ -78,6 +112,7 @@ export class WebUpdate {
             return "no-update";
         if (!this.canInstall())
             return "cannot-install";
+        this.autoAttempt = false;
         this.state = "installing";
         this.code = null;
         void this.install(this.available);
@@ -96,6 +131,9 @@ export class WebUpdate {
         const fail = (code, exitCode) => {
             this.state = "failed";
             this.code = code;
+            // Only an automatic start waits before trying again; the button always works.
+            if (this.autoAttempt)
+                this.autoRetryAt = this.deps.now() + AUTO_RETRY_AFTER_MS;
             record("failed", code, exitCode);
         };
         const { code, exitCode } = await runGlobalInstall(this.deps, target);