@cloudflare/sandbox 0.0.8 → 0.1.0

package/dist/chunk-G4XT4SP7.js

@@ -0,0 +1,638 @@
+// src/client.ts
+var HttpClient = class {
+  baseUrl;
+  options;
+  sessionId = null;
+  constructor(options = {}) {
+    this.options = {
+      ...options
+    };
+    this.baseUrl = this.options.baseUrl;
+  }
+  async doFetch(path, options) {
+    const url = this.options.stub ? `http://localhost:${this.options.port}${path}` : `${this.baseUrl}${path}`;
+    const method = options?.method || "GET";
+    console.log(`[HTTP Client] Making ${method} request to ${url}`);
+    try {
+      let response;
+      if (this.options.stub) {
+        response = await this.options.stub.containerFetch(
+          url,
+          options,
+          this.options.port
+        );
+      } else {
+        response = await fetch(url, options);
+      }
+      console.log(
+        `[HTTP Client] Response: ${response.status} ${response.statusText}`
+      );
+      if (!response.ok) {
+        console.error(
+          `[HTTP Client] Request failed: ${method} ${url} - ${response.status} ${response.statusText}`
+        );
+      }
+      return response;
+    } catch (error) {
+      console.error(`[HTTP Client] Request error: ${method} ${url}`, error);
+      throw error;
+    }
+  }
+  async execute(command, sessionId) {
+    try {
+      const targetSessionId = sessionId || this.sessionId;
+      const response = await this.doFetch(`/api/execute`, {
+        body: JSON.stringify({
+          command,
+          sessionId: targetSessionId
+        }),
+        headers: {
+          "Content-Type": "application/json"
+        },
+        method: "POST"
+      });
+      if (!response.ok) {
+        const errorData = await response.json().catch(() => ({}));
+        throw new Error(
+          errorData.error || `HTTP error! status: ${response.status}`
+        );
+      }
+      const data = await response.json();
+      console.log(
+        `[HTTP Client] Command executed: ${command}, Success: ${data.success}`
+      );
+      this.options.onCommandComplete?.(
+        data.success,
+        data.exitCode,
+        data.stdout,
+        data.stderr,
+        data.command
+      );
+      return data;
+    } catch (error) {
+      console.error("[HTTP Client] Error executing command:", error);
+      this.options.onError?.(
+        error instanceof Error ? error.message : "Unknown error",
+        command
+      );
+      throw error;
+    }
+  }
+  async executeCommandStream(command, sessionId) {
+    try {
+      const targetSessionId = sessionId || this.sessionId;
+      const response = await this.doFetch(`/api/execute/stream`, {
+        body: JSON.stringify({
+          command,
+          sessionId: targetSessionId
+        }),
+        headers: {
+          "Content-Type": "application/json",
+          "Accept": "text/event-stream"
+        },
+        method: "POST"
+      });
+      if (!response.ok) {
+        const errorData = await response.json().catch(() => ({}));
+        throw new Error(
+          errorData.error || `HTTP error! status: ${response.status}`
+        );
+      }
+      if (!response.body) {
+        throw new Error("No response body for streaming request");
+      }
+      console.log(
+        `[HTTP Client] Started command stream: ${command}`
+      );
+      return response.body;
+    } catch (error) {
+      console.error("[HTTP Client] Error in command stream:", error);
+      throw error;
+    }
+  }
+  async gitCheckout(repoUrl, branch = "main", targetDir, sessionId) {
+    try {
+      const targetSessionId = sessionId || this.sessionId;
+      const response = await this.doFetch(`/api/git/checkout`, {
+        body: JSON.stringify({
+          branch,
+          repoUrl,
+          sessionId: targetSessionId,
+          targetDir
+        }),
+        headers: {
+          "Content-Type": "application/json"
+        },
+        method: "POST"
+      });
+      if (!response.ok) {
+        const errorData = await response.json().catch(() => ({}));
+        throw new Error(
+          errorData.error || `HTTP error! status: ${response.status}`
+        );
+      }
+      const data = await response.json();
+      console.log(
+        `[HTTP Client] Git checkout completed: ${repoUrl}, Success: ${data.success}, Target: ${data.targetDir}`
+      );
+      return data;
+    } catch (error) {
+      console.error("[HTTP Client] Error in git checkout:", error);
+      throw error;
+    }
+  }
+  async mkdir(path, recursive = false, sessionId) {
+    try {
+      const targetSessionId = sessionId || this.sessionId;
+      const response = await this.doFetch(`/api/mkdir`, {
+        body: JSON.stringify({
+          path,
+          recursive,
+          sessionId: targetSessionId
+        }),
+        headers: {
+          "Content-Type": "application/json"
+        },
+        method: "POST"
+      });
+      if (!response.ok) {
+        const errorData = await response.json().catch(() => ({}));
+        throw new Error(
+          errorData.error || `HTTP error! status: ${response.status}`
+        );
+      }
+      const data = await response.json();
+      console.log(
+        `[HTTP Client] Directory created: ${path}, Success: ${data.success}, Recursive: ${data.recursive}`
+      );
+      return data;
+    } catch (error) {
+      console.error("[HTTP Client] Error creating directory:", error);
+      throw error;
+    }
+  }
+  async writeFile(path, content, encoding = "utf-8", sessionId) {
+    try {
+      const targetSessionId = sessionId || this.sessionId;
+      const response = await this.doFetch(`/api/write`, {
+        body: JSON.stringify({
+          content,
+          encoding,
+          path,
+          sessionId: targetSessionId
+        }),
+        headers: {
+          "Content-Type": "application/json"
+        },
+        method: "POST"
+      });
+      if (!response.ok) {
+        const errorData = await response.json().catch(() => ({}));
+        throw new Error(
+          errorData.error || `HTTP error! status: ${response.status}`
+        );
+      }
+      const data = await response.json();
+      console.log(
+        `[HTTP Client] File written: ${path}, Success: ${data.success}`
+      );
+      return data;
+    } catch (error) {
+      console.error("[HTTP Client] Error writing file:", error);
+      throw error;
+    }
+  }
+  async readFile(path, encoding = "utf-8", sessionId) {
+    try {
+      const targetSessionId = sessionId || this.sessionId;
+      const response = await this.doFetch(`/api/read`, {
+        body: JSON.stringify({
+          encoding,
+          path,
+          sessionId: targetSessionId
+        }),
+        headers: {
+          "Content-Type": "application/json"
+        },
+        method: "POST"
+      });
+      if (!response.ok) {
+        const errorData = await response.json().catch(() => ({}));
+        throw new Error(
+          errorData.error || `HTTP error! status: ${response.status}`
+        );
+      }
+      const data = await response.json();
+      console.log(
+        `[HTTP Client] File read: ${path}, Success: ${data.success}, Content length: ${data.content.length}`
+      );
+      return data;
+    } catch (error) {
+      console.error("[HTTP Client] Error reading file:", error);
+      throw error;
+    }
+  }
+  async deleteFile(path, sessionId) {
+    try {
+      const targetSessionId = sessionId || this.sessionId;
+      const response = await this.doFetch(`/api/delete`, {
+        body: JSON.stringify({
+          path,
+          sessionId: targetSessionId
+        }),
+        headers: {
+          "Content-Type": "application/json"
+        },
+        method: "POST"
+      });
+      if (!response.ok) {
+        const errorData = await response.json().catch(() => ({}));
+        throw new Error(
+          errorData.error || `HTTP error! status: ${response.status}`
+        );
+      }
+      const data = await response.json();
+      console.log(
+        `[HTTP Client] File deleted: ${path}, Success: ${data.success}`
+      );
+      return data;
+    } catch (error) {
+      console.error("[HTTP Client] Error deleting file:", error);
+      throw error;
+    }
+  }
+  async renameFile(oldPath, newPath, sessionId) {
+    try {
+      const targetSessionId = sessionId || this.sessionId;
+      const response = await this.doFetch(`/api/rename`, {
+        body: JSON.stringify({
+          newPath,
+          oldPath,
+          sessionId: targetSessionId
+        }),
+        headers: {
+          "Content-Type": "application/json"
+        },
+        method: "POST"
+      });
+      if (!response.ok) {
+        const errorData = await response.json().catch(() => ({}));
+        throw new Error(
+          errorData.error || `HTTP error! status: ${response.status}`
+        );
+      }
+      const data = await response.json();
+      console.log(
+        `[HTTP Client] File renamed: ${oldPath} -> ${newPath}, Success: ${data.success}`
+      );
+      return data;
+    } catch (error) {
+      console.error("[HTTP Client] Error renaming file:", error);
+      throw error;
+    }
+  }
+  async moveFile(sourcePath, destinationPath, sessionId) {
+    try {
+      const targetSessionId = sessionId || this.sessionId;
+      const response = await this.doFetch(`/api/move`, {
+        body: JSON.stringify({
+          destinationPath,
+          sessionId: targetSessionId,
+          sourcePath
+        }),
+        headers: {
+          "Content-Type": "application/json"
+        },
+        method: "POST"
+      });
+      if (!response.ok) {
+        const errorData = await response.json().catch(() => ({}));
+        throw new Error(
+          errorData.error || `HTTP error! status: ${response.status}`
+        );
+      }
+      const data = await response.json();
+      console.log(
+        `[HTTP Client] File moved: ${sourcePath} -> ${destinationPath}, Success: ${data.success}`
+      );
+      return data;
+    } catch (error) {
+      console.error("[HTTP Client] Error moving file:", error);
+      throw error;
+    }
+  }
+  async exposePort(port, name) {
+    try {
+      const response = await this.doFetch(`/api/expose-port`, {
+        body: JSON.stringify({
+          port,
+          name
+        }),
+        headers: {
+          "Content-Type": "application/json"
+        },
+        method: "POST"
+      });
+      if (!response.ok) {
+        const errorData = await response.json().catch(() => ({}));
+        console.log(errorData);
+        throw new Error(
+          errorData.error || `HTTP error! status: ${response.status}`
+        );
+      }
+      const data = await response.json();
+      console.log(
+        `[HTTP Client] Port exposed: ${port}${name ? ` (${name})` : ""}, Success: ${data.success}`
+      );
+      return data;
+    } catch (error) {
+      console.error("[HTTP Client] Error exposing port:", error);
+      throw error;
+    }
+  }
+  async unexposePort(port) {
+    try {
+      const response = await this.doFetch(`/api/unexpose-port`, {
+        body: JSON.stringify({
+          port
+        }),
+        headers: {
+          "Content-Type": "application/json"
+        },
+        method: "DELETE"
+      });
+      if (!response.ok) {
+        const errorData = await response.json().catch(() => ({}));
+        throw new Error(
+          errorData.error || `HTTP error! status: ${response.status}`
+        );
+      }
+      const data = await response.json();
+      console.log(
+        `[HTTP Client] Port unexposed: ${port}, Success: ${data.success}`
+      );
+      return data;
+    } catch (error) {
+      console.error("[HTTP Client] Error unexposing port:", error);
+      throw error;
+    }
+  }
+  async getExposedPorts() {
+    try {
+      const response = await this.doFetch(`/api/exposed-ports`, {
+        headers: {
+          "Content-Type": "application/json"
+        },
+        method: "GET"
+      });
+      if (!response.ok) {
+        const errorData = await response.json().catch(() => ({}));
+        throw new Error(
+          errorData.error || `HTTP error! status: ${response.status}`
+        );
+      }
+      const data = await response.json();
+      console.log(
+        `[HTTP Client] Got ${data.count} exposed ports`
+      );
+      return data;
+    } catch (error) {
+      console.error("[HTTP Client] Error getting exposed ports:", error);
+      throw error;
+    }
+  }
+  async ping() {
+    try {
+      const response = await this.doFetch(`/api/ping`, {
+        headers: {
+          "Content-Type": "application/json"
+        },
+        method: "GET"
+      });
+      if (!response.ok) {
+        throw new Error(`HTTP error! status: ${response.status}`);
+      }
+      const data = 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;
+    }
+  }
+  async getCommands() {
+    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 = 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() {
+    return this.sessionId;
+  }
+  setSessionId(sessionId) {
+    this.sessionId = sessionId;
+  }
+  clearSession() {
+    this.sessionId = null;
+  }
+  // Process management methods
+  async startProcess(command, options) {
+    try {
+      const targetSessionId = options?.sessionId || this.sessionId;
+      const response = await this.doFetch("/api/process/start", {
+        body: JSON.stringify({
+          command,
+          options: {
+            ...options,
+            sessionId: targetSessionId
+          }
+        }),
+        headers: {
+          "Content-Type": "application/json"
+        },
+        method: "POST"
+      });
+      if (!response.ok) {
+        const errorData = await response.json().catch(() => ({}));
+        throw new Error(
+          errorData.error || `HTTP error! status: ${response.status}`
+        );
+      }
+      const data = await response.json();
+      console.log(
+        `[HTTP Client] Process started: ${command}, ID: ${data.process.id}`
+      );
+      return data;
+    } catch (error) {
+      console.error("[HTTP Client] Error starting process:", error);
+      throw error;
+    }
+  }
+  async listProcesses() {
+    try {
+      const response = await this.doFetch("/api/process/list", {
+        headers: {
+          "Content-Type": "application/json"
+        },
+        method: "GET"
+      });
+      if (!response.ok) {
+        const errorData = await response.json().catch(() => ({}));
+        throw new Error(
+          errorData.error || `HTTP error! status: ${response.status}`
+        );
+      }
+      const data = await response.json();
+      console.log(
+        `[HTTP Client] Listed ${data.processes.length} processes`
+      );
+      return data;
+    } catch (error) {
+      console.error("[HTTP Client] Error listing processes:", error);
+      throw error;
+    }
+  }
+  async getProcess(processId) {
+    try {
+      const response = await this.doFetch(`/api/process/${processId}`, {
+        headers: {
+          "Content-Type": "application/json"
+        },
+        method: "GET"
+      });
+      if (!response.ok) {
+        const errorData = await response.json().catch(() => ({}));
+        throw new Error(
+          errorData.error || `HTTP error! status: ${response.status}`
+        );
+      }
+      const data = await response.json();
+      console.log(
+        `[HTTP Client] Got process ${processId}: ${data.process?.status || "not found"}`
+      );
+      return data;
+    } catch (error) {
+      console.error("[HTTP Client] Error getting process:", error);
+      throw error;
+    }
+  }
+  async killProcess(processId) {
+    try {
+      const response = await this.doFetch(`/api/process/${processId}`, {
+        headers: {
+          "Content-Type": "application/json"
+        },
+        method: "DELETE"
+      });
+      if (!response.ok) {
+        const errorData = await response.json().catch(() => ({}));
+        throw new Error(
+          errorData.error || `HTTP error! status: ${response.status}`
+        );
+      }
+      const data = await response.json();
+      console.log(
+        `[HTTP Client] Killed process ${processId}`
+      );
+      return data;
+    } catch (error) {
+      console.error("[HTTP Client] Error killing process:", error);
+      throw error;
+    }
+  }
+  async killAllProcesses() {
+    try {
+      const response = await this.doFetch("/api/process/kill-all", {
+        headers: {
+          "Content-Type": "application/json"
+        },
+        method: "DELETE"
+      });
+      if (!response.ok) {
+        const errorData = await response.json().catch(() => ({}));
+        throw new Error(
+          errorData.error || `HTTP error! status: ${response.status}`
+        );
+      }
+      const data = await response.json();
+      console.log(
+        `[HTTP Client] Killed ${data.killedCount} processes`
+      );
+      return data;
+    } catch (error) {
+      console.error("[HTTP Client] Error killing all processes:", error);
+      throw error;
+    }
+  }
+  async getProcessLogs(processId) {
+    try {
+      const response = await this.doFetch(`/api/process/${processId}/logs`, {
+        headers: {
+          "Content-Type": "application/json"
+        },
+        method: "GET"
+      });
+      if (!response.ok) {
+        const errorData = await response.json().catch(() => ({}));
+        throw new Error(
+          errorData.error || `HTTP error! status: ${response.status}`
+        );
+      }
+      const data = await response.json();
+      console.log(
+        `[HTTP Client] Got logs for process ${processId}`
+      );
+      return data;
+    } catch (error) {
+      console.error("[HTTP Client] Error getting process logs:", error);
+      throw error;
+    }
+  }
+  async streamProcessLogs(processId) {
+    try {
+      const response = await this.doFetch(`/api/process/${processId}/stream`, {
+        headers: {
+          "Accept": "text/event-stream",
+          "Cache-Control": "no-cache"
+        },
+        method: "GET"
+      });
+      if (!response.ok) {
+        const errorData = await response.json().catch(() => ({}));
+        throw new Error(
+          errorData.error || `HTTP error! status: ${response.status}`
+        );
+      }
+      if (!response.body) {
+        throw new Error("No response body for streaming request");
+      }
+      console.log(
+        `[HTTP Client] Started streaming logs for process ${processId}`
+      );
+      return response.body;
+    } catch (error) {
+      console.error("[HTTP Client] Error streaming process logs:", error);
+      throw error;
+    }
+  }
+};
+
+export {
+  HttpClient
+};
+//# sourceMappingURL=chunk-G4XT4SP7.js.map