@scrypted/server 0.123.31 → 0.123.32

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';
@@ -21,6 +22,9 @@ 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 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')
@@ -270,17 +274,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/cluster-fork-worker.ts

@@ -1,16 +1,17 @@
+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";
 
 export function createClusterForkWorker(
-    forkComponentPromise: Promise<ClusterFork>,
+    forkComponentPromise: Promise<ClusterForkService>,
     zipHash: string,
     getZip: () => Promise<Buffer>,
-    options: ClusterForkOptions,
+    options: Partial<ClusterFork>,
     packageJson: any,
     connectRPCObject: (o: any) => Promise<any>) {
     const waitKilled = new Deferred<void>();
@@ -39,6 +40,7 @@ export function createClusterForkWorker(
     const peerLiveness = new PeerLiveness(waitKilled.promise);
     const clusterForkResultPromise = forkComponentPromise.then(forkComponent => forkComponent.fork(peerLiveness, {
         runtime: options.runtime || 'node',
+        id: options.id,
         ...options,
     }, packageJson, zipHash, getZip));
     clusterForkResultPromise.catch(() => {});

package/src/plugin/system.ts

@@ -1,7 +1,6 @@
 import { EventListener, EventListenerOptions, EventListenerRegister, Logger, ScryptedDevice, ScryptedDeviceType, ScryptedInterface, ScryptedInterfaceDescriptor, ScryptedInterfaceDescriptors, ScryptedInterfaceProperty, ScryptedNativeId, SystemDeviceState, SystemManager } from "@scrypted/types";
 import { EventRegistry } from "../event-registry";
 import { PrimitiveProxyHandler, RpcPeer } from '../rpc';
-// import type { PluginComponent } from "../services/plugin";
 import { getInterfaceMethods, getInterfaceProperties, getPropertyInterfaces, isValidInterfaceMethod, propertyInterfaces } from "./descriptor";
 import { PluginAPI } from "./plugin-api";
 

package/src/runtime.ts

@@ -37,7 +37,7 @@ import { getIpAddress, SCRYPTED_INSECURE_PORT, SCRYPTED_SECURE_PORT } from './se
 import { AddressSettings } from './services/addresses';
 import { Alerts } from './services/alerts';
 import { Backup } from './services/backup';
-import { ClusterFork } from './services/cluster-fork';
+import { ClusterForkService } from './services/cluster-fork';
 import { CORSControl } from './services/cors';
 import { Info } from './services/info';
 import { getNpmPackageInfo, PluginComponent } from './services/plugin';
@@ -45,7 +45,7 @@ import { ServiceControl } from './services/service-control';
 import { UsersService } from './services/users';
 import { getState, ScryptedStateManager, setState } from './state';
 import { isClusterAddress } from './cluster/cluster-setup';
-import { ClusterWorker } from './scrypted-cluster-main';
+import { RunningClusterWorker } from './scrypted-cluster-main';
 
 interface DeviceProxyPair {
     handler: PluginDeviceProxyHandler;
@@ -63,7 +63,7 @@ interface HttpPluginData {
 export class ScryptedRuntime extends PluginHttp<HttpPluginData> {
     clusterId = crypto.randomBytes(3).toString('hex');
     clusterSecret = process.env.SCRYPTED_CLUSTER_SECRET || crypto.randomBytes(16).toString('hex');
-    clusterWorkers = new Map<string, ClusterWorker>();
+    clusterWorkers = new Map<string, RunningClusterWorker>();
     plugins: { [id: string]: PluginHost } = {};
     pluginDevices: { [id: string]: PluginDevice } = {};
     devices: { [id: string]: DeviceProxyPair } = {};
@@ -89,7 +89,7 @@ export class ScryptedRuntime extends PluginHttp<HttpPluginData> {
     corsControl = new CORSControl(this);
     addressSettings = new AddressSettings(this);
     usersService = new UsersService(this);
-    clusterFork = new ClusterFork(this);
+    clusterFork = new ClusterForkService(this);
     info = new Info();
     backup = new Backup(this);
     pluginHosts = getBuiltinRuntimeHosts();

package/src/scrypted-cluster-main.ts

@@ -1,4 +1,4 @@
-import type { ForkOptions } from '@scrypted/types';
+import type { ClusterManager, ClusterWorker, ForkOptions } from '@scrypted/types';
 import crypto from 'crypto';
 import { once } from 'events';
 import net from 'net';
@@ -11,13 +11,15 @@ import { computeClusterObjectHash } from './cluster/cluster-hash';
 import { getClusterLabels } from './cluster/cluster-labels';
 import { getScryptedClusterMode, InitializeCluster, setupCluster } from './cluster/cluster-setup';
 import type { ClusterObject } from './cluster/connect-rpc-object';
+import type { PluginAPI } from './plugin/plugin-api';
 import { getPluginVolume, getScryptedVolume } from './plugin/plugin-volume';
 import { prepareZip } from './plugin/runtime/node-worker-common';
 import { getBuiltinRuntimeHosts } from './plugin/runtime/runtime-host';
-import { RuntimeWorker } from './plugin/runtime/runtime-worker';
+import type { RuntimeWorker } from './plugin/runtime/runtime-worker';
 import { RpcPeer } from './rpc';
 import { createRpcDuplexSerializer } from './rpc-serializer';
 import type { ScryptedRuntime } from './runtime';
+import type { ClusterForkService } from './services/cluster-fork';
 import { sleep } from './sleep';
 
 installSourceMapSupport({
@@ -64,13 +66,13 @@ export interface ClusterForkOptions {
     clusterWorkerId?: ForkOptions['clusterWorkerId'];
 }
 
-type ConnectForkWorker = (auth: ClusterObject, properties: ClusterWorkerProperties) => Promise<{ clusterId: string }>;
+type ConnectForkWorker = (auth: ClusterObject, properties: ClusterWorkerProperties) => Promise<{ clusterId: string, clusterWorkerId: string }>;
 
 export interface ClusterWorkerProperties {
     labels: string[];
 }
 
-export interface ClusterWorker extends ClusterWorkerProperties {
+export interface RunningClusterWorker extends ClusterWorkerProperties {
     id: string;
     peer: RpcPeer;
     forks: Set<ClusterForkOptions>;
@@ -157,12 +159,11 @@ export function startClusterClient(mainFilename: string) {
             });
 
             try {
-
                 const connectForkWorker: ConnectForkWorker = await peer.getParam('connectForkWorker');
                 const auth: ClusterObject = {
                     address: socket.localAddress,
                     port: socket.localPort,
-                    id: process.env.SCRYPTED_CLUSTER_ID || os.hostname(),
+                    id: process.env.SCRYPTED_CLUSTER_CLIENT_NAME || os.hostname(),
                     proxyId: undefined,
                     sourceKey: undefined,
                     sha256: undefined,
@@ -173,7 +174,8 @@ export function startClusterClient(mainFilename: string) {
                     labels,
                 };
 
-                const { clusterId } = await connectForkWorker(auth, properties);
+                const { clusterId, clusterWorkerId } = await connectForkWorker(auth, properties);
+                process.env.SCRYPTED_CLUSTER_WORKER_ID = clusterWorkerId;
                 const clusterPeerSetup = setupCluster(peer);
                 await clusterPeerSetup.initializeCluster({ clusterId, clusterSecret });
 
@@ -207,6 +209,8 @@ export function startClusterClient(mainFilename: string) {
                         unzippedPath,
                         zipHash,
                     }, undefined);
+                    runtimeWorker.stdout.on('data', data => console.log(data.toString()));
+                    runtimeWorker.stderr.on('data', data => console.error(data.toString()));
 
                     const threadPeer = new RpcPeer('main', 'thread', (message, reject, serializationContext) => runtimeWorker.send(message, reject, serializationContext));
                     runtimeWorker.setupRpcPeer(threadPeer);
@@ -288,6 +292,7 @@ export function createClusterServer(runtime: ScryptedRuntime, certificate: Retur
         const peer = preparePeer(socket, 'server');
 
         const connectForkWorker: ConnectForkWorker = async (auth: ClusterObject, properties: ClusterWorkerProperties) => {
+            const id = crypto.randomUUID();
             try {
                 const sha256 = computeClusterObjectHash(auth, runtime.clusterSecret);
                 if (sha256 !== auth.sha256)
@@ -301,8 +306,7 @@ export function createClusterServer(runtime: ScryptedRuntime, certificate: Retur
                     if (auth.port !== socket.remotePort || !socket.remoteAddress.endsWith(auth.address))
                         throw new Error('cluster object address mismatch');
                 }
-                const id = crypto.randomUUID();
-                const worker: ClusterWorker = {
+                const worker: RunningClusterWorker = {
                     ...properties,
                     // generate a random uuid.
                     id,
@@ -325,6 +329,7 @@ export function createClusterServer(runtime: ScryptedRuntime, certificate: Retur
 
             return {
                 clusterId: runtime.clusterId,
+                clusterWorkerId: id,
             }
         }
         peer.params['connectForkWorker'] = connectForkWorker;
@@ -332,3 +337,28 @@ export function createClusterServer(runtime: ScryptedRuntime, certificate: Retur
 
     return server;
 }
+
+export class ClusterManagerImpl implements ClusterManager {
+    private  clusterServicePromise: Promise<ClusterForkService>;
+
+    constructor(private api: PluginAPI) {
+    }
+
+    getClusterWorkerId(): string {
+        return process.env.SCRYPTED_CLUSTER_WORKER_ID;
+    }
+
+    getClusterMode(): 'server' | 'client' | undefined {
+        return getScryptedClusterMode()[0];
+    }
+
+    async getClusterWorkers(): Promise<Record<string, ClusterWorker>> {
+        const clusterFork = await this.getClusterService();
+        return clusterFork.getClusterWorkers();
+    }
+
+    private getClusterService() {
+        this.clusterServicePromise ||= this.api.getComponent('cluster-fork');
+        return this.clusterServicePromise;
+    }
+}

package/src/services/cluster-fork.ts

@@ -1,9 +1,8 @@
-import type { ScryptedRuntime } from "../runtime";
 import { matchesClusterLabels } from "../cluster/cluster-labels";
-import { ClusterForkOptions, ClusterForkParam, ClusterWorker, PeerLiveness } from "../scrypted-cluster-main";
-import { RpcPeer } from "../rpc";
+import type { ScryptedRuntime } from "../runtime";
+import type { ClusterForkOptions, ClusterForkParam, PeerLiveness, RunningClusterWorker } from "../scrypted-cluster-main";
 
-export class ClusterFork {
+export class ClusterForkService {
     constructor(public runtime: ScryptedRuntime) { }
 
     async fork(peerLiveness: PeerLiveness, options: ClusterForkOptions, packageJson: any, zipHash: string, getZip: () => Promise<Buffer>) {
@@ -18,7 +17,7 @@ export class ClusterFork {
             });
         matchingWorkers.sort((a, b) => b.worker.labels.length - a.worker.labels.length);
 
-        let worker: ClusterWorker;
+        let worker: RunningClusterWorker;
 
         // try to keep fork id affinity to single worker if present. this presents the opportunity for
         // IPC.
@@ -36,6 +35,7 @@ export class ClusterFork {
 
         const fork: ClusterForkParam = await worker.peer.getParam('fork');
         const forkResult = await fork(peerLiveness, options.runtime, packageJson, zipHash, getZip);
+        options.id ||= this.runtime.findPluginDevice(packageJson.name)?._id;
         worker.forks.add(options);
         forkResult.waitKilled().catch(() => { }).finally(() => {
             worker.forks.delete(options);