tasmota-webserial-esptool 7.3.0 → 7.3.2

package/src/esp_loader.ts

@@ -85,6 +85,8 @@ export class ESPLoader extends EventTarget {
   private _reader?: ReadableStreamDefaultReader<Uint8Array>;
   private _isESP32S2NativeUSB: boolean = false;
   private _initializationSucceeded: boolean = false;
+  private __commandLock: Promise<[number, number[]]> = Promise.resolve([0, []]);
+  private _isReconfiguring: boolean = false;
 
   constructor(
     public port: SerialPort,
@@ -112,6 +114,18 @@ export class ESPLoader extends EventTarget {
     }
   }
 
+  private get _commandLock(): Promise<[number, number[]]> {
+    return this._parent ? this._parent._commandLock : this.__commandLock;
+  }
+
+  private set _commandLock(value: Promise<[number, number[]]>) {
+    if (this._parent) {
+      this._parent._commandLock = value;
+    } else {
+      this.__commandLock = value;
+    }
+  }
+
   private detectUSBSerialChip(
     vendorId: number,
     productId: number,
@@ -549,6 +563,9 @@ export class ESPLoader extends EventTarget {
    * Send a command packet, check that the command succeeded and
    * return a tuple with the value and data.
    * See the ESP Serial Protocol for more details on what value/data are
+   *
+   * Commands are serialized to prevent concurrent execution which can cause
+   * WritableStream lock contention on CP210x adapters under Windows
    */
   async checkCommand(
     opcode: number,
@@ -556,69 +573,77 @@ export class ESPLoader extends EventTarget {
     checksum = 0,
     timeout = DEFAULT_TIMEOUT,
   ): Promise<[number, number[]]> {
-    timeout = Math.min(timeout, MAX_TIMEOUT);
-    await this.sendCommand(opcode, buffer, checksum);
-    const [value, responseData] = await this.getResponse(opcode, timeout);
-
-    if (responseData === null) {
-      throw new Error("Didn't get enough status bytes");
-    }
-
-    let data = responseData;
-    let statusLen = 0;
+    // Serialize command execution to prevent lock contention
+    const executeCommand = async (): Promise<[number, number[]]> => {
+      timeout = Math.min(timeout, MAX_TIMEOUT);
+      await this.sendCommand(opcode, buffer, checksum);
+      const [value, responseData] = await this.getResponse(opcode, timeout);
+
+      if (responseData === null) {
+        throw new Error("Didn't get enough status bytes");
+      }
 
-    if (this.IS_STUB || this.chipFamily == CHIP_FAMILY_ESP8266) {
-      statusLen = 2;
-    } else if (
-      [
-        CHIP_FAMILY_ESP32,
-        CHIP_FAMILY_ESP32S2,
-        CHIP_FAMILY_ESP32S3,
-        CHIP_FAMILY_ESP32C2,
-        CHIP_FAMILY_ESP32C3,
-        CHIP_FAMILY_ESP32C5,
-        CHIP_FAMILY_ESP32C6,
-        CHIP_FAMILY_ESP32C61,
-        CHIP_FAMILY_ESP32H2,
-        CHIP_FAMILY_ESP32H4,
-        CHIP_FAMILY_ESP32H21,
-        CHIP_FAMILY_ESP32P4,
-        CHIP_FAMILY_ESP32S31,
-      ].includes(this.chipFamily)
-    ) {
-      statusLen = 4;
-    } else {
-      // When chipFamily is not yet set (e.g., during GET_SECURITY_INFO in detectChip),
-      // assume modern chips use 4-byte status
-      if (opcode === ESP_GET_SECURITY_INFO) {
+      let data = responseData;
+      let statusLen = 0;
+
+      if (this.IS_STUB || this.chipFamily == CHIP_FAMILY_ESP8266) {
+        statusLen = 2;
+      } else if (
+        [
+          CHIP_FAMILY_ESP32,
+          CHIP_FAMILY_ESP32S2,
+          CHIP_FAMILY_ESP32S3,
+          CHIP_FAMILY_ESP32C2,
+          CHIP_FAMILY_ESP32C3,
+          CHIP_FAMILY_ESP32C5,
+          CHIP_FAMILY_ESP32C6,
+          CHIP_FAMILY_ESP32C61,
+          CHIP_FAMILY_ESP32H2,
+          CHIP_FAMILY_ESP32H4,
+          CHIP_FAMILY_ESP32H21,
+          CHIP_FAMILY_ESP32P4,
+          CHIP_FAMILY_ESP32S31,
+        ].includes(this.chipFamily)
+      ) {
         statusLen = 4;
-      } else if ([2, 4].includes(data.length)) {
-        statusLen = data.length;
+      } else {
+        // When chipFamily is not yet set (e.g., during GET_SECURITY_INFO in detectChip),
+        // assume modern chips use 4-byte status
+        if (opcode === ESP_GET_SECURITY_INFO) {
+          statusLen = 4;
+        } else if ([2, 4].includes(data.length)) {
+          statusLen = data.length;
+        }
       }
-    }
 
-    if (data.length < statusLen) {
-      throw new Error("Didn't get enough status bytes");
-    }
-    const status = data.slice(-statusLen, data.length);
-    data = data.slice(0, -statusLen);
-    if (this.debug) {
-      this.logger.debug("status", status);
-      this.logger.debug("value", value);
-      this.logger.debug("data", data);
-    }
-    if (status[0] == 1) {
-      if (status[1] == ROM_INVALID_RECV_MSG) {
-        // Unsupported command can result in more than one error response
-        // Use drainInputBuffer for CP210x compatibility on Windows
-        await this.drainInputBuffer(200);
-        throw new Error("Invalid (unsupported) command " + toHex(opcode));
-      } else {
-        throw new Error("Command failure error code " + toHex(status[1]));
+      if (data.length < statusLen) {
+        throw new Error("Didn't get enough status bytes");
+      }
+      const status = data.slice(-statusLen, data.length);
+      data = data.slice(0, -statusLen);
+      if (this.debug) {
+        this.logger.debug("status", status);
+        this.logger.debug("value", value);
+        this.logger.debug("data", data);
+      }
+      if (status[0] == 1) {
+        if (status[1] == ROM_INVALID_RECV_MSG) {
+          // Unsupported command can result in more than one error response
+          // Use drainInputBuffer for CP210x compatibility on Windows
+          await this.drainInputBuffer(200);
+          throw new Error("Invalid (unsupported) command " + toHex(opcode));
+        } else {
+          throw new Error("Command failure error code " + toHex(status[1]));
+        }
       }
-    }
 
-    return [value, data];
+      return [value, data];
+    };
+
+    // Chain command execution through the lock
+    // Use both .then() handlers to ensure lock continues even on error
+    this._commandLock = this._commandLock.then(executeCommand, executeCommand);
+    return this._commandLock;
   }
 
   /**
@@ -819,6 +844,25 @@ export class ESPLoader extends EventTarget {
 
   async reconfigurePort(baud: number) {
     try {
+      this._isReconfiguring = true;
+
+      // Wait for pending writes to complete
+      try {
+        await this._writeChain;
+      } catch (err) {
+        this.logger.debug(`Pending write error during reconfigure: ${err}`);
+      }
+
+      // Release persistent writer before closing
+      if (this._writer) {
+        try {
+          this._writer.releaseLock();
+        } catch (err) {
+          this.logger.debug(`Writer release error during reconfigure: ${err}`);
+        }
+        this._writer = undefined;
+      }
+
       // SerialPort does not allow to be reconfigured while open so we close and re-open
       // reader.cancel() causes the Promise returned by the read() operation running on
       // the readLoop to return immediately with { value: undefined, done: true } and thus
@@ -837,6 +881,8 @@ export class ESPLoader extends EventTarget {
     } catch (e) {
       this.logger.error(`Reconfigure port error: ${e}`);
       throw new Error(`Unable to change the baud rate to ${baud}: ${e}`);
+    } finally {
+      this._isReconfiguring = false;
     }
   }
 
@@ -1583,18 +1629,98 @@ export class ESPLoader extends EventTarget {
     return espStubLoader;
   }
 
+  __writer?: WritableStreamDefaultWriter<Uint8Array>;
+  __writeChain: Promise<void> = Promise.resolve();
+
+  private get _writer(): WritableStreamDefaultWriter<Uint8Array> | undefined {
+    return this._parent ? this._parent._writer : this.__writer;
+  }
+
+  private set _writer(
+    value: WritableStreamDefaultWriter<Uint8Array> | undefined,
+  ) {
+    if (this._parent) {
+      this._parent._writer = value;
+    } else {
+      this.__writer = value;
+    }
+  }
+
+  private get _writeChain(): Promise<void> {
+    return this._parent ? this._parent._writeChain : this.__writeChain;
+  }
+
+  private set _writeChain(value: Promise<void>) {
+    if (this._parent) {
+      this._parent._writeChain = value;
+    } else {
+      this.__writeChain = value;
+    }
+  }
+
   async writeToStream(data: number[]) {
     if (!this.port.writable) {
       this.logger.debug("Port writable stream not available, skipping write");
       return;
     }
-    const writer = this.port.writable.getWriter();
-    await writer.write(new Uint8Array(data));
-    try {
-      writer.releaseLock();
-    } catch (err) {
-      this.logger.error(`Ignoring release lock error: ${err}`);
+
+    if (this._isReconfiguring) {
+      throw new Error("Cannot write during port reconfiguration");
     }
+
+    // Queue writes to prevent lock contention (critical for CP2102 on Windows)
+    this._writeChain = this._writeChain
+      .then(
+        async () => {
+          // Check if port is still writable before attempting write
+          if (!this.port.writable) {
+            throw new Error("Port became unavailable during write");
+          }
+
+          // Get or create persistent writer
+          if (!this._writer) {
+            try {
+              this._writer = this.port.writable.getWriter();
+            } catch (err) {
+              this.logger.error(`Failed to get writer: ${err}`);
+              throw err;
+            }
+          }
+
+          // Perform the write
+          await this._writer.write(new Uint8Array(data));
+        },
+        async () => {
+          // Previous write failed, but still attempt this write
+          if (!this.port.writable) {
+            throw new Error("Port became unavailable during write");
+          }
+
+          // Writer was likely cleaned up by previous error, create new one
+          if (!this._writer) {
+            this._writer = this.port.writable.getWriter();
+          }
+
+          await this._writer.write(new Uint8Array(data));
+        },
+      )
+      .catch((err) => {
+        this.logger.error(`Write error: ${err}`);
+        // Ensure writer is cleaned up on any error
+        if (this._writer) {
+          try {
+            this._writer.releaseLock();
+          } catch (e) {
+            // Ignore release errors
+          }
+          this._writer = undefined;
+        }
+        // Re-throw to propagate error
+        throw err;
+      });
+
+    // Always await the write chain to ensure errors are caught
+    await this._writeChain;
   }
 
   async disconnect() {
@@ -1606,15 +1732,49 @@ export class ESPLoader extends EventTarget {
       this.logger.debug("Port already closed, skipping disconnect");
       return;
     }
-    await this.port.writable.getWriter().close();
-    await new Promise((resolve) => {
-      if (!this._reader) {
-        resolve(undefined);
+
+    try {
+      this._isReconfiguring = true;
+
+      // Wait for pending writes to complete
+      try {
+        await this._writeChain;
+      } catch (err) {
+        this.logger.debug(`Pending write error during disconnect: ${err}`);
       }
-      this.addEventListener("disconnect", resolve, { once: true });
-      this._reader!.cancel();
-    });
-    this.connected = false;
+
+      // Release persistent writer before closing
+      if (this._writer) {
+        try {
+          await this._writer.close();
+          this._writer.releaseLock();
+        } catch (err) {
+          this.logger.debug(`Writer close/release error: ${err}`);
+        }
+        this._writer = undefined;
+      } else {
+        // No persistent writer exists, close stream directly
+        // This path is taken when no writes have been queued
+        try {
+          const writer = this.port.writable.getWriter();
+          await writer.close();
+          writer.releaseLock();
+        } catch (err) {
+          this.logger.debug(`Direct writer close error: ${err}`);
+        }
+      }
+
+      await new Promise((resolve) => {
+        if (!this._reader) {
+          resolve(undefined);
+        }
+        this.addEventListener("disconnect", resolve, { once: true });
+        this._reader!.cancel();
+      });
+      this.connected = false;
+    } finally {
+      this._isReconfiguring = false;
+    }
   }
 
   /**
@@ -1627,99 +1787,122 @@ export class ESPLoader extends EventTarget {
       return;
     }
 
-    this.logger.log("Reconnecting serial port...");
+    try {
+      this._isReconfiguring = true;
 
-    this.connected = false;
-    this.__inputBuffer = [];
+      this.logger.log("Reconnecting serial port...");
 
-    // Cancel reader
-    if (this._reader) {
+      this.connected = false;
+      this.__inputBuffer = [];
+
+      // Wait for pending writes to complete
       try {
-        await this._reader.cancel();
+        await this._writeChain;
       } catch (err) {
-        this.logger.debug(`Reader cancel error: ${err}`);
+        this.logger.debug(`Pending write error during reconnect: ${err}`);
       }
-      this._reader = undefined;
-    }
 
-    // Close port
-    try {
-      await this.port.close();
-      this.logger.log("Port closed");
-    } catch (err) {
-      this.logger.debug(`Port close error: ${err}`);
-    }
-
-    // Open the port
-    this.logger.debug("Opening port...");
-    try {
-      await this.port.open({ baudRate: ESP_ROM_BAUD });
-      this.connected = true;
-    } catch (err) {
-      throw new Error(`Failed to open port: ${err}`);
-    }
+      // Release persistent writer
+      if (this._writer) {
+        try {
+          this._writer.releaseLock();
+        } catch (err) {
+          this.logger.debug(`Writer release error during reconnect: ${err}`);
+        }
+        this._writer = undefined;
+      }
 
-    // Verify port streams are available
-    if (!this.port.readable || !this.port.writable) {
-      throw new Error(
-        `Port streams not available after open (readable: ${!!this.port.readable}, writable: ${!!this.port.writable})`,
-      );
-    }
+      // Cancel reader
+      if (this._reader) {
+        try {
+          await this._reader.cancel();
+        } catch (err) {
+          this.logger.debug(`Reader cancel error: ${err}`);
+        }
+        this._reader = undefined;
+      }
 
-    // Save chip info and flash size (no need to detect again)
-    const savedChipFamily = this.chipFamily;
-    const savedChipName = this.chipName;
-    const savedChipRevision = this.chipRevision;
-    const savedChipVariant = this.chipVariant;
-    const savedFlashSize = this.flashSize;
+      // Close port
+      try {
+        await this.port.close();
+        this.logger.log("Port closed");
+      } catch (err) {
+        this.logger.debug(`Port close error: ${err}`);
+      }
 
-    // Reinitialize
-    await this.hardReset(true);
+      // Open the port
+      this.logger.debug("Opening port...");
+      try {
+        await this.port.open({ baudRate: ESP_ROM_BAUD });
+        this.connected = true;
+      } catch (err) {
+        throw new Error(`Failed to open port: ${err}`);
+      }
 
-    if (!this._parent) {
-      this.__inputBuffer = [];
-      this.__totalBytesRead = 0;
-      this.readLoop();
-    }
+      // Verify port streams are available
+      if (!this.port.readable || !this.port.writable) {
+        throw new Error(
+          `Port streams not available after open (readable: ${!!this.port.readable}, writable: ${!!this.port.writable})`,
+        );
+      }
 
-    await this.flushSerialBuffers();
-    await this.sync();
+      // Save chip info and flash size (no need to detect again)
+      const savedChipFamily = this.chipFamily;
+      const savedChipName = this.chipName;
+      const savedChipRevision = this.chipRevision;
+      const savedChipVariant = this.chipVariant;
+      const savedFlashSize = this.flashSize;
 
-    // Restore chip info
-    this.chipFamily = savedChipFamily;
-    this.chipName = savedChipName;
-    this.chipRevision = savedChipRevision;
-    this.chipVariant = savedChipVariant;
-    this.flashSize = savedFlashSize;
+      // Reinitialize
+      await this.hardReset(true);
 
-    this.logger.debug(`Reconnect complete (chip: ${this.chipName})`);
+      if (!this._parent) {
+        this.__inputBuffer = [];
+        this.__totalBytesRead = 0;
+        this.readLoop();
+      }
 
-    // Verify port is ready
-    if (!this.port.writable || !this.port.readable) {
-      throw new Error("Port not ready after reconnect");
-    }
+      await this.flushSerialBuffers();
+      await this.sync();
 
-    // Load stub
-    const stubLoader = await this.runStub(true);
-    this.logger.debug("Stub loaded");
+      // Restore chip info
+      this.chipFamily = savedChipFamily;
+      this.chipName = savedChipName;
+      this.chipRevision = savedChipRevision;
+      this.chipVariant = savedChipVariant;
+      this.flashSize = savedFlashSize;
 
-    // Restore baudrate if it was changed
-    if (this._currentBaudRate !== ESP_ROM_BAUD) {
-      await stubLoader.setBaudrate(this._currentBaudRate);
+      this.logger.debug(`Reconnect complete (chip: ${this.chipName})`);
 
-      // Verify port is still ready after baudrate change
+      // Verify port is ready
       if (!this.port.writable || !this.port.readable) {
-        throw new Error(
-          `Port not ready after baudrate change (readable: ${!!this.port.readable}, writable: ${!!this.port.writable})`,
-        );
+        throw new Error("Port not ready after reconnect");
       }
-    }
 
-    // Copy stub state to this instance if we're a stub loader
-    if (this.IS_STUB) {
-      Object.assign(this, stubLoader);
+      // Load stub
+      const stubLoader = await this.runStub(true);
+      this.logger.debug("Stub loaded");
+
+      // Restore baudrate if it was changed
+      if (this._currentBaudRate !== ESP_ROM_BAUD) {
+        await stubLoader.setBaudrate(this._currentBaudRate);
+
+        // Verify port is still ready after baudrate change
+        if (!this.port.writable || !this.port.readable) {
+          throw new Error(
+            `Port not ready after baudrate change (readable: ${!!this.port.readable}, writable: ${!!this.port.writable})`,
+          );
+        }
+      }
+
+      // Copy stub state to this instance if we're a stub loader
+      if (this.IS_STUB) {
+        Object.assign(this, stubLoader);
+      }
+      this.logger.debug("Reconnection successful");
+    } finally {
+      this._isReconfiguring = false;
     }
-    this.logger.debug("Reconnection successful");
   }
 
   /**

package/src/stubs/README.md

@@ -1,3 +1,3 @@
 # Licensing
 
-The binaries in JSON format distributed in this directory are released as Free Software under GNU General Public License Version 2 or later. They were released at https://github.com/espressif/esptool-legacy-flasher-stub/releases/tag/v1.10.0 from where the sources can be obtained.
+The binaries in JSON format distributed in this directory are released as Free Software under GNU General Public License Version 2 or later. The sources can be obtained from https://github.com/espressif/esptool-legacy-flasher-stub/

package/src/stubs/esp32c3.json

@@ -1,8 +1,8 @@
 {
-    "entry": 1077413608,
-    "text": "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",
+    "entry": 1077413654,
+    "text": "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",
     "text_start": 1077411840,
-    "data": "FEDIP6wKOEAWCzhAqAs4QHwMOEDkDDhAkgw4QIYJOEA4DDhAeAw4QMQLOEA2CThA7As4QDYJOECKCjhA1Ao4QBYLOECoCzhAnAo4QK4JOED6CThAmAo4QN4OOEAWCzhAoA04QJoOOED0CDhAwA44QPQIOED0CDhA9Ag4QPQIOED0CDhA9Ag4QPQIOED0CDhARg04QPQIOEC4DThAmg44QA==",
+    "data": "FEDIP9oKOEBECzhA1gs4QKoMOEASDThAwAw4QLQJOEBmDDhApgw4QPILOEBkCThAGgw4QGQJOEC4CjhAAgs4QEQLOEDWCzhAygo4QNwJOEAoCjhAxgo4QAwPOEBECzhAzg04QMgOOEAiCThA7g44QCIJOEAiCThAIgk4QCIJOEAiCThAIgk4QCIJOEAiCThAdA04QCIJOEDmDThAyA44QA==",
     "data_start": 1070164916,
     "bss_start": 1070088192
 }

package/src/stubs/esp32c5.json

@@ -1,8 +1,8 @@
 {
-    "entry": 1082133142,
-    "text": "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",
+    "entry": 1082133196,
+    "text": "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",
     "text_start": 1082130432,
-    "data": "FACEQPoOgEBkD4BA+A+AQMwQgEA0EYBA4hCAQFQNgECIEIBAyBCAQBQQgEAEDYBAPBCAQAQNgEDWDoBAIg+AQGQPgED4D4BA6A6AQHwNgECqDYBA5A6AQC4TgEBkD4BA8BGAQOoSgEC+DIBAEBOAQL4MgEC+DIBAvgyAQL4MgEC+DIBAvgyAQL4MgEC+DIBAlhGAQL4MgEAIEoBA6hKAQA==",
+    "data": "FACEQDAPgECaD4BALhCAQAIRgEBqEYBAGBGAQIoNgEC+EIBA/hCAQEoQgEA6DYBAchCAQDoNgEAMD4BAWA+AQJoPgEAuEIBAHg+AQLINgEDgDYBAGg+AQGQTgECaD4BAJhKAQCATgED0DIBARhOAQPQMgED0DIBA9AyAQPQMgED0DIBA9AyAQPQMgED0DIBAzBGAQPQMgEA+EoBAIBOAQA==",
     "data_start": 1082469300,
     "bss_start": 1082392576
 }