@axiom-lattice/gateway 2.1.53 → 2.1.55

package/jest.config.js

@@ -12,10 +12,15 @@ module.exports = {
     ],
   },
   moduleNameMapper: {
+    "^@axiom-lattice/core$": "<rootDir>/../core/src/index.ts",
+    "^@axiom-lattice/protocols$": "<rootDir>/../protocols/src/index.ts",
+    "^@axiom-lattice/pg-stores$": "<rootDir>/../pg-stores/src/index.ts",
+    "^@axiom-lattice/queue-redis$": "<rootDir>/../queue-redis/src/index.ts",
     "^@/(.*)$": "<rootDir>/src/$1",
     "^@services/(.*)$": "<rootDir>/src/services/$1",
     "^@utils/(.*)$": "<rootDir>/src/utils/$1",
     "^@types$": "<rootDir>/src/types/index.ts",
+    "^e2b$": "<rootDir>/src/__tests__/__mocks__/e2b.ts",
   },
   collectCoverageFrom: ["src/**/*.ts", "!src/**/*.d.ts", "!src/__tests__/**/*"],
   coverageReporters: ["text", "lcov", "html"],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@axiom-lattice/gateway",
-  "version": "2.1.53",
+  "version": "2.1.55",
   "main": "dist/index.js",
   "module": "dist/index.mjs",
   "types": "dist/index.d.ts",
@@ -25,6 +25,7 @@
     "@fastify/swagger": "^9.5.1",
     "@fastify/swagger-ui": "^5.2.3",
     "@fastify/websocket": "^11.0.1",
+    "@larksuiteoapi/node-sdk": "^1.47.0",
     "@langchain/core": "1.1.30",
     "@langchain/langgraph": "1.0.4",
     "@supabase/supabase-js": "^2.49.1",
@@ -38,10 +39,10 @@
     "pg": "^8.11.0",
     "redis": "^5.0.1",
     "uuid": "^9.0.1",
