@eko-ai/eko 1.0.1

package/dist/extension/script/common.js

@@ -0,0 +1,204 @@
+/**
+ * Common JS function
+ */
+if (!window.eko) {
+    window.eko = {}
+}
+
+/**
+ * Extract html content
+ */
+eko.extractHtmlContent = function (element) {
+    element = element || document.body
+    let main = element.querySelector('main')
+    let content = ''
+    if (main) {
+        let articles = main.querySelectorAll('article')
+        if (articles && articles.length > 0) {
+            for (let i = 0; i < articles.length; i++) {
+                content += articles[i].innerText.trim() + '\n'
+            }
+        } else {
+            content += main.innerText.trim()
+        }
+    } else {
+        let articles = element.querySelectorAll('article')
+        if (articles && articles.length > 0) {
+            for (let i = 0; i < articles.length; i++) {
+                content += articles[i].innerText.trim() + '\n'
+            }
+        }
+    }
+    content = content.trim()
+    if (!content) {
+        content = element.innerText
+    }
+    return content.replaceAll(/\n+/g, '\n').replaceAll(/ +/g, ' ').trim()
+}
+
+/**
+ * Element text (remove consecutive spaces and line breaks)
+ * 
+ * @param {HTMLElement|string} object
+ * @returns text
+ */
+eko.cleanText = function(object) {
+    let str = (typeof object == 'string') ? object : object?.innerText
+    return str ? str.replaceAll(/\s+/g, ' ').trim() : ''
+}
+
+/**
+ * sleep
+ * 
+ * @param {number} time millisecond
+ */
+eko.sleep = function(time) {
+    return new Promise(resolve => setTimeout(() => resolve(), time))
+}
+
+/**
+ * element displayed
+ * 
+ * @param {HTMLElement} element 
+ */
+eko.isDisplayed = function (element) {
+    return element && window.getComputedStyle(element).getPropertyValue('display') != 'none'
+}
+
+/**
+ * click
+ * 
+ * @param {HTMLElement} element
+ */
+eko.click = function(element) {
+    if (element.click) {
+        element.click()
+    } else {
+        element.dispatchEvent(new MouseEvent('click', {
+            view: window,
+            bubbles: true,
+            cancelable: true
+        }))
+    }
+}
+
+/**
+ * Trigger simulated input
+ */
+eko.sendKeys = function(element, str, clear, keypress) {
+    element.focus && element.focus()
+    if (clear) {
+        for (let i = 0; i < element.value.length; i++) {
+            element.dispatchEvent(new KeyboardEvent('keydown', { key: 'Backspace' }))
+        }
+        element.value = ''
+    }
+    if (keypress) {
+        Array.from(str).forEach(key => {
+            element.dispatchEvent(new KeyboardEvent('keypress', { key }))
+        })
+        element.value += str
+        element.dispatchEvent(new Event('input'))
+    } else {
+        element.value += str
+        element.dispatchEvent(new Event('input', { bubbles: true }))
+    }
+}
+
+/**
+ * Waiting for Dom to change
+ */
+eko.waitForDomChanged = function (targetElement, fun, timeout, config, firstExecute) {
+    targetElement = targetElement || document.body
+    return new Promise((resolve) => {
+        if (firstExecute) {
+            let result = fun({})
+            if (result) {
+                resolve(result)
+            }
+        }
+        var observer = { value: null }
+        let timeId = setTimeout(() => {
+            observer.value && observer.value.disconnect()
+            resolve()
+        }, timeout)
+        observer.value = new MutationObserver((mutations) => {
+            try {
+                let result = fun(mutations)
+                if (result) {
+                    clearTimeout(timeId)
+                    observer.value && observer.value.disconnect()
+                    resolve(result)
+                }
+            } catch (e) {}
+        });
+        if (!config) {
+            config = {}
+        }
+        observer.value.observe(targetElement, { attributes: true, childList: true, subtree: true, ...config })
+    })
+}
+
+/**
+ * Wait for the page to finish loading after onload
+ */
+eko.waitLoaded = async function() {
+    await eko.waitForDomChanged(document.body, () => document.readyState == 'complete', 5000, {}, true)
+    await eko.sleep(500)
+}
+
+/**
+ * Wait for the element to present
+ */
+eko.waitForElementPresent = function (targetElement, cssSelector, timeout) {
+    targetElement = targetElement || document.body
+    return eko.waitForDomChanged(targetElement, () => targetElement.querySelector(cssSelector), timeout, { attributes: false }, true)
+}
+
+/**
+ * Wait for the element to displayed
+ */
+eko.waitForElementDisplayed = function (targetElement, cssSelector, timeout) {
+    targetElement = targetElement || document.body
+    return eko.waitForDomChanged(targetElement, () => {
+        let element = targetElement.querySelector(cssSelector)
+        if (element) {
+            let visibility = window.getComputedStyle(element).getPropertyValue('display')
+            if (visibility != 'none') {
+                return element
+            } else {
+                return false
+            }
+        } else {
+            return false
+        }
+    }, timeout, {}, true)
+}
+
+/**
+ * Wait for the element to present
+ */
+eko.waitForElementNotPresent = function (targetElement, cssSelector, timeout) {
+    targetElement = targetElement || document.body
+    return eko.waitForDomChanged(targetElement, () => !targetElement.querySelector(cssSelector), timeout, { attributes: false }, true)
+}
+
+/**
+ * Waiting for element to be invisible
+ */
+eko.waitForElementNotDisplayed = function (targetElement, cssSelector, timeout) {
+    targetElement = targetElement || document.body
+    return eko.waitForDomChanged(targetElement, () => {
+        let element = targetElement.querySelector(cssSelector)
+        if (element) {
+            let visibility = window.getComputedStyle(element).getPropertyValue('display')
+            if (visibility != 'none') {
+                return false
+            } else {
+                return true
+            }
+        } else {
+            return true
+        }
+    }, timeout, {}, true)
+}

