@axiom-lattice/gateway 2.1.21 → 2.1.23

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@axiom-lattice/gateway",
-  "version": "2.1.21",
+  "version": "2.1.23",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
   "types": "dist/index.d.ts",
@@ -17,9 +17,13 @@
   "description": "API Gateway for LangGraph agent-based applications",
   "dependencies": {
     "@fastify/cors": "^11.0.0",
+    "@fastify/http-proxy": "^9.5.0",
+    "@fastify/multipart": "^9.4.0",
+    "@fastify/reply-from": "^12.5.0",
     "@fastify/sensible": "^6.0.3",
     "@fastify/swagger": "^9.5.1",
     "@fastify/swagger-ui": "^5.2.3",
+    "@fastify/websocket": "^11.0.1",
     "@langchain/core": "1.1.4",
     "@langchain/langgraph": "1.0.4",
     "@supabase/supabase-js": "^2.49.1",
@@ -32,15 +36,16 @@
     "pino-roll": "^3.1.0",
     "redis": "^5.0.1",
     "uuid": "^9.0.1",
-    "@axiom-lattice/core": "2.1.16",
-    "@axiom-lattice/protocols": "2.1.10",
-    "@axiom-lattice/queue-redis": "1.0.9"
+    "@axiom-lattice/core": "2.1.18",
+    "@axiom-lattice/protocols": "2.1.11",
+    "@axiom-lattice/queue-redis": "1.0.10"
   },
   "devDependencies": {
     "@types/jest": "^29.5.14",
     "@types/lodash": "^4.17.16",
     "@types/node": "^20.17.23",
     "@types/uuid": "^9.0.8",
+    "@types/ws": "^8.18.1",
     "@typescript-eslint/eslint-plugin": "^7.2.0",
     "@typescript-eslint/parser": "^7.2.0",
     "eslint": "^8.57.0",

package/src/controllers/sandbox.ts

@@ -0,0 +1,334 @@
+import { Readable } from "stream";
+import { FastifyInstance } from "fastify";
+import { sandboxService } from "../services/sandbox_service";
+import { getSandBoxManager } from "@axiom-lattice/core";
+
+/** Get filename from path (e.g. /home/gem/uploads/foo.pdf -> foo.pdf) */
+function getFilenameFromPath(path: string): string {
+  const segments = path.replace(/\/+$/, "").split("/");
+  return segments[segments.length - 1] || "download";
+}
+
+/** Common extension -> MIME type for download response */
+const EXT_TO_MIME: Record<string, string> = {
+  ".txt": "text/plain",
+  ".html": "text/html",
+  ".css": "text/css",
+  ".js": "application/javascript",
+  ".json": "application/json",
+  ".pdf": "application/pdf",
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".webp": "image/webp",
+  ".svg": "image/svg+xml",
+  ".zip": "application/zip",
+  ".csv": "text/csv",
+  ".xml": "application/xml",
+};
+
+function getContentTypeFromFilename(filename: string): string {
+  const ext = filename.includes(".") ? filename.slice(filename.lastIndexOf(".")).toLowerCase() : "";
+  return EXT_TO_MIME[ext] ?? "application/octet-stream";
+}
+
+interface SandboxParams {
+  assistantId: string;
+  threadId: string;
+}
+
+interface ProxyParams extends SandboxParams {
+  "*": string;
+}
+
+interface ResourceParams extends SandboxParams {
+  resourcePath: string;
+}
+
+export function registerSandboxProxyRoutes(app: FastifyInstance): void {
+  // Register uploadfile route FIRST before wildcard routes to ensure it matches
+  app.post<{ Params: SandboxParams }>(
+    "/api/assistants/:assistantId/threads/:threadId/sandbox/uploadfile",
+    async (request, reply) => {
+      console.log("[Sandbox Upload] Route matched:", request.url);
+      const { assistantId, threadId } = request.params;
+
+      const sandboxConfig = sandboxService.getSandboxConfig(assistantId);
+      if (!sandboxConfig) {
+        return reply.status(500).send({ error: "Assistant sandbox config not found" });
+      }
+
+      const { isolatedLevel } = sandboxConfig;
+      const sandboxName = sandboxService.computeSandboxName(
+        assistantId,
+        threadId,
+        isolatedLevel
+      );
+
+      const sandboxManager = getSandBoxManager("default")
+      const sandbox = await sandboxManager.createSandbox(sandboxName)
+
+      try {
+        const data = await request.file();
+        if (!data) {
+          return reply.status(400).send({ error: "No file in request" });
+        }
+
+        const buffer = await data.toBuffer();
+        const pathEntry = data.fields?.path;
+        const pathValue =
+          pathEntry && typeof pathEntry === "object" && "value" in pathEntry
+            ? String((pathEntry as { value: unknown }).value)
+            : typeof pathEntry === "string"
+              ? pathEntry
+              : undefined;
+
+        const formData = new FormData();
+        formData.append("file", new Blob([buffer]), data.filename ?? "file");
+
+        const path = `/home/gem/uploads/${pathValue ? pathValue : ""}${data.filename}`;
+        const uploadResult = await sandbox.file.uploadFile({
+          file: buffer,
+          path: path,
+        })
+
+        if (!uploadResult.ok) {
+          return reply.status(502).send({ error: `Upload error: ${uploadResult.error}` });
+        }
+
+        const relativePath = uploadResult.body?.data?.file_path.replace(`/home/gem`, "");
+        const result = { id: relativePath, name: data.filename, size: buffer.length };
+
+        return reply.status(200).send({ message: "File uploaded successfully", ...result });
+      } catch (error: unknown) {
+        const message = error instanceof Error ? error.message : String(error);
+        return reply.status(502).send({ error: `Upload proxy error: ${message}` });
+      }
+    }
+  );
+
+  // Download file from sandbox: GET with query param path (file path in sandbox, e.g. /home/gem/uploads/foo.txt)
+  app.get<{
+    Params: SandboxParams;
+    Querystring: { path: string };
+  }>(
+    "/api/assistants/:assistantId/threads/:threadId/sandbox/downloadfile",
+    async (request, reply) => {
+      const { assistantId, threadId } = request.params;
+      const { path: filePath } = request.query;
+
+      if (!filePath || typeof filePath !== "string") {
+        return reply.status(400).send({ error: "Query parameter 'path' is required" });
+      }
+
+      const sandboxConfig = sandboxService.getSandboxConfig(assistantId);
+      if (!sandboxConfig) {
+        return reply.status(404).send({ error: "Assistant sandbox config not found" });
+      }
+
+      const { isolatedLevel } = sandboxConfig;
+      const sandboxName = sandboxService.computeSandboxName(
+        assistantId,
+        threadId,
+        isolatedLevel
+      );
+
+      const sandboxManager = getSandBoxManager("default");
+      const sandbox = await sandboxManager.createSandbox(sandboxName);
+
+      try {
+        // Resolve path: if relative (no leading /), prefix with /home/gem
+        const resolvedPath = filePath.startsWith("/home/gem") ? filePath : `/home/gem/${filePath.replace(/^\//, "")}`;
+        const filename = getFilenameFromPath(resolvedPath);
+        const inferredContentType = getContentTypeFromFilename(filename);
+
+        const downloadResult = await sandbox.file.downloadFile({
+          path: resolvedPath,
+        });
+
+        if (!downloadResult.ok) {
+          return reply.status(502).send({
+            error: `Download error: ${JSON.stringify(downloadResult.error)}`,
+          });
+        }
+
+        // Use body.stream() to get ReadableStream and pipe directly (no buffering)
+        const body = downloadResult.body as unknown as {
+          stream?: () => ReadableStream<Uint8Array>;
+          contentType?: string;
+          contentDisposition?: string;
+        };
+        if (typeof body?.stream === "function") {
+          const webStream = body.stream();
+          const nodeStream = Readable.fromWeb(webStream);
+          const contentType = body.contentType ?? inferredContentType;
+          const contentDisposition =
+            body.contentDisposition ?? `inline; filename="${filename.replace(/"/g, '\\"')}"; filename*=UTF-8''${encodeURIComponent(filename)}`;
+          reply = reply.status(200).type(contentType).header("Content-Disposition", contentDisposition).send(nodeStream);
+          return reply;
+        }
+
+        // Fallback: buffer body when stream is not available
+        const bodyUnknown = downloadResult.body as unknown;
+        let buf: Buffer;
+        let contentType = inferredContentType;
+        let contentDisposition = `inline; filename="${filename.replace(/"/g, '\\"')}"; filename*=UTF-8''${encodeURIComponent(filename)}`;
+
+        if (bodyUnknown instanceof ArrayBuffer) {
+          buf = Buffer.from(bodyUnknown);
+        } else if (bodyUnknown instanceof Buffer) {
+          buf = bodyUnknown;
+        } else if (
+          bodyUnknown &&
+          typeof (bodyUnknown as { arrayBuffer?: () => Promise<ArrayBuffer> }).arrayBuffer === "function"
+        ) {
+          const res = bodyUnknown as { arrayBuffer: () => Promise<ArrayBuffer>; headers?: Headers };
+          buf = Buffer.from(await res.arrayBuffer());
+          if (res.headers?.get("content-type")) contentType = res.headers.get("content-type")!;
+          if (res.headers?.get("content-disposition")) contentDisposition = res.headers.get("content-disposition")!;
+        } else if (bodyUnknown && typeof (bodyUnknown as { blob?: () => Promise<Blob> }).blob === "function") {
+          const blob = await (bodyUnknown as { blob: () => Promise<Blob> }).blob();
+          buf = Buffer.from(await blob.arrayBuffer());
+        } else {
+          return reply.status(502).send({ error: "Unexpected download response format" });
+        }
+
+        reply = reply.status(200).type(contentType).header("Content-Disposition", contentDisposition).send(buf);
+        return reply;
+      } catch (error: unknown) {
+        const message = error instanceof Error ? error.message : String(error);
+        return reply.status(502).send({ error: `Download proxy error: ${message}` });
+      }
+    }
+  );
+
+  // app.get<{ Params: SandboxParams }>(
+  //   "/api/assistants/:assistantId/threads/:threadId/sandbox/browser",
+  //   async (request, reply) => {
+  //     const { assistantId, threadId } = request.params;
+
+  //     const sandboxConfig = sandboxService.getSandboxConfig(assistantId);
+  //     if (!sandboxConfig) {
+  //       const errorHtml = sandboxService.generateErrorHtml(
+  //         assistantId,
+  //         threadId,
+  //         "unknown",
+  //         `Assistant ${assistantId} not found`
+  //       );
+  //       return reply.status(404).type("text/html").send(errorHtml);
+  //     }
+
+  //     const { isolatedLevel } = sandboxConfig;
+  //     const sandboxName = sandboxService.computeSandboxName(
+  //       assistantId,
+  //       threadId,
+  //       isolatedLevel
+  //     );
+
+  //     try {
+  //       const html = await sandboxService.getVncHtml(sandboxName);
+  //       const rewrittenHtml = sandboxService.rewriteHtml(html, assistantId, threadId);
+  //       return reply.type("text/html").send(rewrittenHtml);
+  //     } catch (error: any) {
+  //       const errorHtml = sandboxService.generateErrorHtml(
+  //         assistantId,
+  //         threadId,
+  //         isolatedLevel,
+  //         error.message || "Failed to connect to sandbox"
+  //       );
+  //       return reply.status(502).type("text/html").send(errorHtml);
+  //     }
+  //   }
+  // );
+
+
+  // app.get<{ Params: SandboxParams }>(
+  //   "/api/assistants/:assistantId/threads/:threadId/sandbox/websockify",
+  //   { websocket: true },
+
+  //   (connection, request) => {
+
+  //     const url = (connection?.url) as string;
+  //     console.log(`[WebSocket] Received connection from URL: ${url}`);
+
+  //     const urlMatch = url.match(/\/api\/assistants\/([^/]+)\/threads\/([^/]+)\/sandbox\/websockify/);
+  //     if (!urlMatch) {
+  //       console.error(`[WebSocket] Failed to parse params from URL: ${url}`);
+  //       connection.close(1008, "Invalid URL format");
+  //       return;
+  //     }
+
+  //     const assistantId = urlMatch[1];
+  //     const threadId = urlMatch[2];
+  //     console.log(`[WebSocket] Parsed params - assistantId: ${assistantId}, threadId: ${threadId}`);
+
+  //     const sandboxConfig = sandboxService.getSandboxConfig(assistantId);
+  //     if (!sandboxConfig) {
+  //       console.error(`[WebSocket] Assistant ${assistantId} not found`);
+  //       connection.close(1008, "Assistant not found");
+  //       return;
+  //     }
+
+  //     const { isolatedLevel } = sandboxConfig;
+  //     const sandboxName = sandboxService.computeSandboxName(
+  //       assistantId,
+  //       threadId,
+  //       isolatedLevel
+  //     );
+
+  //     const targetUrl = sandboxService.getTargetUrl(sandboxName);
+  //     const targetWsUrl = targetUrl.replace(/^http/, "ws").replace(/^https/, "wss") + "/websockify";
+
+  //     console.log(`[WebSocket] Connecting to target: ${targetWsUrl}`);
+
+  //     const targetSocket = new WebSocket(targetWsUrl);
+  //     const clientStream = createWebSocketStream(connection, { encoding: "utf8" });
+
+  //     const targetStream = createWebSocketStream(targetSocket, { encoding: "utf8" });
+
+  //     const forward = pipeline(clientStream, targetStream);
+  //     const backward = pipeline(targetStream, clientStream);
+
+  //     Promise.all([forward, backward]).catch((err) => {
+  //       console.error(`[WebSocket] Proxy pipeline failed:`, err.message);
+  //       targetSocket.terminate();
+  //       connection.terminate();
+  //     });
+  //   }
+  // );
+
+  // app.get<{ Params: ProxyParams }>(
+  //   "/api/assistants/:assistantId/threads/:threadId/sandbox/browser/vnc/*",
+  //   async (request, reply) => {
+  //     const { assistantId, threadId, "*": restPath } = request.params;
+
+  //     const sandboxConfig = sandboxService.getSandboxConfig(assistantId);
+  //     if (!sandboxConfig) {
+  //       return reply.status(404).send("Assistant not found");
+  //     }
+
+  //     const { isolatedLevel } = sandboxConfig;
+  //     const sandboxName = sandboxService.computeSandboxName(
+  //       assistantId,
+  //       threadId,
+  //       isolatedLevel
+  //     );
+
+  //     const targetPath = restPath ? `/vnc/${restPath}` : "/vnc/";
+  //     const targetUrl = `${sandboxService.getTargetUrl(sandboxName)}${targetPath}`;
+
+  //     try {
+  //       const response = await fetch(targetUrl);
+  //       const contentType = response.headers.get("content-type") || "application/octet-stream";
+
+  //       const body = await response.arrayBuffer();
+  //       reply.status(response.status).type(contentType).send(Buffer.from(body));
+  //     } catch (error: any) {
+  //       reply.status(502).send(`Proxy error: ${error.message}`);
+  //     }
+  //   }
+  // );
+
+
+}