oblien 1.3.0 → 2.0.1

package/src/sandbox/core/api/snapshots.js

@@ -1,132 +0,0 @@
-import { BaseAPI } from './base.js';
-
-/**
- * Snapshots API - Handle snapshot/checkpoint operations
- */
-export class SnapshotsAPI extends BaseAPI {
-  /**
-   * Create a checkpoint
-   * @param {Object} options - Checkpoint options
-   * @param {string} options.message - Commit message
-   * @returns {Promise<Object>} Checkpoint result
-   */
-  async commit(options) {
-    return this.post('/snapshots/commit', options);
-  }
-
-  /**
-   * Go to a specific commit
-   * @param {Object} options - Goto options
-   * @param {string} options.commitHash - Commit hash to go to
-   * @returns {Promise<Object>} Goto result
-   */
-  async goto(options) {
-    return this.post('/snapshots/goto', options);
-  }
-
-  /**
-   * List all checkpoints
-   * @param {Object} [options] - List options
-   * @param {number} [options.limit=20] - Max number of checkpoints
-   * @returns {Promise<Object>} Checkpoints list
-   */
-  async listCheckpoints(options = {}) {
-    const limit = options.limit || 20;
-    return this.get(`/snapshots/checkpoints?limit=${limit}`);
-  }
-
-  /**
-   * Get checkpoint info
-   * @param {string} commitHash - Commit hash
-   * @returns {Promise<Object>} Checkpoint info
-   */
-  async getCheckpoint(commitHash) {
-    return this.get(`/snapshots/checkpoint/${commitHash}`);
-  }
-
-  /**
-   * Get current checkpoint
-   * @returns {Promise<Object>} Current checkpoint
-   */
-  async getCurrentCheckpoint() {
-    return this.get('/snapshots/current-checkpoint');
-  }
-
-  /**
-   * Cleanup all checkpoints
-   * @returns {Promise<Object>} Cleanup result
-   */
-  async cleanup() {
-    return this.post('/snapshots/cleanup', {});
-  }
-
-  /**
-   * Delete commits after a specific hash
-   * @param {Object} options - Delete options
-   * @param {string} options.commitHash - Commit hash
-   * @returns {Promise<Object>} Delete result
-   */
-  async deleteAfter(options) {
-    return this.post('/snapshots/delete', options);
-  }
-
-  // Snapshot Archive methods
-
-  /**
-   * Archive current repository
-   * @param {Object} options - Archive options
-   * @param {string} options.id - Archive ID
-   * @param {Object} [options.options] - Additional options
-   * @returns {Promise<Object>} Archive result
-   */
-  async archive(options) {
-    return this.post('/snapshot-archive/archive', options);
-  }
-
-  /**
-   * Restore archived repository
-   * @param {Object} options - Restore options
-   * @param {string} options.id - Archive ID
-   * @param {boolean} [options.override=false] - Override existing
-   * @returns {Promise<Object>} Restore result
-   */
-  async restore(options) {
-    return this.post('/snapshot-archive/restore-archive', options);
-  }
-
-  /**
-   * List all archives
-   * @returns {Promise<Object>} Archives list
-   */
-  async listArchives() {
-    return this.get('/snapshot-archive/archives');
-  }
-
-  /**
-   * Get archive info
-   * @param {string} id - Archive ID
-   * @returns {Promise<Object>} Archive info
-   */
-  async getArchive(id) {
-    return this.get(`/snapshot-archive/archive/${id}`);
-  }
-
-  /**
-   * Delete archive
-   * @param {string} id - Archive ID
-   * @returns {Promise<Object>} Delete result
-   */
-  async deleteArchive(id) {
-    return this.delete(`/snapshot-archive/archive/${id}`);
-  }
-
-  /**
-   * Cleanup archives
-   * @param {Object} [options] - Cleanup options
-   * @returns {Promise<Object>} Cleanup result
-   */
-  async cleanupArchives(options = {}) {
-    return this.post('/snapshot-archive/cleanup-archives', options);
-  }
-}
-

