@marvalt/digivalt-core 0.1.7 → 0.2.0

package/dist/services.cjs

@@ -0,0 +1,1339 @@
+'use strict';
+
+var wadapter = require('@marvalt/wadapter');
+var madapter = require('@marvalt/madapter');
+
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+const getImportMetaEnv = () => {
+    try {
+        return typeof ({ url: (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('services.cjs', document.baseURI).href)) }) !== 'undefined' ? undefined : undefined;
+    }
+    catch {
+        return undefined;
+    }
+};
+const getEnv = (key) => {
+    const viteEnv = getImportMetaEnv();
+    if (viteEnv && key in viteEnv) {
+        const value = viteEnv[key];
+        return value == null ? undefined : String(value);
+    }
+    if (typeof process !== 'undefined' && process.env && key in process.env) {
+        const value = process.env[key];
+        return value == null ? undefined : String(value);
+    }
+    return undefined;
+};
+const isDevEnvironment = () => {
+    const viteEnv = getImportMetaEnv();
+    if (viteEnv && 'DEV' in viteEnv) {
+        return Boolean(viteEnv.DEV);
+    }
+    return typeof process !== 'undefined' && process.env?.NODE_ENV === 'development';
+};
+const isLocalDevelopmentEnabled = () => {
+    return getEnv('VITE_LOCAL_DEVELOPMENT') === 'true';
+};
+
+const createLazyProxy = (factory) => new Proxy({}, {
+    get(_target, prop, receiver) {
+        const instance = factory();
+        const value = Reflect.get(instance, prop, receiver);
+        return typeof value === 'function' ? value.bind(instance) : value;
+    },
+    set(_target, prop, value, receiver) {
+        const instance = factory();
+        return Reflect.set(instance, prop, value, receiver);
+    },
+    has(_target, prop) {
+        const instance = factory();
+        return prop in instance;
+    },
+    ownKeys() {
+        const instance = factory();
+        return Reflect.ownKeys(instance);
+    },
+    getOwnPropertyDescriptor(_target, prop) {
+        const instance = factory();
+        return Object.getOwnPropertyDescriptor(instance, prop);
+    },
+});
+
+/**
+ * Gravity Forms Integration Service
+ * Uses @marvalt/wadapter package for secure form submissions
+ */
+// Convention-based: Uses /api/gravity-forms-submit by default.
+let gravityFormsClientInstance = null;
+const createGravityFormsClient = () => {
+    const config = {
+        apiUrl: getEnv('VITE_WORDPRESS_API_URL'),
+        authMode: 'direct',
+        timeout: 30000,
+        retries: 3,
+    };
+    return new wadapter.GravityFormsClient(config);
+};
+const getGravityFormsClient = () => {
+    if (!gravityFormsClientInstance) {
+        gravityFormsClientInstance = createGravityFormsClient();
+    }
+    return gravityFormsClientInstance;
+};
+const resetGravityFormsClient = () => {
+    gravityFormsClientInstance = null;
+};
+const gravityFormsClient = createLazyProxy(getGravityFormsClient);
+// Legacy service wrapper for backwards compatibility
+const gravityFormsService = {
+    /**
+     * Submit a Gravity Form (legacy interface)
+     * @param formId - Form ID as string or number
+     * @param entry - Entry data with field IDs as keys
+     * @param files - Optional files (not yet supported)
+     * @param useBasicApi - Ignored (always uses proxy)
+     */
+    async submitForm(formId, entry, files, useBasicApi) {
+        console.log('🔍 gravityFormsService.submitForm (legacy wrapper) called:', {
+            formId,
+            entry,
+            hasFiles: !!files,
+            useBasicApi,
+        });
+        if (files && Object.keys(files).length > 0) {
+            console.warn('⚠️ File uploads not yet supported in new Gravity Forms client');
+        }
+        // Convert to new API format
+        const formIdNumber = typeof formId === 'string' ? parseInt(formId, 10) : formId;
+        return getGravityFormsClient().submitForm(formIdNumber, {
+            form_id: formIdNumber,
+            field_values: entry,
+        });
+    },
+    // Pass through other methods
+    getForm: (id) => getGravityFormsClient().getForm(id),
+    getForms: () => getGravityFormsClient().getForms(),
+    getFormConfig: (id) => getGravityFormsClient().getFormConfig(id),
+    getHealth: () => getGravityFormsClient().getHealth(),
+};
+
+/**
+ * Mautic Integration Service (via @marvalt/madapter)
+ */
+// @ts-ignore - internal workspace type resolution
+// Convention-based: Uses /api/mautic-submit Pages Function for server-side OAuth2
+// The Pages Function handles authentication securely without exposing credentials to the browser.
+let mauticServiceInstance = null;
+const createMauticService = () => {
+    const useWranglerProxy = isDevEnvironment() && isLocalDevelopmentEnabled();
+    return new madapter.MauticClient({
+        apiUrl: getEnv('VITE_MAUTIC_URL'),
+        proxyEndpoint: useWranglerProxy
+            ? 'http://127.0.0.1:8788/api/mautic-submit'
+            : '/api/mautic-submit',
+    });
+};
+const getMauticService = () => {
+    if (!mauticServiceInstance) {
+        mauticServiceInstance = createMauticService();
+    }
+    return mauticServiceInstance;
+};
+const resetMauticService = () => {
+    mauticServiceInstance = null;
+};
+const mauticService = createLazyProxy(getMauticService);
+
+// Detect if we're running in a local development environment
+const isLocalDevelopment = () => {
+    // Check if we're in a browser environment
+    if (typeof window !== 'undefined') {
+        // Check for local development indicators
+        const isLocalhost = window.location.hostname === 'localhost' ||
+            window.location.hostname === '127.0.0.1' ||
+            window.location.hostname.includes('192.168.') ||
+            window.location.hostname.includes('10.0.');
+        const isDevPort = window.location.port === '3000' ||
+            window.location.port === '5173' ||
+            window.location.port === '8080';
+        const hasLocalEnv = Boolean(getEnv('DEV')) || getEnv('VITE_LOCAL_DEVELOPMENT') === 'true';
+        return Boolean(isLocalhost && (isDevPort || hasLocalEnv));
+    }
+    else {
+        // Node.js environment - check environment variables
+        return getEnv('NODE_ENV') === 'development' ||
+            getEnv('VITE_LOCAL_DEVELOPMENT') === 'true';
+    }
+};
+// Get the appropriate environment configuration
+const getEnvironmentConfig = () => {
+    const isLocal = isLocalDevelopment();
+    // Default to cloudflare_proxy (via Cloudflare Pages Functions)
+    // Use 'direct' only for local development with whitelisted IPs
+    const authModeRaw = getEnv('VITE_AUTH_MODE');
+    const authMode = authModeRaw || 'cloudflare_proxy';
+    // Reduced debug logging - only in development and only once
+    if (isDevEnvironment() && !authModeRaw) {
+        console.log('ℹ️ VITE_AUTH_MODE not set, defaulting to cloudflare_proxy (Cloudflare Pages Functions)');
+    }
+    // Validate auth mode value
+    if (authMode !== 'direct' && authMode !== 'cloudflare_proxy') {
+        console.error('❌ Invalid VITE_AUTH_MODE value. Must be "direct" or "cloudflare_proxy".');
+        return {
+            mode: 'error',
+            authMode: 'error',
+            dataSource: 'static',
+            baseUrl: '',
+            headers: {},
+            description: `Invalid configuration - VITE_AUTH_MODE="${authModeRaw}"`,
+            suiteCRM: {
+                url: undefined,
+                proxyUrl: undefined,
+                appId: undefined,
+                workerSecret: undefined,
+                oauth2: {
+                    clientId: undefined,
+                    clientSecret: undefined,
+                    tokenUrl: undefined,
+                    username: undefined,
+                    password: undefined,
+                },
+            }
+        };
+    }
+    // Cloudflare proxy mode (uses Cloudflare Pages Functions by default)
+    // Worker URL is optional - Pages Functions handle routing automatically
+    if (authMode === 'cloudflare_proxy') {
+        const workerUrl = getEnv('VITE_CLOUDFLARE_WORKER_URL');
+        // Cloudflare Pages Functions work without explicit worker URL
+        // The worker URL is only needed for separate Cloudflare Workers
+        // Pages Functions automatically handle /api/* routes
+        const baseUrl = workerUrl || '/api';
+        return {
+            mode: isLocal ? 'local' : 'remote',
+            authMode: 'cloudflare_proxy',
+            dataSource: 'static',
+            baseUrl,
+            headers: {
+                'Content-Type': 'application/json'
+            },
+            description: workerUrl
+                ? (isLocal ? 'Local development with Cloudflare Worker proxy' : 'Remote development with Cloudflare Worker proxy')
+                : (isLocal ? 'Local development with Cloudflare Pages Functions' : 'Production with Cloudflare Pages Functions'),
+            mautic: {
+                proxyUrl: getEnv('VITE_MAUTIC_PROXY_URL')
+            },
+            suiteCRM: {
+                url: getEnv('VITE_SUITECRM_URL'),
+                proxyUrl: getEnv('VITE_SUITECRM_PROXY_URL'),
+                appId: undefined,
+                workerSecret: undefined,
+                oauth2: {
+                    clientId: getEnv('VITE_SUITECRM_CLIENT_ID'),
+                    clientSecret: getEnv('VITE_SUITECRM_CLIENT_SECRET'),
+                    tokenUrl: getEnv('VITE_SUITECRM_TOKEN_URL'),
+                    username: getEnv('VITE_SUITECRM_USERNAME'),
+                    password: getEnv('VITE_SUITECRM_PASSWORD'),
+                },
+            }
+        };
+    }
+    // Direct WordPress mode (legacy - for local development only)
+    if (authMode === 'direct') {
+        const wpApiUrl = getEnv('VITE_WORDPRESS_API_URL');
+        if (!wpApiUrl) {
+            console.warn('⚠️ Direct mode requires: VITE_WORDPRESS_API_URL');
+            return {
+                mode: 'error',
+                authMode: 'error',
+                dataSource: 'static',
+                baseUrl: '',
+                headers: {},
+                description: 'Invalid configuration - missing WordPress API URL',
+                suiteCRM: {
+                    url: undefined,
+                    proxyUrl: undefined,
+                    appId: undefined,
+                    workerSecret: undefined,
+                    oauth2: {
+                        clientId: undefined,
+                        clientSecret: undefined,
+                        tokenUrl: undefined,
+                        username: undefined,
+                        password: undefined,
+                    },
+                }
+            };
+        }
+        if (isDevEnvironment()) {
+            console.log('🔍 Using direct WordPress mode (legacy - for local development only)');
+        }
+        const localDev = getEnv('VITE_LOCAL_DEVELOPMENT') === 'true';
+        return {
+            mode: localDev ? 'local' : 'remote',
+            authMode: 'direct',
+            dataSource: 'hybrid',
+            baseUrl: wpApiUrl,
+            headers: { 'Content-Type': 'application/json' },
+            description: localDev ? 'Direct (local dev) without Access' : 'Direct mode',
+            mautic: { url: getEnv('VITE_MAUTIC_URL') },
+            suiteCRM: {
+                url: getEnv('VITE_SUITECRM_URL'),
+                proxyUrl: getEnv('VITE_SUITECRM_PROXY_URL'),
+                appId: undefined,
+                workerSecret: undefined,
+                oauth2: {
+                    clientId: getEnv('VITE_SUITECRM_CLIENT_ID'),
+                    clientSecret: getEnv('VITE_SUITECRM_CLIENT_SECRET'),
+                    tokenUrl: getEnv('VITE_SUITECRM_TOKEN_URL'),
+                    username: getEnv('VITE_SUITECRM_USERNAME'),
+                    password: getEnv('VITE_SUITECRM_PASSWORD'),
+                },
+            }
+        };
+    }
+    // This should never be reached, but just in case
+    return {
+        mode: 'error',
+        authMode: 'error',
+        dataSource: 'static',
+        baseUrl: '',
+        headers: {},
+        description: 'Invalid configuration - unknown error',
+        suiteCRM: {
+            url: undefined,
+            proxyUrl: undefined,
+            appId: undefined,
+            workerSecret: undefined,
+            oauth2: {
+                clientId: undefined,
+                clientSecret: undefined,
+                tokenUrl: undefined,
+                username: undefined,
+                password: undefined,
+            },
+        }
+    };
+};
+// Environment status and diagnostics
+const getEnvironmentStatus = () => {
+    const config = getEnvironmentConfig();
+    const isLocal = isLocalDevelopment();
+    const authMode = getEnv('VITE_AUTH_MODE');
+    // Check if required credentials are available for each mode
+    const hasCloudflareCredentials = !!getEnv('VITE_CLOUDFLARE_WORKER_URL');
+    const hasWordPressApiUrl = !!getEnv('VITE_WORDPRESS_API_URL');
+    return {
+        currentConfig: config,
+        diagnostics: {
+            isLocalDevelopment: isLocal,
+            authMode: authMode,
+            hasCloudflareCredentials,
+            hasWordpressApiUrl: hasWordPressApiUrl,
+            cloudflareWorkerUrl: !!getEnv('VITE_CLOUDFLARE_WORKER_URL'),
+            cfAccessId: !!getEnv('VITE_CF_ACCESS_CLIENT_ID'),
+            cfAccessSecret: !!getEnv('VITE_CF_ACCESS_CLIENT_SECRET'),
+            mauticProxyUrl: !!getEnv('VITE_MAUTIC_PROXY_URL')
+        },
+        recommendations: {
+            // Only show recommendation if authMode is explicitly set to an invalid value
+            // Default is cloudflare_proxy, so no recommendation needed if not set
+            authMode: null, // Defaults to cloudflare_proxy, no warning needed
+            cloudflare: null // Pages Functions work without explicit worker URL
+        }
+    };
+};
+// Export current environment config as default
+getEnvironmentConfig();
+getEnvironmentStatus();
+
+/**
+ * Integration Configuration
+ * Centralized configuration for all third-party integrations
+ */
+/**
+ * Get integration configuration with environment variable fallbacks
+ */
+function getIntegrationConfig() {
+    isDevEnvironment();
+    return {
+        wordpress: {
+            enabled: true,
+            apiUrl: getEnv('VITE_WORDPRESS_API_URL') || '',
+            authMode: getEnv('VITE_AUTH_MODE') || 'direct',
+        },
+        supabase: {
+            enabled: getEnv('VITE_AUTH_MODE') === 'supabase_proxy',
+            url: getEnv('VITE_SUPABASE_URL') || '',
+            anonKey: getEnv('VITE_SUPABASE_ANON_KEY') || '',
+            serviceRoleKey: getEnv('VITE_SUPABASE_SERVICE_ROLE_KEY'),
+        },
+        gravityForms: {
+            enabled: !!(getEnv('VITE_CLOUDFLARE_WORKER_URL') || getEnv('VITE_WORDPRESS_API_URL')),
+            url: getEnv('VITE_WORDPRESS_API_URL'),
+            proxyUrl: getEnv('VITE_CLOUDFLARE_WORKER_URL'),
+            consumerKey: getEnv('VITE_GF_CONSUMER_KEY'),
+            consumerSecret: getEnv('VITE_GF_CONSUMER_SECRET'),
+            forms: {
+                'contact': {
+                    name: 'Contact Form',
+                    type: 'contact',
+                    successMessage: 'Thank you for your message. We\'ll get back to you soon!',
+                },
+                'newsletter': {
+                    name: 'Newsletter Signup',
+                    type: 'newsletter',
+                    successMessage: 'Thank you for subscribing to our newsletter!',
+                },
+                'support': {
+                    name: 'Support Request',
+                    type: 'support',
+                    successMessage: 'Your support request has been submitted successfully.',
+                },
+            },
+        },
+        mautic: {
+            enabled: !!(getEnv('VITE_MAUTIC_PROXY_URL') || getEnv('VITE_MAUTIC_URL')),
+            url: getEnv('VITE_MAUTIC_URL') || '',
+            proxyUrl: getEnv('VITE_MAUTIC_PROXY_URL'),
+            forms: {
+                '1': {
+                    name: 'Newsletter Signup',
+                    type: 'newsletter',
+                    successMessage: 'Thank you for subscribing to our newsletter!',
+                    postAction: 'message',
+                    postActionProperty: 'Thank you for your submission!'
+                },
+                '2': {
+                    name: 'Contact Form',
+                    type: 'contact',
+                    successMessage: 'Thank you for contacting us! We\'ll get back to you soon.',
+                    postAction: 'message',
+                    postActionProperty: 'Thank you for your message!'
+                },
+                '3': {
+                    name: 'Lead Capture',
+                    type: 'lead',
+                    successMessage: 'Thank you for your interest! We\'ll be in touch.',
+                    postAction: 'message',
+                    postActionProperty: 'Thank you for your submission!'
+                }
+            }
+        },
+        suiteCRM: {
+            enabled: !!(getEnv('VITE_SUITECRM_URL') && getEnv('VITE_SUITECRM_CLIENT_ID') && getEnv('VITE_SUITECRM_CLIENT_SECRET')),
+            url: getEnv('VITE_SUITECRM_URL'),
+            proxyUrl: getEnv('VITE_SUITECRM_PROXY_URL'),
+            appId: undefined,
+            workerSecret: undefined,
+            oauth2: {
+                clientId: getEnv('VITE_SUITECRM_CLIENT_ID'),
+                clientSecret: getEnv('VITE_SUITECRM_CLIENT_SECRET'),
+                username: getEnv('VITE_SUITECRM_USERNAME'),
+                password: getEnv('VITE_SUITECRM_PASSWORD'),
+            },
+        },
+        chatwoot: {
+            enabled: !!(getEnv('VITE_CHATWOOT_WEBSITE_TOKEN') && getEnv('VITE_CHATWOOT_BASE_URL')),
+            websiteToken: getEnv('VITE_CHATWOOT_WEBSITE_TOKEN') || '',
+            baseUrl: getEnv('VITE_CHATWOOT_BASE_URL') || '',
+            locale: 'en',
+            type: 'standard',
+            launcherTitle: 'Chat',
+            hideMessageBubble: false,
+            position: 'right',
+            showPopoutButton: false,
+        },
+        analytics: {
+            googleAnalytics: { enabled: false },
+            googleTagManager: { enabled: false },
+            facebookPixel: { enabled: false },
+            linkedinInsight: { enabled: false },
+        },
+        seo: {
+            defaultTitle: '',
+            defaultDescription: '',
+            defaultImage: '',
+            siteName: '',
+            siteUrl: '',
+        },
+        performance: {
+            enableLazyLoading: true,
+            enableImageOptimization: true,
+            enableCodeSplitting: true,
+            enableServiceWorker: false,
+            enableCaching: true,
+        }
+    };
+}
+function getSuiteCRMConfig() {
+    return getIntegrationConfig().suiteCRM;
+}
+
+// @ts-nocheck
+/**
+ * Password utility functions for handling special characters
+ */
+/**
+ * Safely encode a password for API requests
+ * Handles special characters like $, @, #, %, etc.
+ */
+function encodePassword(password) {
+    if (!password)
+        return '';
+    // For JSON requests, we don't need to encode the password
+    // The JSON.stringify() will handle special characters properly
+    return password;
+}
+/**
+ * Validate password for common issues
+ */
+function validatePassword(password) {
+    const issues = [];
+    if (!password) {
+        issues.push('Password is empty');
+    }
+    if (password.length < 1) {
+        issues.push('Password is too short');
+    }
+    // Check for potentially problematic characters
+    const problematicChars = ['$', '@', '#', '%', '&', '*', '(', ')', '[', ']', '{', '}', '|', '\\', '`', '~'];
+    const foundChars = problematicChars.filter(char => password.includes(char));
+    if (foundChars.length > 0) {
+        issues.push(`Password contains potentially problematic characters: ${foundChars.join(', ')}`);
+    }
+    return {
+        isValid: issues.length === 0,
+        issues
+    };
+}
+/**
+ * Get password encoding recommendations
+ */
+function getPasswordRecommendations(password) {
+    const recommendations = [];
+    if (password.includes('$')) {
+        recommendations.push('The $ character in passwords can cause issues in some contexts. Consider using a different character or ensure proper encoding.');
+    }
+    if (password.includes('@')) {
+        recommendations.push('The @ character might be interpreted as email syntax in some contexts.');
+    }
+    if (password.includes('#')) {
+        recommendations.push('The # character might be interpreted as a URL fragment in some contexts.');
+    }
+    if (password.includes('%')) {
+        recommendations.push('The % character might be interpreted as URL encoding in some contexts.');
+    }
+    if (password.length < 8) {
+        recommendations.push('Consider using a longer password for better security.');
+    }
+    return recommendations;
+}
+
+class SuiteCRMService {
+    baseUrl;
+    proxyUrl;
+    appId;
+    workerSecret;
+    useProxy;
+    isConfigured;
+    oauth2Config;
+    accessToken;
+    tokenExpiresAt;
+    sessionId;
+    csrfToken;
+    constructor() {
+        // Get environment configuration
+        const envConfig = getEnvironmentConfig();
+        const suitecrm = getSuiteCRMConfig();
+        if (undefined.DEV) {
+            console.log('🔍 SuiteCRM Service Auth Mode Debug:', {
+                authMode: envConfig.authMode,
+                hasSuiteCRMConfig: !!suitecrm,
+                hasEnvSuiteCRM: !!envConfig.suiteCRM,
+                suitecrmConfig: suitecrm ? {
+                    hasUrl: !!suitecrm.url,
+                    hasProxyUrl: !!suitecrm.proxyUrl,
+                    hasAppId: !!suitecrm.appId,
+                    hasWorkerSecret: !!suitecrm.workerSecret,
+                    hasOAuth2: !!(suitecrm.oauth2?.clientId && suitecrm.oauth2?.clientSecret)
+                } : null,
+                envSuiteCRM: envConfig.suiteCRM ? {
+                    hasUrl: !!envConfig.suiteCRM.url,
+                    hasProxyUrl: !!envConfig.suiteCRM.proxyUrl,
+                    hasAppId: !!envConfig.suiteCRM.appId,
+                    hasWorkerSecret: !!envConfig.suiteCRM.workerSecret,
+                    hasOAuth2: !!(envConfig.suiteCRM.oauth2?.clientId && envConfig.suiteCRM.oauth2?.clientSecret)
+                } : null
+            });
+        }
+        if (envConfig.authMode === 'cloudflare_proxy' && (suitecrm || envConfig.suiteCRM)) {
+            // Cloudflare Worker proxy (recommended - uses Secrets Store)
+            const config = suitecrm || envConfig.suiteCRM;
+            this.proxyUrl = config?.proxyUrl;
+            this.appId = undefined;
+            this.workerSecret = undefined;
+            this.useProxy = true;
+            this.isConfigured = !!this.proxyUrl;
+            if (undefined.DEV) {
+                console.log('🔍 SuiteCRM Service: Using Cloudflare Worker proxy (Secrets Store)');
+                console.log('🔍 Constructor Debug:', {
+                    proxyUrl: this.proxyUrl,
+                    appId: this.appId,
+                    hasWorkerSecret: !!this.workerSecret,
+                    workerSecretLength: this.workerSecret?.length,
+                    isConfigured: this.isConfigured
+                });
+            }
+        }
+        else if (envConfig.authMode === 'direct' && (suitecrm || envConfig.suiteCRM)) {
+            // Direct SuiteCRM API access with OAuth2
+            const config = suitecrm || envConfig.suiteCRM;
+            this.baseUrl = config?.url || '';
+            this.useProxy = false;
+            this.oauth2Config = config?.oauth2;
+            this.isConfigured = !!(this.baseUrl && config?.oauth2?.clientId && config?.oauth2?.clientSecret && config?.oauth2?.username && config?.oauth2?.password);
+            if (undefined.DEV) {
+                console.log('🔍 SuiteCRM Service: Using direct SuiteCRM API access with OAuth2');
+                console.log('🔍 OAuth2 Config:', {
+                    hasClientId: !!this.oauth2Config?.clientId,
+                    hasClientSecret: !!this.oauth2Config?.clientSecret,
+                    hasUsername: !!this.oauth2Config?.username,
+                    hasPassword: !!this.oauth2Config?.password
+                });
+            }
+        }
+        else {
+            // Fallback or error state
+            this.useProxy = false;
+            this.isConfigured = false;
+            if (undefined.DEV) {
+                console.warn('⚠️ SuiteCRM Service: No valid configuration found');
+            }
+        }
+    }
+    validateConfiguration() {
+        if (!this.isConfigured) {
+            throw new Error('SuiteCRM service is not properly configured');
+        }
+    }
+    async getSessionAndCSRFToken() {
+        // Check if we have valid session and CSRF token
+        if (this.sessionId && this.csrfToken) {
+            return { sessionId: this.sessionId, csrfToken: this.csrfToken };
+        }
+        if (undefined.DEV) {
+            console.log('🔍 Starting session and CSRF token extraction...');
+        }
+        try {
+            // Step 1: Get initial session by accessing the login page
+            const loginResponse = await fetch(`${this.baseUrl}/`, {
+                method: 'GET',
+                headers: {
+                    'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
+                    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
+                }
+            });
+            if (undefined.DEV) {
+                console.log('📊 Login response status:', loginResponse.status);
+                console.log('📊 Login response ok:', loginResponse.ok);
+            }
+            if (!loginResponse.ok) {
+                throw new Error(`Failed to access SuiteCRM login page: ${loginResponse.status}`);
+            }
+            // Extract session ID from cookies
+            const cookies = loginResponse.headers.get('set-cookie');
+            if (undefined.DEV) {
+                console.log('🍪 Set-Cookie header:', cookies);
+            }
+            if (cookies) {
+                // Try SCRMSESSID first (SuiteCRM specific)
+                const sessionMatch = cookies.match(/SCRMSESSID=([^;]+)/);
+                if (sessionMatch) {
+                    this.sessionId = sessionMatch[1];
+                    if (undefined.DEV) {
+                        console.log('✅ Found SCRMSESSID:', this.sessionId);
+                    }
+                }
+                else {
+                    if (undefined.DEV) {
+                        console.log('❌ SCRMSESSID not found in cookies');
+                    }
+                    // Fallback to PHPSESSID
+                    const phpSessionMatch = cookies.match(/PHPSESSID=([^;]+)/);
+                    if (phpSessionMatch) {
+                        this.sessionId = phpSessionMatch[1];
+                        if (undefined.DEV) {
+                            console.log('✅ Found PHPSESSID:', this.sessionId);
+                        }
+                    }
+                    else {
+                        if (undefined.DEV) {
+                            console.log('❌ PHPSESSID not found in cookies');
+                        }
+                    }
+                }
+            }
+            else {
+                if (undefined.DEV) {
+                    console.log('❌ No set-cookie header found');
+                }
+            }
+            // Step 2: Extract CSRF token from cookies (XSRF-TOKEN)
+            if (cookies) {
+                const xsrfMatch = cookies.match(/XSRF-TOKEN=([^;]+)/);
+                if (xsrfMatch) {
+                    this.csrfToken = xsrfMatch[1];
+                    if (undefined.DEV) {
+                        console.log('✅ Found XSRF-TOKEN:', this.csrfToken);
+                    }
+                }
+                else {
+                    if (undefined.DEV) {
+                        console.log('❌ XSRF-TOKEN not found in cookies');
+                    }
+                }
+            }
+            // If not found in cookies, try HTML
+            if (!this.csrfToken) {
+                if (undefined.DEV) {
+                    console.log('🔍 Trying to extract CSRF token from HTML...');
+                }
+                const loginHtml = await loginResponse.text();
+                const csrfMatch = loginHtml.match(/name="csrf_token" value="([^"]+)"/);
+                if (csrfMatch) {
+                    this.csrfToken = csrfMatch[1];
+                    if (undefined.DEV) {
+                        console.log('✅ Found csrf_token in HTML:', this.csrfToken);
+                    }
+                }
+                else {
+                    if (undefined.DEV) {
+                        console.log('❌ csrf_token not found in HTML');
+                    }
+                }
+            }
+            if (undefined.DEV) {
+                console.log('📋 Final Summary:');
+                console.log('Session ID:', this.sessionId ? '✅ Found' : '❌ Not found');
+                console.log('CSRF Token:', this.csrfToken ? '✅ Found' : '❌ Not found');
+            }
+            if (!this.sessionId || !this.csrfToken) {
+                throw new Error('Failed to obtain session ID or CSRF token from SuiteCRM');
+            }
+            if (undefined.DEV) {
+                console.log('🔑 Session and CSRF token obtained:', {
+                    sessionId: this.sessionId ? 'SET' : 'NOT SET',
+                    csrfToken: this.csrfToken ? 'SET' : 'NOT SET'
+                });
+            }
+            return { sessionId: this.sessionId, csrfToken: this.csrfToken };
+        }
+        catch (error) {
+            if (undefined.DEV) {
+                console.error('❌ Error in getSessionAndCSRFToken:', error);
+                console.error('Error details:', {
+                    message: error.message,
+                    stack: error.stack,
+                    name: error.name
+                });
+            }
+            throw error;
+        }
+    }
+    async getAccessToken() {
+        if (!this.oauth2Config) {
+            throw new Error('OAuth2 configuration not available');
+        }
+        // Check if we have a valid cached token
+        if (this.accessToken && this.tokenExpiresAt && Date.now() < this.tokenExpiresAt - 300000) {
+            return this.accessToken;
+        }
+        // Request new OAuth2 token using password grant
+        const tokenUrl = `${this.baseUrl}/Api/access_token`;
+        // Ensure password is properly handled for special characters
+        const rawPassword = this.oauth2Config.password || '';
+        const password = encodePassword(rawPassword);
+        // Validate password and log warnings
+        const passwordValidation = validatePassword(rawPassword);
+        if (!passwordValidation.isValid && undefined.DEV) {
+            console.warn('⚠️ Password validation issues:', passwordValidation.issues);
+        }
+        const recommendations = getPasswordRecommendations(rawPassword);
+        if (recommendations.length > 0 && undefined.DEV) {
+            console.warn('💡 Password recommendations:', recommendations);
+        }
+        const tokenData = {
+            grant_type: 'password',
+            client_id: this.oauth2Config.clientId,
+            client_secret: this.oauth2Config.clientSecret,
+            username: this.oauth2Config.username,
+            password: password,
+        };
+        if (undefined.DEV) {
+            console.log('🔑 Requesting OAuth2 token with password grant:', {
+                tokenUrl,
+                clientId: tokenData.client_id,
+                username: tokenData.username,
+                hasPassword: !!tokenData.password
+            });
+        }
+        const response = await fetch(tokenUrl, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify(tokenData),
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            throw new Error(`OAuth2 token request failed: ${response.status} - ${errorText}`);
+        }
+        const tokenResponse = await response.json();
+        if (undefined.DEV) {
+            console.log('🔑 OAuth2 token obtained:', {
+                tokenType: tokenResponse.token_type,
+                expiresIn: tokenResponse.expires_in
+            });
+        }
+        this.accessToken = tokenResponse.access_token || '';
+        this.tokenExpiresAt = Date.now() + (tokenResponse.expires_in * 1000);
+        return this.accessToken || '';
+    }
+    async getAuthHeaders() {
+        if (this.useProxy) {
+            return {
+                'Content-Type': 'application/json'
+            };
+        }
+        else {
+            // Direct SuiteCRM API access with OAuth2 Bearer token
+            if (this.oauth2Config) {
+                const accessToken = await this.getAccessToken();
+                return {
+                    'Content-Type': 'application/json',
+                    'Accept': 'application/json',
+                    'Authorization': `Bearer ${accessToken}`
+                };
+            }
+            else {
+                // Fallback to session-based authentication
+                const { sessionId, csrfToken } = await this.getSessionAndCSRFToken();
+                return {
+                    'Content-Type': 'application/json',
+                    'Accept': 'application/json',
+                    'X-CSRF-Token': csrfToken,
+                    'Cookie': `SCRMSESSID=${sessionId}`
+                };
+            }
+        }
+    }
+    async makeRequest(endpoint, options = {}) {
+        this.validateConfiguration();
+        const headers = {
+            ...(await this.getAuthHeaders()),
+            ...options.headers
+        };
+        let url;
+        if (this.useProxy) {
+            // Use Cloudflare Worker proxy - pass endpoint as query parameter
+            const queryParams = new URLSearchParams({ endpoint });
+            url = `${this.proxyUrl}?${queryParams.toString()}`;
+        }
+        else {
+            // Direct SuiteCRM API access
+            const directUrl = `${this.baseUrl}/api${endpoint}`;
+            const localDev = undefined.VITE_LOCAL_DEVELOPMENT === 'true';
+            const shouldUseAccess = !localDev && undefined.VITE_AUTH_MODE === 'direct'
+                && !!undefined.VITE_CF_ACCESS_CLIENT_ID && !!undefined.VITE_CF_ACCESS_CLIENT_SECRET;
+            url = shouldUseAccess ? `/api/fetch-with-access?target=${encodeURIComponent(directUrl)}` : directUrl;
+        }
+        if (undefined.DEV) {
+            console.log(`🔗 SuiteCRM API Request: ${options.method || 'GET'} ${url}`);
+            console.log('🔑 Headers:', Object.keys(headers).map(k => `${k}: ${headers[k] ? '***' : 'undefined'}`).join(', '));
+        }
+        const response = await fetch(url, {
+            ...options,
+            headers
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            console.error('❌ SuiteCRM API Error:', response.status, errorText);
+            throw new Error(`SuiteCRM API error: ${response.status} - ${errorText}`);
+        }
+        const data = await response.json();
+        if (undefined.DEV) {
+            console.log('✅ SuiteCRM API Response:', data);
+        }
+        return data;
+    }
+    // Check if SuiteCRM is configured
+    isServiceConfigured() {
+        return this.isConfigured;
+    }
+    // Lead Management
+    async createLead(lead) {
+        if (undefined.DEV) {
+            console.log('🚀 Starting lead creation for:', lead.first_name, lead.last_name);
+        }
+        // Use REST API by default since GraphQL has permission issues
+        // GraphQL can be used later when permissions are resolved
+        return this.createLeadREST(lead);
+    }
+    async createLeadREST(lead) {
+        if (undefined.DEV) {
+            console.log('🔍 Attempting REST API lead creation...');
+        }
+        const leadData = {
+            data: {
+                type: 'Leads',
+                attributes: {
+                    first_name: lead.first_name,
+                    last_name: lead.last_name,
+                    email1: lead.email1,
+                    phone_work: lead.phone_work,
+                    lead_source: lead.lead_source || 'Website',
+                    status: lead.status || 'New',
+                    description: lead.description,
+                    campaign_id: lead.campaign_id
+                }
+            }
+        };
+        const result = await this.makeRequest('/legacy/Api/V8/module', {
+            method: 'POST',
+            body: JSON.stringify(leadData),
+        });
+        if (undefined.DEV) {
+            console.log('✅ REST API lead creation successful:', result);
+        }
+        return result;
+    }
+    async verifyLeadCreation(email, firstName, lastName) {
+        try {
+            if (undefined.DEV) {
+                console.log('🔍 Verifying lead creation for:', email);
+            }
+            // Try to get all leads and filter client-side since SuiteCRM filter syntax is complex
+            const result = await this.makeRequest('/legacy/Api/V8/module/Leads');
+            if (result.data && Array.isArray(result.data)) {
+                // Check if any lead matches the email and name
+                const matchingLead = result.data.find((lead) => lead.attributes?.email1 === email &&
+                    lead.attributes?.first_name === firstName &&
+                    lead.attributes?.last_name === lastName);
+                if (undefined.DEV) {
+                    console.log('✅ Lead verification result:', !!matchingLead);
+                    console.log('🔍 Found leads:', result.data.length);
+                    console.log('🔍 Matching lead:', matchingLead);
+                }
+                return !!matchingLead;
+            }
+            return false;
+        }
+        catch (error) {
+            if (undefined.DEV) {
+                console.log('❌ Lead verification failed:', error);
+            }
+            return false;
+        }
+    }
+    async getLead(leadId) {
+        return this.makeRequest(`/legacy/Api/V8/module/Leads/${leadId}`);
+    }
+    async updateLead(leadId, lead) {
+        const leadData = {
+            data: {
+                type: 'Leads',
+                id: leadId,
+                attributes: lead
+            }
+        };
+        return this.makeRequest(`/legacy/Api/V8/module/Leads/${leadId}`, {
+            method: 'PATCH',
+            body: JSON.stringify(leadData),
+        });
+    }
+    async getLeads(params = {}) {
+        const queryParams = new URLSearchParams();
+        if (params.page)
+            queryParams.append('page[number]', params.page.toString());
+        if (params.per_page)
+            queryParams.append('page[size]', params.per_page.toString());
+        if (params.filter)
+            queryParams.append('filter', params.filter);
+        if (params.sort)
+            queryParams.append('sort', params.sort);
+        const queryString = queryParams.toString();
+        const endpoint = queryString ? `/legacy/Api/V8/module/Leads?${queryString}` : '/legacy/Api/V8/module/Leads';
+        return this.makeRequest(endpoint);
+    }
+    // Contact Management
+    async createContact(contact) {
+        const contactData = {
+            data: {
+                type: 'Contacts',
+                attributes: contact
+            }
+        };
+        return this.makeRequest('/contacts', {
+            method: 'POST',
+            body: JSON.stringify(contactData),
+        });
+    }
+    async getContact(contactId) {
+        return this.makeRequest(`/contacts/${contactId}`);
+    }
+    async updateContact(contactId, contact) {
+        const contactData = {
+            data: {
+                type: 'Contacts',
+                id: contactId,
+                attributes: contact
+            }
+        };
+        return this.makeRequest(`/contacts/${contactId}`, {
+            method: 'PATCH',
+            body: JSON.stringify(contactData),
+        });
+    }
+    // Account Management
+    async createAccount(account) {
+        const accountData = {
+            data: {
+                type: 'Accounts',
+                attributes: account
+            }
+        };
+        return this.makeRequest('/accounts', {
+            method: 'POST',
+            body: JSON.stringify(accountData),
+        });
+    }
+    async getAccount(accountId) {
+        return this.makeRequest(`/accounts/${accountId}`);
+    }
+    // Opportunity Management
+    async createOpportunity(opportunity) {
+        const opportunityData = {
+            data: {
+                type: 'Opportunities',
+                attributes: opportunity
+            }
+        };
+        return this.makeRequest('/opportunities', {
+            method: 'POST',
+            body: JSON.stringify(opportunityData),
+        });
+    }
+    async getOpportunity(opportunityId) {
+        return this.makeRequest(`/opportunities/${opportunityId}`);
+    }
+    // Search and Filter
+    async searchLeads(query) {
+        const searchParams = new URLSearchParams({
+            filter: `contains(first_name,"${query}") or contains(last_name,"${query}") or contains(email1,"${query}")`
+        });
+        return this.makeRequest(`/legacy/Api/V8/module/Leads?${searchParams.toString()}`);
+    }
+    // Utility Methods
+    async getLeadSources() {
+        return this.makeRequest('/enum/lead_sources');
+    }
+    async getLeadStatuses() {
+        return this.makeRequest('/enum/lead_statuses');
+    }
+    // GraphQL support for SuiteCRM 8.8.0+
+    async graphqlRequest(query, variables) {
+        this.validateConfiguration();
+        const headers = await this.getAuthHeaders();
+        // Use the correct endpoint based on mode
+        let url;
+        if (this.useProxy) {
+            // Use Cloudflare Worker proxy for GraphQL - pass endpoint as query parameter
+            const queryParams = new URLSearchParams({ endpoint: '/Api/graphql' });
+            url = `${this.proxyUrl}?${queryParams.toString()}`;
+        }
+        else {
+            // Direct SuiteCRM API access
+            url = `${this.baseUrl}/Api/graphql`;
+        }
+        if (undefined.DEV) {
+            console.log(`🔗 SuiteCRM GraphQL Request: POST ${url}`);
+            console.log('📝 Query:', query);
+            console.log('🔧 Variables:', variables);
+            console.log('🔑 Headers:', Object.keys(headers).map(k => `${k}: ${headers[k] ? '***' : 'undefined'}`).join(', '));
+        }
+        const response = await fetch(url, {
+            method: 'POST',
+            headers,
+            body: JSON.stringify({
+                query,
+                variables
+            })
+        });
+        if (!response.ok) {
+            const errorText = await response.text();
+            console.error('❌ SuiteCRM GraphQL Error:', response.status, errorText);
+            throw new Error(`SuiteCRM GraphQL error: ${response.status} - ${errorText}`);
+        }
+        const data = await response.json();
+        if (undefined.DEV) {
+            console.log('✅ SuiteCRM GraphQL Response:', data);
+        }
+        return data;
+    }
+    // Test connection with GraphQL
+    async testConnection() {
+        try {
+            // Try GraphQL first
+            const graphqlQuery = `
+        query TestConnection {
+          __schema {
+            types {
+              name
+            }
+          }
+        }
+      `;
+            await this.graphqlRequest(graphqlQuery);
+            return true;
+        }
+        catch (graphqlError) {
+            console.log('GraphQL test failed, trying REST API:', graphqlError);
+            try {
+                // Fallback to REST API
+                await this.makeRequest('/leads?page[size]=1');
+                return true;
+            }
+            catch (restError) {
+                console.error('❌ SuiteCRM connection test failed:', { graphqlError, restError });
+                return false;
+            }
+        }
+    }
+    // Simple Lead Creation - Create new lead directly
+    async createLeadSimple(leadData) {
+        if (undefined.DEV) {
+            console.log('🚀 Creating new lead for:', leadData.first_name, leadData.last_name, leadData.email1);
+        }
+        try {
+            const result = await this.createLeadREST(leadData);
+            if (undefined.DEV) {
+                console.log('✅ Lead created successfully');
+            }
+            return {
+                data: result.data,
+                meta: { action: 'lead_created' }
+            };
+        }
+        catch (error) {
+            if (undefined.DEV) {
+                console.error('❌ Lead creation failed:', error);
+            }
+            throw error;
+        }
+    }
+}
+let suitecrmServiceInstance = null;
+const getSuiteCRMService = () => {
+    if (!suitecrmServiceInstance) {
+        suitecrmServiceInstance = new SuiteCRMService();
+    }
+    return suitecrmServiceInstance;
+};
+const resetSuiteCRMService = () => {
+    suitecrmServiceInstance = null;
+};
+const suitecrmService = createLazyProxy(getSuiteCRMService);
+
+/**
+ * Cloudflare WordPress Webhook Service
+ * Handles webhook status and data regeneration monitoring
+ */
+class CfWpWebhookService {
+    baseUrl;
+    refreshSecret;
+    constructor() {
+        this.baseUrl = getEnv('VITE_WORDPRESS_API_URL') || '';
+        this.refreshSecret = getEnv('VITE_WP_REFRESH_SECRET') || '';
+        if (!this.refreshSecret) {
+            console.warn('⚠️ VITE_WP_REFRESH_SECRET not configured - webhook authentication will fail');
+        }
+    }
+    /**
+     * Get webhook status from WordPress
+     */
+    async getWebhookStatus() {
+        try {
+            const response = await fetch(`${this.baseUrl}/wp-json/cf-wp/v1/webhook-status`, {
+                method: 'GET',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Authorization': `Bearer ${this.refreshSecret}`
+                }
+            });
+            if (!response.ok) {
+                throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+            }
+            return await response.json();
+        }
+        catch (error) {
+            console.error('Failed to fetch webhook status:', error);
+            return {
+                last_triggered: null,
+                last_success: null,
+                last_error: error instanceof Error ? error.message : 'Unknown error',
+                total_triggers: 0,
+                success_rate: 0,
+                status: 'error'
+            };
+        }
+    }
+    /**
+     * Get webhook configuration from WordPress
+     */
+    async getWebhookConfig() {
+        try {
+            const response = await fetch(`${this.baseUrl}/wp-json/cf-wp/v1/webhook-config`, {
+                method: 'GET',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Authorization': `Bearer ${this.refreshSecret}`
+                }
+            });
+            if (!response.ok) {
+                throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+            }
+            return await response.json();
+        }
+        catch (error) {
+            console.error('Failed to fetch webhook config:', error);
+            return null;
+        }
+    }
+    /**
+     * Test webhook endpoint
+     */
+    async testWebhook() {
+        try {
+            const testPayload = {
+                post_id: 0,
+                post_type: 'test',
+                action: 'test',
+                timestamp: new Date().toISOString(),
+                frontend_id: 'test'
+            };
+            const response = await fetch('/api/webhook-test', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Authorization': `Bearer ${this.refreshSecret}`
+                },
+                body: JSON.stringify(testPayload)
+            });
+            if (!response.ok) {
+                throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+            }
+            const result = await response.json();
+            return {
+                success: result.success,
+                message: result.message || 'Webhook test completed'
+            };
+        }
+        catch (error) {
+            console.error('Webhook test failed:', error);
+            return {
+                success: false,
+                message: error instanceof Error ? error.message : 'Unknown error'
+            };
+        }
+    }
+    /**
+     * Get last webhook response
+     */
+    async getLastWebhookResponse() {
+        try {
+            const response = await fetch('/webhook-response.json');
+            if (!response.ok) {
+                return null;
+            }
+            return await response.json();
+        }
+        catch (error) {
+            console.error('Failed to fetch last webhook response:', error);
+            return null;
+        }
+    }
+    /**
+     * Manually trigger data regeneration
+     */
+    async triggerDataRegeneration() {
+        try {
+            const response = await fetch('/api/trigger-regeneration', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'Authorization': `Bearer ${this.refreshSecret}`
+                }
+            });
+            if (!response.ok) {
+                throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+            }
+            const result = await response.json();
+            return {
+                success: result.success,
+                message: result.message || 'Data regeneration triggered'
+            };
+        }
+        catch (error) {
+            console.error('Failed to trigger data regeneration:', error);
+            return {
+                success: false,
+                message: error instanceof Error ? error.message : 'Unknown error'
+            };
+        }
+    }
+    /**
+     * Check if webhook is properly configured
+     */
+    isConfigured() {
+        return !!(this.baseUrl && this.refreshSecret);
+    }
+    /**
+     * Get configuration status
+     */
+    getConfigurationStatus() {
+        return {
+            wordpress_url: !!this.baseUrl,
+            refresh_secret: !!this.refreshSecret,
+            fully_configured: !!(this.baseUrl && this.refreshSecret)
+        };
+    }
+}
+let cfWpWebhookServiceInstance = null;
+const getCfWpWebhookService = () => {
+    if (!cfWpWebhookServiceInstance) {
+        cfWpWebhookServiceInstance = new CfWpWebhookService();
+    }
+    return cfWpWebhookServiceInstance;
+};
+const resetCfWpWebhookService = () => {
+    cfWpWebhookServiceInstance = null;
+};
+const cfWpWebhookService = createLazyProxy(getCfWpWebhookService);
+
+exports.cfWpWebhookService = cfWpWebhookService;
+exports.createGravityFormsClient = createGravityFormsClient;
+exports.createMauticService = createMauticService;
+exports.getCfWpWebhookService = getCfWpWebhookService;
+exports.getGravityFormsClient = getGravityFormsClient;
+exports.getMauticService = getMauticService;
+exports.getSuiteCRMService = getSuiteCRMService;
+exports.gravityFormsClient = gravityFormsClient;
+exports.gravityFormsService = gravityFormsService;
+exports.mauticService = mauticService;
+exports.resetCfWpWebhookService = resetCfWpWebhookService;
+exports.resetGravityFormsClient = resetGravityFormsClient;
+exports.resetMauticService = resetMauticService;
+exports.resetSuiteCRMService = resetSuiteCRMService;
+exports.suitecrmService = suitecrmService;
+//# sourceMappingURL=services.cjs.map