@scrypted/server 0.144.1 → 0.144.3

package/src/plugin/plugin-console.ts

@@ -102,7 +102,7 @@ export function prepareConsoles(getConsoleName: () => string, systemManager: ()
         return ret;
     }
 
-    const mixinConsoles = new Map<string, Map<string, Console>>();
+    const mixinConsoles = new Map<ScryptedNativeId, Map<string, Console>>();
 
     function getMixinConsole(mixinId: string, nativeId: ScryptedNativeId) {
         let nativeIdConsoles = mixinConsoles.get(nativeId);
@@ -179,7 +179,7 @@ export function prepareConsoles(getConsoleName: () => string, systemManager: ()
 }
 
 export async function createConsoleServer(remoteStdout: Readable, remoteStderr: Readable, header: string) {
-    const outputs = new Map<string, StdPassThroughs>();
+    const outputs = new Map<ScryptedNativeId, StdPassThroughs>();
 
     const addHeader = (pts: StdPassThroughs) => {
         pts.buffers.push(Buffer.from(header));
@@ -199,6 +199,7 @@ export async function createConsoleServer(remoteStdout: Readable, remoteStderr:
                 buffers: [],
             }
             outputs.set(nativeId, pts);
+            const ptsRef = pts;
 
             let writeTimestamp = true;
             let timestampTimer: NodeJS.Timeout;
@@ -206,7 +207,7 @@ export async function createConsoleServer(remoteStdout: Readable, remoteStderr:
             stderr.on('close', () => clearTimeout(timestampTimer));
 
             const appendOutput = (data: Buffer) => {
-                const { buffers } = pts;
+                const { buffers } = ptsRef;
 
                 if (writeTimestamp) {
                     writeTimestamp = false;
@@ -220,7 +221,7 @@ export async function createConsoleServer(remoteStdout: Readable, remoteStderr:
                 // when we're over 4000 lines or whatever these buffer are,
                 // truncate down to 2000.
                 if (buffers.length > 4000)
-                    pts.buffers = buffers.slice(buffers.length - 2000);
+                    ptsRef.buffers = buffers.slice(buffers.length - 2000);
             };
 
             stdout.on('data', appendOutput);
@@ -279,15 +280,14 @@ export async function createConsoleServer(remoteStdout: Readable, remoteStderr:
     const { server: writeServer, port: writePort } = await clusterListenZero(async (socket) => {
         sockets.add(socket);
         const [data] = await once(socket, 'data');
-        let filter: string = data.toString();
-        const newline = filter.indexOf('\n');
+        let filterStr: string = data.toString();
+        const newline = filterStr.indexOf('\n');
         if (newline !== -1) {
-            socket.unshift(Buffer.from(filter.substring(newline + 1)));
+            socket.unshift(Buffer.from(filterStr.substring(newline + 1)));
         }
-        filter = filter.substring(0, newline);
+        filterStr = filterStr.substring(0, newline);
 
-        if (filter === 'undefined')
-            filter = undefined;
+        const filter = filterStr === 'undefined' ? undefined : filterStr;
 
         const { stdout } = getPassthroughs(filter);
         socket.pipe(stdout, { end: false });
@@ -306,9 +306,10 @@ export async function createConsoleServer(remoteStdout: Readable, remoteStderr:
     return {
         clear(nativeId: ScryptedNativeId) {
             const pt = outputs.get(nativeId);
-            if (pt)
+            if (pt) {
                 pt.buffers = [];
-            addHeader(pt);
+                addHeader(pt);
+            }
         },
         destroy() {
             for (const socket of sockets) {

package/src/plugin/plugin-device.ts

@@ -31,7 +31,7 @@ export const QueryInterfaceSymbol = Symbol("ScryptedPluginDeviceQueryInterface")
 export class PluginDeviceProxyHandler implements PrimitiveProxyHandler<any> {
     scrypted: ScryptedRuntime;
     id: string;
-    mixinTable: MixinTable[];
+    mixinTable!: MixinTable[];
     releasing = new Set<any>();
 
     static sortInterfaces(interfaces: string[]): string[] {
@@ -65,8 +65,8 @@ export class PluginDeviceProxyHandler implements PrimitiveProxyHandler<any> {
     async getMixinProviderId(id: string, mixinDevice: any) {
         if (this.releasing.has(mixinDevice))
             return true;
-        await this.scrypted.devices[id].handler.ensureProxy();
-        for (const mixin of this.scrypted.devices[id].handler.mixinTable) {
+        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) {
                 return mixin.mixinProviderId || id;
@@ -78,7 +78,7 @@ export class PluginDeviceProxyHandler implements PrimitiveProxyHandler<any> {
     // should this be async?
     invalidate() {
         const mixinTable = this.mixinTable;
-        this.mixinTable = undefined;
+        this.mixinTable = undefined!;
         for (const mixinEntry of (mixinTable || [])) {
             this.invalidateEntry(mixinEntry);
         }
@@ -102,7 +102,7 @@ export class PluginDeviceProxyHandler implements PrimitiveProxyHandler<any> {
         const mixins = getState(pluginDevice, ScryptedInterfaceProperty.mixins) || [];
         // iterate the new mixin table to find the last good mixin,
         // and resume creation from there.
-        let lastValidMixinId: string;
+        let lastValidMixinId: string | undefined;
         for (const mixinId of mixins) {
             if (!previousMixinIds.length) {
                 // reached of the previous mixin table, meaning
@@ -121,7 +121,7 @@ export class PluginDeviceProxyHandler implements PrimitiveProxyHandler<any> {
 
         // invalidate and remove everything up to lastValidMixinId
         while (true) {
-            const entry = this.mixinTable[0];
+            const entry = this.mixinTable[0]!;
             if (entry.mixinProviderId === lastValidMixinId)
                 break;
             this.mixinTable.shift();
@@ -149,7 +149,7 @@ export class PluginDeviceProxyHandler implements PrimitiveProxyHandler<any> {
                 try {
                     if (!pluginDevice.nativeId) {
                         const plugin = this.scrypted.plugins[pluginDevice.pluginId];
-                        proxy = await plugin.module;
+                        proxy = await plugin!.module;
                     }
                     else {
                         const providerId = getState(pluginDevice, ScryptedInterfaceProperty.providerId);
@@ -174,7 +174,7 @@ export class PluginDeviceProxyHandler implements PrimitiveProxyHandler<any> {
             })();
 
             this.mixinTable.unshift({
-                mixinProviderId: undefined,
+                mixinProviderId: undefined!,
                 entry,
             });
         }
@@ -202,7 +202,7 @@ export class PluginDeviceProxyHandler implements PrimitiveProxyHandler<any> {
             });
         }
 
-        return this.mixinTable[0].entry.then(entry => {
+        return this.mixinTable[0]!.entry.then(entry => {
             if (entry.error) {
                 console.error('Mixin device creation completed with error. Merging with previous interface set to retain device descriptor.');
                 const previousInterfaces = getState(pluginDevice, ScryptedInterfaceProperty.interfaces) as string[] || [];
@@ -219,7 +219,7 @@ export class PluginDeviceProxyHandler implements PrimitiveProxyHandler<any> {
 
     async rebuildEntry(pluginDevice: PluginDevice, mixinId: string, wrappedMixinTablePromise: Promise<MixinTable[]>): Promise<MixinTableEntry> {
         const wrappedMixinTable = await wrappedMixinTablePromise;
-        const previousEntry = wrappedMixinTable[0].entry;
+        const previousEntry = wrappedMixinTable[0]!.entry;
 
         const type = getDisplayType(pluginDevice);
 
@@ -255,7 +255,7 @@ export class PluginDeviceProxyHandler implements PrimitiveProxyHandler<any> {
                     passthrough: true,
                     allInterfaces,
                     interfaces: new Set<string>(),
-                    proxy: undefined as any,
+                    proxy: undefined!,
                 };
             }
 
@@ -269,7 +269,7 @@ export class PluginDeviceProxyHandler implements PrimitiveProxyHandler<any> {
             const wrappedProxy = new Proxy(wrappedHandler, wrappedHandler);
 
             const implementer = await (mixinProvider as any)[QueryInterfaceSymbol](ScryptedInterface.MixinProvider);
-            const host = this.scrypted.getPluginHostForDeviceId(implementer);
+            const host = this.scrypted.getPluginHostForDeviceId(implementer)!;
             const propertyInterfaces = getPropertyInterfaces(host.api.descriptors || ScryptedInterfaceDescriptors);
             // todo: remove this and pass the setter directly.
             const deviceState = await host.remote.createDeviceState(this.id,
@@ -304,8 +304,8 @@ export class PluginDeviceProxyHandler implements PrimitiveProxyHandler<any> {
                 passthrough: false,
                 allInterfaces,
                 interfaces: new Set<string>(),
-                error: e,
-                proxy: undefined as any,
+                error: e as Error,
+                proxy: undefined!,
             };
         }
     }
@@ -328,7 +328,7 @@ export class PluginDeviceProxyHandler implements PrimitiveProxyHandler<any> {
         if (p === RefreshSymbol || p === QueryInterfaceSymbol)
             return new Proxy(() => p, this);
 
-        if (ScryptedInterfaceDescriptors[ScryptedInterface.ScryptedDevice].methods.includes(prop))
+        if (ScryptedInterfaceDescriptors[ScryptedInterface.ScryptedDevice]!.methods.includes(prop))
             return (this as any)[p].bind(this);
 
         return new Proxy(() => prop, this);
@@ -382,7 +382,7 @@ export class PluginDeviceProxyHandler implements PrimitiveProxyHandler<any> {
         throw new PluginError(`${method} not implemented`)
     }
 
-    async findMethod(method: string) {
+    async findMethod(method: string): Promise<{ mixin: MixinTable, entry: MixinTableEntry } | undefined> {
         for (const mixin of this.mixinTable) {
             const entry = await mixin.entry;
             if (!entry.methods) {
@@ -402,9 +402,10 @@ export class PluginDeviceProxyHandler implements PrimitiveProxyHandler<any> {
                 return { mixin, entry };
             }
         }
+        return undefined;
     }
 
-    async findMixin(iface: string) {
+    async findMixin(iface: string): Promise<{ mixin: MixinTable, entry: MixinTableEntry } | undefined> {
         for (const mixin of this.mixinTable) {
             const entry = await mixin.entry;
             const { interfaces } = entry;
@@ -412,6 +413,7 @@ export class PluginDeviceProxyHandler implements PrimitiveProxyHandler<any> {
                 return { mixin, entry };
             }
         }
+        return undefined;
     }
 
     async apply(target: any, thisArg: any, argArray?: any): Promise<any> {
@@ -443,7 +445,7 @@ export class PluginDeviceProxyHandler implements PrimitiveProxyHandler<any> {
         if (method === 'getReadmeMarkdown') {
             const pluginDevice = this.scrypted.findPluginDeviceById(this.id);
             if (pluginDevice && !pluginDevice.nativeId) {
-                const plugin = this.scrypted.plugins[pluginDevice.pluginId];
+                const plugin = this.scrypted.plugins[pluginDevice.pluginId]!;
                 if (!plugin.packageJson.scrypted.interfaces.includes(ScryptedInterface.Readme)) {
                     const readmePath = path.join(plugin.unzippedPath, 'README.md');
                     if (fs.existsSync(readmePath)) {

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

@@ -12,9 +12,9 @@ import { checkProperty } from './plugin-state-check';
 
 export class PluginHostAPI extends PluginAPIManagedListeners implements PluginAPI {
     pluginId: string;
-    typesVersion: string;
-    descriptors: { [scryptedInterface: string]: ScryptedInterfaceDescriptor };
-    propertyInterfaces: ReturnType<typeof getPropertyInterfaces>;
+    typesVersion!: string;
+    descriptors!: { [scryptedInterface: string]: ScryptedInterfaceDescriptor };
+    propertyInterfaces!: ReturnType<typeof getPropertyInterfaces>;
 
     [RpcPeer.PROPERTY_PROXY_ONEWAY_METHODS] = [
         'onMixinEvent',
@@ -56,12 +56,16 @@ export class PluginHostAPI extends PluginAPIManagedListeners implements PluginAP
             const nativeId: string = nativeIdOrMixinDevice;
             // todo: deprecate this code path
             const mixinProvider = this.scrypted.findPluginDevice(this.pluginId, nativeId);
+            if (!mixinProvider)
+                throw new Error(`mixin provider not found for native id ${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, nativeId);
-            const tableEntry = this.scrypted.devices[device._id].handler.mixinTable.find(entry => entry.mixinProviderId === mixinProvider._id);
+            const tableEntry = this.scrypted.devices[device._id]?.handler?.mixinTable?.find((entry: any) => entry.mixinProviderId === mixinProvider._id);
+            if (!tableEntry)
+                throw new Error(`no mixin table entry found for ${mixinProvider._id} on ${id}`);
             const { interfaces } = await tableEntry.entry;
             if (!interfaces.has(eventInterface))
                 throw new Error(`${mixinProvider._id} does not mixin ${eventInterface} for ${id}`);
@@ -87,7 +91,7 @@ export class PluginHostAPI extends PluginAPIManagedListeners implements PluginAP
 
     async getLogger(nativeId: ScryptedNativeId): Promise<Logger> {
         const device = this.scrypted.findPluginDevice(this.pluginId, nativeId);
-        return this.scrypted.getDeviceLogger(device);
+        return this.scrypted.getDeviceLogger(device!)!;
     }
 
     async getComponent(id: string): Promise<any> {
@@ -103,7 +107,7 @@ export class PluginHostAPI extends PluginAPIManagedListeners implements PluginAP
         return this.scrypted.getComponent(id);
     }
 
-    setDeviceProperty(id: string, property: ScryptedInterfaceProperty, value: any): Promise<void> {
+    async setDeviceProperty(id: string, property: ScryptedInterfaceProperty, value: any): Promise<void> {
         switch (property) {
             case ScryptedInterfaceProperty.room:
             case ScryptedInterfaceProperty.type:
@@ -127,22 +131,32 @@ export class PluginHostAPI extends PluginAPIManagedListeners implements PluginAP
     }
 
     async setStorage(nativeId: ScryptedNativeId, storage: { [key: string]: string }) {
-        const device = this.scrypted.findPluginDevice(this.pluginId, nativeId)
+        const device = this.scrypted.findPluginDevice(this.pluginId, nativeId)!;
         device.storage = storage;
         this.scrypted.datastore.upsert(device);
     }
 
     async onDevicesChanged(deviceManifest: DeviceManifest) {
         const provider = this.scrypted.findPluginDevice(this.pluginId, deviceManifest.providerNativeId);
-        const existing = this.scrypted.findPluginDevices(this.pluginId).filter(p => p.state[ScryptedInterfaceProperty.providerId].value === provider._id);
-        const newIds = deviceManifest.devices.map(device => device.nativeId);
+        if (!provider)
+            throw new Error(`provider not found for plugin id ${this.pluginId} native id ${deviceManifest.providerNativeId}`);
+        const existing = this.scrypted.findPluginDevices(this.pluginId).filter(p => {
+            const state = p.state[ScryptedInterfaceProperty.providerId];
+            if (!state)
+                throw new Error(`providerId state not found for device ${p._id}`);
+            return state.value === provider._id;
+        });
+        if (!deviceManifest.devices)
+            throw new Error(`onDevicesChanged called without devices for provider ${deviceManifest.providerNativeId}`);
+        const devices = deviceManifest.devices;
+        const newIds = devices.map(device => device.nativeId);
         const toRemove = existing.filter(e => e.nativeId && !newIds.includes(e.nativeId));
 
         for (const remove of toRemove) {
             await this.scrypted.removeDevice(remove);
         }
 
-        for (const upsert of deviceManifest.devices) {
+        for (const upsert of devices) {
             upsert.providerNativeId = deviceManifest.providerNativeId;
             const id = await this.pluginHost.upsertDevice(upsert);
             this.scrypted.getDevice(id)?.probe().catch(() => { });
@@ -156,16 +170,16 @@ export class PluginHostAPI extends PluginAPIManagedListeners implements PluginAP
     }
 
     async onDeviceRemoved(nativeId: string) {
-        await this.scrypted.removeDevice(this.scrypted.findPluginDevice(this.pluginId, nativeId))
+        await this.scrypted.removeDevice(this.scrypted.findPluginDevice(this.pluginId, nativeId)!)
     }
 
     async onDeviceEvent(nativeId: any, eventInterface: any, eventData?: any) {
-        const plugin = this.scrypted.findPluginDevice(this.pluginId, nativeId);
+        const plugin = this.scrypted.findPluginDevice(this.pluginId, nativeId)!;
         this.scrypted.stateManager.notifyInterfaceEventFromMixin(plugin, eventInterface, eventData, plugin._id);
     }
 
     async getDeviceById<T>(id: string): Promise<T & ScryptedDevice> {
-        return this.scrypted.getDevice(id);
+        return this.scrypted.getDevice(id)!;
     }
     async listen(callback: (id: string, eventDetails: EventDetails, eventData: any) => void): Promise<EventListenerRegister> {
         return this.manageListener(this.scrypted.stateManager.listen(callback));

package/src/plugin/plugin-host.ts

@@ -36,8 +36,8 @@ export class UnsupportedRuntimeError extends Error {
 }
 
 export class PluginHost {
-    worker: RuntimeWorker;
-    peer: RpcPeer;
+    worker!: RuntimeWorker;
+    peer!: RpcPeer;
     pluginId: string;
     module: Promise<any>;
     scrypted: ScryptedRuntime;
@@ -50,7 +50,7 @@ export class PluginHost {
         perMessageDeflate: true,
         cors: (req, callback) => {
             const header = this.scrypted.getAccessControlAllowOrigin(req.headers);
-            callback(undefined, {
+            callback(undefined!, {
                 origin: header,
                 credentials: true,
             })
@@ -61,11 +61,11 @@ export class PluginHost {
     pluginName: string;
     packageJson: any;
     killed = false;
-    consoleServer: Promise<ConsoleServer>;
+    consoleServer!: Promise<ConsoleServer>;
     zipHash: string;
     zipFile: string;
     unzippedPath: string;
-    clusterWorkerId: Promise<string>;
+    clusterWorkerId!: Promise<string>;
 
     kill() {
         this.killed = true;
@@ -103,10 +103,11 @@ export class PluginHost {
             if (!needInvalidate) {
                 // may also need to invalidate if the the plugin did not previously return a device
                 // because it had not yet completed the discovery process.
-                const device = this.scrypted.devices[pi._id];
+                const device = this.scrypted.devices[pi._id]!;
                 try {
-                    if (device.handler?.mixinTable)
-                        needInvalidate = !(await device.handler.mixinTable?.[device.handler.mixinTable.length - 1].entry).proxy;
+                    const handler = device.handler;
+                    if (handler?.mixinTable)
+                        needInvalidate = !(await handler.mixinTable?.[handler.mixinTable.length - 1]!.entry).proxy;
                 }
                 catch (e) {
                     // device retrieval had previously failed, fetch again.
@@ -125,16 +126,16 @@ export class PluginHost {
         this.pluginName = plugin.packageJson?.name;
         this.packageJson = plugin.packageJson;
 
-        const pluginDeviceId = scrypted.findPluginDevice(this.pluginId)._id;
-        const logger = scrypted.getDeviceLogger(scrypted.findPluginDevice(this.pluginId));
+        const pluginDeviceId = scrypted.findPluginDevice(this.pluginId)!._id;
+        const logger = scrypted.getDeviceLogger(scrypted.findPluginDevice(this.pluginId)!)!;
 
         const volume = getScryptedVolume();
         const pluginVolume = ensurePluginVolume(this.pluginId);
 
         {
-            const zipBuffer = Buffer.from(plugin.zip, 'base64');
+            const zipBuffer = Buffer.from(plugin.zip!, 'base64');
             // allow garbage collection of the base 64 contents
-            plugin = undefined;
+            (plugin as any) = undefined;
             const hash = crypto.createHash('md5').update(zipBuffer).digest().toString('hex');
             this.zipHash = hash;
 
@@ -146,7 +147,7 @@ export class PluginHost {
         const peerPromise = this.startPluginHost(logger, {
             SCRYPTED_VOLUME: volume,
             SCRYPTED_PLUGIN_VOLUME: pluginVolume,
-        }, pluginDebug);
+        }, pluginDebug!);
 
         this.io.on('connection', async (socket) => {
             try {
@@ -157,8 +158,8 @@ export class PluginHost {
                 } = (socket.request as any).scrypted;
 
                 try {
-                    if (socket.request.url.indexOf('/engine.io/api') !== -1) {
-                        if (socket.request.url.indexOf('/public') !== -1) {
+                    if (socket.request.url!.indexOf('/engine.io/api') !== -1) {
+                        if (socket.request.url!.indexOf('/public') !== -1) {
                             socket.close();
                             return;
                         }
@@ -205,13 +206,13 @@ export class PluginHost {
             ? new MediaManagerHostImpl(pluginDeviceId, () => scrypted.stateManager.getSystemState(), console, id => scrypted.getDevice(id))
             : undefined;
 
-        this.api = new PluginHostAPI(scrypted, this.pluginId, this, mediaManager);
+        this.api = new PluginHostAPI(scrypted, this.pluginId, this, mediaManager!);
 
         logger.log('i', `loading ${this.pluginName}`);
         logger.log('i', 'pid ' + this.worker?.pid);
 
-        const remotePromise = this.prepareRemote(peerPromise, logger, pluginDebug);
-        const init = this.initializeRemote(remotePromise, logger, pluginDebug);
+        const remotePromise = this.prepareRemote(peerPromise, logger, pluginDebug!);
+        const init = this.initializeRemote(remotePromise, logger, pluginDebug!);
 
         init.catch(e => {
             console.error('plugin failed to load', e);
@@ -280,7 +281,7 @@ export class PluginHost {
         }
         catch (e) {
             logger.log('e', 'plugin failed to start ' + e);
-            throw new RPCResultError(this.peer, 'cluster plugin start failed', e);
+            throw new RPCResultError(this.peer, 'cluster plugin start failed', e as Error | undefined);
         }
 
         const startupTime = Date.now();
@@ -333,8 +334,8 @@ export class PluginHost {
         let { runtime } = this.packageJson.scrypted;
         runtime ||= 'node';
 
-        const pluginDevice = this.scrypted.findPluginDevice(this.pluginId);
-        const customRuntime = pluginDevice.state.interfaces.value.includes(ScryptedInterface.ScryptedPluginRuntime);
+        const pluginDevice = this.scrypted.findPluginDevice(this.pluginId)!;
+        const customRuntime = pluginDevice.state.interfaces!.value.includes(ScryptedInterface.ScryptedPluginRuntime);
         if (customRuntime) {
             runtime = 'custom';
         }
@@ -375,7 +376,7 @@ export class PluginHost {
 
             this.worker.stdout.on('data', data => console.log(data.toString()));
             this.worker.stderr.on('data', data => console.error(data.toString()));
-            this.clusterWorkerId = Promise.resolve(undefined);
+            this.clusterWorkerId = Promise.resolve(undefined!);
         }
         else {
             const scrypted: ClusterForkOptions = JSON.parse(JSON.stringify(this.packageJson.scrypted));
@@ -414,7 +415,7 @@ export class PluginHost {
                 peer.killedSafe.finally(() => originalPeer.kill());
             }).catch(() => { });
 
-            this.clusterWorkerId = clusterWorkerId;
+            this.clusterWorkerId = clusterWorkerId as Promise<string>;
             clusterWorkerId.then(clusterWorkerId => {
                 console.log('cluster worker id', clusterWorkerId);
             }).catch(() => {
@@ -483,7 +484,7 @@ export class PluginHost {
                 serializer.sendMessage(message, reject, serializationContext);
             }
             catch (e) {
-                reject?.(e);
+                reject?.(e as Error);
             }
         });
         rpcPeer.tags.acl = accessControls;
@@ -500,6 +501,6 @@ export class PluginHost {
         socket.on('close', kill);
         socket.on('error', kill);
 
-        return setupPluginRemote(rpcPeer, api, null, { serverVersion }, () => this.scrypted.stateManager.getSystemState());
+        return setupPluginRemote(rpcPeer, api, null!, { serverVersion }, () => this.scrypted.stateManager.getSystemState());
     }
 }

package/src/plugin/plugin-http.ts

@@ -6,7 +6,7 @@ import WebSocket, { Server as WebSocketServer } from "ws";
 
 export function isConnectionUpgrade(headers: IncomingHttpHeaders) {
     // connection:'keep-alive, Upgrade'
-    return headers.connection?.toLowerCase().includes('upgrade');
+    return headers.connection?.toLowerCase().includes('upgrade') ?? false;
 }
 
 export abstract class PluginHttp<T> {
@@ -38,7 +38,7 @@ export abstract class PluginHttp<T> {
 
     abstract handleEngineIOEndpoint(req: Request, res: ServerResponse, endpointRequest: HttpRequest, pluginData: T): void;
     abstract handleRequestEndpoint(req: Request, res: Response, endpointRequest: HttpRequest, pluginData: T): void;
-    abstract getEndpointPluginData(req: Request, endpoint: string, isUpgrade: boolean, isEngineIOEndpoint: boolean): Promise<T>;
+    abstract getEndpointPluginData(req: Request, endpoint: string, isUpgrade: boolean, isEngineIOEndpoint: boolean): Promise<T | undefined>;
     abstract handleWebSocket(endpoint: string, httpRequest: HttpRequest, ws: WebSocket, pluginData: T): Promise<void>;
     abstract checkUpgrade(req: Request, res: Response, pluginData: T): void;
 
@@ -49,7 +49,7 @@ export abstract class PluginHttp<T> {
 
         const end = (code: number, message: string) => {
             if (isUpgrade) {
-                const socket = res.socket;
+                const socket = res.socket!;
                 socket.write(`HTTP/1.1 ${code} ${message}\r\n` +
                     '\r\n');
                 socket.destroy();
@@ -65,6 +65,10 @@ export abstract class PluginHttp<T> {
         let endpoint = pkg;
         if (owner)
             endpoint = `@${owner}/${endpoint}`;
+        if (!endpoint) {
+            end(400, 'Bad Request');
+            return;
+        }
         const pluginData = await this.getEndpointPluginData(req, endpoint, isUpgrade, isEngineIOEndpoint);
 
         if (!pluginData) {
@@ -125,7 +129,7 @@ export abstract class PluginHttp<T> {
             catch (e) {
                 res.header('Content-Type', 'text/plain');
                 res.status(500);
-                res.send(e.toString());
+                res.send((e as Error).toString());
                 console.error(e);
             }
         }
@@ -136,7 +140,7 @@ export abstract class PluginHttp<T> {
             catch (e) {
                 res.header('Content-Type', 'text/plain');
                 res.status(500);
-                res.send(e.toString());
+                res.send((e as Error).toString());
                 console.error(e);
             }
         }

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

@@ -8,7 +8,7 @@ import { PluginRemote, PluginRemoteLoadZipOptions, PluginZipAPI } from './plugin
  * execution order of state reporting may fail.
  */
  export class LazyRemote implements PluginRemote {
-    remote: PluginRemote;
+    remote!: PluginRemote;
 
     constructor(public remotePromise: Promise<PluginRemote>, public remoteReadyPromise: Promise<PluginRemote>) {
         this.remoteReadyPromise = (async () => {

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

@@ -74,7 +74,7 @@ export function createWebSocketClass(__websocketConnect: WebSocketConnect): any
 
     class WebSocket extends WebSocketEventTarget {
         _url: string;
-        _protocols: string[];
+        _protocols: string[] | undefined;
         readyState: number;
 
         constructor(public connection: WebSocketConnection, protocols?: string[]) {