@scrypted/server 0.144.1 → 0.144.2

package/src/plugin/plugin-remote-worker.ts

@@ -84,8 +84,8 @@ export function startPluginRemote(mainFilename: string, pluginId: string, peerSe
             class PluginForkableAPI extends PluginAPIProxy {
                 [RpcPeer.PROPERTY_PROXY_ONEWAY_METHODS] = (_api as any)[RpcPeer.PROPERTY_PROXY_ONEWAY_METHODS];
 
-                setStorage(nativeId: string, storage: { [key: string]: any; }): Promise<void> {
-                    const id = deviceManager.nativeIds.get(nativeId).id;
+                override setStorage(nativeId: string, storage: { [key: string]: any; }): Promise<void> {
+                    const id = deviceManager.nativeIds.get(nativeId)!.id;
                     for (const r of forks) {
                         r.setNativeId(nativeId, id, storage);
                     }
@@ -104,7 +104,7 @@ export function startPluginRemote(mainFilename: string, pluginId: string, peerSe
             if (name === 'repl') {
                 if (!replPort)
                     throw new Error('REPL unavailable: Plugin not loaded.')
-                return [await replPort, process.env.SCRYPTED_CLUSTER_ADDRESS];
+                return [await replPort, process.env.SCRYPTED_CLUSTER_ADDRESS!] as [number, string];
             }
             throw new Error(`unknown service ${name}`);
         },
@@ -183,11 +183,11 @@ export function startPluginRemote(mainFilename: string, pluginId: string, peerSe
 
                 process.on('uncaughtException', e => {
                     getPluginConsole().error('uncaughtException', e);
-                    scrypted.log.e('uncaughtException ' + (e.stack || e?.toString()));
+                    scrypted.log!.e('uncaughtException ' + (e.stack || e?.toString()));
                 });
                 process.on('unhandledRejection', e => {
                     getPluginConsole().error('unhandledRejection', e);
-                    scrypted.log.e('unhandledRejection ' + ((e as Error).stack || e?.toString()));
+                    scrypted.log!.e('unhandledRejection ' + ((e as Error).stack || e?.toString()));
                 });
 
                 installSourceMapSupport({
@@ -209,10 +209,10 @@ export function startPluginRemote(mainFilename: string, pluginId: string, peerSe
             await installOptionalDependencies(getPluginConsole(), packageJson);
 
             const main = await pluginReader(mainNodejs);
-            const script = main.toString();
+            const script = main!.toString();
 
             scrypted.connect = (socket, options) => {
-                process.send(options, socket);
+                process.send!(options, socket);
             }
 
             const pluginRemoteAPI: PluginRemote = scrypted.pluginRemoteAPI;
@@ -221,12 +221,12 @@ export function startPluginRemote(mainFilename: string, pluginId: string, peerSe
                 let forkPeer: Promise<RpcPeer>;
                 let runtimeWorker: RuntimeWorker;
                 let nativeWorker: child_process.ChildProcess | worker_threads.Worker;
-                let clusterWorkerId: Promise<string>;
+                let clusterWorkerId: Promise<string> | undefined;
 
                 const runtimeWorkerOptions: RuntimeWorkerOptions = {
                     packageJson,
                     env: undefined,
-                    pluginDebug: undefined,
+                    pluginDebug: undefined!,
                     zipFile,
                     unzippedPath,
                     zipHash,
@@ -234,13 +234,15 @@ export function startPluginRemote(mainFilename: string, pluginId: string, peerSe
 
                 // if running in a cluster, fork to a matching cluster worker only if necessary.
                 if (utilizesClusterForkWorker(options)) {
-                    ({ runtimeWorker, forkPeer, clusterWorkerId } = createClusterForkWorker(
+                    const result = createClusterForkWorker(
                         runtimeWorkerOptions,
-                        options,
+                        options!,
                         api.getComponent('cluster-fork'),
                         () => zipAPI.getZip(),
-                        scrypted.connectRPCObject)
-                    );
+                        scrypted.connectRPCObject);
+                    runtimeWorker = result.runtimeWorker;
+                    forkPeer = result.forkPeer;
+                    clusterWorkerId = result.clusterWorkerId as Promise<string>;
                 }
                 else {
                     if (options?.runtime) {
@@ -248,10 +250,10 @@ export function startPluginRemote(mainFilename: string, pluginId: string, peerSe
                         const runtime = builtins.get(options.runtime);
                         if (!runtime)
                             throw new Error('unknown runtime ' + options.runtime);
-                        runtimeWorker = runtime(mainFilename, runtimeWorkerOptions, undefined);
+                        runtimeWorker = runtime(mainFilename, runtimeWorkerOptions, undefined!);
 
                         if (runtimeWorker instanceof ChildProcessWorker) {
-                            nativeWorker = runtimeWorker.childProcess;
+                            nativeWorker = runtimeWorker.childProcess!;
                         }
                     }
                     else {
@@ -261,7 +263,7 @@ export function startPluginRemote(mainFilename: string, pluginId: string, peerSe
                         const ntw = new NodeThreadWorker(mainFilename, pluginId, {
                             packageJson,
                             env: undefined,
-                            pluginDebug: undefined,
+                            pluginDebug: undefined!,
                             zipFile,
                             unzippedPath,
                             zipHash,
@@ -316,8 +318,8 @@ export function startPluginRemote(mainFilename: string, pluginId: string, peerSe
                     class PluginForkAPI extends PluginAPIProxy {
                         [RpcPeer.PROPERTY_PROXY_ONEWAY_METHODS] = (api as any)[RpcPeer.PROPERTY_PROXY_ONEWAY_METHODS];
 
-                        setStorage(nativeId: string, storage: { [key: string]: any; }): Promise<void> {
-                            const id = deviceManager.nativeIds.get(nativeId).id;
+                        override setStorage(nativeId: string, storage: { [key: string]: any; }): Promise<void> {
+                            const id = deviceManager.nativeIds.get(nativeId)!.id;
                             pluginRemoteAPI.setNativeId(nativeId, id, storage);
                             for (const r of forks) {
                                 if (r === remote)
@@ -361,7 +363,7 @@ export function startPluginRemote(mainFilename: string, pluginId: string, peerSe
                     removeListener(event, listener) {
                         return runtimeWorker.removeListener(event as any, listener);
                     },
-                    nativeWorker,
+                    nativeWorker: nativeWorker!,
                 };
                 return {
                     [Symbol.dispose]() {
@@ -376,7 +378,7 @@ export function startPluginRemote(mainFilename: string, pluginId: string, peerSe
             try {
                 const isModule = packageJson.type === 'module';
                 const filename = zipOptions?.debug ? pluginMainNodeJs : pluginIdMainNodeJs;
-                const sdkVersion = await pluginReader('sdk.json').then(b => JSON.parse(b.toString()).version).catch(() => { });
+                const sdkVersion = await pluginReader('sdk.json').then(b => JSON.parse(b!.toString()).version).catch(() => { });
                 const mainNodeJsOnFilesystem = path.join(unzippedPath, mainNodejs);
                 if (sdkVersion) {
                     // todo: remove this, only existed in prerelease versions

package/src/plugin/plugin-remote.ts

@@ -51,7 +51,7 @@ export async function setupPluginRemote(peer: RpcPeer, api: PluginAPI, pluginId:
                         delete state[id];
                         continue;
                     }
-                    state[id] = getAccessControlDeviceState(id, state[id]);
+                    state[id] = getAccessControlDeviceState(id, state[id]!)!;
                 }
             }
 
@@ -67,11 +67,11 @@ export async function setupPluginRemote(peer: RpcPeer, api: PluginAPI, pluginId:
             if (eventDetails.eventInterface === ScryptedInterface.ScryptedDevice) {
                 if (eventDetails.property === ScryptedInterfaceProperty.id) {
                     // a change on the id property means device was deleted
-                    remote.updateDeviceState(eventData, undefined);
+                    remote.updateDeviceState(eventData, undefined!);
                 }
                 else {
                     // a change on anything else is a descriptor update
-                    remote.updateDeviceState(id, getAccessControlDeviceState(id));
+                    remote.updateDeviceState(id, getAccessControlDeviceState(id)!);
                 }
                 return;
             }
@@ -127,7 +127,7 @@ export function attachPluginRemote(peer: RpcPeer, options?: PluginRemoteAttachOp
 
                 ioSockets[id] = callbacks;
 
-                callbacks.connect(undefined, {
+                callbacks.connect(undefined!, {
                     close: (message) => connection.close(message),
                     send: (message) => connection.send(message),
                 });
@@ -140,14 +140,14 @@ export function attachPluginRemote(peer: RpcPeer, options?: PluginRemoteAttachOp
         api = await options?.onGetRemote?.(api, pluginId) || api;
 
         const systemManager = new SystemManagerImpl();
-        const deviceManager = new DeviceManagerImpl(systemManager, getDeviceConsole, getMixinConsole);
+        const deviceManager = new DeviceManagerImpl(systemManager, getDeviceConsole!, getMixinConsole!);
         const endpointManager = new EndpointManagerImpl();
-        const clusterManager = new ClusterManagerImpl(undefined, api, undefined);
+        const clusterManager = new ClusterManagerImpl(undefined, api, undefined!);
         const hostMediaManager = await api.getMediaManager();
         if (!hostMediaManager) {
-            peer.params['createMediaManager'] = async () => createMediaManager(systemManager, deviceManager);
+            peer.params['createMediaManager'] = async () => createMediaManager!(systemManager, deviceManager);
         }
-        const mediaManager = hostMediaManager || await createMediaManager(systemManager, deviceManager);
+        const mediaManager = hostMediaManager || await createMediaManager!(systemManager, deviceManager);
         peer.params['mediaManager'] = mediaManager;
 
         systemManager.api = api;
@@ -163,11 +163,11 @@ export function attachPluginRemote(peer: RpcPeer, options?: PluginRemoteAttachOp
             clusterManager,
             log,
             pluginHostAPI: api,
-            pluginRemoteAPI: undefined,
+            pluginRemoteAPI: undefined!,
             serverVersion: hostInfo?.serverVersion,
-            connect: undefined,
-            fork: undefined,
-            connectRPCObject: undefined,
+            connect: undefined!,
+            fork: undefined!,
+            connectRPCObject: undefined!,
         };
 
         delete peer.params.getRemote;
@@ -188,7 +188,7 @@ export function attachPluginRemote(peer: RpcPeer, options?: PluginRemoteAttachOp
                 'ioEvent',
                 'setNativeId',
             ],
-            getServicePort,
+            getServicePort: getServicePort!,
             async createDeviceState(id: string, setState: (property: string, value: any) => Promise<void>) {
                 return deviceManager.createDeviceState(id, setState);
             },
@@ -300,7 +300,7 @@ export function attachPluginRemote(peer: RpcPeer, options?: PluginRemoteAttachOp
                 params.pluginRuntimeAPI = ret;
 
                 try {
-                    return await options.onLoadZip(ret, params, packageJson, zipAPI, zipOptions);
+                    return await options!.onLoadZip!(ret, params, packageJson, zipAPI, zipOptions!);
                 }
                 catch (e) {
                     console.error('plugin start/fork failed', e)

package/src/plugin/plugin-repl.ts

@@ -19,9 +19,13 @@ export async function createREPLServer(scrypted: ScryptedStatic, params: any, pl
         }
 
         while (filter) {
-            const { id } = nativeIds.get(filter);
-            const d = await systemManager.getDeviceById(id);
+            const entry = nativeIds.get(filter);
+            if (!entry)
+                break;
+            const d = await systemManager.getDeviceById(entry.id);
             chain.push(filter);
+            if (!d?.providerId)
+                break;
             filter = reversed.get(d.providerId);
         }
 

package/src/plugin/runtime/child-process-worker.ts

@@ -1,13 +1,12 @@
 import child_process from 'child_process';
-import { once } from 'events';
-import { EventEmitter } from "ws";
+import { EventEmitter, once } from 'events';
 import { RpcMessage, RpcPeer } from "../../rpc";
 import { RuntimeWorker, RuntimeWorkerOptions } from "./runtime-worker";
 
 export abstract class ChildProcessWorker extends EventEmitter implements RuntimeWorker {
     public pluginId: string;
-    protected worker: child_process.ChildProcess;
-    killPromise: Promise<void>;
+    protected worker: child_process.ChildProcess | undefined;
+    killPromise!: Promise<void>;
 
     get childProcess() {
         return this.worker;
@@ -20,18 +19,18 @@ export abstract class ChildProcessWorker extends EventEmitter implements Runtime
     }
 
     setupWorker() {
-        this.worker.on('close', () => this.emit('error', new Error('close')));
-        this.worker.on('disconnect', () => this.emit('error', new Error('disconnect')));
-        this.worker.on('exit', (code, signal) => this.emit('exit', code, signal));
-        this.worker.on('error', e => this.emit('error', e));
+        this.worker!.on('close', () => this.emit('error', new Error('close')));
+        this.worker!.on('disconnect', () => this.emit('error', new Error('disconnect')));
+        this.worker!.on('exit', (code, signal) => this.emit('exit', code, signal));
+        this.worker!.on('error', e => this.emit('error', e));
         // aggressively catch errors
         // ECONNRESET can be raised when the child process is killed
-        for (const stdio of this.worker.stdio || []) {
+        for (const stdio of this.worker!.stdio || []) {
             if (stdio)
                 stdio.on('error', e => this.emit('error', e));
         }
 
-        this.killPromise = once(this.worker, 'exit').then(() => {}).catch(() => {});
+        this.killPromise = once(this.worker!, 'exit').then(() => { }).catch(() => { });
     }
 
     get pid() {
@@ -39,11 +38,11 @@ export abstract class ChildProcessWorker extends EventEmitter implements Runtime
     }
 
     get stdout() {
-        return this.worker.stdout;
+        return this.worker!.stdout!;
     }
 
     get stderr() {
-        return this.worker.stderr;
+        return this.worker!.stderr!;
     }
 
     kill(): void {

package/src/plugin/runtime/cluster-fork-worker.ts

@@ -16,7 +16,9 @@ export function createClusterForkWorker(
 
     // these are specific to the cluster worker host
     // and will be set there.
+    // @ts-ignore these are optional at runtime
     delete runtimeWorkerOptions.zipFile;
+    // @ts-ignore these are optional at runtime
     delete runtimeWorkerOptions.unzippedPath;
 
     const waitKilled = new Deferred<void>();

package/src/plugin/runtime/custom-worker.ts

@@ -8,13 +8,13 @@ import { ChildProcessWorker } from "./child-process-worker";
 import { RuntimeWorkerOptions } from "./runtime-worker";
 
 export class CustomRuntimeWorker extends ChildProcessWorker {
-    serializer: ReturnType<typeof createRpcDuplexSerializer>;
-    fork: boolean;
+    serializer!: ReturnType<typeof createRpcDuplexSerializer>;
+    fork!: boolean;
 
     constructor(options: RuntimeWorkerOptions, runtime: ScryptedRuntime) {
         super(options);
 
-        const pluginDevice = runtime.findPluginDevice(this.pluginId);
+        const pluginDevice = runtime.findPluginDevice(this.pluginId)!;
         const scryptedRuntimeArguments: ScryptedRuntimeArguments = pluginDevice.state.scryptedRuntimeArguments?.value;
         if (!scryptedRuntimeArguments)
             throw new Error('custom runtime requires scryptedRuntimeArguments');
@@ -52,8 +52,8 @@ export class CustomRuntimeWorker extends ChildProcessWorker {
     }
 
     setupRpcPeer(peer: RpcPeer): void {
-        const peerin = this.worker.stdio[3] as Writable;
-        const peerout = this.worker.stdio[4] as Readable;
+        const peerin = this.worker!.stdio[3]! as Writable;
+        const peerout = this.worker!.stdio[4]! as Readable;
 
         const serializer = this.serializer = createRpcDuplexSerializer(peerin);
         serializer.setupRpcPeer(peer);
@@ -75,7 +75,7 @@ export class CustomRuntimeWorker extends ChildProcessWorker {
             this.serializer.sendMessage(message, reject, serializationContext);
         }
         catch (e) {
-            reject?.(e);
+            reject?.(e as Error);
         }
     }
 }

package/src/plugin/runtime/node-fork-worker.ts

@@ -77,7 +77,7 @@ export class NodeForkWorker extends ChildProcessWorker {
     }
 
     setupRpcPeer(peer: RpcPeer): void {
-        this.worker.on('message', (message, sendHandle) => {
+        this.worker!.on('message', (message, sendHandle) => {
             if ((message as any).type && sendHandle) {
                 peer.handleMessage(message as any, {
                     sendHandle,
@@ -105,11 +105,11 @@ export class NodeForkWorker extends ChildProcessWorker {
             });
         }
         catch (e) {
-            reject?.(e);
+            reject?.(e as Error);
         }
     }
 
-    get pid() {
+    override get pid() {
         return this.worker?.pid;
     }
 }

package/src/plugin/runtime/node-thread-worker.ts

@@ -104,8 +104,8 @@ export class NodeThreadWorker extends EventEmitter implements RuntimeWorker {
             return;
         this.worker.terminate();
         this.port.close();
-        this.port = undefined;
-        this.worker = undefined;
+        this.port = undefined!;
+        this.worker = undefined!;
     }
 
     send(message: RpcMessage, reject?: (e: Error) => void, serializationContext?: any): void {
@@ -129,7 +129,7 @@ export class NodeThreadWorker extends EventEmitter implements RuntimeWorker {
             port.postMessage(postMessage, transferList);
         }
         catch (e) {
-            reject?.(e);
+            reject?.(e as Error);
         }
     }
 

package/src/plugin/runtime/python-worker.ts

@@ -13,7 +13,7 @@ import { RuntimeWorkerOptions } from "./runtime-worker";
 
 export class PythonRuntimeWorker extends ChildProcessWorker {
     static {
-        if (!fs.existsSync(process.env.SCRYPTED_PYTHON_PATH)) {
+        if (!process.env.SCRYPTED_PYTHON_PATH || !fs.existsSync(process.env.SCRYPTED_PYTHON_PATH)) {
             try {
                 const py = new PortablePython(packagedPythonVersion);
                 const portablePython = py.executablePath;
@@ -26,18 +26,18 @@ export class PythonRuntimeWorker extends ChildProcessWorker {
         }
     }
 
-    serializer: ReturnType<typeof createRpcDuplexSerializer>;
+    serializer!: ReturnType<typeof createRpcDuplexSerializer>;
     peerin: Writable;
     peerout: Readable;
     _stdout = new PassThrough();
     _stderr = new PassThrough();
     pythonInstallationComplete = true;
 
-    get stdout() {
+    override get stdout() {
         return this._stdout;
     }
 
-    get stderr() {
+    override get stderr() {
         return this._stderr;
     }
 
@@ -99,7 +99,7 @@ export class PythonRuntimeWorker extends ChildProcessWorker {
         const setup = () => {
             const types = require.resolve('@scrypted/types');
             const PYTHONPATH = types.substring(0, types.indexOf('types') + 'types'.length);
-            this.worker = child_process.spawn(pythonPath, args, {
+            this.worker = child_process.spawn(pythonPath as string, args, {
                 cwd: options.unzippedPath,
                 // stdin, stdout, stderr, peer in, peer out
                 stdio: ['pipe', 'pipe', 'pipe', 'pipe', 'pipe'],
@@ -112,8 +112,8 @@ export class PythonRuntimeWorker extends ChildProcessWorker {
             });
             this.setupWorker();
 
-            this.worker.stdout.pipe(this.stdout);
-            this.worker.stderr.pipe(this.stderr);
+            this.worker.stdout!.pipe(this.stdout);
+            this.worker.stderr!.pipe(this.stderr);
         };
 
         let pluginPythonVersion: string = options.packageJson.scrypted.pythonVersion?.[os.platform()]?.[os.arch()] || options.packageJson.scrypted.pythonVersion?.default;
@@ -125,8 +125,8 @@ export class PythonRuntimeWorker extends ChildProcessWorker {
         // if the plugin requests a specific python, then install it via portable python
         if (!pluginPythonVersion) {
             setup();
-            this.peerin = this.worker.stdio[3] as Writable;
-            this.peerout = this.worker.stdio[4] as Readable;
+            this.peerin = this.worker!.stdio[3]! as Writable;
+            this.peerout = this.worker!.stdio[4]! as Readable;
             return;
         }
 
@@ -135,8 +135,8 @@ export class PythonRuntimeWorker extends ChildProcessWorker {
         if (envPython && fs.existsSync(envPython)) {
             pythonPath = envPython;
             setup();
-            this.peerin = this.worker.stdio[3] as Writable;
-            this.peerout = this.worker.stdio[4] as Readable;
+            this.peerin = this.worker!.stdio[3]! as Writable;
+            this.peerout = this.worker!.stdio[4]! as Readable;
             return;
         }
 
@@ -146,8 +146,8 @@ export class PythonRuntimeWorker extends ChildProcessWorker {
         const finishSetup = () => {
             setup();
 
-            peerin.pipe(this.worker.stdio[3] as Writable);
-            (this.worker.stdio[4] as Readable).pipe(peerout);
+            peerin.pipe(this.worker!.stdio[3]! as Writable);
+            (this.worker!.stdio[4]! as Readable).pipe(peerout);
         };
 
         const pyVersion = require('py/package.json').version;
@@ -200,7 +200,7 @@ export class PythonRuntimeWorker extends ChildProcessWorker {
             this.serializer.sendMessage(message, reject, serializationContext);
         }
         catch (e) {
-            reject?.(e);
+            reject?.(e as Error);
         }
     }
 }

package/src/plugin/runtime/runtime-worker.ts

@@ -13,7 +13,7 @@ export interface RuntimeWorkerOptions {
 }
 
 export interface RuntimeWorker {
-    pid: number;
+    pid: number | undefined;
     stdout: Readable;
     stderr: Readable;
     killPromise: Promise<any>;

package/src/plugin/system.ts

@@ -10,8 +10,8 @@ function newDeviceProxy(id: string, systemManager: SystemManagerImpl) {
 }
 
 class DeviceProxyHandler implements PrimitiveProxyHandler<any> {
-    customProperties: Map<string | number | symbol, any>;
-    device: Promise<ScryptedDevice>;
+    customProperties!: Map<string | number | symbol, any>;
+    device!: Promise<ScryptedDevice | undefined>;
     constructor(public id: string, public systemManager: SystemManagerImpl) {
     }
 
@@ -20,14 +20,14 @@ class DeviceProxyHandler implements PrimitiveProxyHandler<any> {
     }
 
     ownKeys(target: any): ArrayLike<string | symbol> {
-        const interfaces = new Set<string>(this.systemManager.state[this.id].interfaces.value);
+        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);
+    getOwnPropertyDescriptor(target: any, p: string | symbol): PropertyDescriptor | undefined {
+        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)) {
@@ -39,9 +39,10 @@ class DeviceProxyHandler implements PrimitiveProxyHandler<any> {
         if (properties.includes(prop)) {
             return {
                 configurable: true,
-                value: this.systemManager.state[this.id][prop]?.value
+                value: this.systemManager.state[this.id]![prop]?.value
             }
         }
+        return undefined;
     }
 
     deleteProperty(target: any, p: string | symbol): boolean {
@@ -76,19 +77,19 @@ class DeviceProxyHandler implements PrimitiveProxyHandler<any> {
         if (handled)
             return handled;
 
-        const interfaces = new Set<string>(this.systemManager.state[this.id].interfaces?.value || []);
+        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;
+            return (this.systemManager.state[this.id]! as any)?.[p]?.value;
 
         if (!isValidInterfaceMethod(this.systemManager.descriptors || ScryptedInterfaceDescriptors, interfaces, prop))
             return;
 
-        if (ScryptedInterfaceDescriptors[ScryptedInterface.ScryptedDevice].methods.includes(prop))
+        if (ScryptedInterfaceDescriptors[ScryptedInterface.ScryptedDevice]!.methods.includes(prop))
             return (this as any)[p].bind(this);
 
         return new Proxy(() => p, this);
@@ -97,7 +98,7 @@ class DeviceProxyHandler implements PrimitiveProxyHandler<any> {
     ensureDevice() {
         if (!this.device)
             this.device = this.systemManager.api.getDeviceById(this.id);
-        return this.device;
+        return this.device!;
     }
 
     async apply(target: any, thisArg: any, argArray?: any) {
@@ -132,7 +133,7 @@ class DeviceProxyHandler implements PrimitiveProxyHandler<any> {
 
 
 class EventListenerRegisterImpl implements EventListenerRegister {
-    promise: Promise<EventListenerRegister>;
+    promise: Promise<EventListenerRegister> | undefined;
     constructor(promise: Promise<EventListenerRegister>) {
         this.promise = promise;
     }
@@ -151,21 +152,21 @@ class EventListenerRegisterImpl implements EventListenerRegister {
 function makeOneWayCallback<T>(input: T): T {
     const f: any = input;
     const oneways: string[] = f[RpcPeer.PROPERTY_PROXY_ONEWAY_METHODS] || [];
-    if (!oneways.includes(null))
-        oneways.push(null);
+    if (!oneways.includes(null!))
+        oneways.push(null!);
     f[RpcPeer.PROPERTY_PROXY_ONEWAY_METHODS] = oneways;
     return input;
 }
 
 export class SystemManagerImpl implements SystemManager {
-    api: PluginAPI;
-    state: { [id: string]: { [property: string]: SystemDeviceState } };
+    api!: PluginAPI;
+    state!: { [id: string]: { [property: string]: SystemDeviceState } };
     deviceProxies: { [id: string]: ScryptedDevice } = {};
-    log: Logger;
+    log!: Logger;
     events = new EventRegistry();
-    typesVersion: string;
-    descriptors: { [scryptedInterface: string]: ScryptedInterfaceDescriptor };
-    propertyInterfaces: ReturnType<typeof getPropertyInterfaces>;
+    typesVersion!: string;
+    descriptors!: { [scryptedInterface: string]: ScryptedInterfaceDescriptor };
+    propertyInterfaces!: ReturnType<typeof getPropertyInterfaces>;
 
     getDeviceState(id: string) {
         return this.state[id];
@@ -196,9 +197,9 @@ export class SystemManagerImpl implements SystemManager {
                 }
             }
         }
-        if (!id)
+        if (!id!)
             return;
-        let proxy = this.deviceProxies[id];
+        let proxy = this.deviceProxies[id!];
         if (!proxy)
             proxy = this.deviceProxies[id] = newDeviceProxy(id, this);
         return proxy;
@@ -206,10 +207,10 @@ export class SystemManagerImpl implements SystemManager {
 
     getDeviceByName(name: string): any {
         for (const id of Object.keys(this.state)) {
-            const s = this.state[id];
+            const s = this.state[id]!;
             if ((s.interfaces?.value as string[])?.includes(ScryptedInterface.ScryptedPlugin) && s.pluginId?.value === name)
                 return this.getDeviceById(id);
-            if (s.name.value === name)
+            if (s.name!.value === name)
                 return this.getDeviceById(id);
         }
     }

package/src/promise-utils.ts

@@ -1,5 +1,5 @@
 export interface RefreshPromise<T> {
-    promise: Promise<T>;
+    promise: Promise<T> | undefined;
     cacheDuration: number;
 }
 
@@ -66,12 +66,12 @@ export function timeoutFunction<T>(timeout: number, f: (isTimedOut: () => boolea
 }
 
 export function createPromiseDebouncer<T>() {
-    let current: Promise<T>;
+    let current: Promise<T> | undefined;
 
     return (func: () => Promise<T>): Promise<T> => {
         if (!current)
-            current = func().finally(() => current = undefined);
-        return current;
+            current = func().finally(() => current = undefined as unknown as Promise<T>);
+        return current!;
     }
 }
 

package/src/rpc-serializer.ts

@@ -109,8 +109,8 @@ export function createRpcDuplexSerializer(writable: {
         sendMessageFinish: (message) => sendMessageFinish(Buffer.from(JSON.stringify(message))),
     });
 
-    let header: Buffer;
-    let pending: Buffer;
+    let header: Buffer | undefined;
+    let pending: Buffer | undefined;
     let offset: number;
     let type: number;
 
@@ -183,7 +183,7 @@ export function createRpcDuplexSerializer(writable: {
 
 export function createDataChannelSerializer(dc: { send: (data: Buffer) => void }) {
     // Chunking and debouncing state
-    let pending: Buffer[];
+    let pending: Buffer[] | undefined;
     
     // Max packet size for data channels is 16KB
     const MAX_PACKET_SIZE = 16384;