@pheem49/mint 1.2.1

package/src/AI_Brain/headless_agent.js

@@ -0,0 +1,120 @@
+/**
+ * Mint Headless Agent
+ * Runs Mint's background features (like Proactive Suggestions) without a GUI.
+ */
+
+const { exec } = require('child_process');
+const { getSystemInfo } = require('../System/system_info');
+const { readConfig } = require('../System/config_manager');
+const systemEvents = require('../System/system_events');
+const taskManager = require('../System/task_manager');
+const { executeAutonomousTask } = require('./autonomous_brain');
+
+// ANSI Colors for console
+const colors = {
+    reset: "\x1b[0m",
+    bright: "\x1b[1m",
+    mint: "\x1b[38;5;121m",
+    gray: "\x1b[90m"
+};
+
+let isProcessingTask = false;
+
+async function startAgent() {
+    console.log(`\n${colors.mint}${colors.bright}[Mint-Agent] Background agent started.${colors.reset}`);
+    console.log(`${colors.gray}[Mint-Agent] Monitoring system events and task queue...${colors.reset}\n`);
+
+    // Initialize System Monitoring
+    systemEvents.startMonitoring();
+
+    // Listen for Battery Events
+    systemEvents.on('low-battery', (level) => {
+        sendNotification(
+            "⚠️ แบตเตอรี่ใกล้หมดแล้วนะคะ", 
+            `ตอนนี้แบตเตอรี่เหลือ ${level}% แล้วค่ะ อย่าลืมชาร์จแบตนะค๊า ✨`
+        );
+    });
+
+    // Listen for Network Events
+    systemEvents.on('connection-change', (isOnline) => {
+        const title = isOnline ? "✅ เชื่อมต่อสำเร็จ" : "❌ การเชื่อมต่อขาดหาย";
+        const msg = isOnline ? "มิ้นท์เชื่อมต่ออินเทอร์เน็ตได้แล้วค่ะ! ✨" : "มิ้นท์ไม่เห็นสัญญาณอินเทอร์เน็ตเลยนะคะ";
+        sendNotification(title, msg);
+    });
+
+    // Send a startup notification to let the user know the agent is alive
+    sendNotification("Mint Agent", "มิ้นท์ประจำการอยู่เบื้องหลังแล้วนะค๊า! 🛡️✨");
+    
+    // Polling Loop for Tasks and Health
+    setInterval(async () => {
+        await checkTaskQueue();
+        
+        try {
+            const info = await getSystemInfo();
+            // Heartbeat logic
+        } catch (err) {}
+    }, 15000); // Check every 15 seconds
+}
+
+async function checkTaskQueue() {
+    if (isProcessingTask) return;
+
+    const task = taskManager.getPendingTask();
+    if (!task) return;
+
+    isProcessingTask = true;
+    console.log(`\n${colors.mint}[Agent] Picking up task: ${task.description}${colors.reset}`);
+    
+    taskManager.updateTask(task.id, { status: 'running' });
+    sendNotification("🚀 เริ่มทำงานให้แล้วนะคะ", `กำลังดำเนินการ: ${task.description}`);
+
+    try {
+        const result = await executeAutonomousTask(task.description, (progress) => {
+            console.log(`${colors.gray}[Progress] ${progress}${colors.reset}`);
+            // Send periodic progress notifications if important
+            if (progress.includes('เสนอให้รันคำสั่ง')) {
+                sendNotification("💡 มิ้นท์มีข้อแนะนำค่ะ", progress);
+            }
+        });
+
+        taskManager.updateTask(task.id, { status: 'completed', result });
+        sendNotification("✅ งานเสร็จเรียบร้อยแล้วค่ะ!", result);
+        console.log(`\n${colors.mint}[Agent] Task completed successfully.${colors.reset}`);
+
+    } catch (err) {
+        console.error('[Agent] Task execution failed:', err);
+        taskManager.updateTask(task.id, { status: 'failed', result: err.message });
+        sendNotification("❌ เกิดข้อผิดพลาดในการทำงาน", err.message);
+    } finally {
+        isProcessingTask = false;
+    }
+}
+
+/**
+ * Sends a system-level notification using notify-send (Linux Pop!_OS)
+ */
+async function sendNotification(title, message) {
+    // Check if notify-send exists before trying to use it
+    const hasNotifySend = await new Promise(resolve => {
+        exec('which notify-send', (err) => resolve(!err));
+    });
+
+    if (!hasNotifySend) {
+        console.log(`${colors.gray}[Agent Info]${colors.reset} Notification suppressed (notify-send not found). Install with: sudo apt install libnotify-bin`);
+        console.log(`${colors.mint}[Agent Noti]${colors.reset} ${title}: ${message}`);
+        return;
+    }
+
+    const iconPath = require('path').join(__dirname, '../../assets/icon.png');
+    const cmd = `notify-send "${title}" "${message}" -i "${iconPath}" -a "Mint AI"`;
+    
+    exec(cmd, (err) => {
+        if (err) {
+            console.error('[Mint-Agent] Failed to send notification:', err.message);
+        } else {
+            console.log(`${colors.mint}[Agent Noti]${colors.reset} ${title}: ${message}`);
+        }
+    });
+}
+
+module.exports = { startAgent };

