@agent-native/core-corpus 0.210.1-nightly-20261020124228 → 0.210.2

package/corpus/templates/analytics/netlify.toml

@@ -40,3 +40,6 @@ memory = "2gb"
 
 [functions.session-replay-retention-sweep-background]
 timeout = 120
+
+[functions.content-metrics-collection-background]
+timeout = 900

package/corpus/templates/analytics/scripts/emit-netlify-dashboard-report-cron.ts

@@ -50,6 +50,10 @@ const RETENTION_SCHEDULED_NAME = "session-replay-retention-cron";
 const RETENTION_WORKER_NAME = "session-replay-retention-sweep-background";
 const RETENTION_ROUTE_PATH = "/api/session-replay/retention";
 const RETENTION_SCHEDULE = "0 3 * * *";
+const CONTENT_METRICS_SCHEDULED_NAME = "content-metrics-cron";
+const CONTENT_METRICS_WORKER_NAME = "content-metrics-collection-background";
+const CONTENT_METRICS_ROUTE_PATH = "/api/content-metrics/collect";
+const CONTENT_METRICS_SCHEDULE = "0 7 * * *";
 
 function ensureDir(dir: string) {
   mkdirSync(dir, { recursive: true });
@@ -619,12 +623,45 @@ export const config = {
   writeWorkerEntry(dest, BIGQUERY_WORKER_NAME, source);
 }
 
-function emitRetentionScheduledTrigger(token: string) {
-  const dest = path.join(FUNCTIONS_DIR, RETENTION_SCHEDULED_NAME);
+type DailyJobSpec = {
+  scheduledName: string;
+  workerName: string;
+  routePath: string;
+  schedule: string;
+  header: string;
+  runtimeFlag: string;
+  label: string;
+  logPrefix: string;
+};
+
+const RETENTION_JOB: DailyJobSpec = {
+  scheduledName: RETENTION_SCHEDULED_NAME,
+  workerName: RETENTION_WORKER_NAME,
+  routePath: RETENTION_ROUTE_PATH,
+  schedule: RETENTION_SCHEDULE,
+  header: "x-agent-native-session-replay-retention-cron",
+  runtimeFlag: "__AGENT_NATIVE_SESSION_REPLAY_RETENTION_SCHEDULED_RUNTIME__",
+  label: "session replay retention",
+  logPrefix: "session-replay-retention-cron",
+};
+
+const CONTENT_METRICS_JOB: DailyJobSpec = {
+  scheduledName: CONTENT_METRICS_SCHEDULED_NAME,
+  workerName: CONTENT_METRICS_WORKER_NAME,
+  routePath: CONTENT_METRICS_ROUTE_PATH,
+  schedule: CONTENT_METRICS_SCHEDULE,
+  header: "x-agent-native-content-metrics-cron",
+  runtimeFlag: "__AGENT_NATIVE_CONTENT_METRICS_SCHEDULED_RUNTIME__",
+  label: "content metrics collection",
+  logPrefix: "content-metrics-cron",
+};
+
+function emitDailyScheduledTrigger(job: DailyJobSpec, token: string) {
+  const dest = path.join(FUNCTIONS_DIR, job.scheduledName);
   rmSync(dest, { recursive: true, force: true });
   ensureDir(dest);
 
-  const source = `const WORKER_PATH = "/.netlify/functions/${RETENTION_WORKER_NAME}";
+  const source = `const WORKER_PATH = "/.netlify/functions/${job.workerName}";
 const CRON_TOKEN = ${JSON.stringify(token)};
 
 function siteOrigin(request) {
@@ -640,14 +677,14 @@ export default async function handler(request) {
     method: "POST",
     headers: {
       "content-type": "application/json",
-      "x-agent-native-session-replay-retention-cron": CRON_TOKEN,
+      "${job.header}": CRON_TOKEN,
     },
     body: JSON.stringify({ scheduled: true }),
   });
 
   if (!response.ok && response.status !== 202) {
     console.error(
-      "[session-replay-retention-cron] Background retention trigger failed:",
+      "[${job.logPrefix}] Background trigger failed:",
       response.status,
       // coercion-ok: the non-2xx status remains the failure signal; the body is diagnostics only.
       await response.text().catch(() => ""),
@@ -656,27 +693,27 @@ export default async function handler(request) {
 }
 
 export const config = {
-  name: "session replay retention cron trigger",
+  name: "${job.label} cron trigger",
   generator: "agent-native analytics build",
-  schedule: ${JSON.stringify(RETENTION_SCHEDULE)},
+  schedule: ${JSON.stringify(job.schedule)},
 };
 `;
 
-  writeFileSync(path.join(dest, `${RETENTION_SCHEDULED_NAME}.mjs`), source);
+  writeFileSync(path.join(dest, `${job.scheduledName}.mjs`), source);
 }
 
-function emitRetentionBackgroundWorker(token: string) {
-  const dest = path.join(FUNCTIONS_DIR, RETENTION_WORKER_NAME);
+function emitDailyBackgroundWorker(job: DailyJobSpec, token: string) {
+  const dest = path.join(FUNCTIONS_DIR, job.workerName);
   rmSync(dest, { recursive: true, force: true });
   cloneServerBundleForFunction(SERVER_DIR, dest);
   rmSync(path.join(dest, "server.mjs"), { force: true });
 
   const source = `globalThis.__AGENT_NATIVE_BACKGROUND_RUNTIME__ = true;
 globalThis.__AGENT_NATIVE_LOW_CONNECTION_BACKGROUND_RUNTIME__ = true;
-globalThis.__AGENT_NATIVE_SESSION_REPLAY_RETENTION_SCHEDULED_RUNTIME__ = true;
+globalThis.${job.runtimeFlag} = true;
 
 const CRON_TOKEN = ${JSON.stringify(token)};
-const ROUTE_PATH = ${JSON.stringify(RETENTION_ROUTE_PATH)};
+const ROUTE_PATH = ${JSON.stringify(job.routePath)};
 let cachedHandler;
 
 function timingSafeEquals(a, b) {
@@ -689,7 +726,7 @@ function timingSafeEquals(a, b) {
 }
 
 export default async function handler(request, context) {
-  const token = request.headers.get("x-agent-native-session-replay-retention-cron") || "";
+  const token = request.headers.get("${job.header}") || "";
   if (!timingSafeEquals(token, CRON_TOKEN)) {
     return new Response("Unauthorized", { status: 401 });
   }
@@ -709,7 +746,7 @@ export default async function handler(request, context) {
 }
 
 export const config = {
-  name: "session replay retention background sweep",
+  name: "${job.label} background sweep",
   generator: "agent-native analytics build",
   background: true,
   nodeBundler: "none",
@@ -718,7 +755,7 @@ export const config = {
 };
 `;
 
-  writeWorkerEntry(dest, RETENTION_WORKER_NAME, source);
+  writeWorkerEntry(dest, job.workerName, source);
 }
 
 function isDirectRun(): boolean {
@@ -743,6 +780,7 @@ function main(): void {
   const rollupToken = randomBytes(32).toString("hex");
   const bigQueryToken = randomBytes(32).toString("hex");
   const retentionToken = randomBytes(32).toString("hex");
+  const contentMetricsToken = randomBytes(32).toString("hex");
   emitScheduledTrigger(token);
   emitBackgroundWorker(token);
   emitAlertScheduledTrigger(alertToken);
@@ -753,8 +791,10 @@ function main(): void {
   emitRollupBackgroundWorker(rollupToken);
   emitBigQueryScheduledTrigger(bigQueryToken);
   emitBigQueryBackgroundWorker(bigQueryToken);
-  emitRetentionScheduledTrigger(retentionToken);
-  emitRetentionBackgroundWorker(retentionToken);
+  emitDailyScheduledTrigger(RETENTION_JOB, retentionToken);
+  emitDailyBackgroundWorker(RETENTION_JOB, retentionToken);
+  emitDailyScheduledTrigger(CONTENT_METRICS_JOB, contentMetricsToken);
+  emitDailyBackgroundWorker(CONTENT_METRICS_JOB, contentMetricsToken);
   console.log(
     `[dashboard-report-cron] Emitted Netlify scheduled trigger "${SCHEDULED_NAME}" (${SCHEDULE}) and background worker "${WORKER_NAME}".`,
   );
@@ -773,6 +813,9 @@ function main(): void {
   console.log(
     `[session-replay-retention-cron] Emitted Netlify scheduled trigger "${RETENTION_SCHEDULED_NAME}" (${RETENTION_SCHEDULE}) and background worker "${RETENTION_WORKER_NAME}".`,
   );
+  console.log(
+    `[content-metrics-cron] Emitted Netlify scheduled trigger "${CONTENT_METRICS_SCHEDULED_NAME}" (${CONTENT_METRICS_SCHEDULE}) and background worker "${CONTENT_METRICS_WORKER_NAME}".`,
+  );
 }
 
 if (isDirectRun()) {

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

@@ -1,4 +1,5 @@
 import {
+  bigint,
   table,
   text,
   integer,
@@ -1047,3 +1048,106 @@ export const sessionReplayIngests = table(
     ),
   }),
 );
+
+// Content view: one tenant's collection settings, read by the daily job. The
+// stored owner is the identity whose credentials each step resolves.
+export const analyticsContentCollections = table(
+  "analytics_content_collections",
+  {
+    tenantKey: text("tenant_key").primaryKey(),
+    ownerEmail: text("owner_email").notNull(),
+    orgId: text("org_id"),
+    enabled: boolean("enabled").notNull().default(false),
+    config: text("config").notNull().default("{}"),
+    createdAt: text("created_at").notNull().default(now()),
+    updatedAt: text("updated_at").notNull().default(now()),
+  },
+);
+
+export const analyticsContentItems = table(
+  "analytics_content_items",
+  {
+    id: text("id").primaryKey(),
+    tenantKey: text("tenant_key").notNull(),
+    ownerEmail: text("owner_email").notNull(),
+    orgId: text("org_id"),
+    source: text("source").notNull(),
+    externalId: text("external_id").notNull(),
+    url: text("url"),
+    title: text("title"),
+    author: text("author"),
+    authors: text("authors").notNull().default("[]"),
+    publishedAt: text("published_at"),
+    relevance: text("relevance"),
+    metadata: text("metadata").notNull().default("{}"),
+    firstSeenAt: text("first_seen_at").notNull(),
+    updatedAt: text("updated_at").notNull(),
+  },
+  (t) => ({
+    sourceExternalUnique: uniqueIndex("analytics_content_items_key_idx").on(
+      t.tenantKey,
+      t.source,
+      t.externalId,
+    ),
+    tenantPublishedIdx: index("analytics_content_items_published_idx").on(
+      t.tenantKey,
+      t.publishedAt,
+    ),
+  }),
+);
+
+// A row exists only for a value a succeeded run collected. A missing row is
+// "not collected", never zero; the collection runs say which.
+export const analyticsContentMetricSnapshots = table(
+  "analytics_content_metric_snapshots",
+  {
+    id: text("id").primaryKey(),
+    tenantKey: text("tenant_key").notNull(),
+    ownerEmail: text("owner_email").notNull(),
+    orgId: text("org_id"),
+    itemId: text("item_id").notNull(),
+    metricDate: text("metric_date").notNull(),
+    metric: text("metric").notNull(),
+    value: real("value").notNull(),
+    source: text("source").notNull(),
+    runId: text("run_id").notNull(),
+    collectedAt: text("collected_at").notNull(),
+  },
+  (t) => ({
+    snapshotUnique: uniqueIndex(
+      "analytics_content_metric_snapshots_key_idx",
+    ).on(t.tenantKey, t.itemId, t.metricDate, t.metric),
+    tenantDateIdx: index("analytics_content_metric_snapshots_date_idx").on(
+      t.tenantKey,
+      t.metricDate,
+    ),
+  }),
+);
+
+export const analyticsContentCollectionRuns = table(
+  "analytics_content_collection_runs",
+  {
+    id: text("id").primaryKey(),
+    tenantKey: text("tenant_key").notNull(),
+    ownerEmail: text("owner_email").notNull(),
+    orgId: text("org_id"),
+    step: text("step").notNull(),
+    trigger: text("trigger").notNull(),
+    status: text("status").notNull(),
+    windowStart: text("window_start"),
+    windowEnd: text("window_end"),
+    startedAt: text("started_at").notNull(),
+    finishedAt: text("finished_at"),
+    rowCount: integer("row_count"),
+    bytesProcessed: bigint("bytes_processed", { mode: "number" }),
+    bytesCap: bigint("bytes_cap", { mode: "number" }),
+    costUsd: real("cost_usd"),
+    errorCode: text("error_code"),
+    errorMessage: text("error_message"),
+  },
+  (t) => ({
+    tenantStepStartedIdx: index(
+      "analytics_content_collection_runs_step_idx",
+    ).on(t.tenantKey, t.step, t.startedAt),
+  }),
+);

package/corpus/templates/analytics/server/jobs/content-metrics-collection.ts

@@ -0,0 +1,20 @@
+import {
+  collectContentForAllTenants,
+  type ContentStepRunSummary,
+} from "../lib/content-metrics/collect";
+
+let running = false;
+
+export type ContentCollectionPassResult =
+  | { ran: true; steps: ContentStepRunSummary[] }
+  | { ran: false; reason: "already_running" };
+
+export async function runContentMetricsCollectionOnce(): Promise<ContentCollectionPassResult> {
+  if (running) return { ran: false, reason: "already_running" };
+  running = true;
+  try {
+    return { ran: true, steps: await collectContentForAllTenants() };
+  } finally {
+    running = false;
+  }
+}

package/corpus/templates/analytics/server/lib/content-metrics/collect.ts

@@ -0,0 +1,141 @@
+import { runWithRequestContext } from "@agent-native/core/server";
+
+import {
+  CONTENT_COLLECTION_STEPS,
+  stepEnabled,
+  type ContentCollectionStepId,
+} from "./config.js";
+import { contentRunFailureFromError, type ContentStep } from "./step.js";
+import { builderBlogStep } from "./steps/builder-blog.js";
+import { ga4Step } from "./steps/ga4.js";
+import { searchConsoleStep } from "./steps/search-console.js";
+import {
+  closeStaleContentRuns,
+  completeContentRun,
+  failContentRun,
+  listEnabledContentCollections,
+  startContentRun,
+  type ContentCollection,
+  type ContentRunStatus,
+  type ContentRunTrigger,
+} from "./store.js";
+
+const STEPS: Record<ContentCollectionStepId, ContentStep> = {
+  builder_blog: builderBlogStep,
+  ga4: ga4Step,
+  search_console: searchConsoleStep,
+};
+
+export type ContentStepRunSummary = {
+  tenantKey: string;
+  step: ContentCollectionStepId;
+  status: ContentRunStatus | "skipped";
+  runId: string | null;
+  reason?: string;
+};
+
+export async function collectContentForCollection(
+  collection: ContentCollection,
+  options: {
+    trigger: ContentRunTrigger;
+    now?: Date;
+    signal?: AbortSignal;
+    steps?: ContentCollectionStepId[];
+  },
+): Promise<ContentStepRunSummary[]> {
+  const now = options.now ?? new Date();
+  const summaries: ContentStepRunSummary[] = [];
+  const steps = options.steps ?? [...CONTENT_COLLECTION_STEPS];
+
+  for (const stepId of steps) {
+    if (!stepEnabled(collection.config, stepId)) {
+      summaries.push({
+        tenantKey: collection.tenantKey,
+        step: stepId,
+        status: "skipped",
+        runId: null,
+        reason: "step_disabled",
+      });
+      continue;
+    }
+    const claim = await startContentRun(
+      collection,
+      stepId,
+      options.trigger,
+      now,
+    );
+    if ("reason" in claim) {
+      summaries.push({
+        tenantKey: collection.tenantKey,
+        step: stepId,
+        status: "skipped",
+        runId: null,
+        reason: claim.reason,
+      });
+      continue;
+    }
+
+    const runId = claim.runId;
+    try {
+      const result = await runWithRequestContext(
+        {
+          userEmail: collection.ownerEmail,
+          ...(collection.orgId ? { orgId: collection.orgId } : {}),
+        },
+        () =>
+          STEPS[stepId].run({
+            collection,
+            now,
+            ...(options.signal ? { signal: options.signal } : {}),
+          }),
+      );
+      await completeContentRun(
+        collection,
+        runId,
+        stepId,
+        result,
+        result.outcome,
+      );
+      summaries.push({
+        tenantKey: collection.tenantKey,
+        step: stepId,
+        status: "succeeded",
+        runId,
+      });
+    } catch (error) {
+      const failure = contentRunFailureFromError(error);
+      await failContentRun(runId, failure);
+      summaries.push({
+        tenantKey: collection.tenantKey,
+        step: stepId,
+        status: failure.status,
+        runId,
+        reason: failure.errorCode,
+      });
+    }
+  }
+  return summaries;
+}
+
+/** The daily pass over every tenant that turned content collection on. */
+export async function collectContentForAllTenants(
+  options: { now?: Date; signal?: AbortSignal } = {},
+): Promise<ContentStepRunSummary[]> {
+  await closeStaleContentRuns(options.now);
+  const summaries: ContentStepRunSummary[] = [];
+  let afterTenantKey: string | undefined;
+  for (;;) {
+    const collections = await listEnabledContentCollections(afterTenantKey);
+    for (const collection of collections) {
+      summaries.push(
+        ...(await collectContentForCollection(collection, {
+          trigger: "scheduled",
+          ...options,
+        })),
+      );
+    }
+    if (collections.length < 1000) break;
+    afterTenantKey = collections[collections.length - 1]!.tenantKey;
+  }
+  return summaries;
+}

package/corpus/templates/analytics/server/lib/content-metrics/config.ts

@@ -0,0 +1,69 @@
+import { z } from "zod";
+
+/**
+ * Collection steps, in the order the daily job runs them. A step's id is the
+ * `step` stored on its collection runs and the `source` on what it writes.
+ */
+export const CONTENT_COLLECTION_STEPS = [
+  "builder_blog",
+  "ga4",
+  "search_console",
+] as const;
+export type ContentCollectionStepId = (typeof CONTENT_COLLECTION_STEPS)[number];
+
+const stepToggleSchema = z.object({ enabled: z.boolean() });
+
+/**
+ * A Search Console property: `sc-domain:example.com` or a URL-prefix
+ * property such as `https://www.example.com/`. `pathPrefix` keeps a large
+ * site to the pages the Content view tracks.
+ */
+export const searchConsoleSiteSchema = z.object({
+  siteUrl: z.string().trim().min(1),
+  pathPrefix: z.string().trim().startsWith("/").optional(),
+});
+export type SearchConsoleSite = z.infer<typeof searchConsoleSiteSchema>;
+
+export const contentCollectionConfigSchema = z.object({
+  builderBlog: stepToggleSchema.default({ enabled: true }),
+  ga4: stepToggleSchema.default({ enabled: true }),
+  // Off until a property owner grants the service account access; a run
+  // before then would only record "no access".
+  searchConsole: stepToggleSchema
+    .extend({ sites: z.array(searchConsoleSiteSchema).max(20).default([]) })
+    .default({ enabled: false, sites: [] }),
+});
+
+export type ContentCollectionConfig = z.infer<
+  typeof contentCollectionConfigSchema
+>;
+
+export function defaultContentCollectionConfig(): ContentCollectionConfig {
+  return contentCollectionConfigSchema.parse({});
+}
+
+export function stepEnabled(
+  config: ContentCollectionConfig,
+  step: ContentCollectionStepId,
+): boolean {
+  switch (step) {
+    case "builder_blog":
+      return config.builderBlog.enabled;
+    case "ga4":
+      return config.ga4.enabled;
+    case "search_console":
+      return config.searchConsole.enabled;
+  }
+}
+
+export type ContentCollectionScope = {
+  ownerEmail: string;
+  orgId: string | null;
+};
+
+/** Same tenant keys the first-party rollup tables use. */
+export function contentTenantKey(scope: ContentCollectionScope): string {
+  return scope.orgId
+    ? `org:${scope.orgId}`
+    : `user:${scope.ownerEmail.trim().toLowerCase()}`;
+}

package/corpus/templates/analytics/server/lib/content-metrics/migration.ts

@@ -0,0 +1,67 @@
+// Created by a migration in server/plugins/db.ts. Hosted request paths never
+// run DDL, so the statements live here and the migration list pastes them.
+export const CONTENT_METRICS_MIGRATION_SQL = [
+  `CREATE TABLE IF NOT EXISTS analytics_content_collections (
+    tenant_key TEXT PRIMARY KEY,
+    owner_email TEXT NOT NULL,
+    org_id TEXT,
+    enabled BOOLEAN NOT NULL DEFAULT false,
+    config TEXT NOT NULL DEFAULT '{}',
+    created_at TEXT NOT NULL DEFAULT now(),
+    updated_at TEXT NOT NULL DEFAULT now()
+  )`,
+  `CREATE TABLE IF NOT EXISTS analytics_content_items (
+    id TEXT PRIMARY KEY,
+    tenant_key TEXT NOT NULL,
+    owner_email TEXT NOT NULL,
+    org_id TEXT,
+    source TEXT NOT NULL,
+    external_id TEXT NOT NULL,
+    url TEXT,
+    title TEXT,
+    author TEXT,
+    authors TEXT NOT NULL DEFAULT '[]',
+    published_at TEXT,
+    relevance TEXT,
+    metadata TEXT NOT NULL DEFAULT '{}',
+    first_seen_at TEXT NOT NULL,
+    updated_at TEXT NOT NULL
+  )`,
+  `CREATE UNIQUE INDEX IF NOT EXISTS analytics_content_items_key_idx ON analytics_content_items (tenant_key, source, external_id)`,
+  `CREATE INDEX IF NOT EXISTS analytics_content_items_published_idx ON analytics_content_items (tenant_key, published_at)`,
+  `CREATE TABLE IF NOT EXISTS analytics_content_metric_snapshots (
+    id TEXT PRIMARY KEY,
+    tenant_key TEXT NOT NULL,
+    owner_email TEXT NOT NULL,
+    org_id TEXT,
+    item_id TEXT NOT NULL,
+    metric_date TEXT NOT NULL,
+    metric TEXT NOT NULL,
+    value DOUBLE PRECISION NOT NULL,
+    source TEXT NOT NULL,
+    run_id TEXT NOT NULL,
+    collected_at TEXT NOT NULL
+  )`,
+  `CREATE UNIQUE INDEX IF NOT EXISTS analytics_content_metric_snapshots_key_idx ON analytics_content_metric_snapshots (tenant_key, item_id, metric_date, metric)`,
+  `CREATE INDEX IF NOT EXISTS analytics_content_metric_snapshots_date_idx ON analytics_content_metric_snapshots (tenant_key, metric_date)`,
+  `CREATE TABLE IF NOT EXISTS analytics_content_collection_runs (
+    id TEXT PRIMARY KEY,
+    tenant_key TEXT NOT NULL,
+    owner_email TEXT NOT NULL,
+    org_id TEXT,
+    step TEXT NOT NULL,
+    trigger TEXT NOT NULL,
+    status TEXT NOT NULL,
+    window_start TEXT,
+    window_end TEXT,
+    started_at TEXT NOT NULL,
+    finished_at TEXT,
+    row_count INTEGER,
+    bytes_processed BIGINT,
+    bytes_cap BIGINT,
+    cost_usd DOUBLE PRECISION,
+    error_code TEXT,
+    error_message TEXT
+  )`,
+  `CREATE INDEX IF NOT EXISTS analytics_content_collection_runs_step_idx ON analytics_content_collection_runs (tenant_key, step, started_at)`,
+];

package/corpus/templates/analytics/server/lib/content-metrics/status.ts

@@ -0,0 +1,96 @@
+import {
+  readServiceAccountIdentity,
+  type ServiceAccountIdentity,
+} from "../google-analytics.js";
+import {
+  CONTENT_COLLECTION_STEPS,
+  stepEnabled,
+  type ContentCollectionStepId,
+} from "./config.js";
+import {
+  latestContentRun,
+  readContentCollection,
+  type ContentCollection,
+} from "./store.js";
+
+export type ContentStepStatus = {
+  step: ContentCollectionStepId;
+  enabled: boolean;
+  lastRun: {
+    id: string;
+    trigger: string;
+    status: string;
+    startedAt: string;
+    finishedAt: string | null;
+    windowStart: string | null;
+    windowEnd: string | null;
+    rowCount: number | null;
+    bytesProcessed: number | null;
+    bytesCap: number | null;
+    errorCode: string | null;
+    errorMessage: string | null;
+  } | null;
+};
+
+export type ContentCollectionStatus = {
+  configured: boolean;
+  enabled: boolean;
+  ownerEmail: string | null;
+  config: ContentCollection["config"] | null;
+  /** Who a Search Console or GA4 property owner grants access to. */
+  serviceAccount: ServiceAccountIdentity;
+  steps: ContentStepStatus[];
+};
+
+export async function readContentCollectionStatus(
+  orgId: string,
+  userEmail: string,
+): Promise<ContentCollectionStatus> {
+  const collection = await readContentCollection({
+    orgId,
+    ownerEmail: userEmail,
+  });
+  const serviceAccount = await readServiceAccountIdentity();
+  if (!collection) {
+    return {
+      configured: false,
+      enabled: false,
+      ownerEmail: null,
+      config: null,
+      serviceAccount,
+      steps: [],
+    };
+  }
+  const steps: ContentStepStatus[] = [];
+  for (const step of CONTENT_COLLECTION_STEPS) {
+    const run = await latestContentRun(collection, step);
+    steps.push({
+      step,
+      enabled: stepEnabled(collection.config, step),
+      lastRun: run
+        ? {
+            id: run.id,
+            trigger: run.trigger,
+            status: run.status,
+            startedAt: run.startedAt,
+            finishedAt: run.finishedAt,
+            windowStart: run.windowStart,
+            windowEnd: run.windowEnd,
+            rowCount: run.rowCount,
+            bytesProcessed: run.bytesProcessed,
+            bytesCap: run.bytesCap,
+            errorCode: run.errorCode,
+            errorMessage: run.errorMessage,
+          }
+        : null,
+    });
+  }
+  return {
+    configured: true,
+    enabled: collection.enabled,
+    ownerEmail: collection.ownerEmail,
+    config: collection.config,
+    serviceAccount,
+    steps,
+  };
+}