Keep track of collapsed steps and avoid expanding them automatically

src/main/frontend/pipeline-console-view/pipeline-console/main/hooks/use-steps-poller.spec.ts

@@ -3,6 +3,7 @@
 import { act, renderHook, waitFor } from "@testing-library/react";
 import { Mock, vi } from "vitest";
 
+import * as treeApi from "../../../../common/tree-api.ts";
 import * as model from "../PipelineConsoleModel.tsx";
 import { useStepsPoller } from "./use-steps-poller.ts";
 
@@ -81,6 +82,50 @@ it("selects the step from URL on initial load", async () => {
   unmount();
 });
 
+it("selected steps can be collapsed and remain collapsed", async () => {
+  window.history.pushState({}, "", "/?selected-node=step-1&start-byte=0");
+
+  (treeApi.default as Mock).mockReturnValue({
+    run: {
+      stages: mockStages,
+      complete: true, // avoid "steps" poller
+    },
+  });
+  let currentSteps = [
+    { id: "step-1", title: "Step 1", stageId: "stage-1", state: "running" },
+    { id: "step-2", title: "Step 2", stageId: "stage-1", state: "queued" },
+  ];
+  (model.getRunSteps as Mock).mockResolvedValue(currentSteps);
+
+  const props = { currentRunPath: "/run/1" };
+  const { result, unmount, rerender } = renderHook(() => useStepsPoller(props));
+  await waitFor(() => expect(result.current.expandedSteps).toContain("step-1"));
+
+  expect(result.current.expandedSteps).toContain("step-1");
+  act(() => result.current.onStepToggle("step-1"));
+  expect(result.current.expandedSteps).not.toContain("step-1");
+
+  // Simulate step-1 finishing and step-2 becoming active
+  currentSteps = [
+    { id: "step-1", title: "Step 1", stageId: "stage-1", state: "success" },
+    { id: "step-2", title: "Step 2", stageId: "stage-1", state: "running" },
+  ];
+  (model.getRunSteps as Mock).mockResolvedValue(currentSteps);
+
+  // trigger rerun of ?selected-node logic
+  (treeApi.default as Mock).mockReturnValue({
+    run: { stages: mockStages.slice(0), complete: true },
+  });
+  rerender(props); // happens implicitly from polling.
+
+  await waitFor(() =>
+    expect(result.current.openStageSteps).to.deep.equal(currentSteps),
+  );
+  expect(result.current.expandedSteps).not.toContain("step-1");
+
+  unmount();
+});
+
 it("switches to next stage when current one finishes", async () => {
   let currentSteps = [
     { id: "s1", title: "Step 1", stageId: "stage-1", state: "running" },

src/main/frontend/pipeline-console-view/pipeline-console/main/hooks/use-steps-poller.ts

@@ -25,6 +25,7 @@ export function useStepsPoller(props: RunPollerProps) {
     new Map<string, StepLogBufferInfo>(),
   );
   const [userManuallySetNode, setUserManuallySetNode] = useState(false);
+  const [collapsedSteps] = useState<Set<string>>(new Set());
 
   const stepsRef = useRef<StepInfo[]>([]);
 
@@ -63,6 +64,7 @@ export function useStepsPoller(props: RunPollerProps) {
       if (!selected) {
         return false;
       }
+      if (collapsedSteps.has(selected)) return true;
 
       setUserManuallySetNode(true);
 
@@ -200,14 +202,12 @@ export function useStepsPoller(props: RunPollerProps) {
 
       const stepsForStage = steps.filter((step) => step.stageId === nodeId);
       const lastStep = stepsForStage[stepsForStage.length - 1];
-      const newlyExpandedSteps = lastStep ? [lastStep.id] : [];
 
       history.replaceState({}, "", `?selected-node=` + nodeId);
 
       setOpenStage(nodeId);
-      setExpandedSteps((prev) => [...prev, ...newlyExpandedSteps]);
-
-      if (lastStep) {
+      if (lastStep && !collapsedSteps.has(lastStep.id)) {
+        setExpandedSteps((prev) => [...prev, lastStep.id]);
         updateStepConsoleOffset(lastStep.id, false, 0 - LOG_FETCH_SIZE);
       }
     },
@@ -217,9 +217,11 @@ export function useStepsPoller(props: RunPollerProps) {
   const onStepToggle = (nodeId: string) => {
     setUserManuallySetNode(true);
     if (!expandedSteps.includes(nodeId)) {
+      collapsedSteps.delete(nodeId);
       setExpandedSteps((prev) => [...prev, nodeId]);
       updateStepConsoleOffset(nodeId, false, 0 - LOG_FETCH_SIZE);
     } else {
+      collapsedSteps.add(nodeId);
       setExpandedSteps((prev) => prev.filter((id) => id !== nodeId));
     }
   };