oblien 1.1.0 → 1.1.2

package/src/sandbox/index.js

@@ -0,0 +1,185 @@
+/**
+ * Sandboxes Module
+ * Manages cloud sandboxes - create, control, monitor
+ */
+
+import { Sandbox } from './sandbox.js';
+
+export class OblienSandboxes {
+    /**
+     * @param {import('../client.js').OblienClient} client - Oblien client instance
+     */
+    constructor(client) {
+        if (!client) {
+            throw new Error('Oblien client is required');
+        }
+
+        this.client = client;
+    }
+
+    /**
+     * Create a new sandbox
+     * @param {Object} options - Sandbox options
+     * @param {string} [options.name] - Sandbox name
+     * @param {string} [options.region='us-east-1'] - Region: 'us-east-1' | 'us-west-1' | 'eu-west-1'
+     * @param {string} [options.template='node-20'] - Template: 'node-20' | 'python-3' | 'blank' | custom
+     * @param {Object} [options.config] - Custom configuration
+     * @param {boolean} [options.autoStart=true] - Auto-start sandbox after creation
+     * @returns {Promise<Object>} Created sandbox data with token
+     */
+    async create(options = {}) {
+        const {
+            name,
+            region = 'us-east-1',
+            template = 'node-20',
+            config,
+            autoStart = true
+        } = options;
+
+        const response = await this.client.post('sandbox', {
+            name,
+            region,
+            template,
+            config,
+            autoStart
+        });
+
+        return response;
+    }
+
+    /**
+     * List all sandboxes with pagination and filtering
+     * @param {Object} [options] - Query options
+     * @param {number} [options.page=1] - Page number
+     * @param {number} [options.limit=20] - Results per page
+     * @param {string} [options.status] - Filter by status: 'active' | 'stopped' | 'suspended' | 'deleted'
+     * @returns {Promise<Object>} Sandboxes data with pagination info
+     */
+    async list(options = {}) {
+        const params = {
+            page: options.page || 1,
+            limit: options.limit || 20
+        };
+
+        if (options.status) {
+            params.status = options.status;
+        }
+
+        const response = await this.client.get('sandbox', params);
+        return response;
+    }
+
+    /**
+     * Get sandbox by ID
+     * @param {string} sandboxId - Sandbox ID
+     * @returns {Promise<Object>} Sandbox data
+     */
+    async get(sandboxId) {
+        if (!sandboxId) {
+            throw new Error('Sandbox ID is required');
+        }
+
+        const sandbox = new Sandbox({ client: this.client, sandboxId });
+        return await sandbox.get();
+    }
+
+    /**
+     * Update sandbox
+     * @param {string} sandboxId - Sandbox ID
+     * @param {Object} updates - Fields to update
+     * @returns {Promise<Object>} Update result
+     */
+    async update(sandboxId, updates) {
+        const sandbox = new Sandbox({ client: this.client, sandboxId });
+        return await sandbox.update(updates);
+    }
+
+    /**
+     * Delete sandbox
+     * @param {string} sandboxId - Sandbox ID
+     * @returns {Promise<Object>} Delete result
+     */
+    async delete(sandboxId) {
+        const sandbox = new Sandbox({ client: this.client, sandboxId });
+        return await sandbox.delete();
+    }
+
+    /**
+     * Start sandbox
+     * @param {string} sandboxId - Sandbox ID
+     * @returns {Promise<Object>} Start result with new token
+     */
+    async start(sandboxId) {
+        const sandbox = new Sandbox({ client: this.client, sandboxId });
+        return await sandbox.start();
+    }
+
+    /**
+     * Stop sandbox
+     * @param {string} sandboxId - Sandbox ID
+     * @returns {Promise<Object>} Stop result
+     */
+    async stop(sandboxId) {
+        const sandbox = new Sandbox({ client: this.client, sandboxId });
+        return await sandbox.stop();
+    }
+
+    /**
+     * Restart sandbox
+     * @param {string} sandboxId - Sandbox ID
+     * @returns {Promise<Object>} Restart result with new token
+     */
+    async restart(sandboxId) {
+        const sandbox = new Sandbox({ client: this.client, sandboxId });
+        return await sandbox.restart();
+    }
+
+    /**
+     * Regenerate sandbox token
+     * @param {string} sandboxId - Sandbox ID
+     * @returns {Promise<Object>} New token (1h expiry)
+     */
+    async regenerateToken(sandboxId) {
+        const sandbox = new Sandbox({ client: this.client, sandboxId });
+        return await sandbox.regenerateToken();
+    }
+
+    /**
+     * Get sandbox metrics
+     * @param {string} sandboxId - Sandbox ID
+     * @returns {Promise<Object>} Sandbox metrics
+     */
+    async getMetrics(sandboxId) {
+        const sandbox = new Sandbox({ client: this.client, sandboxId });
+        return await sandbox.getMetrics();
+    }
+
+    /**
+     * Get sandbox stats (overall statistics)
+     * @returns {Promise<Object>} Sandbox statistics
+     */
+    async getStats() {
+        return await this.client.get('sandbox/stats');
+    }
+
+    /**
+     * Get sandbox activity
+     * @returns {Promise<Object>} Sandbox activity logs
+     */
+    async getActivity() {
+        return await this.client.get('sandbox/activity');
+    }
+
+    /**
+     * Create a Sandbox instance for chaining operations
+     * @param {string} sandboxId - Sandbox ID
+     * @returns {Sandbox} Sandbox instance
+     */
+    sandbox(sandboxId) {
+        return new Sandbox({ client: this.client, sandboxId });
+    }
+}
+
+export { Sandbox };
+export default OblienSandboxes;
+

