computesdk 1.0.1 → 1.1.0

package/dist/index.js

@@ -20,515 +20,975 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
-  AuthenticationError: () => AuthenticationError,
-  BaseProvider: () => BaseProvider,
-  ComputeError: () => ComputeError,
-  ComputeSDK: () => ComputeSDK,
-  ConfigurationError: () => ConfigurationError,
-  DEFAULT_TIMEOUT: () => DEFAULT_TIMEOUT,
-  ENV_KEYS: () => ENV_KEYS,
-  ExecutionError: () => ExecutionError,
-  ProviderError: () => ProviderError,
-  ProviderUnavailableError: () => ProviderUnavailableError,
-  TimeoutError: () => TimeoutError,
-  autoSelectProvider: () => autoSelectProvider,
-  createComputeRegistry: () => createComputeRegistry,
-  default: () => index_default,
-  detectAvailableProviders: () => detectAvailableProviders,
-  executeSandbox: () => executeSandbox,
-  getDefaultRuntime: () => getDefaultRuntime,
-  isCloudflareWorkers: () => isCloudflareWorkers,
-  normalizeContainerConfig: () => normalizeContainerConfig,
-  normalizeSandboxConfig: () => normalizeSandboxConfig,
-  retry: () => retry,
-  validateProviderApiKey: () => validateProviderApiKey
+  SandboxManager: () => SandboxManager,
+  compute: () => compute,
+  createProvider: () => createProvider,
+  handleComputeRequest: () => handleComputeRequest
 });
 module.exports = __toCommonJS(index_exports);
 
