computesdk 1.1.0 → 1.2.0

package/dist/index.js

@@ -20,45 +20,29 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
-  SandboxManager: () => SandboxManager,
+  CommandExitError: () => CommandExitError,
   compute: () => compute,
   createProvider: () => createProvider,
-  handleComputeRequest: () => handleComputeRequest
+  handleComputeRequest: () => handleComputeRequest,
+  isCommandExitError: () => isCommandExitError
 });
 module.exports = __toCommonJS(index_exports);
 
-// src/sandbox.ts
-var SandboxManager = class {
-  /**
-   * Create a sandbox from a provider
-   */
-  async create(provider, options) {
-    return await provider.sandbox.create(options);
-  }
-  /**
-   * Get an existing sandbox by ID from a provider
-   */
-  async getById(provider, sandboxId) {
-    return await provider.sandbox.getById(sandboxId);
-  }
-  /**
-   * List all active sandboxes from a provider
-   */
-  async list(provider) {
-    return await provider.sandbox.list();
-  }
-  /**
-   * Destroy a sandbox via a provider
-   */
-  async destroy(provider, sandboxId) {
-    return await provider.sandbox.destroy(sandboxId);
+// src/types/sandbox.ts
+var CommandExitError = class extends Error {
+  constructor(result) {
+    super(`Command exited with code ${result.exitCode}`);
+    this.result = result;
+    this.name = "CommandExitError";
   }
 };
+function isCommandExitError(error) {
+  return typeof error === "object" && error !== null && "name" in error && error.name === "CommandExitError" && "result" in error;
+}
 
 // src/compute.ts
 var ComputeManager = class {
   constructor() {
-    this.sandboxManager = new SandboxManager();
     this.config = null;
     this.sandbox = {
       /**
@@ -74,15 +58,16 @@ var ComputeManager = class {
        *   provider: e2b({ apiKey: 'your-key' })
        * })
        * 
-       * // With default provider
-       * compute.setConfig({ provider: e2b({ apiKey: 'your-key' }) })
-       * const sandbox = await compute.sandbox.create({})
+        * // With default provider (both forms work)
+        * compute.setConfig({ defaultProvider: e2b({ apiKey: 'your-key' }) })
+        * const sandbox1 = await compute.sandbox.create({})
+        * const sandbox2 = 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);
+        const provider = params && "provider" in params && params.provider ? params.provider : this.getDefaultProvider();
+        const options = params?.options;
+        return await provider.sandbox.create(options);
       },
       /**
        * Get an existing sandbox by ID from a provider (or default provider if configured)
@@ -90,12 +75,12 @@ var ComputeManager = class {
       getById: async (providerOrSandboxId, sandboxId) => {
         if (typeof providerOrSandboxId === "string") {
           const provider = this.getDefaultProvider();
-          return await this.sandboxManager.getById(provider, providerOrSandboxId);
+          return await provider.sandbox.getById(providerOrSandboxId);
         } else {
           if (!sandboxId) {
             throw new Error("sandboxId is required when provider is specified");
           }
-          return await this.sandboxManager.getById(providerOrSandboxId, sandboxId);
+          return await providerOrSandboxId.sandbox.getById(sandboxId);
         }
       },
       /**
@@ -103,7 +88,7 @@ var ComputeManager = class {
        */
       list: async (provider) => {
         const actualProvider = provider || this.getDefaultProvider();
-        return await this.sandboxManager.list(actualProvider);
+        return await actualProvider.sandbox.list();
       },
       /**
        * Destroy a sandbox via a provider (or default provider if configured)
@@ -111,12 +96,12 @@ var ComputeManager = class {
       destroy: async (providerOrSandboxId, sandboxId) => {
         if (typeof providerOrSandboxId === "string") {
           const provider = this.getDefaultProvider();
-          return await this.sandboxManager.destroy(provider, providerOrSandboxId);
+          return await provider.sandbox.destroy(providerOrSandboxId);
         } else {
           if (!sandboxId) {
             throw new Error("sandboxId is required when provider is specified");
           }
-          return await this.sandboxManager.destroy(providerOrSandboxId, sandboxId);
+          return await providerOrSandboxId.sandbox.destroy(sandboxId);
         }
       }
     };
@@ -125,7 +110,17 @@ var ComputeManager = class {
    * Set default configuration
    */
   setConfig(config) {
-    this.config = config;
+    if (!config.defaultProvider && !config.provider) {
+      throw new Error("Either defaultProvider or provider must be specified in setConfig");
+    }
+    if (config.defaultProvider && config.provider) {
+      console.warn("Both defaultProvider and provider specified in setConfig. Using defaultProvider. The provider key is deprecated, please use defaultProvider instead.");
+    }
+    const actualProvider = config.defaultProvider || config.provider;
+    this.config = {
+      provider: actualProvider,
+      defaultProvider: actualProvider
+    };
   }
   /**
    * Get current configuration
@@ -145,7 +140,7 @@ var ComputeManager = class {
   getDefaultProvider() {
     if (!this.config?.provider) {
       throw new Error(
-        "No default provider configured. Either call compute.setConfig({ provider }) or pass provider explicitly."
+        "No default provider configured. Either call compute.setConfig({ defaultProvider }) or pass provider explicitly."
       );
     }
     return this.config.provider;
@@ -154,567 +149,281 @@ var ComputeManager = class {
   // 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/request-handler.ts
-async function handleComputeRequest(params) {
-  const { request, provider } = params;
+async function executeAction(body, provider) {
   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" }
-        });
+    const { action, sandboxId } = body;
+    if (action === "compute.sandbox.create") {
+      const sandbox2 = await compute.sandbox.create({
+        provider,
+        options: body.options || { runtime: "python" }
+      });
+      return {
+        success: true,
+        sandboxId: sandbox2.sandboxId,
+        provider: provider.name
+      };
+    }
+    if (action === "compute.sandbox.list") {
+      const sandboxes = await compute.sandbox.list(provider);
+      return {
+        success: true,
+        sandboxId: "",
+        provider: provider.name,
+        sandboxes: sandboxes.map((sb) => ({
+          sandboxId: sb.sandboxId,
+          provider: sb.provider
+        }))
+      };
+    }
+    if (action === "compute.sandbox.destroy") {
+      if (!sandboxId) {
+        throw new Error("sandboxId is required for destroy action");
       }
+      await compute.sandbox.destroy(provider, sandboxId);
+      return {
+        success: true,
+        sandboxId,
+        provider: provider.name
+      };
+    }
+    if (!sandboxId) {
+      throw new Error("sandboxId is required for this action");
+    }
+    const sandbox = await compute.sandbox.getById(provider, sandboxId);
+    if (!sandbox) {
+      throw new Error(`Sandbox ${sandboxId} not found`);
+    }
+    if (action === "compute.sandbox.getInfo") {
+      const result = await sandbox.getInfo();
+      return {
+        success: true,
+        sandboxId,
+        provider: provider.name,
+        info: {
+          id: result.id,
+          provider: result.provider,
+          runtime: result.runtime,
+          status: result.status,
+          createdAt: result.createdAt.toISOString(),
+          timeout: result.timeout,
+          metadata: result.metadata
+        }
+      };
+    }
+    if (action === "compute.sandbox.runCode") {
+      if (!body.code) throw new Error("code is required");
+      const result = await sandbox.runCode(body.code, body.runtime);
+      return {
+        success: true,
+        sandboxId,
+        provider: provider.name,
+        result: {
+          stdout: result.stdout,
+          stderr: result.stderr,
+          exitCode: result.exitCode,
+          executionTime: result.executionTime
+        }
+      };
+    }
+    if (action === "compute.sandbox.runCommand") {
+      if (!body.command) throw new Error("command is required");
+      const result = await sandbox.runCommand(body.command, body.args);
+      return {
+        success: true,
+        sandboxId,
+        provider: provider.name,
+        result: {
+          stdout: result.stdout,
+          stderr: result.stderr,
+          exitCode: result.exitCode,
+          executionTime: result.executionTime
+        }
+      };
+    }
+    if (action === "compute.sandbox.filesystem.readFile") {
+      if (!body.path) throw new Error("path is required");
+      const result = await sandbox.filesystem.readFile(body.path);
+      return {
+        success: true,
+        sandboxId,
+        provider: provider.name,
+        fileContent: result
+      };
+    }
+    if (action === "compute.sandbox.filesystem.writeFile") {
+      if (!body.path) throw new Error("path is required");
+      if (body.content === void 0) throw new Error("content is required");
+      await sandbox.filesystem.writeFile(body.path, body.content);
+      return { success: true, sandboxId, provider: provider.name };
+    }
+    if (action === "compute.sandbox.filesystem.mkdir") {
+      if (!body.path) throw new Error("path is required");
+      await sandbox.filesystem.mkdir(body.path);
+      return { success: true, sandboxId, provider: provider.name };
+    }
+    if (action === "compute.sandbox.filesystem.readdir") {
+      if (!body.path) throw new Error("path is required");
+      const result = await sandbox.filesystem.readdir(body.path);
+      return {
+        success: true,
+        sandboxId,
+        provider: provider.name,
+        files: result.map((entry) => ({
+          name: entry.name,
+          path: entry.path,
+          isDirectory: entry.isDirectory,
+          size: entry.size,
+          lastModified: entry.lastModified.toISOString()
+        }))
+      };
+    }
+    if (action === "compute.sandbox.filesystem.exists") {
+      if (!body.path) throw new Error("path is required");
+      const result = await sandbox.filesystem.exists(body.path);
+      return {
+        success: true,
+        sandboxId,
+        provider: provider.name,
+        exists: result
+      };
+    }
+    if (action === "compute.sandbox.filesystem.remove") {
+      if (!body.path) throw new Error("path is required");
+      await sandbox.filesystem.remove(body.path);
+      return { success: true, sandboxId, provider: provider.name };
+    }
+    throw new Error(`Unknown action: ${action}`);
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : "Unknown error occurred",
+      sandboxId: body.sandboxId || "",
+      provider: provider.name
     };
-    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,
+  }
+}
+async function handleComputeRequest(paramsOrRequestOrBody, provider) {
+  if (typeof paramsOrRequestOrBody === "object" && "request" in paramsOrRequestOrBody && "provider" in paramsOrRequestOrBody) {
+    const params = paramsOrRequestOrBody;
+    return await executeAction(params.request, params.provider);
+  }
+  if (!provider) {
+    throw new Error("Provider is required when not using object-style API");
+  }
+  const requestOrBody = paramsOrRequestOrBody;
+  try {
+    let body;
+    if (requestOrBody instanceof Request) {
+      if (requestOrBody.method !== "POST") {
+        return Response.json({
+          success: false,
+          error: "Only POST requests are supported",
           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
-        };
+        }, { status: 405 });
       }
-      // 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 {
+      try {
+        body = await requestOrBody.json();
+      } catch (parseError) {
+        return Response.json({
           success: false,
-          error: `Unknown action: ${request.action}`,
-          sandboxId: request.sandboxId || "",
+          error: "Invalid JSON in request body",
+          sandboxId: "",
           provider: provider.name
-        };
+        }, { status: 400 });
+      }
+    } else {
+      body = requestOrBody;
     }
+    const result = await executeAction(body, provider);
+    return Response.json(result, {
+      status: result.success ? 200 : 500
+    });
   } catch (error) {
-    return {
+    return Response.json({
       success: false,
-      error: error instanceof Error ? error.message : "Unknown error occurred",
-      sandboxId: request.sandboxId || "",
+      error: error instanceof Error ? error.message : "Request handling failed",
+      sandboxId: "",
       provider: provider.name
-    };
+    }, { status: 500 });
   }
 }
 
 // src/factory.ts
+var defaultFilesystemMethods = {
+  readFile: async (sandbox, path, runCommand) => {
+    const result = await runCommand(sandbox, "cat", [path]);
+    if (result.exitCode !== 0) {
+      throw new Error(`Failed to read file ${path}: ${result.stderr}`);
+    }
+    return result.stdout.replace(/\n$/, "");
+  },
+  writeFile: async (sandbox, path, content, runCommand) => {
+    const result = await runCommand(sandbox, "sh", ["-c", `echo ${JSON.stringify(content)} > ${JSON.stringify(path)}`]);
+    if (result.exitCode !== 0) {
+      throw new Error(`Failed to write file ${path}: ${result.stderr}`);
+    }
+  },
+  mkdir: async (sandbox, path, runCommand) => {
+    const result = await runCommand(sandbox, "mkdir", ["-p", path]);
+    if (result.exitCode !== 0) {
+      throw new Error(`Failed to create directory ${path}: ${result.stderr}`);
+    }
+  },
+  readdir: async (sandbox, path, runCommand) => {
+    let result = await runCommand(sandbox, "ls", ["-la", path]);
+    let hasDetailedOutput = true;
+    if (result.exitCode !== 0) {
+      result = await runCommand(sandbox, "ls", ["-l", path]);
+    }
+    if (result.exitCode !== 0) {
+      result = await runCommand(sandbox, "ls", [path]);
+      hasDetailedOutput = false;
+    }
+    if (result.exitCode !== 0) {
+      throw new Error(`Failed to list directory ${path}: ${result.stderr}`);
+    }
+    const lines = (result.stdout || "").split("\n").filter((line) => line.trim() && !line.startsWith("total"));
+    return lines.map((line) => {
+      if (hasDetailedOutput && line.includes(" ")) {
+        const parts = line.trim().split(/\s+/);
+        const name = parts[parts.length - 1];
+        const isDirectory = line.startsWith("d");
+        return {
+          name,
+          path: `${path}/${name}`,
+          isDirectory,
+          size: parseInt(parts[4]) || 0,
+          lastModified: /* @__PURE__ */ new Date()
+        };
+      } else {
+        const name = line.trim();
+        return {
+          name,
+          path: `${path}/${name}`,
+          isDirectory: false,
+          // Can't determine from simple ls
+          size: 0,
+          lastModified: /* @__PURE__ */ new Date()
+        };
+      }
+    });
+  },
+  exists: async (sandbox, path, runCommand) => {
+    const result = await runCommand(sandbox, "test", ["-e", path]);
+    return result.exitCode === 0;
+  },
+  remove: async (sandbox, path, runCommand) => {
+    const result = await runCommand(sandbox, "rm", ["-rf", path]);
+    if (result.exitCode !== 0) {
+      throw new Error(`Failed to remove ${path}: ${result.stderr}`);
+    }
+  }
+};
 var UnsupportedFileSystem = class {
   constructor(providerName) {
     this.providerName = providerName;
@@ -738,155 +447,46 @@ var UnsupportedFileSystem = class {
     throw new Error(`Filesystem operations are not supported by ${this.providerName}'s sandbox environment. ${this.providerName} sandboxes are designed for code execution only.`);
   }
 };
-var UnsupportedTerminal = class {
-  constructor(providerName) {
-    this.providerName = providerName;
-  }
-  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.`);
-  }
-  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.`);
-  }
-  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.`);
-  }
-  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.`);
-  }
-};
 var SupportedFileSystem = class {
-  constructor(sandbox, methods) {
+  constructor(sandbox, methods, allMethods) {
     this.sandbox = sandbox;
     this.methods = methods;
+    this.allMethods = allMethods;
   }
   async readFile(path) {
-    return this.methods.readFile(this.sandbox, path);
+    return this.methods.readFile(this.sandbox, path, this.allMethods.runCommand);
   }
   async writeFile(path, content) {
-    return this.methods.writeFile(this.sandbox, path, content);
+    return this.methods.writeFile(this.sandbox, path, content, this.allMethods.runCommand);
   }
   async mkdir(path) {
-    return this.methods.mkdir(this.sandbox, path);
+    return this.methods.mkdir(this.sandbox, path, this.allMethods.runCommand);
   }
   async readdir(path) {
-    return this.methods.readdir(this.sandbox, path);
+    return this.methods.readdir(this.sandbox, path, this.allMethods.runCommand);
   }
   async exists(path) {
-    return this.methods.exists(this.sandbox, path);
+    return this.methods.exists(this.sandbox, path, this.allMethods.runCommand);
   }
   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 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;
-  }
-  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);
+    return this.methods.remove(this.sandbox, path, this.allMethods.runCommand);
   }
 };
 var GeneratedSandbox = class {
-  constructor(sandbox, sandboxId, providerName, methods, config, destroyMethod) {
+  constructor(sandbox, sandboxId, providerName, methods, config, destroyMethod, providerInstance) {
     this.sandbox = sandbox;
     this.methods = methods;
     this.config = config;
     this.destroyMethod = destroyMethod;
+    this.providerInstance = providerInstance;
     this.sandboxId = sandboxId;
     this.provider = providerName;
+    this.instance = sandbox;
     if (methods.filesystem) {
-      this.filesystem = new SupportedFileSystem(sandbox, methods.filesystem);
+      this.filesystem = new SupportedFileSystem(sandbox, methods.filesystem, methods);
     } else {
       this.filesystem = new UnsupportedFileSystem(providerName);
     }
-    if (methods.terminal) {
-      this.terminal = new SupportedTerminal(sandbox, methods.terminal);
-    } else {
-      this.terminal = new UnsupportedTerminal(providerName);
-    }
   }
   async runCode(code, runtime) {
     return await this.methods.runCode(this.sandbox, code, runtime, this.config);
@@ -897,6 +497,12 @@ var GeneratedSandbox = class {
   async getInfo() {
     return await this.methods.getInfo(this.sandbox);
   }
+  async getUrl(options) {
+    return await this.methods.getUrl(this.sandbox, options);
+  }
+  getProvider() {
+    return this.providerInstance;
+  }
   async kill() {
     await this.destroy();
   }
@@ -905,10 +511,11 @@ var GeneratedSandbox = class {
   }
 };
 var GeneratedSandboxManager = class {
-  constructor(config, providerName, methods) {
+  constructor(config, providerName, methods, providerInstance) {
     this.config = config;
     this.providerName = providerName;
     this.methods = methods;
+    this.providerInstance = providerInstance;
     this.activeSandboxes = /* @__PURE__ */ new Map();
   }
   async create(options) {
@@ -919,7 +526,8 @@ var GeneratedSandboxManager = class {
       this.providerName,
       this.methods,
       this.config,
-      this.methods.destroy
+      this.methods.destroy,
+      this.providerInstance
     );
     this.activeSandboxes.set(result.sandboxId, sandbox);
     return sandbox;
@@ -939,7 +547,8 @@ var GeneratedSandboxManager = class {
       this.providerName,
       this.methods,
       this.config,
-      this.methods.destroy
+      this.methods.destroy,
+      this.providerInstance
     );
     this.activeSandboxes.set(result.sandboxId, sandbox);
     return sandbox;
@@ -956,7 +565,8 @@ var GeneratedSandboxManager = class {
           this.providerName,
           this.methods,
           this.config,
-          this.methods.destroy
+          this.methods.destroy,
+          this.providerInstance
         );
         this.activeSandboxes.set(result.sandboxId, sandbox);
       }
@@ -975,20 +585,25 @@ var GeneratedProvider = class {
     this.sandbox = new GeneratedSandboxManager(
       config,
       providerConfig.name,
-      providerConfig.methods.sandbox
+      providerConfig.methods.sandbox,
+      this
     );
   }
 };
 function createProvider(providerConfig) {
+  if (!providerConfig.methods.sandbox.filesystem) {
+    providerConfig.methods.sandbox.filesystem = defaultFilesystemMethods;
+  }
   return (config) => {
     return new GeneratedProvider(config, providerConfig);
   };
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  SandboxManager,
+  CommandExitError,
   compute,
   createProvider,
-  handleComputeRequest
+  handleComputeRequest,
+  isCommandExitError
 });
 //# sourceMappingURL=index.js.map