chore: move all services inside the apps folder (#7321)

* chore: move all services inside the apps folder

* chore: rename apiserver to server

apps/live/.env.example

@@ -0,0 +1,13 @@
+API_BASE_URL="http://localhost:8000"
+
+WEB_BASE_URL="http://localhost:3000"
+
+LIVE_BASE_URL="http://localhost:3100"
+LIVE_BASE_PATH="/live"
+
+LIVE_SERVER_SECRET_KEY="secret-key"
+
+# If you prefer not to provide a Redis URL, you can set the REDIS_HOST and REDIS_PORT environment variables instead.
+REDIS_PORT=6379
+REDIS_HOST=localhost
+REDIS_URL="redis://localhost:6379/"

apps/live/.eslintignore

@@ -0,0 +1,4 @@
+.turbo/*
+out/*
+dist/*
+public/*

apps/live/.eslintrc.json

@@ -0,0 +1,5 @@
+{
+  "root": true,
+  "extends": ["@plane/eslint-config/server.js"],
+  "parser": "@typescript-eslint/parser"
+}

apps/live/.prettierignore

@@ -0,0 +1,6 @@
+.next
+.turbo
+out/
+dist/
+build/
+node_modules/

apps/live/.prettierrc

@@ -0,0 +1,5 @@
+{
+  "printWidth": 120,
+  "tabWidth": 2,
+  "trailingComma": "es5"
+}

apps/live/Dockerfile.dev

@@ -0,0 +1,15 @@
+FROM node:20-alpine
+RUN apk add --no-cache libc6-compat
+# Set working directory
+WORKDIR /app
+
+COPY . .
+RUN yarn global add turbo
+RUN yarn install
+EXPOSE 3003
+
+ENV TURBO_TELEMETRY_DISABLED 1
+
+VOLUME [ "/app/node_modules", "/app/live/node_modules"]
+
+CMD ["yarn","dev", "--filter=live"]

apps/live/Dockerfile.live

@@ -0,0 +1,43 @@
+FROM node:20-alpine AS base
+# The web Dockerfile is copy-pasted into our main docs at /docs/handbook/deploying-with-docker.
+# Make sure you update this Dockerfile, the Dockerfile in the web workspace and copy that over to Dockerfile in the docs.
+
+FROM base AS builder
+# Check https://github.com/nodejs/docker-node/tree/b4117f9333da4138b03a546ec926ef50a31506c3#nodealpine to understand why libc6-compat might be needed.
+RUN apk update
+RUN apk add --no-cache libc6-compat
+# Set working directory
+WORKDIR /app
+RUN yarn global add turbo
+COPY . .
+RUN turbo prune live --docker
+
+# Add lockfile and package.json's of isolated subworkspace
+FROM base AS installer
+RUN apk update
+RUN apk add --no-cache libc6-compat
+WORKDIR /app
+
+# First install dependencies (as they change less often)
+COPY .gitignore .gitignore
+COPY --from=builder /app/out/json/ .
+COPY --from=builder /app/out/yarn.lock ./yarn.lock
+RUN yarn install
+
+# Build the project and its dependencies
+COPY --from=builder /app/out/full/ .
+COPY turbo.json turbo.json
+
+ENV TURBO_TELEMETRY_DISABLED 1
+
+RUN yarn turbo build --filter=live
+
+FROM base AS runner
+WORKDIR /app
+
+COPY --from=installer /app .
+# COPY --from=installer /app/live/node_modules ./node_modules
+
+ENV TURBO_TELEMETRY_DISABLED 1
+
+EXPOSE 3000

apps/live/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "live",
+  "version": "0.27.0",
+  "license": "AGPL-3.0",
+  "description": "A realtime collaborative server powers Plane's rich text editor",
+  "main": "./src/server.ts",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "dev": "tsup --watch --onSuccess 'node --env-file=.env dist/server.js'",
+    "build": "tsc --noEmit && tsup",
+    "start": "node --env-file=.env dist/server.js",
+    "check:lint": "eslint . --max-warnings 0",
+    "check:types": "tsc --noEmit",
+    "check:format": "prettier --check \"**/*.{ts,tsx,md,json,css,scss}\"",
+    "fix:lint": "eslint . --fix",
+    "fix:format": "prettier --write \"**/*.{ts,tsx,md,json,css,scss}\"",
+    "clean": "rm -rf .turbo && rm -rf node_modules && rm -rf dist"
+  },
+  "keywords": [],
+  "author": "",
+  "dependencies": {
+    "@hocuspocus/extension-database": "^2.15.0",
+    "@hocuspocus/extension-logger": "^2.15.0",
+    "@hocuspocus/extension-redis": "^2.15.0",
+    "@hocuspocus/server": "^2.15.0",
+    "@plane/editor": "*",
+    "@plane/types": "*",
+    "@tiptap/core": "2.10.4",
+    "@tiptap/html": "2.11.0",
+    "axios": "^1.8.3",
+    "compression": "^1.7.4",
+    "cors": "^2.8.5",
+    "dotenv": "^16.4.5",
+    "express": "^4.21.2",
+    "express-ws": "^5.0.2",
+    "helmet": "^7.1.0",
+    "ioredis": "^5.4.1",
+    "lodash": "^4.17.21",
+    "morgan": "^1.10.0",
+    "pino-http": "^10.3.0",
+    "pino-pretty": "^11.2.2",
+    "uuid": "^10.0.0",
+    "y-prosemirror": "^1.2.15",
+    "y-protocols": "^1.0.6",
+    "yjs": "^13.6.20"
+  },
+  "devDependencies": {
+    "@plane/eslint-config": "*",
+    "@plane/typescript-config": "*",
+    "@types/compression": "^1.7.5",
+    "@types/cors": "^2.8.17",
+    "@types/dotenv": "^8.2.0",
+    "@types/express": "^4.17.21",
+    "@types/express-ws": "^3.0.4",
+    "@types/node": "^20.14.9",
+    "@types/pino-http": "^5.8.4",
+    "concurrently": "^9.0.1",
+    "nodemon": "^3.1.7",
+    "ts-node": "^10.9.2",
+    "tsup": "8.4.0",
+    "typescript": "5.8.3"
+  }
+}

