@eko-ai/eko-extension/dist/index.cjs

Empowering language to transform human words into action.

'use strict';

var eko = require('@eko-ai/eko');

class BrowserAgent extends eko.BaseBrowserLabelsAgent {
    async screenshot(agentContext) {
        let windowId = await this.getWindowId(agentContext);
        let dataUrl;
        try {
            dataUrl = await chrome.tabs.captureVisibleTab(windowId, {
                format: "jpeg",
                quality: 60,
            });
        }
        catch (e) {
            await this.sleep(1000);
            dataUrl = await chrome.tabs.captureVisibleTab(windowId, {
                format: "jpeg",
                quality: 60,
            });
        }
        let data = dataUrl.substring(dataUrl.indexOf("base64,") + 7);
        return {
            imageBase64: data,
            imageType: "image/jpeg",
        };
    }
    async navigate_to(agentContext, url) {
        let windowId = await this.getWindowId(agentContext);
        let tab = await chrome.tabs.create({
            url: url,
            windowId: windowId,
        });
        tab = await this.waitForTabComplete(tab.id);
        await this.sleep(200);
        agentContext.variables.set("windowId", tab.windowId);
        let navigateTabIds = agentContext.variables.get("navigateTabIds") || [];
        navigateTabIds.push(tab.id);
        agentContext.variables.set("navigateTabIds", navigateTabIds);
        return {
            url: url,
            title: tab.title,
            tabId: tab.id
        };
    }
    async get_all_tabs(agentContext) {
        let windowId = await this.getWindowId(agentContext);
        let tabs = await chrome.tabs.query({
            windowId: windowId,
        });
        let result = [];
        for (let i = 0; i < tabs.length; i++) {
            let tab = tabs[i];
            result.push({
                tabId: tab.id,
                url: tab.url,
                title: tab.title,
            });
        }
        return result;
    }
    async switch_tab(agentContext, tabId) {
        let tab = await chrome.tabs.update(tabId, { active: true });
        if (!tab) {
            throw new Error("tabId does not exist: " + tabId);
        }
        agentContext.variables.set("windowId", tab.windowId);
        return {
            tabId: tab.id,
            url: tab.url,
            title: tab.title,
        };
    }
    async go_back(agentContext) {
        try {
            let canGoBack = await this.execute_script(agentContext, () => {
                return window.navigation.canGoBack;
            }, []);
            if (canGoBack + "" == "true") {
                await this.execute_script(agentContext, () => {
                    window.navigation.back();
                }, []);
                await this.sleep(100);
                return;
            }
            let history_length = await this.execute_script(agentContext, () => {
                return window.history.length;
            }, []);
            if (history_length > 1) {
                await this.execute_script(agentContext, () => {
                    window.history.back();
                }, []);
            }
            else {
                let navigateTabIds = agentContext.variables.get("navigateTabIds");
                if (navigateTabIds && navigateTabIds.length > 0) {
                    return await this.switch_tab(agentContext, navigateTabIds[navigateTabIds.length - 1]);
                }
            }
            await this.sleep(100);
        }
        catch (e) {
            console.error("BrowserAgent, go_back, error: ", e);
        }
    }
    async execute_script(agentContext, func, args) {
        let tabId = await this.getTabId(agentContext);
        let frameResults = await chrome.scripting.executeScript({
            target: { tabId: tabId },
            func: func,
            args: args,
        });
        return frameResults[0].result;
    }
    async getTabId(agentContext) {
        let windowId = await this.getWindowId(agentContext);
        let tabs = (await chrome.tabs.query({
            windowId,
            active: true,
            windowType: "normal",
        }));
        if (tabs.length == 0) {
            tabs = (await chrome.tabs.query({
                windowId,
                windowType: "normal",
            }));
        }
        return tabs[tabs.length - 1].id;
    }
    async getWindowId(agentContext) {
        let windowId = agentContext.variables.get("windowId");
        if (windowId) {
            return windowId;
        }
        windowId = agentContext.context.variables.get("windowId");
        if (windowId) {
            return windowId;
        }
        let window = await chrome.windows.getLastFocused({
            windowTypes: ["normal"],
        });
        if (!window) {
            window = await chrome.windows.getCurrent({
                windowTypes: ["normal"],
            });
        }
        if (window) {
            return window.id;
        }
        let tabs = (await chrome.tabs.query({
            windowType: "normal",
            currentWindow: true,
        }));
        if (tabs.length == 0) {
            tabs = (await chrome.tabs.query({
                windowType: "normal",
                lastFocusedWindow: true,
            }));
        }
        return tabs[tabs.length - 1].windowId;
    }
    async waitForTabComplete(tabId, timeout = 8000) {
        return new Promise(async (resolve, reject) => {
            const time = setTimeout(async () => {
                chrome.tabs.onUpdated.removeListener(listener);
                let tab = await chrome.tabs.get(tabId);
                if (tab.status === "complete") {
                    resolve(tab);
                }
                else {
                    resolve(tab);
                }
            }, timeout);
            const listener = async (updatedTabId, changeInfo, tab) => {
                if (updatedTabId == tabId && changeInfo.status === "complete") {
                    chrome.tabs.onUpdated.removeListener(listener);
                    clearTimeout(time);
                    resolve(tab);
                }
            };
            let tab = await chrome.tabs.get(tabId);
            if (tab.status === "complete") {
                resolve(tab);
                clearTimeout(time);
                return;
            }
            chrome.tabs.onUpdated.addListener(listener);
        });
    }
    sleep(time) {
        return new Promise((resolve) => setTimeout(() => resolve(), time));
    }
}

exports.BrowserAgent = BrowserAgent;
//# sourceMappingURL=index.cjs.map