tasmota-webserial-esptool 9.1.7 → 9.1.9

package/src/esp_loader.ts

@@ -101,8 +101,7 @@ export class ESPLoader extends EventTarget {
   private __isReconfiguring: boolean = false;
   private __abandonCurrentOperation: boolean = false;
 
-  // Adaptive speed adjustment for flash read operations - DISABLED
-  // Using fixed conservative values that work reliably
+  // Adaptive speed adjustment for flash read operations
   private __adaptiveBlockMultiplier: number = 1;
   private __adaptiveMaxInFlightMultiplier: number = 1;
   private __consecutiveSuccessfulChunks: number = 0;
@@ -118,6 +117,7 @@ export class ESPLoader extends EventTarget {
   }
 
   // Chip properties with parent delegation
+  // chipFamily accessed before initialization as designed
   get chipFamily(): ChipFamily {
     return this._parent ? this._parent.chipFamily : this.__chipFamily!;
   }
@@ -167,7 +167,13 @@ export class ESPLoader extends EventTarget {
   }
 
   private get _inputBuffer(): number[] {
-    return this._parent ? this._parent._inputBuffer : this.__inputBuffer!;
+    if (this._parent) {
+      return this._parent._inputBuffer;
+    }
+    if (this.__inputBuffer === undefined) {
+      throw new Error("_inputBuffer accessed before initialization");
+    }
+    return this.__inputBuffer;
   }
 
   private get _inputBufferReadIndex(): number {
@@ -695,6 +701,7 @@ export class ESPLoader extends EventTarget {
   }
 
   state_DTR = false;
+  state_RTS = false;
 
   // ============================================================================
   // Web Serial (Desktop) - DTR/RTS Signal Handling & Reset Strategies
@@ -759,6 +766,7 @@ export class ESPLoader extends EventTarget {
   // ============================================================================
 
   async setRTSWebUSB(state: boolean) {
+    this.state_RTS = state;
     // Always specify both signals to avoid flipping the other line
     // The WebUSB setSignals() now preserves unspecified signals, but being explicit is safer
     await (this.port as WebUSBSerialPort).setSignals({
@@ -772,12 +780,13 @@ export class ESPLoader extends EventTarget {
     // Always specify both signals to avoid flipping the other line
     await (this.port as WebUSBSerialPort).setSignals({
       dataTerminalReady: state,
-      requestToSend: undefined, // Let setSignals preserve current RTS state
+      requestToSend: this.state_RTS, // Explicitly preserve current RTS state
     });
   }
 
   async setDTRandRTSWebUSB(dtr: boolean, rts: boolean) {
     this.state_DTR = dtr;
+    this.state_RTS = rts;
     await (this.port as WebUSBSerialPort).setSignals({
       dataTerminalReady: dtr,
       requestToSend: rts,
@@ -990,7 +999,7 @@ export class ESPLoader extends EventTarget {
           // Strategy 1: USB-JTAG/Serial (works in CDC mode on Desktop)
           resetStrategies.push({
             name: "USB-JTAG/Serial (WebUSB) - ESP32-S2",
-            fn: async function () {
+            fn: async () => {
               return await self.hardResetUSBJTAGSerialWebUSB();
             },
           });
@@ -998,7 +1007,7 @@ export class ESPLoader extends EventTarget {
           // Strategy 2: USB-JTAG/Serial Inverted DTR (works in JTAG mode)
           resetStrategies.push({
             name: "USB-JTAG/Serial Inverted DTR (WebUSB) - ESP32-S2",
-            fn: async function () {
+            fn: async () => {
               return await self.hardResetUSBJTAGSerialInvertedDTRWebUSB();
             },
           });
@@ -1006,7 +1015,7 @@ export class ESPLoader extends EventTarget {
           // Strategy 3: UnixTight (CDC fallback)
           resetStrategies.push({
             name: "UnixTight (WebUSB) - ESP32-S2 CDC",
-            fn: async function () {
+            fn: async () => {
               return await self.hardResetUnixTightWebUSB();
             },
           });
@@ -1014,7 +1023,7 @@ export class ESPLoader extends EventTarget {
           // Strategy 4: Classic reset (CDC fallback)
           resetStrategies.push({
             name: "Classic (WebUSB) - ESP32-S2 CDC",
-            fn: async function () {
+            fn: async () => {
               return await self.hardResetClassicWebUSB();
             },
           });
@@ -1022,19 +1031,19 @@ export class ESPLoader extends EventTarget {
           // Other USB-JTAG chips: Try Inverted DTR first - works best for ESP32-H2 and other JTAG chips
           resetStrategies.push({
             name: "USB-JTAG/Serial Inverted DTR (WebUSB)",
-            fn: async function () {
+            fn: async () => {
               return await self.hardResetUSBJTAGSerialInvertedDTRWebUSB();
             },
           });
           resetStrategies.push({
             name: "USB-JTAG/Serial (WebUSB)",
-            fn: async function () {
+            fn: async () => {
               return await self.hardResetUSBJTAGSerialWebUSB();
             },
           });
           resetStrategies.push({
             name: "Inverted DTR Classic (WebUSB)",
-            fn: async function () {
+            fn: async () => {
               return await self.hardResetInvertedDTRWebUSB();
             },
           });
@@ -1047,31 +1056,31 @@ export class ESPLoader extends EventTarget {
           // CH340/CH343: UnixTight works best (like CP2102)
           resetStrategies.push({
             name: "UnixTight (WebUSB) - CH34x",
-            fn: async function () {
+            fn: async () => {
               return await self.hardResetUnixTightWebUSB();
             },
           });
           resetStrategies.push({
             name: "Classic (WebUSB) - CH34x",
-            fn: async function () {
+            fn: async () => {
               return await self.hardResetClassicWebUSB();
             },
           });
           resetStrategies.push({
             name: "Inverted Both (WebUSB) - CH34x",
-            fn: async function () {
+            fn: async () => {
               return await self.hardResetInvertedWebUSB();
             },
           });
           resetStrategies.push({
             name: "Inverted RTS (WebUSB) - CH34x",
-            fn: async function () {
+            fn: async () => {
               return await self.hardResetInvertedRTSWebUSB();
             },
           });
           resetStrategies.push({
             name: "Inverted DTR (WebUSB) - CH34x",
-            fn: async function () {
+            fn: async () => {
               return await self.hardResetInvertedDTRWebUSB();
             },
           });
@@ -1081,35 +1090,35 @@ export class ESPLoader extends EventTarget {
 
           resetStrategies.push({
             name: "UnixTight (WebUSB) - CP2102",
-            fn: async function () {
+            fn: async () => {
               return await self.hardResetUnixTightWebUSB();
             },
           });
 
           resetStrategies.push({
             name: "Classic (WebUSB) - CP2102",
-            fn: async function () {
+            fn: async () => {
               return await self.hardResetClassicWebUSB();
             },
           });
 
           resetStrategies.push({
             name: "Inverted Both (WebUSB) - CP2102",
-            fn: async function () {
+            fn: async () => {
               return await self.hardResetInvertedWebUSB();
             },
           });
 
           resetStrategies.push({
             name: "Inverted RTS (WebUSB) - CP2102",
-            fn: async function () {
+            fn: async () => {
               return await self.hardResetInvertedRTSWebUSB();
             },
           });
 
           resetStrategies.push({
             name: "Inverted DTR (WebUSB) - CP2102",
-            fn: async function () {
+            fn: async () => {
               return await self.hardResetInvertedDTRWebUSB();
             },
           });
@@ -1117,7 +1126,7 @@ export class ESPLoader extends EventTarget {
           // For other USB-Serial chips, try UnixTight first, then multiple strategies
           resetStrategies.push({
             name: "UnixTight (WebUSB)",
-            fn: async function () {
+            fn: async () => {
               return await self.hardResetUnixTightWebUSB();
             },
           });
@@ -1195,7 +1204,6 @@ export class ESPLoader extends EventTarget {
         }
       }
     } else {
-      // Web Serial (Desktop) strategies
       // Strategy: USB-JTAG/Serial reset
       if (isUSBJTAGSerial || isEspressifUSB) {
         resetStrategies.push({
@@ -1306,9 +1314,9 @@ export class ESPLoader extends EventTarget {
       // just reset (no bootloader mode)
       if (this.isWebUSB()) {
         // WebUSB: Use longer delays for better compatibility
-        await this.setRTS(true); // EN->LOW
+        await this.setRTSWebUSB(true); // EN->LOW
         await this.sleep(200);
-        await this.setRTS(false);
+        await this.setRTSWebUSB(false);
         await this.sleep(200);
         this.logger.log("Hard reset (WebUSB).");
       } else {
@@ -1550,6 +1558,13 @@ export class ESPLoader extends EventTarget {
         // Process all available bytes without going back to outer loop
         // This is critical for handling high-speed burst transfers
         while (this._inputBufferAvailable > 0) {
+          // Periodic timeout check to prevent hang on slow data
+          if (Date.now() - startTime > timeout) {
+            const waitingFor = partialPacket === null ? "header" : "content";
+            throw new SlipReadError(
+              "Timed out waiting for packet " + waitingFor,
+            );
+          }
           const b = this._readByte()!;
 
           if (partialPacket === null) {
@@ -2665,7 +2680,21 @@ export class ESPLoader extends EventTarget {
         resolve(undefined);
         return;
       }
-      this.addEventListener("disconnect", resolve, { once: true });
+
+      // Set a timeout to prevent hanging (important for node-usb)
+      const timeout = setTimeout(() => {
+        this.logger.debug("Disconnect timeout - forcing resolution");
+        resolve(undefined);
+      }, 1000);
+
+      this.addEventListener(
+        "disconnect",
+        () => {
+          clearTimeout(timeout);
+          resolve(undefined);
+        },
+        { once: true },
+      );
 
       // Only cancel if reader is still active
       try {
@@ -2673,10 +2702,19 @@ export class ESPLoader extends EventTarget {
       } catch (err) {
         this.logger.debug(`Reader cancel error: ${err}`);
         // Reader already released, resolve immediately
+        clearTimeout(timeout);
         resolve(undefined);
       }
     });
     this.connected = false;
+
+    // Close the port (important for node-usb adapter)
+    try {
+      await this.port.close();
+      this.logger.debug("Port closed successfully");
+    } catch (err) {
+      this.logger.debug(`Port close error: ${err}`);
+    }
   }
 
   /**
@@ -3346,6 +3384,12 @@ class EspStubLoader extends ESPLoader {
     if (size > maxValue) {
       throw new Error(`Size ${size} exceeds maximum value ${maxValue}`);
     }
+    // Check for wrap-around
+    if (offset + size > maxValue) {
+      throw new Error(
+        `Region end (offset + size = ${offset + size}) exceeds maximum addressable range ${maxValue}`,
+      );
+    }
 
     const timeout = timeoutPerMb(ERASE_REGION_TIMEOUT_PER_MB, size);
     const buffer = pack("<II", offset, size);

package/src/index.ts

@@ -21,39 +21,68 @@ export {
   CHIP_FAMILY_ESP32H21,
   CHIP_FAMILY_ESP32P4,
   CHIP_FAMILY_ESP32S31,
+  // Command constants
+  ESP_FLASH_BEGIN,
+  ESP_FLASH_DATA,
+  ESP_FLASH_END,
+  ESP_MEM_BEGIN,
+  ESP_MEM_END,
+  ESP_MEM_DATA,
+  ESP_SYNC,
+  ESP_WRITE_REG,
+  ESP_READ_REG,
+  ESP_ERASE_FLASH,
+  ESP_ERASE_REGION,
+  ESP_READ_FLASH,
+  ESP_SPI_SET_PARAMS,
+  ESP_SPI_ATTACH,
+  ESP_CHANGE_BAUDRATE,
+  ESP_SPI_FLASH_MD5,
+  ESP_GET_SECURITY_INFO,
+  ESP_CHECKSUM_MAGIC,
+  ESP_FLASH_DEFL_BEGIN,
+  ESP_FLASH_DEFL_DATA,
+  ESP_FLASH_DEFL_END,
+  ROM_INVALID_RECV_MSG,
+  // Block size constants
+  USB_RAM_BLOCK,
+  ESP_RAM_BLOCK,
+  // Timeout constants
+  DEFAULT_TIMEOUT,
+  CHIP_ERASE_TIMEOUT,
+  MAX_TIMEOUT,
+  SYNC_TIMEOUT,
+  ERASE_REGION_TIMEOUT_PER_MB,
+  MEM_END_ROM_TIMEOUT,
+  FLASH_READ_TIMEOUT,
 } from "./const";
 
 export const connect = async (logger: Logger) => {
+  // - Request a port and open a connection.
+  // Try to use requestSerialPort if available (supports WebUSB for Android)
   let port: SerialPort;
-
-  // Check if a custom requestSerialPort function is available (e.g., from WebUSB wrapper)
   const customRequestPort = (
     globalThis as { requestSerialPort?: () => Promise<SerialPort> }
   ).requestSerialPort;
-
   if (typeof customRequestPort === "function") {
-    // Use custom port request function (handles Android/WebUSB automatically)
-    logger.log("Using custom port request function");
     port = await customRequestPort();
   } else {
-    // Fallback to standard Web Serial API
+    // Check if Web Serial API is available
     if (!navigator.serial) {
       throw new Error(
         "Web Serial API is not supported in this browser. " +
-          "Please use Chrome 89+, Edge 89+, or Opera on desktop, or Chrome 61+ on Android with USB OTG. " +
+          "Please use Chrome, Edge, or Opera on desktop, or Chrome on Android. " +
           "Note: The page must be served over HTTPS or localhost.",
       );
     }
     port = await navigator.serial.requestPort();
   }
 
-  // Only open if not already open (WebUSB may return an opened port)
+  // Only open if not already open (requestSerialPort may return an opened port)
   if (!port.readable || !port.writable) {
     await port.open({ baudRate: ESP_ROM_BAUD });
   }
 
-  logger.log("Connected successfully.");
-
   return new ESPLoader(port, logger);
 };
 
@@ -63,12 +92,10 @@ export const connectWithPort = async (port: SerialPort, logger: Logger) => {
     throw new Error("Port is required");
   }
 
-  // Only open if not already open
+  // Check if port is already open, if not open it
   if (!port.readable || !port.writable) {
     await port.open({ baudRate: ESP_ROM_BAUD });
   }
 
-  logger.log("Connected successfully.");
-
   return new ESPLoader(port, logger);
 };