package/src/AI_Brain/knowledge_base.js

@@ -0,0 +1,222 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { GoogleGenAI } = require('@google/genai');
+const pdf = require('pdf-parse');
+const mammoth = require('mammoth');
+const xlsx = require('xlsx');
+const axios = require('axios');
+const cheerio = require('cheerio');
+const { readConfig } = require('../System/config_manager');
+
+// Handle electron dependency safely for benchmarks/tests
+let app;
+try {
+    const electron = require('electron');
+    app = electron.app;
+} catch (e) {
+    app = null;
+}
+
+let ai = null;
+let activeApiKey = '';
+const initialEnvKey = (process.env.GEMINI_API_KEY || '').trim();
+
+function resolveApiKey() {
+    let settingsKey = '';
+    try {
+        const cfg = readConfig();
+        settingsKey = (cfg.apiKey || '').trim();
+    } catch (e) {
+        settingsKey = '';
+    }
+
+    const envKey = initialEnvKey;
+    const selectedKey = settingsKey || envKey || '';
+
+    if (selectedKey !== (process.env.GEMINI_API_KEY || '')) {
+        process.env.GEMINI_API_KEY = selectedKey;
+    }
+
+    activeApiKey = selectedKey;
+    return selectedKey;
+}
+
+function getAiClient() {
+    const prevKey = activeApiKey;
+    const nextKey = resolveApiKey();
+    if (!ai || nextKey !== prevKey) {
+        ai = new GoogleGenAI({ apiKey: nextKey });
+    }
+    return ai;
+}
+
+function getDbPath() {
+    if (app && app.getPath) {
+        return path.join(app.getPath('userData'), 'mint-knowledge.json');
+    }
+    // Use global .mint directory for CLI/Benchmarking
+    const mintDir = path.join(os.homedir(), '.mint');
+    if (!fs.existsSync(mintDir)) {
+        fs.mkdirSync(mintDir, { recursive: true });
+    }
+    return path.join(mintDir, 'mint-knowledge.json');
+}
+
+function loadDb() {
+    try {
+        const p = getDbPath();
+        if (fs.existsSync(p)) {
+            return JSON.parse(fs.readFileSync(p, 'utf8'));
+        }
+    } catch (err) {
+        console.error('[KnowledgeBase] Load Error:', err);
+    }
+    return { documents: [] };
+}
+
+function saveDb(db) {
+    fs.writeFileSync(getDbPath(), JSON.stringify(db, null, 2));
+}
+
+async function generateEmbedding(text) {
+    const client = getAiClient();
+    const response = await client.models.embedContent({
+        model: 'gemini-embedding-001',
+        contents: text,
+    });
+    // The google/genai package returns an array of embeddings
+    return response.embeddings[0].values;
+}
+
+function cosineSimilarity(vecA, vecB) {
+    let dotProduct = 0.0;
+    let normA = 0.0;
+    let normB = 0.0;
+    for (let i = 0; i < vecA.length; i++) {
+        dotProduct += vecA[i] * vecB[i];
+        normA += vecA[i] * vecA[i];
+        normB += vecB[i] * vecB[i];
+    }
+    if (normA === 0 || normB === 0) return 0;
+    return dotProduct / (Math.sqrt(normA) * Math.sqrt(normB));
+}
+
+function chunkText(text, maxChars = 1000, overlap = 200) {
+    const chunks = [];
+    let current = 0;
+    const step = maxChars - overlap;
+    while (current < text.length) {
+        chunks.push(text.slice(current, current + maxChars));
+        current += step;
+    }
+    return chunks;
+}
+
+/**
+ * Reads a local file or URL, chunks its text, generates embeddings, and saves to knowledge base.
+ */
+async function indexFile(resourcePath) {
+    try {
+        if (!resourcePath || resourcePath.trim() === '') return "ไม่พบข้อมูล กรุณาระบุ Path หรือ URL ค่ะ";
+        
+        let content = '';
+        let sourceName = '';
+        let resourceId = '';
+
+        // Handle Web URLs
+        if (resourcePath.startsWith('http://') || resourcePath.startsWith('https://')) {
+            sourceName = resourcePath;
+            resourceId = resourcePath;
+            try {
+                const response = await axios.get(resourcePath);
+                const $ = cheerio.load(response.data);
+                $('script, style, noscript, nav, footer, header').remove();
+                content = $('body').text().replace(/\s+/g, ' ').trim();
+            } catch (e) {
+                return `ไม่สามารถดึงข้อมูลจากเว็บไซต์ได้ค่ะ: ${e.message}`;
+            }
+        } 
+        // Handle Local Files
+        else {
+            const filePath = resourcePath;
+            if (!fs.existsSync(filePath)) return `ไม่พบไฟล์: ${filePath}`;
+            
+            const stats = fs.statSync(filePath);
+            if (stats.size > 5 * 1024 * 1024) return `ขนาดไฟล์ใหญ่เกินไป (> 5MB): ${filePath}`; 
+            
+            sourceName = path.basename(filePath);
+            resourceId = filePath;
+            const ext = path.extname(filePath).toLowerCase();
+
+            if (ext === '.pdf') {
+                const dataBuffer = fs.readFileSync(filePath);
+                const data = await pdf(dataBuffer);
+                content = data.text;
+            } else if (ext === '.docx') {
+                const result = await mammoth.extractRawText({path: filePath});
+                content = result.value;
+            } else if (ext === '.xlsx') {
+                const workbook = xlsx.readFile(filePath);
+                content = '';
+                for (const sheetName of workbook.SheetNames) {
+                    const sheet = workbook.Sheets[sheetName];
+                    const csv = xlsx.utils.sheet_to_csv(sheet);
+                    content += `\n--- Sheet: ${sheetName} ---\n` + csv;
+                }
+            } else {
+                content = fs.readFileSync(filePath, 'utf8');
+            }
+        }
+
+        if (!content || content.trim().length === 0) return `ข้อมูลว่างเปล่าหรือไม่มีข้อความ: ${resourcePath}`;
+        
+        const chunks = chunkText(content);
+        const db = loadDb();
+        
+        for (let i = 0; i < chunks.length; i++) {
+            const embedding = await generateEmbedding(chunks[i]);
+            db.documents.push({
+                id: `${resourceId}#${i}-${Date.now()}`,
+                source: sourceName,
+                path: resourcePath,
+                text: chunks[i],
+                embedding
+            });
+        }
+        
+        saveDb(db);
+        return `✅ เรียนรู้ข้อมูลจาก ${sourceName} เรียบร้อยแล้ว (แบ่งเป็น ${chunks.length} ส่วน)`;
+    } catch (err) {
+        console.error('[KnowledgeBase] Indexing error:', err);
+        return `❌ เกิดข้อผิดพลาดในการเรียนรู้ไฟล์: ${err.message}`;
+    }
+}
+
+/**
+ * Searches the local knowledge base for relevant chunks.
+ */
+async function searchKnowledge(query, topK = 3) {
+    const db = loadDb();
+    if (!db.documents || db.documents.length === 0) return null;
+    
+    try {
+        const queryVector = await generateEmbedding(query);
+        const results = db.documents.map(doc => ({
+            ...doc,
+            score: cosineSimilarity(queryVector, doc.embedding)
+        })).sort((a, b) => b.score - a.score);
+        
+        // Return top results above a threshold
+        const top = results.slice(0, topK).filter(r => r.score > 0.65);
+        if (top.length > 0) {
+            console.log(`[KnowledgeBase] Found ${top.length} matches for query.`);
+            return top;
+        }
+    } catch(err) {
+        console.error("[KnowledgeBase] Search error:", err);
+    }
+    return null;
+}
+
+module.exports = { indexFile, searchKnowledge };

