@agent-native/core 0.90.11 → 0.91.1

package/corpus/templates/analytics/actions/add-status-page-monitor.ts

@@ -0,0 +1,36 @@
+import { defineAction } from "@agent-native/core";
+import {
+  getRequestOrgId,
+  getRequestUserEmail,
+} from "@agent-native/core/server";
+import { z } from "zod";
+
+import { addStatusPageMonitor } from "../server/lib/status-pages";
+
+export default defineAction({
+  description:
+    "Add a monitor to a status page (appended to the end, deduplicated). The monitor must be owned by the current user.",
+  schema: z.object({
+    id: z.string().describe("Status page id."),
+    monitorId: z.string().describe("Monitor id to add."),
+    displayName: z
+      .string()
+      .nullable()
+      .optional()
+      .describe("Optional public display-name override."),
+    showUrl: z
+      .boolean()
+      .optional()
+      .describe("Opt in to publicly showing this monitor's URL/host."),
+  }),
+  run: async ({ id, monitorId, displayName, showUrl }) => {
+    const email = getRequestUserEmail();
+    if (!email) throw new Error("no authenticated user");
+    const orgId = getRequestOrgId() || null;
+    return addStatusPageMonitor(
+      id,
+      { monitorId, displayName, showUrl },
+      { email, orgId },
+    );
+  },
+});

package/corpus/templates/analytics/actions/capture-test-error.ts

@@ -0,0 +1,33 @@
+import { defineAction } from "@agent-native/core";
+import {
+  getRequestOrgId,
+  getRequestUserEmail,
+} from "@agent-native/core/server";
+import { z } from "zod";
+
+import { captureTestError } from "../server/lib/error-capture.js";
+
+function resolveScope() {
+  const userEmail = getRequestUserEmail();
+  if (!userEmail) throw new Error("no authenticated user");
+  return { userEmail, orgId: getRequestOrgId() || null };
+}
+
+export default defineAction({
+  description:
+    "Generate a sample captured error to verify the Error capture pipeline end-to-end. Creates or reopens an error issue owned by the current user/org so it shows up in the Monitoring → Errors view.",
+  schema: z.object({
+    message: z
+      .string()
+      .optional()
+      .describe("Optional custom error message for the sample error."),
+    type: z
+      .string()
+      .optional()
+      .describe("Optional error type/name, e.g. TypeError. Defaults to Error."),
+  }),
+  http: { method: "POST" },
+  run: async (args) => {
+    return captureTestError(resolveScope(), args);
+  },
+});

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

@@ -0,0 +1,24 @@
+import { defineAction } from "@agent-native/core";
+import {
+  getRequestOrgId,
+  getRequestUserEmail,
+} from "@agent-native/core/server";
+import { z } from "zod";
+
+import { deleteMonitor } from "../server/lib/uptime-monitors";
+
+export default defineAction({
+  description:
+    "Delete an uptime monitor and its check history and incident records.",
+  schema: z.object({
+    id: z.string().describe("Monitor id to delete."),
+  }),
+  http: { method: "POST" },
+  run: async ({ id }) => {
+    const email = getRequestUserEmail();
+    if (!email) throw new Error("no authenticated user");
+    const orgId = getRequestOrgId() || null;
+    await deleteMonitor(id, { email, orgId });
+    return { ok: true, id };
+  },
+});

package/corpus/templates/analytics/actions/delete-status-page.ts

@@ -0,0 +1,23 @@
+import { defineAction } from "@agent-native/core";
+import {
+  getRequestOrgId,
+  getRequestUserEmail,
+} from "@agent-native/core/server";
+import { z } from "zod";
+
+import { deleteStatusPage } from "../server/lib/status-pages";
+
+export default defineAction({
+  description: "Delete one of the current user's public status pages by id.",
+  schema: z.object({
+    id: z.string().describe("Status page id."),
+  }),
+  http: { method: "DELETE" },
+  run: async ({ id }) => {
+    const email = getRequestUserEmail();
+    if (!email) throw new Error("no authenticated user");
+    const orgId = getRequestOrgId() || null;
+    await deleteStatusPage(id, { email, orgId });
+    return { id, deleted: true };
+  },
+});

