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

package/dist/adapters/claude-code/hook-client.d.ts

@@ -1,3 +1,4 @@
+import type { EnsureDeps } from "../../services/web-ensure.js";
 export declare const CLAUDE_HOOK_EVENTS: readonly ["session-start", "user-prompt-submit", "stop"];
 export type ClaudeHookEvent = (typeof CLAUDE_HOOK_EVENTS)[number];
 /** Claude Code caps added context at 10,000 characters; keep a margin. */
@@ -15,16 +16,6 @@ export interface HookServerSettings {
         password: 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;
 /** A readable byte stream such as `process.stdin`. */
 export interface HookInputStream {
     on(event: "data", listener: (chunk: Buffer | string) => void): unknown;
@@ -37,7 +28,7 @@ export interface ClaudeHookOptions {
     stdin?: HookInputStream;
     writeStdout?: (text: string) => void;
     fetch?: typeof fetch;
-    spawn?: SpawnFn;
+    spawn?: EnsureDeps["spawn"];
     now?: () => number;
     sleep?: (ms: number) => Promise<void>;
     log?: (message: string, data: Record<string, unknown>) => void | Promise<void>;
@@ -46,6 +37,8 @@ export interface ClaudeHookOptions {
     loadSettings?: () => Promise<HookServerSettings>;
     /** The `om-memory-system` script that `web` is run from. */
     cliScript?: string;
+    /** Overrides for the shared start rule, such as the start lock. */
+    ensureDeps?: Partial<EnsureDeps>;
     inputTimeoutMs?: number;
     maxInputBytes?: number;
     /** Overrides the event's request budget. */
@@ -70,4 +63,3 @@ export declare function readHookInput(stream: HookInputStream, limits: {
 export declare function truncateContext(text: string, limit?: number): string;
 /** Run one hook event. Never throws; the result says what happened. */
 export declare function runClaudeHook(event: ClaudeHookEvent, options?: ClaudeHookOptions): Promise<ClaudeHookResult>;
-export {};

package/dist/adapters/claude-code/hook-client.js

@@ -1,6 +1,4 @@
-import { spawn as nodeSpawn } from "node:child_process";
 import { homedir } from "node:os";
-import { fileURLToPath } from "node:url";
 import { AUTH_HEADER } from "../../services/auth-token.js";
 // Claude Code hook client: read the hook input, find or start the OMMS web
 // app, send one request, print the added context, and log one metadata line.
@@ -15,8 +13,6 @@ export const CLAUDE_CONTEXT_LIMIT = 9_500;
 export const RETRIEVAL_TAG = "omms-retrieval";
 const INPUT_TIMEOUT_MS = 2_000;
 const MAX_INPUT_BYTES = 1024 * 1024;
-const HEALTH_PROBE_MS = 1_000;
-const POLL_INTERVAL_MS = 250;
 const BUDGETS = {
     "session-start": { startMs: 15_000, requestMs: 3_000 },
     "user-prompt-submit": { startMs: 5_000, requestMs: 3_000 },
@@ -116,16 +112,12 @@ function productionDefaults() {
         stdin: process.stdin,
         writeStdout: (text) => process.stdout.write(text),
         fetch: globalThis.fetch,
-        spawn: nodeSpawn,
         now: () => Date.now(),
         sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
         // The shared logger only uses the file system; load it lazily anyway.
         log: async (message, data) => (await import("../../services/logger.js")).log(message, data),
         readToken: async () => (await import("../../services/auth-token.js")).getOrCreateAuthToken(),
-        resolveRuntime: async () => (await import("../../services/web-autostart.js")).resolveWebRuntime(),
         loadSettings: loadWebSettings,
-        // From dist/adapters/claude-code/ to the CLI entry point.
-        cliScript: fileURLToPath(new URL("../../cli/index.js", import.meta.url)),
     };
 }
 /** Port, bind address, and auth as `om-memory-system web` reads them (global config from home). */
@@ -190,7 +182,7 @@ async function runSteps(event, deps, result) {
     if (!settings.enabled)
         return "server-disabled";
     const budget = BUDGETS[event];
-    const ready = await ensureServer(settings.baseUrl, budget.startMs, deps, result);
+    const ready = await ensureServer(settings, budget.startMs, deps, result);
     if (ready !== "ok")
         return ready;
     const headers = {
@@ -238,48 +230,25 @@ async function runSteps(event, deps, result) {
     result.outputBytes = Buffer.byteLength(output);
     return "ok";
 }
-async function isHealthy(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 false;
-        // Same envelope check as WebServer.checkServerAvailable: another local
-        // service on the port must not count as OMMS.
-        const body = (await response.json());
-        return body.success === true && body.status === "ok";
-    }
-    catch {
-        return false;
-    }
-}
-/** Use a running web app, or start `om-memory-system web` and wait for it within the budget. */
-async function ensureServer(baseUrl, budgetMs, deps, result) {
-    const started = deps.now();
-    const remaining = () => budgetMs - (deps.now() - started);
-    if (await isHealthy(baseUrl, Math.min(HEALTH_PROBE_MS, remaining()), deps))
-        return "ok";
-    const runtime = await deps.resolveRuntime();
-    if (!runtime)
-        return "server-unreachable";
-    const child = deps.spawn(runtime, [deps.cliScript, "web"], {
-        detached: true,
-        stdio: "ignore",
-        cwd: homedir(),
-        windowsHide: true,
+/** Use a running web app, or start one through the shared rule and wait for it within the budget. */
+async function ensureServer(settings, budgetMs, deps, result) {
+    const { ensureWebApp } = await import("../../services/web-ensure.js");
+    const answer = await ensureWebApp({
+        settings: { enabled: settings.enabled, baseUrl: settings.baseUrl },
+        budgetMs,
+        wait: true,
+        deps: {
+            fetch: deps.fetch,
+            now: deps.now,
+            sleep: deps.sleep,
+            ...(deps.spawn ? { spawn: deps.spawn } : {}),
+            ...(deps.resolveRuntime ? { resolveRuntime: deps.resolveRuntime } : {}),
+            ...(deps.cliScript ? { cliScript: deps.cliScript } : {}),
+            ...deps.ensureDeps,
+        },
     });
-    // A missing runtime reports through this event; polling then runs out.
-    child.on("error", () => undefined);
-    child.unref();
-    result.spawned = true;
-    while (remaining() > 0) {
-        await deps.sleep(Math.min(POLL_INTERVAL_MS, remaining()));
-        if (remaining() <= 0)
-            break;
-        if (await isHealthy(baseUrl, Math.min(HEALTH_PROBE_MS, remaining()), deps))
-            return "ok";
-    }
-    return "start-timeout";
+    result.spawned = answer === "started";
+    if (answer === "running" || answer === "started")
+        return "ok";
+    return answer === "start-timeout" ? "start-timeout" : "server-unreachable";
 }

package/dist/adapters/pi/extension.js

@@ -111,6 +111,24 @@ export default function ommsPiExtension(pi) {
                     code: error instanceof Error ? error.name : "unknown",
                 }));
             }
+            if (process.env.OMMS_DISABLE_WEB_AUTOSTART !== "1") {
+                // Start the shared web app if none runs. The session does not wait for it.
+                void Promise.all([
+                    import("../../services/web-ensure.js"),
+                    import("../../services/web-api-auth.js"),
+                ])
+                    .then(([{ ensureWebApp }, { webServerUrl }]) => ensureWebApp({
+                    settings: {
+                        enabled: CONFIG.webServerEnabled,
+                        baseUrl: webServerUrl(CONFIG.webServerHost, CONFIG.webServerPort),
+                    },
+                    budgetMs: 0,
+                    wait: false,
+                }))
+                    .catch((error) => log("Pi web app start failed", {
+                    code: error instanceof Error ? error.name : "unknown",
+                }));
+            }
             // Retry turns whose capture failed earlier, with this session's capture model.
             void import("../../services/capture-retry-drain.js")
                 .then(({ drainCaptureRetries, registerCaptureRetryDrain, startCaptureRetryDrain }) => {

package/dist/cli/web-command.js

@@ -182,6 +182,18 @@ export async function runWebCommand(args, options = {}, online, handover = {}) {
     };
     process.once("SIGINT", stop);
     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");
+    server.setOnPowerAction(createPowerAction({
+        stopServer: async () => {
+            clearInterval(keeper);
+            process.off("SIGINT", stop);
+            process.off("SIGTERM", stop);
+            await server.stop();
+        },
+        loginItem: action === "--login-item",
+        autostart: options,
+    }));
     // A newer `web install` asked this web app to give up the port.
     server.setOnStepAside(async () => {
         clearInterval(keeper);

package/dist/cli/web-power.d.ts

@@ -0,0 +1,40 @@
+import type { WebAutostartOptions } from "../services/web-autostart.js";
+export type PowerAction = "stop" | "restart";
+interface SpawnedChild {
+    pid?: number;
+    unref(): void;
+    on(event: "error", listener: (error: Error) => void): unknown;
+}
+export interface PowerDeps {
+    spawn: (command: string, args: string[], options: {
+        detached: true;
+        stdio: "ignore";
+        cwd: string;
+        windowsHide: true;
+    }) => SpawnedChild;
+    /** Restart the login item through the service manager. False when it cannot. */
+    restartLoginItem: () => boolean | Promise<boolean>;
+    /** Write the start lock, naming `pid`, so a host that starts meanwhile waits. */
+    writeStartLock: (pid: number) => void | Promise<void>;
+    exit: (code: number) => void;
+    /** The runtime and arguments of this process, for a detached copy. */
+    execPath: string;
+    args: string[];
+    cwd: string;
+    pid: number;
+    log: (message: string, data: Record<string, unknown>) => void | Promise<void>;
+}
+/**
+ * The callback the web server runs after it replies to Stop or Restart.
+ * `stopServer` stops serving and any keep-alive timer. Restart starts a fresh
+ * copy on the same port: the service manager for the login item, and a detached
+ * copy otherwise. A detached child of the login item would die with its
+ * launchd job or systemd control group.
+ */
+export declare function createPowerAction(options: {
+    stopServer: () => Promise<void>;
+    loginItem: boolean;
+    autostart?: WebAutostartOptions;
+    deps?: Partial<PowerDeps>;
+}): (action: PowerAction) => Promise<void>;
+export {};

package/dist/cli/web-power.js

@@ -0,0 +1,61 @@
+import { spawn as nodeSpawn } from "node:child_process";
+import { homedir } from "node:os";
+function productionDeps(options) {
+    return {
+        spawn: nodeSpawn,
+        restartLoginItem: async () => (await import("../services/web-autostart.js")).restartWebAutostart(options),
+        writeStartLock: async (pid) => {
+            const { nodeLockFs, startLockPath } = await import("../services/web-ensure.js");
+            const path = startLockPath();
+            nodeLockFs.remove(path);
+            nodeLockFs.createExclusive(path, JSON.stringify({ pid, at: Date.now() }));
+        },
+        exit: (code) => process.exit(code),
+        execPath: process.execPath,
+        args: process.argv.slice(1),
+        cwd: homedir(),
+        pid: process.pid,
+        log: async (message, data) => (await import("../services/logger.js")).log(message, data),
+    };
+}
+/**
+ * The callback the web server runs after it replies to Stop or Restart.
+ * `stopServer` stops serving and any keep-alive timer. Restart starts a fresh
+ * copy on the same port: the service manager for the login item, and a detached
+ * copy otherwise. A detached child of the login item would die with its
+ * launchd job or systemd control group.
+ */
+export function createPowerAction(options) {
+    const deps = { ...productionDeps(options.autostart ?? {}), ...options.deps };
+    return async (action) => {
+        if (action === "stop") {
+            await options.stopServer();
+            deps.exit(0);
+            return;
+        }
+        try {
+            // Hold other hosts off until the copy owns the port.
+            if (!options.loginItem)
+                await deps.writeStartLock(deps.pid);
+            await options.stopServer();
+            if (options.loginItem && (await deps.restartLoginItem()))
+                return deps.exit(0);
+            const child = deps.spawn(deps.execPath, deps.args, {
+                detached: true,
+                stdio: "ignore",
+                cwd: deps.cwd,
+                windowsHide: true,
+            });
+            child.on("error", () => undefined);
+            child.unref();
+            if (child.pid)
+                await deps.writeStartLock(child.pid);
+        }
+        catch (error) {
+            await Promise.resolve(deps.log("Web app restart failed", {
+                code: error instanceof Error ? error.name : "unknown",
+            })).catch(() => undefined);
+        }
+        deps.exit(0);
+    };
+}

package/dist/importer/import-readiness.d.ts

@@ -1,6 +1,6 @@
 import type { ImportHost } from "./import-args.js";
 /**
- * What a real web import could use right now, checked inside the OpenCode
+ * What a real web import could use right now, checked inside the web app
  * process that runs it. `env://` and `file://` keys were resolved when the
  * config loaded, so a variable set only in the user's shell shows as missing.
  * "Ready" means configured, not tested: the Health section runs test calls.

package/dist/importer/import-readiness.js

@@ -70,5 +70,10 @@ export function importBlockedReason(readiness, request) {
         return state === "ready" ? null : EXTERNAL_REASONS[state];
     }
     const connected = readiness.opencode.models.some((model) => `${model.provider}/${model.model}` === request.modelChoice);
-    return connected ? null : "The chosen OpenCode model is not connected";
+    if (connected)
+        return null;
+    // The web app has no OpenCode session, so no host model is ever connected here.
+    return readiness.opencode.available
+        ? "The chosen OpenCode model is not connected"
+        : "The chosen OpenCode model is not connected here. An import with an OpenCode signed-in model runs from the terminal or with /import in OpenCode. Choose the external API for a web import.";
 }

package/dist/importer/settings-health.js

@@ -94,22 +94,31 @@ export async function runSettingsHealth(input) {
         });
     }
     if (input.testModels) {
-        await check("OpenCode model test", async () => {
-            const { resolveOpencodeHostModel } = await import("../services/ai/live-model-choice.js");
-            const ref = resolveOpencodeHostModel(CONFIG);
-            if (ref?.modelID === "inherit")
-                throw new Error("A session model needs an active session to test");
-            const capture = ref
-                ? (await createOpencodeImportModels(ref, input.directory)).capture
-                : (await import("./model-selection.js")).selectImportModel({}).capture;
-            await capture.summarize({
-                userPrompt: PROBE,
-                context: PROBE,
-                sessionId: "health",
-                projectDirectory: input.directory,
+        const { resolveOpencodeHostModel } = await import("../services/ai/live-model-choice.js");
+        const { getOpencodeHostModels } = await import("./backfill-controls.js");
+        const opencodeRef = resolveOpencodeHostModel(CONFIG);
+        if (opencodeRef && !getOpencodeHostModels()) {
+            // The web app runs outside OpenCode, so an OpenCode signed-in model cannot be called here.
+            checks.push({
+                check: "OpenCode model test",
+                status: "warn",
+                reason: "Skipped: an OpenCode signed-in model can be tested only inside OpenCode. Run a capture in OpenCode, or set the external API as the capture model.",
             });
-            return "Fixed prompt completed";
-        });
+        }
+        else {
+            await check("OpenCode model test", async () => {
+                const capture = opencodeRef
+                    ? (await createOpencodeImportModels(opencodeRef, input.directory)).capture
+                    : (await import("./model-selection.js")).selectImportModel({}).capture;
+                await capture.summarize({
+                    userPrompt: PROBE,
+                    context: PROBE,
+                    sessionId: "health",
+                    projectDirectory: input.directory,
+                });
+                return "Fixed prompt completed";
+            });
+        }
         if (pi.kind === "manual") {
             await check("Pi model test", async () => {
                 const { selectImportModel } = await import("./model-selection.js");

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