@scrypted/server 0.0.71 → 0.0.78

package/python/rpc.py

@@ -1,11 +1,7 @@
-from asyncio.events import AbstractEventLoop
 from asyncio.futures import Future
 from typing import Callable
-import asyncio
-import json
 import traceback
 import inspect
-import json
 from collections.abc import Mapping, Sequence
 import weakref
 
@@ -50,17 +46,19 @@ class RpcProxyMethod:
         return self.__proxy.__apply__(self.__proxy_method_name, args)
 
 
-class RpcProxy:
+class RpcProxy(object):
     def __init__(self, peer, proxyId: str, proxyConstructorName: str, proxyProps: any, proxyOneWayMethods: list[str]):
-        self.__proxy_id = proxyId
-        self.__proxy_constructor = proxyConstructorName
-        self.__proxy_peer = peer
-        self.__proxy_props = proxyProps
-        self.__proxy_oneway_methods = proxyOneWayMethods
+        self.__dict__['__proxy_id'] = proxyId
+        self.__dict__['__proxy_constructor'] = proxyConstructorName
+        self.__dict__['__proxy_peer'] = peer
+        self.__dict__['__proxy_props'] = proxyProps
+        self.__dict__['__proxy_oneway_methods'] = proxyOneWayMethods
 
     def __getattr__(self, name):
-        if self.__proxy_props and hasattr(self.__proxy_props, name):
-            return self.__proxy_props[name]
+        if name in self.__dict__:
+            return self.__dict__[name]
+        if self.__dict__['__proxy_props'] and name in self.__dict__['__proxy_props']:
+            return self.__dict__['__proxy_props'][name]
         return RpcProxyMethod(self, name)
 
     def __call__(self, *args, **kwargs):
@@ -68,7 +66,7 @@ class RpcProxy:
         pass
 
     def __apply__(self, method: str, args: list):
-        return self.__proxy_peer.__apply__(self.__proxy_id, self.__proxy_oneway_methods, method, args)
+        return self.__dict__['__proxy_peer'].__apply__(self.__dict__['__proxy_id'], self.__dict__['__proxy_oneway_methods'], method, args)
 
 
 class RpcPeer:
@@ -86,20 +84,20 @@ class RpcPeer:
     def __init__(self, send: Callable[[object, Callable[[Exception], None]], None]) -> None:
         self.send = send
 
-    def __apply__(self, proxyId: str, oneWayMethods: list[str], method: str, argArray: list):
-        args = []
-        for arg in argArray:
-            args.append(self.serialize(arg, False))
+    def __apply__(self, proxyId: str, oneWayMethods: list[str], method: str, args: list):
+        serializedArgs = []
+        for arg in args:
+            serializedArgs.append(self.serialize(arg, False))
 
         rpcApply = {
             'type': 'apply',
             'id': None,
             'proxyId': proxyId,
-            'argArray': args,
+            'args': serializedArgs,
             'method': method,
         }
 
-        if not oneWayMethods or method not in oneWayMethods:
+        if oneWayMethods and method in oneWayMethods:
             rpcApply['oneway'] = True
             self.send(rpcApply)
             future = Future()
@@ -142,8 +140,7 @@ class RpcPeer:
             }
             return ret
 
-        serializerMapName = self.constructorSerializerMap.get(
-            type(value).__name__)
+        serializerMapName = self.constructorSerializerMap.get(type(value), None)
         if serializerMapName:
             __remote_constructor_name = serializerMapName
             serializer = self.nameDeserializerMap.get(serializerMapName, None)
@@ -227,8 +224,8 @@ class RpcPeer:
 
     async def handleMessage(self, message: any):
         try:
