@agnocon/piece-browserless 0.1.7

package/src/lib/actions/get-website-performance.ts

@@ -0,0 +1,321 @@
+import { createAction, Property } from '@agnocon/pieces-framework';
+import { HttpMethod } from '@agnocon/pieces-common';
+import { browserlessAuth } from '../common/auth';
+import { browserlessCommon } from '../common/client';
+
+export const getWebsitePerformance = createAction({
+    name: 'get_website_performance',
+    displayName: 'Get Website Performance',
+    description: 'Analyze website performance metrics using Lighthouse',
+    audience: 'both',
+    aiMetadata: { description: 'Runs a Lighthouse audit on a public URL in a headless browser and returns performance, accessibility, best-practices, SEO, and PWA scores plus key metrics. Use to measure a page\'s quality; the URL is required, and you can scope the audit to specific categories and simulate a desktop or mobile device with network throttling. Read-only analysis: re-running with the same input re-audits the page without side effects (scores may vary slightly run to run).', idempotent: true },
+    auth: browserlessAuth,
+    props: {
+        url: Property.ShortText({
+            displayName: 'URL',
+            description: 'The URL of the website to analyze',
+            required: true,
+        }),
+        categories: Property.Array({
+            displayName: 'Performance Categories',
+            description: 'Select which performance categories to analyze (performance, accessibility, best-practices, seo, pwa)',
+            required: false,
+            properties: {
+                category: Property.StaticDropdown({
+                    displayName: 'Category',
+                    required: true,
+                    options: {
+                        options: [
+                            { label: 'Performance', value: 'performance' },
+                            { label: 'Accessibility', value: 'accessibility' },
+                            { label: 'Best Practices', value: 'best-practices' },
+                            { label: 'SEO', value: 'seo' },
+                            { label: 'PWA', value: 'pwa' }
+                        ]
+                    }
+                })
+            }
+        }),
+        device: Property.StaticDropdown({
+            displayName: 'Device Type',
+            description: 'Device type for performance analysis',
+            required: false,
+            defaultValue: 'desktop',
+            options: {
+                options: [
+                    { label: 'Desktop', value: 'desktop' },
+                    { label: 'Mobile', value: 'mobile' }
+                ]
+            }
+        }),
+        throttling: Property.StaticDropdown({
+            displayName: 'Network Throttling',
+            description: 'Network throttling simulation',
+            required: false,
+            defaultValue: 'mobileSlow4G',
+            options: {
+                options: [
+                    { label: 'No Throttling', value: 'none' },
+                    { label: 'Slow 4G', value: 'mobileSlow4G' },
+                    { label: 'Regular 4G', value: 'mobileRegular4G' },
+                    { label: 'Fast 4G', value: 'mobileFast4G' }
+                ]
+            }
+        }),
+        onlyCategories: Property.Checkbox({
+            displayName: 'Only Category Scores',
+            description: 'Return only category scores without detailed audit results',
+            required: false,
+            defaultValue: false,
+        }),
+        locale: Property.ShortText({
+            displayName: 'Locale',
+            description: 'Locale for the analysis (e.g., en-US, de-DE)',
+            required: false,
+            defaultValue: 'en-US',
+        }),
+        userAgent: Property.ShortText({
+            displayName: 'User Agent',
+            description: 'Custom user agent string',
+            required: false,
+        }),
+        timeout: Property.Number({
+            displayName: 'Timeout (ms)',
+            description: 'Maximum time to wait for the analysis to complete',
+            required: false,
+            defaultValue: 60000,
+        }),
+        waitForSelector: Property.ShortText({
+            displayName: 'Wait for Selector',
+            description: 'CSS selector to wait for before running performance analysis',
+            required: false,
+        }),
+        emulateMediaType: Property.StaticDropdown({
+            displayName: 'Emulate Media Type',
+            description: 'Emulate CSS media type',
+            required: false,
+            options: {
+                options: [
+                    { label: 'Screen', value: 'screen' },
+                    { label: 'Print', value: 'print' }
+                ]
+            }
+        }),
+        budgets: Property.Array({
+            displayName: 'Performance Budgets',
+            description: 'Lighthouse performance budgets for resource sizes',
+            required: false,
+            properties: {
+                resourceType: Property.StaticDropdown({
+                    displayName: 'Resource Type',
+                    description: 'Type of resource to budget',
+                    required: true,
+                    options: {
+                        options: [
+                            { label: 'Document', value: 'document' },
+                            { label: 'Script', value: 'script' },
+                            { label: 'Stylesheet', value: 'stylesheet' },
+                            { label: 'Image', value: 'image' },
+                            { label: 'Media', value: 'media' },
+                            { label: 'Font', value: 'font' },
+                            { label: 'Other', value: 'other' },
+                            { label: 'Third-party', value: 'third-party' }
+                        ]
+                    }
+                }),
+                budget: Property.Number({
+                    displayName: 'Budget Size (KB)',
+                    description: 'Maximum allowed size in kilobytes',
+                    required: true,
+                })
+            }
+        }),
+        stealth: Property.Checkbox({
+            displayName: 'Stealth Mode',
+            description: 'Enable stealth mode for bot detection bypass',
+            required: false,
+            defaultValue: false,
+        }),
+        blockAds: Property.Checkbox({
+            displayName: 'Block Ads',
+            description: 'Enable ad blocker during performance analysis',
+            required: false,
+            defaultValue: false,
+        }),
+    },
+    async run(context) {
+        const requestBody: any = {
+            url: context.propsValue.url,
+        };
+
+        const lighthouseConfig: any = {
+            extends: 'lighthouse:default',
+            settings: {}
+        };
+
+        if (context.propsValue.categories && context.propsValue.categories.length > 0) {
+            lighthouseConfig.settings.onlyCategories = context.propsValue.categories.map((cat: any) => cat.category);
+        }
+
+        if (context.propsValue.locale) {
+            lighthouseConfig.settings.locale = context.propsValue.locale;
+        }
+
+        if (context.propsValue.device) {
+            lighthouseConfig.settings.formFactor = context.propsValue.device;
+        }
+
+        if (context.propsValue.throttling && context.propsValue.throttling !== 'none') {
+            lighthouseConfig.settings.throttling = { rttMs: 150, throughputKbps: 1638.4, cpuSlowdownMultiplier: 4 };
+
+            switch (context.propsValue.throttling) {
+                case 'mobileSlow4G':
+                    lighthouseConfig.settings.throttling = { rttMs: 150, throughputKbps: 1638.4, cpuSlowdownMultiplier: 4 };
+                    break;
+                case 'mobileRegular4G':
+                    lighthouseConfig.settings.throttling = { rttMs: 100, throughputKbps: 2048, cpuSlowdownMultiplier: 3 };
+                    break;
+                case 'mobileFast4G':
+                    lighthouseConfig.settings.throttling = { rttMs: 50, throughputKbps: 4096, cpuSlowdownMultiplier: 2 };
+                    break;
+            }
+        }
+
+        if (context.propsValue.userAgent) {
+            lighthouseConfig.settings.userAgent = context.propsValue.userAgent;
+        }
+
+        if (context.propsValue.timeout) {
+            lighthouseConfig.settings.timeout = context.propsValue.timeout;
+        }
+
+        if (context.propsValue.waitForSelector) {
+            lighthouseConfig.settings.waitForSelector = context.propsValue.waitForSelector;
+        }
+
+        if (context.propsValue.emulateMediaType) {
+            lighthouseConfig.settings.emulatedFormFactor = context.propsValue.emulateMediaType;
+        }
+
+        if (context.propsValue.onlyCategories && !lighthouseConfig.settings.onlyCategories) {
+            lighthouseConfig.settings.onlyCategories = ['performance', 'accessibility', 'best-practices', 'seo', 'pwa'];
+        }
+
+        requestBody.config = lighthouseConfig;
+
+        if (context.propsValue.budgets && context.propsValue.budgets.length > 0) {
+            requestBody.budgets = context.propsValue.budgets.map((budget: any) => ({
+                resourceType: budget.resourceType,
+                budget: budget.budget * 1024
+            }));
+        }
+
+        let resourceUri = '/performance';
+        const queryParams: string[] = [];
+
+        if (context.propsValue.stealth) {
+            queryParams.push('stealth=true');
+        }
+
+        if (context.propsValue.blockAds) {
+            queryParams.push('blockAds=true');
+        }
+
+        if (queryParams.length > 0) {
+            resourceUri += `?${queryParams.join('&')}`;
+        }
+
+        const response = await browserlessCommon.apiCall({
+            auth: context.auth.props,
+            method: HttpMethod.POST,
+            resourceUri,
+            body: requestBody,
+        });
+
+        const performanceData = response.body;
+        
+        const summary: any = {
+            url: context.propsValue.url,
+            formFactor: context.propsValue.device || 'desktop',
+            timestamp: new Date().toISOString(),
+        };
+
+        if (performanceData.lhr && performanceData.lhr.categories) {
+            const categories = performanceData.lhr.categories;
+            summary.scores = {
+                performance: categories.performance?.score ? Math.round(categories.performance.score * 100) : null,
+                accessibility: categories.accessibility?.score ? Math.round(categories.accessibility.score * 100) : null,
+                bestPractices: categories['best-practices']?.score ? Math.round(categories['best-practices'].score * 100) : null,
+                seo: categories.seo?.score ? Math.round(categories.seo.score * 100) : null,
+                pwa: categories.pwa?.score ? Math.round(categories.pwa.score * 100) : null,
+            };
+        }
+
+        if (performanceData.lhr && performanceData.lhr.audits) {
+            const audits = performanceData.lhr.audits;
+            summary.metrics = {
+                firstContentfulPaint: {
+                    value: audits['first-contentful-paint']?.displayValue || null,
+                    score: audits['first-contentful-paint']?.score ? Math.round(audits['first-contentful-paint'].score * 100) : null
+                },
+                largestContentfulPaint: {
+                    value: audits['largest-contentful-paint']?.displayValue || null,
+                    score: audits['largest-contentful-paint']?.score ? Math.round(audits['largest-contentful-paint'].score * 100) : null
+                },
+                firstMeaningfulPaint: {
+                    value: audits['first-meaningful-paint']?.displayValue || null,
+                    score: audits['first-meaningful-paint']?.score ? Math.round(audits['first-meaningful-paint'].score * 100) : null
+                },
+                speedIndex: {
+                    value: audits['speed-index']?.displayValue || null,
+                    score: audits['speed-index']?.score ? Math.round(audits['speed-index'].score * 100) : null
+                },
+                timeToInteractive: {
+                    value: audits['interactive']?.displayValue || null,
+                    score: audits['interactive']?.score ? Math.round(audits['interactive'].score * 100) : null
+                },
+                totalBlockingTime: {
+                    value: audits['total-blocking-time']?.displayValue || null,
+                    score: audits['total-blocking-time']?.score ? Math.round(audits['total-blocking-time'].score * 100) : null
+                },
+                cumulativeLayoutShift: {
+                    value: audits['cumulative-layout-shift']?.displayValue || null,
+                    score: audits['cumulative-layout-shift']?.score ? Math.round(audits['cumulative-layout-shift'].score * 100) : null
+                },
+            };
+
+            summary.opportunities = [];
+            if (audits['unused-css-rules']?.details?.items?.length > 0) {
+                summary.opportunities.push({
+                    type: 'unused-css',
+                    title: 'Remove unused CSS',
+                    potentialSavings: audits['unused-css-rules'].displayValue || 'Unknown'
+                });
+            }
+            if (audits['unused-javascript']?.details?.items?.length > 0) {
+                summary.opportunities.push({
+                    type: 'unused-javascript',
+                    title: 'Remove unused JavaScript',
+                    potentialSavings: audits['unused-javascript'].displayValue || 'Unknown'
+                });
+            }
+            if (audits['render-blocking-resources']?.details?.items?.length > 0) {
+                summary.opportunities.push({
+                    type: 'render-blocking',
+                    title: 'Eliminate render-blocking resources',
+                    potentialSavings: audits['render-blocking-resources'].displayValue || 'Unknown'
+                });
+            }
+        }
+
+        return {
+            success: true,
+            summary,
+            fullReport: performanceData,
+            metadata: {
+                analysisTime: response.headers?.['x-response-time'] || 'unknown',
+                lighthouseVersion: performanceData.lhr?.lighthouseVersion || 'unknown',
+            }
+        };
+    },
+});

