@axiom-lattice/gateway 2.1.28 → 2.1.30

package/src/controllers/workspace.ts

@@ -0,0 +1,598 @@
+/**
+ * WorkspaceController
+ *
+ * Controller for workspace and project management
+ * Handles CRUD operations, file browsing, and file uploads
+ */
+
+import { FastifyInstance, FastifyRequest, FastifyReply } from "fastify";
+import * as fs from "fs/promises";
+import * as path from "path";
+import { Readable } from "stream";
+import { getStoreLattice } from "@axiom-lattice/core";
+import { SandboxFilesystem, FilesystemBackend } from "@axiom-lattice/core";
+import { getSandBoxManager } from "@axiom-lattice/core";
+import { sandboxService } from "../services/sandbox_service";
+import { v4 as uuidv4 } from "uuid";
+import type {
+  CreateWorkspaceRequest,
+  UpdateWorkspaceRequest,
+  CreateProjectRequest,
+  UpdateProjectRequest,
+  Workspace,
+  Project,
+} from "@axiom-lattice/protocols";
+
+interface WorkspaceParams {
+  workspaceId: string;
+}
+
+interface ProjectParams {
+  workspaceId: string;
+  projectId: string;
+}
+
+interface ListPathQuery {
+  path?: string;
+}
+
+interface ReadFileQuery {
+  path: string;
+  offset?: number;
+  limit?: number;
+}
+
+export class WorkspaceController {
+  private workspaceStore;
+  private projectStore;
+
+  constructor() {
+    this.workspaceStore = getStoreLattice("default", "workspace").store;
+    this.projectStore = getStoreLattice("default", "project").store;
+  }
+
+  private getTenantId(request: FastifyRequest): string {
+    return (request.headers["x-tenant-id"] as string) || "default";
+  }
+
+  // ==================== Workspace CRUD ====================
+
+  async listWorkspaces(request: FastifyRequest, reply: FastifyReply) {
+    const tenantId = this.getTenantId(request);
+    const workspaces = await this.workspaceStore.getAllWorkspaces(tenantId);
+    return { success: true, data: workspaces };
+  }
+
+  async createWorkspace(
+    request: FastifyRequest<{ Body: CreateWorkspaceRequest }>,
+    reply: FastifyReply
+  ) {
+    const tenantId = this.getTenantId(request);
+    const data = request.body;
+    const id = uuidv4();
+
+    const workspace = await this.workspaceStore.createWorkspace(
+      tenantId,
+      id,
+      data
+    );
+
+    return reply.status(201).send({ success: true, data: workspace });
+  }
+
+  async getWorkspace(
+    request: FastifyRequest<{ Params: WorkspaceParams }>,
+    reply: FastifyReply
+  ) {
+    const tenantId = this.getTenantId(request);
+    const { workspaceId } = request.params;
+
+    const workspace = await this.workspaceStore.getWorkspaceById(
+      tenantId,
+      workspaceId
+    );
+
+    if (!workspace) {
+      return reply.status(404).send({ success: false, error: "Workspace not found" });
+    }
+
+    return { success: true, data: workspace };
+  }
+
+  async updateWorkspace(
+    request: FastifyRequest<{
+      Params: WorkspaceParams;
+      Body: UpdateWorkspaceRequest;
+    }>,
+    reply: FastifyReply
+  ) {
+    const tenantId = this.getTenantId(request);
+    const { workspaceId } = request.params;
+    const updates = request.body;
+
+    const workspace = await this.workspaceStore.updateWorkspace(
+      tenantId,
+      workspaceId,
+      updates
+    );
+
+    if (!workspace) {
+      return reply.status(404).send({ success: false, error: "Workspace not found" });
+    }
+
+    return { success: true, data: workspace };
+  }
+
+  async deleteWorkspace(
+    request: FastifyRequest<{ Params: WorkspaceParams }>,
+    reply: FastifyReply
+  ) {
+    const tenantId = this.getTenantId(request);
+    const { workspaceId } = request.params;
+
+    const deleted = await this.workspaceStore.deleteWorkspace(
+      tenantId,
+      workspaceId
+    );
+
+    if (!deleted) {
+      return reply.status(404).send({ success: false, error: "Workspace not found" });
+    }
+
+    return { success: true };
+  }
+
+  // ==================== Project CRUD ====================
+
+  async listProjects(
+    request: FastifyRequest<{ Params: WorkspaceParams }>,
+    reply: FastifyReply
+  ) {
+    const tenantId = this.getTenantId(request);
+    const { workspaceId } = request.params;
+
+    const projects = await this.projectStore.getProjectsByWorkspace(
+      tenantId,
+      workspaceId
+    );
+
+    return { success: true, data: projects };
+  }
+
+  async createProject(
+    request: FastifyRequest<{
+      Params: WorkspaceParams;
+      Body: CreateProjectRequest;
+    }>,
+    reply: FastifyReply
+  ) {
+    const tenantId = this.getTenantId(request);
+    const { workspaceId } = request.params;
+    const data = request.body;
+    const id = uuidv4();
+
+    const project = await this.projectStore.createProject(
+      tenantId,
+      workspaceId,
+      id,
+      data
+    );
+
+    return reply.status(201).send({ success: true, data: project });
+  }
+
+  async getProject(
+    request: FastifyRequest<{ Params: ProjectParams }>,
+    reply: FastifyReply
+  ) {
+    const tenantId = this.getTenantId(request);
+    const { projectId } = request.params;
+
+    const project = await this.projectStore.getProjectById(tenantId, projectId);
+
+    if (!project) {
+      return reply.status(404).send({ success: false, error: "Project not found" });
+    }
+
+    return { success: true, data: project };
+  }
+
+  async updateProject(
+    request: FastifyRequest<{
+      Params: ProjectParams;
+      Body: UpdateProjectRequest;
+    }>,
+    reply: FastifyReply
+  ) {
+    const tenantId = this.getTenantId(request);
+    const { projectId } = request.params;
+    const updates = request.body;
+
+    const project = await this.projectStore.updateProject(
+      tenantId,
+      projectId,
+      updates
+    );
+
+    if (!project) {
+      return reply.status(404).send({ success: false, error: "Project not found" });
+    }
+
+    return { success: true, data: project };
+  }
+
+  async deleteProject(
+    request: FastifyRequest<{ Params: ProjectParams }>,
+    reply: FastifyReply
+  ) {
+    const tenantId = this.getTenantId(request);
+    const { projectId } = request.params;
+
+    const deleted = await this.projectStore.deleteProject(tenantId, projectId);
+
+    if (!deleted) {
+      return reply.status(404).send({ success: false, error: "Project not found" });
+    }
+
+    return { success: true };
+  }
+
+  // ==================== File Operations ====================
+
+  private async getBackend(workspaceId: string, projectId: string) {
+    const tenantId = "default";
+    const workspace = await this.workspaceStore.getWorkspaceById(
+      tenantId,
+      workspaceId
+    );
+
+    if (!workspace) {
+      throw new Error("Workspace not found");
+    }
+
+    if (workspace.storageType === "sandbox") {
+      const sandboxManager = getSandBoxManager("default");
+      const sandboxName = "global";
+      const sandbox = await sandboxManager.createSandbox(sandboxName);
+      return { backend: new SandboxFilesystem({
+        sandboxInstance: sandbox,
+        workingDirectory: `/workspaces/${workspaceId}/${projectId}`,
+      }), workspace };
+    } else {
+      return { backend: new FilesystemBackend({
+        rootDir: `/lattice_store/workspaces/${workspaceId}/${projectId}`,
+        virtualMode: true,
+      }), workspace };
+    }
+  }
+
+  private getFilenameFromPath(filePath: string): string {
+    const segments = filePath.split("/");
+    return segments[segments.length - 1] || "download";
+  }
+
+  private getMimeType(filename: string): string {
+    const ext = filename.split(".").pop()?.toLowerCase() || "";
+    const mimeTypes: Record<string, string> = {
+      pdf: "application/pdf",
+      csv: "text/csv",
+      xlsx: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+      xls: "application/vnd.ms-excel",
+      txt: "text/plain",
+      json: "application/json",
+      png: "image/png",
+      jpg: "image/jpeg",
+      jpeg: "image/jpeg",
+      gif: "image/gif",
+      svg: "image/svg+xml",
+      html: "text/html",
+      htm: "text/html",
+      mp3: "audio/mpeg",
+      mp4: "video/mp4",
+      webm: "video/webm",
+    };
+    return mimeTypes[ext] || "application/octet-stream";
+  }
+
+  async downloadFile(
+    request: FastifyRequest<{
+      Params: ProjectParams;
+      Querystring: { path: string };
+    }>,
+    reply: FastifyReply
+  ) {
+    const { workspaceId, projectId } = request.params;
+    const filePath = request.query.path;
+
+    if (!filePath) {
+      return reply.status(400).send({ success: false, error: "Path is required" });
+    }
+
+    try {
+      const { workspace } = await this.getBackend(workspaceId, projectId);
+      const resolvedPath = filePath.startsWith("/") ? filePath : `/${filePath}`;
+
+      if (workspace.storageType === "sandbox") {
+        const sandboxManager = getSandBoxManager("default");
+        const sandbox = await sandboxManager.createSandbox("global");
+        const realPath = path.join("/home/gem/workspaces", workspaceId, projectId, resolvedPath);
+        const filename = this.getFilenameFromPath(resolvedPath);
+        const inferredContentType = this.getMimeType(filename);
+
+        const downloadResult = await sandbox.file.downloadFile({
+          path: realPath,
+        });
+
+        if (!downloadResult.ok) {
+          return reply.status(502).send({
+            success: false,
+            error: `Download error: ${JSON.stringify(downloadResult.error)}`,
+          });
+        }
+
+        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*=UTF-8''${encodeURIComponent(filename)}`;
+          return reply.status(200).type(contentType).header("Content-Disposition", contentDisposition).send(nodeStream);
+        }
+
+        const bodyUnknown = downloadResult.body as unknown;
+        let buf: Buffer;
+        let contentType = inferredContentType;
+        let contentDisposition = `inline; 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({ success: false, error: "Unexpected download response format" });
+        }
+
+        return reply.status(200).type(contentType).header("Content-Disposition", contentDisposition).send(buf);
+      }
+
+      const { backend } = await this.getBackend(workspaceId, projectId);
+      const content = await backend.read(resolvedPath, 0, Infinity);
+      const filename = this.getFilenameFromPath(resolvedPath);
+      const mimeType = this.getMimeType(filename);
+      const buffer = Buffer.from(content, "utf-8");
+
+      return reply
+        .status(200)
+        .type(mimeType)
+        .header("Content-Disposition", `inline; filename*=UTF-8''${encodeURIComponent(filename)}`)
+        .send(buffer);
+    } catch (error: unknown) {
+      const message = error instanceof Error ? error.message : String(error);
+      return reply.status(502).send({ success: false, error: `Download proxy error: ${message}` });
+    }
+  }
+
+  async listPath(
+    request: FastifyRequest<{
+      Params: ProjectParams;
+      Querystring: ListPathQuery;
+    }>
+  ) {
+    const { workspaceId, projectId } = request.params;
+    const path = (request.query.path as string) || "/";
+
+    const { backend } = await this.getBackend(workspaceId, projectId);
+    const files = await backend.lsInfo(path);
+
+    return { success: true, data: files };
+  }
+
+  async readFile(
+    request: FastifyRequest<{
+      Params: ProjectParams;
+      Querystring: ReadFileQuery;
+    }>
+  ) {
+    const { workspaceId, projectId } = request.params;
+    const { path, offset = 0, limit = 1000 } = request.query;
+
+    const { backend } = await this.getBackend(workspaceId, projectId);
+    const content = await backend.read(path, Number(offset), Number(limit));
+
+    return { success: true, data: { content, offset, limit } };
+  }
+
+  /**
+   * Upload a file to the workspace project storage.
+   *
+   * Route: POST /api/workspaces/:workspaceId/projects/:projectId/uploadfile
+   * Accepts multipart/form-data with:
+   * - `file`: the file to upload (required)
+   * - `path`: optional directory path relative to project root (e.g., "docs", "src/utils")
+   * For sandbox storage, delegates to the sandbox upload API.
+   * For filesystem storage, writes directly under /lattice_store/workspaces/{workspaceId}/{projectId}.
+   */
+  async uploadFile(
+    request: FastifyRequest<{
+      Params: ProjectParams;
+    }>,
+    reply: FastifyReply
+  ) {
+    const tenantId = this.getTenantId(request);
+    const { workspaceId, projectId } = request.params;
+
+    const workspace = await this.workspaceStore.getWorkspaceById(
+      tenantId,
+      workspaceId
+    );
+
+    if (!workspace) {
+      return reply
+        .status(404)
+        .send({ success: false, error: "Workspace not found" });
+    }
+
+    try {
+      const data = await (request as any).file();
+      if (!data) {
+        return reply
+          .status(400)
+          .send({ success: false, error: "No file in request" });
+      }
+
+      const buffer: Buffer = await data.toBuffer();
+      const filename: string = data.filename || "file";
+
+      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;
+
+      if (pathValue && !/^[a-zA-Z0-9_./-]+$/.test(pathValue)) {
+        return reply
+          .status(400)
+          .send({ success: false, error: "Invalid path parameter" });
+      }
+
+      if (workspace.storageType === "sandbox") {
+        const sandboxManager = getSandBoxManager("default");
+        const sandboxName = "global";
+        const sandbox = await sandboxManager.createSandbox(sandboxName);
+
+        const baseDir = path.join("/home/gem/workspaces", workspaceId, projectId);
+        const realPath = pathValue
+          ? path.join(baseDir, pathValue, filename)
+          : path.join(baseDir, filename);
+
+        const uploadResult = await sandbox.file.uploadFile({
+          file: buffer,
+          path: realPath,
+        }, { timeoutInSeconds: 300 });
+
+        if (!uploadResult.ok) {
+          return reply.status(502).send({
+            success: false,
+            error: `Upload error: ${JSON.stringify(uploadResult.error)}`,
+          });
+        }
+
+        const relativePath =
+          uploadResult.body?.data?.file_path?.replace(path.join("/home/gem/workspaces", workspaceId, projectId), "") ||
+          (pathValue ? `/${pathValue}/${filename}` : `/${filename}`);
+
+        const result = {
+          path: relativePath,
+          name: filename,
+          is_dir: false,
+          size: buffer.length,
+          modified_at: new Date().toISOString(),
+        };
+
+        return reply.status(200).send({ success: true, data: result });
+      }
+
+      // Filesystem storage: write under /lattice_store/workspaces/{workspaceId}/{projectId} and expose as virtual path "/<filename>"
+      const rootDir = `/lattice_store/workspaces/${workspaceId}/${projectId}`;
+      const targetDir = pathValue ? path.join(rootDir, pathValue) : rootDir;
+      const targetPath = path.join(targetDir, filename);
+      await fs.mkdir(path.dirname(targetPath), { recursive: true });
+      await fs.writeFile(targetPath, buffer);
+      const stat = await fs.stat(targetPath);
+
+      const result = {
+        path: pathValue ? `/${pathValue}/${filename}` : `/${filename}`,
+        name: filename,
+        is_dir: false,
+        size: stat.size,
+        modified_at: stat.mtime.toISOString(),
+      };
+
+      return reply.status(200).send({ success: true, data: result });
+    } catch (error: any) {
+      return reply.status(500).send({
+        success: false,
+        error: `Upload handler error: ${error?.message || String(error)}`,
+      });
+    }
+  }
+}
+
+export function registerWorkspaceRoutes(app: FastifyInstance) {
+  const controller = new WorkspaceController();
+
+  // Workspace routes
+  app.get("/api/workspaces", controller.listWorkspaces.bind(controller));
+  app.post("/api/workspaces", controller.createWorkspace.bind(controller));
+  app.get(
+    "/api/workspaces/:workspaceId",
+    controller.getWorkspace.bind(controller)
+  );
+  app.patch(
+    "/api/workspaces/:workspaceId",
+    controller.updateWorkspace.bind(controller)
+  );
+  app.delete(
+    "/api/workspaces/:workspaceId",
+    controller.deleteWorkspace.bind(controller)
+  );
+
+  // Project routes
+  app.get(
+    "/api/workspaces/:workspaceId/projects",
+    controller.listProjects.bind(controller)
+  );
+  app.post(
+    "/api/workspaces/:workspaceId/projects",
+    controller.createProject.bind(controller)
+  );
+  app.get(
+    "/api/workspaces/:workspaceId/projects/:projectId",
+    controller.getProject.bind(controller)
+  );
+  app.patch(
+    "/api/workspaces/:workspaceId/projects/:projectId",
+    controller.updateProject.bind(controller)
+  );
+  app.delete(
+    "/api/workspaces/:workspaceId/projects/:projectId",
+    controller.deleteProject.bind(controller)
+  );
+
+  // File operations
+  app.get(
+    "/api/workspaces/:workspaceId/projects/:projectId/listpath",
+    controller.listPath.bind(controller)
+  );
+  app.get(
+    "/api/workspaces/:workspaceId/projects/:projectId/readfile",
+    controller.readFile.bind(controller)
+  );
+  app.post(
+    "/api/workspaces/:workspaceId/projects/:projectId/uploadfile",
+    controller.uploadFile.bind(controller)
+  );
+  app.get(
+    "/api/workspaces/:workspaceId/projects/:projectId/downloadfile",
+    controller.downloadFile.bind(controller)
+  );
+}

