@scrypted/server 0.123.1 → 0.123.3

package/src/plugin/runtime/cluster-fork.worker.ts

@@ -0,0 +1,92 @@
+import { EventEmitter, PassThrough } from "stream";
+import { Deferred } from "../../deferred";
+import { RpcPeer } from "../../rpc";
+import { ClusterForkOptions, getClusterLabels, matchesClusterLabels, PeerLiveness } from "../../scrypted-cluster";
+import type { ClusterFork } from "../../services/cluster-fork";
+import { writeWorkerGenerator } from "../plugin-console";
+import type { RuntimeWorker } from "./runtime-worker";
+import { sleep } from "../../sleep";
+
+export function needsClusterForkWorker(options: ClusterForkOptions) {
+    return process.env.SCRYPTED_CLUSTER_ADDRESS && options?.runtime && !matchesClusterLabels(options, getClusterLabels())
+}
+
+export function createClusterForkWorker(
+    forkComponentPromise: ClusterFork | Promise<ClusterFork>,
+    zipHash: string,
+    getZip: () => Promise<Buffer>,
+    options: ClusterForkOptions,
+    packageJson: any,
+    connectRPCObject: (o: any) => Promise<any>) {
+    const waitKilled = new Deferred<void>();
+    waitKilled.promise.finally(() => events.emit('exit'));
+    const events = new EventEmitter();
+
+    const stdout = new PassThrough();
+    const stderr = new PassThrough();
+
+    const runtimeWorker: RuntimeWorker = {
+        pid: 'cluster',
+        stdout,
+        stderr,
+        on: events.on.bind(events),
+        once: events.once.bind(events),
+        removeListener: events.removeListener.bind(events),
+        kill: () => {
+            waitKilled.resolve();
+        },
+    } as any;
+
+    waitKilled.promise.finally(() => {
+        runtimeWorker.pid = undefined;
+    });
+
+    const forkPeer = (async () => {
+        // need to ensure this happens on next tick to prevent unhandled promise rejection.
+        // await sleep(0);
+        const forkComponent = await forkComponentPromise;
+        const peerLiveness = new PeerLiveness(new Deferred().promise);
+        const clusterForkResult = await forkComponent.fork(peerLiveness, options, packageJson, zipHash, getZip);
+        waitKilled.promise.finally(() => {
+            runtimeWorker.pid = undefined;
+            clusterForkResult.kill();
+        });
+        clusterForkResult.waitKilled().catch(() => { })
+            .finally(() => {
+                waitKilled.resolve();
+            });
+
+        try {
+            const clusterGetRemote = await connectRPCObject(await clusterForkResult.getResult());
+            const {
+                stdout: stdoutGen,
+                stderr: stderrGen,
+                getRemote
+            } = await clusterGetRemote();
+
+            writeWorkerGenerator(stdoutGen, stdout).catch(() => { });
+            writeWorkerGenerator(stderrGen, stderr).catch(() => { });
+
+            const directGetRemote = await connectRPCObject(getRemote);
+            if (directGetRemote === getRemote)
+                throw new Error('cluster fork peer not direct connected');
+            const peer: RpcPeer = directGetRemote[RpcPeer.PROPERTY_PROXY_PEER];
+            if (!peer)
+                throw new Error('cluster fork peer undefined?');
+            return peer;
+        }
+        catch (e) {
+            clusterForkResult.kill();
+            throw e;
+        }
+    })();
+
+    forkPeer.catch(() => {
+        waitKilled.resolve();
+    });
+
+    return {
+        runtimeWorker,
+        forkPeer,
+    }
+}

package/src/plugin/runtime/custom-worker.ts

