tasmota-esp-web-tools 12.1.2 → 12.2.1

package/README.md

@@ -108,6 +108,68 @@ The `chipVariant` field is optional. If omitted, the build will match any varian
 
 See [manifest-example-p4-variants.json](manifest-example-p4-variants.json) for a complete example.
 
+## Flash Size Support
+
+For chips with different flash sizes, you can specify `flashSizeMB` to target specific hardware configurations. This is useful for ESP32-S3 modules that come with various flash sizes.
+
+```json
+{
+  "name": "My Firmware",
+  "builds": [
+    {
+      "chipFamily": "ESP32-S3",
+      "flashSizeMB": 16,
+      "parts": [{ "path": "s3-16mb.bin", "offset": 0 }]
+    },
+    {
+      "chipFamily": "ESP32-S3",
+      "flashSizeMB": 4,
+      "parts": [{ "path": "s3-4mb.bin", "offset": 0 }]
+    },
+    {
+      "chipFamily": "ESP32-S3",
+      "parts": [{ "path": "s3-generic.bin", "offset": 0 }]
+    }
+  ]
+}
+```
+
+A device with ESP32-S3 and 16MB flash gets the first build, 4MB gets the second, and any other ESP32-S3 falls back to the third.
+
+The `flashSizeMB` field is **optional**. If omitted, the build will match any flash size. Builds with matching `flashSizeMB` are preferred over builds without it (most-specific-matching algorithm).
+
+## USB Interface Support (UART vs CDC)
+
+For chips that can be connected either through a native USB interface (USB-JTAG/USB-OTG, e.g. ESP32-S2/S3/C3/C6/...) or through an external USB-to-Serial bridge (CP210x, FTDI, CH340, ...), you can ship dedicated firmware variants by specifying `usbInterface`:
+
+- `"CDC"` – firmware built for native USB (CDC) console / programming
+- `"UART"` – firmware built for the regular UART console via an external USB-to-Serial chip
+
+```json
+{
+  "name": "My Firmware",
+  "builds": [
+    {
+      "chipFamily": "ESP32-S3",
+      "usbInterface": "CDC",
+      "parts": [{ "path": "s3-cdc.bin", "offset": 0 }]
+    },
+    {
+      "chipFamily": "ESP32-S3",
+      "usbInterface": "UART",
+      "parts": [{ "path": "s3-uart.bin", "offset": 0 }]
+    }
+  ]
+}
+```
+
+ESP Web Tools automatically detects how the device is connected:
+
+- If the device is reached via native USB (USB-JTAG/USB-OTG) the build with `usbInterface: "CDC"` is selected.
+- Otherwise (external USB-to-Serial bridge) the build with `usbInterface: "UART"` is selected.
+
+The `usbInterface` field is **optional**. If omitted, the build will match any USB interface and is used as a fallback. It can also be combined freely with `chipVariant` and `flashSizeMB`.
+
 ## Performance
 
 ESP Web Tools supports configurable baud rates for flashing. By default, it uses 115200 baud for maximum compatibility. You can increase the baud rate for significantly faster flashing speeds.

package/dist/components/ew-littlefs-manager.js

