@agent-native/core 0.77.24 → 0.78.1

package/corpus/templates/analytics/server/db/schema.ts

@@ -3,8 +3,10 @@ import {
   text,
   integer,
   now,
+  index,
   ownableColumns,
   createSharesTable,
+  uniqueIndex,
 } from "@agent-native/core/db/schema";
 
 /**
@@ -49,6 +51,38 @@ export const dashboardViews = table("dashboard_views", {
   createdAt: text("created_at").notNull().default(now()),
 });
 
+/**
+ * Scheduled email snapshots for SQL dashboards. Each row belongs to the user
+ * who created the subscription; dashboard access is re-checked before every
+ * send so revoking dashboard access also stops future deliveries.
+ */
+export const dashboardReportSubscriptions = table(
+  "dashboard_report_subscriptions",
+  {
+    id: text("id").primaryKey(),
+    dashboardId: text("dashboard_id").notNull(),
+    name: text("name").notNull(),
+    recipients: text("recipients").notNull().default("[]"),
+    filters: text("filters").notNull().default("{}"),
+    frequency: text("frequency", { enum: ["daily"] })
+      .notNull()
+      .default("daily"),
+    timeOfDay: text("time_of_day").notNull().default("09:00"),
+    timezone: text("timezone").notNull().default("UTC"),
+    enabled: integer("enabled", { mode: "boolean" }).notNull().default(true),
+    nextRunAt: text("next_run_at"),
+    lastRunAt: text("last_run_at"),
+    lastStatus: text("last_status", {
+      enum: ["success", "error", "running"],
+    }),
+    lastError: text("last_error"),
+    createdAt: text("created_at").notNull().default(now()),
+    updatedAt: text("updated_at").notNull().default(now()),
+    ownerEmail: text("owner_email").notNull().default("local@localhost"),
+    orgId: text("org_id"),
+  },
+);
+
 /**
  * Ad-hoc analyses. Previously stored in the settings KV store under
  * `adhoc-analysis-{id}`. Those keys are read as a fallback during lazy
@@ -102,6 +136,13 @@ export const analyticsPublicKeys = table("analytics_public_keys", {
   name: text("name").notNull(),
   publicKey: text("public_key").notNull(),
   publicKeyPrefix: text("public_key_prefix").notNull(),
+  replayAllowedOrigins: text("replay_allowed_origins").notNull().default("[]"),
+  replayMaxBytesPerDay: integer("replay_max_bytes_per_day")
+    .notNull()
+    .default(100 * 1024 * 1024),
+  replayMaxRequestsPerMinute: integer("replay_max_requests_per_minute")
+    .notNull()
+    .default(120),
   createdAt: text("created_at").notNull().default(now()),
   lastUsedAt: text("last_used_at"),
   revokedAt: text("revoked_at"),
@@ -137,3 +178,93 @@ export const analyticsEvents = table("analytics_events", {
   ownerEmail: text("owner_email").notNull().default("local@localhost"),
   orgId: text("org_id"),
 });
+
+/**
+ * Session replay summaries recorded through the first-party analytics replay
+ * endpoint. Raw replay chunks live in session_replay_chunks and are only read
+ * through scoped replay helpers, not first-party dashboard SQL.
+ */
+export const sessionRecordings = table("session_recordings", {
+  id: text("id").primaryKey(),
+  publicKeyId: text("public_key_id").notNull(),
+  clientRecordingId: text("client_recording_id").notNull(),
+  sessionId: text("session_id").notNull(),
+  userId: text("user_id"),
+  anonymousId: text("anonymous_id"),
+  userKey: text("user_key"),
+  startedAt: text("started_at").notNull(),
+  endedAt: text("ended_at"),
+  durationMs: integer("duration_ms"),
+  chunkCount: integer("chunk_count").notNull().default(0),
+  eventCount: integer("event_count").notNull().default(0),
+  totalBytes: integer("total_bytes").notNull().default(0),
+  pageCount: integer("page_count").notNull().default(0),
+  errorCount: integer("error_count").notNull().default(0),
+  rageClickCount: integer("rage_click_count").notNull().default(0),
+  privacyMode: text("privacy_mode").notNull().default("unknown"),
+  firstUrl: text("first_url"),
+  lastUrl: text("last_url"),
+  path: text("path"),
+  hostname: text("hostname"),
+  referrer: text("referrer"),
+  app: text("app"),
+  template: text("template"),
+  status: text("status", { enum: ["active", "completed"] })
+    .notNull()
+    .default("active"),
+  metadata: text("metadata").notNull().default("{}"),
+  createdAt: text("created_at").notNull().default(now()),
+  updatedAt: text("updated_at").notNull().default(now()),
+  lastIngestedAt: text("last_ingested_at"),
+  ...ownableColumns(),
+});
+
+export const sessionRecordingShares = createSharesTable(
+  "session_recording_shares",
+);
+
+export const sessionReplayChunks = table(
+  "session_replay_chunks",
+  {
+    id: text("id").primaryKey(),
+    recordingId: text("recording_id").notNull(),
+    seq: integer("seq").notNull(),
+    checksum: text("checksum").notNull(),
+    byteLength: integer("byte_length").notNull().default(0),
+    eventCount: integer("event_count").notNull().default(0),
+    startedAt: text("started_at"),
+    endedAt: text("ended_at"),
+    storageKind: text("storage_kind", { enum: ["inline", "blob"] }).notNull(),
+    storageRef: text("storage_ref"),
+    inlineData: text("inline_data"),
+    createdAt: text("created_at").notNull().default(now()),
+    ownerEmail: text("owner_email").notNull().default("local@localhost"),
+    orgId: text("org_id"),
+  },
+  (chunk) => ({
+    recordingSeqUnique: uniqueIndex(
+      "session_replay_chunks_recording_seq_idx",
+    ).on(chunk.recordingId, chunk.seq),
+  }),
+);
+
+export const sessionReplayIngests = table(
+  "session_replay_ingests",
+  {
+    id: text("id").primaryKey(),
+    publicKeyId: text("public_key_id").notNull(),
+    recordingId: text("recording_id").notNull(),
+    byteLength: integer("byte_length").notNull().default(0),
+    createdAt: text("created_at").notNull().default(now()),
+    ownerEmail: text("owner_email").notNull().default("local@localhost"),
+    orgId: text("org_id"),
+  },
+  (ingest) => ({
+    publicKeyCreatedAtIdx: index(
+      "session_replay_ingests_public_key_created_at_idx",
+    ).on(ingest.publicKeyId, ingest.createdAt),
+    recordingIdx: index("session_replay_ingests_recording_idx").on(
+      ingest.recordingId,
+    ),
+  }),
+);

