@eko-ai/eko 1.0.1 → 1.0.3

package/dist/nodejs.esm.js

@@ -1,5 +1,228 @@
-var index = /*#__PURE__*/Object.freeze({
-	__proto__: null
+import { createInterface } from 'readline';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { readFile, access, appendFile, writeFile } from 'fs/promises';
+import { resolve } from 'path';
+import { constants } from 'fs';
+
+const execAsync = promisify(exec);
+class CommandExecute {
+    constructor() {
+        this.name = 'command_execute';
+        this.description = 'Execute a shell command with user confirmation';
+        this.input_schema = {
+            type: 'object',
+            properties: {
+                command: {
+                    type: 'string',
+                    description: 'The command to execute. Ensure that the command is non-interactive and does not require user input.'
+                },
+                cwd: {
+                    type: 'string',
+                    description: 'Working directory for command execution'
+                }
+            },
+            required: ['command']
+        };
+    }
+    async getUserConfirmation(command) {
+        const rl = createInterface({
+            input: process.stdin,
+            output: process.stdout
+        });
+        return new Promise(resolve => {
+            rl.question(`Are you sure you want to execute command: "${command}"? (y/N) `, answer => {
+                rl.close();
+                resolve(answer.toLowerCase() === 'y');
+            });
+        });
+    }
+    async execute(context, params) {
+        const confirmed = await this.getUserConfirmation(params.command);
+        if (!confirmed) {
+            return {
+                executed: false,
+                reason: 'User cancelled execution'
+            };
+        }
+        try {
+            const { stdout, stderr } = await execAsync(params.command, {
+                cwd: params.cwd
+            });
+            return {
+                executed: true,
+                stdout,
+                stderr
+            };
+        }
+        catch (error) {
+            const err = error;
+            return {
+                executed: false,
+                error: err.message,
+                code: err.code,
+                stderr: err.stderr
+            };
+        }
+    }
+}
+
+class FileRead {
+    constructor() {
+        this.name = 'file_read';
+        this.description = 'Read content from a file';
+        this.input_schema = {
+            type: 'object',
+            properties: {
+                path: {
+                    type: 'string',
+                    description: 'Path to the file to read'
+                },
+                encoding: {
+                    type: 'string',
+                    description: 'File encoding (default: utf8)',
+                    enum: ['utf8', 'ascii', 'utf16le', 'base64', 'binary']
+                }
+            },
+            required: ['path']
+        };
+    }
+    async execute(context, params) {
+        try {
+            const fullPath = resolve(params.path);
+            const content = await readFile(fullPath, {
+                encoding: params.encoding || 'utf8'
+            });
+            return {
+                success: true,
+                path: fullPath,
+                content
+            };
+        }
+        catch (error) {
+            const err = error;
+            return {
+                success: false,
+                error: err.message,
+                code: err.code
+            };
+        }
+    }
+}
+
+class FileWrite {
+    constructor() {
+        this.name = 'file_write';
+        this.description = 'Write content to a file with user confirmation';
+        this.input_schema = {
+            type: 'object',
+            properties: {
+                path: {
+                    type: 'string',
+                    description: 'Path to write the file'
+                },
+                content: {
+                    type: 'string',
+                    description: 'Content to write to the file'
+                },
+                append: {
+                    type: 'boolean',
+                    description: 'Whether to append to existing file (default: false)'
+                },
+                encoding: {
+                    type: 'string',
+                    description: 'File encoding (default: utf8)',
+                    enum: ['utf8', 'ascii', 'utf16le', 'base64', 'binary']
+                }
+            },
+            required: ['path', 'content']
+        };
+    }
+    async checkFileExists(path) {
+        try {
+            await access(path, constants.F_OK);
+            return true;
+        }
+        catch (_a) {
+            return false;
+        }
+    }
+    async getUserConfirmation(path, exists, append) {
+        const rl = createInterface({
+            input: process.stdin,
+            output: process.stdout
+        });
+        const action = exists
+            ? (append ? 'append to' : 'overwrite')
+            : 'create';
+        return new Promise(resolve => {
+            rl.question(`Are you sure you want to ${action} file at "${path}"? (y/N) `, answer => {
+                rl.close();
+                resolve(answer.toLowerCase() === 'y');
+            });
+        });
+    }
+    async execute(context, params) {
+        try {
+            const fullPath = resolve(params.path);
+            const exists = await this.checkFileExists(fullPath);
+            const append = params.append || false;
+            const confirmed = await this.getUserConfirmation(fullPath, exists, append);
+            if (!confirmed) {
+                return {
+                    success: false,
+                    reason: 'User cancelled operation'
+                };
+            }
+            if (append) {
+                await appendFile(fullPath, params.content, {
+                    encoding: params.encoding || 'utf8'
+                });
+            }
+            else {
+                await writeFile(fullPath, params.content, {
+                    encoding: params.encoding || 'utf8'
+                });
+            }
+            return {
+                success: true,
+                path: fullPath,
+                action: append ? 'append' : 'write'
+            };
+        }
+        catch (error) {
+            const err = error;
+            return {
+                success: false,
+                error: err.message,
+                code: err.code
+            };
+        }
+    }
+}
+
+var tools = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    CommandExecute: CommandExecute,
+    FileRead: FileRead,
+    FileWrite: FileWrite
 });
 
