@scrypted/server 0.0.106 → 0.0.110

package/src/plugin/plugin-remote.ts

@@ -6,8 +6,7 @@ import { PluginAPI, PluginLogger, PluginRemote, PluginRemoteLoadZipOptions } fro
 import { SystemManagerImpl } from './system';
 import { RpcPeer, RPCResultError, PROPERTY_PROXY_ONEWAY_METHODS, PROPERTY_JSON_DISABLE_SERIALIZATION } from '../rpc';
 import { BufferSerializer } from './buffer-serializer';
-import { EventEmitter } from 'events';
-import { createWebSocketClass } from './plugin-remote-websocket';
+import { createWebSocketClass, WebSocketConnectCallbacks, WebSocketMethods } from './plugin-remote-websocket';
 
 class DeviceLogger implements Logger {
     nativeId: ScryptedNativeId;
@@ -262,14 +261,7 @@ class StorageImpl implements Storage {
     }
 }
 
-interface WebSocketCallbacks {
-    end: any;
-    error: any;
-    data: any;
-}
-
-
-export async function setupPluginRemote(peer: RpcPeer, api: PluginAPI, pluginId: string): Promise<PluginRemote> {
+export async function setupPluginRemote(peer: RpcPeer, api: PluginAPI, pluginId: string, getSystemState: () => { [id: string]: { [property: string]: SystemDeviceState } }): Promise<PluginRemote> {
     try {
         // the host/remote connection can be from server to plugin (node to node),
         // core plugin to web (node to browser).
@@ -277,16 +269,46 @@ export async function setupPluginRemote(peer: RpcPeer, api: PluginAPI, pluginId:
         // but in plugin-host, mark Buffer as transport safe.
         peer.addSerializer(Buffer, 'Buffer', new BufferSerializer());
         const getRemote = await peer.getParam('getRemote');
-        return await getRemote(api, pluginId);
+        const remote = await getRemote(api, pluginId);
+
+        await remote.setSystemState(getSystemState());
+        api.listen((id, eventDetails, eventData) => {
+            // ScryptedDevice events will be handled specially and repropagated by the remote.
+            if (eventDetails.eventInterface === ScryptedInterface.ScryptedDevice) {
+                if (eventDetails.property === ScryptedInterfaceProperty.id) {
+                    // a change on the id property means device was deleted
+                    remote.updateDeviceState(eventData, undefined);
+                }
+                else {
+                    // a change on anything else is a descriptor update
+                    remote.updateDeviceState(id, getSystemState()[id]);
+                }
+                return;
+            }
+
+            if (eventDetails.property) {
+                remote.notify(id, eventDetails.eventTime, eventDetails.eventInterface, eventDetails.property, getSystemState()[id]?.[eventDetails.property], eventDetails.changed);
+            }
+            else {
+                remote.notify(id, eventDetails.eventTime, eventDetails.eventInterface, eventDetails.property, eventData, eventDetails.changed);
+            }
+        });
+
+        return remote;
     }
     catch (e) {
         throw new RPCResultError(peer, 'error while retrieving PluginRemote', e);
     }
 }
 
+export interface WebSocketCustomHandler {
+    id: string,
+    methods: WebSocketMethods;
+}
+
 export interface PluginRemoteAttachOptions {
     createMediaManager?: (systemManager: SystemManager) => Promise<MediaManager>;
-    getServicePort?: (name: string) => Promise<number>;
+    getServicePort?: (name: string, ...args: any[]) => Promise<number>;
     getDeviceConsole?: (nativeId?: ScryptedNativeId) => Console;
     getPluginConsole?: () => Console;
     getMixinConsole?: (id: string, nativeId?: ScryptedNativeId) => Console;
@@ -309,8 +331,9 @@ export function attachPluginRemote(peer: RpcPeer, options?: PluginRemoteAttachOp
         const systemManager = new SystemManagerImpl();
         const deviceManager = new DeviceManagerImpl(systemManager, getDeviceConsole, getMixinConsole);
         const endpointManager = new EndpointManagerImpl();
-        const ioSockets: { [id: string]: WebSocketCallbacks } = {};
         const mediaManager = await api.getMediaManager() || await createMediaManager(systemManager);
+        peer.params['mediaManager'] = mediaManager;
+        const ioSockets: { [id: string]: WebSocketConnectCallbacks } = {};
 
         systemManager.api = api;
         deviceManager.api = api;
@@ -383,11 +406,11 @@ export function attachPluginRemote(peer: RpcPeer, options?: PluginRemoteAttachOp
             async updateDeviceState(id: string, state: { [property: string]: SystemDeviceState }) {
                 if (!state) {
                     delete systemManager.state[id];
-                    systemManager.events.notify(id, Date.now(), ScryptedInterface.ScryptedDevice, ScryptedInterfaceProperty.id, id, true);
+                    systemManager.events.notify(undefined, undefined, ScryptedInterface.ScryptedDevice, ScryptedInterfaceProperty.id, id, true);
                 }
                 else {
                     systemManager.state[id] = state;
-                    systemManager.events.notify(id, Date.now(), ScryptedInterface.ScryptedDevice, undefined, undefined, true);
+                    systemManager.events.notify(id, undefined, ScryptedInterface.ScryptedDevice, undefined, state, true);
                 }
             },
 
@@ -432,32 +455,16 @@ export function attachPluginRemote(peer: RpcPeer, options?: PluginRemoteAttachOp
                     volume.writeFileSync(name, entry.getData());
                 }
 
-                function websocketConnect(url: string, protocols: any, connect: any, end: any, error: any, data: any) {
-                    if (url.startsWith('io://')) {
-                        const id = url.substring('io://'.length);
-
-                        ioSockets[id] = {
-                            data,
-                            error,
-                            end
-                        };
-
-                        connect(undefined, {
-                            close: () => api.ioClose(id),
-                        }, (message: string) => api.ioSend(id, message));
-                    }
-                    else if (url.startsWith('ws://')) {
-                        const id = url.substring('ws://'.length);
+                function websocketConnect(url: string, protocols: any, callbacks: WebSocketConnectCallbacks) {
+                    if (url.startsWith('io://') || url.startsWith('ws://')) {
+                        const id = url.substring('xx://'.length);
 
-                        ioSockets[id] = {
-                            data,
-                            error,
-                            end
-                        };
+                        ioSockets[id] = callbacks;
 
-                        connect(undefined, {
+                        callbacks.connect(undefined, {
                             close: () => api.ioClose(id),
-                        }, (message: string) => api.ioSend(id, message));
+                            send: (message: string) => api.ioSend(id, message),
+                        });
                     }
                     else {
                         throw new Error('unsupported websocket');

package/src/plugin/system.ts

@@ -1,6 +1,6 @@
 import { EventListenerOptions, EventDetails, EventListenerRegister, ScryptedDevice, ScryptedInterface, ScryptedInterfaceDescriptors, SystemDeviceState, SystemManager, ScryptedInterfaceProperty, ScryptedDeviceType, Logger } from "@scrypted/sdk/types";
 import { PluginAPI } from "./plugin-api";
-import { handleFunctionInvocations } from '../rpc';
+import { handleFunctionInvocations, PROPERTY_PROXY_ONEWAY_METHODS } from '../rpc';
 import { EventRegistry } from "../event-registry";
 import { allInterfaceProperties, isValidInterfaceMethod } from "./descriptor";
 
@@ -56,7 +56,7 @@ class DeviceProxyHandler implements ProxyHandler<any>, ScryptedDevice {
         return (this.device as any)[method](...argArray);
     }
 
-    listen(event: string | EventListenerOptions, callback: (eventSource: ScryptedDevice, eventDetails: EventDetails, eventData: object) => void): EventListenerRegister {
+    listen(event: string | EventListenerOptions, callback: (eventSource: ScryptedDevice, eventDetails: EventDetails, eventData: any) => void): EventListenerRegister {
         return this.systemManager.listenDevice(this.id, event, callback);
     }
 
@@ -92,6 +92,15 @@ class EventListenerRegisterImpl implements EventListenerRegister {
     }
 }
 
+function makeOneWayCallback<T>(input: T): T {
+    const f: any = input;
+    const oneways: string[] = f[PROPERTY_PROXY_ONEWAY_METHODS] || [];
+    if (!oneways.includes(null))
+        oneways.push(null);
+    f[PROPERTY_PROXY_ONEWAY_METHODS] = oneways;
+    return input;
+}
+
 export class SystemManagerImpl implements SystemManager {
     api: PluginAPI;
     state: {[id: string]: {[property: string]: SystemDeviceState}};
@@ -122,10 +131,10 @@ export class SystemManagerImpl implements SystemManager {
                 return this.getDeviceById(id);
         }
     }
-    listen(EventListener: (eventSource: ScryptedDevice, eventDetails: EventDetails, eventData: object) => void): EventListenerRegister {
-        return this.events.listen((id, eventDetails, eventData) => EventListener(this.getDeviceById(id), eventDetails, eventData));
+    listen(callback: (eventSource: ScryptedDevice, eventDetails: EventDetails, eventData: any) => void): EventListenerRegister {
+        return this.events.listen(makeOneWayCallback((id, eventDetails, eventData) => callback(this.getDeviceById(id), eventDetails, eventData)));
     }
-    listenDevice(id: string, options: string | EventListenerOptions, callback: (eventSource: ScryptedDevice, eventDetails: EventDetails, eventData: object) => void): EventListenerRegister {
+    listenDevice(id: string, options: string | EventListenerOptions, callback: (eventSource: ScryptedDevice, eventDetails: EventDetails, eventData: any) => void): EventListenerRegister {
         let { event, watch } = (options || {}) as EventListenerOptions;
         if (!event && typeof options === 'string')
             event = options as string;
@@ -136,7 +145,7 @@ export class SystemManagerImpl implements SystemManager {
         if (watch)
             return this.events.listenDevice(id, event, (eventDetails, eventData) => callback(this.getDeviceById(id), eventDetails, eventData));
 
-        return new EventListenerRegisterImpl(this.api.listenDevice(id, options, (eventDetails, eventData) => callback(this.getDeviceById(id), eventDetails, eventData)))
+        return new EventListenerRegisterImpl(this.api.listenDevice(id, options, makeOneWayCallback((eventDetails, eventData) => callback(this.getDeviceById(id), eventDetails, eventData))));
     }
 
     async removeDevice(id: string) {

package/src/rpc.ts

@@ -1,5 +1,7 @@
 import vm from 'vm';
 
+const finalizerIdSymbol = Symbol('rpcFinalizerId');
+
 function getDefaultTransportSafeArgumentTypes() {
     const jsonSerializable = new Set<string>();
     jsonSerializable.add(Number.name);
@@ -40,6 +42,7 @@ interface RpcOob extends RpcMessage {
 
 interface RpcRemoteProxyValue {
     __remote_proxy_id: string;
+    __remote_proxy_finalizer_id: string;
     __remote_constructor_name: string;
     __remote_proxy_props: any;
     __remote_proxy_oneway_methods: string[];
@@ -52,6 +55,7 @@ interface RpcLocalProxyValue {
 
 interface RpcFinalize extends RpcMessage {
     __local_proxy_id: string;
+    __local_proxy_finalizer_id: string;
 }
 
 interface Deferred {
@@ -78,20 +82,17 @@ export const PROPERTY_PROXY_PROPERTIES = '__proxy_props';
 export const PROPERTY_JSON_COPY_SERIALIZE_CHILDREN = '__json_copy_serialize_children';
 
 class RpcProxy implements ProxyHandler<any> {
+
     constructor(public peer: RpcPeer,
-        public id: string,
+        public entry: LocalProxiedEntry,
         public constructorName: string,
         public proxyProps: any,
         public proxyOneWayMethods: string[]) {
-        this.peer = peer;
-        this.id = id;
-        this.constructorName = constructorName;
-        this.proxyProps = proxyProps;
     }
 
     get(target: any, p: PropertyKey, receiver: any): any {
         if (p === '__proxy_id')
-            return this.id;
+            return this.entry.id;
         if (p === '__proxy_constructor')
             return this.constructorName;
         if (p === '__proxy_peer')
@@ -114,8 +115,17 @@ class RpcProxy implements ProxyHandler<any> {
         return new Proxy(() => p, this);
     }
 
+    set(target: any, p: string | symbol, value: any, receiver: any): boolean {
+        if (p === finalizerIdSymbol)
+            this.entry.finalizerId = value;
+        return true;
+    }
+
     apply(target: any, thisArg: any, argArray?: any): any {
-        const method = target();
+        // rpc objects can be functions. if the function is a oneway method,
+        // it will have a null in the oneway method list. this is because
+        // undefined is not JSON serializable.
+        const method = target() || null;
         const args: any[] = [];
         for (const arg of (argArray || [])) {
             args.push(this.peer.serialize(arg));
@@ -124,7 +134,7 @@ class RpcProxy implements ProxyHandler<any> {
         const rpcApply: RpcApply = {
             type: "apply",
             id: undefined,
-            proxyId: this.id,
+            proxyId: this.entry.id,
             args,
             method,
         };
@@ -187,16 +197,21 @@ export interface RpcSerializer {
     deserialize(serialized: any): any;
 }
 
+interface LocalProxiedEntry {
+    id: string;
+    finalizerId: string;
+}
+
 export class RpcPeer {
     idCounter = 1;
     onOob: (oob: any) => void;
     params: { [name: string]: any } = {};
     pendingResults: { [id: string]: Deferred } = {};
     proxyCounter = 1;
-    localProxied = new Map<any, string>();
+    localProxied = new Map<any, LocalProxiedEntry>();
     localProxyMap: { [id: string]: any } = {};
     remoteWeakProxies: { [id: string]: WeakRef<any> } = {};
-    finalizers = new FinalizationRegistry(id => this.finalize(id as string));
+    finalizers = new FinalizationRegistry(entry => this.finalize(entry as LocalProxiedEntry));
     nameDeserializerMap = new Map<string, RpcSerializer>();
     constructorSerializerMap = new Map<string, string>();
     transportSafeArgumentTypes = getDefaultTransportSafeArgumentTypes();
@@ -238,10 +253,11 @@ export class RpcPeer {
         this.constructorSerializerMap.set(ctr, name);
     }
 
-    finalize(id: string) {
-        delete this.remoteWeakProxies[id];
+    finalize(entry: LocalProxiedEntry) {
+        delete this.remoteWeakProxies[entry.id];
         const rpcFinalize: RpcFinalize = {
-            __local_proxy_id: id,
+            __local_proxy_id: entry.id,
+            __local_proxy_finalizer_id: entry.finalizerId,
             type: 'finalize',
         }
         this.send(rpcFinalize);
@@ -294,9 +310,12 @@ export class RpcPeer {
             return ret;
         }
 
-        const { __remote_proxy_id, __local_proxy_id, __remote_constructor_name, __serialized_value, __remote_proxy_props, __remote_proxy_oneway_methods } = value;
+        const { __remote_proxy_id, __remote_proxy_finalizer_id, __local_proxy_id, __remote_constructor_name, __serialized_value, __remote_proxy_props, __remote_proxy_oneway_methods } = value;
         if (__remote_proxy_id) {
-            const proxy = this.remoteWeakProxies[__remote_proxy_id]?.deref() || this.newProxy(__remote_proxy_id, __remote_constructor_name, __remote_proxy_props, __remote_proxy_oneway_methods);
+            let proxy = this.remoteWeakProxies[__remote_proxy_id]?.deref();
+            if (!proxy)
+                proxy = this.newProxy(__remote_proxy_id, __remote_constructor_name, __remote_proxy_props, __remote_proxy_oneway_methods);
+            proxy[finalizerIdSymbol] = __remote_proxy_finalizer_id;
             return proxy;
         }
 
@@ -329,10 +348,13 @@ export class RpcPeer {
 
         let __remote_constructor_name = value.__proxy_constructor || value.constructor?.name?.toString();
 
-        let proxyId = this.localProxied.get(value);
-        if (proxyId) {
+        let proxiedEntry = this.localProxied.get(value);
+        if (proxiedEntry) {
+            const __remote_proxy_finalizer_id = (this.proxyCounter++).toString();
+            proxiedEntry.finalizerId = __remote_proxy_finalizer_id;
             const ret: RpcRemoteProxyValue = {
-                __remote_proxy_id: proxyId,
+                __remote_proxy_id: proxiedEntry.id,
+                __remote_proxy_finalizer_id,
                 __remote_constructor_name,
                 __remote_proxy_props: value?.[PROPERTY_PROXY_PROPERTIES],
                 __remote_proxy_oneway_methods: value?.[PROPERTY_PROXY_ONEWAY_METHODS],
@@ -355,6 +377,7 @@ export class RpcPeer {
             const serialized = serializer.serialize(value);
             const ret: RpcRemoteProxyValue = {
                 __remote_proxy_id: undefined,
+                __remote_proxy_finalizer_id: undefined,
                 __remote_constructor_name,
                 __remote_proxy_props: value?.[PROPERTY_PROXY_PROPERTIES],
                 __remote_proxy_oneway_methods: value?.[PROPERTY_PROXY_ONEWAY_METHODS],
@@ -363,12 +386,17 @@ export class RpcPeer {
             return ret;
         }
 
-        proxyId = (this.proxyCounter++).toString();
-        this.localProxied.set(value, proxyId);
-        this.localProxyMap[proxyId] = value;
+        const __remote_proxy_id = (this.proxyCounter++).toString();
+        proxiedEntry = {
+            id: __remote_proxy_id,
+            finalizerId: __remote_proxy_id,
+        };
+        this.localProxied.set(value, proxiedEntry);
+        this.localProxyMap[__remote_proxy_id] = value;
 
         const ret: RpcRemoteProxyValue = {
-            __remote_proxy_id: proxyId,
+            __remote_proxy_id,
+            __remote_proxy_finalizer_id: __remote_proxy_id,
             __remote_constructor_name,
             __remote_proxy_props: value?.[PROPERTY_PROXY_PROPERTIES],
             __remote_proxy_oneway_methods: value?.[PROPERTY_PROXY_ONEWAY_METHODS],
@@ -378,12 +406,16 @@ export class RpcPeer {
     }
 
     newProxy(proxyId: string, proxyConstructorName: string, proxyProps: any, proxyOneWayMethods: string[]) {
-        const rpc = new RpcProxy(this, proxyId, proxyConstructorName, proxyProps, proxyOneWayMethods);
+        const localProxiedEntry: LocalProxiedEntry = {
+            id: proxyId,
+            finalizerId: undefined,
+        }
+        const rpc = new RpcProxy(this, localProxiedEntry, proxyConstructorName, proxyProps, proxyOneWayMethods);
         const target = proxyConstructorName === 'Function' || proxyConstructorName === 'AsyncFunction' ? function () { } : rpc;
         const proxy = new Proxy(target, rpc);
         const weakref = new WeakRef(proxy);
         this.remoteWeakProxies[proxyId] = weakref;
-        this.finalizers.register(rpc, proxyId);
+        this.finalizers.register(rpc, localProxiedEntry);
         global.gc?.();
         return proxy;
     }
@@ -460,8 +492,16 @@ export class RpcPeer {
                 case 'finalize': {
                     const rpcFinalize = message as RpcFinalize;
                     const local = this.localProxyMap[rpcFinalize.__local_proxy_id];
-                    delete this.localProxyMap[rpcFinalize.__local_proxy_id];
-                    this.localProxied.delete(local);
+                    if (local) {
+                        const localProxiedEntry = this.localProxied.get(local);
+                        // if a finalizer id is specified, it must match.
+                        if (rpcFinalize.__local_proxy_finalizer_id && rpcFinalize.__local_proxy_finalizer_id !== localProxiedEntry?.finalizerId) {
+                            console.error(this.selfName, this.peerName, 'finalizer mismatch')
+                            break;
+                        }
+                        delete this.localProxyMap[rpcFinalize.__local_proxy_id];
+                        this.localProxied.delete(local);
+                    }
                     break;
                 }
                 case 'oob': {