om-memory-system 4.13.0 → 4.13.3

package/README.md

@@ -55,6 +55,12 @@ downloads a small embedding model (the part that makes memories searchable),
 so you need internet access once. The terminal import command also needs
 Node.js 22.14 or later.
 
+> [!NOTE]
+> OMMS is tested mostly on macOS and Linux. Windows runs only in the release
+> check, so it gets less testing. If something breaks on Windows,
+> [open an issue](https://github.com/cmdaltctr/omms/issues). If you fix it,
+> a pull request is welcome.
+
 ## Set up
 
 ### 1. Install

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

@@ -4,4 +4,6 @@ import { type ClaudeStatusOptions } from "./status.js";
  * `om-memory-system claude-hook <event>`. Always returns 0: a hook must never
  * block or break a Claude Code session, whatever goes wrong.
  */
-export declare function runClaudeHookCommand(argv: string[], io?: ClaudeHookOptions & ClaudeStatusOptions): Promise<number>;
+export declare function runClaudeHookCommand(argv: string[], io?: ClaudeHookOptions & ClaudeStatusOptions & {
+    skipSelfUpdate?: boolean;
+}): Promise<number>;

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

@@ -9,6 +9,18 @@ async function printStatus(io) {
     const status = await buildClaudeStatus({ ...inputs, fetch: io.fetch ?? globalThis.fetch });
     (io.writeStdout ?? ((text) => process.stdout.write(text)))(`${JSON.stringify(status)}\n`);
 }
+/** Update the Claude plugin in the background when npm has a newer release. Never throws. */
+async function selfUpdate(io) {
+    try {
+        const { startPluginSelfUpdate, pluginSelfUpdateDeps } = await import("./plugin-self-update.js");
+        const log = io.log ??
+            (async (message, data) => (await import("../../services/logger.js")).log(message, data));
+        await startPluginSelfUpdate(pluginSelfUpdateDeps(log));
+    }
+    catch {
+        /* The memory hook already ran; a failed update check changes nothing. */
+    }
+}
 /**
  * `om-memory-system claude-hook <event>`. Always returns 0: a hook must never
  * block or break a Claude Code session, whatever goes wrong.
@@ -22,6 +34,8 @@ export async function runClaudeHookCommand(argv, io = {}) {
         }
         if (isHookEvent(event)) {
             await runClaudeHook(event, io);
+            if (event === "session-start" && !io.skipSelfUpdate)
+                await selfUpdate(io);
             return 0;
         }
         // Only a known name reaches the log; argv is not trusted text.

package/dist/adapters/claude-code/plugin-self-update.d.ts

@@ -0,0 +1,27 @@
+/** A second session does not start another update for the same release within this time. */
+export declare const SELF_UPDATE_RETRY_MS: number;
+export type PluginSelfUpdateCode = "started" | "current" | "recent" | "disabled" | "no-plugin" | "unreadable-plugin" | "unreachable" | "spawn-failed";
+export interface PluginSelfUpdateDeps {
+    /** False when `OMMS_DISABLE_UPDATE_CHECK` is `1`. */
+    enabled: boolean;
+    /** `CLAUDE_PLUGIN_ROOT`; undefined outside a Claude plugin. */
+    pluginRoot: string | undefined;
+    readPluginVersion: (root: string) => string;
+    fetch: typeof fetch;
+    now: () => number;
+    readMarker: () => {
+        version: string;
+        startedAt: number;
+    } | null;
+    writeMarker: (value: {
+        version: string;
+        startedAt: number;
+    }) => void;
+    /** Start a process that outlives this hook. */
+    spawnDetached: (command: string, args: string[]) => void;
+    log: (message: string, data: Record<string, unknown>) => void | Promise<void>;
+}
+/** Start a background plugin update when npm has a newer release. Never throws. */
+export declare function startPluginSelfUpdate(deps: PluginSelfUpdateDeps): Promise<PluginSelfUpdateCode>;
+/** Production inputs: the real plugin manifest, npm, and a marker file in ~/.omms. */
+export declare function pluginSelfUpdateDeps(log: PluginSelfUpdateDeps["log"], env?: NodeJS.ProcessEnv): PluginSelfUpdateDeps;

package/dist/adapters/claude-code/plugin-self-update.js

@@ -0,0 +1,103 @@
+import { spawn } from "node:child_process";
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { availableUpdate, latestNpmVersion } from "../../services/update-check.js";
+// Claude Code installs the OMMS plugin from the `stable` branch, but its own
+// update pass runs at its own time and can leave a new session on the old
+// plugin. At session start OMMS compares the plugin with npm `latest` and, when
+// it is older, runs Claude Code's own update commands in the background. The
+// new copy loads in the next session or after /reload-plugins.
+/** A second session does not start another update for the same release within this time. */
+export const SELF_UPDATE_RETRY_MS = 30 * 60 * 1000;
+/** Node script that refreshes the marketplace, then updates the plugin. Run detached. */
+const UPDATE_SCRIPT = `
+const { spawnSync } = require("node:child_process");
+const shell = process.platform === "win32";
+for (const args of [["plugin", "marketplace", "update", "omms"], ["plugin", "update", "omms@omms"]]) {
+  const run = spawnSync("claude", args, { stdio: "ignore", shell, timeout: 120000 });
+  if (run.status !== 0) process.exit(1);
+}
+`;
+/** Start a background plugin update when npm has a newer release. Never throws. */
+export async function startPluginSelfUpdate(deps) {
+    const code = await decide(deps);
+    if (code.code === "started" || code.code === "spawn-failed") {
+        await deps.log("Claude plugin self-update", {
+            code: code.code,
+            plugin: code.plugin,
+            latest: code.latest,
+        });
+    }
+    return code.code;
+}
+async function decide(deps) {
+    if (!deps.enabled)
+        return { code: "disabled" };
+    if (!deps.pluginRoot)
+        return { code: "no-plugin" };
+    let plugin;
+    try {
+        plugin = deps.readPluginVersion(deps.pluginRoot);
+    }
+    catch {
+        return { code: "unreadable-plugin" };
+    }
+    const latest = await latestNpmVersion(deps.fetch);
+    if (latest === null)
+        return { code: "unreachable" };
+    const newer = availableUpdate(plugin, latest);
+    if (!newer)
+        return { code: "current" };
+    const marker = deps.readMarker();
+    const now = deps.now();
+    if (marker?.version === newer && now - marker.startedAt <= SELF_UPDATE_RETRY_MS) {
+        return { code: "recent" };
+    }
+    // Write first, so a session that starts during the update does not start another.
+    deps.writeMarker({ version: newer, startedAt: now });
+    try {
+        deps.spawnDetached(process.execPath, ["-e", UPDATE_SCRIPT]);
+    }
+    catch {
+        return { code: "spawn-failed", plugin, latest: newer };
+    }
+    return { code: "started", plugin, latest: newer };
+}
+/** Production inputs: the real plugin manifest, npm, and a marker file in ~/.omms. */
+export function pluginSelfUpdateDeps(log, env = process.env) {
+    const markerPath = join(homedir(), ".omms", "claude-plugin-update.json");
+    return {
+        enabled: env.OMMS_DISABLE_UPDATE_CHECK !== "1",
+        pluginRoot: env.CLAUDE_PLUGIN_ROOT || undefined,
+        readPluginVersion: (root) => {
+            const manifest = JSON.parse(readFileSync(join(root, ".claude-plugin", "plugin.json"), "utf8"));
+            if (typeof manifest.version !== "string")
+                throw new Error("no version");
+            return manifest.version;
+        },
+        fetch: globalThis.fetch,
+        now: Date.now,
+        readMarker: () => {
+            try {
+                const value = JSON.parse(readFileSync(markerPath, "utf8"));
+                return typeof value.version === "string" && typeof value.startedAt === "number"
+                    ? { version: value.version, startedAt: value.startedAt }
+                    : null;
+            }
+            catch {
+                return null;
+            }
+        },
+        writeMarker: (value) => {
+            mkdirSync(dirname(markerPath), { recursive: true });
+            writeFileSync(markerPath, JSON.stringify(value));
+        },
+        spawnDetached: (command, args) => {
+            const child = spawn(command, args, { detached: true, stdio: "ignore", windowsHide: true });
+            child.on("error", () => { });
+            child.unref();
+        },
+        log,
+    };
+}

package/dist/services/turso/cross-process-write-lock.js

@@ -1,4 +1,5 @@
-import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
+import { randomUUID } from "node:crypto";
+import { existsSync, linkSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { CONFIG } from "../../config.js";
 /**
@@ -51,6 +52,26 @@ function readLiveLock(path) {
 function lockFilePath(scope, hash) {
     return join(CONFIG.storagePath, WRITE_LOCK_DIR, `${scope}_${hash}.lock`);
 }
+async function publishLock(candidate, path) {
+    // Match the bounded Windows hard-link retries used by the web start lock (TDR-034).
+    const waits = [1, 2, 5, 10, 20, 50, 100, 200];
+    for (let attempt = 0;; attempt++) {
+        try {
+            linkSync(candidate, path);
+            return;
+        }
+        catch (error) {
+            const code = error.code;
+            if (process.platform !== "win32" ||
+                !code ||
+                !["EPERM", "EACCES", "EBUSY"].includes(code) ||
+                waits[attempt] === undefined) {
+                throw error;
+            }
+            await new Promise((resolve) => setTimeout(resolve, waits[attempt]));
+        }
+    }
+}
 export async function withCrossProcessWriteLock(scope, hash, fn) {
     const dir = join(CONFIG.storagePath, WRITE_LOCK_DIR);
     if (!existsSync(dir)) {
@@ -59,31 +80,47 @@ export async function withCrossProcessWriteLock(scope, hash, fn) {
     const path = lockFilePath(scope, hash);
     const state = { pid: process.pid, timestamp: new Date().toISOString() };
     const deadline = Date.now() + LOCK_TIMEOUT_MS;
-    for (;;) {
-        try {
-            writeFileSync(path, JSON.stringify(state), { flag: "wx" });
-            break;
-        }
-        catch {
-            const holder = readLiveLock(path);
-            if (!holder)
-                continue;
-            if (Date.now() > deadline) {
-                throw new Error(`Timed out acquiring the cross-process write lock for ${scope}/${hash}: ` +
-                    `held by pid ${holder.pid} since ${holder.timestamp}`);
+    const candidate = `${path}.${process.pid}.${randomUUID()}.tmp`;
+    let acquired = false;
+    try {
+        // Exclusive open exposes an empty file before its PID is written. Publish
+        // the complete payload with a hard link, which cannot replace a live lock.
+        writeFileSync(candidate, JSON.stringify(state), { flag: "wx" });
+        for (;;) {
+            try {
+                await publishLock(candidate, path);
+                acquired = true;
+                break;
+            }
+            catch (error) {
+                if (error.code !== "EEXIST")
+                    throw error;
+                const holder = readLiveLock(path);
+                if (!holder)
+                    continue;
+                if (Date.now() > deadline) {
+                    throw new Error(`Timed out acquiring the cross-process write lock for ${scope}/${hash}: ` +
+                        `held by pid ${holder.pid} since ${holder.timestamp}`, { cause: error });
+                }
+                await new Promise((resolve) => setTimeout(resolve, LOCK_POLL_MS + Math.random() * 10));
             }
-            await new Promise((resolve) => setTimeout(resolve, LOCK_POLL_MS + Math.random() * 10));
         }
-    }
-    try {
         return await fn();
     }
     finally {
+        if (acquired) {
+            try {
+                unlinkSync(path);
+            }
+            catch {
+                // Best effort: a stale file is cleaned up by the next acquirer.
+            }
+        }
         try {
-            unlinkSync(path);
+            unlinkSync(candidate);
         }
         catch {
-            // Best effort: a stale file is cleaned up by the next acquirer.
+            // A failed publication must not leave its temporary payload behind.
         }
     }
 }

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

@@ -1,4 +1,6 @@
 export declare const UPDATE_CHECK_INTERVAL_MS: number;
+/** An open page triggers a new check once the last one is this old. */
+export declare const STATUS_RECHECK_AFTER_MS: number;
 /** An install that takes longer is stopped, and the web app keeps serving. */
 export declare const INSTALL_TIMEOUT_MS: number;
 export type UpdateState = "idle" | "installing" | "restarting" | "failed";
@@ -60,11 +62,14 @@ export declare class WebUpdate {
     private state;
     private code;
     private started;
+    private lastCheck;
+    private checking;
     constructor(deps: WebUpdateDeps);
-    /** Check now, then every 6 hours. A second call does nothing. */
+    /** Check now, then every 10 minutes. A second call does nothing. */
     start(): void;
-    /** Read npm `latest`. A failed read keeps the last result. */
+    /** Read npm `latest`. A failed read keeps the last result. Calls during a read share it. */
     check(): Promise<void>;
+    private read;
     status(): UpdateStatus;
     private canInstall;
     /** Start the install and the restart. A request while one runs joins it. */

package/dist/services/web-update.js

@@ -1,9 +1,12 @@
 import { posix, win32 } from "node:path";
 import { availableUpdate, latestNpmVersion } from "./update-check.js";
-// The web app's npm release check. It reads npm `latest` at start and then every
-// 6 hours, and keeps the result in memory for `GET /api/web/status`. It imports
+// The web app's npm release check. It reads npm `latest` at start, every 10
+// minutes, and when an open page reads the status and the last check is over a
+// minute old. It keeps the result in memory for `GET /api/web/status`. It imports
 // no host adapter and no config, so tests pass every input.
-export const UPDATE_CHECK_INTERVAL_MS = 6 * 60 * 60 * 1000;
+export const UPDATE_CHECK_INTERVAL_MS = 10 * 60 * 1000;
+/** An open page triggers a new check once the last one is this old. */
+export const STATUS_RECHECK_AFTER_MS = 60 * 1000;
 /** An install that takes longer is stopped, and the web app keeps serving. */
 export const INSTALL_TIMEOUT_MS = 5 * 60 * 1000;
 /** Only a plain release reaches the npm arguments; the value comes from the registry. */
@@ -24,10 +27,12 @@ export class WebUpdate {
     state = "idle";
     code = null;
     started = false;
+    lastCheck = -Infinity;
+    checking = null;
     constructor(deps) {
         this.deps = deps;
     }
-    /** Check now, then every 6 hours. A second call does nothing. */
+    /** Check now, then every 10 minutes. A second call does nothing. */
     start() {
         if (this.started || !this.deps.enabled)
             return;
@@ -35,10 +40,15 @@ export class WebUpdate {
         void this.check();
         this.deps.setInterval(() => void this.check(), UPDATE_CHECK_INTERVAL_MS).unref?.();
     }
-    /** Read npm `latest`. A failed read keeps the last result. */
-    async check() {
+    /** Read npm `latest`. A failed read keeps the last result. Calls during a read share it. */
+    check() {
         if (!this.deps.enabled)
-            return;
+            return Promise.resolve();
+        this.checking ??= this.read().finally(() => (this.checking = null));
+        return this.checking;
+    }
+    async read() {
+        this.lastCheck = this.deps.now();
         const latest = await latestNpmVersion(this.deps.fetch);
         if (latest === null) {
             this.deps.log("Web app update check failed", { code: "unreachable" });
@@ -47,6 +57,9 @@ export class WebUpdate {
         this.available = availableUpdate(this.deps.version, latest);
     }
     status() {
+        // An open page polls the status, so a release shows within about a minute.
+        if (this.deps.now() - this.lastCheck > STATUS_RECHECK_AFTER_MS)
+            void this.check();
         return {
             available: this.available,
             state: this.state,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "om-memory-system",
-  "version": "4.13.0",
+  "version": "4.13.3",
   "description": "Opinionated modular memory system for coding agents (OpenCode + Pi)",
   "type": "module",
   "main": "dist/plugin.js",