@proagentstore/cli 0.4.91 → 0.4.92

package/dist/index.js

@@ -1716,6 +1716,152 @@ function mayAutomaticallyRestart(input) {
   return input.authoritative && input.enabled && input.workObserved && input.busy.length === 0;
 }
 
+// src/commands/runner/auto-update-controller.ts
+var AutomaticUpdateController = class {
+  constructor(deps) {
+    this.deps = deps;
+    this.setTimer = deps.setTimer ?? ((fn, ms) => setTimeout(fn, ms));
+    this.clearTimer = deps.clearTimer ?? ((timer) => clearTimeout(timer));
+  }
+  deps;
+  timer = null;
+  checking = false;
+  waiting = false;
+  installing = false;
+  failures = 0;
+  setTimer;
+  clearTimer;
+  /** Called only for a true policy transition. `keep` deliberately leaves a due heartbeat timer alone. */
+  onPolicy(action) {
+    if (action === "cancel") return this.cancel();
+    if (action === "start") this.schedule(true);
+  }
+  /** Testable immediate entry point; production reaches it through the scheduled timer. */
+  async runNow() {
+    const current = this.deps.policy();
+    if (this.checking || this.waiting || !current.authoritative || !current.value.autoUpdate) return;
+    this.checking = true;
+    try {
+      if (!await this.deps.refreshPolicy() || !this.enabled()) {
+        this.deps.status("offline", { reason: "The owner policy could not be refreshed; automatic update is deferred." });
+        return;
+      }
+      await this.decide(false);
+    } catch (error) {
+      this.fail(error);
+    } finally {
+      this.checking = false;
+    }
+  }
+  /** Explicit remote updates and unattended checks share this single flight. */
+  async installManually(plan) {
+    return this.install(plan, false);
+  }
+  enabled() {
+    const { value, authoritative } = this.deps.policy();
+    return authoritative && value.autoUpdate;
+  }
+  schedule(initial = false) {
+    if (!this.enabled() || this.timer || this.waiting) return;
+    const delay = initial ? Math.round(5e3 + (this.deps.random ?? Math.random)() * 25e3) : nextAutoUpdateDelayMs(this.failures, this.deps.random);
+    this.timer = this.setTimer(() => {
+      this.timer = null;
+      void this.runNow();
+    }, delay);
+    this.timer.unref?.();
+  }
+  cancel() {
+    if (this.timer) this.clearTimer(this.timer);
+    this.timer = null;
+  }
+  fail(error) {
+    this.failures++;
+    this.deps.status("failure", { reason: error instanceof Error ? error.message : String(error) });
+    this.schedule();
+  }
+  async decide(deferred) {
+    const facts = await this.deps.facts();
+    if (!this.enabled()) return;
+    const plan = this.deps.plan(facts);
+    if (plan.action === "up-to-date") {
+      this.failures = 0;
+      this.deps.status("verified-success", { latestVersion: facts.latest ?? void 0, reason: void 0 });
+      this.schedule();
+      return;
+    }
+    if (plan.action === "refused") {
+      this.deps.status("unsupported", { reason: plan.reason });
+      this.schedule();
+      return;
+    }
+    if (plan.action === "wait") {
+      this.deps.status("waiting-for-idle", { latestVersion: plan.latest, reason: void 0 });
+      this.defer();
+      return;
+    }
+    this.deps.status("running", { latestVersion: plan.latest, reason: void 0 });
+    const restarted = await this.install(plan, true);
+    if (restarted) this.deps.status("restarting", { latestVersion: plan.latest, reason: void 0 });
+    else if (!deferred) this.defer(plan.latest);
+  }
+  defer(latest) {
+    if (this.waiting) return;
+    this.waiting = true;
+    this.timer = this.setTimer(() => {
+      this.timer = null;
+      void (async () => {
+        this.waiting = false;
+        try {
+          if (!await this.deps.refreshPolicy() || !this.enabled()) {
+            this.deps.status("offline", { reason: "The owner policy could not be refreshed; automatic update is deferred." });
+            return;
+          }
+          await this.decide(true);
+        } catch (error) {
+          this.fail(error);
+        }
+      })();
+    }, 15e3);
+    this.timer.unref?.();
+    this.deps.status("waiting-for-idle", latest ? { latestVersion: latest } : void 0);
+  }
+  async install(plan, automatic) {
+    if (this.installing) return false;
+    this.installing = true;
+    try {
+      return await this.deps.installAndRestart(plan, automatic);
+    } finally {
+      this.installing = false;
+    }
+  }
+};
+var RelayMutationAdmission = class {
+  draining = false;
+  inFlight = 0;
+  waiters = [];
+  begin() {
+    if (this.draining) return null;
+    this.inFlight++;
+    let released = false;
+    return () => {
+      if (released) return;
+      released = true;
+      this.inFlight--;
+      if (this.inFlight === 0) {
+        for (const wake of this.waiters.splice(0)) wake();
+      }
+    };
+  }
+  async drain() {
+    this.draining = true;
+    if (this.inFlight === 0) return;
+    await new Promise((resolve5) => this.waiters.push(resolve5));
+  }
+  resume() {
+    this.draining = false;
+  }
+};
+
 // src/commands/runner/relay.ts
 var MEMBERSHIP_SYNC_PATH = "/pags/membership/sync";
 var CLI_CONTROL_PATHS = /* @__PURE__ */ new Set([MEMBERSHIP_SYNC_PATH, RUNNER_UPDATE_PATH]);