package/corpus/templates/analytics/actions/get-error-issue.ts

@@ -0,0 +1,36 @@
+import { defineAction } from "@agent-native/core";
+import {
+  getRequestOrgId,
+  getRequestUserEmail,
+} from "@agent-native/core/server";
+import { z } from "zod";
+
+import { getErrorIssue } from "../server/lib/error-capture.js";
+
+function resolveScope() {
+  const userEmail = getRequestUserEmail();
+  if (!userEmail) throw new Error("no authenticated user");
+  return { userEmail, orgId: getRequestOrgId() || null };
+}
+
+export default defineAction({
+  description:
+    "Get one captured error issue with its recent occurrences (parsed stack frames, breadcrumbs, tags/extra) and links to the session replays where the error happened. Use this to triage a specific issue and jump to the replay.",
+  schema: z.object({
+    id: z.string().describe("Error issue id (erriss_...)."),
+    eventsLimit: z.coerce
+      .number()
+      .int()
+      .min(1)
+      .max(200)
+      .optional()
+      .describe("Max recent occurrences to return. Defaults to 50."),
+  }),
+  http: { method: "GET" },
+  readOnly: true,
+  run: async (args) => {
+    return getErrorIssue(resolveScope(), args.id, {
+      eventsLimit: args.eventsLimit,
+    });
+  },
+});

package/corpus/templates/analytics/actions/get-monitor-stats.ts

@@ -0,0 +1,55 @@
+import { defineAction } from "@agent-native/core";
+import {
+  getRequestOrgId,
+  getRequestUserEmail,
+} from "@agent-native/core/server";
+import { z } from "zod";
+
+import {
+  getMonitorStats,
+  listOwnedMonitorIds,
+  type MonitorStats,
+} from "../server/lib/monitor-stats";
+
+export default defineAction({
+  description:
+    "Get aggregated uptime stats for the current user's monitors: current status, uptime % over 24h/7d/30d/90d, a bucketed uptime timeline, a recent response-time series, incident count, and MTBF. Pass monitorIds to scope to specific monitors, or omit to include all.",
+  schema: z.object({
+    monitorIds: z
+      .array(z.string())
+      .optional()
+      .describe("Monitor ids to include. Omit for all of the user's monitors."),
+    timelineDays: z.coerce
+      .number()
+      .int()
+      .min(1)
+      .max(365)
+      .optional()
+      .describe("Trailing daily buckets for the uptime timeline (default 90)."),
+    responseWindowHours: z.coerce
+      .number()
+      .int()
+      .min(1)
+      .max(24 * 90)
+      .optional()
+      .describe(
+        "Trailing hours for the hourly response-time series (default 24).",
+      ),
+  }),
+  http: { method: "GET" },
+  run: async ({ monitorIds, timelineDays, responseWindowHours }) => {
+    const email = getRequestUserEmail();
+    if (!email) throw new Error("no authenticated user");
+    const orgId = getRequestOrgId() || null;
+    const ctx = { email, orgId };
+    const ids =
+      monitorIds && monitorIds.length > 0
+        ? monitorIds
+        : await listOwnedMonitorIds(ctx);
+    const stats = await getMonitorStats(ctx, ids, {
+      timelineDays,
+      responseWindowHours,
+    });
+    return Array.from(stats.values()) satisfies MonitorStats[];
+  },
+});

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

@@ -0,0 +1,27 @@
+import { defineAction } from "@agent-native/core";
+import {
+  getRequestOrgId,
+  getRequestUserEmail,
+} from "@agent-native/core/server";
+import { z } from "zod";
+
+import { getMonitor } from "../server/lib/uptime-monitors";
+
+export default defineAction({
+  description:
+    "Get one uptime monitor with its recent check results and incident history.",
+  schema: z.object({
+    id: z.string().describe("Monitor id."),
+  }),
+  http: { method: "GET" },
+  run: async ({ id }) => {
+    const email = getRequestUserEmail();
+    if (!email) throw new Error("no authenticated user");
+    const orgId = getRequestOrgId() || null;
+    const detail = await getMonitor(id, { email, orgId });
+    if (!detail) {
+      throw Object.assign(new Error("Monitor not found"), { statusCode: 404 });
+    }
+    return detail;
+  },
+});

