@scrypted/server 0.1.10 → 0.1.13

package/src/plugin/plugin-device.ts

@@ -1,15 +1,14 @@
-import { DeviceProvider, EventDetails, EventListener, EventListenerOptions, EventListenerRegister, ScryptedDevice, ScryptedDeviceType, ScryptedInterface, ScryptedInterfaceDescriptors, ScryptedInterfaceProperty } from "@scrypted/types";
-import { ScryptedRuntime } from "../runtime";
+import { DeviceProvider, EventListener, EventListenerOptions, EventListenerRegister, MixinProvider, ScryptedDevice, ScryptedDeviceType, ScryptedInterface, ScryptedInterfaceDescriptors, ScryptedInterfaceProperty } from "@scrypted/types";
+import fs from 'fs';
+import path from 'path';
 import { PluginDevice } from "../db-types";
-import { MixinProvider } from "@scrypted/types";
-import { RpcPeer, PrimitiveProxyHandler } from "../rpc";
-import { getState } from "../state";
 import { getDisplayType } from "../infer-defaults";
-import { allInterfaceProperties, isValidInterfaceMethod, methodInterfaces } from "./descriptor";
-import { PluginError } from "./plugin-error";
+import { PrimitiveProxyHandler, RpcPeer } from "../rpc";
+import { ScryptedRuntime } from "../runtime";
 import { sleep } from "../sleep";
