tasmota-esp-web-tools 11.0.0 → 11.0.1

package/dist/connect.js

@@ -1,29 +1,72 @@
+import { connect as esptoolConnect } from "tasmota-webserial-esptool";
+/**
+ * Detect if running on Android
+ */
+const isAndroid = () => {
+    const userAgent = navigator.userAgent || "";
+    return /Android/i.test(userAgent);
+};
+/**
+ * Load WebUSB serial wrapper for Android
+ */
+const loadWebUSBSerial = async () => {
+    // Check if already loaded
+    if (globalThis.requestSerialPort) {
+        return;
+    }
+    // Dynamically load the WebUSB serial script from the npm package
+    return new Promise((resolve, reject) => {
+        const script = document.createElement("script");
+        script.type = "module";
+        script.src =
+            "https://unpkg.com/tasmota-webserial-esptool/js/webusb-serial.js";
+        script.onload = () => {
+            if (globalThis.requestSerialPort) {
+                resolve();
+            }
+            else {
+                reject(new Error("WebUSB serial script loaded but requestSerialPort not found"));
+            }
+        };
+        script.onerror = () => reject(new Error("Failed to load WebUSB serial script"));
+        document.head.appendChild(script);
+    });
+};
 export const connect = async (button) => {
     import("./install-dialog.js");
-    let port;
+    // Android: Load WebUSB support first
+    if (isAndroid() && "usb" in navigator) {
+        try {
+            await loadWebUSBSerial();
+        }
+        catch (err) {
+            alert(`Failed to load WebUSB support: ${err.message}`);
+            return;
+        }
+    }
+    // Use tasmota-webserial-esptool's connect() - handles ALL port logic
+    let esploader;
     try {
-        port = await navigator.serial.requestPort();
+        esploader = await esptoolConnect({
+            log: () => { }, // Silent logger for connection
+            debug: () => { },
+            error: (msg) => console.error(msg),
+        });
     }
     catch (err) {
         if (err.name === "NotFoundError") {
             import("./no-port-picked/index").then((mod) => mod.openNoPortPickedDialog(() => connect(button)));
             return;
         }
-        alert(`Error: ${err.message}`);
+        alert(`Connection failed: ${err.message}`);
         return;
     }
-    if (!port) {
-        return;
-    }
-    try {
-        await port.open({ baudRate: 115200 });
-    }
-    catch (err) {
-        alert(err.message);
+    if (!esploader) {
+        alert("Failed to connect to device");
         return;
     }
     const el = document.createElement("ewt-install-dialog");
-    el.port = port;
+    el.esploader = esploader; // Pass ESPLoader instead of port
     el.manifestPath = button.manifest || button.getAttribute("manifest");
     el.overrides = button.overrides;
     el.firmwareFile = button.firmwareFile;
@@ -38,8 +81,13 @@ export const connect = async (button) => {
     else if (button.baudRate !== undefined) {
         el.baudRate = button.baudRate;
     }
-    el.addEventListener("closed", () => {
-        port.close();
+    el.addEventListener("closed", async () => {
+        try {
+            await esploader.disconnect();
+        }
+        catch (err) {
+            // Ignore disconnect errors
+        }
     }, { once: true });
     document.body.appendChild(el);
 };

package/dist/const.d.ts

@@ -72,13 +72,7 @@ export interface ErrorState extends BaseFlashState {
         details: string | Error;
     };
 }
-export interface ESP32S2USBReconnectState extends BaseFlashState {
-    state: FlashStateType.ESP32_S2_USB_RECONNECT;
-    details: {
-        oldPort: SerialPort;
-    };
-}
-export type FlashState = InitializingState | ManifestState | PreparingState | ErasingState | WritingState | FinishedState | ErrorState | ESP32S2USBReconnectState;
+export type FlashState = InitializingState | ManifestState | PreparingState | ErasingState | WritingState | FinishedState | ErrorState;
 export declare const enum FlashStateType {
     INITIALIZING = "initializing",
     MANIFEST = "manifest",
@@ -86,16 +80,14 @@ export declare const enum FlashStateType {
     ERASING = "erasing",
     WRITING = "writing",
     FINISHED = "finished",
-    ERROR = "error",
-    ESP32_S2_USB_RECONNECT = "esp32_s2_usb_reconnect"
+    ERROR = "error"
 }
 export declare const enum FlashError {
     FAILED_INITIALIZING = "failed_initialize",
     FAILED_MANIFEST_FETCH = "fetch_manifest_failed",
     NOT_SUPPORTED = "not_supported",
     FAILED_FIRMWARE_DOWNLOAD = "failed_firmware_download",
-    WRITE_FAILED = "write_failed",
-    ESP32_S2_USB_RECONNECT = "esp32_s2_usb_reconnect"
+    WRITE_FAILED = "write_failed"
 }
 declare global {
     interface HTMLElementEventMap {

package/dist/flash.d.ts

@@ -1,3 +1,4 @@
 import { Logger } from "tasmota-webserial-esptool";
 import { FlashState } from "./const";
-export declare const flash: (onEvent: (state: FlashState) => void, port: SerialPort, logger: Logger, manifestPath: string, eraseFirst: boolean, firmwareBuffer: Uint8Array, baudRate?: number) => Promise<void>;
+export declare const flash: (onEvent: (state: FlashState) => void, esploader: any, // ESPLoader instance from tasmota-webserial-esptool
+logger: Logger, manifestPath: string, eraseFirst: boolean, firmwareBuffer: Uint8Array, baudRate?: number) => Promise<void>;

package/dist/flash.js

@@ -1,13 +1,11 @@
-import { ESPLoader } from "tasmota-webserial-esptool";
 import { getChipFamilyName } from "./util/chip-family-name";
 import { sleep } from "./util/sleep";
-import { isESP32S2NativeUSB, isESP32S2ReconnectError, closeAndForgetPort, } from "./util/esp32s2-reconnect";
-export const flash = async (onEvent, port, logger, manifestPath, eraseFirst, firmwareBuffer, baudRate) => {
+export const flash = async (onEvent, esploader, // ESPLoader instance from tasmota-webserial-esptool
+logger, manifestPath, eraseFirst, firmwareBuffer, baudRate) => {
     let manifest;
     let build;
     let chipFamily;
     let chipVariant = null;
-    const isS2NativeUSB = isESP32S2NativeUSB(port);
     const fireStateEvent = (stateUpdate) => onEvent({
         ...stateUpdate,
         manifest,
@@ -24,57 +22,31 @@ export const flash = async (onEvent, port, logger, manifestPath, eraseFirst, fir
         manifestURL = new URL(manifestPath, location.toString()).toString();
         manifestProm = fetch(manifestURL).then((resp) => resp.json());
     }
-    const esploader = new ESPLoader(port, logger);
+    // Use the provided ESPLoader instance - NO port logic here!
     // For debugging
     window.esploader = esploader;
-    // ESP32-S2 Native USB event handler - listen on ESPLoader instance
-    const handleESP32S2Reconnect = () => {
-        logger.log("ESP32-S2 Native USB disconnect detected - reconnection required");
-    };
-    // Register event listener for ESP32-S2 Native USB reconnect on ESPLoader
-    if (isS2NativeUSB) {
-        esploader.addEventListener("esp32s2-usb-reconnect", handleESP32S2Reconnect);
-        logger.log("ESP32-S2 Native USB detected - monitoring for port switch");
-    }
-    // Cleanup function to remove event listener
-    const cleanup = () => {
-        if (isS2NativeUSB) {
-            esploader.removeEventListener("esp32s2-usb-reconnect", handleESP32S2Reconnect);
-        }
-    };
     fireStateEvent({
         state: "initializing" /* FlashStateType.INITIALIZING */,
         message: "Initializing...",
         details: { done: false },
     });
-    try {
-        await esploader.initialize();
-    }
-    catch (err) {
-        logger.error(err);
-        // Check if this is an ESP32-S2 Native USB reconnect situation
-        if (isS2NativeUSB && isESP32S2ReconnectError(err)) {
-            cleanup();
-            // Close and forget the old port
-            await closeAndForgetPort(port);
-            // Fire reconnect event to trigger port reselection dialog
+    // Only initialize if not already done
+    if (!esploader.chipFamily) {
+        try {
+            await esploader.initialize();
+        }
+        catch (err) {
+            logger.error(err);
             fireStateEvent({
-                state: "esp32_s2_usb_reconnect" /* FlashStateType.ESP32_S2_USB_RECONNECT */,
-                message: "ESP32-S2 USB port changed - please select the new port",
-                details: { oldPort: port },
+                state: "error" /* FlashStateType.ERROR */,
+                message: "Failed to initialize. Try resetting your device or holding the BOOT button while clicking INSTALL.",
+                details: { error: "failed_initialize" /* FlashError.FAILED_INITIALIZING */, details: err },
             });
+            if (esploader.connected) {
+                await esploader.disconnect();
+            }
             return;
         }
-        cleanup();
-        fireStateEvent({
-            state: "error" /* FlashStateType.ERROR */,
-            message: "Failed to initialize. Try resetting your device or holding the BOOT button while clicking INSTALL.",
-            details: { error: "failed_initialize" /* FlashError.FAILED_INITIALIZING */, details: err },
-        });
-        if (esploader.connected) {
-            await esploader.disconnect();
-        }
-        return;
     }
     chipFamily = getChipFamilyName(esploader);
     chipVariant = esploader.chipVariant;
@@ -92,7 +64,6 @@ export const flash = async (onEvent, port, logger, manifestPath, eraseFirst, fir
         manifest = await manifestProm;
     }
     catch (err) {
-        cleanup();
         fireStateEvent({
             state: "error" /* FlashStateType.ERROR */,
             message: `Unable to fetch manifest: ${err}`,
@@ -106,80 +77,74 @@ export const flash = async (onEvent, port, logger, manifestPath, eraseFirst, fir
         if (b.chipFamily !== chipFamily) {
             return false;
         }
-        // If build specifies a chipVariant, it must match
-        if (b.chipVariant !== undefined) {
-            return b.chipVariant === chipVariant;
+        // If build specifies chipVariant, it must match
+        if (b.chipVariant && b.chipVariant !== chipVariant) {
+            return false;
         }
-        // If build doesn't specify chipVariant, it matches any variant
         return true;
     });
-    fireStateEvent({
-        state: "manifest" /* FlashStateType.MANIFEST */,
-        message: `Found manifest for ${manifest.name}`,
-        details: { done: true },
-    });
     if (!build) {
-        const chipInfo = chipVariant
-            ? `${chipFamily} (${chipVariant})`
-            : chipFamily;
-        cleanup();
         fireStateEvent({
             state: "error" /* FlashStateType.ERROR */,
-            message: `Your ${chipInfo} board is not supported.`,
-            details: { error: "not_supported" /* FlashError.NOT_SUPPORTED */, details: chipInfo },
+            message: `Your ${chipFamily}${chipVariant ? ` (${chipVariant})` : ""} is not supported by this firmware.`,
+            details: { error: "not_supported" /* FlashError.NOT_SUPPORTED */, details: chipFamily },
         });
         await esploader.disconnect();
         return;
     }
+    fireStateEvent({
+        state: "manifest" /* FlashStateType.MANIFEST */,
+        message: "Manifest fetched",
+        details: { done: true },
+    });
     fireStateEvent({
         state: "preparing" /* FlashStateType.PREPARING */,
         message: "Preparing installation...",
         details: { done: false },
     });
+    // The esploader passed in is always a stub (from _ensureStub())
+    // Baudrate was already set in _ensureStub()
+    const espStub = esploader;
+    // Verify stub has chipFamily (should be copied in _ensureStub)
+    if (!espStub.chipFamily) {
+        logger.error("Stub missing chipFamily - this should not happen!");
+        fireStateEvent({
+            state: "error" /* FlashStateType.ERROR */,
+            message: "Internal error: Stub not properly initialized",
+            details: {
+                error: "failed_initialize" /* FlashError.FAILED_INITIALIZING */,
+                details: "Missing chipFamily",
+            },
+        });
+        return;
+    }
+    logger.log(`Using stub: IS_STUB=${espStub.IS_STUB}, chipFamily=${espStub.chipFamily}`);
+    // Fetch firmware files
     const filePromises = build.parts.map(async (part) => {
-        if (firmwareBuffer.length == 0) {
-            //No firmware buffer provided, now download ...
-            const url = new URL(part.path, manifestURL).toString();
-            const resp = await fetch(url);
-            if (!resp.ok) {
-                throw new Error(`Downlading firmware ${part.path} failed: ${resp.status}`);
-            }
-            return resp.arrayBuffer();
+        const url = new URL(part.path, manifestURL || location.toString()).toString();
+        const resp = await fetch(url);
+        if (!resp.ok) {
+            throw new Error(`Downlading firmware ${part.path} failed: ${resp.status}`);
         }
-        // buffer from local file upload
-        return firmwareBuffer;
+        return resp.arrayBuffer();
     });
-    // Run the stub while we wait for files to download
-    const espStub = await esploader.runStub();
-    // Increase baud rate for faster flashing if specified via baud-rate attribute
-    // Default: No change (115200 baud - stub default)
-    // Can be set via baud-rate attribute in HTML (e.g., baud-rate="2000000")
-    if (baudRate !== undefined && baudRate > 115200) {
-        try {
-            await espStub.setBaudrate(baudRate);
-        }
-        catch (err) {
-            // If baud rate change fails, continue with default 115200
-            logger.log(`Could not change baud rate to ${baudRate}: ${err.message}`);
-        }
+    // If firmwareBuffer is provided, use it instead of fetching
+    if (firmwareBuffer) {
+        filePromises.push(Promise.resolve(firmwareBuffer.buffer));
     }
     const files = [];
     let totalSize = 0;
     for (const prom of filePromises) {
         try {
             const data = await prom;
-            files.push(data instanceof ArrayBuffer ? new Uint8Array(data) : data);
+            files.push(data);
             totalSize += data.byteLength;
         }
         catch (err) {
-            cleanup();
             fireStateEvent({
                 state: "error" /* FlashStateType.ERROR */,
                 message: err.message,
-                details: {
-                    error: "failed_firmware_download" /* FlashError.FAILED_FIRMWARE_DOWNLOAD */,
-                    details: err.message,
-                },
+                details: { error: "failed_firmware_download" /* FlashError.FAILED_FIRMWARE_DOWNLOAD */, details: err },
             });
             await esploader.disconnect();
             return;
@@ -190,78 +155,90 @@ export const flash = async (onEvent, port, logger, manifestPath, eraseFirst, fir
         message: "Installation prepared",
         details: { done: true },
     });
+    // CRITICAL: Erase MUST be done BEFORE writing, if requested
     if (eraseFirst) {
         fireStateEvent({
             state: "erasing" /* FlashStateType.ERASING */,
-            message: "Erasing device...",
+            message: "Erasing flash...",
             details: { done: false },
         });
-        await espStub.eraseFlash();
-        fireStateEvent({
-            state: "erasing" /* FlashStateType.ERASING */,
-            message: "Device erased",
-            details: { done: true },
-        });
+        try {
+            logger.log("Erasing flash memory. Please wait...");
+            await espStub.eraseFlash();
+            logger.log("Flash erased successfully");
+            fireStateEvent({
+                state: "erasing" /* FlashStateType.ERASING */,
+                message: "Flash erased",
+                details: { done: true },
+            });
+        }
+        catch (err) {
+            logger.error(`Flash erase failed: ${err.message}`);
+            fireStateEvent({
+                state: "error" /* FlashStateType.ERROR */,
+                message: `Failed to erase flash: ${err.message}`,
+                details: { error: "write_failed" /* FlashError.WRITE_FAILED */, details: err },
+            });
+            await esploader.disconnect();
+            return;
+        }
     }
-    let lastPct = 0;
     fireStateEvent({
         state: "writing" /* FlashStateType.WRITING */,
-        message: `Writing progress: ${lastPct}%`,
+        message: `Writing progress: 0 %`,
         details: {
             bytesTotal: totalSize,
             bytesWritten: 0,
-            percentage: lastPct,
+            percentage: 0,
         },
     });
-    let totalWritten = 0;
-    for (const part of build.parts) {
-        const file = files.shift();
-        const fileBuffer = file instanceof Uint8Array ? new Uint8Array(file).buffer : file;
-        try {
-            await espStub.flashData(fileBuffer, (bytesWritten) => {
-                const newPct = Math.floor(((totalWritten + bytesWritten) / totalSize) * 100);
+    let lastPct = 0;
+    let totalBytesWritten = 0;
+    try {
+        for (let i = 0; i < build.parts.length; i++) {
+            const part = build.parts[i];
+            const data = files[i];
+            await espStub.flashData(data, (bytesWritten, bytesTotal) => {
+                const newPct = Math.floor(((totalBytesWritten + bytesWritten) / totalSize) * 100);
                 if (newPct === lastPct) {
                     return;
                 }
                 lastPct = newPct;
                 fireStateEvent({
                     state: "writing" /* FlashStateType.WRITING */,
-                    message: `Writing progress: ${newPct}%`,
+                    message: `Writing progress: ${newPct} %`,
                     details: {
                         bytesTotal: totalSize,
-                        bytesWritten: totalWritten + bytesWritten,
+                        bytesWritten: totalBytesWritten + bytesWritten,
                         percentage: newPct,
                     },
                 });
-            }, part.offset, true);
+            }, part.offset);
+            totalBytesWritten += data.byteLength;
         }
-        catch (err) {
-            cleanup();
-            fireStateEvent({
-                state: "error" /* FlashStateType.ERROR */,
-                message: err.message,
-                details: { error: "write_failed" /* FlashError.WRITE_FAILED */, details: err },
-            });
-            await esploader.disconnect();
-            return;
-        }
-        totalWritten += file.byteLength;
+    }
+    catch (err) {
+        fireStateEvent({
+            state: "error" /* FlashStateType.ERROR */,
+            message: err.message,
+            details: { error: "write_failed" /* FlashError.WRITE_FAILED */, details: err },
+        });
+        await esploader.disconnect();
+        return;
     }
     fireStateEvent({
         state: "writing" /* FlashStateType.WRITING */,
         message: "Writing complete",
         details: {
             bytesTotal: totalSize,
-            bytesWritten: totalWritten,
+            bytesWritten: totalSize,
             percentage: 100,
         },
     });
     await sleep(100);
-    console.log("DISCONNECT");
-    await esploader.disconnect();
-    console.log("HARD RESET");
-    await esploader.hardReset();
-    cleanup();
+    // DON'T release locks after flash!
+    // Keep the stub and locks so the port can be used again
+    // (e.g., for Improv, Manage Filesystem, or another flash)
     fireStateEvent({
         state: "finished" /* FlashStateType.FINISHED */,
         message: "All done!",

package/dist/install-button.js

@@ -9,7 +9,7 @@ export class InstallButton extends HTMLElement {
             this.toggleAttribute("install-unsupported", true);
             this.renderRoot.innerHTML = !InstallButton.isAllowed
                 ? "<slot name='not-allowed'>You can only install ESP devices on HTTPS websites or on the localhost.</slot>"
-                : "<slot name='unsupported'>Your browser does not support installing things on ESP devices. Use Google Chrome or Microsoft Edge.</slot>";
+                : "<slot name='unsupported'>Your browser does not support installing things on ESP devices. Use Google Chrome or Microsoft Edge (Desktop) or Chrome on Android with USB OTG.</slot>";
             return;
         }
         this.toggleAttribute("install-supported", true);
@@ -36,7 +36,7 @@ export class InstallButton extends HTMLElement {
         this.renderRoot.append(slot);
     }
 }
-InstallButton.isSupported = "serial" in navigator;
+InstallButton.isSupported = "serial" in navigator || "usb" in navigator;
 InstallButton.isAllowed = window.isSecureContext;
 InstallButton.style = `
   button {

package/dist/install-dialog.d.ts

@@ -14,7 +14,7 @@ import "./pages/ewt-page-message";
 import { Logger, Manifest } from "./const.js";
 import { ImprovSerial } from "improv-wifi-serial-sdk/dist/serial";
 export declare class EwtInstallDialog extends LitElement {
-    port: SerialPort;
+    esploader: any;
     manifestPath: string;
     firmwareFile?: File;
     baudRate?: number;
@@ -33,12 +33,15 @@ export declare class EwtInstallDialog extends LitElement {
     private _wasProvisioned;
     private _error?;
     private _busy;
-    private _esp32s2ReconnectInProgress;
     private _ssids?;
     private _selectedSsid;
     private _partitions?;
     private _selectedPartition?;
     private _espStub?;
+    private _improvChecked;
+    private get _isAndroid();
+    private _ensureStub;
+    private get _port();
     protected render(): TemplateResult<1>;
     _renderProgress(label: string | TemplateResult, progress?: number): TemplateResult<1>;
     _renderError(label: string): [string, TemplateResult, boolean];
@@ -50,8 +53,6 @@ export declare class EwtInstallDialog extends LitElement {
     _renderLogs(): [string | undefined, TemplateResult, boolean];
     _renderPartitions(): [string | undefined, TemplateResult, boolean];
     _renderLittleFS(): [string | undefined, TemplateResult, boolean, boolean];
-    _renderESP32S2Reconnect(): [string | undefined, TemplateResult, boolean];
-    private _handleESP32S2ReconnectClick;
     private _readPartitionTable;
     private _openFilesystem;
     private _formatSize;
@@ -61,12 +62,6 @@ export declare class EwtInstallDialog extends LitElement {
     private _focusFormElement;
     private _initialize;
     private _startInstall;
-    /**
-     * Handle ESP32-S2 Native USB reconnect.
-     * When the ESP32-S2 switches from ROM bootloader to USB CDC mode,
-     * the USB port changes and we need to let the user select the new port.
-     */
-    private _handleESP32S2Reconnect;
     private _confirmInstall;
     _flashFilebuffer(fileBuffer: Uint8Array): Promise<void>;
     private _doProvision;