@cloudflare/sandbox 0.0.8 → 0.1.0

package/dist/chunk-7WZJ3TRE.js

@@ -1,1364 +0,0 @@
-// 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;
-    }
-  }
-  // Public methods to set event handlers
-  setOnOutput(handler) {
-    this.options.onOutput = handler;
-  }
-  setOnCommandComplete(handler) {
-    this.options.onCommandComplete = handler;
-  }
-  setOnStreamEvent(handler) {
-    this.options.onStreamEvent = handler;
-  }
-  // Public getter methods
-  getOnOutput() {
-    return this.options.onOutput;
-  }
-  getOnCommandComplete() {
-    return this.options.onCommandComplete;
-  }
-  getOnStreamEvent() {
-    return this.options.onStreamEvent;
-  }
-  async createSession() {
-    try {
-      const response = await this.doFetch(`/api/session/create`, {
-        headers: {
-          "Content-Type": "application/json"
-        },
-        method: "POST"
-      });
-      if (!response.ok) {
-        throw new Error(`HTTP error! status: ${response.status}`);
-      }
-      const data = await response.json();
-      this.sessionId = data.sessionId;
-      console.log(`[HTTP Client] Created session: ${this.sessionId}`);
-      return this.sessionId;
-    } catch (error) {
-      console.error("[HTTP Client] Error creating session:", error);
-      throw error;
-    }
-  }
-  async listSessions() {
-    try {
-      const response = await this.doFetch(`/api/session/list`, {
-        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] Listed ${data.count} sessions`);
-      return data;
-    } catch (error) {
-      console.error("[HTTP Client] Error listing sessions:", error);
-      throw error;
-    }
-  }
-  async execute(command, args = [], sessionId) {
-    try {
-      const targetSessionId = sessionId || this.sessionId;
-      const response = await this.doFetch(`/api/execute`, {
-        body: JSON.stringify({
-          args,
-          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,
-        data.args
-      );
-      return data;
-    } catch (error) {
-      console.error("[HTTP Client] Error executing command:", error);
-      this.options.onError?.(
-        error instanceof Error ? error.message : "Unknown error",
-        command,
-        args
-      );
-      throw error;
-    }
-  }
-  async executeStream(command, args = [], sessionId) {
-    try {
-      const targetSessionId = sessionId || this.sessionId;
-      const response = await this.doFetch(`/api/execute/stream`, {
-        body: JSON.stringify({
-          args,
-          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}`
-        );
-      }
-      if (!response.body) {
-        throw new Error("No response body for streaming request");
-      }
-      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);
-                const event = 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
-      );
-      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 gitCheckoutStream(repoUrl, branch = "main", targetDir, sessionId) {
-    try {
-      const targetSessionId = sessionId || this.sessionId;
-      const response = await this.doFetch(`/api/git/checkout/stream`, {
-        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}`
-        );
-      }
-      if (!response.body) {
-        throw new Error("No response body for streaming request");
-      }
-      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);
-                const event = 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();
-      }
-    } 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 || ""]
-      );
-      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 mkdirStream(path, recursive = false, sessionId) {
-    try {
-      const targetSessionId = sessionId || this.sessionId;
-      const response = await this.doFetch(`/api/mkdir/stream`, {
-        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}`
-        );
-      }
-      if (!response.body) {
-        throw new Error("No response body for streaming request");
-      }
-      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);
-                const event = 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();
-      }
-    } 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]
-      );
-      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 writeFileStream(path, content, encoding = "utf-8", sessionId) {
-    try {
-      const targetSessionId = sessionId || this.sessionId;
-      const response = await this.doFetch(`/api/write/stream`, {
-        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}`
-        );
-      }
-      if (!response.body) {
-        throw new Error("No response body for streaming request");
-      }
-      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);
-                const event = 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();
-      }
-    } 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]
-      );
-      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 readFileStream(path, encoding = "utf-8", sessionId) {
-    try {
-      const targetSessionId = sessionId || this.sessionId;
-      const response = await this.doFetch(`/api/read/stream`, {
-        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}`
-        );
-      }
-      if (!response.body) {
-        throw new Error("No response body for streaming request");
-      }
-      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);
-                const event = JSON.parse(eventData);
-                console.log(
-                  `[HTTP Client] Read file stream event: ${event.type}`
-                );
-                this.options.onStreamEvent?.(event);
-                switch (event.type) {
-                  case "command_start":
-                    console.log(
-                      `[HTTP Client] Read file started: ${event.path}`
-                    );
-                    this.options.onCommandStart?.("read", [path, encoding]);
-                    break;
-                  case "command_complete":
-                    console.log(
-                      `[HTTP Client] Read file completed: ${event.path}, Success: ${event.success}, Content length: ${event.content?.length || 0}`
-                    );
-                    this.options.onCommandComplete?.(
-                      event.success,
-                      0,
-                      event.content || "",
-                      "",
-                      "read",
-                      [path, encoding]
-                    );
-                    break;
-                  case "error":
-                    console.error(
-                      `[HTTP Client] Read file error: ${event.error}`
-                    );
-                    this.options.onError?.(event.error, "read", [
-                      path,
-                      encoding
-                    ]);
-                    break;
-                }
-              } catch (parseError) {
-                console.warn(
-                  "[HTTP Client] Failed to parse read file stream event:",
-                  parseError
-                );
-              }
-            }
-          }
-        }
-      } finally {
-        reader.releaseLock();
-      }
-    } catch (error) {
-      console.error("[HTTP Client] Error in streaming read file:", error);
-      this.options.onError?.(
-        error instanceof Error ? error.message : "Unknown error",
-        "read",
-        [path, encoding]
-      );
-      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 deleteFileStream(path, sessionId) {
-    try {
-      const targetSessionId = sessionId || this.sessionId;
-      const response = await this.doFetch(`/api/delete/stream`, {
-        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}`
-        );
-      }
-      if (!response.body) {
-        throw new Error("No response body for streaming request");
-      }
-      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);
-                const event = 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();
-      }
-    } catch (error) {
-      console.error("[HTTP Client] Error in streaming delete file:", error);
-      this.options.onError?.(
-        error instanceof Error ? error.message : "Unknown error",
-        "delete",
-        [path]
-      );
-      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 renameFileStream(oldPath, newPath, sessionId) {
-    try {
-      const targetSessionId = sessionId || this.sessionId;
-      const response = await this.doFetch(`/api/rename/stream`, {
-        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}`
-        );
-      }
-      if (!response.body) {
-        throw new Error("No response body for streaming request");
-      }
-      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);
-                const event = 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();
-      }
-    } 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]
-      );
-      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 moveFileStream(sourcePath, destinationPath, sessionId) {
-    try {
-      const targetSessionId = sessionId || this.sessionId;
-      const response = await this.doFetch(`/api/move/stream`, {
-        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}`
-        );
-      }
-      if (!response.body) {
-        throw new Error("No response body for streaming request");
-      }
-      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);
-                const event = 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();
-      }
-    } 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]
-      );
-      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;
-  }
-};
-function createClient(options) {
-  return new HttpClient(options);
-}
-async function quickExecute(command, args = [], options) {
-  const client = createClient(options);
-  await client.createSession();
-  try {
-    return await client.execute(command, args);
-  } finally {
-    client.clearSession();
-  }
-}
-async function quickExecuteStream(command, args = [], options) {
-  const client = createClient(options);
-  await client.createSession();
-  try {
-    await client.executeStream(command, args);
-  } finally {
-    client.clearSession();
-  }
-}
-async function quickGitCheckout(repoUrl, branch = "main", targetDir, options) {
-  const client = createClient(options);
-  await client.createSession();
-  try {
-    return await client.gitCheckout(repoUrl, branch, targetDir);
-  } finally {
-    client.clearSession();
-  }
-}
-async function quickMkdir(path, recursive = false, options) {
-  const client = createClient(options);
-  await client.createSession();
-  try {
-    return await client.mkdir(path, recursive);
-  } finally {
-    client.clearSession();
-  }
-}
-async function quickGitCheckoutStream(repoUrl, branch = "main", targetDir, options) {
-  const client = createClient(options);
-  await client.createSession();
-  try {
-    await client.gitCheckoutStream(repoUrl, branch, targetDir);
-  } finally {
-    client.clearSession();
-  }
-}
-async function quickMkdirStream(path, recursive = false, options) {
-  const client = createClient(options);
-  await client.createSession();
-  try {
-    await client.mkdirStream(path, recursive);
-  } finally {
-    client.clearSession();
-  }
-}
-async function quickWriteFile(path, content, encoding = "utf-8", options) {
-  const client = createClient(options);
-  await client.createSession();
-  try {
-    return await client.writeFile(path, content, encoding);
-  } finally {
-    client.clearSession();
-  }
-}
-async function quickWriteFileStream(path, content, encoding = "utf-8", options) {
-  const client = createClient(options);
-  await client.createSession();
-  try {
-    await client.writeFileStream(path, content, encoding);
-  } finally {
-    client.clearSession();
-  }
-}
-async function quickReadFile(path, encoding = "utf-8", options) {
-  const client = createClient(options);
-  await client.createSession();
-  try {
-    return await client.readFile(path, encoding);
-  } finally {
-    client.clearSession();
-  }
-}
-async function quickReadFileStream(path, encoding = "utf-8", options) {
-  const client = createClient(options);
-  await client.createSession();
-  try {
-    await client.readFileStream(path, encoding);
-  } finally {
-    client.clearSession();
-  }
-}
-async function quickDeleteFile(path, options) {
-  const client = createClient(options);
-  await client.createSession();
-  try {
-    return await client.deleteFile(path);
-  } finally {
-    client.clearSession();
-  }
-}
-async function quickDeleteFileStream(path, options) {
-  const client = createClient(options);
-  await client.createSession();
-  try {
-    await client.deleteFileStream(path);
-  } finally {
-    client.clearSession();
-  }
-}
-async function quickRenameFile(oldPath, newPath, options) {
-  const client = createClient(options);
-  await client.createSession();
-  try {
-    return await client.renameFile(oldPath, newPath);
-  } finally {
-    client.clearSession();
-  }
-}
-async function quickRenameFileStream(oldPath, newPath, options) {
-  const client = createClient(options);
-  await client.createSession();
-  try {
-    await client.renameFileStream(oldPath, newPath);
-  } finally {
-    client.clearSession();
-  }
-}
-async function quickMoveFile(sourcePath, destinationPath, options) {
-  const client = createClient(options);
-  await client.createSession();
-  try {
-    return await client.moveFile(sourcePath, destinationPath);
-  } finally {
-    client.clearSession();
-  }
-}
-async function quickMoveFileStream(sourcePath, destinationPath, options) {
-  const client = createClient(options);
-  await client.createSession();
-  try {
-    await client.moveFileStream(sourcePath, destinationPath);
-  } finally {
-    client.clearSession();
-  }
-}
-
-export {
-  HttpClient,
-  createClient,
-  quickExecute,
-  quickExecuteStream,
-  quickGitCheckout,
-  quickMkdir,
-  quickGitCheckoutStream,
-  quickMkdirStream,
-  quickWriteFile,
-  quickWriteFileStream,
-  quickReadFile,
-  quickReadFileStream,
-  quickDeleteFile,
-  quickDeleteFileStream,
-  quickRenameFile,
-  quickRenameFileStream,
-  quickMoveFile,
-  quickMoveFileStream
-};
-//# sourceMappingURL=chunk-7WZJ3TRE.js.map