-            type = message['type']
-            if type == 'param':
+            messageType = message['type']
+            if messageType == 'param':
                 result = {
                     'type': 'result',
                     'id': message['id'],
@@ -246,7 +243,7 @@ class RpcPeer:
 
                 self.send(result)
 
-            elif type == 'apply':
+            elif messageType == 'apply':
                 result = {
                     'type': 'result',
                     'id': message['id'],
@@ -261,7 +258,7 @@ class RpcPeer:
                                         message['proxyId'])
 
                     args = []
-                    for arg in (message['argArray'] or []):
+                    for arg in (message['args'] or []):
                         args.append(self.deserialize(arg))
 
                     value = None
@@ -284,7 +281,7 @@ class RpcPeer:
                 if not message.get('oneway', False):
                     self.send(result)
 
-            elif type == 'result':
+            elif messageType == 'result':
                 future = self.pendingResults.get(message['id'], None)
                 if not future:
                     raise RpcResultException(
@@ -299,7 +296,7 @@ class RpcPeer:
                     return
                 future.set_result(self.deserialize(
                     message.get('result', None)))
-            elif type == 'finalize':
+            elif messageType == 'finalize':
                 local = self.localProxyMap.pop(
                     message['__local_proxy_id'], None)
                 self.localProxied.pop(local, None)
@@ -330,57 +327,3 @@ class RpcPeer:
             }
             self.send(paramMessage, reject)
         return await self.createPendingResult(send)
-
-# c = RpcPeer()
-
-
-async def readLoop(loop, peer, reader):
-    async for line in reader:
-        try:
-            message = json.loads(line)
-            asyncio.run_coroutine_threadsafe(peer.handleMessage(message), loop)
-        except Exception as e:
-            print('read loop error', e)
-            pass
-
-
-async def async_main(loop: AbstractEventLoop):
-    reader, writer = await asyncio.open_connection(
-        '127.0.0.1', 3033)
-
-    async def send(message, reject):
-        jsonString = json.dumps(message)
-        writer.write(bytes(jsonString + '\n', 'utf8'))
-        try:
-            await writer.drain()
-        except Exception as e:
-            if reject:
-                reject(e)
-
-    peer = RpcPeer(send)
-    peer.params['print'] = print
-
-    async def consoleTest():
-        console = await peer.getParam('console')
-        await console.log('test', 'poops', 'peddeps')
-
-    await asyncio.gather(readLoop(loop, peer, reader), consoleTest())
-    print('done')
-
-    # print("line %s" % line)
-
-    # async with aiofiles.open(0, mode='r') as f:
-    #     async for line in f:
-    #         print("line %s" % line)
-    # # pokemon = json.loads(contents)
-    # # print(pokemon['name'])
-
-
-def main():
-    loop = asyncio.get_event_loop()
-    loop.run_until_complete(async_main(loop))
-    loop.close()
-
-
-if __name__ == "__main__":
-    main()

package/src/cert.ts

@@ -0,0 +1,74 @@
+// import libraries
+import forge from 'node-forge';
+import crypto from 'crypto';
+
+const { pki } = forge;
+
+
+export const CURRENT_SELF_SIGNED_CERTIFICATE_VERSION = 'v2';
+
+export function createSelfSignedCertificate() {
+
+    // generate a keypair and create an X.509v3 certificate
+    const keys = pki.rsa.generateKeyPair(2048);
+    const cert = pki.createCertificate();
+    cert.publicKey = keys.publicKey;
+
+    // NOTE: serialNumber is the hex encoded value of an ASN.1 INTEGER.
+    // Conforming CAs should ensure serialNumber is:
+    // - no more than 20 octets
+    // - non-negative (prefix a '00' if your value starts with a '1' bit)
+    cert.serialNumber = '01' + crypto.randomBytes(19).toString("hex"); // 1 octet = 8 bits = 1 byte = 2 hex chars
+    cert.validity.notBefore = new Date();
+    cert.validity.notAfter = new Date();
+    cert.validity.notAfter.setFullYear(cert.validity.notBefore.getFullYear() + 1); // adding 1 year of validity from now
+    const attrs = [{
+        name: 'commonName',
+        value: 'localhost'
+    }];
+    cert.setSubject(attrs);
+    cert.setIssuer(attrs);
+    cert.setExtensions([{
+        name: 'basicConstraints',
+        cA: true
+    }, {
+        name: 'keyUsage',
+        keyCertSign: true,
+        digitalSignature: true,
+        nonRepudiation: true,
+        keyEncipherment: true,
+        dataEncipherment: true
+    }, {
+        name: 'extKeyUsage',
+        serverAuth: true,
+        clientAuth: true,
+        codeSigning: true,
+        emailProtection: true,
+        timeStamping: true
+    }, {
+        name: 'nsCertType',
+        client: true,
+        server: true,
+        email: true,
+        objsign: true,
+        sslCA: true,
+        emailCA: true,
+        objCA: true
+    }, {
+        name: 'subjectAltName',
+        altNames: [{
+            type: 7, // IP
+            ip: '127.0.0.1'
+        }]
+    }, {
+        name: 'subjectKeyIdentifier'
+    }]);
+
+    // self-sign certificate
+    cert.sign(keys.privateKey);
+    return {
+        serviceKey: pki.privateKeyToPem(keys.privateKey),
+        certificate: pki.certificateToPem(cert),
+        version: CURRENT_SELF_SIGNED_CERTIFICATE_VERSION,
+    };
+}

package/src/plugin/media.ts

@@ -1,4 +1,4 @@
-import { MediaStreamUrl, VideoCamera, Camera, BufferConverter, FFMpegInput, MediaManager, MediaObject, ScryptedDevice, ScryptedInterface, ScryptedMimeTypes, SystemManager, SCRYPTED_MEDIA_SCHEME } from "@scrypted/sdk/types";
+import { ScryptedInterfaceProperty, SystemDeviceState, MediaStreamUrl, VideoCamera, Camera, BufferConverter, FFMpegInput, MediaManager, MediaObject, ScryptedDevice, ScryptedInterface, ScryptedMimeTypes, SystemManager, SCRYPTED_MEDIA_SCHEME } from "@scrypted/sdk/types";
 import { convert, ensureBuffer } from "../convert";
 import { MediaObjectRemote } from "./plugin-api";
 import mimeType from 'mime'
@@ -15,14 +15,27 @@ function addBuiltins(console: Console, mediaManager: MediaManager) {
         fromMimeType: ScryptedMimeTypes.Url + ';' + ScryptedMimeTypes.AcceptUrlParameter,
         toMimeType: ScryptedMimeTypes.FFmpegInput,
         async convert(data: string | Buffer, fromMimeType: string): Promise<Buffer | string> {
+            const url = data.toString();
             const args: FFMpegInput = {
-                inputArguments: ['-i', data.toString()]
+                url,
+                inputArguments: [
+                    '-i',
+                    url,
+                ],
             }
 
             return Buffer.from(JSON.stringify(args));
         }
     });
 
