@scrypted/server 0.1.12 → 0.1.13

package/src/plugin/system.ts

@@ -1,16 +1,14 @@
-import { EventListenerOptions, EventDetails, EventListenerRegister, ScryptedDevice, ScryptedInterface, ScryptedInterfaceDescriptors, SystemDeviceState, SystemManager, ScryptedInterfaceProperty, ScryptedDeviceType, Logger, EventListener } from "@scrypted/types";
-import { PluginAPI } from "./plugin-api";
-import {  PrimitiveProxyHandler, RpcPeer } from '../rpc';
+import { EventListener, EventListenerOptions, EventListenerRegister, Logger, ScryptedDevice, ScryptedDeviceType, ScryptedInterface, ScryptedInterfaceDescriptor, ScryptedInterfaceDescriptors, ScryptedInterfaceProperty, SystemDeviceState, SystemManager } from "@scrypted/types";
 import { EventRegistry } from "../event-registry";
-import { allInterfaceProperties, isValidInterfaceMethod } from "./descriptor";
-
+import { PrimitiveProxyHandler, RpcPeer } from '../rpc';
+import { getInterfaceMethods, getInterfaceProperties, getPropertyInterfaces, isValidInterfaceMethod, propertyInterfaces } from "./descriptor";
+import { PluginAPI } from "./plugin-api";
 
 function newDeviceProxy(id: string, systemManager: SystemManagerImpl) {
     const handler = new DeviceProxyHandler(id, systemManager);
     return new Proxy(handler, handler);
 }
 
