om-memory-system 3.6.0-next.38 → 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.d.ts

@@ -1,3 +1,10 @@
 import type { WebAutostartOptions } from "../services/web-autostart.js";
+/** Test seams for the handover in `web install`. */
+export interface WebHandoverDeps {
+    fetch?: typeof fetch;
+    sleep?: (ms: number) => Promise<void>;
+    /** The version this command runs as. */
+    version?: string;
+}
 /** Run the standalone web app or manage its per-user login item. */
-export declare function runWebCommand(args: string[], options?: WebAutostartOptions, online?: () => Promise<boolean>): Promise<number>;
+export declare function runWebCommand(args: string[], options?: WebAutostartOptions, online?: () => Promise<boolean>, handover?: WebHandoverDeps): Promise<number>;

package/dist/cli/web-command.js

@@ -1,6 +1,95 @@
 import { homedir } from "node:os";
+const POLL_MS = 250;
+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. */
+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. */
+async function negotiateOwner(ctx) {
+    const { compareVersions } = await import("../services/version-compare.js");
+    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" };
+}
+/** Print which version serves the port after `web install`. */
+async function announceHandover(ctx, handover) {
+    const { url, port, version } = ctx;
+    if (handover.kind === "stuck") {
+        console.log(`OMMS ${handover.owner} holds port ${port} and cannot hand it over. Stop the web app (Ctrl+C in its terminal, or quit the session that runs it), then run om-memory-system web install again.`);
+    }
+    else if (handover.kind === "newer") {
+        console.log(`OMMS ${handover.owner} already serves port ${port}. It is newer than this command (${version}). Update the global command: npm i -g om-memory-system`);
+    }
+    else if (handover.kind === "same") {
+        console.log(`OMMS web app: ${url} (version ${handover.owner})`);
+    }
+    else if (handover.kind === "none") {
+        console.log(`OMMS web app: ${url}`);
+    }
+    else {
+        let serving = null;
+        for (let i = 0; i < POLL_LIMIT && !serving; i++) {
+            serving = await readWebVersion(ctx.fetchFn, url, ctx.headers);
+            if (!serving)
+                await ctx.sleep(POLL_MS);
+        }
+        if (!serving)
+            console.log(`OMMS web app: ${url}`);
+        else if (serving === version)
+            console.log(`OMMS web app: ${url} (version ${serving})`);
+        else
+            console.log(`OMMS web app: ${url} (version ${serving}). This is not the version of this command (${version}).`);
+    }
+}
 /** Run the standalone web app or manage its per-user login item. */
-export async function runWebCommand(args, options = {}, online) {
+export async function runWebCommand(args, options = {}, online, handover = {}) {
     const home = options.home ?? homedir();
     const config = await import("../config.js");
     config.initConfig(home);
@@ -21,12 +110,33 @@ export async function runWebCommand(args, options = {}, online) {
         const { readGlobalConfigRevision, writeGlobalConfigKeys } = await import("../services/global-config-writer.js");
         await writeGlobalConfigKeys({ webServerAutoStart: action === "install" }, readGlobalConfigRevision());
         config.initConfig(home);
+        let context;
+        let outcome = { kind: "none" };
+        if (action === "install") {
+            const [{ getOrCreateAuthToken, AUTH_HEADER }, { packageVersion }] = await Promise.all([
+                import("../services/auth-token.js"),
+                import("../services/package-version.js"),
+            ]);
+            const apiToken = config.CONFIG.webServerApiToken;
+            context = {
+                fetchFn: handover.fetch ?? fetch,
+                sleep: handover.sleep ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms))),
+                url,
+                port: config.CONFIG.webServerPort,
+                headers: {
+                    [AUTH_HEADER]: getOrCreateAuthToken(),
+                    ...(apiToken ? { authorization: `Bearer ${apiToken}` } : {}),
+                },
+                version: handover.version ?? packageVersion(),
+            };
+            outcome = await negotiateOwner(context);
+        }
         const result = action === "install"
             ? installWebAutostart({ ...options, start: true })
             : removeWebAutostart({ ...options, start: true });
         console.log(`OMMS login item: ${result.state}`);
-        if (action === "install" && result.state === "installed")
-            console.log(`OMMS web app: ${url}`);
+        if (context && result.state === "installed")
+            await announceHandover(context, outcome);
         return action === "install" && result.state !== "installed" ? 1 : 0;
     }
     if (action === "status") {
@@ -72,5 +182,23 @@ export async function runWebCommand(args, options = {}, online) {
     };
     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);
+        await server.stop();
+        process.exit(0);
+    });
     return 0;
 }

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