+    mediaManager.builtinConverters.push({
+        fromMimeType: ScryptedMimeTypes.FFmpegInput,
+        toMimeType: ScryptedMimeTypes.MediaStreamUrl,
+        async convert(data: string | Buffer, fromMimeType: string): Promise<Buffer | string> {
+            return data;
+        }
+    });
+
     mediaManager.builtinConverters.push({
         fromMimeType: ScryptedMimeTypes.MediaStreamUrl,
         toMimeType: ScryptedMimeTypes.FFmpegInput,
@@ -52,10 +65,9 @@ function addBuiltins(console: Console, mediaManager: MediaManager) {
                 )
             }
 
-            const ret: FFMpegInput = {
+            const ret: FFMpegInput = Object.assign({
                 inputArguments,
-                mediaStreamOptions: mediaUrl.mediaStreamOptions,
-            }
+            }, mediaUrl);
 
             return Buffer.from(JSON.stringify(ret));
         }
@@ -87,15 +99,16 @@ function addBuiltins(console: Console, mediaManager: MediaManager) {
     });
 }
 
-export class MediaManagerImpl implements MediaManager {
-    systemManager: SystemManager;
+export abstract class MediaManagerBase implements MediaManager {
     builtinConverters: BufferConverter[] = [];
 
-    constructor(systemManager: SystemManager, public console: Console) {
-        this.systemManager = systemManager;
+    constructor(public console: Console) {
         addBuiltins(this.console, this);
     }
 
+    abstract getSystemState(): { [id: string]: { [property: string]: SystemDeviceState } };
+    abstract getDeviceById<T>(id: string): T;
+
     async getFFmpegPath(): Promise<string> {
         // try to get the ffmpeg path as a value of another variable
         // ie, in docker builds:
@@ -119,9 +132,9 @@ export class MediaManagerImpl implements MediaManager {
     }
 
     getConverters(): BufferConverter[] {
-        const devices = Object.keys(this.systemManager.getSystemState()).map(id => this.systemManager.getDeviceById(id));
-        const converters: BufferConverter[] = Object.values(devices).filter(device => device.interfaces?.includes(ScryptedInterface.BufferConverter))
-            .map(device => device as ScryptedDevice & BufferConverter);
+        const converters = Object.entries(this.getSystemState())
+            .filter(([id, state]) => state[ScryptedInterfaceProperty.interfaces]?.value?.includes(ScryptedInterface.BufferConverter))
+            .map(([id]) => this.getDeviceById<BufferConverter>(id));
         converters.push(...this.builtinConverters);
         return converters;
     }
@@ -185,10 +198,10 @@ export class MediaManagerImpl implements MediaManager {
         const path = url.pathname.split('/')[1];
         let mo: MediaObject;
         if (path === ScryptedInterface.VideoCamera) {
-            mo = await this.systemManager.getDeviceById<VideoCamera>(id).getVideoStream();
+            mo = await this.getDeviceById<VideoCamera>(id).getVideoStream();
         }
         else if (path === ScryptedInterface.Camera) {
-            mo = await this.systemManager.getDeviceById<Camera>(id).takePicture() as any;
+            mo = await this.getDeviceById<Camera>(id).takePicture() as any;
         }
         else {
             throw new Error('Unrecognized Scrypted Media interface.')
@@ -197,3 +210,29 @@ export class MediaManagerImpl implements MediaManager {
         return mo;
     }
 }
+
+export class MediaManagerImpl extends MediaManagerBase {
+    constructor(public systemManager: SystemManager, console: Console) {
+        super(console);
+    }
+
+    getSystemState(): { [id: string]: { [property: string]: SystemDeviceState; }; } {
+        return this.systemManager.getSystemState();
+    }
+
+    getDeviceById<T>(id: string): T {
+        return this.systemManager.getDeviceById<T>(id);
+    }
+}
+
+export class MediaManagerHostImpl extends MediaManagerBase {
+    constructor(public systemState: { [id: string]: { [property: string]: SystemDeviceState } },
+        public getDeviceById: (id: string) => any,
+        console: Console) {
+        super(console);
+    }
+
+    getSystemState(): { [id: string]: { [property: string]: SystemDeviceState; }; } {
+        return this.systemState;
+    }
+}

package/src/plugin/plugin-api.ts

@@ -136,7 +136,6 @@ export interface PluginRemoteLoadZipOptions {
 }
 
 export interface PluginRemote {
-    __proxy_oneway_methods?: string[],
     loadZip(packageJson: any, zipData: Buffer, options?: PluginRemoteLoadZipOptions): Promise<any>;
     setSystemState(state: {[id: string]: {[property: string]: SystemDeviceState}}): Promise<void>;
     setNativeId(nativeId: ScryptedNativeId, id: string, storage: {[key: string]: any}): Promise<void>;

package/src/plugin/plugin-device.ts

@@ -2,7 +2,7 @@ import { DeviceProvider, EventDetails, EventListenerOptions, EventListenerRegist
 import { ScryptedRuntime } from "../runtime";
 import { PluginDevice } from "../db-types";
 import { MixinProvider } from "@scrypted/sdk/types";
-import { handleFunctionInvocations, PROPERTY_PROXY_ONEWAY_METHODS } from "../rpc";
+import { handleFunctionInvocations } from "../rpc";
 import { getState } from "../state";
 import { getDisplayType } from "../infer-defaults";
 import { allInterfaceProperties, isValidInterfaceMethod, methodInterfaces } from "./descriptor";
@@ -39,6 +39,7 @@ export class PluginDeviceProxyHandler implements ProxyHandler<any>, ScryptedDevi
         })().catch(() => { });;
     }
 
+    // this must not be async, because it potentially changes execution order.
     ensureProxy(): Promise<PluginDevice> {
         const pluginDevice = this.scrypted.findPluginDeviceById(this.id);
         if (!pluginDevice)
@@ -115,7 +116,7 @@ export class PluginDeviceProxyHandler implements ProxyHandler<any>, ScryptedDevi
             return mixinTable;
         })();
 
-        return this.mixinTable.then(mixinTable => pluginDevice);
+        return this.mixinTable.then(_ => pluginDevice);
     }
 
     get(target: any, p: PropertyKey, receiver: any): any {
@@ -164,6 +165,16 @@ export class PluginDeviceProxyHandler implements ProxyHandler<any>, ScryptedDevi
         this.scrypted.stateManager.updateDescriptor(device);
     }
 
+    async probe(): Promise<boolean> {
+        try {
+            await this.ensureProxy();
+            return true;
+        }
+        catch (e) {
+            return false;
+        }
+    }
+
     async applyMixin(method: string, argArray?: any): Promise<any> {
         const iface = methodInterfaces[method];
         if (!iface)

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

@@ -6,11 +6,23 @@ import { Logger } from '../logger';
 import { getState } from '../state';
 import { PluginHost } from './plugin-host';
 import debounce from 'lodash/debounce';
+import { PROPERTY_PROXY_ONEWAY_METHODS } from '../rpc';
 
 
 export class PluginHostAPI extends PluginAPIManagedListeners implements PluginAPI {
     pluginId: string;
 
+    [PROPERTY_PROXY_ONEWAY_METHODS]: [
+        'onMixinEvent',
+        'onDeviceEvent',
+        'setStorage',
+        'ioSend',
+        'ioClose',
+        'setDeviceProperty',
+        'deliverPush',
+        'requestRestart',
+    ];
+
     restartDebounced = debounce(async () => {
         const host = this.scrypted.plugins[this.pluginId];
         const logger = await this.getLogger(undefined);
@@ -23,7 +35,7 @@ export class PluginHostAPI extends PluginAPIManagedListeners implements PluginAP
         this.scrypted.runPlugin(plugin);
     }, 15000);
 
-    constructor(public scrypted: ScryptedRuntime, plugin: Plugin, public pluginHost: PluginHost) {
+    constructor(public scrypted: ScryptedRuntime, plugin: Plugin, public pluginHost: PluginHost, public mediaManager: MediaManager) {
         super();
         this.pluginId = plugin._id;
     }
@@ -40,8 +52,8 @@ export class PluginHostAPI extends PluginAPIManagedListeners implements PluginAP
         this.scrypted.stateManager.notifyInterfaceEvent(device, eventInterface, eventData);
     }
 
-    getMediaManager(): Promise<MediaManager> {
-        return null;
+    async getMediaManager(): Promise<MediaManager> {
+        return this.mediaManager;
     }
 
     async deliverPush(endpoint: string, httpRequest: HttpRequest) {