apps/live/src/ce/lib/fetch-document.ts

@@ -0,0 +1,14 @@
+// types
+import { TDocumentTypes } from "@/core/types/common.js";
+
+type TArgs = {
+  cookie: string | undefined;
+  documentType: TDocumentTypes | undefined;
+  pageId: string;
+  params: URLSearchParams;
+}
+
+export const fetchDocument = async (args: TArgs): Promise<Uint8Array | null> => {
+  const { documentType } = args;
+  throw Error(`Fetch failed: Invalid document type ${documentType} provided.`);
+}

apps/live/src/ce/lib/update-document.ts

@@ -0,0 +1,15 @@
+// types
+import { TDocumentTypes } from "@/core/types/common.js";
+
+type TArgs = {
+  cookie: string | undefined;
+  documentType: TDocumentTypes | undefined;
+  pageId: string;
+  params: URLSearchParams;
+  updatedDescription: Uint8Array;
+}
+
+export const updateDocument = async (args: TArgs): Promise<void> => {
+  const { documentType } = args;
+  throw Error(`Update failed: Invalid document type ${documentType} provided.`);
+}

apps/live/src/ce/types/common.d.ts

@@ -0,0 +1 @@
+export type TAdditionalDocumentTypes = {};

apps/live/src/core/extensions/index.ts

