@scrypted/server 0.123.9 → 0.123.10

package/dist/services/cluster-fork.d.ts

@@ -1,8 +1,8 @@
 import type { ScryptedRuntime } from "../runtime";
-import { ClusterForkOptions, PeerLiveness } from "../scrypted-cluster";
+import { ClusterForkOptions, PeerLiveness } from "../scrypted-cluster-main";
 export declare class ClusterFork {
     runtime: ScryptedRuntime;
     constructor(runtime: ScryptedRuntime);
-    fork(peerLiveness: PeerLiveness, options: ClusterForkOptions, packageJson: any, zipHash: string, getZip: () => Promise<Buffer>): Promise<import("../scrypted-cluster").ClusterForkResult>;
+    fork(peerLiveness: PeerLiveness, options: ClusterForkOptions, packageJson: any, zipHash: string, getZip: () => Promise<Buffer>): Promise<import("../scrypted-cluster-main").ClusterForkResult>;
     getClusterWorkers(): Promise<any>;
 }

package/dist/services/cluster-fork.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ClusterFork = void 0;
-const scrypted_cluster_1 = require("../scrypted-cluster");
+const cluster_labels_1 = require("../cluster/cluster-labels");
 class ClusterFork {
     runtime;
     constructor(runtime) {
@@ -10,7 +10,7 @@ class ClusterFork {
     async fork(peerLiveness, options, packageJson, zipHash, getZip) {
         const matchingWorkers = [...this.runtime.clusterWorkers].map(worker => ({
             worker,
-            matches: (0, scrypted_cluster_1.matchesClusterLabels)(options, worker.labels),
+            matches: (0, cluster_labels_1.matchesClusterLabels)(options, worker.labels),
         }))
             .filter(({ matches }) => matches);
         matchingWorkers.sort((a, b) => b.worker.labels.length - a.worker.labels.length);

package/dist/services/cluster-fork.js.map

@@ -1 +1 @@
-{"version":3,"file":"cluster-fork.js","sourceRoot":"","sources":["../../src/services/cluster-fork.ts"],"names":[],"mappings":";;;AACA,0DAA+G;AAE/G,MAAa,WAAW;IACD;IAAnB,YAAmB,OAAwB;QAAxB,YAAO,GAAP,OAAO,CAAiB;IAAI,CAAC;IAEhD,KAAK,CAAC,IAAI,CAAC,YAA0B,EAAE,OAA2B,EAAE,WAAgB,EAAE,OAAe,EAAE,MAA6B;QAChI,MAAM,eAAe,GAAG,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC,cAAc,CAAC,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;YACpE,MAAM;YACN,OAAO,EAAE,IAAA,uCAAoB,EAAC,OAAO,EAAE,MAAM,CAAC,MAAM,CAAC;SACxD,CAAC,CAAC;aACF,MAAM,CAAC,CAAC,EAAE,OAAO,EAAE,EAAE,EAAE,CAAC,OAAO,CAAC,CAAC;QAClC,eAAe,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;QAChF,MAAM,MAAM,GAAG,eAAe,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC;QAE1C,IAAI,CAAC,MAAM;YACP,MAAM,IAAI,KAAK,CAAC,sCAAsC,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;QAE5F,MAAM,IAAI,GAAqB,MAAM,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;QAClE,OAAO,IAAI,CAAC,YAAY,EAAE,OAAO,CAAC,OAAO,EAAE,WAAW,EAAE,OAAO,EAAE,MAAM,CAAC,CAAC;IAC7E,CAAC;IAED,KAAK,CAAC,iBAAiB;QACnB,MAAM,GAAG,GAAQ,EAAE,CAAC;QACpB,KAAK,MAAM,MAAM,IAAI,IAAI,CAAC,OAAO,CAAC,cAAc,EAAE,CAAC;YAC/C,GAAG,CAAC,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,GAAG;gBACxB,MAAM,EAAE,MAAM,CAAC,MAAM;aACxB,CAAC;QACN,CAAC;QACD,OAAO,GAAG,CAAC;IACf,CAAC;CACJ;AA5BD,kCA4BC"}
+{"version":3,"file":"cluster-fork.js","sourceRoot":"","sources":["../../src/services/cluster-fork.ts"],"names":[],"mappings":";;;AACA,8DAAiE;AAGjE,MAAa,WAAW;IACD;IAAnB,YAAmB,OAAwB;QAAxB,YAAO,GAAP,OAAO,CAAiB;IAAI,CAAC;IAEhD,KAAK,CAAC,IAAI,CAAC,YAA0B,EAAE,OAA2B,EAAE,WAAgB,EAAE,OAAe,EAAE,MAA6B;QAChI,MAAM,eAAe,GAAG,CAAC,GAAG,IAAI,CAAC,OAAO,CAAC,cAAc,CAAC,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;YACpE,MAAM;YACN,OAAO,EAAE,IAAA,qCAAoB,EAAC,OAAO,EAAE,MAAM,CAAC,MAAM,CAAC;SACxD,CAAC,CAAC;aACF,MAAM,CAAC,CAAC,EAAE,OAAO,EAAE,EAAE,EAAE,CAAC,OAAO,CAAC,CAAC;QAClC,eAAe,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,CAAC,CAAC;QAChF,MAAM,MAAM,GAAG,eAAe,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC;QAE1C,IAAI,CAAC,MAAM;YACP,MAAM,IAAI,KAAK,CAAC,sCAAsC,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;QAE5F,MAAM,IAAI,GAAqB,MAAM,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;QAClE,OAAO,IAAI,CAAC,YAAY,EAAE,OAAO,CAAC,OAAO,EAAE,WAAW,EAAE,OAAO,EAAE,MAAM,CAAC,CAAC;IAC7E,CAAC;IAED,KAAK,CAAC,iBAAiB;QACnB,MAAM,GAAG,GAAQ,EAAE,CAAC;QACpB,KAAK,MAAM,MAAM,IAAI,IAAI,CAAC,OAAO,CAAC,cAAc,EAAE,CAAC;YAC/C,GAAG,CAAC,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,GAAG;gBACxB,MAAM,EAAE,MAAM,CAAC,MAAM;aACxB,CAAC;QACN,CAAC;QACD,OAAO,GAAG,CAAC;IACf,CAAC;CACJ;AA5BD,kCA4BC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scrypted/server",
-  "version": "0.123.9",
+  "version": "0.123.10",
   "description": "",
   "dependencies": {
     "@scrypted/ffmpeg-static": "^6.1.0-build3",

package/python/plugin_remote.py

@@ -11,7 +11,6 @@ import os
 import platform
 import random
 import sys
-import threading
 import time
 import traceback
 import zipfile
@@ -582,7 +581,7 @@ class ClusterSetup():
             return
         return sourcePeer.localProxyMap.get(id, None)
 
-    async def connectRPCObject(self, o: ClusterObject):
+    async def connectClusterObject(self, o: ClusterObject):
         sha256 = self.computeClusterObjectHash(o)
         if sha256 != o["sha256"]:
             raise Exception("secret incorrect")
@@ -647,7 +646,7 @@ class ClusterSetup():
             future: asyncio.Future[rpc.RpcPeer] = asyncio.Future()
             future.set_result(peer)
             self.clusterPeers[clusterPeerKey] = future
-            peer.params["connectRPCObject"] = lambda o: self.connectRPCObject(o)
+            peer.params["connectRPCObject"] = lambda o: self.connectClusterObject(o)
             try:
                 await peerReadLoop()
             except:
@@ -675,6 +674,93 @@ class ClusterSetup():
         )
         return base64.b64encode(m.digest()).decode("utf-8")
 
+    def ensureClusterPeer(self, address: str, port: int):
+        if isClusterAddress(address):
+            address = "127.0.0.1"
+        clusterPeerKey = getClusterPeerKey(address, port)
+        clusterPeerPromise = self.clusterPeers.get(clusterPeerKey)
+        if clusterPeerPromise:
+            return clusterPeerPromise
+
+        async def connectClusterPeer():
+            try:
+                reader, writer = await asyncio.open_connection(address, port)
+                sourceAddress, sourcePort = writer.get_extra_info("sockname")
+                if (
+                    sourceAddress != self.SCRYPTED_CLUSTER_ADDRESS
+                    and sourceAddress != "127.0.0.1"
+                ):
+                    print("source address mismatch", sourceAddress)
+                rpcTransport = rpc_reader.RpcStreamTransport(reader, writer)
+                clusterPeer, peerReadLoop = await rpc_reader.prepare_peer_readloop(
+                    self.loop, rpcTransport
+                )
+                # set all params from self.peer
+                for key, value in self.peer.params.items():
+                    clusterPeer.params[key] = value
+                clusterPeer.onProxySerialization = (
+                    lambda value: self.clusterSetup.onProxySerialization(
+                        clusterPeer, value, clusterPeerKey
+                    )
+                )
+            except:
+                self.clusterPeers.pop(clusterPeerKey)
+                raise
+
+            async def run_loop():
+                try:
+                    await peerReadLoop()
+                except:
+                    pass
+                finally:
+                    self.clusterPeers.pop(clusterPeerKey)
+
+            asyncio.run_coroutine_threadsafe(run_loop(), self.loop)
+            return clusterPeer
+
+        clusterPeerPromise = self.loop.create_task(connectClusterPeer())
+
+        self.clusterPeers[clusterPeerKey] = clusterPeerPromise
+        return clusterPeerPromise
+
+    async def connectRPCObject(self, value):
+        __cluster = getattr(value, "__cluster")
+        if type(__cluster) is not dict:
+            return value
+
+        clusterObject: ClusterObject = __cluster
+
+        if clusterObject.get("id", None) != self.clusterId:
+            return value
+
+        address = clusterObject.get("address", None)
+        port = clusterObject["port"]
+        proxyId = clusterObject["proxyId"]
+        if port == self.clusterPort:
+            return await self.connectRPCObject(clusterObject)
+
+        clusterPeerPromise = self.ensureClusterPeer(address, port)
+
+        try:
+            clusterPeer = await clusterPeerPromise
+            weakref = clusterPeer.remoteWeakProxies.get(proxyId, None)
+            existing = weakref() if weakref else None
+            if existing:
+                return existing
+
+            peerConnectRPCObject = clusterPeer.tags.get("connectRPCObject")
+            if not peerConnectRPCObject:
+                peerConnectRPCObject = await clusterPeer.getParam(
+                    "connectRPCObject"
+                )
+                clusterPeer.tags["connectRPCObject"] = peerConnectRPCObject
+            newValue = await peerConnectRPCObject(clusterObject)
+            if not newValue:
+                raise Exception("rpc object not found?")
+            return newValue
+        except Exception as e:
+            return value
+
 class PluginRemote:
     def __init__(
         self, clusterSetup: ClusterSetup, api, pluginId: str, hostInfo, loop: AbstractEventLoop
@@ -757,94 +843,7 @@ class PluginRemote:
 
         sdk = ScryptedStatic()
 
-        def ensureClusterPeer(address: str, port: int):
-            if isClusterAddress(address):
-                address = "127.0.0.1"
-            clusterPeerKey = getClusterPeerKey(address, port)
-            clusterPeerPromise = self.clusterSetup.clusterPeers.get(clusterPeerKey)
-            if clusterPeerPromise:
-                return clusterPeerPromise
-
-            async def connectClusterPeer():
-                try:
-                    reader, writer = await asyncio.open_connection(address, port)
-                    sourceAddress, sourcePort = writer.get_extra_info("sockname")
-                    if (
-                        sourceAddress != self.clusterSetup.SCRYPTED_CLUSTER_ADDRESS
-                        and sourceAddress != "127.0.0.1"
-                    ):
-                        print("source address mismatch", sourceAddress)
-                    rpcTransport = rpc_reader.RpcStreamTransport(reader, writer)
-                    clusterPeer, peerReadLoop = await rpc_reader.prepare_peer_readloop(
-                        self.loop, rpcTransport
-                    )
-                    # set all params from self.peer
-                    for key, value in self.peer.params.items():
-                        clusterPeer.params[key] = value
-                    clusterPeer.onProxySerialization = (
-                        lambda value: self.clusterSetup.onProxySerialization(
-                            clusterPeer, value, clusterPeerKey
-                        )
-                    )
-                except:
-                    self.clusterSetup.clusterPeers.pop(clusterPeerKey)
-                    raise
-
-                async def run_loop():
-                    try:
-                        await peerReadLoop()
-                    except:
-                        pass
-                    finally:
-                        self.clusterSetup.clusterPeers.pop(clusterPeerKey)
-
-                asyncio.run_coroutine_threadsafe(run_loop(), self.loop)
-                return clusterPeer
-
-            clusterPeerPromise = self.loop.create_task(connectClusterPeer())
-
-            self.clusterSetup.clusterPeers[clusterPeerKey] = clusterPeerPromise
-            return clusterPeerPromise
-
-        async def connectRPCObject(value):
-            __cluster = getattr(value, "__cluster")
-            if type(__cluster) is not dict:
-                return value
-
-            clusterObject: ClusterObject = __cluster
-
-            if clusterObject.get("id", None) != self.clusterSetup.clusterId:
-                return value
-
-            address = clusterObject.get("address", None)
-            port = clusterObject["port"]
-            proxyId = clusterObject["proxyId"]
-            if port == self.clusterSetup.clusterPort:
-                return await self.clusterSetup.connectRPCObject(clusterObject)
-
-            clusterPeerPromise = ensureClusterPeer(address, port)
-
-            try:
-                clusterPeer = await clusterPeerPromise
-                weakref = clusterPeer.remoteWeakProxies.get(proxyId, None)
-                existing = weakref() if weakref else None
-                if existing:
-                    return existing
-
-                peerConnectRPCObject = clusterPeer.tags.get("connectRPCObject")
-                if not peerConnectRPCObject:
-                    peerConnectRPCObject = await clusterPeer.getParam(
-                        "connectRPCObject"
-                    )
-                    clusterPeer.tags["connectRPCObject"] = peerConnectRPCObject
-                newValue = await peerConnectRPCObject(clusterObject)
-                if not newValue:
-                    raise Exception("rpc object not found?")
-                return newValue
-            except Exception as e:
-                return value
-
-        sdk.connectRPCObject = connectRPCObject
+        sdk.connectRPCObject = lambda v: self.clusterSetup.connectRPCObject(v)
 
         forkMain = options and options.get("fork")
         debug = options.get("debug", None)
@@ -1142,15 +1141,6 @@ class PluginRemote:
         raise Exception(f"unknown service {name}")
 
     async def start_stats_runner(self, update_stats):
-        pong = None
-
-        async def ping(time: int):
-            nonlocal pong
-            pong = pong or await self.peer.getParam("pong")
-            await pong(time)
-
-        self.peer.params["ping"] = ping
-
         def stats_runner():
             ptime = round(time.process_time() * 1000000) + self.ptimeSum
             try:
@@ -1193,6 +1183,14 @@ async def plugin_async_main(
     clusterSetup = ClusterSetup(loop, peer)
     peer.params["initializeCluster"] = lambda options: clusterSetup.initializeCluster(options)
 
+    pong = None
+    async def ping(time: int):
+        nonlocal pong
+        pong = pong or await peer.getParam("pong")
+        await pong(time)
+
+    peer.params["ping"] = ping
+
     peer.params["getRemote"] = lambda api, pluginId, hostInfo: PluginRemote(
         clusterSetup, api, pluginId, hostInfo, loop
     )
@@ -1215,48 +1213,9 @@ def main(rpcTransport: rpc_reader.RpcTransport):
     loop.run_until_complete(plugin_async_main(loop, rpcTransport))
     loop.close()
 
-
-def plugin_main(rpcTransport: rpc_reader.RpcTransport):
-    if True:
-        main(rpcTransport)
-        return
-
-    # 03/05/2024
-    # Not sure why this code below was necessary. I thought it was gstreamer needing to
-    # be initialized on the main thread, but that no longer seems to be the case.
-
-    # gi import will fail on windows (and posisbly elsewhere)
-    # if it does, try starting without it.
-    try:
-        import gi
-
-        gi.require_version("Gst", "1.0")
-        from gi.repository import GLib, Gst
-
-        Gst.init(None)
-
-        # can't remember why starting the glib main loop is necessary.
-        # maybe gstreamer on linux and other things needed it?
-        # seems optional on other platforms.
-        loop = GLib.MainLoop()
-
-        worker = threading.Thread(
-            target=main, args=(rpcTransport,), name="asyncio-main"
-        )
-        worker.start()
-
-        loop.run()
-        return
-    except:
-        pass
-
-    # reattempt without gi outside of the exception handler in case the plugin fails.
-    main(rpcTransport)
-
-
 def plugin_fork(conn: multiprocessing.connection.Connection):
-    plugin_main(rpc_reader.RpcConnectionTransport(conn))
+    main(rpc_reader.RpcConnectionTransport(conn))
 
 
 if __name__ == "__main__":
-    plugin_main(rpc_reader.RpcFileTransport(3, 4))
+    main(rpc_reader.RpcFileTransport(3, 4))

package/src/cluster/cluster-labels.ts

@@ -0,0 +1,36 @@
+import os from 'os';
+import { ClusterForkOptions } from "../scrypted-cluster-main";
+
+export function matchesClusterLabels(options: ClusterForkOptions, labels: string[]) {
+    let matched = 0;
+    for (const label of options?.labels?.require || []) {
+        if (!labels.includes(label))
+            return 0;
+    }
+
+    // if there is nothing in the any list, consider it matched
+    let foundAny = !options?.labels?.any?.length;
+    for (const label of options.labels?.any || []) {
+        if (labels.includes(label)) {
+            matched++;
+            foundAny = true;
+        }
+    }
+    if (!foundAny)
+        return 0;
+
+    for (const label of options?.labels?.prefer || []) {
+        if (labels.includes(label))
+            matched++;
+    }
+    // ensure non zero result.
+    matched++;
+    return matched;
+}
+
+export function getClusterLabels() {
+    let labels = process.env.SCRYPTED_CLUSTER_LABELS?.split(',') || [];
+    labels.push(process.arch, process.platform, os.hostname());
+    labels = [...new Set(labels)];
+    return labels;
+}

package/src/{scrypted-cluster-common.ts → cluster/cluster-setup.ts}

@@ -1,16 +1,15 @@
 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) {
+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 { computeClusterObjectHash } from "./cluster-hash";
+import { ClusterObject, ConnectRPCObject } from "./connect-rpc-object";
+
+function getClusterPeerKey(address: string, port: number) {
     return `${address}:${port}`;
 }
 
@@ -18,7 +17,7 @@ export function isClusterAddress(address: string) {
     return !address || address === process.env.SCRYPTED_CLUSTER_ADDRESS;
 }
 
-export async function peerConnectRPCObject(peer: RpcPeer, o: ClusterObject) {
+async function peerConnectRPCObject(peer: RpcPeer, o: ClusterObject) {
     let peerConnectRPCObject: Promise<ConnectRPCObject> = peer.tags['connectRPCObject'];
     if (!peerConnectRPCObject) {
         peerConnectRPCObject = peer.getParam('connectRPCObject');
@@ -28,7 +27,7 @@ export async function peerConnectRPCObject(peer: RpcPeer, o: ClusterObject) {
     return resolved(o);
 }
 
-export function prepareClusterPeer(peer: RpcPeer) {
+export function setupCluster(peer: RpcPeer) {
     const SCRYPTED_CLUSTER_ADDRESS = process.env.SCRYPTED_CLUSTER_ADDRESS;
     let clusterId: string;
     let clusterSecret: string;
@@ -371,4 +370,57 @@ export function prepareClusterPeer(peer: RpcPeer) {
         mainThreadBrokerRegister,
         connectRPCObject,
     }
-}
+}
+
+export type InitializeCluster = (cluster: { clusterId: string, clusterSecret: string }) => Promise<void>;
+
+export function getScryptedClusterMode(): ['server' | 'client', string, number] {
+    const mode = process.env.SCRYPTED_CLUSTER_MODE as 'server' | 'client';
+
+    if (!mode) {
+        if (process.env.SCRYPTED_CLUSTER_ADDRESS) {
+            console.warn('SCRYPTED_CLUSTER_ADDRESS, but SCRYPTED_CLUSTER_MODE is not set. This setting will be ignored.');
+            delete process.env.SCRYPTED_CLUSTER_ADDRESS;
+        }
+        if (process.env.SCRPYTED_CLUSTER_SERVER) {
+            console.warn('SCRYPTED_CLUSTER_SERVER, but SCRYPTED_CLUSTER_MODE is not set. This setting will be ignored.');
+            delete process.env.SCRPYTED_CLUSTER_SERVER
+        }
+        if (process.env.SCRYPTED_CLUSTER_SECRET) {
+            console.warn('SCRYPTED_CLUSTER_SECRET, but SCRYPTED_CLUSTER_MODE is not set. This setting will be ignored.');
+            delete process.env.SCRYPTED_CLUSTER_SECRET;
+        }
+        return;
+    }
+
+    if (!['server', 'client'].includes(mode))
+        throw new Error('SCRYPTED_CLUSTER_MODE must be set to either "server" or "client".');
+
+    if (!process.env.SCRYPTED_CLUSTER_SECRET)
+        throw new Error('SCRYPTED_CLUSTER_MODE is set but SCRYPTED_CLUSTER_SECRET is not set.');
+
+    const [server, sport] = process.env.SCRYPTED_CLUSTER_SERVER?.split(':') || [];
+    const port = parseInt(sport) || 10556;
+    const address = process.env.SCRYPTED_CLUSTER_ADDRESS;
+
+    if (mode === 'client') {
+        if (!net.isIP(server))
+            throw new Error('SCRYPTED_CLUSTER_SERVER is not a valid IP address:port.');
+
+        if (!net.isIP(address))
+            throw new Error('SCRYPTED_CLUSTER_ADDRESS is not set to a valid IP address.');
+    }
+    else {
+        // the cluster address may come from the server:port combo or address variable but not both.
+        if (address && server && server !== address)
+            throw new Error('SCRYPTED_CLUSTER_ADDRESS and SCRYPTED_CLUSTER_SERVER must not both be used.');
+
+        const serverAddress = address || server;
+        if (!net.isIP(serverAddress))
+            throw new Error('SCRYPTED_CLUSTER_ADDRESS is not set.');
+        process.env.SCRYPTED_CLUSTER_ADDRESS = serverAddress;
+        delete process.env.SCRYPTED_CLUSTER_SERVER;
+    }
+
+    return [mode, server, port];
+}

package/src/plugin/plugin-console.ts

@@ -4,7 +4,7 @@ import { once } from 'events';
 import net, { Server } from 'net';
 import { PassThrough, Readable, Writable } from 'stream';
 import { listenZero } from '../listen-zero';
-import { isClusterAddress } from '../scrypted-cluster-common';
+import { isClusterAddress } from '../cluster/cluster-setup';
 
 export interface ConsoleServer {
     pluginConsole: Console;

package/src/plugin/plugin-host.ts

@@ -10,7 +10,7 @@ import { Logger } from '../logger';
 import { RpcPeer, RPCResultError } from '../rpc';
 import { createRpcSerializer } from '../rpc-serializer';
 import { ScryptedRuntime } from '../runtime';
-import { prepareClusterPeer } from '../scrypted-cluster-common';
+import { setupCluster } from '../cluster/cluster-setup';
 import { sleep } from '../sleep';
 import { AccessControls } from './acl';
 import { MediaManagerHostImpl } from './media';
@@ -342,7 +342,7 @@ export class PluginHost {
                 }
             });
 
-            const clusterSetup = prepareClusterPeer(this.peer);
+            const clusterSetup = setupCluster(this.peer);
             const { runtimeWorker, forkPeer } = createClusterForkWorker((async () => {
                 await clusterSetup.initializeCluster({
                     clusterId: this.scrypted.clusterId,
@@ -394,12 +394,12 @@ export class PluginHost {
         };
         (async () => {
             try {
-                let pingPromise: Promise<any>
+                let pingPromise: Promise<(time: number) => Promise<void>>
                 while (!this.killed) {
                     await sleep(30000);
                     if (this.killed)
                         return;
-                    pingPromise ||= peer.then(p => p.getParam('ping'));
+                    pingPromise ||= this.peer.getParam('ping');
                     const ping = await pingPromise;
                     await ping(Date.now());
                 }

package/src/plugin/plugin-remote-worker.ts

@@ -1,17 +1,12 @@
 import { ForkWorker, ScryptedStatic, SystemManager } from '@scrypted/types';
 import child_process from 'child_process';
-import { once } from 'events';
 import fs from 'fs';
-import net from 'net';
 import path from 'path';
 import { install as installSourceMapSupport } from 'source-map-support';
 import worker_threads from 'worker_threads';
-import { ClusterObject, ConnectRPCObject } from '../cluster/connect-rpc-object';
-import { Deferred } from '../deferred';
+import { setupCluster } from '../cluster/cluster-setup';
 import { RpcMessage, RpcPeer } from '../rpc';
 import { evalLocal } from '../rpc-peer-eval';
-import { createDuplexRpcPeer } from '../rpc-serializer';
-import { getClusterPeerKey, isClusterAddress, peerConnectRPCObject, prepareClusterPeer } from '../scrypted-cluster-common';
 import { MediaManagerImpl } from './media';
 import { PluginAPI, PluginAPIProxy, PluginRemote, PluginRemoteLoadZipOptions, PluginZipAPI } from './plugin-api';
 import { pipeWorkerConsole, prepareConsoles } from './plugin-console';
@@ -37,7 +32,7 @@ export interface StartPluginRemoteOptions {
 export function startPluginRemote(mainFilename: string, pluginId: string, peerSend: (message: RpcMessage, reject?: (e: Error) => void, serializationContext?: any) => void, startPluginRemoteOptions?: StartPluginRemoteOptions) {
     const peer = new RpcPeer('unknown', 'host', peerSend);
 
-    const clusterPeerSetup = prepareClusterPeer(peer);
+    const clusterPeerSetup = setupCluster(peer);
     const { initializeCluster, connectRPCObject, mainThreadBrokerRegister , mainThreadPort } = clusterPeerSetup;
 
     peer.params.initializeCluster = initializeCluster;

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

@@ -1,11 +1,11 @@
 import { EventEmitter, PassThrough } from "stream";
 import { Deferred } from "../../deferred";
 import { RpcPeer } from "../../rpc";
-import { ClusterForkOptions, getClusterLabels, matchesClusterLabels, PeerLiveness } from "../../scrypted-cluster";
+import { getClusterLabels, matchesClusterLabels } from "../../cluster/cluster-labels";
+import { ClusterForkOptions, PeerLiveness } from "../../scrypted-cluster-main";
 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())

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

@@ -4,7 +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';
+import { getScryptedClusterMode } from '../../cluster/cluster-setup';
 
 export const NODE_PLUGIN_CHILD_PROCESS = 'child';
 export const NODE_PLUGIN_FORK_PROCESS = 'fork';

package/src/runtime.ts

@@ -33,7 +33,6 @@ 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';
@@ -45,7 +44,8 @@ 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';
+import { isClusterAddress } from './cluster/cluster-setup';
+import { ClusterWorker } from './scrypted-cluster-main';
 
 interface DeviceProxyPair {
     handler: PluginDeviceProxyHandler;