Wire typed OnStopAfter through production code; support runtime relative deltas

Co-authored-by: gh-aw-bot <259018956+gh-aw-bot@users.noreply.github.com>

Author: Copilot

actions/setup/js/check_stop_time.cjs

@@ -3,6 +3,64 @@
 
 const { ERR_CONFIG, ERR_VALIDATION } = require("./error_codes.cjs");
 const { writeDenialSummary } = require("./pre_activation_summary.cjs");
+
+// Matches a relative time delta such as "+25h", "+3d", "+1w", "+1mo", "+1d12h".
+// Mirrors pkg/workflow/time_delta.go's parseTimeDeltaForStopAfter: minutes are not
+// supported since the minimum unit for stop-after is hours.
+const TIME_DELTA_PATTERN = /(\d+)(mo|w|d|h)/g;
+
+/** @param {string} stopTime */
+function isRelativeStopTime(stopTime) {
+  return stopTime.startsWith("+");
+}
+
+/** @param {string} deltaStr */
+function parseTimeDeltaForStopAfter(deltaStr) {
+  const rest = deltaStr.slice(1);
+  if (!rest) {
+    throw new Error("empty time delta after '+'");
+  }
+
+  const matches = [...rest.matchAll(TIME_DELTA_PATTERN)];
+  if (matches.length === 0) {
+    throw new Error(`invalid time delta format: +${rest}. Expected format like +25h, +3d, +1w, +1mo, +1d12h`);
+  }
+
+  const consumed = matches.reduce((sum, match) => sum + match[0].length, 0);
+  if (consumed !== rest.length) {
+    throw new Error(`invalid time delta format: +${rest}. Extra characters detected`);
+  }
+
+  const delta = { months: 0, weeks: 0, days: 0, hours: 0 };
+  const seenUnits = new Set();
+  for (const [, valueStr, unit] of matches) {
+    if (seenUnits.has(unit)) {
+      throw new Error(`duplicate unit '${unit}' in time delta: +${rest}`);
+    }
+    seenUnits.add(unit);
+    const value = parseInt(valueStr, 10);
+    if (unit === "mo") delta.months = value;
+    else if (unit === "w") delta.weeks = value;
+    else if (unit === "d") delta.days = value;
+    else if (unit === "h") delta.hours = value;
+  }
+  return delta;
+}
+
+/**
+ * Resolves a relative stop-time delta (e.g. "+48h") to an absolute Date, relative to baseTime.
+ * @param {string} deltaStr
+ * @param {Date} baseTime
+ */
+function resolveRelativeStopTime(deltaStr, baseTime) {
+  const delta = parseTimeDeltaForStopAfter(deltaStr);
+  const result = new Date(baseTime.getTime());
+  result.setUTCMonth(result.getUTCMonth() + delta.months);
+  result.setUTCDate(result.getUTCDate() + delta.weeks * 7 + delta.days);
+  result.setUTCHours(result.getUTCHours() + delta.hours);
+  return result;
+}
+
 async function main() {
   const stopTime = process.env.GH_AW_STOP_TIME;
   const workflowName = process.env.GH_AW_WORKFLOW_NAME;
@@ -19,8 +77,21 @@ async function main() {
 
   core.info(`Checking stop-time limit: ${stopTime}`);
 
-  // Parse the stop time (format: "YYYY-MM-DD HH:MM:SS")
-  const stopTimeDate = new Date(stopTime);
+  // Resolve the stop time. A GitHub Actions expression (e.g. "${{ inputs.stop-after }}")
+  // is passed through verbatim at compile time and evaluated by the runner before this
+  // step runs, so it may still be a relative delta (e.g. "+48h") rather than an already
+  // resolved absolute timestamp (format: "YYYY-MM-DD HH:MM:SS").
+  let stopTimeDate;
+  if (isRelativeStopTime(stopTime)) {
+    try {
+      stopTimeDate = resolveRelativeStopTime(stopTime, new Date());
+    } catch (err) {
+      core.setFailed(`${ERR_VALIDATION}: Invalid stop-time format: ${stopTime}. ${err instanceof Error ? err.message : String(err)}`);
+      return;
+    }
+  } else {
+    stopTimeDate = new Date(stopTime);
+  }
 
   if (Number.isNaN(stopTimeDate.getTime())) {
     core.setFailed(`${ERR_VALIDATION}: Invalid stop-time format: ${stopTime}. Expected format: YYYY-MM-DD HH:MM:SS`);

actions/setup/js/check_stop_time.test.cjs

@@ -97,5 +97,28 @@ const mockCore = {
             expect(mockCore.setOutput).toHaveBeenCalledWith("stop_time_ok", "false"),
             expect(mockCore.setFailed).not.toHaveBeenCalled());
         });
+      }),
+      describe("when stop time is a relative delta (e.g. resolved from a GitHub Actions expression)", () => {
+        it("should allow execution for a future relative delta such as +48h", async () => {
+          ((process.env.GH_AW_STOP_TIME = "+48h"),
+            (process.env.GH_AW_WORKFLOW_NAME = "test-workflow"),
+            await eval(`(async () => { ${checkStopTimeScript}; await main(); })()`),
+            expect(mockCore.setOutput).toHaveBeenCalledWith("stop_time_ok", "true"),
+            expect(mockCore.setFailed).not.toHaveBeenCalled());
+        });
+        it("should support combined units such as +1d12h", async () => {
+          ((process.env.GH_AW_STOP_TIME = "+1d12h"),
+            (process.env.GH_AW_WORKFLOW_NAME = "test-workflow"),
+            await eval(`(async () => { ${checkStopTimeScript}; await main(); })()`),
+            expect(mockCore.setOutput).toHaveBeenCalledWith("stop_time_ok", "true"),
+            expect(mockCore.setFailed).not.toHaveBeenCalled());
+        });
+        it("should fail with a descriptive error for an invalid relative delta", async () => {
+          ((process.env.GH_AW_STOP_TIME = "+5x"),
+            (process.env.GH_AW_WORKFLOW_NAME = "test-workflow"),
+            await eval(`(async () => { ${checkStopTimeScript}; await main(); })()`),
+            expect(mockCore.setFailed).toHaveBeenCalledWith(expect.stringContaining("Invalid stop-time format")),
+            expect(mockCore.setOutput).not.toHaveBeenCalled());
+        });
       }));
   }));

