@agent-native/core 0.92.2 → 0.92.3

package/corpus/templates/analytics/app/pages/monitoring/uptime/MonitorDetail.tsx

@@ -36,6 +36,7 @@ import { cn } from "@/lib/utils";
 
 import { fmt, useUptimeT } from "./i18n";
 import type {
+  MonitorCheckDiagnostics,
   MonitorDetail as MonitorDetailData,
   MonitorStats,
   MonitorSummary,
@@ -420,17 +421,22 @@ export function MonitorDetail({
                             {formatLatency(result.latencyMs)}
                           </TableCell>
                           <TableCell className="max-w-[220px] text-xs text-muted-foreground">
-                            {result.failedAssertions.length > 0 ? (
-                              <span className="text-amber-500">
-                                {result.failedAssertions.join("; ")}
-                              </span>
-                            ) : result.error ? (
-                              <span className="text-destructive">
-                                {result.error}
-                              </span>
-                            ) : (
-                              <span className="text-emerald-500">{t.ok}</span>
-                            )}
+                            <div className="space-y-1">
+                              {result.failedAssertions.length > 0 ? (
+                                <span className="text-amber-500">
+                                  {result.failedAssertions.join("; ")}
+                                </span>
+                              ) : result.error ? (
+                                <span className="text-destructive">
+                                  {result.error}
+                                </span>
+                              ) : (
+                                <span className="text-emerald-500">{t.ok}</span>
+                              )}
+                              <div className="text-[11px] leading-snug text-muted-foreground/80">
+                                {formatDiagnostics(result.diagnostics)}
+                              </div>
+                            </div>
                           </TableCell>
                         </TableRow>
                       );
@@ -508,6 +514,30 @@ export function MonitorDetail({
   );
 }
 
+function formatDiagnostics(diagnostics: MonitorCheckDiagnostics): string {
+  const timings = diagnostics.timings ?? {};
+  const parts = [
+    diagnostics.source,
+    timings.requestMs != null
+      ? `headers ${formatLatency(timings.requestMs)}`
+      : null,
+    timings.ssrfSetupMs != null
+      ? `ssrf ${formatLatency(timings.ssrfSetupMs)}`
+      : null,
+    timings.bodyReadMs != null
+      ? `body ${formatLatency(timings.bodyReadMs)}`
+      : null,
+    diagnostics.response?.finalHost
+      ? `host ${diagnostics.response.finalHost}`
+      : null,
+    diagnostics.error?.kind ? `error ${diagnostics.error.kind}` : null,
+    diagnostics.runtime?.commitRef
+      ? `sha ${diagnostics.runtime.commitRef.slice(0, 7)}`
+      : null,
+  ].filter(Boolean);
+  return parts.join(" · ");
+}
+
 function StatCard({
   label,
   children,

package/corpus/templates/analytics/app/pages/monitoring/uptime/types.ts

@@ -91,6 +91,50 @@ export interface MonitorCheckResult {
   latencyMs: number | null;
   error: string | null;
   failedAssertions: string[];
+  diagnostics: MonitorCheckDiagnostics;
+}
+
+export interface MonitorCheckDiagnostics {
+  source:
+    | "netlify-scheduled"
+    | "netlify-runtime"
+    | "in-process"
+    | "manual"
+    | "unknown";
+  runtime: {
+    nodeEnv?: string;
+    netlify?: boolean;
+    deployId?: string;
+    deployContext?: string;
+    commitRef?: string;
+    functionName?: string;
+    region?: string;
+  };
+  request: {
+    method: MonitorMethod;
+    timeoutMs: number;
+    followRedirects: boolean;
+    assertionTypes: AssertionType[];
+    bodyReadRequired: boolean;
+    allowPrivateHosts: boolean;
+  };
+  timings: {
+    totalMs?: number;
+    ssrfSetupMs?: number;
+    requestMs?: number;
+    bodyReadMs?: number;
+  };
+  response?: {
+    finalUrl?: string;
+    finalHost?: string;
+    statusCode?: number;
+    headers?: Record<string, string>;
+  };
+  error?: {
+    kind: "config" | "timeout" | "network" | "body-timeout";
+    name?: string;
+    message: string;
+  };
 }
 
 export interface MonitorIncident {

package/corpus/templates/analytics/changelog/2026-07-09-dashboard-action-menus-now-close-cleanly-before-opening-hist.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-09
+---
+
+Dashboard action menus now close cleanly before opening history, email, archive, or delete dialogs.

package/corpus/templates/analytics/changelog/2026-07-09-dashboard-email-reports-still-send-when-the-screenshot-captu.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-09
+---
+
+Dashboard email report screenshots load reliably after dashboard URL redirects.

package/corpus/templates/analytics/changelog/2026-07-09-uptime-alerts-now-suppress-recovery-noise-during-flapping-an.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-09
+---
+
+Uptime alerts now suppress recovery noise during flapping and confirm slow-response spikes before emailing.

package/corpus/templates/analytics/changelog/2026-07-09-uptime-check-history-now-shows-timing-diagnostics-so-slow-or.md

@@ -0,0 +1,6 @@
+---
+type: improved
+date: 2026-07-09
+---
+
+Uptime check history now shows timing diagnostics so slow or timed-out probes are easier to debug.

package/corpus/templates/analytics/changelog/2026-07-09-uptime-recovery-alerts-now-send-when-the-original-outage-not.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-09
+---
+
+Uptime recovery alerts now send when the original outage notification reached email, Slack, or webhook channels.

package/corpus/templates/analytics/docs/uptime-monitoring.md

@@ -38,6 +38,10 @@ Each check runs on the server (`server/lib/uptime-monitors.ts`):
    - `down` — the status does not match, a content/header assertion fails, or
      the request errored/timed out. Alerts at the monitor's configured severity.
    - `error` — a configuration/SSRF problem prevented the check from running.
+6. Persist a compact diagnostics payload on the check row with safe runtime
+   context, phase timings, response headers such as `x-nf-request-id`, and the
+   error kind. Diagnostics intentionally exclude request headers, request bodies,
+   response bodies, secrets, and large payloads.
 
 ### Status matcher
 
@@ -73,15 +77,19 @@ Each check runs on the server (`server/lib/uptime-monitors.ts`):
   `emailRecipients`; `slack` / `webhook` use the monitor's optional
   delivery-only `slackWebhookUrl` / `webhookUrl` (falling back to workspace
   `NOTIFICATIONS_SLACK_WEBHOOK_URL` / `NOTIFICATIONS_WEBHOOK_URL` when unset).
-- Transient no-response failures, such as network errors or timeouts, must fail
-  twice in a row before opening an incident or alerting. Set
+- Transient no-response failures, such as network errors or timeouts, and
+  transient latency degradations must fail twice in a row before opening an
+  incident or alerting. Set
   `UPTIME_MONITOR_TRANSIENT_FAILURE_CONFIRMATION_CHECKS=1` to alert on the first
   transient failure, or a higher value (max 10) for stricter confirmation.
 - While an incident is open it will not re-alert. After an incident resolves,
   `cooldownMinutes` suppresses a fresh "down" alert for that window to prevent
-  flapping.
+  flapping. Incidents opened during that quiet window do not send recovery
+  emails either, so one flaky target cannot produce "recovered" noise for an
+  alert that was intentionally suppressed.
 - On **recovery**, it resolves the open incident and sends an informational
-  "recovered" notification (with downtime duration).
+  "recovered" notification (with downtime duration) only when the incident sent
+  an initial down/degraded notification.
 
 A `lastStatus === "running"` claim guard (with a staleness timeout) ensures that
 concurrent sweeps never double-run the same monitor.
@@ -105,23 +113,28 @@ set `UPTIME_MONITOR_ALLOW_PRIVATE_HOSTS=1` (off by default).
 
 ## Background job
 
-The sweep is registered by `server/plugins/uptime-monitor-jobs.ts` and runs
+The sweep is registered by `server/plugins/uptime-monitor-jobs.ts` for
+long-lived runtimes. Netlify builds emit a scheduled trigger plus background
+worker from `scripts/emit-netlify-dashboard-report-cron.ts`; the route
+`/api/uptime-monitors/run` is callable by that generated worker or by an
+external cron with `UPTIME_MONITORS_CRON_SECRET`. Both paths run
 `runDueMonitorsOnce()` (`server/jobs/uptime-monitors.ts`), which selects enabled
 monitors whose interval has elapsed, checks them, records results, opens/resolves
 incidents, and prunes old check results.
 
 Environment flags (mirrors the analytics alert job):
 
-| flag                                                   | effect                                                                             |
-| ------------------------------------------------------ | ---------------------------------------------------------------------------------- |
-| `UPTIME_MONITOR_JOBS`                                  | `1` enables the in-process cron; `0` disables it.                                  |
-| `RUN_BACKGROUND_JOBS`                                  | fallback flag when `UPTIME_MONITOR_JOBS` is unset.                                 |
-| (production)                                           | on by default unless a flag is `0` or a platform scheduler owns it.                |
-| `UPTIME_MONITOR_INTERVAL_MS`                           | wake interval for the sweep (default 30s, min 10s).                                |
-| `UPTIME_MONITOR_SWEEP_LIMIT`                           | max monitors processed per sweep (default 100).                                    |
-| `UPTIME_MONITOR_RESULT_RETENTION_DAYS`                 | how long check results are kept (default 30).                                      |
-| `UPTIME_MONITOR_ALLOW_PRIVATE_HOSTS`                   | allow probing private/internal hosts.                                              |
-| `UPTIME_MONITOR_TRANSIENT_FAILURE_CONFIRMATION_CHECKS` | consecutive timeout/network failures required before alerting (default 2, max 10). |
+| flag                                                   | effect                                                                                           |
+| ------------------------------------------------------ | ------------------------------------------------------------------------------------------------ |
+| `UPTIME_MONITOR_JOBS`                                  | `1` enables the in-process cron; `0` disables it.                                                |
+| `RUN_BACKGROUND_JOBS`                                  | fallback flag when `UPTIME_MONITOR_JOBS` is unset.                                               |
+| (production)                                           | on by default unless a flag is `0` or a platform scheduler owns it.                              |
+| `UPTIME_MONITOR_INTERVAL_MS`                           | wake interval for the sweep (default 30s, min 10s).                                              |
+| `UPTIME_MONITOR_SWEEP_LIMIT`                           | max monitors processed per sweep (default 100).                                                  |
+| `UPTIME_MONITOR_RESULT_RETENTION_DAYS`                 | how long check results are kept (default 30).                                                    |
+| `UPTIME_MONITOR_ALLOW_PRIVATE_HOSTS`                   | allow probing private/internal hosts.                                                            |
+| `UPTIME_MONITOR_TRANSIENT_FAILURE_CONFIRMATION_CHECKS` | consecutive timeout/network/slow-response failures required before alerting (default 2, max 10). |
+| `UPTIME_MONITORS_CRON_SECRET`                          | bearer token for external cron callers of `/api/uptime-monitors/run`.                            |
 
 The monitor tables (`monitors`, `monitor_check_results`, `monitor_incidents`)
 are created by the app migration list in `server/plugins/db.ts`, which runs at
@@ -157,7 +170,7 @@ All three tables carry `ownableColumns()` (`owner_email` / `org_id` /
   `last_checked_at`, `last_success_at`, `last_error`, `last_latency_ms`,
   `last_status_code`, `consecutive_failures`).
 - **`monitor_check_results`** — one row per probe (`ok`, `status`, `status_code`,
-  `latency_ms`, `error`, `failed_assertions`), indexed on
+  `latency_ms`, `error`, `failed_assertions`, `diagnostics`), indexed on
   `(monitor_id, checked_at)`; pruned by the sweep so it stays bounded.
 - **`monitor_incidents`** — one row per failure streak (`started_at`,
   `resolved_at` null = ongoing, `cause`, `severity`, `notification_id`,

package/corpus/templates/analytics/netlify.toml

@@ -26,3 +26,6 @@ memory = "2gb"
 
 [functions.analytics-alert-sweep-background]
 timeout = 120
+
+[functions.uptime-monitor-sweep-background]
+timeout = 120

package/corpus/templates/analytics/scripts/emit-netlify-dashboard-report-cron.ts

@@ -16,6 +16,10 @@ const ALERT_SCHEDULED_NAME = "analytics-alert-cron";
 const ALERT_WORKER_NAME = "analytics-alert-sweep-background";
 const ALERT_ROUTE_PATH = "/api/analytics-alerts/run";
 const ALERT_SCHEDULE = "*/5 * * * *";
+const UPTIME_SCHEDULED_NAME = "uptime-monitor-cron";
+const UPTIME_WORKER_NAME = "uptime-monitor-sweep-background";
+const UPTIME_ROUTE_PATH = "/api/uptime-monitors/run";
+const UPTIME_SCHEDULE = "* * * * *";
 
 function ensureDir(dir: string) {
   mkdirSync(dir, { recursive: true });
@@ -236,6 +240,122 @@ export const config = {
   writeFileSync(path.join(dest, `${ALERT_WORKER_NAME}.mjs`), source);
 }
 
+function emitUptimeScheduledTrigger(token: string) {
+  const dest = path.join(FUNCTIONS_DIR, UPTIME_SCHEDULED_NAME);
+  rmSync(dest, { recursive: true, force: true });
+  ensureDir(dest);
+
+  const source = `const WORKER_PATH = "/.netlify/functions/${UPTIME_WORKER_NAME}";
+const CRON_TOKEN = ${JSON.stringify(token)};
+
+function siteOrigin(request) {
+  const configured = process.env.URL || process.env.DEPLOY_URL;
+  if (configured) return configured;
+  const url = new URL(request.url);
+  return url.origin;
+}
+
+async function readScheduledInvocation(request) {
+  if (request.method !== "POST") return null;
+  let body;
+  try {
+    body = await request.json();
+  } catch {
+    return null;
+  }
+  const nextRun = typeof body?.next_run === "string" ? body.next_run : "";
+  return nextRun && Number.isFinite(Date.parse(nextRun))
+    ? { nextRun }
+    : null;
+}
+
+export default async function handler(request) {
+  const scheduled = await readScheduledInvocation(request);
+  if (!scheduled) return new Response("Not Found", { status: 404 });
+
+  const url = new URL(WORKER_PATH, siteOrigin(request));
+  const response = await fetch(url.toString(), {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+      "x-agent-native-uptime-monitor-cron": CRON_TOKEN,
+    },
+    body: JSON.stringify({ scheduled: true, next_run: scheduled.nextRun }),
+  });
+
+  if (!response.ok && response.status !== 202) {
+    console.error(
+      "[uptime-monitor-cron] Background sweep trigger failed:",
+      response.status,
+      await response.text().catch(() => ""),
+    );
+  }
+}
+
+export const config = {
+  name: "uptime monitor cron trigger",
+  generator: "agent-native analytics build",
+  schedule: ${JSON.stringify(UPTIME_SCHEDULE)},
+};
+`;
+
+  writeFileSync(path.join(dest, `${UPTIME_SCHEDULED_NAME}.mjs`), source);
+}
+
+function emitUptimeBackgroundWorker(token: string) {
+  const dest = path.join(FUNCTIONS_DIR, UPTIME_WORKER_NAME);
+  rmSync(dest, { recursive: true, force: true });
+  cpSync(SERVER_DIR, dest, { recursive: true });
+  rmSync(path.join(dest, "server.mjs"), { force: true });
+
+  const source = `globalThis.__AGENT_NATIVE_UPTIME_MONITOR_SCHEDULED_RUNTIME__ = true;
+
+const CRON_TOKEN = ${JSON.stringify(token)};
+const ROUTE_PATH = ${JSON.stringify(UPTIME_ROUTE_PATH)};
+let cachedHandler;
+
+function timingSafeEquals(a, b) {
+  if (a.length !== b.length) return false;
+  let diff = 0;
+  for (let i = 0; i < a.length; i += 1) {
+    diff |= a.charCodeAt(i) ^ b.charCodeAt(i);
+  }
+  return diff === 0;
+}
+
+export default async function handler(request, context) {
+  const token = request.headers.get("x-agent-native-uptime-monitor-cron") || "";
+  if (!timingSafeEquals(token, CRON_TOKEN)) {
+    return new Response("Unauthorized", { status: 401 });
+  }
+
+  cachedHandler ??= (await import("./main.mjs")).default;
+  const url = new URL(request.url);
+  url.pathname = ROUTE_PATH;
+  url.search = "";
+
+  const rewritten = new Request(url.toString(), {
+    method: "POST",
+    headers: new Headers({ "content-type": "application/json" }),
+    body: JSON.stringify({ scheduled: true }),
+  });
+
+  return await cachedHandler(rewritten, context);
+}
+
+export const config = {
+  name: "uptime monitor background sweep",
+  generator: "agent-native analytics build",
+  background: true,
+  nodeBundler: "none",
+  includedFiles: ["**"],
+  preferStatic: false,
+};
+`;
+
+  writeFileSync(path.join(dest, `${UPTIME_WORKER_NAME}.mjs`), source);
+}
+
 function isDirectRun(): boolean {
   const entrypoint = process.argv[1];
   return Boolean(
@@ -254,16 +374,22 @@ function main(): void {
 
   const token = randomBytes(32).toString("hex");
   const alertToken = randomBytes(32).toString("hex");
+  const uptimeToken = randomBytes(32).toString("hex");
   emitScheduledTrigger(token);
   emitBackgroundWorker(token);
   emitAlertScheduledTrigger(alertToken);
   emitAlertBackgroundWorker(alertToken);
+  emitUptimeScheduledTrigger(uptimeToken);
+  emitUptimeBackgroundWorker(uptimeToken);
   console.log(
     `[dashboard-report-cron] Emitted Netlify scheduled trigger "${SCHEDULED_NAME}" (${SCHEDULE}) and background worker "${WORKER_NAME}".`,
   );
   console.log(
     `[analytics-alert-cron] Emitted Netlify scheduled trigger "${ALERT_SCHEDULED_NAME}" (${ALERT_SCHEDULE}) and background worker "${ALERT_WORKER_NAME}".`,
   );
+  console.log(
+    `[uptime-monitor-cron] Emitted Netlify scheduled trigger "${UPTIME_SCHEDULED_NAME}" (${UPTIME_SCHEDULE}) and background worker "${UPTIME_WORKER_NAME}".`,
+  );
 }
 
 if (isDirectRun()) {

package/corpus/templates/analytics/server/db/schema-monitoring.ts

@@ -109,6 +109,8 @@ export const monitorCheckResults = table("monitor_check_results", {
   error: text("error"),
   /** JSON array of human-readable assertion failures. */
   failedAssertions: text("failed_assertions").notNull().default("[]"),
+  /** Compact JSON with phase timings and safe runtime/response metadata. */
+  diagnostics: text("diagnostics").notNull().default("{}"),
   createdAt: text("created_at").notNull().default(now()),
   ...ownableColumns(),
 });
@@ -129,6 +131,9 @@ export const monitorIncidents = table("monitor_incidents", {
   cause: text("cause").notNull().default(""),
   lastError: text("last_error"),
   notificationId: text("notification_id"),
+  notificationDelivered: integer("notification_delivered", { mode: "boolean" })
+    .notNull()
+    .default(false),
   checksFailed: integer("checks_failed").notNull().default(1),
   createdAt: text("created_at").notNull().default(now()),
   ...ownableColumns(),

package/corpus/templates/analytics/server/jobs/uptime-monitors.ts

@@ -51,6 +51,7 @@ export async function runDueMonitorsOnce(
     ownerEmail?: string;
     orgId?: string | null;
     limit?: number;
+    source?: "netlify-scheduled" | "in-process";
   } = {},
 ): Promise<UptimeSweepResult> {
   if (running) {
@@ -94,7 +95,10 @@ export async function runDueMonitorsOnce(
         const claimed = await claimMonitorRun(monitor);
         if (!claimed) continue;
         processed++;
-        const outcome = await runMonitorCheck(monitor, { allowPrivateHosts });
+        const outcome = await runMonitorCheck(monitor, {
+          allowPrivateHosts,
+          source: options.source,
+        });
         await recordMonitorResult(monitor, outcome);
         await evaluateAndNotifyMonitor(monitor, outcome, {
           email: monitor.ownerEmail,