@sagentlab/navarch-runtime 0.1.35 → 0.1.37

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.
@@ -352,6 +361,12 @@ as an explicit read-only mount.
   user or checked-in legacy `sandbox_mode` from silently disabling the
   generated profile; Codex authentication still comes from `CODEX_HOME`, and
   repository instructions such as `AGENTS.md` still load.
+  On macOS the profile also grants read access to `/Library/Developer` and
+  `/Applications` (Xcode and CoreSimulator, which `xcrun simctl` and
+  `xcodebuild` load) and write access to `~/Library/Developer` (simulator
+  devices and DerivedData); the Claude hook gets the same write root. Without
+  these, iOS builds and simulator tests fail under the sandbox with
+  `access to /Library/Developer/PrivateFrameworks/CoreSimulator.framework is blocked`.
 - **Gemini:** the runtime uses Gemini CLI's native sandbox with only the
   current worktree, shared gitdir, session `gh` config, and approved extra
   roots mounted. The `gh` config and lease MCP settings are read-only; header

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/dist/worktree-guard.cjs

@@ -7,6 +7,7 @@ exports.guardHookScriptPath = guardHookScriptPath;
 exports.readClaudeApiKeyHelper = readClaudeApiKeyHelper;
 exports.prepareWorktreeGuard = prepareWorktreeGuard;
 exports.codexToolReadRoots = codexToolReadRoots;
+exports.macosDeveloperWriteRoots = macosDeveloperWriteRoots;
 exports.sessionGhConfigDir = sessionGhConfigDir;
 exports.codexWorktreeGuardArgs = codexWorktreeGuardArgs;
 exports.geminiSandboxMounts = geminiSandboxMounts;
@@ -74,9 +75,12 @@ async function prepareWorktreeGuard(options) {
     const hookScriptPath = guardHookScriptPath();
     const configPath = node_path_1.default.join(options.workDir, "worktree-guard.json");
     const settingsPath = node_path_1.default.join(options.workDir, "claude-settings.json");
+    const workspaceRoot = node_path_1.default.resolve(options.workspaceRoot);
     const allowedRoots = [
         options.worktreePath,
         options.repositoryPath,
+        // Xcode's per-user simulator/DerivedData state; see macosDeveloperWriteRoots.
+        ...macosDeveloperWriteRoots().filter((root) => !isPathInside(node_path_1.default.resolve(root), workspaceRoot)),
         ...(options.extraRoots ?? []),
     ];
     const deniedRoots = [options.workspaceRoot];
@@ -110,7 +114,7 @@ async function prepareWorktreeGuard(options) {
  * installations are sufficient for helpers such as apply_patch, npm, gh, and
  * browser evidence tooling.
  */
-function codexToolReadRoots(env = process.env) {
+function codexToolReadRoots(env = process.env, platform = process.platform) {
     const homeDir = env.HOME?.trim() || node_os_1.default.homedir();
     const codexHome = env.CODEX_HOME?.trim() || node_path_1.default.join(homeDir, ".codex");
     return [
@@ -126,8 +130,31 @@ function codexToolReadRoots(env = process.env) {
         "/System/Library/CoreServices/SystemAppearance.bundle",
         node_path_1.default.join(homeDir, "Library", "Caches", "ms-playwright"),
         node_path_1.default.join(homeDir, ".cache", "ms-playwright"),
+        ...(platform === "darwin" ? MACOS_TOOLCHAIN_READ_ROOTS : []),
     ];
 }
+/**
+ * World-readable macOS toolchain locations. `xcrun simctl` / `xcodebuild`
+ * load /Library/Developer/PrivateFrameworks/CoreSimulator.framework and the
+ * Xcode bundle itself; without these an iOS build or simulator test dies
+ * under Codex's seatbelt with "access to ... is blocked". Both are already
+ * system prefixes for the Claude hook (bin/worktree-guard-hook.cjs), so this
+ * only brings the Codex profile level with it.
+ */
+const MACOS_TOOLCHAIN_READ_ROOTS = ["/Library/Developer", "/Applications"];
+/**
+ * Per-user macOS developer state that Xcode writes during a build or test
+ * run: simulator devices under `~/Library/Developer/CoreSimulator` and
+ * DerivedData under `~/Library/Developer/Xcode`. Shared between sessions on
+ * one machine (that is inherent to Xcode), but nothing under it is Navarch
+ * session state or credentials. Empty off macOS.
+ */
+function macosDeveloperWriteRoots(env = process.env, platform = process.platform) {
+    if (platform !== "darwin")
+        return [];
+    const homeDir = env.HOME?.trim() || node_os_1.default.homedir();
+    return [node_path_1.default.join(homeDir, "Library", "Developer")];
+}
 /**
  * Isolated gh configuration root for one coding-agent session.
  *
@@ -169,7 +196,7 @@ function codexWorktreeGuardArgs(options) {
             continue;
         filesystem[resolved] = "read";
     }
-    for (const root of options.extraRoots ?? []) {
+    for (const root of [...macosDeveloperWriteRoots(), ...(options.extraRoots ?? [])]) {
         const resolved = node_path_1.default.resolve(root);
         // Match the Claude hook's denied-root precedence: an extra root cannot
         // reopen sibling sessions or metadata inside the Navarch workspace.

package/package.json

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