Use workflow_dispatch return_run_details to get run ID directly (#19414)

Copilot · web-flow · commit a86e657586e4 · 2026-03-03T13:14:03.000Z
diff --git a/.changeset/patch-log-run-id.md b/.changeset/patch-log-run-id.md
diff --git a/actions/setup/js/dispatch_workflow.cjs b/actions/setup/js/dispatch_workflow.cjs
@@ -155,16 +155,49 @@ async function main(config = {}) {
       const workflowFile = `${workflowName}${extension}`;
       core.info(`Dispatching workflow: ${workflowFile}`);
 
-      // Dispatch the workflow using the resolved file
-      await githubClient.rest.actions.createWorkflowDispatch({
-        owner: repo.owner,
-        repo: repo.repo,
-        workflow_id: workflowFile,
-        ref: ref,
-        inputs: inputs,
-      });
+      // Dispatch the workflow using the resolved file.
+      // Request return_run_details for newer GitHub API support; fall back without it
+      // for older GitHub Enterprise Server deployments that don't support the parameter.
+      /** @type {{ data: { workflow_run_id?: number } }} */
+      let response;
+      try {
+        response = await githubClient.rest.actions.createWorkflowDispatch({
+          owner: repo.owner,
+          repo: repo.repo,
+          workflow_id: workflowFile,
+          ref: ref,
+          inputs: inputs,
+          return_run_details: true,
+        });
+      } catch (dispatchError) {
+        /** @type {any} */
+        const err = dispatchError;
+        const status = err && typeof err === "object" ? err.status : undefined;
+        const message = err && typeof err === "object" && err.response && err.response.data && typeof err.response.data.message === "string" ? err.response.data.message : String(dispatchError);
+
+        const isValidationStatus = status === 400 || status === 422;
+        const mentionsReturnRunDetails = typeof message === "string" && message.toLowerCase().includes("return_run_details");
+
+        if (isValidationStatus && mentionsReturnRunDetails) {
+          core.info("Workflow dispatch failed due to unsupported 'return_run_details' parameter; retrying without it for GitHub Enterprise compatibility.");
+          response = await githubClient.rest.actions.createWorkflowDispatch({
+            owner: repo.owner,
+            repo: repo.repo,
+            workflow_id: workflowFile,
+            ref: ref,
+            inputs: inputs,
+          });
+        } else {
+          throw err;
+        }
+      }
 
-      core.info(`✓ Successfully dispatched workflow: ${workflowFile}`);
+      const runId = response && response.data ? response.data.workflow_run_id : undefined;
+      if (runId) {
+        core.info(`✓ Successfully dispatched workflow: ${workflowFile} (run ID: ${runId})`);
+      } else {
+        core.info(`✓ Successfully dispatched workflow: ${workflowFile}`);
+      }
 
       // Record the time of this dispatch for rate limiting
       lastDispatchTime = Date.now();
@@ -173,6 +206,7 @@ async function main(config = {}) {
         success: true,
         workflow_name: workflowName,
         inputs: inputs,
+        run_id: runId,
       };
     } catch (error) {
       const errorMessage = getErrorMessage(error);
diff --git a/actions/setup/js/dispatch_workflow.test.cjs b/actions/setup/js/dispatch_workflow.test.cjs
@@ -25,7 +25,7 @@ global.context = {
 global.github = {
   rest: {
     actions: {
-      createWorkflowDispatch: vi.fn().mockResolvedValue({}),
+      createWorkflowDispatch: vi.fn().mockResolvedValue({ data: { workflow_run_id: 123456 } }),
     },
     repos: {
       get: vi.fn().mockResolvedValue({
@@ -72,6 +72,7 @@ describe("dispatch_workflow handler factory", () => {
 
     expect(result.success).toBe(true);
     expect(result.workflow_name).toBe("test-workflow");
+    expect(result.run_id).toBe(123456);
     // Should use the extension from config
     expect(github.rest.actions.createWorkflowDispatch).toHaveBeenCalledWith({
       owner: "test-owner",
@@ -82,6 +83,7 @@ describe("dispatch_workflow handler factory", () => {
         param1: "value1",
         param2: "42",
       },
+      return_run_details: true,
     });
   });
 
@@ -232,6 +234,7 @@ describe("dispatch_workflow handler factory", () => {
       workflow_id: "no-inputs-workflow.lock.yml",
       ref: expect.any(String),
       inputs: {}, // Should pass empty object even when inputs property is missing
+      return_run_details: true,
     });
   });
 
@@ -304,6 +307,7 @@ describe("dispatch_workflow handler factory", () => {
       workflow_id: "test-workflow.lock.yml",
       ref: "refs/heads/feature-branch",
       inputs: {},
+      return_run_details: true,
     });
   });
 
@@ -334,6 +338,7 @@ describe("dispatch_workflow handler factory", () => {
       workflow_id: "test-workflow.lock.yml",
       ref: "refs/heads/main",
       inputs: {},
+      return_run_details: true,
     });
   });
 
@@ -364,6 +369,7 @@ describe("dispatch_workflow handler factory", () => {
       workflow_id: "test-workflow.lock.yml",
       ref: "refs/heads/feature/add-new-feature",
       inputs: {},
+      return_run_details: true,
     });
   });
 
@@ -396,6 +402,7 @@ describe("dispatch_workflow handler factory", () => {
       workflow_id: "test-workflow.lock.yml",
       ref: "refs/heads/develop",
       inputs: {},
+      return_run_details: true,
     });
   });
 
