@brutalsystems/muster 3.3.1 → 3.3.2

package/dist/reap.js

@@ -125,8 +125,10 @@ async function stopSession(home, socket, launchId) {
     });
     try {
         const entry = (await new Registry(home).all()).find((e) => e.launchId === launchId);
+        // By launch id: since --resume, the durable id may name a newer launch of
+        // the same session, which this check was not armed for.
         if (entry)
-            await muster.stop(entry.id);
+            await muster.stop(entry.launchId);
     }
     finally {
         await muster.close();

package/dist/registry.js

@@ -45,6 +45,21 @@ export class IdempotencyKeyReuse extends Error {
  */
 const UNOWNED_LOCK_MS = 60_000;
 let self;
+/** Statuses whose process is over: such an entry no longer holds its id. */
+const FINISHED = ["exited", "failed", "stopped"];
+/**
+ * The entry a durable id names. One id can have several since `--resume`: the
+ * launches that ran a session before, now finished, and the one running it
+ * now. The live one is meant, else the newest; two live ones cannot arise,
+ * because `update` refuses a second live holder of an id.
+ */
+export function currentEntry(entries) {
+    const live = entries.filter((e) => !FINISHED.includes(e.status));
+    if (live.length > 1)
+        throw new Error("Ambiguous durable id; update by launchId");
+    return (live[0] ??
+        [...entries].sort((a, b) => b.createdAt.localeCompare(a.createdAt))[0]);
+}
 export class Registry {
     home;
     lockWait;
@@ -300,16 +315,16 @@ export class Registry {
     async update(id, patch) {
         return this.transaction(async (entries) => {
             const byLaunch = entries.find((e) => e.launchId === id);
-            const durable = entries.filter((e) => e.id === id);
-            if (!byLaunch && durable.length > 1)
-                throw new Error("Ambiguous durable id; update by launchId");
-            const entry = byLaunch ?? durable[0];
+            const entry = byLaunch ?? currentEntry(entries.filter((e) => e.id === id));
             if (!entry)
                 throw new Error(`Unknown launch ${id}`);
             if ("requester" in patch)
                 throw new Error("requester is recorded once and cannot be updated");
             if (patch.id &&
-                entries.some((e) => e !== entry && e.runtime === entry.runtime && e.id === patch.id))
+                entries.some((e) => e !== entry &&
+                    e.runtime === entry.runtime &&
+                    e.id === patch.id &&
+                    !FINISHED.includes(e.status)))
                 throw new Error("Durable identity already registered");
             Object.assign(entry, patch);
             return structuredClone(entry);

package/dist/run.js

@@ -11,7 +11,7 @@ import { assertEnforcementMeetsMinimum, assertLevelWithinCeiling, assertMayAct,
 import { IdentityError, readIdentity, } from "./identity-store.js";
 import { resolveCredential } from "./identity-token.js";
 import { copyIdentity, identityEnv } from "./identity-copy.js";
-import { Registry } from "./registry.js";
+import { currentEntry, Registry } from "./registry.js";
 import { LaunchLog } from "./log.js";
 import { hosts, selectHost } from "./hosts/index.js";
 import { AGENTS } from "./agents.js";
@@ -1185,11 +1185,21 @@ export class Muster {
     }
     async find(id) {
         const all = await this.registry.all();
+        // A launch id names exactly one launch, so a caller that holds one (the
+        // reaper) can never reach a later launch of the same resumed session.
+        const launch = all.find((e) => e.launchId === id);
+        if (launch)
+            return launch;
         const exact = all.filter((e) => e.id === id);
         if (exact.length === 1)
             return exact[0];
-        if (exact.length > 1)
-            throw new Error(`Ambiguous durable id: ${exact.map((e) => e.runtime + ":" + e.id).join(", ")}`);
+        // The same session under two runtimes is ambiguous. Under one, it was
+        // resumed: the launch running it now, else the latest, is the one meant.
+        if (exact.length > 1) {
+            if (new Set(exact.map((e) => e.runtime)).size > 1)
+                throw new Error(`Ambiguous durable id: ${exact.map((e) => e.runtime + ":" + e.id).join(", ")}`);
+            return currentEntry(exact);
+        }
         const peers = all.filter((e) => e.kind === "session" && e.status === "running" && e.peer);
         const named = peers.map((e) => ({
             runtime: runtimeName(e.runtime),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brutalsystems/muster",
-  "version": "3.3.1",
+  "version": "3.3.2",
   "description": "Launch instructed, reachable local agent sessions",
   "type": "module",
   "engines": {