@agent-native/core 0.91.2 → 0.92.1

package/corpus/templates/analytics/changelog/2026-07-08-shared-extension-links-now-show-a-clear-message-when-you-do-.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-08
+---
+
+Shared extension links now show a clear message when you do not have access.

package/corpus/templates/analytics/changelog/2026-07-08-sidebar-dashboard-menus-now-open-above-the-dashboard-canvas.md

@@ -0,0 +1,6 @@
+---
+type: fixed
+date: 2026-07-08
+---
+
+Sidebar dashboard menus now open above the dashboard canvas

package/corpus/templates/analytics/changelog/2026-07-08-team-settings-show-access-controls-next-to-member-lists.md

@@ -0,0 +1,6 @@
+---
+type: improved
+date: 2026-07-08
+---
+
+Team settings now show organization access controls next to long member lists when there is room.

package/corpus/templates/analytics/changelog/2026-07-08-uptime-alerting-clarifies-in-app-inbox-vs-email-and-lets-you-paste-slack-or-webhook-urls-per-monitor.md

@@ -0,0 +1,6 @@
+---
+type: improved
+date: 2026-07-08
+---
+
+Uptime alerting clarifies in-app inbox vs email and lets you paste Slack or webhook URLs per monitor.

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

@@ -60,10 +60,12 @@ Each check runs on the server (`server/lib/uptime-monitors.ts`):
 
 - 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 metadata
-  `{ kind: "uptime_monitor", monitorId, url, statusCode, latencyMs, failedAssertions }`.
-  The `inbox` channel is always included; `email`/`slack`/`webhook` are added
-  when configured, and email uses the monitor's `emailRecipients`.
+  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).
 - 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.
@@ -119,13 +121,13 @@ have their schema.
 Every operation is an owner-scoped action, so the agent can create and triage
 monitors from chat exactly like the UI:
 
-| action              | method | what it does                                                                                                                                                        |
-| ------------------- | ------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `save-monitor`      | POST   | create or update a monitor (name, url, method, interval, timeout, expected status, assertions, redirects, severity, channels, email recipients, cooldown, enabled). |
-| `list-monitors`     | GET    | list monitors with latest status, latency, and 24h/7d uptime %.                                                                                                     |
-| `get-monitor`       | GET    | one monitor plus its recent check results and incidents.                                                                                                            |
-| `delete-monitor`    | POST   | delete a monitor and its results + incidents.                                                                                                                       |
-| `run-monitor-check` | POST   | run one check now, record it, and open/resolve incidents.                                                                                                           |
+| action              | method | what it does                                                                                                                                                                                     |
+| ------------------- | ------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| `save-monitor`      | POST   | create or update a monitor (name, url, method, interval, timeout, expected status, assertions, redirects, severity, channels, email recipients, optional Slack/webhook URLs, cooldown, enabled). |
+| `list-monitors`     | GET    | list monitors with latest status, latency, and 24h/7d uptime %.                                                                                                                                  |
+| `get-monitor`       | GET    | one monitor plus its recent check results and incidents.                                                                                                                                         |
+| `delete-monitor`    | POST   | delete a monitor and its results + incidents.                                                                                                                                                    |
+| `run-monitor-check` | POST   | run one check now, record it, and open/resolve incidents.                                                                                                                                        |
 
 Example prompts:
 

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"] }
@@ -70,6 +70,10 @@ export const monitors = table("monitors", {
   channels: text("channels").notNull().default('["inbox"]'),
   /** Email recipients as JSON array of addresses. */
   emailRecipients: text("email_recipients").notNull().default("[]"),
+  /** Optional per-monitor Slack incoming webhook URL (overrides workspace env). */
+  slackWebhookUrl: text("slack_webhook_url"),
+  /** Optional per-monitor generic webhook URL (overrides workspace env). */
+  webhookUrl: text("webhook_url"),
   /** Minutes to suppress repeat alerts while an incident is ongoing. */
   cooldownMinutes: integer("cooldown_minutes").notNull().default(15),
   enabled: integer("enabled", { mode: "boolean" }).notNull().default(true),

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,