@@ -439,6 +446,103 @@ describe("dispatch_workflow handler factory", () => {
       workflow_id: "test-workflow.lock.yml",
       ref: "refs/heads/staging",
       inputs: {},
+      return_run_details: true,
     });
   });
+
+  it("should return run_id when API returns workflow_run_id", async () => {
+    github.rest.actions.createWorkflowDispatch.mockResolvedValueOnce({
+      data: { workflow_run_id: 987654 },
+    });
+
+    const config = {
+      workflows: ["test-workflow"],
+      workflow_files: { "test-workflow": ".lock.yml" },
+    };
+    const handler = await main(config);
+
+    const result = await handler({ type: "dispatch_workflow", workflow_name: "test-workflow", inputs: {} }, {});
+
+    expect(result.success).toBe(true);
+    expect(result.run_id).toBe(987654);
+    expect(core.info).toHaveBeenCalledWith(expect.stringContaining("run ID: 987654"));
+  });
+
+  it("should succeed without run_id when API returns no workflow_run_id", async () => {
+    github.rest.actions.createWorkflowDispatch.mockResolvedValueOnce({ data: {} });
+
+    const config = {
+      workflows: ["test-workflow"],
+      workflow_files: { "test-workflow": ".lock.yml" },
+    };
+    const handler = await main(config);
+
+    const result = await handler({ type: "dispatch_workflow", workflow_name: "test-workflow", inputs: {} }, {});
+
+    expect(result.success).toBe(true);
+    expect(result.run_id).toBeUndefined();
+  });
+
+  it("should retry without return_run_details when API rejects with 422 mentioning it, and still succeed", async () => {
+    const error = new Error("Unprocessable Entity");
+    // @ts-ignore
+    error.status = 422;
+    // @ts-ignore
+    error.response = { data: { message: "Unknown field 'return_run_details'" } };
+
+    github.rest.actions.createWorkflowDispatch.mockRejectedValueOnce(error).mockResolvedValueOnce({ data: {} });
+
+    const config = {
+      workflows: ["test-workflow"],
+      workflow_files: { "test-workflow": ".lock.yml" },
+    };
+    const handler = await main(config);
+
+    const result = await handler({ type: "dispatch_workflow", workflow_name: "test-workflow", inputs: {} }, {});
+
+    expect(result.success).toBe(true);
+    expect(result.run_id).toBeUndefined();
+
+    // First call should include return_run_details: true
+    expect(github.rest.actions.createWorkflowDispatch).toHaveBeenNthCalledWith(1, {
+      owner: "test-owner",
+      repo: "test-repo",
+      workflow_id: "test-workflow.lock.yml",
+      ref: "refs/heads/main",
+      inputs: {},
+      return_run_details: true,
+    });
+
+    // Second call should retry without return_run_details
+    expect(github.rest.actions.createWorkflowDispatch).toHaveBeenNthCalledWith(2, {
+      owner: "test-owner",
+      repo: "test-repo",
+      workflow_id: "test-workflow.lock.yml",
+      ref: "refs/heads/main",
+      inputs: {},
+    });
+
+    expect(github.rest.actions.createWorkflowDispatch).toHaveBeenCalledTimes(2);
+  });
+
+  it("should not retry when API rejects with 422 for an unrelated reason", async () => {
+    const error = new Error("Unprocessable Entity");
+    // @ts-ignore
+    error.status = 422;
+    // @ts-ignore
+    error.response = { data: { message: "Workflow does not exist" } };
+
+    github.rest.actions.createWorkflowDispatch.mockRejectedValueOnce(error);
+
+    const config = {
+      workflows: ["test-workflow"],
+      workflow_files: { "test-workflow": ".lock.yml" },
+    };
+    const handler = await main(config);
+
+    const result = await handler({ type: "dispatch_workflow", workflow_name: "test-workflow", inputs: {} }, {});
+
+    expect(result.success).toBe(false);
+    expect(github.rest.actions.createWorkflowDispatch).toHaveBeenCalledTimes(1);
+  });
 });
