@cloudflare/sandbox 0.2.4 → 0.3.1

package/dist/{chunk-CKIGERRS.js → chunk-LFLJGISB.js}

@@ -4,19 +4,12 @@ import {
   sanitizeSandboxId,
   validatePort
 } from "./chunk-6UAWTJ5S.js";
-import {
-  parseSSEStream
-} from "./chunk-NNGBXDMY.js";
-import {
-  ProcessNotFoundError,
-  SandboxError
-} from "./chunk-6EWSYSO7.js";
 import {
   CodeInterpreter
 } from "./chunk-FKBV7CZS.js";
 import {
   JupyterClient
-} from "./chunk-HHUDRGPY.js";
+} from "./chunk-BEQUGUY4.js";
 
 // src/sandbox.ts
 import { Container, getContainer } from "@cloudflare/containers";
@@ -134,6 +127,7 @@ var Sandbox = class extends Container {
   client;
   sandboxName = null;
   codeInterpreter;
+  defaultSession = null;
   constructor(ctx, env) {
     super(ctx, env);
     this.client = new JupyterClient({
@@ -172,15 +166,15 @@ var Sandbox = class extends Container {
   async setEnvVars(envVars) {
     this.envVars = { ...this.envVars, ...envVars };
     console.log(`[Sandbox] Updated environment variables`);
+    if (this.defaultSession) {
+      await this.defaultSession.setEnvVars(envVars);
+    }
   }
   onStart() {
     console.log("Sandbox successfully started");
   }
   onStop() {
     console.log("Sandbox successfully shut down");
-    if (this.client) {
-      this.client.clearSession();
-    }
   }
   onError(error) {
     console.log("Sandbox error:", error);
@@ -202,295 +196,97 @@ var Sandbox = class extends Container {
     if (proxyMatch) {
       return parseInt(proxyMatch[1]);
     }
-    return 3e3;
-  }
-  // Enhanced exec method - always returns ExecResult with optional streaming
-  // This replaces the old exec method to match ISandbox interface
-  async exec(command, options) {
-    const startTime = Date.now();
-    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-    let timeoutId;
-    try {
-      if (options?.signal?.aborted) {
-        throw new Error("Operation was aborted");
-      }
-      let result;
-      if (options?.stream && options?.onOutput) {
-        result = await this.executeWithStreaming(
-          command,
-          options,
-          startTime,
-          timestamp
-        );
-      } else {
-        const response = await this.client.execute(command, {
-          sessionId: options?.sessionId,
-          cwd: options?.cwd,
-          env: options?.env
-        });
-        const duration = Date.now() - startTime;
-        result = this.mapExecuteResponseToExecResult(
-          response,
-          duration,
-          options?.sessionId
-        );
-      }
-      if (options?.onComplete) {
-        options.onComplete(result);
-      }
-      return result;
-    } catch (error) {
-      if (options?.onError && error instanceof Error) {
-        options.onError(error);
-      }
-      throw error;
-    } finally {
-      if (timeoutId) {
-        clearTimeout(timeoutId);
-      }
+    if (url.port) {
+      return parseInt(url.port);
     }
+    return 3e3;
   }
-  async executeWithStreaming(command, options, startTime, timestamp) {
-    let stdout = "";
-    let stderr = "";
-    try {
-      const stream = await this.client.executeCommandStream(
-        command,
-        options.sessionId
-      );
-      for await (const event of parseSSEStream(stream)) {
-        if (options.signal?.aborted) {
-          throw new Error("Operation was aborted");
-        }
-        switch (event.type) {
-          case "stdout":
-          case "stderr":
-            if (event.data) {
-              if (event.type === "stdout") stdout += event.data;
-              if (event.type === "stderr") stderr += event.data;
-              if (options.onOutput) {
-                options.onOutput(event.type, event.data);
-              }
-            }
-            break;
-          case "complete": {
-            const duration = Date.now() - startTime;
-            return event.result || {
-              success: event.exitCode === 0,
-              exitCode: event.exitCode || 0,
-              stdout,
-              stderr,
-              command,
-              duration,
-              timestamp,
-              sessionId: options.sessionId
-            };
-          }
-          case "error":
-            throw new Error(event.error || "Command execution failed");
-        }
-      }
-      throw new Error("Stream ended without completion event");
-    } catch (error) {
-      if (options.signal?.aborted) {
-        throw new Error("Operation was aborted");
-      }
-      throw error;
+  // Helper to ensure default session is initialized
+  async ensureDefaultSession() {
+    if (!this.defaultSession) {
+      const sessionId = `sandbox-${this.sandboxName || "default"}`;
+      this.defaultSession = await this.createSession({
+        id: sessionId,
+        env: this.envVars || {},
+        cwd: "/workspace",
+        isolation: true
+      });
+      console.log(`[Sandbox] Default session initialized: ${sessionId}`);
     }
+    return this.defaultSession;
   }
-  mapExecuteResponseToExecResult(response, duration, sessionId) {
-    return {
-      success: response.success,
-      exitCode: response.exitCode,
-      stdout: response.stdout,
-      stderr: response.stderr,
-      command: response.command,
-      duration,
-      timestamp: response.timestamp,
-      sessionId
-    };
+  async exec(command, options) {
+    const session = await this.ensureDefaultSession();
+    return session.exec(command, options);
   }
-  // Background process management
   async startProcess(command, options) {
-    try {
-      const response = await this.client.startProcess(command, {
-        processId: options?.processId,
-        sessionId: options?.sessionId,
-        timeout: options?.timeout,
-        env: options?.env,
-        cwd: options?.cwd,
-        encoding: options?.encoding,
-        autoCleanup: options?.autoCleanup
-      });
-      const process = response.process;
-      const processObj = {
-        id: process.id,
-        pid: process.pid,
-        command: process.command,
-        status: process.status,
-        startTime: new Date(process.startTime),
-        endTime: void 0,
-        exitCode: void 0,
-        sessionId: process.sessionId,
-        async kill() {
-          throw new Error("Method will be replaced");
-        },
-        async getStatus() {
-          throw new Error("Method will be replaced");
-        },
-        async getLogs() {
-          throw new Error("Method will be replaced");
-        }
-      };
-      processObj.kill = async (signal) => {
-        await this.killProcess(process.id, signal);
-      };
-      processObj.getStatus = async () => {
-        const current = await this.getProcess(process.id);
-        return current?.status || "error";
-      };
-      processObj.getLogs = async () => {
-        const logs = await this.getProcessLogs(process.id);
-        return { stdout: logs.stdout, stderr: logs.stderr };
-      };
-      if (options?.onStart) {
-        options.onStart(processObj);
-      }
-      return processObj;
-    } catch (error) {
-      if (options?.onError && error instanceof Error) {
-        options.onError(error);
-      }
-      throw error;
-    }
+    const session = await this.ensureDefaultSession();
+    return session.startProcess(command, options);
   }
   async listProcesses() {
-    const response = await this.client.listProcesses();
-    return response.processes.map((processData) => ({
-      id: processData.id,
-      pid: processData.pid,
-      command: processData.command,
-      status: processData.status,
-      startTime: new Date(processData.startTime),
-      endTime: processData.endTime ? new Date(processData.endTime) : void 0,
-      exitCode: processData.exitCode,
-      sessionId: processData.sessionId,
-      kill: async (signal) => {
-        await this.killProcess(processData.id, signal);
-      },
-      getStatus: async () => {
-        const current = await this.getProcess(processData.id);
-        return current?.status || "error";
-      },
-      getLogs: async () => {
-        const logs = await this.getProcessLogs(processData.id);
-        return { stdout: logs.stdout, stderr: logs.stderr };
-      }
-    }));
+    const session = await this.ensureDefaultSession();
+    return session.listProcesses();
   }
   async getProcess(id) {
-    const response = await this.client.getProcess(id);
-    if (!response.process) {
-      return null;
-    }
-    const processData = response.process;
-    return {
-      id: processData.id,
-      pid: processData.pid,
-      command: processData.command,
-      status: processData.status,
-      startTime: new Date(processData.startTime),
-      endTime: processData.endTime ? new Date(processData.endTime) : void 0,
-      exitCode: processData.exitCode,
-      sessionId: processData.sessionId,
-      kill: async (signal) => {
-        await this.killProcess(processData.id, signal);
-      },
-      getStatus: async () => {
-        const current = await this.getProcess(processData.id);
-        return current?.status || "error";
-      },
-      getLogs: async () => {
-        const logs = await this.getProcessLogs(processData.id);
-        return { stdout: logs.stdout, stderr: logs.stderr };
-      }
-    };
+    const session = await this.ensureDefaultSession();
+    return session.getProcess(id);
   }
-  async killProcess(id, _signal) {
-    try {
-      await this.client.killProcess(id);
-    } catch (error) {
-      if (error instanceof Error && error.message.includes("Process not found")) {
-        throw new ProcessNotFoundError(id);
-      }
-      throw new SandboxError(
-        `Failed to kill process ${id}: ${error instanceof Error ? error.message : "Unknown error"}`,
-        "KILL_PROCESS_FAILED"
-      );
-    }
+  async killProcess(id, signal) {
+    const session = await this.ensureDefaultSession();
+    return session.killProcess(id, signal);
   }
   async killAllProcesses() {
-    const response = await this.client.killAllProcesses();
-    return response.killedCount;
+    const session = await this.ensureDefaultSession();
+    return session.killAllProcesses();
   }
   async cleanupCompletedProcesses() {
-    return 0;
+    const session = await this.ensureDefaultSession();
+    return session.cleanupCompletedProcesses();
   }
   async getProcessLogs(id) {
-    try {
-      const response = await this.client.getProcessLogs(id);
-      return {
-        stdout: response.stdout,
-        stderr: response.stderr
-      };
-    } catch (error) {
-      if (error instanceof Error && error.message.includes("Process not found")) {
-        throw new ProcessNotFoundError(id);
-      }
-      throw error;
-    }
+    const session = await this.ensureDefaultSession();
+    return session.getProcessLogs(id);
   }
-  // Streaming methods - return ReadableStream for RPC compatibility
+  // Streaming methods - delegates to default session
   async execStream(command, options) {
-    if (options?.signal?.aborted) {
-      throw new Error("Operation was aborted");
-    }
-    const stream = await this.client.executeCommandStream(
-      command,
-      options?.sessionId
-    );
-    return stream;
+    const session = await this.ensureDefaultSession();
+    return session.execStream(command, options);
   }
   async streamProcessLogs(processId, options) {
-    if (options?.signal?.aborted) {
-      throw new Error("Operation was aborted");
-    }
-    const stream = await this.client.streamProcessLogs(processId);
-    return stream;
+    const session = await this.ensureDefaultSession();
+    return session.streamProcessLogs(processId, options);
   }
   async gitCheckout(repoUrl, options) {
-    return this.client.gitCheckout(repoUrl, options.branch, options.targetDir);
+    const session = await this.ensureDefaultSession();
+    return session.gitCheckout(repoUrl, options);
   }
   async mkdir(path, options = {}) {
-    return this.client.mkdir(path, options.recursive);
+    const session = await this.ensureDefaultSession();
+    return session.mkdir(path, options);
   }
   async writeFile(path, content, options = {}) {
-    return this.client.writeFile(path, content, options.encoding);
+    const session = await this.ensureDefaultSession();
+    return session.writeFile(path, content, options);
   }
   async deleteFile(path) {
-    return this.client.deleteFile(path);
+    const session = await this.ensureDefaultSession();
+    return session.deleteFile(path);
   }
   async renameFile(oldPath, newPath) {
-    return this.client.renameFile(oldPath, newPath);
+    const session = await this.ensureDefaultSession();
+    return session.renameFile(oldPath, newPath);
   }
   async moveFile(sourcePath, destinationPath) {
-    return this.client.moveFile(sourcePath, destinationPath);
+    const session = await this.ensureDefaultSession();
+    return session.moveFile(sourcePath, destinationPath);
   }
   async readFile(path, options = {}) {
-    return this.client.readFile(path, options.encoding);
+    const session = await this.ensureDefaultSession();
+    return session.readFile(path, options);
   }
   async listFiles(path, options = {}) {
-    return this.client.listFiles(path, options);
+    const session = await this.ensureDefaultSession();
+    return session.listFiles(path, options);
   }
   async exposePort(port, options) {
     await this.client.exposePort(port, options?.name);
@@ -680,6 +476,186 @@ var Sandbox = class extends Container {
   async deleteCodeContext(contextId) {
     return this.codeInterpreter.deleteCodeContext(contextId);
   }
+  // ============================================================================
+  // Session Management (Simple Isolation)
+  // ============================================================================
+  /**
+   * Create a new execution session with isolation
+   * Returns a session object with exec() method
+   */
+  async createSession(options) {
+    const sessionId = options.id || `session-${Date.now()}`;
+    await this.client.createSession({
+      id: sessionId,
+      env: options.env,
+      cwd: options.cwd,
+      isolation: options.isolation
+    });
+    return {
+      id: sessionId,
+      // Command execution - clean method names
+      exec: async (command, options2) => {
+        const result = await this.client.exec(sessionId, command);
+        return {
+          ...result,
+          command,
+          duration: 0,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString()
+        };
+      },
+      execStream: async (command, options2) => {
+        return await this.client.execStream(sessionId, command);
+      },
+      // Process management - route to session-aware methods
+      startProcess: async (command, options2) => {
+        const response = await this.client.startProcess(command, sessionId, {
+          processId: options2?.processId,
+          timeout: options2?.timeout,
+          env: options2?.env,
+          cwd: options2?.cwd,
+          encoding: options2?.encoding,
+          autoCleanup: options2?.autoCleanup
+        });
+        const process = response.process;
+        return {
+          id: process.id,
+          pid: process.pid,
+          command: process.command,
+          status: process.status,
+          startTime: new Date(process.startTime),
+          endTime: process.endTime ? new Date(process.endTime) : void 0,
+          exitCode: process.exitCode ?? void 0,
+          kill: async (signal) => {
+            await this.client.killProcess(process.id);
+          },
+          getStatus: async () => {
+            const resp = await this.client.getProcess(process.id);
+            return resp.process?.status || "error";
+          },
+          getLogs: async () => {
+            return await this.client.getProcessLogs(process.id);
+          }
+        };
+      },
+      listProcesses: async () => {
+        const response = await this.client.listProcesses(sessionId);
+        return response.processes.map((p) => ({
+          id: p.id,
+          pid: p.pid,
+          command: p.command,
+          status: p.status,
+          startTime: new Date(p.startTime),
+          endTime: p.endTime ? new Date(p.endTime) : void 0,
+          exitCode: p.exitCode ?? void 0,
+          kill: async (signal) => {
+            await this.client.killProcess(p.id);
+          },
+          getStatus: async () => {
+            const processResp = await this.client.getProcess(p.id);
+            return processResp.process?.status || "error";
+          },
+          getLogs: async () => {
+            return this.client.getProcessLogs(p.id);
+          }
+        }));
+      },
+      getProcess: async (id) => {
+        const response = await this.client.getProcess(id);
+        if (!response.process) return null;
+        const p = response.process;
+        return {
+          id: p.id,
+          pid: p.pid,
+          command: p.command,
+          status: p.status,
+          startTime: new Date(p.startTime),
+          endTime: p.endTime ? new Date(p.endTime) : void 0,
+          exitCode: p.exitCode ?? void 0,
+          kill: async (signal) => {
+            await this.client.killProcess(p.id);
+          },
+          getStatus: async () => {
+            const processResp = await this.client.getProcess(p.id);
+            return processResp.process?.status || "error";
+          },
+          getLogs: async () => {
+            return this.client.getProcessLogs(p.id);
+          }
+        };
+      },
+      killProcess: async (id, signal) => {
+        await this.client.killProcess(id);
+      },
+      killAllProcesses: async () => {
+        const response = await this.client.killAllProcesses(sessionId);
+        return response.killedCount;
+      },
+      streamProcessLogs: async (processId, options2) => {
+        return await this.client.streamProcessLogs(processId, options2);
+      },
+      getProcessLogs: async (id) => {
+        return await this.client.getProcessLogs(id);
+      },
+      cleanupCompletedProcesses: async () => {
+        return 0;
+      },
+      // File operations - clean method names (no "InSession" suffix)
+      writeFile: async (path, content, options2) => {
+        return await this.client.writeFile(path, content, options2?.encoding, sessionId);
+      },
+      readFile: async (path, options2) => {
+        return await this.client.readFile(path, options2?.encoding, sessionId);
+      },
+      mkdir: async (path, options2) => {
+        return await this.client.mkdir(path, options2?.recursive, sessionId);
+      },
+      deleteFile: async (path) => {
+        return await this.client.deleteFile(path, sessionId);
+      },
+      renameFile: async (oldPath, newPath) => {
+        return await this.client.renameFile(oldPath, newPath, sessionId);
+      },
+      moveFile: async (sourcePath, destinationPath) => {
+        return await this.client.moveFile(sourcePath, destinationPath, sessionId);
+      },
+      listFiles: async (path, options2) => {
+        return await this.client.listFiles(path, sessionId, options2);
+      },
+      gitCheckout: async (repoUrl, options2) => {
+        return await this.client.gitCheckout(repoUrl, sessionId, options2?.branch, options2?.targetDir);
+      },
+      // Port management
+      exposePort: async (port, options2) => {
+        return await this.exposePort(port, options2);
+      },
+      unexposePort: async (port) => {
+        return await this.unexposePort(port);
+      },
+      getExposedPorts: async (hostname) => {
+        return await this.getExposedPorts(hostname);
+      },
+      // Environment management
+      setEnvVars: async (envVars) => {
+        console.log(`[Session ${sessionId}] Environment variables update not yet implemented`);
+      },
+      // Code Interpreter API
+      createCodeContext: async (options2) => {
+        return await this.createCodeContext(options2);
+      },
+      runCode: async (code, options2) => {
+        return await this.runCode(code, options2);
+      },
+      runCodeStream: async (code, options2) => {
+        return await this.runCodeStream(code, options2);
+      },
+      listCodeContexts: async () => {
+        return await this.listCodeContexts();
+      },
+      deleteCodeContext: async (contextId) => {
+        return await this.deleteCodeContext(contextId);
+      }
+    };
+  }
 };
 
 export {
@@ -688,4 +664,4 @@ export {
   proxyToSandbox,
   isLocalhostPattern
 };
-//# sourceMappingURL=chunk-CKIGERRS.js.map
+//# sourceMappingURL=chunk-LFLJGISB.js.map