@ucptools/validator 1.0.1 → 1.2.0

package/dist/services/cron.js

@@ -0,0 +1,693 @@
+"use strict";
+/**
+ * Cron Service
+ *
+ * Handles scheduled tasks like weekly domain validation.
+ * Designed to be triggered by Vercel Cron, external scheduler, or manual API call.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDomainsNeedingValidation = getDomainsNeedingValidation;
+exports.runWeeklyValidation = runWeeklyValidation;
+exports.getCronStats = getCronStats;
+exports.runTrialEmailSequence = runTrialEmailSequence;
+exports.runHostedProfileMaintenance = runHostedProfileMaintenance;
+exports.runExpireTrials = runExpireTrials;
+const index_js_1 = require("../db/index.js");
+const schema_js_1 = require("../db/schema.js");
+const drizzle_orm_1 = require("drizzle-orm");
+const validation_history_js_1 = require("./validation-history.js");
+const email_js_1 = require("./email.js");
+const monitoring_diff_js_1 = require("./monitoring-diff.js");
+const notifications_js_1 = require("./notifications.js");
+const hosted_profiles_js_1 = require("./hosted-profiles.js");
+const posthog_js_1 = require("./posthog.js");
+/**
+ * Get all domains that need validation based on their monitoring frequency.
+ * - Must be active
+ * - User must have active or trialing subscription
+ * - Filters by frequency: daily → 24h threshold, weekly → 7d threshold
+ * - Never-checked domains are always included
+ */
+async function getDomainsNeedingValidation() {
+    const db = (0, index_js_1.getDb)();
+    // Get all active domains with active/trialing subscriptions
+    const domains = await db
+        .select({
+        id: schema_js_1.monitoredDomains.id,
+        domain: schema_js_1.monitoredDomains.domain,
+        userId: schema_js_1.monitoredDomains.userId,
+        userEmail: schema_js_1.users.email,
+        userName: schema_js_1.users.name,
+        lastCheckedAt: schema_js_1.monitoredDomains.lastCheckedAt,
+        lastScore: schema_js_1.monitoredDomains.lastScore,
+        lastGrade: schema_js_1.monitoredDomains.lastGrade,
+        alertOnScoreChange: schema_js_1.monitoredDomains.alertOnScoreChange,
+        alertOnGradeChange: schema_js_1.monitoredDomains.alertOnGradeChange,
+        alertThreshold: schema_js_1.monitoredDomains.alertThreshold,
+        monitoringFrequency: schema_js_1.monitoredDomains.monitoringFrequency,
+        webhookUrl: schema_js_1.monitoredDomains.webhookUrl,
+        webhookEnabled: schema_js_1.monitoredDomains.webhookEnabled,
+    })
+        .from(schema_js_1.monitoredDomains)
+        .innerJoin(schema_js_1.users, (0, drizzle_orm_1.eq)(schema_js_1.monitoredDomains.userId, schema_js_1.users.id))
+        .innerJoin(schema_js_1.subscriptions, (0, drizzle_orm_1.eq)(schema_js_1.users.id, schema_js_1.subscriptions.userId))
+        .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(schema_js_1.monitoredDomains.isActive, true), (0, drizzle_orm_1.or)((0, drizzle_orm_1.eq)(schema_js_1.subscriptions.status, 'active'), (0, drizzle_orm_1.eq)(schema_js_1.subscriptions.status, 'trialing'), (0, drizzle_orm_1.eq)(schema_js_1.subscriptions.status, 'expired'))));
+    // Filter in JS by frequency threshold
+    const now = Date.now();
+    const ONE_DAY_MS = 24 * 60 * 60 * 1000;
+    const SEVEN_DAYS_MS = 7 * ONE_DAY_MS;
+    return domains.filter(d => {
+        // Never checked → always include
+        if (!d.lastCheckedAt)
+            return true;
+        const elapsed = now - new Date(d.lastCheckedAt).getTime();
+        const frequency = d.monitoringFrequency || 'weekly';
+        if (frequency === 'daily') {
+            return elapsed >= ONE_DAY_MS;
+        }
+        // weekly (default)
+        return elapsed >= SEVEN_DAYS_MS;
+    });
+}
+/**
+ * Run domain validation for all eligible domains (frequency-aware).
+ * Includes diff analysis, severity classification, and webhook dispatch.
+ *
+ * @param maxDomains - Maximum number of domains to process (for rate limiting)
+ * @param delayBetweenMs - Delay between validations in milliseconds
+ */
+async function runWeeklyValidation(maxDomains = 100, delayBetweenMs = 1000) {
+    const startTime = Date.now();
+    const result = {
+        success: true,
+        domainsProcessed: 0,
+        domainsValidated: 0,
+        domainsFailed: 0,
+        alertsSent: 0,
+        alertsFailed: 0,
+        webhooksSent: 0,
+        errors: [],
+        durationMs: 0,
+    };
+    const dashboardBaseUrl = process.env.DASHBOARD_URL || 'https://ucptools.dev/dashboard';
+    try {
+        const domains = await getDomainsNeedingValidation();
+        const toProcess = domains.slice(0, maxDomains);
+        console.log(`[Cron] Found ${domains.length} domains needing validation, processing ${toProcess.length}`);
+        for (const domainInfo of toProcess) {
+            result.domainsProcessed++;
+            try {
+                console.log(`[Cron] Validating domain: ${domainInfo.domain}`);
+                // Run validation and store history
+                const { result: validationResult, historyEntry } = await (0, validation_history_js_1.validateAndStoreHistory)(domainInfo.id, domainInfo.domain);
+                result.domainsValidated++;
+                const newScore = validationResult.ai_readiness.score;
+                const newGrade = validationResult.ai_readiness.grade;
+                console.log(`[Cron] Successfully validated: ${domainInfo.domain} (score: ${newScore})`);
+                // ── Diff analysis ──────────────────────────────────────────
+                let diff = null;
+                const previousEntry = await (0, validation_history_js_1.getPreviousValidation)(domainInfo.id, historyEntry?.id);
+                if (previousEntry?.resultJson) {
+                    try {
+                        const previousResult = JSON.parse(previousEntry.resultJson);
+                        diff = (0, monitoring_diff_js_1.diffValidationResults)(previousResult, validationResult, domainInfo.alertThreshold ?? 10);
+                        // Store severity + changes summary on the history entry
+                        if (historyEntry) {
+                            await (0, validation_history_js_1.updateHistorySeverity)(historyEntry.id, diff.severity, JSON.stringify({ text: diff.summary, changes: diff.changes }));
+                        }
+                        // Update lastSeverity on the monitored domain
+                        const db = (0, index_js_1.getDb)();
+                        await db
+                            .update(schema_js_1.monitoredDomains)
+                            .set({ lastSeverity: diff.severity, updatedAt: new Date() })
+                            .where((0, drizzle_orm_1.eq)(schema_js_1.monitoredDomains.id, domainInfo.id));
+                        console.log(`[Cron] Diff for ${domainInfo.domain}: severity=${diff.severity}, changes=${diff.changes.length}`);
+                    }
+                    catch (diffError) {
+                        console.error(`[Cron] Diff error for ${domainInfo.domain}:`, diffError);
+                    }
+                }
+                // ── Severity-based alerting ────────────────────────────────
+                const severity = diff?.severity;
+                const dashboardUrl = `${dashboardBaseUrl}/domains/${domainInfo.id}`;
+                const shouldEmail = severity === 'broken'
+                    || (severity === 'degraded' && (domainInfo.alertOnScoreChange || domainInfo.alertOnGradeChange))
+                    || (!diff && domainInfo.alertOnScoreChange && domainInfo.lastScore !== null && Math.abs(newScore - domainInfo.lastScore) >= (domainInfo.alertThreshold ?? 10));
+                if (shouldEmail) {
+                    try {
+                        let emailResult;
+                        // Use severity-aware template when we have diff data
+                        if (diff && (severity === 'broken' || severity === 'degraded' || severity === 'changed')) {
+                            emailResult = await (0, email_js_1.sendSeverityAlert)({
+                                to: {
+                                    email: domainInfo.userEmail,
+                                    name: domainInfo.userName || undefined,
+                                },
+                                domain: domainInfo.domain,
+                                severity,
+                                oldScore: domainInfo.lastScore,
+                                newScore,
+                                oldGrade: domainInfo.lastGrade,
+                                newGrade,
+                                summary: diff.summary,
+                                changes: diff.changes.map(c => ({
+                                    field: c.field,
+                                    type: c.type,
+                                    oldValue: c.oldValue,
+                                    newValue: c.newValue,
+                                })),
+                                dashboardUrl,
+                            });
+                        }
+                        else {
+                            // Fallback to basic score change alert
+                            emailResult = await (0, email_js_1.sendScoreChangeAlert)({
+                                to: {
+                                    email: domainInfo.userEmail,
+                                    name: domainInfo.userName || undefined,
+                                },
+                                domain: domainInfo.domain,
+                                oldScore: domainInfo.lastScore ?? 0,
+                                newScore,
+                                oldGrade: domainInfo.lastGrade || 'F',
+                                newGrade,
+                                dashboardUrl,
+                            });
+                        }
+                        if (emailResult.success) {
+                            result.alertsSent++;
+                            console.log(`[Cron] Alert sent to ${domainInfo.userEmail} (severity: ${severity || 'score-change'})`);
+                        }
+                        else {
+                            result.alertsFailed++;
+                            console.error(`[Cron] Failed to send alert: ${emailResult.error}`);
+                        }
+                    }
+                    catch (emailError) {
+                        result.alertsFailed++;
+                        console.error(`[Cron] Email error:`, emailError);
+                    }
+                }
+                // ── Webhook dispatch ───────────────────────────────────────
+                if (diff && diff.severity !== 'stable' && domainInfo.webhookEnabled && domainInfo.webhookUrl) {
+                    const eventMap = {
+                        broken: 'profile_broken',
+                        degraded: 'profile_degraded',
+                        changed: 'profile_changed',
+                    };
+                    const payload = {
+                        event: eventMap[diff.severity] || 'profile_changed',
+                        domain: domainInfo.domain,
+                        severity: diff.severity,
+                        oldScore: domainInfo.lastScore,
+                        newScore,
+                        oldGrade: domainInfo.lastGrade,
+                        newGrade,
+                        changes: diff.changes.map(c => ({
+                            field: c.field,
+                            type: c.type,
+                            oldValue: c.oldValue,
+                            newValue: c.newValue,
+                        })),
+                        summary: diff.summary,
+                        timestamp: new Date().toISOString(),
+                        dashboardUrl,
+                    };
+                    const sent = await (0, notifications_js_1.sendDomainWebhook)(domainInfo.webhookUrl, payload);
+                    if (sent)
+                        result.webhooksSent++;
+                }
+            }
+            catch (error) {
+                result.domainsFailed++;
+                const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+                result.errors.push({ domain: domainInfo.domain, error: errorMessage });
+                console.error(`[Cron] Failed to validate ${domainInfo.domain}:`, errorMessage);
+            }
+            // Add delay between validations to avoid overwhelming the system
+            if (delayBetweenMs > 0 && result.domainsProcessed < toProcess.length) {
+                await sleep(delayBetweenMs);
+            }
+        }
+        result.success = result.domainsFailed === 0;
+    }
+    catch (error) {
+        result.success = false;
+        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+        result.errors.push({ domain: 'system', error: errorMessage });
+        console.error('[Cron] Domain validation failed:', errorMessage);
+    }
+    result.durationMs = Date.now() - startTime;
+    console.log(`[Cron] Completed: ${result.domainsValidated}/${result.domainsProcessed} validated, ${result.alertsSent} alerts, ${result.webhooksSent} webhooks in ${result.durationMs}ms`);
+    return result;
+}
+/**
+ * Get cron status/stats
+ */
+async function getCronStats() {
+    const domains = await getDomainsNeedingValidation();
+    // Next run is typically handled by external scheduler
+    // For Vercel Cron, this would be configured in vercel.json
+    const nextRunAt = new Date();
+    nextRunAt.setDate(nextRunAt.getDate() + 7);
+    nextRunAt.setHours(0, 0, 0, 0);
+    return {
+        pendingDomains: domains.length,
+        lastRunAt: null, // Would need separate tracking for this
+        nextRunAt,
+    };
+}
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+/**
+ * Send trial sequence emails to users
+ *
+ * - Day 3: Value reminder + Feature highlight
+ * - Day 6: Trial ending + Conversion CTA
+ *
+ * This should be run daily via cron job.
+ */
+async function runTrialEmailSequence() {
+    const startTime = Date.now();
+    const result = {
+        success: true,
+        day1Sent: 0,
+        day1Failed: 0,
+        day2Sent: 0,
+        day2Failed: 0,
+        day3Sent: 0,
+        day3Failed: 0,
+        day6Sent: 0,
+        day6Failed: 0,
+        errors: [],
+        durationMs: 0,
+    };
+    const dashboardBaseUrl = process.env.DASHBOARD_URL || 'https://ucptools.dev/dashboard';
+    try {
+        const db = (0, index_js_1.getDb)();
+        // Get trialing users with their trial start dates
+        const trialingUsers = await db
+            .select({
+            userId: schema_js_1.users.id,
+            email: schema_js_1.users.email,
+            name: schema_js_1.users.name,
+            trialStartedAt: schema_js_1.subscriptions.createdAt,
+            currentPeriodEnd: schema_js_1.subscriptions.currentPeriodEnd,
+        })
+            .from(schema_js_1.subscriptions)
+            .innerJoin(schema_js_1.users, (0, drizzle_orm_1.eq)(schema_js_1.subscriptions.userId, schema_js_1.users.id))
+            .where((0, drizzle_orm_1.eq)(schema_js_1.subscriptions.status, 'trialing'));
+        console.log(`[Cron] Found ${trialingUsers.length} users in trial`);
+        const now = new Date();
+        for (const user of trialingUsers) {
+            if (!user.trialStartedAt)
+                continue;
+            const trialStart = new Date(user.trialStartedAt);
+            const daysSinceTrialStart = Math.floor((now.getTime() - trialStart.getTime()) / (1000 * 60 * 60 * 24));
+            // Get user's domain count for personalization
+            const domainCount = await db
+                .select({ count: schema_js_1.monitoredDomains.id })
+                .from(schema_js_1.monitoredDomains)
+                .where((0, drizzle_orm_1.eq)(schema_js_1.monitoredDomains.userId, user.userId))
+                .then((rows) => rows.length);
+            // Day 1 email - Quick Start Guide
+            if (daysSinceTrialStart === 1) {
+                try {
+                    console.log(`[Cron] Sending Day 1 email to ${user.email}`);
+                    const emailResult = await (0, email_js_1.sendTrialDay1Email)({
+                        to: {
+                            email: user.email,
+                            name: user.name || undefined,
+                        },
+                        dashboardUrl: dashboardBaseUrl,
+                    });
+                    (0, posthog_js_1.trackEmailSent)({ userId: user.userId, email: user.email, emailType: 'trial_day1', success: emailResult.success });
+                    if (emailResult.success) {
+                        result.day1Sent++;
+                        console.log(`[Cron] Day 1 email sent to ${user.email}`);
+                    }
+                    else {
+                        result.day1Failed++;
+                        result.errors.push({
+                            userId: user.userId,
+                            email: user.email,
+                            error: emailResult.error || 'Unknown error',
+                        });
+                    }
+                }
+                catch (error) {
+                    result.day1Failed++;
+                    result.errors.push({
+                        userId: user.userId,
+                        email: user.email,
+                        error: error instanceof Error ? error.message : 'Unknown error',
+                    });
+                }
+            }
+            // Day 2 email - Personalized Domain Report
+            if (daysSinceTrialStart === 2) {
+                try {
+                    console.log(`[Cron] Sending Day 2 email to ${user.email}`);
+                    // Get the user's first domain for personalization
+                    const userDomains = await db
+                        .select({
+                        id: schema_js_1.monitoredDomains.id,
+                        domain: schema_js_1.monitoredDomains.domain,
+                        lastScore: schema_js_1.monitoredDomains.lastScore,
+                        lastGrade: schema_js_1.monitoredDomains.lastGrade,
+                    })
+                        .from(schema_js_1.monitoredDomains)
+                        .where((0, drizzle_orm_1.eq)(schema_js_1.monitoredDomains.userId, user.userId))
+                        .limit(1);
+                    const firstDomain = userDomains[0];
+                    let topIssues = [];
+                    // Get latest validation result for top issues
+                    if (firstDomain) {
+                        const latestHistory = await db
+                            .select({ resultJson: schema_js_1.validationHistory.resultJson })
+                            .from(schema_js_1.validationHistory)
+                            .where((0, drizzle_orm_1.eq)(schema_js_1.validationHistory.domainId, firstDomain.id))
+                            .orderBy((0, drizzle_orm_1.desc)(schema_js_1.validationHistory.validatedAt))
+                            .limit(1);
+                        if (latestHistory[0]?.resultJson) {
+                            try {
+                                const lastResult = JSON.parse(latestHistory[0].resultJson);
+                                const issues = lastResult?.issues || lastResult?.findings || [];
+                                topIssues = issues
+                                    .filter((i) => i.severity === 'error' || i.severity === 'warn')
+                                    .slice(0, 5)
+                                    .map((i) => ({ message: i.message, severity: i.severity }));
+                            }
+                            catch {
+                                // Ignore JSON parse errors
+                            }
+                        }
+                    }
+                    const emailResult = await (0, email_js_1.sendTrialDay2Email)({
+                        to: {
+                            email: user.email,
+                            name: user.name || undefined,
+                        },
+                        dashboardUrl: dashboardBaseUrl,
+                        domain: firstDomain?.domain,
+                        score: firstDomain?.lastScore ?? undefined,
+                        grade: firstDomain?.lastGrade ?? undefined,
+                        topIssues,
+                    });
+                    (0, posthog_js_1.trackEmailSent)({ userId: user.userId, email: user.email, emailType: 'trial_day2', success: emailResult.success });
+                    if (emailResult.success) {
+                        result.day2Sent++;
+                        console.log(`[Cron] Day 2 email sent to ${user.email}`);
+                    }
+                    else {
+                        result.day2Failed++;
+                        result.errors.push({
+                            userId: user.userId,
+                            email: user.email,
+                            error: emailResult.error || 'Unknown error',
+                        });
+                    }
+                }
+                catch (error) {
+                    result.day2Failed++;
+                    result.errors.push({
+                        userId: user.userId,
+                        email: user.email,
+                        error: error instanceof Error ? error.message : 'Unknown error',
+                    });
+                }
+            }
+            // Day 3 email (send on day 3)
+            if (daysSinceTrialStart === 3) {
+                try {
+                    console.log(`[Cron] Sending Day 3 email to ${user.email}`);
+                    const emailResult = await (0, email_js_1.sendTrialDay3Email)({
+                        to: {
+                            email: user.email,
+                            name: user.name || undefined,
+                        },
+                        dashboardUrl: dashboardBaseUrl,
+                        domainsAdded: domainCount,
+                    });
+                    (0, posthog_js_1.trackEmailSent)({ userId: user.userId, email: user.email, emailType: 'trial_day3', success: emailResult.success });
+                    if (emailResult.success) {
+                        result.day3Sent++;
+                        console.log(`[Cron] Day 3 email sent to ${user.email}`);
+                    }
+                    else {
+                        result.day3Failed++;
+                        result.errors.push({
+                            userId: user.userId,
+                            email: user.email,
+                            error: emailResult.error || 'Unknown error',
+                        });
+                    }
+                }
+                catch (error) {
+                    result.day3Failed++;
+                    result.errors.push({
+                        userId: user.userId,
+                        email: user.email,
+                        error: error instanceof Error ? error.message : 'Unknown error',
+                    });
+                }
+            }
+            // Day 6 email (send on day 6)
+            if (daysSinceTrialStart === 6) {
+                try {
+                    console.log(`[Cron] Sending Day 6 email to ${user.email}`);
+                    // Get validation count for this user
+                    const validationCount = await db
+                        .select({ count: schema_js_1.monitoredDomains.id })
+                        .from(schema_js_1.monitoredDomains)
+                        .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(schema_js_1.monitoredDomains.userId, user.userId), 
+                    // Has been validated at least once
+                    (0, drizzle_orm_1.lt)(schema_js_1.monitoredDomains.lastCheckedAt, now)))
+                        .then((rows) => rows.length);
+                    const emailResult = await (0, email_js_1.sendTrialDay6Email)({
+                        to: {
+                            email: user.email,
+                            name: user.name || undefined,
+                        },
+                        dashboardUrl: dashboardBaseUrl,
+                        domainsAdded: domainCount,
+                        validationsRun: validationCount,
+                    });
+                    (0, posthog_js_1.trackEmailSent)({ userId: user.userId, email: user.email, emailType: 'trial_day6', success: emailResult.success });
+                    if (emailResult.success) {
+                        result.day6Sent++;
+                        console.log(`[Cron] Day 6 email sent to ${user.email}`);
+                    }
+                    else {
+                        result.day6Failed++;
+                        result.errors.push({
+                            userId: user.userId,
+                            email: user.email,
+                            error: emailResult.error || 'Unknown error',
+                        });
+                    }
+                }
+                catch (error) {
+                    result.day6Failed++;
+                    result.errors.push({
+                        userId: user.userId,
+                        email: user.email,
+                        error: error instanceof Error ? error.message : 'Unknown error',
+                    });
+                }
+            }
+            // Small delay between emails to avoid rate limits
+            await sleep(100);
+        }
+        result.success =
+            result.day1Failed === 0 && result.day2Failed === 0 && result.day3Failed === 0 && result.day6Failed === 0;
+    }
+    catch (error) {
+        result.success = false;
+        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+        result.errors.push({ userId: 'system', email: '', error: errorMessage });
+        console.error('[Cron] Trial email sequence failed:', errorMessage);
+    }
+    result.durationMs = Date.now() - startTime;
+    console.log(`[Cron] Trial emails completed: Day 1: ${result.day1Sent}, Day 2: ${result.day2Sent}, Day 3: ${result.day3Sent}, Day 6: ${result.day6Sent} sent in ${result.durationMs}ms`);
+    return result;
+}
+/**
+ * Run validation on active hosted profiles that haven't been validated in 7+ days.
+ * Also checks pending DNS verifications.
+ */
+async function runHostedProfileMaintenance(maxProfiles = 100, delayBetweenMs = 500) {
+    const startTime = Date.now();
+    const result = {
+        success: true,
+        profilesValidated: 0,
+        profilesFailed: 0,
+        verificationsChecked: 0,
+        verificationsConfirmed: 0,
+        errors: [],
+        durationMs: 0,
+    };
+    try {
+        // 1. Re-validate active profiles needing validation
+        const profilesToValidate = await (0, hosted_profiles_js_1.getProfilesNeedingValidation)(maxProfiles);
+        console.log(`[Cron] Found ${profilesToValidate.length} hosted profiles needing validation`);
+        for (const profile of profilesToValidate) {
+            try {
+                await (0, hosted_profiles_js_1.validateHostedProfile)(profile.id);
+                result.profilesValidated++;
+            }
+            catch (error) {
+                result.profilesFailed++;
+                result.errors.push({
+                    profileId: profile.id,
+                    error: error instanceof Error ? error.message : 'Unknown error',
+                });
+            }
+            if (delayBetweenMs > 0) {
+                await sleep(delayBetweenMs);
+            }
+        }
+        // 2. Check pending verifications
+        const pendingVerifications = await (0, hosted_profiles_js_1.getProfilesPendingVerification)(50);
+        console.log(`[Cron] Found ${pendingVerifications.length} profiles pending DNS verification`);
+        for (const profile of pendingVerifications) {
+            result.verificationsChecked++;
+            try {
+                const check = await (0, hosted_profiles_js_1.checkDnsVerification)(profile.id);
+                if (check.verified) {
+                    result.verificationsConfirmed++;
+                    console.log(`[Cron] DNS verified for ${profile.domain}`);
+                }
+            }
+            catch (error) {
+                result.errors.push({
+                    profileId: profile.id,
+                    error: error instanceof Error ? error.message : 'DNS check failed',
+                });
+            }
+            if (delayBetweenMs > 0) {
+                await sleep(delayBetweenMs);
+            }
+        }
+        result.success = result.profilesFailed === 0;
+    }
+    catch (error) {
+        result.success = false;
+        result.errors.push({
+            profileId: 'system',
+            error: error instanceof Error ? error.message : 'Unknown error',
+        });
+        console.error('[Cron] Hosted profile maintenance failed:', error);
+    }
+    result.durationMs = Date.now() - startTime;
+    console.log(`[Cron] Hosted profile maintenance: ${result.profilesValidated} validated, ${result.verificationsConfirmed}/${result.verificationsChecked} DNS verified in ${result.durationMs}ms`);
+    return result;
+}
+/**
+ * Expire trials that have passed their currentPeriodEnd date.
+ *
+ * Downgrades users from trialing/starter → canceled/free.
+ * Sends a "trial expired" email with upgrade CTA.
+ *
+ * Should be run daily via cron job (same schedule as trial-emails).
+ */
+async function runExpireTrials() {
+    const startTime = Date.now();
+    const result = {
+        success: true,
+        expired: 0,
+        emailsSent: 0,
+        emailsFailed: 0,
+        errors: [],
+        durationMs: 0,
+    };
+    const dashboardBaseUrl = process.env.DASHBOARD_URL || 'https://ucptools.dev/dashboard';
+    try {
+        const db = (0, index_js_1.getDb)();
+        const now = new Date();
+        // Find all trialing subscriptions where currentPeriodEnd has passed
+        const expiredTrials = await db
+            .select({
+            userId: schema_js_1.subscriptions.userId,
+            currentPeriodEnd: schema_js_1.subscriptions.currentPeriodEnd,
+            userEmail: schema_js_1.users.email,
+            userName: schema_js_1.users.name,
+        })
+            .from(schema_js_1.subscriptions)
+            .innerJoin(schema_js_1.users, (0, drizzle_orm_1.eq)(schema_js_1.subscriptions.userId, schema_js_1.users.id))
+            .where((0, drizzle_orm_1.and)((0, drizzle_orm_1.eq)(schema_js_1.subscriptions.status, 'trialing'), (0, drizzle_orm_1.lt)(schema_js_1.subscriptions.currentPeriodEnd, now)));
+        console.log(`[Cron] Found ${expiredTrials.length} expired trials to downgrade`);
+        for (const trial of expiredTrials) {
+            try {
+                // Expire trial — keep tier so monitoring continues, set status to expired
+                await db
+                    .update(schema_js_1.subscriptions)
+                    .set({
+                    status: 'expired',
+                    updatedAt: new Date(),
+                })
+                    .where((0, drizzle_orm_1.eq)(schema_js_1.subscriptions.userId, trial.userId));
+                result.expired++;
+                console.log(`[Cron] Expired trial for user ${trial.userId} (${trial.userEmail})`);
+                // Get domain count for email personalization
+                const domainCount = await db
+                    .select({ id: schema_js_1.monitoredDomains.id })
+                    .from(schema_js_1.monitoredDomains)
+                    .where((0, drizzle_orm_1.eq)(schema_js_1.monitoredDomains.userId, trial.userId))
+                    .then((rows) => rows.length);
+                // Send trial expired email
+                try {
+                    const emailResult = await (0, email_js_1.sendTrialExpiredEmail)({
+                        to: {
+                            email: trial.userEmail,
+                            name: trial.userName || undefined,
+                        },
+                        dashboardUrl: dashboardBaseUrl,
+                        domainsAdded: domainCount,
+                    });
+                    (0, posthog_js_1.trackEmailSent)({ userId: trial.userId, email: trial.userEmail, emailType: 'trial_expired', success: emailResult.success });
+                    if (emailResult.success) {
+                        result.emailsSent++;
+                        console.log(`[Cron] Trial expired email sent to ${trial.userEmail}`);
+                    }
+                    else {
+                        result.emailsFailed++;
+                        result.errors.push({
+                            userId: trial.userId,
+                            error: `Email failed: ${emailResult.error}`,
+                        });
+                    }
+                }
+                catch (emailError) {
+                    result.emailsFailed++;
+                    result.errors.push({
+                        userId: trial.userId,
+                        error: `Email error: ${emailError instanceof Error ? emailError.message : 'Unknown'}`,
+                    });
+                }
+            }
+            catch (error) {
+                result.errors.push({
+                    userId: trial.userId,
+                    error: error instanceof Error ? error.message : 'Unknown error',
+                });
+                console.error(`[Cron] Failed to expire trial for ${trial.userId}:`, error);
+            }
+            await sleep(100);
+        }
+        result.success = result.errors.length === 0;
+    }
+    catch (error) {
+        result.success = false;
+        result.errors.push({
+            userId: 'system',
+            error: error instanceof Error ? error.message : 'Unknown error',
+        });
+        console.error('[Cron] Trial expiration failed:', error);
+    }
+    result.durationMs = Date.now() - startTime;
+    console.log(`[Cron] Trial expiration completed: ${result.expired} expired, ${result.emailsSent} emails sent in ${result.durationMs}ms`);
+    return result;
+}
+//# sourceMappingURL=cron.js.map