package/dist/extension/script/duckduckgo.js

@@ -0,0 +1,25 @@
+
+eko.getDetailLinks = async function (search) {
+    await eko.waitForElementPresent(document.body, 'section h2 a', 5000)
+    let search_list = document.querySelectorAll('section h2 a')
+    if (search_list.length === 0) {
+        search_list = document.querySelectorAll('h2 a')
+    }
+    let links = []
+    for (let i = 0; i < search_list.length; i++) {
+        let title = eko.cleanText(search_list[i])
+        let url = search_list[i].getAttribute('href')
+        links.push({ title, url })
+    }
+    return {
+        links: links
+    }
+}
+
+eko.getContent = async function (search) {
+    await eko.waitLoaded()
+    return {
+        title: document.title,
+        content: eko.extractHtmlContent()
+    }
+}

package/dist/extension/script/google.js

@@ -0,0 +1,26 @@
+
+eko.getDetailLinks = async function (search) {
+    let search_div = await eko.waitForElementPresent(document.body, '#search', 5000)
+    if (!search_div) {
+        search_div = document.body
+    }
+    let links = []
+    let elements = search_div.querySelectorAll('a:has(h3)')
+    for (let i = 0; i < elements.length; i++) {
+        let h3 = elements[i].querySelector('h3')
+        let title = eko.cleanText(h3)
+        let url = elements[i].getAttribute('href')
+        links.push({ title, url })
+    }
+    return {
+        links: links
+    }
+}
+
+eko.getContent = async function (search) {
+    await eko.waitLoaded()
+    return {
+        title: document.title,
+        content: eko.extractHtmlContent()
+    }
+}

package/dist/extension/tools/browser.d.ts

