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

openapi.yaml

@@ -376,6 +376,9 @@ components:
             - null
           format: int64
           description: Total duration in milliseconds (null if still running)
+        waitingForInput:
+          type: boolean
+          description: Whether the stage is waiting for user input
         children:
           type: array
           items:

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

@@ -127,6 +127,23 @@ 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,
+            waitingForInput: true,
+          });
+        });
+        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/frontend/pipeline-graph-view/pipeline-graph/main/PipelineGraphModel.tsx

@@ -57,6 +57,7 @@ export interface StageInfo {
 
   skeleton?: boolean;
   pauseLiveTotal?: boolean;
+  waitingForInput?: boolean;
 }
 
 interface BaseNodeInfo {

src/main/frontend/setupTests.ts

@@ -8,3 +8,26 @@ const IntersectionObserverMock = vi.fn(() => ({
 }));
 
 vi.stubGlobal("IntersectionObserver", IntersectionObserverMock);
+
+// Ensure a functional localStorage implementation for tests that persist user preferences.
+if (
+  !("localStorage" in window) ||
+  typeof window.localStorage?.getItem !== "function" ||
+  typeof window.localStorage?.setItem !== "function"
+) {
+  const store: Record<string, string> = {};
+  const localStoragePolyfill = {
+    getItem: (key: string) => (key in store ? store[key] : null),
+    setItem: (key: string, value: string) => {
+      store[key] = String(value);
+    },
+    removeItem: (key: string) => {
+      delete store[key];
+    },
+    clear: () => {
+      Object.keys(store).forEach((k) => delete store[k]);
+    },
+  };
+  // @ts-expect-error override for test environment
+  window.localStorage = localStoragePolyfill;
+}

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

@@ -67,6 +67,12 @@
         // 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 {
@@ -64,6 +67,7 @@ public JSONObject processBean(Object bean, JsonConfig config) {
             json.element("placeholder", stage.placeholder);
             json.element("agent", stage.agent);
             json.element("url", stage.url);
+            json.element("waitingForInput", stage.waitingForInput);
             return json;
         }
     }

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

@@ -19,6 +19,7 @@
     private boolean synthetic;
     private TimingInfo timingInfo;
     private String agent;
+    private PipelineStepBuilderApi builder;
 
     public PipelineStageInternal(
             String id,
@@ -113,7 +114,43 @@
         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 @@
                 synthetic && name.equals(Messages.FlowNodeWrapper_noStage()),
                 timingInfo,
                 agent,
-                runUrl);
+                runUrl,
+                waitingForInput);
     }
 }