freestyle-sandboxes 0.0.37 → 0.0.40

package/dist/langgraph/index.cjs

@@ -2,7 +2,7 @@
 
 var index$1 = require('../index.cjs');
 var zod = require('zod');
-var index = require('../index-BBXyg0JQ.cjs');
+var index = require('../index-H7UNEAjs.cjs');
 require('@hey-api/client-fetch');
 
 var REGEX = /^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$/i;

package/dist/langgraph/index.mjs

@@ -1,6 +1,6 @@
 import { FreestyleSandboxes } from '../index.mjs';
 import { z } from 'zod';
-import { g as getDefaultExportFromCjs, z as zodToJsonSchema, a as executeCodeSchema, e as executeCodeDescription } from '../index-DCF70Xbq.mjs';
+import { g as getDefaultExportFromCjs, z as zodToJsonSchema, a as executeCodeSchema, e as executeCodeDescription } from '../index-D1ulQeJR.mjs';
 import '@hey-api/client-fetch';
 
 var REGEX = /^(?:[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$/i;

package/dist/mastra/index.cjs

@@ -1,7 +1,7 @@
 'use strict';
 
 var zod = require('zod');
-var index = require('../index-BBXyg0JQ.cjs');
+var index = require('../index-H7UNEAjs.cjs');
 var index$1 = require('../index.cjs');
 require('@hey-api/client-fetch');
 

package/dist/mastra/index.mjs

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { e as executeCodeDescription, a as executeCodeSchema } from '../index-DCF70Xbq.mjs';
+import { e as executeCodeDescription, a as executeCodeSchema } from '../index-D1ulQeJR.mjs';
 import { FreestyleSandboxes } from '../index.mjs';
 import '@hey-api/client-fetch';
 

package/dist/utils/index.cjs

@@ -33,7 +33,8 @@ const prepareDirForDeployment = async (directory) => {
     nodir: true,
     ignore: ["**/node_modules/**"],
     absolute: false,
-    dot: true
+    dot: true,
+    posix: true
   });
   for (const relativePath of patterns) {
     try {
@@ -59,7 +60,8 @@ const prepareDirForDeploymentSync = (directory) => {
     nodir: true,
     ignore: ["**/node_modules/**"],
     absolute: false,
-    dot: true
+    dot: true,
+    posix: true
   });
   for (const relativePath of patterns) {
     try {

package/dist/utils/index.mjs

@@ -10,7 +10,8 @@ const prepareDirForDeployment = async (directory) => {
     nodir: true,
     ignore: ["**/node_modules/**"],
     absolute: false,
-    dot: true
+    dot: true,
+    posix: true
   });
   for (const relativePath of patterns) {
     try {
@@ -36,7 +37,8 @@ const prepareDirForDeploymentSync = (directory) => {
     nodir: true,
     ignore: ["**/node_modules/**"],
     absolute: false,
-    dot: true
+    dot: true,
+    posix: true
   });
   for (const relativePath of patterns) {
     try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "freestyle-sandboxes",
-  "version": "0.0.37",
+  "version": "0.0.40",
   "type": "module",
   "main": "./dist/index.cjs",
   "module": "./dist/index.mjs",
@@ -46,6 +46,16 @@
         "default": "./dist/langgraph/index.mjs"
       }
     },
+    "./expo": {
+      "require": {
+        "types": "./dist/expo/index.d.cts",
+        "default": "./dist/expo/index.cjs"
+      },
+      "import": {
+        "types": "./dist/expo/index.d.mts",
+        "default": "./dist/expo/index.mjs"
+      }
+    },
     "./utils": {
       "require": {
         "types": "./dist/utils/index.d.cts",
@@ -67,16 +77,18 @@
   "description": "",
   "devDependencies": {
     "@hey-api/openapi-ts": "^0.60.1",
-    "pkgroll": "^2.6.0",
     "@langchain/core": "^0.3.38",
     "@langchain/langgraph": "^0.2.44",
     "@mastra/core": "^0.6.0",
     "ai": "^4.0.25",
-    "humanlayer": "^0.7.0"
+    "humanlayer": "^0.7.0",
+    "pkgroll": "^2.6.0"
   },
   "dependencies": {
     "@hey-api/client-fetch": "^0.5.7",
+    "expo-router": "^4.0.20",
     "glob": "^11.0.1",
+    "hono": "^4.7.5",
     "openai": "^4.77.3",
     "openapi": "^1.0.1",
     "zod": "^3.24.1"

package/src/ai/index.ts

@@ -6,7 +6,6 @@ import {
 import { FreestyleSandboxes } from "..";
 import { tool } from "ai";
 import { z } from "zod";
-import { P } from "../../dist/types.gen-BuhQ5LpB";
 
 export const executeCodeSchema = z.object({
   script: z.string().describe(`
@@ -52,9 +51,11 @@ export const executeTool = (
   config: FreestyleExecuteScriptParamsConfiguration & {
     apiKey: string;
     onResult?: (_v: {
+      toolCallId: string;
       input: {
         script: string;
-      } & Record<string, unknown>;
+        [key: string]: unknown;
+      };
       result: FreestyleExecuteScriptResultSuccess | HandleExecuteScriptError;
     }) => void | Promise<void>;
     truncateOutput?: boolean;
@@ -69,11 +70,12 @@ export const executeTool = (
   return tool({
     description: executeCodeDescription(envVars, nodeModules),
     parameters: executeCodeSchema,
-    execute: async ({ script, ...otherParams }) => {
+    execute: async ({ script, ...otherParams }, { toolCallId }) => {
       try {
         const res = await api.executeScript(script, config);
         if (config.onResult) {
           await config.onResult({
+            toolCallId,
             result: res,
             input: {
               script,

package/src/expo/_expo_internals.ts

@@ -0,0 +1,389 @@
+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

@@ -0,0 +1,26 @@
+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);
+};

package/src/utils/index.ts

@@ -15,6 +15,7 @@ export const prepareDirForDeployment = async (
     ignore: ["**/node_modules/**"],
     absolute: false,
     dot: true,
+    posix: true,
   });
 
   for (const relativePath of patterns) {
@@ -47,6 +48,7 @@ export const prepareDirForDeploymentSync = (
     ignore: ["**/node_modules/**"],
     absolute: false,
     dot: true,
+    posix: true,
   });
 
   for (const relativePath of patterns) {