Added support for paused status in stages that are waiting for input

src/main/frontend/common/components/status-icon.spec.tsx

@@ -127,6 +127,22 @@ describe("StatusIcon", () => {
         expect(result.current).to.equal(0);
         unmount();
       });
+      it("should continue progress when waitingForInput is true", async () => {
+        const { result, unmount } = renderHook(() => {
+          return useStageProgress({
+            ...mockStage,
+            state: Result.running,
+            startTimeMillis: now - 2_000,
+            previousTotalDurationMillis: 20_000,
+          });
+        });
+        expect(result.current).to.equal(10);
+        await act(() => vi.advanceTimersByTime(1_000));
+        expect(result.current).to.equal(15);
+        await act(() => vi.advanceTimersByTime(1_000));
+        expect(result.current).to.equal(20);
+        unmount();
+      });
     });
     describe("other states", function () {
       for (const state in Result) {

src/main/frontend/common/components/status-icon.tsx

@@ -252,6 +252,8 @@ export function resultToColor(result: Result, skeleton: boolean | undefined) {
       return "jenkins-!-accent-color";
     case "unstable":
       return "jenkins-!-warning-color";
+    case "paused":
+      return "jenkins-!-accent-color";
     default:
       return "jenkins-!-skipped-color";
   }

src/main/java/io/jenkins/plugins/pipelinegraphview/utils/PipelineGraphApi.java

@@ -67,6 +67,12 @@ private PipelineGraph createTree(PipelineGraphBuilderApi builder) {
         // these are completely new representations.
         List<PipelineStageInternal> stages = getPipelineNodes(builder);
 
+        // Set the builder on each stage so they can check for paused steps
+        if (builder instanceof PipelineStepBuilderApi) {
+            PipelineStepBuilderApi stepBuilder = (PipelineStepBuilderApi) builder;
+            stages.forEach(stage -> stage.setBuilder(stepBuilder));
+        }
+
         // id => stage
         Map<String, PipelineStageInternal> stageMap = stages.stream()
                 .collect(Collectors.toMap(

src/main/java/io/jenkins/plugins/pipelinegraphview/utils/PipelineStage.java

@@ -17,6 +17,7 @@ public class PipelineStage extends AbstractPipelineNode {
     private final boolean placeholder;
     final String agent;
     private final String url;
+    public final boolean waitingForInput;
 
     public PipelineStage(
             String id,
@@ -32,8 +33,9 @@ public PipelineStage(
             boolean placeholder,
             TimingInfo timingInfo,
             String agent,
-            String runUrl) {
-        super(id, name, state, type, title, timingInfo);
+            String runUrl,
+            boolean waitingForInput) {
+        super(id, name, waitingForInput ? PipelineState.PAUSED : state, type, title, timingInfo);
         this.children = children;
         this.seqContainerName = seqContainerName;
         this.nextSibling = nextSibling;
@@ -42,6 +44,7 @@ public PipelineStage(
         this.placeholder = placeholder;
         this.agent = agent;
         this.url = "/" + runUrl + URL_NAME + "?selected-node=" + id;
+        this.waitingForInput = waitingForInput;
     }
 
     public static class PipelineStageJsonProcessor extends AbstractPipelineNodeJsonProcessor {

src/main/java/io/jenkins/plugins/pipelinegraphview/utils/PipelineStageInternal.java

@@ -19,6 +19,7 @@ class PipelineStageInternal {
     private boolean synthetic;
     private TimingInfo timingInfo;
     private String agent;
+    private PipelineStepBuilderApi builder;
 
     public PipelineStageInternal(
             String id,
@@ -113,7 +114,43 @@ public void setAgent(String aAgent) {
         this.agent = aAgent;
     }
 
+    public void setBuilder(PipelineStepBuilderApi builder) {
+        this.builder = builder;
+    }
+
+    /**
+     * Checks if this stage or any of its children are waiting for input.
+     * A stage is waiting for input if any of its steps have a non-null inputStep
+     * and the step state is PAUSED.
+     */
+    private boolean isWaitingForInput(List<PipelineStage> children) {
+        // Check if any child stages are waiting for input
+        if (children != null && !children.isEmpty()) {
+            for (PipelineStage child : children) {
+                if (child.waitingForInput) {
+                    return true;
+                }
+            }
+        }
+
+        // Check steps for this stage
+        if (builder != null && id != null) {
+            List<FlowNodeWrapper> steps = builder.getStageSteps(id);
+            if (steps != null) {
+                for (FlowNodeWrapper step : steps) {
+                    // Check if step has an input and is paused
+                    if (step.getInputStep() != null && step.getStatus().state == BlueRun.BlueRunState.PAUSED) {
+                        return true;
+                    }
+                }
+            }
+        }
+
+        return false;
+    }
+
     public PipelineStage toPipelineStage(List<PipelineStage> children, String runUrl) {
+        boolean waitingForInput = isWaitingForInput(children);
         return new PipelineStage(
                 id,
                 name,
@@ -128,6 +165,7 @@ public PipelineStage toPipelineStage(List<PipelineStage> children, String runUrl
                 synthetic && name.equals(Messages.FlowNodeWrapper_noStage()),
                 timingInfo,
                 agent,
-                runUrl);
+                runUrl,
+                waitingForInput);
     }
 }