@@ -0,0 +1,143 @@
+// Third-party libraries
+import { Redis } from "ioredis";
+// Hocuspocus extensions and core
+import { Database } from "@hocuspocus/extension-database";
+import { Extension } from "@hocuspocus/server";
+import { Logger } from "@hocuspocus/extension-logger";
+import { Redis as HocusPocusRedis } from "@hocuspocus/extension-redis";
+// core helpers and utilities
+import { manualLogger } from "@/core/helpers/logger.js";
+import { getRedisUrl } from "@/core/lib/utils/redis-url.js";
+// core libraries
+import {
+  fetchPageDescriptionBinary,
+  updatePageDescription,
+} from "@/core/lib/page.js";
+// plane live libraries
+import { fetchDocument } from "@/plane-live/lib/fetch-document.js";
+import { updateDocument } from "@/plane-live/lib/update-document.js";
+// types
+import {
+  type HocusPocusServerContext,
+  type TDocumentTypes,
+} from "@/core/types/common.js";
+
+export const getExtensions: () => Promise<Extension[]> = async () => {
+  const extensions: Extension[] = [
+    new Logger({
+      onChange: false,
+      log: (message) => {
+        manualLogger.info(message);
+      },
+    }),
+    new Database({
+      fetch: async ({ context, documentName: pageId, requestParameters }) => {
+        const cookie = (context as HocusPocusServerContext).cookie;
+        // query params
+        const params = requestParameters;
+        const documentType = params.get("documentType")?.toString() as
+          | TDocumentTypes
+          | undefined;
+        // TODO: Fix this lint error.
+        // eslint-disable-next-line no-async-promise-executor
+        return new Promise(async (resolve) => {
+          try {
+            let fetchedData = null;
+            if (documentType === "project_page") {
+              fetchedData = await fetchPageDescriptionBinary(
+                params,
+                pageId,
+                cookie,
+              );
+            } else {
+              fetchedData = await fetchDocument({
+                cookie,
+                documentType,
+                pageId,
+                params,
+              });
+            }
+            resolve(fetchedData);
+          } catch (error) {
+            manualLogger.error("Error in fetching document", error);
+          }
+        });
+      },
+      store: async ({
+        context,
+        state,
+        documentName: pageId,
+        requestParameters,
+      }) => {
+        const cookie = (context as HocusPocusServerContext).cookie;
+        // query params
+        const params = requestParameters;
+        const documentType = params.get("documentType")?.toString() as
+          | TDocumentTypes
+          | undefined;
+
+        // TODO: Fix this lint error.
+        // eslint-disable-next-line no-async-promise-executor
+        return new Promise(async () => {
+          try {
+            if (documentType === "project_page") {
+              await updatePageDescription(params, pageId, state, cookie);
+            } else {
+              await updateDocument({
+                cookie,
+                documentType,
+                pageId,
+                params,
+                updatedDescription: state,
+              });
+            }
+          } catch (error) {
+            manualLogger.error("Error in updating document:", error);
+          }
+        });
+      },
+    }),
+  ];
+
+  const redisUrl = getRedisUrl();
+
+  if (redisUrl) {
+    try {
+      const redisClient = new Redis(redisUrl);
+
+      await new Promise<void>((resolve, reject) => {
+        redisClient.on("error", (error: any) => {
+          if (
+            error?.code === "ENOTFOUND" ||
+            error.message.includes("WRONGPASS") ||
+            error.message.includes("NOAUTH")
+          ) {
+            redisClient.disconnect();
+          }
+          manualLogger.warn(
+            `Redis Client wasn't able to connect, continuing without Redis (you won't be able to sync data between multiple plane live servers)`,
+            error,
+          );
+          reject(error);
+        });
+
+        redisClient.on("ready", () => {
+          extensions.push(new HocusPocusRedis({ redis: redisClient }));
+          manualLogger.info("Redis Client connected ✅");
+          resolve();
+        });
+      });
+    } catch (error) {
+      manualLogger.warn(
+        `Redis Client wasn't able to connect, continuing without Redis (you won't be able to sync data between multiple plane live servers)`,
+        error,
+      );
+    }
+  } else {
+    manualLogger.warn(
+      "Redis URL is not set, continuing without Redis (you won't be able to sync data between multiple plane live servers)",
+    );
+  }
+
+  return extensions;
+};

apps/live/src/core/helpers/convert-document.ts

@@ -0,0 +1,44 @@
+// plane editor
+import {
+  getAllDocumentFormatsFromDocumentEditorBinaryData,
+  getAllDocumentFormatsFromRichTextEditorBinaryData,
+  getBinaryDataFromDocumentEditorHTMLString,
+  getBinaryDataFromRichTextEditorHTMLString,
+} from "@plane/editor";
+// plane types
+import { TDocumentPayload } from "@plane/types";
+
+type TArgs = {
+  document_html: string;
+  variant: "rich" | "document";
+};
+
+export const convertHTMLDocumentToAllFormats = (args: TArgs): TDocumentPayload => {
+  const { document_html, variant } = args;
+
+  let allFormats: TDocumentPayload;
+
+  if (variant === "rich") {
+    const contentBinary = getBinaryDataFromRichTextEditorHTMLString(document_html);
+    const { contentBinaryEncoded, contentHTML, contentJSON } =
+      getAllDocumentFormatsFromRichTextEditorBinaryData(contentBinary);
+    allFormats = {
+      description: contentJSON,
+      description_html: contentHTML,
+      description_binary: contentBinaryEncoded,
+    };
+  } else if (variant === "document") {
+    const contentBinary = getBinaryDataFromDocumentEditorHTMLString(document_html);
+    const { contentBinaryEncoded, contentHTML, contentJSON } =
+      getAllDocumentFormatsFromDocumentEditorBinaryData(contentBinary);
+    allFormats = {
+      description: contentJSON,
+      description_html: contentHTML,
+      description_binary: contentBinaryEncoded,
+    };
+  } else {
+    throw new Error(`Invalid variant provided: ${variant}`);
+  }
+
+  return allFormats;
+};

