@scrypted/server 0.144.0 → 0.144.2

package/src/scrypted-server-main.ts

@@ -62,12 +62,12 @@ installSourceMapSupport({
     environment: 'node',
 });
 
-let workerInspectPort: number = undefined;
-let workerInspectAddress: string = undefined;
+let workerInspectPort: number | undefined = undefined;
+let workerInspectAddress: string | undefined = undefined;
 
 async function doconnect(): Promise<net.Socket> {
     return new Promise((resolve, reject) => {
-        const target = net.connect(workerInspectPort, workerInspectAddress);
+        const target = net.connect(workerInspectPort!, workerInspectAddress!);
         target.once('error', reject)
         target.once('connect', () => resolve(target))
     })
@@ -123,7 +123,8 @@ app.use(bodyParser.json());
 app.use(bodyParser.raw({ type: 'application/*', limit: 100000000 }) as any);
 
 function checkListenSet(socket: net.Socket) {
-    return listenSet.check(socket.localAddress, net.isIPv4(socket.localAddress) ? 'ipv4' : 'ipv6');
+    const localAddress = socket.localAddress!;
+    return listenSet.check(localAddress, net.isIPv4(localAddress) ? 'ipv4' : 'ipv6');
 }
 
 if (listenSet.rules.length) {
@@ -236,7 +237,7 @@ async function start(mainFilename: string, options?: {
         };
     }
 
-    const getDefaultAuthentication = (req: Request) => {
+    const getDefaultAuthentication = (req: Request): ScryptedUser | undefined => {
         const defaultAuthentication = !req.query.disableDefaultAuthentication && process.env.SCRYPTED_DEFAULT_AUTHENTICATION;
         if (defaultAuthentication) {
             const referer = req.headers.referer;
@@ -244,7 +245,7 @@ async function start(mainFilename: string, options?: {
                 try {
                     const u = new URL(referer);
                     if (u.searchParams.has('disableDefaultAuthentication'))
-                        return;
+                        return undefined;
                 }
                 catch (e) {
                     // no/invalid referer, allow the default auth
@@ -252,6 +253,7 @@ async function start(mainFilename: string, options?: {
             }
             return scrypted.usersService.users.get(defaultAuthentication);
         }
+        return undefined;
     }
 
     app.use(async (req, res, next) => {
@@ -358,7 +360,7 @@ async function start(mainFilename: string, options?: {
         if (req.protocol === 'https' && req.headers.authorization && req.headers.authorization.toLowerCase()?.indexOf('basic') !== -1) {
             const basicChecker = basicAuth.check(async (req) => {
                 try {
-                    const user = await db.tryGet(ScryptedUser, req.user);
+                    const user = (await db.tryGet(ScryptedUser, req.user))!;
                     res.locals.username = user._id;
                     res.locals.aclId = user.aclId;
                 }
@@ -435,7 +437,7 @@ async function start(mainFilename: string, options?: {
         if (owner)
             endpoint = `@${owner}/${endpoint}`;
         try {
-            const json = await getNpmPackageInfo(endpoint);
+            const json = await getNpmPackageInfo(endpoint!);
             res.send(json);
         }
         catch (e) {
@@ -450,9 +452,9 @@ async function start(mainFilename: string, options?: {
         if (owner)
             endpoint = `@${owner}/${endpoint}`;
         try {
-            const plugin = await scrypted.installNpm(endpoint, tag);
+            const plugin = (await scrypted.installNpm(endpoint!, tag))!;
             res.send({
-                id: scrypted.findPluginDevice(plugin.pluginId)._id,
+                id: scrypted.findPluginDevice(plugin.pluginId)!._id,
             });
         }
         catch (e) {
@@ -527,7 +529,7 @@ async function start(mainFilename: string, options?: {
                 }
             }
         }
-        catch (e) {
+        catch (e: any) {
             res.header('Content-Type', 'text/plain');
             res.status(500);
             res.send(e.toString());
@@ -544,9 +546,9 @@ async function start(mainFilename: string, options?: {
         return req.secure ? 'login_user_token' : 'login_user_token_insecure';
     };
 
-    const checkValidUserToken = (token: string) => {
+    const checkValidUserToken = (token: string): UserToken | undefined => {
         if (!token)
-            return;
+            return undefined;
         try {
             const userToken = UserToken.validateToken(token);
             if (scrypted.usersService.users.has(userToken.username))
@@ -555,6 +557,7 @@ async function start(mainFilename: string, options?: {
         catch (e) {
             // console.warn('invalid token', e.message);
         }
+        return undefined;
     }
 
     const getSignedLoginUserToken = (req: Request<any>) => {
@@ -751,7 +754,7 @@ async function start(mainFilename: string, options?: {
                 hostname,
             })
         }
-        catch (e) {
+        catch (e: any) {
             // env based anon user login
             const defaultAuthentication = getDefaultAuthentication(req);
             if (defaultAuthentication) {

package/src/server-settings.ts

@@ -1,10 +1,10 @@
 import { getUsableNetworkAddresses } from './ip';
 
-export const SCRYPTED_INSECURE_PORT = parseInt(process.env.SCRYPTED_INSECURE_PORT) || 11080;
-export const SCRYPTED_SECURE_PORT = parseInt(process.env.SCRYPTED_SECURE_PORT) || 10443;
-export const SCRYPTED_DEBUG_PORT = parseInt(process.env.SCRYPTED_DEBUG_PORT) || 10081;
-export const SCRYPTED_CLUSTER_WORKERS = parseInt(process.env.SCRYPTED_CLUSTER_WORKERS) || 32;
+export const SCRYPTED_INSECURE_PORT = parseInt(process.env.SCRYPTED_INSECURE_PORT ?? '') || 11080;
+export const SCRYPTED_SECURE_PORT = parseInt(process.env.SCRYPTED_SECURE_PORT ?? '') || 10443;
+export const SCRYPTED_DEBUG_PORT = parseInt(process.env.SCRYPTED_DEBUG_PORT ?? '') || 10081;
+export const SCRYPTED_CLUSTER_WORKERS = parseInt(process.env.SCRYPTED_CLUSTER_WORKERS ?? '') || 32;
 
-export function getIpAddress(): string {
+export function getIpAddress(): string | undefined {
     return getUsableNetworkAddresses()[0];
 }

package/src/services/addresses.ts

@@ -25,16 +25,16 @@ export class AddressSettings {
         await this.scrypted.datastore.upsert(localAddresses);
     }
 
-    async getLocalAddresses(raw?: boolean): Promise<string[]> {
+    async getLocalAddresses(raw?: boolean): Promise<string[] | undefined> {
         const settings = await this.scrypted.datastore.tryGet(Settings, 'localAddresses');
 
         if (!settings?.value?.[0])
-            return;
+            return undefined;
 
         const ret: string[] = [];
         const networkInterfaces = os.networkInterfaces();
         const allAddresses = new Set(Object.values(networkInterfaces)
-            .flat().map(ni => ni.address));
+            .flat().filter((ni): ni is os.NetworkInterfaceInfo => ni !== undefined).map(ni => ni.address));
         for (const addressOrInterface of settings.value) {
             const nif = networkInterfaces[addressOrInterface];
             if (raw) {

package/src/services/alerts.ts

@@ -14,10 +14,10 @@ export class Alerts {
     }
     async removeAlert(alert: ScryptedAlert) {
         await this.scrypted.datastore.removeId(ScryptedAlert, alert._id);
-        this.scrypted.stateManager.notifyInterfaceEvent(null, 'Logger' as any, undefined);
+        this.scrypted.stateManager.notifyInterfaceEvent(undefined, 'Logger' as any, undefined);
     }
     async clearAlerts() {
         await this.scrypted.datastore.removeAll(ScryptedAlert);
-        this.scrypted.stateManager.notifyInterfaceEvent(null, 'Logger' as any, undefined);
+        this.scrypted.stateManager.notifyInterfaceEvent(undefined, 'Logger' as any, undefined);
     }
 }

package/src/services/cluster-fork.ts

@@ -9,7 +9,7 @@ import { removeIPv4EmbeddedIPv6 } from "../ip";
 
 class WrappedForkResult implements ClusterForkResultInterface {
     [RpcPeer.PROPERTY_PROXY_PROPERTIES] = {
-        clusterWorkerId: undefined as string,
+        clusterWorkerId: undefined as unknown as string,
     };
 
     constructor(public clusterWorkerId: string, public forkResult: Promise<ClusterForkResultInterface>) {
@@ -48,7 +48,7 @@ export class ClusterForkService {
                 return matches && (!options.clusterWorkerId || worker.id === options.clusterWorkerId);
             });
 
-        let worker: RunningClusterWorker;
+        let worker: RunningClusterWorker | undefined;
 
         // try to keep fork id affinity to single worker if present. this presents the opportunity for
         // IPC.
@@ -73,7 +73,7 @@ export class ClusterForkService {
                 // sort by number of forks, to distribute load.
                 .sort((a, b) => a.worker.forks.size * a.worker.weight - b.worker.forks.size * b.worker.weight);
 
-            worker = matchingWorkers[0]?.worker;
+            worker = matchingWorkers[0]?.worker!;
         }
 
         console.log('forking to worker', worker.id, options);
@@ -81,7 +81,7 @@ export class ClusterForkService {
         worker.fork ||= worker.peer.getParam('fork');
         const fork: ClusterForkParam = await worker.fork;
 
-        const forkResultPromise = fork(options.runtime, runtimeWorkerOptions, peerLiveness, getZip);
+        const forkResultPromise = fork(options.runtime!, runtimeWorkerOptions, peerLiveness, getZip);
         options.id ||= this.runtime.findPluginDevice(runtimeWorkerOptions.packageJson.name)?._id;
 
         // the server is responsible for killing the forked process when the requestor is killed.
@@ -117,12 +117,12 @@ export class ClusterForkService {
     }
 
     async getParam(clusterWorkerId: string, key: string) {
-        const clusterWorker = this.runtime.clusterWorkers.get(clusterWorkerId);
+        const clusterWorker = this.runtime.clusterWorkers.get(clusterWorkerId)!;
         return clusterWorker.peer.getParam(key);
     }
 
     async getFsPromises(clusterWorkerId: string) {
-        const clusterWorker = this.runtime.clusterWorkers.get(clusterWorkerId);
+        const clusterWorker = this.runtime.clusterWorkers.get(clusterWorkerId)!;
         if (clusterWorker.mode === 'server') {
             return {
                 [RpcPeer.PROPERTY_JSON_COPY_SERIALIZE_CHILDREN]: true,
@@ -133,21 +133,21 @@ export class ClusterForkService {
     }
 
     async getEnvControl(clusterWorkerId: string) {
-        const clusterWorker = this.runtime.clusterWorkers.get(clusterWorkerId);
+        const clusterWorker = this.runtime.clusterWorkers.get(clusterWorkerId)!;
         if (clusterWorker.mode === 'server')
             return this.runtime.envControl;
         return clusterWorker.peer.getParam('env-control');
     }
 
     async getServiceControl(clusterWorkerId: string) {
-        const clusterWorker = this.runtime.clusterWorkers.get(clusterWorkerId);
+        const clusterWorker = this.runtime.clusterWorkers.get(clusterWorkerId)!;
         if (clusterWorker.mode === 'server')
             return this.runtime.serviceControl;
         return clusterWorker.peer.getParam('service-control');
     }
 
     async getInfo(clusterWorkerId: string) {
-        const clusterWorker = this.runtime.clusterWorkers.get(clusterWorkerId);
+        const clusterWorker = this.runtime.clusterWorkers.get(clusterWorkerId)!;
         if (clusterWorker.mode === 'server')
             return this.runtime.info;
         return clusterWorker.peer.getParam('info');

package/src/services/plugin.ts

@@ -25,7 +25,7 @@ export class PluginComponent {
     }
 
     async renameDeviceId(id: string, newId: string) {
-        const pluginDevice = this.scrypted.findPluginDeviceById(id);
+        const pluginDevice = this.scrypted.findPluginDeviceById(id)!;
         await this.kill(pluginDevice.pluginId);
         // wait for everything to settle.
         await sleep(2000);
@@ -45,7 +45,7 @@ export class PluginComponent {
     }
 
     async setStorage(id: string, storage: { [key: string]: string }) {
-        const pluginDevice = this.scrypted.findPluginDeviceById(id);
+        const pluginDevice = this.scrypted.findPluginDeviceById(id)!;
         pluginDevice.storage = storage;
         await this.scrypted.datastore.upsert(pluginDevice);
         const host = this.scrypted.getPluginHostForDeviceId(id);
@@ -58,7 +58,7 @@ export class PluginComponent {
             console.warn(message);
             throw new Error(message);
         }
-        const pluginDevice = this.scrypted.findPluginDeviceById(id);
+        const pluginDevice = this.scrypted.findPluginDeviceById(id)!;
         this.scrypted.stateManager.setPluginDeviceState(pluginDevice, ScryptedInterfaceProperty.mixins, [...new Set(mixins)]);
         this.scrypted.stateManager.updateDescriptor(pluginDevice);
         await this.scrypted.datastore.upsert(pluginDevice);
@@ -75,7 +75,7 @@ export class PluginComponent {
     }
     async reload(pluginId: string) {
         const plugin = await this.scrypted.datastore.tryGet(Plugin, pluginId);
-        await this.scrypted.runPlugin(plugin);
+        await this.scrypted.runPlugin(plugin!);
     }
     async kill(pluginId: string) {
         return this.scrypted.plugins[pluginId]?.kill();
@@ -98,7 +98,7 @@ export class PluginComponent {
     }
     async getPluginInfo(pluginId: string) {
         const packageJson = await this.getPackageJson(pluginId);
-        const host = this.scrypted.plugins[pluginId];
+        const host = this.scrypted.plugins[pluginId]!;
         let rpcObjects = 0;
         let pendingResults = 0;
         const pendingResultMethods: {
@@ -108,7 +108,7 @@ export class PluginComponent {
             rpcObjects = host.peer.localProxied.size + Object.keys(host.peer.remoteWeakProxies).length;
             pendingResults = Object.keys(host.peer.pendingResults).length;
             for (const deferred of Object.values(host.peer.pendingResults)) {
-                pendingResultMethods[deferred.method] = (pendingResultMethods[deferred.method] || 0) + 1;
+                pendingResultMethods[deferred.method!] = (pendingResultMethods[deferred.method!] || 0) + 1;
             }
         }
         return {
@@ -118,7 +118,7 @@ export class PluginComponent {
             packageJson,
             pendingResults,
             pendingResultCounts: pendingResultMethods,
-            id: this.scrypted.findPluginDevice(pluginId)._id,
+            id: this.scrypted.findPluginDevice(pluginId)!._id,
         }
     }
 
@@ -148,7 +148,7 @@ export class PluginComponent {
                 const version = registry['dist-tags'].latest;
                 if (registry?.versions?.[version]?.deprecated) {
                     console.log('plugin deprecated, uninstalling:', plugin);
-                    await this.scrypted.removeDevice(this.scrypted.findPluginDevice(plugin));
+                    await this.scrypted.removeDevice(this.scrypted.findPluginDevice(plugin)!);
                     continue;
                 }
                 if (!semver.gt(version, host.packageJson.version)) {
@@ -167,21 +167,21 @@ export class PluginComponent {
     }
 
     async clearConsole(id: string) {
-        const pluginDevice = this.scrypted.findPluginDeviceById(id);
-        const consoleServer = await this.scrypted.plugins[pluginDevice.pluginId].consoleServer;
+        const pluginDevice = this.scrypted.findPluginDeviceById(id)!;
+        const consoleServer = await this.scrypted.plugins[pluginDevice.pluginId]!.consoleServer;
         consoleServer.clear(pluginDevice.nativeId);
     }
 
     async getRemoteServicePort(pluginId: string, name: string, ...args: any[]): Promise<[number, string]> {
         if (name === 'console') {
-            const consoleServer = await this.scrypted.plugins[pluginId].consoleServer;
-            return [consoleServer.readPort, process.env.SCRYPTED_CLUSTER_ADDRESS];
+            const consoleServer = await this.scrypted.plugins[pluginId]!.consoleServer;
+            return [consoleServer.readPort, process.env.SCRYPTED_CLUSTER_ADDRESS!];
         }
         if (name === 'console-writer') {
-            const consoleServer = await this.scrypted.plugins[pluginId].consoleServer;
-            return [consoleServer.writePort, process.env.SCRYPTED_CLUSTER_ADDRESS];
+            const consoleServer = await this.scrypted.plugins[pluginId]!.consoleServer;
+            return [consoleServer.writePort, process.env.SCRYPTED_CLUSTER_ADDRESS!];
         }
 
-        return this.scrypted.plugins[pluginId].remote.getServicePort(name, ...args);
+        return this.scrypted.plugins[pluginId]!.remote.getServicePort(name, ...args);
     }
 }

package/src/services/service-control.ts

@@ -20,7 +20,7 @@ export class ServiceControl {
             await httpFetch({
                 url: webhookUpdate,
                 headers: {
-                    Authorization: webhookUpdateAuthorization,
+                    Authorization: webhookUpdateAuthorization!,
                 }
             });
         }

package/src/services/users.ts

@@ -5,9 +5,9 @@ import crypto from 'crypto';
 
 export class UsersService {
     users = new Map<string, ScryptedUser>();
-    usersPromise: Promise<ScryptedUser[]>;
+    usersPromise!: Promise<ScryptedUser[]>;
 
-    static async addUserToDatabase(db: WrappedLevel, username: string, password: string, aclId: string) {
+    static async addUserToDatabase(db: WrappedLevel, username: string, password: string, aclId?: string) {
         const user = new ScryptedUser();
         user._id = username;
         user.aclId = aclId;
@@ -63,7 +63,7 @@ export class UsersService {
         this.updateUsersPromise();
     }
 
-    async addUserInternal(username: string, password: string, aclId: string) {
+    async addUserInternal(username: string, password: string, aclId?: string) {
         await this.ensureUsersPromise();
 
         const user = await UsersService.addUserToDatabase(this.scrypted.datastore, username, password, aclId);

package/src/state.ts

@@ -34,7 +34,7 @@ export class ScryptedStateManager extends EventRegistry {
         this.scrypted = scrypted;
     }
 
-    async getImplementerId(pluginDevice: PluginDevice, eventInterface: ScryptedInterface | string) {
+    async getImplementerId(pluginDevice: PluginDevice, eventInterface: ScryptedInterface | string | undefined) {
         if (!eventInterface)
             throw new Error(`ScryptedInterface is required`);
 
@@ -62,7 +62,7 @@ export class ScryptedStateManager extends EventRegistry {
                 });
 
                 this.notifyEventDetails(pluginDevice._id, {
-                    eventId: undefined,
+                    eventId: undefined!,
                     eventInterface,
                     eventTime: Date.now(),
                     mixinId,
@@ -75,8 +75,7 @@ export class ScryptedStateManager extends EventRegistry {
         this.notify(pluginDevice?._id, Date.now(), eventInterface, undefined, value);
     }
 
-    async setPluginDeviceStateFromMixin(pluginDevice: PluginDevice, property: string, value: any, eventInterface: ScryptedInterface, mixinId: string) {
-        // TODO: crashing here. send descriptor from python too.
+    async setPluginDeviceStateFromMixin(pluginDevice: PluginDevice, property: string, value: any, eventInterface: string | undefined, mixinId: string) {
         eventInterface = eventInterface || propertyInterfaces[property];
 
         const implementerId = await this.getImplementerId(pluginDevice, eventInterface);
@@ -85,9 +84,9 @@ export class ScryptedStateManager extends EventRegistry {
                 event: eventInterface,
                 mixinId,
             });
-            this.scrypted.getDeviceLogger(pluginDevice).log('i', `${property}: ${value} (mixin)`);
+            this.scrypted.getDeviceLogger(pluginDevice)!.log('i', `${property}: ${value} (mixin)`);
             this.notifyEventDetails(pluginDevice._id, {
-                eventId: undefined,
+                eventId: undefined!,
                 eventInterface,
                 eventTime: Date.now(),
                 mixinId,
@@ -99,7 +98,7 @@ export class ScryptedStateManager extends EventRegistry {
         return this.setPluginDeviceState(pluginDevice, property, value, eventInterface);
     }
 
-    setPluginDeviceState(device: PluginDevice, property: string, value: any, eventInterface?: ScryptedInterface) {
+    setPluginDeviceState(device: PluginDevice, property: string, value: any, eventInterface?: string) {
         eventInterface = eventInterface || propertyInterfaces[property];
         if (!eventInterface)
             throw new Error(`eventInterface must be provided`);
@@ -108,7 +107,7 @@ export class ScryptedStateManager extends EventRegistry {
 
         if (eventInterface !== ScryptedInterface.ScryptedDevice) {
             if (this.notify(device?._id, Date.now(), eventInterface, property, value, { changed }) && device) {
-                this.scrypted.getDeviceLogger(device).log('i', `${property}: ${value}`);
+                this.scrypted.getDeviceLogger(device)!.log('i', `${property}: ${value}`);
             }
         }
 
@@ -126,7 +125,7 @@ export class ScryptedStateManager extends EventRegistry {
         this.notify(undefined, undefined, ScryptedInterface.ScryptedDevice, ScryptedInterfaceProperty.id, id, { changed: true });
     }
 
-    notifyInterfaceEvent(device: PluginDevice, eventInterface: ScryptedInterface | string, value: any, mixinId?: string) {
+    notifyInterfaceEvent(device: PluginDevice | undefined, eventInterface: ScryptedInterface | string, value: any, mixinId?: string) {
         this.notify(device?._id, Date.now(), eventInterface, undefined, value, {
             changed: true,
             mixinId,
@@ -149,7 +148,7 @@ export class ScryptedStateManager extends EventRegistry {
         return systemState;
     }
 
-    listenDevice(id: string, options: string | EventListenerOptions, callback: (eventDetails: EventDetails, eventData: any) => void): EventListenerRegister {
+    override listenDevice(id: string, options: string | EventListenerOptions, callback: (eventDetails: EventDetails, eventData: any) => void): EventListenerRegister {
         let { denoise, event, watch } = (options || {}) as EventListenerOptions;
         if (!event && typeof options === 'string')
             event = options as string;
@@ -163,7 +162,7 @@ export class ScryptedStateManager extends EventRegistry {
                 while (polling && !watch) {
                     // listen is not user initiated. an explicit refresh call would be.
                     try {
-                        await this.refresh(id, event, false)
+                        await this.refresh(id, event!, false)
                     }
                     catch (e) {
                         console.error('refresh ended by exception', e);
@@ -174,10 +173,11 @@ export class ScryptedStateManager extends EventRegistry {
         }
 
         let lastData: any = undefined;
-        let cb = (eventDetails: EventDetails, eventData: any) => {
+        let callbackWrapper: typeof callback | undefined = callback;
+        let cb: typeof callback | undefined = (eventDetails, eventData) => {
             if (denoise && lastData === eventData)
                 return;
-            callback?.(eventDetails, eventData);
+            callbackWrapper?.(eventDetails, eventData);
         };
 
         const wrappedRegister = super.listenDevice(id, options, cb);
@@ -185,7 +185,7 @@ export class ScryptedStateManager extends EventRegistry {
         return new EventListenerRegisterImpl(() => {
             wrappedRegister.removeListener();
             cb = undefined;
-            callback = undefined;
+            callbackWrapper = undefined;
             polling = false;
         });
     }
@@ -203,7 +203,7 @@ export class ScryptedStateManager extends EventRegistry {
         }
 
         const device: any = this.scrypted.getDevice<Refresh>(id);
-        const logger = this.scrypted.getDeviceLogger(this.scrypted.findPluginDeviceById(id));
+        const logger = this.scrypted.getDeviceLogger(this.scrypted.findPluginDeviceById(id))!;
 
         if (!device.interfaces.includes(ScryptedInterface.Refresh))
             throw new Error('device does not implement refresh');
@@ -221,13 +221,13 @@ export class ScryptedStateManager extends EventRegistry {
                 await sleep(timeout);
                 try {
                     const rt = this.refreshThrottles[id];
-                    if (!rt.tailRefresh)
+                    if (!rt!.tailRefresh)
                         return;
-                    await device[RefreshSymbol](rt.refreshInterface, rt.userInitiated);
+                    await device[RefreshSymbol](rt!.refreshInterface, rt!.userInitiated);
                 }
                 catch (e) {
                     logger.log('e', 'Refresh failed');
-                    logger.log('e', e.toString());
+                    logger.log('e', (e as Error).toString());
                 }
                 finally {
                     delete this.refreshThrottles[id];
@@ -257,7 +257,7 @@ export class ScryptedStateManager extends EventRegistry {
 
 interface RefreshThrottle {
     promise: Promise<void>;
-    refreshInterface: string;
+    refreshInterface: string | undefined;
     userInitiated: boolean;
     tailRefresh: boolean;
 }
@@ -266,10 +266,10 @@ function isSameValue(value1: any, value2: any) {
     return value1 === value2 || JSON.stringify(value1) === JSON.stringify(value2);
 }
 
-export function setState(pluginDevice: PluginDevice, property: string, value: any): boolean {
+export function setState(pluginDevice: PluginDevice, property: string, value: any): boolean | undefined {
     // device may have been deleted.
     if (!pluginDevice.state)
-        return;
+        return undefined;
     if (!pluginDevice.state[property])
         pluginDevice.state[property] = {};
     const state = pluginDevice.state[property];

package/src/threading.ts

@@ -36,15 +36,15 @@ export async function newThread<T>(...args: any[]): Promise<T> {
         const thread_vm: typeof vm = global.require('vm');
         const mainPeer: RpcPeer = new RpcPeer('thread', 'main', (message: any, reject: any) => {
             try {
-                thread_worker_threads.parentPort.postMessage(thread_v8.serialize(message));
+                thread_worker_threads.parentPort!.postMessage(thread_v8.serialize(message));
             }
             catch (e) {
-                reject?.(e);
+                reject?.(e as Error);
             }
         });
         mainPeer.transportSafeArgumentTypes.add(Buffer.name);
         mainPeer.transportSafeArgumentTypes.add(Uint8Array.name);
-        thread_worker_threads.parentPort.on('message', (message: any) => mainPeer.handleMessage(thread_v8.deserialize(message)));
+        thread_worker_threads.parentPort!.on('message', (message: any) => mainPeer.handleMessage(thread_v8.deserialize(message)));
 
         mainPeer.params.eval = async (script: string, moduleNames: string[], paramNames: string[], ...paramValues: any[]) => {
             const f = thread_vm.compileFunction(`return (${script})`, paramNames, {
@@ -55,7 +55,7 @@ export async function newThread<T>(...args: any[]): Promise<T> {
                 params[module] = global.require(module);
             }
             for (let i = 0; i < paramNames.length; i++) {
-                params[paramNames[i]] = paramValues[i];
+                params[paramNames[i]!] = paramValues[i];
             }
             const c = await f(...paramValues);
             return await c(params);
@@ -79,7 +79,7 @@ export async function newThread<T>(...args: any[]): Promise<T> {
             worker.postMessage(v8.serialize(message));
         }
         catch (e) {
-            reject?.(e);
+            reject?.(e as Error);
         }
     });
     threadPeer.transportSafeArgumentTypes.add(Buffer.name);

package/src/usertoken.ts

@@ -2,7 +2,7 @@ export const ONE_DAY_MILLISECONDS = 86400000;
 export const ONE_YEAR_MILLISECONDS = ONE_DAY_MILLISECONDS * 365;
 
 export class UserToken {
-    constructor(public username: string, public aclId: string, public timestamp = Date.now(), public duration = ONE_DAY_MILLISECONDS) {
+    constructor(public username: string, public aclId?: string, public timestamp = Date.now(), public duration = ONE_DAY_MILLISECONDS) {
     }
 
     static validateToken(token: string): UserToken {