@agent-native/core 0.92.0 → 0.92.2

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

@@ -34,6 +34,7 @@ import {
   count,
   desc,
   eq,
+  gt,
   gte,
   isNull,
   lte,
@@ -203,6 +204,7 @@ const MAX_REDIRECT_HOPS = 5;
 const MONITOR_RUNNING_STALE_MS = 5 * 60 * 1000;
 const DEFAULT_RESULT_RETENTION_DAYS = 30;
 const DEFAULT_MONITOR_LIMIT_PER_OWNER = 100;
+export const DEFAULT_MONITOR_TIMEOUT_MS = 10_000;
 const MAX_REQUEST_HEADER_COUNT = 20;
 const MAX_REQUEST_HEADER_NAME_LENGTH = 128;
 const MAX_REQUEST_HEADER_VALUE_BYTES = 2048;
@@ -215,6 +217,7 @@ const MIN_INTERVAL_SECONDS = 30;
 const MAX_INTERVAL_SECONDS = 24 * 60 * 60;
 const MIN_TIMEOUT_MS = 1000;
 const MAX_TIMEOUT_MS = 120_000;
+const DEFAULT_TRANSIENT_FAILURE_CONFIRMATION_CHECKS = 2;
 
 const ASSERTION_TYPES: AssertionType[] = [
   "body_contains",
@@ -280,6 +283,14 @@ function monitorLimitPerOwner(): number {
     : DEFAULT_MONITOR_LIMIT_PER_OWNER;
 }
 
+function transientFailureConfirmationChecks(): number {
+  const raw = process.env.UPTIME_MONITOR_TRANSIENT_FAILURE_CONFIRMATION_CHECKS;
+  const parsed = Number.parseInt(raw ?? "", 10);
+  return Number.isFinite(parsed) && parsed > 0
+    ? Math.min(parsed, 10)
+    : DEFAULT_TRANSIENT_FAILURE_CONFIRMATION_CHECKS;
+}
+
 export function hostFromUrl(url: string): string {
   try {
     return new URL(url).host;
@@ -674,6 +685,40 @@ export function evaluateCheck(params: EvaluateCheckParams): {
 // SSRF-safe fetch + probe
 // ---------------------------------------------------------------------------
 
+// A single SSRF-safe dispatcher (undici Agent) is reused across every probe.
+// Building a fresh Agent per check disabled HTTP keep-alive — each check paid a
+// cold DNS + TCP + TLS handshake, inflating the recorded latency well above the
+// site's real response time (and occasionally spiking near the timeout) — and
+// leaked Agents, which are never closed. The connect-time private-IP guard runs
+// on every new socket, so reuse keeps the exact same SSRF protection.
+// `undefined` = not built yet; the resolved value may be `null` on runtimes
+// without undici / node:dns, in which case callers fall back to plain `fetch`.
+let sharedSsrfDispatcherPromise: Promise<unknown | null> | undefined;
+
+function getSharedSsrfDispatcher(): Promise<unknown | null> {
+  if (!sharedSsrfDispatcherPromise) {
+    sharedSsrfDispatcherPromise = createSsrfSafeDispatcher().catch(() => null);
+  }
+  return sharedSsrfDispatcherPromise;
+}
+
+async function prepareMonitorFetch(
+  url: string,
+  opts: { allowPrivateHosts: boolean },
+): Promise<{ dispatcher: unknown | undefined }> {
+  const dispatcher = opts.allowPrivateHosts
+    ? undefined
+    : ((await getSharedSsrfDispatcher()) ?? undefined);
+
+  if (!opts.allowPrivateHosts && (await isBlockedExtensionUrlWithDns(url))) {
+    throw new Error(
+      `SSRF blocked: refusing to fetch private/internal address (${url})`,
+    );
+  }
+
+  return { dispatcher };
+}
+
 async function safeMonitorFetch(
   url: string,
   init: RequestInit,
@@ -681,17 +726,26 @@ async function safeMonitorFetch(
     followRedirects: boolean;
     maxRedirects: number;
     allowPrivateHosts: boolean;
+    /** Prebuilt outside the abort window so SSRF setup is not billed as site latency. */
+    dispatcher?: unknown;
+    /** When true, the caller already DNS-checked `url` before starting the timer. */
+    initialDnsChecked?: boolean;
   },
 ): Promise<Response> {
-  const dispatcher = opts.allowPrivateHosts
-    ? undefined
-    : ((await createSsrfSafeDispatcher()) ?? undefined);
+  const dispatcher =
+    opts.dispatcher !== undefined
+      ? opts.dispatcher
+      : opts.allowPrivateHosts
+        ? undefined
+        : ((await getSharedSsrfDispatcher()) ?? undefined);
 
   let currentUrl = url;
   const maxHops = opts.followRedirects ? opts.maxRedirects : 0;
 
   for (let hop = 0; hop <= maxHops; hop++) {
+    const skipDns = hop === 0 && opts.initialDnsChecked;
     if (
+      !skipDns &&
       !opts.allowPrivateHosts &&
       (await isBlockedExtensionUrlWithDns(currentUrl))
     ) {
@@ -710,6 +764,7 @@ async function safeMonitorFetch(
     if (opts.followRedirects && isRedirect) {
       const location = response.headers.get("location");
       if (!location) return response;
+      await cancelResponseBody(response);
       currentUrl = new URL(location, currentUrl).href;
       continue;
     }
@@ -720,17 +775,50 @@ async function safeMonitorFetch(
   );
 }
 
-async function readCappedText(res: Response, cap: number): Promise<string> {
+async function cancelResponseBody(res: Response): Promise<void> {
+  try {
+    await res.body?.cancel();
+  } catch {
+    // Best-effort cleanup only.
+  }
+}
+
+async function readCappedText(
+  res: Response,
+  cap: number,
+  timeoutMs?: number,
+): Promise<{ text: string; timedOut: boolean }> {
+  let timedOut = false;
+  let timer: ReturnType<typeof setTimeout> | null = null;
   const body = res.body;
   if (!body) {
     try {
-      const text = await res.text();
-      return text.length > cap ? text.slice(0, cap) : text;
+      const text =
+        timeoutMs && timeoutMs > 0
+          ? await Promise.race([
+              res.text(),
+              new Promise<string>((resolve) => {
+                timer = setTimeout(() => {
+                  timedOut = true;
+                  resolve("");
+                }, timeoutMs);
+              }),
+            ])
+          : await res.text();
+      return { text: text.length > cap ? text.slice(0, cap) : text, timedOut };
     } catch {
-      return "";
+      return { text: "", timedOut };
+    } finally {
+      if (timer) clearTimeout(timer);
     }
   }
   const reader = body.getReader();
+  if (timeoutMs && timeoutMs > 0) {
+    timer = setTimeout(() => {
+      timedOut = true;
+      void reader.cancel().catch(() => {});
+    }, timeoutMs);
+  }
   const chunks: Uint8Array[] = [];
   let total = 0;
   try {
@@ -745,6 +833,7 @@ async function readCappedText(res: Response, cap: number): Promise<string> {
   } catch {
     // Partial body is fine for text assertions.
   } finally {
+    if (timer) clearTimeout(timer);
     try {
       await reader.cancel();
     } catch {
@@ -761,7 +850,10 @@ async function readCappedText(res: Response, cap: number): Promise<string> {
     merged.set(slice, offset);
     offset += slice.length;
   }
-  return new TextDecoder("utf-8", { fatal: false }).decode(merged);
+  return {
+    text: new TextDecoder("utf-8", { fatal: false }).decode(merged),
+    timedOut,
+  };
 }
 
 function headersToObject(headers: Headers): Record<string, string> {
@@ -772,10 +864,22 @@ function headersToObject(headers: Headers): Record<string, string> {
   return out;
 }
 
+function needsResponseBody(assertions: Assertion[]): boolean {
+  return assertions.some(
+    (assertion) =>
+      assertion.type === "body_contains" || assertion.type === "body_absent",
+  );
+}
+
 /**
  * Execute one probe for `monitor`. Performs an SSRF-safe fetch with an
  * AbortController timeout, measures latency, caps the response body, and
  * classifies the result. Never throws — failures are captured in the outcome.
+ *
+ * The abort budget covers only the HTTP fetch (headers / redirect chain), not
+ * SSRF dispatcher/DNS setup or optional body reads. Billing setup time against
+ * `timeoutMs` produced false "Timed out after Nms" alerts when the site itself
+ * was fine.
  */
 export async function runMonitorCheck(
   monitor: Pick<
@@ -817,14 +921,50 @@ export async function runMonitorCheck(
     };
   }
 
-  const controller = new AbortController();
   const timeoutMs = clampInt(
     monitor.timeoutMs,
     MIN_TIMEOUT_MS,
     MAX_TIMEOUT_MS,
-    15000,
+    DEFAULT_MONITOR_TIMEOUT_MS,
   );
-  const timer = setTimeout(() => controller.abort(), timeoutMs);
+
+  let dispatcher: unknown | undefined;
+  try {
+    ({ dispatcher } = await prepareMonitorFetch(monitor.url, {
+      allowPrivateHosts,
+    }));
+  } catch (err) {
+    const message =
+      err instanceof Error ? err.message : String(err ?? "check failed");
+    const isConfig = message.startsWith("SSRF blocked");
+    const errorText = message.slice(0, 500);
+    const outcome = evaluateCheck({
+      statusCode: null,
+      latencyMs: null,
+      bodyText: "",
+      headers: {},
+      matcher,
+      assertions,
+      fetchError: errorText,
+      errorKind: isConfig ? "config" : "network",
+    });
+    return {
+      checkedAt,
+      statusCode: null,
+      latencyMs: null,
+      status: outcome.status,
+      ok: outcome.ok,
+      failedAssertions: outcome.failedAssertions,
+      error: errorText,
+    };
+  }
+
+  const controller = new AbortController();
+  let timedOut = false;
+  const timer = setTimeout(() => {
+    timedOut = true;
+    controller.abort();
+  }, timeoutMs);
   const start = Date.now();
 
   try {
@@ -845,15 +985,32 @@ export async function runMonitorCheck(
       followRedirects: monitor.followRedirects,
       maxRedirects: MAX_REDIRECT_HOPS,
       allowPrivateHosts,
+      dispatcher,
+      initialDnsChecked: Boolean(dispatcher),
     });
 
-    const bodyText =
-      method === "HEAD"
-        ? ""
-        : await readCappedText(response, MAX_RESPONSE_BODY_BYTES);
+    // Stop the abort timer as soon as headers arrive so a slow/optional body
+    // read cannot be mislabeled as a request timeout with a null status code.
+    clearTimeout(timer);
+
     const latencyMs = Date.now() - start;
     const statusCode = response.status;
     const headers = headersToObject(response.headers);
+    let bodyText = "";
+    let bodyReadError: string | null = null;
+    if (method !== "HEAD" && needsResponseBody(assertions)) {
+      const body = await readCappedText(
+        response,
+        MAX_RESPONSE_BODY_BYTES,
+        timeoutMs,
+      );
+      bodyText = body.text;
+      if (body.timedOut) {
+        bodyReadError = `Response body read timed out after ${timeoutMs}ms`;
+      }
+    } else {
+      await cancelResponseBody(response);
+    }
 
     const outcome = evaluateCheck({
       statusCode,
@@ -863,31 +1020,33 @@ export async function runMonitorCheck(
       matcher,
       assertions,
     });
+    const failedAssertions = bodyReadError
+      ? [...outcome.failedAssertions, bodyReadError]
+      : outcome.failedAssertions;
+    const status = bodyReadError ? "down" : outcome.status;
 
     return {
       checkedAt,
       statusCode,
       latencyMs,
-      status: outcome.status,
-      ok: outcome.ok,
-      failedAssertions: outcome.failedAssertions,
-      error: outcome.failedAssertions.length
-        ? outcome.failedAssertions.join("; ")
-        : null,
+      status,
+      ok: status === "up" && outcome.ok,
+      failedAssertions,
+      error: failedAssertions.length ? failedAssertions.join("; ") : null,
     };
   } catch (err) {
-    const isTimeout =
-      (err as { name?: string })?.name === "AbortError" ||
-      controller.signal.aborted;
     const message =
       err instanceof Error ? err.message : String(err ?? "check failed");
     const isConfig = message.startsWith("SSRF blocked");
+    // Only our timer sets `timedOut`. Prefer the real SSRF/config message when
+    // both happened (e.g. abort fired while a redirect DNS check was in flight).
+    const isTimeout = timedOut && !isConfig;
     const errorText = isTimeout
       ? `Timed out after ${timeoutMs}ms`
       : message.slice(0, 500);
     const outcome = evaluateCheck({
       statusCode: null,
-      latencyMs: null,
+      latencyMs: isTimeout ? timeoutMs : null,
       bodyText: "",
       headers: {},
       matcher,
@@ -898,7 +1057,7 @@ export async function runMonitorCheck(
     return {
       checkedAt,
       statusCode: null,
-      latencyMs: null,
+      latencyMs: isTimeout ? timeoutMs : null,
       status: outcome.status,
       ok: outcome.ok,
       failedAssertions: outcome.failedAssertions,
@@ -925,7 +1084,7 @@ function rowToMonitor(row: any): Monitor {
     ),
     requestBody: row.requestBody ?? null,
     intervalSeconds: Number(row.intervalSeconds ?? 300),
-    timeoutMs: Number(row.timeoutMs ?? 15000),
+    timeoutMs: Number(row.timeoutMs ?? DEFAULT_MONITOR_TIMEOUT_MS),
     expectedStatus: normalizeStatusMatcher(
       safeJsonParse<unknown>(row.expectedStatus, null),
     ),
@@ -1155,10 +1314,10 @@ export async function saveMonitor(
     300,
   );
   const timeoutMs = clampInt(
-    input.timeoutMs ?? 15000,
+    input.timeoutMs ?? DEFAULT_MONITOR_TIMEOUT_MS,
     MIN_TIMEOUT_MS,
     MAX_TIMEOUT_MS,
-    15000,
+    DEFAULT_MONITOR_TIMEOUT_MS,
   );
   const expectedStatus = normalizeStatusMatcher(input.expectedStatus);
   const assertions = normalizeAssertions(input.assertions);
@@ -1433,6 +1592,25 @@ function describeCause(outcome: CheckOutcome): string {
   return "Check failed";
 }
 
+function isTransientNoResponseFailure(outcome: CheckOutcome): boolean {
+  return (
+    outcome.status === "down" &&
+    outcome.statusCode == null &&
+    Boolean(outcome.error)
+  );
+}
+
+export function shouldOpenMonitorIncident(
+  outcome: CheckOutcome,
+  priorConsecutiveFailures: number,
+  confirmationChecks = transientFailureConfirmationChecks(),
+): boolean {
+  const needed = isTransientNoResponseFailure(outcome)
+    ? Math.max(1, Math.min(10, Math.floor(confirmationChecks)))
+    : 1;
+  return Math.max(0, Math.floor(priorConsecutiveFailures)) + 1 >= needed;
+}
+
 async function getOpenIncident(
   monitorId: string,
   ctx: AccessCtx,
@@ -1477,6 +1655,29 @@ async function recentlyResolvedWithinCooldown(
   return now.getTime() - resolved < monitor.cooldownMinutes * 60 * 1000;
 }
 
+async function getFailureStreakStartedAt(
+  monitor: Monitor,
+  ctx: AccessCtx,
+  fallback: string,
+): Promise<string> {
+  const db = getDb() as any;
+  const table = schema.monitorCheckResults;
+  const clauses: any[] = [
+    resultsOwnerWhere(ctx),
+    eq(table.monitorId, monitor.id),
+    eq(table.ok, false),
+  ];
+  if (monitor.lastSuccessAt)
+    clauses.push(gt(table.checkedAt, monitor.lastSuccessAt));
+  const [row] = await db
+    .select({ checkedAt: table.checkedAt })
+    .from(table)
+    .where(and(...clauses))
+    .orderBy(asc(table.checkedAt))
+    .limit(1);
+  return row?.checkedAt ?? fallback;
+}
+
 async function notifyMonitorDown(monitor: Monitor, outcome: CheckOutcome) {
   const host = hostFromUrl(monitor.url);
   const label = outcome.status === "degraded" ? "degraded" : "down";
@@ -1560,8 +1761,8 @@ export interface EvaluateMonitorResult {
 
 /**
  * Open / update / resolve incidents based on the latest outcome and send
- * notifications. On a transition into failure it opens an incident and
- * notifies (respecting an anti-flap cooldown); on recovery it resolves the
+ * notifications. On a transition into confirmed failure it opens an incident
+ * and notifies (respecting an anti-flap cooldown); on recovery it resolves the
  * open incident and sends a recovery notice.
  */
 export async function evaluateAndNotifyMonitor(
@@ -1575,6 +1776,8 @@ export async function evaluateAndNotifyMonitor(
 
   if (!outcome.ok) {
     const cause = describeCause(outcome);
+    const priorConsecutiveFailures = monitor.consecutiveFailures ?? 0;
+    const nextChecksFailed = priorConsecutiveFailures + 1;
     if (open) {
       const nextStatus =
         open.status === "down" ? "down" : (outcome.status as MonitorStatus);
@@ -1590,6 +1793,10 @@ export async function evaluateAndNotifyMonitor(
       return { status: outcome.status, incidentId: open.id, notified: false };
     }
 
+    if (!shouldOpenMonitorIncident(outcome, priorConsecutiveFailures)) {
+      return { status: outcome.status, notified: false };
+    }
+
     const suppressed = await recentlyResolvedWithinCooldown(monitor, ctx, now);
     let notificationId: string | undefined;
     if (!suppressed) {
@@ -1604,17 +1811,21 @@ export async function evaluateAndNotifyMonitor(
       }
     }
     const incidentId = randomUUID();
+    const startedAt =
+      nextChecksFailed > 1
+        ? await getFailureStreakStartedAt(monitor, ctx, outcome.checkedAt)
+        : outcome.checkedAt;
     await db.insert(schema.monitorIncidents).values({
       id: incidentId,
       monitorId: monitor.id,
-      startedAt: outcome.checkedAt,
+      startedAt,
       resolvedAt: null,
       status: outcome.status === "degraded" ? "degraded" : "down",
       severity: monitor.severity,
       cause,
       lastError: outcome.error,
       notificationId: notificationId ?? null,
-      checksFailed: 1,
+      checksFailed: nextChecksFailed,
       createdAt: outcome.checkedAt,
       ownerEmail: monitor.ownerEmail,
       orgId: monitor.orgId,

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

@@ -568,6 +568,8 @@ const runAnalyticsMigrations = runMigrations(
       severity TEXT NOT NULL DEFAULT 'warning',
       channels TEXT NOT NULL DEFAULT '["inbox"]',
       email_recipients TEXT NOT NULL DEFAULT '[]',
+      slack_webhook_url TEXT,
+      webhook_url TEXT,
       enabled BOOLEAN NOT NULL DEFAULT true,
       last_evaluated_at TEXT,
       last_triggered_at TEXT,
@@ -592,6 +594,8 @@ const runAnalyticsMigrations = runMigrations(
       severity TEXT NOT NULL DEFAULT 'warning',
       channels TEXT NOT NULL DEFAULT '["inbox"]',
       email_recipients TEXT NOT NULL DEFAULT '[]',
+      slack_webhook_url TEXT,
+      webhook_url TEXT,
       enabled INTEGER NOT NULL DEFAULT 1,
       last_evaluated_at TEXT,
       last_triggered_at TEXT,
@@ -891,7 +895,7 @@ const runAnalyticsMigrations = runMigrations(
       request_headers TEXT NOT NULL DEFAULT '{}',
       request_body TEXT,
       interval_seconds INTEGER NOT NULL DEFAULT 300,
-      timeout_ms INTEGER NOT NULL DEFAULT 15000,
+      timeout_ms INTEGER NOT NULL DEFAULT 10000,
       expected_status TEXT NOT NULL DEFAULT '{"mode":"class","classes":["2xx"]}',
       assertions TEXT NOT NULL DEFAULT '[]',
       follow_redirects BOOLEAN NOT NULL DEFAULT true,
@@ -921,7 +925,7 @@ const runAnalyticsMigrations = runMigrations(
       request_headers TEXT NOT NULL DEFAULT '{}',
       request_body TEXT,
       interval_seconds INTEGER NOT NULL DEFAULT 300,
-      timeout_ms INTEGER NOT NULL DEFAULT 15000,
+      timeout_ms INTEGER NOT NULL DEFAULT 10000,
       expected_status TEXT NOT NULL DEFAULT '{"mode":"class","classes":["2xx"]}',
       assertions TEXT NOT NULL DEFAULT '[]',
       follow_redirects INTEGER NOT NULL DEFAULT 1,
@@ -1124,6 +1128,112 @@ const runAnalyticsMigrations = runMigrations(
       name: "uptime-monitors-webhook-url",
       sql: `ALTER TABLE monitors ADD COLUMN IF NOT EXISTS webhook_url TEXT`,
     },
+    {
+      version: 108,
+      name: "analytics-alert-rules-slack-webhook-url",
+      sql: `ALTER TABLE analytics_alert_rules ADD COLUMN IF NOT EXISTS slack_webhook_url TEXT`,
+    },
+    {
+      version: 109,
+      name: "analytics-alert-rules-webhook-url",
+      sql: `ALTER TABLE analytics_alert_rules ADD COLUMN IF NOT EXISTS webhook_url TEXT`,
+    },
+    {
+      version: 110,
+      name: "dashboards-updated-by",
+      sql: `ALTER TABLE dashboards ADD COLUMN IF NOT EXISTS updated_by TEXT`,
+    },
+    {
+      version: 111,
+      name: "dashboard-revisions-table",
+      sql: {
+        postgres: `CREATE TABLE IF NOT EXISTS dashboard_revisions (
+      id TEXT PRIMARY KEY,
+      dashboard_id TEXT NOT NULL,
+      kind TEXT NOT NULL,
+      title TEXT NOT NULL,
+      config TEXT NOT NULL,
+      created_at TEXT NOT NULL DEFAULT (now()::text),
+      created_by TEXT,
+      owner_email TEXT NOT NULL DEFAULT 'local@localhost',
+      org_id TEXT
+    )`,
+        sqlite: `CREATE TABLE IF NOT EXISTS dashboard_revisions (
+      id TEXT PRIMARY KEY,
+      dashboard_id TEXT NOT NULL,
+      kind TEXT NOT NULL,
+      title TEXT NOT NULL,
+      config TEXT NOT NULL,
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      created_by TEXT,
+      owner_email TEXT NOT NULL DEFAULT 'local@localhost',
+      org_id TEXT
+    )`,
+      },
+    },
+    {
+      version: 112,
+      name: "dashboard-revisions-dashboard-created-idx",
+      sql: `CREATE INDEX IF NOT EXISTS dashboard_revisions_dashboard_created_idx ON dashboard_revisions (dashboard_id, created_at)`,
+    },
+    {
+      version: 113,
+      name: "analysis-revisions-table",
+      sql: {
+        postgres: `CREATE TABLE IF NOT EXISTS analysis_revisions (
+      id TEXT PRIMARY KEY,
+      analysis_id TEXT NOT NULL,
+      name TEXT NOT NULL,
+      description TEXT NOT NULL DEFAULT '',
+      question TEXT NOT NULL DEFAULT '',
+      instructions TEXT NOT NULL DEFAULT '',
+      data_sources TEXT NOT NULL DEFAULT '[]',
+      result_markdown TEXT NOT NULL DEFAULT '',
+      result_data TEXT,
+      created_at TEXT NOT NULL DEFAULT (now()::text),
+      created_by TEXT,
+      owner_email TEXT NOT NULL DEFAULT 'local@localhost',
+      org_id TEXT
+    )`,
+        sqlite: `CREATE TABLE IF NOT EXISTS analysis_revisions (
+      id TEXT PRIMARY KEY,
+      analysis_id TEXT NOT NULL,
+      name TEXT NOT NULL,
+      description TEXT NOT NULL DEFAULT '',
+      question TEXT NOT NULL DEFAULT '',
+      instructions TEXT NOT NULL DEFAULT '',
+      data_sources TEXT NOT NULL DEFAULT '[]',
+      result_markdown TEXT NOT NULL DEFAULT '',
+      result_data TEXT,
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      created_by TEXT,
+      owner_email TEXT NOT NULL DEFAULT 'local@localhost',
+      org_id TEXT
+    )`,
+      },
+    },
+    {
+      version: 114,
+      name: "analysis-revisions-analysis-created-idx",
+      sql: `CREATE INDEX IF NOT EXISTS analysis_revisions_analysis_created_idx ON analysis_revisions (analysis_id, created_at)`,
+    },
+    {
+      version: 115,
+      name: "uptime-monitors-timeout-10s",
+      sql: {
+        postgres: `
+        ALTER TABLE monitors ALTER COLUMN timeout_ms SET DEFAULT 10000;
+        UPDATE monitors
+        SET timeout_ms = 10000, updated_at = COALESCE(NULLIF(updated_at, ''), now()::text)
+        WHERE timeout_ms IS NULL OR timeout_ms < 10000 OR timeout_ms = 15000
+      `,
+        sqlite: `
+        UPDATE monitors
+        SET timeout_ms = 10000, updated_at = COALESCE(NULLIF(updated_at, ''), datetime('now'))
+        WHERE timeout_ms IS NULL OR timeout_ms < 10000 OR timeout_ms = 15000
+      `,
+      },
+    },
   ],
   { table: "analytics_migrations" },
 );

package/corpus/templates/analytics/server/routes/api/dashboard-agent-context.json.get.ts

@@ -51,6 +51,7 @@ function rowToDashboard(row: any): DashboardRecord {
     visibility: row.visibility,
     createdAt: row.createdAt,
     updatedAt: row.updatedAt,
+    updatedBy: row.updatedBy ?? null,
     archivedAt: row.archivedAt ?? null,
     hiddenAt: row.hiddenAt ?? null,
     hiddenBy: row.hiddenBy ?? null,

package/corpus/templates/assets/.agents/skills/actions/SKILL.md

@@ -377,6 +377,11 @@ Most operations should be actions. You only need custom routes in `server/routes
 - **Webhooks** — external services POST to a specific URL
 - **OAuth callbacks** — redirect-based flows that need specific URL patterns
 
+When the agent needs a durable image or file URL, call the core `upload-image`
+action or use `uploadFile()` in server code. Do not write base64 into SQL,
+markdown, deck/design JSON, or action results. `_agentImages` on action results
+is for ephemeral vision previews only, not persistence.
+
 If it's a standard CRUD operation, data query, or a wrapper around an action, use the action instead.
 
 ## Legacy Pattern (bare export)

package/corpus/templates/assets/.agents/skills/real-time-sync/SKILL.md

@@ -50,7 +50,7 @@ The agent modifies data in SQL, but the UI runs in the browser. SSE bridges same
 
    For list/sidebar queries, use the same pattern — pass the counter into the queryKey of every list query you want to keep fresh.
 
-4. **Fallback** polling calls `/_agent-native/poll?since=N`. It runs every 2 seconds until SSE is connected, then relaxes to 15 seconds (`SSE_FALLBACK_INTERVAL_MS`). If SSE is disabled or unavailable (e.g., edge/serverless deployments), polling continues at the 2 s cadence. Polling is the universal serverless fallback — it detects DB timestamp changes even when the write happened in a different process or invocation.
+4. **Fallback** polling calls `/_agent-native/poll?since=N`. It runs every 2 seconds until SSE is connected, then relaxes to 15 seconds (`SSE_FALLBACK_INTERVAL_MS`). If SSE is disabled or unavailable (e.g., edge/serverless deployments), polling continues at the 2 s cadence. Polling is the universal serverless fallback: new framework writes are read from the durable `sync_events` log, while the older DB timestamp scan remains as a slower safety net for direct SQL writes and older processes.
 
 5. When the agent writes to the database, the version increments, SSE/polling detects it, and React Query refetches the affected queries.
 

package/corpus/templates/assets/.agents/skills/security/SKILL.md

@@ -51,6 +51,13 @@ export default defineAction({
 
 The legacy `parameters:` field (plain JSON Schema) has no runtime validation — do not use it for new code.
 
+## Large Payloads
+
+Do not accept or persist unbounded base64/file blobs through actions, SQL writes,
+or `application_state`. Route uploads through the file-upload provider and store
+references. This prevents database bloat, slow hot paths, and accidental secret
+or customer-data embedding inside binary payloads.
+
 ## SQL Injection
 
 Never concatenate user input into SQL strings. Use Drizzle ORM's query builder (always safe) or parameterized queries: