Handle deleted PR head branches in push_to_pull_request_branch before fetch and after push failures (#26705)

Author: Copilot

actions/setup/js/push_to_pull_request_branch.cjs

@@ -455,6 +455,30 @@ async function main(config = {}) {
     // Switch to or create the target branch
     core.info(`Switching to branch: ${branchName}`);
 
+    // Detect missing/deleted branches early and return a clear error.
+    // This avoids an opaque git fetch exit code when the PR branch was deleted.
+    {
+      const lsRemoteResult = await exec.getExecOutput("git", ["ls-remote", "--exit-code", "--heads", "origin", branchName], {
+        env: { ...process.env, ...gitAuthEnv },
+        ignoreReturnCode: true,
+      });
+
+      if (lsRemoteResult.exitCode === 2) {
+        return {
+          success: false,
+          error: `Branch ${branchName} no longer exists on origin (it may have been deleted), can't push to it.`,
+        };
+      }
+
+      if (lsRemoteResult.exitCode !== 0) {
+        const stderr = (lsRemoteResult.stderr || "").trim();
+        return {
+          success: false,
+          error: `Failed to verify branch ${branchName} exists on origin: ${stderr || `git ls-remote exited with code ${lsRemoteResult.exitCode}`}`,
+        };
+      }
+    }
+
     // Fetch the specific target branch from origin
     // Use GIT_CONFIG_* env vars for auth because .git/config credentials are
     // cleaned by clean_git_credentials.sh before the agent runs.
@@ -684,9 +708,27 @@ async function main(config = {}) {
         core.error(`Failed to push changes: ${pushErrorMessage}`);
         const nonFastForwardPatterns = ["non-fast-forward", "rejected", "fetch first", "Updates were rejected"];
         const isNonFastForward = nonFastForwardPatterns.some(pattern => pushErrorMessage.includes(pattern));
-        const userMessage = isNonFastForward
+        let userMessage = isNonFastForward
           ? "Failed to push changes: remote PR branch changed while the workflow was running (non-fast-forward). Re-run the workflow on the latest PR branch state."
           : `Failed to push changes: ${pushErrorMessage}`;
+
+        // Diagnose common race where branch was deleted after preflight checks.
+        try {
+          const lsRemoteAfterPushResult = await exec.getExecOutput("git", ["ls-remote", "--exit-code", "--heads", "origin", branchName], {
+            env: { ...process.env, ...gitAuthEnv },
+            ignoreReturnCode: true,
+          });
+
+          if (lsRemoteAfterPushResult.exitCode === 2) {
+            userMessage = "Failed to push changes: remote PR branch appears to have been deleted while the workflow was running.";
+          } else if (lsRemoteAfterPushResult.exitCode !== 0) {
+            const remoteCheckError = (lsRemoteAfterPushResult.stderr || "").trim();
+            core.warning(`Push failed and branch existence re-check also failed for ${branchName}: ${remoteCheckError || `git ls-remote exited with code ${lsRemoteAfterPushResult.exitCode}`}`);
+          }
+        } catch (diagnosisError) {
+          core.warning(`Push failed and branch existence re-check errored for ${branchName}: ${getErrorMessage(diagnosisError)}`);
+        }
+
         return { success: false, error_type: "push_failed", error: userMessage };
       }
 

actions/setup/js/push_to_pull_request_branch.test.cjs

@@ -631,6 +631,35 @@ index 0000000..abc1234
       expect(result.commit_url).toContain("test-owner/test-repo/commit/");
     });
 