@@ -0,0 +1,21 @@
+import { ScreenshotResult } from '../../types/tools.types';
+export declare function key(tabId: number, key: string, coordinate?: [number, number]): Promise<any>;
+export declare function type(tabId: number, text: string, coordinate?: [number, number]): Promise<any>;
+export declare function type_by_xpath(tabId: number, text: string, xpath: string): Promise<any>;
+export declare function clear_input(tabId: number, coordinate?: [number, number]): Promise<any>;
+export declare function clear_input_by_xpath(tabId: number, xpath: string): Promise<any>;
+export declare function mouse_move(tabId: number, coordinate: [number, number]): Promise<any>;
+export declare function left_click(tabId: number, coordinate?: [number, number]): Promise<any>;
+export declare function left_click_by_xpath(tabId: number, xpath: string): Promise<any>;
+export declare function left_click_drag(tabId: number, coordinate: [number, number]): Promise<any>;
+export declare function right_click(tabId: number, coordinate?: [number, number]): Promise<any>;
+export declare function right_click_by_xpath(tabId: number, xpath: string): Promise<any>;
+export declare function double_click(tabId: number, coordinate?: [number, number]): Promise<any>;
+export declare function double_click_by_xpath(tabId: number, xpath: string): Promise<any>;
+export declare function screenshot(windowId: number): Promise<ScreenshotResult>;
+export declare function scroll_to(tabId: number, coordinate: [number, number]): Promise<any>;
+export declare function scroll_to_xpath(tabId: number, xpath: string): Promise<any>;
+export declare function cursor_position(tabId: number): Promise<{
+    coordinate: [number, number];
+}>;
+export declare function size(tabId?: number): Promise<[number, number]>;

package/dist/extension/tools/browser_use.d.ts

@@ -0,0 +1,18 @@
+import { BrowserUseParam, BrowserUseResult } from '../../types/tools.types';
+import { Tool, InputSchema, ExecutionContext } from '../../types/action.types';
+/**
+ * Browser Use for general
+ */
+export declare class BrowserUse implements Tool<BrowserUseParam, BrowserUseResult> {
+    name: string;
+    description: string;
+    input_schema: InputSchema;
+    constructor();
+    /**
+     * browser
+     *
+     * @param {*} params { action: 'input_text', index: 1, text: 'string' }
+     * @returns > { success: true, image?: { type: 'base64', media_type: 'image/jpeg', data: '/9j...' }, text?: string }
+     */
+    execute(context: ExecutionContext, params: BrowserUseParam): Promise<BrowserUseResult>;
+}

package/dist/extension/tools/element_click.d.ts

@@ -0,0 +1,12 @@
+import { Tool, InputSchema, ExecutionContext } from '../../types/action.types';
+import { TaskPrompt } from '../../types/tools.types';
+/**
+ * Element click
+ */
+export declare class ElementClick implements Tool<TaskPrompt, any> {
+    name: string;
+    description: string;
+    input_schema: InputSchema;
+    constructor();
+    execute(context: ExecutionContext, params: TaskPrompt): Promise<any>;
+}

package/dist/extension/tools/export_file.d.ts

@@ -0,0 +1,18 @@
+import { ExportFileParam } from '../../types/tools.types';
+import { Tool, InputSchema, ExecutionContext } from '../../types/action.types';
+/**
+ * Export file
+ */
+export declare class ExportFile implements Tool<ExportFileParam, unknown> {
+    name: string;
+    description: string;
+    input_schema: InputSchema;
+    constructor();
+    /**
+     * export
+     *
+     * @param {*} params { fileType: 'csv', content: 'field1,field2\ndata1,data2' }
+     * @returns > { success: true }
+     */
+    execute(context: ExecutionContext, params: ExportFileParam): Promise<unknown>;
+}

package/dist/extension/tools/extract_content.d.ts

