freestyle-sandboxes 0.0.68 → 0.0.70

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "freestyle-sandboxes",
-  "version": "0.0.68",
+  "version": "0.0.70",
   "type": "module",
   "main": "./dist/index.cjs",
   "module": "./dist/index.mjs",
@@ -108,4 +108,4 @@
     "zod": "^3.24.1"
   },
   "packageManager": "pnpm@9.11.0+sha512.0a203ffaed5a3f63242cd064c8fb5892366c103e328079318f78062f24ea8c9d50bc6a47aa3567cabefd824d170e78fa2745ed1f16b132e16436146b7688f19b"
-}
+}

package/src/dev-server.ts

@@ -0,0 +1,92 @@
+export interface FreestyleDevServer {
+  /**
+   * The URL for the dev server's HTTP API.
+   */
+  ephemeralUrl: string;
+
+  /**
+   * The URL to the MCP endpoint for the dev server.
+   */
+  mcpEphemeralUrl: string;
+
+  /**
+   * The URL for the VSCode server running in the dev server.
+   */
+  codeServerUrl: string;
+
+  /**
+   * Whether the dev server was just created.
+   */
+  isNew: boolean;
+
+  fs: FreestyleDevServerFilesystem;
+
+  process: FreestyleDevServerProcess;
+
+  /**
+   * Get the status of the dev server
+   */
+  status(): Promise<{
+    installing: boolean;
+    devRunning: boolean;
+  }>;
+
+  /**
+   * Commit and push changes to the dev server repository
+   * @param message The commit message
+   */
+  commitAndPush(message: string): Promise<void>;
+
+  /**
+   * Shutdown the dev server
+   */
+  shutdown(): Promise<{
+    success: boolean;
+    message: string;
+  }>;
+}
+
+export interface FreestyleDevServerFilesystem {
+  /**
+   * List files in the dev server directory
+   */
+  ls(path?: string): Promise<Array<string>>;
+
+  /**
+   * Read a file from the dev server
+   * @param path The path to the file
+   * @param encoding The encoding to use (defaults to utf-8)
+   */
+  readFile(path: string, encoding?: string): Promise<string>;
+
+  /**
+   * Write a file to the dev server
+   * @param path The path to write to
+   * @param content The content to write
+   * @param encoding The encoding to use (defaults to utf-8)
+   */
+  writeFile(
+    path: string,
+    content: string | ArrayBufferLike,
+    encoding?: string
+  ): Promise<void>;
+
+  watch(): AsyncGenerator<{ eventType: string; filename: string }>;
+}
+
+export interface FreestyleDevServerProcess {
+  /**
+   * Execute a command on the dev server
+   * @param cmd The command to execute
+   * @param background Whether to run the command in the background
+   */
+  exec(
+    cmd: string,
+    background?: boolean
+  ): Promise<{
+    id: string;
+    isNew: boolean;
+    stdout?: string[];
+    stderr?: string[];
+  }>;
+}

package/src/index.ts

