@eko-ai/eko-nodejs 3.0.0-alpha.4 → 3.0.0-alpha.6

package/dist/index.esm.js

@@ -1,10 +1,12 @@
+import * as fs from 'fs';
+import { realpathSync as realpathSync$1, readlinkSync, readdirSync, readdir as readdir$1, lstatSync } from 'fs';
+import * as os from 'os';
+import * as path$1 from 'path';
 import { Log, BaseBrowserLabelsAgent, BaseFileAgent, uuidv4 } from '@eko-ai/eko';
 import { chromium } from 'playwright';
-import * as fs from 'fs/promises';
-import * as path$1 from 'path';
+import * as fs$1 from 'fs/promises';
 import { fileURLToPath } from 'node:url';
 import { win32, posix } from 'node:path';
-import { realpathSync as realpathSync$1, readlinkSync, readdirSync, readdir as readdir$1, lstatSync } from 'fs';
 import * as actualFS from 'node:fs';
 import { realpath, readlink, readdir, lstat } from 'node:fs/promises';
 import { EventEmitter } from 'node:events';
@@ -19,6 +21,104 @@ async function getCdpWsEndpoint(port) {
     Log.info("browserInfo: ", browserInfo);
     return browserInfo.webSocketDebuggerUrl;
 }
+function getDefaultChromeUserDataDir(copyToTempDir = false) {
+    const platform = os.platform();
+    const homeDir = os.homedir();
+    let defaultPath;
+    switch (platform) {
+        case "win32":
+            // Windows: %LOCALAPPDATA%\Google\Chrome\User Data
+            const localAppData = process.env.LOCALAPPDATA || path$1.join(homeDir, "AppData", "Local");
+            defaultPath = path$1.join(localAppData, "Google", "Chrome", "User Data");
+            break;
+        case "darwin":
+            // macOS: ~/Library/Application Support/Google/Chrome
+            defaultPath = path$1.join(homeDir, "Library", "Application Support", "Google", "Chrome");
+            break;
+        case "linux":
+            // Linux: ~/.config/google-chrome
+            defaultPath = path$1.join(homeDir, ".config", "google-chrome");
+            break;
+    }
+    if (defaultPath && fs.existsSync(defaultPath)) {
+        if (copyToTempDir) {
+            const tempDir = os.tmpdir();
+            const tempPath = path$1.join(tempDir, "chrome-user-data");
+            if (fs.existsSync(tempPath)) {
+                Log.info(`Removing existing temp directory: ${tempPath}`);
+                fs.rmSync(tempPath, { recursive: true, force: true });
+            }
+            fs.cpSync(defaultPath, tempPath, { recursive: true });
+            // Delete all Chrome locked files and directories to prevent startup conflicts.
+            removeLockFiles(tempPath);
+            const defaultProfilePath = path$1.join(tempPath, "Default");
+            if (fs.existsSync(defaultProfilePath)) {
+                removeLockFiles(defaultProfilePath);
+            }
+            Log.info(`Created clean Chrome user data directory: ${tempPath}`);
+            return tempPath;
+        }
+        else {
+            return defaultPath;
+        }
+    }
+    return undefined;
+}
+function removeLockFiles(dirPath) {
+    try {
+        const items = fs.readdirSync(dirPath);
+        items.forEach((item) => {
+            const itemPath = path$1.join(dirPath, item);
+            try {
+                const stat = fs.statSync(itemPath);
+                if (stat.isDirectory()) {
+                    removeLockFiles(itemPath);
+                }
+                const shouldDelete = item === "SingletonLock" ||
+                    item === "lockfile" ||
+                    item === "RunningChromeVersion" ||
+                    item === "SingletonCookie" ||
+                    item === "SingletonSocket" ||
+                    item === "chrome_debug.log" ||
+                    item === "LOCK" ||
+                    item === "LOG" ||
+                    item === "LOG.old" ||
+                    item.includes(".lock") ||
+                    item.includes("Lock") ||
+                    item.includes("LOCK") ||
+                    item.includes(".tmp") ||
+                    item.includes("Temp") ||
+                    item.endsWith(".pid") ||
+                    item.endsWith(".log") ||
+                    item.includes("chrome_shutdown_ms.txt") ||
+                    item.includes("Crashpad") ||
+                    (stat.isDirectory() &&
+                        (item.includes("CrashReports") ||
+                            item.includes("ShaderCache") ||
+                            item.includes("crashpad_database")));
+                if (shouldDelete) {
+                    fs.rmSync(itemPath, { recursive: true, force: true });
+                }
+            }
+            catch (statError) {
+                if (item.includes("Lock") ||
+                    item.includes("lock") ||
+                    item.includes("LOCK")) {
+                    try {
+                        Log.info(`Force deleting suspected lock file: ${itemPath}`);
+                        fs.rmSync(itemPath, { recursive: true, force: true });
+                    }
+                    catch (deleteError) {
+                        Log.warn(`Failed to force delete ${itemPath}:`, deleteError);
+                    }
+                }
+            }
+        });
+    }
+    catch (error) {
+        Log.warn(`Error while removing lock files from ${dirPath}:`, error);
+    }
+}
 
 class BrowserAgent extends BaseBrowserLabelsAgent {
     constructor() {
@@ -34,6 +134,15 @@ class BrowserAgent extends BaseBrowserLabelsAgent {
     setCdpWsEndpoint(cdpWsEndpoint) {
         this.cdpWsEndpoint = cdpWsEndpoint;
     }
+    initUserDataDir(userDataDir) {
+        if (userDataDir) {
+            this.userDataDir = userDataDir;
+        }
+        else {
+            this.userDataDir = getDefaultChromeUserDataDir(true);
+        }
+        return this.userDataDir;
+    }
     setOptions(options) {
         this.options = options;
     }
@@ -193,13 +302,34 @@ class BrowserAgent extends BaseBrowserLabelsAgent {
                 this.browser_context = await chromium.launchPersistentContext(this.userDataDir, {
                     headless: this.headless,
                     // channel: 'chrome',
+                    args: [
+                        "--no-sandbox",
+                        "--remote-allow-origins=*",
+                        "--disable-dev-shm-usage",
+                        "--disable-popup-blocking",
+                        "--enable-automation",
+                        "--ignore-ssl-errors",
+                        "--ignore-certificate-errors",
+                        "--ignore-certificate-errors-spki-list",
+                        "--disable-blink-features=AutomationControlled",
+                    ],
                     ...this.options,
                 });
             }
             else {
                 this.browser = await chromium.launch({
                     headless: this.headless,
-                    args: ["--no-sandbox"],
+                    args: [
+                        "--no-sandbox",
+                        "--remote-allow-origins=*",
+                        "--disable-dev-shm-usage",
+                        "--disable-popup-blocking",
+                        "--enable-automation",
+                        "--ignore-ssl-errors",
+                        "--ignore-certificate-errors",
+                        "--ignore-certificate-errors-spki-list",
+                        "--disable-blink-features=AutomationControlled",
+                    ],
                     ...this.options,
                 });
                 this.browser_context = await this.browser.newContext();
@@ -8166,10 +8296,10 @@ glob.glob = glob;
 
 class FileAgent extends BaseFileAgent {
     async file_list(agentContext, directoryPath) {
-        const files = await fs.readdir(directoryPath);
+        const files = await fs$1.readdir(directoryPath);
         const fileDetails = await Promise.all(files.map(async (file) => {
             const filePath = path$1.join(directoryPath, file);
-            const stats = await fs.stat(filePath);
+            const stats = await fs$1.stat(filePath);
             return {
                 name: file,
                 path: filePath,
@@ -8181,32 +8311,32 @@ class FileAgent extends BaseFileAgent {
         return fileDetails;
     }
     async file_read(agentContext, filePath) {
-        return await fs.readFile(filePath, "utf-8");
+        return await fs$1.readFile(filePath, "utf-8");
     }
     async file_write(agentContext, filePath, content, append) {
         const directory = path$1.dirname(filePath);
-        await fs.mkdir(directory, { recursive: true });
+        await fs$1.mkdir(directory, { recursive: true });
         if (append) {
-            await fs.appendFile(filePath, content, "utf-8");
+            await fs$1.appendFile(filePath, content, "utf-8");
         }
         else {
-            await fs.writeFile(filePath, content, "utf-8");
+            await fs$1.writeFile(filePath, content, "utf-8");
         }
     }
     async file_str_replace(agentContext, filePath, oldStr, newStr) {
-        let content = await fs.readFile(filePath, "utf-8");
+        let content = await fs$1.readFile(filePath, "utf-8");
         const originalContent = content;
         content = content.replace(new RegExp(oldStr, "g"), newStr);
         if (content === originalContent) {
             return;
         }
-        await fs.writeFile(filePath, content, "utf-8");
+        await fs$1.writeFile(filePath, content, "utf-8");
     }
     async file_find_by_name(agentContext, directoryPath, globPattern) {
         const pattern = path$1.join(directoryPath, globPattern);
         const files = await glob.glob(pattern);
         const fileDetails = await Promise.all(files.map(async (file) => {
-            const stats = await fs.stat(file);
+            const stats = await fs$1.stat(file);
             return {
                 name: path$1.basename(file),
                 path: file,
@@ -8277,7 +8407,9 @@ class SimpleStdioMcpClient {
             const callback = new Promise((resolve, reject) => {
                 if (signal) {
                     signal.addEventListener("abort", () => {
-                        reject(new Error("AbortError"));
+                        const error = new Error("Operation was interrupted");
+                        error.name = "AbortError";
+                        reject(error);
                     });
                 }
                 this.requestMap.set(id, resolve);