npm - @axiom-lattice/gateway - Versions diffs - 2.1.22 → 2.1.23 - Mend

@axiom-lattice/gateway 2.1.22 → 2.1.23

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (11) hide show

package/.turbo/turbo-build.log +8 -8
package/CHANGELOG.md +8 -0
package/dist/index.js +134 -48
package/dist/index.js.map +1 -1
package/dist/index.mjs +124 -38
package/dist/index.mjs.map +1 -1
package/package.json +3 -2
package/src/controllers/sandbox.ts +235 -51
package/src/index.ts +8 -0
package/src/services/agent_service.ts +2 -0
package/src/services/sandbox_service.ts +3 -8

package/dist/index.mjs CHANGED Viewed

@@ -1,6 +1,7 @@
 // src/index.ts
 import fastify from "fastify";
 import cors from "@fastify/cors";
+import multipart from "@fastify/multipart";
 import sensible from "@fastify/sensible";
 import websocket from "@fastify/websocket";
@@ -61,6 +62,7 @@ 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
       },
@@ -115,6 +117,7 @@ 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
         },
@@ -1986,9 +1989,11 @@ var getHealthSchema = {
   }
 };
+// src/controllers/sandbox.ts
+import { Readable } from "stream";
 // src/services/sandbox_service.ts
-import { getAgentConfig, getAgentLattice as getAgentLattice2, normalizeSandboxName } from "@axiom-lattice/core";
-var SANDBOX_BASE_URL = process.env.SANDBOX_BASE_URL || "http://localhost:8080";
+import { getAgentConfig, getAgentLattice as getAgentLattice2, getSandBoxManager, normalizeSandboxName } from "@axiom-lattice/core";
 var ERROR_HTML = `<!DOCTYPE html>
 <html lang="zh-CN">
 <head>
@@ -2099,9 +2104,6 @@ var ERROR_HTML = `<!DOCTYPE html>
 </body>
 </html>`;
 var SandboxService = class {
-  constructor(baseUrl) {
-    this.baseUrl = baseUrl || SANDBOX_BASE_URL;
-  }
   getSandboxConfig(assistantId) {
     const agentConfig = getAgentConfig(assistantId);
     if (!agentConfig) {
@@ -2127,7 +2129,8 @@ var SandboxService = class {
     return normalizeSandboxName(sandboxName);
   }
   getTargetUrl(sandboxName) {
-    return `${this.baseUrl}/sandbox/${sandboxName}`;
+    const sandboxManager = getSandBoxManager("default");
+    return `${sandboxManager.getBaseURL()}/sandbox/${sandboxName}`;
   }
   async getVncHtml(sandboxName) {
     const response = await fetch(`${this.getTargetUrl(sandboxName)}/vnc/index.html`);
@@ -2171,21 +2174,41 @@ var SandboxService = class {
 var sandboxService = new SandboxService();
 // src/controllers/sandbox.ts
-var SANDBOX_BASE_URL2 = process.env.SANDBOX_BASE_URL || "http://localhost:8080";
-async function registerSandboxProxyRoutes(app2) {
-  app2.get(
-    "/api/assistants/:assistantId/threads/:threadId/sandbox",
+import { getSandBoxManager as getSandBoxManager2 } from "@axiom-lattice/core";
+function getFilenameFromPath(path) {
+  const segments = path.replace(/\/+$/, "").split("/");
+  return segments[segments.length - 1] || "download";
+}
+var EXT_TO_MIME = {
+  ".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) {
+  const ext = filename.includes(".") ? filename.slice(filename.lastIndexOf(".")).toLowerCase() : "";
+  return EXT_TO_MIME[ext] ?? "application/octet-stream";
+}
+function registerSandboxProxyRoutes(app2) {
+  app2.post(
+    "/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;
       const sandboxName = sandboxService.computeSandboxName(
@@ -2193,28 +2216,46 @@ async function registerSandboxProxyRoutes(app2) {
         threadId,
         isolatedLevel
       );
+      const sandboxManager = getSandBoxManager2("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);
+        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.value) : typeof pathEntry === "string" ? pathEntry : void 0;
+        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
+        });
+        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) {
-        const errorHtml = sandboxService.generateErrorHtml(
-          assistantId,
-          threadId,
-          isolatedLevel,
-          error.message || "Failed to connect to sandbox"
-        );
-        return reply.status(502).type("text/html").send(errorHtml);
+        const message = error instanceof Error ? error.message : String(error);
+        return reply.status(502).send({ error: `Upload proxy error: ${message}` });
       }
     }
   );
   app2.get(
-    "/api/assistants/:assistantId/threads/:threadId/sandbox/vnc/*",
+    "/api/assistants/:assistantId/threads/:threadId/sandbox/downloadfile",
     async (request, reply) => {
-      const { assistantId, threadId, "*": restPath } = request.params;
+      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("Assistant not found");
+        return reply.status(404).send({ error: "Assistant sandbox config not found" });
       }
       const { isolatedLevel } = sandboxConfig;
       const sandboxName = sandboxService.computeSandboxName(
@@ -2222,15 +2263,53 @@ async function registerSandboxProxyRoutes(app2) {
         threadId,
         isolatedLevel
       );
-      const targetPath = restPath ? `/vnc/${restPath}` : "/vnc/";
-      const targetUrl = `${sandboxService.getTargetUrl(sandboxName)}${targetPath}`;
+      const sandboxManager = getSandBoxManager2("default");
+      const sandbox = await sandboxManager.createSandbox(sandboxName);
       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));
+        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)}`
+          });
+        }
+        const body = downloadResult.body;
+        if (typeof body?.stream === "function") {
+          const webStream = body.stream();
+          const nodeStream = Readable.fromWeb(webStream);
+          const contentType2 = body.contentType ?? inferredContentType;
+          const contentDisposition2 = body.contentDisposition ?? `inline; filename="${filename.replace(/"/g, '\\"')}"; filename*=UTF-8''${encodeURIComponent(filename)}`;
+          reply = reply.status(200).type(contentType2).header("Content-Disposition", contentDisposition2).send(nodeStream);
+          return reply;
+        }
+        const bodyUnknown = downloadResult.body;
+        let buf;
+        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.arrayBuffer === "function") {
+          const res = bodyUnknown;
+          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.blob === "function") {
+          const blob = await bodyUnknown.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) {
-        reply.status(502).send(`Proxy error: ${error.message}`);
+        const message = error instanceof Error ? error.message : String(error);
+        return reply.status(502).send({ error: `Download proxy error: ${message}` });
       }
     }
   );
@@ -2773,12 +2852,19 @@ app.register(cors, {
     "Authorization",
     "X-Requested-With",
     "x-tenant-id",
-    "x-request-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);
 app.setErrorHandler((error, request, reply) => {
   const getHeaderValue = (header) => {