@sagentlab/navarch-runtime 0.1.35 → 0.1.36

package/README.md

@@ -233,6 +233,15 @@ accepted. Rollouts are assigned by the machine's server-managed `stable` or
 `canary` channel and deterministic rollout percentage. Set
 `NAVARCH_AUTO_UPDATE=off` to keep telemetry but disable automatic activation.
 
+Project owners can also request a same-version restart from the project Agents
+page. Only a worker running under `navarch-runtime supervise` advertises this
+capability. The restart command arrives on the normal machine heartbeat; the
+worker stops claiming, reports zero capacity, drains active sessions, and exits
+with a restart-only handoff code. The supervisor respawns the current verified
+binary without staging an update. The control plane acknowledges the one-shot
+command only after a heartbeat reports a different boot ID, preventing a stale
+command from causing a restart loop.
+
 Plain `navarch-runtime start` continues to work and reports available releases,
 but deliberately does not activate them because no parent process would exist
 to perform a safe handoff or rollback.

package/dist/cli.cjs

@@ -207,7 +207,12 @@ async function startCommand(flags) {
     const bootId = (0, node_crypto_1.randomUUID)();
     const updateCoordinatorRef = {};
     let readySent = false;
-    const heartbeat = new heartbeat_loop_cjs_1.MachineHeartbeatLoop(api, identity.machine_id, config, capacity, bootId, (result) => updateCoordinatorRef.current?.consider(result.update), () => {
+    const heartbeat = new heartbeat_loop_cjs_1.MachineHeartbeatLoop(api, identity.machine_id, config, capacity, bootId, (result) => {
+        if (result.restart)
+            updateCoordinatorRef.current?.considerRestart(result.restart);
+        else
+            updateCoordinatorRef.current?.consider(result.update);
+    }, () => {
         if (!readySent && process.send) {
             readySent = true;
             process.send({ type: "navarch-ready", boot_id: bootId });

package/dist/config.cjs

@@ -103,6 +103,7 @@ function loadRuntimeConfig(env = process.env) {
             .map((s) => s.trim())
             .filter(Boolean),
         updateChannel: env.NAVARCH_UPDATE_CHANNEL === "canary" ? "canary" : "stable",
+        supervised: env.NAVARCH_SUPERVISED === "1",
         autoUpdate: env.NAVARCH_SUPERVISED === "1" &&
             !["off", "false", "0"].includes(env.NAVARCH_AUTO_UPDATE ?? ""),
         // Reads only the quota numbers providers already write to disk, so it is on

package/dist/heartbeat-loop.cjs

@@ -70,6 +70,8 @@ class MachineHeartbeatLoop {
                         ? await (0, usage_limits_cjs_1.collectAgentUsage)({
                             codexHome: this.config.codexHome,
                             claudeConfigPath: this.config.claudeConfigPath,
+                            providers: [...new Set([this.config.agentType, ...(this.config.runtimes ?? [])])]
+                                .filter((runtime) => runtime === "codex" || runtime === "claude-code"),
                         })
                         : null;
                     const result = await this.api.machineHeartbeat(this.machineId, {
@@ -82,6 +84,7 @@ class MachineHeartbeatLoop {
                             channel: this.config.updateChannel,
                             state: this.updateState,
                             boot_id: this.bootId,
+                            supervised: this.config.supervised,
                             ...(this.lastUpdateError ? { last_update_error: this.lastUpdateError } : {}),
                         },
                     });

package/dist/supervisor.cjs

@@ -1,11 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.REMOTE_RESTART_EXIT_CODE = void 0;
 exports.superviseRuntime = superviseRuntime;
 const node_child_process_1 = require("node:child_process");
 const logger_cjs_1 = require("./logger.cjs");
 const update_installer_cjs_1 = require("./update-installer.cjs");
 const log = (0, logger_cjs_1.createLogger)("supervisor");
 const UPDATE_RESTART_EXIT_CODE = 75;
+exports.REMOTE_RESTART_EXIT_CODE = 76;
 function runWorker(binPath, args, healthTimeoutMs, workerEnv, setCurrentChild, onHealthy) {
     return new Promise((resolve) => {
         const child = (0, node_child_process_1.spawn)(process.execPath, [binPath, "start", ...args], {
@@ -126,6 +128,10 @@ async function superviseRuntime(configDir, initialBinPath, workerArgs = [], heal
                 await (0, update_installer_cjs_1.clearPendingUpdate)(configDir);
                 continue;
             }
+            if (result.code === exports.REMOTE_RESTART_EXIT_CODE) {
+                log.info("remote restart requested; respawning current runtime");
+                continue;
+            }
             if (result.code !== UPDATE_RESTART_EXIT_CODE)
                 return result.code;
             const pending = await (0, update_installer_cjs_1.readPendingUpdate)(configDir);

package/dist/update-coordinator.cjs

@@ -4,16 +4,18 @@ exports.RuntimeUpdateCoordinator = void 0;
 const logger_cjs_1 = require("./logger.cjs");
 const update_installer_cjs_1 = require("./update-installer.cjs");
 const version_cjs_1 = require("./version.cjs");
+const supervisor_cjs_1 = require("./supervisor.cjs");
 const log = (0, logger_cjs_1.createLogger)("update");
 class RuntimeUpdateCoordinator {
     options;
     targetInProgress = null;
+    restartInProgress = null;
     warnedUnsupervised = false;
     constructor(options) {
         this.options = options;
     }
     consider(directive) {
-        if (!directive || directive.target_version === version_cjs_1.RUNTIME_VERSION)
+        if (!directive || directive.target_version === version_cjs_1.RUNTIME_VERSION || this.restartInProgress)
             return;
         if (!this.options.config.autoUpdate) {
             if (!this.warnedUnsupervised) {
@@ -27,6 +29,34 @@ class RuntimeUpdateCoordinator {
         this.targetInProgress = directive.target_version;
         void this.apply(directive);
     }
+    considerRestart(directive) {
+        if (!directive || this.targetInProgress || this.restartInProgress)
+            return;
+        if (!this.options.config.supervised) {
+            log.warn(`ignoring remote restart ${directive.command_id}: runtime is not supervised`);
+            return;
+        }
+        this.restartInProgress = directive.command_id;
+        void this.applyRestart(directive);
+    }
+    async applyRestart(directive) {
+        const { heartbeat, claimLoop, capacity } = this.options;
+        try {
+            heartbeat.setUpdateState("draining");
+            log.info(`remote restart ${directive.command_id} received; draining active sessions`);
+            await claimLoop.drain();
+            await capacity.waitForIdle();
+            log.info(`remote restart ${directive.command_id} ready; handing off to supervisor`);
+            (this.options.requestRestart ?? ((code) => process.exit(code)))(supervisor_cjs_1.REMOTE_RESTART_EXIT_CODE);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            log.error(`remote restart failed: ${message}`);
+            heartbeat.setUpdateState("failed", message.slice(0, 500));
+            claimLoop.start();
+            this.restartInProgress = null;
+        }
+    }
     async apply(directive) {
         const { config, heartbeat, claimLoop, capacity } = this.options;
         try {

package/dist/usage-limits.cjs

@@ -359,7 +359,9 @@ async function collectClaudeUsage(options) {
 }
 const DEFAULT_COLLECT_TIMEOUT_MS = 5_000;
 /**
- * Gathers every provider report available on this machine. Providers are read
+ * Gathers reports for the providers this runtime actually advertises. Provider
+ * CLIs can share a host, so scanning every state directory would attribute a
+ * different agent's quota to this machine. Selected providers are still read
  * independently so one unreadable or malformed source cannot suppress another,
  * and any thrown error degrades to "no report" rather than failing the caller.
  */
@@ -372,10 +374,15 @@ async function collectAgentUsage(options) {
         timer.unref?.();
     });
     try {
-        const collection = Promise.allSettled([
-            collectCodexUsage({ codexHome: options.codexHome, now: options.now }),
-            collectClaudeUsage({ configPath: options.claudeConfigPath, now: options.now }),
-        ]);
+        const providers = new Set(options.providers ?? ["codex", "claude-code"]);
+        const collectors = [];
+        if (providers.has("codex")) {
+            collectors.push(collectCodexUsage({ codexHome: options.codexHome, now: options.now }));
+        }
+        if (providers.has("claude-code")) {
+            collectors.push(collectClaudeUsage({ configPath: options.claudeConfigPath, now: options.now }));
+        }
+        const collection = Promise.allSettled(collectors);
         const settled = await Promise.race([collection, deadline]);
         if (!settled) {
             log.warn(`usage collection timed out after ${timeoutMs}ms`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sagentlab/navarch-runtime",
-  "version": "0.1.35",
+  "version": "0.1.36",
   "description": "Navarch machine-side session manager: claims delivery tasks and runs them through Claude Code, Codex, Gemini, or OpenCode.",
   "type": "commonjs",
   "license": "MIT",