@@ -0,0 +1,18 @@
+import { ExtractContentResult } from '../../types/tools.types';
+import { Tool, InputSchema, ExecutionContext } from '../../types/action.types';
+/**
+ * Extract Page Content
+ */
+export declare class ExtractContent implements Tool<any, ExtractContentResult> {
+    name: string;
+    description: string;
+    input_schema: InputSchema;
+    constructor();
+    /**
+     * Extract Page Content
+     *
+     * @param {*} params {}
+     * @returns > { tabId, result: { title, url, content }, success: true }
+     */
+    execute(context: ExecutionContext, params: any): Promise<ExtractContentResult>;
+}

package/dist/extension/tools/find_element_position.d.ts

@@ -0,0 +1,12 @@
+import { Tool, InputSchema, ExecutionContext } from '../../types/action.types';
+import { TaskPrompt, ElementRect } from '../../types/tools.types';
+/**
+ * Find Element Position
+ */
+export declare class FindElementPosition implements Tool<TaskPrompt, ElementRect | null> {
+    name: string;
+    description: string;
+    input_schema: InputSchema;
+    constructor();
+    execute(context: ExecutionContext, params: TaskPrompt): Promise<ElementRect | null>;
+}

package/dist/extension/tools/form_autofill.d.ts

@@ -0,0 +1,11 @@
+import { Tool, InputSchema, ExecutionContext } from '../../types/action.types';
+/**
+ * Form Autofill
+ */
+export declare class FormAutofill implements Tool<any, any> {
+    name: string;
+    description: string;
+    input_schema: InputSchema;
+    constructor();
+    execute(context: ExecutionContext, params: any): Promise<any>;
+}

package/dist/extension/tools/html_script.d.ts

@@ -0,0 +1,21 @@
+import { ElementRect } from '../../types/tools.types';
+export declare function exportFile(filename: string, type: string, content: string): void;
+export declare function xpath(element: any): string;
+export declare function queryWithXpath(xpath: string): Node | null;
+export declare function queryAllWithXpath(xpath: string): Array<any>;
+export declare function getDropdownOptions(xpath: string): {
+    options: Array<{
+        index: number;
+        text: string;
+        value?: string;
+    }>;
+    id?: string;
+    name?: string;
+} | null;
+export declare function selectDropdownOption(xpath: string, text: string): any;
+/**
+ * Extract the elements related to html operability and wrap them into pseudo-html code.
+ */
+export declare function extractOperableElements(): string;
+export declare function clickOperableElement(id: any): any;
+export declare function getOperableElementRect(id: any): ElementRect | null;

package/dist/extension/tools/index.d.ts

@@ -0,0 +1,11 @@
+import { BrowserUse } from './browser_use';
+import { ElementClick } from './element_click';
+import { ExportFile } from './export_file';
+import { ExtractContent } from './extract_content';
+import { FindElementPosition } from './find_element_position';
+import { FormAutofill } from './form_autofill';
+import { OpenUrl } from './open_url';
+import { Screenshot } from './screenshot';
+import { TabManagement } from './tab_management';
+import { WebSearch } from './web_search';
+export { BrowserUse, ElementClick, ExportFile, ExtractContent, FindElementPosition, FormAutofill, OpenUrl, Screenshot, TabManagement, WebSearch, };

package/dist/extension/tools/open_url.d.ts

@@ -0,0 +1,18 @@
+import { OpenUrlParam, OpenUrlResult } from '../../types/tools.types';
+import { Tool, InputSchema, ExecutionContext } from '../../types/action.types';
+/**
+ * Open Url
+ */
+export declare class OpenUrl implements Tool<OpenUrlParam, OpenUrlResult> {
+    name: string;
+    description: string;
+    input_schema: InputSchema;
+    constructor();
+    /**
+     * Open Url
+     *
+     * @param {*} params { url: 'https://www.google.com', newWindow: true }
+     * @returns > { tabId, windowId, title, success: true }
+     */
+    execute(context: ExecutionContext, params: OpenUrlParam): Promise<OpenUrlResult>;
+}

