Add homeassistant websocket API

Author: floflo0

pill_mate/backend/eslint.config.mjs

@@ -23,6 +23,7 @@ export default tseslint.config(
             quotes: ['error', 'single'],
             'comma-dangle': ['error', 'always-multiline'],
             'no-trailing-spaces': ['error'],
+            'eqeqeq': ['error', 'always'],
             'import/order': 'error',
             'import/no-unresolved': 'off',
         },

pill_mate/backend/package-lock.json

@@ -15,14 +15,16 @@
         "sequelize": "^6.37.5",
         "sequelize-typescript": "^2.1.6",
         "sqlite3": "^5.1.7",
-        "winston": "^3.17.0"
+        "winston": "^3.17.0",
+        "ws": "^8.18.0"
     },
     "devDependencies": {
         "@eslint/js": "^9.16.0",
         "@types/express": "^5.0.0",
         "@types/morgan": "^1.9.9",
         "@types/node": "^22.10.1",
         "@types/validator": "^13.12.2",
+        "@types/ws": "^8.5.14",
         "eslint": "^9.16.0",
         "eslint-plugin-import": "^2.31.0",
         "prettier": "^3.4.2",

pill_mate/backend/package.json

@@ -1,17 +1,23 @@
 import express, { Request, Response } from 'express';
 import morgan from 'morgan';
 
-import { logger } from './logger';
+import { createLogger } from './logger';
+import HomeAssistant from './homeassistant';
+
+const HOME_ASSISTANT_SUPERVISOR_TOKEN = process.env.SUPERVISOR_TOKEN || '';
+
+const homeassistant = new HomeAssistant(HOME_ASSISTANT_SUPERVISOR_TOKEN);
 
 const app = express();
 
+const logger = createLogger('express');
+
 app.use(morgan('dev', {
     stream: {
         write: message => logger.http(message.trim()),
     },
 }));
 
-
 app.get('/', (req: Request, res: Response) => {
     res.send('Hello, World!');
 });

pill_mate/backend/src/app.ts

@@ -0,0 +1,89 @@
+import { WebSocket } from 'ws';
+
+import { createLogger } from '../logger';
+import { Message, ResultSuccessMessage } from './message';
+
+const logger = createLogger('websocket');
+
+export default class HomeAssistant {
+
+    private readonly webSocket: WebSocket;
+    private readonly accessToken: string;
+    private nextId: number = 1;
+    private pendingRequests: { [key: number]: {
+        resolve(result: object): void,
+        reject(error: Error): void,
+    } } = {};
+
+    constructor(accessToken: string) {
+        this.accessToken = accessToken;
+
+        this.webSocket = new WebSocket('ws://supervisor/core/websocket');
+
+        this.webSocket.on('open', () => {
+            logger.info('Connected to Home Assistant WebSocket server');
+        });
+
+        this.webSocket.on('error', logger.error);
+
+        this.webSocket.on('close', (code, reason) => {
+            logger.error(`Connection closed: ${code} ${reason}`);
+        });
+
+        this.webSocket.on('message', (data, isBinary) => {
+            if (isBinary) {
+                logger.error('Binary message received');
+                return;
+            };
+
+            const message = JSON.parse(data.toString('utf-8')) as Message;
+            logger.debug(`Received message: ${data}`);
+
+            if (message.type === 'auth_required') {
+                this.send({
+                    type: 'auth',
+                    access_token: this.accessToken,
+                });
+                return;
+            }
+
+            if (message.type === 'auth_ok') {
+                logger.info('Authentication succeeded');
+                return;
+            }
+
+            if (message.type === 'auth_invalid') {
+                logger.error(`Authentication failed: ${message.message}`);
+                process.exit(1);
+            }
+
+            if (message.type === 'result') {
+                if (!message.success) {
+                    logger.error(`${message.error.code}: ${message.error.message}`);
+
+                    this.pendingRequests[message.id]?.reject(new Error(message.error.message));
+                    return;
+                }
+
+                this.pendingRequests[message.id]?.resolve(message);
+                return;
+            }
+
+            logger.error(`Unknown message type: ${(message as { type: string }).type}`);
+        });
+    }
+
+    private send(data: object) {
+        const message = JSON.stringify(data);
+        logger.debug(`Send message: ${message}`);
+        this.webSocket.send(message);
+    }
+
+    private send_with_id(data: object): Promise<ResultSuccessMessage> {
+        this.send({ id: this.nextId, ...data });
+        return new Promise((resolve, reject) => {
+            this.pendingRequests[this.nextId] = { resolve, reject };
+            ++this.nextId;
+        });
+    }
+}

pill_mate/backend/src/homeassistant/index.ts

@@ -0,0 +1,30 @@
+type VersionMessage = { ha_version: string };
+type IdMessage = { id: number };
+
+export type AuthRequiredMessage = VersionMessage & { type: 'auth_required' };
+export type AuthOkMessage = VersionMessage & { type: 'auth_ok' };
+export type AuthInvalid = { type: 'auth_invalid', message: string };
+
+export type BaseResultMessage = IdMessage & {
+    type: 'result',
+    success: boolean,
+};
+export type ResultSuccessMessage = BaseResultMessage & {
+    success: true,
+    result: object,
+};
+export type ResultErrorMessage = BaseResultMessage & {
+    success: false,
+    error: {
+        code: string,
+        message: string,
+    },
+};
+
+export type Message = (
+    | AuthRequiredMessage
+    | AuthOkMessage
+    | AuthInvalid
+    | ResultSuccessMessage
+    | ResultErrorMessage
+);

pill_mate/backend/src/homeassistant/message.ts

@@ -3,11 +3,13 @@ import { config } from 'dotenv';
 config({ path: '../.env' });
 
 import app from './app';
-import { logger } from './logger';
+import { createLogger } from './logger';
 import { sequelize } from './sequelize';
 
 const port = process.env.BACKEND_PORT || 3000;
 
+const logger = createLogger('backend');
+
 (async () => {
     await sequelize.sync({ alter: { drop: false } });
 

pill_mate/backend/src/index.ts

@@ -1,6 +1,6 @@
 import winston from 'winston';
 
-const createLogger = (label: string) => winston.createLogger({
+export const createLogger = (label: string) => winston.createLogger({
     level: process.env.DEV ? 'debug' : 'info',
     format: winston.format.combine(
         winston.format.timestamp({ format: 'YYYY-MM-DD HH:mm:ss' }),
@@ -13,5 +13,3 @@ const createLogger = (label: string) => winston.createLogger({
     ),
     transports: [new winston.transports.Console()],
 });
-
-export const logger = createLogger('backend');

pill_mate/backend/src/logger.ts

@@ -1,11 +1,13 @@
 import { Sequelize } from 'sequelize-typescript';
 
-import { logger } from './logger';
+import { createLogger } from './logger';
+
+const logger = createLogger('sequelize');
 
 export const sequelize = new Sequelize({
     dialect: 'sqlite',
     storage: '/homeassistant/home-assistant_v2.db',
-    logging: message => logger.log({ level: 'debug', message: `sequelize: ${message}` }),
+    logging: message => logger.debug(message),
     models: [],
     hooks: {
         beforeDefine: (_, model) => {