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

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/core/memory-operations.js

@@ -12,6 +12,7 @@ function formatSearchResults(query, results, limit) {
         results: memoryResults.slice(0, limit || 10).map((result) => ({
             id: result.id,
             content: result.memory || result.chunk,
+            type: result.type,
             similarity: Math.round(result.similarity * 100),
         })),
     };
@@ -198,6 +199,7 @@ export async function executeMemoryOperation(args, context) {
                     memories: result.memories?.map((memory) => ({
                         id: memory.id,
                         content: memory.summary,
+                        type: memory.type,
                         createdAt: memory.createdAt,
                     })),
                 };

package/dist/importer/claude-hook-api.js

@@ -1,5 +1,6 @@
+import { realpathSync } from "node:fs";
 import { readFile } from "node:fs/promises";
-import { isAbsolute } from "node:path";
+import { basename, dirname, isAbsolute, join, resolve, sep } from "node:path";
 import { CONFIG, refreshConfigIfChanged } from "../config.js";
 import { captureConversation } from "../core/capture.js";
 import { classifyCaptureFailure, quickRetryDelayMs } from "../core/capture-retry-policy.js";
@@ -12,6 +13,7 @@ import { log } from "../services/logger.js";
 import { isFullyPrivate, stripPrivateContent } from "../services/privacy.js";
 import { getTags } from "../services/tags.js";
 import { extractClaudeWindowsAfter, parseClaudeTranscript, } from "./claude-conversation.js";
+import { defaultClaudeProjectsRoot } from "./claude-reader.js";
 // The web app's side of the Claude Code hooks (design decisions 4, 6, 7):
 // retrieval for SessionStart and UserPromptSubmit, a one-worker capture queue
 // for Stop, profile learning, and the once-per-process backfill start. Logs
@@ -61,6 +63,41 @@ function parseRetrieveRequest(body) {
         prompt: optionalString(input, "prompt"),
     };
 }
+/**
+ * Resolves symlinks and returns the letter case on disk. Node's plain
+ * `realpathSync` keeps the case it is given, which fails the root check on a
+ * case-insensitive file system. A path that does not exist yet resolves
+ * through its nearest existing parent.
+ */
+function realPathOrResolved(path) {
+    const absolute = resolve(path);
+    try {
+        return realpathSync.native(absolute);
+    }
+    catch {
+        const parent = dirname(absolute);
+        if (parent === absolute)
+            return absolute;
+        return join(realPathOrResolved(parent), basename(absolute));
+    }
+}
+/**
+ * Claude Code writes `<projects root>/<folder>/<session_id>.jsonl`. Accept only
+ * that shape, so the route cannot be used to read other `.jsonl` files. Returns
+ * the resolved path, which the capture then reads.
+ */
+function checkedTranscriptPath(transcriptPath, sessionId) {
+    const fileName = `${sessionId}.jsonl`;
+    const real = realPathOrResolved(transcriptPath);
+    if (basename(transcriptPath) !== fileName || basename(real) !== fileName) {
+        throw new ClaudeHookRequestError("transcript_path must be named <session_id>.jsonl");
+    }
+    const root = realPathOrResolved(defaultClaudeProjectsRoot());
+    if (!real.startsWith(root + sep)) {
+        throw new ClaudeHookRequestError("transcript_path must be under the Claude projects folder");
+    }
+    return real;
+}
 function parseCaptureRequest(body) {
     const input = objectBody(body);
     const transcriptPath = input.transcript_path;
@@ -69,9 +106,11 @@ function parseCaptureRequest(body) {
         !transcriptPath.endsWith(".jsonl")) {
         throw new ClaudeHookRequestError("transcript_path must be an absolute .jsonl path");
     }
+    const { sessionId, cwd } = sessionAndCwd(input);
     return {
-        ...sessionAndCwd(input),
-        transcriptPath,
+        sessionId,
+        cwd,
+        transcriptPath: checkedTranscriptPath(transcriptPath, sessionId),
         lastAssistantMessage: optionalString(input, "last_assistant_message"),
         stopHookActive: input.stop_hook_active === true,
     };

package/dist/importer/claude-reader.d.ts

@@ -16,6 +16,7 @@ import { type ImportPathMap, type ImportProjectReport, type LazyImportSource } f
  * time.
  */
 export declare const CLAUDE_HEADER_READ_LIMIT: number;
+/** `$CLAUDE_CONFIG_DIR/projects` when the variable is set, else `~/.claude/projects`. */
 export declare function defaultClaudeProjectsRoot(): string;
 export interface DiscoveredClaudeSession {
     file: string;

package/dist/importer/claude-reader.js

@@ -23,8 +23,10 @@ import { countImportableUnits, projectFilterTag, selectImportWindows, } from "./
  */
 export const CLAUDE_HEADER_READ_LIMIT = 1024 * 1024;
 const READ_CHUNK = 64 * 1024;
+/** `$CLAUDE_CONFIG_DIR/projects` when the variable is set, else `~/.claude/projects`. */
 export function defaultClaudeProjectsRoot() {
-    return join(homedir(), ".claude", "projects");
+    const configDir = process.env.CLAUDE_CONFIG_DIR?.trim();
+    return join(configDir || join(homedir(), ".claude"), "projects");
 }
 /** A missing folder is an empty history. Any other read error is reported, not hidden. */
 function readEntries(dir, unreadable) {

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