-    "@axiom-lattice/core": "2.1.47",
-    "@axiom-lattice/pg-stores": "1.0.37",
-    "@axiom-lattice/protocols": "2.1.25",
-    "@axiom-lattice/queue-redis": "1.0.24"
+    "@axiom-lattice/core": "2.1.49",
+    "@axiom-lattice/pg-stores": "1.0.39",
+    "@axiom-lattice/protocols": "2.1.26",
+    "@axiom-lattice/queue-redis": "1.0.25"
   },
   "devDependencies": {
     "@types/jest": "^29.5.14",

package/src/__tests__/__mocks__/e2b.ts

@@ -0,0 +1 @@
+export const Sandbox = jest.fn();

package/src/__tests__/channel-installations.test.ts

@@ -0,0 +1,199 @@
+import { FastifyInstance } from "fastify";
+import fastify from "fastify";
+import { registerChannelInstallationRoutes } from "../routes/channel-installations";
+
+// Set DATABASE_URL before importing controller
+process.env.DATABASE_URL = "postgres://test:test@localhost:5432/test";
+
+// Mock the store
+const mockGetInstallationsByTenant = jest.fn();
+const mockGetInstallationById = jest.fn();
+const mockCreateInstallation = jest.fn();
+const mockUpdateInstallation = jest.fn();
+const mockDeleteInstallation = jest.fn();
+
+jest.mock("@axiom-lattice/pg-stores", () => ({
+  PostgreSQLChannelInstallationStore: jest.fn().mockImplementation(() => ({
+    getInstallationsByTenant: mockGetInstallationsByTenant,
+    getInstallationById: mockGetInstallationById,
+    createInstallation: mockCreateInstallation,
+    updateInstallation: mockUpdateInstallation,
+    deleteInstallation: mockDeleteInstallation,
+  })),
+}));
+
+describe("Channel Installation API", () => {
+  let app: FastifyInstance;
+
+  beforeEach(() => {
+    // Reset mocks
+    mockGetInstallationsByTenant.mockReset();
+    mockGetInstallationById.mockReset();
+    mockCreateInstallation.mockReset();
+    mockUpdateInstallation.mockReset();
+    mockDeleteInstallation.mockReset();
+
+    app = fastify();
+    registerChannelInstallationRoutes(app);
+  });
+
+  afterEach(async () => {
+    await app.close();
+  });
+
+  describe("GET /api/channel-installations", () => {
+    it("should return list of installations for tenant", async () => {
+      mockGetInstallationsByTenant.mockResolvedValueOnce([
+        {
+          id: "install-1",
+          tenantId: "tenant-a",
+          channel: "lark",
+          name: "Test Installation",
+          config: {
+            appId: "cli_test",
+            appSecret: "secret",
+            assistantId: "assistant-1",
+            mappingMode: "hybrid",
+          },
+          createdAt: new Date(),
+          updatedAt: new Date(),
+        },
+      ]);
+
+      const response = await app.inject({
+        method: "GET",
+        url: "/api/channel-installations",
+        headers: {
+          "x-tenant-id": "tenant-a",
+        },
+      });
+
+      expect(response.statusCode).toBe(200);
+      const body = JSON.parse(response.body);
+      expect(body.success).toBe(true);
+      expect(body.data).toHaveProperty("records");
+      expect(body.data).toHaveProperty("total");
+      expect(body.data.records).toHaveLength(1);
+    });
+
+    it("should filter by channel type", async () => {
+      const response = await app.inject({
+        method: "GET",
+        url: "/api/channel-installations?channel=lark",
+        headers: {
+          "x-tenant-id": "tenant-a",
+        },
+      });
+
+      expect(response.statusCode).toBe(200);
+    });
+  });
+
+  describe("GET /api/channel-installations/:installationId", () => {
+    it("should return installation by id", async () => {
+      const response = await app.inject({
+        method: "GET",
+        url: "/api/channel-installations/install-1",
+        headers: {
+          "x-tenant-id": "tenant-a",
+        },
+      });
+
+      // Will return 404 since mock returns null, but route is accessible
+      expect([200, 404]).toContain(response.statusCode);
+    });
+  });
+
+  describe("POST /api/channel-installations", () => {
+    it("should create new installation", async () => {
+      mockCreateInstallation.mockResolvedValueOnce({
+        id: "new-install-id",
+        tenantId: "tenant-a",
+        channel: "lark",
+        name: "Test Lark Installation",
+        config: {
+          appId: "cli_test",
+          appSecret: "secret",
+          assistantId: "assistant-1",
+          mappingMode: "hybrid",
+        },
+        createdAt: new Date(),
+        updatedAt: new Date(),
+      });
+
+      const response = await app.inject({
+        method: "POST",
+        url: "/api/channel-installations",
+        headers: {
+          "x-tenant-id": "tenant-a",
+          "content-type": "application/json",
+        },
+        payload: {
+          channel: "lark",
+          name: "Test Lark Installation",
+          config: {
+            appId: "cli_test",
+            appSecret: "secret",
+            assistantId: "assistant-1",
+            mappingMode: "hybrid",
+          },
+        },
+      });
+
+      expect(response.statusCode).toBe(201);
+      const body = JSON.parse(response.body);
+      expect(body.success).toBe(true);
+      expect(body.data).toHaveProperty("id");
+    });
+
+    it("should validate required fields", async () => {
+      const response = await app.inject({
+        method: "POST",
+        url: "/api/channel-installations",
+        headers: {
+          "x-tenant-id": "tenant-a",
+          "content-type": "application/json",
+        },
+        payload: {
+          // Missing channel and config
+        },
+      });
+
+      expect(response.statusCode).toBe(400);
+    });
+  });
+
+  describe("PUT /api/channel-installations/:installationId", () => {
+    it("should update installation", async () => {
+      const response = await app.inject({
+        method: "PUT",
+        url: "/api/channel-installations/install-1",
+        headers: {
+          "x-tenant-id": "tenant-a",
+          "content-type": "application/json",
+        },
+        payload: {
+          name: "Updated Name",
+        },
+      });
+
+      // Will return 404 since mock returns null, but route is accessible
+      expect([200, 404]).toContain(response.statusCode);
+    });
+  });
+
+  describe("DELETE /api/channel-installations/:installationId", () => {
+    it("should delete installation", async () => {
+      const response = await app.inject({
+        method: "DELETE",
+        url: "/api/channel-installations/install-1",
+        headers: {
+          "x-tenant-id": "tenant-a",
+        },
+      });
+
+      // Will return 404 since mock returns null, but route is accessible
+      expect([200, 404]).toContain(response.statusCode);
+    });
+  });
+});

package/src/__tests__/sandbox-provider-registration.test.ts

@@ -0,0 +1,74 @@
+import { beforeEach, describe, expect, it, jest } from "@jest/globals";
+
+const mockCreateSandboxProvider = jest.fn();
+const mockRegisterSandboxLattice = jest.fn();
+const mockHasSandboxLattice = jest.fn();
+const mockAppListen = jest.fn();
+const mockAppClose = jest.fn();
+const mockProcessExit = jest.spyOn(process, "exit").mockImplementation((() => undefined) as never);
+
+jest.mock("../routes", () => ({
+  registerLatticeRoutes: jest.fn(),
+}));
+
+jest.mock("@axiom-lattice/core", () => ({
+  createSandboxProvider: mockCreateSandboxProvider,
+  registerLoggerLattice: jest.fn(),
+  getLoggerLattice: jest.fn(() => ({
+    client: {
+      info: jest.fn(),
+      warn: jest.fn(),
+      error: jest.fn(),
+    },
+    updateContext: jest.fn(),
+  })),
+  loggerLatticeManager: {
+    hasLattice: jest.fn(() => false),
+    removeLattice: jest.fn(),
+  },
+  sandboxLatticeManager: {
+    hasLattice: mockHasSandboxLattice,
+    registerLattice: mockRegisterSandboxLattice,
+  },
+  sqlDatabaseManager: {
+    setConfigStore: jest.fn(),
+  },
+  getStoreLattice: jest.fn(() => {
+    throw new Error("database store unavailable in test");
+  }),
+  agentInstanceManager: {
+    restore: jest.fn().mockResolvedValue({ restored: 0, errors: 0 }),
+  },
+}));
+
+describe("gateway sandbox provider registration", () => {
+  beforeEach(() => {
+    jest.resetModules();
+    jest.clearAllMocks();
+    mockHasSandboxLattice.mockReturnValue(false);
+    mockCreateSandboxProvider.mockReturnValue({ provider: "mock" });
+    process.env.SANDBOX_PROVIDER_TYPE = "microsandbox-remote";
+    process.env.MICROSANDBOX_SERVICE_BASE_URL = "http://sandbox-host:4002";
+  });
+
+  it("uses microsandbox-remote when configured", async () => {
+    const { LatticeGateway } = await import("../index");
+
+    jest.spyOn(LatticeGateway.app, "listen").mockImplementation(mockAppListen);
+    jest.spyOn(LatticeGateway.app, "close").mockImplementation(mockAppClose);
+
+    await LatticeGateway.startAsHttpEndpoint({ port: 0 });
+
+    expect(mockCreateSandboxProvider).toHaveBeenCalledWith(
+      expect.objectContaining({
+        type: "microsandbox-remote",
+        microsandboxServiceBaseURL: "http://sandbox-host:4002",
+      })
+    );
+    expect(mockRegisterSandboxLattice).toHaveBeenCalledWith("default", {
+      provider: "mock",
+    });
+
+    await LatticeGateway.app.close();
+  });
+});

package/src/__tests__/workspace.test.ts

@@ -35,8 +35,17 @@ const mockStoreLattice = {
   },
 };
 
