@mnemom/mnemom 0.17.2-next.6 → 0.17.2-next.8

package/dist/lib/update/worker.js

@@ -0,0 +1,104 @@
+/**
+ * The detached background worker (entry: src/update-worker.ts) and the real
+ * `RunDeps` wiring shared with `mnemom update`.
+ *
+ * The parent passes the settings it resolved (`<entry> <channel> <mode> <pid>`): the
+ * worker runs with stdio ignored, so re-resolving here would always see a
+ * non-TTY and force `off`.
+ */
+import { CLI_VERSION } from "../../version.js";
+import { getApiUrl } from "../config.js";
+import { isUpdateChannel, isUpdateMode } from "./decide.js";
+import { classifyInstall } from "./install-method.js";
+import { fetchChannelEntitlement, fetchDistTags } from "./registry.js";
+import { runUpdate } from "./run.js";
+import { acquireLock, loadUpdateState, saveUpdateState } from "./state.js";
+import { npmGlobalRoot, npmInstallGlobal } from "./system.js";
+export function parseWorkerArgs(args) {
+    const [entry, channel, mode, pid] = args;
+    if (!entry || !isUpdateChannel(channel) || !isUpdateMode(mode))
+        return null;
+    const parentPid = Number.parseInt(pid ?? "", 10);
+    return { entry, settings: { channel, mode }, parentPid: parentPid > 0 ? parentPid : undefined };
+}
+export const PARENT_POLL_MS = 5000;
+/** Give up waiting on a very long session; the next run picks the update up. */
+export const PARENT_WAIT_MAX_MS = 12 * 60 * 60 * 1000;
+/** `kill(pid, 0)` probes liveness without signalling. EPERM still means alive. */
+export function isAlive(pid, kill = (p, s) => void process.kill(p, s)) {
+    try {
+        kill(pid, 0);
+        return true;
+    }
+    catch (err) {
+        return err.code === "EPERM";
+    }
+}
+/** Resolve true once `pid` is gone, false if it outlives `maxMs`. */
+export async function waitForExit(pid, deps = {
+    alive: (p) => isAlive(p),
+    sleep: (ms) => new Promise((r) => setTimeout(r, ms)),
+    now: Date.now,
+}, maxMs = PARENT_WAIT_MAX_MS) {
+    if (pid === undefined)
+        return true;
+    const deadline = deps.now() + maxMs;
+    while (deps.alive(pid)) {
+        if (deps.now() >= deadline)
+            return false;
+        await deps.sleep(PARENT_POLL_MS);
+    }
+    return true;
+}
+export function realRunDeps(entry, credential) {
+    return {
+        current: CLI_VERSION,
+        now: Date.now,
+        loadState: () => loadUpdateState(),
+        saveState: (patch) => saveUpdateState(patch),
+        fetchDistTags: () => fetchDistTags(fetch),
+        fetchEntitlement: async () => fetchChannelEntitlement(fetch, getApiUrl(), await credential()),
+        installMethod: async () => classifyInstall(entry, await npmGlobalRoot()),
+        install: (version) => npmInstallGlobal(version),
+    };
+}
+/**
+ * The install lock is held ONLY around `npm install` — never while waiting for
+ * the parent to exit (a 12h wait would look stale at LOCK_STALE_MS and let a
+ * second installer in). Lock busy → skip this pass; the other installer wins.
+ */
+export function lockedInstall(parentPid, deps) {
+    let release = null;
+    return {
+        beforeInstall: async () => {
+            if (!(await deps.waitForExit(parentPid)))
+                return false;
+            release = deps.acquireLock();
+            return release !== null;
+        },
+        install: async (version) => {
+            try {
+                return await deps.install(version);
+            }
+            finally {
+                release?.();
+            }
+        },
+    };
+}
+export async function runWorker(args, run) {
+    const parsed = parseWorkerArgs(args);
+    if (!parsed)
+        return "bad-args";
+    return run(parsed);
+}
+export function defaultWorkerRun(credential) {
+    return ({ entry, settings, parentPid }) => runUpdate({
+        ...realRunDeps(entry, credential),
+        ...lockedInstall(parentPid, {
+            waitForExit: (pid) => waitForExit(pid),
+            acquireLock: () => acquireLock(),
+            install: (version) => npmInstallGlobal(version),
+        }),
+    }, settings);
+}

