@scrypted/server 0.123.31 → 0.123.33

package/src/plugin/plugin-host.ts

@@ -25,7 +25,7 @@ import { WebSocketConnection } from './plugin-remote-websocket';
 import { ensurePluginVolume, getScryptedVolume } from './plugin-volume';
 import { createClusterForkWorker } from './runtime/cluster-fork-worker';
 import { prepareZipSync } from './runtime/node-worker-common';
-import { RuntimeWorker } from './runtime/runtime-worker';
+import type { RuntimeWorker, RuntimeWorkerOptions } from './runtime/runtime-worker';
 
 const serverVersion = require('../../package.json').version;
 
@@ -341,7 +341,15 @@ export class PluginHost {
         if (!workerHost)
             throw new UnsupportedRuntimeError(this.packageJson.scrypted.runtime);
 
-        let peer: Promise<RpcPeer>
+        let peer: Promise<RpcPeer>;
+        const runtimeWorkerOptions: RuntimeWorkerOptions = {
+            packageJson: this.packageJson,
+            env,
+            pluginDebug,
+            unzippedPath: this.unzippedPath,
+            zipFile: this.zipFile,
+            zipHash: this.zipHash,
+        };
         if (!needsClusterForkWorker(this.packageJson.scrypted)) {
             this.peer = new RpcPeer('host', this.pluginId, (message, reject, serializationContext) => {
                 if (connected) {
@@ -354,14 +362,7 @@ export class PluginHost {
 
             peer = Promise.resolve(this.peer);
 
-            this.worker = workerHost(this.scrypted.mainFilename, this.pluginId, {
-                packageJson: this.packageJson,
-                env,
-                pluginDebug,
-                unzippedPath: this.unzippedPath,
-                zipFile: this.zipFile,
-                zipHash: this.zipHash,
-            }, this.scrypted);
+            this.worker = workerHost(this.scrypted.mainFilename, runtimeWorkerOptions, this.scrypted);
 
             this.worker.setupRpcPeer(this.peer);
 
@@ -379,25 +380,28 @@ export class PluginHost {
             });
 
             const clusterSetup = setupCluster(this.peer);
-            const { runtimeWorker, forkPeer, clusterWorkerId } = createClusterForkWorker((async () => {
-                await clusterSetup.initializeCluster({
-                    clusterId: this.scrypted.clusterId,
-                    clusterSecret: this.scrypted.clusterSecret,
-                });
-                return this.scrypted.clusterFork;
-            })(),
-                this.zipHash, async () => fs.promises.readFile(this.zipFile),
-                this.packageJson.scrypted, this.packageJson, clusterSetup.connectRPCObject);
+            const { runtimeWorker, forkPeer, clusterWorkerId } = createClusterForkWorker(
+                runtimeWorkerOptions,
+                this.packageJson.scrypted,
+                (async () => {
+                    await clusterSetup.initializeCluster({
+                        clusterId: this.scrypted.clusterId,
+                        clusterSecret: this.scrypted.clusterSecret,
+                    });
+                    return this.scrypted.clusterFork;
+                })(),
+                async () => fs.promises.readFile(this.zipFile),
+                clusterSetup.connectRPCObject);
 
             forkPeer.then(peer => {
                 const originalPeer = this.peer;
                 originalPeer.killedSafe.finally(() => peer.kill());
                 this.peer = peer;
                 peer.killedSafe.finally(() => originalPeer.kill());
-            }).catch(() => {});
+            }).catch(() => { });
             clusterWorkerId.then(clusterWorkerId => {
                 console.log('cluster worker id', clusterWorkerId);
-            }).catch(() => {});
+            }).catch(() => { });
 
             this.worker = runtimeWorker;
             peer = forkPeer;

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

@@ -8,11 +8,12 @@ import { needsClusterForkWorker } from '../cluster/cluster-labels';
 import { setupCluster } from '../cluster/cluster-setup';
 import { RpcMessage, RpcPeer } from '../rpc';
 import { evalLocal } from '../rpc-peer-eval';
+import type { DeviceManagerImpl } from './device';
 import { MediaManagerImpl } from './media';
 import { PluginAPI, PluginAPIProxy, PluginRemote, PluginRemoteLoadZipOptions, PluginZipAPI } from './plugin-api';
 import { pipeWorkerConsole, prepareConsoles } from './plugin-console';
 import { getPluginNodePath, installOptionalDependencies } from './plugin-npm-dependencies';
-import { attachPluginRemote, DeviceManagerImpl, setupPluginRemote } from './plugin-remote';
+import { attachPluginRemote, setupPluginRemote } from './plugin-remote';
 import { createREPLServer } from './plugin-repl';
 import { getPluginVolume } from './plugin-volume';
 import { ChildProcessWorker } from './runtime/child-process-worker';
@@ -20,7 +21,10 @@ import { createClusterForkWorker } from './runtime/cluster-fork-worker';
 import { NodeThreadWorker } from './runtime/node-thread-worker';
 import { prepareZip } from './runtime/node-worker-common';
 import { getBuiltinRuntimeHosts } from './runtime/runtime-host';
-import { RuntimeWorker } from './runtime/runtime-worker';
+import { RuntimeWorker, RuntimeWorkerOptions } from './runtime/runtime-worker';
+import type { ClusterForkService } from '../services/cluster-fork';
+import type { PluginComponent } from '../services/plugin';
+import { ClusterManagerImpl } from '../scrypted-cluster-main';
 
 const serverVersion = require('../../package.json').version;
 
@@ -44,10 +48,9 @@ export function startPluginRemote(mainFilename: string, pluginId: string, peerSe
     let deviceManager: DeviceManagerImpl;
     let api: PluginAPI;
 
-    let pluginsPromise: Promise<any>;
+    let pluginsPromise: Promise<PluginComponent>;
     function getPlugins() {
-        if (!pluginsPromise)
-            pluginsPromise = api.getComponent('plugins');
+        pluginsPromise ||= api.getComponent('plugins');
         return pluginsPromise;
     }
 
@@ -113,6 +116,7 @@ export function startPluginRemote(mainFilename: string, pluginId: string, peerSe
             await initializeCluster(zipOptions);
 
             scrypted.connectRPCObject = connectRPCObject;
+            scrypted.clusterManager = new ClusterManagerImpl(api);
 
             if (worker_threads.isMainThread) {
                 const fsDir = path.join(unzippedPath, 'fs')
@@ -212,10 +216,23 @@ export function startPluginRemote(mainFilename: string, pluginId: string, peerSe
                 let nativeWorker: child_process.ChildProcess | worker_threads.Worker;
                 let clusterWorkerId: Promise<string>;
 
+                const runtimeWorkerOptions: RuntimeWorkerOptions = {
+                    packageJson,
+                    env: undefined,
+                    pluginDebug: undefined,
+                    zipFile,
+                    unzippedPath,
+                    zipHash,
+                };
+
                 // if running in a cluster, fork to a matching cluster worker only if necessary.
                 if (needsClusterForkWorker(options)) {
                     ({ runtimeWorker, forkPeer, clusterWorkerId } = createClusterForkWorker(
-                        api.getComponent('cluster-fork'), zipHash, () => zipAPI.getZip(), options, packageJson, scrypted.connectRPCObject)
+                        runtimeWorkerOptions,
+                        options,
+                        api.getComponent('cluster-fork'),
+                        () => zipAPI.getZip(),
+                        scrypted.connectRPCObject)
                     );
                 }
                 else {
@@ -224,14 +241,7 @@ export function startPluginRemote(mainFilename: string, pluginId: string, peerSe
                         const runtime = builtins.get(options.runtime);
                         if (!runtime)
                             throw new Error('unknown runtime ' + options.runtime);
-                        runtimeWorker = runtime(mainFilename, pluginId, {
-                            packageJson,
-                            env: undefined,
-                            pluginDebug: undefined,
-                            zipFile,
-                            unzippedPath,
-                            zipHash,
-                        }, undefined);
+                        runtimeWorker = runtime(mainFilename, runtimeWorkerOptions, undefined);
 
                         if (runtimeWorker instanceof ChildProcessWorker) {
                             nativeWorker = runtimeWorker.childProcess;
@@ -270,17 +280,17 @@ export function startPluginRemote(mainFilename: string, pluginId: string, peerSe
                         }
                     }
 
-                    // thread workers inherit main console. pipe anything else.
-                    if (!(runtimeWorker instanceof NodeThreadWorker)) {
-                        const console = options?.id ? getMixinConsole(options.id, options.nativeId) : undefined;
-                        pipeWorkerConsole(nativeWorker, console);
-                    }
-
                     const localPeer = new RpcPeer('main', 'thread', (message, reject, serializationContext) => runtimeWorker.send(message, reject, serializationContext));
                     runtimeWorker.setupRpcPeer(localPeer);
                     forkPeer = Promise.resolve(localPeer);
                 }
 
+                // thread workers inherit main console. pipe anything else.
+                if (!(runtimeWorker instanceof NodeThreadWorker)) {
+                    const console = options?.id ? getMixinConsole(options.id, options.nativeId) : undefined;
+                    pipeWorkerConsole(runtimeWorker, console);
+                }
+
                 const result = (async () => {
                     const threadPeer = await forkPeer;
 

package/src/plugin/plugin-remote.ts

@@ -1,372 +1,13 @@
-import { Device, DeviceManager, DeviceManifest, DeviceState, EndpointAccessControlAllowOrigin, EndpointManager, EventDetails, Logger, MediaManager, ScryptedInterface, ScryptedInterfaceProperty, ScryptedMimeTypes, ScryptedNativeId, ScryptedStatic, SystemDeviceState, SystemManager, WritableDeviceState } from '@scrypted/types';
+import { EventDetails, MediaManager, ScryptedInterface, ScryptedInterfaceProperty, ScryptedNativeId, ScryptedStatic, SystemDeviceState, SystemManager } from '@scrypted/types';
 import { RpcPeer, RPCResultError } from '../rpc';
-import { AccessControls } from './acl';
 import { BufferSerializer } from '../rpc-buffer-serializer';
-import { PluginAPI, PluginHostInfo, PluginLogger, PluginRemote, PluginRemoteLoadZipOptions, PluginZipAPI } from './plugin-api';
+import { AccessControls } from './acl';
+import { DeviceManagerImpl, StorageImpl } from './device';
+import { EndpointManagerImpl } from './endpoint';
+import { PluginAPI, PluginHostInfo, PluginRemote, PluginRemoteLoadZipOptions, PluginZipAPI } from './plugin-api';
 import { createWebSocketClass, WebSocketConnectCallbacks, WebSocketConnection, WebSocketMethods, WebSocketSerializer } from './plugin-remote-websocket';
-import { checkProperty } from './plugin-state-check';
 import { SystemManagerImpl } from './system';
 
-class DeviceLogger implements Logger {
-    nativeId: ScryptedNativeId;
-    api: PluginAPI;
-    logger: Promise<PluginLogger>;
-
-    constructor(api: PluginAPI, nativeId: ScryptedNativeId, public console: any) {
-        this.api = api;
-        this.nativeId = nativeId;
-    }
-
-    async ensureLogger(): Promise<PluginLogger> {
-        if (!this.logger)
-            this.logger = this.api.getLogger(this.nativeId);
-        return await this.logger;
-    }
-
-    async log(level: string, message: string) {
-        (await this.ensureLogger()).log(level, message);
-    }
-
-    a(msg: string): void {
-        this.log('a', msg);
-    }
-    async clear() {
-        (await this.ensureLogger()).clear();
-    }
-    async clearAlert(msg: string) {
-        (await this.ensureLogger()).clearAlert(msg);
-    }
-    async clearAlerts() {
-        (await this.ensureLogger()).clearAlerts();
-    }
-    d(msg: string): void {
-        this.log('d', msg);
-    }
-    e(msg: string): void {
-        this.log('e', msg);
-    }
-    i(msg: string): void {
-        this.log('i', msg);
-    }
-    v(msg: string): void {
-        this.log('v', msg);
-    }
-    w(msg: string): void {
-        this.log('w', msg);
-    }
-}
-
-class EndpointManagerImpl implements EndpointManager {
-    deviceManager: DeviceManagerImpl;
-    api: PluginAPI;
-    pluginId: string;
-    mediaManager: MediaManager;
-
-    getEndpoint(nativeId?: ScryptedNativeId) {
-        if (!nativeId)
-            return this.pluginId;
-        const id = this.deviceManager.nativeIds.get(nativeId)?.id;
-        if (!id)
-            throw new Error('invalid nativeId ' + nativeId);
-        if (!nativeId)
-            return this.pluginId;
-        return id;
-    }
-
-    async getUrlSafeIp() {
-        // ipv6 addresses have colons and need to be bracketed for url safety
-        const ip: string = await this.api.getComponent('SCRYPTED_IP_ADDRESS')
-        return ip?.includes(':') ? `[${ip}]` : ip;
-    }
-
-    /**
-     * @deprecated
-     */
-    async getAuthenticatedPath(nativeId?: ScryptedNativeId): Promise<string> {
-        return this.getPath(nativeId);
-    }
-
-    /**
-     * @deprecated
-     */
-    async getInsecurePublicLocalEndpoint(nativeId?: ScryptedNativeId): Promise<string> {
-        return this.getLocalEndpoint(nativeId, {
-            insecure: true,
-            public: true,
-        })
-    }
-
-    /**
-     * @deprecated
-     */
-    async getPublicCloudEndpoint(nativeId?: ScryptedNativeId): Promise<string> {
-        return this.getCloudEndpoint(nativeId, {
-            public: true,
-        });
-    }
-
-    /**
-     * @deprecated
-     */
-    async getPublicLocalEndpoint(nativeId?: ScryptedNativeId): Promise<string> {
-        return this.getLocalEndpoint(nativeId, {
-            public: true,
-        })
-    }
-
-    /**
-     * @deprecated
-     */
-    async getPublicPushEndpoint(nativeId?: ScryptedNativeId): Promise<string> {
-        const mo = await this.mediaManager.createMediaObject(Buffer.from(this.getEndpoint(nativeId)), ScryptedMimeTypes.PushEndpoint);
-        return this.mediaManager.convertMediaObjectToUrl(mo, ScryptedMimeTypes.PushEndpoint);
-    }
-
-    async getPath(nativeId?: string, options?: { public?: boolean; }): Promise<string> {
-        return `/endpoint/${this.getEndpoint(nativeId)}/${options?.public ? 'public/' : ''}`
-    }
-
-    async getLocalEndpoint(nativeId?: string, options?: { public?: boolean; insecure?: boolean; }): Promise<string> {
-        const protocol = options?.insecure ? 'http' : 'https';
-        const port = await this.api.getComponent(options?.insecure ? 'SCRYPTED_INSECURE_PORT' : 'SCRYPTED_SECURE_PORT');
-        const path = await this.getPath(nativeId, options);
-        const url = `${protocol}://${await this.getUrlSafeIp()}:${port}${path}`;
-        return url;
-    }
-
-    async getCloudEndpoint(nativeId?: string, options?: { public?: boolean; }): Promise<string> {
-        const local = await this.getLocalEndpoint(nativeId, options);
-        const mo = await this.mediaManager.createMediaObject(Buffer.from(local), ScryptedMimeTypes.LocalUrl);
-        return this.mediaManager.convertMediaObjectToUrl(mo, ScryptedMimeTypes.LocalUrl);
-    }
-
-    async getCloudPushEndpoint(nativeId?: string): Promise<string> {
-        const mo = await this.mediaManager.createMediaObject(Buffer.from(this.getEndpoint(nativeId)), ScryptedMimeTypes.PushEndpoint);
-        return this.mediaManager.convertMediaObjectToUrl(mo, ScryptedMimeTypes.PushEndpoint);
-    }
-
-    async setLocalAddresses(addresses: string[]): Promise<void> {
-        const addressSettings = await this.api.getComponent('addresses');
-        return addressSettings.setLocalAddresses(addresses);
-    }
-
-    async getLocalAddresses(): Promise<string[]> {
-        const addressSettings = await this.api.getComponent('addresses');
-        return await addressSettings.getLocalAddresses() as string[];
-    }
-
-    async setAccessControlAllowOrigin(options: EndpointAccessControlAllowOrigin): Promise<void> {
-        const self = this;
-        const setAccessControlAllowOrigin = await this.deviceManager.systemManager.getComponent('setAccessControlAllowOrigin') as typeof self.setAccessControlAllowOrigin;
-        return setAccessControlAllowOrigin(options);
-    }
-}
-
-class DeviceStateProxyHandler implements ProxyHandler<any> {
-    constructor(public deviceManager: DeviceManagerImpl, public id: string,
-        public setState: (property: string, value: any) => Promise<void>) {
-    }
-
-    get?(target: any, p: PropertyKey, receiver: any) {
-        if (p === 'id')
-            return this.id;
-        if (p === RpcPeer.PROPERTY_PROXY_PROPERTIES)
-            return { id: this.id }
-        if (p === 'setState')
-            return this.setState;
-        return this.deviceManager.systemManager.state[this.id][p as string]?.value;
-    }
-
-    set?(target: any, p: PropertyKey, value: any, receiver: any) {
-        checkProperty(p.toString(), value);
-        this.deviceManager.systemManager.state[this.id][p as string] = {
-            value,
-        };
-        this.setState(p.toString(), value);
-        return true;
-    }
-}
-
-interface DeviceManagerDevice {
-    id: string;
-    storage: { [key: string]: any };
-}
-
-export class DeviceManagerImpl implements DeviceManager {
-    api: PluginAPI;
-    nativeIds = new Map<string, DeviceManagerDevice>();
-    deviceStorage = new Map<string, StorageImpl>();
-    mixinStorage = new Map<string, Map<string, StorageImpl>>();
-
-    constructor(public systemManager: SystemManagerImpl,
-        public getDeviceConsole: (nativeId?: ScryptedNativeId) => Console,
-        public getMixinConsole: (mixinId: string, nativeId?: ScryptedNativeId) => Console) {
-    }
-
-    async requestRestart() {
-        return this.api.requestRestart();
-    }
-
-    getDeviceLogger(nativeId?: ScryptedNativeId): Logger {
-        return new DeviceLogger(this.api, nativeId, this.getDeviceConsole?.(nativeId) || console);
-    }
-
-    getDeviceState(nativeId?: any): DeviceState {
-        const handler = new DeviceStateProxyHandler(this, this.nativeIds.get(nativeId).id,
-            (property, value) => this.api.setState(nativeId, property, value));
-        return new Proxy(handler, handler);
-    }
-
-    createDeviceState(id: string, setState: (property: string, value: any) => Promise<void>): WritableDeviceState {
-        const handler = new DeviceStateProxyHandler(this, id, setState);
-        return new Proxy(handler, handler);
-    }
-
-    getDeviceStorage(nativeId?: any): StorageImpl {
-        let ret = this.deviceStorage.get(nativeId);
-        if (!ret) {
-            ret = new StorageImpl(this, nativeId);
-            this.deviceStorage.set(nativeId, ret);
-        }
-        return ret;
-    }
-    getMixinStorage(id: string, nativeId?: ScryptedNativeId) {
-        let ms = this.mixinStorage.get(nativeId);
-        if (!ms) {
-            ms = new Map();
-            this.mixinStorage.set(nativeId, ms);
-        }
-        let ret = ms.get(id);
-        if (!ret) {
-            ret = new StorageImpl(this, nativeId, `mixin:${id}:`);
-            ms.set(id, ret);
-        }
-        return ret;
-    }
-    pruneMixinStorage() {
-        for (const nativeId of this.nativeIds.keys()) {
-            const storage = this.nativeIds.get(nativeId).storage;
-            for (const key of Object.keys(storage)) {
-                if (!key.startsWith('mixin:'))
-                    continue;
-                const [, id,] = key.split(':');
-                // there's no rush to persist this, it will happen automatically on the plugin
-                // persisting something at some point.
-                // the key itself is unreachable due to the device no longer existing.
-                if (id && !this.systemManager.state[id])
-                    delete storage[key];
-            }
-        }
-    }
-    async onMixinEvent(id: string, nativeId: ScryptedNativeId, eventInterface: string, eventData: any) {
-        return this.api.onMixinEvent(id, nativeId, eventInterface, eventData);
-    }
-    getNativeIds(): string[] {
-        return Array.from(this.nativeIds.keys());
-    }
-    async onDeviceDiscovered(device: Device) {
-        return this.api.onDeviceDiscovered(device);
-    }
-    async onDeviceRemoved(nativeId: string) {
-        return this.api.onDeviceRemoved(nativeId);
-    }
-    async onDeviceEvent(nativeId: any, eventInterface: any, eventData?: any) {
-        return this.api.onDeviceEvent(nativeId, eventInterface, eventData);
-    }
-    async onDevicesChanged(devices: DeviceManifest) {
-        return this.api.onDevicesChanged(devices);
-    }
-}
-
-function toStorageString(value: any) {
-    if (value === null)
-        return 'null';
-    if (value === undefined)
-        return 'undefined';
-
-    return value.toString();
-}
-
-class StorageImpl implements Storage {
-    api: PluginAPI;
-    [name: string]: any;
-
-    private static allowedMethods = [
-        'length',
-        'clear',
-        'getItem',
-        'setItem',
-        'key',
-        'removeItem',
-    ];
-    private static indexedHandler: ProxyHandler<StorageImpl> = {
-        get(target, property) {
-            const keyString = property.toString();
-            if (StorageImpl.allowedMethods.includes(keyString)) {
-                const f = target[keyString];
-                if (keyString === 'length')
-                    return f;
-                return f.bind(target);
-            }
-            return target.getItem(toStorageString(property));
-        },
-        set(target, property, value): boolean {
-            target.setItem(toStorageString(property), value);
-            return true;
-        }
-    };
-
-    constructor(public deviceManager: DeviceManagerImpl, public nativeId: ScryptedNativeId, public prefix?: string) {
-        this.deviceManager = deviceManager;
-        this.api = deviceManager.api;
-        this.nativeId = nativeId;
-        if (!this.prefix)
-            this.prefix = '';
-
-        return new Proxy(this, StorageImpl.indexedHandler);
-    }
-
-    get storage(): { [key: string]: any } {
-        return this.deviceManager.nativeIds.get(this.nativeId).storage;
-    }
-
-    get length(): number {
-        return Object.keys(this.storage).filter(key => key.startsWith(this.prefix)).length;
-    }
-
-    clear(): void {
-        if (!this.prefix) {
-            this.deviceManager.nativeIds.get(this.nativeId).storage = {};
-        }
-        else {
-            const storage = this.storage;
-            Object.keys(this.storage).filter(key => key.startsWith(this.prefix)).forEach(key => delete storage[key]);
-        }
-        this.api.setStorage(this.nativeId, this.storage);
-    }
-
-    getItem(key: string): string {
-        return this.storage[this.prefix + key];
-    }
-    key(index: number): string {
-        if (!this.prefix) {
-            return Object.keys(this.storage)[index];
-        }
-        return Object.keys(this.storage).filter(key => key.startsWith(this.prefix))[index].substring(this.prefix.length);
-    }
-    removeItem(key: string): void {
-        delete this.storage[this.prefix + key];
-        this.api.setStorage(this.nativeId, this.storage);
-    }
-    setItem(key: string, value: string): void {
-        key = toStorageString(key);
-        value = toStorageString(value);
-        if (this.storage[this.prefix + key] === value)
-            return;
-        this.storage[this.prefix + key] = value;
-        this.api.setStorage(this.nativeId, this.storage);
-    }
-}
 
 export async function setupPluginRemote(peer: RpcPeer, api: PluginAPI, pluginId: string, hostInfo: PluginHostInfo, getSystemState: () => { [id: string]: { [property: string]: SystemDeviceState } }): Promise<PluginRemote> {
     try {
@@ -517,6 +158,7 @@ export function attachPluginRemote(peer: RpcPeer, options?: PluginRemoteAttachOp
             deviceManager,
             endpointManager,
             mediaManager,
+            clusterManager: undefined,
             log,
             pluginHostAPI: api,
             pluginRemoteAPI: undefined,

package/src/plugin/runtime/child-process-worker.ts

@@ -4,14 +4,16 @@ import { RpcMessage, RpcPeer } from "../../rpc";
 import { RuntimeWorker, RuntimeWorkerOptions } from "./runtime-worker";
 
 export abstract class ChildProcessWorker extends EventEmitter implements RuntimeWorker {
+    public pluginId: string;
     protected worker: child_process.ChildProcess;
 
     get childProcess() {
         return this.worker;
     }
 
-    constructor(public pluginId: string, options: RuntimeWorkerOptions) {
+    constructor(options: RuntimeWorkerOptions) {
         super();
+        this.pluginId = options.packageJson.name;
     }
 
     setupWorker() {

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

@@ -1,18 +1,24 @@
+import type { ClusterFork } from "@scrypted/types";
 import { EventEmitter, PassThrough } from "stream";
 import { Deferred } from "../../deferred";
 import { RpcPeer } from "../../rpc";
-import { ClusterForkOptions, PeerLiveness } from "../../scrypted-cluster-main";
-import type { ClusterFork } from "../../services/cluster-fork";
+import { PeerLiveness } from "../../scrypted-cluster-main";
+import type { ClusterForkService } from "../../services/cluster-fork";
 import { writeWorkerGenerator } from "../plugin-console";
-import type { RuntimeWorker } from "./runtime-worker";
+import type { RuntimeWorker, RuntimeWorkerOptions } from "./runtime-worker";
 
 export function createClusterForkWorker(
-    forkComponentPromise: Promise<ClusterFork>,
-    zipHash: string,
+    runtimeWorkerOptions: RuntimeWorkerOptions,
+    options: Partial<ClusterFork>,
+    forkComponentPromise: Promise<ClusterForkService>,
     getZip: () => Promise<Buffer>,
-    options: ClusterForkOptions,
-    packageJson: any,
     connectRPCObject: (o: any) => Promise<any>) {
+
+    // these are specific to the cluster worker host
+    // and will be set there.
+    delete runtimeWorkerOptions.zipFile;
+    delete runtimeWorkerOptions.unzippedPath;
+
     const waitKilled = new Deferred<void>();
     waitKilled.promise.finally(() => events.emit('exit'));
     const events = new EventEmitter();
@@ -37,20 +43,22 @@ export function createClusterForkWorker(
     });
 
     const peerLiveness = new PeerLiveness(waitKilled.promise);
-    const clusterForkResultPromise = forkComponentPromise.then(forkComponent => forkComponent.fork(peerLiveness, {
+    const clusterForkResultPromise = forkComponentPromise.then(forkComponent => forkComponent.fork(runtimeWorkerOptions, {
         runtime: options.runtime || 'node',
+        id: options.id,
         ...options,
-    }, packageJson, zipHash, getZip));
-    clusterForkResultPromise.catch(() => {});
+    }, peerLiveness,
+        getZip));
+    clusterForkResultPromise.catch(() => { });
 
     const clusterWorkerId = clusterForkResultPromise.then(clusterForkResult => clusterForkResult.clusterWorkerId);
-    clusterWorkerId.catch(() => {});
+    clusterWorkerId.catch(() => { });
 
     const forkPeer = (async () => {
         const clusterForkResult = await clusterForkResultPromise;
         waitKilled.promise.finally(() => {
             runtimeWorker.pid = undefined;
-            clusterForkResult.kill().catch(() => {});
+            clusterForkResult.kill().catch(() => { });
         });
         clusterForkResult.waitKilled().catch(() => { })
             .finally(() => {

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

@@ -11,8 +11,8 @@ export class CustomRuntimeWorker extends ChildProcessWorker {
     serializer: ReturnType<typeof createRpcDuplexSerializer>;
     fork: boolean;
 
-    constructor(pluginId: string, options: RuntimeWorkerOptions, runtime: ScryptedRuntime) {
-        super(pluginId, options);
+    constructor(options: RuntimeWorkerOptions, runtime: ScryptedRuntime) {
+        super(options);
 
         const pluginDevice = runtime.findPluginDevice(this.pluginId);
         const scryptedRuntimeArguments: ScryptedRuntimeArguments = pluginDevice.state.scryptedRuntimeArguments?.value;
@@ -27,7 +27,7 @@ export class CustomRuntimeWorker extends ChildProcessWorker {
             // stdin, stdout, stderr, peer in, peer out
             stdio: ['pipe', 'pipe', 'pipe', 'pipe', 'pipe', 'pipe'],
             env: Object.assign({}, process.env, env, {
-                SCRYYPTED_PLUGIN_ID: pluginId,
+                SCRYYPTED_PLUGIN_ID: this.pluginId,
                 SCRYPTED_DEBUG_PORT: pluginDebug?.inspectPort?.toString(),
                 SCRYPTED_UNZIPPED_PATH: options.unzippedPath,
                 SCRYPTED_ZIP_FILE: options.zipFile,