@cloudflare/sandbox 0.0.0-db09b4d → 0.0.0-e1fa354

package/src/client.ts

@@ -1,36 +1,23 @@
-import type { DurableObject } from "cloudflare:workers";
+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,
+  WriteFileResponse,
+} from "./types";
 
-interface ExecuteRequest {
-  command: string;
-  args?: string[];
-}
-
-export interface ExecuteResponse {
-  success: boolean;
-  stdout: string;
-  stderr: string;
-  exitCode: number;
-  command: string;
-  args: 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[];
@@ -41,120 +28,103 @@ 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;
+
+interface ReadFileRequest {
   path: string;
-  timestamp: string;
+  encoding?: string;
+  sessionId: 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;
+}
+
+
+interface ListFilesRequest {
+  path: string;
+  options?: {
+    recursive?: boolean;
+    includeHidden?: boolean;
+  };
+  sessionId: string;
+}
+
+
+interface PreviewInfo {
+  url: string;
+  port: number;
+  name?: string;
 }
 
-export interface MoveFileResponse {
+interface ExposedPort extends PreviewInfo {
+  exposedAt: string;
+  timestamp: string;
+}
+
+interface ExposePortResponse {
   success: boolean;
-  exitCode: number;
-  sourcePath: string;
-  destinationPath: string;
+  port: number;
+  name?: string;
+  exposedAt: string;
   timestamp: string;
 }
 
-interface PingResponse {
-  message: string;
+interface UnexposePortResponse {
+  success: boolean;
+  port: number;
   timestamp: string;
 }
 
-interface StreamEvent {
-  type: "command_start" | "output" | "command_complete" | "error";
-  command?: string;
-  args?: string[];
-  stream?: "stdout" | "stderr";
-  data?: string;
-  message?: string;
-  path?: string;
-  oldPath?: string;
-  newPath?: string;
-  sourcePath?: string;
-  destinationPath?: string;
-  success?: boolean;
-  exitCode?: number;
-  stdout?: string;
-  stderr?: string;
-  error?: string;
-  timestamp?: string;
+interface GetExposedPortsResponse {
+  ports: ExposedPort[];
+  count: number;
+  timestamp: string;
+}
+
+interface PingResponse {
+  message: string;
+  timestamp: string;
 }
 
 interface HttpClientOptions {
   stub?: Sandbox;
   baseUrl?: string;
   port?: number;
-  onCommandStart?: (command: string, args: string[]) => void;
+  onCommandStart?: (command: string) => void;
   onOutput?: (
     stream: "stdout" | "stderr",
     data: string,
@@ -165,17 +135,14 @@ interface HttpClientOptions {
     exitCode: number,
     stdout: string,
     stderr: string,
-    command: string,
-    args: string[]
+    command: string
   ) => void;
-  onError?: (error: string, command?: string, args?: string[]) => void;
-  onStreamEvent?: (event: StreamEvent) => void;
+  onError?: (error: string, command?: string) => void;
 }
 
 export class HttpClient {
   private baseUrl: string;
   private options: HttpClientOptions;
-  private sessionId: string | null = null;
 
   constructor(options: HttpClientOptions = {}) {
     this.options = {
@@ -184,130 +151,93 @@ export class HttpClient {
     this.baseUrl = this.options.baseUrl!;
   }
 
-  private async doFetch(
+  protected async doFetch(
     path: string,
     options?: RequestInit
   ): Promise<Response> {
-    if (this.options.stub) {
-      return this.options.stub.containerFetch(path, options, this.options.port);
-    }
-    return fetch(this.baseUrl + path, options);
-  }
-  // Public methods to set event handlers
-  setOnOutput(
-    handler: (
-      stream: "stdout" | "stderr",
-      data: string,
-      command: string
-    ) => void
-  ): void {
-    this.options.onOutput = handler;
-  }
-
-  setOnCommandComplete(
-    handler: (
-      success: boolean,
-      exitCode: number,
-      stdout: string,
-      stderr: string,
-      command: string,
-      args: string[]
-    ) => void
-  ): void {
-    this.options.onCommandComplete = handler;
-  }
-
-  setOnStreamEvent(handler: (event: StreamEvent) => void): void {
-    this.options.onStreamEvent = handler;
-  }
+    const url = this.options.stub
+      ? `http://localhost:${this.options.port}${path}`
+      : `${this.baseUrl}${path}`;
+    const method = options?.method || "GET";
 
-  // Public getter methods
-  getOnOutput():
-    | ((stream: "stdout" | "stderr", data: string, command: string) => void)
-    | undefined {
-    return this.options.onOutput;
-  }
+    console.log(`[HTTP Client] Making ${method} request to ${url}`);
 
-  getOnCommandComplete():
-    | ((
-        success: boolean,
-        exitCode: number,
-        stdout: string,
-        stderr: string,
-        command: string,
-        args: string[]
-      ) => void)
-    | undefined {
-    return this.options.onCommandComplete;
-  }
+    try {
+      let response: Response;
 
-  getOnStreamEvent(): ((event: StreamEvent) => void) | undefined {
-    return this.options.onStreamEvent;
-  }
+      if (this.options.stub) {
+        response = await this.options.stub.containerFetch(
+          url,
+          options,
+          this.options.port
+        );
+      } else {
+        response = await fetch(url, options);
+      }
 
-  async createSession(): Promise<string> {
-    try {
-      const response = await this.doFetch(`/api/session/create`, {
-        headers: {
-          "Content-Type": "application/json",
-        },
-        method: "POST",
-      });
+      console.log(
+        `[HTTP Client] Response: ${response.status} ${response.statusText}`
+      );
 
       if (!response.ok) {
-        throw new Error(`HTTP error! status: ${response.status}`);
+        console.error(
+          `[HTTP Client] Request failed: ${method} ${url} - ${response.status} ${response.statusText}`
+        );
       }
 
-      const data: SessionResponse = await response.json();
-      this.sessionId = data.sessionId;
-      console.log(`[HTTP Client] Created session: ${this.sessionId}`);
-      return this.sessionId;
+      return response;
     } catch (error) {
-      console.error("[HTTP Client] Error creating session:", error);
+      console.error(`[HTTP Client] Request error: ${method} ${url}`, error);
       throw error;
     }
   }
 
-  async listSessions(): Promise<SessionListResponse> {
+  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/list`, {
+      const response = await this.doFetch(`/api/session/create`, {
+        method: "POST",
         headers: {
           "Content-Type": "application/json",
         },
-        method: "GET",
+        body: JSON.stringify(options),
       });
 
       if (!response.ok) {
-        throw new Error(`HTTP error! status: ${response.status}`);
+        const errorData = (await response.json().catch(() => ({}))) as {
+          error?: string;
+        };
+        throw new Error(
+          errorData.error || `Failed to create session: ${response.status}`
+        );
       }
 
-      const data: SessionListResponse = await response.json();
-      console.log(`[HTTP Client] Listed ${data.count} sessions`);
+      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 listing sessions:", error);
+      console.error("[HTTP Client] Error creating session:", error);
       throw error;
     }
   }
 
-  async execute(
+  async exec(
+    sessionId: string,
     command: string,
-    args: 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({
-          args,
-          command,
-          sessionId: targetSessionId,
-        }),
+        method: "POST",
         headers: {
           "Content-Type": "application/json",
         },
-        method: "POST",
+        body: JSON.stringify({ id: sessionId, command }),
       });
 
       if (!response.ok) {
@@ -315,55 +245,57 @@ 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,
-        data.args
+        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,
-        args
+        command
       );
       throw error;
     }
   }
 
-  async executeStream(
-    command: string,
-    args: string[] = [],
-    sessionId?: string
-  ): Promise<void> {
+  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({
-          args,
-          command,
-          sessionId: targetSessionId,
-        }),
+        method: "POST",
         headers: {
           "Content-Type": "application/json",
         },
-        method: "POST",
+        body: JSON.stringify({ 
+          id: sessionId,
+          command
+        }),
       });
 
       if (!response.ok) {
@@ -371,123 +303,38 @@ 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");
       }
 
-      const reader = response.body.getReader();
-      const decoder = new TextDecoder();
-
-      try {
-        while (true) {
-          const { done, value } = await reader.read();
-
-          if (done) {
-            break;
-          }
-
-          const chunk = decoder.decode(value, { stream: true });
-          const lines = chunk.split("\n");
-
-          for (const line of lines) {
-            if (line.startsWith("data: ")) {
-              try {
-                const eventData = line.slice(6); // Remove 'data: ' prefix
-                const event: StreamEvent = JSON.parse(eventData);
-
-                console.log(`[HTTP Client] Stream event: ${event.type}`);
-                this.options.onStreamEvent?.(event);
-
-                switch (event.type) {
-                  case "command_start":
-                    console.log(
-                      `[HTTP Client] Command started: ${
-                        event.command
-                      } ${event.args?.join(" ")}`
-                    );
-                    this.options.onCommandStart?.(
-                      event.command!,
-                      event.args || []
-                    );
-                    break;
-
-                  case "output":
-                    console.log(`[${event.stream}] ${event.data}`);
-                    this.options.onOutput?.(
-                      event.stream!,
-                      event.data!,
-                      event.command!
-                    );
-                    break;
-
-                  case "command_complete":
-                    console.log(
-                      `[HTTP Client] Command completed: ${event.command}, Success: ${event.success}, Exit code: ${event.exitCode}`
-                    );
-                    this.options.onCommandComplete?.(
-                      event.success!,
-                      event.exitCode!,
-                      event.stdout!,
-                      event.stderr!,
-                      event.command!,
-                      event.args || []
-                    );
-                    break;
-
-                  case "error":
-                    console.error(
-                      `[HTTP Client] Command error: ${event.error}`
-                    );
-                    this.options.onError?.(
-                      event.error!,
-                      event.command,
-                      event.args
-                    );
-                    break;
-                }
-              } catch (parseError) {
-                console.warn(
-                  "[HTTP Client] Failed to parse stream event:",
-                  parseError
-                );
-              }
-            }
-          }
-        }
-      } finally {
-        reader.releaseLock();
-      }
-    } catch (error) {
-      console.error("[HTTP Client] Error in streaming execution:", error);
-      this.options.onError?.(
-        error instanceof Error ? error.message : "Unknown error",
-        command,
-        args
+      console.log(
+        `[HTTP Client] Started streaming command in session ${sessionId}: ${command}`
       );
+      return response.body;
+    } catch (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",
         },
@@ -515,22 +362,18 @@ export class HttpClient {
     }
   }
 
-  async gitCheckoutStream(
-    repoUrl: string,
-    branch: string = "main",
-    targetDir?: string,
-    sessionId?: string
-  ): Promise<void> {
+  async mkdir(
+    path: string,
+    recursive: boolean = false,
+    sessionId: string
+  ): Promise<MkdirResponse> {
     try {
-      const targetSessionId = sessionId || this.sessionId;
-
-      const response = await this.doFetch(`/api/git/checkout/stream`, {
+      const response = await this.doFetch(`/api/mkdir`, {
         body: JSON.stringify({
-          branch,
-          repoUrl,
-          sessionId: targetSessionId,
-          targetDir,
-        }),
+          path,
+          recursive,
+          sessionId,
+        } as MkdirRequest),
         headers: {
           "Content-Type": "application/json",
         },
@@ -546,119 +389,32 @@ export class HttpClient {
         );
       }
 
-      if (!response.body) {
-        throw new Error("No response body for streaming request");
-      }
+      const data: MkdirResponse = await response.json();
+      console.log(
+        `[HTTP Client] Directory created: ${path}, Success: ${data.success}, Recursive: ${data.recursive}${sessionId ? ` in session: ${sessionId}` : ''}`
+      );
 
-      const reader = response.body.getReader();
-      const decoder = new TextDecoder();
-
-      try {
-        while (true) {
-          const { done, value } = await reader.read();
-
-          if (done) {
-            break;
-          }
-
-          const chunk = decoder.decode(value, { stream: true });
-          const lines = chunk.split("\n");
-
-          for (const line of lines) {
-            if (line.startsWith("data: ")) {
-              try {
-                const eventData = line.slice(6); // Remove 'data: ' prefix
-                const event: StreamEvent = JSON.parse(eventData);
-
-                console.log(
-                  `[HTTP Client] Git checkout stream event: ${event.type}`
-                );
-                this.options.onStreamEvent?.(event);
-
-                switch (event.type) {
-                  case "command_start":
-                    console.log(
-                      `[HTTP Client] Git checkout started: ${
-                        event.command
-                      } ${event.args?.join(" ")}`
-                    );
-                    this.options.onCommandStart?.(
-                      event.command!,
-                      event.args || []
-                    );
-                    break;
-
-                  case "output":
-                    console.log(`[${event.stream}] ${event.data}`);
-                    this.options.onOutput?.(
-                      event.stream!,
-                      event.data!,
-                      event.command!
-                    );
-                    break;
-
-                  case "command_complete":
-                    console.log(
-                      `[HTTP Client] Git checkout completed: ${event.command}, Success: ${event.success}, Exit code: ${event.exitCode}`
-                    );
-                    this.options.onCommandComplete?.(
-                      event.success!,
-                      event.exitCode!,
-                      event.stdout!,
-                      event.stderr!,
-                      event.command!,
-                      event.args || []
-                    );
-                    break;
-
-                  case "error":
-                    console.error(
-                      `[HTTP Client] Git checkout error: ${event.error}`
-                    );
-                    this.options.onError?.(
-                      event.error!,
-                      event.command,
-                      event.args
-                    );
-                    break;
-                }
-              } catch (parseError) {
-                console.warn(
-                  "[HTTP Client] Failed to parse git checkout stream event:",
-                  parseError
-                );
-              }
-            }
-          }
-        }
-      } finally {
-        reader.releaseLock();
-      }
+      return data;
     } catch (error) {
-      console.error("[HTTP Client] Error in streaming git checkout:", error);
-      this.options.onError?.(
-        error instanceof Error ? error.message : "Unknown error",
-        "git clone",
-        [branch, repoUrl, targetDir || ""]
-      );
+      console.error("[HTTP Client] Error creating directory:", error);
       throw error;
     }
   }
 
-  async mkdir(
+  async writeFile(
     path: string,
-    recursive: boolean = false,
-    sessionId?: string
-  ): Promise<MkdirResponse> {
+    content: string,
+    encoding: string = "utf-8",
+    sessionId: string
+  ): Promise<WriteFileResponse> {
     try {
-      const targetSessionId = sessionId || this.sessionId;
-
-      const response = await this.doFetch(`/api/mkdir`, {
+      const response = await this.doFetch(`/api/write`, {
         body: JSON.stringify({
+          content,
+          encoding,
           path,
-          recursive,
-          sessionId: targetSessionId,
-        }),
+          sessionId,
+        } as WriteFileRequest),
         headers: {
           "Content-Type": "application/json",
         },
@@ -674,32 +430,30 @@ export class HttpClient {
         );
       }
 
-      const data: MkdirResponse = await response.json();
+      const data: WriteFileResponse = await response.json();
       console.log(
-        `[HTTP Client] Directory created: ${path}, Success: ${data.success}, Recursive: ${data.recursive}`
+        `[HTTP Client] File written: ${path}, Success: ${data.success}${sessionId ? ` in session: ${sessionId}` : ''}`
       );
 
       return data;
     } catch (error) {
-      console.error("[HTTP Client] Error creating directory:", error);
+      console.error("[HTTP Client] Error writing file:", error);
       throw error;
     }
   }
 
-  async mkdirStream(
+  async readFile(
     path: string,
-    recursive: boolean = false,
-    sessionId?: string
-  ): Promise<void> {
+    encoding: string = "utf-8",
+    sessionId: string
+  ): Promise<ReadFileResponse> {
     try {
-      const targetSessionId = sessionId || this.sessionId;
-
-      const response = await this.doFetch(`/api/mkdir/stream`, {
+      const response = await this.doFetch(`/api/read`, {
         body: JSON.stringify({
+          encoding,
           path,
-          recursive,
-          sessionId: targetSessionId,
-        }),
+          sessionId,
+        } as ReadFileRequest),
         headers: {
           "Content-Type": "application/json",
         },
@@ -715,117 +469,28 @@ export class HttpClient {
         );
       }
 
-      if (!response.body) {
-        throw new Error("No response body for streaming request");
-      }
+      const data: ReadFileResponse = await response.json();
+      console.log(
+        `[HTTP Client] File read: ${path}, Success: ${data.success}, Content length: ${data.content.length}${sessionId ? ` in session: ${sessionId}` : ''}`
+      );
 
-      const reader = response.body.getReader();
-      const decoder = new TextDecoder();
-
-      try {
-        while (true) {
-          const { done, value } = await reader.read();
-
-          if (done) {
-            break;
-          }
-
-          const chunk = decoder.decode(value, { stream: true });
-          const lines = chunk.split("\n");
-
-          for (const line of lines) {
-            if (line.startsWith("data: ")) {
-              try {
-                const eventData = line.slice(6); // Remove 'data: ' prefix
-                const event: StreamEvent = JSON.parse(eventData);
-
-                console.log(`[HTTP Client] Mkdir stream event: ${event.type}`);
-                this.options.onStreamEvent?.(event);
-
-                switch (event.type) {
-                  case "command_start":
-                    console.log(
-                      `[HTTP Client] Mkdir started: ${
-                        event.command
-                      } ${event.args?.join(" ")}`
-                    );
-                    this.options.onCommandStart?.(
-                      event.command!,
-                      event.args || []
-                    );
-                    break;
-
-                  case "output":
-                    console.log(`[${event.stream}] ${event.data}`);
-                    this.options.onOutput?.(
-                      event.stream!,
-                      event.data!,
-                      event.command!
-                    );
-                    break;
-
-                  case "command_complete":
-                    console.log(
-                      `[HTTP Client] Mkdir completed: ${event.command}, Success: ${event.success}, Exit code: ${event.exitCode}`
-                    );
-                    this.options.onCommandComplete?.(
-                      event.success!,
-                      event.exitCode!,
-                      event.stdout!,
-                      event.stderr!,
-                      event.command!,
-                      event.args || []
-                    );
-                    break;
-
-                  case "error":
-                    console.error(`[HTTP Client] Mkdir error: ${event.error}`);
-                    this.options.onError?.(
-                      event.error!,
-                      event.command,
-                      event.args
-                    );
-                    break;
-                }
-              } catch (parseError) {
-                console.warn(
-                  "[HTTP Client] Failed to parse mkdir stream event:",
-                  parseError
-                );
-              }
-            }
-          }
-        }
-      } finally {
-        reader.releaseLock();
-      }
+      return data;
     } catch (error) {
-      console.error("[HTTP Client] Error in streaming mkdir:", error);
-      this.options.onError?.(
-        error instanceof Error ? error.message : "Unknown error",
-        "mkdir",
-        recursive ? ["-p", path] : [path]
-      );
+      console.error("[HTTP Client] Error reading file:", error);
       throw error;
     }
   }
 
-  async writeFile(
+  async deleteFile(
     path: string,
-    content: string,
-    encoding: string = "utf-8",
-    sessionId?: string
-  ): Promise<WriteFileResponse> {
+    sessionId: string
+  ): Promise<DeleteFileResponse> {
     try {
-      const targetSessionId = sessionId || this.sessionId;
-
-      const response = await this.doFetch(`/api/write`, {
+      const response = await this.doFetch(`/api/delete`, {
         body: JSON.stringify({
-          content,
-          encoding,
           path,
-          sessionId: targetSessionId,
-        }),
+          sessionId,
+        } as DeleteFileRequest),
         headers: {
           "Content-Type": "application/json",
         },
@@ -841,34 +506,30 @@ export class HttpClient {
         );
       }
 
-      const data: WriteFileResponse = await response.json();
+      const data: DeleteFileResponse = await response.json();
       console.log(
-        `[HTTP Client] File written: ${path}, Success: ${data.success}`
+        `[HTTP Client] File deleted: ${path}, Success: ${data.success}${sessionId ? ` in session: ${sessionId}` : ''}`
       );
 
       return data;
     } catch (error) {
-      console.error("[HTTP Client] Error writing file:", error);
+      console.error("[HTTP Client] Error deleting file:", error);
       throw error;
     }
   }
 
-  async writeFileStream(
-    path: string,
-    content: string,
-    encoding: string = "utf-8",
-    sessionId?: string
-  ): Promise<void> {
+  async renameFile(
+    oldPath: string,
+    newPath: string,
+    sessionId: string
+  ): Promise<RenameFileResponse> {
     try {
-      const targetSessionId = sessionId || this.sessionId;
-
-      const response = await this.doFetch(`/api/write/stream`, {
+      const response = await this.doFetch(`/api/rename`, {
         body: JSON.stringify({
-          content,
-          encoding,
-          path,
-          sessionId: targetSessionId,
-        }),
+          newPath,
+          oldPath,
+          sessionId,
+        } as RenameFileRequest),
         headers: {
           "Content-Type": "application/json",
         },
@@ -884,112 +545,30 @@ export class HttpClient {
         );
       }
 
-      if (!response.body) {
-        throw new Error("No response body for streaming request");
-      }
+      const data: RenameFileResponse = await response.json();
+      console.log(
+        `[HTTP Client] File renamed: ${oldPath} -> ${newPath}, Success: ${data.success}${sessionId ? ` in session: ${sessionId}` : ''}`
+      );
 
-      const reader = response.body.getReader();
-      const decoder = new TextDecoder();
-
-      try {
-        while (true) {
-          const { done, value } = await reader.read();
-
-          if (done) {
-            break;
-          }
-
-          const chunk = decoder.decode(value, { stream: true });
-          const lines = chunk.split("\n");
-
-          for (const line of lines) {
-            if (line.startsWith("data: ")) {
-              try {
-                const eventData = line.slice(6); // Remove 'data: ' prefix
-                const event: StreamEvent = JSON.parse(eventData);
-
-                console.log(
-                  `[HTTP Client] Write file stream event: ${event.type}`
-                );
-                this.options.onStreamEvent?.(event);
-
-                switch (event.type) {
-                  case "command_start":
-                    console.log(
-                      `[HTTP Client] Write file started: ${event.path}`
-                    );
-                    this.options.onCommandStart?.("write", [
-                      path,
-                      content,
-                      encoding,
-                    ]);
-                    break;
-
-                  case "output":
-                    console.log(`[output] ${event.message}`);
-                    this.options.onOutput?.("stdout", event.message!, "write");
-                    break;
-
-                  case "command_complete":
-                    console.log(
-                      `[HTTP Client] Write file completed: ${event.path}, Success: ${event.success}`
-                    );
-                    this.options.onCommandComplete?.(
-                      event.success!,
-                      0,
-                      "",
-                      "",
-                      "write",
-                      [path, content, encoding]
-                    );
-                    break;
-
-                  case "error":
-                    console.error(
-                      `[HTTP Client] Write file error: ${event.error}`
-                    );
-                    this.options.onError?.(event.error!, "write", [
-                      path,
-                      content,
-                      encoding,
-                    ]);
-                    break;
-                }
-              } catch (parseError) {
-                console.warn(
-                  "[HTTP Client] Failed to parse write file stream event:",
-                  parseError
-                );
-              }
-            }
-          }
-        }
-      } finally {
-        reader.releaseLock();
-      }
+      return data;
     } catch (error) {
-      console.error("[HTTP Client] Error in streaming write file:", error);
-      this.options.onError?.(
-        error instanceof Error ? error.message : "Unknown error",
-        "write",
-        [path, content, encoding]
-      );
+      console.error("[HTTP Client] Error renaming file:", error);
       throw error;
     }
   }
 
-  async deleteFile(
-    path: string,
-    sessionId?: string
-  ): Promise<DeleteFileResponse> {
+  async moveFile(
+    sourcePath: string,
+    destinationPath: string,
+    sessionId: string
+  ): Promise<MoveFileResponse> {
     try {
-      const targetSessionId = sessionId || this.sessionId;
-
-      const response = await this.doFetch(`/api/delete`, {
+      const response = await this.doFetch(`/api/move`, {
         body: JSON.stringify({
-          path,
-          sessionId: targetSessionId,
-        }),
+          destinationPath,
+          sourcePath,
+          sessionId,
+        } as MoveFileRequest),
         headers: {
           "Content-Type": "application/json",
         },
@@ -1005,27 +584,33 @@ export class HttpClient {
         );
       }
 
-      const data: DeleteFileResponse = await response.json();
+      const data: MoveFileResponse = await response.json();
       console.log(
-        `[HTTP Client] File deleted: ${path}, Success: ${data.success}`
+        `[HTTP Client] File moved: ${sourcePath} -> ${destinationPath}, Success: ${data.success}${sessionId ? ` in session: ${sessionId}` : ''}`
       );
 
       return data;
     } catch (error) {
-      console.error("[HTTP Client] Error deleting file:", error);
+      console.error("[HTTP Client] Error moving file:", error);
       throw error;
     }
   }
 
-  async deleteFileStream(path: string, sessionId?: string): Promise<void> {
+  async listFiles(
+    path: string,
+    sessionId: string,
+    options?: {
+      recursive?: boolean;
+      includeHidden?: boolean;
+    }
+  ): Promise<ListFilesResponse> {
     try {
-      const targetSessionId = sessionId || this.sessionId;
-
-      const response = await this.doFetch(`/api/delete/stream`, {
+      const response = await this.doFetch(`/api/list-files`, {
         body: JSON.stringify({
           path,
-          sessionId: targetSessionId,
-        }),
+          options,
+          sessionId,
+        } as ListFilesRequest),
         headers: {
           "Content-Type": "application/json",
         },
@@ -1041,100 +626,24 @@ export class HttpClient {
         );
       }
 
-      if (!response.body) {
-        throw new Error("No response body for streaming request");
-      }
+      const data: ListFilesResponse = await response.json();
+      console.log(
+        `[HTTP Client] Listed ${data.files.length} files in: ${path}, Success: ${data.success}${sessionId ? ` in session: ${sessionId}` : ''}`
+      );
 
-      const reader = response.body.getReader();
-      const decoder = new TextDecoder();
-
-      try {
-        while (true) {
-          const { done, value } = await reader.read();
-
-          if (done) {
-            break;
-          }
-
-          const chunk = decoder.decode(value, { stream: true });
-          const lines = chunk.split("\n");
-
-          for (const line of lines) {
-            if (line.startsWith("data: ")) {
-              try {
-                const eventData = line.slice(6); // Remove 'data: ' prefix
-                const event: StreamEvent = JSON.parse(eventData);
-
-                console.log(
-                  `[HTTP Client] Delete file stream event: ${event.type}`
-                );
-                this.options.onStreamEvent?.(event);
-
-                switch (event.type) {
-                  case "command_start":
-                    console.log(
-                      `[HTTP Client] Delete file started: ${event.path}`
-                    );
-                    this.options.onCommandStart?.("delete", [path]);
-                    break;
-
-                  case "command_complete":
-                    console.log(
-                      `[HTTP Client] Delete file completed: ${event.path}, Success: ${event.success}`
-                    );
-                    this.options.onCommandComplete?.(
-                      event.success!,
-                      0,
-                      "",
-                      "",
-                      "delete",
-                      [path]
-                    );
-                    break;
-
-                  case "error":
-                    console.error(
-                      `[HTTP Client] Delete file error: ${event.error}`
-                    );
-                    this.options.onError?.(event.error!, "delete", [path]);
-                    break;
-                }
-              } catch (parseError) {
-                console.warn(
-                  "[HTTP Client] Failed to parse delete file stream event:",
-                  parseError
-                );
-              }
-            }
-          }
-        }
-      } finally {
-        reader.releaseLock();
-      }
+      return data;
     } catch (error) {
-      console.error("[HTTP Client] Error in streaming delete file:", error);
-      this.options.onError?.(
-        error instanceof Error ? error.message : "Unknown error",
-        "delete",
-        [path]
-      );
+      console.error("[HTTP Client] Error listing files:", error);
       throw error;
     }
   }
 
-  async renameFile(
-    oldPath: string,
-    newPath: string,
-    sessionId?: string
-  ): Promise<RenameFileResponse> {
+  async exposePort(port: number, name?: string): Promise<ExposePortResponse> {
     try {
-      const targetSessionId = sessionId || this.sessionId;
-
-      const response = await this.doFetch(`/api/rename`, {
+      const response = await this.doFetch(`/api/expose-port`, {
         body: JSON.stringify({
-          newPath,
-          oldPath,
-          sessionId: targetSessionId,
+          port,
+          name,
         }),
         headers: {
           "Content-Type": "application/json",
@@ -1146,41 +655,36 @@ export class HttpClient {
         const errorData = (await response.json().catch(() => ({}))) as {
           error?: string;
         };
+        console.log(errorData);
         throw new Error(
           errorData.error || `HTTP error! status: ${response.status}`
         );
       }
 
-      const data: RenameFileResponse = await response.json();
+      const data: ExposePortResponse = await response.json();
       console.log(
-        `[HTTP Client] File renamed: ${oldPath} -> ${newPath}, Success: ${data.success}`
+        `[HTTP Client] Port exposed: ${port}${
+          name ? ` (${name})` : ""
+        }, Success: ${data.success}`
       );
 
       return data;
     } catch (error) {
-      console.error("[HTTP Client] Error renaming file:", error);
+      console.error("[HTTP Client] Error exposing port:", error);
       throw error;
     }
   }
 
-  async renameFileStream(
-    oldPath: string,
-    newPath: string,
-    sessionId?: string
-  ): Promise<void> {
+  async unexposePort(port: number): Promise<UnexposePortResponse> {
     try {
-      const targetSessionId = sessionId || this.sessionId;
-
-      const response = await this.doFetch(`/api/rename/stream`, {
+      const response = await this.doFetch(`/api/unexpose-port`, {
         body: JSON.stringify({
-          newPath,
-          oldPath,
-          sessionId: targetSessionId,
+          port,
         }),
         headers: {
           "Content-Type": "application/json",
         },
-        method: "POST",
+        method: "DELETE",
       });
 
       if (!response.ok) {
@@ -1192,108 +696,25 @@ export class HttpClient {
         );
       }
 
-      if (!response.body) {
-        throw new Error("No response body for streaming request");
-      }
+      const data: UnexposePortResponse = await response.json();
+      console.log(
+        `[HTTP Client] Port unexposed: ${port}, Success: ${data.success}`
+      );
 
-      const reader = response.body.getReader();
-      const decoder = new TextDecoder();
-
-      try {
-        while (true) {
-          const { done, value } = await reader.read();
-
-          if (done) {
-            break;
-          }
-
-          const chunk = decoder.decode(value, { stream: true });
-          const lines = chunk.split("\n");
-
-          for (const line of lines) {
-            if (line.startsWith("data: ")) {
-              try {
-                const eventData = line.slice(6); // Remove 'data: ' prefix
-                const event: StreamEvent = JSON.parse(eventData);
-
-                console.log(
-                  `[HTTP Client] Rename file stream event: ${event.type}`
-                );
-                this.options.onStreamEvent?.(event);
-
-                switch (event.type) {
-                  case "command_start":
-                    console.log(
-                      `[HTTP Client] Rename file started: ${event.oldPath} -> ${event.newPath}`
-                    );
-                    this.options.onCommandStart?.("rename", [oldPath, newPath]);
-                    break;
-
-                  case "command_complete":
-                    console.log(
-                      `[HTTP Client] Rename file completed: ${event.oldPath} -> ${event.newPath}, Success: ${event.success}`
-                    );
-                    this.options.onCommandComplete?.(
-                      event.success!,
-                      0,
-                      "",
-                      "",
-                      "rename",
-                      [oldPath, newPath]
-                    );
-                    break;
-
-                  case "error":
-                    console.error(
-                      `[HTTP Client] Rename file error: ${event.error}`
-                    );
-                    this.options.onError?.(event.error!, "rename", [
-                      oldPath,
-                      newPath,
-                    ]);
-                    break;
-                }
-              } catch (parseError) {
-                console.warn(
-                  "[HTTP Client] Failed to parse rename file stream event:",
-                  parseError
-                );
-              }
-            }
-          }
-        }
-      } finally {
-        reader.releaseLock();
-      }
+      return data;
     } catch (error) {
-      console.error("[HTTP Client] Error in streaming rename file:", error);
-      this.options.onError?.(
-        error instanceof Error ? error.message : "Unknown error",
-        "rename",
-        [oldPath, newPath]
-      );
+      console.error("[HTTP Client] Error unexposing port:", error);
       throw error;
     }
   }
 
-  async moveFile(
-    sourcePath: string,
-    destinationPath: string,
-    sessionId?: string
-  ): Promise<MoveFileResponse> {
+  async getExposedPorts(): Promise<GetExposedPortsResponse> {
     try {
-      const targetSessionId = sessionId || this.sessionId;
-
-      const response = await this.doFetch(`/api/move`, {
-        body: JSON.stringify({
-          destinationPath,
-          sessionId: targetSessionId,
-          sourcePath,
-        }),
+      const response = await this.doFetch(`/api/exposed-ports`, {
         headers: {
           "Content-Type": "application/json",
         },
-        method: "POST",
+        method: "GET",
       });
 
       if (!response.ok) {
@@ -1305,32 +726,59 @@ export class HttpClient {
         );
       }
 
-      const data: MoveFileResponse = await response.json();
-      console.log(
-        `[HTTP Client] File moved: ${sourcePath} -> ${destinationPath}, Success: ${data.success}`
-      );
+      const data: GetExposedPortsResponse = await response.json();
+      console.log(`[HTTP Client] Got ${data.count} exposed ports`);
 
       return data;
     } catch (error) {
-      console.error("[HTTP Client] Error moving file:", error);
+      console.error("[HTTP Client] Error getting exposed ports:", error);
       throw error;
     }
   }
 
-  async moveFileStream(
-    sourcePath: string,
-    destinationPath: string,
-    sessionId?: string
-  ): Promise<void> {
+  async ping(): Promise<string> {
     try {
-      const targetSessionId = sessionId || this.sessionId;
+      const response = await this.doFetch(`/api/ping`, {
+        headers: {
+          "Content-Type": "application/json",
+        },
+        method: "GET",
+      });
 
-      const response = await this.doFetch(`/api/move/stream`, {
+      if (!response.ok) {
+        throw new Error(`HTTP error! status: ${response.status}`);
+      }
+
+      const data: PingResponse = await response.json();
+      console.log(`[HTTP Client] Ping response: ${data.message}`);
+      return data.timestamp;
+    } catch (error) {
+      console.error("[HTTP Client] Error pinging server:", error);
+      throw error;
+    }
+  }
+
+
+  // Process management methods
+  async startProcess(
+    command: string,
+    sessionId: string,
+    options?: {
+      processId?: string;
+      timeout?: number;
+      env?: Record<string, string>;
+      cwd?: string;
+      encoding?: string;
+      autoCleanup?: boolean;
+    }
+  ): Promise<StartProcessResponse> {
+    try {
+      const response = await this.doFetch("/api/process/start", {
         body: JSON.stringify({
-          destinationPath,
-          sessionId: targetSessionId,
-          sourcePath,
-        }),
+          command,
+          sessionId,
+          options,
+        } as StartProcessRequest),
         headers: {
           "Content-Type": "application/json",
         },
@@ -1346,96 +794,24 @@ export class HttpClient {
         );
       }
 
-      if (!response.body) {
-        throw new Error("No response body for streaming request");
-      }
+      const data: StartProcessResponse = await response.json();
+      console.log(
+        `[HTTP Client] Process started: ${command}, ID: ${data.process.id}`
+      );
 
-      const reader = response.body.getReader();
-      const decoder = new TextDecoder();
-
-      try {
-        while (true) {
-          const { done, value } = await reader.read();
-
-          if (done) {
-            break;
-          }
-
-          const chunk = decoder.decode(value, { stream: true });
-          const lines = chunk.split("\n");
-
-          for (const line of lines) {
-            if (line.startsWith("data: ")) {
-              try {
-                const eventData = line.slice(6); // Remove 'data: ' prefix
-                const event: StreamEvent = JSON.parse(eventData);
-
-                console.log(
-                  `[HTTP Client] Move file stream event: ${event.type}`
-                );
-                this.options.onStreamEvent?.(event);
-
-                switch (event.type) {
-                  case "command_start":
-                    console.log(
-                      `[HTTP Client] Move file started: ${event.sourcePath} -> ${event.destinationPath}`
-                    );
-                    this.options.onCommandStart?.("move", [
-                      sourcePath,
-                      destinationPath,
-                    ]);
-                    break;
-
-                  case "command_complete":
-                    console.log(
-                      `[HTTP Client] Move file completed: ${event.sourcePath} -> ${event.destinationPath}, Success: ${event.success}`
-                    );
-                    this.options.onCommandComplete?.(
-                      event.success!,
-                      0,
-                      "",
-                      "",
-                      "move",
-                      [sourcePath, destinationPath]
-                    );
-                    break;
-
-                  case "error":
-                    console.error(
-                      `[HTTP Client] Move file error: ${event.error}`
-                    );
-                    this.options.onError?.(event.error!, "move", [
-                      sourcePath,
-                      destinationPath,
-                    ]);
-                    break;
-                }
-              } catch (parseError) {
-                console.warn(
-                  "[HTTP Client] Failed to parse move file stream event:",
-                  parseError
-                );
-              }
-            }
-          }
-        }
-      } finally {
-        reader.releaseLock();
-      }
+      return data;
     } catch (error) {
-      console.error("[HTTP Client] Error in streaming move file:", error);
-      this.options.onError?.(
-        error instanceof Error ? error.message : "Unknown error",
-        "move",
-        [sourcePath, destinationPath]
-      );
+      console.error("[HTTP Client] Error starting process:", error);
       throw error;
     }
   }
 
-  async ping(): Promise<string> {
+  async listProcesses(sessionId?: string): Promise<ListProcessesResponse> {
     try {
-      const response = await this.doFetch(`/api/ping`, {
+      const url = sessionId 
+        ? `/api/process/list?session=${encodeURIComponent(sessionId)}`
+        : "/api/process/list";
+      const response = await this.doFetch(url, {
         headers: {
           "Content-Type": "application/json",
         },
@@ -1443,21 +819,27 @@ export class HttpClient {
       });
 
       if (!response.ok) {
-        throw new Error(`HTTP error! status: ${response.status}`);
+        const errorData = (await response.json().catch(() => ({}))) as {
+          error?: string;
+        };
+        throw new Error(
+          errorData.error || `HTTP error! status: ${response.status}`
+        );
       }
 
-      const data: PingResponse = await response.json();
-      console.log(`[HTTP Client] Ping response: ${data.message}`);
-      return data.timestamp;
+      const data: ListProcessesResponse = await response.json();
+      console.log(`[HTTP Client] Listed ${data.processes.length} processes`);
+
+      return data;
     } catch (error) {
-      console.error("[HTTP Client] Error pinging server:", error);
+      console.error("[HTTP Client] Error listing processes:", error);
       throw error;
     }
   }
 
-  async getCommands(): Promise<string[]> {
+  async getProcess(processId: string): Promise<GetProcessResponse> {
     try {
-      const response = await fetch(`${this.baseUrl}/api/commands`, {
+      const response = await this.doFetch(`/api/process/${processId}`, {
         headers: {
           "Content-Type": "application/json",
         },
@@ -1465,260 +847,163 @@ export class HttpClient {
       });
 
       if (!response.ok) {
-        throw new Error(`HTTP error! status: ${response.status}`);
+        const errorData = (await response.json().catch(() => ({}))) as {
+          error?: string;
+        };
+        throw new Error(
+          errorData.error || `HTTP error! status: ${response.status}`
+        );
       }
 
-      const data: CommandsResponse = await response.json();
+      const data: GetProcessResponse = await response.json();
       console.log(
-        `[HTTP Client] Available commands: ${data.availableCommands.length}`
+        `[HTTP Client] Got process ${processId}: ${
+          data.process?.status || "not found"
+        }`
       );
-      return data.availableCommands;
+
+      return data;
     } catch (error) {
-      console.error("[HTTP Client] Error getting commands:", error);
+      console.error("[HTTP Client] Error getting process:", error);
       throw error;
     }
   }
 
-  getSessionId(): string | null {
-    return this.sessionId;
-  }
-
-  setSessionId(sessionId: string): void {
-    this.sessionId = sessionId;
-  }
+  async killProcess(
+    processId: string
+  ): Promise<{ success: boolean; message: string }> {
+    try {
+      const response = await this.doFetch(`/api/process/${processId}`, {
+        headers: {
+          "Content-Type": "application/json",
+        },
+        method: "DELETE",
+      });
 
-  clearSession(): void {
-    this.sessionId = null;
-  }
-}
+      if (!response.ok) {
+        const errorData = (await response.json().catch(() => ({}))) as {
+          error?: string;
+        };
+        throw new Error(
+          errorData.error || `HTTP error! status: ${response.status}`
+        );
+      }
 
-// Example usage and utility functions
-export function createClient(options?: HttpClientOptions): HttpClient {
-  return new HttpClient(options);
-}
+      const data = (await response.json()) as {
+        success: boolean;
+        message: string;
+      };
+      console.log(`[HTTP Client] Killed process ${processId}`);
 
-// Convenience function for quick command execution
-export async function quickExecute(
-  command: string,
-  args: string[] = [],
-  options?: HttpClientOptions
-): Promise<ExecuteResponse> {
-  const client = createClient(options);
-  await client.createSession();
-
-  try {
-    return await client.execute(command, args);
-  } finally {
-    client.clearSession();
+      return data;
+    } catch (error) {
+      console.error("[HTTP Client] Error killing process:", error);
+      throw error;
+    }
   }
-}
 
-// Convenience function for quick streaming command execution
-export async function quickExecuteStream(
-  command: string,
-  args: string[] = [],
-  options?: HttpClientOptions
-): Promise<void> {
-  const client = createClient(options);
-  await client.createSession();
-
-  try {
-    await client.executeStream(command, args);
-  } finally {
-    client.clearSession();
-  }
-}
+  async killAllProcesses(sessionId?: string): Promise<{
+    success: boolean;
+    killedCount: number;
+    message: string;
+  }> {
+    try {
+      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",
+        },
+        method: "DELETE",
+      });
 
-// Convenience function for quick git checkout
-export async function quickGitCheckout(
-  repoUrl: string,
-  branch: string = "main",
-  targetDir?: string,
-  options?: HttpClientOptions
-): Promise<GitCheckoutResponse> {
-  const client = createClient(options);
-  await client.createSession();
-
-  try {
-    return await client.gitCheckout(repoUrl, branch, targetDir);
-  } finally {
-    client.clearSession();
-  }
-}
+      if (!response.ok) {
+        const errorData = (await response.json().catch(() => ({}))) as {
+          error?: string;
+        };
+        throw new Error(
+          errorData.error || `HTTP error! status: ${response.status}`
+        );
+      }
 
-// Convenience function for quick directory creation
-export async function quickMkdir(
-  path: string,
-  recursive: boolean = false,
-  options?: HttpClientOptions
-): Promise<MkdirResponse> {
-  const client = createClient(options);
-  await client.createSession();
-
-  try {
-    return await client.mkdir(path, recursive);
-  } finally {
-    client.clearSession();
-  }
-}
+      const data = (await response.json()) as {
+        success: boolean;
+        killedCount: number;
+        message: string;
+      };
+      console.log(`[HTTP Client] Killed ${data.killedCount} processes`);
 
-// Convenience function for quick streaming git checkout
-export async function quickGitCheckoutStream(
-  repoUrl: string,
-  branch: string = "main",
-  targetDir?: string,
-  options?: HttpClientOptions
-): Promise<void> {
-  const client = createClient(options);
-  await client.createSession();
-
-  try {
-    await client.gitCheckoutStream(repoUrl, branch, targetDir);
-  } finally {
-    client.clearSession();
+      return data;
+    } catch (error) {
+      console.error("[HTTP Client] Error killing all processes:", error);
+      throw error;
+    }
   }
-}
 
-// Convenience function for quick streaming directory creation
-export async function quickMkdirStream(
-  path: string,
-  recursive: boolean = false,
-  options?: HttpClientOptions
-): Promise<void> {
-  const client = createClient(options);
-  await client.createSession();
-
-  try {
-    await client.mkdirStream(path, recursive);
-  } finally {
-    client.clearSession();
-  }
-}
+  async getProcessLogs(processId: string): Promise<GetProcessLogsResponse> {
+    try {
+      const response = await this.doFetch(`/api/process/${processId}/logs`, {
+        headers: {
+          "Content-Type": "application/json",
+        },
+        method: "GET",
+      });
 
-// Convenience function for quick file writing
-export async function quickWriteFile(
-  path: string,
-  content: string,
-  encoding: string = "utf-8",
-  options?: HttpClientOptions
-): Promise<WriteFileResponse> {
-  const client = createClient(options);
-  await client.createSession();
-
-  try {
-    return await client.writeFile(path, content, encoding);
-  } finally {
-    client.clearSession();
-  }
-}
+      if (!response.ok) {
+        const errorData = (await response.json().catch(() => ({}))) as {
+          error?: string;
+        };
+        throw new Error(
+          errorData.error || `HTTP error! status: ${response.status}`
+        );
+      }
 
-// Convenience function for quick streaming file writing
-export async function quickWriteFileStream(
-  path: string,
-  content: string,
-  encoding: string = "utf-8",
-  options?: HttpClientOptions
-): Promise<void> {
-  const client = createClient(options);
-  await client.createSession();
-
-  try {
-    await client.writeFileStream(path, content, encoding);
-  } finally {
-    client.clearSession();
-  }
-}
+      const data: GetProcessLogsResponse = await response.json();
+      console.log(`[HTTP Client] Got logs for process ${processId}`);
 
-// Convenience function for quick file deletion
-export async function quickDeleteFile(
-  path: string,
-  options?: HttpClientOptions
-): Promise<DeleteFileResponse> {
-  const client = createClient(options);
-  await client.createSession();
-
-  try {
-    return await client.deleteFile(path);
-  } finally {
-    client.clearSession();
+      return data;
+    } catch (error) {
+      console.error("[HTTP Client] Error getting process logs:", error);
+      throw error;
+    }
   }
-}
 
-// Convenience function for quick streaming file deletion
-export async function quickDeleteFileStream(
-  path: string,
-  options?: HttpClientOptions
-): Promise<void> {
-  const client = createClient(options);
-  await client.createSession();
-
-  try {
-    await client.deleteFileStream(path);
-  } finally {
-    client.clearSession();
-  }
-}
+  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",
+          "Cache-Control": "no-cache",
+        },
+        method: "GET",
+        signal: options?.signal,
+      });
 
-// Convenience function for quick file renaming
-export async function quickRenameFile(
-  oldPath: string,
-  newPath: string,
-  options?: HttpClientOptions
-): Promise<RenameFileResponse> {
-  const client = createClient(options);
-  await client.createSession();
-
-  try {
-    return await client.renameFile(oldPath, newPath);
-  } finally {
-    client.clearSession();
-  }
-}
+      if (!response.ok) {
+        const errorData = (await response.json().catch(() => ({}))) as {
+          error?: string;
+        };
+        throw new Error(
+          errorData.error || `HTTP error! status: ${response.status}`
+        );
+      }
 
-// Convenience function for quick streaming file renaming
-export async function quickRenameFileStream(
-  oldPath: string,
-  newPath: string,
-  options?: HttpClientOptions
-): Promise<void> {
-  const client = createClient(options);
-  await client.createSession();
-
-  try {
-    await client.renameFileStream(oldPath, newPath);
-  } finally {
-    client.clearSession();
-  }
-}
+      if (!response.body) {
+        throw new Error("No response body for streaming request");
+      }
 
-// Convenience function for quick file moving
-export async function quickMoveFile(
-  sourcePath: string,
-  destinationPath: string,
-  options?: HttpClientOptions
-): Promise<MoveFileResponse> {
-  const client = createClient(options);
-  await client.createSession();
-
-  try {
-    return await client.moveFile(sourcePath, destinationPath);
-  } finally {
-    client.clearSession();
-  }
-}
+      console.log(
+        `[HTTP Client] Started streaming logs for process ${processId}`
+      );
 
-// Convenience function for quick streaming file moving
-export async function quickMoveFileStream(
-  sourcePath: string,
-  destinationPath: string,
-  options?: HttpClientOptions
-): Promise<void> {
-  const client = createClient(options);
-  await client.createSession();
-
-  try {
-    await client.moveFileStream(sourcePath, destinationPath);
-  } finally {
-    client.clearSession();
+      return response.body;
+    } catch (error) {
+      console.error("[HTTP Client] Error streaming process logs:", error);
+      throw error;
+    }
   }
 }