patchrelay 0.41.6 → 0.41.8

package/dist/build-info.json

@@ -1,6 +1,6 @@
 {
   "service": "patchrelay",
-  "version": "0.41.6",
-  "commit": "24441e13272f",
-  "builtAt": "2026-04-13T17:33:37.051Z"
+  "version": "0.41.8",
+  "commit": "8142a14a520c",
+  "builtAt": "2026-04-14T13:31:00.535Z"
 }

package/dist/hook-runner.js

@@ -8,7 +8,7 @@ export async function runProjectHook(repoPath, hookName, options) {
     }
     const result = await execCommand(hookPath, [], {
         cwd: options.cwd,
-        env: { ...process.env, ...(options.env ?? {}) },
+        env: { ...sanitizedParentEnv(), ...(options.env ?? {}) },
         timeoutMs: options.timeoutMs ?? 120_000,
     });
     return {
@@ -18,6 +18,23 @@ export async function runProjectHook(repoPath, hookName, options) {
         stderr: result.stderr,
     };
 }
+// Patchrelay runs as a service with NODE_ENV=production, which makes `npm ci`
+// in a project hook silently omit devDependencies. The subject project's install
+// surface is a separate concern from patchrelay's own runtime, so scrub the
+// variables that would leak patchrelay's production posture into the hook.
+const STRIPPED_PARENT_ENV_VARS = [
+    "NODE_ENV",
+    "NPM_CONFIG_PRODUCTION",
+    "NPM_CONFIG_OMIT",
+    "NPM_CONFIG_INCLUDE",
+];
+function sanitizedParentEnv() {
+    const env = { ...process.env };
+    for (const key of STRIPPED_PARENT_ENV_VARS) {
+        delete env[key];
+    }
+    return env;
+}
 export function buildHookEnv(issueKey, branchName, stage, worktreePath) {
     return {
         PATCHRELAY_ISSUE_KEY: issueKey,

package/dist/worktree-manager.js

@@ -1,6 +1,17 @@
 import { existsSync, lstatSync, realpathSync } from "node:fs";
 import path from "node:path";
 import { ensureDir, execCommand } from "./utils.js";
+const FETCH_RETRY_DELAYS_MS = [0, 1_000];
+const TRANSIENT_FETCH_ERROR_PATTERNS = [
+    /connection reset by peer/i,
+    /recv failure/i,
+    /tls handshake timeout/i,
+    /connection timed out/i,
+    /operation timed out/i,
+    /timed out after \d+ms/i,
+    /remote end hung up unexpectedly/i,
+    /unexpected disconnect while reading sideband packet/i,
+];
 export class WorktreeManager {
     config;
     constructor(config) {
@@ -84,9 +95,7 @@ export class WorktreeManager {
         // Fetch latest main so the branch forks from a clean, up-to-date base.
         // This prevents branch contamination when local HEAD has drifted.
         // freshenWorktree in run-orchestrator acts as a secondary safety net.
-        const fetchResult = await execCommand(this.config.runner.gitBin, ["-C", repoPath, "fetch", "origin", "main"], {
-            timeoutMs: 60_000,
-        });
+        const fetchResult = await this.fetchWithTransientRetry(repoPath, "main");
         if (fetchResult.exitCode !== 0) {
             throw new Error(`Failed to fetch origin/main before creating issue worktree: ${fetchResult.stderr?.slice(0, 300) ?? "git fetch failed"}`);
         }
@@ -95,6 +104,34 @@ export class WorktreeManager {
             throw new Error(`Failed to create issue worktree at ${worktreePath}: ${addResult.stderr?.slice(0, 300) ?? "git worktree add failed"}`);
         }
     }
+    async fetchWithTransientRetry(repoPath, branchName) {
+        let lastResult;
+        let lastError;
+        for (let attempt = 0; attempt <= FETCH_RETRY_DELAYS_MS.length; attempt += 1) {
+            if (attempt > 0) {
+                await delay(FETCH_RETRY_DELAYS_MS[attempt - 1] ?? 0);
+            }
+            try {
+                const result = await execCommand(this.config.runner.gitBin, ["-C", repoPath, "fetch", "origin", branchName], {
+                    timeoutMs: 60_000,
+                });
+                if (result.exitCode === 0 || !isTransientFetchFailure(result.stderr)) {
+                    return result;
+                }
+                lastResult = result;
+            }
+            catch (error) {
+                if (!isTransientFetchFailure(error instanceof Error ? error.message : String(error))) {
+                    throw error;
+                }
+                lastError = error instanceof Error ? error : new Error(String(error));
+            }
+        }
+        if (lastResult) {
+            return lastResult;
+        }
+        throw lastError ?? new Error(`Failed to fetch origin/${branchName}`);
+    }
     async assertTrustedExistingWorktree(repoPath, worktreeRoot, worktreePath, options) {
         const worktreeStats = lstatSync(worktreePath);
         if (worktreeStats.isSymbolicLink()) {
@@ -145,3 +182,15 @@ function isPathWithinRoot(rootPath, candidatePath) {
     const relative = path.relative(rootPath, candidatePath);
     return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
 }
+function isTransientFetchFailure(message) {
+    if (!message) {
+        return false;
+    }
+    return TRANSIENT_FETCH_ERROR_PATTERNS.some((pattern) => pattern.test(message));
+}
+function delay(delayMs) {
+    if (delayMs <= 0) {
+        return Promise.resolve();
+    }
+    return new Promise((resolve) => setTimeout(resolve, delayMs));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "patchrelay",
-  "version": "0.41.6",
+  "version": "0.41.8",
   "license": "MIT",
   "type": "module",
   "repository": {