apps/live/src/core/helpers/error-handler.ts

@@ -0,0 +1,21 @@
+import { ErrorRequestHandler } from "express";
+import { manualLogger } from "@/core/helpers/logger.js";
+
+export const errorHandler: ErrorRequestHandler = (err, _req, res) => {
+  // Log the error
+  manualLogger.error(err);
+
+  // Set the response status
+  res.status(err.status || 500);
+
+  // Send the response
+  res.json({
+    error: {
+      message:
+        process.env.NODE_ENV === "production"
+          ? "An unexpected error occurred"
+          : err.message,
+      ...(process.env.NODE_ENV !== "production" && { stack: err.stack }),
+    },
+  });
+};

apps/live/src/core/helpers/logger.ts

@@ -0,0 +1,39 @@
+import { pinoHttp } from "pino-http";
+import { Logger } from "pino";
+
+const transport = {
+  target: "pino-pretty",
+  options: {
+    colorize: true,
+  },
+};
+
+const hooks = {
+  logMethod(inputArgs: any, method: any): any {
+    if (inputArgs.length >= 2) {
+      const arg1 = inputArgs.shift();
+      const arg2 = inputArgs.shift();
+      return method.apply(this, [arg2, arg1, ...inputArgs]);
+    }
+    return method.apply(this, inputArgs);
+  },
+};
+
+export const logger = pinoHttp({
+  level: "info",
+  transport: transport,
+  hooks: hooks,
+  serializers: {
+    req(req) {
+      return `${req.method} ${req.url}`;
+    },
+    res(res) {
+      return `${res.statusCode} ${res?.statusMessage || ""}`;
+    },
+    responseTime(time) {
+      return `${time}ms`;
+    },
+  },
+});
+
+export const manualLogger: Logger = logger.logger;

apps/live/src/core/helpers/page.ts

@@ -0,0 +1,59 @@
+import { getSchema } from "@tiptap/core";
+import { generateHTML, generateJSON } from "@tiptap/html";
+import { prosemirrorJSONToYDoc, yXmlFragmentToProseMirrorRootNode } from "y-prosemirror";
+import * as Y from "yjs"
+// plane editor
+import { CoreEditorExtensionsWithoutProps, DocumentEditorExtensionsWithoutProps } from "@plane/editor/lib";
+
+const DOCUMENT_EDITOR_EXTENSIONS = [
+  ...CoreEditorExtensionsWithoutProps,
+  ...DocumentEditorExtensionsWithoutProps,
+];
+const documentEditorSchema = getSchema(DOCUMENT_EDITOR_EXTENSIONS);
+
+export const getAllDocumentFormatsFromBinaryData =  (description: Uint8Array): {
+  contentBinaryEncoded: string;
+  contentJSON: object;
+  contentHTML: string;
+} => {
+  // encode binary description data
+  const base64Data = Buffer.from(description).toString("base64");
+  const yDoc = new Y.Doc();
+  Y.applyUpdate(yDoc, description);
+  // convert to JSON
+  const type = yDoc.getXmlFragment("default");
+  const contentJSON = yXmlFragmentToProseMirrorRootNode(
+    type,
+    documentEditorSchema
+  ).toJSON();
+  // convert to HTML
+  const contentHTML = generateHTML(contentJSON, DOCUMENT_EDITOR_EXTENSIONS);
+
+  return {
+    contentBinaryEncoded: base64Data,
+    contentJSON,
+    contentHTML,
+  };
+}
+
+export const getBinaryDataFromHTMLString = (descriptionHTML: string): {
+  contentBinary: Uint8Array
+} => {
+  // convert HTML to JSON
+  const contentJSON = generateJSON(
+    descriptionHTML ?? "<p></p>",
+    DOCUMENT_EDITOR_EXTENSIONS
+  );
+  // convert JSON to Y.Doc format
+  const transformedData = prosemirrorJSONToYDoc(
+    documentEditorSchema,
+    contentJSON,
+    "default"
+  );
+  // convert Y.Doc to Uint8Array format
+  const encodedData = Y.encodeStateAsUpdate(transformedData);
+
+  return {
+    contentBinary: encodedData
+  }
+}

