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

package/dist/services/claude-folder.js

@@ -0,0 +1,24 @@
+import { homedir } from "node:os";
+import { isAbsolute, join } from "node:path";
+/** Empty, an absolute path, or `~/...`. A relative path would depend on the web app's working directory. */
+export function isValidClaudeConfigDir(value) {
+    if (typeof value !== "string")
+        return false;
+    const trimmed = value.trim();
+    return trimmed === "" || trimmed.startsWith("~/") || isAbsolute(trimmed);
+}
+export function resolveClaudeFolder(configured, env = process.env.CLAUDE_CONFIG_DIR, home = homedir()) {
+    const expand = (path) => (path.startsWith("~/") ? join(home, path.slice(2)) : path);
+    const setting = configured?.trim();
+    if (setting)
+        return { folder: expand(setting), source: "setting" };
+    // A variable set without shell expansion can still hold a literal `~/`.
+    const fromEnv = env?.trim();
+    if (fromEnv)
+        return { folder: expand(fromEnv), source: "env" };
+    return { folder: join(home, ".claude"), source: "default" };
+}
+/** `<Claude folder>/projects`, where Claude Code writes its transcripts. */
+export function claudeProjectsRoot(configured, env, home) {
+    return join(resolveClaudeFolder(configured, env, home).folder, "projects");
+}

package/dist/services/global-config-writer.js

