@push.rocks/smartagent 1.0.2

package/dist_ts/smartagent.tools.browser.d.ts

@@ -0,0 +1,16 @@
+import * as interfaces from './smartagent.interfaces.js';
+import { BaseToolWrapper } from './smartagent.tools.base.js';
+/**
+ * Browser tool for web page interaction
+ * Wraps @push.rocks/smartbrowser (Puppeteer-based)
+ */
+export declare class BrowserTool extends BaseToolWrapper {
+    name: string;
+    description: string;
+    actions: interfaces.IToolAction[];
+    private smartbrowser;
+    initialize(): Promise<void>;
+    cleanup(): Promise<void>;
+    execute(action: string, params: Record<string, unknown>): Promise<interfaces.IToolExecutionResult>;
+    getCallSummary(action: string, params: Record<string, unknown>): string;
+}

package/dist_ts/smartagent.tools.browser.js

@@ -0,0 +1,177 @@
+import * as plugins from './plugins.js';
+import * as interfaces from './smartagent.interfaces.js';
+import { BaseToolWrapper } from './smartagent.tools.base.js';
+/**
+ * Browser tool for web page interaction
+ * Wraps @push.rocks/smartbrowser (Puppeteer-based)
+ */
+export class BrowserTool extends BaseToolWrapper {
+    name = 'browser';
+    description = 'Interact with web pages - take screenshots, generate PDFs, and execute JavaScript on pages';
+    actions = [
+        {
+            name: 'screenshot',
+            description: 'Take a screenshot of a webpage',
+            parameters: {
+                type: 'object',
+                properties: {
+                    url: { type: 'string', description: 'URL of the page to screenshot' },
+                },
+                required: ['url'],
+            },
+        },
+        {
+            name: 'pdf',
+            description: 'Generate a PDF from a webpage',
+            parameters: {
+                type: 'object',
+                properties: {
+                    url: { type: 'string', description: 'URL of the page to convert to PDF' },
+                },
+                required: ['url'],
+            },
+        },
+        {
+            name: 'evaluate',
+            description: 'Execute JavaScript code on a webpage and return the result. The script runs in the browser context.',
+            parameters: {
+                type: 'object',
+                properties: {
+                    url: { type: 'string', description: 'URL of the page to run the script on' },
+                    script: {
+                        type: 'string',
+                        description: 'JavaScript code to execute. Must be a valid expression or statements that return a value.',
+                    },
+                },
+                required: ['url', 'script'],
+            },
+        },
+        {
+            name: 'getPageContent',
+            description: 'Get the text content and title of a webpage',
+            parameters: {
+                type: 'object',
+                properties: {
+                    url: { type: 'string', description: 'URL of the page to get content from' },
+                },
+                required: ['url'],
+            },
+        },
+    ];
+    smartbrowser;
+    async initialize() {
+        this.smartbrowser = new plugins.smartbrowser.SmartBrowser();
+        await this.smartbrowser.start();
+        this.isInitialized = true;
+    }
+    async cleanup() {
+        if (this.smartbrowser) {
+            await this.smartbrowser.stop();
+        }
+        this.isInitialized = false;
+    }
+    async execute(action, params) {
+        this.validateAction(action);
+        this.ensureInitialized();
+        try {
+            switch (action) {
+                case 'screenshot': {
+                    const result = await this.smartbrowser.screenshotFromPage(params.url);
+                    return {
+                        success: true,
+                        result: {
+                            url: params.url,
+                            name: result.name,
+                            id: result.id,
+                            bufferBase64: Buffer.from(result.buffer).toString('base64'),
+                            bufferLength: result.buffer.length,
+                            type: 'screenshot',
+                        },
+                    };
+                }
+                case 'pdf': {
+                    const result = await this.smartbrowser.pdfFromPage(params.url);
+                    return {
+                        success: true,
+                        result: {
+                            url: params.url,
+                            name: result.name,
+                            id: result.id,
+                            bufferBase64: Buffer.from(result.buffer).toString('base64'),
+                            bufferLength: result.buffer.length,
+                            type: 'pdf',
+                        },
+                    };
+                }
+                case 'evaluate': {
+                    const script = params.script;
+                    // Create an async function from the script
+                    // The script should be valid JavaScript that returns a value
+                    const result = await this.smartbrowser.evaluateOnPage(params.url, async () => {
+                        // This runs in the browser context
+                        // We need to evaluate the script string dynamically
+                        // eslint-disable-next-line no-eval
+                        return eval(script);
+                    });
+                    return {
+                        success: true,
+                        result: {
+                            url: params.url,
+                            script: script.substring(0, 200) + (script.length > 200 ? '...' : ''),
+                            evaluationResult: result,
+                        },
+                    };
+                }
+                case 'getPageContent': {
+                    const result = await this.smartbrowser.evaluateOnPage(params.url, async () => {
+                        return {
+                            title: document.title,
+                            textContent: document.body?.innerText || '',
+                            url: window.location.href,
+                        };
+                    });
+                    return {
+                        success: true,
+                        result: {
+                            url: params.url,
+                            title: result.title,
+                            textContent: result.textContent.length > 10000
+                                ? result.textContent.substring(0, 10000) + '... [truncated]'
+                                : result.textContent,
+                            actualUrl: result.url,
+                        },
+                    };
+                }
+                default:
+                    return {
+                        success: false,
+                        error: `Unknown action: ${action}`,
+                    };
+            }
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
+    getCallSummary(action, params) {
+        switch (action) {
+            case 'screenshot':
+                return `Take screenshot of "${params.url}"`;
+            case 'pdf':
+                return `Generate PDF from "${params.url}"`;
+            case 'evaluate': {
+                const script = params.script;
+                const preview = script.length > 100 ? script.substring(0, 100) + '...' : script;
+                return `Execute JavaScript on "${params.url}": "${preview}"`;
+            }
+            case 'getPageContent':
+                return `Get text content and title from "${params.url}"`;
+            default:
+                return `Unknown action: ${action}`;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/smartagent.tools.filesystem.d.ts

@@ -0,0 +1,16 @@
+import * as interfaces from './smartagent.interfaces.js';
+import { BaseToolWrapper } from './smartagent.tools.base.js';
+/**
+ * Filesystem tool for file and directory operations
+ * Wraps @push.rocks/smartfs
+ */
+export declare class FilesystemTool extends BaseToolWrapper {
+    name: string;
+    description: string;
+    actions: interfaces.IToolAction[];
+    private smartfs;
+    initialize(): Promise<void>;
+    cleanup(): Promise<void>;
+    execute(action: string, params: Record<string, unknown>): Promise<interfaces.IToolExecutionResult>;
+    getCallSummary(action: string, params: Record<string, unknown>): string;
+}

package/dist_ts/smartagent.tools.filesystem.js

@@ -0,0 +1,352 @@
+import * as plugins from './plugins.js';
+import * as interfaces from './smartagent.interfaces.js';
+import { BaseToolWrapper } from './smartagent.tools.base.js';
+/**
+ * Filesystem tool for file and directory operations
+ * Wraps @push.rocks/smartfs
+ */
+export class FilesystemTool extends BaseToolWrapper {
+    name = 'filesystem';
+    description = 'Read, write, list, and delete files and directories';
+    actions = [
+        {
+            name: 'read',
+            description: 'Read the contents of a file',
+            parameters: {
+                type: 'object',
+                properties: {
+                    path: { type: 'string', description: 'Absolute path to the file' },
+                    encoding: {
+                        type: 'string',
+                        enum: ['utf8', 'binary', 'base64'],
+                        default: 'utf8',
+                        description: 'File encoding',
+                    },
+                },
+                required: ['path'],
+            },
+        },
+        {
+            name: 'write',
+            description: 'Write content to a file (creates or overwrites)',
+            parameters: {
+                type: 'object',
+                properties: {
+                    path: { type: 'string', description: 'Absolute path to the file' },
+                    content: { type: 'string', description: 'Content to write' },
+                    encoding: {
+                        type: 'string',
+                        enum: ['utf8', 'binary', 'base64'],
+                        default: 'utf8',
+                        description: 'File encoding',
+                    },
+                },
+                required: ['path', 'content'],
+            },
+        },
+        {
+            name: 'append',
+            description: 'Append content to a file',
+            parameters: {
+                type: 'object',
+                properties: {
+                    path: { type: 'string', description: 'Absolute path to the file' },
+                    content: { type: 'string', description: 'Content to append' },
+                },
+                required: ['path', 'content'],
+            },
+        },
+        {
+            name: 'list',
+            description: 'List files and directories in a path',
+            parameters: {
+                type: 'object',
+                properties: {
+                    path: { type: 'string', description: 'Directory path to list' },
+                    recursive: { type: 'boolean', default: false, description: 'List recursively' },
+                    filter: { type: 'string', description: 'Glob pattern to filter results (e.g., "*.ts")' },
+                },
+                required: ['path'],
+            },
+        },
+        {
+            name: 'delete',
+            description: 'Delete a file or directory',
+            parameters: {
+                type: 'object',
+                properties: {
+                    path: { type: 'string', description: 'Path to delete' },
+                    recursive: {
+                        type: 'boolean',
+                        default: false,
+                        description: 'For directories, delete recursively',
+                    },
+                },
+                required: ['path'],
+            },
+        },
+        {
+            name: 'exists',
+            description: 'Check if a file or directory exists',
+            parameters: {
+                type: 'object',
+                properties: {
+                    path: { type: 'string', description: 'Path to check' },
+                },
+                required: ['path'],
+            },
+        },
+        {
+            name: 'stat',
+            description: 'Get file or directory statistics (size, dates, etc.)',
+            parameters: {
+                type: 'object',
+                properties: {
+                    path: { type: 'string', description: 'Path to get stats for' },
+                },
+                required: ['path'],
+            },
+        },
+        {
+            name: 'copy',
+            description: 'Copy a file to a new location',
+            parameters: {
+                type: 'object',
+                properties: {
+                    source: { type: 'string', description: 'Source file path' },
+                    destination: { type: 'string', description: 'Destination file path' },
+                },
+                required: ['source', 'destination'],
+            },
+        },
+        {
+            name: 'move',
+            description: 'Move a file to a new location',
+            parameters: {
+                type: 'object',
+                properties: {
+                    source: { type: 'string', description: 'Source file path' },
+                    destination: { type: 'string', description: 'Destination file path' },
+                },
+                required: ['source', 'destination'],
+            },
+        },
+        {
+            name: 'mkdir',
+            description: 'Create a directory',
+            parameters: {
+                type: 'object',
+                properties: {
+                    path: { type: 'string', description: 'Directory path to create' },
+                    recursive: {
+                        type: 'boolean',
+                        default: true,
+                        description: 'Create parent directories if needed',
+                    },
+                },
+                required: ['path'],
+            },
+        },
+    ];
+    smartfs;
+    async initialize() {
+        this.smartfs = new plugins.smartfs.SmartFs(new plugins.smartfs.SmartFsProviderNode());
+        this.isInitialized = true;
+    }
+    async cleanup() {
+        this.isInitialized = false;
+    }
+    async execute(action, params) {
+        this.validateAction(action);
+        this.ensureInitialized();
+        try {
+            switch (action) {
+                case 'read': {
+                    const encoding = params.encoding || 'utf8';
+                    const content = await this.smartfs
+                        .file(params.path)
+                        .encoding(encoding)
+                        .read();
+                    return {
+                        success: true,
+                        result: {
+                            path: params.path,
+                            content: content.toString(),
+                            encoding,
+                        },
+                    };
+                }
+                case 'write': {
+                    const encoding = params.encoding || 'utf8';
+                    await this.smartfs
+                        .file(params.path)
+                        .encoding(encoding)
+                        .write(params.content);
+                    return {
+                        success: true,
+                        result: {
+                            path: params.path,
+                            written: true,
+                            bytesWritten: params.content.length,
+                        },
+                    };
+                }
+                case 'append': {
+                    await this.smartfs.file(params.path).append(params.content);
+                    return {
+                        success: true,
+                        result: {
+                            path: params.path,
+                            appended: true,
+                        },
+                    };
+                }
+                case 'list': {
+                    let dir = this.smartfs.directory(params.path);
+                    if (params.recursive) {
+                        dir = dir.recursive();
+                    }
+                    if (params.filter) {
+                        dir = dir.filter(params.filter);
+                    }
+                    const entries = await dir.list();
+                    return {
+                        success: true,
+                        result: {
+                            path: params.path,
+                            entries,
+                            count: entries.length,
+                        },
+                    };
+                }
+                case 'delete': {
+                    const path = params.path;
+                    // Check if it's a directory or file
+                    const exists = await this.smartfs.file(path).exists();
+                    if (exists) {
+                        // Try to get stats to check if it's a directory
+                        try {
+                            const stats = await this.smartfs.file(path).stat();
+                            if (stats.isDirectory && params.recursive) {
+                                await this.smartfs.directory(path).recursive().delete();
+                            }
+                            else {
+                                await this.smartfs.file(path).delete();
+                            }
+                        }
+                        catch {
+                            await this.smartfs.file(path).delete();
+                        }
+                    }
+                    return {
+                        success: true,
+                        result: {
+                            path,
+                            deleted: true,
+                        },
+                    };
+                }
+                case 'exists': {
+                    const exists = await this.smartfs.file(params.path).exists();
+                    return {
+                        success: true,
+                        result: {
+                            path: params.path,
+                            exists,
+                        },
+                    };
+                }
+                case 'stat': {
+                    const stats = await this.smartfs.file(params.path).stat();
+                    return {
+                        success: true,
+                        result: {
+                            path: params.path,
+                            stats,
+                        },
+                    };
+                }
+                case 'copy': {
+                    await this.smartfs.file(params.source).copy(params.destination);
+                    return {
+                        success: true,
+                        result: {
+                            source: params.source,
+                            destination: params.destination,
+                            copied: true,
+                        },
+                    };
+                }
+                case 'move': {
+                    await this.smartfs.file(params.source).move(params.destination);
+                    return {
+                        success: true,
+                        result: {
+                            source: params.source,
+                            destination: params.destination,
+                            moved: true,
+                        },
+                    };
+                }
+                case 'mkdir': {
+                    let dir = this.smartfs.directory(params.path);
+                    if (params.recursive !== false) {
+                        dir = dir.recursive();
+                    }
+                    await dir.create();
+                    return {
+                        success: true,
+                        result: {
+                            path: params.path,
+                            created: true,
+                        },
+                    };
+                }
+                default:
+                    return {
+                        success: false,
+                        error: `Unknown action: ${action}`,
+                    };
+            }
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
+    getCallSummary(action, params) {
+        switch (action) {
+            case 'read':
+                return `Read file "${params.path}" with encoding ${params.encoding || 'utf8'}`;
+            case 'write': {
+                const content = params.content;
+                const preview = content.length > 100 ? content.substring(0, 100) + '...' : content;
+                return `Write ${content.length} bytes to "${params.path}". Content preview: "${preview}"`;
+            }
+            case 'append': {
+                const content = params.content;
+                const preview = content.length > 100 ? content.substring(0, 100) + '...' : content;
+                return `Append ${content.length} bytes to "${params.path}". Content preview: "${preview}"`;
+            }
+            case 'list':
+                return `List directory "${params.path}"${params.recursive ? ' recursively' : ''}${params.filter ? ` with filter "${params.filter}"` : ''}`;
+            case 'delete':
+                return `Delete "${params.path}"${params.recursive ? ' recursively' : ''}`;
+            case 'exists':
+                return `Check if "${params.path}" exists`;
+            case 'stat':
+                return `Get statistics for "${params.path}"`;
+            case 'copy':
+                return `Copy "${params.source}" to "${params.destination}"`;
+            case 'move':
+                return `Move "${params.source}" to "${params.destination}"`;
+            case 'mkdir':
+                return `Create directory "${params.path}"${params.recursive !== false ? ' (with parents)' : ''}`;
+            default:
+                return `Unknown action: ${action}`;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"smartagent.tools.filesystem.js","sourceRoot":"","sources":["../ts/smartagent.tools.filesystem.ts"],"names":[],"mappings":"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"}

package/dist_ts/smartagent.tools.http.d.ts

@@ -0,0 +1,15 @@
+import * as interfaces from './smartagent.interfaces.js';
+import { BaseToolWrapper } from './smartagent.tools.base.js';
+/**
+ * HTTP tool for making web requests
+ * Wraps @push.rocks/smartrequest
+ */
+export declare class HttpTool extends BaseToolWrapper {
+    name: string;
+    description: string;
+    actions: interfaces.IToolAction[];
+    initialize(): Promise<void>;
+    cleanup(): Promise<void>;
+    execute(action: string, params: Record<string, unknown>): Promise<interfaces.IToolExecutionResult>;
+    getCallSummary(action: string, params: Record<string, unknown>): string;
+}