apps/live/src/core/hocuspocus-server.ts

@@ -0,0 +1,73 @@
+import { Server } from "@hocuspocus/server";
+import { v4 as uuidv4 } from "uuid";
+// lib
+import { handleAuthentication } from "@/core/lib/authentication.js";
+// extensions
+import { getExtensions } from "@/core/extensions/index.js";
+import {
+  DocumentCollaborativeEvents,
+  TDocumentEventsServer,
+} from "@plane/editor/lib";
+// editor types
+import { TUserDetails } from "@plane/editor";
+// types
+import { type HocusPocusServerContext } from "@/core/types/common.js";
+
+export const getHocusPocusServer = async () => {
+  const extensions = await getExtensions();
+  const serverName = process.env.HOSTNAME || uuidv4();
+  return Server.configure({
+    name: serverName,
+    onAuthenticate: async ({
+      requestHeaders,
+      context,
+      // user id used as token for authentication
+      token,
+    }) => {
+      let cookie: string | undefined = undefined;
+      let userId: string | undefined = undefined;
+
+      // Extract cookie (fallback to request headers) and userId from token (for scenarios where
+      // the cookies are not passed in the request headers)
+      try {
+        const parsedToken = JSON.parse(token) as TUserDetails;
+        userId = parsedToken.id;
+        cookie = parsedToken.cookie;
+      } catch (error) {
+        // If token parsing fails, fallback to request headers
+        console.error("Token parsing failed, using request headers:", error);
+      } finally {
+        // If cookie is still not found, fallback to request headers
+        if (!cookie) {
+          cookie = requestHeaders.cookie?.toString();
+        }
+      }
+
+      if (!cookie || !userId) {
+        throw new Error("Credentials not provided");
+      }
+
+      // set cookie in context, so it can be used throughout the ws connection
+      (context as HocusPocusServerContext).cookie = cookie;
+
+      try {
+        await handleAuthentication({
+          cookie,
+          userId,
+        });
+      } catch (error) {
+        throw Error("Authentication unsuccessful!");
+      }
+    },
+    async onStateless({ payload, document }) {
+      // broadcast the client event (derived from the server event) to all the clients so that they can update their state
+      const response =
+        DocumentCollaborativeEvents[payload as TDocumentEventsServer].client;
+      if (response) {
+        document.broadcastStateless(response);
+      }
+    },
+    extensions,
+    debounce: 10000,
+  });
+};

apps/live/src/core/lib/authentication.ts

@@ -0,0 +1,33 @@
+// services
+import { UserService } from "@/core/services/user.service.js";
+// core helpers
+import { manualLogger } from "@/core/helpers/logger.js";
+
+const userService = new UserService();
+
+type Props = {
+  cookie: string;
+  userId: string;
+};
+
+export const handleAuthentication = async (props: Props) => {
+  const { cookie, userId } = props;
+  // fetch current user info
+  let response;
+  try {
+    response = await userService.currentUser(cookie);
+  } catch (error) {
+    manualLogger.error("Failed to fetch current user:", error);
+    throw error;
+  }
+  if (response.id !== userId) {
+    throw Error("Authentication failed: Token doesn't match the current user.");
+  }
+
+  return {
+    user: {
+      id: response.id,
+      name: response.display_name,
+    },
+  };
+};

apps/live/src/core/lib/page.ts