-
 class DeviceProxyHandler implements PrimitiveProxyHandler<any>, ScryptedDevice {
     device: Promise<ScryptedDevice>;
     constructor(public id: string, public systemManager: SystemManagerImpl) {
@@ -20,6 +18,31 @@ class DeviceProxyHandler implements PrimitiveProxyHandler<any>, ScryptedDevice {
         return `ScryptedDevice-${this.id}`
     }
 
+    ownKeys(target: any): ArrayLike<string | symbol> {
+        const interfaces = new Set<string>(this.systemManager.state[this.id].interfaces.value);
+        const methods = getInterfaceMethods(this.systemManager.descriptors || ScryptedInterfaceDescriptors, interfaces);
+        const properties = getInterfaceProperties(this.systemManager.descriptors || ScryptedInterfaceDescriptors, interfaces);
+        return [...methods, ...properties];
+    }
+
+    getOwnPropertyDescriptor(target: any, p: string | symbol): PropertyDescriptor {
+        const interfaces = new Set<string>(this.systemManager.state[this.id].interfaces.value);
+        const methods = getInterfaceMethods(this.systemManager.descriptors || ScryptedInterfaceDescriptors, interfaces);
+        const prop = p.toString();
+        if (methods.includes(prop)) {
+            return {
+                configurable: true,
+            };
+        }
+        const properties = getInterfaceProperties(this.systemManager.descriptors || ScryptedInterfaceDescriptors, interfaces);
+        if (properties.includes(prop)) {
+            return {
+                configurable: true,
+                value: this.systemManager.state[this.id][prop]?.value
+            }
+        }
+    }
+
     get(target: any, p: PropertyKey, receiver: any): any {
         if (p === 'id')
             return this.id;
@@ -28,11 +51,16 @@ class DeviceProxyHandler implements PrimitiveProxyHandler<any>, ScryptedDevice {
         if (handled)
             return handled;
 
-        if (allInterfaceProperties.includes(p.toString()))
+        const interfaces = new Set<string>(this.systemManager.state[this.id].interfaces.value);
+        const prop = p.toString();
+        const isValidProperty = this.systemManager.propertyInterfaces?.[prop] || propertyInterfaces[prop];
+
+        // this will also return old properties that should not exist on a device. ie, a disabled mixin provider.
+        // should this change?
+        if (isValidProperty)
             return (this.systemManager.state[this.id] as any)?.[p]?.value;
 
-        const prop = p.toString();
-        if (!isValidInterfaceMethod(this.systemManager.state[this.id].interfaces.value, prop))
+        if (!isValidInterfaceMethod(this.systemManager.descriptors || ScryptedInterfaceDescriptors, interfaces, prop))
             return;
 
         if (ScryptedInterfaceDescriptors[ScryptedInterface.ScryptedDevice].methods.includes(prop))
@@ -41,7 +69,7 @@ class DeviceProxyHandler implements PrimitiveProxyHandler<any>, ScryptedDevice {
         return new Proxy(() => p, this);
     }
 
-     ensureDevice() {
+    ensureDevice() {
         if (!this.device)
             this.device = this.systemManager.api.getDeviceById(this.id);
         return this.device;
@@ -101,15 +129,18 @@ function makeOneWayCallback<T>(input: T): T {
 
 export class SystemManagerImpl implements SystemManager {
     api: PluginAPI;
-    state: {[id: string]: {[property: string]: SystemDeviceState}};
-    deviceProxies: {[id: string]: ScryptedDevice} = {};
+    state: { [id: string]: { [property: string]: SystemDeviceState } };
+    deviceProxies: { [id: string]: ScryptedDevice } = {};
     log: Logger;
     events = new EventRegistry();
+    typesVersion: string;
+    descriptors: { [scryptedInterface: string]: ScryptedInterfaceDescriptor };
+    propertyInterfaces: ReturnType<typeof getPropertyInterfaces>;
 
     getDeviceState(id: string) {
         return this.state[id];
     }
-    getSystemState(): {[id: string]: {[property: string]: SystemDeviceState}} {
+    getSystemState(): { [id: string]: { [property: string]: SystemDeviceState } } {
         return this.state;
     }
 
@@ -155,4 +186,11 @@ export class SystemManagerImpl implements SystemManager {
     getComponent(id: string): Promise<any> {
         return this.api.getComponent(id);
     }
+
+    setScryptedInterfaceDescriptors(typesVersion: string, descriptors: { [scryptedInterface: string]: ScryptedInterfaceDescriptor }): Promise<void> {
+        this.typesVersion = typesVersion;
+        this.descriptors = descriptors;
+        this.propertyInterfaces = getPropertyInterfaces(descriptors);
+        return this.api.setScryptedInterfaceDescriptors(typesVersion, descriptors);
+    }
 }

package/src/rpc.ts

@@ -246,6 +246,17 @@ export class RpcPeer {
     static readonly PROPERTY_JSON_DISABLE_SERIALIZATION = '__json_disable_serialization';
     static readonly PROPERTY_PROXY_PROPERTIES = '__proxy_props';
     static readonly PROPERTY_JSON_COPY_SERIALIZE_CHILDREN = '__json_copy_serialize_children';
+    static readonly PROBED_PROPERTIES = new Set<any>([
+        'then',
+        'constructor',
+        '__proxy_id',
+        '__proxy_constructor',
+        '__proxy_peer',
+        RpcPeer.PROPERTY_PROXY_ONEWAY_METHODS,
+        RpcPeer.PROPERTY_JSON_DISABLE_SERIALIZATION,
+        RpcPeer.PROPERTY_PROXY_PROPERTIES,
+        RpcPeer.PROPERTY_JSON_COPY_SERIALIZE_CHILDREN,
+    ]);
 
     constructor(public selfName: string, public peerName: string, public send: (message: RpcMessage, reject?: (e: Error) => void, serializationContext?: any) => void) {
     }

package/src/scrypted-server-main.ts

@@ -225,6 +225,7 @@ async function start() {
     });
 
     console.log('#######################################################');
+    console.log(`Scrypted Volume           : ${volumeDir}`);
     console.log(`Scrypted Server (Local)   : https://localhost:${SCRYPTED_SECURE_PORT}/`);
     for (const address of getHostAddresses(true, true)) {
         console.log(`Scrypted Server (Remote)  : https://${address}:${SCRYPTED_SECURE_PORT}/`);

package/src/state.ts

@@ -1,11 +1,11 @@
-import { ScryptedRuntime } from "./runtime";
-import { ScryptedNativeId, EventDetails, EventListenerOptions, EventListenerRegister, Refresh, ScryptedInterface, ScryptedInterfaceProperty, SystemDeviceState } from "@scrypted/types";
-import { RefreshSymbol } from "./plugin/plugin-device";
+import { EventDetails, EventListenerOptions, EventListenerRegister, Refresh, ScryptedInterface, ScryptedInterfaceProperty, ScryptedNativeId, SystemDeviceState } from "@scrypted/types";
 import throttle from 'lodash/throttle';
-import { sleep } from "./sleep";
-import { EventListenerRegisterImpl, EventRegistry } from "./event-registry";
 import { PluginDevice } from "./db-types";
+import { EventListenerRegisterImpl, EventRegistry } from "./event-registry";
 import { allInterfaceProperties, propertyInterfaces } from "./plugin/descriptor";
+import { RefreshSymbol } from "./plugin/plugin-device";
+import { ScryptedRuntime } from "./runtime";
+import { sleep } from "./sleep";
 
 export class ScryptedStateManager extends EventRegistry {
     scrypted: ScryptedRuntime;
@@ -34,41 +34,30 @@ export class ScryptedStateManager extends EventRegistry {
         this.scrypted = scrypted;
     }
 
-    setPluginState(pluginId: string, nativeId: ScryptedNativeId, property: string, value: any) {
+    setPluginState(pluginId: string, nativeId: ScryptedNativeId, eventInterface: ScryptedInterface, property: string, value: any) {
         const device = this.scrypted.findPluginDevice(pluginId, nativeId);
         if (!device)
             throw new Error(`device not found for plugin id ${pluginId} native id ${nativeId}`);
-        this.setPluginDeviceState(device, property, value);
+        this.setPluginDeviceState(device, property, value, eventInterface);
     }
 
-    setPluginDeviceState(device: PluginDevice, property: string, value: any) {
-        if (!allInterfaceProperties.includes(property))
-            throw new Error(`invalid property ${property}`);
-
-        // this currently doesn't work because inherited properties are not detected.
-        // ie, MediaPlayer implements StartStop and Pause
-        // if (!isValidInterfaceProperty(device.state.interfaces.value, property))
-        //     throw new Error(`interface for property ${property} not implemented`);
-        if (!allInterfaceProperties.includes(property))
+    setPluginDeviceState(device: PluginDevice, property: string, value: any, eventInterface?: ScryptedInterface) {
+        eventInterface = eventInterface || propertyInterfaces[property];
+        if (!eventInterface)
             throw new Error(`${property} is not a valid property`);
 
         const changed = setState(device, property, value);
 
-        this.notifyPropertyEvent(device, property, value, changed);
-
-        this.upserts.add(device._id);
-        this.upsertThrottle();
-
-        return changed;
-    }
-
-    notifyPropertyEvent(device: PluginDevice, property: string, value: any, changed?: boolean) {
         const eventTime = device?.state?.[property]?.lastEventTime;
-        const eventInterface = propertyInterfaces[property];
 
         if (this.notify(device?._id, eventTime, eventInterface, property, value, changed) && device) {
             this.scrypted.getDeviceLogger(device).log('i', `state change: ${property} ${value}`);
         }
+
+        this.upserts.add(device._id);
+        this.upsertThrottle();
+
+        return changed;
     }
 
     updateDescriptor(device: PluginDevice) {