package/src/sandbox/core/api/terminal.js

@@ -1,20 +0,0 @@
-import { BaseAPI } from './base.js';
-
-/**
- * Terminal API - Handle terminal operations
- */
-export class TerminalAPI extends BaseAPI {
-  /**
-   * Execute a terminal command
-   * @param {Object} options - Terminal options
-   * @param {string} options.command - Command to execute
-   * @param {string} [options.cwd] - Working directory
-   * @param {Object} [options.env] - Environment variables
-   * @param {number} [options.timeout] - Execution timeout
-   * @returns {Promise<Object>} Command result
-   */
-  async execute(options) {
-    return this.post('/terminal', options);
-  }
-}
-

package/src/sandbox/core/auth.js

@@ -1,256 +0,0 @@
-import * as http from './utils/http.js';
-import { SandboxClient } from './client.js';
-
-/**
- * Authentication client for managing Oblien account and sandboxes
- * 
- * @example
- * ```javascript
- * import { OblienClient } from 'agent-sandbox';
- * 
- * const client = new OblienClient({
- *   clientId: process.env.OBLIEN_CLIENT_ID,
- *   clientSecret: process.env.OBLIEN_CLIENT_SECRET
- * });
- * 
- * // Create a sandbox and get ready-to-use client
- * const sandbox = await client.createSandbox({
- *   name: 'my-sandbox',
- *   region: 'us-east-1'
- * });
- * 
- * // Now use it directly
- * await sandbox.files.list({ dirPath: '/opt/app' });
- * await sandbox.git.clone({ url: '...', targetDir: '/opt/app' });
- * ```
- */
-export class OblienClient {
-  /**
-   * Create a new OblienClient instance
-   * @param {Object} config - Client configuration
-   * @param {string} config.clientId - Your Oblien client ID
-   * @param {string} config.clientSecret - Your Oblien client secret
-   * @param {string} [apiURL='https://api.oblien.com/sandbox'] - API base URL
-   */
-  constructor(config, apiURL = 'https://api.oblien.com/sandbox') {
-    if (!config.clientId && !config.headers) {
-      throw new Error('clientId is required');
-    }
-    if (!config.clientSecret && !config.headers) {
-      throw new Error('clientSecret is required');
-    }
-    this.headers = config.headers || {};
-    this.clientId = config.clientId;
-    this.clientSecret = config.clientSecret;
-    this.apiURL = apiURL.replace(/\/$/, '');
-
-    /**
-     * Sandboxes API (low-level access)
-     * @type {SandboxesAPI}
-     */
-    this.sandboxes = new SandboxesAPI(this);
-  }
-
-  /**
-   * Create a new sandbox and return a ready-to-use SandboxClient
-   * 
-   * @param {Object} [options] - Sandbox options
-   * @param {string} [options.name] - Sandbox name
-   * @param {string} [options.region] - Region (us-east-1, eu-west-1, etc.)
-   * @param {string} [options.template] - Template to use
-   * @param {Object} [options.config] - Additional configuration
-   * @returns {Promise<SandboxClient>} Ready-to-use SandboxClient instance
-   * 
-   * @example
-   * ```javascript
-   * const sandbox = await client.createSandbox({
-   *   name: 'my-dev-sandbox',
-   *   region: 'us-east-1'
-   * });
-   * 
-   * // Use it immediately
-   * await sandbox.files.list({ dirPath: '/opt/app' });
-   * ```
-   */
-  async createSandbox(options = {}) {
-    const sandboxInfo = await this.sandboxes.create(options);
-    return new SandboxClient({
-      baseURL: sandboxInfo.url,
-      token: sandboxInfo.token,
-      sandboxId: sandboxInfo.id,
-      sandboxName: sandboxInfo.name
-    });
-  }
-
-  /**
-   * Connect to an existing sandbox by ID
-   * 
-   * @param {string} sandboxId - Sandbox ID
-   * @returns {Promise<SandboxClient>} Ready-to-use SandboxClient instance
-   * 
-   * @example
-   * ```javascript
-   * const sandbox = await client.sandbox('sandbox_abc123');
-   * await sandbox.files.list({ dirPath: '/opt/app' });
-   * ```
-   */
-  async sandbox(sandboxId) {
-    const sandboxInfo = await this.sandboxes.get(sandboxId);
-    if (!sandboxInfo.success) {
-      throw new Error(JSON.stringify(sandboxInfo));
-    }
-    return new SandboxClient({
-      baseURL: sandboxInfo.sandbox.url,
-      token: sandboxInfo.sandbox.token,
-      sandboxId: sandboxInfo.sandbox.id,
-      sandboxName: sandboxInfo.sandbox.name
-    });
-  }
-
-  /**
-   * Get authorization headers with client credentials
-   * @returns {Object} Headers with client credentials
-   */
-  getAuthHeaders() {
-    return {
-      'X-Client-ID': this.clientId,
-      'X-Client-Secret': this.clientSecret,
-      ...this.headers
-    };
-  }
-
-  /**
-   * Make authenticated GET request
-   * @param {string} path - API path
-   * @returns {Promise<any>} Response data
-   */
-  async get(path) {
-    const headers = this.getAuthHeaders();
-    return http.get(`${this.apiURL}${path}`, headers);
-  }
-
-  /**
-   * Make authenticated POST request
-   * @param {string} path - API path
-   * @param {Object} body - Request body
-   * @returns {Promise<any>} Response data
-   */
-  async post(path, body = {}) {
-    const headers = this.getAuthHeaders();
-    return http.post(`${this.apiURL}${path}`, body, headers);
-  }
-
-  /**
-   * Make authenticated DELETE request
-   * @param {string} path - API path
-   * @returns {Promise<any>} Response data
-   */
-  async delete(path) {
-    const headers = this.getAuthHeaders();
-    return http.del(`${this.apiURL}${path}`, headers);
-  }
-}
-
-/**
- * Sandboxes API - Manage sandbox instances
- */
-class SandboxesAPI {
-  /**
-   * @param {OblienClient} client - OblienClient instance
-   */
-  constructor(client) {
-    this.client = client;
-  }
-
-  /**
-   * Create a new sandbox
-   * @param {Object} options - Sandbox options
-   * @param {string} [options.name] - Sandbox name
-   * @param {string} [options.region] - Region (us-east-1, eu-west-1, etc.)
-   * @param {string} [options.template] - Template to use
-   * @param {Object} [options.config] - Additional configuration
-   * @returns {Promise<Object>} Sandbox details {id, token, url, name, status}
-   */
-  async create(options = {}) {
-    const response = await this.client.post('/', options);
-    return response.sandbox;
-  }
-
-  /**
-   * List all sandboxes
-   * @param {Object} [options] - List options
-   * @param {number} [options.page=1] - Page number
-   * @param {number} [options.limit=20] - Items per page
-   * @param {string} [options.status] - Filter by status (active, stopped, etc.)
-   * @returns {Promise<Object>} Sandboxes list
-   */
-  async list(options = {}) {
-    const params = new URLSearchParams(options).toString();
-    const path = `/${params ? '?' + params : ''}`;
-    return this.client.get(path);
-  }
-
-  /**
-   * Get sandbox details
-   * @param {string} sandboxId - Sandbox ID
-   * @returns {Promise<Object>} Sandbox details
-   */
-  async get(sandboxId) {
-    return this.client.get(`/${sandboxId}`);
-  }
-
-  /**
-   * Delete a sandbox
-   * @param {string} sandboxId - Sandbox ID
-   * @returns {Promise<Object>} Delete confirmation
-   */
-  async delete(sandboxId) {
-    return this.client.delete(`/${sandboxId}`);
-  }
-
-  /**
-   * Start a stopped sandbox
-   * @param {string} sandboxId - Sandbox ID
-   * @returns {Promise<Object>} Sandbox details
-   */
-  async start(sandboxId) {
-    return this.client.post(`/${sandboxId}/start`);
-  }
-
-  /**
-   * Stop a running sandbox
-   * @param {string} sandboxId - Sandbox ID
-   * @returns {Promise<Object>} Sandbox details
-   */
-  async stop(sandboxId) {
-    return this.client.post(`/${sandboxId}/stop`);
-  }
-
-  /**
-   * Restart a sandbox
-   * @param {string} sandboxId - Sandbox ID
-   * @returns {Promise<Object>} Sandbox details
-   */
-  async restart(sandboxId) {
-    return this.client.post(`/${sandboxId}/restart`);
-  }
-
-  /**
-   * Regenerate sandbox token
-   * @param {string} sandboxId - Sandbox ID
-   * @returns {Promise<Object>} New token details
-   */
-  async regenerateToken(sandboxId) {
-    return this.client.post(`/${sandboxId}/regenerate-token`);
-  }
-
-  /**
-   * Get sandbox metrics
-   * @param {string} sandboxId - Sandbox ID
-   * @returns {Promise<Object>} Metrics data
-   */
-  async metrics(sandboxId) {
-    return this.client.get(`/${sandboxId}/metrics`);
-  }
-}
-