@@ -0,0 +1,112 @@
+// helpers
+import {
+  getAllDocumentFormatsFromBinaryData,
+  getBinaryDataFromHTMLString,
+} from "@/core/helpers/page.js";
+// services
+import { PageService } from "@/core/services/page.service.js";
+import { manualLogger } from "../helpers/logger.js";
+const pageService = new PageService();
+
+export const updatePageDescription = async (
+  params: URLSearchParams,
+  pageId: string,
+  updatedDescription: Uint8Array,
+  cookie: string | undefined,
+) => {
+  if (!(updatedDescription instanceof Uint8Array)) {
+    throw new Error(
+      "Invalid updatedDescription: must be an instance of Uint8Array",
+    );
+  }
+
+  const workspaceSlug = params.get("workspaceSlug")?.toString();
+  const projectId = params.get("projectId")?.toString();
+  if (!workspaceSlug || !projectId || !cookie) return;
+
+  const { contentBinaryEncoded, contentHTML, contentJSON } =
+    getAllDocumentFormatsFromBinaryData(updatedDescription);
+  try {
+    const payload = {
+      description_binary: contentBinaryEncoded,
+      description_html: contentHTML,
+      description: contentJSON,
+    };
+
+    await pageService.updateDescription(
+      workspaceSlug,
+      projectId,
+      pageId,
+      payload,
+      cookie,
+    );
+  } catch (error) {
+    manualLogger.error("Update error:", error);
+    throw error;
+  }
+};
+
+const fetchDescriptionHTMLAndTransform = async (
+  workspaceSlug: string,
+  projectId: string,
+  pageId: string,
+  cookie: string,
+) => {
+  if (!workspaceSlug || !projectId || !cookie) return;
+
+  try {
+    const pageDetails = await pageService.fetchDetails(
+      workspaceSlug,
+      projectId,
+      pageId,
+      cookie,
+    );
+    const { contentBinary } = getBinaryDataFromHTMLString(
+      pageDetails.description_html ?? "<p></p>",
+    );
+    return contentBinary;
+  } catch (error) {
+    manualLogger.error(
+      "Error while transforming from HTML to Uint8Array",
+      error,
+    );
+    throw error;
+  }
+};
+
+export const fetchPageDescriptionBinary = async (
+  params: URLSearchParams,
+  pageId: string,
+  cookie: string | undefined,
+) => {
+  const workspaceSlug = params.get("workspaceSlug")?.toString();
+  const projectId = params.get("projectId")?.toString();
+  if (!workspaceSlug || !projectId || !cookie) return null;
+
+  try {
+    const response = await pageService.fetchDescriptionBinary(
+      workspaceSlug,
+      projectId,
+      pageId,
+      cookie,
+    );
+    const binaryData = new Uint8Array(response);
+
+    if (binaryData.byteLength === 0) {
+      const binary = await fetchDescriptionHTMLAndTransform(
+        workspaceSlug,
+        projectId,
+        pageId,
+        cookie,
+      );
+      if (binary) {
+        return binary;
+      }
+    }
+
+    return binaryData;
+  } catch (error) {
+    manualLogger.error("Fetch error:", error);
+    throw error;
+  }
+};

apps/live/src/core/lib/utils/redis-url.ts

@@ -0,0 +1,15 @@
+export function getRedisUrl() {
+  const redisUrl = process.env.REDIS_URL?.trim();
+  const redisHost = process.env.REDIS_HOST?.trim();
+  const redisPort = process.env.REDIS_PORT?.trim();
+
+  if (redisUrl) {
+    return redisUrl;
+  }
+
+  if (redisHost && redisPort && !Number.isNaN(Number(redisPort))) {
+    return `redis://${redisHost}:${redisPort}`;
+  }
+
+  return "";
+}

apps/live/src/core/services/api.service.ts

@@ -0,0 +1,46 @@
+import axios, { AxiosInstance } from "axios";
+import { config } from "dotenv";
+
+config();
+
+export const API_BASE_URL = process.env.API_BASE_URL ?? "";
+
+export abstract class APIService {
+  protected baseURL: string;
+  private axiosInstance: AxiosInstance;
+
+  constructor(baseURL: string) {
+    this.baseURL = baseURL;
+    this.axiosInstance = axios.create({
+      baseURL,
+      withCredentials: true,
+    });
+  }
+
+  get(url: string, params = {}, config = {}) {
+    return this.axiosInstance.get(url, {
+      ...params,
+      ...config,
+    });
+  }
+
+  post(url: string, data = {}, config = {}) {
+    return this.axiosInstance.post(url, data, config);
+  }
+
+  put(url: string, data = {}, config = {}) {
+    return this.axiosInstance.put(url, data, config);
+  }
+
+  patch(url: string, data = {}, config = {}) {
+    return this.axiosInstance.patch(url, data, config);
+  }
+
+  delete(url: string, data?: any, config = {}) {
+    return this.axiosInstance.delete(url, { data, ...config });
+  }
+
+  request(config = {}) {
+    return this.axiosInstance(config);
+  }
+}

apps/live/src/core/services/page.service.ts