-// src/errors.ts
-var ComputeError = class extends Error {
+// src/sandbox.ts
+var SandboxManager = class {
   /**
-   * Create a new ComputeError
-   * 
-   * @param message Error message
-   * @param provider Provider identifier
-   * @param sandboxId Optional sandbox identifier
+   * Create a sandbox from a provider
    */
-  constructor(message, provider, sandboxId) {
-    super(message);
-    this.name = this.constructor.name;
-    this.provider = provider;
-    this.sandboxId = sandboxId;
-    Object.setPrototypeOf(this, new.target.prototype);
+  async create(provider, options) {
+    return await provider.sandbox.create(options);
   }
-};
-var ExecutionError = class extends ComputeError {
   /**
-   * Create a new ExecutionError
-   * 
-   * @param message Error message
-   * @param provider Provider identifier
-   * @param exitCode Exit code from the execution
-   * @param sandboxId Optional sandbox identifier
+   * Get an existing sandbox by ID from a provider
    */
-  constructor(message, provider, exitCode, sandboxId) {
-    super(message, provider, sandboxId);
-    /** Error code */
-    this.code = "EXECUTION_ERROR";
-    /** Execution errors are generally not retryable */
-    this.isRetryable = false;
-    this.exitCode = exitCode;
+  async getById(provider, sandboxId) {
+    return await provider.sandbox.getById(sandboxId);
   }
-};
-var TimeoutError = class extends ComputeError {
   /**
-   * Create a new TimeoutError
-   * 
-   * @param message Error message
-   * @param provider Provider identifier
-   * @param timeoutMs Timeout duration in milliseconds
-   * @param sandboxId Optional sandbox identifier
+   * List all active sandboxes from a provider
    */
-  constructor(message, provider, timeoutMs, sandboxId) {
-    super(message, provider, sandboxId);
-    /** Error code */
-    this.code = "TIMEOUT_ERROR";
-    /** Timeout errors may be retryable with a longer timeout */
-    this.isRetryable = true;
-    this.timeoutMs = timeoutMs;
+  async list(provider) {
+    return await provider.sandbox.list();
   }
-};
-var ProviderError = class extends ComputeError {
   /**
-   * Create a new ProviderError
-   * 
-   * @param message Error message
-   * @param provider Provider identifier
-   * @param originalError Optional original error from the provider
-   * @param sandboxId Optional sandbox identifier
+   * Destroy a sandbox via a provider
    */
-  constructor(message, provider, originalError, sandboxId) {
-    super(message, provider, sandboxId);
-    /** Error code */
-    this.code = "PROVIDER_ERROR";
-    /** Provider errors may be retryable */
-    this.isRetryable = true;
-    this.originalError = originalError;
+  async destroy(provider, sandboxId) {
+    return await provider.sandbox.destroy(sandboxId);
   }
 };
-var ConfigurationError = class extends ComputeError {
+
+// src/compute.ts
+var ComputeManager = class {
+  constructor() {
+    this.sandboxManager = new SandboxManager();
+    this.config = null;
+    this.sandbox = {
+      /**
+       * Create a sandbox from a provider (or default provider if configured)
+       * 
+       * @example
+       * ```typescript
+       * import { e2b } from '@computesdk/e2b'
+       * import { compute } from 'computesdk'
+       * 
+       * // With explicit provider
+       * const sandbox = await compute.sandbox.create({
+       *   provider: e2b({ apiKey: 'your-key' })
+       * })
+       * 
+       * // With default provider
+       * compute.setConfig({ provider: e2b({ apiKey: 'your-key' }) })
+       * const sandbox = await compute.sandbox.create({})
+       * ```
+       */
+      create: async (params) => {
+        const provider = "provider" in params && params.provider ? params.provider : this.getDefaultProvider();
+        const options = params.options;
+        return await this.sandboxManager.create(provider, options);
+      },
+      /**
+       * Get an existing sandbox by ID from a provider (or default provider if configured)
+       */
+      getById: async (providerOrSandboxId, sandboxId) => {
+        if (typeof providerOrSandboxId === "string") {
+          const provider = this.getDefaultProvider();
+          return await this.sandboxManager.getById(provider, providerOrSandboxId);
+        } else {
+          if (!sandboxId) {
+            throw new Error("sandboxId is required when provider is specified");
+          }
+          return await this.sandboxManager.getById(providerOrSandboxId, sandboxId);
+        }
+      },
+      /**
+       * List all active sandboxes from a provider (or default provider if configured)
+       */
+      list: async (provider) => {
+        const actualProvider = provider || this.getDefaultProvider();
+        return await this.sandboxManager.list(actualProvider);
+      },
+      /**
+       * Destroy a sandbox via a provider (or default provider if configured)
+       */
+      destroy: async (providerOrSandboxId, sandboxId) => {
+        if (typeof providerOrSandboxId === "string") {
+          const provider = this.getDefaultProvider();
+          return await this.sandboxManager.destroy(provider, providerOrSandboxId);
+        } else {
+          if (!sandboxId) {
+            throw new Error("sandboxId is required when provider is specified");
+          }
+          return await this.sandboxManager.destroy(providerOrSandboxId, sandboxId);
+        }
+      }
+    };
+  }
   /**
-   * Create a new ConfigurationError
-   * 
-   * @param message Error message
-   * @param provider Provider identifier
-   * @param sandboxId Optional sandbox identifier
+   * Set default configuration
    */
-  constructor(message, provider, sandboxId) {
-    super(message, provider, sandboxId);
-    /** Error code */
-    this.code = "CONFIGURATION_ERROR";
-    /** Configuration errors are not retryable without changes */
-    this.isRetryable = false;
+  setConfig(config) {
+    this.config = config;
   }
-};
-var AuthenticationError = class extends ComputeError {
   /**
-   * Create a new AuthenticationError
-   * 
-   * @param message Error message
-   * @param provider Provider identifier
-   * @param sandboxId Optional sandbox identifier
+   * Get current configuration
    */
-  constructor(message, provider, sandboxId) {
-    super(message, provider, sandboxId);
-    /** Error code */
-    this.code = "AUTHENTICATION_ERROR";
-    /** Authentication errors are not retryable without new credentials */
-    this.isRetryable = false;
+  getConfig() {
+    return this.config;
   }
-};
-var ProviderUnavailableError = class extends ComputeError {
   /**
-   * Create a new ProviderUnavailableError
-   * 
-   * @param message Error message
-   * @param provider Provider identifier
-   * @param sandboxId Optional sandbox identifier
+   * Clear current configuration
    */
-  constructor(message, provider, sandboxId) {
-    super(message, provider, sandboxId);
-    /** Error code */
-    this.code = "PROVIDER_UNAVAILABLE";
-    /** Provider unavailability may be temporary */
-    this.isRetryable = true;
+  clearConfig() {
+    this.config = null;
+  }
+  /**
+   * Get the default provider, throwing if not configured
+   */
+  getDefaultProvider() {
+    if (!this.config?.provider) {
+      throw new Error(
+        "No default provider configured. Either call compute.setConfig({ provider }) or pass provider explicitly."
+      );
+    }
+    return this.config.provider;
+  }
+  // Future: compute.blob.*, compute.database.*, compute.git.* will be added here
+  // blob = new BlobManager();
+  // database = new DatabaseManager();  
+  // git = new GitManager();
+  /**
+   * Get the sandbox manager (useful for testing)
+   */
+  getSandboxManager() {
+    return this.sandboxManager;
   }
 };
+var compute = new ComputeManager();
 
-// src/config.ts
-var DEFAULT_TIMEOUT = 3e5;
-var ENV_KEYS = {
-  E2B: "E2B_API_KEY",
-  VERCEL: "VERCEL_TOKEN",
-  CLOUDFLARE: "CLOUDFLARE_API_TOKEN",
-  FLY: "FLY_API_TOKEN"
-};
-function isCloudflareWorkers() {
-  return typeof DurableObject !== "undefined" && typeof WebSocketPair !== "undefined" && typeof caches !== "undefined";
+// src/request-handler.ts
+async function handleComputeRequest(params) {
+  const { request, provider } = params;
+  try {
+    const getSandbox = async (sandboxId) => {
+      if (sandboxId) {
+        const existingSandbox = await compute.sandbox.getById(provider, sandboxId);
+        if (!existingSandbox) {
+          throw new Error(`Sandbox with ID ${sandboxId} not found`);
+        }
+        return existingSandbox;
+      } else {
+        return await compute.sandbox.create({
+          provider,
+          options: request.options || { runtime: "python" }
+        });
+      }
+    };
+    switch (request.action) {
+      // Sandbox operations
+      case "compute.sandbox.create": {
+        const sandbox = await compute.sandbox.create({
+          provider,
+          options: request.options || { runtime: "python" }
+        });
+        return {
+          success: true,
+          sandboxId: sandbox.sandboxId,
+          provider: provider.name
+        };
+      }
+      case "compute.sandbox.destroy": {
+        if (!request.sandboxId) {
+          return {
+            success: false,
+            error: "Sandbox ID is required for destroy action",
+            sandboxId: "",
+            provider: provider.name
+          };
+        }
+        await compute.sandbox.destroy(provider, request.sandboxId);
+        return {
+          success: true,
+          sandboxId: request.sandboxId,
+          provider: provider.name
+        };
+      }
+      case "compute.sandbox.getInfo": {
+        if (!request.sandboxId) {
+          return {
+            success: false,
+            error: "Sandbox ID is required for getInfo action",
+            sandboxId: "",
+            provider: provider.name
+          };
+        }
+        const sandbox = await getSandbox(request.sandboxId);
+        const info = await sandbox.getInfo();
+        return {
+          success: true,
+          sandboxId: request.sandboxId,
+          provider: provider.name,
+          info: {
+            id: info.id,
+            provider: info.provider,
+            runtime: info.runtime,
+            status: info.status,
+            createdAt: info.createdAt.toISOString(),
+            timeout: info.timeout,
+            metadata: info.metadata
+          }
+        };
+      }
+      case "compute.sandbox.list": {
+        const sandboxes = await compute.sandbox.list(provider);
+        return {
+          success: true,
+          sandboxId: "",
+          provider: provider.name,
+          sandboxes: sandboxes.map((sandbox) => ({
+            sandboxId: sandbox.sandboxId,
+            provider: sandbox.provider
+          }))
+        };
+      }
+      // Code execution
+      case "compute.sandbox.runCode": {
+        if (!request.code) {
+          return {
+            success: false,
+            error: "Code is required for runCode action",
+            sandboxId: request.sandboxId || "",
+            provider: provider.name
+          };
+        }
+        const sandbox = await getSandbox(request.sandboxId);
+        const result = await sandbox.runCode(request.code, request.runtime);
+        return {
+          success: true,
+          sandboxId: sandbox.sandboxId,
+          provider: provider.name,
+          result: {
+            stdout: result.stdout,
+            stderr: result.stderr,
+            exitCode: result.exitCode,
+            executionTime: result.executionTime
+          }
+        };
+      }
+      case "compute.sandbox.runCommand": {
+        if (!request.command) {
+          return {
+            success: false,
+            error: "Command is required for runCommand action",
+            sandboxId: request.sandboxId || "",
+            provider: provider.name
+          };
+        }
+        const sandbox = await getSandbox(request.sandboxId);
+        const result = await sandbox.runCommand(request.command, request.args);
+        return {
+          success: true,
+          sandboxId: sandbox.sandboxId,
+          provider: provider.name,
+          result: {
+            stdout: result.stdout,
+            stderr: result.stderr,
+            exitCode: result.exitCode,
+            executionTime: result.executionTime
+          }
+        };
+      }
+      // Filesystem operations
+      case "compute.sandbox.filesystem.readFile": {
+        if (!request.sandboxId) {
+          return {
+            success: false,
+            error: "Sandbox ID is required for filesystem operations",
+            sandboxId: "",
+            provider: provider.name
+          };
+        }
+        if (!request.path) {
+          return {
+            success: false,
+            error: "File path is required for readFile action",
+            sandboxId: request.sandboxId,
+            provider: provider.name
+          };
+        }
+        const sandbox = await getSandbox(request.sandboxId);
+        const content = await sandbox.filesystem.readFile(request.path);
+        return {
+          success: true,
+          sandboxId: request.sandboxId,
+          provider: provider.name,
+          fileContent: content
+        };
+      }
+      case "compute.sandbox.filesystem.writeFile": {
+        if (!request.sandboxId) {
+          return {
+            success: false,
+            error: "Sandbox ID is required for filesystem operations",
+            sandboxId: "",
+            provider: provider.name
+          };
+        }
+        if (!request.path) {
+          return {
+            success: false,
+            error: "File path is required for writeFile action",
+            sandboxId: request.sandboxId,
+            provider: provider.name
+          };
+        }
+        if (request.content === void 0) {
+          return {
+            success: false,
+            error: "File content is required for writeFile action",
+            sandboxId: request.sandboxId,
+            provider: provider.name
+          };
+        }
+        const sandbox = await getSandbox(request.sandboxId);
+        await sandbox.filesystem.writeFile(request.path, request.content);
+        return {
+          success: true,
+          sandboxId: request.sandboxId,
+          provider: provider.name
+        };
+      }
+      case "compute.sandbox.filesystem.mkdir": {
+        if (!request.sandboxId) {
+          return {
+            success: false,
+            error: "Sandbox ID is required for filesystem operations",
+            sandboxId: "",
+            provider: provider.name
+          };
+        }
+        if (!request.path) {
+          return {
+            success: false,
+            error: "Directory path is required for mkdir action",
+            sandboxId: request.sandboxId,
+            provider: provider.name
+          };
+        }
+        const sandbox = await getSandbox(request.sandboxId);
+        await sandbox.filesystem.mkdir(request.path);
+        return {
+          success: true,
+          sandboxId: request.sandboxId,
+          provider: provider.name
+        };
+      }
+      case "compute.sandbox.filesystem.readdir": {
+        if (!request.sandboxId) {
+          return {
+            success: false,
+            error: "Sandbox ID is required for filesystem operations",
+            sandboxId: "",
+            provider: provider.name
+          };
+        }
+        if (!request.path) {
+          return {
+            success: false,
+            error: "Directory path is required for readdir action",
+            sandboxId: request.sandboxId,
+            provider: provider.name
+          };
+        }
+        const sandbox = await getSandbox(request.sandboxId);
+        const entries = await sandbox.filesystem.readdir(request.path);
+        return {
+          success: true,
+          sandboxId: request.sandboxId,
+          provider: provider.name,
+          files: entries.map((entry) => ({
+            name: entry.name,
+            path: entry.path,
+            isDirectory: entry.isDirectory,
+            size: entry.size,
+            lastModified: entry.lastModified.toISOString()
+          }))
+        };
+      }
+      case "compute.sandbox.filesystem.exists": {
+        if (!request.sandboxId) {
+          return {
+            success: false,
+            error: "Sandbox ID is required for filesystem operations",
+            sandboxId: "",
+            provider: provider.name
+          };
+        }
+        if (!request.path) {
+          return {
+            success: false,
+            error: "Path is required for exists action",
+            sandboxId: request.sandboxId,
+            provider: provider.name
+          };
+        }
+        const sandbox = await getSandbox(request.sandboxId);
+        const exists = await sandbox.filesystem.exists(request.path);
+        return {
+          success: true,
+          sandboxId: request.sandboxId,
+          provider: provider.name,
+          exists
+        };
+      }
+      case "compute.sandbox.filesystem.remove": {
+        if (!request.sandboxId) {
+          return {
+            success: false,
+            error: "Sandbox ID is required for filesystem operations",
+            sandboxId: "",
+            provider: provider.name
+          };
+        }
+        if (!request.path) {
+          return {
+            success: false,
+            error: "Path is required for remove action",
+            sandboxId: request.sandboxId,
+            provider: provider.name
+          };
+        }
+        const sandbox = await getSandbox(request.sandboxId);
+        await sandbox.filesystem.remove(request.path);
+        return {
+          success: true,
+          sandboxId: request.sandboxId,
+          provider: provider.name
+        };
+      }
+      // Terminal operations
+      case "compute.sandbox.terminal.create": {
+        if (!request.sandboxId) {
+          return {
+            success: false,
+            error: "Sandbox ID is required for terminal operations",
+            sandboxId: "",
+            provider: provider.name
+          };
+        }
+        const sandbox = await getSandbox(request.sandboxId);
+        const terminal = await sandbox.terminal.create(request.terminalOptions);
+        return {
+          success: true,
+          sandboxId: request.sandboxId,
+          provider: provider.name,
+          terminal: {
+            pid: terminal.pid,
+            command: terminal.command,
+            status: terminal.status,
+            cols: terminal.cols,
+            rows: terminal.rows
+          }
+        };
+      }
+      case "compute.sandbox.terminal.list": {
+        if (!request.sandboxId) {
+          return {
+            success: false,
+            error: "Sandbox ID is required for terminal operations",
+            sandboxId: "",
+            provider: provider.name
+          };
+        }
+        const sandbox = await getSandbox(request.sandboxId);
+        const terminals = await sandbox.terminal.list();
+        return {
+          success: true,
+          sandboxId: request.sandboxId,
+          provider: provider.name,
+          terminals: terminals.map((terminal) => ({
+            pid: terminal.pid,
+            command: terminal.command,
+            status: terminal.status,
+            cols: terminal.cols,
+            rows: terminal.rows
+          }))
+        };
+      }
+      case "compute.sandbox.terminal.getById": {
+        if (!request.sandboxId) {
+          return {
+            success: false,
+            error: "Sandbox ID is required for terminal operations",
+            sandboxId: "",
+            provider: provider.name
+          };
+        }
+        if (!request.terminalId) {
+          return {
+            success: false,
+            error: "Terminal ID is required for getById action",
+            sandboxId: request.sandboxId,
+            provider: provider.name
+          };
+        }
+        const sandbox = await getSandbox(request.sandboxId);
+        const terminal = await sandbox.terminal.getById(request.terminalId);
+        if (!terminal) {
+          return {
+            success: false,
+            error: `Terminal with ID ${request.terminalId} not found`,
+            sandboxId: request.sandboxId,
+            provider: provider.name
+          };
+        }
+        return {
+          success: true,
+          sandboxId: request.sandboxId,
+          provider: provider.name,
+          terminal: {
+            pid: terminal.pid,
+            command: terminal.command,
+            status: terminal.status,
+            cols: terminal.cols,
+            rows: terminal.rows
+          }
+        };
+      }
+      case "compute.sandbox.terminal.destroy": {
+        if (!request.sandboxId) {
+          return {
+            success: false,
+            error: "Sandbox ID is required for terminal operations",
+            sandboxId: "",
+            provider: provider.name
+          };
+        }
+        if (!request.terminalId) {
+          return {
+            success: false,
+            error: "Terminal ID is required for destroy action",
+            sandboxId: request.sandboxId,
+            provider: provider.name
+          };
+        }
+        const sandbox = await getSandbox(request.sandboxId);
+        await sandbox.terminal.destroy(request.terminalId);
+        return {
+          success: true,
+          sandboxId: request.sandboxId,
+          provider: provider.name
+        };
+      }
+      // Terminal I/O operations
+      case "compute.sandbox.terminal.write": {
+        if (!request.sandboxId) {
+          return {
+            success: false,
+            error: "Sandbox ID is required for terminal operations",
+            sandboxId: "",
+            provider: provider.name
+          };
+        }
+        if (!request.terminalId) {
+          return {
+            success: false,
+            error: "Terminal ID is required for write action",
+            sandboxId: request.sandboxId,
+            provider: provider.name
+          };
+        }
+        if (!request.data) {
+          return {
+            success: false,
+            error: "Data is required for write action",
+            sandboxId: request.sandboxId,
+            provider: provider.name
+          };
+        }
+        const sandbox = await getSandbox(request.sandboxId);
+        const terminal = await sandbox.terminal.getById(request.terminalId);
+        if (!terminal) {
+          return {
+            success: false,
+            error: `Terminal with ID ${request.terminalId} not found`,
+            sandboxId: request.sandboxId,
+            provider: provider.name
+          };
+        }
+        await terminal.write(request.data);
+        return {
+          success: true,
+          sandboxId: request.sandboxId,
+          provider: provider.name
+        };
+      }
+      case "compute.sandbox.terminal.resize": {
+        if (!request.sandboxId) {
+          return {
+            success: false,
+            error: "Sandbox ID is required for terminal operations",
+            sandboxId: "",
+            provider: provider.name
+          };
+        }
+        if (!request.terminalId) {
+          return {
+            success: false,
+            error: "Terminal ID is required for resize action",
+            sandboxId: request.sandboxId,
+            provider: provider.name
+          };
+        }
+        if (!request.cols || !request.rows) {
+          return {
+            success: false,
+            error: "Cols and rows are required for resize action",
+            sandboxId: request.sandboxId,
+            provider: provider.name
+          };
+        }
+        const sandbox = await getSandbox(request.sandboxId);
+        const terminal = await sandbox.terminal.getById(request.terminalId);
+        if (!terminal) {
+          return {
+            success: false,
+            error: `Terminal with ID ${request.terminalId} not found`,
+            sandboxId: request.sandboxId,
+            provider: provider.name
+          };
+        }
+        await terminal.resize(request.cols, request.rows);
+        return {
+          success: true,
+          sandboxId: request.sandboxId,
+          provider: provider.name
+        };
+      }
+      case "compute.sandbox.terminal.kill": {
+        if (!request.sandboxId) {
+          return {
+            success: false,
+            error: "Sandbox ID is required for terminal operations",
+            sandboxId: "",
+            provider: provider.name
+          };
+        }
+        if (!request.terminalId) {
+          return {
+            success: false,
+            error: "Terminal ID is required for kill action",
+            sandboxId: request.sandboxId,
+            provider: provider.name
+          };
+        }
+        const sandbox = await getSandbox(request.sandboxId);
+        const terminal = await sandbox.terminal.getById(request.terminalId);
+        if (!terminal) {
+          return {
+            success: false,
+            error: `Terminal with ID ${request.terminalId} not found`,
+            sandboxId: request.sandboxId,
+            provider: provider.name
+          };
+        }
+        await terminal.kill();
+        return {
+          success: true,
+          sandboxId: request.sandboxId,
+          provider: provider.name
+        };
+      }
+      default:
+        return {
+          success: false,
+          error: `Unknown action: ${request.action}`,
+          sandboxId: request.sandboxId || "",
+          provider: provider.name
+        };
+    }
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : "Unknown error occurred",
+      sandboxId: request.sandboxId || "",
+      provider: provider.name
+    };
+  }
 }
-function detectAvailableProviders() {
-  const available = [];
-  if (process.env[ENV_KEYS.E2B]) {
-    available.push("e2b");
+
+// src/factory.ts
+var UnsupportedFileSystem = class {
+  constructor(providerName) {
+    this.providerName = providerName;
   }
-  if (process.env[ENV_KEYS.VERCEL]) {
-    available.push("vercel");
+  async readFile(_path) {
+    throw new Error(`Filesystem operations are not supported by ${this.providerName}'s sandbox environment. ${this.providerName} sandboxes are designed for code execution only.`);
   }
-  if (isCloudflareWorkers() || process.env[ENV_KEYS.CLOUDFLARE]) {
-    available.push("cloudflare");
+  async writeFile(_path, _content) {
+    throw new Error(`Filesystem operations are not supported by ${this.providerName}'s sandbox environment. ${this.providerName} sandboxes are designed for code execution only.`);
   }
-  if (process.env[ENV_KEYS.FLY]) {
-    available.push("fly");
+  async mkdir(_path) {
+    throw new Error(`Filesystem operations are not supported by ${this.providerName}'s sandbox environment. ${this.providerName} sandboxes are designed for code execution only.`);
   }
-  return available;
-}
-function autoSelectProvider() {
-  const available = detectAvailableProviders();
-  return available.length > 0 ? available[0] : void 0;
-}
-function normalizeContainerConfig(container) {
-  if (!container) {
-    return void 0;
+  async readdir(_path) {
+    throw new Error(`Filesystem operations are not supported by ${this.providerName}'s sandbox environment. ${this.providerName} sandboxes are designed for code execution only.`);
   }
-  if (typeof container === "string") {
-    return { image: container };
+  async exists(_path) {
+    throw new Error(`Filesystem operations are not supported by ${this.providerName}'s sandbox environment. ${this.providerName} sandboxes are designed for code execution only.`);
   }
-  if (!container.image) {
-    throw new ConfigurationError("Container configuration must include an image", "config");
+  async remove(_path) {
+    throw new Error(`Filesystem operations are not supported by ${this.providerName}'s sandbox environment. ${this.providerName} sandboxes are designed for code execution only.`);
   }
-  return container;
-}
-function getDefaultRuntime(provider, runtime) {
-  if (runtime) {
-    return runtime;
-  }
-  switch (provider) {
-    case "e2b":
-      return "python";
-    case "vercel":
-      return "node";
-    case "cloudflare":
-    case "fly":
-      throw new ConfigurationError(
-        `Container-based provider '${provider}' requires explicit runtime or container configuration`,
-        provider
-      );
-    default:
-      return "node";
+};
+var UnsupportedTerminal = class {
+  constructor(providerName) {
+    this.providerName = providerName;
   }
-}
-function validateProviderApiKey(provider) {
-  let envKey;
-  switch (provider) {
-    case "e2b":
-      envKey = ENV_KEYS.E2B;
-      break;
-    case "vercel":
-      envKey = ENV_KEYS.VERCEL;
-      break;
-    case "cloudflare":
-      if (isCloudflareWorkers()) {
-        return;
-      }
-      envKey = ENV_KEYS.CLOUDFLARE;
-      break;
-    case "fly":
-      envKey = ENV_KEYS.FLY;
-      break;
-    case "auto":
-      return;
-    // Will be handled by auto-selection
-    default:
-      throw new ConfigurationError(`Unknown provider: ${provider}`, "config");
-  }
-  if (!process.env[envKey]) {
-    const available = detectAvailableProviders();
-    const suggestions = available.length > 0 ? `Available providers: ${available.join(", ")}` : `No provider API keys found. Set ${Object.values(ENV_KEYS).join(" or ")} environment variables.`;
-    throw new ConfigurationError(
-      `Missing API key for provider '${provider}'. ${suggestions}`,
-      provider
-    );
+  async create(_options) {
+    throw new Error(`Terminal operations are not supported by ${this.providerName}'s sandbox environment. ${this.providerName} sandboxes are designed for code execution only.`);
   }
-}
-function normalizeSandboxConfig(config) {
-  const normalized = {
-    provider: config?.provider || "auto",
-    timeout: config?.timeout || DEFAULT_TIMEOUT
-  };
-  if (normalized.provider === "auto") {
-    const autoProvider = autoSelectProvider();
-    if (!autoProvider) {
-      throw new ConfigurationError(
-        `No provider API keys found. Set one of the following environment variables: ${Object.values(ENV_KEYS).join(", ")}`,
-        "config"
-      );
-    }
-    normalized.provider = autoProvider;
-  } else {
-    validateProviderApiKey(normalized.provider);
+  async getById(_terminalId) {
+    throw new Error(`Terminal operations are not supported by ${this.providerName}'s sandbox environment. ${this.providerName} sandboxes are designed for code execution only.`);
   }
-  if (config?.runtime) {
-    normalized.runtime = config.runtime;
-  } else if (!config?.container) {
-    normalized.runtime = getDefaultRuntime(normalized.provider);
+  async list() {
+    throw new Error(`Terminal operations are not supported by ${this.providerName}'s sandbox environment. ${this.providerName} sandboxes are designed for code execution only.`);
   }
-  if (config?.container) {
-    normalized.container = normalizeContainerConfig(config.container);
+  async destroy(_terminalId) {
+    throw new Error(`Terminal operations are not supported by ${this.providerName}'s sandbox environment. ${this.providerName} sandboxes are designed for code execution only.`);
   }
-  return normalized;
-}
-
-// src/utils.ts
-async function executeSandbox(params) {
-  return await params.sandbox.execute(params.code, params.runtime);
-}
-async function retry(fn, maxRetries = 3, baseDelay = 1e3) {
-  let lastError;
-  for (let i = 0; i < maxRetries; i++) {
-    try {
-      return await fn();
-    } catch (error) {
-      lastError = error instanceof Error ? error : new Error(String(error));
-      if (i === maxRetries - 1) {
-        throw lastError;
+};
+var SupportedFileSystem = class {
+  constructor(sandbox, methods) {
+    this.sandbox = sandbox;
+    this.methods = methods;
+  }
+  async readFile(path) {
+    return this.methods.readFile(this.sandbox, path);
+  }
+  async writeFile(path, content) {
+    return this.methods.writeFile(this.sandbox, path, content);
+  }
+  async mkdir(path) {
+    return this.methods.mkdir(this.sandbox, path);
+  }
+  async readdir(path) {
+    return this.methods.readdir(this.sandbox, path);
+  }
+  async exists(path) {
+    return this.methods.exists(this.sandbox, path);
+  }
+  async remove(path) {
+    return this.methods.remove(this.sandbox, path);
+  }
+};
+var GeneratedTerminalSession = class {
+  constructor(terminal, sandbox, methods, terminalId, command, cols = 80, rows = 24) {
+    this.terminal = terminal;
+    this.sandbox = sandbox;
+    this.methods = methods;
+    this.pid = parseInt(terminalId);
+    this.command = command;
+    this.status = "running";
+    this.cols = cols;
+    this.rows = rows;
+  }
+  async write(data) {
+    return this.methods.write(this.sandbox, this.terminal, data);
+  }
+  async resize(cols, rows) {
+    return this.methods.resize(this.sandbox, this.terminal, cols, rows);
+  }
+  async kill() {
+    return this.methods.kill(this.sandbox, this.terminal);
+  }
+};
+var SupportedTerminal = class {
+  constructor(sandbox, methods) {
+    this.sandbox = sandbox;
+    this.methods = methods;
+  }
+  async create(options) {
+    let terminalSession;
+    const createOptions = {
+      ...options,
+      onData: (data) => {
+        if (terminalSession?.onData) {
+          terminalSession.onData(data);
+        }
+      },
+      onExit: (exitCode) => {
+        if (terminalSession?.onExit) {
+          terminalSession.onExit(exitCode);
+        }
       }
-      const delay = baseDelay * Math.pow(2, i);
-      await new Promise((resolve) => setTimeout(resolve, delay));
-    }
+    };
+    const result = await this.methods.create(this.sandbox, createOptions);
+    terminalSession = new GeneratedTerminalSession(
+      result.terminal,
+      this.sandbox,
+      this.methods,
+      result.terminalId,
+      options?.command || "bash",
+      options?.cols || 80,
+      options?.rows || 24
+    );
+    terminalSession.onData = options?.onData;
+    terminalSession.onExit = options?.onExit;
+    return terminalSession;
   }
-  throw lastError;
-}
-
-// src/registry.ts
-function createComputeRegistry(providers) {
-  if (!providers || Object.keys(providers).length === 0) {
-    throw new ConfigurationError("Provider registry requires at least one provider", "registry");
-  }
-  function sandbox(id) {
-    const parts = id.split(":");
-    if (parts.length < 1) {
-      throw new ConfigurationError(`Invalid sandbox ID format: ${id}`, "registry");
-    }
-    const providerName = parts[0];
-    const providerFactory = providers[providerName];
-    if (!providerFactory) {
-      const availableProviders = Object.keys(providers).join(", ");
-      throw new ConfigurationError(
-        `Provider '${providerName}' not found in registry. Available providers: ${availableProviders}`,
-        "registry"
-      );
+  async getById(terminalId) {
+    const result = await this.methods.getById(this.sandbox, terminalId);
+    if (!result) return null;
+    return new GeneratedTerminalSession(
+      result.terminal,
+      this.sandbox,
+      this.methods,
+      result.terminalId,
+      "bash",
+      // Default command for existing terminals
+      80,
+      // Default cols
+      24
+      // Default rows
+    );
+  }
+  async list() {
+    const results = await this.methods.list(this.sandbox);
+    return results.map((result) => new GeneratedTerminalSession(
+      result.terminal,
+      this.sandbox,
+      this.methods,
+      result.terminalId,
+      "bash",
+      // Default command
+      80,
+      // Default cols
+      24
+      // Default rows
+    ));
+  }
+  async destroy(terminalId) {
+    return this.methods.destroy(this.sandbox, terminalId);
+  }
+};
+var GeneratedSandbox = class {
+  constructor(sandbox, sandboxId, providerName, methods, config, destroyMethod) {
+    this.sandbox = sandbox;
+    this.methods = methods;
+    this.config = config;
+    this.destroyMethod = destroyMethod;
+    this.sandboxId = sandboxId;
+    this.provider = providerName;
+    if (methods.filesystem) {
+      this.filesystem = new SupportedFileSystem(sandbox, methods.filesystem);
+    } else {
+      this.filesystem = new UnsupportedFileSystem(providerName);
     }
-    if (parts.length === 1) {
-      return providerFactory();
-    } else if (parts.length === 2) {
-      const runtimeOrImage = parts[1];
-      if (isRuntime(runtimeOrImage)) {
-        return providerFactory({ runtime: runtimeOrImage });
-      }
-      return providerFactory({ container: { image: runtimeOrImage } });
+    if (methods.terminal) {
+      this.terminal = new SupportedTerminal(sandbox, methods.terminal);
     } else {
-      const containerImage = parts.slice(1).join(":");
-      return providerFactory({ container: { image: containerImage } });
+      this.terminal = new UnsupportedTerminal(providerName);
     }
   }
-  return { sandbox };
-}
-function isRuntime(value) {
-  return ["node", "python"].includes(value);
-}
-
-// src/providers/base.ts
-var import_uuid = require("uuid");
-var BaseProvider = class {
-  /**
-   * Create a new base provider
-   * 
-   * @param provider Provider identifier
-   * @param timeout Execution timeout in milliseconds
-   */
-  constructor(provider, timeout) {
-    /** Specification version */
-    this.specificationVersion = "v1";
-    this.provider = provider;
-    this.sandboxId = (0, import_uuid.v4)();
-    this.timeout = timeout;
+  async runCode(code, runtime) {
+    return await this.methods.runCode(this.sandbox, code, runtime, this.config);
   }
-  /**
-   * Execute code in the sandbox
-   * 
-   * @param code Code to execute
-   * @param runtime Optional runtime to use
-   * @returns Execution result
-   */
-  async execute(code, runtime) {
-    const startTime = Date.now();
-    try {
-      const timeoutPromise = new Promise((_, reject) => {
-        setTimeout(() => {
-          reject(new TimeoutError(
-            `Execution timed out after ${this.timeout}ms`,
-            this.provider,
-            this.timeout,
-            this.sandboxId
-          ));
-        }, this.timeout);
-      });
-      const result = await Promise.race([
-        this.doExecute(code, runtime),
-        timeoutPromise
-      ]);
-      const executionTime = Date.now() - startTime;
-      return {
-        ...result,
-        executionTime,
-        sandboxId: this.sandboxId,
-        provider: this.provider
-      };
-    } catch (error) {
-      if (error instanceof Error && error.name.includes("Error") && "code" in error) {
-        throw error;
-      }
-      throw new ProviderError(
-        `Execution failed: ${error instanceof Error ? error.message : String(error)}`,
-        this.provider,
-        error instanceof Error ? error : void 0,
-        this.sandboxId
-      );
-    }
+  async runCommand(command, args) {
+    return await this.methods.runCommand(this.sandbox, command, args);
+  }
+  async getInfo() {
+    return await this.methods.getInfo(this.sandbox);
   }
-  /**
-   * Kill the sandbox
-   * 
-   * @returns Promise that resolves when the sandbox is killed
-   */
   async kill() {
-    try {
-      await this.doKill();
-    } catch (error) {
-      throw new ProviderError(
-        `Failed to kill sandbox: ${error instanceof Error ? error.message : String(error)}`,
-        this.provider,
-        error instanceof Error ? error : void 0,
-        this.sandboxId
-      );
-    }
+    await this.destroy();
   }
-  /**
-   * Get information about the sandbox
-   * 
-   * @returns Sandbox information
-   */
-  async getInfo() {
-    try {
-      return await this.doGetInfo();
-    } catch (error) {
-      throw new ProviderError(
-        `Failed to get sandbox info: ${error instanceof Error ? error.message : String(error)}`,
-        this.provider,
-        error instanceof Error ? error : void 0,
-        this.sandboxId
-      );
-    }
+  async destroy() {
+    await this.destroyMethod(this.config, this.sandboxId);
   }
 };
-
-// src/sdk.ts
-var ComputeSDK = class {
-  /**
-   * Create a new sandbox with the specified configuration
-   * 
-   * @param config Optional sandbox configuration
-   * @returns Configured sandbox instance
-   */
-  static createSandbox(config) {
-    const normalizedConfig = normalizeSandboxConfig(config);
-    const providerName = normalizedConfig.provider;
-    try {
-      const providerPackage = `@computesdk/${providerName}`;
-      const provider = require(providerPackage);
-      const factory = provider[providerName];
-      if (!factory) {
-        throw new ConfigurationError(
-          `Provider package ${providerPackage} does not export a '${providerName}' function`,
-          "sdk"
-        );
-      }
-      if (providerName === "cloudflare") {
-        throw new ConfigurationError(
-          'Cloudflare provider requires env parameter with Sandbox namespace. Use createSandbox({ provider: "cloudflare", env: yourEnv }) from within a Worker.',
-          "sdk"
-        );
-      } else if (providerName === "fly") {
-        if (!normalizedConfig.container) {
-          throw new ConfigurationError(
-            `${providerName} provider requires container configuration`,
-            "sdk"
-          );
-        }
-        return factory({ ...normalizedConfig, container: normalizedConfig.container });
-      } else {
-        return factory(normalizedConfig);
-      }
-    } catch (error) {
-      if (error instanceof ConfigurationError) {
-        throw error;
-      }
-      if (error.code === "MODULE_NOT_FOUND") {
-        throw new ConfigurationError(
-          `Provider '${providerName}' not installed. Run: npm install @computesdk/${providerName}`,
-          "sdk"
+var GeneratedSandboxManager = class {
+  constructor(config, providerName, methods) {
+    this.config = config;
+    this.providerName = providerName;
+    this.methods = methods;
+    this.activeSandboxes = /* @__PURE__ */ new Map();
+  }
+  async create(options) {
+    const result = await this.methods.create(this.config, options);
+    const sandbox = new GeneratedSandbox(
+      result.sandbox,
+      result.sandboxId,
+      this.providerName,
+      this.methods,
+      this.config,
+      this.methods.destroy
+    );
+    this.activeSandboxes.set(result.sandboxId, sandbox);
+    return sandbox;
+  }
+  async getById(sandboxId) {
+    const existing = this.activeSandboxes.get(sandboxId);
+    if (existing) {
+      return existing;
+    }
+    const result = await this.methods.getById(this.config, sandboxId);
+    if (!result) {
+      return null;
+    }
+    const sandbox = new GeneratedSandbox(
+      result.sandbox,
+      result.sandboxId,
+      this.providerName,
+      this.methods,
+      this.config,
+      this.methods.destroy
+    );
+    this.activeSandboxes.set(result.sandboxId, sandbox);
+    return sandbox;
+  }
+  async list() {
+    const results = await this.methods.list(this.config);
+    const sandboxes = [];
+    for (const result of results) {
+      let sandbox = this.activeSandboxes.get(result.sandboxId);
+      if (!sandbox) {
+        sandbox = new GeneratedSandbox(
+          result.sandbox,
+          result.sandboxId,
+          this.providerName,
+          this.methods,
+          this.config,
+          this.methods.destroy
         );
+        this.activeSandboxes.set(result.sandboxId, sandbox);
       }
-      throw new ConfigurationError(
-        `Failed to load provider '${providerName}': ${error.message}`,
-        "sdk"
-      );
+      sandboxes.push(sandbox);
     }
+    return sandboxes;
   }
-  /**
-   * Detect available providers based on environment variables
-   * 
-   * @returns Array of available provider types
-   */
-  static detectProviders() {
-    return detectAvailableProviders();
+  async destroy(sandboxId) {
+    await this.methods.destroy(this.config, sandboxId);
+    this.activeSandboxes.delete(sandboxId);
   }
 };
-
-// src/index.ts
-var index_default = ComputeSDK;
+var GeneratedProvider = class {
+  constructor(config, providerConfig) {
+    this.name = providerConfig.name;
+    this.sandbox = new GeneratedSandboxManager(
+      config,
+      providerConfig.name,
+      providerConfig.methods.sandbox
+    );
+  }
+};
+function createProvider(providerConfig) {
+  return (config) => {
+    return new GeneratedProvider(config, providerConfig);
+  };
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  AuthenticationError,
-  BaseProvider,
-  ComputeError,
-  ComputeSDK,
-  ConfigurationError,
-  DEFAULT_TIMEOUT,
-  ENV_KEYS,
-  ExecutionError,
-  ProviderError,
-  ProviderUnavailableError,
-  TimeoutError,
-  autoSelectProvider,
-  createComputeRegistry,
-  detectAvailableProviders,
-  executeSandbox,
-  getDefaultRuntime,
-  isCloudflareWorkers,
-  normalizeContainerConfig,
-  normalizeSandboxConfig,
-  retry,
-  validateProviderApiKey
+  SandboxManager,
+  compute,
+  createProvider,
+  handleComputeRequest
 });
 //# sourceMappingURL=index.js.map