feat: move arrpc server into a worker thread

Author: pendo324

Diff for: package.json

@@ -40,6 +40,7 @@
         "electron": "^33.2.1",
         "electron-builder": "^25.1.8",
         "esbuild": "^0.24.0",
+        "esbuild-plugin-inline-import": "^1.1.0",
         "eslint": "^9.16.0",
         "eslint-import-resolver-alias": "^1.1.2",
         "eslint-plugin-path-alias": "^2.1.0",

Diff for: pnpm-lock.yaml

@@ -4,9 +4,10 @@
  * Copyright (c) 2023 Vendicated and Vencord contributors
  */
 
-import { BuildContext, BuildOptions, context } from "esbuild";
+import { build, BuildContext, BuildOptions, context } from "esbuild";
 import { copyFile } from "fs/promises";
 
+import inlineImportPlugin from "esbuild-plugin-inline-import";
 import vencordDep from "./vencordDep.mjs";
 
 const isDev = process.argv.includes("--dev");
@@ -22,8 +23,25 @@ const NodeCommonOpts: BuildOptions = {
     ...CommonOpts,
     format: "cjs",
     platform: "node",
-    external: ["electron"],
+    external: ["electron", "inline:./arrpcWorker.ts"],
     target: ["esnext"],
+    plugins: [
+        inlineImportPlugin({
+            transform: async (_, args) => {
+                const { outputFiles } = await build({
+                    entryPoints: [args.path],
+                    bundle: true,
+                    write: false,
+                    format: "cjs",
+                    platform: "node",
+                    target: ["esnext"]
+                });
+
+                const { contents } = outputFiles[0];
+                return Buffer.from(contents).toString();
+            }
+        })
+    ],
     define: {
         IS_DEV: JSON.stringify(isDev)
     }

Diff for: scripts/build/build.mts

@@ -4,31 +4,65 @@
  * Copyright (c) 2023 Vendicated and Vencord contributors
  */
 
-import Server from "arrpc";
 import { IpcEvents } from "shared/IpcEvents";
+import { MessageChannel, Worker } from "worker_threads";
+const { port1: hostPort, port2: workerPort } = new MessageChannel();
+
+// @ts-ignore: ts error looking for type defintions
+import arrpcWorkerScript from "inline:./arrpcWorker.ts";
 
 import { mainWin } from "./mainWindow";
 import { Settings } from "./settings";
+import { ArrpcEvent, ArrpcHostEvent } from "./utils/arrpcWorkerTypes";
 
-let server: any;
+let worker: any;
 
 const inviteCodeRegex = /^(\w|-)+$/;
 
 export async function initArRPC() {
-    if (server || !Settings.store.arRPC) return;
+    if (worker || !Settings.store.arRPC) return;
 
     try {
-        server = await new Server();
-        server.on("activity", (data: any) => mainWin.webContents.send(IpcEvents.ARRPC_ACTIVITY, JSON.stringify(data)));
-        server.on("invite", (invite: string, callback: (valid: boolean) => void) => {
-            invite = String(invite);
-            if (!inviteCodeRegex.test(invite)) return callback(false);
-
-            mainWin.webContents
-                // Safety: Result of JSON.stringify should always be safe to equal
-                // Also, just to be super super safe, invite is regex validated above
-                .executeJavaScript(`Vesktop.openInviteModal(${JSON.stringify(invite)})`)
-                .then(callback);
+        worker = new Worker(arrpcWorkerScript, {
+            workerData: {
+                workerPort
+            },
+            transferList: [workerPort],
+            eval: true
+        });
+        hostPort.on("message", (e: ArrpcEvent) => {
+            switch (e.eventType) {
+                case IpcEvents.ARRPC_ACTIVITY: {
+                    mainWin.webContents.send(IpcEvents.ARRPC_ACTIVITY, e.data);
+                    break;
+                }
+                case "invite": {
+                    const invite = String(e.data);
+
+                    if (!inviteCodeRegex.test(invite)) {
+                        const hostEvent: ArrpcHostEvent = {
+                            eventType: "ack-invite",
+                            data: false,
+                            inviteId: e.inviteId
+                        };
+                        return hostPort.postMessage(hostEvent);
+                    }
+
+                    mainWin.webContents
+                        // Safety: Result of JSON.stringify should always be safe to equal
+                        // Also, just to be super super safe, invite is regex validated above
+                        .executeJavaScript(`Vesktop.openInviteModal(${JSON.stringify(invite)})`)
+                        .then(() => {
+                            const hostEvent: ArrpcHostEvent = {
+                                eventType: "ack-invite",
+                                data: true,
+                                inviteId: e.inviteId
+                            };
+                            hostPort.postMessage(hostEvent);
+                        });
+                    break;
+                }
+            }
         });
     } catch (e) {
         console.error("Failed to start arRPC server", e);

Diff for: src/main/arrpc.ts

@@ -0,0 +1,42 @@
+/*
+ * SPDX-License-Identifier: GPL-3.0
+ * Vesktop, a desktop app aiming to give you a snappier Discord Experience
+ * Copyright (c) 2023 Vendicated and Vencord contributors
+ */
+
+import Server from "arrpc";
+import { IpcEvents } from "shared/IpcEvents";
+import { MessagePort, workerData } from "worker_threads";
+
+import { ArrpcEvent, ArrpcHostEvent } from "./utils/arrpcWorkerTypes";
+
+let server: any;
+
+type InviteCallback = (valid: boolean) => void;
+
+let inviteCallbacks: Array<InviteCallback> = [];
+
+(async function () {
+    const { workerPort }: { workerPort: MessagePort } = workerData;
+    server = await new Server();
+    server.on("activity", (data: any) => {
+        const event: ArrpcEvent = {
+            eventType: IpcEvents.ARRPC_ACTIVITY,
+            data: JSON.stringify(data)
+        };
+        workerPort.postMessage(event);
+    });
+    server.on("invite", (invite: string, callback: InviteCallback) => {
+        const event: ArrpcEvent = {
+            eventType: "invite",
+            data: invite,
+            inviteId: inviteCallbacks.push(callback) - 1
+        };
+        workerPort.postMessage(event);
+    });
+
+    workerPort.on("message", (e: ArrpcHostEvent) => {
+        inviteCallbacks[e.inviteId](e.data);
+        inviteCallbacks = [...inviteCallbacks.slice(0, e.inviteId), ...inviteCallbacks.slice(e.inviteId + 1)];
+    });
+})();

Diff for: src/main/arrpcWorker.ts

@@ -0,0 +1,26 @@
+/*
+ * SPDX-License-Identifier: GPL-3.0
+ * Vesktop, a desktop app aiming to give you a snappier Discord Experience
+ * Copyright (c) 2023 Vendicated and Vencord contributors
+ */
+
+import { IpcEvents } from "shared/IpcEvents";
+
+export type ArrpcEvent = ArrpcActivityEvent | ArrpcInviteEvent;
+
+export interface ArrpcActivityEvent {
+    eventType: IpcEvents.ARRPC_ACTIVITY;
+    data: string;
+}
+
+export interface ArrpcInviteEvent {
+    eventType: "invite";
+    data: string;
+    inviteId: number;
+}
+
+export interface ArrpcHostEvent {
+    eventType: "ack-invite";
+    inviteId: number;
+    data: boolean;
+}