package/src/AI_Brain/proactive_engine.js

@@ -0,0 +1,168 @@
+const { GoogleGenAI } = require('@google/genai');
+const path = require('path');
+const fs = require('fs');
+const { app } = require('electron');
+const { readConfig } = require('../System/config_manager');
+
+// ============================================================
+// Proactive Engine — Smart Suggestion Engine (Multi-Choice)
+// ============================================================
+
+const ai = new GoogleGenAI({});
+const DEFAULT_GEMINI_MODEL = 'gemini-3.1-flash-lite-preview';
+let lastLoggedModel = '';
+
+const PROACTIVE_SYSTEM_PROMPT = `You are a Smart Suggestion Engine built into a Desktop AI Agent called "Mint".
+Your job: observe the user's screen + behavior, then offer MULTIPLE relevant quick-action options — NOT just one question.
+
+CRITICAL RULES:
+1. Respond ONLY with valid JSON, no markdown.
+2. If nothing notable is on screen, return: {"message": null, "context": "", "suggestions": []}
+3. Generate 2–4 SHORT suggestion chips that are genuinely useful based on what's visible.
+4. Each suggestion must have a clear label (1–3 words) and an action.
+5. Write "message" in Thai — short, friendly, observational (e.g. "พบว่าคุณเพิ่งเปิด Chrome").
+6. Do NOT repeat suggestions from recent activities.
+7. Suggestions should feel like smart shortcuts, not questions.
+
+Response schema (STRICT):
+{
+  "context": "short English description of what you see on screen",
+  "message": "สั้น ๆ เป็นภาษาไทย บอกว่า AI เห็นอะไร และเสนออะไร",
+  "suggestions": [
+    { "label": "YouTube", "action": { "type": "open_url", "target": "https://youtube.com" } },
+    { "label": "Gmail",   "action": { "type": "open_url", "target": "https://mail.google.com" } },
+    { "label": "GitHub",  "action": { "type": "open_url", "target": "https://github.com" } }
+  ]
+}
+
+Action types allowed: "open_url", "open_app", "search", "none"
+
+Examples:
+
+SCENARIO: User opened Chrome or Firefox
+→ message: "เพิ่งเปิด Browser — ต้องการเข้าเว็บไหนคะ?"
+→ suggestions: YouTube, Gmail, GitHub, Google Maps (based on behavior history)
+
+SCENARIO: User is in VS Code / coding
+→ message: "กำลัง Code อยู่ใช่ไหมคะ? มีอะไรช่วยได้บ้าง"
+→ suggestions: Stack Overflow, MDN Docs, GitHub, ค้นหา Error
+
+SCENARIO: User opened Spotify
+→ message: "เปิด Spotify แล้ว ต้องการเล่นอะไรคะ?"
+→ suggestions: เพลง Chill, เพลง Focus, Top Charts, Podcast
+
+SCENARIO: User opened Terminal
+→ message: "เปิด Terminal แล้ว ต้องการทำอะไรคะ?"
+→ suggestions: GitHub, Stack Overflow, DevDocs, ค้นหา Command
+
+BAD examples (return null):
+- Nothing notable on screen
+- User is actively typing
+- Same context as before
+`;
+
+let lastSuggestionContext = '';
+let lastSuggestionTime = 0;
+
+function resolveGeminiModel() {
+    try {
+        const cfg = readConfig();
+        const model = (cfg.geminiModel || '').trim();
+        return model || DEFAULT_GEMINI_MODEL;
+    } catch {
+        return DEFAULT_GEMINI_MODEL;
+    }
+}
+
+function getMinSuggestionIntervalMs() {
+    try {
+        const CONFIG_PATH = path.join(app.getPath('userData'), 'mint-config.json');
+        if (fs.existsSync(CONFIG_PATH)) {
+            const cfg = JSON.parse(fs.readFileSync(CONFIG_PATH, 'utf8'));
+            return (cfg.proactiveCooldown || 120) * 1000;
+        }
+    } catch {
+        // ignore
+    }
+    return 120_000;
+}
+
+/**
+ * Analyze screen and return a multi-choice suggestion object.
+ * @param {string} base64Image
+ * @param {string} behaviorSummary
+ * @returns {Promise<{message: string, context: string, suggestions: Array} | null>}
+ */
+async function analyzeAndSuggest(base64Image, behaviorSummary) {
+    try {
+        const model = resolveGeminiModel();
+        if (model && model !== lastLoggedModel) {
+            console.log(`[Gemini] Proactive Engine model: ${model}`);
+            lastLoggedModel = model;
+        }
+
+        const now = Date.now();
+        const minInterval = getMinSuggestionIntervalMs();
+
+        if (now - lastSuggestionTime < minInterval) return null;
+
+        const base64Data = base64Image.replace(/^data:image\/\w+;base64,/, '');
+
+        const userMessage = [
+            {
+                text: `Analyze the screen and generate smart multi-choice suggestions for the user.
+
+User behavior context: ${behaviorSummary || 'No history yet.'}
+
+Rules: Only suggest if you see a clear opportunity. Return 2–4 relevant chips. Return null message if nothing notable.`
+            },
+            {
+                inlineData: {
+                    mimeType: 'image/png',
+                    data: base64Data
+                }
+            }
+        ];
+
+        const response = await ai.models.generateContent({
+            model,
+            config: {
+                systemInstruction: PROACTIVE_SYSTEM_PROMPT,
+                responseMimeType: 'application/json'
+            },
+            contents: [{ role: 'user', parts: userMessage }]
+        });
+
+        let parsed;
+        try {
+            parsed = JSON.parse(response.text);
+        } catch {
+            const jsonMatch = response.text.match(/\{[\s\S]*\}/);
+            if (jsonMatch) parsed = JSON.parse(jsonMatch[0]);
+            else return null;
+        }
+
+        // Validate: must have message and at least 1 suggestion
+        if (!parsed || !parsed.message || !Array.isArray(parsed.suggestions) || parsed.suggestions.length === 0) {
+            return null;
+        }
+
+        // Skip repeat context
+        if (parsed.context && parsed.context === lastSuggestionContext) {
+            console.log('[ProactiveEngine] Skipping repeat context.');
+            return null;
+        }
+
+        lastSuggestionContext = parsed.context || '';
+        lastSuggestionTime = now;
+
+        console.log(`[ProactiveEngine] ${parsed.suggestions.length} suggestions for: ${parsed.context}`);
+        return parsed;
+
+    } catch (err) {
+        console.error('[ProactiveEngine] Error:', err.message);
+        return null;
+    }
+}
+
+module.exports = { analyzeAndSuggest };

