@skyhook-io/radar-app 1.13.0 → 1.13.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@skyhook-io/radar-app",
-  "version": "1.13.0",
+  "version": "1.13.2",
   "description": "Radar's full web UI as a reusable React component. Used by Radar's own binary and by external consumers like Radar Cloud.",
   "repository": {
     "type": "git",
@@ -41,7 +41,7 @@
     "yaml": "^2.9.0"
   },
   "peerDependencies": {
-    "@skyhook-io/k8s-ui": ">=1.13.4",
+    "@skyhook-io/k8s-ui": ">=1.14.2",
     "@tanstack/react-query": ">=5",
     "@xyflow/react": ">=12.0.0",
     "clsx": ">=2",

package/src/App.tsx

@@ -37,6 +37,7 @@ import { CloudFunnelButton } from './components/CloudFunnelButton'
 import { useNavCustomization } from './context/NavCustomization'
 import type { FleetTakeoverTarget } from './context/NavCustomization'
 import { PrimaryNavRail } from './components/nav/PrimaryNavRail'
+import { navigateFromPrimaryRail } from './components/nav/navigation'
 import { useNavRailPinned } from './hooks/useNavRailPinned'
 import { useMediaQuery } from './hooks/useMediaQuery'
 import { ContextSwitchProvider, useContextSwitch } from './context/ContextSwitchContext'
@@ -322,7 +323,12 @@ function AppInner({ manageDocumentTitle = false, documentTitleSuffix, onClusterL
   // The AI panel is an absolute slot in the body frame (the column under the header):
   // it reserves a right gutter on the CONTENT only, so the navbar + nav rail stay
   // static. contentGutter is the docked panel width (0 when closed/overlay/maximized).
-  const { open: diagnoseOpen, contentGutter } = useDiagnoseLayout()
+  const {
+    open: diagnoseOpen,
+    close: closeDiagnose,
+    contentGutter,
+    maximized: diagnoseMaximized,
+  } = useDiagnoseLayout()
   // Hand off to a host-owned URL. The host's `onHostNavigate` (Radar Cloud's
   // cross-tree swap) navigates same-document so the chrome morphs instead of
   // cold-booting; without it we fall back to a hard `window.location` nav.
@@ -468,12 +474,19 @@ function AppInner({ manageDocumentTitle = false, documentTitleSuffix, onClusterL
 
     const path = view === 'home' ? '/' : `/${view}`
 
-    // Start fresh — keep only cross-view params (namespaces), discard all view-specific ones
+    // Start fresh — keep only cross-view params, discard view-specific ones.
+    // Read the live location because Diagnose owns `ai-run` through the History
+    // API; React Router's searchParams snapshot does not update for that write.
     const newParams = new URLSearchParams()
-    const globalNamespaces = searchParams.get('namespaces')
+    const currentParams = new URLSearchParams(window.location.search)
+    const globalNamespaces = currentParams.get('namespaces')
     if (globalNamespaces) {
       newParams.set('namespaces', globalNamespaces)
     }
+    const diagnoseRun = currentParams.get('ai-run')
+    if (diagnoseRun) {
+      newParams.set('ai-run', diagnoseRun)
+    }
 
     // Add any new params
     if (params) {
@@ -483,7 +496,18 @@ function AppInner({ manageDocumentTitle = false, documentTitleSuffix, onClusterL
     }
 
     navigate({ pathname: path, search: newParams.toString() })
-  }, [navigate, searchParams, takeover, goHost])
+  }, [navigate, takeover, goHost])
+
+  // The standalone rail expresses intent to leave the full-width investigation
+  // workspace. Close it before routing so the destination is immediately visible;
+  // docked investigations stay open across views as a persistent side panel.
+  const handlePrimaryNavigate = useCallback((view: ExtendedMainView) => {
+    navigateFromPrimaryRail(
+      diagnoseOpen && diagnoseMaximized,
+      closeDiagnose,
+      () => setMainView(view),
+    )
+  }, [diagnoseOpen, diagnoseMaximized, closeDiagnose, setMainView])
 
   // Cloud (embedded) takes over the "fleet-shaped" per-cluster views with its
   // own fleet pages scoped to this cluster — owned by the host's left rail — so
@@ -1135,9 +1159,13 @@ function AppInner({ manageDocumentTitle = false, documentTitleSuffix, onClusterL
       setSelectedResource(null)
       setSelectedHelmRelease(null)
 
-      // Reset URL to current view with no resource-specific params.
-      // Old cluster's selected pod/resource/kind don't exist on the new cluster.
-      navigate({ pathname: location.pathname, search: '' }, { replace: true })
+      // Reset resource-specific params while retaining the durable investigation
+      // focus. Diagnose resolves runs by id and owns whether the focused run is
+      // still readable after the context switch.
+      const nextParams = new URLSearchParams()
+      const diagnoseRun = new URLSearchParams(window.location.search).get('ai-run')
+      if (diagnoseRun) nextParams.set('ai-run', diagnoseRun)
+      navigate({ pathname: location.pathname, search: nextParams.toString() }, { replace: true })
 
       // Auto-unpause so the new cluster's topology loads immediately
       setTopologyPaused(false)
@@ -1658,7 +1686,7 @@ function AppInner({ manageDocumentTitle = false, documentTitleSuffix, onClusterL
       {showNavRail && (
         <PrimaryNavRail
           activeView={navActiveView}
-          onNavigate={setMainView}
+          onNavigate={handlePrimaryNavigate}
           pinned={navRailEffectivePinned}
           onTogglePinned={toggleNavRailPinned}
           showPinToggle={!railForcedSlim}
@@ -2436,7 +2464,25 @@ function AppInner({ manageDocumentTitle = false, documentTitleSuffix, onClusterL
           below the header and right of the nav rail, sharing the frame with the
           drawers above. Docked = right slot (pushes content via contentGutter);
           maximized = fills the frame. */}
-      {diagnoseOpen && <DiagnoseSurface topInset={chromeless ? 0 : APP_HEADER_HEIGHT} />}
+      {diagnoseOpen && (
+        <DiagnoseSurface
+          topInset={chromeless ? 0 : APP_HEADER_HEIGHT}
+          onOpenResource={(ref) => {
+            const resource: SelectedResource = {
+              kind: ref.kind,
+              namespace: ref.namespace ?? '',
+              name: ref.name,
+              group: ref.group,
+            }
+            const path = relatedResourcePath(resource)
+            if (path.startsWith('/workload/')) {
+              navigate(path)
+              return
+            }
+            navigateFromIssue(resource)
+          }}
+        />
+      )}
 
       {/* Port Forward floating panel (indicator lives in header) */}
       <PortForwardPanel />

package/src/RadarApp.tsx

@@ -106,10 +106,10 @@ export interface RadarAppProps {
    */
   documentTitleSuffix?: string;
   /**
-   * Injects a resource-level "Diagnose" action (e.g. a "Diagnose with AI"
+   * Injects a resource-level "Investigate" action (e.g. an "Investigate with AI"
    * button) into every resource detail action bar's right-aligned universal
    * actions. The host returns the node to render given the resource context.
-   * Standalone Radar omits this and renders no Diagnose button — OSS stays
+   * Standalone Radar omits this and renders no Investigate button — OSS stays
    * agent-free. See ./context/DiagnoseCustomization for the render-prop shape.
    */
   renderDiagnoseAction?: RenderDiagnoseAction;
@@ -228,7 +228,7 @@ export function RadarApp({
                   value={renderDiagnoseAction ?? defaultDiagnoseAction}
                   consentCopy={diagnoseConsent}
                 >
-                  <DiagnoseProvider>
+                  <DiagnoseProvider browserURLState={router !== "memory"}>
                     <App
                       manageDocumentTitle={manageDocumentTitle}
                       documentTitleSuffix={documentTitleSuffix}

package/src/api/diagnose.test.ts

@@ -0,0 +1,268 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { createRun, subscribeRun, type DiagnoseStreamEvent } from "./diagnose";
+
+type SSEListener = (event: { data: string; lastEventId: string }) => void;
+
+class FakeEventSource {
+  static CLOSED = 2;
+  static instances: FakeEventSource[] = [];
+
+  readyState = 1;
+  onopen: (() => void) | null = null;
+  onerror: (() => void) | null = null;
+  closed = false;
+  private listeners = new Map<string, SSEListener>();
+
+  constructor(
+    readonly url: string,
+    readonly options?: EventSourceInit,
+  ) {
+    FakeEventSource.instances.push(this);
+  }
+
+  addEventListener(type: string, listener: SSEListener) {
+    this.listeners.set(type, listener);
+  }
+
+  emit(type: string, event: DiagnoseStreamEvent, lastEventId = "") {
+    this.listeners.get(type)?.({ data: JSON.stringify(event), lastEventId });
+  }
+
+  close() {
+    this.closed = true;
+  }
+}
+
+describe("createRun", () => {
+  afterEach(() => vi.unstubAllGlobals());
+
+  it.each(["argoproj.io", ""])(
+    "sends the target API group %j in the request body",
+    async (group) => {
+      const fetchMock = vi.fn().mockResolvedValue({
+        ok: true,
+        json: async () => ({
+          id: "run-1",
+          kind: "Rollout",
+          group,
+          namespace: "prod",
+          name: "checkout",
+        }),
+      });
+      vi.stubGlobal("fetch", fetchMock);
+
+      await createRun(
+        {
+          kind: "Rollout",
+          group,
+          namespace: "prod",
+          name: "checkout",
+        },
+        { agent: "codex" },
+      );
+
+      const init = fetchMock.mock.calls[0]?.[1] as RequestInit;
+      expect(JSON.parse(String(init.body))).toEqual({
+        kind: "Rollout",
+        group,
+        namespace: "prod",
+        name: "checkout",
+        agent: "codex",
+      });
+    },
+  );
+});
+
+it("passes durable SSE sequence IDs and explanation origin through replay", () => {
+  vi.stubGlobal("EventSource", FakeEventSource);
+  const onEvent = vi.fn();
+  const close = subscribeRun("sequence-test", { onEvent });
+  const source = FakeEventSource.instances.at(-1)!;
+  source.emit("done", { type: "done" }, "42");
+  source.emit("turn", { type: "turn", explainAssessment: 42 }, "43");
+  expect(onEvent).toHaveBeenNthCalledWith(1, { type: "done" }, 42);
+  expect(onEvent).toHaveBeenNthCalledWith(
+    2,
+    { type: "turn", explainAssessment: 42 },
+    43,
+  );
+  close();
+  vi.unstubAllGlobals();
+});
+
+describe("subscribeRun replay boundaries", () => {
+  beforeEach(() => {
+    FakeEventSource.instances = [];
+    vi.stubGlobal("EventSource", FakeEventSource);
+  });
+
+  afterEach(() => vi.unstubAllGlobals());
+
+  it("brackets every connection replay and forwards the completion marker", () => {
+    const starts = vi.fn();
+    const events: DiagnoseStreamEvent[] = [];
+    const cancel = subscribeRun("run-1", {
+      onReplayStart: starts,
+      onEvent: (event) => events.push(event),
+    });
+    const source = FakeEventSource.instances[0]!;
+
+    source.onopen?.();
+    source.emit("turn", { type: "turn" });
+    source.emit("replay_complete", { type: "replay_complete" });
+    source.onopen?.(); // EventSource reconnects through the same instance.
+
+    expect(starts).toHaveBeenCalledTimes(2);
+    expect(events.map((event) => event.type)).toEqual([
+      "turn",
+      "replay_complete",
+    ]);
+    cancel();
+    expect(source.closed).toBe(true);
+  });
+
+  it("distinguishes a durable closed sentinel from an unavailable stream", () => {
+    const durableClose = vi.fn();
+    subscribeRun("run-1", {
+      onEvent: vi.fn(),
+      onClosed: durableClose,
+    });
+    const closedSource = FakeEventSource.instances[0]!;
+    closedSource.emit("closed", { type: "closed" });
+    closedSource.readyState = FakeEventSource.CLOSED;
+    closedSource.onerror?.();
+    expect(durableClose).toHaveBeenCalledWith("run_closed");
+    expect(durableClose).toHaveBeenCalledTimes(1);
+
+    const unavailable = vi.fn();
+    subscribeRun("run-2", {
+      onEvent: vi.fn(),
+      onClosed: unavailable,
+    });
+    const source = FakeEventSource.instances[1]!;
+    source.readyState = FakeEventSource.CLOSED;
+    source.onerror?.();
+    expect(unavailable).toHaveBeenCalledWith("unavailable");
+  });
+
+  it("forwards hydration failures while preserving only retryable reconnects", () => {
+    const retryEvents: DiagnoseStreamEvent[] = [];
+    subscribeRun("run-retry", {
+      onEvent: (event) => retryEvents.push(event),
+    });
+    const retrySource = FakeEventSource.instances[0]!;
+    retrySource.emit("history_unavailable", {
+      type: "history_unavailable",
+      error: "history store is busy",
+      retryable: true,
+    });
+    expect(retryEvents).toEqual([
+      {
+        type: "history_unavailable",
+        error: "history store is busy",
+        retryable: true,
+      },
+    ]);
+    expect(retrySource.closed).toBe(false);
+
+    const permanentEvents: DiagnoseStreamEvent[] = [];
+    subscribeRun("run-permanent", {
+      onEvent: (event) => permanentEvents.push(event),
+    });
+    const permanentSource = FakeEventSource.instances[1]!;
+    permanentSource.emit("history_unavailable", {
+      type: "history_unavailable",
+      error: "history cannot be decoded",
+      retryable: false,
+    });
+    expect(permanentEvents.map((event) => event.type)).toEqual([
+      "history_unavailable",
+    ]);
+    expect(permanentSource.closed).toBe(true);
+  });
+
+  it("ignores a trailing closed frame after a permanent history failure", () => {
+    const events: DiagnoseStreamEvent[] = [];
+    const onClosed = vi.fn();
+    subscribeRun("run-corrupt-history", {
+      onEvent: (event) => events.push(event),
+      onClosed,
+    });
+    const source = FakeEventSource.instances[0]!;
+
+    source.emit("history_unavailable", {
+      type: "history_unavailable",
+      error: "history cannot be decoded",
+      retryable: false,
+    });
+    // This frame can already be queued when history_unavailable closes the
+    // EventSource. It must not relabel the run as evicted in InvestigationView.
+    source.emit("closed", { type: "closed" });
+
+    expect(events).toEqual([
+      {
+        type: "history_unavailable",
+        error: "history cannot be decoded",
+        retryable: false,
+      },
+    ]);
+    expect(onClosed).not.toHaveBeenCalled();
+  });
+
+  it("forwards evidence-backed apply outcomes on terminal events", () => {
+    const events: DiagnoseStreamEvent[] = [];
+    subscribeRun("run-apply", {
+      onEvent: (event) => events.push(event),
+    });
+    const source = FakeEventSource.instances[0]!;
+    source.emit("done", {
+      type: "done",
+      applyOutcome: "confirmed",
+      diagnosis: {
+        rootCause: "",
+        report: "Deployment updated.",
+        remediation: [],
+      },
+    });
+    source.emit("error", {
+      type: "error",
+      applyOutcome: "unknown",
+      error: "The write result was incomplete.",
+    });
+
+    expect(events).toEqual([
+      expect.objectContaining({ type: "done", applyOutcome: "confirmed" }),
+      expect.objectContaining({ type: "error", applyOutcome: "unknown" }),
+    ]);
+  });
+});
+
+describe("investigation start requests", () => {
+  afterEach(() => vi.unstubAllGlobals());
+
+  const target = {
+    kind: "Deployment",
+    group: "apps",
+    namespace: "prod",
+    name: "payments",
+    issueId: "issue-1",
+  };
+
+  it.each([
+    ["investigate further", target],
+    ["start fresh", { ...target, fresh: true }],
+  ])("preserves the %s intent on the wire", async (_name, request) => {
+    const fetch = vi
+      .fn()
+      .mockResolvedValue(new Response(JSON.stringify({ id: "new-run" })));
+    vi.stubGlobal("fetch", fetch);
+    await createRun(request, { agent: "hub" });
+    const init = fetch.mock.calls[0][1] as RequestInit;
+    expect(init.method).toBe("POST");
+    expect(JSON.parse(init.body as string)).toEqual({
+      ...request,
+      agent: "hub",
+    });
+    expect(JSON.parse(init.body as string).issueId).toBe("issue-1");
+  });
+});