@aglyn/plugins-crm 1.0.0-beta.218 → 1.0.0-beta.219

package/src/lib/server/daily-digest-route.js

@@ -0,0 +1,588 @@
+import { _ as _extends } from "@swc/helpers/_/_extends";
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */ import { buildRoute, CRM_COLLECTIONS, DIGEST_PREFS_FIELD, digestEnabled, hostRoleFor, isReleaseFlagOnForOrg, notificationMuted, parseOrgReleaseFlagOverrides, pluginRequestFromWeb, resolveBrandingProfile, resolveEffectivePlan, resolveOrgEntitlements, Route } from "@aglyn/aglyn/server";
+import { buildMemberDigests, composeCrmDigestEmailText, composeCrmDigestSubject, composeCrmDigestSummary, CRM_DIGEST_DEFAULT_TIME_ZONE, CRM_DIGEST_LEAD_AGE_MS, CRM_DIGEST_LEAD_WINDOW, CRM_DIGEST_TASK_CEILING, crmDigestCounts, crmDigestEntitled, crmDigestWindow, isUnworkedLead, utcDayKey } from "../model/crm-digest.js";
+import { rateLimitedRetryAtMs, sendEmail } from "@aglyn/shared-util-email";
+import { withoutMailWithheldAccounts } from "@aglyn/tenant-data-admin/server/account-mail";
+import { findUserByUidAcrossPools, firebaseAdmin, getServerReleaseFlagValues, listOrgMembers, memberHasOrgPermission, meterPlatformEmail, notifyUsers } from "@aglyn/tenant-data-admin";
+// From the LEAF, not the barrel (AGL-2407): the cron specs mock
+// `@aglyn/tenant-data-admin` wholesale, and a suppression gate imported
+// through the barrel would be silently replaced by whatever the factory
+// lists. Same reasoning as `usage-alert-email.ts`.
+import { filterSuppressedEmails } from "@aglyn/tenant-data-admin/server/email-suppression";
+import { loadSystemEmail, renderLoadedSystemEmail, systemEmailBrand, systemEmailContent } from "@aglyn/tenant-data-admin/server/render-system-email";
+import { isCronAuthorized, isCronDryRun } from "@aglyn/tenant-data-admin/server/cron-auth";
+import { writeCronBeat } from "@aglyn/aglyn/app-utils/health-report";
+import { brandSupportLine } from "@aglyn/aglyn/app-utils/brand-support-line";
+import { platformConsoleOrigin as consoleOrigin } from "@aglyn/aglyn/app-utils/platform-brand";
+import { scopeTokensForHost } from "@aglyn/aglyn/app-utils/scope-tokens";
+/**
+ * The mark a scheduled run leaves for `/api/health/crons` (AGL-1955), on the
+ * INVOCATION and before the work — the console's rule for every cron. Never
+ * throws: reaching the admin app is inside the try, because a monitor that
+ * can take down the job it describes is worse than the failure it watches.
+ */ async function recordCronBeat(jobId) {
+    try {
+        await writeCronBeat(firebaseAdmin.app().firestore(), jobId);
+    } catch (unused) {
+    // Deliberately swallowed: a job that stops stamping reds its own row.
+    }
+}
+// lockdown-423: exempt — server-internal cron (x-cron-secret), no user caller; it reads an org's CRM to remind its members and writes nothing a locked org could lose.
+/**
+ * The daily CRM digest (AGL-2619): `POST /api/crm/daily-digest`.
+ *
+ * Overdue and due-today are computed at read time by design (AGL-2599), so
+ * until this route nothing ever told anybody a task was late — overdue work
+ * was found by opening the Tasks section. Once a morning, per org and per
+ * member with open work, this counts their overdue and due-today tasks and
+ * the leads nobody has worked, and says so ONCE: a console notification
+ * (`content.crmDailyDigest`) and an email through the platform's own
+ * sending path. The words and the arithmetic live in `crm-digest.ts`; this
+ * file is the reads, the sends and the sweep.
+ *
+ * ## Who is told, and who is not
+ *
+ * A task's assignee, a lead's owner, and — for a lead nobody owns — every
+ * member who reaches the site it was captured on. Only members who may open
+ * the CRM (`data.manage`, resolved through their custom role the way the task
+ * routes resolve it), and only in an org whose plan carries the suite and
+ * whose `release_crm` flag is on: a digest about a surface the reader
+ * cannot open is a reminder to pay, not a reminder to call.
+ *
+ * Two switches on the recipient's own account are honored. The **Daily CRM
+ * digest** preference (`users/{uid}.digestPrefs.crmDaily`, on until turned
+ * off) governs the whole digest, mail included. The operational category
+ * mute (`notificationPrefs.content`) governs the console notification alone,
+ * as it does for every other `content.` type — the mute is a fact about the
+ * console feed, and the digest switch is a fact about the digest.
+ *
+ * ## Once a day, and resumable
+ *
+ * `orgs/{orgId}/crmDigests/{YYYY-MM-DD}` records, per member, that today's
+ * digest went out. It is stamped AFTER the sends, so a run that dies
+ * mid-org re-sends only to the members it never reached, and a second run
+ * on the same UTC day sends nothing. Orgs are swept in id order behind a
+ * cursor the way `usage-alerts` sweeps them, so the workflow's `done:false`
+ * loop carries a platform of any size across invocations.
+ *
+ * The email is a `bulk` send under the platform send-rate governor
+ * (AGL-2409): a cron fan-out on the shared sending domain, answering nothing
+ * anybody just did. A refusal STOPS the run and reports `done: true` — the
+ * window is full, and re-POSTing into it would only red the workflow — and
+ * because the refused member was never stamped, tomorrow's run digests them
+ * afresh. Nothing about today's list is worth mailing tomorrow anyway.
+ *
+ * Metered as PLATFORM mail, not the org's: this is the platform reminding a
+ * member, and a reminder that pushed an org toward its email overage would
+ * be its own small absurdity. It is not a one-to-one CRM send and counts
+ * against no per-member sending allowance.
+ */ /** The beat `/api/health/crons` would read, were this job in its inventory. */ export const CRM_DIGEST_JOB_ID = 'crm-daily-digest';
+/**
+ * Orgs per invocation.
+ *
+ * Fewer than `usage-alerts`' hundred: an org costs a task query, a paged
+ * host list, a leads query per site, the roster, and a send per member with
+ * work, under `maxDuration = 60`. A chunk that times out never advances its
+ * cursor, so the safe size is the one that finishes.
+ */ export const CRM_DIGEST_ORG_CHUNK = 25;
+/** Hosts read per page inside one org, ordered by id like the orgs sweep. */ const CRM_DIGEST_HOST_PAGE = 100;
+/**
+ * The most sites one org's digest reads leads from, after which the sweep
+ * stops and SAYS SO in the response rather than reading without bound.
+ */ export const CRM_DIGEST_HOST_CEILING = 200;
+/**
+ * The key a person's switch for this digest is stored under in
+ * `users/{uid}.digestPrefs` — the one the CRM declares under
+ * `notificationDigests` in `plugins.config.json`, which is the one the
+ * settings page writes. `daily-digest-route.spec.ts` holds the two to one
+ * spelling.
+ */ export const CRM_DAILY_DIGEST_KEY = 'crmDaily';
+/** `orgs/{orgId}/crmDigests/{day}` — server-written, matched by no rule. */ export const CRM_DIGEST_MARKER_COLLECTION = 'crmDigests';
+/**
+ * The most members per org whose address is chased through the auth pools
+ * when their member document carries none. Bounds WORK, not audience — the
+ * denormalized copy is normally present, and `orgAdminEmails` draws the same
+ * line for the same reason.
+ */ export const CRM_DIGEST_EMAIL_MAX_UID_LOOKUPS = 5;
+/**
+ * The zone the digest's "today" is drawn in.
+ *
+ * `CRM_DIGEST_TIME_ZONE` overrides the default for a self-hosted console
+ * whose team wakes up elsewhere; a value `Intl` does not know falls back to
+ * the default with a warning rather than throwing the whole run away.
+ */ export function digestTimeZone(env = process.env) {
+    var _env_CRM_DIGEST_TIME_ZONE;
+    const configured = String((_env_CRM_DIGEST_TIME_ZONE = env['CRM_DIGEST_TIME_ZONE']) != null ? _env_CRM_DIGEST_TIME_ZONE : '').trim();
+    if (!configured) return CRM_DIGEST_DEFAULT_TIME_ZONE;
+    try {
+        new Intl.DateTimeFormat('en-US', {
+            timeZone: configured
+        });
+        return configured;
+    } catch (unused) {
+        console.warn(`crm-daily-digest: CRM_DIGEST_TIME_ZONE "${configured}" is not a zone — ` + `using ${CRM_DIGEST_DEFAULT_TIME_ZONE}`);
+        return CRM_DIGEST_DEFAULT_TIME_ZONE;
+    }
+}
+/**
+ * Every host owned by an org, paged by document id — the shape
+ * `usage-alerts` reads hosts with, at a lower ceiling because each host here
+ * costs a leads query.
+ */ async function hostsOfOrg(firestore, orgId) {
+    const docs = [];
+    let cursor = null;
+    for(;;){
+        let query = firestore.collection('hosts').where('orgId', '==', orgId).orderBy(firebaseAdmin.firestore.FieldPath.documentId()).limit(CRM_DIGEST_HOST_PAGE);
+        if (cursor) query = query.startAfter(firestore.collection('hosts').doc(cursor));
+        const page = await query.get();
+        for (const doc of page.docs)docs.push(doc);
+        if (page.docs.length < CRM_DIGEST_HOST_PAGE) return {
+            docs,
+            truncated: false
+        };
+        if (docs.length >= CRM_DIGEST_HOST_CEILING) {
+            console.warn(`crm-daily-digest: org ${orgId} has more than ${CRM_DIGEST_HOST_CEILING} ` + 'hosts — leads on the rest are not digested');
+            return {
+                docs,
+                truncated: true
+            };
+        }
+        cursor = page.docs[page.docs.length - 1].id;
+    }
+}
+/**
+ * The console path a notification opens — the legacy `/{hostDocId}/rest`
+ * shape every host notification uses, or the `/org/rest` shape the console
+ * rewrites onto the organization's own hub when nothing owed names a site:
+ * an organization task (AGL-2637) has none.
+ */ function notificationLink(hostId, section) {
+    return hostId ? `/${hostId}/crm/${section}` : `/org/crm/${section}`;
+}
+async function digestOrg(ctx, orgDoc) {
+    var _orgDoc_data, _marker_get, _org_slug;
+    const { firestore, nowMs, day, timeZone, dryRun } = ctx;
+    const orgId = orgDoc.id;
+    const org = (_orgDoc_data = orgDoc.data()) != null ? _orgDoc_data : {};
+    const quiet = {
+        digests: 0,
+        notified: 0,
+        emailed: 0
+    };
+    if (!crmDigestEntitled(resolveOrgEntitlements(org).features)) {
+        return _extends({}, quiet, {
+            skipped: 'not-entitled'
+        });
+    }
+    const flagOn = isReleaseFlagOnForOrg('release_crm', ctx.flagValues['release_crm'], orgId, parseOrgReleaseFlagOverrides(org['releaseFlags']), resolveEffectivePlan(org));
+    if (!flagOn) return _extends({}, quiet, {
+        skipped: 'release-flag'
+    });
+    const window = crmDigestWindow(nowMs, timeZone);
+    /*
+   * Every open task due before tomorrow, soonest first — overdue and today
+   * in one query on `(status, dueAtMs)`, bucketed afterwards. Undated tasks
+   * carry `dueAtMs: null`, which a range excludes.
+   */ const taskPage = await orgDoc.ref.collection(CRM_COLLECTIONS.tasks).where('status', '==', 'open').where('dueAtMs', '<', window.endMs).orderBy('dueAtMs', 'asc').limit(CRM_DIGEST_TASK_CEILING).get();
+    const tasks = taskPage.docs.map((doc)=>{
+        var _doc_get, _doc_get1, _doc_get2, _doc_get3;
+        return {
+            id: doc.id,
+            title: String((_doc_get = doc.get('title')) != null ? _doc_get : ''),
+            kind: (_doc_get1 = doc.get('kind')) != null ? _doc_get1 : 'todo',
+            dueAtMs: Number(doc.get('dueAtMs')),
+            assigneeUid: String((_doc_get2 = doc.get('assigneeUid')) != null ? _doc_get2 : ''),
+            hostId: String((_doc_get3 = doc.get('hostId')) != null ? _doc_get3 : ''),
+            contactId: doc.get('contactId') || undefined,
+            companyId: doc.get('companyId') || undefined,
+            dealId: doc.get('dealId') || undefined
+        };
+    });
+    const tasksTruncated = taskPage.docs.length >= CRM_DIGEST_TASK_CEILING;
+    /*
+   * The leads nobody has worked, per site. A window of the newest old leads
+   * by first sighting, filtered in memory, for the reason the Leads section
+   * gives: the capture door stamps no `status`, and a query cannot select on
+   * a field's absence.
+   */ const hosts = await hostsOfOrg(firestore, orgId);
+    const hostById = new Map(hosts.docs.map((doc)=>[
+            doc.id,
+            doc
+        ]));
+    const leadCutoff = nowMs - CRM_DIGEST_LEAD_AGE_MS;
+    const leads = [];
+    for (const host of hosts.docs){
+        /*
+     * Still per site, but over the ORG collection narrowed to what that site
+     * may see (AGL-3275). The digest is a per-site message, so the loop stays;
+     * what changed is that a site's leads are selected by `visibleTo` rather
+     * than by the collection's parent, and a lead two brands share is in both
+     * of their digests — which is the honest answer, since both hold it.
+     */ const page = await firestore.collection('orgs').doc(orgId).collection('leads').where('visibleTo', 'array-contains-any', scopeTokensForHost(host.id)).where('firstSeenAtMs', '<=', leadCutoff).orderBy('firstSeenAtMs', 'desc').limit(CRM_DIGEST_LEAD_WINDOW).get();
+        for (const doc of page.docs){
+            var _data_email, _data_name, _data_ownerUid;
+            const data = doc.data();
+            if (!isUnworkedLead(data, nowMs)) continue;
+            leads.push({
+                id: doc.id,
+                hostId: host.id,
+                email: String((_data_email = data['email']) != null ? _data_email : ''),
+                name: String((_data_name = data['name']) != null ? _data_name : '') || undefined,
+                ownerUid: String((_data_ownerUid = data['ownerUid']) != null ? _data_ownerUid : '') || undefined,
+                firstSeenAtMs: Number(data['firstSeenAtMs'])
+            });
+        }
+    }
+    if (!tasks.length && !leads.length) return _extends({}, quiet, {
+        skipped: 'nothing-owed'
+    });
+    const listed = (await listOrgMembers(orgId)).filter((member)=>member.orgSuspended !== true);
+    // A locked or disabled account is not told (AGL-3418): it cannot sign in
+    // to act on it.
+    const reachable = new Set(await withoutMailWithheldAccounts(listed.map((member)=>member.$id)));
+    const members = listed.filter((member)=>reachable.has(member.$id));
+    const memberById = new Map(members.map((member)=>[
+            member.$id,
+            member
+        ]));
+    const digests = buildMemberDigests({
+        tasks,
+        leads,
+        window,
+        members: members.map((member)=>({
+                uid: member.$id,
+                reachesHost: (hostId)=>hostRoleFor(member, hostId) !== null
+            }))
+    });
+    if (!digests.size) return _extends({}, quiet, {
+        skipped: 'nobody-to-tell'
+    });
+    const markerRef = orgDoc.ref.collection(CRM_DIGEST_MARKER_COLLECTION).doc(day);
+    const marker = await markerRef.get();
+    const sentToday = (_marker_get = marker.get('members')) != null ? _marker_get : {};
+    // Sorted so the order members are told in — and the member a refusal
+    // lands on — is the same on every run.
+    const uids = [
+        ...digests.keys()
+    ].sort();
+    const userDocs = await firestore.getAll(...uids.map((uid)=>firestore.collection('users').doc(uid)));
+    const userById = new Map(userDocs.map((doc)=>[
+            doc.id,
+            doc
+        ]));
+    const branding = resolveBrandingProfile(org);
+    const orgSlug = String((_org_slug = org['slug']) != null ? _org_slug : '');
+    const hostName = (hostId)=>{
+        const host = hostById.get(hostId);
+        return String((host == null ? void 0 : host.get('name')) || (host == null ? void 0 : host.get('subdomain')) || hostId);
+    };
+    const hubUrl = (hostId)=>{
+        var _ref;
+        var _hostById_get;
+        const subdomain = String((_ref = (_hostById_get = hostById.get(hostId)) == null ? void 0 : _hostById_get.get('subdomain')) != null ? _ref : '');
+        if (!orgSlug || !subdomain) return null;
+        return `${ctx.origin}${buildRoute(Route.HOST_DASHBOARD, {
+            orgSlug,
+            host: subdomain
+        })}/crm`;
+    };
+    // The organization's own hub, for a member whose owed tasks name no site.
+    const orgHubUrl = orgSlug ? `${ctx.origin}${buildRoute(Route.ORG_HOME, {
+        orgSlug
+    })}/crm` : null;
+    const settingsUrl = `${ctx.origin}${buildRoute(Route.MANAGE_NOTIFICATION_SETTINGS)}`;
+    const supportLine = brandSupportLine(branding);
+    const brand = systemEmailBrand(org);
+    let digestEmail;
+    const report = {
+        digests: 0,
+        notified: 0,
+        emailed: 0,
+        members: {}
+    };
+    if (hosts.truncated) report.hostsTruncated = true;
+    if (tasksTruncated) report.tasksTruncated = true;
+    const rows = report.members;
+    let poolLookups = 0;
+    for (const uid of uids){
+        var _member_email;
+        var _find, _digest_leads_;
+        const digest = digests.get(uid);
+        if (sentToday[uid]) {
+            rows[uid] = {
+                skipped: 'already-sent'
+            };
+            continue;
+        }
+        const member = memberById.get(uid);
+        if (!await memberHasOrgPermission(orgId, member, 'data.manage')) {
+            rows[uid] = {
+                skipped: 'no-data-manage'
+            };
+            continue;
+        }
+        const userDoc = userById.get(uid);
+        if (!digestEnabled(userDoc == null ? void 0 : userDoc.get(DIGEST_PREFS_FIELD), CRM_DAILY_DIGEST_KEY)) {
+            rows[uid] = {
+                skipped: 'digest-off'
+            };
+            continue;
+        }
+        const muted = notificationMuted(userDoc == null ? void 0 : userDoc.get('notificationPrefs'), 'content.crmDailyDigest');
+        const counts = crmDigestCounts(digest);
+        const row = _extends({}, counts);
+        rows[uid] = row;
+        report.digests += 1;
+        if (dryRun) {
+            row.notified = !muted;
+            continue;
+        }
+        // The site the links open on: where the first task THAT HAS A SITE
+        // lives, else where the first lead was captured. An organization task
+        // (AGL-2637) names no site, and a digest owed nothing but those opens
+        // on the organization's hub.
+        const anchorHostId = ((_find = [
+            ...digest.overdue,
+            ...digest.today
+        ].find((task)=>task.hostId)) == null ? void 0 : _find.hostId) || ((_digest_leads_ = digest.leads[0]) == null ? void 0 : _digest_leads_.hostId) || '';
+        const section = counts.overdue + counts.today > 0 ? 'tasks' : 'leads';
+        const hub = anchorHostId ? hubUrl(anchorHostId) : orgHubUrl;
+        /*
+     * THE EMAIL FIRST. A refusal from the send-rate governor stops the run
+     * with nothing else done for this member — no notification to double
+     * tomorrow, no marker to skip them on — so the order here is the
+     * idempotence, not a preference.
+     */ let emailed = false;
+        let emailReason;
+        let address = String((_member_email = member.email) != null ? _member_email : '').trim().toLowerCase();
+        if (!address.includes('@') && poolLookups < CRM_DIGEST_EMAIL_MAX_UID_LOOKUPS) {
+            var _ref;
+            var _pooled_record;
+            poolLookups += 1;
+            const pooled = await findUserByUidAcrossPools(uid).catch(()=>null);
+            address = String((_ref = pooled == null ? void 0 : (_pooled_record = pooled.record) == null ? void 0 : _pooled_record.email) != null ? _ref : '').trim().toLowerCase();
+        }
+        const recipients = address.includes('@') ? await filterSuppressedEmails([
+            address
+        ], firestore) : [];
+        if (!recipients.length) {
+            emailReason = address.includes('@') ? 'suppressed' : 'no-recipient';
+        } else {
+            const digestInput = {
+                digest,
+                nowMs,
+                timeZone,
+                productName: branding.productName,
+                tasksUrl: hub ? `${hub}/tasks` : ctx.origin,
+                leadsUrl: (hostId)=>{
+                    var _hubUrl;
+                    return `${(_hubUrl = hubUrl(hostId)) != null ? _hubUrl : ctx.origin}/leads`;
+                },
+                settingsUrl,
+                hostName,
+                supportLine
+            };
+            const subject = composeCrmDigestSubject(counts);
+            // The `crm-daily-digest` system email (AGL-3367), in the org's brand,
+            // read once per org and rendered per member.
+            digestEmail != null ? digestEmail : digestEmail = loadSystemEmail('crm-daily-digest').catch(()=>null);
+            const loaded = await digestEmail;
+            const rendered = loaded ? renderLoadedSystemEmail(loaded, _extends({}, brand.merge, {
+                'digest.subject': subject,
+                'digest.body': composeCrmDigestEmailText(_extends({}, digestInput, {
+                    omitClosing: true
+                })),
+                settingsUrl
+            }), brand.options) : null;
+            const result = await sendEmail(_extends({
+                to: recipients
+            }, systemEmailContent(rendered, {
+                subject,
+                text: composeCrmDigestEmailText(digestInput)
+            }), {
+                fromName: branding.fromName,
+                context: 'crm-daily-digest',
+                priority: 'bulk'
+            }));
+            if (result.sent) {
+                emailed = true;
+                await meterPlatformEmail().catch(()=>undefined);
+            } else if (rateLimitedRetryAtMs(result) !== null) {
+                row.deferred = true;
+                report.deferred = true;
+                return report;
+            } else {
+                var _result_reason;
+                emailReason = (_result_reason = result.reason) != null ? _result_reason : 'failed';
+            }
+        }
+        let notified = false;
+        if (!muted) {
+            await notifyUsers([
+                uid
+            ], _extends({
+                type: 'content.crmDailyDigest',
+                title: 'Your CRM today',
+                body: composeCrmDigestSummary(counts),
+                link: notificationLink(anchorHostId, section),
+                orgId
+            }, anchorHostId ? {
+                hostId: anchorHostId
+            } : {}));
+            notified = true;
+        }
+        await markerRef.set({
+            day,
+            members: {
+                [uid]: _extends({
+                    atMs: nowMs
+                }, counts, {
+                    notified,
+                    emailed
+                })
+            },
+            updatedAt: firebaseAdmin.firestore.FieldValue.serverTimestamp()
+        }, {
+            merge: true
+        });
+        row.notified = notified;
+        row.emailed = emailed;
+        if (emailReason) row.emailReason = emailReason;
+        if (notified) report.notified += 1;
+        if (emailed) report.emailed += 1;
+    }
+    return report;
+}
+export async function crmDailyDigestRoute(request) {
+    const { method, body, headers: rawHeaders, query } = await pluginRequestFromWeb(request);
+    const headers = rawHeaders;
+    if (method !== 'POST' && method !== 'GET') {
+        return Response.json({
+            error: 'Method not allowed'
+        }, {
+            status: 405
+        });
+    }
+    if (!process.env.CRON_SECRET) {
+        return Response.json({
+            error: 'The CRM digest is not configured (CRON_SECRET).'
+        }, {
+            status: 501
+        });
+    }
+    if (!isCronAuthorized(headers)) {
+        return Response.json({
+            error: 'Unauthenticated'
+        }, {
+            status: 401
+        });
+    }
+    // A GET reports the plan and sends nothing; a bodyless POST — what the
+    // scheduled workflow sends — is a real run. `isCronDryRun` keys the
+    // default on the METHOD for exactly that reason.
+    const dryRun = isCronDryRun({
+        method,
+        body,
+        query
+    });
+    // Stamped on the invocation, not on the work (AGL-1955), so the beat is
+    // already there the day this job joins `SCHEDULED_JOBS`.
+    if (method === 'POST') await recordCronBeat(CRM_DIGEST_JOB_ID);
+    try {
+        var _ref;
+        var _orgDocs_;
+        const firestore = firebaseAdmin.app().firestore();
+        const nowMs = Date.now();
+        const ctx = {
+            firestore,
+            nowMs,
+            day: utcDayKey(nowMs),
+            timeZone: digestTimeZone(),
+            dryRun,
+            flagValues: await getServerReleaseFlagValues(),
+            origin: consoleOrigin()
+        };
+        // The resumable sweep, in the shape `usage-alerts` reads orgs (AGL-2220):
+        // ordered by id, `limit + 1` to learn whether there is more, the cursor
+        // validated as an org id before it becomes a reference.
+        const requestedLimit = Number(body == null ? void 0 : body.limit);
+        const pageSize = Number.isFinite(requestedLimit) && requestedLimit > 0 ? Math.min(Math.floor(requestedLimit), CRM_DIGEST_ORG_CHUNK) : CRM_DIGEST_ORG_CHUNK;
+        const rawCursor = body == null ? void 0 : body.cursor;
+        const cursor = typeof rawCursor === 'string' && rawCursor.length > 0 && !rawCursor.includes('/') ? rawCursor : null;
+        let orgQuery = firestore.collection('orgs').orderBy(firebaseAdmin.firestore.FieldPath.documentId()).limit(pageSize + 1);
+        if (cursor) orgQuery = orgQuery.startAfter(firestore.collection('orgs').doc(cursor));
+        const page = await orgQuery.get();
+        const hasMore = page.docs.length > pageSize;
+        const orgDocs = hasMore ? page.docs.slice(0, pageSize) : page.docs;
+        const orgs = {};
+        const failures = {};
+        let digests = 0;
+        let notified = 0;
+        let emailed = 0;
+        let deferred = false;
+        for (const orgDoc of orgDocs){
+            try {
+                const report = await digestOrg(ctx, orgDoc);
+                orgs[orgDoc.id] = report;
+                digests += report.digests;
+                notified += report.notified;
+                emailed += report.emailed;
+                if (report.deferred) {
+                    deferred = true;
+                    break;
+                }
+            } catch (error) {
+                var _ref1;
+                console.error('[crm] daily digest failed for org', orgDoc.id, error);
+                failures[orgDoc.id] = (_ref1 = error == null ? void 0 : error.message) != null ? _ref1 : 'unknown';
+            }
+        }
+        const failed = Object.keys(failures);
+        return Response.json(_extends({
+            day: ctx.day,
+            timeZone: ctx.timeZone,
+            dryRun,
+            swept: orgDocs.length,
+            digests,
+            notified,
+            emailed,
+            orgs
+        }, deferred ? {
+            deferred: true
+        } : {}, failed.length ? {
+            failures
+        } : {}, {
+            // A deferred run reports `done: true` — see the module comment —
+            // so the workflow's loop does not re-POST into a full window.
+            nextCursor: deferred || !hasMore ? null : (_ref = (_orgDocs_ = orgDocs[orgDocs.length - 1]) == null ? void 0 : _orgDocs_.id) != null ? _ref : null,
+            done: deferred || !hasMore
+        }), // 207: this chunk finished and some org in it needs a person, which is
+        // what fails the workflow (its one alerting channel).
+        {
+            status: failed.length ? 207 : 200
+        });
+    } catch (error) {
+        console.error('[crm] daily digest run failed', error);
+        return Response.json({
+            error: 'CRM digest run failed'
+        }, {
+            status: 500
+        });
+    }
+}
+
+//# sourceMappingURL=daily-digest-route.js.map