@axiom-lattice/gateway 2.1.22 → 2.1.23

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@axiom-lattice/gateway",
-  "version": "2.1.22",
+  "version": "2.1.23",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
   "types": "dist/index.d.ts",
@@ -18,6 +18,7 @@
   "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",
@@ -35,7 +36,7 @@
     "pino-roll": "^3.1.0",
     "redis": "^5.0.1",
     "uuid": "^9.0.1",
-    "@axiom-lattice/core": "2.1.17",
+    "@axiom-lattice/core": "2.1.18",
     "@axiom-lattice/protocols": "2.1.11",
     "@axiom-lattice/queue-redis": "1.0.10"
   },

package/src/controllers/sandbox.ts

@@ -1,8 +1,37 @@
-import { FastifyInstance, FastifyRequest, FastifyReply } from "fastify";
-// import { WebSocket, createWebSocketStream } from "ws";
-import { pipeline } from "stream/promises";
+import { Readable } from "stream";
+import { FastifyInstance } from "fastify";
 import { sandboxService } from "../services/sandbox_service";
-const SANDBOX_BASE_URL = process.env.SANDBOX_BASE_URL || "http://localhost:8080";
+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;
@@ -17,21 +46,17 @@ interface ResourceParams extends SandboxParams {
   resourcePath: string;
 }
 
-export async function registerSandboxProxyRoutes(app: FastifyInstance): Promise<void> {
-  app.get<{ Params: SandboxParams }>(
-    "/api/assistants/:assistantId/threads/:threadId/sandbox",
+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) {
-        const errorHtml = sandboxService.generateErrorHtml(
-          assistantId,
-          threadId,
-          "unknown",
-          `Assistant ${assistantId} not found`
-        );
-        return reply.status(404).type("text/html").send(errorHtml);
+        return reply.status(500).send({ error: "Assistant sandbox config not found" });
       }
 
       const { isolatedLevel } = sandboxConfig;
@@ -41,22 +66,181 @@ export async function registerSandboxProxyRoutes(app: FastifyInstance): Promise<
         isolatedLevel
       );
 
+      const sandboxManager = getSandBoxManager("default")
+      const sandbox = await sandboxManager.createSandbox(sandboxName)
+
       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);
+        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 }>(
@@ -114,37 +298,37 @@ export async function registerSandboxProxyRoutes(app: FastifyInstance): Promise<
   //   }
   // );
 
-  app.get<{ Params: ProxyParams }>(
-    "/api/assistants/:assistantId/threads/:threadId/sandbox/vnc/*",
-    async (request, reply) => {
-      const { assistantId, threadId, "*": restPath } = request.params;
+  // 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 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 { isolatedLevel } = sandboxConfig;
+  //     const sandboxName = sandboxService.computeSandboxName(
+  //       assistantId,
+  //       threadId,
+  //       isolatedLevel
+  //     );
 
-      const targetPath = restPath ? `/vnc/${restPath}` : "/vnc/";
-      const targetUrl = `${sandboxService.getTargetUrl(sandboxName)}${targetPath}`;
+  //     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";
+  //     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}`);
-      }
-    }
-  );
+  //       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}`);
+  //     }
+  //   }
+  // );
 
 
 }

package/src/index.ts

@@ -1,5 +1,6 @@
 import fastify from "fastify";
 import cors from "@fastify/cors";
+import multipart from "@fastify/multipart";
 import sensible from "@fastify/sensible";
 import websocket from "@fastify/websocket";
 import { registerLatticeRoutes } from "./routes";
@@ -114,11 +115,18 @@ app.register(cors, {
     "X-Requested-With",
     "x-tenant-id",
     "x-request-id",
+    "x-assistant-id",
+    "x-thread-id",
   ],
   exposedHeaders: ["Content-Type"],
   credentials: true,
 });
 app.register(sensible);
+app.register(multipart, {
+  limits: {
+    fileSize: Number(process.env.BODY_LIMIT) || 50 * 1024 * 1024,
+  },
+});
 app.register(websocket);
 
 // Error handler

package/src/services/agent_service.ts

@@ -76,6 +76,7 @@ export async function agent_invoke({
         "x-tenant-id": tenant_id,
         "x-request-id": run_id,
         "x-thread-id": thread_id,
+        "x-assistant-id": assistant_id,
         runConfig, // Inject runConfig for tools to access
       },
       recursionLimit: 200,
@@ -146,6 +147,7 @@ export async function agent_stream({
           "x-tenant-id": tenant_id,
           "x-request-id": run_id,
           "x-thread-id": thread_id,
+          "x-assistant-id": assistant_id,
           runConfig, // Inject runConfig for tools to access
         },
         streamMode: ["updates", "messages"],

package/src/services/sandbox_service.ts

@@ -1,7 +1,6 @@
-import { getAgentConfig, getAgentLattice, normalizeSandboxName } from "@axiom-lattice/core";
+import { getAgentConfig, getAgentLattice, getSandBoxManager, normalizeSandboxName, sandboxLatticeManager } from "@axiom-lattice/core";
 import { ConnectedSandboxConfig } from "@axiom-lattice/protocols";
 
-const SANDBOX_BASE_URL = process.env.SANDBOX_BASE_URL || "http://localhost:8080";
 
 const ERROR_HTML = `<!DOCTYPE html>
 <html lang="zh-CN">
@@ -114,11 +113,6 @@ const ERROR_HTML = `<!DOCTYPE html>
 </html>`;
 
 export class SandboxService {
-  private baseUrl: string;
-
-  constructor(baseUrl?: string) {
-    this.baseUrl = baseUrl || SANDBOX_BASE_URL;
-  }
 
   getSandboxConfig(assistantId: string): ConnectedSandboxConfig | null {
     const agentConfig = getAgentConfig(assistantId);
@@ -154,7 +148,8 @@ export class SandboxService {
   }
 
   getTargetUrl(sandboxName: string): string {
-    return `${this.baseUrl}/sandbox/${sandboxName}`;
+    const sandboxManager = getSandBoxManager("default")
+    return `${sandboxManager.getBaseURL()}/sandbox/${sandboxName}`;
   }
 
   async getVncHtml(sandboxName: string): Promise<string> {