om-memory-system 3.6.0-next.38 → 3.6.0-next.40

package/dist/index.js

@@ -9,11 +9,9 @@ import { OPENCODE_IMPORT_COMMAND, OPENCODE_IMPORT_DESCRIPTION, latestUserMessage
 import { buildRecentMemoriesSection, formatMemoriesForCompaction } from "./core/retrieval.js";
 import { performUserProfileLearning } from "./adapters/opencode/profile-learning.js";
 import { userPromptManager } from "./services/user-prompt/user-prompt-manager.js";
-import { startWebServer, WebServer } from "./services/web-server.js";
 import { pruneTraces } from "./services/capture-diagnostics.js";
 import { ensureTursoReady } from "./services/turso/ready.js";
 import { tursoConnectionManager } from "./services/turso/connection-manager.js";
-import { WebAuth } from "./services/web-auth.js";
 import { isConfigured, CONFIG, initConfigWithLegacyMigration } from "./config.js";
 import { resolveOpencodeHostModel } from "./services/ai/live-model-choice.js";
 import { log } from "./services/logger.js";
@@ -193,7 +191,6 @@ export const OmmsPlugin = async (ctx) => {
     logAutoCaptureProviderStatus();
     const tags = getTags(directory);
     const autoCaptureHost = createOpenCodeAutoCaptureHost(ctx);
-    let webServer = null;
     let idleTimeout = null;
     const GLOBAL_PLUGIN_WARMUP_KEY = Symbol.for("omms.plugin.warmedup");
     if (!globalThis[GLOBAL_PLUGIN_WARMUP_KEY] && isConfigured()) {
@@ -211,8 +208,8 @@ export const OmmsPlugin = async (ctx) => {
     await configureOpencodeHostTransport(ctx);
     // Shared profile dedup, conflict, description, and cleanup calls use OpenCode's host model.
     registerOpencodeProfileModel();
-    // Web imports, Health, and Settings served by this process can list and use OpenCode's models.
-    // Awaited so the web server never serves those routes before the registry is filled.
+    // In-process backfill, capture, and the capture retry drain use OpenCode's models.
+    // Awaited so those paths never run before the registry is filled.
     await import("./adapters/opencode/backfill-startup.js")
         .then(({ registerOpencodeImportModels, registerOpencodeCaptureRetryDrain }) => {
         registerOpencodeImportModels();
@@ -290,96 +287,36 @@ export const OmmsPlugin = async (ctx) => {
             }
         }
     }
-    if (CONFIG.webServerEnabled && tursoReadyForWeb) {
-        const webAuth = new WebAuth({
-            password: CONFIG.webServerAuthPassword,
-            username: CONFIG.webServerAuthUsername,
-        });
-        startWebServer({
-            directory,
-            port: CONFIG.webServerPort,
-            host: CONFIG.webServerHost,
-            enabled: CONFIG.webServerEnabled,
-            auth: webAuth,
-            apiToken: CONFIG.webServerApiToken,
-        })
-            .then((server) => {
-            webServer = server;
-            const url = webServer.getUrl();
-            webServer.setOnTakeoverCallback(async () => {
-                if (ctx.client?.tui) {
-                    ctx.client.tui
-                        .showToast({
-                        body: {
-                            title: "Memory Explorer",
-                            message: "Took over web server ownership",
-                            variant: "success",
-                            duration: 3000,
-                        },
-                    })
-                        .catch(() => { });
-                }
-            });
-            webServer.setOnPortsExhaustedCallback(() => {
-                if (ctx.client?.tui) {
-                    ctx.client.tui
-                        .showToast({
-                        body: {
-                            title: "Memory Explorer",
-                            message: `Web UI unavailable: ports ${CONFIG.webServerPort}-${CONFIG.webServerPort + 10} are held by non-responsive processes`,
-                            variant: "error",
-                            duration: 5000,
-                        },
-                    })
-                        .catch(() => { });
+    if (CONFIG.webServerEnabled &&
+        tursoReadyForWeb &&
+        process.env.OMMS_DISABLE_WEB_AUTOSTART !== "1") {
+        const showToast = (message, variant, duration) => {
+            if (!ctx.client?.tui)
+                return;
+            ctx.client.tui
+                .showToast({ body: { title: "Memory Explorer", message, variant, duration } })
+                .catch(() => { });
+        };
+        // The shared web app serves the page. This plugin starts it only when none runs.
+        void Promise.all([import("./services/web-ensure.js"), import("./services/web-api-auth.js")])
+            .then(([{ ensureWebApp }, { webServerUrl }]) => {
+            const baseUrl = webServerUrl(CONFIG.webServerHost, CONFIG.webServerPort);
+            return ensureWebApp({
+                settings: { enabled: CONFIG.webServerEnabled, baseUrl },
+                budgetMs: 10_000,
+            }).then((result) => {
+                if (result === "running" || result === "started") {
+                    showToast(`Web UI available at ${baseUrl}`, "info", 3000);
                 }
-            });
-            if (webServer.isServerOwner()) {
-                if (ctx.client?.tui) {
-                    ctx.client.tui
-                        .showToast({
-                        body: {
-                            title: "Memory Explorer",
-                            message: webAuth.isEnabled()
-                                ? `Web UI started at ${url} (auth required)`
-                                : `Web UI started at ${url}`,
-                            variant: "success",
-                            duration: 5000,
-                        },
-                    })
-                        .catch(() => { });
+                else if (result === "port-busy") {
+                    showToast(`Web UI unavailable: another program uses port ${CONFIG.webServerPort}`, "error", 5000);
                 }
-            }
-            else {
-                if (ctx.client?.tui) {
-                    ctx.client.tui
-                        .showToast({
-                        body: {
-                            title: "Memory Explorer",
-                            message: `Web UI available at ${url}`,
-                            variant: "info",
-                            duration: 3000,
-                        },
-                    })
-                        .catch(() => { });
+                else if (result === "no-runtime") {
+                    showToast("Web UI unavailable: no Node or Bun runtime found to start it", "error", 5000);
                 }
-            }
+            });
         })
-            .catch((error) => {
-            log("Web server failed to start", { error: String(error) });
-            if (ctx.client?.tui) {
-                ctx.client.tui
-                    .showToast({
-                    body: {
-                        title: "Memory Explorer Error",
-                        message: `Failed to start: ${String(error)}`,
-                        variant: "error",
-                        duration: 5000,
-                    },
-                })
-                    .catch(() => { });
-            }
-        });
+            .catch((error) => log("Web app start failed", { error: String(error) }));
     }
     let cleanedUp = false;
     const cleanupPlugin = async () => {
@@ -390,8 +327,6 @@ export const OmmsPlugin = async (ctx) => {
             clearTimeout(idleTimeout);
             idleTimeout = null;
         }
-        if (webServer)
-            await webServer.stop();
         if (memoryClient)
             await memoryClient.close();
     };
@@ -607,12 +542,10 @@ export const OmmsPlugin = async (ctx) => {
                 idleTimeout = setTimeout(async () => {
                     try {
                         await performAutoCapture(autoCaptureHost, sessionID, directory);
-                        if (webServer?.isServerOwner()) {
-                            await performUserProfileLearning(ctx, directory);
-                            const { cleanupService } = await import("./services/cleanup-service.js");
-                            if (await cleanupService.shouldRunCleanup())
-                                await cleanupService.runCleanup();
-                        }
+                        await performUserProfileLearning(ctx, directory);
+                        const { cleanupService } = await import("./services/cleanup-service.js");
+                        if (await cleanupService.shouldRunCleanup())
+                            await cleanupService.runCleanup();
                     }
                     catch (error) {
                         log("Idle processing error", { error: String(error) });

package/dist/services/version-compare.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Compare two versions in SemVer order. Returns a negative number when `a` is older,
+ * a positive number when `a` is newer, `0` when equal, and `null` when either
+ * version cannot be parsed, such as `unknown`.
+ */
+export declare function compareVersions(a: string, b: string): number | null;
+/** True only when `a` is provably older than `b`. An unplaceable version is never older. */
+export declare function isOlderVersion(a: string, b: string): boolean;

package/dist/services/version-compare.js

@@ -0,0 +1,58 @@
+const SEMVER = /^(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/;
+function parse(version) {
+    const match = SEMVER.exec(version.trim());
+    if (!match)
+        return null;
+    return {
+        core: [Number(match[1]), Number(match[2]), Number(match[3])],
+        pre: match[4] ? match[4].split(".") : [],
+    };
+}
+function comparePart(a, b) {
+    const aNumeric = /^\d+$/.test(a);
+    const bNumeric = /^\d+$/.test(b);
+    if (aNumeric && bNumeric)
+        return Math.sign(Number(a) - Number(b));
+    // A numeric part is older than a text part.
+    if (aNumeric)
+        return -1;
+    if (bNumeric)
+        return 1;
+    return a < b ? -1 : a > b ? 1 : 0;
+}
+/**
+ * Compare two versions in SemVer order. Returns a negative number when `a` is older,
+ * a positive number when `a` is newer, `0` when equal, and `null` when either
+ * version cannot be parsed, such as `unknown`.
+ */
+export function compareVersions(a, b) {
+    const left = parse(a);
+    const right = parse(b);
+    if (!left || !right)
+        return null;
+    for (let i = 0; i < 3; i++) {
+        const diff = left.core[i] - right.core[i];
+        if (diff)
+            return Math.sign(diff);
+    }
+    // A release is newer than any of its prereleases.
+    if (!left.pre.length || !right.pre.length)
+        return right.pre.length - left.pre.length;
+    for (let i = 0; i < Math.max(left.pre.length, right.pre.length); i++) {
+        const l = left.pre[i];
+        const r = right.pre[i];
+        if (l === undefined)
+            return -1;
+        if (r === undefined)
+            return 1;
+        const diff = comparePart(l, r);
+        if (diff)
+            return diff;
+    }
+    return 0;
+}
+/** True only when `a` is provably older than `b`. An unplaceable version is never older. */
+export function isOlderVersion(a, b) {
+    const order = compareVersions(a, b);
+    return order !== null && order < 0;
+}

package/dist/services/web-api-auth.d.ts

@@ -1,4 +1,6 @@
 export declare function isLoopbackHost(host: string): boolean;
+/** True for a peer socket address on this machine: 127.x.x.x, ::1, or an IPv4-mapped 127.x.x.x. */
+export declare function isLoopbackAddress(address: string | undefined): boolean;
 /** A URL needs brackets around an IPv6 literal such as ::1. */
 export declare function webServerUrl(host: string, port: number): string;
 export declare function assertWebServerNetworkAuth(host: string, apiToken?: string, basicAuthEnabled?: boolean): void;

package/dist/services/web-api-auth.js

@@ -3,6 +3,16 @@ const LOOPBACK_HOSTS = new Set(["127.0.0.1", "localhost", "::1", "[::1]", "0:0:0
 export function isLoopbackHost(host) {
     return LOOPBACK_HOSTS.has(host.trim().toLowerCase());
 }
+/** True for a peer socket address on this machine: 127.x.x.x, ::1, or an IPv4-mapped 127.x.x.x. */
+export function isLoopbackAddress(address) {
+    if (!address)
+        return false;
+    const value = address
+        .trim()
+        .toLowerCase()
+        .replace(/^::ffff:/, "");
+    return value === "::1" || /^127(?:\.\d{1,3}){3}$/.test(value);
+}
 /** A URL needs brackets around an IPv6 literal such as ::1. */
 export function webServerUrl(host, port) {
     const urlHost = host.includes(":") && !host.startsWith("[") ? `[${host}]` : host;

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

@@ -24,6 +24,12 @@ export declare function webAutostartStatus(options?: WebAutostartOptions): WebAu
 export declare function installWebAutostart(options?: WebAutostartOptions): WebAutostartStatus;
 /** Remove only an item carrying the OMMS marker. */
 export declare function removeWebAutostart(options?: WebAutostartOptions): WebAutostartStatus;
+/**
+ * Restart the login item through the platform service manager. A detached child
+ * of the item would die with its launchd job or systemd control group, so the
+ * service manager does the restart. Returns false when it cannot.
+ */
+export declare function restartWebAutostart(options?: WebAutostartOptions): boolean;
 /** Host start checks the global settings. A failed item cannot block a session. */
 export declare function reconcileWebAutostart(config?: Pick<typeof CONFIG, "webServerAutoStart" | "webServerEnabled">, options?: WebAutostartOptions): void;
 export {};

package/dist/services/web-autostart.js

@@ -211,6 +211,37 @@ export function removeWebAutostart(options = {}) {
     unlinkSync(path);
     return { state: "not-installed", path };
 }
+/**
+ * Restart the login item through the platform service manager. A detached child
+ * of the item would die with its launchd job or systemd control group, so the
+ * service manager does the restart. Returns false when it cannot.
+ */
+export function restartWebAutostart(options = {}) {
+    const home = options.home ?? homedir();
+    const platform = options.platform ?? process.platform;
+    try {
+        if (platform === "darwin") {
+            runCommand(options, home, "launchctl", [
+                "kickstart",
+                "-k",
+                `gui/${process.getuid?.() ?? 0}/${NAME}`,
+            ]);
+        }
+        else if (platform === "linux") {
+            runCommand(options, home, "systemctl", ["--user", "restart", "omms-web.service"]);
+        }
+        else {
+            return false;
+        }
+        return true;
+    }
+    catch (error) {
+        log("OMMS login item restart failed", {
+            code: error instanceof Error ? error.name : "unknown",
+        });
+        return false;
+    }
+}
 /** Host start checks the global settings. A failed item cannot block a session. */
 export function reconcileWebAutostart(config = CONFIG, options = {}) {
     if (process.env.OMMS_DISABLE_WEB_AUTOSTART === "1")

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

@@ -0,0 +1,59 @@
+export type EnsureResult = "running" | "started" | "disabled" | "port-busy" | "no-runtime" | "start-timeout";
+/** Port and switch of the web app, as the caller read them from `CONFIG`. */
+export interface EnsureSettings {
+    enabled: boolean;
+    baseUrl: string;
+}
+interface SpawnedChild {
+    unref(): void;
+    on(event: "error", listener: (error: Error) => void): unknown;
+}
+type SpawnFn = (command: string, args: string[], options: {
+    detached: true;
+    stdio: "ignore";
+    cwd: string;
+    windowsHide: true;
+}) => SpawnedChild;
+/** The three file operations the start lock needs. */
+export interface LockFs {
+    /** Create the file only when it does not exist. Returns false when it does. */
+    createExclusive(path: string, text: string): boolean;
+    read(path: string): string | null;
+    remove(path: string): void;
+}
+export interface EnsureDeps {
+    fetch: typeof fetch;
+    spawn: SpawnFn;
+    sleep: (ms: number) => Promise<void>;
+    now: () => number;
+    resolveRuntime: () => Promise<string | null> | string | null;
+    /** The `om-memory-system` script that `web` is run from. */
+    cliScript: string;
+    lockPath: string;
+    lockFs: LockFs;
+    pidAlive: (pid: number) => boolean;
+    /** The pid written into the lock. */
+    pid: number;
+    log: (message: string, data: Record<string, unknown>) => void | Promise<void>;
+}
+export interface EnsureOptions {
+    settings: EnsureSettings;
+    /** How long the caller may wait for the web app to answer. */
+    budgetMs: number;
+    /** `false` starts the web app and returns at once (session starts). Default `true`. */
+    wait?: boolean;
+    deps?: Partial<EnsureDeps>;
+}
+/** A lock older than this is stale. Also the longest a background start holds it. */
+export declare const START_LOCK_STALE_MS = 20000;
+/** Path of the start lock; the standalone command writes it for a restart copy. */
+export declare function startLockPath(home?: string): string;
+export declare const nodeLockFs: LockFs;
+/** 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;
+/**
+ * Use a running OMMS web app, or start one detached `om-memory-system web`.
+ * Never throws; a failed check must not block or fail the host session.
+ */
+export declare function ensureWebApp(options: EnsureOptions): Promise<EnsureResult>;
+export {};

package/dist/services/web-ensure.js

@@ -0,0 +1,214 @@
+import { spawn as nodeSpawn } from "node:child_process";
+import { mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+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. */
+export const START_LOCK_STALE_MS = 20_000;
+/** Path of the start lock; the standalone command writes it for a restart copy. */
+export function startLockPath(home = homedir()) {
+    return join(home, ".omms", "web-start.lock");
+}
+export const nodeLockFs = {
+    createExclusive(path, text) {
+        mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+        try {
+            writeFileSync(path, text, { flag: "wx", mode: 0o600 });
+            return true;
+        }
+        catch (error) {
+            if (error.code === "EEXIST")
+                return false;
+            throw error;
+        }
+    },
+    read(path) {
+        try {
+            return readFileSync(path, "utf8");
+        }
+        catch {
+            return null;
+        }
+    },
+    remove(path) {
+        rmSync(path, { force: true });
+    },
+};
+/** Remove the start lock when it names `pid`. A restart copy calls this once it owns the port. */
+export function removeStartLockFor(pid, path = startLockPath(), lockFs = nodeLockFs) {
+    try {
+        const held = JSON.parse(lockFs.read(path) ?? "null");
+        if (held?.pid === pid)
+            lockFs.remove(path);
+    }
+    catch {
+        /* An unreadable lock is stale and the next caller replaces it. */
+    }
+}
+function processAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        // EPERM means the process exists but belongs to someone else.
+        return error.code === "EPERM";
+    }
+}
+function productionDefaults() {
+    return {
+        fetch: globalThis.fetch,
+        spawn: nodeSpawn,
+        sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
+        now: () => Date.now(),
+        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)),
+        lockPath: startLockPath(),
+        lockFs: nodeLockFs,
+        pidAlive: processAlive,
+        pid: process.pid,
+        log: async (message, data) => (await import("./logger.js")).log(message, data),
+    };
+}
+/** An OMMS reply is `{ success: true, status: "ok" }`; another local service must not count. */
+async function probe(baseUrl, timeoutMs, deps) {
+    try {
+        const response = await deps.fetch(`${baseUrl}/api/health`, {
+            method: "GET",
+            signal: AbortSignal.timeout(Math.max(1, timeoutMs)),
+        });
+        if (!response.ok)
+            return "other";
+        const body = (await response.json());
+        return body.success === true && body.status === "ok" ? "omms" : "other";
+    }
+    catch (error) {
+        // A reply that is not JSON came from a program that answered; a refused or
+        // timed out connection means nothing answers.
+        return error instanceof SyntaxError ? "other" : "none";
+    }
+}
+function lockIsStale(text, deps) {
+    if (text === null)
+        return true;
+    try {
+        const { pid, at } = JSON.parse(text);
+        if (typeof pid !== "number" || typeof at !== "number")
+            return true;
+        return !deps.pidAlive(pid) || deps.now() - at > START_LOCK_STALE_MS;
+    }
+    catch {
+        return true;
+    }
+}
+/** Take the start lock. A stale lock is removed and taken once more. */
+function takeLock(deps) {
+    const mine = JSON.stringify({ pid: deps.pid, at: deps.now() });
+    if (deps.lockFs.createExclusive(deps.lockPath, mine))
+        return true;
+    const seen = deps.lockFs.read(deps.lockPath);
+    if (!lockIsStale(seen, deps))
+        return false;
+    // Another caller may have replaced the stale lock since it was read.
+    if (deps.lockFs.read(deps.lockPath) !== seen)
+        return false;
+    deps.lockFs.remove(deps.lockPath);
+    return deps.lockFs.createExclusive(deps.lockPath, mine);
+}
+/**
+ * Use a running OMMS web app, or start one detached `om-memory-system web`.
+ * Never throws; a failed check must not block or fail the host session.
+ */
+export async function ensureWebApp(options) {
+    const { settings, budgetMs, wait = true } = options;
+    if (!settings.enabled)
+        return "disabled";
+    const deps = { ...productionDefaults(), ...options.deps };
+    const began = deps.now();
+    const remaining = () => budgetMs - (deps.now() - began);
+    const probeMs = () => budgetMs > 0 ? Math.min(HEALTH_PROBE_MS, Math.max(1, remaining())) : HEALTH_PROBE_MS;
+    const logCode = async (code) => {
+        try {
+            await deps.log("Web app ensure", { code });
+        }
+        catch {
+            /* A failed log line must not break the host. */
+        }
+    };
+    let held = false;
+    try {
+        const first = await probe(settings.baseUrl, probeMs(), deps);
+        if (first === "omms")
+            return "running";
+        if (first === "other") {
+            await logCode("port-busy");
+            return "port-busy";
+        }
+        const runtime = await deps.resolveRuntime();
+        if (!runtime) {
+            await logCode("no-runtime");
+            return "no-runtime";
+        }
+        held = takeLock(deps);
+        if (!held)
+            return await waitForOther(settings.baseUrl, wait, remaining, deps);
+        // Another caller may have finished its start before this one took the lock.
+        const second = await probe(settings.baseUrl, probeMs(), deps);
+        if (second === "omms")
+            return "running";
+        if (second === "other") {
+            await logCode("port-busy");
+            return "port-busy";
+        }
+        const child = deps.spawn(runtime, [deps.cliScript, "web"], {
+            detached: true,
+            stdio: "ignore",
+            cwd: homedir(),
+            windowsHide: true,
+        });
+        // A missing runtime reports through this event; polling then runs out.
+        child.on("error", () => undefined);
+        child.unref();
+        if (!wait) {
+            // Keep the lock until the web app answers, so a second host waits for it.
+            const releaseWhenUp = pollUntilUp(settings.baseUrl, START_LOCK_STALE_MS, deps)
+                .catch(() => false)
+                .finally(() => removeStartLockFor(deps.pid, deps.lockPath, deps.lockFs));
+            void releaseWhenUp;
+            held = false;
+            return "started";
+        }
+        const up = await pollUntilUp(settings.baseUrl, remaining(), deps);
+        return up ? "started" : "start-timeout";
+    }
+    catch {
+        await logCode("error");
+        return "start-timeout";
+    }
+    finally {
+        if (held)
+            removeStartLockFor(deps.pid, deps.lockPath, deps.lockFs);
+    }
+}
+/** A caller without the lock never spawns. It waits for the caller that holds it. */
+async function waitForOther(baseUrl, wait, remaining, deps) {
+    if (!wait)
+        return "started";
+    return (await pollUntilUp(baseUrl, remaining(), deps)) ? "running" : "start-timeout";
+}
+/** Poll health every 250 ms until an OMMS web app answers or the budget ends. */
+async function pollUntilUp(baseUrl, budgetMs, deps) {
+    const began = deps.now();
+    const remaining = () => budgetMs - (deps.now() - began);
+    while (remaining() > 0) {
+        await deps.sleep(Math.min(POLL_INTERVAL_MS, remaining()));
+        if (remaining() <= 0)
+            break;
+        if ((await probe(baseUrl, Math.min(HEALTH_PROBE_MS, remaining()), deps)) === "omms")
+            return true;
+    }
+    return false;
+}

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

@@ -23,7 +23,10 @@ interface WebServerConfig {
     enabled: boolean;
     auth?: WebAuth;
     apiToken?: string;
+    /** How long a stepped-aside server waits before it may take the port back. */
+    stepAsideHoldOffMs?: number;
 }
+type PowerAction = "stop" | "restart";
 export declare class WebServer {
     private server;
     private config;
@@ -32,6 +35,11 @@ export declare class WebServer {
     private healthCheckInterval;
     private onTakeoverCallback;
     private onPortsExhaustedCallback;
+    private onStepAsideCallback;
+    private onPowerActionCallback;
+    private powerActionRunning;
+    private stepAsideTimer;
+    private holdOffTimer;
     private portsExhaustedNotified;
     private takeoverFailures;
     private readonly maxFallbackPort;
@@ -46,6 +54,13 @@ export declare class WebServer {
     constructor(config: WebServerConfig);
     setOnTakeoverCallback(callback: () => Promise<void>): void;
     setOnPortsExhaustedCallback(callback: () => void): void;
+    /** Standalone web apps register this to exit when a newer OMMS asks them to step aside. */
+    setOnStepAside(callback: () => void | Promise<void>): void;
+    /** Standalone web apps register this to stop or restart from the page. */
+    setOnPowerAction(callback: (action: PowerAction) => void | Promise<void>): void;
+    private handlePowerAction;
+    private scheduleStepAside;
+    private handleStepAside;
     start(): Promise<void>;
     private _start;
     private startHealthCheckLoop;