@@ -1839,7 +1985,7 @@ async function connectViaRelay(instanceIds, localUrl, runnerToken, opts, force =
   };
   let updateInstallInFlight = false;
   let installedPendingRestart = null;
-  let automaticRestartDraining = false;
+  const relayMutationAdmission = new RelayMutationAdmission();
   const installAndRestart = async (plan, automatic = false) => {
     if (updateInstallInFlight) return false;
     updateInstallInFlight = true;
@@ -1858,17 +2004,17 @@ async function connectViaRelay(instanceIds, localUrl, runnerToken, opts, force =
       }
     }
     if (automatic) {
-      automaticRestartDraining = true;
+      await relayMutationAdmission.drain();
       await new Promise((resolve5) => setTimeout(resolve5, 500));
       if (!await refreshAutomaticPolicy() || !autoUpdatePolicy.autoUpdate) {
-        automaticRestartDraining = false;
+        relayMutationAdmission.resume();
         updateInstallInFlight = false;
         return false;
       }
     }
     const finalFacts = await updateFacts();
     if (finalFacts.busy.length || automatic && !mayAutomaticallyRestart({ authoritative: autoUpdatePolicyAuthoritative, enabled: autoUpdatePolicy.autoUpdate, workObserved: !finalFacts.busy.includes("runner-work-observation-unavailable"), busy: finalFacts.busy })) {
-      automaticRestartDraining = false;
+      relayMutationAdmission.resume();
       updateInstallInFlight = false;
       return false;
     }
@@ -1985,6 +2131,17 @@ async function connectViaRelay(instanceIds, localUrl, runnerToken, opts, force =
     }, delay);
     automaticTimer.unref();
   };
+  const automaticUpdateController = new AutomaticUpdateController({
+    policy: () => ({ value: autoUpdatePolicy, authoritative: autoUpdatePolicyAuthoritative }),
+    refreshPolicy: refreshAutomaticPolicy,
+    facts: updateFacts,
+    plan: planRunnerUpdate,
+    // This bridge is deliberately the same function used by explicit runner_update. It owns npm,
+    // a fresh authoritative policy, the mutation drain, final local-work observation and restart.
+    installAndRestart,
+    status: saveAutoUpdateStatus
+  });
+  scheduleAutomaticUpdate = (initial = false, cancel = false) => automaticUpdateController.onPolicy(cancel ? "cancel" : initial ? "start" : "keep");
   if (autoUpdatePolicyAuthoritative && autoUpdatePolicy.autoUpdate) scheduleAutomaticUpdate(true);
   const answerUpdate = async (body) => {
     const dryRun = body?.dryRun === true;
@@ -1995,7 +2152,7 @@ async function connectViaRelay(instanceIds, localUrl, runnerToken, opts, force =
       return { status: 200, result: { ...plan, detail: "Restarts itself as soon as these engines finish their turns \u2014 no run is cut off." } };
     }
     try {
-      if (!await installAndRestart(plan)) return { status: 409, result: { error: "A runner update is already installing or restarting." } };
+      if (!await automaticUpdateController.installManually(plan)) return { status: 409, result: { error: "A runner update is already installing or restarting." } };
     } catch (e) {
       return { status: 500, result: { error: `npm could not install ${plan.latest}: ${e instanceof Error ? e.message : String(e)}` } };
     }
@@ -2064,7 +2221,7 @@ async function connectViaRelay(instanceIds, localUrl, runnerToken, opts, force =
         runnerNode,
         // The final automatic-update drain is an admission gate, not merely another poll:
         // command work starts only when the old runner is still permitted to serve it.
-        () => !automaticRestartDraining
+        () => relayMutationAdmission.begin()
       )
     );
     if (label) writeLine(`Attached agent: ${label}`);
@@ -2208,7 +2365,7 @@ async function readSessionResources(localUrl, runnerToken) {
 }
 var RTT_PROBE_PREFIX = "rtt:";
 var RTT_ECHO_PREFIX = "rtt-echo:";
-function openRelaySocket(instanceId, wsBase, mintToken, localUrl, runnerToken, force = false, onConflict, onOpen, onControl, runnerNode = hostname3(), admitMutation = () => true) {
+function openRelaySocket(instanceId, wsBase, mintToken, localUrl, runnerToken, force = false, onConflict, onOpen, onControl, runnerNode = hostname3(), beginMutation = () => () => void 0) {
   let backoffMs = 1e3;
   let reconnecting = false;
   let closed = false;
@@ -2276,7 +2433,8 @@ function openRelaySocket(instanceId, wsBase, mintToken, localUrl, runnerToken, f
         return;
       }
       const method = (cmd.method || "POST").toUpperCase();
-      if (method !== "GET" && method !== "HEAD" && !admitMutation()) {
+      const releaseMutation = method !== "GET" && method !== "HEAD" ? beginMutation() : null;
+      if (method !== "GET" && method !== "HEAD" && !releaseMutation) {
         try {
           ws.send(JSON.stringify({ id: cmd.id, status: 503, result: { error: "Runner is draining for a safe automatic update; retry shortly." } }));
         } catch {
@@ -2310,6 +2468,8 @@ function openRelaySocket(instanceId, wsBase, mintToken, localUrl, runnerToken, f
           ws.send(JSON.stringify({ id: cmd.id, status: 500, error: err instanceof Error ? err.message : String(err) }));
         } catch {
         }
+      } finally {
+        releaseMutation?.();
       }
     };
     ws.onclose = (ev) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@proagentstore/cli",
-	"version": "0.4.91",
+	"version": "0.4.92",
   "description": "CLI for creating, publishing, and running ProAgentStore agents",
   "license": "MIT",
   "type": "module",