esp32tool 1.6.1 → 1.6.3

package/js/script.js

@@ -1986,8 +1986,18 @@ async function clickNVSEditor() {
     nvsEditorInstance.initProgressUI();
     nvsEditorInstance.showProgress('Reading partition table...', 0);
 
-    const ptData = await espStub.readFlash(PARTITION_TABLE_OFFSET, PARTITION_TABLE_SIZE);
-    const partitions = parsePartitionTable(ptData);
+    const MAX_PT_ATTEMPTS = 10;
+    let partitions = [];
+    for (let attempt = 0; attempt < MAX_PT_ATTEMPTS; attempt++) {
+      const offset = PARTITION_TABLE_OFFSET + attempt * 0x1000;
+      logMsg(`Reading partition table from 0x${offset.toString(16)}...`);
+      const ptData = await espStub.readFlash(offset, PARTITION_TABLE_SIZE);
+      partitions = parsePartitionTable(ptData);
+      if (partitions.length > 0) break;
+    }
+    if (partitions.length === 0) {
+      throw new Error('No valid partition table found after ' + MAX_PT_ATTEMPTS + ' attempts');
+    }
 
     // Step 2: Find NVS partition (type=0x01 data, subtype=0x02 nvs)
     const nvsPartition = partitions.find(p => p.type === 0x01 && p.subtype === 0x02);
@@ -2107,17 +2117,28 @@ async function clickReadPartitions() {
   butReadFlash.disabled = true;
 
   try {
-    logMsg(`Reading partition table from 0x${PARTITION_TABLE_OFFSET.toString(16)}...`);
-    const data = await espStub.readFlash(PARTITION_TABLE_OFFSET, PARTITION_TABLE_SIZE);
-    
-    const partitions = parsePartitionTable(data);
-    
+    const MAX_ATTEMPTS = 10;
+    let partitions = [];
+    let foundOffset = null;
+
+    for (let attempt = 0; attempt < MAX_ATTEMPTS; attempt++) {
+      const offset = PARTITION_TABLE_OFFSET + attempt * 0x1000;
+      logMsg(`Reading partition table from 0x${offset.toString(16)}...`);
+      const data = await espStub.readFlash(offset, PARTITION_TABLE_SIZE);
+      partitions = parsePartitionTable(data);
+
+      if (partitions.length > 0) {
+        foundOffset = offset;
+        break;
+      }
+    }
+
     if (partitions.length === 0) {
-      errorMsg("No valid partition table found");
+      errorMsg("No valid partition table found after " + MAX_ATTEMPTS + " attempts");
       return;
     }
 
-    logMsg(`Found ${partitions.length} partition(s)`);
+    logMsg(`Found ${partitions.length} partition(s) at 0x${foundOffset.toString(16)}`);
     
     // Display partitions
     displayPartitions(partitions);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "esp32tool",
-  "version": "1.6.1",
+  "version": "1.6.3",
   "type": "module",
   "description": "Flash & Read ESP devices using WebSerial, Electron, and also Android mobile via WebUSB",
   "main": "electron/main.cjs",
@@ -49,27 +49,27 @@
     "@electron-forge/maker-zip": "^7.11.1",
     "@electron-forge/plugin-auto-unpack-natives": "^7.11.1",
     "@electron/fuses": "^2.0.0",
-    "@eslint/js": "^9.39.2",
+    "@eslint/js": "^9.39.3",
     "@rollup/plugin-json": "^6.1.0",
     "@rollup/plugin-node-resolve": "^16.0.0",
     "@rollup/plugin-terser": "^0.4.4",
     "@rollup/plugin-typescript": "^12.3.0",
-    "@types/node": "^25.2.3",
+    "@types/node": "^25.3.0",
     "@types/pako": "^2.0.4",
     "@types/serialport": "^10.2.0",
     "@types/w3c-web-serial": "^1.0.7",
     "archiver": "^7.0.1",
-    "electron": "^40.4.1",
+    "electron": "^40.6.0",
     "electron-squirrel-startup": "^1.0.1",
-    "eslint": "^9.39.2",
+    "eslint": "^10.0.2",
     "eslint-config-prettier": "^10.1.8",
     "eslint-plugin-prettier": "^5.5.5",
     "npm-run-all": "^4.1.5",
     "prettier": "^3.8.1",
-    "rollup": "^4.57.0",
+    "rollup": "^4.59.0",
     "serve": "^14.2.5",
     "typescript": "^5.7.3",
-    "typescript-eslint": "^8.56.0"
+    "typescript-eslint": "^8.56.1"
   },
   "dependencies": {
     "pako": "^2.1.0",
@@ -79,8 +79,10 @@
   "overrides": {
     "tmp": "^0.2.4",
     "tar": "^7.5.6",
-    "ajv": "^8.18.0",
     "minimatch": "^10.2.1",
+    "serve": {
+      "ajv": "^8.18.0"
+    },
     "@electron/asar": "^4.0.1"
   }
 }

package/src/esp_loader.ts

@@ -1161,14 +1161,11 @@ export class ESPLoader extends EventTarget {
    * Classic reset with shorter delays for WebUSB (Android)
    */
   async hardResetClassicShortDelayWebUSB() {
-    await this.setDTRWebUSB(false); // IO0=HIGH
-    await this.setRTSWebUSB(true); // EN=LOW, chip in reset
-    await sleep(50);
-    await this.setDTRWebUSB(true); // IO0=LOW
-    await this.setRTSWebUSB(false); // EN=HIGH, chip out of reset
-    await sleep(25);
-    await this.setDTRWebUSB(false); // IO0=HIGH, done
-    await sleep(100);
+    await this.runSignalSequence([
+      { dtr: false, rts: true, delayMs: 50 },
+      { dtr: true, rts: false, delayMs: 25 },
+      { dtr: false, delayMs: 100 },
+    ]);
   }
 
   /**
@@ -1176,14 +1173,11 @@ export class ESPLoader extends EventTarget {
    * Inverted reset sequence for WebUSB (Android) - both signals inverted
    */
   async hardResetInvertedWebUSB() {
-    await this.setDTRWebUSB(true); // IO0=HIGH (inverted)
-    await this.setRTSWebUSB(false); // EN=LOW, chip in reset (inverted)
-    await sleep(100);
-    await this.setDTRWebUSB(false); // IO0=LOW (inverted)
-    await this.setRTSWebUSB(true); // EN=HIGH, chip out of reset (inverted)
-    await sleep(50);
-    await this.setDTRWebUSB(true); // IO0=HIGH, done (inverted)
-    await sleep(200);
+    await this.runSignalSequence([
+      { dtr: true, rts: false, delayMs: 100 },
+      { dtr: false, rts: true, delayMs: 50 },
+      { dtr: true, delayMs: 200 },
+    ]);
   }
 
   /**
@@ -1191,14 +1185,11 @@ export class ESPLoader extends EventTarget {
    * Only DTR inverted for WebUSB (Android)
    */
   async hardResetInvertedDTRWebUSB() {
-    await this.setDTRWebUSB(true); // IO0=HIGH (DTR inverted)
-    await this.setRTSWebUSB(true); // EN=LOW, chip in reset (RTS normal)
-    await sleep(100);
-    await this.setDTRWebUSB(false); // IO0=LOW (DTR inverted)
-    await this.setRTSWebUSB(false); // EN=HIGH, chip out of reset (RTS normal)
-    await sleep(50);
-    await this.setDTRWebUSB(true); // IO0=HIGH, done (DTR inverted)
-    await sleep(200);
+    await this.runSignalSequence([
+      { dtr: true, rts: true, delayMs: 100 },
+      { dtr: false, rts: false, delayMs: 50 },
+      { dtr: true, delayMs: 200 },
+    ]);
   }
 
   /**
@@ -1206,14 +1197,11 @@ export class ESPLoader extends EventTarget {
    * Only RTS inverted for WebUSB (Android)
    */
   async hardResetInvertedRTSWebUSB() {
-    await this.setDTRWebUSB(false); // IO0=HIGH (DTR normal)
-    await this.setRTSWebUSB(false); // EN=LOW, chip in reset (RTS inverted)
-    await sleep(100);
-    await this.setDTRWebUSB(true); // IO0=LOW (DTR normal)
-    await this.setRTSWebUSB(true); // EN=HIGH, chip out of reset (RTS inverted)
-    await sleep(50);
-    await this.setDTRWebUSB(false); // IO0=HIGH, done (DTR normal)
-    await sleep(200);
+    await this.runSignalSequence([
+      { dtr: false, rts: false, delayMs: 100 },
+      { dtr: true, rts: true, delayMs: 50 },
+      { dtr: false, delayMs: 200 },
+    ]);
   }
 
   /**

package/src/index.ts

@@ -100,11 +100,7 @@ export const connectWithPort = async (port: SerialPort, logger: Logger) => {
   return new ESPLoader(port, logger);
 };
 
-export {
-  parsePartitionTable,
-  getPartitionTableOffset,
-  formatSize,
-} from "./partition";
+export { parsePartitionTable, formatSize } from "./partition";
 export type { Partition } from "./partition";
 
 // Export utility functions for use in UI code

package/src/partition.ts

@@ -58,7 +58,6 @@ const DATA_SUBTYPES: { [key: number]: string } = {
   0x83: "littlefs",
 };
 
-const PARTITION_TABLE_OFFSET = 0x8000; // Default partition table offset
 const PARTITION_ENTRY_SIZE = 32;
 const PARTITION_MAGIC = 0x50aa;
 
@@ -137,13 +136,6 @@ export function parsePartitionTable(data: Uint8Array): Partition[] {
   return partitions;
 }
 
-/**
- * Get the default partition table offset
- */
-export function getPartitionTableOffset(): number {
-  return PARTITION_TABLE_OFFSET;
-}
-
 /**
  * Format size in human-readable format
  */

package/sw.js

@@ -1,5 +1,5 @@
 // Service Worker for ESP32Tool PWA
-const CACHE_NAME = 'esp32tool-v1.6.1';
+const CACHE_NAME = 'esp32tool-v1.6.3';
 const RUNTIME_CACHE = 'esp32tool-runtime';
 
 // Core files to cache on install (relative paths work for any deployment path)

package/electron/main.js

@@ -1,338 +0,0 @@
-const { app, BrowserWindow, Menu, session, ipcMain, dialog } = require('electron');
-const path = require('path');
-const fs = require('fs');
-
-// Handle creating/removing shortcuts on Windows when installing/uninstalling.
-// Only required for Windows Squirrel installer
-if (process.platform === 'win32') {
-  try {
-    if (require('electron-squirrel-startup')) {
-      app.quit();
-    }
-  } catch (e) {
-    // Module not available, ignore
-  }
-}
-
-let mainWindow;
-
-// Store granted serial port devices
-const grantedDevices = new Map();
-
-function createWindow() {
-  mainWindow = new BrowserWindow({
-    width: 1200,
-    height: 800,
-    minWidth: 800,
-    minHeight: 600,
-    webPreferences: {
-      nodeIntegration: false,
-      contextIsolation: true,
-      preload: path.join(__dirname, 'preload.js'),
-    },
-    icon: path.join(__dirname, 'icons', 'icon.png'),
-    title: 'ESP32Tool',
-    autoHideMenuBar: false,
-  });
-
-  // Load the index.html of the app
-  mainWindow.loadFile(path.join(__dirname, '..', 'index.html'));
-
-  // Open DevTools in development
-  if (process.env.NODE_ENV === 'development') {
-    mainWindow.webContents.openDevTools();
-  }
-
-  mainWindow.on('closed', () => {
-    mainWindow = null;
-  });
-
-  // Setup serial port handlers for this window's session
-  setupSerialPortHandlers(mainWindow.webContents.session);
-}
-
-function setupSerialPortHandlers(ses) {
-  let lastSelectedPort = null;
-  let esp32s2ReconnectPending = false;
-  let portSelectionQueue = [];
-  
-  // Handle serial port selection - shows when navigator.serial.requestPort() is called
-  ses.on('select-serial-port', (event, portList, webContents, callback) => {
-    event.preventDefault();
-
-    console.log('Available serial ports:', portList.map(p => ({
-      portId: p.portId,
-      portName: p.portName,
-      displayName: p.displayName
-    })));
-
-    if (portList && portList.length > 0) {
-      // Try to find ESP-compatible port
-      const espPort = portList.find(port => {
-        const name = (port.displayName || port.portName || '').toLowerCase();
-        return name.includes('cp2102') ||
-               name.includes('cp2103') ||
-               name.includes('cp2104') ||
-               name.includes('cp2105') ||
-               name.includes('cp2108') ||
-               name.includes('ch9102') ||
-               name.includes('ch9104') ||
-               name.includes('ch340') ||
-               name.includes('ch341') ||
-               name.includes('ch343') ||
-               name.includes('ftdi') ||
-               name.includes('usb') ||
-               name.includes('uart') ||
-               name.includes('silicon labs') ||
-               name.includes('esp');
-      });
-
-      // Select ESP-compatible port or first available
-      const selectedPort = espPort || portList[0];
-      console.log('Selected port:', selectedPort.portId, selectedPort.displayName || selectedPort.portName);
-      lastSelectedPort = selectedPort;
-      
-      callback(selectedPort.portId);
-    } else {
-      console.log('No serial ports available - queuing selection');
-      // No ports available yet - queue this callback for when a port appears
-      portSelectionQueue.push(callback);
-    }
-  });
-
-  // Track port additions - handle ESP32-S2 reconnect
-  ses.on('serial-port-added', (event, port) => {
-    console.log('Serial port added:', port);
-    
-    // If we have queued port selections, handle them now
-    if (portSelectionQueue.length > 0) {
-      console.log('Processing queued port selection');
-      const callback = portSelectionQueue.shift();
-      callback(port.portId);
-      lastSelectedPort = port;
-    }
-    
-    // Check if this looks like an ESP32-S2 CDC port appearing after ROM port disappeared
-    if (lastSelectedPort && port.portName !== lastSelectedPort.portName) {
-      const name = (port.displayName || port.portName || '').toLowerCase();
-      if (name.includes('esp') || name.includes('usb') || name.includes('uart')) {
-        console.log('ESP32-S2 reconnect detected - new CDC port available');
-        esp32s2ReconnectPending = true;
-      }
-    }
-  });
-
-  // Track port removals - detect ESP32-S2 disconnect
-  ses.on('serial-port-removed', (event, port) => {
-    console.log('Serial port removed:', port);
-    
-    // If the last selected port was removed, prepare for reconnect
-    if (lastSelectedPort && port.portId === lastSelectedPort.portId) {
-      console.log('Last selected port removed - may be ESP32-S2 mode switch');
-      // Don't clear lastSelectedPort yet, we might need it for comparison
-    }
-  });
-
-  // Grant permission for serial port access checks
-  ses.setPermissionCheckHandler((webContents, permission, requestingOrigin, details) => {
-    if (permission === 'serial') {
-      return true;
-    }
-    return true;
-  });
-
-  // Handle device permission requests  
-  ses.setDevicePermissionHandler((details) => {
-    if (details.deviceType === 'serial') {
-      if (details.device) {
-        grantedDevices.set(details.device.deviceId, details.device);
-      }
-      return true;
-    }
-    return true;
-  });
-}
-
-// Create application menu
-function createMenu() {
-  const template = [
-    {
-      label: 'File',
-      submenu: [
-        { role: 'quit' }
-      ]
-    },
-    {
-      label: 'Edit',
-      submenu: [
-        { role: 'undo' },
-        { role: 'redo' },
-        { type: 'separator' },
-        { role: 'cut' },
-        { role: 'copy' },
-        { role: 'paste' },
-        { role: 'selectAll' }
-      ]
-    },
-    {
-      label: 'View',
-      submenu: [
-        { role: 'reload' },
-        { role: 'forceReload' },
-        { role: 'toggleDevTools' },
-        { type: 'separator' },
-        { role: 'resetZoom' },
-        { role: 'zoomIn' },
-        { role: 'zoomOut' },
-        { type: 'separator' },
-        { role: 'togglefullscreen' }
-      ]
-    },
-    {
-      label: 'Help',
-      submenu: [
-        {
-          label: 'About ESP32Tool',
-          click: async () => {
-            const { shell } = require('electron');
-            await shell.openExternal('https://github.com/Jason2866/esp32tool');
-          }
-        },
-        {
-          label: 'ESP32 Documentation',
-          click: async () => {
-            const { shell } = require('electron');
-            await shell.openExternal('https://docs.espressif.com/');
-          }
-        }
-      ]
-    }
-  ];
-
-  // macOS specific menu adjustments
-  if (process.platform === 'darwin') {
-    template.unshift({
-      label: app.getName(),
-      submenu: [
-        { role: 'about' },
-        { type: 'separator' },
-        { role: 'services' },
-        { type: 'separator' },
-        { role: 'hide' },
-        { role: 'hideOthers' },
-        { role: 'unhide' },
-        { type: 'separator' },
-        { role: 'quit' }
-      ]
-    });
-  }
-
-  const menu = Menu.buildFromTemplate(template);
-  Menu.setApplicationMenu(menu);
-}
-
-// This method will be called when Electron has finished initialization
-app.whenReady().then(() => {
-  createMenu();
-  createWindow();
-
-  app.on('activate', () => {
-    // On macOS re-create a window when dock icon is clicked and no windows are open
-    if (BrowserWindow.getAllWindows().length === 0) {
-      createWindow();
-    }
-  });
-});
-
-// Quit when all windows are closed, except on macOS
-app.on('window-all-closed', () => {
-  if (process.platform !== 'darwin') {
-    app.quit();
-  }
-});
-
-// ============================================
-// IPC Handlers for File Operations
-// ============================================
-
-// Save file dialog and write data
-ipcMain.handle('save-file', async (event, { data, defaultFilename, filters }) => {
-  const result = await dialog.showSaveDialog(mainWindow, {
-    defaultPath: defaultFilename,
-    filters: filters || [
-      { name: 'Binary Files', extensions: ['bin'] },
-      { name: 'All Files', extensions: ['*'] }
-    ]
-  });
-
-  if (result.canceled || !result.filePath) {
-    return { success: false, canceled: true };
-  }
-
-  try {
-    // Convert data to Buffer if it's a Uint8Array
-    const buffer = Buffer.from(data);
-    fs.writeFileSync(result.filePath, buffer);
-    return { success: true, filePath: result.filePath };
-  } catch (error) {
-    return { success: false, error: error.message };
-  }
-});
-
-// Open file dialog and read data
-ipcMain.handle('open-file', async (event, { filters }) => {
-  const result = await dialog.showOpenDialog(mainWindow, {
-    properties: ['openFile'],
-    filters: filters || [
-      { name: 'Binary Files', extensions: ['bin'] },
-      { name: 'All Files', extensions: ['*'] }
-    ]
-  });
-
-  if (result.canceled || result.filePaths.length === 0) {
-    return { success: false, canceled: true };
-  }
-
-  try {
-    const filePath = result.filePaths[0];
-    const data = fs.readFileSync(filePath);
-    const filename = path.basename(filePath);
-    return { 
-      success: true, 
-      filePath, 
-      filename,
-      data: Array.from(data) // Convert Buffer to array for IPC transfer
-    };
-  } catch (error) {
-    return { success: false, error: error.message };
-  }
-});
-
-// Show input dialog (replacement for prompt())
-ipcMain.handle('show-prompt', async (event, { message, defaultValue }) => {
-  // Use a simple approach - return the default value
-  // In Electron, we use the save dialog instead of prompt
-  return defaultValue;
-});
-
-// Show message box
-ipcMain.handle('show-message', async (event, { type, title, message, buttons }) => {
-  const result = await dialog.showMessageBox(mainWindow, {
-    type: type || 'info',
-    title: title || 'ESP32Tool',
-    message: message,
-    buttons: buttons || ['OK']
-  });
-  return result.response;
-});
-
-// Show confirm dialog
-ipcMain.handle('show-confirm', async (event, { message }) => {
-  const result = await dialog.showMessageBox(mainWindow, {
-    type: 'question',
-    title: 'Confirm',
-    message: message,
-    buttons: ['OK', 'Cancel']
-  });
-  return result.response === 0; // true if OK clicked
-});