-export { index as tools };
+function getAllTools() {
+    let toolsMap = new Map();
+    for (const key in tools) {
+        let tool = tools[key];
+        if (typeof tool === 'function' && tool.prototype && 'execute' in tool.prototype) {
+            try {
+                let instance = new tool();
+                toolsMap.set(instance.name || key, instance);
+            }
+            catch (e) {
+                console.error(`Failed to instantiate ${key}:`, e);
+            }
+        }
+    }
+    return toolsMap;
+}
+
+export { getAllTools, tools };

package/dist/schemas/workflow.schema.d.ts

@@ -63,6 +63,9 @@ export declare const workflowSchema: {
                             name: {
                                 type: string;
                             };
+                            description: {
+                                type: string;
+                            };
                             params: {
                                 type: string;
                             };

package/dist/services/llm/claude-provider.d.ts

@@ -3,6 +3,7 @@ import { LLMProvider, LLMParameters, LLMResponse, Message, LLMStreamHandler } fr
 export declare class ClaudeProvider implements LLMProvider {
     private client;
     private defaultModel;
+    constructor(options: ClientOptions, defaultModel?: string);
     constructor(apiKey: string, defaultModel?: string | null, options?: ClientOptions);
     private processResponse;
     generateText(messages: Message[], params: LLMParameters): Promise<LLMResponse>;

package/dist/services/llm/openai-provider.d.ts

@@ -3,6 +3,7 @@ import { LLMProvider, LLMParameters, LLMResponse, Message, LLMStreamHandler } fr
 export declare class OpenaiProvider implements LLMProvider {
     private client;
     private defaultModel;
+    constructor(options: ClientOptions, defaultModel?: string);
     constructor(apiKey: string, defaultModel?: string | null, options?: ClientOptions);
     private buildParams;
     generateText(messages: Message[], params: LLMParameters): Promise<LLMResponse>;

package/dist/types/action.types.d.ts

@@ -27,10 +27,12 @@ export interface ExecutionContext {
     variables: Map<string, unknown>;
     tools?: Map<string, Tool<any, any>>;
     callback?: WorkflowCallback;
+    [key: string]: any;
 }
 export interface Action {
     type: 'prompt' | 'script' | 'hybrid';
     name: string;
+    description: string;
     execute: (input: unknown, context: ExecutionContext) => Promise<unknown>;
     tools: Tool<any, any>[];
 }

package/dist/web/core.d.ts

@@ -0,0 +1,2 @@
+import { Tool } from '../types';
+export declare function getAllTools(): Map<string, Tool<any, any>>;

package/dist/web/index.d.ts

@@ -1,2 +1,3 @@
+export * from './core';
 import * as tools from './tools';
 export { tools };

package/dist/web/script/build_dom_tree.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Get clickable elements on the page
+ *
+ * @param {*} doHighlightElements Is highlighted
+ * @param {*} includeAttributes [attr_names...]
+ * @returns { element_str, selector_map }
+ */
+export function get_clickable_elements(doHighlightElements: any | undefined, includeAttributes: any): string;
+export function get_highlight_element(highlightIndex: any): any;
+export function remove_highlight(): void;

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

@@ -0,0 +1,20 @@
+import { ScreenshotResult } from '../../types/tools.types';
+export declare function type(text: string, xpath?: string, highlightIndex?: number): boolean;
+export declare function clear_input(xpath?: string, highlightIndex?: number): boolean;
+export declare function left_click(xpath?: string, highlightIndex?: number): boolean;
+export declare function right_click(xpath?: string, highlightIndex?: number): boolean;
+export declare function double_click(xpath?: string, highlightIndex?: number): boolean;
+export declare function screenshot(): Promise<ScreenshotResult>;
+export declare function scroll_to(xpath?: string, highlightIndex?: number): boolean;
+export declare function get_dropdown_options(xpath?: string, highlightIndex?: number): {
+    options: Array<{
+        index: number;
+        text: string;
+        value?: string;
+    }>;
+    id?: string;
+    name?: string;
+} | null;
+export declare function select_dropdown_option(text: string, xpath?: string, highlightIndex?: number): any;
+export declare function extractHtmlContent(): string;
+export declare function size(): [number, number];

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

@@ -0,0 +1,19 @@
+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>;
+    destroy(context: ExecutionContext): void;
+}

package/dist/web/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/web/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/web/tools/extract_content.d.ts

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

package/dist/web/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/web/tools/html_script.d.ts

@@ -0,0 +1,10 @@
+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): 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/web/tools/index.d.ts

@@ -1 +1,7 @@
-export {};
+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 { Screenshot } from './screenshot';
+export { BrowserUse, ElementClick, ExportFile, ExtractContent, FindElementPosition, Screenshot, };

package/dist/web/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>;
+}