om-memory-system 4.2.0 → 4.3.0

package/README.md

@@ -137,8 +137,9 @@ import guides, and the [CLI reference](docs/cli.md).
 ## Keeping OMMS up to date
 
 Pi shows a notice when a new version is out; update with
-`pi update npm:om-memory-system`. On OpenCode v2, run `opencode plugin check`
-and `opencode plugin update om-memory-system`. Restart the agent afterwards.
+`pi update npm:om-memory-system`. On OpenCode v2, the footer shows when a new version is out;
+run `opencode plugin update om-memory-system`. Restart the agent afterwards.
+[UPDATES.md](UPDATES.md) explains how updates work on every host.
 To stay on one version, install it with the number, for example
 `pi install npm:om-memory-system@3.1.1` or
 `opencode plugin add om-memory-system@3.1.1`; a pinned install is never

package/dist/adapters/opencode/tui-status.d.ts

@@ -0,0 +1,28 @@
+/** What the OpenCode footer shows: the web app's state and a newer release, if any. */
+export interface TuiStatusState {
+    web: "warming" | "connected" | "offline";
+    update: string | null;
+}
+export declare function tuiStatusText(state: TuiStatusState): string;
+/** The `latest` version on npm, or null when the registry cannot be reached. */
+export declare function latestNpmVersion(fetchFn: typeof fetch, timeoutMs?: number): Promise<string | null>;
+/** A newer release than `current`, ignoring prereleases; null otherwise. */
+export declare function availableUpdate(current: string, latest: string | null): string | null;
+export interface TuiStatusDeps {
+    currentVersion: string;
+    healthUrl: string;
+    fetch: typeof fetch;
+    setText: (text: string) => void;
+    /** Shown once per start when a newer release is on npm. */
+    notify: (message: string) => void;
+    checkUpdates?: boolean;
+    healthIntervalMs?: number;
+    updateIntervalMs?: number;
+}
+/**
+ * Keep the footer text current: the web app is polled, and npm is asked for a
+ * newer release at start and then every few hours. Returns a stop function.
+ */
+export declare function startTuiStatus(deps: TuiStatusDeps): () => void;
+/** Wire the status to this install: its version, the configured web app port, and global fetch. */
+export declare function startInstalledTuiStatus(callbacks: Pick<TuiStatusDeps, "setText" | "notify">): Promise<() => void>;

package/dist/adapters/opencode/tui-status.js

