@orion-studios/payload-seo-audit 1.0.0 → 1.1.1

package/dist/utilities/dataforseo.js

@@ -0,0 +1,169 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shouldRunAuthoritySync = exports.syncDataForSEOAuthoritySnapshot = void 0;
+const normalizeBaseURL = (value) => value.replace(/\/+$/, '') || 'https://api.dataforseo.com';
+const resolveTarget = (site) => {
+    if (site.domain?.trim())
+        return site.domain.trim();
+    if (!site.canonicalHost?.trim())
+        return null;
+    try {
+        return new URL(site.canonicalHost).hostname;
+    }
+    catch {
+        return site.canonicalHost;
+    }
+};
+const mapLinkType = (value) => {
+    if (typeof value !== 'string')
+        return 'unknown';
+    const normalized = value.toLowerCase();
+    if (normalized.includes('nofollow'))
+        return 'nofollow';
+    if (normalized.includes('dofollow') || normalized.includes('follow'))
+        return 'follow';
+    return 'unknown';
+};
+const extractSourceDomain = (sourceURL) => {
+    if (!sourceURL)
+        return null;
+    try {
+        return new URL(sourceURL).hostname;
+    }
+    catch {
+        return null;
+    }
+};
+const postDataForSEO = async ({ baseURL, login, password, endpoint, payload, }) => {
+    const auth = Buffer.from(`${login}:${password}`).toString('base64');
+    const response = await fetch(`${baseURL}${endpoint}`, {
+        method: 'POST',
+        cache: 'no-store',
+        headers: {
+            authorization: `Basic ${auth}`,
+            'content-type': 'application/json',
+        },
+        body: JSON.stringify([payload]),
+    });
+    if (!response.ok) {
+        throw new Error(`DataForSEO request failed with status ${response.status}`);
+    }
+    return (await response.json());
+};
+const syncDataForSEOAuthoritySnapshot = async ({ payload, site, settings, }) => {
+    if (!settings.authority.enabled || settings.authority.provider !== 'dataforseo') {
+        return {
+            enabled: false,
+            provider: settings.authority.provider,
+            imported: 0,
+            skipped: 'disabled',
+        };
+    }
+    const login = settings.authority.dataForSeoLogin.trim();
+    const password = settings.authority.dataForSeoPassword.trim();
+    const target = resolveTarget(site);
+    if (!login || !password || !target) {
+        return {
+            enabled: true,
+            provider: 'dataforseo',
+            imported: 0,
+            skipped: 'missing-config',
+        };
+    }
+    const baseURL = normalizeBaseURL(settings.authority.dataForSeoBaseURL.trim());
+    try {
+        const summaryResponse = await postDataForSEO({
+            baseURL,
+            login,
+            password,
+            endpoint: '/v3/backlinks/summary/live',
+            payload: {
+                target,
+                include_subdomains: true,
+                exclude_internal_backlinks: true,
+            },
+        });
+        const backlinksResponse = await postDataForSEO({
+            baseURL,
+            login,
+            password,
+            endpoint: '/v3/backlinks/backlinks/live',
+            payload: {
+                target,
+                include_subdomains: true,
+                exclude_internal_backlinks: true,
+                limit: settings.authority.captureTopBacklinksLimit,
+            },
+        });
+        const summaryTask = summaryResponse?.tasks?.[0];
+        const backlinksTask = backlinksResponse?.tasks?.[0];
+        const summaryResult = summaryTask?.result?.[0] || {};
+        const backlinkItems = backlinksTask?.result?.[0]?.items || [];
+        const backlinks = backlinkItems.map((item) => ({
+            sourceURL: item?.source_url || undefined,
+            targetURL: item?.target_url || undefined,
+            anchorText: item?.anchor || undefined,
+            firstSeen: item?.first_seen || undefined,
+            lastSeen: item?.last_visited || undefined,
+            linkType: mapLinkType(item?.link_attribute),
+        }));
+        const uniqueDomains = new Set(backlinks
+            .map((item) => extractSourceDomain(item.sourceURL))
+            .filter((value) => Boolean(value)));
+        const totalBacklinks = Math.max(Number(summaryResult?.total_count || 0), Number(summaryResult?.backlinks || 0), backlinks.length);
+        const referringDomains = Math.max(Number(summaryResult?.referring_domains || 0), uniqueDomains.size);
+        const domainAuthorityProxy = Math.max(1, Math.min(100, Number(summaryResult?.domain_rank || Math.round(Math.log10(referringDomains + 1) * 30))));
+        const summaryCost = Number(summaryTask?.cost || 0);
+        const backlinksCost = Number(backlinksTask?.cost || 0);
+        const estimatedCostUSD = Number((summaryCost + backlinksCost).toFixed(4));
+        const snapshot = await payload.create({
+            collection: 'seo-authority-snapshots',
+            data: {
+                label: `DataForSEO Snapshot ${new Date().toISOString()}`,
+                capturedAt: new Date().toISOString(),
+                source: 'provider',
+                totalBacklinks,
+                referringDomains,
+                domainAuthorityProxy,
+                backlinks,
+                providerMetadata: {
+                    provider: 'dataforseo',
+                    target,
+                    summaryCost,
+                    backlinksCost,
+                    estimatedCostUSD,
+                    summaryStatusCode: summaryTask?.status_code,
+                    backlinksStatusCode: backlinksTask?.status_code,
+                },
+            },
+            overrideAccess: true,
+        });
+        return {
+            enabled: true,
+            provider: 'dataforseo',
+            imported: backlinks.length,
+            snapshotID: snapshot.id,
+            estimatedCostUSD,
+        };
+    }
+    catch (error) {
+        return {
+            enabled: true,
+            provider: 'dataforseo',
+            imported: 0,
+            skipped: 'request-failed',
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+};
+exports.syncDataForSEOAuthoritySnapshot = syncDataForSEOAuthoritySnapshot;
+const shouldRunAuthoritySync = ({ runType, settings, }) => {
+    if (!settings.authority.enabled || settings.authority.provider === 'none')
+        return false;
+    if (settings.authority.runPolicy === 'all')
+        return true;
+    if (settings.authority.runPolicy === 'scheduled-only')
+        return runType === 'scheduled';
+    return runType === 'manual' || runType === 'scheduled';
+};
+exports.shouldRunAuthoritySync = shouldRunAuthoritySync;

package/dist/utilities/gsc.d.ts

@@ -1,15 +1,8 @@
 import type { Payload } from 'payload';
-import type { SEOSiteRecord } from '../utilities/types';
-export declare const syncGSCKeywordVisibility: ({ payload, site, }: {
+import type { GSCSyncResult, IntegrationSettings, SEOSiteRecord } from '../utilities/types';
+export declare const syncGSCKeywordVisibility: ({ payload, site, settings, }: {
     payload: Payload;
     site: SEOSiteRecord;
-}) => Promise<{
-    imported: number;
-    enabled: boolean;
-    skipped?: undefined;
-} | {
-    imported: number;
-    enabled: boolean;
-    skipped: string;
-}>;
+    settings: IntegrationSettings;
+}) => Promise<GSCSyncResult>;
 //# sourceMappingURL=gsc.d.ts.map

package/dist/utilities/gsc.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"gsc.d.ts","sourceRoot":"","sources":["../../src/utilities/gsc.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,SAAS,CAAA;AACtC,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAA;AASvD,eAAO,MAAM,wBAAwB,GAAU,oBAG5C;IACD,OAAO,EAAE,OAAO,CAAA;IAChB,IAAI,EAAE,aAAa,CAAA;CACpB;;;;;;;;EA+DA,CAAA"}
+{"version":3,"file":"gsc.d.ts","sourceRoot":"","sources":["../../src/utilities/gsc.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,SAAS,CAAA;AACtC,OAAO,KAAK,EAAE,aAAa,EAAE,mBAAmB,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAA;AAyC3F,eAAO,MAAM,wBAAwB,GAAU,8BAI5C;IACD,OAAO,EAAE,OAAO,CAAA;IAChB,IAAI,EAAE,aAAa,CAAA;IACnB,QAAQ,EAAE,mBAAmB,CAAA;CAC9B,KAAG,OAAO,CAAC,aAAa,CA2ExB,CAAA"}

package/dist/utilities/gsc.js

@@ -2,37 +2,68 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.syncGSCKeywordVisibility = void 0;
 const googleapis_1 = require("googleapis");
-const requiredEnv = () => ({
-    clientID: process.env.SEO_GSC_CLIENT_ID,
-    clientSecret: process.env.SEO_GSC_CLIENT_SECRET,
-    redirectURI: process.env.SEO_GSC_REDIRECT_URI,
-    refreshToken: process.env.SEO_GSC_REFRESH_TOKEN,
-});
-const syncGSCKeywordVisibility = async ({ payload, site, }) => {
-    if (site.integrations?.enableSearchConsole !== true) {
-        return { imported: 0, enabled: false };
+const toISODate = (value) => value.toISOString().slice(0, 10);
+const resolveSiteURL = (site, settings) => {
+    const override = settings.gsc.siteUrlOverride.trim();
+    if (override)
+        return override;
+    return (site.canonicalHost || '').trim();
+};
+const createOAuthClient = (settings) => {
+    const clientID = settings.gsc.oauthClientID.trim();
+    const clientSecret = settings.gsc.oauthClientSecret.trim();
+    const redirectURI = settings.gsc.oauthRedirectURI.trim();
+    const refreshToken = settings.gsc.oauthRefreshToken.trim();
+    if (!clientID || !clientSecret || !redirectURI || !refreshToken) {
+        return null;
+    }
+    const oauth2Client = new googleapis_1.google.auth.OAuth2(clientID, clientSecret, redirectURI);
+    oauth2Client.setCredentials({
+        refresh_token: refreshToken,
+    });
+    return oauth2Client;
+};
+const createServiceAccountClient = (settings) => {
+    const email = settings.gsc.serviceAccountEmail.trim();
+    const privateKey = settings.gsc.serviceAccountPrivateKey.trim();
+    if (!email || !privateKey)
+        return null;
+    return new googleapis_1.google.auth.JWT({
+        email,
+        key: privateKey,
+        scopes: ['https://www.googleapis.com/auth/webmasters.readonly'],
+    });
+};
+const syncGSCKeywordVisibility = async ({ payload, site, settings, }) => {
+    if (!settings.gsc.enabled) {
+        return { imported: 0, enabled: false, skipped: 'disabled' };
+    }
+    const siteURL = resolveSiteURL(site, settings);
+    if (!siteURL) {
+        return { imported: 0, enabled: true, skipped: 'missing-site-url' };
     }
-    const env = requiredEnv();
-    if (!env.clientID || !env.clientSecret || !env.redirectURI || !env.refreshToken || !site.canonicalHost) {
-        return { imported: 0, enabled: true, skipped: 'missing-config' };
+    const authClient = settings.gsc.authMode === 'service-account'
+        ? createServiceAccountClient(settings)
+        : createOAuthClient(settings);
+    if (!authClient) {
+        return {
+            imported: 0,
+            enabled: true,
+            skipped: `missing-${settings.gsc.authMode}-credentials`,
+        };
     }
     try {
-        const oauth2Client = new googleapis_1.google.auth.OAuth2(env.clientID, env.clientSecret, env.redirectURI);
-        oauth2Client.setCredentials({
-            refresh_token: env.refreshToken,
-        });
-        const searchConsole = googleapis_1.google.searchconsole({ version: 'v1', auth: oauth2Client });
+        const searchConsole = googleapis_1.google.searchconsole({ version: 'v1', auth: authClient });
         const endDate = new Date();
         const startDate = new Date();
-        startDate.setDate(endDate.getDate() - 7);
-        const toISODate = (value) => value.toISOString().slice(0, 10);
+        startDate.setDate(endDate.getDate() - settings.gsc.lookbackDays);
         const response = await searchConsole.searchanalytics.query({
-            siteUrl: site.canonicalHost,
+            siteUrl: siteURL,
             requestBody: {
                 startDate: toISODate(startDate),
                 endDate: toISODate(endDate),
                 dimensions: ['query', 'page'],
-                rowLimit: 250,
+                rowLimit: settings.gsc.rowLimit,
             },
         });
         const rows = response.data.rows || [];
@@ -63,7 +94,12 @@ const syncGSCKeywordVisibility = async ({ payload, site, }) => {
     }
     catch (error) {
         console.warn('GSC sync failed:', error);
-        return { imported: 0, enabled: true, skipped: 'request-failed' };
+        return {
+            imported: 0,
+            enabled: true,
+            skipped: 'request-failed',
+            error: error instanceof Error ? error.message : String(error),
+        };
     }
 };
 exports.syncGSCKeywordVisibility = syncGSCKeywordVisibility;

package/dist/utilities/integrationSettings.d.ts

@@ -0,0 +1,10 @@
+import type { Payload } from 'payload';
+import type { NormalizedSeoConfig } from '../config';
+import type { IntegrationSettings, SEOSiteRecord } from '../utilities/types';
+export declare const siteFromSeoConfig: (seoConfig: NormalizedSeoConfig) => SEOSiteRecord;
+export declare const resolveIntegrationSettings: ({ payload, site, seoConfig, }: {
+    payload: Payload;
+    site: SEOSiteRecord;
+    seoConfig: NormalizedSeoConfig;
+}) => Promise<IntegrationSettings>;
+//# sourceMappingURL=integrationSettings.d.ts.map

package/dist/utilities/integrationSettings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"integrationSettings.d.ts","sourceRoot":"","sources":["../../src/utilities/integrationSettings.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,SAAS,CAAA;AACtC,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,WAAW,CAAA;AACpD,OAAO,KAAK,EAMV,mBAAmB,EACnB,aAAa,EACd,MAAM,oBAAoB,CAAA;AA6C3B,eAAO,MAAM,iBAAiB,GAAI,WAAW,mBAAmB,KAAG,aAuBjE,CAAA;AA0DF,eAAO,MAAM,0BAA0B,GAAU,+BAI9C;IACD,OAAO,EAAE,OAAO,CAAA;IAChB,IAAI,EAAE,aAAa,CAAA;IACnB,SAAS,EAAE,mBAAmB,CAAA;CAC/B,KAAG,OAAO,CAAC,mBAAmB,CA2F9B,CAAA"}

package/dist/utilities/integrationSettings.js

@@ -0,0 +1,198 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveIntegrationSettings = exports.siteFromSeoConfig = void 0;
+const secrets_1 = require("../utilities/secrets");
+const defaultAuthorityPolicy = 'manual+scheduled';
+const asBoolean = (value, fallback) => typeof value === 'boolean' ? value : fallback;
+const asString = (value, fallback = '') => typeof value === 'string' ? value : fallback;
+const asNumber = (value, fallback) => {
+    const numeric = Number(value);
+    return Number.isFinite(numeric) ? numeric : fallback;
+};
+const normalizeCountryCode = (value) => value.trim().toUpperCase().slice(0, 2);
+const normalizeRunPolicy = (value) => {
+    if (value === 'scheduled-only' || value === 'all')
+        return value;
+    return defaultAuthorityPolicy;
+};
+const normalizeProvider = (value) => {
+    if (value === 'dataforseo')
+        return 'dataforseo';
+    return 'none';
+};
+const normalizeFormFactor = (value) => {
+    if (value === 'PHONE' || value === 'DESKTOP')
+        return value;
+    return 'ALL_FORM_FACTORS';
+};
+const normalizeScope = (value) => {
+    if (value === 'origin-only' || value === 'key-urls-only')
+        return value;
+    return 'origin+key-urls';
+};
+const normalizeAuthMode = (value) => {
+    if (value === 'service-account')
+        return 'service-account';
+    return 'oauth';
+};
+const normalizePrivateKey = (value) => value.replace(/\\n/g, '\n');
+const siteFromSeoConfig = (seoConfig) => ({
+    id: 1,
+    name: seoConfig.site.name,
+    domain: seoConfig.site.domain,
+    canonicalHost: seoConfig.site.canonicalHost,
+    sitemapURL: seoConfig.site.sitemapURL,
+    keyURLs: seoConfig.site.keyURLs.map((url) => ({ url })),
+    crawlSettings: {
+        maxPages: seoConfig.crawl.maxPages,
+        maxDepth: seoConfig.crawl.maxDepth,
+        requestTimeoutMs: seoConfig.crawl.requestTimeoutMs,
+        includePatterns: seoConfig.crawl.includePatterns.map((pattern) => ({ pattern })),
+        excludePatterns: seoConfig.crawl.excludePatterns.map((pattern) => ({ pattern })),
+    },
+    integrations: {
+        enablePageSpeed: seoConfig.integrations.enablePageSpeed,
+        enableSearchConsole: seoConfig.integrations.enableSearchConsole,
+        enableCrUX: seoConfig.integrations.enableCrUX,
+    },
+    thresholds: {
+        targetLCPMs: seoConfig.thresholds.targetLCPMs,
+        targetCLS: seoConfig.thresholds.targetCLS,
+    },
+});
+exports.siteFromSeoConfig = siteFromSeoConfig;
+const readEnvDefaults = ({ seoConfig, site, }) => {
+    const canonicalHost = site.canonicalHost || seoConfig.site.canonicalHost;
+    return {
+        source: 'env',
+        gsc: {
+            enabled: seoConfig.integrations.enableSearchConsole,
+            authMode: 'oauth',
+            siteUrlOverride: canonicalHost,
+            rowLimit: 250,
+            lookbackDays: 7,
+            oauthClientID: process.env.SEO_GSC_CLIENT_ID || '',
+            oauthClientSecret: process.env.SEO_GSC_CLIENT_SECRET || '',
+            oauthRedirectURI: process.env.SEO_GSC_REDIRECT_URI || '',
+            oauthRefreshToken: process.env.SEO_GSC_REFRESH_TOKEN || '',
+            serviceAccountEmail: process.env.GOOGLE_SERVICE_ACCOUNT_EMAIL || '',
+            serviceAccountPrivateKey: process.env.GOOGLE_SERVICE_ACCOUNT_PRIVATE_KEY || '',
+        },
+        pageSpeed: {
+            enabled: seoConfig.integrations.enablePageSpeed,
+            apiKey: process.env.SEO_PAGESPEED_API_KEY || process.env.GOOGLE_PAGESPEED_API_KEY || '',
+        },
+        crux: {
+            enabled: seoConfig.integrations.enableCrUX,
+            apiKey: process.env.SEO_CRUX_API_KEY || '',
+            queryScope: 'origin+key-urls',
+            formFactor: normalizeFormFactor(process.env.SEO_CRUX_FORM_FACTOR),
+            countryCode: normalizeCountryCode(process.env.SEO_CRUX_COUNTRY || ''),
+            lookbackWindowDays: 28,
+        },
+        authority: {
+            enabled: Boolean(process.env.SEO_PROVIDER && process.env.SEO_PROVIDER_API_KEY),
+            provider: normalizeProvider((process.env.SEO_PROVIDER || '').toLowerCase()),
+            captureTopBacklinksLimit: asNumber(process.env.SEO_DATAFORSEO_LIMIT, 100),
+            runPolicy: defaultAuthorityPolicy,
+            dataForSeoLogin: process.env.SEO_DATAFORSEO_LOGIN || '',
+            dataForSeoPassword: process.env.SEO_DATAFORSEO_PASSWORD || '',
+            dataForSeoBaseURL: process.env.SEO_DATAFORSEO_BASE_URL || 'https://api.dataforseo.com',
+        },
+        ops: {
+            enabled: Boolean(process.env.SEO_OPS_WEBHOOK_URL),
+            webhookURL: process.env.SEO_OPS_WEBHOOK_URL || '',
+            webhookSecret: process.env.SEO_OPS_WEBHOOK_SECRET || '',
+            sendPerRun: true,
+            sendMonthlyRollup: true,
+            lastRollupMonth: process.env.SEO_OPS_LAST_ROLLUP_MONTH || '',
+        },
+    };
+};
+const resolveIntegrationSettings = async ({ payload, site, seoConfig, }) => {
+    const envDefaults = readEnvDefaults({ seoConfig, site });
+    let globalDoc = null;
+    try {
+        const doc = (await payload.findGlobal({
+            slug: 'seo-integrations',
+            depth: 0,
+            overrideAccess: true,
+            req: {
+                context: {
+                    seoAuditInternal: true,
+                },
+            },
+        }));
+        globalDoc = (0, secrets_1.decryptSecretPaths)({
+            data: doc,
+            secretPaths: [
+                'gsc.oauthClientSecret',
+                'gsc.oauthRefreshToken',
+                'gsc.serviceAccountPrivateKey',
+                'pageSpeed.apiKey',
+                'crux.apiKey',
+                'authority.dataForSeoLogin',
+                'authority.dataForSeoPassword',
+                'ops.webhookSecret',
+            ],
+            payload,
+        });
+    }
+    catch {
+        globalDoc = null;
+    }
+    if (!globalDoc) {
+        return envDefaults;
+    }
+    const gsc = (globalDoc.gsc || {});
+    const pageSpeed = (globalDoc.pageSpeed || {});
+    const crux = (globalDoc.crux || {});
+    const authority = (globalDoc.authority || {});
+    const ops = (globalDoc.ops || {});
+    return {
+        source: 'global',
+        gsc: {
+            enabled: asBoolean(gsc.enabled, envDefaults.gsc.enabled),
+            authMode: normalizeAuthMode(gsc.authMode || envDefaults.gsc.authMode),
+            siteUrlOverride: asString(gsc.siteUrlOverride, envDefaults.gsc.siteUrlOverride),
+            rowLimit: Math.max(25, Math.min(25000, asNumber(gsc.rowLimit, envDefaults.gsc.rowLimit))),
+            lookbackDays: Math.max(1, Math.min(90, asNumber(gsc.lookbackDays, envDefaults.gsc.lookbackDays))),
+            oauthClientID: asString(gsc.oauthClientID, envDefaults.gsc.oauthClientID),
+            oauthClientSecret: asString(gsc.oauthClientSecret, envDefaults.gsc.oauthClientSecret),
+            oauthRedirectURI: asString(gsc.oauthRedirectURI, envDefaults.gsc.oauthRedirectURI),
+            oauthRefreshToken: asString(gsc.oauthRefreshToken, envDefaults.gsc.oauthRefreshToken),
+            serviceAccountEmail: asString(gsc.serviceAccountEmail, envDefaults.gsc.serviceAccountEmail),
+            serviceAccountPrivateKey: normalizePrivateKey(asString(gsc.serviceAccountPrivateKey, envDefaults.gsc.serviceAccountPrivateKey)),
+        },
+        pageSpeed: {
+            enabled: asBoolean(pageSpeed.enabled, envDefaults.pageSpeed.enabled),
+            apiKey: asString(pageSpeed.apiKey, envDefaults.pageSpeed.apiKey),
+        },
+        crux: {
+            enabled: asBoolean(crux.enabled, envDefaults.crux.enabled),
+            apiKey: asString(crux.apiKey, envDefaults.crux.apiKey),
+            queryScope: normalizeScope(crux.queryScope),
+            formFactor: normalizeFormFactor(crux.formFactor),
+            countryCode: normalizeCountryCode(asString(crux.countryCode, envDefaults.crux.countryCode)),
+            lookbackWindowDays: Math.max(1, Math.min(180, asNumber(crux.lookbackWindowDays, envDefaults.crux.lookbackWindowDays))),
+        },
+        authority: {
+            enabled: asBoolean(authority.enabled, envDefaults.authority.enabled),
+            provider: normalizeProvider(authority.provider),
+            captureTopBacklinksLimit: Math.max(10, Math.min(1000, asNumber(authority.captureTopBacklinksLimit, envDefaults.authority.captureTopBacklinksLimit))),
+            runPolicy: normalizeRunPolicy(authority.runPolicy),
+            dataForSeoLogin: asString(authority.dataForSeoLogin, envDefaults.authority.dataForSeoLogin),
+            dataForSeoPassword: asString(authority.dataForSeoPassword, envDefaults.authority.dataForSeoPassword),
+            dataForSeoBaseURL: asString(authority.dataForSeoBaseURL, envDefaults.authority.dataForSeoBaseURL),
+        },
+        ops: {
+            enabled: asBoolean(ops.enabled, envDefaults.ops.enabled),
+            webhookURL: asString(ops.webhookURL, envDefaults.ops.webhookURL),
+            webhookSecret: asString(ops.webhookSecret, envDefaults.ops.webhookSecret),
+            sendPerRun: asBoolean(ops.sendPerRun, true),
+            sendMonthlyRollup: asBoolean(ops.sendMonthlyRollup, true),
+            lastRollupMonth: asString(ops.lastRollupMonth, envDefaults.ops.lastRollupMonth),
+        },
+    };
+};
+exports.resolveIntegrationSettings = resolveIntegrationSettings;

package/dist/utilities/opsWebhook.d.ts

@@ -0,0 +1,15 @@
+import type { Payload } from 'payload';
+import type { AuthoritySyncResult, CrUXSyncResult, GSCSyncResult, IntegrationSettings } from '../utilities/types';
+export declare const notifyOpsForRun: ({ payload, settings, snapshotID, runType, siteName, pagesChecked, overallScore, gsc, crux, authority, }: {
+    payload: Payload;
+    settings: IntegrationSettings;
+    snapshotID: number | string;
+    runType: "manual" | "scheduled" | "publish-triggered";
+    siteName: string;
+    pagesChecked: number;
+    overallScore: number;
+    gsc: GSCSyncResult;
+    crux: CrUXSyncResult;
+    authority: AuthoritySyncResult;
+}) => Promise<void>;
+//# sourceMappingURL=opsWebhook.d.ts.map

package/dist/utilities/opsWebhook.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"opsWebhook.d.ts","sourceRoot":"","sources":["../../src/utilities/opsWebhook.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,SAAS,CAAA;AACtC,OAAO,KAAK,EAAE,mBAAmB,EAAE,cAAc,EAAE,aAAa,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAA;AA0CjH,eAAO,MAAM,eAAe,GAAU,yGAWnC;IACD,OAAO,EAAE,OAAO,CAAA;IAChB,QAAQ,EAAE,mBAAmB,CAAA;IAC7B,UAAU,EAAE,MAAM,GAAG,MAAM,CAAA;IAC3B,OAAO,EAAE,QAAQ,GAAG,WAAW,GAAG,mBAAmB,CAAA;IACrD,QAAQ,EAAE,MAAM,CAAA;IAChB,YAAY,EAAE,MAAM,CAAA;IACpB,YAAY,EAAE,MAAM,CAAA;IACpB,GAAG,EAAE,aAAa,CAAA;IAClB,IAAI,EAAE,cAAc,CAAA;IACpB,SAAS,EAAE,mBAAmB,CAAA;CAC/B,kBAqHA,CAAA"}

package/dist/utilities/opsWebhook.js

@@ -0,0 +1,130 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.notifyOpsForRun = void 0;
+const crypto_1 = __importDefault(require("crypto"));
+const signPayload = (secret, payload) => crypto_1.default.createHmac('sha256', secret).update(payload).digest('hex');
+const sendWebhook = async ({ url, secret, body, }) => {
+    const rawBody = JSON.stringify(body);
+    const headers = {
+        'content-type': 'application/json',
+    };
+    if (secret?.trim()) {
+        headers['x-seo-ops-signature'] = signPayload(secret, rawBody);
+    }
+    await fetch(url, {
+        method: 'POST',
+        cache: 'no-store',
+        headers,
+        body: rawBody,
+    });
+};
+const startOfMonth = (date) => new Date(Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), 1));
+const endOfMonth = (date) => new Date(Date.UTC(date.getUTCFullYear(), date.getUTCMonth() + 1, 1));
+const monthKey = (date) => `${date.getUTCFullYear()}-${String(date.getUTCMonth() + 1).padStart(2, '0')}`;
+const notifyOpsForRun = async ({ payload, settings, snapshotID, runType, siteName, pagesChecked, overallScore, gsc, crux, authority, }) => {
+    if (!settings.ops.enabled || !settings.ops.webhookURL.trim())
+        return;
+    const webhookURL = settings.ops.webhookURL.trim();
+    const webhookSecret = settings.ops.webhookSecret.trim();
+    if (settings.ops.sendPerRun) {
+        await sendWebhook({
+            url: webhookURL,
+            secret: webhookSecret,
+            body: {
+                event: 'seo.run.completed',
+                timestamp: new Date().toISOString(),
+                data: {
+                    snapshotID,
+                    runType,
+                    siteName,
+                    pagesChecked,
+                    overallScore,
+                    gsc,
+                    crux,
+                    authority,
+                },
+            },
+        });
+    }
+    if (!settings.ops.sendMonthlyRollup)
+        return;
+    const now = new Date();
+    const currentMonthKey = monthKey(now);
+    if (settings.ops.lastRollupMonth === currentMonthKey)
+        return;
+    const monthStart = startOfMonth(now);
+    const monthEnd = endOfMonth(now);
+    const snapshots = await payload.find({
+        collection: 'seo-snapshots',
+        where: {
+            and: [
+                {
+                    startedAt: {
+                        greater_than_equal: monthStart.toISOString(),
+                    },
+                },
+                {
+                    startedAt: {
+                        less_than: monthEnd.toISOString(),
+                    },
+                },
+                {
+                    status: {
+                        equals: 'completed',
+                    },
+                },
+            ],
+        },
+        limit: 500,
+        depth: 0,
+        overrideAccess: true,
+    });
+    const docs = snapshots.docs;
+    const totalRuns = docs.length;
+    const totalPagesChecked = docs.reduce((sum, snapshot) => sum + Number(snapshot?.metrics?.pagesChecked || 0), 0);
+    const avgOverallScore = totalRuns > 0
+        ? Number((docs.reduce((sum, snapshot) => sum + Number(snapshot?.scores?.overall || 0), 0) / totalRuns).toFixed(2))
+        : 0;
+    await sendWebhook({
+        url: webhookURL,
+        secret: webhookSecret,
+        body: {
+            event: 'seo.monthly.rollup',
+            timestamp: new Date().toISOString(),
+            data: {
+                month: currentMonthKey,
+                totalRuns,
+                totalPagesChecked,
+                avgOverallScore,
+            },
+        },
+    });
+    try {
+        const integrationsDoc = (await payload.findGlobal({
+            slug: 'seo-integrations',
+            depth: 0,
+            overrideAccess: true,
+            req: {
+                context: {
+                    seoAuditInternal: true,
+                },
+            },
+        }));
+        await payload.updateGlobal({
+            slug: 'seo-integrations',
+            data: {
+                ops: {
+                    ...(integrationsDoc?.ops || {}),
+                    lastRollupMonth: currentMonthKey,
+                },
+            },
+            overrideAccess: true,
+        });
+    }
+    catch {
+    }
+};
+exports.notifyOpsForRun = notifyOpsForRun;

package/dist/utilities/pagespeed.d.ts

@@ -1,3 +1,3 @@
 import type { SEOPageSpeedSummary } from '../utilities/types';
-export declare const getPageSpeedSummary: (urls: string[]) => Promise<SEOPageSpeedSummary | null>;
+export declare const getPageSpeedSummary: (urls: string[], explicitApiKey?: string) => Promise<SEOPageSpeedSummary | null>;
 //# sourceMappingURL=pagespeed.d.ts.map

package/dist/utilities/pagespeed.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pagespeed.d.ts","sourceRoot":"","sources":["../../src/utilities/pagespeed.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAA;AA2B7D,eAAO,MAAM,mBAAmB,GAAU,MAAM,MAAM,EAAE,KAAG,OAAO,CAAC,mBAAmB,GAAG,IAAI,CA4B5F,CAAA"}
+{"version":3,"file":"pagespeed.d.ts","sourceRoot":"","sources":["../../src/utilities/pagespeed.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAA;AA2B7D,eAAO,MAAM,mBAAmB,GAC9B,MAAM,MAAM,EAAE,EACd,iBAAiB,MAAM,KACtB,OAAO,CAAC,mBAAmB,GAAG,IAAI,CAuCpC,CAAA"}