package/corpus/templates/analytics/actions/get-public-status-page.ts

@@ -0,0 +1,41 @@
+import { defineAction } from "@agent-native/core";
+import { z } from "zod";
+
+import { getPublicStatusPage } from "../server/lib/status-pages";
+
+/**
+ * UNAUTHENTICATED read of a PUBLISHED status page by slug. Returns only the
+ * sanitized public projection (display name/host, current status, uptime %s,
+ * timeline buckets, optional response time) — never monitor URLs (unless the
+ * owner enabled per-monitor "show URL"), headers, assertions, or alert config.
+ *
+ * Its HTTP route is whitelisted in server/plugins/auth.ts so link visitors and
+ * the public SSR page's light auto-refresh can read it without a session. It is
+ * hidden from the agent tool surface (`agentTool: false`) — the agent already
+ * has the owner-scoped `list-status-pages` / `get-status-page`.
+ */
+export default defineAction({
+  description:
+    "Read a published public status page by slug (unauthenticated, safe fields only).",
+  schema: z.object({
+    slug: z.string().describe("Public status page slug."),
+  }),
+  http: { method: "GET" },
+  // Public, unauthenticated read: no session is required and no owner context is
+  // used (the page owner is resolved from the row itself). The HTTP route is
+  // also whitelisted in server/plugins/auth.ts.
+  requiresAuth: false,
+  readOnly: true,
+  // Hidden from the agent tool surface — the agent uses the owner-scoped
+  // list-status-pages / get-status-page instead.
+  agentTool: false,
+  run: async ({ slug }) => {
+    const page = await getPublicStatusPage(slug);
+    if (!page) {
+      throw Object.assign(new Error("Status page not found"), {
+        statusCode: 404,
+      });
+    }
+    return page;
+  },
+});

package/corpus/templates/analytics/actions/get-status-page.ts

@@ -0,0 +1,29 @@
+import { defineAction } from "@agent-native/core";
+import {
+  getRequestOrgId,
+  getRequestUserEmail,
+} from "@agent-native/core/server";
+import { z } from "zod";
+
+import { getStatusPagePreview } from "../server/lib/status-pages";
+
+export default defineAction({
+  description:
+    "Get one of the current user's status pages by id, with its config and a live preview (the same sanitized view the public page renders, including drafts).",
+  schema: z.object({
+    id: z.string().describe("Status page id."),
+  }),
+  http: { method: "GET" },
+  run: async ({ id }) => {
+    const email = getRequestUserEmail();
+    if (!email) throw new Error("no authenticated user");
+    const orgId = getRequestOrgId() || null;
+    const result = await getStatusPagePreview(id, { email, orgId });
+    if (!result) {
+      throw Object.assign(new Error("Status page not found"), {
+        statusCode: 404,
+      });
+    }
+    return result;
+  },
+});

package/corpus/templates/analytics/actions/list-error-issues.ts

@@ -0,0 +1,40 @@
+import { defineAction } from "@agent-native/core";
+import {
+  getRequestOrgId,
+  getRequestUserEmail,
+} from "@agent-native/core/server";
+import { z } from "zod";
+
+import { listErrorIssues } from "../server/lib/error-capture.js";
+
+function resolveScope() {
+  const userEmail = getRequestUserEmail();
+  if (!userEmail) throw new Error("no authenticated user");
+  return { userEmail, orgId: getRequestOrgId() || null };
+}
+
+export default defineAction({
+  description:
+    "List captured JavaScript error issues (Sentry-style groups) accessible to the current user/org. Each issue groups occurrences by fingerprint with counts, users affected, first/last seen, status, and a recent-volume sparkline.",
+  schema: z.object({
+    status: z
+      .enum(["unresolved", "resolved", "ignored", "all"])
+      .optional()
+      .describe("Filter by triage status. Defaults to all."),
+    query: z
+      .string()
+      .optional()
+      .describe("Search across issue title, type, culprit, and fingerprint."),
+    app: z.string().optional().describe("Optional app filter."),
+    sort: z
+      .enum(["lastSeen", "eventCount", "firstSeen"])
+      .optional()
+      .describe("Sort order; defaults to most recently seen."),
+    limit: z.coerce.number().int().min(1).max(100).optional().default(50),
+  }),
+  http: { method: "GET" },
+  readOnly: true,
+  run: async (args) => {
+    return listErrorIssues(resolveScope(), args);
+  },
+});

