@agent-native/core 0.92.0 → 0.92.2

package/corpus/templates/analytics/changelog/2026-07-08-uptime-checks-no-longer-count-ssrf-setup-time-against-the-re.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-08
+---
+
+Uptime checks no longer count SSRF setup time against the request timeout, cutting false timeout alerts

package/corpus/templates/analytics/changelog/2026-07-08-uptime-checks-reuse-one-keep-alive-connection-so-recorded-la.md

@@ -0,0 +1,6 @@
+---
+type: improved
+date: 2026-07-08
+---
+
+Uptime checks reuse one keep-alive connection, so recorded latency reflects the real response time instead of a fresh handshake each probe.

package/corpus/templates/analytics/changelog/2026-07-08-uptime-monitors-now-confirm-transient-timeout-failures-befor.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-08
+---
+
+Uptime monitors now confirm transient timeout failures before alerting, reducing noisy false alarms.

package/corpus/templates/analytics/changelog/2026-07-08-uptime-monitors-now-use-a-10-second-request-timeout-by-defau.md

@@ -0,0 +1,6 @@
+---
+type: improved
+date: 2026-07-08
+---
+
+Uptime monitors now use a 10-second request timeout by default and update existing short-timeout checks.

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

@@ -19,12 +19,19 @@ are shareable and the agent can deep-link a monitor.
 
 Each check runs on the server (`server/lib/uptime-monitors.ts`):
 
-1. Fetch the monitor's `url` with the configured `method`, headers, and body,
-   through an SSRF-safe path, with an `AbortController` timeout.
-2. Measure latency and read up to **512 KB** of the response body (skipped for
-   `HEAD`).
-3. Evaluate the **status matcher** and every **assertion**.
-4. Classify the result:
+1. Run SSRF setup (dispatcher + DNS private-address check) **outside** the
+   request timeout budget. The connect-time dispatcher is built once and reused
+   across checks (HTTP keep-alive), so latency reflects the real request round
+   trip instead of a fresh DNS + TCP + TLS handshake on every probe.
+2. Fetch the monitor's `url` with the configured `method`, headers, and body,
+   through that SSRF-safe path, with an `AbortController` timeout that covers
+   only the HTTP request (headers / redirect chain).
+3. Measure latency from the HTTP response headers. If a body assertion is
+   configured, read up to **512 KB** of the response body (skipped for `HEAD`)
+   with a bounded body-read timer after clearing the request abort timer, so a
+   slow body cannot be mislabeled as a request timeout or hang indefinitely.
+4. Evaluate the **status matcher** and every **assertion**.
+5. Classify the result:
    - `up` — status matches and all assertions pass.
    - `degraded` — status matches but only a `max_latency_ms` assertion fails
      (the endpoint responded, just too slowly). Alerts at `warning` severity.
@@ -58,14 +65,18 @@ Each check runs on the server (`server/lib/uptime-monitors.ts`):
 
 `evaluateAndNotifyMonitor` manages incidents like the analytics alert engine:
 
-- On a transition **into failure**, it opens a `monitor_incidents` row (one per
-  continuous failure streak) and calls `notifyWithDelivery` with a clear title
-  and body plus safe inbox metadata
+- On a transition **into confirmed failure**, it opens a `monitor_incidents` row
+  (one per continuous failure streak) and calls `notifyWithDelivery` with a
+  clear title and body plus safe inbox metadata
   `{ kind: "uptime_monitor", monitorId, url, statusCode, latencyMs, failedAssertions, emailRecipients }`.
   The `inbox` channel is the in-app bell; `email` uses the monitor's
   `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
+  `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.
@@ -101,15 +112,16 @@ 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.                               |
+| 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). |
 
 The monitor tables (`monitors`, `monitor_check_results`, `monitor_incidents`)
 are created by the app migration list in `server/plugins/db.ts`, which runs at

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

