@agent-native/core 0.92.0 → 0.92.2

package/corpus/templates/analytics/actions/list-dashboard-usage-stats.ts

@@ -0,0 +1,299 @@
+import { defineAction } from "@agent-native/core/action";
+import { buildDeepLink } from "@agent-native/core/server";
+import { and, eq, like, or, sql } from "drizzle-orm";
+import { z } from "zod";
+
+import { getDb, schema } from "../server/db/index.js";
+import { requireDbAdminContextFromRequest } from "../server/lib/db-admin-connections";
+
+type DashboardUsageStats = {
+  id: string;
+  name: string;
+  kind: "explorer" | "sql";
+  ownerEmail: string | null;
+  visibility: "private" | "org" | "public";
+  createdAt: string;
+  updatedAt: string;
+  updatedBy: string | null;
+  archivedAt: string | null;
+  hiddenAt: string | null;
+  hiddenBy: string | null;
+  viewCount: number;
+  engagementCount: number;
+  eventEngagementCount: number;
+  savedViewCount: number;
+  uniqueUserCount: number;
+  lastViewedAt: string | null;
+  lastSavedViewAt: string | null;
+  panelCount: number | null;
+  url: string;
+};
+
+function toNumber(value: unknown): number {
+  if (typeof value === "number" && Number.isFinite(value)) return value;
+  if (typeof value === "bigint") return Number(value);
+  if (typeof value === "string" && value.trim()) {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : 0;
+  }
+  return 0;
+}
+
+function parseConfig(value: unknown): Record<string, unknown> {
+  if (value && typeof value === "object" && !Array.isArray(value)) {
+    return value as Record<string, unknown>;
+  }
+  if (typeof value !== "string") return {};
+  try {
+    const parsed = JSON.parse(value);
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed)
+      ? parsed
+      : {};
+  } catch {
+    return {};
+  }
+}
+
+function dashboardName(row: { title: string; config: unknown }): string {
+  const config = parseConfig(row.config);
+  const configName = config.name;
+  if (typeof configName === "string" && configName.trim()) {
+    return configName.trim();
+  }
+  return row.title || "Untitled";
+}
+
+function dashboardPanelCount(row: {
+  kind: string;
+  config: unknown;
+}): number | null {
+  if (row.kind !== "sql") return null;
+  const panels = parseConfig(row.config).panels;
+  return Array.isArray(panels) ? panels.length : 0;
+}
+
+export function dashboardIdFromPath(path: string | null): string | null {
+  const pathname = path ?? "";
+  const match = pathname.match(/(?:^|\/)(?:dashboards|adhoc)\/([^/?#]+)/);
+  if (!match) return null;
+  if (match[1] === "explorer-dashboard") {
+    return null;
+  }
+  try {
+    return decodeURIComponent(match[1]);
+  } catch {
+    return match[1];
+  }
+}
+
+export function dashboardIdFromEventLocation(
+  path: string | null,
+  url: string | null,
+): string | null {
+  const direct = dashboardIdFromPath(path);
+  if (direct) return direct;
+  const raw = url || path;
+  if (!raw) return null;
+  try {
+    const parsed = new URL(raw, "https://analytics.local");
+    if (
+      /(?:^|\/)(?:dashboards|adhoc)\/explorer-dashboard$/.test(parsed.pathname)
+    ) {
+      const id = parsed.searchParams.get("id");
+      return id && id.trim() ? id : null;
+    }
+  } catch {
+    // Fall through to regex below for malformed relative strings.
+  }
+  const match = raw.match(
+    /(?:^|\/)(?:dashboards|adhoc)\/explorer-dashboard(?:\?[^#]*)?[?&]id=([^&#]+)/,
+  );
+  if (!match) return null;
+  try {
+    return decodeURIComponent(match[1].replace(/\+/g, " "));
+  } catch {
+    return match[1];
+  }
+}
+
+function dashboardUrl(row: { id: string; kind: string }): string {
+  return row.kind === "explorer"
+    ? `/dashboards/explorer-dashboard?id=${encodeURIComponent(row.id)}`
+    : `/dashboards/${encodeURIComponent(row.id)}`;
+}
+
+export default defineAction({
+  description:
+    "List admin-only dashboard usage and cleanup stats for every dashboard in the active organization. Includes lifecycle metadata, owner, last tracked modifier, pageviews, engagement events, unique viewers, saved view counts, archive/hidden state, and dashboard links. Requires active organization owner/admin role.",
+  schema: z.object({}),
+  http: { method: "GET" },
+  readOnly: true,
+  link: () => ({
+    url: buildDeepLink({
+      app: "analytics",
+      view: "agents",
+      params: { agentsView: "dashboards" },
+    }),
+    label: "Open dashboard usage admin",
+    view: "agents",
+  }),
+  run: async (_args, ctx) => {
+    const admin = await requireDbAdminContextFromRequest(ctx);
+    const db = getDb() as any;
+
+    // guard:allow-unscoped — org owner/admin audit intentionally spans all
+    // dashboard rows in the active org after requireDbAdminContextFromRequest.
+    const dashboardRows = await db
+      .select()
+      .from(schema.dashboards)
+      .where(eq(schema.dashboards.orgId, admin.orgId));
+
+    const dashboardIds = new Set<string>(
+      dashboardRows.map((row: { id: string }) => row.id),
+    );
+
+    const savedViewRows = await db
+      .select({
+        dashboardId: schema.dashboardViews.dashboardId,
+        count: sql<number>`count(*)`,
+        lastSavedViewAt: sql<
+          string | null
+        >`max(${schema.dashboardViews.createdAt})`,
+      })
+      .from(schema.dashboardViews)
+      .groupBy(schema.dashboardViews.dashboardId);
+
+    const savedViewsByDashboard = new Map<
+      string,
+      { count: number; lastSavedViewAt: string | null }
+    >();
+    for (const row of savedViewRows as Array<{
+      dashboardId: string;
+      count: unknown;
+      lastSavedViewAt: string | null;
+    }>) {
+      if (!dashboardIds.has(row.dashboardId)) continue;
+      savedViewsByDashboard.set(row.dashboardId, {
+        count: toNumber(row.count),
+        lastSavedViewAt: row.lastSavedViewAt ?? null,
+      });
+    }
+
+    const analyticsUserIdentity = sql<
+      string | null
+    >`coalesce(nullif(${schema.analyticsEvents.userKey}, ''), nullif(${schema.analyticsEvents.userId}, ''), nullif(${schema.analyticsEvents.anonymousId}, ''), nullif(${schema.analyticsEvents.sessionId}, ''))`;
+    const eventRows = await db
+      .select({
+        path: schema.analyticsEvents.path,
+        url: schema.analyticsEvents.url,
+        eventName: schema.analyticsEvents.eventName,
+        count: sql<number>`count(*)`,
+        userIdentity: analyticsUserIdentity,
+        lastSeenAt: sql<
+          string | null
+        >`max(${schema.analyticsEvents.receivedAt})`,
+      })
+      .from(schema.analyticsEvents)
+      .where(
+        and(
+          eq(schema.analyticsEvents.orgId, admin.orgId),
+          or(
+            like(schema.analyticsEvents.path, "%/dashboards/%"),
+            like(schema.analyticsEvents.path, "%/adhoc/%"),
+            like(schema.analyticsEvents.url, "%/dashboards/%"),
+            like(schema.analyticsEvents.url, "%/adhoc/%"),
+          ),
+        ),
+      )
+      .groupBy(
+        schema.analyticsEvents.path,
+        schema.analyticsEvents.url,
+        schema.analyticsEvents.eventName,
+        analyticsUserIdentity,
+      );
+
+    const eventsByDashboard = new Map<
+      string,
+      {
+        viewCount: number;
+        eventEngagementCount: number;
+        uniqueUsers: Set<string>;
+        lastViewedAt: string | null;
+      }
+    >();
+    for (const row of eventRows as Array<{
+      path: string | null;
+      url: string | null;
+      eventName: string;
+      count: unknown;
+      userIdentity: string | null;
+      lastSeenAt: string | null;
+    }>) {
+      const dashboardId = dashboardIdFromEventLocation(row.path, row.url);
+      if (!dashboardId || !dashboardIds.has(dashboardId)) continue;
+      const current = eventsByDashboard.get(dashboardId) ?? {
+        viewCount: 0,
+        eventEngagementCount: 0,
+        uniqueUsers: new Set<string>(),
+        lastViewedAt: null,
+      };
+      const count = toNumber(row.count);
+      if (row.eventName === "pageview") {
+        current.viewCount += count;
+        current.lastViewedAt =
+          !current.lastViewedAt ||
+          (row.lastSeenAt && row.lastSeenAt > current.lastViewedAt)
+            ? (row.lastSeenAt ?? current.lastViewedAt)
+            : current.lastViewedAt;
+      } else {
+        current.eventEngagementCount += count;
+      }
+      if (row.userIdentity) current.uniqueUsers.add(row.userIdentity);
+      eventsByDashboard.set(dashboardId, current);
+    }
+
+    return (dashboardRows as Array<any>)
+      .map((row): DashboardUsageStats => {
+        const savedViews = savedViewsByDashboard.get(row.id) ?? {
+          count: 0,
+          lastSavedViewAt: null,
+        };
+        const events = eventsByDashboard.get(row.id) ?? {
+          viewCount: 0,
+          eventEngagementCount: 0,
+          uniqueUsers: new Set<string>(),
+          lastViewedAt: null,
+        };
+        return {
+          id: row.id,
+          name: dashboardName(row),
+          kind: row.kind === "explorer" ? "explorer" : "sql",
+          ownerEmail: row.ownerEmail ?? null,
+          visibility:
+            row.visibility === "org" || row.visibility === "public"
+              ? row.visibility
+              : "private",
+          createdAt: row.createdAt,
+          updatedAt: row.updatedAt,
+          updatedBy: row.updatedBy ?? null,
+          archivedAt: row.archivedAt ?? null,
+          hiddenAt: row.hiddenAt ?? null,
+          hiddenBy: row.hiddenBy ?? null,
+          viewCount: events.viewCount,
+          eventEngagementCount: events.eventEngagementCount,
+          savedViewCount: savedViews.count,
+          engagementCount: events.eventEngagementCount + savedViews.count,
+          uniqueUserCount: events.uniqueUsers.size,
+          lastViewedAt: events.lastViewedAt,
+          lastSavedViewAt: savedViews.lastSavedViewAt,
+          panelCount: dashboardPanelCount(row),
+          url: dashboardUrl(row),
+        };
+      })
+      .sort((a, b) => {
+        const views = b.viewCount - a.viewCount;
+        if (views !== 0) return views;
+        return b.updatedAt.localeCompare(a.updatedAt);
+      });
+  },
+});

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)

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>
+    </>
+  );
+}