package/corpus/templates/analytics/actions/list-monitors.ts

@@ -0,0 +1,21 @@
+import { defineAction } from "@agent-native/core";
+import {
+  getRequestOrgId,
+  getRequestUserEmail,
+} from "@agent-native/core/server";
+import { z } from "zod";
+
+import { listMonitors } from "../server/lib/uptime-monitors";
+
+export default defineAction({
+  description:
+    "List the current user's uptime monitors with their latest status, latency, and 24h/7d uptime percentage.",
+  schema: z.object({}),
+  http: { method: "GET" },
+  run: async () => {
+    const email = getRequestUserEmail();
+    if (!email) throw new Error("no authenticated user");
+    const orgId = getRequestOrgId() || null;
+    return listMonitors({ email, orgId });
+  },
+});

package/corpus/templates/analytics/actions/list-status-pages.ts

@@ -0,0 +1,21 @@
+import { defineAction } from "@agent-native/core";
+import {
+  getRequestOrgId,
+  getRequestUserEmail,
+} from "@agent-native/core/server";
+import { z } from "zod";
+
+import { listStatusPages } from "../server/lib/status-pages";
+
+export default defineAction({
+  description:
+    "List the current user's public status pages with their slug, title, published state, layout options, and included monitors.",
+  schema: z.object({}),
+  http: { method: "GET" },
+  run: async () => {
+    const email = getRequestUserEmail();
+    if (!email) throw new Error("no authenticated user");
+    const orgId = getRequestOrgId() || null;
+    return listStatusPages({ email, orgId });
+  },
+});

package/corpus/templates/analytics/actions/match-error-issues.ts

@@ -0,0 +1,51 @@
+import { defineAction } from "@agent-native/core";
+import {
+  getRequestOrgId,
+  getRequestUserEmail,
+} from "@agent-native/core/server";
+import { z } from "zod";
+
+import { matchErrorIssuesBySignatures } from "../server/lib/error-capture.js";
+
+function resolveScope() {
+  const userEmail = getRequestUserEmail();
+  if (!userEmail) throw new Error("no authenticated user");
+  return { userEmail, orgId: getRequestOrgId() || null };
+}
+
+export default defineAction({
+  description:
+    "Resolve session console error lines to their captured error issues. Given each line's message/stack/source (as shown in a session recording's devtools console), returns the matching Sentry-style issue id per line so the UI or agent can deep-link to /monitoring?view=errors&issue=<id>. Fingerprints are computed with the same grouping logic as ingest, so a match is the exact issue the error was filed under; lines with no captured issue are omitted. Read-only.",
+  schema: z.object({
+    signatures: z
+      .array(
+        z.object({
+          key: z
+            .string()
+            .describe("Caller-chosen id echoed back as the result key."),
+          source: z
+            .string()
+            .optional()
+            .describe(
+              "Console source, e.g. window-error / unhandledrejection / console.",
+            ),
+          message: z
+            .string()
+            .describe(
+              'Console error message, e.g. "TypeError: x is not a function".',
+            ),
+          stack: z
+            .string()
+            .optional()
+            .describe("Raw stack string for the error, if captured."),
+        }),
+      )
+      .max(100)
+      .describe("Session console error lines to resolve to issues."),
+  }),
+  http: { method: "POST" },
+  readOnly: true,
+  run: async (args) => {
+    return matchErrorIssuesBySignatures(resolveScope(), args.signatures);
+  },
+});

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

