release-2.7.1 (#1296)

* Add Helm and GitOps deployment setup

* fix: build better-sqlite3 from source in Docker (#1267)

* fix: preserve runtime SSL settings (#1268)

* fix: support forwarding from the memory SSH agent (#1269)

* fix: support forwarding from the memory agent

* style: format memory agent test

* fix: prompt for encrypted SFTP key passphrases (#1270)

* fix: prompt for SFTP key passphrases

* style: format SSH key utility test

* fix: include host context in automation notifications (#1271)

* fix: include host context in automation notifications

* style: format automation notification changes

* fix: reserve sidebar height for host tags (#1272)

* fix: keep host action rows stable at large font sizes (#1273)

* fix: honor certificate setting during server probe (#1274)

* fix: package standard Linux icon sizes (#1275)

* fix: avoid duplicate Docker HTTPS listener (#1276)

* Fix host status without metrics collection (#1277)

* fix: allow eight-digit secure auth codes (#1263)

Allow TOTP prompts to accept secure auth codes longer than six digits without blocking valid authentication attempts.

Generated with Codebuff 🤖

Co-authored-by: Chetan <chetan.development@gmail.com>
Co-authored-by: Codebuff <noreply@codebuff.com>

* Harden Helm deployment defaults

* Update Helm workflow action

* Exclude Helm templates from Prettier

* Fix browser RDP file drops (#1279)

* Fix Proxmox guest credential usernames (#1280)

* Add WSL local terminal option (#1281)

* refactor: split the transfer engine into focused modules (#1282)

* refactor: extract SFTP promisify helpers into sftp-promisify module

* refactor: extract transfer timing and rate stats into transfer-stats module

* refactor: extract transfer error classes and recovery checks into transfer-errors module

* refactor: extract host/path utility helpers into transfer-host-utils module

* refactor: extract SFTP directory tree helpers into transfer-sftp-dir module

* refactor: extract segment copy job builder into transfer-segment-copy module

* refactor: extract file scan and sample helpers into transfer-scan module

* refactor: move throttled progress helper into transfer-stats module

* style: format transfer modules

* perf: optimize tmux monitor aggregation (#1283)

* fix: reserve credential tag row height (#1284)

* feat: edit AI provider model settings (#1285)

* fix: clarify click-to-expand host setting (#1286)

* fix: allow portable imports on remote databases (#1287)

* fix: allow HTTPS to share the configured port (#1288)

* fix: resolve synced jump hosts on the server (#1289)

* fix: make terminal clipboard shortcuts layout independent (#1290)

* fix: use compatible fetch dispatcher for Tailscale (#1291)

* fix: add OIDC environment recovery override (#1292)

* fix: coalesce rapid mobile terminal input (#1293)

* fix: coalesce rapid mobile terminal input

* fix: support clean xterm patch installs

* fix: resolve synced remote desktop host IDs (#1295)

* feat: make the SFTP file manager path bar editable (#1294)

Co-authored-by: Maxime Bonillo <257463937+dropafterfree@users.noreply.github.com>
Co-authored-by: ZacharyZcR <zacharyzcr1984@gmail.com>

* feat: add passkey sign in to the login screen

* fix: remove rounded corners from the host list search bar

* fix: stop image storage settings text wrapping to one word per line

* fix: prevent malformed websocket messages from crashing the server

* chore: increment version

* fix: remove gaps between host rows in the sidebar list

Keep sub-pixel row measurements and stop wiping the size cache on hover.

* fix: Failed to connect through jump hosts (#1180)

https://github.com/Termix-SSH/Support/issues/1180

* feat: Progress bar for file downloads in the file manager (#1158)

https://github.com/Termix-SSH/Support/issues/1158

* feat: Allow setting Silent OIDC Login via ENV var (#1174)

https://github.com/Termix-SSH/Support/issues/1174

* feat: `IdentityFile` to limit the number of attempts by agents (#1165)

https://github.com/Termix-SSH/Support/issues/1165

* feat: Credentials clone (#1159)

https://github.com/Termix-SSH/Support/issues/1159

* chore: update release notes

* docs: move helm setup guide to the docs site

* fix: type errors in FilteredAgent agent identity handling

* fix: remove stale better-sqlite3 prebuilds so the source build is used

* fix: actually build better-sqlite3 from source so arm64 docker images work

* fix: credential edit pencil in host editor and add clone action to credential list

* fix: clear editingHost so the credential pencil actually opens the editor

* chore: run format and lint

* fix: folder drag and drop upload failing in the file manager

* chore: sync Crowdin translations for 2.7.1

---------

Co-authored-by: alex-ctms <alex-ctms@users.noreply.github.com>
Co-authored-by: ZacharyZcR <zacharyzcr1984@gmail.com>
Co-authored-by: Chetan Kumar <74929596+ckloop@users.noreply.github.com>
Co-authored-by: Chetan <chetan.development@gmail.com>
Co-authored-by: Codebuff <noreply@codebuff.com>
Co-authored-by: ZacharyZcR <payasonorahc@protonmail.com>
Co-authored-by: dropafterfree <maxime.bonillo@gmail.com>
Co-authored-by: Maxime Bonillo <257463937+dropafterfree@users.noreply.github.com>

src/backend/hosts/serial.ts

@@ -4,6 +4,7 @@ import { SerialPort } from "serialport";
 import { AuthManager } from "../utils/auth-manager.js";
 import { DataCrypto } from "../utils/data-crypto.js";
 import { sshLogger } from "../utils/logger.js";
+import { parseWsMessage } from "../utils/ws-message.js";
 
 interface SerialConnectData {
   path: string;
@@ -13,11 +14,6 @@ interface SerialConnectData {
   parity?: "none" | "even" | "odd";
 }
 
-interface WebSocketMessage {
-  type: string;
-  data?: SerialConnectData | string | unknown;
-}
-
 const authManager = AuthManager.getInstance();
 
 const wss = new WebSocketServer({ port: 30011 });
@@ -93,109 +89,117 @@ wss.on("connection", async (ws: WebSocket, req) => {
   };
 
   ws.on("message", async (raw: RawData) => {
-    let parsed: WebSocketMessage;
+    let type: string;
+    let data: unknown;
     try {
-      parsed = JSON.parse(raw.toString()) as WebSocketMessage;
+      ({ type, data } = parseWsMessage(raw));
     } catch {
       return;
     }
 
-    const { type, data } = parsed;
-
-    switch (type) {
-      case "list_ports": {
-        try {
-          const ports = await SerialPort.list();
-          send({ type: "ports_list", data: ports });
-        } catch (err) {
-          send({
-            type: "error",
-            data: getErrorMessage(err, "Failed to list ports"),
-          });
-        }
-        break;
-      }
-
-      case "connect": {
-        if (port?.isOpen) {
-          port.close();
-          port = null;
-        }
-
-        const cfg = data as SerialConnectData;
-        if (!cfg?.path || !cfg?.baudRate) {
-          send({ type: "error", data: "Missing port path or baud rate" });
+    try {
+      switch (type) {
+        case "list_ports": {
+          try {
+            const ports = await SerialPort.list();
+            send({ type: "ports_list", data: ports });
+          } catch (err) {
+            send({
+              type: "error",
+              data: getErrorMessage(err, "Failed to list ports"),
+            });
+          }
           break;
         }
 
-        try {
-          port = new SerialPort({
-            path: cfg.path,
-            baudRate: cfg.baudRate,
-            dataBits: cfg.dataBits ?? 8,
-            stopBits: cfg.stopBits ?? 1,
-            parity: cfg.parity ?? "none",
-            autoOpen: false,
-          });
+        case "connect": {
+          if (port?.isOpen) {
+            port.close();
+            port = null;
+          }
 
-          port.open((err) => {
-            if (err) {
-              sshLogger.error("Serial port open failed", err, {
-                operation: "serial_open",
-                path: cfg.path,
-                userId,
-              });
-              send({ type: "error", data: err.message });
-              port = null;
-              return;
-            }
-            sshLogger.info("Serial port opened", {
-              operation: "serial_open",
+          const cfg = data as SerialConnectData;
+          if (!cfg?.path || !cfg?.baudRate) {
+            send({ type: "error", data: "Missing port path or baud rate" });
+            break;
+          }
+
+          try {
+            port = new SerialPort({
               path: cfg.path,
               baudRate: cfg.baudRate,
-              userId,
+              dataBits: cfg.dataBits ?? 8,
+              stopBits: cfg.stopBits ?? 1,
+              parity: cfg.parity ?? "none",
+              autoOpen: false,
             });
-            send({ type: "connected" });
-          });
 
-          port.on("data", (chunk: Buffer) => {
-            send({ type: "data", data: chunk.toString("binary") });
-          });
+            port.open((err) => {
+              if (err) {
+                sshLogger.error("Serial port open failed", err, {
+                  operation: "serial_open",
+                  path: cfg.path,
+                  userId,
+                });
+                send({ type: "error", data: err.message });
+                port = null;
+                return;
+              }
+              sshLogger.info("Serial port opened", {
+                operation: "serial_open",
+                path: cfg.path,
+                baudRate: cfg.baudRate,
+                userId,
+              });
+              send({ type: "connected" });
+            });
 
-          port.on("error", (err) => {
-            send({ type: "error", data: err.message });
-          });
+            port.on("data", (chunk: Buffer) => {
+              send({ type: "data", data: chunk.toString("binary") });
+            });
 
-          port.on("close", () => {
-            send({ type: "disconnected" });
-            port = null;
-          });
-        } catch (err) {
-          send({
-            type: "error",
-            data: getErrorMessage(err, "Failed to open serial port"),
-          });
-        }
-        break;
-      }
+            port.on("error", (err) => {
+              send({ type: "error", data: err.message });
+            });
 
-      case "input": {
-        if (!port?.isOpen) break;
-        const input = typeof data === "string" ? data : "";
-        if (!input) break;
-        port.write(Buffer.from(input, "binary"), (err) => {
-          if (err) {
-            send({ type: "error", data: err.message });
+            port.on("close", () => {
+              send({ type: "disconnected" });
+              port = null;
+            });
+          } catch (err) {
+            send({
+              type: "error",
+              data: getErrorMessage(err, "Failed to open serial port"),
+            });
           }
-        });
-        break;
-      }
+          break;
+        }
 
-      case "disconnect": {
-        cleanup();
-        send({ type: "disconnected" });
-        break;
+        case "input": {
+          if (!port?.isOpen) break;
+          const input = typeof data === "string" ? data : "";
+          if (!input) break;
+          port.write(Buffer.from(input, "binary"), (err) => {
+            if (err) {
+              send({ type: "error", data: err.message });
+            }
+          });
+          break;
+        }
+
+        case "disconnect": {
+          cleanup();
+          send({ type: "disconnected" });
+          break;
+        }
       }
+    } catch (err) {
+      sshLogger.error("Error handling serial WebSocket message", err, {
+        operation: "serial_message_handler_error",
+        userId,
+        messageType: type,
+      });
+      send({ type: "error", data: "Failed to process message" });
     }
   });