@scrypted/server 0.1.11 → 0.1.14

package/src/plugin/descriptor.ts

@@ -1,29 +1,35 @@
-import { ScryptedInterface, ScryptedInterfaceDescriptors } from "@scrypted/types";
+import { ScryptedInterface, ScryptedInterfaceDescriptor, ScryptedInterfaceDescriptors } from "@scrypted/types";
 
-export const allInterfaceMethods: string[] = [].concat(...Object.values(ScryptedInterfaceDescriptors).map((type: any) => type.methods));
-export const allInterfaceProperties: string[] = [].concat(...Object.values(ScryptedInterfaceDescriptors).map((type: any) => type.properties));
-export const deviceMethods: string[] = ['listen', 'setName', 'setRoom', 'setType'];
+export const allInterfaceProperties: string[] = [].concat(...Object.values(ScryptedInterfaceDescriptors).map(type => type.properties));
 
-export const methodInterfaces: { [method: string]: string } = {};
-for (const desc of Object.values(ScryptedInterfaceDescriptors)) {
-    for (const method of desc.methods) {
-        methodInterfaces[method] = desc.name;
+export function getPropertyInterfaces(descriptors: { [scryptedInterface: string]: ScryptedInterfaceDescriptor }) {
+    const propertyInterfaces: { [property: string]: ScryptedInterface } = {};
+
+    for (const descriptor of Object.values(descriptors)) {
+        for (const property of descriptor.properties) {
+            propertyInterfaces[property] = descriptor.name as ScryptedInterface;
+        }
     }
+
+    return propertyInterfaces;
 }
 
-export const propertyInterfaces: { [property: string]: ScryptedInterface } = {};
-for (const descriptor of Object.values(ScryptedInterfaceDescriptors)) {
-    for (const property of descriptor.properties) {
-        propertyInterfaces[property] = descriptor.name as ScryptedInterface;
-    }
+export const propertyInterfaces = getPropertyInterfaces(ScryptedInterfaceDescriptors);
+
+export function getInterfaceMethods(descriptors: { [scryptedInterface: string]: ScryptedInterfaceDescriptor }, interfaces: Set<string>) {
+    return Object.values(descriptors).filter(e => interfaces.has(e.name)).map(type => type.methods).flat();
+}
+
+export function getInterfaceProperties(descriptors: { [scryptedInterface: string]: ScryptedInterfaceDescriptor }, interfaces: Set<string>) {
+    return Object.values(descriptors).filter(e => interfaces.has(e.name)).map(type => type.properties).flat();
 }
 
-export function isValidInterfaceMethod(interfaces: string[], method: string) {
-    const availableMethods: string[] = [].concat(...Object.values(ScryptedInterfaceDescriptors).filter((e: any) => interfaces.includes(e.name)).map((type: any) => type.methods));
-    return availableMethods.includes(method) || ScryptedInterfaceDescriptors[ScryptedInterface.ScryptedDevice].methods.includes(method);
+export function isValidInterfaceMethod(descriptors: { [scryptedInterface: string]: ScryptedInterfaceDescriptor }, interfaces: Set<string>, method: string) {
+    const availableMethods = getInterfaceMethods(descriptors, interfaces);
+    return availableMethods.includes(method) || descriptors[ScryptedInterface.ScryptedDevice].methods.includes(method);
 }
 
-export function isValidInterfaceProperty(interfaces: string[], property: string): boolean {
-    const availableProperties: string[] = [].concat(...Object.values(ScryptedInterfaceDescriptors).filter((e: any) => interfaces.includes(e.name)).map((type: any) => type.properties));
+export function isValidInterfaceProperty(descriptors: { [scryptedInterface: string]: ScryptedInterfaceDescriptor }, interfaces: string[], property: string): boolean {
+    const availableProperties = getInterfaceProperties(descriptors, new Set(interfaces));
     return availableProperties.includes(property);
 }

package/src/plugin/media.ts

@@ -1,4 +1,4 @@
-import { getInstalledFfmpeg } from '@scrypted/ffmpeg';
+import pathToFfmpeg from 'ffmpeg-static';
 import { BufferConverter, BufferConvertorOptions, DeviceManager, FFmpegInput, MediaManager, MediaObject, MediaObjectOptions, MediaStreamUrl, ScryptedInterface, ScryptedInterfaceProperty, ScryptedMimeTypes, ScryptedNativeId, SystemDeviceState, SystemManager } from "@scrypted/types";
 import axios from 'axios';
 import child_process from 'child_process';
@@ -146,8 +146,10 @@ export abstract class MediaManagerBase implements MediaManager {
                         console.log('ffmpeg stream to image convesion timed out.');
                         cp.kill('SIGKILL');
                     }, 10000);
-                    await once(cp, 'exit');
                     clearTimeout(to);
+                    const [exitCode] = await once(cp, 'exit');
+                    if (exitCode)
+                        throw new Error(`ffmpeg stream to image convesion failed with exit code: ${exitCode}`);
                     return fs.readFileSync(tmpfile.name);
                 }
                 finally {
@@ -186,7 +188,7 @@ export abstract class MediaManagerBase implements MediaManager {
             return f;
 
         const defaultPath = os.platform() === 'win32' ? 'ffmpeg.exe' : 'ffmpeg';
-        return getInstalledFfmpeg() || defaultPath;
+        return pathToFfmpeg || defaultPath;
     }
 
     async getFilesPath(): Promise<string> {

package/src/plugin/plugin-api.ts

@@ -1,4 +1,4 @@
-import { ScryptedNativeId, ScryptedDevice, Device, DeviceManifest, EventDetails, EventListenerOptions, EventListenerRegister, ScryptedInterfaceProperty, MediaObject, SystemDeviceState, MediaManager, HttpRequest } from '@scrypted/types'
+import type { ScryptedNativeId, ScryptedDevice, Device, DeviceManifest, EventDetails, EventListenerOptions, EventListenerRegister, ScryptedInterfaceProperty, MediaObject, SystemDeviceState, MediaManager, HttpRequest, ScryptedInterfaceDescriptor } from '@scrypted/types'
 
 export interface PluginLogger {
     log(level: string, message: string): Promise<void>;
@@ -34,6 +34,8 @@ export interface PluginAPI {
     getMediaManager(): Promise<MediaManager>;
 
     requestRestart(): Promise<void>;
+
+    setScryptedInterfaceDescriptors(typesVersion: string, descriptors: { [scryptedInterface: string]: ScryptedInterfaceDescriptor }): Promise<void>;
 }
 
 class EventListenerRegisterProxy implements EventListenerRegister {
@@ -71,6 +73,10 @@ export class PluginAPIProxy extends PluginAPIManagedListeners implements PluginA
         super();
     }
 
+    setScryptedInterfaceDescriptors(typesVersion: string, descriptors: { [scryptedInterface: string]: ScryptedInterfaceDescriptor }): Promise<void> {
+        return this.api.setScryptedInterfaceDescriptors(typesVersion, descriptors);
+    }
+
     setState(nativeId: ScryptedNativeId, key: string, value: any): Promise<void> {
         return this.api.setState(nativeId, key, value);
     }

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-npm-dependencies.ts

@@ -6,6 +6,7 @@ import { once } from 'events';
 import process from 'process';
 import mkdirp from "mkdirp";
 import semver from 'semver';
+import os from 'os';
 
 export function getPluginNodePath(name: string) {
     const pluginVolume = ensurePluginVolume(name);
@@ -48,7 +49,10 @@ export async function installOptionalDependencies(console: Console, packageJson:
     mkdirp.sync(nodePrefix);
     fs.writeFileSync(packageJsonPath, JSON.stringify(reduced));
 
-    const cp = child_process.spawn('npm', ['--prefix', nodePrefix, 'install'], {
+    let npm = 'npm';
+    if (os.platform() === 'win32')
+        npm += '.cmd';
+    const cp = child_process.spawn(npm, ['--prefix', nodePrefix, 'install'], {
         cwd: nodePrefix,
         stdio: 'inherit',
     });

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

@@ -45,7 +45,9 @@ export class PythonRuntimeWorker extends ChildProcessWorker {
             }
         }
 
-        this.worker = child_process.spawn('python3', args, {
+        const pythonPath = os.platform() === 'win32' ? 'py.exe' : 'python3';
+
+        this.worker = child_process.spawn(pythonPath, args, {
             // stdin, stdout, stderr, peer in, peer out
             stdio: ['pipe', 'pipe', 'pipe', 'pipe', 'pipe'],
             env: Object.assign({

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