@agent-native/core 0.92.0 → 0.92.1

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,