diff --git a/pkg/cli/run_workflow_execution.go b/pkg/cli/run_workflow_execution.go
@@ -7,6 +7,7 @@ import (
 	"os"
 	"os/exec"
 	"path/filepath"
+	"regexp"
 	"strconv"
 	"strings"
 	"time"
@@ -395,9 +396,17 @@ func RunWorkflowOnGitHub(ctx context.Context, workflowIdOrName string, opts RunO
 	fmt.Fprintln(os.Stderr, console.FormatSuccessMessage("Successfully triggered workflow: "+lockFileName))
 	executionLog.Printf("Workflow triggered successfully: %s", lockFileName)
 
-	// Try to get the latest run for this workflow to show a direct link
-	// Add a delay to allow GitHub Actions time to register the new workflow run
-	runInfo, runErr := getLatestWorkflowRunWithRetry(lockFileName, opts.RepoOverride, opts.Verbose)
+	// Try to get run info: first attempt to parse from gh workflow run output (new in v2.87+),
+	// then fall back to polling with getLatestWorkflowRunWithRetry for older gh CLI versions.
+	// Parsing failure is expected for older gh CLI versions and the fallback ensures backward compatibility.
+	var runInfo *WorkflowRunInfo
+	var runErr error
+	if parsedRunInfo := parseRunInfoFromOutput(output); parsedRunInfo != nil {
+		executionLog.Printf("Parsed run info from gh output: id=%d, url=%s", parsedRunInfo.DatabaseID, parsedRunInfo.URL)
+		runInfo = parsedRunInfo
+	} else {
+		runInfo, runErr = getLatestWorkflowRunWithRetry(lockFileName, opts.RepoOverride, opts.Verbose)
+	}
 	if runErr == nil && runInfo.URL != "" {
 		fmt.Fprintln(os.Stderr, console.FormatInfoMessage("🔗 View workflow run: "+runInfo.URL))
 		executionLog.Printf("Workflow run URL: %s (ID: %d)", runInfo.URL, runInfo.DatabaseID)
@@ -554,3 +563,26 @@ func RunWorkflowsOnGitHub(ctx context.Context, workflowNames []string, opts RunO
 		UseStderr:     false, // Use stdout for run command
 	})
 }
+
+// runInfoURLRegexp matches GitHub Actions run URLs of the form:
+// https://{host}/{owner}/{repo}/actions/runs/{run_id}
+// Supports both public GitHub (github.com) and GitHub Enterprise Server deployments.
+var runInfoURLRegexp = regexp.MustCompile(`https://[^/\s]+/[^/\s]+/[^/\s]+/actions/runs/(\d+)`)
+
+// parseRunInfoFromOutput tries to extract workflow run information from the
+// output of `gh workflow run` (v2.87+), which now returns the run URL.
+// Returns nil if the run URL cannot be found in the output.
+func parseRunInfoFromOutput(output string) *WorkflowRunInfo {
+	matches := runInfoURLRegexp.FindStringSubmatch(output)
+	if len(matches) < 2 {
+		return nil
+	}
+	runID, err := strconv.ParseInt(matches[1], 10, 64)
+	if err != nil {
+		return nil
+	}
+	return &WorkflowRunInfo{
+		URL:        matches[0],
+		DatabaseID: runID,
+	}
+}
diff --git a/pkg/cli/run_workflow_execution_test.go b/pkg/cli/run_workflow_execution_test.go
@@ -250,3 +250,79 @@ func TestRunWorkflowOnGitHub_FlagCombinations(t *testing.T) {
 // focus on input validation and early error conditions that can be tested
 // without those dependencies. Full end-to-end tests should be in integration
 // test files (run_command_test.go with //go:build integration tag).
+
+// TestParseRunInfoFromOutput tests extracting run info from gh workflow run output
+func TestParseRunInfoFromOutput(t *testing.T) {
+	tests := []struct {
+		name        string
+		output      string
+		expectNil   bool
+		expectedID  int64
+		expectedURL string
+	}{
+		{
+			name: "gh v2.87+ output with run URL",
+			output: "Created workflow_dispatch event for test.lock.yml at refs/heads/main\n" +
+				"To see the workflow run, visit:\n" +
+				"  https://github.com/owner/repo/actions/runs/12345678\n" +
+				"Use `gh run view 12345678` to see the run logs",
+			expectNil:   false,
+			expectedID:  12345678,
+			expectedURL: "https://github.com/owner/repo/actions/runs/12345678",
+		},
+		{
+			name:      "old gh output without run URL",
+			output:    "Created workflow_dispatch event for test.lock.yml at refs/heads/main",
+			expectNil: true,
+		},
+		{
+			name:      "empty output",
+			output:    "",
+			expectNil: true,
+		},
+		{
+			name:        "URL with org and repo containing hyphens",
+			output:      "https://github.com/my-org/my-repo/actions/runs/9876543210",
+			expectNil:   false,
+			expectedID:  9876543210,
+			expectedURL: "https://github.com/my-org/my-repo/actions/runs/9876543210",
+		},
+		{
+			name:        "GitHub Enterprise Server URL",
+			output:      "https://github.mycompany.com/owner/repo/actions/runs/55554444",
+			expectNil:   false,
+			expectedID:  55554444,
+			expectedURL: "https://github.mycompany.com/owner/repo/actions/runs/55554444",
+		},
+		{
+			name: "GHES URL in multi-line output",
+			output: "Created workflow_dispatch event for test.lock.yml at refs/heads/main\n" +
+				"To see the workflow run, visit:\n" +
+				"  https://ghe.example.com/myorg/myrepo/actions/runs/99887766\n",
+			expectNil:   false,
+			expectedID:  99887766,
+			expectedURL: "https://ghe.example.com/myorg/myrepo/actions/runs/99887766",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := parseRunInfoFromOutput(tt.output)
+			if tt.expectNil {
+				if result != nil {
+					t.Errorf("Expected nil result but got: %+v", result)
+				}
+				return
+			}
+			if result == nil {
+				t.Fatalf("Expected non-nil result but got nil")
+			}
+			if result.DatabaseID != tt.expectedID {
+				t.Errorf("Expected DatabaseID %d, got %d", tt.expectedID, result.DatabaseID)
+			}
+			if result.URL != tt.expectedURL {
+				t.Errorf("Expected URL %q, got %q", tt.expectedURL, result.URL)
+			}
+		})
+	}
+}