-import path from 'path';
-import fs from 'fs';
+import { getState } from "../state";
+import { allInterfaceProperties, getInterfaceMethods, getPropertyInterfaces } from "./descriptor";
+import { PluginError } from "./plugin-error";
 
 interface MixinTable {
     mixinProviderId: string;
@@ -17,7 +16,8 @@ interface MixinTable {
 }
 
 interface MixinTableEntry {
-    interfaces: Set<string>
+    interfaces: Set<string>;
+    methods?: Set<string>;
     allInterfaces: string[];
     proxy: any;
     error?: Error;
@@ -244,9 +244,10 @@ export class PluginDeviceProxyHandler implements PrimitiveProxyHandler<any>, Scr
 
             const implementer = await (mixinProvider as any)[QueryInterfaceSymbol](ScryptedInterface.MixinProvider);
             const host = this.scrypted.getPluginHostForDeviceId(implementer);
+            const propertyInterfaces = getPropertyInterfaces(host.api.descriptors || ScryptedInterfaceDescriptors);
             // todo: remove this and pass the setter directly.
             const deviceState = await host.remote.createDeviceState(this.id,
-                async (property, value) => this.scrypted.stateManager.setPluginDeviceState(pluginDevice, property, value));
+                async (property, value) => this.scrypted.stateManager.setPluginDeviceState(pluginDevice, property, value, propertyInterfaces[property]));
             const mixinProxy = await mixinProvider.getMixin(wrappedProxy, previousInterfaces as ScryptedInterface[], deviceState);
             if (!mixinProxy)
                 throw new PluginError(`mixin provider ${mixinId} did not return mixin for ${this.id}`);
@@ -283,7 +284,7 @@ export class PluginDeviceProxyHandler implements PrimitiveProxyHandler<any>, Scr
     }
 
     get(target: any, p: PropertyKey, receiver: any): any {
-        if (p === 'constructor')
+        if (RpcPeer.PROBED_PROPERTIES.has(p))
             return;
         const handled = RpcPeer.handleFunctionInvocations(this, target, p, receiver);
         if (handled)
@@ -300,9 +301,6 @@ export class PluginDeviceProxyHandler implements PrimitiveProxyHandler<any>, Scr
         if (p === RefreshSymbol || p === QueryInterfaceSymbol)
             return new Proxy(() => p, this);
 
-        if (!isValidInterfaceMethod(pluginDevice.state.interfaces.value, prop))
-            return;
-
         if (ScryptedInterfaceDescriptors[ScryptedInterface.ScryptedDevice].methods.includes(prop))
             return (this as any)[p].bind(this);
 
@@ -339,11 +337,7 @@ export class PluginDeviceProxyHandler implements PrimitiveProxyHandler<any>, Scr
     }
 
     async applyMixin(method: string, argArray?: any): Promise<any> {
-        const iface = methodInterfaces[method];
-        if (!iface)
-            throw new PluginError(`unknown method ${method}`);
-
-        const found = await this.findMixin(iface);
+        const found = await this.findMethod(method);
         if (found) {
             const { mixin, entry } = found;
             const { proxy } = entry;
@@ -355,6 +349,23 @@ export class PluginDeviceProxyHandler implements PrimitiveProxyHandler<any>, Scr
         throw new PluginError(`${method} not implemented`)
     }
 
+    async findMethod(method: string) {
+        for (const mixin of this.mixinTable) {
+            const entry = await mixin.entry;
+            if (!entry.methods) {
+                const pluginDevice = this.scrypted.findPluginDeviceById(mixin.mixinProviderId || this.id);
+                const plugin = this.scrypted.plugins[pluginDevice.pluginId];
+                let methods = new Set<string>(getInterfaceMethods(ScryptedInterfaceDescriptors, entry.interfaces))
+                if (plugin.api.descriptors)
+                    methods = new Set<string>([...methods, ...getInterfaceMethods(plugin.api.descriptors, entry.interfaces)]);
+                entry.methods = methods;
+            }
+            if (entry.methods.has(method)) {
+                return { mixin, entry };
+            }
+        }
+    }
+
     async findMixin(iface: string) {
         for (const mixin of this.mixinTable) {
             const entry = await mixin.entry;
@@ -407,9 +418,6 @@ export class PluginDeviceProxyHandler implements PrimitiveProxyHandler<any>, Scr
             return this.scrypted.getPackageJson(pluginDevice.pluginId);
         }
 
-        if (!isValidInterfaceMethod(pluginDevice.state.interfaces.value, method))
-            throw new PluginError(`device ${this.id} does not support method ${method}`);
-
         if (method === 'refresh') {
             const refreshInterface = argArray[0];
             const userInitiated = argArray[1];

package/src/plugin/plugin-host-api.ts

@@ -1,17 +1,20 @@
-import { ScryptedNativeId, ScryptedDevice, Device, DeviceManifest, EventDetails, EventListenerOptions, EventListenerRegister, ScryptedInterfaceProperty, MediaManager, HttpRequest, ScryptedInterface } from '@scrypted/types'
-import { ScryptedRuntime } from '../runtime';
+import { Device, DeviceManifest, EventDetails, EventListenerOptions, EventListenerRegister, HttpRequest, MediaManager, ScryptedDevice, ScryptedInterfaceDescriptor, ScryptedInterfaceProperty, ScryptedNativeId } from '@scrypted/types';
+import debounce from 'lodash/debounce';
 import { Plugin } from '../db-types';
-import { PluginAPI, PluginAPIManagedListeners } from './plugin-api';
 import { Logger } from '../logger';
+import { RpcPeer } from '../rpc';
+import { ScryptedRuntime } from '../runtime';
 import { getState } from '../state';
+import { getPropertyInterfaces } from './descriptor';
+import { PluginAPI, PluginAPIManagedListeners } from './plugin-api';
 import { PluginHost } from './plugin-host';
-import debounce from 'lodash/debounce';
-import { RpcPeer } from '../rpc';
-import { propertyInterfaces } from './descriptor';
 import { checkProperty } from './plugin-state-check';
 
 export class PluginHostAPI extends PluginAPIManagedListeners implements PluginAPI {
     pluginId: string;
+    typesVersion: string;
+    descriptors: { [scryptedInterface: string]: ScryptedInterfaceDescriptor };
+    propertyInterfaces: ReturnType<typeof getPropertyInterfaces>;
 
     [RpcPeer.PROPERTY_PROXY_ONEWAY_METHODS] = [
         'onMixinEvent',
@@ -116,7 +119,7 @@ export class PluginHostAPI extends PluginAPIManagedListeners implements PluginAP
 
     async setState(nativeId: ScryptedNativeId, key: string, value: any) {
         checkProperty(key, value);
-        this.scrypted.stateManager.setPluginState(this.pluginId, nativeId, key, value);
+        this.scrypted.stateManager.setPluginState(this.pluginId, nativeId, this.propertyInterfaces?.[key], key, value);
     }
 
     async setStorage(nativeId: ScryptedNativeId, storage: { [key: string]: string }) {
@@ -179,4 +182,10 @@ export class PluginHostAPI extends PluginAPIManagedListeners implements PluginAP
         logger.log('i', 'plugin restart was requested');
         return this.restartDebounced();
     }
+
+    async setScryptedInterfaceDescriptors(typesVersion: string, descriptors: { [scryptedInterface: string]: ScryptedInterfaceDescriptor }): Promise<void> {
+        this.typesVersion = typesVersion;
+        this.descriptors = descriptors;
+        this.propertyInterfaces = getPropertyInterfaces(descriptors);
+    }
 }

package/src/plugin/plugin-host.ts

@@ -333,7 +333,14 @@ export class PluginHost {
         });
 
         this.worker.on('rpc', (message, sendHandle) => {
-            this.createRpcPeer(sendHandle as net.Socket);
+            const socket  = sendHandle as net.Socket;
+            const { pluginId } = message;
+            const host = this.scrypted.plugins[pluginId];
+            if (!host) {
+                socket.destroy();
+                return;
+            }
+            host.createRpcPeer(socket);
         });
 
         this.peer.params.updateStats = (stats: any) => {

package/src/plugin/plugin-volume.ts

@@ -1,8 +1,9 @@
+import os from 'os';
 import path from 'path';
 import mkdirp from 'mkdirp';
 
 export function getScryptedVolume() {
-    const volumeDir = process.env.SCRYPTED_VOLUME || path.join(process.cwd(), 'volume');
+    const volumeDir = process.env.SCRYPTED_VOLUME || path.join(os.homedir(), '.scrypted', 'volume');
     return volumeDir;
 }
 

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/runtime.ts

@@ -40,7 +40,7 @@ interface DeviceProxyPair {
     proxy: ScryptedDevice;
 }
 
-const MIN_SCRYPTED_CORE_VERSION = 'v0.1.5';
+const MIN_SCRYPTED_CORE_VERSION = 'v0.1.16';
 const PLUGIN_DEVICE_STATE_VERSION = 2;
 
 interface HttpPluginData {

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