@turbotic/taai-agent 0.0.1

package/build/generate-script.js

@@ -0,0 +1,404 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = generateScript;
+const PRE_SCRIPT = (executionId, userId, agentEndpoint) => `
+    const { parentPort } = require('worker_threads');
+    const jwt = require('jsonwebtoken');
+
+    let __script_frame_context = JSON.parse(process.env?.HYDRATED_CONTEXT || '{}');
+    async function setContext(key, value) {
+        __script_frame_context[key] = value;
+        parentPort.postMessage({
+            type: 'setContext',
+            key,
+            value
+        });
+    }
+
+    function getContext(key) {
+        const c = __script_frame_context[key];
+
+        if (!c) {
+            throw new Error(\`Context key \${key} not set\`);
+        }
+
+        return c;
+    }
+
+    const generateToken = async () => 
+    {
+        // Generate signed token for each API call
+        const apiToken = jwt.sign(
+            {
+                executionId: '${executionId}',
+                iat: Math.floor(Date.now() / 1000),
+                exp: Math.floor(Date.now() / 1000) + 300  // 5 minute expiry (300 seconds)
+            },
+            process.env.SCRIPT_RUNNER_JWT_SECRET
+        );
+        return apiToken;
+    }
+
+    const publishScreenshot = async (base64Screenshot) => {
+        const token = await generateToken();
+        const response = await global.fetch('${agentEndpoint}/api/screenshots', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'X-Script-Runner': 'true',
+            },
+            body: JSON.stringify({
+                X_SCRIPT_RUNNER_TOKEN : token,
+                base64Screenshot,
+                executionId: '${executionId}',
+                currentUserId: '${userId}'
+            })
+        });
+
+        if (!response.ok) {
+            console.log('Failed to publish screenshot', response);
+            throw new Error('Failed to publish screenshot');
+        }
+    }
+
+    const simplifyHtml = async (html) => {
+        const token = await generateToken();
+        const response = await global.fetch('${agentEndpoint}/api/gen/extract-text', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'X-Script-Runner': 'true',
+            },
+            body: JSON.stringify({
+                html,
+                X_SCRIPT_RUNNER_TOKEN : token,
+                executionId: '${executionId}',
+                currentUserId: '${userId}'
+            })
+        });
+
+        if (!response.ok) {
+            throw new Error('Failed to simplify HTML');
+        }
+
+        const data = await response.text();
+        return data;
+    }
+
+    const findSelectorsUsingAI = async (html, promptToFindSelectors) => {
+        const token = await generateToken();
+        const response = await global.fetch('${agentEndpoint}/api/gen/find-selectors', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'X-Script-Runner': 'true',
+            },
+            body: JSON.stringify({
+                html,
+                promptToFindSelectors,
+                X_SCRIPT_RUNNER_TOKEN : token,
+                executionId: '${executionId}',
+                currentUserId: '${userId}'
+            })
+        });
+
+        if (!response.ok) {
+            console.log('Status', response?.status);
+            console.log('Error finding selectors using AI', await response?.text());
+            throw new Error('Failed to find selectors using AI');
+        }
+
+        const data = (await response.json())?.selectors?.selector;
+        return data;
+    }
+
+    // Microsoft Graph API Authentication Functions
+    const getMicrosoftAccessTokenFromTurbotic = async (type) => {
+        const token = await generateToken();
+        const response = await global.fetch('${agentEndpoint}/api/integrations/microsoft/auth-token', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'X-Script-Runner': 'true',
+            },
+            body: JSON.stringify({
+                executionId: '${executionId}',
+                type: type,
+                X_SCRIPT_RUNNER_TOKEN : token,
+                currentUserId: '${userId}'
+            })
+        });
+
+        if (!response.ok) {
+            const errorData = await response.json();
+            throw new Error(\`Microsoft authentication failed: \${errorData.error || response.statusText}\`);
+        }
+
+        const data = await response.json();
+        return data.accessToken;
+    }
+
+    const hasMicrosoftIntegration = async () => {
+        const token = await generateToken();
+        const response = await global.fetch('${agentEndpoint}/api/integrations/microsoft/check', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'X-Script-Runner': 'true',
+            },
+            body: JSON.stringify({
+                executionId: '${executionId}',
+                X_SCRIPT_RUNNER_TOKEN : token,
+                currentUserId: '${userId}'
+            })
+        });
+
+        if (!response.ok) {
+            return false;
+        }
+
+        const data = await response.json();
+        return data.hasIntegration;
+    }
+
+    // Ping Search Helper Functions
+        const searchWebWithTurboticAI = async (query, options = {}) => {
+            try {
+                console.log('🔍 Searching Web for: ' + query);
+                const token = await generateToken();
+                // Call the dedicated API endpoint
+                const response = await global.fetch('${agentEndpoint}/api/web-search', {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        'X-Script-Runner': 'true',
+                    },
+                    body: JSON.stringify({
+                        query: query,
+                        options: options,
+                        X_SCRIPT_RUNNER_TOKEN: token,
+                        currentUserId: '${userId}',
+                        executionId: '${executionId}'
+                    })
+                });
+
+                if (!response.ok) {
+                    const errorData = await response.json();
+                    throw new Error('Search API failed: ' + response.statusText + ' - ' + errorData.error);
+                }
+
+                const result = await response.json();
+                return result;
+
+            } catch (error) {
+                console.error('Search web error:', error);
+                throw new Error('Search web failed: ' + error.message);
+            }
+    }
+
+    // OpenAI Chat Helper Function
+    // Uses user's OpenAI API key if available, otherwise falls back to Turbotic's Azure OpenAI
+    const TurboticOpenAI = async (messages, options = {}) => {
+        try {
+            const {
+                model = 'gpt-4.1',
+                temperature = 0,
+                max_tokens = null
+            } = options;
+
+            console.log('🤖 Calling OpenAI with ' + messages.length + ' message(s)');
+            console.log('🤖 agentEndpoint: ' + '${agentEndpoint}');
+            const token = await generateToken();
+            // Call the dedicated API endpoint
+            const response = await global.fetch('${agentEndpoint}/api/openai-chat', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'X-Script-Runner': 'true',
+                },
+                    body: JSON.stringify({
+                        messages: messages,
+                        model: model,
+                        temperature: temperature,
+                        max_tokens: max_tokens,
+                        options: options,
+                        X_SCRIPT_RUNNER_TOKEN: token,
+                        currentUserId: '${userId}',
+                        executionId: '${executionId}'
+                })
+            });
+
+            if (!response.ok) {
+                let errorMessage = \`OpenAI API failed: \${response.status} \${response.statusText}\`;
+                try {
+                    const responseText = await response.text();
+                    if (responseText) {
+                        try {
+                            const errorData = JSON.parse(responseText);
+                            errorMessage += ' - ' + (errorData.error || responseText);
+                        } catch {
+                            errorMessage += ' - ' + responseText;
+                        }
+                    } else {
+                        errorMessage += ' - Empty response body (API may be down or experiencing issues)';
+                    }
+                } catch (parseError) {
+                    errorMessage += ' - Could not parse error response';
+                }
+                console.error('❌ TurboticOpenAI API Error:', errorMessage);
+                throw new Error(errorMessage);
+            }
+
+            const result = await response.json();
+            return result;
+
+        } catch (error) {
+            console.error('OpenAI chat error:', error);
+            throw new Error('OpenAI chat failed: ' + error.message);
+        }
+    }
+
+    // Email Sending Helper Function
+    // Priority: 1. Outlook (if user has Microsoft integration), 2. User's SendGrid API key, 3. Turbotic's SendGrid
+    const sendEmailViaTurbotic = async (emailData, options = {}) => {
+        try {
+            const {
+                to,
+                subject,
+                html = null,
+                text = null,
+                from = null,
+                attachments = null
+            } = emailData;
+
+            if (!to || !subject || (!html && !text)) {
+                throw new Error('to, subject, and either html or text are required');
+            }
+
+            console.log('📧 Sending email to: ' + (Array.isArray(to) ? to.join(', ') : to));
+            const token = await generateToken();
+            // Call the dedicated API endpoint
+            const response = await global.fetch('${agentEndpoint}/api/send-email', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'X-Script-Runner': 'true',
+                },
+                    body: JSON.stringify({
+                        to: to,
+                        subject: subject,
+                        html: html,
+                        text: text,
+                        from: from,
+                        attachments: attachments,
+                        options: options,
+                        currentUserId: '${userId}',
+                        executionId: '${executionId}',
+                        X_SCRIPT_RUNNER_TOKEN: token,
+                })
+            });
+
+            if (!response.ok) {
+                const errorData = await response.json();
+                throw new Error('Send email failed: ' + response.statusText + ' - ' + (errorData.error || 'Unknown error'));
+            }
+
+            const result = await response.json();
+            return result;
+
+        } catch (error) {
+            console.error('Send email error:', error);
+            throw new Error('Send email failed: ' + error.message);
+        }
+    }
+
+
+    const pingUrls = async (urls, options = {}) => {
+        const {
+            timeout = 5000,
+            maxRetries = 3
+        } = options;
+
+        try {
+            console.log('🏓 Pinging ' + urls.length + ' URLs...');
+
+            const pingResults = [];
+            for (const url of urls) {
+                let lastError = null;
+                let success = false;
+                let latency = 0;
+
+                for (let attempt = 1; attempt <= maxRetries; attempt++) {
+                    try {
+                        const startTime = Date.now();
+                        const response = await global.fetch(url, { 
+                            method: 'HEAD', 
+                            signal: AbortSignal.timeout(timeout) 
+                        });
+                        latency = Date.now() - startTime;
+                        
+                        if (response.ok) {
+                            success = true;
+                            break;
+                        }
+                    } catch (error) {
+                        lastError = error.message;
+                        if (attempt < maxRetries) {
+                            await new Promise(resolve => setTimeout(resolve, Math.pow(2, attempt) * 1000));
+                        }
+                    }
+                }
+
+                pingResults.push({
+                    url: url,
+                    success: success,
+                    latency: latency,
+                    error: success ? null : lastError,
+                    timestamp: new Date()
+                });
+            }
+
+            const successfulPings = pingResults.filter(r => r.success).length;
+            const averageLatency = pingResults
+                .filter(r => r.success)
+                .reduce((sum, r) => sum + r.latency, 0) / successfulPings || 0;
+
+            return {
+                results: pingResults,
+                totalUrls: urls.length,
+                successfulPings,
+                failedPings: urls.length - successfulPings,
+                averageLatency: Math.round(averageLatency),
+                timeout,
+                maxRetries
+            };
+
+        } catch (error) {
+            console.error('Ping test error:', error);
+            throw new Error('Ping test failed: ' + error.message);
+        }
+    }
+`;
+function generateScript(rawScript, userId) {
+    const executionId = process.env.EXECUTION_ID || '';
+    const automationAiEndpoint = process.env.AUTOMATIONAI_ENDPOINT || '';
+    const agentEndpoint = process.env.SCRIPT_RUNNER_AGENT_ENDPOINT || 'http://localhost:3005';
+    const useScriptRunnerAgent = process.env.USE_SCRIPT_RUNNER_AGENT === 'true';
+    // Use agent endpoint if enabled, otherwise use app endpoint
+    const apiEndpoint = useScriptRunnerAgent ? agentEndpoint : automationAiEndpoint;
+    console.log(`[Script Generation] EXECUTION_ID: ${executionId}`);
+    console.log(`[Script Generation] AUTOMATIONAI_ENDPOINT: ${automationAiEndpoint}`);
+    console.log(`[Script Generation] AGENT_ENDPOINT: ${agentEndpoint}`);
+    console.log(`[Script Generation] USE_SCRIPT_RUNNER_AGENT: ${useScriptRunnerAgent}`);
+    console.log(`[Script Generation] API_ENDPOINT: ${apiEndpoint}`);
+    // Replace any usage of require('node-fetch') with globalThis.fetch in the provided raw script
+    const transformedRawScript = rawScript.replace(/require\(["']node-fetch["']\)/g, 'globalThis.fetch');
+    const generatedScript = `
+        ${PRE_SCRIPT(executionId, userId, apiEndpoint)}
+        ${transformedRawScript}
+    `;
+    // Log a preview of the generated script
+    const preview = generatedScript.substring(0, 500);
+    console.log(`[Script Generation] Generated script preview:`, preview);
+    return generatedScript;
+}