package/src/Automation_Layer/browser_automation.js

@@ -0,0 +1,147 @@
+const puppeteer = require('puppeteer');
+const { GoogleGenAI } = require('@google/genai');
+const { readConfig } = require('../System/config_manager');
+
+const ai = new GoogleGenAI({});
+const DEFAULT_GEMINI_MODEL = 'gemini-3.1-flash-lite-preview';
+let lastLoggedModel = '';
+
+const BROWSER_SYSTEM_PROMPT = `You are an Autonomous Browser Agent. Your goal is to fulfill the user's web instruction by driving a headless browser.
+
+CRITICAL INSTRUCTIONS:
+Always respond EXACTLY with valid JSON. NO MARKDOWN. NO CODE BLOCKS (\`\`\`json). The JSON must have this exact structure:
+{
+  "thought": "Reasoning about what to do next based on the current page content and goal.",
+  "action": "goto" | "click" | "eval" | "done",
+  "target": "URL for goto | CSS selector for click | JavaScript expression for eval | Final answer for done"
+}
+
+Actions:
+- "goto": Navigate to the specified URL. Target MUST be a full URL (e.g. "https://www.google.com/search?q=AI+news")
+- "click": Click an element. Target MUST be a valid CSS selector.
+- "eval": Evaluate JavaScript to extract text. Target MUST be JS code returning a string (e.g. "document.body.innerText.substring(0, 1000)").
+- "done": Task finished. Target MUST be the final summary or answer to present to the user.
+
+You will receive the result of your previous action in the next message. If you get stuck or fail, try another approach or use "done" to report the failure.`;
+
+function resolveGeminiModel() {
+    try {
+        const cfg = readConfig();
+        const model = (cfg.geminiModel || '').trim();
+        return model || DEFAULT_GEMINI_MODEL;
+    } catch {
+        return DEFAULT_GEMINI_MODEL;
+    }
+}
+
+async function performWebAutomation(query) {
+    if (!query) return "No query provided.";
+
+    console.log("Starting web automation for:", query);
+
+    const config = readConfig();
+    const browserPath = config.automationBrowser;
+
+    let browser;
+    try {
+        const launchOptions = {
+            headless: false,
+            defaultViewport: null,
+            args: ['--start-maximized']
+        };
+
+        // If it's a specific path (like /usr/bin/firefox), set executablePath
+        if (browserPath && browserPath !== 'chromium') {
+            launchOptions.executablePath = browserPath;
+            if (browserPath.toLowerCase().includes('firefox')) {
+                launchOptions.browser = 'firefox';
+            }
+        }
+
+        browser = await puppeteer.launch(launchOptions);
+
+        const page = await browser.newPage();
+        
+        const model = resolveGeminiModel();
+        if (model && model !== lastLoggedModel) {
+            console.log(`[Gemini] Web Automation model: ${model}`);
+            lastLoggedModel = model;
+        }
+
+        const chat = ai.chats.create({
+            model,
+            config: {
+                systemInstruction: BROWSER_SYSTEM_PROMPT,
+                responseMimeType: "application/json"
+            }
+        });
+
+        let currentObservation = `Goal: ${query}\nSystem Note: You have a blank browser page. What is your first action? Start by using "goto" to navigate to a relevant search engine or website.`;
+        
+        let maxSteps = 10;
+        let step = 0;
+
+        while (step < maxSteps) {
+            step++;
+            console.log(`\n--- Agent Step ${step} ---`);
+            console.log(`Observation:`, currentObservation.substring(0, 150) + (currentObservation.length > 150 ? '...' : ''));
+
+            const response = await chat.sendMessage({ message: currentObservation });
+            
+            let parsed;
+            try {
+                const text = response.text;
+                const cleanText = text.replace(/^```json\n/, '').replace(/\n```$/, '').trim();
+                parsed = JSON.parse(cleanText);
+            } catch (e) {
+                console.error("Agent failed to return valid JSON:", response.text);
+                currentObservation = "Error: Invalid JSON returned. Please reply with ONLY valid JSON matching the schema.";
+                continue;
+            }
+
+            console.log("Agent Thought:", parsed.thought);
+            console.log("Agent Action:", parsed.action);
+            console.log("Agent Target:", parsed.target);
+
+            const { action, target } = parsed;
+
+            if (action === 'done') {
+                console.log("Agent finished with answer:", target);
+                // Intentionally keeping the browser open so the user can see the page.
+                return `🤖 Web Automation Result: ${target}`;
+            }
+
+            try {
+                if (action === 'goto') {
+                    await page.goto(target, { waitUntil: 'domcontentloaded', timeout: 30000 });
+                    const pageTitle = await page.title();
+                    currentObservation = `Successfully navigated to ${pageTitle}. ` + await page.evaluate(() => document.body.innerText.substring(0, 1500));
+                } else if (action === 'click') {
+                    await page.waitForSelector(target, { timeout: 5000 });
+                    await page.click(target);
+                    await new Promise(r => setTimeout(r, 2000)); 
+                    const pageTitle = await page.title();
+                    currentObservation = `Clicked element. Current page: ${pageTitle}. ` + await page.evaluate(() => document.body.innerText.substring(0, 1500));
+                } else if (action === 'eval') {
+                    const evalResult = await page.evaluate(target);
+                    currentObservation = `Eval result: ` + String(evalResult).substring(0, 1500);
+                } else {
+                    currentObservation = `Error: Unknown action type "${action}".`;
+                }
+            } catch (actionError) {
+                console.error("Action execution failed:", actionError);
+                currentObservation = `Action failed: ${actionError.message}. Please try again or use another method (for instance, try a different CSS selector or just read the current page).`;
+            }
+        }
+
+        // Intentionally keeping the browser open
+        return "Agent reached maximum steps (10) without finding a final answer.";
+
+    } catch (error) {
+        console.error("Web Automation Error:", error);
+        if (browser) browser.close();
+        return `I encountered an overall error while automating the browser: ${error.message}`;
+    }
+}
+
+module.exports = { performWebAutomation };