Control station/config versioning

.github/workflows/release.yaml

@@ -90,7 +90,6 @@ jobs:
         if: runner.os == 'Linux'
         run: |
           sudo apt-get update
-          sudo apt-get install -y rpm libarchive-tools
 
       # Download ONLY the appropriate backend for this platform
       - name: Download Linux backend
@@ -188,8 +187,6 @@ jobs:
             electron-app/dist/*.exe
             electron-app/dist/*.AppImage
             electron-app/dist/*.deb
-            electron-app/dist/*.rpm
-            electron-app/dist/*.pacman
             electron-app/dist/*.dmg
             electron-app/dist/*.zip
             electron-app/dist/*.yml

README.md

@@ -1,5 +1,6 @@
 # Hyperloop Control Station H11
- ![Testing View](https://raw.githubusercontent.com/Hyperloop-UPV/webpage/5c1c827d82d380689856ee61af43da30da22e0fc/src/assets/backgrounds/testing-view.png)
+
+![Testing View](https://raw.githubusercontent.com/Hyperloop-UPV/webpage/5c1c827d82d380689856ee61af43da30da22e0fc/src/assets/backgrounds/testing-view.png)
 
 ## Monorepo usage
 
@@ -20,17 +21,17 @@ Before starting, ensure you have the following installed:
 
 Our `pnpm-workspace.yaml` defines the following workspaces:
 
-| Workspace                      | Language | Description                                    |
-| :----------------------------- | :------- | :--------------------------------------------- |
-| `testing-view`                 | TS/React | Web interface for telemetry testing            |
-| `competition-view`             | TS/React | UI for the competition                         |
-| `backend`                      | Go       | Data ingestion and pod communication server    |
-| `packet-sender`                | Rust     | Utility for simulating vehicle packets         |
-| `electron-app`                 | JS       | The main Control Station desktop application   |
-| `@workspace/ui`                | TS/React | Shared UI component library (frontend-kit)     |
-| `@workspace/core`              | TS       | Shared business logic and types (frontend-kit) |
-| `@workspace/eslint-config`     | ESLint   | Common ESLint configuration (frontend-kit)     |
-| `@workspace/typescript-config` | TS       | Common TypeScript configuration (frontend-kit) |
+| Workspace                      | Language | Description                                           |
+| :----------------------------- | :------- | :---------------------------------------------------- |
+| `testing-view`                 | TS/React | Web interface for telemetry testing                   |
+| `competition-view`             | TS/React | UI for the competition                                |
+| `backend`                      | Go       | Data ingestion and pod communication server           |
+| `packet-sender`                | Rust     | Utility for simulating vehicle packets                |
+| `hyperloop-control-station`    | JS       | The main Control Station electron desktop application |
+| `@workspace/ui`                | TS/React | Shared UI component library (frontend-kit)            |
+| `@workspace/core`              | TS       | Shared business logic and types (frontend-kit)        |
+| `@workspace/eslint-config`     | ESLint   | Common ESLint configuration (frontend-kit)            |
+| `@workspace/typescript-config` | TS       | Common TypeScript configuration (frontend-kit)        |
 
 ---
 

electron-app/.gitignore

@@ -81,4 +81,5 @@ coverage
 
 # Config and config backups
 config.toml
-config.toml.backup-*
+config.toml.backup-*
+version.toml

electron-app/build.mjs

@@ -254,7 +254,10 @@ logger.header("Hyperloop Control Station Build");
 
   if (frontendBuilt && !process.env.CI) {
     logger.info("Finalizing Electron...");
-    run("pnpm --filter electron-app install --frozen-lockfile", __dirname);
+    run(
+      "pnpm --filter hyperloop-control-station install --frozen-lockfile",
+      __dirname
+    );
   }
 
   if (allSuccess) {

electron-app/main.js

@@ -36,8 +36,6 @@ if (process.platform === "linux") {
 // Setup IPC handlers for renderer process communication
 setupIpcHandlers();
 
-app.setName("hyperloop-control-station");
-
 // App lifecycle: wait for Electron to be ready
 app.whenReady().then(async () => {
   // Get the screen width and height
@@ -118,11 +116,11 @@ app.on("window-all-closed", () => {
 });
 
 // Cleanup before app quits
-app.on("before-quit", () => {
-  // Stop backend process gracefully
-  stopBackend();
-  // Stop packet sender process gracefully
-  stopPacketSender();
+app.on("before-quit", (e) => {
+  e.preventDefault();
+  Promise.all([stopBackend(), stopPacketSender()])
+    .catch((error) => logger.electron.error("Error during shutdown:", error))
+    .finally(() => app.exit());
 });
 
 // Handle uncaught exceptions globally

electron-app/package.json

@@ -1,5 +1,5 @@
 {
-  "name": "electron-app",
+  "name": "hyperloop-control-station",
   "version": "1.0.0",
   "description": "Hyperloop UPV Control Station",
   "main": "main.js",
@@ -57,7 +57,7 @@
       "owner": "Hyperloop-UPV",
       "repo": "software"
     },
-    "productName": "Hyperloop-Control-Station",
+    "productName": "Hyperloop-Ctrl",
     "directories": {
       "output": "dist"
     },
@@ -107,9 +107,7 @@
     "linux": {
       "target": [
         "AppImage",
-        "deb",
-        "rpm",
-        "pacman"
+        "deb"
       ],
       "icon": "icons/512x512.png",
       "category": "Utility",

electron-app/preload.js

@@ -37,6 +37,10 @@ contextBridge.exposeInMainWorld("electronAPI", {
   // Open folder selection dialog
   selectFolder: () => ipcRenderer.invoke("select-folder"),
   // Receive log message from backend
-  onLog: (callback) =>
-    ipcRenderer.on("log", (_event, value) => callback(value)),
+  onLog: (callback) => {
+    const listener = (_event, value) => callback(value);
+    ipcRenderer.removeAllListeners("log");
+    ipcRenderer.on("log", listener);
+    return () => ipcRenderer.removeListener("log", listener);
+  },
 });

electron-app/src/config/__tests__/ConfigManager.initialization.test.js

@@ -1,5 +1,5 @@
-import { describe, it, expect, beforeEach, vi } from "vitest";
 import fs from "fs";
+import { beforeEach, describe, expect, it, vi } from "vitest";
 import { ConfigManager } from "../configManager.js";
 
 // Mock fs module
@@ -8,15 +8,24 @@ vi.mock("fs");
 describe("ConfigManager - Initialization", () => {
   const templatePath = "/path/to/template.toml";
   const userConfigPath = "/path/to/user.toml";
+  const versionFilePath = "/path/to/version.toml";
+  const appVersion = "1.0.0";
+  const appVersionReturnValue = `version = "${appVersion}"`;
 
   beforeEach(() => {
     vi.clearAllMocks();
   });
 
   it("should create config manager instance", () => {
     fs.existsSync.mockReturnValue(true);
+    fs.readFileSync.mockReturnValue(appVersionReturnValue);
 
-    const manager = new ConfigManager(userConfigPath, templatePath);
+    const manager = new ConfigManager(
+      userConfigPath,
+      templatePath,
+      versionFilePath,
+      appVersion,
+    );
 
     expect(manager.userConfigPath).toBe(userConfigPath);
     expect(manager.templatePath).toBe(templatePath);
@@ -28,8 +37,9 @@ describe("ConfigManager - Initialization", () => {
       return true;
     });
     fs.mkdirSync.mockImplementation(() => {});
+    fs.readFileSync.mockReturnValue(appVersionReturnValue);
 
-    new ConfigManager(userConfigPath, templatePath);
+    new ConfigManager(userConfigPath, templatePath, versionFilePath, appVersion);
 
     expect(fs.mkdirSync).toHaveBeenCalledWith("/path/to", {
       recursive: true,
@@ -39,17 +49,17 @@ describe("ConfigManager - Initialization", () => {
   it("should copy template if user config does not exist", () => {
     fs.existsSync.mockImplementation((path) => {
       if (path === userConfigPath) return false;
-      if (path === templatePath) return true;
       return true;
     });
     fs.copyFileSync.mockImplementation(() => {});
+    fs.writeFileSync.mockImplementation(() => {});
     const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => {});
 
-    new ConfigManager(userConfigPath, templatePath);
+    new ConfigManager(userConfigPath, templatePath, versionFilePath, appVersion);
 
     expect(fs.copyFileSync).toHaveBeenCalledWith(templatePath, userConfigPath);
     expect(consoleSpy).toHaveBeenCalledWith(
-      expect.stringContaining("Created config from template")
+      expect.stringContaining("Created config from template"),
     );
 
     consoleSpy.mockRestore();
@@ -59,7 +69,7 @@ describe("ConfigManager - Initialization", () => {
     fs.existsSync.mockReturnValue(false);
 
     expect(() => {
-      new ConfigManager(userConfigPath, templatePath);
+      new ConfigManager(userConfigPath, templatePath, versionFilePath, appVersion);
     }).toThrow("Template not found");
   });
 });

electron-app/src/config/__tests__/ConfigManager.read-write.test.js

@@ -9,6 +9,9 @@ import fs from "fs";
 describe("ConfigManager - Read/Write Operations", () => {
   const templatePath = "/path/to/template.toml";
   const userConfigPath = "/path/to/user.toml";
+  const versionFilePath = "/path/to/version.toml";
+  const appVersion = "1.0.0";
+  const appVersionReturnValue = `version = "${appVersion}"`;
   const mockTomlContent = `# User Config
 name = "test"
 enabled = true
@@ -23,9 +26,15 @@ host = "localhost"`;
   describe("read", () => {
     it("should read and parse TOML config", () => {
       fs.existsSync.mockReturnValue(true);
+      fs.readFileSync.mockReturnValueOnce(appVersionReturnValue);
       fs.readFileSync.mockReturnValue(mockTomlContent);
 
-      const manager = new ConfigManager(userConfigPath, templatePath);
+      const manager = new ConfigManager(
+        userConfigPath,
+        templatePath,
+        versionFilePath,
+        appVersion,
+      );
       const config = manager.read();
 
       expect(config).toHaveProperty("name", "test");
@@ -35,20 +44,32 @@ host = "localhost"`;
 
     it("should throw error on invalid TOML", () => {
       fs.existsSync.mockReturnValue(true);
+      fs.readFileSync.mockReturnValueOnce(appVersionReturnValue);
       fs.readFileSync.mockReturnValue("invalid toml [[[");
 
-      const manager = new ConfigManager(userConfigPath, templatePath);
+      const manager = new ConfigManager(
+        userConfigPath,
+        templatePath,
+        versionFilePath,
+        appVersion,
+      );
 
       expect(() => manager.read()).toThrow("Failed to read config");
     });
 
     it("should throw error on file read failure", () => {
       fs.existsSync.mockReturnValue(true);
+      fs.readFileSync.mockReturnValueOnce(appVersionReturnValue);
       fs.readFileSync.mockImplementation(() => {
         throw new Error("Permission denied");
       });
 
-      const manager = new ConfigManager(userConfigPath, templatePath);
+      const manager = new ConfigManager(
+        userConfigPath,
+        templatePath,
+        versionFilePath,
+        appVersion,
+      );
 
       expect(() => manager.read()).toThrow("Failed to read config");
     });
@@ -57,9 +78,15 @@ host = "localhost"`;
   describe("readRaw", () => {
     it("should return raw TOML content", () => {
       fs.existsSync.mockReturnValue(true);
+      fs.readFileSync.mockReturnValueOnce(appVersionReturnValue);
       fs.readFileSync.mockReturnValue(mockTomlContent);
 
-      const manager = new ConfigManager(userConfigPath, templatePath);
+      const manager = new ConfigManager(
+        userConfigPath,
+        templatePath,
+        versionFilePath,
+        appVersion,
+      );
       const raw = manager.readRaw();
 
       expect(raw).toBe(mockTomlContent);
@@ -70,11 +97,17 @@ host = "localhost"`;
   describe("update", () => {
     it("should update config from object", () => {
       fs.existsSync.mockReturnValue(true);
+      fs.readFileSync.mockReturnValueOnce(appVersionReturnValue);
       fs.readFileSync.mockReturnValue(mockTomlContent);
       fs.writeFileSync.mockImplementation(() => {});
       const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => {});
 
-      const manager = new ConfigManager(userConfigPath, templatePath);
+      const manager = new ConfigManager(
+        userConfigPath,
+        templatePath,
+        versionFilePath,
+        appVersion,
+      );
       const result = manager.update({
         name: "updated",
         enabled: false,
@@ -91,12 +124,18 @@ host = "localhost"`;
 
     it("should throw error on update failure", () => {
       fs.existsSync.mockReturnValue(true);
+      fs.readFileSync.mockReturnValueOnce(appVersionReturnValue);
       fs.readFileSync.mockReturnValue(mockTomlContent);
       fs.writeFileSync.mockImplementation(() => {
         throw new Error("Write failed");
       });
 
-      const manager = new ConfigManager(userConfigPath, templatePath);
+      const manager = new ConfigManager(
+        userConfigPath,
+        templatePath,
+        versionFilePath,
+        appVersion,
+      );
 
       expect(() => manager.update({ name: "test" })).toThrow(
         "Failed to update config"
@@ -107,11 +146,17 @@ host = "localhost"`;
   describe("updateValue", () => {
     it("should update a single value", () => {
       fs.existsSync.mockReturnValue(true);
+      fs.readFileSync.mockReturnValueOnce(appVersionReturnValue);
       fs.readFileSync.mockReturnValue(mockTomlContent);
       fs.writeFileSync.mockImplementation(() => {});
       const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => {});
 
-      const manager = new ConfigManager(userConfigPath, templatePath);
+      const manager = new ConfigManager(
+        userConfigPath,
+        templatePath,
+        versionFilePath,
+        appVersion,
+      );
       const result = manager.updateValue("database", "host", "192.168.1.1");
 
       expect(result).toBe(true);
@@ -125,11 +170,17 @@ host = "localhost"`;
 
     it("should throw error on value update failure", () => {
       fs.existsSync.mockReturnValue(true);
+      fs.readFileSync.mockReturnValueOnce(appVersionReturnValue);
       fs.readFileSync.mockImplementation(() => {
         throw new Error("Read failed");
       });
 
-      const manager = new ConfigManager(userConfigPath, templatePath);
+      const manager = new ConfigManager(
+        userConfigPath,
+        templatePath,
+        versionFilePath,
+        appVersion,
+      );
 
       expect(() => manager.updateValue("section", "key", "value")).toThrow(
         "Failed to update value"