oblien 1.1.0 → 1.1.1

package/src/agents/tools.js

@@ -0,0 +1,155 @@
+/**
+ * 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/icons/index.js

@@ -0,0 +1,185 @@
+/**
+ * Oblien Icons Module
+ * Search and fetch icons, images, and videos
+ */
+
+export class OblienIcons {
+    constructor(client) {
+        if (!client) throw new Error('Oblien client is required');
+        this.client = client;
+    }
+
+    /**
+     * Search for icons using semantic search
+     * 
+     * @param {string} query - Search query
+     * @param {Object} options - Search options
+     * @param {number} options.offset - Pagination offset (default: 0)
+     * @param {number} options.limit - Number of results (default: 100)
+     * @returns {Promise<Object>} Search results with pagination info
+     * 
+     * @example
+     * const results = await icons.search('home', { limit: 50 });
+     * // Returns:
+     * // {
+     * //   results: [
+     * //     {
+     * //       url: 'https://cdn.oblien.com/static/png-icons/...',
+     * //       filename: 'home-outline.png',
+     * //       name: 'home',
+     * //       description: 'home',
+     * //       style: 'Outline',
+     * //       score: 0.95,
+     * //       success: true
+     * //     }
+     * //   ],
+     * //   hasMore: true,
+     * //   offset: 50,
+     * //   total: 245
+     * // }
+     */
+    async search(query, options = {}) {
+        if (!query || typeof query !== 'string') {
+            throw new Error('Query must be a non-empty string');
+        }
+
+        const { offset = 0, limit = 100 } = options;
+
+        return this.client.post('icons/search-icons', {
+            query: query.trim(),
+            offset,
+            limit
+        });
+    }
+
+    /**
+     * Fetch multiple items (icons, images, videos) with semantic matching
+     * 
+     * @param {Array<Object>} items - Array of items to fetch
+     * @param {string} items[].type - Type: 'icon', 'image', or 'video'
+     * @param {string} items[].description - Description for semantic matching
+     * @param {boolean} items[].is_vector - Whether the item is a vector (optional)
+     * @param {string} items[].variant - Variant type (optional, for images/videos)
+     * @returns {Promise<Array>} Array of fetched items with URLs
+     * 
+     * @example
+     * const items = await icons.fetch([
+     *   { type: 'icon', description: 'user profile' },
+     *   { type: 'icon', description: 'settings gear' },
+     *   { type: 'image', description: 'mountain landscape' },
+     *   { type: 'video', description: 'ocean waves' }
+     * ]);
+     * 
+     * // Returns:
+     * // [
+     * //   {
+     * //     url: 'https://cdn.oblien.com/static/icons/...',
+     * //     description: 'user profile',
+     * //     style: 'Outline',
+     * //     success: true
+     * //   },
+     * //   {
+     * //     url: 'https://cdn.oblien.com/static/assets/...',
+     * //     type: 'image',
+     * //     description: 'mountain landscape',
+     * //     variant: 'regular',
+     * //     success: true
+     * //   }
+     * // ]
+     */
+    async fetch(items) {
+        if (!Array.isArray(items) || items.length === 0) {
+            throw new Error('Items must be a non-empty array');
+        }
+
+        // Validate items
+        for (const item of items) {
+            if (!item.type || !['icon', 'image', 'video'].includes(item.type)) {
+                throw new Error('Each item must have a valid type: icon, image, or video');
+            }
+            if (!item.description || typeof item.description !== 'string') {
+                throw new Error('Each item must have a description string');
+            }
+        }
+
+        return this.client.post('icons/fetch', { data: items });
+    }
+
+    /**
+     * Fetch a single icon
+     * Convenience method for fetching one icon
+     * 
+     * @param {string} description - Icon description
+     * @returns {Promise<Object>} Icon object with URL
+     * 
+     * @example
+     * const icon = await icons.fetchIcon('home');
+     * // Returns: { url: '...', description: 'home', style: 'Outline', success: true }
+     */
+    async fetchIcon(description) {
+        if (!description || typeof description !== 'string') {
+            throw new Error('Description must be a non-empty string');
+        }
+
+        const result = await this.fetch([{ type: 'icon', description }]);
+        return result[0] || null;
+    }
+
+    /**
+     * Fetch multiple icons at once
+     * Convenience method for fetching multiple icons
+     * 
+     * @param {Array<string>} descriptions - Array of icon descriptions
+     * @returns {Promise<Array>} Array of icon objects
+     * 
+     * @example
+     * const icons = await icons.fetchIcons(['home', 'settings', 'user']);
+     * // Returns: [{ url: '...', description: 'home', ... }, ...]
+     */
+    async fetchIcons(descriptions) {
+        if (!Array.isArray(descriptions) || descriptions.length === 0) {
+            throw new Error('Descriptions must be a non-empty array');
+        }
+
+        const items = descriptions.map(desc => ({ type: 'icon', description: desc }));
+        return this.fetch(items);
+    }
+
+    /**
+     * Search icons with pagination helper
+     * Automatically handles pagination and returns all results
+     * 
+     * @param {string} query - Search query
+     * @param {Object} options - Search options
+     * @param {number} options.maxResults - Maximum results to fetch (default: 500)
+     * @param {number} options.batchSize - Results per batch (default: 100)
+     * @returns {Promise<Array>} All matching icons
+     * 
+     * @example
+     * const allIcons = await icons.searchAll('home', { maxResults: 200 });
+     * // Returns: [{ url: '...', name: 'home', ... }, ...]
+     */
+    async searchAll(query, options = {}) {
+        const { maxResults = 500, batchSize = 100 } = options;
+        const allResults = [];
+        let offset = 0;
+        let hasMore = true;
+
+        while (hasMore && allResults.length < maxResults) {
+            const response = await this.search(query, {
+                offset,
+                limit: Math.min(batchSize, maxResults - allResults.length)
+            });
+
+            if (response.results && response.results.length > 0) {
+                allResults.push(...response.results);
+            }
+
+            hasMore = response.hasMore && allResults.length < maxResults;
+            offset = response.offset;
+        }
+
+        return allResults;
+    }
+}
+

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;
+