tasmota-esp-web-tools 9.0.2 → 10.0.0

package/dist/flash.js

@@ -1,21 +1,12 @@
 import { ESPLoader } from "tasmota-webserial-esptool";
 import { getChipFamilyName } from "./util/chip-family-name";
 import { sleep } from "./util/sleep";
-/**
- * Check if a serial port is an ESP32-S2 Native USB device in TinyUSB CDC mode
- * VID 0x303a = Espressif
- * PID 0x0002 = ESP32-S2 TinyUSB CDC
- */
-const isESP32S2NativeUSB = (port) => {
-    const info = port.getInfo();
-    return info.usbVendorId === 0x303a && info.usbProductId === 0x0002;
-};
+import { isESP32S2NativeUSB, isESP32S2ReconnectError, closeAndForgetPort, } from "./util/esp32s2-reconnect";
 export const flash = async (onEvent, port, logger, manifestPath, eraseFirst, firmwareBuffer, baudRate) => {
     let manifest;
     let build;
     let chipFamily;
     let chipVariant = null;
-    let esp32s2ReconnectRequired = false;
     const isS2NativeUSB = isESP32S2NativeUSB(port);
     const fireStateEvent = (stateUpdate) => onEvent({
         ...stateUpdate,
@@ -38,7 +29,6 @@ export const flash = async (onEvent, port, logger, manifestPath, eraseFirst, fir
     window.esploader = esploader;
     // ESP32-S2 Native USB event handler - listen on ESPLoader instance
     const handleESP32S2Reconnect = () => {
-        esp32s2ReconnectRequired = true;
         logger.log("ESP32-S2 Native USB disconnect detected - reconnection required");
     };
     // Register event listener for ESP32-S2 Native USB reconnect on ESPLoader
@@ -63,26 +53,10 @@ export const flash = async (onEvent, port, logger, manifestPath, eraseFirst, fir
     catch (err) {
         logger.error(err);
         // Check if this is an ESP32-S2 Native USB reconnect situation
-        // This happens when:
-        // 1. ESP32-S2 in TinyUSB CDC mode was reset to bootloader
-        // 2. ESP32-S2 disconnected during initialization
-        if (isS2NativeUSB &&
-            (esp32s2ReconnectRequired || String(err).includes("reconnect required"))) {
+        if (isS2NativeUSB && isESP32S2ReconnectError(err)) {
             cleanup();
-            // Close the old port if still accessible
-            try {
-                await port.close();
-            }
-            catch {
-                // Port may already be closed
-            }
-            // Forget the old port to allow reselection
-            try {
-                await port.forget();
-            }
-            catch {
-                // Forget may not be supported or port already released
-            }
+            // Close and forget the old port
+            await closeAndForgetPort(port);
             // Fire reconnect event to trigger port reselection dialog
             fireStateEvent({
                 state: "esp32_s2_usb_reconnect" /* FlashStateType.ESP32_S2_USB_RECONNECT */,

package/dist/install-dialog.d.ts

@@ -8,6 +8,7 @@ import "./components/ewt-icon-button";
 import "./components/ewt-textfield";
 import "./components/ewt-select";
 import "./components/ewt-list-item";
+import "./components/ewt-littlefs-manager";
 import "./pages/ewt-page-progress";
 import "./pages/ewt-page-message";
 import { Logger, Manifest } from "./const.js";
@@ -35,6 +36,9 @@ export declare class EwtInstallDialog extends LitElement {
     private _esp32s2ReconnectInProgress;
     private _ssids?;
     private _selectedSsid;
+    private _partitions?;
+    private _selectedPartition?;
+    private _espStub?;
     protected render(): TemplateResult<1>;
     _renderProgress(label: string | TemplateResult, progress?: number): TemplateResult<1>;
     _renderError(label: string): [string, TemplateResult, boolean];
@@ -44,6 +48,13 @@ export declare class EwtInstallDialog extends LitElement {
     _renderAskErase(): [string | undefined, TemplateResult];
     _renderInstall(): [string | undefined, TemplateResult, boolean, boolean];
     _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;
     willUpdate(changedProps: PropertyValues): void;
     protected firstUpdated(changedProps: PropertyValues): void;
     protected updated(changedProps: PropertyValues): void;

package/dist/install-dialog.js

@@ -10,6 +10,7 @@ import "./components/ewt-icon-button";
 import "./components/ewt-textfield";
 import "./components/ewt-select";
 import "./components/ewt-list-item";
+import "./components/ewt-littlefs-manager";
 import "./pages/ewt-page-progress";
 import "./pages/ewt-page-message";
 import { chipIcon, closeIcon, firmwareIcon } from "./components/svg";
@@ -21,6 +22,9 @@ import { fireEvent } from "./util/fire-event";
 import { sleep } from "./util/sleep";
 import { downloadManifest } from "./util/manifest";
 import { dialogStyles } from "./styles";
+import { parsePartitionTable } from "./partition.js";
+import { detectFilesystemType } from "./util/partition.js";
+import { isESP32S2NativeUSB, isESP32S2ReconnectError, closeAndForgetPort, } from "./util/esp32s2-reconnect";
 const ERROR_ICON = "⚠️";
 const OK_ICON = "🎉";
 export class EwtInstallDialog extends LitElement {
@@ -82,6 +86,15 @@ export class EwtInstallDialog extends LitElement {
         else if (this._state === "LOGS") {
             [heading, content, hideActions] = this._renderLogs();
         }
+        else if (this._state === "PARTITIONS") {
+            [heading, content, hideActions] = this._renderPartitions();
+        }
+        else if (this._state === "LITTLEFS") {
+            [heading, content, hideActions, allowClosing] = this._renderLittleFS();
+        }
+        else if (this._state === "ESP32S2_RECONNECT") {
+            [heading, content, hideActions] = this._renderESP32S2Reconnect();
+        }
         return html `
       <ewt-dialog
         open
@@ -215,6 +228,15 @@ export class EwtInstallDialog extends LitElement {
         }}
           ></ewt-button>
         </div>
+        <div>
+          <ewt-button
+            label="Manage Filesystem"
+            @click=${() => {
+            this._state = "PARTITIONS";
+            this._readPartitionTable();
+        }}
+          ></ewt-button>
+        </div>
         ${this._isSameFirmware && this._manifest.funding_url
             ? html `
               <div>
@@ -276,6 +298,16 @@ export class EwtInstallDialog extends LitElement {
         }}
           ></ewt-button>
         </div>
+
+        <div>
+          <ewt-button
+            label="Manage Filesystem"
+            @click=${() => {
+            this._state = "PARTITIONS";
+            this._readPartitionTable();
+        }}
+          ></ewt-button>
+        </div>
       </div>
     `;
         return [heading, content, hideActions, allowClosing];
@@ -651,6 +683,263 @@ export class EwtInstallDialog extends LitElement {
     `;
         return [heading, content, hideActions];
     }
+    _renderPartitions() {
+        const heading = "Partition Table";
+        let content;
+        const hideActions = false;
+        if (this._busy) {
+            content = this._renderProgress("Reading partition table...");
+        }
+        else if (!this._partitions || this._partitions.length === 0) {
+            content = html `
+        <ewt-page-message
+          .icon=${ERROR_ICON}
+          label="No partitions found"
+        ></ewt-page-message>
+        <ewt-button
+          slot="primaryAction"
+          label="Back"
+          @click=${() => {
+                this._state = "DASHBOARD";
+            }}
+        ></ewt-button>
+      `;
+        }
+        else {
+            content = html `
+        <div class="partition-list">
+          <table class="partition-table">
+            <thead>
+              <tr>
+                <th>Name</th>
+                <th>Type</th>
+                <th>SubType</th>
+                <th>Offset</th>
+                <th>Size</th>
+                <th>Action</th>
+              </tr>
+            </thead>
+            <tbody>
+              ${this._partitions.map((partition) => html `
+                  <tr>
+                    <td>${partition.name}</td>
+                    <td>${partition.typeName}</td>
+                    <td>${partition.subtypeName}</td>
+                    <td>0x${partition.offset.toString(16)}</td>
+                    <td>${this._formatSize(partition.size)}</td>
+                    <td>
+                      ${partition.type === 0x01 && partition.subtype === 0x82
+                ? html `
+                            <ewt-button
+                              label="Open FS"
+                              @click=${() => this._openFilesystem(partition)}
+                            ></ewt-button>
+                          `
+                : ""}
+                    </td>
+                  </tr>
+                `)}
+            </tbody>
+          </table>
+        </div>
+        <ewt-button
+          slot="primaryAction"
+          label="Back"
+          @click=${() => {
+                this._state = "DASHBOARD";
+            }}
+        ></ewt-button>
+      `;
+        }
+        return [heading, content, hideActions];
+    }
+    _renderLittleFS() {
+        const heading = undefined;
+        const hideActions = true;
+        const allowClosing = true;
+        const content = html `
+      <ewt-littlefs-manager
+        .partition=${this._selectedPartition}
+        .espStub=${this._espStub}
+        .logger=${this.logger}
+        .onClose=${() => {
+            this._state = "PARTITIONS";
+        }}
+      ></ewt-littlefs-manager>
+    `;
+        return [heading, content, hideActions, allowClosing];
+    }
+    _renderESP32S2Reconnect() {
+        const heading = "ESP32-S2 USB Port Changed";
+        const content = html `
+      <ewt-page-message
+        .icon=${"⚠️"}
+        .label=${"The ESP32-S2 has switched to USB CDC mode. Please select the new USB port to continue."}
+      ></ewt-page-message>
+      <ewt-button
+        slot="primaryAction"
+        label="Select New Port"
+        @click=${this._handleESP32S2ReconnectClick}
+      ></ewt-button>
+      <ewt-button
+        slot="secondaryAction"
+        label="Cancel"
+        @click=${() => {
+            this._state = "DASHBOARD";
+        }}
+      ></ewt-button>
+    `;
+        const hideActions = false;
+        return [heading, content, hideActions];
+    }
+    async _handleESP32S2ReconnectClick() {
+        try {
+            this._busy = true;
+            // Request new port (this is triggered by user click, so it works)
+            this.logger.log("Requesting new port selection...");
+            const newPort = await navigator.serial.requestPort();
+            await newPort.open({ baudRate: 115200 });
+            this.logger.log("New port selected, updating...");
+            this.port = newPort;
+            // Restart partition table reading with new port
+            this._state = "PARTITIONS";
+            await this._readPartitionTable();
+        }
+        catch (err) {
+            if (err.name === "NotFoundError") {
+                this.logger.log("Port selection cancelled");
+                this._state = "DASHBOARD";
+            }
+            else {
+                this._error = `Failed to reconnect: ${err.message}`;
+                this._state = "ERROR";
+            }
+        }
+        finally {
+            this._busy = false;
+        }
+    }
+    async _readPartitionTable() {
+        const PARTITION_TABLE_OFFSET = 0x8000;
+        const PARTITION_TABLE_SIZE = 0x1000;
+        this._busy = true;
+        this._partitions = undefined;
+        try {
+            this.logger.log("Reading partition table from 0x8000...");
+            // Import ESPLoader from the package
+            const { ESPLoader } = await import("tasmota-webserial-esptool");
+            let currentPort = this.port;
+            let esploader = new ESPLoader(currentPort, {
+                log: (msg, ...args) => this.logger.log(msg, ...args),
+                debug: (msg, ...args) => { var _a, _b; return (_b = (_a = this.logger).debug) === null || _b === void 0 ? void 0 : _b.call(_a, msg, ...args); },
+                error: (msg, ...args) => this.logger.error(msg, ...args),
+            });
+            // Set up ESP32-S2 reconnect handler BEFORE initialize
+            const reconnectHandler = async (event) => {
+                this.logger.log("ESP32-S2 USB reconnect event:", event.detail.message);
+                await closeAndForgetPort(currentPort);
+                this.logger.log("Please select the new ESP32-S2 USB CDC port");
+            };
+            esploader.addEventListener("esp32s2-usb-reconnect", reconnectHandler, {
+                once: true,
+            });
+            // Initialize ESP loader
+            this.logger.log("Initializing ESP loader...");
+            try {
+                await esploader.initialize();
+                this.logger.log("ESP loader initialized successfully");
+            }
+            catch (err) {
+                // Check if this is an ESP32-S2 reconnect scenario
+                if (isESP32S2NativeUSB(currentPort) && isESP32S2ReconnectError(err)) {
+                    this.logger.log("ESP32-S2 USB port changed - user needs to select new port");
+                    // Close and forget old port
+                    await closeAndForgetPort(currentPort);
+                    // Show UI with button for user to click
+                    this._busy = false;
+                    this._state = "ESP32S2_RECONNECT";
+                    return;
+                }
+                else {
+                    throw err;
+                }
+            }
+            this.logger.log("Running stub...");
+            const espStub = await esploader.runStub();
+            this._espStub = espStub;
+            // Add a small delay after stub is running
+            await sleep(500);
+            this.logger.log("Reading flash data...");
+            const data = await espStub.readFlash(PARTITION_TABLE_OFFSET, PARTITION_TABLE_SIZE);
+            const partitions = parsePartitionTable(data);
+            if (partitions.length === 0) {
+                this.logger.error("No valid partition table found");
+                this._partitions = [];
+            }
+            else {
+                this.logger.log(`Found ${partitions.length} partition(s)`);
+                this._partitions = partitions;
+            }
+        }
+        catch (e) {
+            this.logger.error(`Failed to read partition table: ${e.message || e}`);
+            if (e.message === "Port selection cancelled") {
+                this._error = "Port selection cancelled";
+            }
+            else {
+                this._error = `Failed to read partition table: ${e.message || e}. Try resetting your device.`;
+            }
+            this._state = "ERROR";
+        }
+        finally {
+            this._busy = false;
+        }
+    }
+    async _openFilesystem(partition) {
+        try {
+            this._busy = true;
+            this.logger.log(`Detecting filesystem type for partition "${partition.name}"...`);
+            // Check if ESP stub is still available
+            if (!this._espStub) {
+                throw new Error("ESP stub not available. Please reconnect.");
+            }
+            const fsType = await detectFilesystemType(this._espStub, partition.offset, partition.size, this.logger);
+            this.logger.log(`Detected filesystem: ${fsType}`);
+            if (fsType === "littlefs") {
+                this._selectedPartition = partition;
+                this._state = "LITTLEFS";
+            }
+            else if (fsType === "spiffs") {
+                this.logger.error("SPIFFS support not yet implemented. Use LittleFS partitions.");
+                this._error = "SPIFFS support not yet implemented";
+                this._state = "ERROR";
+            }
+            else {
+                this.logger.error("Unknown filesystem type. Cannot open partition.");
+                this._error = "Unknown filesystem type";
+                this._state = "ERROR";
+            }
+        }
+        catch (e) {
+            this.logger.error(`Failed to open filesystem: ${e.message || e}`);
+            this._error = `Failed to open filesystem: ${e.message || e}`;
+            this._state = "ERROR";
+        }
+        finally {
+            this._busy = false;
+        }
+    }
+    _formatSize(bytes) {
+        if (bytes < 1024) {
+            return `${bytes} B`;
+        }
+        else if (bytes < 1024 * 1024) {
+            return `${(bytes / 1024).toFixed(2)} KB`;
+        }
+        else {
+            return `${(bytes / (1024 * 1024)).toFixed(2)} MB`;
+        }
+    }
     willUpdate(changedProps) {
         if (!changedProps.has("_state")) {
             return;
@@ -972,6 +1261,44 @@ EwtInstallDialog.styles = [
         width: calc(80vw - 48px);
         height: 80vh;
       }
+      :host([state="PARTITIONS"]) ewt-dialog {
+        --mdc-dialog-max-width: 800px;
+      }
+      :host([state="LITTLEFS"]) ewt-dialog {
+        --mdc-dialog-max-width: 95vw;
+        --mdc-dialog-max-height: 90vh;
+      }
+      :host([state="LITTLEFS"]) .mdc-dialog__content {
+        padding: 10px 20px;
+      }
+      :host([state="LITTLEFS"]) ewt-littlefs-manager {
+        display: block;
+        max-width: 100%;
+      }
+      .partition-list {
+        max-height: 60vh;
+        overflow-y: auto;
+      }
+      .partition-table {
+        width: 100%;
+        border-collapse: collapse;
+        margin: 16px 0;
+      }
+      .partition-table th,
+      .partition-table td {
+        padding: 8px 12px;
+        text-align: left;
+        border: 1px solid #ccc;
+      }
+      .partition-table th {
+        font-weight: 600;
+        background-color: #f0f0f0;
+        position: sticky;
+        top: 0;
+      }
+      .partition-table tbody tr:hover {
+        background-color: rgba(3, 169, 244, 0.1);
+      }
     `,
 ];
 __decorate([
@@ -1004,4 +1331,13 @@ __decorate([
 __decorate([
     state()
 ], EwtInstallDialog.prototype, "_selectedSsid", void 0);
+__decorate([
+    state()
+], EwtInstallDialog.prototype, "_partitions", void 0);
+__decorate([
+    state()
+], EwtInstallDialog.prototype, "_selectedPartition", void 0);
+__decorate([
+    state()
+], EwtInstallDialog.prototype, "_espStub", void 0);
 customElements.define("ewt-install-dialog", EwtInstallDialog);

package/dist/partition.d.ts

@@ -0,0 +1,26 @@
+/**
+ * ESP32 Partition Table Parser
+ * Based on ESP-IDF partition table format
+ */
+export interface Partition {
+    name: string;
+    type: number;
+    subtype: number;
+    offset: number;
+    size: number;
+    flags: number;
+    typeName: string;
+    subtypeName: string;
+}
+/**
+ * Parse the entire partition table
+ */
+export declare function parsePartitionTable(data: Uint8Array): Partition[];
+/**
+ * Get the default partition table offset
+ */
+export declare function getPartitionTableOffset(): number;
+/**
+ * Format size in human-readable format
+ */
+export declare function formatSize(bytes: number): string;

package/dist/partition.js

@@ -0,0 +1,129 @@
+/**
+ * ESP32 Partition Table Parser
+ * Based on ESP-IDF partition table format
+ */
+// Partition types
+const PARTITION_TYPES = {
+    0x00: "app",
+    0x01: "data",
+};
+// App subtypes
+const APP_SUBTYPES = {
+    0x00: "factory",
+    0x10: "ota_0",
+    0x11: "ota_1",
+    0x12: "ota_2",
+    0x13: "ota_3",
+    0x14: "ota_4",
+    0x15: "ota_5",
+    0x16: "ota_6",
+    0x17: "ota_7",
+    0x18: "ota_8",
+    0x19: "ota_9",
+    0x1a: "ota_10",
+    0x1b: "ota_11",
+    0x1c: "ota_12",
+    0x1d: "ota_13",
+    0x1e: "ota_14",
+    0x1f: "ota_15",
+    0x20: "test",
+};
+// Data subtypes
+const DATA_SUBTYPES = {
+    0x00: "ota",
+    0x01: "phy",
+    0x02: "nvs",
+    0x03: "coredump",
+    0x04: "nvs_keys",
+    0x05: "efuse",
+    0x80: "esphttpd",
+    0x81: "fat",
+    0x82: "spiffs",
+};
+const PARTITION_TABLE_OFFSET = 0x8000; // Default partition table offset
+const PARTITION_ENTRY_SIZE = 32;
+const PARTITION_MAGIC = 0x50aa;
+/**
+ * Parse a single partition entry from binary data
+ */
+function parsePartitionEntry(data) {
+    if (data.length < PARTITION_ENTRY_SIZE) {
+        return null;
+    }
+    // Check magic bytes
+    const magic = (data[0] | (data[1] << 8)) & 0xffff;
+    if (magic !== PARTITION_MAGIC) {
+        return null;
+    }
+    const type = data[2];
+    const subtype = data[3];
+    const offset = data[4] | (data[5] << 8) | (data[6] << 16) | (data[7] << 24);
+    const size = data[8] | (data[9] << 8) | (data[10] << 16) | (data[11] << 24);
+    // Name is at offset 12, max 16 bytes, null-terminated
+    let name = "";
+    for (let i = 12; i < 28; i++) {
+        if (data[i] === 0)
+            break;
+        name += String.fromCharCode(data[i]);
+    }
+    const flags = data[28] | (data[29] << 8) | (data[30] << 16) | (data[31] << 24);
+    // Get type and subtype names
+    const typeName = PARTITION_TYPES[type] || `unknown(0x${type.toString(16)})`;
+    let subtypeName = "";
+    if (type === 0x00) {
+        subtypeName = APP_SUBTYPES[subtype] || `unknown(0x${subtype.toString(16)})`;
+    }
+    else if (type === 0x01) {
+        subtypeName =
+            DATA_SUBTYPES[subtype] || `unknown(0x${subtype.toString(16)})`;
+    }
+    else {
+        subtypeName = `0x${subtype.toString(16)}`;
+    }
+    return {
+        name,
+        type,
+        subtype,
+        offset,
+        size,
+        flags,
+        typeName,
+        subtypeName,
+    };
+}
+/**
+ * Parse the entire partition table
+ */
+export function parsePartitionTable(data) {
+    const partitions = [];
+    for (let i = 0; i < data.length; i += PARTITION_ENTRY_SIZE) {
+        const entryData = data.slice(i, i + PARTITION_ENTRY_SIZE);
+        const partition = parsePartitionEntry(entryData);
+        if (partition === null) {
+            // End of partition table or invalid entry
+            break;
+        }
+        partitions.push(partition);
+    }
+    return partitions;
+}
+/**
+ * Get the default partition table offset
+ */
+export function getPartitionTableOffset() {
+    return PARTITION_TABLE_OFFSET;
+}
+/**
+ * Format size in human-readable format
+ */
+export function formatSize(bytes) {
+    if (bytes < 1024) {
+        return `${bytes} B`;
+    }
+    else if (bytes < 1024 * 1024) {
+        return `${(bytes / 1024).toFixed(2)} KB`;
+    }
+    else {
+        return `${(bytes / (1024 * 1024)).toFixed(2)} MB`;
+    }
+}

package/dist/util/esp32s2-reconnect.d.ts

@@ -0,0 +1,22 @@
+/**
+ * ESP32-S2 Native USB Reconnect Utilities
+ *
+ * The ESP32-S2 can switch between ROM bootloader mode and USB CDC mode,
+ * causing the serial port to change. These utilities help detect and handle
+ * this scenario consistently across the application.
+ */
+/**
+ * Check if a serial port is an ESP32-S2 Native USB device
+ * VID 0x303a = Espressif
+ * PID 0x0002 = ESP32-S2 Native USB (ROM bootloader)
+ */
+export declare const isESP32S2NativeUSB: (port: SerialPort) => boolean;
+/**
+ * Check if an error is likely caused by ESP32-S2 port switching
+ */
+export declare const isESP32S2ReconnectError: (error: any) => boolean;
+/**
+ * Close and forget a serial port
+ * This releases the port so a new one can be selected
+ */
+export declare const closeAndForgetPort: (port: SerialPort) => Promise<void>;