package/src/sandbox/sandbox.js

@@ -0,0 +1,124 @@
+/**
+ * Sandbox Class
+ * Represents a single sandbox with methods for operations
+ */
+
+export class Sandbox {
+    /**
+     * @param {Object} options
+     * @param {import('../client.js').OblienClient} options.client - Oblien client instance
+     * @param {string} [options.sandboxId] - Sandbox ID
+     */
+    constructor({ client, sandboxId = null }) {
+        if (!client) {
+            throw new Error('Oblien client is required');
+        }
+
+        this.client = client;
+        this.sandboxId = sandboxId;
+    }
+
+    /**
+     * Get sandbox details
+     * @returns {Promise<Object>} Sandbox data
+     */
+    async get() {
+        if (!this.sandboxId) {
+            throw new Error('Sandbox ID is required');
+        }
+
+        const response = await this.client.get(`sandbox/${this.sandboxId}`);
+        return response.sandbox || response;
+    }
+
+    /**
+     * Update sandbox
+     * @param {Object} updates - Fields to update
+     * @param {string} [updates.name] - Sandbox name
+     * @param {string} [updates.region] - Region
+     * @param {Object} [updates.config] - Configuration
+     * @returns {Promise<Object>} Update result
+     */
+    async update(updates) {
+        if (!this.sandboxId) {
+            throw new Error('Sandbox ID is required');
+        }
+
+        return await this.client.put(`sandbox/${this.sandboxId}`, updates);
+    }
+
+    /**
+     * Delete sandbox
+     * @returns {Promise<Object>} Delete result
+     */
+    async delete() {
+        if (!this.sandboxId) {
+            throw new Error('Sandbox ID is required');
+        }
+
+        return await this.client.delete(`sandbox/${this.sandboxId}`);
+    }
+
+    /**
+     * Start sandbox
+     * @returns {Promise<Object>} Start result with new token
+     */
+    async start() {
+        if (!this.sandboxId) {
+            throw new Error('Sandbox ID is required');
+        }
+
+        return await this.client.post(`sandbox/${this.sandboxId}/start`);
+    }
+
+    /**
+     * Stop sandbox
+     * @returns {Promise<Object>} Stop result
+     */
+    async stop() {
+        if (!this.sandboxId) {
+            throw new Error('Sandbox ID is required');
+        }
+
+        return await this.client.post(`sandbox/${this.sandboxId}/stop`);
+    }
+
+    /**
+     * Restart sandbox
+     * @returns {Promise<Object>} Restart result with new token
+     */
+    async restart() {
+        if (!this.sandboxId) {
+            throw new Error('Sandbox ID is required');
+        }
+
+        return await this.client.post(`sandbox/${this.sandboxId}/restart`);
+    }
+
+    /**
+     * Regenerate sandbox token
+     * @returns {Promise<Object>} New token (1h expiry)
+     */
+    async regenerateToken() {
+        if (!this.sandboxId) {
+            throw new Error('Sandbox ID is required');
+        }
+
+        return await this.client.post(`sandbox/${this.sandboxId}/regenerate-token`);
+    }
+
+    /**
+     * Get sandbox metrics
+     * @returns {Promise<Object>} Sandbox metrics
+     */
+    async getMetrics() {
+        if (!this.sandboxId) {
+            throw new Error('Sandbox ID is required');
+        }
+
+        return await this.client.get(`sandbox/${this.sandboxId}/metrics`);
+    }
+}
+
+export default Sandbox;
+

package/src/search/index.js

