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

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/api-handlers.js

@@ -496,7 +496,7 @@ export async function handleSearch(query, tag, page = 1, pageSize = 20) {
             type: "memory",
             id: r.id,
             content: r.memory,
-            memoryType: r.metadata?.type,
+            memoryType: r.type ?? r.metadata?.type,
             tags: r.tags,
             createdAt: safeToISOString(r.createdAt ?? r.metadata?.createdAt),
             updatedAt: r.metadata?.updatedAt ? safeToISOString(r.metadata.updatedAt) : undefined,

package/dist/services/client.d.ts

@@ -64,6 +64,7 @@ export declare class LocalMemoryClient {
         memories: {
             id: any;
             summary: any;
+            type: string | undefined;
             createdAt: string;
             metadata: any;
             displayName: any;

package/dist/services/client.js

@@ -204,6 +204,7 @@ export class LocalMemoryClient {
             const memories = allMemories.slice(0, limit).map((r) => ({
                 id: r.id,
                 summary: r.content,
+                type: r.type ? String(r.type) : undefined,
                 createdAt: safeToISOString(r.created_at),
                 metadata: safeJSONParse(r.metadata),
                 displayName: r.display_name,

package/dist/services/turso/types.d.ts

@@ -32,6 +32,7 @@ export interface SearchResult {
     similarity: number;
     createdAt?: number;
     tags?: string[];
+    type?: string;
     metadata?: Record<string, unknown>;
     displayName?: string;
     userName?: string;

package/dist/services/turso/vector-search.js

@@ -109,7 +109,7 @@ export class TursoVectorSearch {
         // hits still get a full hybrid score (missing ANN side is not forced to 0).
         const rows = await db.all(containerTag === ""
             ? `
-      SELECT id, content, tags, created_at, metadata, container_tag,
+      SELECT id, content, tags, type, created_at, metadata, container_tag,
              display_name, user_name, user_email, project_path, project_name,
              git_repo_url, is_pinned,
              vector_distance_cos(vector, vector32(?)) AS content_dist,
@@ -120,7 +120,7 @@ export class TursoVectorSearch {
       WHERE id IN (${placeholders})
     `
             : `
-      SELECT id, content, tags, created_at, metadata, container_tag,
+      SELECT id, content, tags, type, created_at, metadata, container_tag,
              display_name, user_name, user_email, project_path, project_name,
              git_repo_url, is_pinned,
              vector_distance_cos(vector, vector32(?)) AS content_dist,
@@ -158,6 +158,7 @@ export class TursoVectorSearch {
                 similarity,
                 createdAt: Number(row.created_at),
                 tags: memoryTagsStr ? memoryTagsStr.split(",") : [],
+                type: row.type ? String(row.type) : undefined,
                 metadata: parseMetadata(row.metadata),
                 containerTag: String(row.container_tag),
                 displayName: row.display_name ? String(row.display_name) : undefined,

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

@@ -26,6 +26,7 @@ interface WebServerConfig {
     /** 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;
@@ -35,6 +36,8 @@ export declare class WebServer {
     private onTakeoverCallback;
     private onPortsExhaustedCallback;
     private onStepAsideCallback;
+    private onPowerActionCallback;
+    private powerActionRunning;
     private stepAsideTimer;
     private holdOffTimer;
     private portsExhaustedNotified;
@@ -53,6 +56,9 @@ export declare class WebServer {
     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>;