freestyle-sandboxes 0.0.97 → 0.1.1

package/src/ai/index.ts

@@ -1,164 +0,0 @@
-import {
-  FreestyleDeployWebConfiguration,
-  FreestyleExecuteScriptParamsConfiguration,
-  FreestyleExecuteScriptResultSuccess,
-  HandleExecuteScriptError,
-} from "../../openapi";
-import { FreestyleSandboxes } from "..";
-import { tool } from "ai";
-import { z } from "zod";
-
-export const executeCodeSchema = z.object({
-  script: z.string().describe(`
-        The JavaScript or TypeScript script to execute, must be in the format of:
-
-        import { someModule } from "someModule";
-        export default () => {
-           ... your code here ...
-           return output;
-        }
-
-        or for async functions:
-
-        import { someModule } from "someModule";
-
-        export default async () => {
-            ... your code here ...
-            return output;
-        }
-        `),
-});
-
-export const executeCodeDescription = (envVars: string, nodeModules: string) =>
-  `Execute a JavaScript or TypeScript script.\n${
-    envVars.length > 0
-      ? `You can use the following environment variables: ${envVars}`
-      : ""
-  }\n${
-    nodeModules.length > 0
-      ? `You can use the following node modules: ${nodeModules}`
-      : "You cannot use any node modules."
-  }`;
-/**
- * Execute a JavaScript or TypeScript script
- *
- *
- * @param config - Configuration for the tool
- * @param config.apiKey - The API key to use
- * @param {Function} [config.onResult] - Optional callback function to handle the result.
- * @param {boolean} [config.truncateOutput=false] - Whether to truncate the result to 1000 characters and truncate individual logs to the first 250 characters; useful to prevent long outputs from filling the context window.
- */
-export const executeTool = (
-  config: FreestyleExecuteScriptParamsConfiguration & {
-    apiKey: string;
-    onResult?: (_v: {
-      toolCallId: string;
-      input: {
-        script: string;
-        [key: string]: unknown;
-      };
-      result: FreestyleExecuteScriptResultSuccess | HandleExecuteScriptError;
-    }) => void | Promise<void>;
-    truncateOutput?: boolean;
-  }
-) => {
-  const api = new FreestyleSandboxes({
-    ...config,
-  });
-
-  const envVars = Object.keys(config.envVars ?? {}).join(", ");
-  const nodeModules = Object.keys(config.nodeModules ?? {}).join(", ");
-  return tool({
-    description: executeCodeDescription(envVars, nodeModules),
-    parameters: executeCodeSchema,
-    execute: async ({ script, ...otherParams }, { toolCallId }) => {
-      try {
-        const res = await api.executeScript(script, config);
-        if (config.onResult) {
-          await config.onResult({
-            toolCallId,
-            result: res,
-            input: {
-              script,
-              ...otherParams,
-            },
-          });
-        }
-        if (config.truncateOutput) {
-          if ("output" in res) {
-            res.result = JSON.stringify(res.result).slice(0, 1000);
-            res.logs = res.logs.slice(0, 1000);
-          }
-        }
-        return res;
-      } catch (e) {
-        console.log("ERROR: ", e.message);
-        return {
-          message: e.message,
-          error: e.error,
-        };
-      }
-    },
-  });
-};
-
-/**
- * Deploy a Web project
- * @param config - Configuration for the tool
- * @param config.apiKey - The API key to use
- */
-export const deployWebTool = (
-  config: FreestyleDeployWebConfiguration & {
-    apiKey: string;
-  }
-) => {
-  const api = new FreestyleSandboxes({
-    ...config,
-  });
-
-  const envVars = Object.keys(config.envVars ?? {}).join(", ");
-  const nodeModules = Object.keys(config.nodeModules ?? {}).join(", ");
-  return tool({
-    description: `Deploy a Web project. ${
-      envVars.length > 0
-        ? `You can use the following environment variables: ${envVars}`
-        : ""
-    }\n${
-      nodeModules.length > 0
-        ? `You can use the following node modules: ${nodeModules}`
-        : "You cannot use any node modules."
-    }`,
-    parameters: z.object({
-      files: z.record(z.string()).describe(`
-            A record of file names and their contents to deploy. For example:
-            {
-              "index.js": "import http from 'node:http';\\nnconsole.log('starting server');\\n\\nconst server = http.createServer(async(req, res) => {\\n  res.writeHead(200, { 'Content-Type': 'text/plain' });\\n  res.end('Welcome to New York its been waiting for you');\\n});\\n\\nserver.listen(3000, () => {\\n  console.log('Server is running at http://localhost:3000');\\n});",
-            }
-            `),
-    }),
-    execute: async ({ files }) => {
-      // map from record<string, string> to record<string, {content: string}>
-      const new_files = Object.keys(files).reduce((acc, key) => {
-        acc[key] = { content: files[key] };
-        return acc;
-      }, {} as Record<string, { content: string }>);
-      try {
-        const res = await api.deployWeb(
-          {
-            kind: "files",
-            files: new_files,
-          },
-          config
-        );
-        return res;
-      } catch (e) {
-        console.log("ERROR: ", e.message);
-        return `Error deploying web project:\n\n${JSON.stringify(
-          files,
-          null,
-          2
-        )}\n\nError: ${e.message}`;
-      }
-    },
-  });
-};

