om-memory-system 5.7.0-next.218 → 5.9.0

package/dist/services/web-update.js

@@ -9,6 +9,8 @@ export const UPDATE_CHECK_INTERVAL_MS = 10 * 60 * 1000;
 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;
+/** An automatic start waits this long after a failed automatic install. */
+export const AUTO_RETRY_AFTER_MS = 30 * 60 * 1000;
 /** Only a plain release reaches the npm arguments; the value comes from the registry. */
 const PLAIN_VERSION = /^\d+\.\d+\.\d+$/;
 /** Enough of npm's error stream to find a code; the rest is dropped. */
@@ -29,6 +31,8 @@ export class WebUpdate {
     started = false;
     lastCheck = -Infinity;
     checking = null;
+    autoRetryAt = -Infinity;
+    autoAttempt = false;
     constructor(deps) {
         this.deps = deps;
     }
@@ -55,6 +59,25 @@ export class WebUpdate {
             return;
         }
         this.available = availableUpdate(this.deps.version, latest);
+        this.maybeAutoInstall();
+    }
+    /** Start the install the Update button starts, once a check found a release. */
+    maybeAutoInstall() {
+        if (this.state === "installing" || this.state === "restarting")
+            return;
+        if (!this.available)
+            return;
+        if (this.deps.now() < this.autoRetryAt)
+            return;
+        // A check can finish while a Stop or Restart runs; the manual route has the same gate.
+        if (this.deps.autoBlocked?.())
+            return;
+        if (!this.canInstall())
+            return;
+        if (this.requestInstall() !== "accepted")
+            return;
+        this.autoAttempt = true;
+        this.deps.log("Web app auto-update started", { from: this.deps.version, to: this.available });
     }
     status() {
         // An open page polls the status, so a release shows within about a minute.
@@ -78,6 +101,7 @@ export class WebUpdate {
             return "no-update";
         if (!this.canInstall())
             return "cannot-install";
+        this.autoAttempt = false;
         this.state = "installing";
         this.code = null;
         void this.install(this.available);
@@ -96,6 +120,9 @@ export class WebUpdate {
         const fail = (code, exitCode) => {
             this.state = "failed";
             this.code = code;
+            // Only an automatic start waits before trying again; the button always works.
+            if (this.autoAttempt)
+                this.autoRetryAt = this.deps.now() + AUTO_RETRY_AFTER_MS;
             record("failed", code, exitCode);
         };
         const { code, exitCode } = await runGlobalInstall(this.deps, target);

package/dist/v2/plugin.js

@@ -1,8 +1,64 @@
+import { fileURLToPath } from "node:url";
 import { OmmsPlugin } from "../index.js";
 import { loadOpencodeProvider } from "../adapters/opencode/opencode-provider-loader.js";
 import { registerV2Adapter } from "./adapter.js";
 import { createV2MemoryBridge } from "./memory-bridge.js";
 import { createLegacyClient } from "./legacy-client.js";
+/**
+ * Remove old OMMS copies from the OpenCode cache. It runs in the background and
+ * is not awaited, so a slow or failing clean-up never delays or breaks setup.
+ * `OMMS_DISABLE_UPDATE_CHECK` does not stop it: removing old copies saves disk
+ * space and installs nothing. It keeps the copy that `~/.omms/runtime.json` names.
+ */
+function startCacheCleanup() {
+    void (async () => {
+        const modulePath = fileURLToPath(import.meta.url);
+        const [{ installedFromNpm }, { pruneOldCacheCopies }, { readRuntimeRecord }, { ommsDir }, { packageVersion }, { log },] = await Promise.all([
+            import("../services/host-self-update.js"),
+            import("../services/host-copies.js"),
+            import("../services/runtime-record.js"),
+            import("../services/runtime-handoff.js"),
+            import("../services/package-version.js"),
+            import("../services/logger.js"),
+        ]);
+        if (!installedFromNpm(modulePath))
+            return;
+        const recorded = readRuntimeRecord(ommsDir());
+        await pruneOldCacheCopies({
+            modulePath,
+            runningVersion: packageVersion(),
+            keepRoots: recorded ? [recorded.root] : [],
+            now: Date.now(),
+            log: (message, data) => log(message, data),
+        });
+    })().catch(() => { });
+}
+let serviceUpdateStarted = false;
+/**
+ * Check npm for a newer OMMS from the background service too, so OpenCode
+ * without a TUI (OpenChamber, `opencode serve`) also updates. Once per
+ * process: setup can run for each project. Not awaited; a failure is ignored.
+ */
+function startServiceSelfUpdate() {
+    if (serviceUpdateStarted)
+        return;
+    serviceUpdateStarted = true;
+    void (async () => {
+        const modulePath = fileURLToPath(import.meta.url);
+        const [{ opencodeSelfUpdateDeps, startOpencodeServiceSelfUpdate }, { startHostSelfUpdate }, { packageVersion }, { log },] = await Promise.all([
+            import("../adapters/opencode/self-update.js"),
+            import("../services/host-self-update.js"),
+            import("../services/package-version.js"),
+            import("../services/logger.js"),
+        ]);
+        const deps = opencodeSelfUpdateDeps({
+            modulePath,
+            currentVersion: packageVersion(),
+            log: (message, data) => log(message, data),
+        });
+        startOpencodeServiceSelfUpdate({ run: () => startHostSelfUpdate(deps) });
+    })().catch(() => { });
+}
 const OmmsPluginV2 = {
     id: "omms",
     async setup(ctx) {
@@ -18,7 +74,10 @@ const OmmsPluginV2 = {
         // context. Route internal structured-output calls through the adapter.
         const { setV2Client } = await loadOpencodeProvider();
         setV2Client(legacyClient);
-        return registerV2Adapter(ctx, legacy, createV2MemoryBridge(ctx.location.directory));
+        const adapter = await registerV2Adapter(ctx, legacy, createV2MemoryBridge(ctx.location.directory));
+        startCacheCleanup();
+        startServiceSelfUpdate();
+        return adapter;
     },
 };
 export default OmmsPluginV2;