package/dist/lib/version-gate.d.ts

@@ -28,8 +28,9 @@ export declare function isBelowVersion(current: string, floor: string): boolean;
  *
  * @param exit  injectable for tests; defaults to process.exit
  * @param write injectable for tests; defaults to process.stderr.write
+ * @param upgrade injectable for tests; defaults to the auto-update floor upgrade
  */
-export declare function enforceMinCliVersion(response: Pick<Response, "headers">, exit?: (code: number) => never, write?: (chunk: string) => void): void;
+export declare function enforceMinCliVersion(response: Pick<Response, "headers">, exit?: (code: number) => never, write?: (chunk: string) => void, upgrade?: (floor: string) => boolean): void;
 /**
  * Drop-in wrapper around global fetch for Mnemom API calls: issues the request,
  * enforces the advertised minimum CLI version on the response, then returns it.

package/dist/lib/version-gate.js

@@ -14,6 +14,7 @@
  * wrong outcome.
  */
 import { CLI_VERSION } from "../version.js";
+import { defaultFloorUpgradeDeps, upgradeToFloor } from "./update/min-version.js";
 const MIN_CLI_HEADER = "x-mnemom-min-cli";
 /**
  * Compare dotted numeric versions. Returns true iff `current` is strictly below
@@ -53,8 +54,9 @@ let exited = false;
  *
  * @param exit  injectable for tests; defaults to process.exit
  * @param write injectable for tests; defaults to process.stderr.write
+ * @param upgrade injectable for tests; defaults to the auto-update floor upgrade
  */
-export function enforceMinCliVersion(response, exit = process.exit, write = (chunk) => void process.stderr.write(chunk)) {
+export function enforceMinCliVersion(response, exit = process.exit, write = (chunk) => void process.stderr.write(chunk), upgrade = (floor) => upgradeToFloor(floor, defaultFloorUpgradeDeps())) {
     // Defensive: some callers/tests provide a Response-like object without a real
     // Headers instance. Treat a missing/incompatible headers bag as "no floor".
     const headers = response?.headers;
@@ -66,6 +68,12 @@ export function enforceMinCliVersion(response, exit = process.exit, write = (chu
     if (exited)
         return;
     exited = true;
+    // Auto-update on + self-updatable install: fix it now, then ask for a re-run
+    // (this process is still the old code).
+    if (upgrade(floor)) {
+        write(`\n✓ Updated the Mnemom CLI (was v${CLI_VERSION}; server minimum v${floor}). Re-run your command.\n\n`);
+        exit(1);
+    }
     write(`\n✖ Your Mnemom CLI (v${CLI_VERSION}) is too old for this server (minimum v${floor}).\n` +
         `  Old CLIs can silently drop newer request fields — e.g. \`--org\` on \`mnemom agent claim\`.\n\n` +
         `  Upgrade:  npm i -g @mnemom/mnemom@latest\n\n`);

package/dist/update-worker.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Detached auto-update worker — spawned by lib/update/startup.ts with
+ * `<entry> <channel> <mode> <parent-pid>`. All logic lives in lib/update/worker.ts; this
+ * driver only wires the real process in and swallows every error.
+ */
+export {};

package/dist/update-worker.js

@@ -0,0 +1,8 @@
+/**
+ * Detached auto-update worker — spawned by lib/update/startup.ts with
+ * `<entry> <channel> <mode> <parent-pid>`. All logic lives in lib/update/worker.ts; this
+ * driver only wires the real process in and swallows every error.
+ */
+import { backgroundCredential } from "./lib/update/system.js";
+import { defaultWorkerRun, runWorker } from "./lib/update/worker.js";
+runWorker(process.argv.slice(2), defaultWorkerRun(() => backgroundCredential())).catch(() => { });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mnemom/mnemom",
-  "version": "0.17.2-next.6",
+  "version": "0.17.2-next.8",
   "description": "Transparent AI agent tracing",
   "type": "module",
   "bin": {