+    it("should detect deleted branch before fetch", async () => {
+      const patchPath = createPatchFile();
+
+      mockExec.getExecOutput.mockResolvedValueOnce({ exitCode: 2, stdout: "", stderr: "fatal: couldn't find remote ref feature-branch" });
+
+      const module = await loadModule();
+      const handler = await module.main({});
+      const result = await handler({ patch_path: patchPath }, {});
+
+      expect(result.success).toBe(false);
+      expect(result.error).toContain("no longer exists on origin");
+      expect(mockExec.exec).not.toHaveBeenCalled();
+    });
+
+    it("should fail with diagnostic error when branch existence check fails for other reasons", async () => {
+      const patchPath = createPatchFile();
+
+      mockExec.getExecOutput.mockResolvedValueOnce({ exitCode: 128, stdout: "", stderr: "fatal: Authentication failed" });
+
+      const module = await loadModule();
+      const handler = await module.main({});
+      const result = await handler({ patch_path: patchPath }, {});
+
+      expect(result.success).toBe(false);
+      expect(result.error).toContain("Failed to verify branch");
+      expect(result.error).toContain("Authentication failed");
+      expect(mockExec.exec).not.toHaveBeenCalled();
+    });
+
     it("should handle git fetch failure", async () => {
       const patchPath = createPatchFile();
 
@@ -740,6 +769,67 @@ index 0000000..abc1234
       expect(result.success).toBe(false);
     });
 
+    it("should diagnose deleted branch when push fails", async () => {
+      const patchPath = createPatchFile();
+
+      // Set up successful operations until push
+      mockExec.exec.mockResolvedValueOnce(0); // fetch
+      mockExec.exec.mockResolvedValueOnce(0); // rev-parse
+      mockExec.exec.mockResolvedValueOnce(0); // checkout
+
+      mockExec.getExecOutput.mockResolvedValueOnce({ exitCode: 0, stdout: "before-sha\n", stderr: "" }); // git rev-parse HEAD (before patch)
+
+      mockExec.exec.mockResolvedValueOnce(0); // git am
+
+      // pushSignedCommits + post-failure diagnosis responses
+      const originalGetExecOutput = mockExec.getExecOutput;
+      let exitCodeLsRemoteCallCount = 0;
+      mockExec.getExecOutput = vi.fn().mockImplementation(async (cmd, args) => {
+        const argList = Array.isArray(args) ? args : [];
+        if (argList[0] === "rev-parse" && argList[1] === "HEAD") {
+          return { exitCode: 0, stdout: "before-sha\n", stderr: "" };
+        }
+        if (argList[0] === "rev-list") {
+          return { exitCode: 0, stdout: "abc123\n", stderr: "" };
+        }
+        if (argList[0] === "diff-tree") {
+          return { exitCode: 0, stdout: "", stderr: "" };
+        }
+        if (argList[0] === "ls-remote" && argList[1] === "--exit-code") {
+          exitCodeLsRemoteCallCount += 1;
+          if (exitCodeLsRemoteCallCount === 1) {
+            // Initial preflight check before fetch
+            return { exitCode: 0, stdout: "remote-oid\trefs/heads/feature-branch\n", stderr: "" };
+          }
+          // Post-push diagnosis call from push_to_pull_request_branch catch block
+          return { exitCode: 2, stdout: "", stderr: "fatal: couldn't find remote ref feature-branch" };
+        }
+        if (argList[0] === "ls-remote") {
+          return { exitCode: 0, stdout: "remote-oid\trefs/heads/feature-branch\n", stderr: "" };
+        }
+        if (argList[0] === "log") {
+          return { exitCode: 0, stdout: "Test commit\n", stderr: "" };
+        }
+        if (argList[0] === "diff" && argList[1] === "--name-status") {
+          return { exitCode: 0, stdout: "", stderr: "" };
+        }
+        return originalGetExecOutput(cmd, args);
+      });
+
+      // GraphQL call fails, triggering fallback to git push
+      mockGithub.graphql.mockRejectedValueOnce(new Error("GraphQL error: branch protection"));
+      // Fallback git push fails
+      mockExec.exec.mockRejectedValueOnce(new Error("remote: Internal Server Error"));
+
+      const module = await loadModule();
+      const handler = await module.main({});
+      const result = await handler({ patch_path: patchPath }, {});
+
+      expect(result.success).toBe(false);
+      expect(result.error_type).toBe("push_failed");
+      expect(result.error).toContain("appears to have been deleted");
+    });
+
     it("should detect force-pushed branch via ref mismatch", async () => {
       const patchPath = createPatchFile();