@@ -4,13 +4,13 @@ import { z } from "zod";
 
 export default defineAction({
   description:
-    "Navigate the UI to a specific view, dashboard, analysis, extension, Analytics session recording, or Analytics agent-admin surface. For filter changes (dashboard filter query params like ?f_date=... or session filters like ?range=30d&q=signup), use the framework-level `set-search-params` tool instead of this action.",
+    "Navigate the UI to a specific view, dashboard, analysis, extension, Analytics session recording, Monitoring tab (uptime checks, public status pages, or captured errors), or Analytics agent-admin surface. For filter changes (dashboard filter query params like ?f_date=... or session filters like ?range=30d&q=signup), use the framework-level `set-search-params` tool instead of this action.",
   schema: z.object({
     view: z
       .string()
       .optional()
       .describe(
-        "View to navigate to (ask, adhoc, analyses, extensions, sessions, agents, catalog, data-dictionary, data-sources, settings)",
+        "View to navigate to (ask, adhoc, analyses, extensions, sessions, monitoring, agents, catalog, data-dictionary, data-sources, settings)",
       ),
     dashboardId: z
       .string()
@@ -38,6 +38,30 @@ export default defineAction({
       .describe(
         "Connected app database id to select when navigating to agentsView=database",
       ),
+    monitoringView: z
+      .enum(["uptime", "errors"])
+      .optional()
+      .describe(
+        "Monitoring tab subview to open (uptime checks or captured errors). Used with view=monitoring; defaults to uptime.",
+      ),
+    monitorId: z
+      .string()
+      .optional()
+      .describe(
+        'Uptime monitor id to open (used with view=monitoring; implies the uptime subview). Pass "new" to open the create-monitor form.',
+      ),
+    statusPageId: z
+      .string()
+      .optional()
+      .describe(
+        'Public status page to open in the uptime subview\'s Status pages config (used with view=monitoring; implies the uptime subview). Pass "list" for the index, "new" for the create form, or a status page id to edit that page.',
+      ),
+    errorIssueId: z
+      .string()
+      .optional()
+      .describe(
+        "Captured error issue id to open (used with view=monitoring; implies the errors subview).",
+      ),
   }),
   http: false,
   run: async (args) => {
@@ -48,10 +72,14 @@ export default defineAction({
       !args.extensionId &&
       !args.recordingId &&
       !args.agentsView &&
-      !args.dbAdminConnectionId
+      !args.dbAdminConnectionId &&
+      !args.monitoringView &&
+      !args.monitorId &&
+      !args.statusPageId &&
+      !args.errorIssueId
     ) {
       throw new Error(
-        "At least --view, --dashboardId, --analysisId, --extensionId, --recordingId, --agentsView, or --dbAdminConnectionId is required.",
+        "At least --view, --dashboardId, --analysisId, --extensionId, --recordingId, --agentsView, --dbAdminConnectionId, --monitoringView, --monitorId, --statusPageId, or --errorIssueId is required.",
       );
     }
     const nav: Record<string, string> = {};
@@ -81,6 +109,28 @@ export default defineAction({
       nav.agentsView = "database";
       if (!args.view) nav.view = "agents";
     }
+    if (args.monitoringView) {
+      nav.monitoringView = args.monitoringView;
+      if (!args.view) nav.view = "monitoring";
+    }
+    if (args.monitorId) {
+      nav.monitorId = args.monitorId;
+      // Monitors live under the uptime subview.
+      nav.monitoringView = "uptime";
+      if (!args.view) nav.view = "monitoring";
+    }
+    if (args.statusPageId) {
+      nav.statusPageId = args.statusPageId;
+      // Status pages are configured under the uptime subview.
+      nav.monitoringView = "uptime";
+      if (!args.view) nav.view = "monitoring";
+    }
+    if (args.errorIssueId) {
+      nav.errorIssueId = args.errorIssueId;
+      // Error issues live under the errors subview.
+      nav.monitoringView = "errors";
+      if (!args.view) nav.view = "monitoring";
+    }
     await writeAppState("navigate", nav);
 
     const parts: string[] = [];
@@ -92,6 +142,10 @@ export default defineAction({
     if (nav.agentsView) parts.push(`agents:${nav.agentsView}`);
     if (nav.dbAdminConnectionId)
       parts.push(`db-admin:${nav.dbAdminConnectionId}`);
+    if (nav.monitoringView) parts.push(`monitoring:${nav.monitoringView}`);
+    if (nav.monitorId) parts.push(`monitor:${nav.monitorId}`);
+    if (nav.statusPageId) parts.push(`status-page:${nav.statusPageId}`);
+    if (nav.errorIssueId) parts.push(`issue:${nav.errorIssueId}`);
     return `Navigating to ${parts.join(" ")}`;
   },
 });

package/corpus/templates/analytics/actions/remove-status-page-monitor.ts

@@ -0,0 +1,22 @@
+import { defineAction } from "@agent-native/core";
+import {
+  getRequestOrgId,
+  getRequestUserEmail,
+} from "@agent-native/core/server";
+import { z } from "zod";
+
+import { removeStatusPageMonitor } from "../server/lib/status-pages";
+
+export default defineAction({
+  description: "Remove a monitor from a status page.",
+  schema: z.object({
+    id: z.string().describe("Status page id."),
+    monitorId: z.string().describe("Monitor id to remove."),
+  }),
+  run: async ({ id, monitorId }) => {
+    const email = getRequestUserEmail();
+    if (!email) throw new Error("no authenticated user");
+    const orgId = getRequestOrgId() || null;
+    return removeStatusPageMonitor(id, monitorId, { email, orgId });
+  },
+});

package/corpus/templates/analytics/actions/reorder-status-page-monitors.ts

@@ -0,0 +1,25 @@
+import { defineAction } from "@agent-native/core";
+import {
+  getRequestOrgId,
+  getRequestUserEmail,
+} from "@agent-native/core/server";
+import { z } from "zod";
+
+import { reorderStatusPageMonitors } from "../server/lib/status-pages";
+
+export default defineAction({
+  description:
+    "Reorder the monitors on a status page. Pass the full list of monitor ids in the desired display order.",
+  schema: z.object({
+    id: z.string().describe("Status page id."),
+    monitorIds: z
+      .array(z.string())
+      .describe("All included monitor ids, in the desired order."),
+  }),
+  run: async ({ id, monitorIds }) => {
+    const email = getRequestUserEmail();
+    if (!email) throw new Error("no authenticated user");
+    const orgId = getRequestOrgId() || null;
+    return reorderStatusPageMonitors(id, monitorIds, { email, orgId });
+  },
+});

package/corpus/templates/analytics/actions/resolve-error-issue.ts

@@ -0,0 +1,38 @@
+import { defineAction } from "@agent-native/core";
+import {
+  getRequestOrgId,
+  getRequestUserEmail,
+} from "@agent-native/core/server";
+import { z } from "zod";
+
+import { updateErrorIssue } from "../server/lib/error-capture.js";
+
+function resolveScope() {
+  const userEmail = getRequestUserEmail();
+  if (!userEmail) throw new Error("no authenticated user");
+  return { userEmail, orgId: getRequestOrgId() || null };
+}
+
+export default defineAction({
+  description:
+    "Update the triage state of a captured error issue: set status to unresolved (reopen), resolved, or ignored, and optionally (re)assign a triage owner.",
+  schema: z.object({
+    id: z.string().describe("Error issue id (erriss_...)."),
+    status: z
+      .enum(["unresolved", "resolved", "ignored"])
+      .optional()
+      .describe("New triage status."),
+    assignee: z
+      .string()
+      .nullable()
+      .optional()
+      .describe("Assignee email, or null to clear the assignment."),
+  }),
+  http: { method: "POST" },
+  run: async (args) => {
+    return updateErrorIssue(resolveScope(), args.id, {
+      status: args.status,
+      assignee: args.assignee,
+    });
+  },
+});

package/corpus/templates/analytics/actions/run-monitor-check.ts

@@ -0,0 +1,23 @@
+import { defineAction } from "@agent-native/core";
+import {
+  getRequestOrgId,
+  getRequestUserEmail,
+} from "@agent-native/core/server";
+import { z } from "zod";
+
+import { runMonitorNow } from "../server/lib/uptime-monitors";
+
+export default defineAction({
+  description:
+    "Run one uptime check now for a monitor. Probes the URL, records the result, opens/resolves incidents, and returns the outcome.",
+  schema: z.object({
+    id: z.string().describe("Monitor id to check now."),
+  }),
+  http: { method: "POST" },
+  run: async ({ id }) => {
+    const email = getRequestUserEmail();
+    if (!email) throw new Error("no authenticated user");
+    const orgId = getRequestOrgId() || null;
+    return runMonitorNow(id, { email, orgId });
+  },
+});