pkg/workflow/stop_after.go

@@ -39,16 +39,22 @@ func parseOnStopAfterValue(onMap map[string]any) (string, error) {
 
 // extractStopAfterFromOn extracts the stop-after value from the on: section
 func (c *Compiler) extractStopAfterFromOn(frontmatter map[string]any, workflowData ...*WorkflowData) (string, error) {
-	// Use cached On field from ParsedFrontmatter if available (when workflowData is provided)
-	var onSection any
-	var exists bool
-	if len(workflowData) > 0 && workflowData[0] != nil && workflowData[0].ParsedFrontmatter != nil && workflowData[0].ParsedFrontmatter.On != nil {
-		onSection = workflowData[0].ParsedFrontmatter.On
-		exists = true
-	} else {
-		onSection, exists = frontmatter["on"]
+	// Prefer the typed field populated by ParseFrontmatterConfig when available, so
+	// production code has a single source of truth instead of reparsing the raw map.
+	// ParseFrontmatterConfig silently leaves OnStopAfter empty on a parse error (e.g. a
+	// non-string value), so fall back to re-parsing the raw on: map in that edge case to
+	// surface the original compile error instead of silently treating it as unset.
+	if len(workflowData) > 0 && workflowData[0] != nil && workflowData[0].ParsedFrontmatter != nil {
+		pf := workflowData[0].ParsedFrontmatter
+		if pf.OnStopAfter != "" {
+			return pf.OnStopAfter, nil
+		}
+		return parseOnStopAfterValue(pf.On)
 	}
 
+	// Fallback: no typed ParsedFrontmatter available, so parse the raw frontmatter map.
+	onSection, exists := frontmatter["on"]
+
 	if !exists {
 		return "", nil
 	}

pkg/workflow/stop_after_test.go

@@ -383,6 +383,63 @@ func TestExtractStopAfterFromOnMatchesTypedFieldValue(t *testing.T) {
 	}
 }
 
+// TestExtractStopAfterFromOnPrefersTypedFieldOverRawMap is a sentinel test proving that
+// extractStopAfterFromOn returns the typed OnStopAfter field instead of reparsing the raw
+// frontmatter map, by making the two diverge: the typed field is set explicitly to a
+// different value than on.stop-after in the raw map. If production code ever regresses to
+// reparsing the raw map instead of consuming the typed field, this test will fail.
+func TestExtractStopAfterFromOnPrefersTypedFieldOverRawMap(t *testing.T) {
+	frontmatter := map[string]any{
+		"on": map[string]any{
+			"workflow_dispatch": nil,
+			"stop-after":        "+24h",
+		},
+	}
+
+	parsedFrontmatter := &FrontmatterConfig{
+		On:          frontmatter["on"].(map[string]any),
+		OnStopAfter: "+999h", // deliberately diverges from the raw map's "+24h"
+	}
+
+	compiler := NewCompiler()
+	workflowData := &WorkflowData{ParsedFrontmatter: parsedFrontmatter}
+	stopAfter, err := compiler.extractStopAfterFromOn(frontmatter, workflowData)
+	if err != nil {
+		t.Fatalf("extractStopAfterFromOn failed: %v", err)
+	}
+	if stopAfter != "+999h" {
+		t.Errorf("extractStopAfterFromOn() = %q, want %q (the typed field value, not the raw map's %q)", stopAfter, "+999h", "+24h")
+	}
+}
+
+// TestExtractStopAfterFromOnSurfacesErrorWhenTypedFieldParseFailed verifies that when
+// ParseFrontmatterConfig leaves OnStopAfter empty because the raw value failed to parse
+// (e.g. a non-string value), extractStopAfterFromOn still surfaces the original parse
+// error instead of silently treating stop-after as unset.
+func TestExtractStopAfterFromOnSurfacesErrorWhenTypedFieldParseFailed(t *testing.T) {
+	frontmatter := map[string]any{
+		"on": map[string]any{
+			"workflow_dispatch": nil,
+			"stop-after":        123, // invalid: must be a string
+		},
+	}
+
+	parsedFrontmatter, err := ParseFrontmatterConfig(frontmatter)
+	if err != nil {
+		t.Fatalf("ParseFrontmatterConfig failed: %v", err)
+	}
+	if parsedFrontmatter.OnStopAfter != "" {
+		t.Fatalf("Expected typed field to remain empty on parse failure, got %q", parsedFrontmatter.OnStopAfter)
+	}
+
+	compiler := NewCompiler()
+	workflowData := &WorkflowData{ParsedFrontmatter: parsedFrontmatter}
+	_, err = compiler.extractStopAfterFromOn(frontmatter, workflowData)
+	if err == nil {
+		t.Fatal("Expected extractStopAfterFromOn to return an error for invalid stop-after type, got nil")
+	}
+}
+
 // TestProcessStopAfterConfigurationGitHubExpression verifies that a stop-after value
 // expressed as a GitHub Actions expression is passed through verbatim without being
 // parsed as a relative delta or absolute timestamp.