@@ -26,13 +26,13 @@ export class CustomRuntimeWorker extends ChildProcessWorker {
         const opts: child_process.ForkOptions | child_process.SpawnOptions = {
             // stdin, stdout, stderr, peer in, peer out
             stdio: ['pipe', 'pipe', 'pipe', 'pipe', 'pipe', 'pipe'],
-            env: Object.assign({
+            env: Object.assign({}, process.env, env, {
                 SCRYYPTED_PLUGIN_ID: pluginId,
                 SCRYPTED_DEBUG_PORT: pluginDebug?.inspectPort?.toString(),
                 SCRYPTED_UNZIPPED_PATH: options.unzippedPath,
                 SCRYPTED_ZIP_FILE: options.zipFile,
                 SCRYPTED_ZIP_HASH: options.zipHash,
-            }, process.env, env),
+            }),
         };
 
         if (!scryptedRuntimeArguments.executable) {

package/src/plugin/runtime/node-fork-worker.ts

@@ -4,6 +4,7 @@ import { RpcMessage, RpcPeer } from "../../rpc";
 import { SidebandSocketSerializer } from "../socket-serializer";
 import { ChildProcessWorker } from "./child-process-worker";
 import { RuntimeWorkerOptions } from "./runtime-worker";
+import { getScryptedClusterMode } from '../../scrypted-cluster';
 
 export const NODE_PLUGIN_CHILD_PROCESS = 'child';
 export const NODE_PLUGIN_FORK_PROCESS = 'fork';
@@ -39,12 +40,14 @@ export class NodeForkWorker extends ChildProcessWorker {
             execArgv.push(`--inspect=0.0.0.0:${pluginDebug.inspectPort}`);
         }
 
-        this.worker = child_process.fork(mainFilename, [
+        const args = [
             // change the argument marker depending on whether this is the main scrypted server process
             // starting a plugin vs the plugin forking for multiprocessing.
-            isNodePluginWorkerProcess() ? NODE_PLUGIN_FORK_PROCESS : NODE_PLUGIN_CHILD_PROCESS,
+            isNodePluginWorkerProcess() || getScryptedClusterMode()?.[0] === 'client' ? NODE_PLUGIN_FORK_PROCESS : NODE_PLUGIN_CHILD_PROCESS,
             this.pluginId
-        ], {
+        ];
+
+        this.worker = child_process.fork(mainFilename, args, {
             stdio: ['pipe', 'pipe', 'pipe', 'ipc'],
             env: Object.assign({}, process.env, env),
             serialization: 'advanced',

package/src/plugin/runtime/python-worker.ts

@@ -100,12 +100,12 @@ export class PythonRuntimeWorker extends ChildProcessWorker {
                 cwd: options.unzippedPath,
                 // stdin, stdout, stderr, peer in, peer out
                 stdio: ['pipe', 'pipe', 'pipe', 'pipe', 'pipe'],
-                env: Object.assign({
+                env: Object.assign({}, process.env, env, gstEnv, {
                     // rev this if the base python version or server characteristics change.
                     SCRYPTED_PYTHON_VERSION: '20240317',
                     PYTHONUNBUFFERED: '1',
                     PYTHONPATH,
-                }, gstEnv, process.env, env),
+                }),
             });
             this.setupWorker();
 

package/src/rpc.ts

@@ -117,7 +117,7 @@ class RpcProxy implements PrimitiveProxyHandler<any> {
             return this.entry.id;
         if (p === '__proxy_constructor')
             return this.constructorName;
-        if (p === '__proxy_peer')
+        if (p === RpcPeer.PROPERTY_PROXY_PEER)
             return this.peer;
         if (p === RpcPeer.PROPERTY_PROXY_PROPERTIES)
             return this.proxyProps;
@@ -374,6 +374,7 @@ export class RpcPeer {
     static readonly RANDOM_DIGITS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
     static readonly RPC_RESULT_ERROR_NAME = 'RPCResultError';
     static readonly PROPERTY_PROXY_ID = '__proxy_id';
+    static readonly PROPERTY_PROXY_PEER = '__proxy_peer';
     static readonly PROPERTY_PROXY_ONEWAY_METHODS = '__proxy_oneway_methods';
     static readonly PROPERTY_JSON_DISABLE_SERIALIZATION = '__json_disable_serialization';
     static readonly PROPERTY_PROXY_PROPERTIES = '__proxy_props';
@@ -383,7 +384,7 @@ export class RpcPeer {
         'constructor',
         '__proxy_id',
         '__proxy_constructor',
-        '__proxy_peer',
+        RpcPeer.PROPERTY_PROXY_PEER,
         RpcPeer.PROPERTY_PROXY_ONEWAY_METHODS,
         RpcPeer.PROPERTY_JSON_DISABLE_SERIALIZATION,
         RpcPeer.PROPERTY_PROXY_PROPERTIES,

package/src/runtime.ts

@@ -33,16 +33,19 @@ import { isConnectionUpgrade, PluginHttp } from './plugin/plugin-http';
 import { WebSocketConnection } from './plugin/plugin-remote-websocket';
 import { getPluginVolume } from './plugin/plugin-volume';
 import { getBuiltinRuntimeHosts } from './plugin/runtime/runtime-host';
+import { ClusterWorker } from './scrypted-cluster';
 import { getIpAddress, SCRYPTED_INSECURE_PORT, SCRYPTED_SECURE_PORT } from './server-settings';
 import { AddressSettings } from './services/addresses';
 import { Alerts } from './services/alerts';
 import { Backup } from './services/backup';
+import { ClusterFork } from './services/cluster-fork';
 import { CORSControl } from './services/cors';
 import { Info } from './services/info';
 import { getNpmPackageInfo, PluginComponent } from './services/plugin';
 import { ServiceControl } from './services/service-control';
 import { UsersService } from './services/users';
 import { getState, ScryptedStateManager, setState } from './state';
+import { isClusterAddress } from './scrypted-cluster-common';
 
 interface DeviceProxyPair {
     handler: PluginDeviceProxyHandler;
@@ -59,7 +62,8 @@ interface HttpPluginData {
 
 export class ScryptedRuntime extends PluginHttp<HttpPluginData> {
     clusterId = crypto.randomBytes(3).toString('hex');
-    clusterSecret = crypto.randomBytes(16).toString('hex');
+    clusterSecret = process.env.SCRYPTED_CLUSTER_SECRET || crypto.randomBytes(16).toString('hex');
+    clusterWorkers = new Set<ClusterWorker>();
     plugins: { [id: string]: PluginHost } = {};
     pluginDevices: { [id: string]: PluginDevice } = {};
     devices: { [id: string]: DeviceProxyPair } = {};
@@ -85,6 +89,7 @@ export class ScryptedRuntime extends PluginHttp<HttpPluginData> {
     corsControl = new CORSControl(this);
     addressSettings = new AddressSettings(this);
     usersService = new UsersService(this);
+    clusterFork = new ClusterFork(this);
     info = new Info();
     backup = new Backup(this);
     pluginHosts = getBuiltinRuntimeHosts();
@@ -119,7 +124,13 @@ export class ScryptedRuntime extends PluginHttp<HttpPluginData> {
                     return;
                 }
 
-                const socket = net.connect(clusterObject.port, '127.0.0.1');
+                let address = clusterObject.address;
+                if (isClusterAddress(address)) 
+                    address = '127.0.0.1';
+                const socket = net.connect({
+                    port: clusterObject.port,
+                    host: address,
+                });
                 socket.on('error', () => connection.close());
                 socket.on('close', () => connection.close());
                 socket.on('data', data => connection.send(data));
@@ -220,6 +231,8 @@ export class ScryptedRuntime extends PluginHttp<HttpPluginData> {
     }
 
     getDeviceLogger(device: PluginDevice): Logger {
+        if (!device)
+            return;
         return this.devicesLogger.getLogger(device._id, getState(device, ScryptedInterfaceProperty.name));
     }
 
@@ -361,6 +374,8 @@ export class ScryptedRuntime extends PluginHttp<HttpPluginData> {
                 return this.usersService;
             case 'backup':
                 return this.backup;
+            case 'cluster-fork':
+                return this.clusterFork;
         }
     }
 

package/src/scrypted-cluster-common.ts

@@ -0,0 +1,374 @@
+import { once } from 'events';
+import net from 'net';
+import worker_threads from 'worker_threads';
+import { computeClusterObjectHash } from "./cluster/cluster-hash";
+import { ClusterObject, ConnectRPCObject } from "./cluster/connect-rpc-object";
+import { Deferred } from './deferred';
+import { listenZero } from './listen-zero';
+import { NodeThreadWorker } from './plugin/runtime/node-thread-worker';
+import { RpcPeer } from "./rpc";
+import { createDuplexRpcPeer } from "./rpc-serializer";
+import { InitializeCluster } from "./scrypted-cluster";
+
+export function getClusterPeerKey(address: string, port: number) {
+    return `${address}:${port}`;
+}
+
+export function isClusterAddress(address: string) {
+    return !address || address === process.env.SCRYPTED_CLUSTER_ADDRESS;
+}
+
+export async function peerConnectRPCObject(peer: RpcPeer, o: ClusterObject) {
+    let peerConnectRPCObject: Promise<ConnectRPCObject> = peer.tags['connectRPCObject'];
+    if (!peerConnectRPCObject) {
+        peerConnectRPCObject = peer.getParam('connectRPCObject');
+        peer.tags['connectRPCObject'] = peerConnectRPCObject;
+    }
+    const resolved = await peerConnectRPCObject;
+    return resolved(o);
+}
+
+export function prepareClusterPeer(peer: RpcPeer) {
+    const SCRYPTED_CLUSTER_ADDRESS = process.env.SCRYPTED_CLUSTER_ADDRESS;
+    let clusterId: string;
+    let clusterSecret: string;
+    let clusterPort: number;
+
+    // all cluster clients, incoming and outgoing, connect with random ports which can be used as peer ids
+    // on the cluster server that is listening on the actual port.
+    // incoming connections: use the remote random/unique port
+    // outgoing connections: use the local random/unique port
+    const clusterPeers = new Map<string, Promise<RpcPeer>>();
+
+    const resolveObject = async (id: string, sourceKey: string) => {
+        const sourcePeer = sourceKey
+            ? await clusterPeers.get(sourceKey)
+            : peer;
+        if (!sourcePeer)
+            console.error('source peer not found', sourceKey);
+        const ret = sourcePeer?.localProxyMap.get(id);
+        if (!ret) {
+            console.error('source key not found', sourceKey, id);
+            return;
+        }
+        return ret;
+    }
+
+    const connectClusterObject = async (o: ClusterObject) => {
+        const sha256 = computeClusterObjectHash(o, clusterSecret);
+        if (sha256 !== o.sha256)
+            throw new Error('secret incorrect');
+        return resolveObject(o.proxyId, o.sourceKey);
+    }
+
+    const ensureClusterPeer = (address: string, connectPort: number) => {
+        if (isClusterAddress(address))
+            address = '127.0.0.1';
+
+        const clusterPeerKey = getClusterPeerKey(address, connectPort);
+        let clusterPeerPromise = clusterPeers.get(clusterPeerKey);
+        if (clusterPeerPromise)
+            return clusterPeerPromise;
+
+        clusterPeerPromise = (async () => {
+            const socket = net.connect(connectPort, address);
+            socket.on('close', () => clusterPeers.delete(clusterPeerKey));
+
+            try {
+                await once(socket, 'connect');
+                const { address: sourceAddress } = (socket.address() as net.AddressInfo);
+                if (sourceAddress !== SCRYPTED_CLUSTER_ADDRESS && sourceAddress !== '127.0.0.1') {
+                    // source address may end with .0 if its a gateway into docker.
+                    if (!sourceAddress.endsWith('.0'))
+                        console.warn("source address mismatch", sourceAddress);
+                }
+
+                const clusterPeer = createDuplexRpcPeer(peer.selfName, clusterPeerKey, socket, socket);
+                // set params from the primary peer, needed for get getRemote in cluster mode.
+                Object.assign(clusterPeer.params, peer.params);
+                clusterPeer.onProxySerialization = (value) => onProxySerialization(clusterPeer, value, clusterPeerKey);
+                return clusterPeer;
+            }
+            catch (e) {
+                console.error('failure ipc connect', e);
+                socket.destroy();
+                throw e;
+            }
+        })();
+
+        clusterPeers.set(clusterPeerKey, clusterPeerPromise);
+        return clusterPeerPromise;
+    };
+
+
+    const tidChannels = new Map<number, Deferred<worker_threads.MessagePort>>();
+    const tidPeers = new Map<number, Promise<RpcPeer>>();
+
+    function connectTidPeer(tid: number) {
+        let peerPromise = tidPeers.get(tid);
+        if (peerPromise)
+            return peerPromise;
+        let tidDeferred = tidChannels.get(tid);
+        // if the tid port is not available yet, request it.
+        if (!tidDeferred) {
+            tidDeferred = new Deferred<worker_threads.MessagePort>();
+            tidChannels.set(tid, tidDeferred);
+
+            if (mainThreadPort) {
+                // request the connection via the main thread
+                mainThreadPort.postMessage({
+                    threadId: tid,
+                });
+            }
+        }
+
+        const threadPeerKey = `thread:${tid}`;
+        function peerCleanup() {
+            clusterPeers.delete(threadPeerKey);
+        }
+        peerPromise = tidDeferred.promise.then(port => {
+            const threadPeer = NodeThreadWorker.createRpcPeer(peer.selfName, threadPeerKey, port);
+            // set params from the primary peer, needed for get getRemote in cluster mode.
+            Object.assign(threadPeer.params, peer.params);
+            threadPeer.onProxySerialization = value => onProxySerialization(threadPeer, value, threadPeerKey);
+
+            threadPeer.params.connectRPCObject = connectClusterObject;
+
+            function cleanup(message: string) {
+                peerCleanup();
+                tidChannels.delete(tid);
+                tidPeers.delete(tid);
+                threadPeer.kill(message);
+            }
+            port.on('close', () => cleanup('connection closed.'));
+            port.on('messageerror', () => cleanup('message error.'));
+            return threadPeer;
+        });
+        peerPromise.catch(() => peerCleanup());
+        clusterPeers.set(threadPeerKey, peerPromise);
+        tidPeers.set(tid, peerPromise);
+
+        return peerPromise;
+    }
+
+    const mainThreadPort: worker_threads.MessagePort = worker_threads.isMainThread ? undefined : worker_threads.workerData.mainThreadPort;
+    if (!worker_threads.isMainThread) {
+        // the main thread port will send messages with a thread port when a thread wants to initiate a connection.
+        mainThreadPort.on('message', async (message: { port: worker_threads.MessagePort, threadId: number }) => {
+            const { port, threadId } = message;
+            let tidDeferred = tidChannels.get(threadId);
+            if (!tidDeferred) {
+                tidDeferred = new Deferred<worker_threads.MessagePort>();
+                tidChannels.set(threadId, tidDeferred);
+            }
+            tidDeferred.resolve(port);
+            connectTidPeer(threadId);
+        });
+    }
+
+    async function connectIPCObject(clusterObject: ClusterObject, tid: number) {
+        // if the main thread is trying to connect to an object,
+        // the argument order matters here, as the connection attempt looks at the
+        // connectThreadId to see if the target is main thread.
+        if (worker_threads.isMainThread)
+            mainThreadBrokerConnect(tid, worker_threads.threadId);
+        const clusterPeer = await connectTidPeer(tid);
+        const existing = clusterPeer.remoteWeakProxies[clusterObject.proxyId]?.deref();
+        if (existing)
+            return existing;
+        return peerConnectRPCObject(clusterPeer, clusterObject);
+    }
+
+    const brokeredConnections = new Set<string>();
+    const workers = new Map<number, worker_threads.MessagePort>();
+    function mainThreadBrokerConnect(threadId: number, connectThreadId: number) {
+        if (worker_threads.isMainThread && threadId === worker_threads.threadId) {
+            const msg = 'invalid ipc, main thread cannot connect to itself';
+            console.error(msg);
+            throw new Error(msg);
+        }
+        // both workers nay initiate connection to each other at same time, so this
+        // is a synchronization point.
+        const key = JSON.stringify([threadId, connectThreadId].sort());
+        if (brokeredConnections.has(key))
+            return;
+
+        brokeredConnections.add(key);
+
+        const worker = workers.get(threadId);
+        const connect = workers.get(connectThreadId);
+        const channel = new worker_threads.MessageChannel();
+
+        worker.postMessage({
+            port: channel.port1,
+            threadId: connectThreadId,
+        }, [channel.port1]);
+
+        if (connect) {
+            connect.postMessage({
+                port: channel.port2,
+                threadId,
+            }, [channel.port2]);
+        }
+        else if (connectThreadId === worker_threads.threadId) {
+            connectTidPeer(threadId);
+            const deferred = tidChannels.get(threadId);
+            deferred.resolve(channel.port2);
+        }
+        else {
+            channel.port2.close();
+        }
+    }
+
+    function mainThreadBrokerRegister(workerPort: worker_threads.MessagePort, threadId: number) {
+        workers.set(threadId, workerPort);
+
+        // this is main thread, so there will be two types of requests from the child: registration requests from grandchildren and connection requests.
+        workerPort.on('message', async (message: { port: worker_threads.MessagePort, threadId: number }) => {
+            const { port, threadId: connectThreadId } = message;
+
+            if (port) {
+                mainThreadBrokerRegister(port, connectThreadId);
+            }
+            else {
+                mainThreadBrokerConnect(threadId, connectThreadId);
+            }
+        });
+    }
+
+    const connectRPCObject = async (value: any) => {
+        const clusterObject: ClusterObject = value?.__cluster;
+        if (clusterObject?.id !== clusterId)
+            return value;
+        const { address, port, proxyId } = clusterObject;
+        // handle the case when trying to connect to an object is on this cluster node,
+        // returning the actual object, rather than initiating a loopback connection.
+        if (port === clusterPort)
+            return connectClusterObject(clusterObject);
+
+        // can use worker to worker ipc if the address and pid matches and both side are node.
+        if (address === SCRYPTED_CLUSTER_ADDRESS && proxyId.startsWith('n-')) {
+            const parts = proxyId.split('-');
+            const pid = parseInt(parts[1]);
+            if (pid === process.pid)
+                return connectIPCObject(clusterObject, parseInt(parts[2]));
+        }
+
+        try {
+            const clusterPeerPromise = ensureClusterPeer(address, port);
+            const clusterPeer = await clusterPeerPromise;
+            // may already have this proxy so check first.
+            const existing = clusterPeer.remoteWeakProxies[proxyId]?.deref();
+            if (existing)
+                return existing;
+            const newValue = await peerConnectRPCObject(clusterPeer, clusterObject);
+            if (!newValue)
+                throw new Error('rpc object not found?');
+            return newValue;
+        }
+        catch (e) {
+            console.error('failure rpc', clusterObject, e);
+            return value;
+        }
+    }
+
+    const onProxySerialization = (peer: RpcPeer, value: any, sourceKey: string) => {
+        const properties = RpcPeer.prepareProxyProperties(value) || {};
+        let clusterEntry: ClusterObject = properties.__cluster;
+
+        // ensure globally stable proxyIds.
+        // worker threads will embed their pid and tid in the proxy id for cross worker fast path.
+        const proxyId = peer.localProxied.get(value)?.id || clusterEntry?.proxyId || `n-${process.pid}-${worker_threads.threadId}-${RpcPeer.generateId()}`;
+
+        // if the cluster entry already exists, check if it belongs to this node.
+        // if it belongs to this node, the entry must also be for this peer.
+        // relying on the liveness/gc of a different peer may cause race conditions.
+        if (clusterEntry) {
+            if (isClusterAddress(clusterEntry?.address) && clusterPort === clusterEntry.port && sourceKey !== clusterEntry.sourceKey)
+                clusterEntry = undefined;
+        }
+
+        if (!clusterEntry) {
+            clusterEntry = {
+                id: clusterId,
+                address: SCRYPTED_CLUSTER_ADDRESS,
+                port: clusterPort,
+                proxyId,
+                sourceKey,
+                sha256: null,
+            };
+            clusterEntry.sha256 = computeClusterObjectHash(clusterEntry, clusterSecret);
+            properties.__cluster = clusterEntry;
+        }
+
+        return {
+            proxyId,
+            properties,
+        };
+    }
+    const initializeCluster: InitializeCluster = async (options: {
+        clusterId: string;
+        clusterSecret: string;
+    }) => {
+        if (clusterPort)
+            return;
+
+        ({ clusterId, clusterSecret } = options);
+
+
+        const clients = new Set<net.Socket>();
+
+        const clusterRpcServer = net.createServer(client => {
+            const clusterPeerAddress = client.remoteAddress;
+            const clusterPeerPort = client.remotePort;
+            const clusterPeerKey = getClusterPeerKey(clusterPeerAddress, clusterPeerPort);
+            const clusterPeer = createDuplexRpcPeer(peer.selfName, clusterPeerKey, client, client);
+            // set params from the primary peer, needed for get getRemote in cluster mode.
+            Object.assign(clusterPeer.params, peer.params);
+            // the listening peer sourceKey (client address/port) is used by the OTHER peer (the client)
+            // to determine if it is already connected to THIS peer (the server).
+            clusterPeer.onProxySerialization = (value) => onProxySerialization(clusterPeer, value, clusterPeerKey);
+            clusterPeers.set(clusterPeerKey, Promise.resolve(clusterPeer));
+            clusterPeer.params.connectRPCObject = connectClusterObject;
+            client.on('close', () => {
+                clusterPeers.delete(clusterPeerKey);
+                clusterPeer.kill('cluster socket closed');
+                clients.delete(client);
+            });
+            clients.add(client);
+        });
+
+        const listenAddress = SCRYPTED_CLUSTER_ADDRESS
+            ? '0.0.0.0'
+            : '127.0.0.1';
+
+        clusterPort = await listenZero(clusterRpcServer, listenAddress);
+        peer.onProxySerialization = value => onProxySerialization(peer, value, undefined);
+        delete peer.params.initializeCluster;
+
+        peer.killed.catch(() => { }).finally(() => clusterRpcServer.close());
+        clusterRpcServer.on('close', () => {
+            peer.kill('cluster server closed');
+            // close all clusterRpcServer clients
+            for (const client of clients) {
+                client.destroy();
+            }
+            clients.clear();
+        });
+    }
+
+    return {
+        initializeCluster,
+        get clusterPort() {
+            return clusterPort;
+        },
+        SCRYPTED_CLUSTER_ADDRESS,
+        clusterPeers,
+        onProxySerialization,
+        connectClusterObject,
+        ensureClusterPeer,
+        mainThreadPort,
+        mainThreadBrokerRegister,
+        connectRPCObject,
+    }
+}

package/src/scrypted-cluster-main.ts

@@ -0,0 +1,12 @@
+import { install as installSourceMapSupport } from 'source-map-support';
+import { startClusterClient } from './scrypted-cluster';
+
+installSourceMapSupport({
+    environment: 'node',
+});
+
+async function start(mainFilename: string) {
+    startClusterClient(mainFilename);
+}
+
+export default start;