@@ -0,0 +1,191 @@
+/**
+ * Search Module
+ * Web search, content extraction, and research crawling
+ */
+
+export class OblienSearch {
+    /**
+     * @param {import('../client.js').OblienClient} client - Oblien client instance
+     */
+    constructor(client) {
+        if (!client) {
+            throw new Error('Oblien client is required');
+        }
+
+        this.client = client;
+    }
+
+    /**
+     * Search the web with multiple queries
+     * @param {Object} options - Search options
+     * @param {Array<string>} options.queries - Array of search queries (required)
+     * @param {boolean} [options.includeAnswers=false] - Include AI-generated answers
+     * @param {Object} [options.options] - Additional search options
+     * @param {number} [options.options.maxResults] - Max results per query
+     * @param {string} [options.options.region] - Search region
+     * @param {string} [options.options.timeRange] - Time range filter
+     * @returns {Promise<Array>} Search results
+     */
+    async search(options) {
+        const { queries, includeAnswers = false, options: searchOptions = {} } = options;
+
+        if (!queries || !Array.isArray(queries) || queries.length === 0) {
+            throw new Error('Queries array is required and must not be empty');
+        }
+
+        const response = await this.client.post('search', {
+            queries,
+            includeAnswers,
+            options: searchOptions
+        });
+
+        return response;
+    }
+
+    /**
+     * Extract and summarize content from web pages
+     * @param {Object} options - Extract options
+     * @param {Array<Object>} options.pages - Array of pages to extract (required)
+     * @param {string} options.pages[].url - Page URL (required)
+     * @param {Array<string>} options.pages[].details - Details to extract (required)
+     * @param {string} [options.pages[].summaryLevel='medium'] - Summary level: 'brief' | 'medium' | 'detailed'
+     * @param {Object} [options.options] - Additional extraction options
+     * @returns {Promise<Object>} Extracted content
+     */
+    async extract(options) {
+        const { pages, options: extractOptions = {} } = options;
+
+        if (!pages || !Array.isArray(pages) || pages.length === 0) {
+            throw new Error('Pages array is required and must not be empty');
+        }
+
+        // Validate pages
+        pages.forEach((page, index) => {
+            if (!page.url) {
+                throw new Error(`Page at index ${index} is missing 'url'`);
+            }
+            if (!page.details || !Array.isArray(page.details) || page.details.length === 0) {
+                throw new Error(`Page at index ${index} is missing 'details' array`);
+            }
+        });
+
+        const response = await this.client.post('search/extract', {
+            pages,
+            options: extractOptions
+        });
+
+        return response;
+    }
+
+    /**
+     * Create deep research report with AI crawling
+     * @param {Object} options - Crawl options
+     * @param {string} options.instructions - Research instructions (required)
+     * @param {Object} [options.options] - Additional crawl options
+     * @param {boolean} [options.options.thinking] - Enable thinking mode
+     * @param {boolean} [options.options.allow_thinking_callback] - Allow thinking callbacks
+     * @param {boolean} [options.options.stream_text] - Stream text responses
+     * @param {string} [options.reportType='pdf'] - Report type: 'pdf' | 'markdown' | 'html'
+     * @param {Function} [options.onProgress] - Callback for progress updates (streaming)
+     * @returns {Promise<Object>} Research report result
+     */
+    async crawl(options) {
+        const {
+            instructions,
+            options: crawlOptions = {},
+            reportType = 'pdf',
+            onProgress = null
+        } = options;
+
+        if (!instructions || typeof instructions !== 'string') {
+            throw new Error('Instructions string is required');
+        }
+
+        // If onProgress is provided, we need to handle streaming
+        if (onProgress && typeof onProgress === 'function') {
+            return this._crawlWithStreaming({
+                instructions,
+                options: crawlOptions,
+                reportType,
+                onProgress
+            });
+        }
+
+        // Standard JSON response
+        const response = await this.client.post('search/crawl', {
+            instructions,
+            options: crawlOptions,
+            responseType: 'json',
+            reportType
+        });
+
+        return response;
+    }
+
+    /**
+     * Handle streaming crawl with progress callbacks
+     * @private
+     */
+    async _crawlWithStreaming({ instructions, options, reportType, onProgress }) {
+        const url = this.client._buildURL('search/crawl');
+        const headers = this.client.getAuthHeaders();
+
+        const response = await fetch(url, {
+            method: 'POST',
+            headers,
+            body: JSON.stringify({
+                instructions,
+                options,
+                responseType: 'stream',
+                reportType
+            })
+        });
+
+        if (!response.ok) {
+            const error = await response.json();
+            throw new Error(error.message || error.error || 'Crawl request failed');
+        }
+
+        // Handle streaming response
+        const reader = response.body.getReader();
+        const decoder = new TextDecoder();
+        let buffer = '';
+        let finalResult = null;
+
+        while (true) {
+            const { done, value } = await reader.read();
+            
+            if (done) break;
+
+            buffer += decoder.decode(value, { stream: true });
+            
+            // Process complete SSE messages
+            const lines = buffer.split('\n\n');
+            buffer = lines.pop() || ''; // Keep incomplete message in buffer
+
+            for (const line of lines) {
+                if (line.startsWith('data: ')) {
+                    try {
+                        const data = JSON.parse(line.slice(6));
+                        
+                        if (data.type === 'crawl_end') {
+                            finalResult = data.data;
+                        } else if (data.type === 'error') {
+                            throw new Error(data.error);
+                        } else {
+                            // Progress update
+                            onProgress(data);
+                        }
+                    } catch (error) {
+                        console.error('Error parsing SSE data:', error);
+                    }
+                }
+            }
+        }
+
+        return finalResult || { success: true };
+    }
+}
+
+export default OblienSearch;
+