@@ -0,0 +1,78 @@
+// types
+import { TPage } from "@plane/types";
+// services
+import { API_BASE_URL, APIService } from "@/core/services/api.service.js";
+
+export class PageService extends APIService {
+  constructor() {
+    super(API_BASE_URL);
+  }
+
+  async fetchDetails(
+    workspaceSlug: string,
+    projectId: string,
+    pageId: string,
+    cookie: string
+  ): Promise<TPage> {
+    return this.get(
+      `/api/workspaces/${workspaceSlug}/projects/${projectId}/pages/${pageId}/`,
+      {
+        headers: {
+          Cookie: cookie,
+        },
+      }
+    )
+      .then((response) => response?.data)
+      .catch((error) => {
+        throw error?.response?.data;
+      });
+  }
+
+  async fetchDescriptionBinary(
+    workspaceSlug: string,
+    projectId: string,
+    pageId: string,
+    cookie: string
+  ): Promise<any> {
+    return this.get(
+      `/api/workspaces/${workspaceSlug}/projects/${projectId}/pages/${pageId}/description/`,
+      {
+        headers: {
+          "Content-Type": "application/octet-stream",
+          Cookie: cookie,
+        },
+        responseType: "arraybuffer",
+      }
+    )
+      .then((response) => response?.data)
+      .catch((error) => {
+        throw error?.response?.data;
+      });
+  }
+
+  async updateDescription(
+    workspaceSlug: string,
+    projectId: string,
+    pageId: string,
+    data: {
+      description_binary: string;
+      description_html: string;
+      description: object;
+    },
+    cookie: string
+  ): Promise<any> {
+    return this.patch(
+      `/api/workspaces/${workspaceSlug}/projects/${projectId}/pages/${pageId}/description/`,
+      data,
+      {
+        headers: {
+          Cookie: cookie,
+        },
+      }
+    )
+      .then((response) => response?.data)
+      .catch((error) => {
+        throw error;
+      });
+  }
+}

apps/live/src/core/services/user.service.ts

@@ -0,0 +1,28 @@
+// types
+import type { IUser } from "@plane/types";
+// services
+import { API_BASE_URL, APIService } from "@/core/services/api.service.js";
+
+export class UserService extends APIService {
+  constructor() {
+    super(API_BASE_URL);
+  }
+
+  currentUserConfig() {
+    return {
+      url: `${this.baseURL}/api/users/me/`,
+    };
+  }
+
+  async currentUser(cookie: string): Promise<IUser> {
+    return this.get("/api/users/me/", {
+      headers: {
+        Cookie: cookie,
+      },
+    })
+      .then((response) => response?.data)
+      .catch((error) => {
+        throw error;
+      });
+  }
+}

apps/live/src/core/types/common.d.ts

@@ -0,0 +1,13 @@
+// types
+import { TAdditionalDocumentTypes } from "@/plane-live/types/common.js";
+
+export type TDocumentTypes = "project_page" | TAdditionalDocumentTypes;
+
+export type HocusPocusServerContext = {
+  cookie: string;
+};
+
+export type TConvertDocumentRequestBody = {
+  description_html: string;
+  variant: "rich" | "document";
+};

apps/live/src/ee/lib/fetch-document.ts

@@ -0,0 +1 @@
+export * from "../../ce/lib/fetch-document.js"

apps/live/src/ee/lib/update-document.ts

@@ -0,0 +1 @@
+export * from "../../ce/lib/update-document.js";

apps/live/src/ee/types/common.d.ts

@@ -0,0 +1 @@
+export * from "../../ce/types/common.js"

apps/live/src/server.ts

