@scrypted/server 0.0.105 → 0.0.109

package/python/plugin-remote.py

@@ -21,7 +21,7 @@ from asyncio.futures import Future
 from asyncio.streams import StreamReader, StreamWriter
 import os
 from os import sys
-from sys import stderr, stdout
+import platform
 
 class SystemDeviceState(TypedDict):
     lastEventTime: int
@@ -164,8 +164,8 @@ class PluginRemote:
 
         zip = zipfile.ZipFile(zipPath)
 
-        python_prefix = os.path.join(os.environ.get(
-            'SCRYPTED_PLUGIN_VOLUME'), 'python')
+        plugin_volume = os.environ.get('SCRYPTED_PLUGIN_VOLUME')
+        python_prefix = os.path.join(plugin_volume, 'python-%s-%s' % (platform.system(), platform.machine()))
         if not os.path.exists(python_prefix):
             os.makedirs(python_prefix)
 
@@ -179,7 +179,7 @@ class PluginRemote:
 
             requirementstxt = os.path.join(python_prefix, 'requirements.txt')
             installed_requirementstxt = os.path.join(
-                python_prefix, 'installed-requirements.txt')
+                python_prefix, 'requirements.installed.txt')
 
             need_pip = True
             try:

package/python/rpc.py

@@ -1,8 +1,10 @@
 from asyncio.futures import Future
-from typing import Callable, Mapping, List
+from typing import Any, Callable, Mapping, List
 import traceback
 import inspect
+from typing_extensions import TypedDict
 import weakref
+import sys
 
 jsonSerializable = set()
 jsonSerializable.add(float)
@@ -45,21 +47,35 @@ class RpcProxyMethod:
         return self.__proxy.__apply__(self.__proxy_method_name, args)
 
 
+class LocalProxiedEntry(TypedDict):
+    id: str
+    finalizerId: str
+
+
 class RpcProxy(object):
-    def __init__(self, peer, proxyId: str, proxyConstructorName: str, proxyProps: any, proxyOneWayMethods: List[str]):
-        self.__dict__['__proxy_id'] = proxyId
+    def __init__(self, peer, entry: LocalProxiedEntry, proxyConstructorName: str, proxyProps: any, proxyOneWayMethods: List[str]):
+        self.__dict__['__proxy_id'] = entry['id']
+        self.__dict__['__proxy_entry'] = entry
         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 name == '__proxy_finalizer_id':
+            return self.dict['__proxy_entry']['finalizerId']
         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 __setattr__(self, name: str, value: Any) -> None:
+        if name == '__proxy_finalizer_id':
+            self.dict['__proxy_entry']['finalizerId'] = value
+
+        return super().__setattr__(name, value)
+
     def __call__(self, *args, **kwargs):
         print('call')
         pass
@@ -69,20 +85,18 @@ class RpcProxy(object):
 
 
 class RpcPeer:
-    # todo: these are all class statics lol, fix this.
-    idCounter = 1
-    peerName = 'Unnamed Peer'
-    params: Mapping[str, any] = {}
-    localProxied: Mapping[any, str] = {}
-    localProxyMap: Mapping[str, any] = {}
-    constructorSerializerMap = {}
-    proxyCounter = 1
-    pendingResults: Mapping[str, Future] = {}
-    remoteWeakProxies: Mapping[str, any] = {}
-    nameDeserializerMap: Mapping[str, RpcSerializer] = {}
-
     def __init__(self, send: Callable[[object, Callable[[Exception], None]], None]) -> None:
         self.send = send
+        self.idCounter = 1
+        self.peerName = 'Unnamed Peer'
+        self.params: Mapping[str, any] = {}
+        self.localProxied: Mapping[any, LocalProxiedEntry] = {}
+        self.localProxyMap: Mapping[str, any] = {}
+        self.constructorSerializerMap = {}
+        self.proxyCounter = 1
+        self.pendingResults: Mapping[str, Future] = {}
+        self.remoteWeakProxies: Mapping[str, any] = {}
+        self.nameDeserializerMap: Mapping[str, RpcSerializer] = {}
 
     def __apply__(self, proxyId: str, oneWayMethods: List[str], method: str, args: list):
         serializedArgs = []
@@ -120,12 +134,17 @@ class RpcPeer:
     def serialize(self, value, requireProxy):
         if (not value or (not requireProxy and type(value) in jsonSerializable)):
             return value
