@scrypted/server 0.115.0 → 0.115.2

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) {
     }
@@ -304,7 +304,10 @@ export class RpcPeer {
     finalizers = new FinalizationRegistry(entry => this.finalize(entry as LocalProxiedEntry));
     nameDeserializerMap = new Map<string, RpcSerializer>();
     onProxyTypeSerialization = new Map<string, (value: any) => void>();
-    onProxySerialization: (value: any, proxyId: string) => any;
+    onProxySerialization: (value: any) => {
+        proxyId: string;
+        properties: any;
+    };
     constructorSerializerMap = new Map<any, string>();
     transportSafeArgumentTypes = RpcPeer.getDefaultTransportSafeArgumentTypes();
     killed: Promise<string>;
@@ -630,7 +633,16 @@ export class RpcPeer {
 
         this.onProxyTypeSerialization.get(__remote_constructor_name)?.(value);
 
-        const __remote_proxy_id = RpcPeer.generateId();
+        const {
+            proxyId: __remote_proxy_id,
+            properties: __remote_proxy_props,
+        } = this.onProxySerialization
+                ? this.onProxySerialization(value)
+                : {
+                    proxyId: RpcPeer.generateId(),
+                    properties: RpcPeer.prepareProxyProperties(value),
+                };
+
         proxiedEntry = {
             id: __remote_proxy_id,
             finalizerId: __remote_proxy_id,
@@ -638,8 +650,6 @@ export class RpcPeer {
         this.localProxied.set(value, proxiedEntry);
         this.localProxyMap.set(__remote_proxy_id, value);
 
-        const __remote_proxy_props = this.onProxySerialization ? this.onProxySerialization(value, __remote_proxy_id) : RpcPeer.prepareProxyProperties(value);
-
         const ret: RpcRemoteProxyValue = {
             __remote_proxy_id,
             __remote_proxy_finalizer_id: __remote_proxy_id,

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 => {