package/src/index.ts

@@ -108,16 +108,8 @@ app.addHook("onResponse", (request, reply, done) => {
 // cors
 app.register(cors, {
   origin: true,
-  methods: ["GET", "POST", "PUT", "DELETE", "OPTIONS"],
-  allowedHeaders: [
-    "Content-Type",
-    "Authorization",
-    "X-Requested-With",
-    "x-tenant-id",
-    "x-request-id",
-    "x-assistant-id",
-    "x-thread-id",
-  ],
+  methods: ["GET", "POST", "PUT", "DELETE", "OPTIONS", "PATCH"],
+  allowedHeaders: "*",
   exposedHeaders: ["Content-Type"],
   credentials: true,
 });

package/src/routes/index.ts

@@ -29,6 +29,12 @@ import {
   getSandboxUrlSchema,
 } from "../schemas";
 import { registerSandboxProxyRoutes } from "../controllers/sandbox";
+import { registerWorkspaceRoutes } from "../controllers/workspace";
+import { registerDatabaseConfigRoutes } from "../controllers/database-configs";
+import { registerMetricsServerConfigRoutes } from "../controllers/metrics-configs";
+import { registerUserRoutes } from "../controllers/users";
+import { registerTenantRoutes } from "../controllers/tenants";
+import { registerAuthRoutes } from "../controllers/auth";
 
 export const registerLatticeRoutes = (app: FastifyInstance): void => {
   // 运行路由
@@ -293,4 +299,19 @@ export const registerLatticeRoutes = (app: FastifyInstance): void => {
   );
 
   registerSandboxProxyRoutes(app);
+
+  registerWorkspaceRoutes(app);
+
+  registerDatabaseConfigRoutes(app);
+
+  registerMetricsServerConfigRoutes(app);
+
+  registerUserRoutes(app);
+
+  registerTenantRoutes(app);
+
+  registerAuthRoutes(app, {
+    autoApproveUsers: process.env.AUTO_APPROVE_USERS !== "false",
+    allowTenantRegistration: process.env.ALLOW_TENANT_REGISTRATION !== "false",
+  });
 };