@@ -3,6 +3,7 @@ import { promises as fs, readFileSync, statSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { applyEdits, modify, parse } from "jsonc-parser";
 import { CONFIG_TEMPLATE, getGlobalConfigSourcePath, getGlobalConfigWritePath, validateGlobalConfig, } from "../config.js";
+import { isValidClaudeConfigDir } from "./claude-folder.js";
 const keys = new Set([
     "opencodeProvider",
     "opencodeModel",
@@ -21,6 +22,7 @@ const keys = new Set([
     "memoryModel",
     "memoryApiKey",
     "importPathMaps",
+    "claudeConfigDir",
 ]);
 const MEMORY_PROVIDERS = [
     "openai-chat",
@@ -50,6 +52,9 @@ function isValidEdit(key, value) {
     // Entries are checked by the startup validation below.
     if (key === "importPathMaps")
         return Array.isArray(value);
+    // An empty value clears the field.
+    if (key === "claudeConfigDir")
+        return isValidClaudeConfigDir(value);
     return typeof value === "string" && value.trim().length > 0;
 }
 export class ConfigConflictError extends Error {

package/dist/services/settings-snapshot.d.ts

@@ -29,6 +29,11 @@ export declare function getSettingsSnapshot(directory: string): {
         pi: import("./ai/live-model-choice.js").PiLiveModelChoice;
         "claude-code": import("./ai/live-model-choice.js").AutoCaptureProviderStatus;
     };
+    claudeFolder: {
+        root: string;
+        source: import("./claude-folder.js").ClaudeFolderSource;
+        exists: boolean;
+    };
 };
 /**
  * Where `memoryApiKey` comes from and whether it resolves in this web

package/dist/services/settings-snapshot.js

@@ -2,6 +2,7 @@ import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { parse } from "jsonc-parser";
 import { CONFIG, getGlobalConfigSourcePath } from "../config.js";
+import { resolveClaudeFolder } from "./claude-folder.js";
 import { readGlobalConfigRevision } from "./global-config-writer.js";
 import { getAutoCaptureProviderStatus, isExternalModelReady, resolveClaudeCodeLiveModel, resolvePiLiveModel, } from "./ai/live-model-choice.js";
 const editable = [
@@ -21,6 +22,7 @@ const editable = [
     "memoryApiUrl",
     "memoryModel",
     "importPathMaps",
+    "claudeConfigDir",
 ];
 /** Keys a project config cannot override, so the page always shows the global value. */
 const globalOnly = [
@@ -32,6 +34,7 @@ const globalOnly = [
     "memoryProvider",
     "memoryApiUrl",
     "importPathMaps",
+    "claudeConfigDir",
 ];
 function readSettingsFile(path) {
     if (!path)
@@ -83,6 +86,9 @@ export function getSettingsSnapshot(directory) {
             },
         ];
     }));
+    const claudeSetting = global.claudeConfigDir ?? CONFIG.claudeConfigDir;
+    const claude = resolveClaudeFolder(typeof claudeSetting === "string" ? claudeSetting : "");
+    const claudeRoot = join(claude.folder, "projects");
     return {
         revision: readGlobalConfigRevision(),
         settings,
@@ -95,6 +101,8 @@ export function getSettingsSnapshot(directory) {
             // Claude Code capture uses the external API only; `issues` names each missing setting.
             "claude-code": resolveClaudeCodeLiveModel(CONFIG),
         },
+        // The folder Claude Code capture and import read; the check never reads transcripts.
+        claudeFolder: { root: claudeRoot, source: claude.source, exists: existsSync(claudeRoot) },
     };
 }
 /**

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

@@ -1,3 +1,4 @@
+/** Each code maps to a host message or log code; none of them fails the session. */
 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 {
@@ -14,13 +15,20 @@ type SpawnFn = (command: string, args: string[], options: {
     cwd: string;
     windowsHide: true;
 }) => SpawnedChild;
-/** The three file operations the start lock needs. */
+/** The 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;
+    /** Hard-link `from` to `to`. False when `to` exists or `from` is missing. */
+    link(from: string, to: string): boolean;
+    /** Time since the file's change time, or null when it is missing. A link sets the change time. */
+    ageMs(path: string): number | null;
+    /** Replace the file in one step, so a reader never finds it missing. */
+    replace(path: string, text: string): void;
 }
+/** Injected so tests run the start rule without a network, a process, or a real clock. */
 export interface EnsureDeps {
     fetch: typeof fetch;
     spawn: SpawnFn;
@@ -36,6 +44,7 @@ export interface EnsureDeps {
     pid: number;
     log: (message: string, data: Record<string, unknown>) => void | Promise<void>;
 }
+/** Hosts differ only in these values; the start rule itself has no host-specific code. */
 export interface EnsureOptions {
     settings: EnsureSettings;
     /** How long the caller may wait for the web app to answer. */
@@ -48,9 +57,18 @@ export interface EnsureOptions {
 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;
+/** Lock files are private to the user (0600 in a 0700 folder), like the token file. */
 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;
+/** What taking the start lock needs; a test drives two callers through it step by step. */
+export type LockDeps = Pick<EnsureDeps, "lockPath" | "lockFs" | "pid" | "now" | "pidAlive">;
+/**
+ * Take the start lock. A stale lock is replaced by one caller only: the caller
+ * that hard-links it to a tombstone named after its text. Remove-then-create
+ * alone let two callers each remove the lock the other had just created.
+ */
+export declare function takeStartLock(deps: LockDeps): boolean;
 /**
  * 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.

package/dist/services/web-ensure.js

@@ -1,5 +1,6 @@
 import { spawn as nodeSpawn } from "node:child_process";
-import { mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { createHash } from "node:crypto";
+import { linkSync, mkdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync, } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
@@ -11,6 +12,7 @@ export const START_LOCK_STALE_MS = 20_000;
 export function startLockPath(home = homedir()) {
     return join(home, ".omms", "web-start.lock");
 }
+/** Lock files are private to the user (0600 in a 0700 folder), like the token file. */
 export const nodeLockFs = {
     createExclusive(path, text) {
         mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
@@ -35,6 +37,32 @@ export const nodeLockFs = {
     remove(path) {
         rmSync(path, { force: true });
     },
+    link(from, to) {
+        try {
+            linkSync(from, to);
+            return true;
+        }
+        catch (error) {
+            const code = error.code;
+            if (code === "EEXIST" || code === "ENOENT")
+                return false;
+            throw error;
+        }
+    },
+    ageMs(path) {
+        try {
+            return Date.now() - statSync(path).ctimeMs;
+        }
+        catch {
+            return null;
+        }
+    },
+    replace(path, text) {
+        mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
+        const temp = `${path}.${process.pid}.tmp`;
+        writeFileSync(temp, text, { mode: 0o600 });
+        renameSync(temp, path);
+    },
 };
 /** 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) {
@@ -104,19 +132,40 @@ function lockIsStale(text, deps) {
         return true;
     }
 }
-/** Take the start lock. A stale lock is removed and taken once more. */
-function takeLock(deps) {
+/**
+ * Take the start lock. A stale lock is replaced by one caller only: the caller
+ * that hard-links it to a tombstone named after its text. Remove-then-create
+ * alone let two callers each remove the lock the other had just created.
+ */
+export function takeStartLock(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 (seen === null)
+        return deps.lockFs.createExclusive(deps.lockPath, mine);
     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)
+    const tomb = `${deps.lockPath}.${createHash("sha256").update(seen).digest("hex").slice(0, 16)}.stale`;
+    if (!deps.lockFs.link(deps.lockPath, tomb)) {
+        // A takeover that crashed after its link leaves the tombstone behind. Clear
+        // it, and let the next caller do the takeover.
+        const age = deps.lockFs.ageMs(tomb);
+        if (age !== null && age > START_LOCK_STALE_MS)
+            deps.lockFs.remove(tomb);
         return false;
-    deps.lockFs.remove(deps.lockPath);
-    return deps.lockFs.createExclusive(deps.lockPath, mine);
+    }
+    try {
+        // A slow caller can link a lock that was replaced after it read it. That
+        // lock is live, so leave it.
+        if (deps.lockFs.read(tomb) !== seen)
+            return false;
+        deps.lockFs.remove(deps.lockPath);
+        return deps.lockFs.createExclusive(deps.lockPath, mine);
+    }
+    finally {
+        deps.lockFs.remove(tomb);
+    }
 }
 /**
  * Use a running OMMS web app, or start one detached `om-memory-system web`.
@@ -152,7 +201,7 @@ export async function ensureWebApp(options) {
             await logCode("no-runtime");
             return "no-runtime";
         }
-        held = takeLock(deps);
+        held = takeStartLock(deps);
         if (!held)
             return await waitForOther(settings.baseUrl, wait, remaining, deps);
         // Another caller may have finished its start before this one took the lock.

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

@@ -58,6 +58,7 @@ export declare class WebServer {
     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;
+    /** Only a local caller may stop the web app; the token alone is not enough. */
     private handlePowerAction;
     private scheduleStepAside;
     private handleStepAside;

package/dist/services/web-server.js

@@ -1,3 +1,4 @@
+import { randomUUID } from "node:crypto";
 import { existsSync, readFileSync } from "node:fs";
 import { createServer } from "node:http";
 import { Readable } from "node:stream";
@@ -143,6 +144,8 @@ export function nextFallbackPort(currentPort, failedTakeovers, maxFallbackPort,
 const STEP_ASIDE_HOLD_OFF_MS = 60_000;
 /** Lets the 202 reply reach the caller before the server stops. */
 const STEP_ASIDE_REPLY_GRACE_MS = 100;
+/** Differs between processes, so the page can tell a restarted web app from the old one. */
+const PROCESS_INSTANCE = randomUUID();
 export class WebServer {
     server = null;
     config;
@@ -217,6 +220,7 @@ export class WebServer {
     setOnPowerAction(callback) {
         this.onPowerActionCallback = callback;
     }
+    /** Only a local caller may stop the web app; the token alone is not enough. */
     handlePowerAction(action, remoteAddress) {
         const record = (outcome) => log("Web server power request", { action, outcome, ownVersion: packageVersion() });
         if (!isLoopbackAddress(remoteAddress)) {
@@ -440,6 +444,8 @@ export class WebServer {
                 clearTimeout(timer);
         this.stepAsideTimer = null;
         this.holdOffTimer = null;
+        // A restart whose copy failed calls start() again on this server.
+        this.startPromise = null;
         if (!this.isOwner || !this.server) {
             return;
         }
@@ -591,10 +597,12 @@ export class WebServer {
                         ? controls.resume(host, cwd)
                         : controls.runNow(host, cwd));
             }
+            // The page shows the power button only when this says the caller may control the web app.
             if (path === "/api/web/status" && method === "GET") {
                 return this.jsonResponse({
                     version: packageVersion(),
                     canControl: isLoopbackAddress(remoteAddress) && this.onPowerActionCallback !== null,
+                    instance: PROCESS_INSTANCE,
                 });
             }
             if ((path === "/api/web/stop" || path === "/api/web/restart") && method === "POST") {
@@ -785,8 +793,11 @@ export class WebServer {
                 if (body?.host !== "pi" && body?.host !== "opencode" && body?.host !== "claude-code") {
                     return this.jsonResponse({ error: "Choose Pi, OpenCode, or Claude Code" }, 400);
                 }
-                const { browseImportSources } = await import("../importer/web-import-api.js");
-                return this.importResponse(() => browseImportSources(body.host, body.path));
+                const [{ browseImportSources }, { CONFIG }] = await Promise.all([
+                    import("../importer/web-import-api.js"),
+                    import("../config.js"),
+                ]);
+                return this.importResponse(() => browseImportSources(body.host, body.path, CONFIG.claudeConfigDir));
             }
             if (path === "/api/settings/imports/sources/validate" && method === "POST") {
                 const body = (await req.json());