package/dist/extension/tools/screenshot.d.ts

@@ -0,0 +1,18 @@
+import { Tool, InputSchema, ExecutionContext } from '../../types/action.types';
+import { ScreenshotResult } from '../../types/tools.types';
+/**
+ * Current Page Screenshot
+ */
+export declare class Screenshot implements Tool<any, ScreenshotResult> {
+    name: string;
+    description: string;
+    input_schema: InputSchema;
+    constructor();
+    /**
+     * Current Page Screenshot
+     *
+     * @param {*} params {}
+     * @returns > { image: { type: 'base64', media_type: 'image/png', data } }
+     */
+    execute(context: ExecutionContext, params: unknown): Promise<ScreenshotResult>;
+}

package/dist/extension/tools/tab_management.d.ts

@@ -0,0 +1,19 @@
+import { TabManagementParam, TabManagementResult } from '../../types/tools.types';
+import { Tool, InputSchema, ExecutionContext } from '../../types/action.types';
+/**
+ * Browser tab management
+ */
+export declare class TabManagement implements Tool<TabManagementParam, TabManagementResult> {
+    name: string;
+    description: string;
+    input_schema: InputSchema;
+    constructor();
+    /**
+     * Tab management
+     *
+     * @param {*} params { commond: `new_tab [url]` | 'tab_all' | 'current_tab' | 'go_back' | 'close_tab' | 'switch_tab [tabId]' | `change_url [url]` }
+     * @returns > { result, success: true }
+     */
+    execute(context: ExecutionContext, params: TabManagementParam): Promise<TabManagementResult>;
+    destroy(context: ExecutionContext): void;
+}

package/dist/extension/tools/web_search.d.ts

@@ -0,0 +1,18 @@
+import { WebSearchParam, WebSearchResult } from '../../types/tools.types';
+import { Tool, InputSchema, ExecutionContext } from '../../types/action.types';
+/**
+ * Web Search
+ */
+export declare class WebSearch implements Tool<WebSearchParam, WebSearchResult[]> {
+    name: string;
+    description: string;
+    input_schema: InputSchema;
+    constructor();
+    /**
+     * search
+     *
+     * @param {*} params { url: 'https://www.google.com', query: 'ai agent', maxResults: 5 }
+     * @returns > [{ title, url, content }]
+     */
+    execute(context: ExecutionContext, params: WebSearchParam): Promise<WebSearchResult[]>;
+}

package/dist/extension/utils.d.ts

@@ -0,0 +1,30 @@
+import { ExecutionContext } from '../types/action.types';
+export declare function getWindowId(context: ExecutionContext): Promise<number>;
+export declare function getTabId(context: ExecutionContext): Promise<number>;
+export declare function getCurrentTabId(): Promise<number | undefined>;
+export declare function open_new_tab(url: string, newWindow: boolean, windowId?: number): Promise<chrome.tabs.Tab>;
+export declare function executeScript(tabId: number, func: any, args: any[]): Promise<any>;
+export declare function waitForTabComplete(tabId: number, timeout?: number): Promise<chrome.tabs.Tab>;
+export declare function getPageSize(tabId?: number): Promise<[number, number]>;
+export declare function sleep(time: number): Promise<void>;
+export declare function injectScript(tabId: number, filename?: string): Promise<void>;
+export declare class MsgEvent {
+    eventMap: {
+        [key: string]: Function;
+    };
+    constructor();
+    addListener(callback: Function, id: string): string;
+    removeListener(id: string): void;
+    publish(msg: any): Promise<void>;
+}
+/**
+ * Counter (Function: Wait for all asynchronous tasks to complete)
+ */
+export declare class CountDownLatch {
+    resolve?: Function;
+    currentCount: number;
+    constructor(count: number);
+    countDown(): void;
+    await(timeout: number): Promise<void>;
+}
+export declare function isPromise(obj: any): boolean;