oblien 1.3.0 → 2.0.1

package/src/sandbox/index.js

@@ -1,234 +0,0 @@
-/**
- * Sandboxes Module
- * Manages cloud sandboxes - create, control, monitor
- */
-
-import { OblienClient } from '../client.js';
-import { Sandbox } from './sandbox.js';
-
-export class OblienSandboxes {
-    /**
-     * @param {import('../client.js').OblienClient|Object} clientOrConfig - Oblien client instance or config
-     * @param {string} [clientOrConfig.clientId] - Client ID (if not using client instance)
-     * @param {string} [clientOrConfig.clientSecret] - Client Secret (if not using client instance)
-     * @param {string} [clientOrConfig.baseURL] - Base URL (optional)
-     */
-    constructor(clientOrConfig) {
-        if (!clientOrConfig) {
-            throw new Error('Oblien client or credentials are required');
-        }
-
-        // 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) {
-            this.client = new OblienClient(clientOrConfig);
-        }
-        else {
-            throw new Error('Either provide OblienClient instance or { clientId, clientSecret }');
-        }
-    }
-
-    /**
-     * Create a new sandbox and return Sandbox instance
-     * @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 (default: true)
-     * @returns {Promise<Sandbox>} Sandbox instance ready to use
-     */
-    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
-        });
-
-        const sandboxData = response.sandbox || response;
-
-        // Return Sandbox instance ready to use
-        const sandbox = new Sandbox({
-            client: this.client,
-            sandboxId: sandboxData.id
-        });
-
-        // Pre-cache the token to avoid refetching
-        sandbox._tokenCache = {
-            url: sandboxData.url,
-            token: sandboxData.token
-        };
-        sandbox.baseURL = sandboxData.url;
-        sandbox.token = sandboxData.token;
-        sandbox.sandboxName = sandboxData.name;
-
-        return sandbox;
-    }
-
-    /**
-     * 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 (auto-fetches token)
-     * @param {string} sandboxId - Sandbox ID
-     * @returns {Sandbox} Sandbox instance
-     */
-    sandbox(sandboxId) {
-        return new Sandbox({ client: this.client, sandboxId });
-    }
-
-    /**
-     * Connect to sandbox with direct token (no auto-fetch/renewal)
-     * Use this in backend when you already have a valid token
-     * 
-     * @param {string} token - Sandbox access token (required)
-     * @param {string} [sandboxId] - Sandbox ID (optional)
-     * @param {string} [baseURL] - Sandbox base URL (optional)
-     * @returns {Sandbox} Sandbox instance with direct token
-     * 
-     * @example
-     * const sandbox = client.sandboxes.fromToken('eyJhbGc...', 'sandbox_123');
-     * await sandbox.files.list({ dirPath: '/opt/app' });
-     */
-    fromToken(token, sandboxId = null, baseURL = null) {
-        return Sandbox.fromToken(token, sandboxId, baseURL);
-    }
-}
-
-export { Sandbox };
-export { SandboxClient } from './core/client.js';
-export default OblienSandboxes;
-

package/src/sandbox/sandbox.js