@@ -6,6 +6,7 @@ import type {
   CreatedToken,
   CreateRepositoryResponseSuccess,
   DescribePermissionResponseSuccess,
+  DevServer,
   FreestyleCloudstateDeployRequest,
   FreestyleCloudstateDeploySuccessResponse,
   FreestyleDeployWebConfiguration,
@@ -30,6 +31,7 @@ import type {
   ListGitTokensResponseSuccess,
   ListPermissionResponseSuccess,
 } from "../openapi/index.ts";
+import { FreestyleDevServer } from "./dev-server.ts";
 
 export type {
   AccessLevel,
@@ -62,22 +64,37 @@ export type {
   DeploymentBuildOptions,
 } from "../openapi/index.ts";
 
+type Options = {
+  /**
+   * The base URL for the API.
+   */
+  baseUrl?: string;
+  /**
+   * The API key to use for requests.
+   */
+  apiKey?: string;
+  /**
+   * Custom Headers to be sent with each request.
+   */
+  headers?: Record<string, string>;
+};
+
 export class FreestyleSandboxes {
   private client: Client;
-  constructor(options: {
-    /**
-     * The base URL for the API.
-     */
-    baseUrl?: string;
-    /**
-     * The API key to use for requests.
-     */
-    apiKey: string;
-    /**
-     * Custom Headers to be sent with each request.
-     */
-    headers?: Record<string, string>;
-  }) {
+  options: Options;
+
+  constructor(options?: 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."
+      );
+    }
+
     //@ts-expect-error Deno has a weird behavior thats patched here
     if (typeof Deno !== "undefined") {
       class FreestyleRequest extends Request {
@@ -93,10 +110,10 @@ export class FreestyleSandboxes {
       Request = FreestyleRequest;
     }
     this.client = 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,
       },
     });
   }
@@ -803,10 +820,17 @@ export class FreestyleSandboxes {
      */
     repoUrl?: string;
     repoId?: string;
+    /**
+     * @deprecated
+     */
     repo?: string;
     baseId?: string;
     devCommand?: string;
-  }) {
+    preDevCommandOnce?: string;
+    envVars?: Record<string, string>;
+    computeClass?: string;
+    timeout?: number;
+  }): Promise<FreestyleDevServer> {
     function formatHook(serverUrl: string, repoUrl: string) {
       const hook =
         serverUrl +
@@ -832,7 +856,7 @@ export class FreestyleSandboxes {
     }
 
     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,
@@ -852,19 +876,287 @@ export class FreestyleSandboxes {
     if (!response.data) {
       throw new Error(`Failed to request dev server: ${response.error}`);
     }
+
+    const data: typeof response.data & { codeServerUrl?: string } =
+      response.data;
+
+    const devServerInstance: DevServer = {
+      repoId: options.repoId || options.repo || "",
+      kind: "repo",
+    };
+
+    const client = this.client;
+
+    const that = this;
+
     return {
-      ...response.data,
-      // @ts-ignore
-      mcpEphemeralUrl:
-        (response.data as any).mcpEphemeralUrl || response.data.url + "/mcp",
-      ephemeralUrl: response.data.ephemeralUrl ?? response.data.url,
+      isNew: data.isNew,
+
+      ephemeralUrl: data.ephemeralUrl ?? data.url,
+
+      mcpEphemeralUrl: data.mcpEphemeralUrl ?? data.url + "/mcp",
+
       codeServerUrl:
-        // @ts-ignore
-        response.data.codeServerUrl ??
-        response.data.ephemeralUrl +
+        data.codeServerUrl ??
+        (data.ephemeralUrl ?? data.url) +
           "/__freestyle_code_server/?folder=/template",
+
+      async status() {
+        const response = await sandbox_openapi.handleDevServerStatus({
+          client,
+          body: {
+            devServer: devServerInstance,
+          },
+        });
+
+        if (response.error) {
+          throw new Error(`Failed to get status: ${response.error}`);
+        }
+
+        return {
+          installing: response.data.installing,
+          devRunning: response.data.devRunning,
+        };
+      },
+
+      async commitAndPush(message: string) {
+        const response = await sandbox_openapi.handleGitCommitPush({
+          client,
+          body: {
+            devServer: devServerInstance,
+            message,
+          },
+        });
+
+        if (response.error) {
+          throw new Error(`Failed to commit and push: ${response.error}`);
+        }
+      },
+
+      async shutdown() {
+        const response = await sandbox_openapi.handleShutdownDevServer({
+          client,
+          body: {
+            devServer: devServerInstance,
+          },
+        });
+
+        if (response.error) {
+          throw new Error(`Failed to shutdown dev server: ${response.error}`);
+        }
+
+        return {
+          success: response.data.success,
+          message: response.data.message,
+        };
+      },
+
+      fs: {
+        async ls(path = "") {
+          const response =
+            await sandbox_openapi.handleReadFileFromEphemeralDevServer({
+              client,
+              path: {
+                filepath: path,
+              },
+              body: {
+                devServer: devServerInstance,
+                encoding: "utf-8",
+              },
+            });
+
+          if (response.error) {
+            throw new Error(`Failed to list directory: ${response.error}`);
+          }
+
+          if (!response.data?.content) {
+            return [];
+          }
+
+          if (response.data.content.kind === "directory") {
+            return response.data.content.files;
+          }
+
+          return [];
+        },
+
+        async *watch(): AsyncGenerator<{
+          eventType: string;
+          filename: string;
+        }> {
+          const response = await that.fetch(
+            "/ephemeral/v1/dev-servers/watch-files",
+            {
+              method: "POST",
+              body: JSON.stringify({
+                devServer: {
+                  repoId: devServerInstance.repoId,
+                  kind: devServerInstance.kind,
+                },
+              }),
+            }
+          );
+
+          if (!response.ok) {
+            throw new Error(
+              `Failed to fetch stream: ${response.status} ${response.statusText}`
+            );
+          }
+
+          if (!response.body) {
+            throw new Error("Failed to fetch stream: No response body");
+          }
+
+          const reader = response.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) as {
+                  eventType: string;
+                  filename: string;
+                };
+              }
+            }
+          }
+
+          if (buffer.trim()) {
+            yield JSON.parse(buffer.trim()) as {
+              eventType: string;
+              filename: string;
+            };
+          }
+        },
+
+        async readFile(path: string, encoding = "utf-8") {
+          const response =
+            await sandbox_openapi.handleReadFileFromEphemeralDevServer({
+              client,
+              path: {
+                filepath: path,
+              },
+              body: {
+                devServer: devServerInstance,
+                encoding,
+              },
+            });
+
+          if (response.error) {
+            throw new Error(`Failed to read file: ${response.error}`);
+          }
+
+          if (
+            !response.data?.content ||
+            response.data.content.kind !== "file"
+          ) {
+            throw new Error(`Not a file or file not found: ${path}`);
+          }
+
+          return response.data.content.content;
+        },
+
+        async writeFile(
+          path: string,
+          content: string | ArrayBuffer,
+          encoding = "utf-8"
+        ) {
+          const contentStr =
+            typeof content === "string"
+              ? content
+              : new TextDecoder(encoding).decode(content);
+
+          const response =
+            await sandbox_openapi.handleWriteFileFromEphemeralDevServer({
+              client,
+              path: {
+                filepath: path,
+              },
+              body: {
+                devServer: devServerInstance,
+                content: contentStr,
+                encoding,
+              },
+            });
+
+          if (response.error) {
+            throw new Error(`Failed to write file: ${response.error}`);
+          }
+        },
+      },
+
+      process: {
+        async exec(cmd: string, background = false) {
+          const response = await sandbox_openapi.handleExecOnEphemeralDevServer(
+            {
+              client,
+              body: {
+                devServer: devServerInstance,
+                command: cmd,
+                background,
+              },
+            }
+          );
+
+          if (response.error) {
+            throw new Error(`Failed to execute command: ${response.error}`);
+          }
+
+          return {
+            id: response.data.id,
+            isNew: response.data.isNew,
+            stdout: response.data.stdout,
+            stderr: response.data.stderr,
+          };
+        },
+      },
     };
   }