+
         __remote_constructor_name = 'Function' if callable(value) else value.__proxy_constructor if hasattr(
             value, '__proxy_constructor') else type(value).__name__
-        proxyId = self.localProxied.get(value, None)
-        if proxyId:
+
+        proxiedEntry = self.localProxied.get(value, None)
+        if proxiedEntry:
+            proxiedEntry['finalizerId'] = str(self.proxyCounter)
+            self.proxyCounter = self.proxyCounter + 1
             ret = {
-                '__remote_proxy_id': proxyId,
+                '__remote_proxy_id': proxiedEntry['id'],
+                '__remote_proxy_finalizer_id': proxiedEntry['finalizerId'],
                 '__remote_constructor_name': __remote_constructor_name,
                 '__remote_proxy_props': getattr(value, '__proxy_props', None),
                 '__remote_proxy_oneway_methods': getattr(value, '__proxy_oneway_methods', None),
@@ -140,13 +159,15 @@ class RpcPeer:
             }
             return ret
 
-        serializerMapName = self.constructorSerializerMap.get(type(value), None)
+        serializerMapName = self.constructorSerializerMap.get(
+            type(value), None)
         if serializerMapName:
             __remote_constructor_name = serializerMapName
             serializer = self.nameDeserializerMap.get(serializerMapName, None)
             serialized = serializer.serialize(value)
             ret = {
                 '__remote_proxy_id': None,
+                '__remote_proxy_finalizer_id': None,
                 '__remote_constructor_name': __remote_constructor_name,
                 '__remote_proxy_props': getattr(value, '__proxy_props', None),
                 '__remote_proxy_oneway_methods': getattr(value, '__proxy_oneway_methods', None),
@@ -156,11 +177,16 @@ class RpcPeer:
 
         proxyId = str(self.proxyCounter)
         self.proxyCounter = self.proxyCounter + 1
-        self.localProxied[value] = proxyId
+        proxiedEntry = {
+            'id': proxyId,
+            'finalizerId': proxyId,
+        }
+        self.localProxied[value] = proxiedEntry
         self.localProxyMap[proxyId] = value
 
         ret = {
             '__remote_proxy_id': proxyId,
+            '__remote_proxy_finalizer_id': proxyId,
             '__remote_constructor_name': __remote_constructor_name,
             '__remote_proxy_props': getattr(value, '__proxy_props', None),
             '__remote_proxy_oneway_methods': getattr(value, '__proxy_oneway_methods', None),
@@ -168,20 +194,26 @@ class RpcPeer:
 
         return ret
 
-    def finalize(self, id: str):
+    def finalize(self, localProxiedEntry: LocalProxiedEntry):
+        id = localProxiedEntry['id']
         self.remoteWeakProxies.pop(id, None)
         rpcFinalize = {
             '__local_proxy_id': id,
+            '__local_proxy_finalizer_id': localProxiedEntry['finalizerId'],
             'type': 'finalize',
         }
         self.send(rpcFinalize)
 
     def newProxy(self, proxyId: str, proxyConstructorName: str, proxyProps: any, proxyOneWayMethods: List[str]):
-        proxy = RpcProxy(self, proxyId, proxyConstructorName,
+        localProxiedEntry: LocalProxiedEntry = {
+            'id': proxyId,
+            'finalizerId': None,
+        }
+        proxy = RpcProxy(self, localProxiedEntry, proxyConstructorName,
                          proxyProps, proxyOneWayMethods)
         wr = weakref.ref(proxy)
         self.remoteWeakProxies[proxyId] = wr
-        weakref.finalize(proxy, lambda: self.finalize(proxyId))
+        weakref.finalize(proxy, lambda: self.finalize(localProxiedEntry))
         return proxy
 
     def deserialize(self, value):
@@ -192,6 +224,8 @@ class RpcPeer:
             return value
 
         __remote_proxy_id = value.get('__remote_proxy_id', None)
+        __remote_proxy_finalizer_id = value.get(
+            '__remote_proxy_finalizer_id', None)
         __local_proxy_id = value.get('__local_proxy_id', None)
         __remote_constructor_name = value.get(
             '__remote_constructor_name', None)
@@ -206,6 +240,7 @@ class RpcPeer:
             if not proxy:
                 proxy = self.newProxy(__remote_proxy_id, __remote_constructor_name,
                                       __remote_proxy_props, __remote_proxy_oneway_methods)
+            proxy.__proxy_finalizer_id = __remote_proxy_finalizer_id
             return proxy
 
         if __local_proxy_id:
@@ -297,9 +332,16 @@ class RpcPeer:
                 future.set_result(self.deserialize(
                     message.get('result', None)))
             elif messageType == 'finalize':
-                local = self.localProxyMap.pop(
-                    message['__local_proxy_id'], None)
-                self.localProxied.pop(local, None)
+                finalizerId = message.get('__local_proxy_finalizer_id', None)
+                proxyId = message['__local_proxy_id']
+                local = self.localProxyMap.get(proxyId, None)
+                if local:
+                    localProxiedEntry = self.localProxied.get(local)
+                    if localProxiedEntry and finalizerId and localProxiedEntry['finalizerId'] != finalizerId:
+                        print('mismatch finalizer id', file=sys.stderr)
+                        return
+                    self.localProxied.pop(local, None)
+                    local = self.localProxyMap.pop(proxyId, None)
             else:
                 raise RpcResultException(
                     None, 'unknown rpc message type %s' % type)

package/src/http-interfaces.ts

@@ -1,9 +1,9 @@
 import { HttpResponse, HttpResponseOptions } from "@scrypted/sdk/types";
 import { Response } from "express";
-import { PluginHost } from './plugin/plugin-host';
 import mime from "mime";
+import AdmZip from "adm-zip";
 
-export function createResponseInterface(res: Response, plugin: PluginHost): HttpResponse {
+export function createResponseInterface(res: Response, zip: AdmZip): HttpResponse {
     class HttpResponseImpl implements HttpResponse {
         send(body: string): void;
         send(body: string, options: HttpResponseOptions): void;
@@ -35,7 +35,7 @@ export function createResponseInterface(res: Response, plugin: PluginHost): Http
             if (!res.getHeader('Content-Type'))
                 res.contentType(mime.lookup(path));
 
-            const data = plugin.zip.getEntry(`fs/${path}`)?.getData();
+            const data = zip.getEntry(`fs/${path}`)?.getData();
             if (!data) {
                 res.status(404);
                 res.end();

package/src/plugin/listen-zero.ts

@@ -1,8 +1,21 @@
 import net from 'net';
 import { once } from 'events';
+import express from 'express';
 
 export async function listenZero(server: net.Server) {
     server.listen(0);
     await once(server, 'listening');
     return (server.address() as net.AddressInfo).port;
 }
+
+export function listenZeroExpress(app: express.Express) {
+    const server = app.listen(0);
+    return {
+        server,
+        port: (async () => {
+            await once(server, 'listening');
+            const { port } = (server.address() as net.AddressInfo);
+            return port;
+        })()
+    }
+}

package/src/plugin/plugin-api.ts

@@ -146,7 +146,7 @@ export interface PluginRemote {
 
     createDeviceState(id: string, setState: (property: string, value: any) => Promise<any>): Promise<any>;
 
-    getServicePort(name: string): Promise<number>;
+    getServicePort(name: string, ...args: any[]): Promise<number>;
 }
 
 export interface MediaObjectRemote extends MediaObject {

package/src/plugin/plugin-device.ts

@@ -7,6 +7,7 @@ import { getState } from "../state";
 import { getDisplayType } from "../infer-defaults";
 import { allInterfaceProperties, isValidInterfaceMethod, methodInterfaces } from "./descriptor";
 import { PluginError } from "./plugin-error";
+import { sleep } from "../sleep";
 
 interface MixinTable {
     mixinProviderId: string;
@@ -28,6 +29,7 @@ export class PluginDeviceProxyHandler implements ProxyHandler<any>, ScryptedDevi
     scrypted: ScryptedRuntime;
     id: string;
     mixinTable: MixinTable[];
+    releasing = new Set<any>();
 
     constructor(scrypted: ScryptedRuntime, id: string) {
         this.scrypted = scrypted;
@@ -40,12 +42,19 @@ export class PluginDeviceProxyHandler implements ProxyHandler<any>, ScryptedDevi
         (async () => {
             const mixinProvider = this.scrypted.getDevice(mixinEntry.mixinProviderId) as ScryptedDevice & MixinProvider;
             const { proxy } = await mixinEntry.entry;
+            // allow mixins in the process of being released to manage final
+            // events, etc, before teardown.
+            this.releasing.add(proxy);
             mixinProvider?.releaseMixin(this.id, proxy);
+            await sleep(1000);
+            this.releasing.delete(proxy);
         })().catch(() => { });
     }
 
     async isMixin(id: string, mixinDevice: any) {
-        let found = false;
+        if (this.releasing.has(mixinDevice))
+            return true;
+        await this.scrypted.devices[id].handler.ensureProxy();
         for (const mixin of this.scrypted.devices[id].handler.mixinTable) {
             const { proxy } = await mixin.entry;
             if (proxy === mixinDevice) {
@@ -228,7 +237,7 @@ export class PluginDeviceProxyHandler implements ProxyHandler<any>, ScryptedDevi
             // 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));
-            const mixinProxy = await mixinProvider.getMixin(wrappedProxy, allInterfaces as ScryptedInterface[], deviceState);
+            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}`);
 

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

@@ -8,7 +8,6 @@ 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;
 
@@ -46,23 +45,25 @@ export class PluginHostAPI extends PluginAPIManagedListeners implements PluginAP
     async onMixinEvent(id: string, nativeIdOrMixinDevice: ScryptedNativeId|any, eventInterface: any, eventData?: any) {
         // nativeId code path has been deprecated in favor of mixin object 12/10/2021
         const device = this.scrypted.findPluginDeviceById(id);
+
         if (!nativeIdOrMixinDevice || typeof nativeIdOrMixinDevice === 'string') {
+            const nativeId: string = nativeIdOrMixinDevice;
             // todo: deprecate this code path
-            const mixinProvider = this.scrypted.findPluginDevice(this.pluginId, nativeIdOrMixinDevice);
+            const mixinProvider = this.scrypted.findPluginDevice(this.pluginId, nativeId);
             const mixins: string[] = getState(device, ScryptedInterfaceProperty.mixins) || [];
             if (!mixins.includes(mixinProvider._id))
                 throw new Error(`${mixinProvider._id} is not a mixin provider for ${id}`);
 
-            this.scrypted.findPluginDevice(this.pluginId, nativeIdOrMixinDevice);
+            this.scrypted.findPluginDevice(this.pluginId, nativeId);
             const tableEntry = this.scrypted.devices[device._id].handler.mixinTable.find(entry => entry.mixinProviderId === mixinProvider._id);
             const { interfaces } = await tableEntry.entry;
             if (!interfaces.has(eventInterface))
                 throw new Error(`${mixinProvider._id} does not mixin ${eventInterface} for ${id}`);
         }
         else {
-            if (!await this.scrypted.devices[device._id]?.handler?.isMixin(id, nativeIdOrMixinDevice)) {
-                const mixinProvider = this.scrypted.findPluginDevice(this.pluginId, nativeIdOrMixinDevice);
-                throw new Error(`${mixinProvider?._id} does not mixin ${eventInterface} for ${id}`);
+            const mixin: object = nativeIdOrMixinDevice;
+            if (!await this.scrypted.devices[device._id]?.handler?.isMixin(id, mixin)) {
+                throw new Error(`${mixin} does not mixin ${eventInterface} for ${id}`);
             }
         }
         this.scrypted.stateManager.notifyInterfaceEvent(device, eventInterface, eventData);
@@ -150,8 +151,8 @@ export class PluginHostAPI extends PluginAPIManagedListeners implements PluginAP
     async getDeviceById<T>(id: string): Promise<T & ScryptedDevice> {
         return this.scrypted.getDevice(id);
     }
-    async listen(EventListener: (id: string, eventDetails: EventDetails, eventData: object) => void): Promise<EventListenerRegister> {
-        return this.manageListener(this.scrypted.stateManager.listen(EventListener));
+    async listen(listener: (id: string, eventDetails: EventDetails, eventData: any) => void): Promise<EventListenerRegister> {
+        return this.manageListener(this.scrypted.stateManager.listen(listener));
     }
     async listenDevice(id: string, event: string | EventListenerOptions, callback: (eventDetails: EventDetails, eventData: object) => void): Promise<EventListenerRegister> {
         const device = this.scrypted.findPluginDeviceById(id);

package/src/plugin/plugin-host.ts

@@ -1,15 +1,14 @@
 import { RpcMessage, RpcPeer } from '../rpc';
 import AdmZip from 'adm-zip';
-import { SystemManager, DeviceManager, ScryptedNativeId, Device, EventListenerRegister, EngineIOHandler, ScryptedInterfaceProperty, SystemDeviceState } from '@scrypted/sdk/types'
+import { SystemManager, DeviceManager, ScryptedNativeId, Device, EventListenerRegister, EngineIOHandler, ScryptedInterface, ScryptedInterfaceProperty } from '@scrypted/sdk/types'
 import { ScryptedRuntime } from '../runtime';
 import { Plugin } from '../db-types';
-import io from 'engine.io';
+import io, { Socket } from 'engine.io';
 import { attachPluginRemote, setupPluginRemote } from './plugin-remote';
-import { PluginAPI, PluginRemote, PluginRemoteLoadZipOptions } from './plugin-api';
+import { PluginAPI, PluginAPIProxy, PluginRemote, PluginRemoteLoadZipOptions } from './plugin-api';
 import { Logger } from '../logger';
 import { MediaManagerHostImpl, MediaManagerImpl } from './media';
-import { getState } from '../state';
-import WebSocket, { EventEmitter } from 'ws';
+import WebSocket from 'ws';
 import { PassThrough } from 'stream';
 import { Console } from 'console'
 import { sleep } from '../sleep';
@@ -25,6 +24,7 @@ import { ensurePluginVolume } from './plugin-volume';
 import { installOptionalDependencies } from './plugin-npm-dependencies';
 import { ConsoleServer, createConsoleServer } from './plugin-console';
 import { createREPLServer } from './plugin-repl';
+import { LazyRemote } from './plugin-lazy-remote';
 
 export class PluginHost {
     worker: child_process.ChildProcess;
@@ -41,7 +41,6 @@ export class PluginHost {
     api: PluginHostAPI;
     pluginName: string;
     packageJson: any;
-    listener: EventListenerRegister;
     stats: {
         cpuUsage: NodeJS.CpuUsage,
         memoryUsage: NodeJS.MemoryUsage,
@@ -51,7 +50,6 @@ export class PluginHost {
 
     kill() {
         this.killed = true;
-        this.listener.removeListener();
         this.api.removeListeners();
         this.worker.kill();
         this.io.close();
@@ -77,7 +75,6 @@ export class PluginHost {
         return this.pluginName || 'no plugin name';
     }
 
-
     async upsertDevice(upsert: Device) {
         const pi = await this.scrypted.upsertDevice(this.pluginId, upsert, true);
         await this.remote.setNativeId(pi.nativeId, pi._id, pi.storage || {});
@@ -101,6 +98,17 @@ export class PluginHost {
 
         this.io.on('connection', async (socket) => {
             try {
+                try {
+                    if (socket.request.url.indexOf('/api') !== -1) {
+                        await this.createRpcIoPeer(socket);
+                        return;
+                    }
+                }
+                catch (e) {
+                    socket.close();
+                    return;
+                }
+
                 const {
                     endpointRequest,
                     pluginDevice,
@@ -138,8 +146,7 @@ export class PluginHost {
         logger.log('i', `loading ${this.pluginName}`);
         logger.log('i', 'pid ' + this.worker?.pid);
 
-
-        const remotePromise = setupPluginRemote(this.peer, this.api, self.pluginId);
+        const remotePromise = setupPluginRemote(this.peer, this.api, self.pluginId, () => this.scrypted.stateManager.getSystemState());
         const init = (async () => {
             const remote = await remotePromise;
 
@@ -190,19 +197,9 @@ export class PluginHost {
         this.module = init.then(({ module }) => module);
         this.remote = new LazyRemote(remotePromise, init.then(({ remote }) => remote));
 
-        this.listener = scrypted.stateManager.listen((id, eventDetails, eventData) => {
-            if (eventDetails.property) {
-                const device = scrypted.findPluginDeviceById(id);
-                this.remote.notify(id, eventDetails.eventTime, eventDetails.eventInterface, eventDetails.property, device?.state[eventDetails.property], eventDetails.changed);
-            }
-            else {
-                this.remote.notify(id, eventDetails.eventTime, eventDetails.eventInterface, eventDetails.property, eventData, eventDetails.changed);
-            }
-        });
-
         init.catch(e => {
             console.error('plugin failed to load', e);
-            this.listener.removeListener();
+            this.api.removeListeners();
         });
     }
 
@@ -314,6 +311,27 @@ export class PluginHost {
             }
         };
     }
+
+    async createRpcIoPeer(socket: Socket) {
+        let connected = true;
+        const rpcPeer = new RpcPeer(`api/${this.pluginId}`, 'web', (message, reject) => {
+            if (!connected)
+                reject?.(new Error('peer disconnected'));
+            else
+                socket.send(JSON.stringify(message))
+        });
+        socket.on('message', data => rpcPeer.handleMessage(JSON.parse(data as string)));
+        // wrap the host api with a connection specific api that can be torn down on disconnect
+        const api = new PluginAPIProxy(this.api, await this.peer.getParam('mediaManager'));
+        const kill = () => {
+            connected = false;
+            rpcPeer.kill('engine.io connection closed.')
+            api.removeListeners();
+        }
+        socket.on('close', kill);
+        socket.on('error', kill);
+        return setupPluginRemote(rpcPeer, api, null, () => this.scrypted.stateManager.getSystemState());
+    }
 }
 
 export function startPluginRemote() {
@@ -331,13 +349,6 @@ export function startPluginRemote() {
     let api: PluginAPI;
     let pluginId: string;
 
-    function idForNativeId(nativeId: ScryptedNativeId) {
-        if (!deviceManager)
-            return;
-        const ds = deviceManager.getDeviceState(nativeId);
-        return ds?.id;
-    }
-
     const getConsole = (hook: (stdout: PassThrough, stderr: PassThrough) => Promise<void>,
         also?: Console, alsoPrefix?: string) => {
 
@@ -489,7 +500,7 @@ export function startPluginRemote() {
         getPluginConsole,
         getDeviceConsole,
         getMixinConsole,
-        async getServicePort(name) {
+        async getServicePort(name, ...args: any[]) {
             if (name === 'repl') {
                 if (!replPort)
                     throw new Error('REPL unavailable: Plugin not loaded.')
@@ -530,69 +541,3 @@ export function startPluginRemote() {
         });
     })
 }
-
-/**
- * Warning: do not await in any of these methods unless necessary, otherwise
- * execution order of state reporting may fail.
- */
-class LazyRemote implements PluginRemote {
-    remote: PluginRemote;
-
-    constructor(public remotePromise: Promise<PluginRemote>, public remoteReadyPromise: Promise<PluginRemote>) {
-        this.remoteReadyPromise = (async () => {
-            this.remote = await remoteReadyPromise;
-            return this.remote;
-        })();
-    }
-
-    async loadZip(packageJson: any, zipData: Buffer, options?: PluginRemoteLoadZipOptions): Promise<any> {
-        if (!this.remote)
-            await this.remoteReadyPromise;
-        return this.remote.loadZip(packageJson, zipData, options);
-    }
-    async setSystemState(state: { [id: string]: { [property: string]: SystemDeviceState; }; }): Promise<void> {
-        if (!this.remote)
-            await this.remoteReadyPromise;
-        return this.remote.setSystemState(state);
-    }
-    async setNativeId(nativeId: ScryptedNativeId, id: string, storage: { [key: string]: any; }): Promise<void> {
-        if (!this.remote)
-            await this.remoteReadyPromise;
-        return this.remote.setNativeId(nativeId, id, storage);
-    }
-    async updateDeviceState(id: string, state: { [property: string]: SystemDeviceState; }): Promise<void> {
-        try {
-            if (!this.remote)
-                await this.remoteReadyPromise;
-        }
-        catch (e) {
-            return;
-        }
-        return this.remote.updateDeviceState(id, state);
-    }
-    async notify(id: string, eventTime: number, eventInterface: string, property: string, propertyState: SystemDeviceState, changed?: boolean): Promise<void> {
-        try {
-            if (!this.remote)
-                await this.remoteReadyPromise;
-        }
-        catch (e) {
-            return;
-        }
-        return this.remote.notify(id, eventTime, eventInterface, property, propertyState, changed);
-    }
-    async ioEvent(id: string, event: string, message?: any): Promise<void> {
-        if (!this.remote)
-            await this.remoteReadyPromise;
-        return this.remote.ioEvent(id, event, message);
-    }
-    async createDeviceState(id: string, setState: (property: string, value: any) => Promise<void>): Promise<any> {
-        if (!this.remote)
-            await this.remoteReadyPromise;
-        return this.remote.createDeviceState(id, setState);
-    }
-
-    async getServicePort(name: string): Promise<number> {
-        const remote = await this.remotePromise;
-        return remote.getServicePort(name);
-    }
-}