@proagentstore/cli 0.4.93 → 0.4.95

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

@@ -13,16 +13,35 @@ export class CodingRuntime {
     reposBaseDir;
     sessions = new Map();
     /**
-     * Coding sessions that are running here (#896).
+     * Coding turns that are running here (#896, #1007).
      *
-     * A Claude session survives a restart — it is re-spawned with `--resume <session_id>` and only
-     * the turn in flight is cut — but a Codex, Grok or raw-engine session restarts cold and its turn
-     * is gone. Both are named, because the owner is the one deciding whether to take the machine.
+     * A retained session is a conversation, not necessarily work in flight: a healthy engine remains
+     * available at `runState: "idle"` between turns. Runner updates must protect only turns that can
+     * be interrupted. If this runtime cannot observe a session's state, retain the conservative busy
+     * answer rather than restarting across work whose state it cannot prove is idle.
      */
     liveWork() {
-        return [...this.sessions.values()].map((s) => {
+        return [...this.sessions.entries()].flatMap(([sessionId, s]) => {
             const engine = s.clientType ?? "";
-            return 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.
+                const alive = s.alive;
+                if (alive === false)
+                    return [];
+                const state = s.runState();
+                if (alive === true && state === "idle")
+                    return [];
+                if (alive === true && (state === "thinking" || state === "responding"))
+                    return [`coding session ${sessionId} (${state}): ${consequence}`];
+                // An unrecognised `alive`/`runState` pair is not proof that an engine is idle.
+                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 [`coding session ${sessionId} (unknown): ${consequence}`];
+            }
         });
     }
     /** Background cold-start clones, one per folder (#858). */

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,12 +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 && s.runState && s.runState !== "idle").map((s) => s.sessionId);
-    const localRuns = health.work?.localRuns ?? 0;
-    const codingTurns = health.work?.codingTurns ?? 0;
+    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(),
@@ -1980,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: codingTurns }, (_v, i) => `coding-turn-${i + 1}`), ...Array.from({ length: localRuns }, (_v, i) => health.work?.detail?.[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;
@@ -2003,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;
@@ -2020,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;
@@ -2041,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;
@@ -2138,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");
@@ -2148,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.93",
+	"version": "0.4.95",
   "description": "CLI for creating, publishing, and running ProAgentStore agents",
   "license": "MIT",
   "type": "module",