@@ -0,0 +1,129 @@
+import compression from "compression";
+import cors from "cors";
+import expressWs from "express-ws";
+import express, { Request, Response } from "express";
+import helmet from "helmet";
+// hocuspocus server
+import { getHocusPocusServer } from "@/core/hocuspocus-server.js";
+// helpers
+import { convertHTMLDocumentToAllFormats } from "@/core/helpers/convert-document.js";
+import { logger, manualLogger } from "@/core/helpers/logger.js";
+// types
+import { TConvertDocumentRequestBody } from "@/core/types/common.js";
+
+export class Server {
+  private app: any;
+  private router: any;
+  private hocuspocusServer: any;
+  private serverInstance: any;
+
+  constructor() {
+    this.app = express();
+    this.router = express.Router();
+    expressWs(this.app);
+    this.app.set("port", process.env.PORT || 3000);
+    this.setupMiddleware();
+    this.setupHocusPocus();
+    this.setupRoutes();
+  }
+
+  private setupMiddleware() {
+    // Security middleware
+    this.app.use(helmet());
+    // Middleware for response compression
+    this.app.use(compression({ level: 6, threshold: 5 * 1000 }));
+    // Logging middleware
+    this.app.use(logger);
+    // Body parsing middleware
+    this.app.use(express.json());
+    this.app.use(express.urlencoded({ extended: true }));
+    // cors middleware
+    this.app.use(cors());
+    this.app.use(process.env.LIVE_BASE_PATH || "/live", this.router);
+  }
+
+  private async setupHocusPocus() {
+    this.hocuspocusServer = await getHocusPocusServer().catch((err) => {
+      manualLogger.error("Failed to initialize HocusPocusServer:", err);
+      process.exit(1);
+    });
+  }
+
+  private setupRoutes() {
+    this.router.get("/health", (_req: Request, res: Response) => {
+      res.status(200).json({ status: "OK" });
+    });
+
+    this.router.ws("/collaboration", (ws: any, req: Request) => {
+      try {
+        this.hocuspocusServer.handleConnection(ws, req);
+      } catch (err) {
+        manualLogger.error("WebSocket connection error:", err);
+        ws.close();
+      }
+    });
+
+    this.router.post("/convert-document", (req: Request, res: Response) => {
+      const { description_html, variant } = req.body as TConvertDocumentRequestBody;
+      try {
+        if (description_html === undefined || variant === undefined) {
+          res.status(400).send({
+            message: "Missing required fields",
+          });
+          return;
+        }
+        const { description, description_binary } = convertHTMLDocumentToAllFormats({
+          document_html: description_html,
+          variant,
+        });
+        res.status(200).json({
+          description,
+          description_binary,
+        });
+      } catch (error) {
+        manualLogger.error("Error in /convert-document endpoint:", error);
+        res.status(500).send({
+          message: `Internal server error. ${error}`,
+        });
+      }
+    });
+
+    this.app.use((_req: Request, res: Response) => {
+      res.status(404).send("Not Found");
+    });
+  }
+
+  public listen() {
+    this.serverInstance = this.app.listen(this.app.get("port"), () => {
+      manualLogger.info(`Plane Live server has started at port ${this.app.get("port")}`);
+    });
+  }
+
+  public async destroy() {
+    // Close the HocusPocus server WebSocket connections
+    await this.hocuspocusServer.destroy();
+    manualLogger.info("HocusPocus server WebSocket connections closed gracefully.");
+    // Close the Express server
+    this.serverInstance.close(() => {
+      manualLogger.info("Express server closed gracefully.");
+      process.exit(1);
+    });
+  }
+}
+
+const server = new Server();
+server.listen();
+
+// Graceful shutdown on unhandled rejection
+process.on("unhandledRejection", async (err: any) => {
+  manualLogger.info("Unhandled Rejection: ", err);
+  manualLogger.info(`UNHANDLED REJECTION! 💥 Shutting down...`);
+  await server.destroy();
+});
+
+// Graceful shutdown on uncaught exception
+process.on("uncaughtException", async (err: any) => {
+  manualLogger.info("Uncaught Exception: ", err);
+  manualLogger.info(`UNCAUGHT EXCEPTION! 💥 Shutting down...`);
+  await server.destroy();
+});

apps/live/tsconfig.json

@@ -0,0 +1,26 @@
+{
+  "extends": "@plane/typescript-config/base.json",
+  "compilerOptions": {
+    "module": "ES2015",
+    "moduleResolution": "Bundler",
+    "lib": ["ES2015"],
+    "target": "ES2015",
+    "outDir": "./dist",
+    "rootDir": ".",
+    "baseUrl": ".",
+    "paths": {
+      "@/*": ["./src/*"],
+      "@/plane-live/*": ["./src/ce/*"]
+    },
+    "removeComments": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "sourceMap": true,
+    "inlineSources": true,
+    "experimentalDecorators": true,
+    "emitDecoratorMetadata": true,
+    "sourceRoot": "/"
+  },
+  "include": ["src/**/*.ts", "tsup.config.ts"],
+  "exclude": ["./dist", "./build", "./node_modules"]
+}

apps/live/tsup.config.ts

@@ -0,0 +1,15 @@
+import { defineConfig } from "tsup";
+
+export default defineConfig({
+  entry: ["src/server.ts"],
+  format: ["esm", "cjs"],
+  dts: true,
+  splitting: false,
+  sourcemap: true,
+  minify: false,
+  target: "node18",
+  outDir: "dist",
+  env: {
+    NODE_ENV: process.env.NODE_ENV || "development",
+  },
+});