+const mockSandbox = {
+  file: {
+    uploadFile: jest.fn(),
+    downloadFile: jest.fn(),
+    readFile: jest.fn(),
+  },
+};
+
 // Mock the dependencies
 jest.mock("@axiom-lattice/core", () => ({
+  ...jest.requireActual("@axiom-lattice/core"),
   getStoreLattice: jest.fn().mockReturnValue(mockStoreLattice),
   SandboxFilesystem: jest.fn().mockImplementation(() => ({
     lsInfo: jest.fn(),
@@ -46,14 +55,9 @@ jest.mock("@axiom-lattice/core", () => ({
     lsInfo: jest.fn(),
     read: jest.fn(),
   })),
-  getSandBoxManager: jest.fn().mockReturnValue({
-    createSandbox: jest.fn().mockResolvedValue({
-      file: {
-        downloadFile: jest.fn(),
-        uploadFile: jest.fn(),
-      },
-    }),
-  }),
+  getSandBoxManager: jest.fn(() => ({
+    getSandboxFromConfig: jest.fn().mockResolvedValue(mockSandbox),
+  })),
 }));
 
 // Import after mocks are set up
@@ -221,6 +225,113 @@ describe("WorkspaceController - Tenant Isolation", () => {
     });
   });
 
+  describe("sandbox storage path passthrough", () => {
+    const mockWorkspaceSandbox = {
+      id: mockWorkspaceId,
+      tenantId: mockTenantId,
+      storageType: "sandbox",
+    };
+
+    it("uploadFile should pass path directly to sandbox without baseDir prefix", async () => {
+      mockGetWorkspaceById.mockResolvedValue(mockWorkspaceSandbox);
+
+      // Mock Fastify multipart file
+      const mockFileData = {
+        toBuffer: jest.fn().mockResolvedValue(Buffer.from("test content")),
+        filename: "test.txt",
+        fields: {
+          path: { value: "~/project" },
+        },
+      };
+
+      const request = createMockRequest({
+        file: jest.fn().mockResolvedValue(mockFileData),
+      });
+      const reply = {
+        status: jest.fn().mockReturnThis(),
+        send: jest.fn().mockReturnThis(),
+      } as unknown as FastifyReply;
+
+      await controller.uploadFile(request, reply);
+
+      // Should use frontend-provided path directly, not /tenants/... baseDir
+      expect(mockSandbox.file.uploadFile).toHaveBeenCalledWith({
+        file: "~/project/test.txt",
+        data: expect.any(Buffer),
+      });
+    });
+
+    it("uploadFile should allow ~ in path validation", async () => {
+      mockGetWorkspaceById.mockResolvedValue(mockWorkspaceSandbox);
+
+      const mockFileData = {
+        toBuffer: jest.fn().mockResolvedValue(Buffer.from("test content")),
+        filename: "test.txt",
+        fields: {
+          path: { value: "~/project/docs" },
+        },
+      };
+
+      const request = createMockRequest({
+        file: jest.fn().mockResolvedValue(mockFileData),
+      });
+      const reply = {
+        status: jest.fn().mockReturnThis(),
+        send: jest.fn().mockReturnThis(),
+      } as unknown as FastifyReply;
+
+      await controller.uploadFile(request, reply);
+
+      // Should succeed with ~ in path
+      expect(mockSandbox.file.uploadFile).toHaveBeenCalledWith({
+        file: "~/project/docs/test.txt",
+        data: expect.any(Buffer),
+      });
+    });
+
+    it("downloadFile should pass path directly to sandbox without baseDir prefix", async () => {
+      mockGetWorkspaceById.mockResolvedValue(mockWorkspaceSandbox);
+      mockSandbox.file.downloadFile.mockResolvedValue(Buffer.from("content"));
+
+      const request = createMockRequest({
+        query: { path: "~/agent/AGENTS.md" },
+      });
+      const reply = {
+        status: jest.fn().mockReturnThis(),
+        type: jest.fn().mockReturnThis(),
+        header: jest.fn().mockReturnThis(),
+        send: jest.fn().mockReturnThis(),
+      } as unknown as FastifyReply;
+
+      await controller.downloadFile(request, reply);
+
+      expect(mockSandbox.file.downloadFile).toHaveBeenCalledWith({
+        file: "~/agent/AGENTS.md",
+      });
+    });
+
+    it("viewFile should pass path directly to sandbox without baseDir prefix", async () => {
+      mockGetWorkspaceById.mockResolvedValue(mockWorkspaceSandbox);
+      mockSandbox.file.downloadFile.mockResolvedValue(Buffer.from("content"));
+
+      const request = createMockRequest({
+        query: { path: "~/project/index.html" },
+      });
+      const reply = {
+        status: jest.fn().mockReturnThis(),
+        type: jest.fn().mockReturnThis(),
+        header: jest.fn().mockReturnThis(),
+        send: jest.fn().mockReturnThis(),
+      } as unknown as FastifyReply;
+
+      await controller.viewFile(request, reply);
+
+      expect(mockSandbox.file.downloadFile).toHaveBeenCalledWith({
+        file: "~/project/index.html",
+      });
+    });
+  });
+
   describe("getTenantId helper", () => {
     it("should extract tenantId from user context when available", () => {
       const request = {

package/src/channels/__tests__/routes.test.ts

@@ -0,0 +1,71 @@
+import fastify from "fastify";
+import { registerChannelRoutes } from "../routes";
+
+describe("registerChannelRoutes", () => {
+  const envBackup = { ...process.env };
+
+  afterEach(() => {
+    process.env = { ...envBackup };
+  });
+
+  it("registers the lark route dynamically", async () => {
+    const app = fastify();
+    registerChannelRoutes(app, {
+      lark: {
+        getInstallationConfig: jest.fn().mockResolvedValue({
+          installationId: "install-1",
+          tenantId: "tenant-a",
+          assistantId: "assistant-a",
+          appId: "cli_app_1",
+          appSecret: "secret",
+          verificationToken: "token-1",
+          mappingMode: "hybrid",
+        }),
+        parseRequestBody: jest.fn().mockReturnValue({
+          type: "url_verification",
+          challenge: "challenge-token",
+          token: "token-1",
+        }),
+        verifyParsedBody: jest.fn().mockReturnValue(true),
+        parseEvent: jest.fn(),
+        claimInboundReceipt: jest.fn(),
+        markInboundReceiptCompleted: jest.fn(),
+        markInboundReceiptFailed: jest.fn(),
+        resolveThread: jest.fn(),
+        runAgentAndCollectText: jest.fn(),
+        sendTextReply: jest.fn(),
+      },
+    });
+
+    const response = await app.inject({
+      method: "POST",
+      url: "/api/channels/lark/installations/install-1/events",
+      payload: {
+        challenge: "challenge-token",
+        type: "url_verification",
+      },
+    });
+
+    expect(response.statusCode).toBe(200);
+    expect(response.json()).toEqual({ challenge: "challenge-token" });
+
+    await app.close();
+  });
+
+  it("skips lark route registration when lark config is disabled", async () => {
+    process.env.LARK_ENABLED = "false";
+
+    const app = fastify();
+    registerChannelRoutes(app);
+
+    const response = await app.inject({
+      method: "POST",
+      url: "/api/channels/lark/installations/install-1/events",
+      payload: {},
+    });
+
+    expect(response.statusCode).toBe(404);
+
+    await app.close();
+  });
+});