freestyle-sandboxes 0.0.68 → 0.0.70

package/dist/index.cjs

@@ -57,6 +57,42 @@ const handleEphemeralDevServer = (options) => {
     url: "/ephemeral/v1/dev-servers"
   });
 };
+const handleExecOnEphemeralDevServer = (options) => {
+  return (options?.client ?? client).post({
+    ...options,
+    url: "/ephemeral/v1/dev-servers/exec"
+  });
+};
+const handleWriteFileFromEphemeralDevServer = (options) => {
+  return (options?.client ?? client).put({
+    ...options,
+    url: "/ephemeral/v1/dev-servers/files/{*filepath}"
+  });
+};
+const handleReadFileFromEphemeralDevServer = (options) => {
+  return (options?.client ?? client).post({
+    ...options,
+    url: "/ephemeral/v1/dev-servers/files/{*filepath}"
+  });
+};
+const handleGitCommitPush = (options) => {
+  return (options?.client ?? client).post({
+    ...options,
+    url: "/ephemeral/v1/dev-servers/git/commit-push"
+  });
+};
+const handleShutdownDevServer = (options) => {
+  return (options?.client ?? client).post({
+    ...options,
+    url: "/ephemeral/v1/dev-servers/shutdown"
+  });
+};
+const handleDevServerStatus = (options) => {
+  return (options?.client ?? client).get({
+    ...options,
+    url: "/ephemeral/v1/dev-servers/status"
+  });
+};
 const handleListExecuteRuns = (options) => {
   return (options?.client ?? client).get({
     ...options,
@@ -192,7 +228,17 @@ const handleListWebDeploys = (options) => {
 
 class FreestyleSandboxes {
   client;
+  options;
   constructor(options) {
+    this.options = options ?? {};
+    if (!options?.apiKey) {
+      this.options.apiKey = process.env.FREESTYLE_API_KEY;
+    }
+    if (!this.options.apiKey) {
+      throw new Error(
+        "No API key provided. Please set the FREESTYLE_API_KEY environment variable or configure apiKey when constructing FreestyleSandboxes."
+      );
+    }
     if (typeof Deno !== "undefined") {
       class FreestyleRequest extends Request {
         constructor(input, init) {
@@ -206,10 +252,10 @@ class FreestyleSandboxes {
       Request = FreestyleRequest;
     }
     this.client = clientFetch.createClient({
-      baseUrl: options.baseUrl ?? "https://api.freestyle.sh",
+      baseUrl: this.options?.baseUrl ?? "https://api.freestyle.sh",
       headers: {
-        Authorization: `Bearer ${options.apiKey}`,
-        ...options.headers
+        Authorization: `Bearer ${this.options.apiKey}`,
+        ...this.options?.headers
       }
     });
   }
@@ -797,7 +843,7 @@ ${response.error.message}`);
       );
     }
     if (response.data.isNew) {
-      const rId = options.repoId || options.repoUrl.split("/").at(-1);
+      const rId = options.repoId || options.repoUrl?.split("/").at(-1);
       await this.createGitTrigger({
         repoId: rId,
         action: {
@@ -815,17 +861,208 @@ ${response.error.message}`);
     if (!response.data) {
       throw new Error(`Failed to request dev server: ${response.error}`);
     }
+    const data = response.data;
+    const devServerInstance = {
+      repoId: options.repoId || options.repo || "",
+      kind: "repo"
+    };
+    const client = this.client;
+    const that = this;
     return {
-      ...response.data,
-      // @ts-ignore
-      mcpEphemeralUrl: response.data.mcpEphemeralUrl || response.data.url + "/mcp",
-      ephemeralUrl: response.data.ephemeralUrl ?? response.data.url,
-      codeServerUrl: (
-        // @ts-ignore
-        response.data.codeServerUrl ?? response.data.ephemeralUrl + "/__freestyle_code_server/?folder=/template"
-      )
+      isNew: data.isNew,
+      ephemeralUrl: data.ephemeralUrl ?? data.url,
+      mcpEphemeralUrl: data.mcpEphemeralUrl ?? data.url + "/mcp",
+      codeServerUrl: data.codeServerUrl ?? (data.ephemeralUrl ?? data.url) + "/__freestyle_code_server/?folder=/template",
+      async status() {
+        const response2 = await handleDevServerStatus({
+          client,
+          body: {
+            devServer: devServerInstance
+          }
+        });
+        if (response2.error) {
+          throw new Error(`Failed to get status: ${response2.error}`);
+        }
+        return {
+          installing: response2.data.installing,
+          devRunning: response2.data.devRunning
+        };
+      },
+      async commitAndPush(message) {
+        const response2 = await handleGitCommitPush({
+          client,
+          body: {
+            devServer: devServerInstance,
+            message
+          }
+        });
+        if (response2.error) {
+          throw new Error(`Failed to commit and push: ${response2.error}`);
+        }
+      },
+      async shutdown() {
+        const response2 = await handleShutdownDevServer({
+          client,
+          body: {
+            devServer: devServerInstance
+          }
+        });
+        if (response2.error) {
+          throw new Error(`Failed to shutdown dev server: ${response2.error}`);
+        }
+        return {
+          success: response2.data.success,
+          message: response2.data.message
+        };
+      },
+      fs: {
+        async ls(path = "") {
+          const response2 = await handleReadFileFromEphemeralDevServer({
+            client,
+            path: {
+              filepath: path
+            },
+            body: {
+              devServer: devServerInstance,
+              encoding: "utf-8"
+            }
+          });
+          if (response2.error) {
+            throw new Error(`Failed to list directory: ${response2.error}`);
+          }
+          if (!response2.data?.content) {
+            return [];
+          }
+          if (response2.data.content.kind === "directory") {
+            return response2.data.content.files;
+          }
+          return [];
+        },
+        async *watch() {
+          const response2 = await that.fetch(
+            "/ephemeral/v1/dev-servers/watch-files",
+            {
+              method: "POST",
+              body: JSON.stringify({
+                devServer: {
+                  repoId: devServerInstance.repoId,
+                  kind: devServerInstance.kind
+                }
+              })
+            }
+          );
+          if (!response2.ok) {
+            throw new Error(
+              `Failed to fetch stream: ${response2.status} ${response2.statusText}`
+            );
+          }
+          if (!response2.body) {
+            throw new Error("Failed to fetch stream: No response body");
+          }
+          const reader = response2.body.getReader();
+          const decoder = new TextDecoder("utf-8");
+          let buffer = "";
+          while (true) {
+            const { done, value } = await reader.read();
+            if (done) break;
+            buffer += decoder.decode(value, { stream: true });
+            let newlineIndex;
+            while ((newlineIndex = buffer.indexOf("\n")) >= 0) {
+              const line = buffer.slice(0, newlineIndex).trim();
+              buffer = buffer.slice(newlineIndex + 1);
+              if (line) {
+                yield JSON.parse(line);
+              }
+            }
+          }
+          if (buffer.trim()) {
+            yield JSON.parse(buffer.trim());
+          }
+        },
+        async readFile(path, encoding = "utf-8") {
+          const response2 = await handleReadFileFromEphemeralDevServer({
+            client,
+            path: {
+              filepath: path
+            },
+            body: {
+              devServer: devServerInstance,
+              encoding
+            }
+          });
+          if (response2.error) {
+            throw new Error(`Failed to read file: ${response2.error}`);
+          }
+          if (!response2.data?.content || response2.data.content.kind !== "file") {
+            throw new Error(`Not a file or file not found: ${path}`);
+          }
+          return response2.data.content.content;
+        },
+        async writeFile(path, content, encoding = "utf-8") {
+          const contentStr = typeof content === "string" ? content : new TextDecoder(encoding).decode(content);
+          const response2 = await handleWriteFileFromEphemeralDevServer({
+            client,
+            path: {
+              filepath: path
+            },
+            body: {
+              devServer: devServerInstance,
+              content: contentStr,
+              encoding
+            }
+          });
+          if (response2.error) {
+            throw new Error(`Failed to write file: ${response2.error}`);
+          }
+        }
+      },
+      process: {
+        async exec(cmd, background = false) {
+          const response2 = await handleExecOnEphemeralDevServer(
+            {
+              client,
+              body: {
+                devServer: devServerInstance,
+                command: cmd,
+                background
+              }
+            }
+          );
+          if (response2.error) {
+            throw new Error(`Failed to execute command: ${response2.error}`);
+          }
+          return {
+            id: response2.data.id,
+            isNew: response2.data.isNew,
+            stdout: response2.data.stdout,
+            stderr: response2.data.stderr
+          };
+        }
+      }
     };
   }
+  fetch(path, init) {
+    const headers = new Headers(init?.headers);
+    for (const [key, value] of Object.entries(this.options.headers ?? {})) {
+      if (!headers.has(key)) {
+        headers.append(key, value);
+      }
+    }
+    if (!headers.has("Authorization")) {
+      headers.append("Authorization", `Bearer ${this.options.apiKey}`);
+    }
+    if (!headers.has("Content-Type")) {
+      headers.append("Content-Type", "application/json");
+    }
+    const url = new URL(
+      path,
+      this.options.baseUrl ?? "https://api.freestyle.sh"
+    );
+    return fetch(url, {
+      ...init ?? {},
+      headers
+    });
+  }
 }
 
 exports.FreestyleSandboxes = FreestyleSandboxes;