+
+  fetch(path: string, init?: RequestInit) {
+    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,
+    });
+  }
 }
 
 export * from "../openapi/types.gen.ts";
+
+// const { process, fs } = await api.requestDevServer({
+//   repoId: "test",
+// });
+//
+// await process.exec()
+// await fs.ls()

package/src/react/dev-server/index.tsx

@@ -90,7 +90,7 @@ const FreestyleDevServerInner = React.forwardRef<
   const iframeRef = React.useRef<HTMLIFrameElement>(null);
   const [wasLoaded, setWasLoaded] = React.useState(false);
   const [iframeLoaded, setIframeLoaded] = React.useState(false);
-  
+
   // Function to refresh the iframe
   const refreshIframe = React.useCallback(() => {
     if (iframeRef.current && data?.ephemeralUrl) {
@@ -104,14 +104,14 @@ const FreestyleDevServerInner = React.forwardRef<
       }, 50);
     }
   }, [data?.ephemeralUrl]);
-  
+
   // Expose refresh method through ref
   React.useImperativeHandle(
     ref,
     () => ({
       refresh: refreshIframe,
     }),
-    [refreshIframe]
+    [refreshIframe],
   );
 
   React.useMemo(() => {

package/.env

@@ -1 +0,0 @@
-FREESTYLE_API_KEY=RoZ4n8eAY4ChcgdKV89LjY-Fhvp6Rzqx27bZ4BjHaVf7qpEw7vA7MekK84DdGgZYkR2