fix(dashboard-agent): read the alerts API's real response shape

create_alert reached for an `alert` envelope the route never sent, so it
always reported undefined, and the 403 branch keyed on `reason` where the
route sends `code` — the "email isn't set up on this instance" wording was
unreachable. The unit fixtures were written against both invented shapes, so
they hid it; they now mirror the route's bodies exactly.

The subscribe path also inlined its deduplication key instead of calling
`watchAlertDeduplicationKey`, the one record of whose channel it is.

Author: kathiekiwi

apps/webapp/app/routes/api.v1.dashboard-agent.alerts.ts

@@ -12,6 +12,7 @@ import {
 import {
   canUseDashboardAgentEmailAlerts,
   DASHBOARD_AGENT_WATCH_ALERT_TYPE,
+  watchAlertDeduplicationKey,
 } from "~/services/dashboardAgentWatchAlerts.server";
 import { logger } from "~/services/logger.server";
 import { authenticateUatOrApiRequest } from "~/services/uatRoutePreamble.server";
@@ -179,7 +180,7 @@ export async function action({ request }: ActionFunctionArgs) {
       alertTypes: [DASHBOARD_AGENT_WATCH_ALERT_TYPE],
       environmentTypes: [environment.type],
       // Stable per (email, project), so asking twice re-enables one channel.
-      deduplicationKey: `dashboard-agent-watch:${email}`,
+      deduplicationKey: watchAlertDeduplicationKey(email),
       channel: { type: "EMAIL", email },
     });
 

internal-packages/dashboard-agent/src/dashboard-agent.test.ts

@@ -2237,11 +2237,20 @@ describe("watch alert tools", () => {
     expect(result).toEqual({ alerts });
   });
 
+  // The body below is exactly what `api.v1.dashboard-agent.alerts.ts` returns on success:
+  // the channel flat, with no envelope around it.
+  const CREATED_CHANNEL = {
+    id: "alert_2",
+    type: "EMAIL",
+    target: "so…@example.com",
+    enabled: true,
+  };
+
   it("create_alert posts the email channel and reports the created alert", async () => {
     const { result, requests } = await callAlertTool(
       "create_alert",
       { email: "someone@example.com" },
-      { body: { ok: true, alert: { id: "alert_2", type: "EMAIL" } } }
+      { body: CREATED_CHANNEL }
     );
 
     expect(requests[0]?.url).toBe("http://localhost:3030/api/v1/dashboard-agent/alerts");
@@ -2251,30 +2260,31 @@ describe("watch alert tools", () => {
       channel: "email",
       email: "someone@example.com",
     });
-    expect(result).toEqual({ created: true, alert: { id: "alert_2", type: "EMAIL" } });
+    expect(result).toEqual({ created: true, alert: CREATED_CHANNEL });
 
     // With no email the host defaults to the user's account email, so the body carries
     // only the chat scope and the channel.
-    const noEmail = await callAlertTool("create_alert", {}, { body: { ok: true } });
+    const noEmail = await callAlertTool("create_alert", {}, { body: CREATED_CHANNEL });
     expect(JSON.parse(String(noEmail.requests[0]?.init?.body))).toEqual({
       chatId: "chat_alerts",
       channel: "email",
     });
   });
 
+  // `code` is the key both alert routes send a 403 refusal under.
   it("create_alert relays a 403 with the reason the host gave", async () => {
     const noEmailSetup = await callAlertTool(
       "create_alert",
       {},
-      { status: 403, body: { error: "denied", reason: "email_alerts_not_configured" } }
+      { status: 403, body: { error: "denied", code: "email_alerts_not_configured" } }
     );
     expect(noEmailSetup.result.error).toContain("isn't set up on this instance");
     expect(noEmailSetup.result.error).toContain("dashboard");
 
     const flag = await callAlertTool(
       "create_alert",
       {},
-      { status: 403, body: { error: "denied", reason: "dashboard_agent_disabled" } }
+      { status: 403, body: { error: "denied", code: "dashboard_agent_disabled" } }
     );
     expect(flag.result.error).toContain("aren't enabled here");
   });

internal-packages/dashboard-agent/src/tool-alerts.ts

@@ -36,14 +36,14 @@ export function buildAlertTools(args: {
     }
 
     const data = (await res.json().catch(() => undefined)) as
-      | { error?: string; reason?: string; code?: string }
+      | { error?: string; code?: string }
       | undefined;
 
-    // 403 is a capability refusal and `reason` says which one.
+    // 403 is a capability refusal and `code` says which one.
     if (res.status === 403) {
       return {
         error:
-          data?.reason === "email_alerts_not_configured"
+          data?.code === "email_alerts_not_configured"
             ? "Email delivery isn't set up on this instance, so an email alert can't be created. Tell the user that, and that watch results still show in the dashboard."
             : "Email alerts aren't enabled here. Tell the user that, and that watch results still show in the dashboard.",
       };
@@ -86,7 +86,8 @@ export function buildAlertTools(args: {
           ...(email ? { email } : {}),
         });
         if ("error" in result) return result;
-        return { created: true, alert: (result.data as { alert?: unknown } | undefined)?.alert };
+        // The route's body is the channel itself, not an envelope around one.
+        return { created: true, alert: result.data };
       },
     }),