package/src/sandbox/core/client.js

@@ -1,197 +0,0 @@
-import { FilesAPI } from './api/files.js';
-import { GitAPI } from './api/git.js';
-import { SearchAPI } from './api/search.js';
-import { TerminalAPI } from './api/terminal.js';
-import { SnapshotsAPI } from './api/snapshots.js';
-import { DatabaseAPI } from './api/database.js';
-import { WebSocketConnection } from './websocket/connection.js';
-import { TerminalManager } from './managers/terminal.js';
-import { WatcherManager } from './managers/watcher.js';
-
-/**
- * Sandbox API Client - Interact with a specific sandbox instance
- * 
- * This client is used to interact with an individual sandbox after it has been created.
- * The token is obtained when creating a sandbox via OblienClient.
- * 
- * Full documentation: https://oblien.com/docs/agent-sandbox
- * 
- * @example
- * ```javascript
- * import { SandboxClient } from 'agent-sandbox';
- * 
- * // Token obtained from sandbox creation
- * const sandbox = new SandboxClient({
- *   baseURL: 'https://sandbox.oblien.com',
- *   token: 'sandbox_token_here'
- * });
- * 
- * // List files
- * const files = await sandbox.files.list({ dirPath: '/opt/app' });
- * 
- * // Read a file
- * const content = await sandbox.files.get({ filePath: '/opt/app/index.js' });
- * 
- * // Create a file
- * await sandbox.files.create({
- *   fullPath: '/opt/app/newfile.js',
- *   content: 'console.log("Hello World");'
- * });
- * ```
- */
-export class SandboxClient {
-  /**
-   * Create a new SandboxClient instance
-   * 
-   * Note: Prefer using `client.createSandbox()` or `client.sandbox(id)` from OblienClient
-   * for automatic setup. Use this constructor directly only if you have a token already.
-   * 
-   * @param {Object} config - Client configuration
-   * @param {string} config.baseURL - Base URL of the sandbox instance
-   * @param {string} config.token - Sandbox authentication token
-   * @param {string} [config.sandboxId] - Sandbox ID (optional)
-   * @param {string} [config.sandboxName] - Sandbox name (optional)
-   */
-  constructor(config) {
-    const { baseURL = 'https://sandbox.oblien.com', token, sandboxId, sandboxName, oblienClient } = config;
-
-    // Token can be null if oblienClient is provided (dynamic fetching)
-    if (!token && !oblienClient) {
-      throw new Error('token or oblienClient is required');
-    }
-
-    this.baseURL = baseURL;
-    this.token = token;
-    this.sandboxId = sandboxId;
-    this.sandboxName = sandboxName;
-    this.oblienClient = oblienClient;
-
-    /**
-     * Shared WebSocket connection (ONE connection for everything)
-     * @type {WebSocketConnection}
-     * @private
-     */
-    this._wsConnection = new WebSocketConnection({
-      baseURL,
-      token,
-      sandboxId,
-      onStatusCheck: async () => {
-        // Check if sandbox is active before connecting
-        if (this.oblienClient && this.sandboxId) {
-          try {
-            const result = await this.oblienClient.sandboxes.get(this.sandboxId);
-            if (!result.success) return false;
-            const status = result.sandbox?.status;
-            return status === 'active' || status === 'running';
-          } catch (error) {
-            console.warn('[Sandbox] Status check failed:', error.message);
-            return true; // Allow connection attempt if check fails
-          }
-        }
-        return true;
-      }
-    });
-
-    /**
-     * Files API (token resolved dynamically)
-     * @type {FilesAPI}
-     */
-    this.files = new FilesAPI(this);
-
-    /**
-     * Git API (token resolved dynamically)
-     * @type {GitAPI}
-     */
-    this.git = new GitAPI(this);
-
-    /**
-     * Search API (token resolved dynamically)
-     * @type {SearchAPI}
-     */
-    this.search = new SearchAPI(this);
-
-    /**
-     * Terminal API (token resolved dynamically)
-     * @type {TerminalAPI}
-     */
-    this.staticTerminal = new TerminalAPI(this);
-
-    /**
-     * Snapshots API (token resolved dynamically)
-     * @type {SnapshotsAPI}
-     */
-    this.snapshots = new SnapshotsAPI(this);
-
-    /**
-     * Database API (token resolved dynamically)
-     * @type {DatabaseAPI}
-     */
-    this.database = new DatabaseAPI(this);
-
-    /**
-     * Terminal Manager - Real-time terminal via shared WebSocket
-     * @type {TerminalManager}
-     */
-    this.terminal = new TerminalManager(this._wsConnection);
-
-    /**
-     * File Watcher - Real-time file watching via shared WebSocket
-     * @type {WatcherManager}
-     */
-    this.watcher = new WatcherManager(this._wsConnection);
-  }
-
-  /**
-   * Get base URL for APIs
-   * @returns {string}
-   */
-  getBaseURL() {
-    return this.baseURL;
-  }
-
-  /**
-   * Get token for APIs (can be overridden for dynamic fetching)
-   * @returns {Promise<string>}
-   */
-  async getToken() {
-    return this.token;
-  }
-
-  /**
-   * Test connection to the sandbox API
-   * @returns {Promise<boolean>} True if connection is successful
-   */
-  async testConnection() {
-    try {
-      const response = await fetch(this.files.baseURL);
-      const data = await response.json();
-      return data.success === true;
-    } catch (error) {
-      return false;
-    }
-  }
-
-  /**
-   * Connect to WebSocket (terminal/watcher auto-connect when used)
-   * @returns {Promise<void>}
-   */
-  async connect() {
-    await this._wsConnection.connect();
-  }
-
-  /**
-   * Disconnect from WebSocket
-   */
-  disconnect() {
-    this._wsConnection.disconnect();
-  }
-
-  /**
-   * Check if WebSocket is connected
-   * @returns {boolean}
-   */
-  get connected() {
-    return this._wsConnection.connected;
-  }
-}
-

package/src/sandbox/core/index.js

@@ -1,22 +0,0 @@
-/**
- * agent-sandbox
- * 
- * An isolated, intelligent environment where AI agents can build, run, and manage things
- * 
- * Full documentation: https://oblien.com/docs/agent-sandbox
- * 
- * @module agent-sandbox
- */
-
-export { OblienClient } from './auth.js';
-export { SandboxClient } from './client.js';
-export { FilesAPI } from './api/files.js';
-export { GitAPI } from './api/git.js';
-export { SearchAPI } from './api/search.js';
-export { TerminalAPI } from './api/terminal.js';
-export { SnapshotsAPI } from './api/snapshots.js';
-export { DatabaseAPI } from './api/database.js';
-export { TerminalManager, Terminal } from './managers/terminal.js';
-export { WatcherManager } from './managers/watcher.js';
-export { WebSocketConnection } from './websocket/connection.js';
-