oblien 1.3.0 → 2.0.1

package/src/agents/tools.js

@@ -1,155 +0,0 @@
-/**
- * Tools Class
- * Manages AI tools - listing, searching, creating, and getting tool details
- */
-
-export class Tools {
-    /**
-     * @param {import('../client.js').OblienClient} client - Oblien client instance
-     */
-    constructor(client) {
-        if (!client) {
-            throw new Error('Oblien client is required');
-        }
-
-        this.client = client;
-    }
-
-    /**
-     * List all available tools with optional filters
-     * @param {Object} [options] - Filter options
-     * @param {string} [options.type] - Filter by type: 'client' | 'server' | 'hybrid'
-     * @param {string} [options.category] - Filter by category: 'custom' | 'file' | 'search' | 'terminal' | 'browser' | 'project' | 'web'
-     * @param {boolean} [options.requireEnvironment] - Filter by environment requirement
-     * @param {boolean} [options.myCustomTools] - Show only user's custom tools
-     * @returns {Promise<Object>} List of tools
-     */
-    async list(options = {}) {
-        const params = {};
-
-        if (options.type) params.type = options.type;
-        if (options.category) params.category = options.category;
-        if (options.requireEnvironment !== undefined) {
-            params.require_environment = String(options.requireEnvironment);
-        }
-        if (options.myCustomTools) params.my_custom_tools = 'true';
-
-        const response = await this.client.get('ai/tools', params);
-        return response;
-    }
-
-    /**
-     * Search tools by query
-     * @param {string} query - Search query
-     * @param {Object} [options] - Filter options
-     * @param {string} [options.type] - Filter by type
-     * @param {string} [options.category] - Filter by category
-     * @param {boolean} [options.myCustomTools] - Show only user's custom tools
-     * @returns {Promise<Object>} Search results
-     */
-    async search(query, options = {}) {
-        const params = { q: query };
-
-        if (options.type) params.type = options.type;
-        if (options.category) params.category = options.category;
-        if (options.myCustomTools) params.my_custom_tools = 'true';
-
-        const response = await this.client.get('ai/tools/search', params);
-        return response;
-    }
-
-    /**
-     * Get tool by slug
-     * @param {string} slug - Tool slug/ID
-     * @returns {Promise<Object>} Tool details
-     */
-    async get(slug) {
-        if (!slug) {
-            throw new Error('Tool slug is required');
-        }
-
-        const response = await this.client.get(`ai/tools/${slug}`);
-        return response;
-    }
-
-    /**
-     * Create a custom tool (client-side tool)
-     * @param {Object} toolData - Tool configuration
-     * @param {string} toolData.slug - Unique tool slug/ID
-     * @param {string} toolData.tool_name - Tool name
-     * @param {string} toolData.tool_description - Tool description
-     * @param {string} [toolData.icon] - Tool icon
-     * @param {string} [toolData.type='client'] - Tool type: 'client' | 'server' | 'hybrid'
-     * @param {string} [toolData.category='custom'] - Tool category
-     * @param {Object} [toolData.input_scheme] - Input schema/parameters
-     * @param {Object} [toolData.output_scheme] - Output schema
-     * @param {string} [toolData.prompt] - Tool prompt/instructions
-     * @param {boolean} [toolData.require_environment=false] - Requires context/environment
-     * @param {string} [toolData.context_type] - Context type if required
-     * @returns {Promise<Object>} Created tool
-     */
-    async create(toolData) {
-        const {
-            slug,
-            tool_name,
-            tool_description,
-            icon,
-            type = 'client',
-            category = 'custom',
-            input_scheme,
-            output_scheme,
-            prompt,
-            require_environment = false,
-            context_type
-        } = toolData;
-
-        if (!slug || !tool_name || !tool_description) {
-            throw new Error('slug, tool_name, and tool_description are required');
-        }
-
-        const payload = {
-            slug,
-            tool_name,
-            tool_description,
-            icon,
-            type,
-            category,
-            input_scheme,
-            output_scheme,
-            prompt,
-            require_environment,
-            context_type
-        };
-
-        const response = await this.client.post('ai/tools', payload);
-        return response;
-    }
-
-    /**
-     * Validate tool IDs
-     * @param {Array<string>} toolIds - Array of tool slugs to validate
-     * @returns {Promise<Object>} Validation result
-     */
-    async validate(toolIds) {
-        if (!Array.isArray(toolIds)) {
-            throw new Error('toolIds must be an array');
-        }
-
-        // Get all tools and check which ones exist
-        const allTools = await this.list();
-        const existingSlugs = allTools.tools.map(t => t.slug);
-        
-        const validIds = toolIds.filter(id => existingSlugs.includes(id));
-        const invalidIds = toolIds.filter(id => !existingSlugs.includes(id));
-
-        return {
-            valid: invalidIds.length === 0,
-            validIds,
-            invalidIds,
-            error: invalidIds.length > 0 ? `Invalid tool IDs: ${invalidIds.join(', ')}` : null
-        };
-    }
-}
-
-export default Tools;
-

