om-memory-system 4.4.0-next.67 → 4.4.0-next.70

package/dist/services/web-autostart.js

@@ -6,6 +6,7 @@ import { basename, dirname, join, delimiter, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { CONFIG } from "../config.js";
 import { log } from "./logger.js";
+import { copyVersion, ensureLauncher, launcherPath, recordedCopy, } from "./runtime-record.js";
 import { compareVersions } from "./version-compare.js";
 const MARKER = "OMMS login item";
 const NAME = "io.github.cmdaltctr.omms.web";
@@ -70,53 +71,18 @@ function packageRoot() {
         dir = parent;
     }
 }
-function packageVersionAt(root) {
-    try {
-        const pkg = JSON.parse(readFileSync(join(root, "package.json"), "utf8"));
-        if (pkg.name !== "om-memory-system" || !existsSync(join(root, "dist", "cli", "index.js"))) {
-            return null;
-        }
-        return typeof pkg.version === "string" ? pkg.version : null;
-    }
-    catch {
-        return null;
-    }
-}
-/** The package folder a written login item runs, read back from its command line. */
-export function itemPackageRoot(file) {
-    try {
-        const content = readFileSync(file, "utf8");
-        const match = /([^"<>\r\n]*?)[\\/]dist[\\/]cli[\\/]index\.js/.exec(content);
-        const path = match?.[1]?.replace(/^.*?<string>/, "").trim();
-        if (!path)
-            return null;
-        // Only plists escape XML. Decode ampersands last to preserve literal entity text.
-        return content.includes("<plist")
-            ? path
-                .replaceAll("&quot;", '"')
-                .replaceAll("&apos;", "'")
-                .replaceAll("&lt;", "<")
-                .replaceAll("&gt;", ">")
-                .replaceAll("&amp;", "&")
-            : path;
-    }
-    catch {
-        return null;
-    }
-}
 /**
- * The newest OMMS copy among this one, the global install beside the runtime,
- * and the copy the item already runs. A host starts OMMS from its own cache,
- * which can be older than the global install; that copy must not downgrade
- * the login item.
+ * The newest valid OMMS copy among the candidates. On equal versions the first
+ * wins, so a host's cached copy goes last. This is the copy the launcher starts,
+ * and it matches the launcher's own choice.
  */
 export function preferredPackageRoot(candidates) {
     let best = null;
     for (const root of candidates) {
         if (!root)
             continue;
-        const version = packageVersionAt(root);
-        if (!version || compareVersions(version, version) === null)
+        const version = copyVersion(root);
+        if (!version)
             continue;
         if (!best || (compareVersions(version, best.version) ?? 0) > 0)
             best = { root, version };
@@ -145,15 +111,20 @@ function details(options) {
     const platform = options.platform ?? process.platform;
     const path = itemPath(home, platform);
     const runtime = options.runtime === undefined ? resolveWebRuntime() : options.runtime;
-    const own = options.packageRoot === undefined ? packageRoot() : options.packageRoot;
-    const current = path && existsSync(path) ? itemPackageRoot(path) : null;
+    const dir = join(home, ".omms");
+    const own = options.ownRoot !== undefined
+        ? options.ownRoot
+        : options.packageRoot !== undefined
+            ? options.packageRoot
+            : packageRoot();
+    const recorded = recordedCopy(dir, logCode)?.root ?? null;
     const root = options.packageRoot === undefined
-        ? // On equal versions the first wins, so a host's cached copy goes last.
-            preferredPackageRoot([globalPackageRoot(runtime ?? null, platform), current, own])
-        : own;
+        ? preferredPackageRoot([recorded, globalPackageRoot(runtime ?? null, platform), own])
+        : options.packageRoot;
     const supported = platform !== "linux" || (options.systemctlAvailable ?? Boolean(executable("systemctl")));
-    return { home, platform, path, runtime, root, supported };
+    return { home, platform, path, runtime, root, own, recorded, dir, supported };
 }
+const logCode = (code, data) => log("Runtime record", { code, ...data });
 const xml = (value) => value
     .replaceAll("&", "&amp;")
     .replaceAll("<", "&lt;")
@@ -161,21 +132,21 @@ const xml = (value) => value
     .replaceAll('"', "&quot;");
 const systemd = (value) => `"${value.replaceAll("%", "%%").replaceAll('"', '\\"')}"`;
 const windows = (value) => `"${value.replaceAll("%", "%%")}"`;
-function itemContent(platform, runtime, cli) {
+function itemContent(platform, runtime, launcher) {
     if (platform === "darwin")
         return `<?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 <plist version="1.0"><dict>
 <!-- ${MARKER} -->
 <key>Label</key><string>${NAME}</string>
-<key>ProgramArguments</key><array><string>${xml(runtime)}</string><string>${xml(cli)}</string><string>web</string><string>--login-item</string></array>
+<key>ProgramArguments</key><array><string>${xml(runtime)}</string><string>${xml(launcher)}</string><string>web</string><string>--login-item</string></array>
 <key>RunAtLoad</key><true/><key>KeepAlive</key><false/>
 <key>StandardOutPath</key><string>/dev/null</string><key>StandardErrorPath</key><string>/dev/null</string>
 </dict></plist>\n`;
     if (platform === "linux")
         return `# ${MARKER}
-[Unit]\nDescription=OMMS web app\n[Service]\nType=simple\nExecStart=${systemd(runtime)} ${systemd(cli)} web --login-item\n[Install]\nWantedBy=default.target\n`;
-    return `@echo off\r\nrem ${MARKER}\r\nstart "" /min ${windows(runtime)} ${windows(cli)} web --login-item\r\n`;
+[Unit]\nDescription=OMMS web app\n[Service]\nType=simple\nExecStart=${systemd(runtime)} ${systemd(launcher)} web --login-item\n[Install]\nWantedBy=default.target\n`;
+    return `@echo off\r\nrem ${MARKER}\r\nstart "" /min ${windows(runtime)} ${windows(launcher)} web --login-item\r\n`;
 }
 function owned(path) {
     return readFileSync(path, "utf8").includes(MARKER);
@@ -188,15 +159,16 @@ function runCommand(options, home, command, args) {
 }
 /** Read the login item's state without changing any system files. */
 export function webAutostartStatus(options = {}) {
-    const { path, runtime, root, supported } = details(options);
+    const { path, runtime, root, dir, supported } = details(options);
     if (!path || !supported)
         return { state: "unsupported" };
     if (!runtime)
         return { state: "no-runtime", path };
     if (!root)
         return { state: "no-package", path, runtime };
+    const launcher = launcherPath(dir);
     if (!existsSync(path))
-        return { state: "not-installed", path, runtime, packagePath: root };
+        return { state: "not-installed", path, runtime, packagePath: root, launcher };
     if (!owned(path))
         throw new Error("Login item at the OMMS path is not owned by OMMS");
     return {
@@ -204,6 +176,7 @@ export function webAutostartStatus(options = {}) {
         path,
         runtime,
         packagePath: root,
+        launcher,
         command: readFileSync(path, "utf8"),
     };
 }
@@ -214,9 +187,15 @@ export function installWebAutostart(options = {}) {
         status.state === "no-runtime" ||
         status.state === "no-package")
         return status;
-    const { home, platform, path, runtime, root } = details(options);
+    const { home, platform, path, runtime, root, own, recorded, dir } = details(options);
+    // The item runs a fixed launcher, so the launcher must exist before the item does.
+    if (!ensureLauncher({ dir, sources: [root, own, recorded], log: logCode })) {
+        // A valid package exists. Only the launcher is missing, so say that.
+        logCode("launcher-missing", {});
+        return { state: "no-launcher", path: path, runtime: runtime };
+    }
     const file = path;
-    const content = itemContent(platform, runtime, join(root, "dist", "cli", "index.js"));
+    const content = itemContent(platform, runtime, launcherPath(dir));
     mkdirSync(dirname(file), { recursive: true });
     const changed = !existsSync(file) || readFileSync(file, "utf8") !== content;
     if (changed) {

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

@@ -37,6 +37,8 @@ export interface EnsureDeps {
     resolveRuntime: () => Promise<string | null> | string | null;
     /** The `om-memory-system` script that `web` is run from. */
     cliScript: string;
+    /** `~/.omms/bin/omms-launch.mjs` when it exists. `web` then starts through it, on the newest recorded copy. */
+    launcherScript: string | null;
     lockPath: string;
     lockFs: LockFs;
     pidAlive: (pid: number) => boolean;
@@ -51,6 +53,15 @@ export interface EnsureOptions {
     budgetMs: number;
     /** `false` starts the web app and returns at once (session starts). Default `true`. */
     wait?: boolean;
+    /**
+     * Replace a running web app older than `version`: ask it to step aside, then
+     * start as for an empty port. `headers` are the local token headers the
+     * step-aside route needs. Without it, any running OMMS web app is used.
+     */
+    replaceOlder?: {
+        version: string;
+        headers: Record<string, string>;
+    };
     deps?: Partial<EnsureDeps>;
 }
 /** A lock older than this is stale. Also the longest a background start holds it. */

package/dist/services/web-ensure.js

@@ -1,9 +1,12 @@
 import { spawn as nodeSpawn } from "node:child_process";
 import { createHash } from "node:crypto";
-import { linkSync, mkdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync, } from "node:fs";
+import { existsSync, linkSync, mkdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync, } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
+import { launcherPath } from "./runtime-record.js";
+import { isOlderVersion } from "./version-compare.js";
+import { negotiateOwner, readWebVersion } from "./web-handover.js";
 const HEALTH_PROBE_MS = 1_000;
 const POLL_INTERVAL_MS = 250;
 /** A lock older than this is stale. Also the longest a background start holds it. */
@@ -106,6 +109,13 @@ function processAlive(pid) {
         return error.code === "EPERM";
     }
 }
+/** Tests set the switch, so they never start the developer's real recorded copy. */
+function existingLauncher() {
+    if (process.env.OMMS_DISABLE_RUNTIME_RECORD === "1")
+        return null;
+    const file = launcherPath(join(homedir(), ".omms"));
+    return existsSync(file) ? file : null;
+}
 function productionDefaults() {
     return {
         fetch: globalThis.fetch,
@@ -115,6 +125,7 @@ function productionDefaults() {
         resolveRuntime: async () => (await import("./web-autostart.js")).resolveWebRuntime(),
         // From dist/services/ to the CLI entry point.
         cliScript: fileURLToPath(new URL("../cli/index.js", import.meta.url)),
+        launcherScript: existingLauncher(),
         lockPath: startLockPath(),
         lockFs: nodeLockFs,
         pidAlive: processAlive,
@@ -211,7 +222,12 @@ export async function ensureWebApp(options) {
     let held = false;
     try {
         const first = await probe(settings.baseUrl, probeMs(), deps);
-        if (first === "omms")
+        const { replaceOlder } = options;
+        // An OMMS web app that is older than the newest copy is replaced; any other is used.
+        const replacing = first === "omms" &&
+            replaceOlder !== undefined &&
+            isOlderVersion((await readWebVersion(deps.fetch, settings.baseUrl, replaceOlder.headers)) ?? "", replaceOlder.version);
+        if (first === "omms" && !replacing)
             return "running";
         if (first === "other") {
             await logCode("port-busy");
@@ -220,11 +236,27 @@ export async function ensureWebApp(options) {
         const runtime = await deps.resolveRuntime();
         if (!runtime) {
             await logCode("no-runtime");
-            return "no-runtime";
+            return replacing ? "running" : "no-runtime";
         }
         held = takeStartLock(deps);
+        // The caller that holds the lock replaces the web app; the others use it.
         if (!held)
-            return await waitForOther(settings.baseUrl, wait, remaining, deps);
+            return replacing ? "running" : await waitForOther(settings.baseUrl, wait, remaining, deps);
+        if (replacing && replaceOlder) {
+            const outcome = await negotiateOwner({
+                fetchFn: deps.fetch,
+                sleep: deps.sleep,
+                url: settings.baseUrl,
+                port: Number(new URL(settings.baseUrl).port) || 80,
+                headers: replaceOlder.headers,
+                version: replaceOlder.version,
+            });
+            if (outcome.kind !== "handed") {
+                if (outcome.kind === "stuck")
+                    await logCode("step-aside-failed");
+                return "running";
+            }
+        }
         // Another caller may have finished its start before this one took the lock.
         const second = await probe(settings.baseUrl, probeMs(), deps);
         if (second === "omms")
@@ -233,7 +265,7 @@ export async function ensureWebApp(options) {
             await logCode("port-busy");
             return "port-busy";
         }
-        const child = deps.spawn(runtime, [deps.cliScript, "web"], {
+        const child = deps.spawn(runtime, [deps.launcherScript ?? deps.cliScript, "web"], {
             detached: true,
             stdio: "ignore",
             cwd: homedir(),

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

@@ -0,0 +1,22 @@
+export declare const POLL_MS = 250;
+export declare const POLL_LIMIT = 40;
+/** The version an OMMS web app reports on `url`, or null when none answers with one. */
+export declare function readWebVersion(fetchFn: typeof fetch, url: string, headers: Record<string, string>): Promise<string | null>;
+export type Handover = {
+    kind: "none";
+} | {
+    kind: "handed";
+} | {
+    kind: "stuck" | "same" | "newer";
+    owner: string;
+};
+export interface HandoverContext {
+    fetchFn: typeof fetch;
+    sleep: (ms: number) => Promise<void>;
+    url: string;
+    port: number;
+    headers: Record<string, string>;
+    version: string;
+}
+/** Ask an older OMMS web app on the configured port to step aside, and wait for the port. */
+export declare function negotiateOwner(ctx: HandoverContext): Promise<Handover>;

package/dist/services/web-handover.js

@@ -0,0 +1,62 @@
+import { compareVersions } from "./version-compare.js";
+// The version handover shared by `web install` and the host start: ask an older
+// OMMS web app to step aside, then wait for its port. It imports no host adapter,
+// no store, and no embedding model.
+export const POLL_MS = 250;
+export const POLL_LIMIT = 40;
+const REQUEST_TIMEOUT_MS = 2_000;
+/** The version an OMMS web app reports on `url`, or null when none answers with one. */
+export async function readWebVersion(fetchFn, url, headers) {
+    try {
+        const response = await fetchFn(`${url}/api/settings/version`, {
+            headers,
+            signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
+        });
+        if (!response.ok)
+            return null;
+        const body = (await response.json());
+        return typeof body.running === "string" ? body.running : null;
+    }
+    catch {
+        return null;
+    }
+}
+async function portAnswers(fetchFn, url) {
+    try {
+        await fetchFn(`${url}/api/health`, { signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS) });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** Ask an older OMMS web app on the configured port to step aside, and wait for the port. */
+export async function negotiateOwner(ctx) {
+    const owner = await readWebVersion(ctx.fetchFn, ctx.url, ctx.headers);
+    const order = owner === null ? null : compareVersions(owner, ctx.version);
+    // A version that cannot be placed is never stopped.
+    if (owner === null || order === null)
+        return { kind: "none" };
+    if (order === 0)
+        return { kind: "same", owner };
+    if (order > 0)
+        return { kind: "newer", owner };
+    try {
+        const reply = await ctx.fetchFn(`${ctx.url}/api/web/step-aside`, {
+            method: "POST",
+            headers: { ...ctx.headers, "content-type": "application/json" },
+            body: JSON.stringify({ version: ctx.version }),
+            signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
+        });
+        if (reply.status !== 202)
+            return { kind: "stuck", owner };
+    }
+    catch {
+        return { kind: "stuck", owner };
+    }
+    // If the old app is slow to stop, the login item still takes the port later.
+    for (let i = 0; i < POLL_LIMIT && (await portAnswers(ctx.fetchFn, ctx.url)); i++) {
+        await ctx.sleep(POLL_MS);
+    }
+    return { kind: "handed" };
+}

package/dist/services/web-server.js

@@ -802,17 +802,18 @@ export class WebServer {
                 return this.handleStepAside(remoteAddress, body);
             }
             if (path === "/api/settings/version" && method === "GET") {
-                const [{ packageVersion }, { globalCommandVersion }] = await Promise.all([
+                const [{ packageVersion }, { globalCommandVersion, globalRelation }] = await Promise.all([
                     import("./package-version.js"),
                     import("./global-version.js"),
                 ]);
                 const running = packageVersion();
-                const global = await globalCommandVersion();
+                const global = globalCommandVersion();
                 return this.jsonResponse({
                     running,
                     global: global.version,
                     globalPath: global.path,
                     mismatch: global.version !== null && global.version !== running,
+                    relation: globalRelation(running, global.version),
                 });
             }
             if (path === "/api/settings/web-autostart" && method === "GET") {