@cloudflare/sandbox 0.0.0-ab0979d → 0.0.0-af082ab

package/src/client.ts

@@ -1,41 +1,23 @@
+import type { ExecuteRequest } from "../container_src/types";
 import type { Sandbox } from "./index";
 import type {
+  BaseExecOptions,
+  DeleteFileResponse,
+  ExecuteResponse,
   GetProcessLogsResponse,
   GetProcessResponse,
+  GitCheckoutResponse,
+  ListFilesResponse,
   ListProcessesResponse,
+  MkdirResponse,
+  MoveFileResponse,
+  ReadFileResponse,
+  RenameFileResponse,
   StartProcessRequest,
-  StartProcessResponse
+  StartProcessResponse,
+  WriteFileResponse,
 } from "./types";
 
-interface ExecuteRequest {
-  command: string;
-  sessionId?: string;
-}
-
-export interface ExecuteResponse {
-  success: boolean;
-  stdout: string;
-  stderr: string;
-  exitCode: number;
-  command: string;
-  timestamp: string;
-}
-
-interface SessionResponse {
-  sessionId: string;
-  message: string;
-  timestamp: string;
-}
-
-interface SessionListResponse {
-  sessions: Array<{
-    sessionId: string;
-    hasActiveProcess: boolean;
-    createdAt: string;
-  }>;
-  count: number;
-  timestamp: string;
-}
 
 interface CommandsResponse {
   availableCommands: string[];
@@ -46,104 +28,62 @@ interface GitCheckoutRequest {
   repoUrl: string;
   branch?: string;
   targetDir?: string;
-  sessionId?: string;
+  sessionId: string;
 }
 
-export interface GitCheckoutResponse {
-  success: boolean;
-  stdout: string;
-  stderr: string;
-  exitCode: number;
-  repoUrl: string;
-  branch: string;
-  targetDir: string;
-  timestamp: string;
-}
 
 interface MkdirRequest {
   path: string;
   recursive?: boolean;
-  sessionId?: string;
+  sessionId: string;
 }
 
-export interface MkdirResponse {
-  success: boolean;
-  stdout: string;
-  stderr: string;
-  exitCode: number;
-  path: string;
-  recursive: boolean;
-  timestamp: string;
-}
 
 interface WriteFileRequest {
   path: string;
   content: string;
   encoding?: string;
-  sessionId?: string;
+  sessionId: string;
 }
 
-export interface WriteFileResponse {
-  success: boolean;
-  exitCode: number;
-  path: string;
-  timestamp: string;
-}
 
 interface ReadFileRequest {
   path: string;
   encoding?: string;
-  sessionId?: string;
+  sessionId: string;
 }
 
-export interface ReadFileResponse {
-  success: boolean;
-  exitCode: number;
-  path: string;
-  content: string;
-  timestamp: string;
-}
 
 interface DeleteFileRequest {
   path: string;
-  sessionId?: string;
+  sessionId: string;
 }
 
-export interface DeleteFileResponse {
-  success: boolean;
-  exitCode: number;
-  path: string;
-  timestamp: string;
-}
 
 interface RenameFileRequest {
   oldPath: string;
   newPath: string;
-  sessionId?: string;
+  sessionId: string;
 }
 
-export interface RenameFileResponse {
-  success: boolean;
-  exitCode: number;
-  oldPath: string;
-  newPath: string;
-  timestamp: string;
-}
 
 interface MoveFileRequest {
   sourcePath: string;
   destinationPath: string;
-  sessionId?: string;
+  sessionId: string;
 }
 
-export interface MoveFileResponse {
-  success: boolean;
-  exitCode: number;
-  sourcePath: string;
-  destinationPath: string;
-  timestamp: string;
+
+interface ListFilesRequest {
+  path: string;
+  options?: {
+    recursive?: boolean;
+    includeHidden?: boolean;
+  };
+  sessionId: string;
 }
 
+
 interface PreviewInfo {
   url: string;
   port: number;
@@ -203,7 +143,6 @@ interface HttpClientOptions {
 export class HttpClient {
   private baseUrl: string;
   private options: HttpClientOptions;
-  private sessionId: string | null = null;
 
   constructor(options: HttpClientOptions = {}) {
     this.options = {
@@ -212,7 +151,7 @@ export class HttpClient {
     this.baseUrl = this.options.baseUrl!;
   }
 
-  private async doFetch(
+  protected async doFetch(
     path: string,
     options?: RequestInit
   ): Promise<Response> {
@@ -253,22 +192,52 @@ export class HttpClient {
     }
   }
 
-  async execute(
+  async createSession(options: {
+    id: string;
+    env?: Record<string, string>;
+    cwd?: string;
+    isolation?: boolean;
+  }): Promise<{ success: boolean; id: string; message: string }> {
+    try {
+      const response = await this.doFetch(`/api/session/create`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+        },
+        body: JSON.stringify(options),
+      });
+
+      if (!response.ok) {
+        const errorData = (await response.json().catch(() => ({}))) as {
+          error?: string;
+        };
+        throw new Error(
+          errorData.error || `Failed to create session: ${response.status}`
+        );
+      }
+
+      const data = await response.json() as { success: boolean; id: string; message: string };
+      console.log(`[HTTP Client] Session created: ${options.id}`);
+      return data;
+    } catch (error) {
+      console.error("[HTTP Client] Error creating session:", error);
+      throw error;
+    }
+  }
+
+  async exec(
+    sessionId: string,
     command: string,
-    sessionId?: string
+    options?: Pick<BaseExecOptions, "cwd" | "env">
   ): Promise<ExecuteResponse> {
     try {
-      const targetSessionId = sessionId || this.sessionId;
-
+      // Always use session-specific endpoint
       const response = await this.doFetch(`/api/execute`, {
-        body: JSON.stringify({
-          command,
-          sessionId: targetSessionId,
-        } as ExecuteRequest),
+        method: "POST",
         headers: {
           "Content-Type": "application/json",
         },
-        method: "POST",
+        body: JSON.stringify({ id: sessionId, command }),
       });
 
       if (!response.ok) {
@@ -276,27 +245,34 @@ export class HttpClient {
           error?: string;
         };
         throw new Error(
-          errorData.error || `HTTP error! status: ${response.status}`
+          errorData.error || `Failed to execute in session: ${response.status}`
         );
       }
 
-      const data: ExecuteResponse = await response.json();
+      const data = await response.json() as { stdout: string; stderr: string; exitCode: number; success: boolean };
       console.log(
-        `[HTTP Client] Command executed: ${command}, Success: ${data.success}`
+        `[HTTP Client] Command executed in session ${sessionId}: ${command}`
       );
+      
+      // Convert to ExecuteResponse format for consistency
+      const executeResponse: ExecuteResponse = {
+        ...data,
+        command,
+        timestamp: new Date().toISOString()
+      };
 
       // Call the callback if provided
       this.options.onCommandComplete?.(
-        data.success,
-        data.exitCode,
-        data.stdout,
-        data.stderr,
-        data.command
+        executeResponse.success,
+        executeResponse.exitCode,
+        executeResponse.stdout,
+        executeResponse.stderr,
+        executeResponse.command
       );
 
-      return data;
+      return executeResponse;
     } catch (error) {
-      console.error("[HTTP Client] Error executing command:", error);
+      console.error("[HTTP Client] Error executing in session:", error);
       this.options.onError?.(
         error instanceof Error ? error.message : "Unknown error",
         command
@@ -305,24 +281,21 @@ export class HttpClient {
     }
   }
 
-
-  async executeCommandStream(
-    command: string,
-    sessionId?: string
+  async execStream(
+    sessionId: string,
+    command: string
   ): Promise<ReadableStream<Uint8Array>> {
     try {
-      const targetSessionId = sessionId || this.sessionId;
-
+      // Always use session-specific streaming endpoint
       const response = await this.doFetch(`/api/execute/stream`, {
-        body: JSON.stringify({
-          command,
-          sessionId: targetSessionId,
-        }),
+        method: "POST",
         headers: {
           "Content-Type": "application/json",
-          "Accept": "text/event-stream",
         },
-        method: "POST",
+        body: JSON.stringify({ 
+          id: sessionId,
+          command
+        }),
       });
 
       if (!response.ok) {
@@ -330,40 +303,37 @@ export class HttpClient {
           error?: string;
         };
         throw new Error(
-          errorData.error || `HTTP error! status: ${response.status}`
+          errorData.error || `Failed to stream execute in session: ${response.status}`
         );
       }
 
       if (!response.body) {
-        throw new Error("No response body for streaming request");
+        throw new Error("No response body for streaming execution");
       }
 
       console.log(
-        `[HTTP Client] Started command stream: ${command}`
+        `[HTTP Client] Started streaming command in session ${sessionId}: ${command}`
       );
-
       return response.body;
     } catch (error) {
-      console.error("[HTTP Client] Error in command stream:", error);
+      console.error("[HTTP Client] Error streaming execute in session:", error);
       throw error;
     }
   }
 
   async gitCheckout(
     repoUrl: string,
+    sessionId: string,
     branch: string = "main",
-    targetDir?: string,
-    sessionId?: string
+    targetDir?: string
   ): Promise<GitCheckoutResponse> {
     try {
-      const targetSessionId = sessionId || this.sessionId;
-
       const response = await this.doFetch(`/api/git/checkout`, {
         body: JSON.stringify({
           branch,
           repoUrl,
-          sessionId: targetSessionId,
           targetDir,
+          sessionId,
         } as GitCheckoutRequest),
         headers: {
           "Content-Type": "application/json",
@@ -392,20 +362,17 @@ export class HttpClient {
     }
   }
 
-
   async mkdir(
     path: string,
     recursive: boolean = false,
-    sessionId?: string
+    sessionId: string
   ): Promise<MkdirResponse> {
     try {
-      const targetSessionId = sessionId || this.sessionId;
-
       const response = await this.doFetch(`/api/mkdir`, {
         body: JSON.stringify({
           path,
           recursive,
-          sessionId: targetSessionId,
+          sessionId,
         } as MkdirRequest),
         headers: {
           "Content-Type": "application/json",
@@ -424,7 +391,7 @@ export class HttpClient {
 
       const data: MkdirResponse = await response.json();
       console.log(
-        `[HTTP Client] Directory created: ${path}, Success: ${data.success}, Recursive: ${data.recursive}`
+        `[HTTP Client] Directory created: ${path}, Success: ${data.success}, Recursive: ${data.recursive}${sessionId ? ` in session: ${sessionId}` : ''}`
       );
 
       return data;
@@ -434,22 +401,19 @@ export class HttpClient {
     }
   }
 
-
   async writeFile(
     path: string,
     content: string,
     encoding: string = "utf-8",
-    sessionId?: string
+    sessionId: string
   ): Promise<WriteFileResponse> {
     try {
-      const targetSessionId = sessionId || this.sessionId;
-
       const response = await this.doFetch(`/api/write`, {
         body: JSON.stringify({
           content,
           encoding,
           path,
-          sessionId: targetSessionId,
+          sessionId,
         } as WriteFileRequest),
         headers: {
           "Content-Type": "application/json",
@@ -468,7 +432,7 @@ export class HttpClient {
 
       const data: WriteFileResponse = await response.json();
       console.log(
-        `[HTTP Client] File written: ${path}, Success: ${data.success}`
+        `[HTTP Client] File written: ${path}, Success: ${data.success}${sessionId ? ` in session: ${sessionId}` : ''}`
       );
 
       return data;
@@ -478,20 +442,17 @@ export class HttpClient {
     }
   }
 
-
   async readFile(
     path: string,
     encoding: string = "utf-8",
-    sessionId?: string
+    sessionId: string
   ): Promise<ReadFileResponse> {
     try {
-      const targetSessionId = sessionId || this.sessionId;
-
       const response = await this.doFetch(`/api/read`, {
         body: JSON.stringify({
           encoding,
           path,
-          sessionId: targetSessionId,
+          sessionId,
         } as ReadFileRequest),
         headers: {
           "Content-Type": "application/json",
@@ -510,7 +471,7 @@ export class HttpClient {
 
       const data: ReadFileResponse = await response.json();
       console.log(
-        `[HTTP Client] File read: ${path}, Success: ${data.success}, Content length: ${data.content.length}`
+        `[HTTP Client] File read: ${path}, Success: ${data.success}, Content length: ${data.content.length}${sessionId ? ` in session: ${sessionId}` : ''}`
       );
 
       return data;
@@ -520,18 +481,54 @@ export class HttpClient {
     }
   }
 
+  async readFileStream(
+    path: string,
+    sessionId: string
+  ): Promise<ReadableStream<Uint8Array>> {
+    try {
+      const response = await this.doFetch(`/api/read/stream`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+        },
+        body: JSON.stringify({
+          path,
+          sessionId,
+        } as ReadFileRequest),
+      });
+
+      if (!response.ok) {
+        const errorData = (await response.json().catch(() => ({}))) as {
+          error?: string;
+        };
+        throw new Error(
+          errorData.error || `HTTP error! status: ${response.status}`
+        );
+      }
+
+      if (!response.body) {
+        throw new Error("No response body for file streaming");
+      }
+
+      console.log(
+        `[HTTP Client] Started streaming file: ${path}${sessionId ? ` in session: ${sessionId}` : ''}`
+      );
+      return response.body;
+    } catch (error) {
+      console.error("[HTTP Client] Error streaming file:", error);
+      throw error;
+    }
+  }
 
   async deleteFile(
     path: string,
-    sessionId?: string
+    sessionId: string
   ): Promise<DeleteFileResponse> {
     try {
-      const targetSessionId = sessionId || this.sessionId;
-
       const response = await this.doFetch(`/api/delete`, {
         body: JSON.stringify({
           path,
-          sessionId: targetSessionId,
+          sessionId,
         } as DeleteFileRequest),
         headers: {
           "Content-Type": "application/json",
@@ -550,7 +547,7 @@ export class HttpClient {
 
       const data: DeleteFileResponse = await response.json();
       console.log(
-        `[HTTP Client] File deleted: ${path}, Success: ${data.success}`
+        `[HTTP Client] File deleted: ${path}, Success: ${data.success}${sessionId ? ` in session: ${sessionId}` : ''}`
       );
 
       return data;
@@ -560,20 +557,17 @@ export class HttpClient {
     }
   }
 
-
   async renameFile(
     oldPath: string,
     newPath: string,
-    sessionId?: string
+    sessionId: string
   ): Promise<RenameFileResponse> {
     try {
-      const targetSessionId = sessionId || this.sessionId;
-
       const response = await this.doFetch(`/api/rename`, {
         body: JSON.stringify({
           newPath,
           oldPath,
-          sessionId: targetSessionId,
+          sessionId,
         } as RenameFileRequest),
         headers: {
           "Content-Type": "application/json",
@@ -592,7 +586,7 @@ export class HttpClient {
 
       const data: RenameFileResponse = await response.json();
       console.log(
-        `[HTTP Client] File renamed: ${oldPath} -> ${newPath}, Success: ${data.success}`
+        `[HTTP Client] File renamed: ${oldPath} -> ${newPath}, Success: ${data.success}${sessionId ? ` in session: ${sessionId}` : ''}`
       );
 
       return data;
@@ -602,20 +596,17 @@ export class HttpClient {
     }
   }
 
-
   async moveFile(
     sourcePath: string,
     destinationPath: string,
-    sessionId?: string
+    sessionId: string
   ): Promise<MoveFileResponse> {
     try {
-      const targetSessionId = sessionId || this.sessionId;
-
       const response = await this.doFetch(`/api/move`, {
         body: JSON.stringify({
           destinationPath,
-          sessionId: targetSessionId,
           sourcePath,
+          sessionId,
         } as MoveFileRequest),
         headers: {
           "Content-Type": "application/json",
@@ -634,7 +625,7 @@ export class HttpClient {
 
       const data: MoveFileResponse = await response.json();
       console.log(
-        `[HTTP Client] File moved: ${sourcePath} -> ${destinationPath}, Success: ${data.success}`
+        `[HTTP Client] File moved: ${sourcePath} -> ${destinationPath}, Success: ${data.success}${sessionId ? ` in session: ${sessionId}` : ''}`
       );
 
       return data;
@@ -644,6 +635,47 @@ export class HttpClient {
     }
   }
 
+  async listFiles(
+    path: string,
+    sessionId: string,
+    options?: {
+      recursive?: boolean;
+      includeHidden?: boolean;
+    }
+  ): Promise<ListFilesResponse> {
+    try {
+      const response = await this.doFetch(`/api/list-files`, {
+        body: JSON.stringify({
+          path,
+          options,
+          sessionId,
+        } as ListFilesRequest),
+        headers: {
+          "Content-Type": "application/json",
+        },
+        method: "POST",
+      });
+
+      if (!response.ok) {
+        const errorData = (await response.json().catch(() => ({}))) as {
+          error?: string;
+        };
+        throw new Error(
+          errorData.error || `HTTP error! status: ${response.status}`
+        );
+      }
+
+      const data: ListFilesResponse = await response.json();
+      console.log(
+        `[HTTP Client] Listed ${data.files.length} files in: ${path}, Success: ${data.success}${sessionId ? ` in session: ${sessionId}` : ''}`
+      );
+
+      return data;
+    } catch (error) {
+      console.error("[HTTP Client] Error listing files:", error);
+      throw error;
+    }
+  }
 
   async exposePort(port: number, name?: string): Promise<ExposePortResponse> {
     try {
@@ -670,7 +702,9 @@ export class HttpClient {
 
       const data: ExposePortResponse = await response.json();
       console.log(
-        `[HTTP Client] Port exposed: ${port}${name ? ` (${name})` : ""}, Success: ${data.success}`
+        `[HTTP Client] Port exposed: ${port}${
+          name ? ` (${name})` : ""
+        }, Success: ${data.success}`
       );
 
       return data;
@@ -732,9 +766,7 @@ export class HttpClient {
       }
 
       const data: GetExposedPortsResponse = await response.json();
-      console.log(
-        `[HTTP Client] Got ${data.count} exposed ports`
-      );
+      console.log(`[HTTP Client] Got ${data.count} exposed ports`);
 
       return data;
     } catch (error) {
@@ -765,48 +797,13 @@ export class HttpClient {
     }
   }
 
-  async getCommands(): Promise<string[]> {
-    try {
-      const response = await fetch(`${this.baseUrl}/api/commands`, {
-        headers: {
-          "Content-Type": "application/json",
-        },
-        method: "GET",
-      });
-
-      if (!response.ok) {
-        throw new Error(`HTTP error! status: ${response.status}`);
-      }
-
-      const data: CommandsResponse = await response.json();
-      console.log(
-        `[HTTP Client] Available commands: ${data.availableCommands.length}`
-      );
-      return data.availableCommands;
-    } catch (error) {
-      console.error("[HTTP Client] Error getting commands:", error);
-      throw error;
-    }
-  }
-
-  getSessionId(): string | null {
-    return this.sessionId;
-  }
-
-  setSessionId(sessionId: string): void {
-    this.sessionId = sessionId;
-  }
-
-  clearSession(): void {
-    this.sessionId = null;
-  }
 
   // Process management methods
   async startProcess(
     command: string,
+    sessionId: string,
     options?: {
       processId?: string;
-      sessionId?: string;
       timeout?: number;
       env?: Record<string, string>;
       cwd?: string;
@@ -815,15 +812,11 @@ export class HttpClient {
     }
   ): Promise<StartProcessResponse> {
     try {
-      const targetSessionId = options?.sessionId || this.sessionId;
-
       const response = await this.doFetch("/api/process/start", {
         body: JSON.stringify({
           command,
-          options: {
-            ...options,
-            sessionId: targetSessionId,
-          },
+          sessionId,
+          options,
         } as StartProcessRequest),
         headers: {
           "Content-Type": "application/json",
@@ -852,9 +845,12 @@ export class HttpClient {
     }
   }
 
-  async listProcesses(): Promise<ListProcessesResponse> {
+  async listProcesses(sessionId?: string): Promise<ListProcessesResponse> {
     try {
-      const response = await this.doFetch("/api/process/list", {
+      const url = sessionId 
+        ? `/api/process/list?session=${encodeURIComponent(sessionId)}`
+        : "/api/process/list";
+      const response = await this.doFetch(url, {
         headers: {
           "Content-Type": "application/json",
         },
@@ -871,9 +867,7 @@ export class HttpClient {
       }
 
       const data: ListProcessesResponse = await response.json();
-      console.log(
-        `[HTTP Client] Listed ${data.processes.length} processes`
-      );
+      console.log(`[HTTP Client] Listed ${data.processes.length} processes`);
 
       return data;
     } catch (error) {
@@ -902,7 +896,9 @@ export class HttpClient {
 
       const data: GetProcessResponse = await response.json();
       console.log(
-        `[HTTP Client] Got process ${processId}: ${data.process?.status || 'not found'}`
+        `[HTTP Client] Got process ${processId}: ${
+          data.process?.status || "not found"
+        }`
       );
 
       return data;
@@ -912,7 +908,9 @@ export class HttpClient {
     }
   }
 
-  async killProcess(processId: string): Promise<{ success: boolean; message: string }> {
+  async killProcess(
+    processId: string
+  ): Promise<{ success: boolean; message: string }> {
     try {
       const response = await this.doFetch(`/api/process/${processId}`, {
         headers: {
@@ -930,10 +928,11 @@ export class HttpClient {
         );
       }
 
-      const data = await response.json() as { success: boolean; message: string };
-      console.log(
-        `[HTTP Client] Killed process ${processId}`
-      );
+      const data = (await response.json()) as {
+        success: boolean;
+        message: string;
+      };
+      console.log(`[HTTP Client] Killed process ${processId}`);
 
       return data;
     } catch (error) {
@@ -942,9 +941,16 @@ export class HttpClient {
     }
   }
 
-  async killAllProcesses(): Promise<{ success: boolean; killedCount: number; message: string }> {
+  async killAllProcesses(sessionId?: string): Promise<{
+    success: boolean;
+    killedCount: number;
+    message: string;
+  }> {
     try {
-      const response = await this.doFetch("/api/process/kill-all", {
+      const url = sessionId 
+        ? `/api/process/kill-all?session=${encodeURIComponent(sessionId)}`
+        : "/api/process/kill-all";
+      const response = await this.doFetch(url, {
         headers: {
           "Content-Type": "application/json",
         },
@@ -960,10 +966,12 @@ export class HttpClient {
         );
       }
 
-      const data = await response.json() as { success: boolean; killedCount: number; message: string };
-      console.log(
-        `[HTTP Client] Killed ${data.killedCount} processes`
-      );
+      const data = (await response.json()) as {
+        success: boolean;
+        killedCount: number;
+        message: string;
+      };
+      console.log(`[HTTP Client] Killed ${data.killedCount} processes`);
 
       return data;
     } catch (error) {
@@ -991,9 +999,7 @@ export class HttpClient {
       }
 
       const data: GetProcessLogsResponse = await response.json();
-      console.log(
-        `[HTTP Client] Got logs for process ${processId}`
-      );
+      console.log(`[HTTP Client] Got logs for process ${processId}`);
 
       return data;
     } catch (error) {
@@ -1002,14 +1008,18 @@ export class HttpClient {
     }
   }
 
-  async streamProcessLogs(processId: string): Promise<ReadableStream<Uint8Array>> {
+  async streamProcessLogs(
+    processId: string,
+    options?: { signal?: AbortSignal }
+  ): Promise<ReadableStream<Uint8Array>> {
     try {
       const response = await this.doFetch(`/api/process/${processId}/stream`, {
         headers: {
-          "Accept": "text/event-stream",
+          Accept: "text/event-stream",
           "Cache-Control": "no-cache",
         },
         method: "GET",
+        signal: options?.signal,
       });
 
       if (!response.ok) {