esp32tool 1.3.1 → 1.3.3

package/js/script.js

@@ -8,6 +8,16 @@ if (!globalThis.requestSerialPort) {
   globalThis.requestSerialPort = requestSerialPort;
 }
 
+// Utility functions imported from esptool module
+let toHex, formatMacAddr, sleep;
+
+// Load utilities from esptool package
+window.esptoolPackage.then((esptoolMod) => {
+  toHex = esptoolMod.toHex;
+  formatMacAddr = esptoolMod.formatMacAddr;
+  sleep = esptoolMod.sleep;
+});
+
 let espStub;
 let esp32s2ReconnectInProgress = false;
 let currentLittleFS = null;
@@ -18,6 +28,7 @@ let currentFilesystemType = null; // 'littlefs', 'fatfs', or 'spiffs'
 let littlefsModulePromise = null; // Cache for LittleFS WASM module
 let lastReadFlashData = null; // Store last read flash data for ESP8266
 let currentChipName = null; // Store chip name globally
+let currentMacAddr = null; // Store MAC address globally
 let isConnected = false; // Track connection state
 let consoleInstance = null; // ESP32ToolConsole instance
 let baudRateBeforeConsole = null; // Store baudrate before opening console
@@ -63,6 +74,7 @@ function clearAllCachedData() {
   currentFilesystemType = null;
   lastReadFlashData = null;
   currentChipName = null;
+  currentMacAddr = null;
   
   // Hide filesystem manager
   littlefsManager.classList.add('hidden');
@@ -111,8 +123,8 @@ const chunkSizes = [
   { label: "8 KB", value: 0x2000 },
   { label: "16 KB (WebUSB)", value: 0x4000 },
   { label: "64 KB", value: 0x10000 },
-  { label: "128 KB", value: 0x20000 },
-  { label: "256 KB (Desktop)", value: 0x40000 }
+  { label: "128 KB (Desktop)", value: 0x20000 },
+  { label: "256 KB", value: 0x40000 }
 ];
 
 // blockSize: Size of each data block sent by ESP (in bytes)
@@ -128,8 +140,7 @@ const blockSizes = [
   { label: "1024 B", value: 1024 },
   { label: "1984 B", value: 1984 },
   { label: "2024 B", value: 2024 },
-  { label: "3968 B (Desktop)", value: 3968 },
-  { label: "4096 B (Maximum)", value: 4096 }
+  { label: "3968 B (Desktop)", value: 3968 }
 ];
 
 // maxInFlight: Maximum unacknowledged bytes (in bytes)
@@ -147,15 +158,13 @@ const maxInFlights = [
   { label: "4096 B", value: 4096 },
   { label: "7936 B", value: 7936 },
   { label: "8192 B", value: 8192 },
-  { label: "15872 B", value: 15872 },
+  { label: "15872 B (Desktop)", value: 15872 },
   { label: "31744 B", value: 31744 },
-  { label: "63488 B", value: 63488 }
+  { label: "63488 B", value: 63488 },
+  { label: "126976 B", value: 126976 },
+  { label: "253952 B", value: 253952 }
 ];
 
-const bufferSize = 512;
-const colors = ["#00a7e9", "#f89521", "#be1e2d"];
-const measurementPeriodId = "0001";
-
 // Check if running in Electron
 const isElectron = window.electronAPI && window.electronAPI.isElectron;
 
@@ -238,6 +247,46 @@ function isMobileDevice() {
   return isMobileUA || (hasTouch && isSmallScreen);
 }
 
+/**
+ * Detect if we're using WebUSB (mobile/Android) or Web Serial (desktop)
+ * WebUSB is typically used on Android devices
+ * Web Serial is used on desktop browsers
+ */
+function isUsingWebUSB() {
+  // If we have an active connection, check the port's isWebUSB property
+  if (espStub && espStub.port && typeof espStub.port.isWebUSB !== 'undefined') {
+    return espStub.port.isWebUSB === true;
+  }
+  
+  // Fallback: Check if we're on a mobile device (likely using WebUSB)
+  if (isMobileDevice()) {
+    return true;
+  }
+  
+  // Check if Web Serial is NOT available but USB is (WebUSB only)
+  if (!("serial" in navigator) && "usb" in navigator) {
+    return true;
+  }
+  
+  // Default to Web Serial (desktop)
+  return false;
+}
+
+/**
+ * Get default advanced parameters based on environment
+ * Desktop (Web Serial): Higher values for better performance
+ * Mobile/WebUSB: Lower values for compatibility
+ */
+function getDefaultAdvancedParams() {
+  const isWebUSB = isUsingWebUSB();
+  
+  return {
+    chunkSize: isWebUSB ? 0x4000 : 0x20000,  // 16 KB for WebUSB, 128 KB for Desktop
+    blockSize: isWebUSB ? 248 : 3968,         // 248 B for WebUSB, 3968 B for Desktop
+    maxInFlight: isWebUSB ? 248 : 15872       // 248 B for WebUSB, 15872 B for Desktop
+  };
+}
+
 // Update mobile classes and padding
 function updateMobileClasses() {
   const isMobile = isMobileDevice();
@@ -332,39 +381,7 @@ document.addEventListener("DOMContentLoaded", () => {
   window.addEventListener("error", function (event) {
     console.log("Got an uncaught error: ", event.error);
   });
-  
-  // Header auto-hide functionality - DISABLED
-  const header = document.querySelector(".header");
-  const main = document.querySelector(".main");
-  
-  /* DISABLED: Auto-hide header
-  // Show header on mouse enter at top of page
-  main.addEventListener("mousemove", (e) => {
-    if (e.clientY < 5 && header.classList.contains("header-hidden")) {
-      header.classList.remove("header-hidden");
-      main.classList.remove("no-header-padding");
-    }
-  });
-  
-  // Keep header visible when mouse is over it
-  header.addEventListener("mouseenter", () => {
-    header.classList.remove("header-hidden");
-    main.classList.remove("no-header-padding");
-  });
-  
-  // Hide header when mouse leaves (only if connected)
-  header.addEventListener("mouseleave", () => {
-    if (espStub && header.classList.contains("header-hidden") === false) {
-      setTimeout(() => {
-        if (!header.matches(":hover")) {
-          header.classList.add("header-hidden");
-          main.classList.add("no-header-padding");
-        }
-      }, 1000);
-    }
-  });
-  */
-  
+
   // Check for Web Serial or WebUSB support
   if ("serial" in navigator || "usb" in navigator) {
     const notSupported = document.getElementById("notSupported");
@@ -391,6 +408,9 @@ function initBaudRate() {
 }
 
 function initAdvancedParams() {
+  // Get default values based on environment (Desktop vs WebUSB)
+  const defaults = getDefaultAdvancedParams();
+  
   // Initialize chunkSize dropdown
   for (let item of chunkSizes) {
     const option = document.createElement("option");
@@ -398,8 +418,8 @@ function initAdvancedParams() {
     option.value = item.value;
     chunkSizeSelect.add(option);
   }
-  // Set default: 16 KB for WebUSB, 256 KB for Desktop
-  chunkSizeSelect.value = 0x4000; // 16 KB default
+  // Set default: 16 KB for WebUSB, 128 KB for Desktop
+  chunkSizeSelect.value = defaults.chunkSize;
 
   // Initialize blockSize dropdown
   for (let item of blockSizes) {
@@ -408,8 +428,8 @@ function initAdvancedParams() {
     option.value = item.value;
     blockSizeSelect.add(option);
   }
-  // Set default: 4095 B for Desktop
-  blockSizeSelect.value = 4095;
+  // Set default: 248 B for WebUSB, 3968 B for Desktop
+  blockSizeSelect.value = defaults.blockSize;
 
   // Initialize maxInFlight dropdown
   for (let item of maxInFlights) {
@@ -418,8 +438,51 @@ function initAdvancedParams() {
     option.value = item.value;
     maxInFlightSelect.add(option);
   }
-  // Set default: 8190 B for Desktop
-  maxInFlightSelect.value = 8190;
+  // Set default: 248 B for WebUSB, 15872 B for Desktop
+  maxInFlightSelect.value = defaults.maxInFlight;
+}
+
+/**
+ * Update advanced parameters after connection based on actual port type
+ * This ensures we use optimal values for WebUSB vs Web Serial
+ */
+function updateAdvancedParamsForConnection() {
+  // Get the correct defaults based on actual connection
+  const defaults = getDefaultAdvancedParams();
+  
+  // Get current values
+  const currentChunkSize = parseInt(chunkSizeSelect.value);
+  const currentBlockSize = parseInt(blockSizeSelect.value);
+  const currentMaxInFlight = parseInt(maxInFlightSelect.value);
+  
+  // Check if values are at old defaults (need updating)
+  const oldWebUSBDefaults = { chunkSize: 0x4000, blockSize: 248, maxInFlight: 248 };
+  const oldDesktopDefaults = { chunkSize: 0x40000, blockSize: 3968, maxInFlight: 15872 };
+  
+  const isAtWebUSBDefaults = 
+    currentChunkSize === oldWebUSBDefaults.chunkSize &&
+    currentBlockSize === oldWebUSBDefaults.blockSize &&
+    currentMaxInFlight === oldWebUSBDefaults.maxInFlight;
+    
+  const isAtDesktopDefaults = 
+    currentChunkSize === oldDesktopDefaults.chunkSize &&
+    currentBlockSize === oldDesktopDefaults.blockSize &&
+    currentMaxInFlight === oldDesktopDefaults.maxInFlight;
+  
+  // Only update if at defaults (user hasn't customized)
+  if (isAtWebUSBDefaults || isAtDesktopDefaults) {
+    chunkSizeSelect.value = defaults.chunkSize;
+    blockSizeSelect.value = defaults.blockSize;
+    maxInFlightSelect.value = defaults.maxInFlight;
+    
+    // Save the new values
+    saveSetting("chunkSize", defaults.chunkSize);
+    saveSetting("blockSize", defaults.blockSize);
+    saveSetting("maxInFlight", defaults.maxInFlight);
+    
+    const connectionType = isUsingWebUSB() ? "WebUSB" : "Web Serial";
+    debugMsg(`Advanced parameters updated for ${connectionType} connection`);
+  }
 }
 
 function logMsg(text) {
@@ -500,16 +563,6 @@ function enableStyleSheet(node, enabled) {
   node.disabled = !enabled;
 }
 
-function formatMacAddr(macAddr) {
-  return macAddr
-    .map((value) => value.toString(16).toUpperCase().padStart(2, "0"))
-    .join(":");
-}
-
-function toHex(value) {
-  return "0x" + value.toString(16).padStart(2, "0");
-}
-
 /**
  * Parse flash size string (e.g., "256KB", "4MB") to bytes
  * @param {string} sizeStr - Flash size string with unit (KB or MB)
@@ -609,13 +662,9 @@ async function clickConnect() {
     });
   }
   
-  // Store port info for ESP32-S2 detection
-  let portInfo = esploader.port?.getInfo ? esploader.port.getInfo() : {};
-  let isESP32S2 = portInfo.usbVendorId === 0x303a && portInfo.usbProductId === 0x0002;
-  
   // Handle ESP32-S2 Native USB reconnection requirement for BROWSER
-  // Only add listener if not already in reconnect mode and not in Electron
-  if (!esp32s2ReconnectInProgress && !isElectron) {
+  // Only add listener if not already in reconnect mode
+  if (!esp32s2ReconnectInProgress) {
     esploader.addEventListener("esp32s2-usb-reconnect", async () => {
       // Prevent recursive calls
       if (esp32s2ReconnectInProgress) {
@@ -625,57 +674,47 @@ async function clickConnect() {
       esp32s2ReconnectInProgress = true;
       logMsg("ESP32-S2 Native USB detected!");
       toggleUIConnected(false);
+      const previousStubPort = espStub?.port;
       espStub = undefined;
       
       try {
         // Close the port first
         await esploader.port.close();
-        
-        // For Android WebUSB: ESP32-S2 automatic reconnection doesn't work
-        // Show message and let user reconnect manually with BOOT button
-        if (isAndroid) {
-          logMsg("ESP32-S2 has switched to CDC mode");
-          logMsg("Please press and HOLD the BOOT button on your ESP32-S2, then click Connect");
-          esp32s2ReconnectInProgress = false;
-          return;
-        }
-        // For Desktop Web Serial: Use the modal dialog approach
-        if (!isAndroid && esploader.port.forget) {
-          await esploader.port.forget();
+
+        // Use the modal dialog approach
+        if (previousStubPort && previousStubPort.readable) {
+          await previousStubPort.close();
         }
-      } catch (disconnectErr) {
-        // Ignore disconnect errors
-        debugMsg("Error during disconnect: " + disconnectErr);
+      } catch (closeErr) {
+        // Ignore port close errors
+        debugMsg(`Port close error (ignored): ${closeErr.message}`);
       }
       
-      // Show modal dialog ONLY for Desktop
-      if (!isAndroid) {
-        const modal = document.getElementById("esp32s2Modal");
-        const reconnectBtn = document.getElementById("butReconnectS2");
+      // Show modal dialog
+      const modal = document.getElementById("esp32s2Modal");
+      const reconnectBtn = document.getElementById("butReconnectS2");
         
-        modal.classList.remove("hidden");
+      modal.classList.remove("hidden");
         
-        // Handle reconnect button click
-        const handleReconnect = async () => {
-          modal.classList.add("hidden");
-          reconnectBtn.removeEventListener("click", handleReconnect);
+      // Handle reconnect button click
+      const handleReconnect = async () => {
+        modal.classList.add("hidden");
+        reconnectBtn.removeEventListener("click", handleReconnect);
           
-          logMsg("Requesting new device selection...");
+        logMsg("Requesting new device selection...");
           
-          // Trigger port selection
-          try {
-            await clickConnect();
-            // Reset flag on successful connection
-            esp32s2ReconnectInProgress = false;
-          } catch (err) {
-            errorMsg("Failed to reconnect: " + err);
-            // Reset flag on error so user can try again
-            esp32s2ReconnectInProgress = false;
-          }
-        };
-        
-        reconnectBtn.addEventListener("click", handleReconnect);
-      }
+        // Trigger port selection
+        try {
+          await clickConnect();
+          // Reset flag on successful connection
+          esp32s2ReconnectInProgress = false;
+        } catch (err) {
+          errorMsg("Failed to reconnect: " + err);
+          // Reset flag on error so user can try again
+          esp32s2ReconnectInProgress = false;
+        }
+      };
+      reconnectBtn.addEventListener("click", handleReconnect);
     });
   }
   
@@ -702,9 +741,14 @@ async function clickConnect() {
 
   // Store chip info globally
   currentChipName = esploader.chipName;
+  currentMacAddr = formatMacAddr(esploader.macAddr());
 
   espStub = await esploader.runStub();
   
+  // Update advanced parameters based on actual connection type (WebUSB vs Web Serial)
+  // Only update if user hasn't manually changed them (still at defaults)
+  updateAdvancedParamsForConnection();
+  
   toggleUIConnected(true);
   toggleUIToolbar(true);
   
@@ -760,11 +804,6 @@ async function clickConnect() {
 async function changeBaudRate() {
   saveSetting("baudrate", baudRateSelect.value);
   if (espStub) {
-    // Skip for ESP8266 as it only supports 115200 baud in stub mode
-    if (espStub.chipName === "ESP8266") {
-      logMsg("ESP8266 stub only supports 115200 baud");
-      return;
-    }
     let baud = parseInt(baudRateSelect.value);
     if (baudRates.includes(baud)) {
       await espStub.setBaudrate(baud);
@@ -807,6 +846,36 @@ async function clickShowLog() {
   updateLogVisibility();
 }
 
+/**
+ * @name openConsolePortAndInit
+ * Helper to open port for console and initialize console UI
+ * Avoids code duplication across different console init flows
+ */
+async function openConsolePortAndInit(newPort) {
+  // Open the port at 115200 for console
+  await newPort.open({ baudRate: 115200 });
+  espStub.port = newPort;
+  espStub.connected = true;
+  
+  // Keep parent/loader in sync (used by closeConsole)
+  if (espStub._parent) {
+    espStub._parent.port = newPort;
+  }
+  if (espLoaderBeforeConsole) {
+    espLoaderBeforeConsole.port = newPort;
+  }
+  
+  debugMsg("Port opened for console at 115200 baud");
+  
+  // Device is already in firmware mode, port is open at 115200
+  // Initialize console directly
+  consoleSwitch.checked = true;
+  saveSetting("console", true);
+  
+  // Initialize console UI and handlers
+  await initConsoleUI();
+}
+
 /**
  * @name initConsoleUI
  * Initialize console UI, event handlers, and start console instance
@@ -818,6 +887,9 @@ async function initConsoleUI() {
   
   // Show console container and hide commands
   consoleContainer.classList.remove("hidden");
+  
+  // Add console-active class to body for mobile styling
+  document.body.classList.add("console-active");
   const commands = document.getElementById("commands");
   if (commands) commands.classList.add("hidden");
   
@@ -825,15 +897,29 @@ async function initConsoleUI() {
   consoleInstance = new ESP32ToolConsole(espStub.port, consoleContainer, true);
   await consoleInstance.init();
   
+  // Check if console reset is supported and hide button if not
+  if (espLoaderBeforeConsole && typeof espLoaderBeforeConsole.isConsoleResetSupported === 'function') {
+    const resetSupported = espLoaderBeforeConsole.isConsoleResetSupported();
+    const resetBtn = consoleContainer.querySelector("#console-reset-btn");
+    if (resetBtn) {
+      if (resetSupported) {
+        resetBtn.style.display = "";
+      } else {
+        resetBtn.style.display = "none";
+        debugMsg("Console reset disabled for ESP32-S2 USB-JTAG/CDC (hardware limitation)");
+      }
+    }
+  }
+  
   // Listen for console reset events
   if (consoleResetHandler) {
     consoleContainer.removeEventListener('console-reset', consoleResetHandler);
   }
   consoleResetHandler = async () => {
-    if (espStub && typeof espStub.hardReset === 'function') {
+    if (espLoaderBeforeConsole && typeof espLoaderBeforeConsole.resetInConsoleMode === 'function') {
       try {
         debugMsg("Resetting device from console...");
-        await espStub.hardReset();
+        await espLoaderBeforeConsole.resetInConsoleMode();
         debugMsg("Device reset successful");
       } catch (err) {
         errorMsg("Failed to reset device: " + err.message);
@@ -867,34 +953,6 @@ async function clickConsole() {
   
   if (shouldEnable) {
     // After WDT reset, everything is gone - start fresh with port selection
-    if (isConnected && espStub && !espStub.connected) {
-      // Port was closed after WDT reset - select new port
-      try {
-        logMsg("Please select the serial port for console mode...");
-        const newPort = await navigator.serial.requestPort();
-        
-        // Open the new port at 115200 for console
-        await newPort.open({ baudRate: 115200 });
-        
-        // Update espStub to use the new port
-        espStub.port = newPort;
-        espStub.connected = true;
-        if (espStub._parent) {
-          espStub._parent.port = newPort;
-        }
-        if (espLoaderBeforeConsole) {
-          espLoaderBeforeConsole.port = newPort;
-        }
-        
-        logMsg("Port opened for console at 115200 baud");
-      } catch (openErr) {
-        errorMsg(`Failed to open port for console: ${openErr.message}`);
-        consoleSwitch.checked = false;
-        saveSetting("console", false);
-        return;
-      }
-    }
-    
     // Initialize console if connected and not already created
     if (isConnected && espStub && espStub.port && !consoleInstance) {
       try {
@@ -904,7 +962,6 @@ async function clickConsole() {
         const loaderToSave = espStub._parent || espStub;
         const currentBaudrate = loaderToSave.currentBaudRate;
         const currentChipFamily = espStub.chipFamily;
-        const currentIsStub = espStub.IS_STUB;
 
         // CRITICAL: Save the PARENT loader (not the stub child!)
         espLoaderBeforeConsole = loaderToSave;
@@ -928,21 +985,29 @@ async function clickConsole() {
             // USB-JTAG/OTG device: Port was closed after WDT reset
             debugMsg("Device reset to firmware mode (port closed)");
             
-            // Wait a bit for device to boot
-            await sleep(500);
+            // Wait for device to boot and USB port to become available
+            // Android/WebUSB needs more time than Desktop for USB enumeration
+            const isWebUSB = isUsingWebUSB();
+            const waitTime = isWebUSB ? 1000 : 500; // 1s for Android, 500ms for Desktop
+            debugMsg(`Waiting ${waitTime}ms for device to boot and USB to enumerate...`);
+            await sleep(waitTime);
             
-            // Check if this is ESP32-S2 (needs port forget and modal) or ESP32-S3 (direct requestPort)
+            // Check if this is ESP32-S2 or if we're on Android (WebUSB)
+            // Both need modal for user gesture
             const isS2 = chipFamilyBeforeConsole === 0x3252; // CHIP_FAMILY_ESP32S2 = 0x3252
+            const needsModal = isS2 || isWebUSB;
             
-            if (isS2) {
-              // ESP32-S2: Forget old port and show modal for port selection
-              if (espStub.port && espStub.port.forget) {
-                try {
-                  await espStub.port.forget();
-                  logMsg("Forgot old port");
-                } catch (forgetErr) {
-                  logMsg(`Port forget error (ignored): ${forgetErr.message}`);
+            if (needsModal) {
+              // ESP32-S2 (all platforms) or Android (all chips): Use modal for user gesture
+              
+              // Close old port if still open
+              try {
+                if (espStub.port && espStub.port.readable) {
+                  await espStub.port.close();
+                  debugMsg("Old port closed");
                 }
+              } catch (closeErr) {
+                debugMsg(`Port close error (ignored): ${closeErr.message}`);
               }
               
               // Wait a bit for browser to process
@@ -956,42 +1021,27 @@ async function clickConsole() {
               const modalTitle = modal.querySelector("h2");
               const modalText = modal.querySelector("p");
               if (modalTitle) modalTitle.textContent = "Device has been reset to firmware mode";
-              if (modalText) modalText.textContent = "Please click the button below to select the serial port for console.";
+              if (modalText) {
+                modalText.textContent = isWebUSB 
+                  ? "Please click the button below to select the USB device for console."
+                  : "Please click the button below to select the serial port for console.";
+              }
               
               modal.classList.remove("hidden");
               
-              // Handle reconnect button click
+              // Handle reconnect button click (single-fire to prevent multiple prompts)
               const handleReconnect = async () => {
                 modal.classList.add("hidden");
-                reconnectBtn.removeEventListener("click", handleReconnect);
                 
                 try {
                   // Request the NEW port (user gesture from button click)
-                  debugMsg("Please select the serial port for console mode...");
-                  const newPort = await navigator.serial.requestPort();
-                  
-                  // Open the NEW port at 115200 for console
-                  await newPort.open({ baudRate: 115200 });
-                  espStub.port = newPort;
-                  espStub.connected = true;
-                  
-                  // Keep parent/loader in sync (used by closeConsole)
-                  if (espStub._parent) {
-                    espStub._parent.port = newPort;
-                  }
-                  if (espLoaderBeforeConsole) {
-                    espLoaderBeforeConsole.port = newPort;
-                  }
+                  debugMsg("Please select the port for console mode...");
+                  const newPort = isWebUSB
+                    ? await WebUSBSerial.requestPort((...args) => logMsg(...args))
+                    : await navigator.serial.requestPort();
                   
-                  debugMsg("Port opened for console at 115200 baud");
-                  
-                  // Device is already in firmware mode, port is open at 115200
-                  // Initialize console directly
-                  consoleSwitch.checked = true;
-                  saveSetting("console", true);
-                  
-                  // Initialize console UI and handlers
-                  await initConsoleUI();
+                  // Use helper to open port and initialize console
+                  await openConsolePortAndInit(newPort);
                 } catch (err) {
                   errorMsg(`Failed to open port for console: ${err.message}`);
                   consoleSwitch.checked = false;
@@ -999,36 +1049,17 @@ async function clickConsole() {
                 }
               };
               
-              reconnectBtn.addEventListener("click", handleReconnect);
+              // Use { once: true } to ensure single-fire and automatic cleanup
+              reconnectBtn.addEventListener("click", handleReconnect, { once: true });
             } else {
-              // ESP32-S3/C3/C5/C6/H2/P4: Direct requestPort (no modal, no forget)
+              // Desktop (Web Serial) with ESP32-S3/C3/C5/C6/H2/P4: Direct requestPort
               try {
-                // Request port selection from user (direct, like console branch)
+                // Request port selection from user (direct)
                 debugMsg("Please select the serial port again for console mode...");
                 const newPort = await navigator.serial.requestPort();
                 
-                // Open the new port at 115200 for console
-                await newPort.open({ baudRate: 115200 });
-                espStub.port = newPort;
-                espStub.connected = true;
-                
-                // Keep parent/loader in sync (used by closeConsole)
-                if (espStub._parent) {
-                  espStub._parent.port = newPort;
-                }
-                if (espLoaderBeforeConsole) {
-                  espLoaderBeforeConsole.port = newPort;
-                }
-                
-                debugMsg("Port opened for console at 115200 baud");
-                
-                // Device is already in firmware mode, port is open at 115200
-                // Initialize console directly
-                consoleSwitch.checked = true;
-                saveSetting("console", true);
-                
-                // Initialize console UI and handlers
-                await initConsoleUI();
+                // Use helper to open port and initialize console
+                await openConsolePortAndInit(newPort);
               } catch (err) {
                 errorMsg(`Failed to open port for console: ${err.message}`);
                 consoleSwitch.checked = false;
@@ -1080,82 +1111,69 @@ async function clickConsole() {
  * Close console and restore device to bootloader state
  */
 async function closeConsole() {
+  // Remove console-active class from body FIRST to restore visibility
+  document.body.classList.remove("console-active");
+  
   // Hide console and show commands again
   consoleContainer.classList.add("hidden");
   const commands = document.getElementById("commands");
-  if (commands) commands.classList.remove("hidden");
-  
-  if (consoleInstance) {
-    try {
-      await consoleInstance.disconnect();
-    } catch (err) {
-      debugMsg("Error disconnecting console: " + err);
-    }
-    consoleInstance = null;
+  if (commands) {
+    commands.classList.remove("hidden");
+    // Force display to ensure it's visible
+    commands.style.display = "";
   }
   
   // Restore original state (bootloader + stub + baudrate)
   if (espLoaderBeforeConsole && Number.isFinite(baudRateBeforeConsole)) {
-    // Check if this is a USB-JTAG/OTG device
-    const isUsbJtag = espLoaderBeforeConsole._isUsbJtagOrOtg === true;
+    // Disconnect console first to release locks
+    if (consoleInstance) {
+      try {
+        await consoleInstance.disconnect();
+      } catch (err) {
+        debugMsg("Error disconnecting console: " + err);
+      }
+      consoleInstance = null;
+    }
     
+    // Use esp_loader's exitConsoleMode function
     try {
-      if (isUsbJtag) {
-        // USB-JTAG/OTG devices: Port was lost, need to request new port
-        debugMsg("Please select the serial port again to reconnect...");
+      const needsManualReconnect = await espLoaderBeforeConsole.exitConsoleMode();
+      
+      if (needsManualReconnect) {
+        // ESP32-S2: Port has changed, need to select new port
+        logMsg("ESP32-S2: Port changed - please select the new port");
+        toggleUIConnected(false);
+        espStub = undefined;
+        
+        // Wait a moment for port to stabilize
+        await sleep(1000);
         
+        // Trigger port selection
         try {
-          // Request port selection from user
-          const newPort = await navigator.serial.requestPort();
-          
-          // Update the loader to use the new port
-          espLoaderBeforeConsole.port = newPort;
-          
-          debugMsg("Port selected, reconnecting to bootloader...");
-        } catch (portErr) {
-          errorMsg(`Failed to select port: ${portErr.message}`);
-          // Reset connection state to allow fresh connect
-          espStub = undefined;
-          toggleUIConnected(false);
+          await clickConnect();
           espLoaderBeforeConsole = null;
           baudRateBeforeConsole = null;
           chipFamilyBeforeConsole = null;
-          return;
+        } catch (err) {
+          errorMsg("Failed to reconnect: " + err);
         }
-      }
-      
-      // Use reconnectToBootloader() - it handles everything:
-      // - Releases locks
-      // - Resets to bootloader
-      // - Reopens port at 115200
-      // - Syncs with bootloader using correct reset strategy
-      // NOTE: Call on original loader (before console), not on stub
-      await espLoaderBeforeConsole.reconnectToBootloader();
-      
-      // Now espLoaderBeforeConsole is in bootloader state (IS_STUB = false)
-      // Reload stub using the reconnected bootloader
-      const newStub = await espLoaderBeforeConsole.runStub();
-      espStub = newStub;
-
-      // Restore original baudrate
-      if (baudRateBeforeConsole !== 115200) {
-        await espStub.setBaudrate(baudRateBeforeConsole);
-      }
-
-      espLoaderBeforeConsole = null;
-      baudRateBeforeConsole = null;
-      chipFamilyBeforeConsole = null;
-    } catch (err) {
-      errorMsg("Failed to restore state after console: " + err.message);
-      // Attempt to disconnect cleanly to allow reconnection
-      try {
-        if (espLoaderBeforeConsole?.port) {
-          await espLoaderBeforeConsole.port.close();
+      } else {
+        // Other devices: reconnectToBootloader was called successfully
+        // Reload stub
+        const newStub = await espLoaderBeforeConsole.runStub();
+        espStub = newStub;
+
+        // Restore baudrate
+        if (baudRateBeforeConsole !== 115200) {
+          await espStub.setBaudrate(baudRateBeforeConsole);
         }
-      } catch (closeErr) {
-        debugMsg("Failed to close port: " + closeErr);
+
+        espLoaderBeforeConsole = null;
+        baudRateBeforeConsole = null;
+        chipFamilyBeforeConsole = null;
       }
-      // Reset connection state to allow fresh connect
+    } catch (err) {
+      errorMsg("Failed to exit console mode: " + err.message);
       espStub = undefined;
       toggleUIConnected(false);
       espLoaderBeforeConsole = null;
@@ -1634,7 +1652,10 @@ async function clickReadFlash() {
     return;
   }
 
-  const defaultFilename = `flash_0x${offset.toString(16)}_0x${size.toString(16)}.bin`;
+  // Create filename with chip type and MAC address
+  const chipInfo = currentChipName ? currentChipName.replace(/\s+/g, '_') : 'ESP';
+  const macInfo = currentMacAddr ? currentMacAddr.replace(/:/g, '') : '';
+  const defaultFilename = `${chipInfo}${macInfo ? '_' + macInfo : ''}_flash_0x${offset.toString(16)}_0x${size.toString(16)}.bin`;
 
   baudRateSelect.disabled = true;
   butErase.disabled = true;
@@ -1952,7 +1973,10 @@ function displayPartitions(partitions) {
  * Download a partition
  */
 async function downloadPartition(partition) {
-  const defaultFilename = `${partition.name}_0x${partition.offset.toString(16)}.bin`;
+  // Create filename with chip type and MAC address
+  const chipInfo = currentChipName ? currentChipName.replace(/\s+/g, '_') : 'ESP';
+  const macInfo = currentMacAddr ? currentMacAddr.replace(/:/g, '') : '';
+  const defaultFilename = `${chipInfo}${macInfo ? '_' + macInfo : ''}_${partition.name}_0x${partition.offset.toString(16)}.bin`;
 
   const partitionProgress = document.getElementById("partitionProgress");
   const progressBar = partitionProgress.querySelector("div");
@@ -2041,13 +2065,7 @@ function toggleUIConnected(connected) {
   if (connected) {
     lbl = "Disconnect";
     isConnected = true;
-    
-    /* DISABLED: Auto-hide header after connection
-    setTimeout(() => {
-      header.classList.add("header-hidden");
-      main.classList.add("no-header-padding");
-    }, 2000); // Hide after 2 seconds
-    */
+
   } else {
     isConnected = false;
     toggleUIToolbar(false);
@@ -2066,16 +2084,14 @@ function toggleUIConnected(connected) {
     if (commands) commands.classList.remove("hidden");
     consoleSwitch.checked = false;
     saveSetting("console", false);
-    
-    /* DISABLED: Show header when disconnected
-    header.classList.remove("header-hidden");
-    main.classList.remove("no-header-padding");
-    */
   }
   butConnect.textContent = lbl;
 }
 
 function loadAllSettings() {
+  // Get default values based on environment (Desktop vs WebUSB)
+  const defaults = getDefaultAdvancedParams();
+  
   // Load all saved settings or defaults
   autoscroll.checked = loadSetting("autoscroll", true);
   baudRateSelect.value = loadSetting("baudrate", 2000000);
@@ -2085,10 +2101,10 @@ function loadAllSettings() {
   consoleSwitch.checked = loadSetting("console", false);
   advancedMode.checked = loadSetting("advanced", false);
   
-  // Load advanced parameters
-  chunkSizeSelect.value = loadSetting("chunkSize", 0x4000); // 16 KB default
-  blockSizeSelect.value = loadSetting("blockSize", 4095); // 4095 B default
-  maxInFlightSelect.value = loadSetting("maxInFlight", 8190); // 8190 B default
+  // Load advanced parameters with environment-specific defaults
+  chunkSizeSelect.value = loadSetting("chunkSize", defaults.chunkSize);
+  blockSizeSelect.value = loadSetting("blockSize", defaults.blockSize);
+  maxInFlightSelect.value = loadSetting("maxInFlight", defaults.maxInFlight);
   
   // Apply show log setting
   updateLogVisibility();
@@ -2120,10 +2136,6 @@ function ucWords(text) {
     .replace(/(?<= )[^\s]|^./g, (a) => a.toUpperCase());
 }
 
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
 /**
  * Save data to file - uses Electron API in desktop app, browser download otherwise
  */
@@ -3071,8 +3083,11 @@ async function clickLittlefsBackup() {
     logMsg(`Creating ${getFilesystemDisplayName()} backup image...`);
     const image = currentLittleFS.toImage();
     
+    // Create filename with chip type and MAC address
+    const chipInfo = currentChipName ? currentChipName.replace(/\s+/g, '_') : 'ESP';
+    const macInfo = currentMacAddr ? currentMacAddr.replace(/:/g, '') : '';
     const fsType = currentFilesystemType || 'filesystem';
-    const filename = `${currentLittleFSPartition.name}_${fsType}_backup.bin`;
+    const filename = `${chipInfo}${macInfo ? '_' + macInfo : ''}_${currentLittleFSPartition.name}_${fsType}_backup.bin`;
     await saveDataToFile(image, filename);
     
     logMsg(`${getFilesystemDisplayName()} backup saved as "${filename}"`);