@proagentstore/cli 0.4.94 → 0.4.95

package/dist/browser-runner/coding/runtime.js

@@ -21,9 +21,9 @@ export class CodingRuntime {
      * answer rather than restarting across work whose state it cannot prove is idle.
      */
     liveWork() {
-        return [...this.sessions.values()].flatMap((s) => {
+        return [...this.sessions.entries()].flatMap(([sessionId, s]) => {
             const engine = s.clientType ?? "";
-            const label = engine === "claude" ? "a Claude coding session (resumes after a restart)" : `a ${engine || "coding"} turn (lost on a restart)`;
+            const consequence = engine === "claude" ? "Claude conversation resumes after a restart" : `${engine || "coding"} turn is lost on a restart`;
             try {
                 // `alive: false` is an observed inactive session. Any other answer (including a
                 // malformed older implementation) is unknown and must fail closed below.
@@ -34,13 +34,13 @@ export class CodingRuntime {
                 if (alive === true && state === "idle")
                     return [];
                 if (alive === true && (state === "thinking" || state === "responding"))
-                    return [label];
+                    return [`coding session ${sessionId} (${state}): ${consequence}`];
                 // An unrecognised `alive`/`runState` pair is not proof that an engine is idle.
-                return [label];
+                return [`coding session ${sessionId} (${typeof state === "string" ? state : "unknown"}): ${consequence}`];
             }
             catch {
                 // Do not turn a failed state probe into permission to restart the machine.
-                return [label];
+                return [`coding session ${sessionId} (unknown): ${consequence}`];
             }
         });
     }

package/dist/browser-runner/local-artifact/runtime.js

@@ -401,6 +401,19 @@ export class LocalArtifactRuntime {
             return;
         if (run.timer)
             clearTimeout(run.timer);
+        // An uploaded source is a bounded, per-run transfer, not runner state.  The durable
+        // result deliberately contains only its handle and hash; remove the materialized text as
+        // soon as the engine no longer needs it instead of retaining it with generic scratch data.
+        // `end` is the one terminal path (completion, refusal, timeout, cancellation and launch
+        // failure), so a source cannot linger just because a particular failure path was missed.
+        if (run.envelope.uploadedSources?.length) {
+            try {
+                rmSync(join(run.scratch, "sources"), { recursive: true, force: true });
+            }
+            catch { /* best-effort cleanup */ }
+            for (const source of run.envelope.uploadedSources)
+                source.text = "";
+        }
         run.state = "ended";
         run.endedAt = this.now();
         run.result = {

package/dist/index.js

@@ -1269,6 +1269,19 @@ function restarterFrom(env) {
 function supervisorNote(restarter) {
   return restarter === "pags-up-child-only" ? "The `pags up` on this machine predates supervisor restarts (#860): the runner comes back on the new release, but the `pags up` window keeps running its own older code until it is restarted there once." : null;
 }
+var MAX_DEFERRED_UPDATE_LEASE_MS = 5 * 6e4;
+function deferredUpdateLease(value, now = Date.now()) {
+  if (!value || typeof value !== "object") return null;
+  const raw = value;
+  const operationId = typeof raw.operationId === "string" ? raw.operationId.trim() : "";
+  const expiresAt = typeof raw.deferUntil === "number" ? raw.deferUntil : NaN;
+  if (!operationId || operationId.length > 128 || !Number.isFinite(expiresAt)) return null;
+  if (expiresAt <= now || expiresAt > now + MAX_DEFERRED_UPDATE_LEASE_MS) return null;
+  return { operationId, expiresAt };
+}
+function deferredUpdateLeaseActive(lease, now = Date.now()) {
+  return now < lease.expiresAt;
+}
 function leaveForRestart(restarter, deps = { spawn: spawn3, exit: (code) => process.exit(code) }) {
   if (restarter === "command") {
     deps.spawn(process.env[RESTART_COMMAND_ENV], { shell: true, detached: true, stdio: "ignore", env: process.env }).unref();
@@ -1864,6 +1877,29 @@ var RelayMutationAdmission = class {
 
 // src/commands/runner/relay.ts
 var MEMBERSHIP_SYNC_PATH = "/pags/membership/sync";
+function observedRunnerWork(observation) {
+  const sessions = observation.sessions;
+  const work = observation.work;
+  if (!Array.isArray(sessions) || !work || typeof work !== "object") return ["runner-work-observation-unavailable"];
+  const codingTurns = typeof work.codingTurns === "number" && Number.isInteger(work.codingTurns) && work.codingTurns >= 0 ? work.codingTurns : null;
+  const localRuns = typeof work.localRuns === "number" && Number.isInteger(work.localRuns) && work.localRuns >= 0 ? work.localRuns : null;
+  const detail = Array.isArray(work.detail) && work.detail.every((item) => typeof item === "string") ? work.detail : null;
+  if (codingTurns === null || localRuns === null || detail === null) return ["runner-work-observation-unavailable"];
+  const activeCoding = sessions.flatMap((session) => {
+    if (session?.alive === false) return [];
+    const id = typeof session?.sessionId === "string" && session.sessionId ? session.sessionId : "unidentified-session";
+    const state = typeof session?.runState === "string" && session.runState ? session.runState : "unknown";
+    if (session?.alive === true && state === "idle") return [];
+    return [`coding session ${id} (${state})`];
+  });
+  const unmatchedCodingTurns = Math.max(0, codingTurns - activeCoding.length);
+  const localDetail = detail.slice(codingTurns);
+  return [
+    ...activeCoding,
+    ...Array.from({ length: unmatchedCodingTurns }, (_v, i) => `coding-turn-unmatched-${i + 1}`),
+    ...Array.from({ length: localRuns }, (_v, i) => localDetail[i] || `local-run-${i + 1}`)
+  ];
+}
 var CLI_CONTROL_PATHS = /* @__PURE__ */ new Set([MEMBERSHIP_SYNC_PATH, RUNNER_UPDATE_PATH]);
 async function connectViaRelay(instanceIds, localUrl, runnerToken, opts, force = false, watchInstances = false) {
   const apiBase = pagsApiBase(opts.apiBase).replace(/^http/, "ws");
@@ -1967,14 +2003,7 @@ async function connectViaRelay(instanceIds, localUrl, runnerToken, opts, force =
       }),
       requestRunner("GET", "/health", { url: localUrl, token: runnerToken, instanceId: instanceIds[0] })
     ]);
-    const observationsUnavailable = sessionsResult.status !== "fulfilled" || healthResult.status !== "fulfilled" || !healthResult.value.work;
-    const sessions = sessionsResult.status === "fulfilled" ? sessionsResult.value : { sessions: [] };
-    const health = healthResult.status === "fulfilled" ? healthResult.value : {};
-    const activeCoding = (sessions.sessions ?? []).filter((s) => s.alive !== false && (s.alive !== true || !["idle", "thinking", "responding"].includes(s.runState ?? "") || s.runState !== "idle")).map((s) => s.sessionId || "coding-session-state-unavailable");
-    const localRuns = health.work?.localRuns ?? 0;
-    const codingTurns = health.work?.codingTurns ?? 0;
-    const unmatchedCodingTurns = Math.max(0, codingTurns - activeCoding.length);
-    const localDetail = health.work?.detail?.slice(codingTurns) ?? [];
+    const busy = sessionsResult.status === "fulfilled" && healthResult.status === "fulfilled" ? observedRunnerWork({ sessions: sessionsResult.value.sessions, work: healthResult.value.work }) : ["runner-work-observation-unavailable"];
     return {
       current: CLI_VERSION,
       latest: await latestPublishedVersion(),
@@ -1982,14 +2011,14 @@ async function connectViaRelay(instanceIds, localUrl, runnerToken, opts, force =
       restarter: restarterFrom(process.env),
       // A restart ends browser/application work too. Give these durable names to the same
       // planner so neither manual nor automatic update can mistake them for an idle machine.
-      busy: observationsUnavailable ? ["runner-work-observation-unavailable"] : [...activeCoding, ...Array.from({ length: unmatchedCodingTurns }, (_v, i) => `coding-turn-unmatched-${i + 1}`), ...Array.from({ length: localRuns }, (_v, i) => localDetail[i] || `local-run-${i + 1}`)]
+      busy
     };
   };
   let updateInstallInFlight = false;
   let installedPendingRestart = null;
   const relayMutationAdmission = new RelayMutationAdmission();
-  const installAndRestart = async (plan, automatic = false) => {
-    if (updateInstallInFlight) return false;
+  const installAndRestart = async (plan, automatic = false, lease) => {
+    if (updateInstallInFlight || lease && !deferredUpdateLeaseActive(lease)) return false;
     updateInstallInFlight = true;
     if (automatic && (!await refreshAutomaticPolicy() || !autoUpdatePolicy.autoUpdate)) {
       updateInstallInFlight = false;
@@ -2005,9 +2034,14 @@ async function connectViaRelay(instanceIds, localUrl, runnerToken, opts, force =
         throw error;
       }
     }
+    await relayMutationAdmission.drain();
+    await new Promise((resolve5) => setTimeout(resolve5, 500));
+    if (lease && !deferredUpdateLeaseActive(lease)) {
+      relayMutationAdmission.resume();
+      updateInstallInFlight = false;
+      return false;
+    }
     if (automatic) {
-      await relayMutationAdmission.drain();
-      await new Promise((resolve5) => setTimeout(resolve5, 500));
       if (!await refreshAutomaticPolicy() || !autoUpdatePolicy.autoUpdate) {
         relayMutationAdmission.resume();
         updateInstallInFlight = false;
@@ -2022,15 +2056,22 @@ async function connectViaRelay(instanceIds, localUrl, runnerToken, opts, force =
     }
     writeLine(`Installed ${plan.latest} \u2014 restarting; every agent re-attaches on the way back up.`);
     for (const id of [...attached.keys()]) detach(id);
-    leaveForRestart(plan.restarter);
     return true;
   };
   let updateWaiting = false;
-  const updateWhenIdle = (automatic = false) => {
-    if (updateWaiting) return;
+  let deferredManualLease = null;
+  const updateWhenIdle = (automatic = false, lease) => {
+    if (updateWaiting || !automatic && !lease) return false;
     updateWaiting = true;
-    const until = Date.now() + 60 * 6e4;
+    if (!automatic) deferredManualLease = lease;
+    const until = automatic ? Date.now() + 60 * 6e4 : lease.expiresAt;
     const tick = () => setTimeout(async () => {
+      if (!automatic && (!deferredManualLease || !deferredUpdateLeaseActive(deferredManualLease))) {
+        writeLine("runner_update: the deferred operation lease expired; no delayed restart was performed.");
+        deferredManualLease = null;
+        updateWaiting = false;
+        return;
+      }
       if (automatic && (!await refreshAutomaticPolicy() || !autoUpdatePolicy.autoUpdate)) {
         saveAutoUpdateStatus("offline", { reason: "The owner policy could not be refreshed; automatic update is deferred." });
         updateWaiting = false;
@@ -2043,24 +2084,30 @@ async function connectViaRelay(instanceIds, localUrl, runnerToken, opts, force =
           return;
         }
         if (automatic) saveAutoUpdateStatus("running", { latestVersion: plan.latest, reason: void 0 });
-        const installed = await installAndRestart(plan, automatic).catch((e) => {
+        const installed = await installAndRestart(plan, automatic, automatic ? void 0 : deferredManualLease ?? void 0).catch((e) => {
           if (automatic) saveAutoUpdateStatus("failure", { reason: e instanceof Error ? e.message : String(e) });
           writeError(`runner_update: install failed \u2014 ${e instanceof Error ? e.message : String(e)}`);
           return false;
         });
-        if (automatic && !installed && Date.now() < until) {
+        if (!installed && Date.now() < until) {
           saveAutoUpdateStatus("waiting-for-idle", { latestVersion: plan.latest });
           tick();
-        } else updateWaiting = false;
+        } else {
+          deferredManualLease = null;
+          updateWaiting = false;
+          if (installed) leaveForRestart(plan.restarter);
+        }
       } else if (plan.action === "wait" && Date.now() < until) {
         if (automatic) saveAutoUpdateStatus("waiting-for-idle", { latestVersion: plan.latest, reason: void 0 });
         tick();
       } else {
         if (automatic && plan.action === "refused") saveAutoUpdateStatus("unsupported", { reason: plan.reason });
+        deferredManualLease = null;
         updateWaiting = false;
       }
     }, 15e3).unref();
     tick();
+    return true;
   };
   let automaticTimer = null;
   let automaticChecking = false;
@@ -2140,7 +2187,11 @@ async function connectViaRelay(instanceIds, localUrl, runnerToken, opts, force =
     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,
+    installAndRestart: async (plan, automatic) => {
+      const installed = await installAndRestart(plan, automatic);
+      if (installed) setTimeout(() => leaveForRestart(plan.restarter), 0).unref();
+      return installed;
+    },
     status: saveAutoUpdateStatus
   });
   scheduleAutomaticUpdate = (initial = false, cancel = false) => automaticUpdateController.onPolicy(cancel ? "cancel" : initial ? "start" : "keep");
@@ -2150,15 +2201,18 @@ async function connectViaRelay(instanceIds, localUrl, runnerToken, opts, force =
     const plan = planRunnerUpdate(await updateFacts());
     if (dryRun || plan.action === "up-to-date" || plan.action === "refused") return { status: 200, result: { ...plan, dryRun } };
     if (plan.action === "wait") {
-      updateWhenIdle();
-      return { status: 200, result: { ...plan, detail: "Restarts itself as soon as these engines finish their turns \u2014 no run is cut off." } };
+      const lease = deferredUpdateLease(body);
+      if (!lease) return { status: 400, result: { error: "A busy runner_update needs a current operation lease; no delayed restart was scheduled." } };
+      if (!updateWhenIdle(false, lease)) return { status: 409, result: { error: "A runner update is already waiting for active work to finish." } };
+      return { status: 200, result: { ...plan, operationId: lease.operationId, deferredUntil: lease.expiresAt, detail: "This operation may restart only before its recorded lease expires; no delayed restart survives an expired or terminal operation." } };
     }
     try {
-      if (!await automaticUpdateController.installManually(plan)) return { status: 409, result: { error: "A runner update is already installing or restarting." } };
+      if (!await installAndRestart(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)}` } };
     }
     const supervisor = supervisorNote(plan.restarter);
+    setTimeout(() => leaveForRestart(plan.restarter), 25).unref();
     return { status: 200, result: { action: "restarting", current: plan.current, latest: plan.latest, restartedBy: plan.restarter, ...supervisor ? { supervisor } : {} } };
   };
   const answerControl = async (path, body) => {

package/package.json

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