@@ -0,0 +1,89 @@
+import { isOlderVersion } from "../../services/version-compare.js";
+export function tuiStatusText(state) {
+    const web = state.web === "offline" ? "omms:web app off" : `omms:${state.web}`;
+    return state.update ? `${web} · ${state.update} available` : web;
+}
+/** The `latest` version on npm, or null when the registry cannot be reached. */
+export async function latestNpmVersion(fetchFn, timeoutMs = 5_000) {
+    try {
+        const response = await fetchFn("https://registry.npmjs.org/om-memory-system/latest", {
+            signal: AbortSignal.timeout(timeoutMs),
+            headers: { accept: "application/json" },
+        });
+        if (!response.ok)
+            return null;
+        const body = (await response.json());
+        return typeof body.version === "string" ? body.version : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** A newer release than `current`, ignoring prereleases; null otherwise. */
+export function availableUpdate(current, latest) {
+    if (!latest || latest.includes("-"))
+        return null;
+    return isOlderVersion(current, latest) ? latest : null;
+}
+/**
+ * Keep the footer text current: the web app is polled, and npm is asked for a
+ * newer release at start and then every few hours. Returns a stop function.
+ */
+export function startTuiStatus(deps) {
+    const state = { web: "warming", update: null };
+    let stopped = false;
+    let notified = null;
+    const show = () => {
+        if (!stopped)
+            deps.setText(tuiStatusText(state));
+    };
+    const checkHealth = async () => {
+        try {
+            const response = await deps.fetch(deps.healthUrl, { signal: AbortSignal.timeout(3_000) });
+            state.web = response.ok ? "connected" : "offline";
+        }
+        catch {
+            state.web = "offline";
+        }
+        show();
+    };
+    const checkUpdate = async () => {
+        const update = availableUpdate(deps.currentVersion, await latestNpmVersion(deps.fetch));
+        state.update = update;
+        show();
+        if (update && notified !== update && !stopped) {
+            notified = update;
+            deps.notify(`om-memory-system ${update} is available (running ${deps.currentVersion}). Run: opencode plugin update om-memory-system, then restart OpenCode.`);
+        }
+    };
+    show();
+    void checkHealth();
+    if (deps.checkUpdates !== false)
+        void checkUpdate();
+    const timers = [setInterval(() => void checkHealth(), deps.healthIntervalMs ?? 30_000)];
+    if (deps.checkUpdates !== false) {
+        timers.push(setInterval(() => void checkUpdate(), deps.updateIntervalMs ?? 6 * 3_600_000));
+    }
+    for (const timer of timers)
+        timer.unref?.();
+    return () => {
+        stopped = true;
+        for (const timer of timers)
+            clearInterval(timer);
+    };
+}
+/** Wire the status to this install: its version, the configured web app port, and global fetch. */
+export async function startInstalledTuiStatus(callbacks) {
+    const [{ CONFIG }, { packageVersion }] = await Promise.all([
+        import("../../config.js"),
+        import("../../services/package-version.js"),
+    ]);
+    const host = CONFIG.webServerHost === "0.0.0.0" ? "127.0.0.1" : CONFIG.webServerHost;
+    return startTuiStatus({
+        ...callbacks,
+        currentVersion: packageVersion(),
+        healthUrl: `http://${host.includes(":") ? `[${host}]` : host}:${CONFIG.webServerPort}/api/health`,
+        fetch: globalThis.fetch.bind(globalThis),
+        checkUpdates: process.env.OMMS_DISABLE_UPDATE_CHECK !== "1",
+    });
+}

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

@@ -18,6 +18,15 @@ export interface WebAutostartOptions {
 }
 /** OpenCode's executable is not a JavaScript runtime. */
 export declare function resolveWebRuntime(execPath?: string, platform?: NodeJS.Platform): string | null;
+/** The package folder a written login item runs, read back from its command line. */
+export declare function itemPackageRoot(file: string): string | null;
+/**
+ * The newest OMMS copy among this one, the global install beside the runtime,
+ * and the copy the item already runs. A host starts OMMS from its own cache,
+ * which can be older than the global install; that copy must not downgrade
+ * the login item.
+ */
+export declare function preferredPackageRoot(candidates: readonly (string | null | undefined)[]): string | null;
 /** Read the login item's state without changing any system files. */
 export declare function webAutostartStatus(options?: WebAutostartOptions): WebAutostartStatus;
 /** Install or update only the fixed-name OMMS item. `start` launches it now. */

package/dist/services/web-autostart.js

@@ -6,6 +6,7 @@ import { basename, dirname, join, delimiter, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { CONFIG } from "../config.js";
 import { log } from "./logger.js";
+import { compareVersions } from "./version-compare.js";
 const MARKER = "OMMS login item";
 const NAME = "io.github.cmdaltctr.omms.web";
 function executable(name) {
@@ -69,6 +70,67 @@ function packageRoot() {
         dir = parent;
     }
 }
+function packageVersionAt(root) {
+    try {
+        const pkg = JSON.parse(readFileSync(join(root, "package.json"), "utf8"));
+        if (pkg.name !== "om-memory-system" || !existsSync(join(root, "dist", "cli", "index.js"))) {
+            return null;
+        }
+        return typeof pkg.version === "string" ? pkg.version : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** The package folder a written login item runs, read back from its command line. */
+export function itemPackageRoot(file) {
+    try {
+        const content = readFileSync(file, "utf8");
+        const match = /([^"<>\r\n]*?)[\\/]dist[\\/]cli[\\/]index\.js/.exec(content);
+        const path = match?.[1]?.replace(/^.*?<string>/, "").trim();
+        if (!path)
+            return null;
+        // Only plists escape XML. Decode ampersands last to preserve literal entity text.
+        return content.includes("<plist")
+            ? path
+                .replaceAll("&quot;", '"')
+                .replaceAll("&apos;", "'")
+                .replaceAll("&lt;", "<")
+                .replaceAll("&gt;", ">")
+                .replaceAll("&amp;", "&")
+            : path;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * The newest OMMS copy among this one, the global install beside the runtime,
+ * and the copy the item already runs. A host starts OMMS from its own cache,
+ * which can be older than the global install; that copy must not downgrade
+ * the login item.
+ */
+export function preferredPackageRoot(candidates) {
+    let best = null;
+    for (const root of candidates) {
+        if (!root)
+            continue;
+        const version = packageVersionAt(root);
+        if (!version || compareVersions(version, version) === null)
+            continue;
+        if (!best || (compareVersions(version, best.version) ?? 0) > 0)
+            best = { root, version };
+    }
+    return best?.root ?? null;
+}
+function globalPackageRoot(runtime, platform) {
+    if (!runtime)
+        return null;
+    const prefix = dirname(dirname(runtime));
+    return platform === "win32"
+        ? join(dirname(runtime), "node_modules", "om-memory-system")
+        : join(prefix, "lib", "node_modules", "om-memory-system");
+}
 function itemPath(home, platform) {
     if (platform === "darwin")
         return join(home, "Library", "LaunchAgents", `${NAME}.plist`);
@@ -83,7 +145,11 @@ function details(options) {
     const platform = options.platform ?? process.platform;
     const path = itemPath(home, platform);
     const runtime = options.runtime === undefined ? resolveWebRuntime() : options.runtime;
-    const root = options.packageRoot === undefined ? packageRoot() : options.packageRoot;
+    const own = options.packageRoot === undefined ? packageRoot() : options.packageRoot;
+    const current = path && existsSync(path) ? itemPackageRoot(path) : null;
+    const root = options.packageRoot === undefined
+        ? preferredPackageRoot([own, globalPackageRoot(runtime ?? null, platform), current])
+        : own;
     const supported = platform !== "linux" || (options.systemctlAvailable ?? Boolean(executable("systemctl")));
     return { home, platform, path, runtime, root, supported };
 }