@agent-native/core 0.91.2 → 0.92.1

package/corpus/templates/analytics/actions/navigate.ts

@@ -29,9 +29,11 @@ export default defineAction({
       .optional()
       .describe("Session recording id to open (used with view=sessions)"),
     agentsView: z
-      .enum(["monitoring", "database"])
+      .enum(["monitoring", "dashboards", "database"])
       .optional()
-      .describe("Agents subview to open (monitoring or app databases)"),
+      .describe(
+        "Admin subview to open (monitoring, dashboard usage, or app databases)",
+      ),
     dbAdminConnectionId: z
       .string()
       .optional()

package/corpus/templates/analytics/actions/restore-analysis-revision.ts

@@ -0,0 +1,43 @@
+import { defineAction } from "@agent-native/core";
+import {
+  getRequestOrgId,
+  getRequestUserEmail,
+} from "@agent-native/core/server";
+import { z } from "zod";
+
+import { restoreAnalysisRevision } from "../server/lib/dashboards-store";
+
+function resolveScope() {
+  const orgId = getRequestOrgId() || null;
+  const email = getRequestUserEmail();
+  if (!email) throw new Error("no authenticated user");
+  return { orgId, email };
+}
+
+export default defineAction({
+  description:
+    "Restore an ad-hoc analysis to a saved history revision, snapshotting the current analysis first.",
+  schema: z.object({
+    analysisId: z.string().describe("Analysis id to restore"),
+    revisionId: z.string().describe("Revision id to restore"),
+  }),
+  http: { method: "POST" },
+  run: async (args) => {
+    const analysis = await restoreAnalysisRevision(
+      args.analysisId,
+      args.revisionId,
+      resolveScope(),
+    );
+    if (!analysis) {
+      throw new Error(
+        `Analysis revision "${args.revisionId}" was not found for analysis "${args.analysisId}".`,
+      );
+    }
+    return {
+      id: analysis.id,
+      name: analysis.name,
+      updatedAt: analysis.updatedAt,
+      message: `Restored analysis "${analysis.name}" from history.`,
+    };
+  },
+});

package/corpus/templates/analytics/actions/restore-dashboard-revision.ts

@@ -0,0 +1,68 @@
+import { defineAction } from "@agent-native/core";
+import {
+  applyText,
+  hasCollabState,
+  seedFromText,
+} from "@agent-native/core/collab";
+import {
+  getRequestOrgId,
+  getRequestUserEmail,
+} from "@agent-native/core/server";
+import { z } from "zod";
+
+import { restoreDashboardRevision } from "../server/lib/dashboards-store";
+
+function resolveScope() {
+  const orgId = getRequestOrgId() || null;
+  const email = getRequestUserEmail();
+  if (!email) throw new Error("no authenticated user");
+  return { orgId, email };
+}
+
+async function syncToCollab(
+  dashboardId: string,
+  config: Record<string, unknown>,
+): Promise<void> {
+  const docId = `dash-${dashboardId}`;
+  const configStr = JSON.stringify(config);
+  try {
+    const exists = await hasCollabState(docId);
+    if (exists) {
+      await applyText(docId, configStr, "content", "agent");
+    } else {
+      await seedFromText(docId, configStr);
+    }
+  } catch {
+    // SQL is the source of truth; open editors also refetch on the dashboards signal.
+  }
+}
+
+export default defineAction({
+  description:
+    "Restore a dashboard to a saved history revision, snapshotting the current dashboard first.",
+  schema: z.object({
+    dashboardId: z.string().describe("Dashboard id to restore"),
+    revisionId: z.string().describe("Revision id to restore"),
+  }),
+  http: { method: "POST" },
+  run: async (args) => {
+    const dashboard = await restoreDashboardRevision(
+      args.dashboardId,
+      args.revisionId,
+      resolveScope(),
+    );
+    if (!dashboard) {
+      throw new Error(
+        `Dashboard revision "${args.revisionId}" was not found for dashboard "${args.dashboardId}".`,
+      );
+    }
+    await syncToCollab(dashboard.id, dashboard.config);
+    return {
+      id: dashboard.id,
+      kind: dashboard.kind,
+      name: dashboard.title,
+      updatedAt: dashboard.updatedAt,
+      message: `Restored dashboard "${dashboard.title}" from history.`,
+    };
+  },
+});

package/corpus/templates/analytics/actions/save-analytics-alert-rule.ts

@@ -57,6 +57,20 @@ export default defineAction({
       .array(z.string().email())
       .optional()
       .describe("Email recipients passed to the generic email channel."),
+    slackWebhookUrl: z
+      .string()
+      .optional()
+      .nullable()
+      .describe(
+        "Optional Slack incoming webhook URL for this alert rule. Overrides NOTIFICATIONS_SLACK_WEBHOOK_URL when set.",
+      ),
+    webhookUrl: z
+      .string()
+      .optional()
+      .nullable()
+      .describe(
+        "Optional generic webhook URL for this alert rule. Overrides NOTIFICATIONS_WEBHOOK_URL when set.",
+      ),
     enabled: z.boolean().optional(),
   }),
   http: { method: "POST" },

package/corpus/templates/analytics/actions/save-monitor.ts

@@ -101,7 +101,7 @@ export default defineAction({
       .min(1000)
       .max(120000)
       .optional()
-      .describe("Request timeout in milliseconds (default 15000)."),
+      .describe("Request timeout in milliseconds (default 10000)."),
     expectedStatus: statusMatcherSchema.optional(),
     assertions: z
       .array(assertionSchema)
@@ -123,6 +123,20 @@ export default defineAction({
       .array(z.string().email())
       .optional()
       .describe("Email recipients used by the email channel."),
+    slackWebhookUrl: z
+      .string()
+      .nullable()
+      .optional()
+      .describe(
+        "Optional Slack incoming webhook URL for this monitor. Overrides NOTIFICATIONS_SLACK_WEBHOOK_URL when set.",
+      ),
+    webhookUrl: z
+      .string()
+      .nullable()
+      .optional()
+      .describe(
+        "Optional generic webhook URL for this monitor. Overrides NOTIFICATIONS_WEBHOOK_URL when set.",
+      ),
     cooldownMinutes: z
       .number()
       .int()

package/corpus/templates/analytics/actions/view-screen.ts

@@ -42,10 +42,12 @@ export default defineAction({
       search?: string;
       searchParams?: Record<string, string>;
     } | null;
+    const selectedObject = await readAppState("selected-object");
 
     const screen: Record<string, unknown> = {};
     if (navigation) screen.navigation = navigation;
     if (url?.pathname) screen.pathname = url.pathname;
+    if (selectedObject) screen.selectedObject = selectedObject;
 
     // Surface the active URL filter params (f_*) so the agent doesn't have
     // to reason about the URL string or go hunting in settings for them.
@@ -219,6 +221,7 @@ export default defineAction({
                 lastSeenAt: issue.lastSeenAt,
                 eventCount: issue.eventCount,
                 usersAffected: issue.usersAffected,
+                recentFrequency: issue.sparkline,
                 assignee: issue.assignee,
                 app: issue.app,
                 template: issue.template,
@@ -231,6 +234,10 @@ export default defineAction({
                       url: sample.url,
                       occurredAt: sample.occurredAt,
                       sessionRecordingPath: sample.sessionRecordingPath,
+                      stack: sample.stack.slice(0, 8),
+                      rawStackPreview: sample.rawStack
+                        ? sample.rawStack.split("\n").slice(0, 8).join("\n")
+                        : null,
                     }
                   : null,
                 linkedSessions: detail.sessions.slice(0, 5),
@@ -425,6 +432,20 @@ export default defineAction({
             "feedback",
           ],
         },
+        {
+          id: "dashboards",
+          label: "Dashboard Usage",
+          path: "/agents?view=dashboards",
+          adminOnly: true,
+          action: "list-dashboard-usage-stats",
+          includes: [
+            "dashboard created and modified dates",
+            "last tracked modifier",
+            "view and engagement counts",
+            "saved view counts",
+            "hidden and archived state",
+          ],
+        },
         {
           id: "database",
           label: "App Databases",
@@ -439,6 +460,9 @@ export default defineAction({
           ],
         },
       ];
+      if (screen.agentsView === "dashboards") {
+        screen.dashboardUsageStatsAction = "list-dashboard-usage-stats";
+      }
       const email = getRequestUserEmail();
       if (email) {
         const orgId = getRequestOrgId() || null;

package/corpus/templates/analytics/app/components/analysis/AnalysisHistoryPanel.tsx

@@ -0,0 +1,181 @@
+import { useT } from "@agent-native/core/client";
+import { IconHistory, IconLoader2, IconRotate } from "@tabler/icons-react";
+import { useState } from "react";
+import { toast } from "sonner";
+
+import {
+  AlertDialog,
+  AlertDialogAction,
+  AlertDialogCancel,
+  AlertDialogContent,
+  AlertDialogDescription,
+  AlertDialogFooter,
+  AlertDialogHeader,
+  AlertDialogTitle,
+} from "@/components/ui/alert-dialog";
+import { Button } from "@/components/ui/button";
+import {
+  Sheet,
+  SheetContent,
+  SheetDescription,
+  SheetHeader,
+  SheetTitle,
+} from "@/components/ui/sheet";
+import {
+  type AnalysisRevision,
+  useAnalysisRevisions,
+  useRestoreAnalysisRevision,
+} from "@/hooks/use-analysis-revisions";
+
+function formatRelativeTime(dateStr: string): string {
+  const then = new Date(dateStr).getTime();
+  if (!Number.isFinite(then)) return dateStr;
+  const diffMs = Date.now() - then;
+  const diffMin = Math.floor(diffMs / 60_000);
+  const diffHr = Math.floor(diffMs / 3_600_000);
+  const diffDay = Math.floor(diffMs / 86_400_000);
+
+  if (diffMin < 1) return "Just now";
+  if (diffMin < 60) return `${diffMin}m ago`;
+  if (diffHr < 24) return `${diffHr}h ago`;
+  if (diffDay < 7) return `${diffDay}d ago`;
+  return new Date(dateStr).toLocaleDateString();
+}
+
+export function AnalysisHistoryPanel({
+  analysisId,
+  open,
+  onOpenChange,
+  canRestore = true,
+}: {
+  analysisId: string;
+  open: boolean;
+  onOpenChange: (open: boolean) => void;
+  canRestore?: boolean;
+}) {
+  const t = useT();
+  const { data: revisions, isLoading } = useAnalysisRevisions(
+    open ? analysisId : null,
+  );
+  const restoreRevision = useRestoreAnalysisRevision(analysisId);
+  const [pendingRestore, setPendingRestore] = useState<AnalysisRevision | null>(
+    null,
+  );
+
+  const doRestore = async (revision: AnalysisRevision) => {
+    try {
+      await restoreRevision.mutateAsync({
+        analysisId,
+        revisionId: revision.id,
+      });
+      toast.success(t("analyses.historyRestored"));
+      setPendingRestore(null);
+      onOpenChange(false);
+    } catch {
+      toast.error(t("analyses.historyRestoreFailed"));
+    }
+  };
+
+  return (
+    <>
+      <Sheet open={open} onOpenChange={onOpenChange}>
+        <SheetContent side="right" className="w-[85vw] max-w-[420px] p-0">
+          <SheetHeader className="px-4 pb-0 pt-4">
+            <SheetTitle className="flex items-center gap-2 text-sm font-medium">
+              <IconHistory size={16} />
+              {t("analyses.historyTitle")}
+            </SheetTitle>
+            <SheetDescription>
+              {t("analyses.historyDescription")}
+            </SheetDescription>
+          </SheetHeader>
+          <div className="mt-3 border-t border-border" />
+          <div className="h-[calc(100%-96px)] overflow-y-auto p-2">
+            {isLoading ? (
+              <div className="flex items-center justify-center py-12">
+                <IconLoader2
+                  size={16}
+                  className="animate-spin text-muted-foreground"
+                />
+              </div>
+            ) : !revisions?.length ? (
+              <div className="px-6 py-12 text-center text-xs text-muted-foreground">
+                {t("analyses.historyEmpty")}
+              </div>
+            ) : (
+              <div className="space-y-1">
+                {revisions.map((revision) => (
+                  <div
+                    key={revision.id}
+                    className="rounded-lg border border-border bg-card p-3"
+                  >
+                    <div className="flex items-start justify-between gap-3">
+                      <div className="min-w-0">
+                        <p className="truncate text-xs font-medium">
+                          {revision.name || t("common.untitledAnalysis")}
+                        </p>
+                        <p className="mt-0.5 text-[10px] text-muted-foreground">
+                          {formatRelativeTime(revision.createdAt)}
+                          {revision.createdBy
+                            ? ` by ${revision.createdBy}`
+                            : ""}
+                        </p>
+                      </div>
+                      {canRestore ? (
+                        <Button
+                          type="button"
+                          size="sm"
+                          variant="outline"
+                          className="h-7 shrink-0 px-2 text-[11px]"
+                          onClick={() => setPendingRestore(revision)}
+                          disabled={restoreRevision.isPending}
+                        >
+                          {restoreRevision.isPending ? (
+                            <IconLoader2 size={13} className="animate-spin" />
+                          ) : (
+                            <IconRotate size={13} />
+                          )}
+                          <span className="ml-1">
+                            {t("analyses.historyRestore")}
+                          </span>
+                        </Button>
+                      ) : null}
+                    </div>
+                  </div>
+                ))}
+              </div>
+            )}
+          </div>
+        </SheetContent>
+      </Sheet>
+
+      <AlertDialog
+        open={pendingRestore !== null}
+        onOpenChange={(nextOpen) => {
+          if (!nextOpen) setPendingRestore(null);
+        }}
+      >
+        <AlertDialogContent>
+          <AlertDialogHeader>
+            <AlertDialogTitle>
+              {t("analyses.historyRestoreQuestion")}
+            </AlertDialogTitle>
+            <AlertDialogDescription>
+              {t("analyses.historyRestoreWarning")}
+            </AlertDialogDescription>
+          </AlertDialogHeader>
+          <AlertDialogFooter>
+            <AlertDialogCancel>{t("common.cancel")}</AlertDialogCancel>
+            <AlertDialogAction
+              onClick={() => {
+                if (pendingRestore) void doRestore(pendingRestore);
+              }}
+            >
+              {t("analyses.historyRestore")}
+            </AlertDialogAction>
+          </AlertDialogFooter>
+        </AlertDialogContent>
+      </AlertDialog>
+    </>
+  );
+}

package/corpus/templates/analytics/app/components/dashboard/DashboardHistoryPanel.tsx

@@ -0,0 +1,184 @@
+import { useT } from "@agent-native/core/client";
+import { IconHistory, IconLoader2, IconRotate } from "@tabler/icons-react";
+import { useState } from "react";
+import { toast } from "sonner";
+
+import {
+  AlertDialog,
+  AlertDialogAction,
+  AlertDialogCancel,
+  AlertDialogContent,
+  AlertDialogDescription,
+  AlertDialogFooter,
+  AlertDialogHeader,
+  AlertDialogTitle,
+} from "@/components/ui/alert-dialog";
+import { Button } from "@/components/ui/button";
+import {
+  Sheet,
+  SheetContent,
+  SheetDescription,
+  SheetHeader,
+  SheetTitle,
+} from "@/components/ui/sheet";
+import {
+  type DashboardRevision,
+  useDashboardRevisions,
+  useRestoreDashboardRevision,
+} from "@/hooks/use-dashboard-revisions";
+
+function formatRelativeTime(dateStr: string): string {
+  const then = new Date(dateStr).getTime();
+  if (!Number.isFinite(then)) return dateStr;
+  const diffMs = Date.now() - then;
+  const diffMin = Math.floor(diffMs / 60_000);
+  const diffHr = Math.floor(diffMs / 3_600_000);
+  const diffDay = Math.floor(diffMs / 86_400_000);
+
+  if (diffMin < 1) return "Just now";
+  if (diffMin < 60) return `${diffMin}m ago`;
+  if (diffHr < 24) return `${diffHr}h ago`;
+  if (diffDay < 7) return `${diffDay}d ago`;
+  return new Date(dateStr).toLocaleDateString();
+}
+
+interface DashboardHistoryPanelProps {
+  dashboardId: string;
+  open: boolean;
+  onOpenChange: (open: boolean) => void;
+  canRestore?: boolean;
+}
+
+export function DashboardHistoryPanel({
+  dashboardId,
+  open,
+  onOpenChange,
+  canRestore = true,
+}: DashboardHistoryPanelProps) {
+  const t = useT();
+  const { data: revisions, isLoading } = useDashboardRevisions(
+    open ? dashboardId : null,
+  );
+  const restoreRevision = useRestoreDashboardRevision(dashboardId);
+  const [pendingRestore, setPendingRestore] =
+    useState<DashboardRevision | null>(null);
+
+  const doRestore = async (revision: DashboardRevision) => {
+    try {
+      await restoreRevision.mutateAsync({
+        dashboardId,
+        revisionId: revision.id,
+      });
+      toast.success(t("dashboard.historyRestored"));
+      setPendingRestore(null);
+      onOpenChange(false);
+    } catch {
+      toast.error(t("dashboard.historyRestoreFailed"));
+    }
+  };
+
+  return (
+    <>
+      <Sheet open={open} onOpenChange={onOpenChange}>
+        <SheetContent side="right" className="w-[85vw] max-w-[420px] p-0">
+          <SheetHeader className="px-4 pb-0 pt-4">
+            <SheetTitle className="flex items-center gap-2 text-sm font-medium">
+              <IconHistory size={16} />
+              {t("dashboard.historyTitle")}
+            </SheetTitle>
+            <SheetDescription>
+              {t("dashboard.historyDescription")}
+            </SheetDescription>
+          </SheetHeader>
+
+          <div className="mt-3 border-t border-border" />
+
+          <div className="h-[calc(100%-96px)] overflow-y-auto p-2">
+            {isLoading ? (
+              <div className="flex items-center justify-center py-12">
+                <IconLoader2
+                  size={16}
+                  className="animate-spin text-muted-foreground"
+                />
+              </div>
+            ) : !revisions?.length ? (
+              <div className="px-6 py-12 text-center text-xs text-muted-foreground">
+                {t("dashboard.historyEmpty")}
+              </div>
+            ) : (
+              <div className="space-y-1">
+                {revisions.map((revision) => (
+                  <div
+                    key={revision.id}
+                    className="rounded-lg border border-border bg-card p-3"
+                  >
+                    <div className="flex items-start justify-between gap-3">
+                      <div className="min-w-0">
+                        <p className="truncate text-xs font-medium">
+                          {revision.title || t("common.untitledDashboard")}
+                        </p>
+                        <p className="mt-0.5 text-[10px] text-muted-foreground">
+                          {formatRelativeTime(revision.createdAt)}
+                          {revision.createdBy
+                            ? ` by ${revision.createdBy}`
+                            : ""}
+                        </p>
+                      </div>
+                      {canRestore ? (
+                        <Button
+                          type="button"
+                          size="sm"
+                          variant="outline"
+                          className="h-7 shrink-0 px-2 text-[11px]"
+                          onClick={() => setPendingRestore(revision)}
+                          disabled={restoreRevision.isPending}
+                        >
+                          {restoreRevision.isPending ? (
+                            <IconLoader2 size={13} className="animate-spin" />
+                          ) : (
+                            <IconRotate size={13} />
+                          )}
+                          <span className="ml-1">
+                            {t("dashboard.historyRestore")}
+                          </span>
+                        </Button>
+                      ) : null}
+                    </div>
+                  </div>
+                ))}
+              </div>
+            )}
+          </div>
+        </SheetContent>
+      </Sheet>
+
+      <AlertDialog
+        open={pendingRestore !== null}
+        onOpenChange={(nextOpen) => {
+          if (!nextOpen) setPendingRestore(null);
+        }}
+      >
+        <AlertDialogContent>
+          <AlertDialogHeader>
+            <AlertDialogTitle>
+              {t("dashboard.historyRestoreQuestion")}
+            </AlertDialogTitle>
+            <AlertDialogDescription>
+              {t("dashboard.historyRestoreWarning")}
+            </AlertDialogDescription>
+          </AlertDialogHeader>
+          <AlertDialogFooter>
+            <AlertDialogCancel>{t("common.cancel")}</AlertDialogCancel>
+            <AlertDialogAction
+              onClick={() => {
+                if (pendingRestore) void doRestore(pendingRestore);
+              }}
+            >
+              {t("dashboard.historyRestore")}
+            </AlertDialogAction>
+          </AlertDialogFooter>
+        </AlertDialogContent>
+      </AlertDialog>
+    </>
+  );
+}

package/corpus/templates/analytics/app/components/dashboard/DataTable.tsx

@@ -27,6 +27,8 @@ import {
 import { cn } from "@/lib/utils";
 
 const PAGE_SIZE_OPTIONS = [10, 25, 50, 100];
+const TABLE_MIN_HEIGHT_CLASS = "min-h-[386px]";
+const TABLE_SKELETON_ROWS = 10;
 
 interface DataTableProps {
   title?: string;
@@ -109,11 +111,7 @@ export function DataTable({
   const content = (
     <>
       {isLoading ? (
-        <div className="space-y-2">
-          {Array.from({ length: 5 }).map((_, i) => (
-            <Skeleton key={i} className="h-8 w-full" />
-          ))}
-        </div>
+        <DataTableLoadingSkeleton />
       ) : error ? (
         <p className="text-sm text-red-400 py-4">{error}</p>
       ) : data.length === 0 ? (
@@ -121,7 +119,7 @@ export function DataTable({
           {t("common.noData")}
         </p>
       ) : (
-        <div className="overflow-x-auto">
+        <div className={`overflow-x-auto ${TABLE_MIN_HEIGHT_CLASS}`}>
           <Table>
             <TableHeader>
               <TableRow>
@@ -227,3 +225,40 @@ export function DataTable({
     </Card>
   );
 }
+
+function DataTableLoadingSkeleton() {
+  const columnWidths = ["w-24", "w-32", "w-20", "w-28"];
+
+  return (
+    <div className={`space-y-1 ${TABLE_MIN_HEIGHT_CLASS}`}>
+      <div className="overflow-x-auto">
+        <div className="min-w-[480px]">
+          <div className="grid h-8 grid-cols-4 items-center border-b border-border px-2">
+            {columnWidths.map((width, index) => (
+              <Skeleton key={index} className={`h-3 ${width}`} />
+            ))}
+          </div>
+          {Array.from({ length: TABLE_SKELETON_ROWS }).map((_, row) => (
+            <div
+              key={row}
+              className="grid h-8 grid-cols-4 items-center border-b border-border/50 px-2"
+            >
+              {columnWidths.map((width, col) => (
+                <Skeleton
+                  key={col}
+                  className={`h-3 ${
+                    col === 0 ? "w-36" : col === 2 ? "ml-auto w-16" : width
+                  }`}
+                />
+              ))}
+            </div>
+          ))}
+        </div>
+      </div>
+      <div className="flex h-8 items-center justify-between border-t border-border px-2 text-xs">
+        <Skeleton className="h-3 w-28" />
+        <Skeleton className="h-3 w-24" />
+      </div>
+    </div>
+  );
+}