@sagentlab/navarch-runtime 0.1.10 → 0.1.11

package/dist/api.cjs

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.NavarchApiClient = exports.NavarchApiError = void 0;
+exports.NavarchApiClient = exports.NavarchTransportError = exports.NavarchApiError = void 0;
 class NavarchApiError extends Error {
     status;
     body;
@@ -12,6 +12,18 @@ class NavarchApiError extends Error {
     }
 }
 exports.NavarchApiError = NavarchApiError;
+/** A request that failed before the control plane returned an HTTP response. */
+class NavarchTransportError extends Error {
+    method;
+    endpoint;
+    constructor(method, endpoint, cause) {
+        super(`Navarch API ${method} ${endpoint} transport failed: ${describeError(cause)}`, { cause });
+        this.method = method;
+        this.endpoint = endpoint;
+        this.name = "NavarchTransportError";
+    }
+}
+exports.NavarchTransportError = NavarchTransportError;
 /**
  * Typed client for the Navarch control-plane API surface WP-07 depends on:
  * dispatch/claim, per-lease heartbeat, complete, and broker/issue
@@ -44,11 +56,20 @@ class NavarchApiClient {
             }
             headers.authorization = `Bearer ${this.token}`;
         }
-        const response = await this.fetchImpl(`${this.baseUrl}${pathname}`, {
-            method,
-            headers,
-            body: body === undefined ? undefined : JSON.stringify(body),
-        });
+        const requestUrl = `${this.baseUrl}${pathname}`;
+        let response;
+        try {
+            response = await this.fetchImpl(requestUrl, {
+                method,
+                headers,
+                body: body === undefined ? undefined : JSON.stringify(body),
+            });
+        }
+        catch (err) {
+            // Include enough request/cause context to diagnose DNS, connection, and
+            // TLS failures. Deliberately omit headers and URL credentials/query data.
+            throw new NavarchTransportError(method, safeEndpoint(requestUrl, pathname), err);
+        }
         if (response.status === 204)
             return null;
         const text = await response.text();
@@ -133,3 +154,25 @@ function safeJsonParse(text) {
         return null;
     }
 }
+function safeEndpoint(requestUrl, pathname) {
+    try {
+        const parsed = new URL(requestUrl);
+        return `${parsed.origin}${parsed.pathname}`;
+    }
+    catch {
+        return pathname;
+    }
+}
+function describeError(err) {
+    if (!(err instanceof Error))
+        return String(err);
+    let detail = `${err.name}: ${err.message}`;
+    const cause = err.cause;
+    if (cause instanceof Error) {
+        detail += `; cause: ${cause.name}: ${cause.message}`;
+    }
+    else if (cause && typeof cause === "object" && "code" in cause) {
+        detail += `; cause code: ${String(cause.code)}`;
+    }
+    return detail;
+}

package/dist/claim-loop.cjs

@@ -5,6 +5,7 @@ const node_crypto_1 = require("node:crypto");
 const api_cjs_1 = require("./api.cjs");
 const logger_cjs_1 = require("./logger.cjs");
 const log = (0, logger_cjs_1.createLogger)("claim");
+const MAX_CLAIM_BACKOFF_MS = 60_000;
 /**
  * Polls dispatch/claim on an interval, gated by available capacity
  * (implementation-plan.md WP-07 "Claim loop: poll dispatch, receive context
@@ -20,6 +21,8 @@ class ClaimLoop {
     timer = null;
     stopped = false;
     claimInFlight = false;
+    consecutiveFailures = 0;
+    nextClaimAt = 0;
     quiescenceWaiters = new Set();
     constructor(api, config, capacity, runSession) {
         this.api = api;
@@ -31,6 +34,8 @@ class ClaimLoop {
         if (this.timer)
             return;
         this.stopped = false;
+        this.consecutiveFailures = 0;
+        this.nextClaimAt = 0;
         this.timer = setInterval(() => void this.tick(), this.config.pollIntervalMs);
     }
     stop() {
@@ -52,7 +57,10 @@ class ClaimLoop {
         await new Promise((resolve) => this.quiescenceWaiters.add(resolve));
     }
     async tick() {
-        if (this.stopped || this.claimInFlight || !this.capacity.hasCapacity())
+        if (this.stopped ||
+            this.claimInFlight ||
+            !this.capacity.hasCapacity() ||
+            Date.now() < this.nextClaimAt)
             return;
         this.claimInFlight = true;
         try {
@@ -66,6 +74,11 @@ class ClaimLoop {
                 agent_type: this.config.agentType,
                 session_id: sessionId,
             });
+            if (this.consecutiveFailures > 0) {
+                log.info(`claim polling recovered after ${this.consecutiveFailures} failed attempt(s)`);
+            }
+            this.consecutiveFailures = 0;
+            this.nextClaimAt = 0;
             if (!claimed)
                 return;
             this.capacity.acquire(claimed.lease_id);
@@ -75,16 +88,20 @@ class ClaimLoop {
                 .finally(() => this.capacity.release(claimed.lease_id));
         }
         catch (err) {
+            this.consecutiveFailures += 1;
+            const retryDelayMs = Math.min(MAX_CLAIM_BACKOFF_MS, this.config.pollIntervalMs * 2 ** this.consecutiveFailures);
+            this.nextClaimAt = Date.now() + retryDelayMs;
             // NavarchApiError's message is only the status line ("… failed with
             // 500"); the control plane's actual error text lives in `.body`. Log it
             // so a server-side claim failure is diagnosable from the runtime alone
             // instead of an opaque bare status.
             if (err instanceof api_cjs_1.NavarchApiError) {
                 const detail = typeof err.body === "string" ? err.body : JSON.stringify(err.body);
-                log.warn(`claim failed: ${err.message}${detail ? ` — ${detail}` : ""}`);
+                log.warn(`claim failed (attempt ${this.consecutiveFailures}; retrying in ${retryDelayMs}ms): ` +
+                    `${err.message}${detail ? ` — ${detail}` : ""}`);
             }
             else {
-                log.warn(`claim failed: ${String(err)}`);
+                log.warn(`claim failed (attempt ${this.consecutiveFailures}; retrying in ${retryDelayMs}ms): ${String(err)}`);
             }
         }
         finally {

package/dist/worktree-guard.cjs

@@ -5,9 +5,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.guardHookScriptPath = guardHookScriptPath;
 exports.prepareWorktreeGuard = prepareWorktreeGuard;
+exports.codexToolReadRoots = codexToolReadRoots;
 exports.codexWorktreeGuardArgs = codexWorktreeGuardArgs;
 const node_path_1 = __importDefault(require("node:path"));
 const node_fs_1 = require("node:fs");
+const node_os_1 = __importDefault(require("node:os"));
 const CODEX_GUARD_PROFILE = "navarch-worktree";
 /**
  * Tools the hook screens. Everything else — the lease-scoped Navarch MCP
@@ -55,6 +57,29 @@ async function prepareWorktreeGuard(options) {
     await node_fs_1.promises.writeFile(settingsPath, JSON.stringify(settings, null, 2), "utf8");
     return { settingsPath, configPath, hookScriptPath };
 }
+/**
+ * Read-only roots required by Codex's own tools and installed skills.
+ *
+ * Deliberately exclude the CODEX_HOME root itself: it may contain auth.json
+ * and user configuration. Package executables, installed skill instructions,
+ * plugin code, the operator's executable directory, and browser/toolchain
+ * installations are sufficient for helpers such as apply_patch, npm, gh, and
+ * browser evidence tooling.
+ */
+function codexToolReadRoots(env = process.env) {
+    const homeDir = env.HOME?.trim() || node_os_1.default.homedir();
+    const codexHome = env.CODEX_HOME?.trim() || node_path_1.default.join(homeDir, ".codex");
+    return [
+        node_path_1.default.join(codexHome, "packages"),
+        node_path_1.default.join(codexHome, "skills"),
+        node_path_1.default.join(codexHome, "plugins"),
+        node_path_1.default.join(homeDir, ".agents", "skills"),
+        node_path_1.default.join(homeDir, ".local", "bin"),
+        "/opt/homebrew",
+        node_path_1.default.join(homeDir, "Library", "Caches", "ms-playwright"),
+        node_path_1.default.join(homeDir, ".cache", "ms-playwright"),
+    ];
+}
 /**
  * Builds one-off Codex permission-profile arguments for a host session.
  *
@@ -78,6 +103,12 @@ function codexWorktreeGuardArgs(options) {
         [node_path_1.default.resolve(options.worktreePath)]: "write",
         [node_path_1.default.resolve(options.repositoryPath)]: "write",
     };
+    for (const root of codexToolReadRoots()) {
+        const resolved = node_path_1.default.resolve(root);
+        if (isPathInside(resolved, node_path_1.default.resolve(options.workspaceRoot)))
+            continue;
+        filesystem[resolved] = "read";
+    }
     for (const root of options.extraRoots ?? []) {
         const resolved = node_path_1.default.resolve(root);
         // Match the Claude hook's denied-root precedence: an extra root cannot

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sagentlab/navarch-runtime",
-  "version": "0.1.10",
+  "version": "0.1.11",
   "description": "Navarch machine-side session manager: registers a machine, claims tasks from the control-plane dispatcher, runs them via the Claude Code or Codex adapter, and reports results back.",
   "type": "commonjs",
   "license": "MIT",
@@ -18,7 +18,7 @@
     "task-runner"
   ],
   "bin": {
-    "navarch-runtime": "./bin/navarch.cjs"
+    "navarch-runtime": "bin/navarch.cjs"
   },
   "files": [
     "dist",