@scrypted/server 0.115.1 → 0.115.2

package/src/cluster/cluster-hash.ts

@@ -2,6 +2,6 @@ import crypto from "crypto";
 import { ClusterObject } from "./connect-rpc-object";
 
 export function computeClusterObjectHash(o: ClusterObject, clusterSecret: string) {
-    const sha256 = crypto.createHash('sha256').update(`${o.id}${o.port}${o.sourcePort || ''}${o.proxyId}${clusterSecret}`).digest().toString('base64');
+    const sha256 = crypto.createHash('sha256').update(`${o.id}${o.address || ''}${o.port}${o.sourceKey || ''}${o.proxyId}${clusterSecret}`).digest().toString('base64');
     return sha256;
 }

package/src/cluster/connect-rpc-object.ts

@@ -1,8 +1,9 @@
 export interface ClusterObject {
     id: string;
+    address: string;
     port: number;
     proxyId: string;
-    sourcePort: number;
+    sourceKey: string;
     sha256: string;
 }
 

package/src/plugin/plugin-api.ts

@@ -161,6 +161,7 @@ export interface PluginRemoteLoadZipOptions {
     debug?: boolean;
     zipHash: string;
     fork?: boolean;
+    main?: string;
 
     clusterId: string;
     clusterSecret: string;

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

@@ -8,23 +8,28 @@ export interface PluginStats {
 
 export function startStatsUpdater(allMemoryStats: Map<NodeThreadWorker, NodeJS.MemoryUsage>, updateStats: (stats: PluginStats) => void) {
     setInterval(() => {
-        const cpuUsage = process.cpuUsage();
-        allMemoryStats.set(undefined, process.memoryUsage());
+        let cpuUsage: NodeJS.CpuUsage;
+        let memoryUsage: NodeJS.MemoryUsage;
+        if (process.cpuUsage) {
+            cpuUsage = process.cpuUsage();
+            allMemoryStats.set(undefined, process.memoryUsage());
 
-        const memoryUsage: NodeJS.MemoryUsage = {
-            rss: 0,
-            heapTotal: 0,
-            heapUsed: 0,
-            external: 0,
-            arrayBuffers: 0,
-        }
+            memoryUsage = {
+                rss: 0,
+                heapTotal: 0,
+                heapUsed: 0,
+                external: 0,
+                arrayBuffers: 0,
+            }
+
+            for (const mu of allMemoryStats.values()) {
+                memoryUsage.rss += mu.rss;
+                memoryUsage.heapTotal += mu.heapTotal;
+                memoryUsage.heapUsed += mu.heapUsed;
+                memoryUsage.external += mu.external;
+                memoryUsage.arrayBuffers += mu.arrayBuffers;
+            }
 
-        for (const mu of allMemoryStats.values()) {
-            memoryUsage.rss += mu.rss;
-            memoryUsage.heapTotal += mu.heapTotal;
-            memoryUsage.heapUsed += mu.heapUsed;
-            memoryUsage.external += mu.external;
-            memoryUsage.arrayBuffers += mu.arrayBuffers;
         }
 
         updateStats({

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

@@ -93,10 +93,17 @@ export function startPluginRemote(mainFilename: string, pluginId: string, peerSe
             throw new Error(`unknown service ${name}`);
         },
         async onLoadZip(scrypted: ScryptedStatic, params: any, packageJson: any, getZip: () => Promise<Buffer>, zipOptions: PluginRemoteLoadZipOptions) {
+            const mainFile = zipOptions?.main || 'main';
+            const mainNodejs = `${mainFile}.nodejs.js`;
+            const pluginMainNodeJs = `/plugin/${mainNodejs}`;
+            const pluginIdMainNodeJs = `/${pluginId}/${mainNodejs}`;
+
             const { clusterId, clusterSecret, zipHash } = zipOptions;
             const { zipFile, unzippedPath } = await prepareZip(getPluginVolume(pluginId), zipHash, getZip);
 
-            const onProxySerialization = (value: any, sourcePeerPort?: number) => {
+            const SCRYPTED_CLUSTER_ADDRESS = process.env.SCRYPTED_CLUSTER_ADDRESS;
+
+            const onProxySerialization = (value: any, sourceKey?: string) => {
                 const properties = RpcPeer.prepareProxyProperties(value) || {};
                 let clusterEntry: ClusterObject = properties.__cluster;
 
@@ -106,16 +113,16 @@ export function startPluginRemote(mainFilename: string, pluginId: string, peerSe
                 // 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 && clusterPort === clusterEntry.port && sourcePeerPort !== clusterEntry.sourcePort)
+                if (clusterEntry && clusterPort === clusterEntry.port && sourceKey !== clusterEntry.sourceKey)
                     clusterEntry = undefined;
 
-                // set the cluster identity if it does not exist.
                 if (!clusterEntry) {
                     clusterEntry = {
                         id: clusterId,
+                        address: SCRYPTED_CLUSTER_ADDRESS,
                         port: clusterPort,
                         proxyId,
-                        sourcePort: sourcePeerPort,
+                        sourceKey,
                         sha256: null,
                     };
                     clusterEntry.sha256 = computeClusterObjectHash(clusterEntry, clusterSecret);
@@ -129,8 +136,10 @@ export function startPluginRemote(mainFilename: string, pluginId: string, peerSe
             }
             peer.onProxySerialization = onProxySerialization;
 
-            const resolveObject = async (id: string, sourcePeerPort: number) => {
-                const sourcePeer = sourcePeerPort ? await clusterPeers.get(sourcePeerPort) : peer;
+            const resolveObject = async (id: string, sourceKey: string) => {
+                const sourcePeer = sourceKey
+                    ? await clusterPeers.get(sourceKey)
+                    : peer;
                 return sourcePeer?.localProxyMap.get(id);
             }
 
@@ -138,52 +147,74 @@ export function startPluginRemote(mainFilename: string, pluginId: string, peerSe
             // 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<number, Promise<RpcPeer>>();
+            const clusterPeers = new Map<string, Promise<RpcPeer>>();
+            function getClusterPeerKey(address: string, port: number) {
+                return `${address}:${port}`;
+            }
+
             const clusterRpcServer = net.createServer(client => {
                 const clusterPeer = createDuplexRpcPeer(peer.selfName, 'cluster-client', client, client);
+                const clusterPeerAddress = client.remoteAddress;
                 const clusterPeerPort = client.remotePort;
-                clusterPeer.onProxySerialization = (value) => onProxySerialization(value, clusterPeerPort);
-                clusterPeers.set(clusterPeerPort, Promise.resolve(clusterPeer));
+                const clusterPeerKey = getClusterPeerKey(clusterPeerAddress, clusterPeerPort);
+                // 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(value, clusterPeerKey);
+                clusterPeers.set(clusterPeerKey, Promise.resolve(clusterPeer));
                 startPluginRemoteOptions?.onClusterPeer?.(clusterPeer);
                 const connectRPCObject: ConnectRPCObject = async (o) => {
                     const sha256 = computeClusterObjectHash(o, clusterSecret);
                     if (sha256 !== o.sha256)
                         throw new Error('secret incorrect');
-                    return resolveObject(o.proxyId, o.sourcePort);
+                    return resolveObject(o.proxyId, o.sourceKey);
                 }
                 clusterPeer.params['connectRPCObject'] = connectRPCObject;
                 client.on('close', () => {
-                    clusterPeers.delete(clusterPeerPort);
+                    clusterPeers.delete(clusterPeerKey);
                     clusterPeer.kill('cluster socket closed');
                 });
             })
-            const clusterPort = await listenZero(clusterRpcServer, '127.0.0.1');
 
-            const ensureClusterPeer = (connectPort: number) => {
-                let clusterPeerPromise = clusterPeers.get(connectPort);
-                if (!clusterPeerPromise) {
-                    clusterPeerPromise = (async () => {
-                        const socket = net.connect(connectPort, '127.0.0.1');
-                        socket.on('close', () => clusterPeers.delete(connectPort));
+            const listenAddress = SCRYPTED_CLUSTER_ADDRESS
+                ? '0.0.0.0'
+                : '127.0.0.1';
+            const clusterPort = await listenZero(clusterRpcServer, listenAddress);
+
+            const ensureClusterPeer = (address: string, connectPort: number) => {
+                if (!address || address === SCRYPTED_CLUSTER_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');
+
+                        // this connecting peer sourceKey (server address/port) is used by the OTHER peer (the server)
+                        // to determine if it is already connected to THIS peer (the client).
+                        const { address: sourceAddress, port: sourcePort } = (socket.address() as net.AddressInfo);
+                        if (sourceAddress !== SCRYPTED_CLUSTER_ADDRESS && sourceAddress !== '127.0.0.1')
+                            console.warn("source address mismatch", sourceAddress);
+                        const sourcePeerKey = getClusterPeerKey(sourceAddress, sourcePort);
+
+                        const clusterPeer = createDuplexRpcPeer(peer.selfName, 'cluster-server', socket, socket);
+                        clusterPeer.onProxySerialization = (value) => onProxySerialization(value, sourcePeerKey);
+                        return clusterPeer;
+                    }
+                    catch (e) {
+                        console.error('failure ipc connect', e);
+                        socket.destroy();
+                        throw e;
+                    }
+                })();
 
-                        try {
-                            await once(socket, 'connect');
-                            // the sourcePort will be added to all rpc objects created by this peer session and used by resolveObject for later
-                            // resolution when trying to find the peer.
-                            const sourcePort = (socket.address() as net.AddressInfo).port;
-
-                            const clusterPeer = createDuplexRpcPeer(peer.selfName, 'cluster-server', socket, socket);
-                            clusterPeer.onProxySerialization = (value) => onProxySerialization(value, sourcePort);
-                            return clusterPeer;
-                        }
-                        catch (e) {
-                            console.error('failure ipc connect', e);
-                            socket.destroy();
-                            throw e;
-                        }
-                    })();
-                    clusterPeers.set(connectPort, clusterPeerPromise);
-                }
+                clusterPeers.set(clusterPeerKey, clusterPeerPromise);
                 return clusterPeerPromise;
             };
 
@@ -191,16 +222,16 @@ export function startPluginRemote(mainFilename: string, pluginId: string, peerSe
                 const clusterObject: ClusterObject = value?.__cluster;
                 if (clusterObject?.id !== clusterId)
                     return value;
-                const { port, proxyId, sourcePort } = clusterObject;
+                const { address, port, proxyId, sourceKey } = 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 resolveObject(proxyId, sourcePort);
+                    return resolveObject(proxyId, sourceKey);
 
                 try {
-                    const clusterPeerPromise = ensureClusterPeer(port);
+                    const clusterPeerPromise = ensureClusterPeer(address, port);
                     const clusterPeer = await clusterPeerPromise;
-                    // the proxy id is guaranteed to be unique in all peers in a cluster
+                    // may already have this proxy so check first.
                     const existing = clusterPeer.remoteWeakProxies[proxyId]?.deref();
                     if (existing)
                         return existing;
@@ -266,7 +297,7 @@ export function startPluginRemote(mainFilename: string, pluginId: string, peerSe
             // params.window = window;
             params.exports = exports;
 
-            const entry = pluginReader('main.nodejs.js.map')
+            const entry = pluginReader(`${mainNodejs}.map`)
             const map = entry?.toString();
 
             // plugins may install their own sourcemap support during startup, so
@@ -287,11 +318,11 @@ export function startPluginRemote(mainFilename: string, pluginId: string, peerSe
                 installSourceMapSupport({
                     environment: 'node',
                     retrieveSourceMap(source) {
-                        if (source === '/plugin/main.nodejs.js' || source === `/${pluginId}/main.nodejs.js`) {
+                        if (source === pluginMainNodeJs || source === pluginIdMainNodeJs) {
                             if (!map)
                                 return null;
                             return {
-                                url: '/plugin/main.nodejs.js',
+                                url: pluginMainNodeJs,
                                 map,
                             }
                         }
@@ -314,7 +345,7 @@ export function startPluginRemote(mainFilename: string, pluginId: string, peerSe
                 await pong(time);
             };
 
-            const main = pluginReader('main.nodejs.js');
+            const main = pluginReader(mainNodejs);
             const script = main.toString();
 
             scrypted.connect = (socket, options) => {
@@ -323,7 +354,7 @@ export function startPluginRemote(mainFilename: string, pluginId: string, peerSe
 
             const pluginRemoteAPI: PluginRemote = scrypted.pluginRemoteAPI;
 
-            scrypted.fork = () => {
+            scrypted.fork = (options) => {
                 const ntw = new NodeThreadWorker(mainFilename, pluginId, {
                     packageJson,
                     env: process.env,
@@ -331,6 +362,8 @@ export function startPluginRemote(mainFilename: string, pluginId: string, peerSe
                     zipFile,
                     unzippedPath,
                     zipHash,
+                }, {
+                    name: options?.name,
                 });
 
                 const result = (async () => {
@@ -358,12 +391,18 @@ export function startPluginRemote(mainFilename: string, pluginId: string, peerSe
 
                     const remote = await setupPluginRemote(threadPeer, forkApi, pluginId, { serverVersion }, () => systemManager.getSystemState());
                     forks.add(remote);
-                    ntw.worker.on('exit', () => {
+                    ntw.on('exit', () => {
                         threadPeer.kill('worker exited');
                         forkApi.removeListeners();
                         forks.delete(remote);
                         allMemoryStats.delete(ntw);
                     });
+                    ntw.on('error', e => {
+                        threadPeer.kill('worker error ' + e);
+                        forkApi.removeListeners();
+                        forks.delete(remote);
+                        allMemoryStats.delete(ntw);
+                    });
 
                     for (const [nativeId, dmd] of deviceManager.nativeIds.entries()) {
                         await remote.setNativeId(nativeId, dmd.id, dmd.storage);
@@ -371,6 +410,7 @@ export function startPluginRemote(mainFilename: string, pluginId: string, peerSe
 
                     const forkOptions = Object.assign({}, zipOptions);
                     forkOptions.fork = true;
+                    forkOptions.main = options?.filename;
                     return remote.loadZip(packageJson, getZip, forkOptions)
                 })();
 
@@ -383,7 +423,7 @@ export function startPluginRemote(mainFilename: string, pluginId: string, peerSe
             }
 
             try {
-                const filename = zipOptions?.debug ? '/plugin/main.nodejs.js' : `/${pluginId}/main.nodejs.js`;
+                const filename = zipOptions?.debug ? pluginMainNodeJs : pluginIdMainNodeJs;
                 evalLocal(peer, script, filename, params);
 
                 if (zipOptions?.fork) {

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

@@ -0,0 +1,91 @@
+import { getDenoPath } from '@scrypted/deno';
+import child_process from 'child_process';
+import path from 'path';
+import { RpcMessage, RpcPeer } from "../../rpc";
+import { createRpcDuplexSerializer } from '../../rpc-serializer';
+import { ChildProcessWorker } from "./child-process-worker";
+import { RuntimeWorkerOptions } from "./runtime-worker";
+
+export class DenoWorker extends ChildProcessWorker {
+    serializer: ReturnType<typeof createRpcDuplexSerializer>;
+
+    constructor(mainFilename: string, pluginId: string, options: RuntimeWorkerOptions) {
+        super(pluginId, options);
+
+        const { env, pluginDebug } = options;
+
+        const execArgv: string[] = [];
+        if (pluginDebug) {
+            execArgv.push(`--inspect=0.0.0.0:${pluginDebug.inspectPort}`);
+        }
+
+        const args = [
+            '--unstable-byonm', '--unstable-bare-node-builtins', '--unstable-sloppy-imports',
+            'run',
+            ...execArgv,
+            '--allow-all',
+            path.join(__dirname, '../../../deno', 'deno-plugin-remote.ts'),
+            // TODO: send this across.
+            // mainFilename.replace('dist', 'src').replace('.js', '.ts'),
+            'child', this.pluginId
+        ];
+        this.worker = child_process.spawn(getDenoPath(), args, {
+            // stdio: ['pipe', 'pipe', 'pipe', 'pipe', 'pipe'],
+            stdio: ['pipe', 'pipe', 'pipe', 'ipc'],
+            env: Object.assign({
+                SCRYPTED_MAIN_FILENAME: mainFilename,
+            }, process.env, env),
+            serialization: 'json',
+            // execArgv,
+        });
+
+        this.worker.stderr.on('data', (data) => {
+            console.error(`stderr: ${data}`);
+        });
+        this.worker.stdout.on('data', (data) => {
+            console.log(`stdout: ${data}`);
+        });
+
+        this.setupWorker();
+    }
+
+    kill(): void {
+
+    }
+
+    setupRpcPeer(peer: RpcPeer): void {
+        this.worker.on('message', (message, sendHandle) => {
+            if ((message as any).type && sendHandle) {
+                peer.handleMessage(message as any, {
+                    sendHandle,
+                });
+            }
+            else if (sendHandle) {
+                this.emit('rpc', message, sendHandle);
+            }
+            else {
+                peer.handleMessage(message as any);
+            }
+        });
+        peer.transportSafeArgumentTypes.add(Buffer.name);
+        peer.transportSafeArgumentTypes.add(Uint8Array.name);
+    }
+
+    send(message: RpcMessage, reject?: (e: Error) => void, serializationContext?: any): void {
+        try {
+            if (!this.worker)
+                throw new Error('fork worker has been killed');
+            this.worker.send(message, serializationContext?.sendHandle, e => {
+                if (e && reject)
+                    reject(e);
+            });
+        }
+        catch (e) {
+            reject?.(e);
+        }
+    }
+
+    get pid() {
+        return this.worker?.pid;
+    }
+}

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

@@ -1,11 +1,9 @@
-import { RuntimeWorkerOptions as RuntimeWorkerOptions } from "./runtime-worker";
 import child_process from 'child_process';
-import path from 'path';
+import net from "net";
 import { RpcMessage, RpcPeer } from "../../rpc";
-import { ChildProcessWorker } from "./child-process-worker";
-import { getPluginNodePath } from "../plugin-npm-dependencies";
 import { SidebandSocketSerializer } from "../socket-serializer";
-import net from "net";
+import { ChildProcessWorker } from "./child-process-worker";
+import { RuntimeWorkerOptions } from "./runtime-worker";
 
 export class NodeForkWorker extends ChildProcessWorker {
 

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

@@ -1,24 +1,30 @@
 import v8 from 'v8';
 import worker_threads from "worker_threads";
-import { EventEmitter } from "ws";
+import { EventEmitter } from "events";
 import { RpcMessage, RpcPeer } from "../../rpc";
 import { RuntimeWorker, RuntimeWorkerOptions } from "./runtime-worker";
 
 export class NodeThreadWorker extends EventEmitter implements RuntimeWorker {
-    terminated: boolean;
     worker: worker_threads.Worker;
+    port: worker_threads.MessagePort;
 
-    constructor(mainFilename: string, public pluginId: string, options: RuntimeWorkerOptions) {
+    constructor(mainFilename: string, public pluginId: string, options: RuntimeWorkerOptions, workerOptions?: worker_threads.WorkerOptions) {
         super();
         const { env } = options;
 
+        const message = new worker_threads.MessageChannel();
+        const { port1, port2 } = message;
         this.worker = new worker_threads.Worker(mainFilename, {
             argv: ['child-thread', this.pluginId],
             env: Object.assign({}, process.env, env),
+            workerData: {
+                port: port1,
+            },
+            transferList: [port1],
+            ...workerOptions,
         });
 
         this.worker.on('exit', () => {
-            this.terminated = true;
             this.emit('exit');
         });
         this.worker.on('error', e => {
@@ -27,6 +33,14 @@ export class NodeThreadWorker extends EventEmitter implements RuntimeWorker {
         this.worker.on('messageerror', e => {
             this.emit('error', e);
         });
+
+        this.port = port2;
+        this.port.on('messageerror', e => {
+            this.emit('error', e);
+        });
+        this.port.on('close', () => {
+            this.emit('error', new Error('port closed'));
+        });
     }
 
     get pid() {
@@ -48,6 +62,8 @@ export class NodeThreadWorker extends EventEmitter implements RuntimeWorker {
         this.worker.removeAllListeners();
         this.worker.stdout.removeAllListeners();
         this.worker.stderr.removeAllListeners();
+        this.port.close();
+        this.port = undefined;
         this.worker = undefined;
     }
 
@@ -55,7 +71,7 @@ export class NodeThreadWorker extends EventEmitter implements RuntimeWorker {
         try {
             if (!this.worker)
                 throw new Error('thread worker has been killed');
-            this.worker.postMessage(v8.serialize(message));
+            this.port.postMessage(v8.serialize(message));
         }
         catch (e) {
             reject?.(e);
@@ -63,6 +79,6 @@ export class NodeThreadWorker extends EventEmitter implements RuntimeWorker {
     }
 
     setupRpcPeer(peer: RpcPeer): void {
-        this.worker.on('message', message => peer.handleMessage(v8.deserialize(message)));
+        this.port.on('message', message => peer.handleMessage(v8.deserialize(message)));
     }
 }

package/src/rpc-peer-eval.ts

@@ -1,27 +1,22 @@
-import type { CompileFunctionOptions } from 'vm';
-import { RpcPeer } from "./rpc";
+import type { RpcPeer } from "./rpc";
 
-type CompileFunction = (code: string, params?: ReadonlyArray<string>, options?: CompileFunctionOptions) => Function;
+export interface CompileFunctionOptions {
+    filename?: string;
+}
 
 function compileFunction(code: string, params?: ReadonlyArray<string>, options?: CompileFunctionOptions): any {
     params = params || [];
-    const f = `(function(${params.join(',')}) {;${code};})`;
+    if (options?.filename)
+        code = `${code}\n//# sourceURL=${options.filename}\n`;
+    const f = `(function(${params.join(',')}) {;${code}\n;})`;
     return eval(f);
 }
 
 export function evalLocal<T>(peer: RpcPeer, script: string, filename?: string, coercedParams?: { [name: string]: any }): T {
     const params = Object.assign({}, peer.params, coercedParams);
-    let compile: CompileFunction;
-    try {
-        // prevent bundlers from trying to include non-existent vm module.
-        compile = module[`require`]('vm').compileFunction;
-    }
-    catch (e) {
-        compile = compileFunction;
-    }
-    const f = compile(script, Object.keys(params), {
+    const f = compileFunction(script, Object.keys(params), {
         filename,
     });
     const value = f(...Object.values(params));
     return value;
-}
+}

package/src/rpc.ts

@@ -1,10 +1,10 @@
 export function startPeriodicGarbageCollection() {
-    if (!global.gc) {
+    if (!globalThis.gc) {
         console.warn('rpc peer garbage collection not available: global.gc is not exposed.');
     }
-    let g: typeof global;
+    let g: typeof globalThis;
     try {
-        g = global;
+        g = globalThis;
     }
     catch (e) {
     }

package/src/runtime.ts

@@ -46,6 +46,7 @@ import { getNpmPackageInfo, PluginComponent } from './services/plugin';
 import { ServiceControl } from './services/service-control';
 import { UsersService } from './services/users';
 import { getState, ScryptedStateManager, setState } from './state';
+import { DenoWorker } from './plugin/runtime/deno-worker';
 
 interface DeviceProxyPair {
     handler: PluginDeviceProxyHandler;
@@ -102,6 +103,7 @@ export class ScryptedRuntime extends PluginHttp<HttpPluginData> {
         this.pluginHosts.set('custom', (_, pluginId, options, runtime) => new CustomRuntimeWorker(pluginId, options, runtime));
         this.pluginHosts.set('python', (_, pluginId, options) => new PythonRuntimeWorker(pluginId, options));
         this.pluginHosts.set('node', (mainFilename, pluginId, options) => new NodeForkWorker(mainFilename, pluginId, options));
+        this.pluginHosts.set('deno', (mainFilename, pluginId, options) => new DenoWorker(mainFilename, pluginId, options));
 
         app.disable('x-powered-by');
 

package/src/scrypted-main-exports.ts

@@ -25,9 +25,9 @@ function start(mainFilename: string, options?: {
         require(process.env.SCRYPTED_COMPATIBILITY_FILE);
     }
 
-    if (!global.gc) {
+    if (!globalThis.gc && !process.versions.deno) {
         v8.setFlagsFromString('--expose_gc')
-        global.gc = vm.runInNewContext("gc");
+        globalThis.gc = vm.runInNewContext("gc");
     }
 
     if (!semver.gte(process.version, '16.0.0')) {

package/src/scrypted-main.ts

@@ -1,3 +1,6 @@
 import start from './scrypted-main-exports';
 
-start(__filename);
+if (process.versions.deno)
+    start(process.env.SCRYPTED_MAIN_FILENAME);
+else
+    start(__filename);

package/src/scrypted-plugin-main.ts

@@ -8,13 +8,14 @@ import { RpcMessage } from "./rpc";
 
 function start(mainFilename: string) {
     const pluginId = process.argv[3];
-    console.log('starting plugin', pluginId);
     module.paths.push(getPluginNodePath(pluginId));
 
     if (process.argv[2] === 'child-thread') {
-        const peer = startPluginRemote(mainFilename, process.argv[3], (message, reject) => {
+        console.log('starting thread', pluginId);
+        const { port } = worker_threads.workerData as { port: worker_threads.MessagePort };
+        const peer = startPluginRemote(mainFilename, pluginId, (message, reject) => {
             try {
-                worker_threads.parentPort.postMessage(v8.serialize(message));
+                port.postMessage(v8.serialize(message));
             }
             catch (e) {
                 reject?.(e);
@@ -22,9 +23,18 @@ function start(mainFilename: string) {
         });
         peer.transportSafeArgumentTypes.add(Buffer.name);
         peer.transportSafeArgumentTypes.add(Uint8Array.name);
-        worker_threads.parentPort.on('message', message => peer.handleMessage(v8.deserialize(message)));
+        port.on('message', message => peer.handleMessage(v8.deserialize(message)));
+        port.on('messageerror', e => {
+            console.error('message error', e);
+            process.exit(1);
+        });
+        port.on('close', () => {
+            console.error('port closed');
+            process.exit(1);
+        });
     }
     else {
+        console.log('starting plugin', pluginId);
         const peer = startPluginRemote(mainFilename, process.argv[3], (message, reject, serializationContext) => process.send(message, serializationContext?.sendHandle, {
             swallowErrors: !reject,
         }, e => {