package/src/lib/actions/run-bql-query.ts

@@ -0,0 +1,295 @@
+import { createAction, Property } from '@agnocon/pieces-framework';
+import { HttpMethod } from '@agnocon/pieces-common';
+import { browserlessAuth } from '../common/auth';
+import { browserlessCommon } from '../common/client';
+
+export const runBqlQuery = createAction({
+    name: 'run_bql_query',
+    displayName: 'Run BQL Query',
+    description: 'Execute Browser Query Language (BQL) GraphQL-based queries for advanced browser automation',
+    audience: 'both',
+    aiMetadata: { description: 'Runs a raw Browser Query Language (BQL) GraphQL query against a headless Chromium browser for advanced automation such as navigation, clicking, typing, and multi-step scripted browser flows. Use when the simpler screenshot/scrape/PDF actions cannot express the interaction; requires a valid BQL query string and supports session options like stealth, proxy, and cookies. Not idempotent: the query can perform stateful browser actions and side-effecting navigation, so repeating it may not yield the same result.', idempotent: false },
+    auth: browserlessAuth,
+    props: {
+        query: Property.LongText({
+            displayName: 'BQL Query',
+            description: 'GraphQL-based BQL query for browser automation. Example: mutation { goto(url: "https://example.com") { status } }',
+            required: true,
+        }),
+        variables: Property.Object({
+            displayName: 'Query Variables',
+            description: 'Variables to pass to the BQL query (JSON object)',
+            required: false,
+        }),
+        operationName: Property.ShortText({
+            displayName: 'Operation Name',
+            description: 'Name of the GraphQL operation to execute',
+            required: false,
+        }),
+        timeout: Property.Number({
+            displayName: 'Timeout (ms)',
+            description: 'Maximum execution time in milliseconds',
+            required: false,
+            defaultValue: 30000,
+        }),
+
+        stealth: Property.Checkbox({
+            displayName: 'Stealth Mode',
+            description: 'Enable stealth mode for bot detection bypass',
+            required: false,
+            defaultValue: true,
+        }),
+        headless: Property.Checkbox({
+            displayName: 'Headless Mode',
+            description: 'Run browser in headless mode (set to false for GUI)',
+            required: false,
+            defaultValue: true,
+        }),
+        humanlike: Property.Checkbox({
+            displayName: 'Human-like Behavior',
+            description: 'Enable human-like mouse movement, typing, and delays',
+            required: false,
+            defaultValue: false,
+        }),
+        proxy: Property.StaticDropdown({
+            displayName: 'Proxy Type',
+            description: 'Type of proxy to use',
+            required: false,
+            options: {
+                options: [
+                    { label: 'Residential', value: 'residential' },
+                    { label: 'None', value: 'none' }
+                ]
+            }
+        }),
+        proxyCountry: Property.ShortText({
+            displayName: 'Proxy Country',
+            description: 'Country code for residential proxy (e.g., us, gb, de)',
+            required: false,
+        }),
+        proxySticky: Property.Checkbox({
+            displayName: 'Sticky Proxy',
+            description: 'Maintain same proxy IP across session',
+            required: false,
+            defaultValue: false,
+        }),
+        blockAds: Property.Checkbox({
+            displayName: 'Block Ads',
+            description: 'Enable ad blocker (uBlock Origin)',
+            required: false,
+            defaultValue: false,
+        }),
+        blockConsentModals: Property.Checkbox({
+            displayName: 'Block Consent Modals',
+            description: 'Automatically block/dismiss cookie consent banners',
+            required: false,
+            defaultValue: false,
+        }),
+        record: Property.Checkbox({
+            displayName: 'Record Session',
+            description: 'Enable session recording for debugging',
+            required: false,
+            defaultValue: false,
+        }),
+        slowMo: Property.Number({
+            displayName: 'Slow Motion (ms)',
+            description: 'Add delays between browser actions in milliseconds',
+            required: false,
+        }),
+        ignoreHTTPSErrors: Property.Checkbox({
+            displayName: 'Ignore HTTPS Errors',
+            description: 'Ignore HTTPS certificate errors during navigation',
+            required: false,
+            defaultValue: false,
+        }),
+        userAgent: Property.ShortText({
+            displayName: 'User Agent',
+            description: 'Custom user agent string',
+            required: false,
+        }),
+        viewportWidth: Property.Number({
+            displayName: 'Viewport Width',
+            description: 'Browser viewport width',
+            required: false,
+        }),
+        viewportHeight: Property.Number({
+            displayName: 'Viewport Height',
+            description: 'Browser viewport height',
+            required: false,
+        }),
+        cookies: Property.Array({
+            displayName: 'Cookies',
+            description: 'Cookies to set before executing BQL query',
+            required: false,
+            properties: {
+                name: Property.ShortText({
+                    displayName: 'Cookie Name',
+                    required: true,
+                }),
+                value: Property.ShortText({
+                    displayName: 'Cookie Value',
+                    required: true,
+                }),
+                url: Property.ShortText({
+                    displayName: 'URL',
+                    description: 'Request-URI to associate with the cookie',
+                    required: false,
+                }),
+                domain: Property.ShortText({
+                    displayName: 'Domain',
+                    required: false,
+                }),
+                path: Property.ShortText({
+                    displayName: 'Path',
+                    required: false,
+                }),
+                secure: Property.Checkbox({
+                    displayName: 'Secure',
+                    description: 'Indicates if the cookie is secure',
+                    required: false,
+                    defaultValue: false,
+                }),
+                httpOnly: Property.Checkbox({
+                    displayName: 'HTTP Only',
+                    description: 'Indicates if the cookie is HTTP-only',
+                    required: false,
+                    defaultValue: false,
+                }),
+                sameSite: Property.StaticDropdown({
+                    displayName: 'SameSite',
+                    description: 'SameSite policy for the cookie',
+                    required: false,
+                    options: {
+                        options: [
+                            { label: 'Strict', value: 'Strict' },
+                            { label: 'Lax', value: 'Lax' },
+                            { label: 'None', value: 'None' }
+                        ]
+                    }
+                }),
+                expires: Property.Number({
+                    displayName: 'Expires',
+                    description: 'Expiration date as timestamp (session cookie if not set)',
+                    required: false,
+                }),
+            }
+        }),
+    },
+    async run(context) {
+        const requestBody: any = {
+            query: context.propsValue.query,
+        };
+
+        if (context.propsValue.variables) {
+            requestBody.variables = context.propsValue.variables;
+        }
+
+        if (context.propsValue.operationName) {
+            requestBody.operationName = context.propsValue.operationName;
+        }
+
+        let resourceUri = '/chromium/bql';
+
+        const queryParams: string[] = [];
+
+        if (context.propsValue.timeout) {
+            queryParams.push(`timeout=${context.propsValue.timeout}`);
+        }
+
+        if (context.propsValue.stealth !== undefined) {
+            queryParams.push(`stealth=${context.propsValue.stealth}`);
+        }
+
+        if (context.propsValue.headless !== undefined) {
+            queryParams.push(`headless=${context.propsValue.headless}`);
+        }
+
+        if (context.propsValue.humanlike) {
+            queryParams.push(`humanlike=true`);
+        }
+
+        if (context.propsValue.proxy && context.propsValue.proxy !== 'none') {
+            queryParams.push(`proxy=${context.propsValue.proxy}`);
+            if (context.propsValue.proxyCountry) {
+                queryParams.push(`proxyCountry=${context.propsValue.proxyCountry}`);
+            }
+            if (context.propsValue.proxySticky) {
+                queryParams.push(`proxySticky=true`);
+            }
+        }
+
+        if (context.propsValue.blockAds) {
+            queryParams.push(`blockAds=true`);
+        }
+
+        if (context.propsValue.blockConsentModals) {
+            queryParams.push(`blockConsentModals=true`);
+        }
+
+        if (context.propsValue.record) {
+            queryParams.push(`record=true`);
+        }
+
+        if (context.propsValue.slowMo) {
+            queryParams.push(`slowMo=${context.propsValue.slowMo}`);
+        }
+
+        if (context.propsValue.ignoreHTTPSErrors) {
+            queryParams.push(`ignoreHTTPSErrors=true`);
+        }
+
+        if (context.propsValue.userAgent) {
+            queryParams.push(`userAgent=${encodeURIComponent(context.propsValue.userAgent)}`);
+        }
+
+        if (context.propsValue.viewportWidth && context.propsValue.viewportHeight) {
+            queryParams.push(`viewport=${context.propsValue.viewportWidth}x${context.propsValue.viewportHeight}`);
+        }
+
+        if (context.propsValue.cookies && context.propsValue.cookies.length > 0) {
+            const cookiesJson = JSON.stringify(context.propsValue.cookies.map((cookie: any) => ({
+                name: cookie.name,
+                value: cookie.value,
+                ...(cookie.url && { url: cookie.url }),
+                ...(cookie.domain && { domain: cookie.domain }),
+                ...(cookie.path && { path: cookie.path }),
+                ...(cookie.secure !== undefined && { secure: cookie.secure }),
+                ...(cookie.httpOnly !== undefined && { httpOnly: cookie.httpOnly }),
+                ...(cookie.sameSite && { sameSite: cookie.sameSite }),
+                ...(cookie.expires !== undefined && { expires: cookie.expires })
+            })));
+            queryParams.push(`cookies=${encodeURIComponent(cookiesJson)}`);
+        }
+
+        if (queryParams.length > 0) {
+            resourceUri += `?${queryParams.join('&')}`;
+        }
+
+        const response = await browserlessCommon.apiCall({
+            auth: context.auth.props,
+            method: HttpMethod.POST,
+            resourceUri,
+            body: requestBody,
+        });
+
+        let parsedResult;
+        try {
+            parsedResult = typeof response.body === 'string' ? JSON.parse(response.body) : response.body;
+        } catch (error) {
+            parsedResult = response.body;
+        }
+
+        return {
+            success: true,
+            data: parsedResult?.data || null,
+            errors: parsedResult?.errors || null,
+            result: parsedResult,
+            metadata: {
+                browserType: 'chromium',
+                executionTime: response.headers?.['x-response-time'] || 'unknown',
+                timestamp: new Date().toISOString(),
+                stealth: context.propsValue.stealth || false,
+            }
+        };
+    },
+});