fix(webapp): navigation filters speak the run page's language

Author: kathiekiwi

apps/webapp/app/components/dashboard-agent/navigate-target.test.ts

@@ -1,22 +1,39 @@
 import { describe, expect, it } from "vitest";
+import { getRunFiltersFromSearchParams } from "~/components/runs/v3/RunFilters";
 import { appendRunFilters, navigateDestination, sameOriginPath } from "./navigate-target";
 
 const RUNS_PATH = "/orgs/acme/projects/api/env/prod/runs";
 
+const FAILING = [
+  "COMPLETED_WITH_ERRORS",
+  "SYSTEM_FAILURE",
+  "CRASHED",
+  "EXPIRED",
+  "TIMED_OUT",
+  "INTERRUPTED",
+];
+
+/** What the runs page makes of a URL this module produced. */
+function pageReads(path: string) {
+  return getRunFiltersFromSearchParams(
+    new URLSearchParams(new URL(path, "https://x.invalid").search)
+  );
+}
+
 describe("appendRunFilters", () => {
   it("returns the path untouched with no filters", () => {
     expect(appendRunFilters(RUNS_PATH)).toBe(RUNS_PATH);
   });
 
   it("writes arrays as repeated params and keeps existing ones", () => {
     const result = appendRunFilters(`${RUNS_PATH}?query=payments`, {
-      statuses: ["FAILED", "CRASHED"],
+      statuses: ["COMPLETED_WITH_ERRORS", "CRASHED"],
       tasks: "send-email",
       period: "1d",
     });
 
     expect(result).toBe(
-      `${RUNS_PATH}?query=payments&statuses=FAILED&statuses=CRASHED&tasks=send-email&period=1d`
+      `${RUNS_PATH}?query=payments&statuses=COMPLETED_WITH_ERRORS&statuses=CRASHED&tasks=send-email&period=1d`
     );
   });
 
@@ -30,6 +47,51 @@ describe("appendRunFilters", () => {
     expect(appendRunFilters(RUNS_PATH, { search: "", rootOnly: false, tags: [] })).toBe(RUNS_PATH);
     expect(appendRunFilters(RUNS_PATH, { rootOnly: true })).toBe(`${RUNS_PATH}?rootOnly=true`);
   });
+
+  it("expands FAILED into the statuses the page calls failures", () => {
+    const result = appendRunFilters(RUNS_PATH, { statuses: ["FAILED"], period: "1d" });
+
+    expect(pageReads(result)).toEqual({ statuses: FAILING, period: "1d" });
+  });
+
+  it("takes the status the user said, however they cased it", () => {
+    expect(pageReads(appendRunFilters(RUNS_PATH, { statuses: "failed" }))).toEqual({
+      statuses: FAILING,
+    });
+  });
+
+  it("passes a page-native status through untranslated", () => {
+    const result = appendRunFilters(RUNS_PATH, { statuses: ["COMPLETED_SUCCESSFULLY"] });
+
+    expect(result).toBe(`${RUNS_PATH}?statuses=COMPLETED_SUCCESSFULLY`);
+    expect(pageReads(result)).toEqual({ statuses: ["COMPLETED_SUCCESSFULLY"] });
+  });
+
+  it("translates the other API status names the model borrows", () => {
+    expect(pageReads(appendRunFilters(RUNS_PATH, { statuses: ["QUEUED", "COMPLETED"] }))).toEqual({
+      statuses: ["PENDING", "COMPLETED_SUCCESSFULLY"],
+    });
+  });
+
+  it("drops a status the page cannot parse rather than losing every filter with it", () => {
+    const result = appendRunFilters(RUNS_PATH, { statuses: ["NONSENSE"], period: "1d" });
+
+    expect(result).toBe(`${RUNS_PATH}?period=1d`);
+    expect(pageReads(result)).toEqual({ period: "1d" });
+  });
+
+  // The page's parser has no `search`, and an unread param is only noise in the URL.
+  it("leaves search out of the URL", () => {
+    expect(appendRunFilters(RUNS_PATH, { search: "boom", period: "1d" })).toBe(
+      `${RUNS_PATH}?period=1d`
+    );
+  });
+
+  // Control: the untranslated URL is what the live failure looked like. One status the
+  // page cannot parse and it discards everything, the period included.
+  it("pins why translation is needed: raw FAILED wipes the whole filter set", () => {
+    expect(pageReads(`${RUNS_PATH}?statuses=FAILED&period=1d`)).toEqual({});
+  });
 });
 
 describe("navigateDestination", () => {
@@ -38,7 +100,10 @@ describe("navigateDestination", () => {
   it("routes a dashboard path and applies the intent's filters", () => {
     expect(
       navigateDestination({ path: RUNS_PATH, external: false }, { statuses: ["FAILED"] })
-    ).toEqual({ kind: "route", path: `${RUNS_PATH}?statuses=FAILED` });
+    ).toEqual({
+      kind: "route",
+      path: `${RUNS_PATH}?${FAILING.map((s) => `statuses=${s}`).join("&")}`,
+    });
   });
 
   it("never routes a source file, it leaves the dashboard", () => {

apps/webapp/app/components/dashboard-agent/navigate-target.ts

@@ -1,17 +1,69 @@
 // `trigger://` targets are resolved server-side in `resolveTriggerUri.server.ts`.
 import { type RunFilters } from "@internal/dashboard-agent-contracts";
+import { allTaskRunStatuses } from "~/components/runs/v3/TaskRunStatus";
 
 // Filter keys are the runs page's own URL params, except that the page reads these
 // bounds as epoch milliseconds while an intent carries ISO strings.
 const EPOCH_MS_KEYS = new Set(["from", "to"]);
 
+// The page's filter parser has no `search` param, so it would only clutter the URL.
+const UNSUPPORTED_KEYS = new Set(["search"]);
+
+type PageStatus = (typeof allTaskRunStatuses)[number];
+
+const PAGE_STATUSES = new Set<string>(allTaskRunStatuses);
+
+/** What a user means by "failed runs": every terminal status that is not a success or a cancel. */
+const FAILING_STATUSES = [
+  "COMPLETED_WITH_ERRORS",
+  "SYSTEM_FAILURE",
+  "CRASHED",
+  "EXPIRED",
+  "TIMED_OUT",
+  "INTERRUPTED",
+] as const satisfies readonly PageStatus[];
+
+/** Statuses the API (and so the model) uses that the runs page has never heard of. */
+const STATUS_ALIASES = {
+  FAILED: FAILING_STATUSES,
+  QUEUED: ["PENDING"],
+  COMPLETED: ["COMPLETED_SUCCESSFULLY"],
+  REATTEMPTING: ["RETRYING_AFTER_FAILURE"],
+  FROZEN: ["WAITING_TO_RESUME"],
+} as const satisfies Record<string, readonly PageStatus[]>;
+
+/**
+ * Statuses in the page's own vocabulary. One value it cannot parse makes it discard
+ * every filter — the period too — so anything unrecognized is dropped, not sent.
+ */
+function pageStatuses(values: readonly string[]): string[] {
+  const translated = new Set<string>();
+  for (const value of values) {
+    const status = value.trim().toUpperCase();
+    if (PAGE_STATUSES.has(status)) {
+      translated.add(status);
+      continue;
+    }
+    for (const alias of STATUS_ALIASES[status as keyof typeof STATUS_ALIASES] ?? []) {
+      translated.add(alias);
+    }
+  }
+  return [...translated];
+}
+
 export function appendRunFilters(path: string, filters?: RunFilters): string {
   if (!filters) return path;
   // A base is needed to parse a relative path; only pathname + search is used.
   const url = new URL(path, "https://dashboard.invalid");
 
   for (const [key, value] of Object.entries(filters)) {
     if (value === undefined || value === null || value === "") continue;
+    if (UNSUPPORTED_KEYS.has(key)) continue;
+    if (key === "statuses") {
+      const statuses = Array.isArray(value) ? value : [String(value)];
+      for (const status of pageStatuses(statuses)) url.searchParams.append(key, status);
+      continue;
+    }
     if (EPOCH_MS_KEYS.has(key)) {
       const epochMs = Date.parse(String(value));
       if (!Number.isNaN(epochMs)) url.searchParams.set(key, String(epochMs));