Allow enabling/disabling device sources and known devices

src/app.ts

@@ -14,7 +14,7 @@ import { ClientToServerEvents, ServerToClientEvents, WebsocketServer } from './s
 import { SerializedDevice } from './device/serializedTypes.js';
 import { SerializedSettings } from './settings/serializedTypes.js';
 import AutomationServiceProvider from './serviceProvider/automationServiceProvider.js';
-import Device from './device/device.js';
+import { AnyDevice } from './device/device.js';
 import WebSocketEvent from './device/webSocketEvent.js';
 import AutomationEventType from './automation/automationEventType.js';
 import LoggerServiceProvider from './serviceProvider/loggerServiceProvider.js';
@@ -104,22 +104,22 @@ const configureWebsocket = (io: WebsocketServer, container: Container<ServiceMap
         socket.on(WebSocketEvent.deviceUpdateReceived, (data) => deviceUpdateHandler.handle(data));
     });
 
-    deviceManager.on(DeviceManagerEvent.deviceConnected, (device: Device) => {
+    deviceManager.on(DeviceManagerEvent.deviceConnected, (device: AnyDevice) => {
         io.emit(WebSocketEvent.deviceConnected, serializer.transform<SerializedDevice>(device, deviceDiscriminator));
         void scriptRuntime.runForEvent({ type: DeviceManagerEvent.deviceConnected, device, args: [] });
     });
 
-    deviceManager.on(DeviceManagerEvent.deviceDisconnected, (device: Device) => {
+    deviceManager.on(DeviceManagerEvent.deviceDisconnected, (device: AnyDevice) => {
         io.emit(WebSocketEvent.deviceDisconnected, serializer.transform<SerializedDevice>(device, deviceDiscriminator));
         void scriptRuntime.runForEvent({ type: DeviceManagerEvent.deviceDisconnected, device, args: [] });
     });
 
-    deviceManager.on(DeviceManagerEvent.deviceRefreshed, (device: Device) => {
+    deviceManager.on(DeviceManagerEvent.deviceRefreshed, (device: AnyDevice) => {
         io.emit(WebSocketEvent.deviceRefreshed, serializer.transform<SerializedDevice>(device, deviceDiscriminator));
         void scriptRuntime.runForEvent({ type: DeviceManagerEvent.deviceRefreshed, device, args: [] });
     });
 
-    deviceManager.on(DeviceManagerEvent.deviceNotification, (device: Device, notification) => {
+    deviceManager.on(DeviceManagerEvent.deviceNotification, (device: AnyDevice, notification) => {
         io.emit(WebSocketEvent.deviceNotification, serializer.transform<SerializedDevice>(device, deviceDiscriminator), notification);
         void scriptRuntime.runForEvent({ type: DeviceManagerEvent.deviceNotification, device, args: [notification] });
     });
@@ -132,21 +132,25 @@ const configureWebsocket = (io: WebsocketServer, container: Container<ServiceMap
     scriptRuntime.on(AutomationEventType.consoleLog, (data: string) => io.emit(AutomationEventType.consoleLog, data));
 };
 
-const loadDeviceProviders = (container: Container<ServiceMap>): void => {
-    const serialPortObserver = container.get('device.observer.serial');
-    const bleObserver = container.get('device.observer.ble');
+const startDeviceProviders = (container: Container<ServiceMap>): void => {
     const logger = container.get('logger.default');
+    const settingsManager = container.get('settings.manager');
     const settings = container.get('settings');
-    const deviceProviderManager = container.get('device.provider.loader');
-
-    deviceProviderManager.loadFromSettings(settings);
+    const deviceProviderManager = container.get('device.provider.manager');
+    const deviceManager = container.get('device.manager');
 
     deviceProviderManager
-        .startProviders()
+        .loadFromSettings(settings)
         .catch(e => logError(logger, `Loading device providers failed`, e));
 
-    serialPortObserver.start().catch(e => logError(logger, `Initializing serial port observer failed`, e));
-    bleObserver.init().catch(e => logError(logger, `Initializing BLE observer failed`, e));
+    settingsManager.on(SettingsEventType.changed, (changedSettings: Settings) => {
+        // Reload device sources first so re-enabled devices are only re-announced once their provider runs again
+        deviceProviderManager
+            .loadFromSettings(changedSettings)
+            .catch(e => logError(logger, 'Failed to reload device sources after settings change', e))
+            .then(() => deviceManager.onSettingsChanged())
+            .catch(e => logError(logger, 'Failed to apply device enabled/disabled changes', e));
+    });
 };
 
 const buildCorsOptions = (allowedOrigins: string[]): CorsOptions => ({
@@ -205,7 +209,7 @@ export const createApp = (container: Container<ServiceMap>, options: AppOptions)
 
     configureRoutes(app, container);
     configureWebsocket(websocketServer, container);
-    loadDeviceProviders(container);
+    startDeviceProviders(container);
 
     let serveResult: ServeResult | undefined;
     let canBeShutDown = false;
@@ -259,9 +263,13 @@ export const createApp = (container: Container<ServiceMap>, options: AppOptions)
             logger.info('Shutting down...');
 
             await container.get('automation.scriptRuntime').stop();
-            await container.get('device.observer.serial').stop();
-            await container.get('device.observer.ble').stop();
-            await container.get('device.provider.loader').stopProviders();
+
+            try {
+                await container.get('device.provider.manager').stopProviders();
+            } catch (e: unknown) {
+                logError(logger, 'Failed to stop device providers during shutdown', e);
+            }
+
             container.get('health.metricsCollector').stop();
 
             await websocketServer.close();

src/automation/scriptRuntime.ts

@@ -1,6 +1,6 @@
 import ivm from 'isolated-vm';
 import { transform } from 'sucrase';
-import Device, { DeviceNotification } from '../device/device.js';
+import { AnyDevice, DeviceNotification } from '../device/device.js';
 import DeviceRepositoryInterface from '../repository/deviceRepositoryInterface.js';
 import fs, { WriteStream } from 'fs';
 import readLastLines from 'read-last-lines/dist/index.js';
@@ -11,8 +11,8 @@ import { AttributeValue } from '../device/attribute/deviceAttribute.js';
 import Logger from '../logging/Logger.js';
 
 export type SupportedDeviceEvent =
-    | { type: DeviceManagerEvent.deviceConnected | DeviceManagerEvent.deviceDisconnected | DeviceManagerEvent.deviceRefreshed; device: Device; args: [] }
-    | { type: DeviceManagerEvent.deviceNotification; device: Device; args: [notification: DeviceNotification] };
+    | { type: DeviceManagerEvent.deviceConnected | DeviceManagerEvent.deviceDisconnected | DeviceManagerEvent.deviceRefreshed; device: AnyDevice; args: [] }
+    | { type: DeviceManagerEvent.deviceNotification; device: AnyDevice; args: [notification: DeviceNotification] };
 
 type ScriptRuntimeEvents = {
     [AutomationEventType.consoleLog]: (data: string) => void,
@@ -223,6 +223,25 @@ export default class ScriptRuntime
 
     public async load(scriptCode: string): Promise<void>
     {
+        const writer = fs.createWriteStream(`${this.logPath}/automation.log`);
+        writer.on('error', (err) => {
+            this.logger.error(`Automation log write error: ${err.message}`);
+        });
+
+        // Open the log file before creating the isolate: if this fails, nothing
+        // needs to be torn down yet.
+        try {
+            await new Promise<void>((resolve, reject) => {
+                writer.once('open', () => resolve());
+                writer.once('error', (err) => reject(err));
+            });
+        } catch (e) {
+            writer.destroy();
+            throw e;
+        }
+
+        this.logWriter = writer;
+
         this.isolate = new ivm.Isolate({ memoryLimit: 128 });
         this.vmContext = await this.isolate.createContext();
 
@@ -299,10 +318,6 @@ export default class ScriptRuntime
         this.dispatchRef = await this.vmContext.global.get('__dispatchEvent');
         this.lifecycleRef = await this.vmContext.global.get('__dispatchLifecycle');
 
-        this.logWriter = fs.createWriteStream(`${this.logPath}/automation.log`);
-        this.logWriter.on('error', (err) => {
-            this.logger.error(`Automation log write error: ${err.message}`);
-        });
         this.runningSince = new Date();
 
         const lifecycleRef = this.lifecycleRef;
@@ -441,7 +456,17 @@ export default class ScriptRuntime
 
     public async getLog(maxLines: number): Promise<string>
     {
-        return readLastLines.read(`${this.logPath}/automation.log`, maxLines);
+        try {
+            return await readLastLines.read(`${this.logPath}/automation.log`, maxLines);
+        } catch (e: unknown) {
+            // No script has run yet (or its log file was not created) - treat as empty log
+            // rather than an error condition.
+            if (e instanceof Error && e.message.includes('file does not exist')) {
+                return '';
+            }
+
+            throw e;
+        }
     }
 
     public isRunning(): boolean

src/controller/settings/putSettingsController.ts

@@ -2,7 +2,7 @@ import { Request, Response } from 'express';
 import ControllerInterface from '../controllerInterface.js';
 import SettingsManager from '../../settings/settingsManager.js';
 import Settings, { SettingsSchema } from '../../settings/settings.js';
-import JsonSchemaValidator from '../../schemaValidation/JsonSchemaValidator.js';
+import SchemaValidationError from '../../schemaValidation/schemaValidationError.js';
 import PlainToClassSerializer from '../../serialization/plainToClassSerializer.js';
 import ClassToPlainSerializer from '../../serialization/classToPlainSerializer.js';
 import { JsonObject } from '../../types.js';
@@ -17,35 +17,34 @@ export default class PutSettingsController implements ControllerInterface
 
     private classToPlainSerializer: ClassToPlainSerializer;
 
-    private settingsSchemaValidator: JsonSchemaValidator<typeof SettingsSchema>;
-
     public constructor(
         settingsManager: SettingsManager,
         classToPlainSerializer: ClassToPlainSerializer,
-        plainToClassSerializer: PlainToClassSerializer,
-        settingsSchemaValidator: JsonSchemaValidator<typeof SettingsSchema>
+        plainToClassSerializer: PlainToClassSerializer
     ) {
         this.settingsManager = settingsManager;
-        this.settingsSchemaValidator = settingsSchemaValidator;
         this.plainToClassSerializer = plainToClassSerializer;
         this.classToPlainSerializer = classToPlainSerializer;
     }
 
     public execute(req: PutSettingsRequest, res: Response): void
     {
-        const valid = this.settingsSchemaValidator.validate(req.body);
+        let settings: Settings;
+
+        try {
+            settings = this.plainToClassSerializer.transform(Settings, req.body, SettingsSchema);
+        } catch (e: unknown) {
+            if (!(e instanceof SchemaValidationError)) {
+                throw e;
+            }
 
-        if (!valid) {
-            const validationErrors = this.settingsSchemaValidator.getValidationErrors();
             res.status(400).json({
                 message: `Settings are not in a valid format`,
-                errors: [...validationErrors]
+                errors: e.validationErrors
             });
             return;
         }
 
-        const settings = this.plainToClassSerializer.transform(Settings, req.body);
-
         this.settingsManager.replace(settings);
 
         res.send(JSON.stringify(this.classToPlainSerializer.transform(

src/device/bleDevice.ts

@@ -1,6 +1,6 @@
 import { Peripheral } from '@stoprocent/noble';
 import BaseError from 'modern-errors';
-import Device, { DeviceAttributes, DeviceNotifications, NoDeviceNotifications } from './device.js';
+import Device, { DeviceAttributes, DeviceNotifications, NoDeviceNotifications, WithUntypedAttributes } from './device.js';
 import { AnyDeviceConfig, NoDeviceConfig } from './deviceConfig.js';
 import { Expose } from 'class-transformer';
 import { EventEmitter } from 'events';
@@ -9,11 +9,7 @@ import { logError } from '../util/error.js';
 import Logger from '../logging/Logger.js';
 import { asyncHandler, promiseWithTimeout } from '../util/async.js';
 
-export type InferBleDeviceAttributes<D extends BleDevice<any, any, any>> =
-    D extends BleDevice<infer TAttrs, any, any> ? TAttrs : DeviceAttributes;
-
-export type InferBleDeviceConfig<D extends BleDevice<any, any, any>> =
-    D extends BleDevice<any, any, infer TCfg> ? TCfg : AnyDeviceConfig;
+export type AnyBleDevice = WithUntypedAttributes<BleDevice>;
 
 export default abstract class BleDevice<
     TAttributes extends DeviceAttributes = DeviceAttributes,
@@ -78,6 +74,10 @@ export default abstract class BleDevice<
         this.peripheral.on('disconnect', this.reconnectHandler);
     }
 
+    public getPeripheral(): Peripheral {
+        return this.peripheral;
+    }
+
     private async requestRssiUpdate(): Promise<void> {
         if (this.closing || this.peripheral.state === 'disconnected') {
             return;

src/device/device.ts

@@ -1,21 +1,12 @@
 import { Exclude, Expose } from 'class-transformer';
 import DeviceState from './deviceState.js';
-import DeviceAttribute from './attribute/deviceAttribute.js';
+import DeviceAttribute, { AttributeValue } from './attribute/deviceAttribute.js';
 import { AnyDeviceConfig, NoDeviceConfig } from './deviceConfig.js';
 import { EventEmitter } from 'events';
 import type { DeviceId } from './deviceId.js';
 import type { JsonObject } from '../types.js';
 import { DropFirst } from '../types.js';
 
-export type InferDeviceAttributes<D extends Device<DeviceAttributes, DeviceNotifications, AnyDeviceConfig>> =
-    D extends Device<infer TAttrs, any, any> ? TAttrs : DeviceAttributes;
-
-export type InferDeviceNotifications<D extends Device<DeviceAttributes, DeviceNotifications, AnyDeviceConfig>> =
-    D extends Device<any, infer TNotifs, any> ? TNotifs : AnyDeviceNotifications;
-
-export type InferDeviceConfig<D extends Device<DeviceAttributes, DeviceNotifications, AnyDeviceConfig>> =
-    D extends Device<any, any, infer TCfg> ? TCfg : AnyDeviceConfig;
-
 // An attribute value can be DeviceAttribute or undefined because we want to allow Partial<>
 export type DeviceAttributes = Record<string, DeviceAttribute | undefined>;
 
@@ -58,6 +49,12 @@ export type DeviceEventMap<
     [DeviceEvent.deviceNotification]: [device: TDevice, notification: DeviceNotification<TNotifications>];
 }
 
+export type WithUntypedAttributes<D extends Device<any, any, any>> = Omit<D, 'setAttribute'> & {
+    setAttribute(attributeName: string, value: AttributeValue): Promise<AttributeValue>;
+};
+
+export type AnyDevice = WithUntypedAttributes<Device>;
+
 @Exclude()
 export default abstract class Device<
     TAttributes extends DeviceAttributes = DeviceAttributes,