package/src/dev-server.ts

@@ -1,95 +0,0 @@
-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;
-
-  devCommandRunning: boolean;
-  installCommandRunning: boolean;
-
-  /**
-   * 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/expo/_expo_internals.ts

@@ -1,389 +0,0 @@
-import type {
-  ExpoRoutesManifestV1,
-  RouteInfo,
-} from "expo-router/build/routes-manifest";
-import fs from "node:fs";
-import path from "node:path";
-
-import { createRequire } from "module";
-const require = createRequire(import.meta.url);
-// import { ExpoRouterServerManifestV1FunctionRoute } from "./types";
-
-const debug = console.log;
-
-function getProcessedManifest(path: string): ExpoRoutesManifestV1<RegExp> {
-  // TODO: JSON Schema for validation
-  const routesManifest = JSON.parse(
-    fs.readFileSync(path, "utf-8")
-  ) as ExpoRoutesManifestV1;
-
-  const parsed: ExpoRoutesManifestV1<RegExp> = {
-    ...routesManifest,
-    notFoundRoutes: routesManifest.notFoundRoutes.map((value: any) => {
-      return {
-        ...value,
-        namedRegex: new RegExp(value.namedRegex),
-      };
-    }),
-    apiRoutes: routesManifest.apiRoutes.map((value: any) => {
-      return {
-        ...value,
-        namedRegex: new RegExp(value.namedRegex),
-      };
-    }),
-    htmlRoutes: routesManifest.htmlRoutes.map((value: any) => {
-      return {
-        ...value,
-        namedRegex: new RegExp(value.namedRegex),
-      };
-    }),
-    redirects: routesManifest.redirects?.map((value: any) => {
-      return {
-        ...value,
-        namedRegex: new RegExp(value.namedRegex),
-      };
-    }),
-    rewrites: routesManifest.rewrites?.map((value: any) => {
-      return {
-        ...value,
-        namedRegex: new RegExp(value.namedRegex),
-      };
-    }),
-  };
-
-  return parsed;
-}
-
-export function getRoutesManifest(distFolder: string) {
-  return getProcessedManifest(path.join(distFolder, "_expo/routes.json"));
-}
-
-// TODO: Reuse this for dev as well
-export function createRequestHandler(
-  distFolder: string,
-  {
-    getRoutesManifest: getInternalRoutesManifest,
-    getHtml = async (_request, route) => {
-      // Serve a static file by exact route name
-      const filePath = path.join(distFolder, route.page + ".html");
-      if (fs.existsSync(filePath)) {
-        return fs.readFileSync(filePath, "utf-8");
-      }
-
-      // Serve a static file by route name with hoisted index
-      // See: https://github.com/expo/expo/pull/27935
-      const hoistedFilePath = route.page.match(/\/index$/)
-        ? path.join(distFolder, route.page.replace(/\/index$/, "") + ".html")
-        : null;
-      if (hoistedFilePath && fs.existsSync(hoistedFilePath)) {
-        return fs.readFileSync(hoistedFilePath, "utf-8");
-      }
-
-      return null;
-    },
-    getApiRoute = async (route) => {
-      const filePath = path.join(distFolder, route.file);
-
-      debug(`Handling API route: ${route.page}: ${filePath}`);
-
-      // TODO: What's the standard behavior for malformed projects?
-      if (!fs.existsSync(filePath)) {
-        return null;
-      }
-
-      if (/\.c?js$/.test(filePath)) {
-        return require(filePath);
-      }
-      return import(filePath);
-    },
-    logApiRouteExecutionError = (error: Error) => {
-      console.error(error);
-    },
-    handleApiRouteError = async (error: Error) => {
-      if ("statusCode" in error && typeof error.statusCode === "number") {
-        return new Response(error.message, {
-          status: error.statusCode,
-          headers: {
-            "Content-Type": "text/plain",
-          },
-        });
-      }
-      return new Response("Internal server error", {
-        status: 500,
-        headers: {
-          "Content-Type": "text/plain",
-        },
-      });
-    },
-  }: {
-    getHtml?: (
-      request: Request,
-      route: RouteInfo<RegExp>
-    ) => Promise<string | Response | null>;
-    getRoutesManifest?: (
-      distFolder: string
-    ) => Promise<ExpoRoutesManifestV1<RegExp> | null>;
-    getApiRoute?: (route: RouteInfo<RegExp>) => Promise<any>;
-    logApiRouteExecutionError?: (error: Error) => void;
-    handleApiRouteError?: (error: Error) => Promise<Response>;
-  } = {}
-) {
-  let routesManifest: ExpoRoutesManifestV1<RegExp> | undefined;
-
-  return async function handler(request: Request): Promise<Response> {
-    if (getInternalRoutesManifest) {
-      const manifest = await getInternalRoutesManifest(distFolder);
-      if (manifest) {
-        routesManifest = manifest;
-      } else {
-        // Development error when Expo Router is not setup.
-        return new Response("No routes manifest found", {
-          status: 404,
-          headers: {
-            "Content-Type": "text/plain",
-          },
-        });
-      }
-    } else if (!routesManifest) {
-      routesManifest = getRoutesManifest(distFolder);
-    }
-
-    const url = new URL(request.url, "http://expo.dev");
-
-    const sanitizedPathname = url.pathname;
-
-    debug("Request", sanitizedPathname);
-
-    if (routesManifest.rewrites) {
-      for (const route of routesManifest.rewrites) {
-        if (!route.namedRegex.test(sanitizedPathname)) {
-          continue;
-        }
-
-        const url = getRedirectRewriteLocation(request, route);
-
-        if (url) {
-          request = new Request(
-            new URL(url, new URL(request.url).origin),
-            request
-          );
-        }
-      }
-    }
-
-    if (routesManifest.redirects) {
-      for (const route of routesManifest.redirects) {
-        if (!route.namedRegex.test(sanitizedPathname)) {
-          continue;
-        }
-
-        const Location = getRedirectRewriteLocation(request, route);
-
-        if (Location) {
-          debug("Redirecting", Location);
-
-          // Get the params
-          return new Response(null, {
-            status: route.permanent ? 308 : 307,
-            headers: {
-              Location,
-            },
-          });
-        }
-      }
-    }
-
-    if (request.method === "GET" || request.method === "HEAD") {
-      // First test static routes
-      for (const route of routesManifest.htmlRoutes) {
-        if (!route.namedRegex.test(sanitizedPathname)) {
-          continue;
-        }
-
-        // // Mutate to add the expoUrl object.
-        updateRequestWithConfig(request, route);
-
-        // serve a static file
-        const contents = await getHtml(request, route);
-
-        // TODO: What's the standard behavior for malformed projects?
-        if (!contents) {
-          return new Response("Not found", {
-            status: 404,
-            headers: {
-              "Content-Type": "text/plain",
-            },
-          });
-        } else if (contents instanceof Response) {
-          return contents;
-        }
-
-        return new Response(contents, {
-          status: 200,
-          headers: {
-            "Content-Type": "text/html",
-          },
-        });
-      }
-    }
-
-    // Next, test API routes
-    for (const route of routesManifest.apiRoutes) {
-      if (!route.namedRegex.test(sanitizedPathname)) {
-        continue;
-      }
-
-      const func = await getApiRoute(route);
-
-      if (func instanceof Response) {
-        return func;
-      }
-
-      const routeHandler = func?.[request.method];
-      if (!routeHandler) {
-        return new Response("Method not allowed", {
-          status: 405,
-          headers: {
-            "Content-Type": "text/plain",
-          },
-        });
-      }
-
-      // Mutate to add the expoUrl object.
-      const params = updateRequestWithConfig(request, route);
-
-      try {
-        // TODO: Handle undefined
-        return (await routeHandler(request, params)) as Response;
-      } catch (error) {
-        if (error instanceof Error) {
-          logApiRouteExecutionError(error);
-        }
-
-        return handleApiRouteError(error as Error);
-      }
-    }
-
-    // Finally, test 404 routes
-    for (const route of routesManifest.notFoundRoutes) {
-      if (!route.namedRegex.test(sanitizedPathname)) {
-        continue;
-      }
-
-      // // Mutate to add the expoUrl object.
-      updateRequestWithConfig(request, route);
-
-      // serve a static file
-      const contents = await getHtml(request, route);
-
-      // TODO: What's the standard behavior for malformed projects?
-      if (!contents) {
-        return new Response("Not found", {
-          status: 404,
-          headers: {
-            "Content-Type": "text/plain",
-          },
-        });
-      } else if (contents instanceof Response) {
-        return contents;
-      }
-
-      return new Response(contents, {
-        status: 404,
-        headers: {
-          "Content-Type": "text/html",
-        },
-      });
-    }
-
-    // 404
-    const response = new Response("Not found", {
-      status: 404,
-      headers: {
-        "Content-Type": "text/plain",
-      },
-    });
-    return response;
-  };
-}
-
-/** Match `[page]` -> `page` */
-// Ported from `expo-router/src/matchers.tsx`
-function matchDynamicName(name: string): string | undefined {
-  // Don't match `...` or `[` or `]` inside the brackets
-  // eslint-disable-next-line no-useless-escape
-  return name.match(/^\[([^[\](?:\.\.\.)]+?)\]$/)?.[1];
-}
-
-/** Match `[...page]` -> `page` */
-// Ported from `expo-router/src/matchers.tsx`
-function matchDeepDynamicRouteName(name: string): string | undefined {
-  return name.match(/^\[\.\.\.([^/]+?)\]$/)?.[1];
-}
-
-function updateRequestWithConfig(
-  request: Request,
-  config: ExpoRouterServerManifestV1FunctionRoute
-) {
-  const params: Record<string, string> = {};
-  const url = new URL(request.url);
-  const match = config.namedRegex.exec(url.pathname);
-  if (match?.groups) {
-    for (const [key, value] of Object.entries(match.groups)) {
-      const namedKey = config.routeKeys[key];
-      params[namedKey] = value;
-    }
-  }
-
-  return params;
-}
-
-function getRedirectRewriteLocation(
-  request: Request,
-  route: RouteInfo<RegExp>
-) {
-  if (route.methods) {
-    if (!route.methods.includes(request.method)) {
-      return;
-    }
-  }
-
-  const params = updateRequestWithConfig(request, route);
-
-  const urlSearchParams = new URL(request.url).searchParams;
-
-  let location = route.page
-    .split("/")
-    .map((segment) => {
-      let match = matchDynamicName(segment);
-
-      if (match) {
-        const value = params[match];
-        delete params[match];
-        // If we are redirecting from a catch-all route, we need to remove the extra segments
-        return value?.split("/")[0];
-      }
-
-      match = matchDeepDynamicRouteName(segment);
-
-      if (match) {
-        const value = params[match];
-        delete params[match];
-        return value;
-      }
-
-      return segment;
-    })
-    .join("/");
-
-  if (Object.keys(params).length > 0 || urlSearchParams.size > 0) {
-    location +=
-      "?" +
-      new URLSearchParams({
-        ...params,
-        ...Object.fromEntries(urlSearchParams.entries()),
-      }).toString();
-  }
-
-  return location;
-}

package/src/expo/index.ts

@@ -1,26 +0,0 @@
-import { createRequestHandler } from "./_expo_internals";
-
-import * as path from "node:path";
-import * as process from "node:process";
-import { Hono } from "hono";
-import { serveStatic } from "hono/deno";
-
-export const freestyleExpoServer = ({
-  CLIENT_BUILD_DIR = path.join(process.cwd(), "dist/client"),
-  SERVER_BUILD_DIR = path.join(process.cwd(), "dist/server"),
-} = {}) => {
-  // // Expo handler
-  const expoHandler = createRequestHandler(SERVER_BUILD_DIR);
-
-  const app = new Hono();
-  app.use("*", serveStatic({ root: CLIENT_BUILD_DIR }));
-
-  app.all("*", async (c, next) => {
-    console.log("Request received:", c.req.url);
-    const response = await expoHandler(c.req.raw);
-    return response;
-  });
-
-  // @ts-expect-error — Deno.serve is not in the types
-  Deno.serve(app.fetch);
-};