@scrypted/server 0.1.12 → 0.1.15

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-serializer.ts

@@ -3,7 +3,7 @@ import { SidebandBufferSerializer } from "./plugin/buffer-serializer";
 import { RpcPeer } from "./rpc";
 
 export function createDuplexRpcPeer(selfName: string, peerName: string, readable: Readable, writable: Writable) {
-    const serializer = createRpcDuplexSerializer(readable, writable);
+    const serializer = createRpcDuplexSerializer(writable);
 
     const rpcPeer = new RpcPeer(selfName, peerName, (message, reject, serializationContext) => {
         try {
@@ -16,6 +16,7 @@ export function createDuplexRpcPeer(selfName: string, peerName: string, readable
     });
 
     serializer.setupRpcPeer(rpcPeer);
+    readable.on('data', data => serializer.onData(data));
     readable.on('close', serializer.onDisconnected);
     readable.on('error', serializer.onDisconnected);
     return rpcPeer;
@@ -34,7 +35,7 @@ export function createRpcSerializer(options: {
         rpcPeer.kill('connection closed.');
     }
 
-    const sendMessage = (message: any, reject: (e: Error) => void, serializationContext: any, ) => {
+    const sendMessage = (message: any, reject: (e: Error) => void, serializationContext: any,) => {
         if (!connected) {
             reject?.(new Error('peer disconnected'));
             return;
@@ -78,7 +79,9 @@ export function createRpcSerializer(options: {
     };
 }
 
-export function createRpcDuplexSerializer(readable: Readable, writable: Writable) {
+export function createRpcDuplexSerializer(writable: {
+    write: (data: Buffer) => void;
+}) {
     const socketSend = (type: number, data: Buffer) => {
         const header = Buffer.alloc(5);
         header.writeUInt32BE(data.length + 1, 0);
@@ -102,38 +105,52 @@ export function createRpcDuplexSerializer(readable: Readable, writable: Writable
     });
 
     let header: Buffer;
-    const readMessages = () => {
+    let pending: Buffer;
+
+    const readPending = (length: number) => {
+        if (!pending || pending.length < length)
+            return;
+
+        const ret = pending.slice(0, length);
+        pending = pending.slice(length);
+        if (!pending.length)
+            pending = undefined;
+        return ret;
+    }
+
+    const onData = (data: Buffer) => {
+        if (!pending)
+            pending = data;
+        else
+            pending = Buffer.concat([pending, data]);
+
         while (true) {
             if (!header) {
-                header = readable.read(5);
+                header = readPending(5);
                 if (!header)
                     return;
             }
 
             const length = header.readUInt32BE(0);
             const type = header.readUInt8(4);
-            const payload: Buffer = readable.read(length - 1);
+            const payload: Buffer = readPending(length - 1);
             if (!payload)
                 return;
 
             header = undefined;
 
-            const data = payload;
-
             if (type === 0) {
-                const message = JSON.parse(data.toString());
+                const message = JSON.parse(payload.toString());
                 serializer.onMessageFinish(message);
             }
             else {
-                serializer.onMessageBuffer(data);
+                serializer.onMessageBuffer(payload);
             }
         }
     }
 
-    readable.on('readable', readMessages);
-    readMessages();
-
     return {
+        onData,
         setupRpcPeer: serializer.setupRpcPeer,
         sendMessage: serializer.sendMessage,
         onDisconnected: serializer.onDisconnected,

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

@@ -1,39 +1,38 @@
-import { Level } from './level';
-import { PluginHost } from './plugin/plugin-host';
-import { ScryptedNativeId, Device, EngineIOHandler, HttpRequest, HttpRequestHandler, OauthClient, PushHandler, ScryptedDevice, ScryptedInterface, ScryptedInterfaceProperty, DeviceInformation } from '@scrypted/types';
-import { PluginDeviceProxyHandler } from './plugin/plugin-device';
-import { Plugin, PluginDevice, ScryptedAlert } from './db-types';
-import { getState, ScryptedStateManager, setState } from './state';
-import { Request, Response } from 'express';
-import { createResponseInterface } from './http-interfaces';
-import http, { ServerResponse, IncomingHttpHeaders } from 'http';
-import https from 'https';
-import express from 'express';
-import { LogEntry, Logger, makeAlertId } from './logger';
-import { getDisplayName, getDisplayRoom, getDisplayType, getProvidedNameOrDefault, getProvidedRoomOrDefault, getProvidedTypeOrDefault } from './infer-defaults';
-import { URL } from "url";
-import qs from "query-string";
-import { PluginComponent } from './services/plugin';
-import WebSocket, { Server as WebSocketServer } from "ws";
+import { Device, DeviceInformation, EngineIOHandler, HttpRequest, HttpRequestHandler, OauthClient, PushHandler, ScryptedDevice, ScryptedInterface, ScryptedInterfaceProperty, ScryptedNativeId } from '@scrypted/types';
+import AdmZip from 'adm-zip';
 import axios from 'axios';
-import tar from 'tar';
+import * as io from 'engine.io';
 import { once } from 'events';
+import express, { Request, Response } from 'express';
+import http, { ServerResponse } from 'http';
+import https from 'https';
+import { spawn as ptySpawn } from 'node-pty-prebuilt-multiarch';
+import path from 'path';
+import qs from "query-string";
+import rimraf from 'rimraf';
+import semver from 'semver';
 import { PassThrough } from 'stream';
+import tar from 'tar';
+import { URL } from "url";
+import WebSocket, { Server as WebSocketServer } from "ws";
+import { Plugin, PluginDevice, ScryptedAlert } from './db-types';
+import { createResponseInterface } from './http-interfaces';
+import { getDisplayName, getDisplayRoom, getDisplayType, getProvidedNameOrDefault, getProvidedRoomOrDefault, getProvidedTypeOrDefault } from './infer-defaults';
+import { IOServer } from './io';
+import { Level } from './level';
+import { LogEntry, Logger, makeAlertId } from './logger';
 import { PluginDebug } from './plugin/plugin-debug';
+import { PluginDeviceProxyHandler } from './plugin/plugin-device';
+import { PluginHost } from './plugin/plugin-host';
+import { isConnectionUpgrade, PluginHttp } from './plugin/plugin-http';
+import { getPluginVolume } from './plugin/plugin-volume';
 import { getIpAddress, SCRYPTED_INSECURE_PORT, SCRYPTED_SECURE_PORT } from './server-settings';
-import semver from 'semver';
-import { ServiceControl } from './services/service-control';
 import { Alerts } from './services/alerts';
-import { Info } from './services/info';
-import * as io from 'engine.io';
-import { spawn as ptySpawn } from 'node-pty';
-import rimraf from 'rimraf';
-import { getPluginVolume } from './plugin/plugin-volume';
-import { isConnectionUpgrade, PluginHttp } from './plugin/plugin-http';
-import AdmZip from 'adm-zip';
-import path from 'path';
 import { CORSControl, CORSServer } from './services/cors';
-import { IOServer, IOServerSocket } from './io';
+import { Info } from './services/info';
+import { PluginComponent } from './services/plugin';
+import { ServiceControl } from './services/service-control';
+import { getState, ScryptedStateManager, setState } from './state';
 
 interface DeviceProxyPair {
     handler: PluginDeviceProxyHandler;

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