@@ -1,313 +0,0 @@
-import { SandboxClient } from './core/client.js';
-
-/**
- * Sandbox - Management + Interaction in one
- * Extends SandboxClient and auto-fetches token on first use
- * 
- * Can be used directly:
- * - new Sandbox({ token: '...' }) - Direct token (backend use)
- * - new Sandbox({ client, sandboxId }) - Auto-fetch token
- * - Sandbox.fromToken(token, sandboxId) - Static method
- */
-export class Sandbox extends SandboxClient {
-    /**
-     * @param {Object} options
-     * @param {import('../client.js').OblienClient} [options.client] - Oblien client instance
-     * @param {string} [options.sandboxId] - Sandbox ID
-     * @param {string} [options.token] - Direct token (skips auto-fetch)
-     * @param {string} [options.baseURL] - Sandbox base URL
-     */
-    constructor({ client = null, sandboxId = null, token = null, baseURL = null }) {
-        // Direct token mode (backend use)
-        if (token) {
-            super({
-                baseURL: baseURL || 'https://sandbox.oblien.com',
-                token,
-                sandboxId,
-                oblienClient: client
-            });
-
-            this.client = client;
-            this._tokenCache = {
-                url: baseURL || 'https://sandbox.oblien.com',
-                token
-            };
-            this._directToken = true; // Skip auto-renewal
-            this._fetchPromise = null;
-            return;
-        }
-
-        // Auto-fetch mode (requires client)
-        if (!client) {
-            throw new Error('Either token or client is required');
-        }
-
-        // Initialize parent with null token (will fetch on demand)
-        super({
-            baseURL: baseURL || 'https://sandbox.oblien.com',
-            token: null,
-            sandboxId,
-            oblienClient: client
-        });
-
-        this.client = client;
-        this._tokenCache = null;
-        this._fetchPromise = null;
-    }
-
-    /**
-     * Create Sandbox instance with direct token (no auto-fetch)
-     * Perfect for backend when you already have the token
-     * 
-     * @param {string} token - Sandbox access token
-     * @param {string} [sandboxId] - Sandbox ID (optional)
-     * @param {string} [baseURL] - Sandbox base URL (optional)
-     * @returns {Sandbox}
-     * 
-     * @example
-     * const sandbox = Sandbox.fromToken('eyJhbGc...', 'sandbox_123');
-     * await sandbox.files.list({ dirPath: '/opt/app' });
-     */
-    static fromToken(token, sandboxId = null, baseURL = null) {
-        if (!token) {
-            throw new Error('Token is required');
-        }
-
-        return new Sandbox({ token, sandboxId, baseURL });
-    }
-
-    /**
-     * Create a new sandbox via API
-     * 
-     * @param {import('../client.js').OblienClient} client - Oblien client
-     * @param {Object} options - Sandbox creation options
-     * @returns {Promise<Sandbox>}
-     * 
-     * @example
-     * const sandbox = await Sandbox.create(client, {
-     *   name: 'my-sandbox',
-     *   template: 'node-20'
-     * });
-     * await sandbox.files.list({ dirPath: '/opt/app' });
-     */
-    static async create(client, options = {}) {
-        if (!client) {
-            throw new Error('Oblien client is required');
-        }
-
-        const {
-            name,
-            region = 'us-east-1',
-            template = 'node-20',
-            config,
-            autoStart = true
-        } = options;
-
-        const response = await client.post('sandbox', {
-            name,
-            region,
-            template,
-            config,
-            autoStart
-        });
-
-        const sandboxData = response.sandbox || response;
-
-        return new Sandbox({
-            client,
-            sandboxId: sandboxData.id,
-            token: sandboxData.token,
-            baseURL: sandboxData.url
-        });
-    }
-
-    /**
-     * Override: Get base URL (fetches from API if needed)
-     * @returns {string}
-     */
-    getBaseURL() {
-        return this._tokenCache?.url || this.baseURL;
-    }
-
-    /**
-     * Override: Get token (fetches from API if needed or expired)
-     * @returns {Promise<string>}
-     */
-    async getToken() {
-        // Skip expiry check if using direct token
-        if (!this._directToken && this._tokenCache && this._isTokenExpired()) {
-            this._invalidateToken();
-        }
-
-        if (!this._tokenCache) {
-            if (!this._fetchPromise) {
-                this._fetchPromise = this._fetchToken();
-            }
-            await this._fetchPromise;
-        }
-        return this._tokenCache.token;
-    }
-
-    /**
-     * Check if JWT token is expired
-     * @private
-     * @returns {boolean}
-     */
-    _isTokenExpired() {
-        if (!this._tokenCache?.token) return false;
-
-        try {
-            // Decode JWT token (format: header.payload.signature)
-            const payload = this._tokenCache.token.split('.')[1];
-            if (!payload) return false;
-
-            const decoded = JSON.parse(Buffer.from(payload, 'base64').toString());
-
-            if (decoded.exp) {
-                // Check if expired (with 5 minute buffer)
-                const expiryTime = decoded.exp * 1000;
-                const now = Date.now();
-                const buffer = 5 * 60 * 1000; // 5 minutes
-
-                return now >= (expiryTime - buffer);
-            }
-        } catch (error) {
-            // If can't decode, assume not expired
-            console.warn('[Sandbox] Failed to decode token:', error.message);
-        }
-
-        return false;
-    }
-
-    /**
-     * Internal: Fetch token from API
-     * @private
-     */
-    async _fetchToken() {
-        const details = await this.get();
-        this._tokenCache = {
-            url: details.url,
-            token: details.token
-        };
-        this.baseURL = details.url;
-        this.token = details.token;
-        this.sandboxName = details.name;
-    }
-
-    /**
-     * Internal: Invalidate token cache
-     * @private
-     */
-    _invalidateToken() {
-        this._tokenCache = null;
-        this._fetchPromise = null;
-    }
-
-    // Management Methods
-
-    /**
-     * 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
-     * @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');
-        }
-
-        const result = await this.client.post(`sandbox/${this.sandboxId}/start`);
-        this._invalidateToken();
-        return result;
-    }
-
-    /**
-     * 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');
-        }
-
-        const result = await this.client.post(`sandbox/${this.sandboxId}/restart`);
-        this._invalidateToken();
-        return result;
-    }
-
-    /**
-     * Regenerate sandbox token
-     * @returns {Promise<Object>} New token (1h expiry)
-     */
-    async regenerateToken() {
-        if (!this.sandboxId) {
-            throw new Error('Sandbox ID is required');
-        }
-
-        const result = await this.client.post(`sandbox/${this.sandboxId}/regenerate-token`);
-        this._invalidateToken();
-        return result;
-    }
-
-    /**
-     * 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;