@@ -42,7 +42,7 @@ export const monitors = table("monitors", {
   /** Optional request body (POST/PUT/PATCH). */
   requestBody: text("request_body"),
   intervalSeconds: integer("interval_seconds").notNull().default(300),
-  timeoutMs: integer("timeout_ms").notNull().default(15000),
+  timeoutMs: integer("timeout_ms").notNull().default(10000),
   /**
    * Status matcher as JSON. One of:
    *   { "mode": "class", "classes": ["2xx","3xx"] }

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

@@ -38,11 +38,38 @@ export const dashboards = table("dashboards", {
   /** Hidden dashboards are omitted from default navigation but remain openable. */
   hiddenAt: text("hidden_at"),
   hiddenBy: text("hidden_by"),
+  /** Last authenticated user who changed dashboard metadata/config, if tracked. */
+  updatedBy: text("updated_by"),
   ...ownableColumns(),
 });
 
 export const dashboardShares = createSharesTable("dashboard_shares");
 
+/**
+ * Bounded dashboard history. Each row snapshots the previous dashboard config
+ * before a meaningful save so users and agents can restore known-good states.
+ */
+export const dashboardRevisions = table(
+  "dashboard_revisions",
+  {
+    id: text("id").primaryKey(),
+    dashboardId: text("dashboard_id").notNull(),
+    kind: text("kind", { enum: ["explorer", "sql"] }).notNull(),
+    title: text("title").notNull(),
+    config: text("config").notNull(),
+    createdAt: text("created_at").notNull().default(now()),
+    createdBy: text("created_by"),
+    ownerEmail: text("owner_email").notNull().default("local@localhost"),
+    orgId: text("org_id"),
+  },
+  (t) => ({
+    dashboardCreatedIdx: index("dashboard_revisions_dashboard_created_idx").on(
+      t.dashboardId,
+      t.createdAt,
+    ),
+  }),
+);
+
 /**
  * Saved filter views per dashboard. Lives alongside the parent and is
  * governed by the parent's sharing (no separate share rows).
@@ -117,6 +144,31 @@ export const analyses = table("analyses", {
   ...ownableColumns(),
 });
 
+export const analysisRevisions = table(
+  "analysis_revisions",
+  {
+    id: text("id").primaryKey(),
+    analysisId: text("analysis_id").notNull(),
+    name: text("name").notNull(),
+    description: text("description").notNull().default(""),
+    question: text("question").notNull().default(""),
+    instructions: text("instructions").notNull().default(""),
+    dataSources: text("data_sources").notNull().default("[]"),
+    resultMarkdown: text("result_markdown").notNull().default(""),
+    resultData: text("result_data"),
+    createdAt: text("created_at").notNull().default(now()),
+    createdBy: text("created_by"),
+    ownerEmail: text("owner_email").notNull().default("local@localhost"),
+    orgId: text("org_id"),
+  },
+  (t) => ({
+    analysisCreatedIdx: index("analysis_revisions_analysis_created_idx").on(
+      t.analysisId,
+      t.createdAt,
+    ),
+  }),
+);
+
 export const analysisShares = createSharesTable("analysis_shares");
 
 /**
@@ -209,6 +261,10 @@ export const analyticsAlertRules = table("analytics_alert_rules", {
     .default("warning"),
   channels: text("channels").notNull().default('["inbox"]'),
   emailRecipients: text("email_recipients").notNull().default("[]"),
+  /** Optional per-rule Slack incoming webhook URL (overrides workspace env). */
+  slackWebhookUrl: text("slack_webhook_url"),
+  /** Optional per-rule generic webhook URL (overrides workspace env). */
+  webhookUrl: text("webhook_url"),
   enabled: integer("enabled", { mode: "boolean" }).notNull().default(true),
   lastEvaluatedAt: text("last_evaluated_at"),
   lastTriggeredAt: text("last_triggered_at"),

package/corpus/templates/analytics/server/lib/analytics-alerts.ts

@@ -2,6 +2,7 @@ import { createHash, randomUUID } from "node:crypto";
 
 import { notifyWithDelivery } from "@agent-native/core/notifications";
 import { recordChange } from "@agent-native/core/server";