package/src/browser/index.js

@@ -1,474 +0,0 @@
-/**
- * Oblien Browser Module
- * Browser automation with automatic token management
- */
-
-import { OblienClient } from '../client.js';
-
-export class OblienBrowser {
-    /**
-     * @param {import('../client.js').OblienClient|Object} clientOrConfig - Oblien client instance or { clientId, clientSecret }
-     * @param {Object} [config] - Configuration options
-     * @param {string} [config.browserURL] - Browser service URL
-     */
-    constructor(clientOrConfig, config = {}) {
-        if (!clientOrConfig) {
-            throw new Error('Either provide OblienClient instance or { clientId, clientSecret }');
-        }
-
-        // If it's already a client instance
-        if (clientOrConfig.clientId && clientOrConfig.clientSecret && typeof clientOrConfig.get === 'function') {
-            this.client = clientOrConfig;
-        }
-        // If credentials provided, create client
-        else if (clientOrConfig.clientId && clientOrConfig.clientSecret) {
-            // Extract browserURL if passed in clientOrConfig
-            if (clientOrConfig.browserURL) {
-                config.browserURL = clientOrConfig.browserURL;
-            }
-            this.client = new OblienClient(clientOrConfig);
-        }
-        else {
-            throw new Error('Either provide OblienClient instance or { clientId, clientSecret }');
-        }
-
-        this.browserURL = config.browserURL || 'https://browser.oblien.com';
-
-        // Token cache for reuse within expiration window
-        this._tokenCache = {
-            token: null,
-            expiresAt: null
-        };
-    }
-
-    /**
-     * Generate a browser token
-     * Tokens expire in 1 minute for security
-     * 
-     * @returns {Promise<Object>} Token response with token and expiration
-     * 
-     * @example
-     * const tokenData = await browser.generateToken();
-     * // Returns:
-     * // {
-     * //   success: true,
-     * //   token: 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...',
-     * //   expiresIn: '1m'
-     * // }
-     */
-    async generateToken() {
-        const response = await this.client.post('browser/token');
-
-        // Cache token for reuse
-        if (response.success && response.token) {
-            this._tokenCache = {
-                token: response.token,
-                expiresAt: Date.now() + 50000 // 50 seconds (buffer before 1m expiry)
-            };
-        }
-
-        return response;
-    }
-
-    /**
-     * Get a valid token
-     * Automatically generates new token if cache is empty or expired
-     * @private
-     */
-    async _getToken() {
-        const cached = this._tokenCache;
-
-        // Use cached token if still valid
-        if (cached.token && cached.expiresAt > Date.now()) {
-            return cached.token;
-        }
-
-        // Generate new token
-        const tokenData = await this.generateToken();
-        return tokenData.token;
-    }
-
-    /**
-     * Get page content
-     * Opens a URL and extracts content
-     * 
-     * @param {Object} options - Page content options
-     * @param {string} options.url - URL to visit (required)
-     * @param {string} options.token - Browser token (optional, auto-generates if not provided)
-     * @param {number} options.waitFor - Wait time in ms
-     * @param {string} options.selector - CSS selector to wait for
-     * @param {string} options.extract - Content to extract ('html', 'text', 'both')
-     * @param {boolean} options.waitForFullLoad - Wait for full page load
-     * @param {string} options.proxy - Proxy URL (e.g., 'http://proxy.example.com:8080')
-     * @param {number} options.proxyPort - Proxy port (optional, can be in URL)
-     * @param {string} options.proxyUsername - Proxy authentication username
-     * @param {string} options.proxyPassword - Proxy authentication password
-     * @returns {Promise<Object>} Page content result
-     * 
-     * @example
-     * const result = await browser.getPageContent({
-     *   url: 'https://example.com',
-     *   extract: 'both'
-     * });
-     * 
-     * @example
-     * // With proxy
-     * const result = await browser.getPageContent({
-     *   url: 'https://example.com',
-     *   proxy: 'http://proxy.example.com',
-     *   proxyPort: 8080,
-     *   proxyUsername: 'user',
-     *   proxyPassword: 'pass'
-     * });
-     * 
-     * // Returns:
-     * // {
-     * //   success: true,
-     * //   url: 'https://example.com',
-     * //   html: '<html>...</html>',
-     * //   text: 'Page text content...',
-     * //   title: 'Example Domain'
-     * // }
-     */
-    async getPageContent(options) {
-        const { url, token, ...restOptions } = options;
-
-        if (!url) {
-            throw new Error('URL is required');
-        }
-
-        // Get token (use provided or generate new one)
-        const browserToken = token || await this._getToken();
-
-        const response = await fetch(`${this.browserURL}/page-content`, {
-            method: 'POST',
-            headers: {
-                'Authorization': `Bearer ${browserToken}`,
-                'Content-Type': 'application/json'
-            },
-            body: JSON.stringify({ url, ...restOptions })
-        });
-
-        if (!response.ok) {
-            const error = await response.json().catch(() => ({}));
-            throw new Error(error.error || `Request failed: ${response.status}`);
-        }
-
-        return response.json();
-    }
-
-    /**
-     * Take a screenshot of a page
-     * 
-     * @param {Object} options - Screenshot options
-     * @param {string} options.url - URL to screenshot (required)
-     * @param {string} options.token - Browser token (optional)
-     * @param {boolean} options.fullPage - Capture full page
-     * @param {string} options.format - Image format ('png' or 'jpeg')
-     * @param {number} options.quality - JPEG quality (0-100)
-     * @param {Object} options.viewport - Viewport size {width, height}
-     * @param {string} options.device - Device preset name
-     * @param {string} options.proxy - Proxy URL
-     * @param {number} options.proxyPort - Proxy port
-     * @param {string} options.proxyUsername - Proxy authentication username
-     * @param {string} options.proxyPassword - Proxy authentication password
-     * @returns {Promise<Object>} Screenshot result with base64 image
-     * 
-     * @example
-     * const result = await browser.screenshot({
-     *   url: 'https://example.com',
-     *   fullPage: true,
-     *   format: 'png'
-     * });
-     * 
-     * // Returns:
-     * // {
-     * //   success: true,
-     * //   screenshot: 'data:image/png;base64,iVBORw0KGgo...',
-     * //   format: 'png',
-     * //   width: 1920,
-     * //   height: 1080
-     * // }
-     */
-    async screenshot(options) {
-        const { url, token, ...restOptions } = options;
-
-        if (!url) {
-            throw new Error('URL is required');
-        }
-
-        const browserToken = token || await this._getToken();
-
-        const response = await fetch(`${this.browserURL}/screenshot`, {
-            method: 'POST',
-            headers: {
-                'Authorization': `Bearer ${browserToken}`,
-                'Content-Type': 'application/json'
-            },
-            body: JSON.stringify({ url, ...restOptions })
-        });
-
-        if (!response.ok) {
-            const error = await response.json().catch(() => ({}));
-            throw new Error(error.error || `Screenshot failed: ${response.status}`);
-        }
-
-        return response.json();
-    }
-
-    /**
-     * Generate PDF from a page
-     * 
-     * @param {Object} options - PDF options
-     * @param {string} options.url - URL to convert to PDF (required)
-     * @param {string} options.token - Browser token (optional)
-     * @param {string} options.format - Paper format ('A4', 'Letter', etc.)
-     * @param {boolean} options.landscape - Landscape orientation
-     * @param {boolean} options.printBackground - Print background graphics
-     * @param {Object} options.margin - Page margins {top, right, bottom, left}
-     * @param {string} options.proxy - Proxy URL
-     * @param {number} options.proxyPort - Proxy port
-     * @param {string} options.proxyUsername - Proxy authentication username
-     * @param {string} options.proxyPassword - Proxy authentication password
-     * @returns {Promise<Object>} PDF result with base64 data
-     * 
-     * @example
-     * const result = await browser.pdf({
-     *   url: 'https://example.com',
-     *   format: 'A4',
-     *   printBackground: true
-     * });
-     * 
-     * // Returns:
-     * // {
-     * //   success: true,
-     * //   pdf: 'JVBERi0xLjQKJeLjz9MKMyAwIG9iago8P...',
-     * //   format: 'A4',
-     * //   pages: 5
-     * // }
-     */
-    async pdf(options) {
-        const { url, token, ...restOptions } = options;
-
-        if (!url) {
-            throw new Error('URL is required');
-        }
-
-        const browserToken = token || await this._getToken();
-
-        const response = await fetch(`${this.browserURL}/pdf`, {
-            method: 'POST',
-            headers: {
-                'Authorization': `Bearer ${browserToken}`,
-                'Content-Type': 'application/json'
-            },
-            body: JSON.stringify({ url, ...restOptions })
-        });
-
-        if (!response.ok) {
-            const error = await response.json().catch(() => ({}));
-            throw new Error(error.error || `PDF generation failed: ${response.status}`);
-        }
-
-        return response.json();
-    }
-
-    /**
-     * Monitor network requests on a page
-     * 
-     * @param {Object} options - Monitor options
-     * @param {string} options.url - URL to monitor (required)
-     * @param {string} options.token - Browser token (optional)
-     * @param {number} options.duration - Monitoring duration in ms
-     * @param {Array<string>} options.filterTypes - Filter request types
-     * @param {string} options.proxy - Proxy URL
-     * @param {number} options.proxyPort - Proxy port
-     * @param {string} options.proxyUsername - Proxy authentication username
-     * @param {string} options.proxyPassword - Proxy authentication password
-     * @returns {Promise<Object>} Network requests result
-     * 
-     * @example
-     * const result = await browser.monitorRequests({
-     *   url: 'https://example.com',
-     *   duration: 5000,
-     *   filterTypes: ['xhr', 'fetch']
-     * });
-     * 
-     * // Returns:
-     * // {
-     * //   success: true,
-     * //   requests: [
-     * //     { url: 'https://api.example.com/data', method: 'GET', type: 'xhr', ... }
-     * //   ],
-     * //   count: 15
-     * // }
-     */
-    async monitorRequests(options) {
-        const { url, token, ...restOptions } = options;
-
-        if (!url) {
-            throw new Error('URL is required');
-        }
-
-        const browserToken = token || await this._getToken();
-
-        const response = await fetch(`${this.browserURL}/monitor-requests`, {
-            method: 'POST',
-            headers: {
-                'Authorization': `Bearer ${browserToken}`,
-                'Content-Type': 'application/json'
-            },
-            body: JSON.stringify({ url, ...restOptions })
-        });
-
-        if (!response.ok) {
-            const error = await response.json().catch(() => ({}));
-            throw new Error(error.error || `Request monitoring failed: ${response.status}`);
-        }
-
-        return response.json();
-    }
-
-    /**
-     * Get console logs from a page
-     * 
-     * @param {Object} options - Console logs options
-     * @param {string} options.url - URL to monitor (required)
-     * @param {string} options.token - Browser token (optional)
-     * @param {number} options.duration - Monitoring duration in ms
-     * @param {string} options.proxy - Proxy URL
-     * @param {number} options.proxyPort - Proxy port
-     * @param {string} options.proxyUsername - Proxy authentication username
-     * @param {string} options.proxyPassword - Proxy authentication password
-     * @returns {Promise<Object>} Console logs result
-     * 
-     * @example
-     * const result = await browser.getConsoleLogs({
-     *   url: 'https://example.com',
-     *   duration: 3000
-     * });
-     * 
-     * // Returns:
-     * // {
-     * //   success: true,
-     * //   logs: [
-     * //     { type: 'log', text: 'Console message', timestamp: '...' }
-     * //   ]
-     * // }
-     */
-    async getConsoleLogs(options) {
-        const { url, token, ...restOptions } = options;
-
-        if (!url) {
-            throw new Error('URL is required');
-        }
-
-        const browserToken = token || await this._getToken();
-
-        const response = await fetch(`${this.browserURL}/console-logs`, {
-            method: 'POST',
-            headers: {
-                'Authorization': `Bearer ${browserToken}`,
-                'Content-Type': 'application/json'
-            },
-            body: JSON.stringify({ url, ...restOptions })
-        });
-
-        if (!response.ok) {
-            const error = await response.json().catch(() => ({}));
-            throw new Error(error.error || `Console logs retrieval failed: ${response.status}`);
-        }
-
-        return response.json();
-    }
-
-    /**
-     * Get available device presets
-     * 
-     * @param {Object} options - Options
-     * @param {string} options.token - Browser token (optional)
-     * @returns {Promise<Object>} Device presets
-     * 
-     * @example
-     * const devices = await browser.getDevicePresets();
-     * 
-     * // Returns:
-     * // {
-     * //   devices: {
-     * //     'iPhone 13': { width: 390, height: 844, ... },
-     * //     'iPad Pro': { width: 1024, height: 1366, ... }
-     * //   }
-     * // }
-     */
-    async getDevicePresets(options = {}) {
-        const { token } = options;
-
-        const browserToken = token || await this._getToken();
-
-        const response = await fetch(`${this.browserURL}/device-presets`, {
-            method: 'GET',
-            headers: {
-                'Authorization': `Bearer ${browserToken}`
-            }
-        });
-
-        if (!response.ok) {
-            const error = await response.json().catch(() => ({}));
-            throw new Error(error.error || `Failed to get device presets: ${response.status}`);
-        }
-
-        return response.json();
-    }
-
-    /**
-     * Get browser server status
-     * 
-     * @param {Object} options - Options
-     * @param {string} options.token - Browser token (optional)
-     * @returns {Promise<Object>} Server status
-     * 
-     * @example
-     * const status = await browser.getStatus();
-     * 
-     * // Returns:
-     * // {
-     * //   status: 'running',
-     * //   poolSize: 5,
-     * //   activeBrowsers: 2
-     * // }
-     */
-    async getStatus(options = {}) {
-        const { token } = options;
-
-        const browserToken = token || await this._getToken();
-
-        const response = await fetch(`${this.browserURL}/status`, {
-            method: 'GET',
-            headers: {
-                'Authorization': `Bearer ${browserToken}`
-            }
-        });
-
-        if (!response.ok) {
-            const error = await response.json().catch(() => ({}));
-            throw new Error(error.error || `Failed to get status: ${response.status}`);
-        }
-
-        return response.json();
-    }
-
-    /**
-     * Clear token cache
-     * Useful when you want to force fresh token generation
-     * 
-     * @example
-     * browser.clearTokenCache();
-     */
-    clearTokenCache() {
-        this._tokenCache = {
-            token: null,
-            expiresAt: null
-        };
-    }
-}
-