package/corpus/templates/analytics/server/handlers/session-replay.ts

@@ -0,0 +1,281 @@
+import { readBody } from "@agent-native/core/server";
+import {
+  defineEventHandler,
+  getHeader,
+  getQuery,
+  getRouterParam,
+  setResponseHeader,
+  setResponseStatus,
+} from "h3";
+
+import { runApiHandlerWithContext } from "../lib/credentials";
+import {
+  getSessionReplayManifest,
+  getSessionReplayEvents,
+  getSessionReplaySummary,
+  listSessionRecordings,
+  parseSessionReplayIngestPayload,
+  recordSessionReplayChunks,
+  readSessionReplayChunkBytes,
+  type SessionReplayListFilters,
+} from "../lib/session-replay.js";
+
+const PUBLIC_KEY_QUERY_NAMES = new Set([
+  "apiKey",
+  "analyticsKey",
+  "key",
+  "publicKey",
+  "writeKey",
+]);
+
+function readOrigin(event: any): string | null {
+  const origin = getHeader(event, "origin");
+  if (typeof origin === "string" && origin.trim()) return origin.trim();
+  return null;
+}
+
+function setCors(event: any): void {
+  const origin = readOrigin(event);
+  if (origin) {
+    setResponseHeader(event, "Access-Control-Allow-Origin", origin);
+    setResponseHeader(event, "Vary", "Origin");
+  }
+  setResponseHeader(
+    event,
+    "Access-Control-Allow-Methods",
+    "GET, POST, OPTIONS",
+  );
+  setResponseHeader(
+    event,
+    "Access-Control-Allow-Headers",
+    "content-type, x-agent-native-analytics-key",
+  );
+  setResponseHeader(event, "Access-Control-Max-Age", "86400");
+}
+
+function statusFromError(error: any): number {
+  return typeof error?.statusCode === "number" ? error.statusCode : 400;
+}
+
+function messageFromError(error: any): string {
+  return error?.message || String(error);
+}
+
+function hasQueryKey(query: Record<string, unknown>): boolean {
+  return Object.keys(query).some((key) => PUBLIC_KEY_QUERY_NAMES.has(key));
+}
+
+function injectHeaderKey(body: unknown, headerKey?: string): unknown {
+  if (!headerKey) return body;
+  if (typeof body === "string" && body.trim()) {
+    return { ...JSON.parse(body), publicKey: headerKey };
+  }
+  if (body && typeof body === "object" && !Array.isArray(body)) {
+    return { ...(body as Record<string, unknown>), publicKey: headerKey };
+  }
+  return { publicKey: headerKey };
+}
+
+function requestByteLength(body: unknown): number {
+  if (typeof body === "string") return Buffer.byteLength(body, "utf8");
+  try {
+    return Buffer.byteLength(JSON.stringify(body), "utf8");
+  } catch {
+    return 0;
+  }
+}
+
+function asString(value: unknown): string | undefined {
+  if (typeof value === "string" && value.trim()) return value.trim();
+  if (Array.isArray(value) && typeof value[0] === "string" && value[0].trim()) {
+    return value[0].trim();
+  }
+  return undefined;
+}
+
+function asInt(value: unknown): number | undefined {
+  const raw = asString(value);
+  if (!raw || !/^\d+$/.test(raw)) return undefined;
+  return Number(raw);
+}
+
+function asBool(value: unknown): boolean | undefined {
+  const raw = asString(value)?.toLowerCase();
+  if (!raw) return undefined;
+  if (["1", "true", "yes", "on"].includes(raw)) return true;
+  if (["0", "false", "no", "off"].includes(raw)) return false;
+  return undefined;
+}
+
+function asStatus(value: unknown): "active" | "completed" | undefined {
+  const raw = asString(value);
+  return raw === "active" || raw === "completed" ? raw : undefined;
+}
+
+function listFiltersFromQuery(
+  query: Record<string, unknown>,
+): SessionReplayListFilters {
+  return {
+    query: asString(query.query) ?? asString(query.q),
+    app: asString(query.app),
+    template: asString(query.template),
+    sessionId: asString(query.sessionId),
+    userId: asString(query.userId),
+    anonymousId: asString(query.anonymousId),
+    path: asString(query.path),
+    from: asString(query.from),
+    to: asString(query.to),
+    minDurationMs: asInt(query.minDurationMs),
+    hasErrors: asBool(query.hasErrors),
+    hasRageClicks: asBool(query.hasRageClicks),
+    status: asStatus(query.status),
+    limit: asInt(query.limit),
+  };
+}
+
+export const handleSessionReplayOptions = defineEventHandler((event) => {
+  setCors(event);
+  setResponseStatus(event, 204);
+  return "";
+});
+
+export const handleSessionReplayIngest = defineEventHandler(async (event) => {
+  setCors(event);
+  try {
+    const query = getQuery(event);
+    if (hasQueryKey(query)) {
+      throw Object.assign(
+        new Error(
+          "Analytics public keys must be sent in the request body or x-agent-native-analytics-key header, not the query string",
+        ),
+        { statusCode: 400 },
+      );
+    }
+
+    const headerKey = getHeader(event, "x-agent-native-analytics-key");
+    const rawBody = await readBody(event);
+    const body = injectHeaderKey(rawBody, headerKey);
+    const parsed = parseSessionReplayIngestPayload(body);
+    const result = await recordSessionReplayChunks(parsed, {
+      origin: readOrigin(event),
+      requestBytes: requestByteLength(rawBody),
+    });
+    setResponseStatus(event, 202);
+    return { success: true, ...result };
+  } catch (error: any) {
+    setResponseStatus(event, statusFromError(error));
+    return { error: messageFromError(error) };
+  }
+});
+
+export const handleSessionReplayList = defineEventHandler(async (event) => {
+  return runApiHandlerWithContext(event, async (ctx) => {
+    try {
+      const recordings = await listSessionRecordings(
+        { userEmail: ctx.userEmail, orgId: ctx.orgId ?? null },
+        listFiltersFromQuery(getQuery(event)),
+      );
+      return { recordings };
+    } catch (error: any) {
+      setResponseStatus(event, statusFromError(error));
+      return { error: messageFromError(error) };
+    }
+  });
+});
+
+export const handleSessionReplaySummary = defineEventHandler(async (event) => {
+  const recordingId = getRouterParam(event, "recordingId");
+  if (!recordingId) {
+    setResponseStatus(event, 400);
+    return { error: "Missing recordingId" };
+  }
+
+  return runApiHandlerWithContext(event, async (ctx) => {
+    try {
+      const recording = await getSessionReplaySummary(recordingId, {
+        userEmail: ctx.userEmail,
+        orgId: ctx.orgId ?? null,
+      });
+      return { recording };
+    } catch (error: any) {
+      setResponseStatus(event, statusFromError(error));
+      return { error: messageFromError(error) };
+    }
+  });
+});
+
+export const handleSessionReplayEvents = defineEventHandler(async (event) => {
+  const recordingId = getRouterParam(event, "recordingId");
+  if (!recordingId) {
+    setResponseStatus(event, 400);
+    return { error: "Missing recordingId" };
+  }
+
+  return runApiHandlerWithContext(event, async (ctx) => {
+    try {
+      const query = getQuery(event);
+      return await getSessionReplayEvents(
+        recordingId,
+        { userEmail: ctx.userEmail, orgId: ctx.orgId ?? null },
+        {
+          startSeq: asInt(query.startSeq),
+          endSeq: asInt(query.endSeq),
+          limit: asInt(query.limit),
+        },
+      );
+    } catch (error: any) {
+      setResponseStatus(event, statusFromError(error));
+      return { error: messageFromError(error) };
+    }
+  });
+});
+
+export const handleSessionReplayManifest = defineEventHandler(async (event) => {
+  const recordingId = getRouterParam(event, "recordingId");
+  if (!recordingId) {
+    setResponseStatus(event, 400);
+    return { error: "Missing recordingId" };
+  }
+
+  return runApiHandlerWithContext(event, async (ctx) => {
+    try {
+      return await getSessionReplayManifest(recordingId, {
+        userEmail: ctx.userEmail,
+        orgId: ctx.orgId ?? null,
+      });
+    } catch (error: any) {
+      setResponseStatus(event, statusFromError(error));
+      return { error: messageFromError(error) };
+    }
+  });
+});
+
+export const handleSessionReplayChunkBytes = defineEventHandler(
+  async (event) => {
+    const recordingId = getRouterParam(event, "recordingId");
+    const seqRaw = getRouterParam(event, "seq");
+    const seq = asInt(seqRaw);
+    if (!recordingId || seq === undefined) {
+      setResponseStatus(event, 400);
+      return { error: "Missing recordingId or seq" };
+    }
+
+    return runApiHandlerWithContext(event, async (ctx) => {
+      try {
+        const result = await readSessionReplayChunkBytes(recordingId, seq, {
+          userEmail: ctx.userEmail,
+          orgId: ctx.orgId ?? null,
+        });
+        setResponseHeader(event, "Content-Type", "application/json");
+        setResponseHeader(event, "Content-Encoding", "gzip");
+        setResponseHeader(event, "Cache-Control", "no-store");
+        setResponseHeader(event, "X-Session-Replay-Seq", String(result.seq));
+        setResponseHeader(event, "X-Session-Replay-Checksum", result.checksum);
+        return result.data;
+      } catch (error: any) {
+        setResponseStatus(event, statusFromError(error));
+        return { error: messageFromError(error) };
+      }
+    });
+  },
+);