@@ -20,11 +20,13 @@ async function loadLittleFS() {
     try {
         // Try to import from the calculated path
         const indexUrl = _wasmBasePath + "index.js";
+        // eslint-disable-next-line no-console
         console.log("[LittleFS] Loading module from:", indexUrl);
         _littleFSModule = await import(/* @vite-ignore */ indexUrl);
         return _littleFSModule;
     }
     catch (err) {
+        // eslint-disable-next-line no-console
         console.error("[LittleFS] Failed to load from calculated path:", _wasmBasePath, err);
         // Fallback to relative import (for local development)
         try {
@@ -32,6 +34,7 @@ async function loadLittleFS() {
             return _littleFSModule;
         }
         catch (fallbackErr) {
+            // eslint-disable-next-line no-console
             console.error("[LittleFS] Fallback import also failed:", fallbackErr);
             throw new Error(`Failed to load LittleFS module: ${err}`);
         }

package/dist/connect.js

@@ -50,6 +50,7 @@ export const connect = async (button) => {
         esploader = await esptoolConnect({
             log: () => { }, // Silent logger for connection
             debug: () => { },
+            // eslint-disable-next-line no-console
             error: (msg) => console.error(msg),
         });
     }

package/dist/const.d.ts

@@ -6,6 +6,14 @@ export interface Logger {
 export interface Build {
     chipFamily: "ESP32" | "ESP8266" | "ESP32-S2" | "ESP32-S3" | "ESP32-C2" | "ESP32-C3" | "ESP32-C5" | "ESP32-C6" | "ESP32-C61" | "ESP32-H2" | "ESP32-P4";
     chipVariant?: string;
+    flashSizeMB?: number;
+    /**
+     * Optional USB interface qualifier.
+     * - "CDC": native USB CDC (USB-JTAG/USB-OTG, e.g. direct USB on S2/S3/C3/C6/...)
+     * - "UART": external USB-to-Serial bridge (CP210x, FTDI, CH340, ...)
+     * If omitted, the build will match any USB interface.
+     */
+    usbInterface?: "UART" | "CDC";
     parts: {
         path: string;
         offset: number;
@@ -29,6 +37,7 @@ export interface BaseFlashState {
     build?: Build;
     chipFamily?: Build["chipFamily"] | "Unknown Chip";
     chipVariant?: string | null;
+    flashSize?: string;
 }
 export interface InitializingState extends BaseFlashState {
     state: FlashStateType.INITIALIZING;

package/dist/flash.js

@@ -1,18 +1,87 @@
 import { getChipFamilyName } from "./util/chip-family-name";
 import { sleep } from "./util/sleep";
 import { corsProxyFetch } from "./util/cors-proxy";
+/**
+ * Parse flash size string (e.g., "4MB", "8MB", "16MB") to megabytes number
+ */
+function parseFlashSizeToMB(flashSize) {
+    if (!flashSize)
+        return undefined;
+    const match = flashSize.match(/^(\d+)(MB|GB)$/);
+    if (!match)
+        return undefined;
+    const size = parseInt(match[1], 10);
+    const unit = match[2];
+    if (unit === "GB")
+        return size * 1024;
+    return size;
+}
+/**
+ * Select the best build using most-specific-matching algorithm
+ * - Builds with matching usbInterface are strongly preferred
+ * - Builds with matching flashSizeMB are preferred
+ * - Among builds with same specificity, first one wins
+ * - Builds without these qualifiers are fallback options
+ */
+function selectBestBuild(builds, detectedFlashSizeMB, detectedUsbInterface) {
+    if (builds.length === 0)
+        return undefined;
+    // Score builds: higher score = more specific match
+    let bestBuild;
+    let bestScore = -Infinity;
+    for (const build of builds) {
+        let score = 0;
+        // USB interface match - if specified, must match
+        if (build.usbInterface !== undefined) {
+            if (detectedUsbInterface !== undefined &&
+                build.usbInterface === detectedUsbInterface) {
+                score += 1000; // Strong preference for explicit usbInterface match
+            }
+            else {
+                // Mismatched usbInterface - disqualify this build
+                continue;
+            }
+        }
+        // Builds without usbInterface stay neutral (compatible with any)
+        // Flash size match gives second priority
+        if (build.flashSizeMB !== undefined && detectedFlashSizeMB !== undefined) {
+            if (build.flashSizeMB === detectedFlashSizeMB) {
+                score += 100; // Exact flash size match
+            }
+            else {
+                score -= 1; // Penalize non-matching specific builds
+            }
+        }
+        else if (build.flashSizeMB !== undefined) {
+            // flashSizeMB is defined but detectedFlashSizeMB is undefined
+            score -= 1; // Penalize non-matching specific builds
+        }
+        // Generic builds (flashSizeMB undefined) stay at score 0
+        // Prefer this build if it has higher score
+        // If same score, keep the first one (stable selection)
+        if (score > bestScore) {
+            bestScore = score;
+            bestBuild = build;
+        }
+    }
+    return bestScore >= 0 ? bestBuild : undefined;
+}
 export const flash = async (onEvent, esploader, // ESPLoader instance from tasmota-webserial-esptool
 logger, manifestPath, eraseFirst, firmwareBuffer, _baudRate) => {
     let manifest;
     let build;
+    // eslint-disable-next-line prefer-const
     let chipFamily;
     let chipVariant = null;
+    // eslint-disable-next-line prefer-const
+    let flashSize;
     const fireStateEvent = (stateUpdate) => onEvent({
         ...stateUpdate,
         manifest,
         build,
         chipFamily,
         chipVariant,
+        flashSize,
     });
     let manifestProm = null;
     let manifestURL = "";
@@ -51,9 +120,34 @@ logger, manifestPath, eraseFirst, firmwareBuffer, _baudRate) => {
     }
     chipFamily = getChipFamilyName(esploader);
     chipVariant = esploader.chipVariant;
+    // Detect flash size if not already detected
+    if (!esploader.flashSize && esploader.detectFlashSize) {
+        try {
+            await esploader.detectFlashSize();
+        }
+        catch (err) {
+            logger.debug("Failed to detect flash size:", err);
+        }
+    }
+    flashSize = esploader.flashSize; // e.g., "4MB", "8MB"
+    const flashSizeMB = flashSize ? parseFlashSizeToMB(flashSize) : undefined;
+    // Detect USB connection type to pick CDC vs UART firmware variants
+    // - true: native USB (USB-JTAG/USB-OTG) -> CDC
+    // - false: external USB-to-Serial bridge -> UART
+    let detectedUsbInterface;
+    if (typeof esploader.detectUsbConnectionType === "function") {
+        try {
+            const isUsbJtagOrOtg = await esploader.detectUsbConnectionType();
+            detectedUsbInterface = isUsbJtagOrOtg ? "CDC" : "UART";
+            logger.debug(`Detected USB interface: ${detectedUsbInterface}`);
+        }
+        catch (err) {
+            logger.debug("Failed to detect USB connection type:", err);
+        }
+    }
     fireStateEvent({
         state: "initializing" /* FlashStateType.INITIALIZING */,
-        message: `Initialized. Found ${chipFamily}${chipVariant ? ` (${chipVariant})` : ""}`,
+        message: `Initialized. Found ${chipFamily}${chipVariant ? ` (${chipVariant})` : ""}${flashSize ? `, ${flashSize}` : ""}`,
         details: { done: true },
     });
     fireStateEvent({
@@ -73,17 +167,24 @@ logger, manifestPath, eraseFirst, firmwareBuffer, _baudRate) => {
         await esploader.disconnect();
         return;
     }
-    build = manifest.builds.find((b) => {
-        // Match chipFamily and optionally chipVariant
+    // Filter builds by chipFamily and chipVariant
+    const compatibleBuilds = manifest.builds.filter((b) => {
         if (b.chipFamily !== chipFamily) {
             return false;
         }
-        // If build specifies chipVariant, it must match
         if (b.chipVariant && b.chipVariant !== chipVariant) {
             return false;
         }
         return true;
     });
+    // Select the best build using most-specific-matching algorithm
+    // Prefer builds with more matching qualifiers (flashSizeMB)
+    const exactVariantBuilds = compatibleBuilds.filter((b) => b.chipVariant !== undefined && b.chipVariant === chipVariant);
+    const variantAgnosticBuilds = compatibleBuilds.filter((b) => b.chipVariant === undefined);
+    build = selectBestBuild(exactVariantBuilds, flashSizeMB, detectedUsbInterface);
+    if (!build) {
+        build = selectBestBuild(variantAgnosticBuilds, flashSizeMB, detectedUsbInterface);
+    }
     if (!build) {
         fireStateEvent({
             state: "error" /* FlashStateType.ERROR */,

package/dist/install-dialog.d.ts

@@ -45,12 +45,14 @@ export declare class EwtInstallDialog extends LitElement {
     private _consoleInitialized;
     private _improvSupported;
     private _isUsbJtagOrOtgDevice;
+    private _flashSize?;
     private _openConsoleAfterReconnect;
     private _visitDeviceAfterReconnect;
     private _addToHAAfterReconnect;
     private _changeWiFiAfterReconnect;
     private _ensureStub;
     private get _port();
+    private _probeFlashSize;
     private _isUsbJtagOrOtg;
     private _isWebUsbWithExternalSerial;
     private _releaseReaderWriter;

package/dist/install-dialog.js

@@ -57,6 +57,8 @@ export class EwtInstallDialog extends LitElement {
         this._handleDisconnect = () => {
             this._state = "ERROR";
             this._error = "Disconnected";
+            // Reset flash size when device is actually disconnected
+            this._flashSize = undefined;
         };
     }
     // Ensure stub is initialized (called before any operation that needs it)
@@ -116,6 +118,8 @@ export class EwtInstallDialog extends LitElement {
         const espStub = await this.esploader.runStub();
         this.logger.log(`Stub created: IS_STUB=${espStub.IS_STUB}, chipFamily=${getChipFamilyName(espStub)}`);
         this._espStub = espStub;
+        // Detect flash size AFTER stub creation (flash size is only available after stub)
+        await this._probeFlashSize(espStub);
         // Set baudrate BEFORE any operations (use user-selected baudrate if available)
         if (this.baudRate && this.baudRate > 115200) {
             this.logger.log(`Setting baudrate to ${this.baudRate}...`);
@@ -138,6 +142,19 @@ export class EwtInstallDialog extends LitElement {
     get _port() {
         return this.esploader.port;
     }
+    // Helper to probe flash size from a running stub (only available after stub)
+    async _probeFlashSize(espStub) {
+        if (espStub.detectFlashSize && !this._flashSize) {
+            try {
+                await espStub.detectFlashSize();
+                this._flashSize = espStub.flashSize;
+                this.logger.log(`Flash size detected: ${this._flashSize}`);
+            }
+            catch (err) {
+                this.logger.debug("Failed to detect flash size:", err);
+            }
+        }
+    }
     // Helper to check if device is using USB-JTAG or USB-OTG (not external serial chip)
     async _isUsbJtagOrOtg() {
         // Use detectUsbConnectionType from tasmota-webserial-esptool
@@ -504,16 +521,17 @@ export class EwtInstallDialog extends LitElement {
     }
     _renderDashboard() {
         const heading = this._info.name;
-        let content;
         const hideActions = true;
         const allowClosing = true;
-        content = html `
+        const content = html `
       <ew-list>
         <ew-list-item>
           <div slot="headline">Connected to ${this._info.name}</div>
           <div slot="supporting-text">
             ${this._info.firmware}&nbsp;${this._info.version}
-            (${this._info.chipFamily})
+            (${this._info.chipFamily}${this._flashSize
+            ? `, ${this._flashSize}`
+            : ""})
           </div>
         </ew-list-item>
         ${!this._isSameVersion
@@ -827,11 +845,25 @@ export class EwtInstallDialog extends LitElement {
     }
     _renderDashboardNoImprov() {
         const heading = "Device Dashboard";
-        let content;
         const hideActions = true;
         const allowClosing = true;
-        content = html `
+        // Build device info string if available
+        const chipFamily = this.esploader.chipFamily
+            ? getChipFamilyName(this.esploader)
+            : null;
+        const deviceInfo = chipFamily
+            ? `(${chipFamily}${this._flashSize ? `, ${this._flashSize}` : ""})`
+            : null;
+        const content = html `
       <ew-list>
+        ${deviceInfo
+            ? html `
+              <ew-list-item>
+                <div slot="headline">${chipFamily}</div>
+                <div slot="supporting-text">${deviceInfo}</div>
+              </ew-list-item>
+            `
+            : ""}
         <ew-list-item
           type="button"
           ?disabled=${this._busy}
@@ -1219,6 +1251,7 @@ export class EwtInstallDialog extends LitElement {
         return [heading, content];
     }
     _renderInstall() {
+        var _a, _b, _c;
         let heading;
         let content;
         let hideActions = false;
@@ -1247,11 +1280,20 @@ export class EwtInstallDialog extends LitElement {
         else if (!this._installConfirmed) {
             heading = "Confirm Installation";
             const action = isUpdate ? "update to" : "install";
+            // Build device info with flash size if available
+            const deviceInfo = this._flashSize
+                ? html ` (${((_a = this._info) === null || _a === void 0 ? void 0 : _a.chipFamily) || ""}${((_b = this._info) === null || _b === void 0 ? void 0 : _b.chipFamily)
+                    ? `, ${this._flashSize}`
+                    : this._flashSize})`
+                : "";
             content = html `
         ${isUpdate
                 ? html `Your device is running
-              ${this._info.firmware}&nbsp;${this._info.version}.<br /><br />`
-                : ""}
+              ${this._info.firmware}&nbsp;${this._info
+                    .version}${deviceInfo}.<br /><br />`
+                : deviceInfo
+                    ? html `Device detected: ${deviceInfo}<br /><br />`
+                    : ""}
         Do you want to ${action}
         ${this._manifest.name}&nbsp;${this._manifest.version}?
         ${this._installErase
@@ -1274,7 +1316,11 @@ export class EwtInstallDialog extends LitElement {
             this._installState.state === "manifest" /* FlashStateType.MANIFEST */ ||
             this._installState.state === "preparing" /* FlashStateType.PREPARING */) {
             heading = "Installing";
-            content = this._renderProgress("Preparing installation");
+            // Show flash size in preparing message if available
+            const preparingMsg = ((_c = this._installState) === null || _c === void 0 ? void 0 : _c.flashSize)
+                ? `Preparing installation (${this._installState.flashSize})`
+                : "Preparing installation";
+            content = this._renderProgress(preparingMsg);
             hideActions = true;
         }
         else if (this._installState.state === "erasing" /* FlashStateType.ERASING */) {
@@ -1355,9 +1401,8 @@ export class EwtInstallDialog extends LitElement {
     }
     _renderLogs() {
         const heading = `Logs`;
-        let content;
         const hideActions = false;
-        content = html `
+        const content = html `
       <ew-console
         .port=${this._port}
         .logger=${this.logger}
@@ -1422,7 +1467,22 @@ export class EwtInstallDialog extends LitElement {
       `;
         }
         else {
+            // Build device info with flash size for partition view
+            const chipFamily = this.esploader.chipFamily
+                ? getChipFamilyName(this.esploader)
+                : null;
+            const deviceInfo = chipFamily
+                ? `${chipFamily}${this._flashSize ? `, ${this._flashSize}` : ""}`
+                : null;
             content = html `
+        ${deviceInfo
+                ? html `<div
+              class="device-info"
+              style="margin-bottom: 16px; font-size: 14px; color: var(--md-sys-color-on-surface-variant, #666);"
+            >
+              Device: ${deviceInfo}
+            </div>`
+                : ""}
         <div class="partition-list">
           <table class="partition-table">
             <thead>
@@ -1786,6 +1846,8 @@ export class EwtInstallDialog extends LitElement {
                         this._espStub = await this.esploader.runStub();
                         this.logger.log(`Stub created: IS_STUB=${this._espStub.IS_STUB}`);
                     }
+                    // Detect flash size after stub is running
+                    await this._probeFlashSize(this._espStub);
                     // CRITICAL: Save parent loader
                     const loaderToSave = this._espStub._parent || this._espStub;
                     this._savedLoaderBeforeConsole = loaderToSave;
@@ -2500,6 +2562,8 @@ export class EwtInstallDialog extends LitElement {
             await this._closeClientWithoutEvents(this._client);
         }
         document.body.style.overflow = (_a = this._bodyOverflow) !== null && _a !== void 0 ? _a : "";
+        // Reset flash size when dialog is closed
+        this._flashSize = undefined;
         fireEvent(this, "closed");
         this.parentNode.removeChild(this);
     }
@@ -2689,4 +2753,7 @@ __decorate([
 __decorate([
     state()
 ], EwtInstallDialog.prototype, "_isUsbJtagOrOtgDevice", void 0);
+__decorate([
+    state()
+], EwtInstallDialog.prototype, "_flashSize", void 0);
 customElements.define("ewt-install-dialog", EwtInstallDialog);

package/dist/util/line-break-transformer.js

@@ -11,7 +11,9 @@ export class LineBreakTransformer {
         let lastIndex = 0;
         let match;
         while ((match = re.exec(this.chunks)) !== null) {
-            if (match[0] === "\r" && re.lastIndex === this.chunks.length) {
+            // If this is a lone \r at the very end of the buffer, leave it so it can
+            // be combined with a possible following \n in the next chunk.
+            if (match[0] === "\r" && match.index === this.chunks.length - 1) {
                 break;
             }
             const line = this.chunks.substring(lastIndex, match.index);

package/dist/util/manifest.js

@@ -7,6 +7,7 @@ export const downloadManifest = async (manifestPath) => {
     }
     const manifest = await resp.json();
     if ("new_install_skip_erase" in manifest) {
+        // eslint-disable-next-line no-console
         console.warn('Manifest option "new_install_skip_erase" is deprecated. Use "new_install_prompt_erase" instead.');
         if (manifest.new_install_skip_erase) {
             manifest.new_install_prompt_erase = true;

package/dist/util/timestamp-transformer.js

@@ -7,6 +7,9 @@
 //   [HH:MM:SS.mmm]    wall-clock bracket with millis
 //   HH:MM:SS.mmm      plain wall-clock
 const DEVICE_TIMESTAMP_RE = /^\s*(?:\[\d{2}:\d{2}:\d{2}(?:\.\d+)?\]|(?:\d{2}:){2}\d{2}\.\d)/;
+// Matches leading ANSI SGR (color/style) codes at the start of a string
+// biome-ignore lint/suspicious/noControlCharactersInRegex: ANSI escape sequences
+const LEADING_ANSI_RE = /^(\x1b\[(?:\d+;)*\d*m)+/;
 export class TimestampTransformer {
     constructor() {
         this.deviceHasTimestamps = false;
@@ -25,11 +28,30 @@ export class TimestampTransformer {
             controller.enqueue(chunk);
             return;
         }
+        // Extract leading ANSI codes to preserve them across line splits
+        const ansiMatch = chunk.match(LEADING_ANSI_RE);
+        const leadingAnsi = ansiMatch ? ansiMatch[0] : "";
+        const contentWithoutAnsi = leadingAnsi
+            ? chunk.slice(leadingAnsi.length)
+            : chunk;
         const date = new Date();
         const h = date.getHours().toString().padStart(2, "0");
         const m = date.getMinutes().toString().padStart(2, "0");
         const s = date.getSeconds().toString().padStart(2, "0");
-        controller.enqueue(`[${h}:${m}:${s}] ${chunk}`);
+        const timestamp = `[${h}:${m}:${s}]`;
+        // For multi-line chunks, we need to preserve ANSI codes on each line
+        // Split on newlines, but keep the newline characters
+        const lines = contentWithoutAnsi.split(/(\r?\n)/);
+        let result = "";
+        for (const part of lines) {
+            if (part === "\n" || part === "\r\n") {
+                result += part;
+            }
+            else if (part !== "") {
+                result += leadingAnsi + timestamp + " " + part;
+            }
+        }
+        controller.enqueue(result);
     }
     reset() {
         this.deviceHasTimestamps = false;

package/dist/web/{index-DUmRg0Cu.js → index-B5owDZF7.js}

@@ -1,4 +1,4 @@
-import{y as e,z as t,k as o,_ as l,t as r,b as i,h as a}from"./styles-D69gtq6_.js";const n=e`
+import{y as e,z as t,k as o,_ as l,t as r,b as i,h as a}from"./styles-D4zXLz1s.js";const n=e`
   <svg
     version="1.1"
     id="Capa_1"