+import { getUserSetting, putUserSetting } from "@agent-native/core/settings";
 import {
   and,
   asc,
@@ -53,9 +54,15 @@ export interface AnalyticsAlertRuleInput {
   severity?: AnalyticsAlertSeverity;
   channels?: string[];
   emailRecipients?: string[];
+  slackWebhookUrl?: string | null;
+  webhookUrl?: string | null;
   enabled?: boolean;
 }
 
+export interface AnalyticsAlertRuleDefaults {
+  emailRecipients: string[];
+}
+
 export interface AnalyticsAlertRule {
   id: string;
   name: string;
@@ -70,6 +77,8 @@ export interface AnalyticsAlertRule {
   severity: AnalyticsAlertSeverity;
   channels: string[];
   emailRecipients: string[];
+  slackWebhookUrl: string | null;
+  webhookUrl: string | null;
   enabled: boolean;
   lastEvaluatedAt: string | null;
   lastTriggeredAt: string | null;
@@ -126,6 +135,7 @@ function nowIso(): string {
 
 const ALERT_RULE_RUNNING_STALE_MS = 15 * 60 * 1000;
 const DEFAULT_HTTP_5XX_ALERT_ID_PREFIX = "default-http-5xx-spike";
+const ALERT_RULE_DEFAULTS_KEY = "analytics-alert-rule-defaults";
 
 function safeJsonParse<T>(raw: unknown, fallback: T): T {
   if (typeof raw !== "string" || !raw.trim()) return fallback;
@@ -143,6 +153,10 @@ function normalizeName(name: string): string {
   return normalized.slice(0, 120);
 }
 
+function badRequest(message: string): Error {
+  return Object.assign(new Error(message), { statusCode: 400 });
+}
+
 function normalizeNullableText(
   value: string | null | undefined,
 ): string | null {
@@ -203,6 +217,61 @@ function normalizeEmailRecipients(recipients: string[] | undefined): string[] {
   return normalized;
 }
 
+function alertRuleDefaultsKey(ctx: AccessCtx): string {
+  return `${ALERT_RULE_DEFAULTS_KEY}:${ctx.orgId ?? "personal"}`;
+}
+
+function settingStringArray(value: unknown): string[] {
+  return Array.isArray(value)
+    ? value.filter((item): item is string => typeof item === "string")
+    : [];
+}
+
+export async function getAnalyticsAlertRuleDefaults(
+  ctx: AccessCtx,
+): Promise<AnalyticsAlertRuleDefaults> {
+  const stored = await getUserSetting(ctx.email, alertRuleDefaultsKey(ctx));
+  return {
+    emailRecipients: normalizeEmailRecipients(
+      settingStringArray(stored?.emailRecipients),
+    ),
+  };
+}
+
+export async function rememberAnalyticsAlertRuleDefaults(
+  input: Pick<AnalyticsAlertRuleInput, "emailRecipients">,
+  ctx: AccessCtx,
+): Promise<void> {
+  const emailRecipients = normalizeEmailRecipients(input.emailRecipients);
+  if (emailRecipients.length === 0) return;
+  try {
+    await putUserSetting(ctx.email, alertRuleDefaultsKey(ctx), {
+      emailRecipients,
+      updatedAt: nowIso(),
+    });
+  } catch (error) {
+    console.warn("Failed to persist analytics alert rule defaults", error);
+  }
+}
+
+function normalizeOptionalHttpUrl(
+  value: string | null | undefined,
+  label: string,
+): string | null {
+  const trimmed = typeof value === "string" ? value.trim() : "";
+  if (!trimmed) return null;
+  let parsed: URL;
+  try {
+    parsed = new URL(trimmed);
+  } catch {
+    throw badRequest(`${label} must be an absolute http(s) URL`);
+  }
+  if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+    throw badRequest(`${label} must be an absolute http(s) URL`);
+  }
+  return trimmed;
+}
+
 function boolEnv(name: string): boolean | null {
   const raw = process.env[name]?.trim().toLowerCase();
   if (!raw) return null;
@@ -292,6 +361,8 @@ function rowToRule(row: any): AnalyticsAlertRule {
     severity: row.severity === "critical" ? "critical" : "warning",
     channels: safeJsonParse<string[]>(row.channels, ["inbox"]),
     emailRecipients: safeJsonParse<string[]>(row.emailRecipients, []),
+    slackWebhookUrl: row.slackWebhookUrl?.trim() || null,
+    webhookUrl: row.webhookUrl?.trim() || null,
     enabled: row.enabled === true || row.enabled === 1,
     lastEvaluatedAt: row.lastEvaluatedAt ?? null,
     lastTriggeredAt: row.lastTriggeredAt ?? null,
@@ -360,6 +431,11 @@ export async function saveAnalyticsAlertRule(
   const severity = input.severity === "critical" ? "critical" : "warning";
   const emailRecipients = normalizeEmailRecipients(input.emailRecipients);
   const channels = normalizeChannels(input.channels, emailRecipients);
+  const slackWebhookUrl = normalizeOptionalHttpUrl(
+    input.slackWebhookUrl,
+    "Slack webhook URL",
+  );
+  const webhookUrl = normalizeOptionalHttpUrl(input.webhookUrl, "Webhook URL");
   const enabled = input.enabled ?? true;
   const db = getDb() as any;
 
@@ -385,6 +461,8 @@ export async function saveAnalyticsAlertRule(
         severity,
         channels: JSON.stringify(channels),
         emailRecipients: JSON.stringify(emailRecipients),
+        slackWebhookUrl,
+        webhookUrl,
         enabled,
         updatedAt,
         lastError: null,
@@ -405,6 +483,8 @@ export async function saveAnalyticsAlertRule(
       severity,
       channels: JSON.stringify(channels),
       emailRecipients: JSON.stringify(emailRecipients),
+      slackWebhookUrl,
+      webhookUrl,
       enabled,
       createdAt: updatedAt,
       updatedAt,
@@ -415,6 +495,7 @@ export async function saveAnalyticsAlertRule(
 
   const saved = await getAnalyticsAlertRule(id, ctx);
   if (!saved) throw new Error("Failed to save analytics alert rule");
+  await rememberAnalyticsAlertRuleDefaults({ emailRecipients }, ctx);
   recordChange({
     source: "analytics-alert-rules",
     type: "change",
@@ -657,6 +738,7 @@ export async function evaluateAndNotifyAnalyticsAlertRule(
 
   const body = alertBody(rule, evaluation);
   const channels = ensureInboxNotificationChannel(rule.channels);
+  const deliveryMetadata = alertNotifyDeliveryMetadata(rule);
   const delivery = await notifyWithDelivery(
     {
       severity: rule.severity,
@@ -680,6 +762,7 @@ export async function evaluateAndNotifyAnalyticsAlertRule(
         sampleEvents: evaluation.sampleEvents,
         emailRecipients: rule.emailRecipients,
         requestedChannels: rule.channels,
+        ...(deliveryMetadata ? { delivery: deliveryMetadata } : {}),
       },
     },
     { owner: rule.ownerEmail },
@@ -719,6 +802,15 @@ function ensureInboxNotificationChannel(channels: string[]): string[] {
   return normalized.includes("inbox") ? normalized : ["inbox", ...normalized];
 }
 
+function alertNotifyDeliveryMetadata(
+  rule: AnalyticsAlertRule,
+): Record<string, string> | undefined {
+  const delivery: Record<string, string> = {};
+  if (rule.slackWebhookUrl) delivery.slackWebhookUrl = rule.slackWebhookUrl;
+  if (rule.webhookUrl) delivery.webhookUrl = rule.webhookUrl;
+  return Object.keys(delivery).length > 0 ? delivery : undefined;
+}
+
 export async function markAnalyticsAlertRuleError(
   id: string,
   error: unknown,