om-memory-system 4.4.0-next.65 → 4.4.0-next.69

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") {