esp32tool 1.6.6 → 1.6.7

package/electron/main.cjs

@@ -1,12 +1,19 @@
-const { app, BrowserWindow, Menu, session, ipcMain, dialog } = require('electron');
-const path = require('path');
-const fs = require('fs');
+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') {
+if (process.platform === "win32") {
   try {
-    if (require('electron-squirrel-startup')) {
+    if (require("electron-squirrel-startup")) {
       app.quit();
     }
   } catch (e) {
@@ -28,22 +35,22 @@ function createWindow() {
     webPreferences: {
       nodeIntegration: false,
       contextIsolation: true,
-      preload: path.join(__dirname, 'preload.js'),
+      preload: path.join(__dirname, "preload.js"),
     },
-    icon: path.join(__dirname, 'icons', 'icon.png'),
-    title: 'ESP32Tool',
+    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'));
+  mainWindow.loadFile(path.join(__dirname, "..", "index.html"));
 
   // Open DevTools in development
-  if (process.env.NODE_ENV === 'development') {
+  if (process.env.NODE_ENV === "development") {
     mainWindow.webContents.openDevTools();
   }
 
-  mainWindow.on('closed', () => {
+  mainWindow.on("closed", () => {
     mainWindow = null;
   });
 
@@ -53,51 +60,56 @@ function createWindow() {
 
 function setupSerialPortHandlers(ses) {
   const isLikelyEspPort = (port) => {
-    const name = `${port?.displayName || ''} ${port?.portName || ''}`.toLowerCase();
+    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('ft232') ||
-      name.includes('usb') ||
-      name.includes('uart') ||
-      name.includes('silicon labs') ||
-      name.includes('esp32') ||
-      name.includes('esp8266') ||
-      name.includes('esp')
+      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("ft232") ||
+      name.includes("usb") ||
+      name.includes("uart") ||
+      name.includes("silicon labs") ||
+      name.includes("esp32") ||
+      name.includes("esp8266") ||
+      name.includes("esp")
     );
   };
 
-  const getPortLabel = (port) => port?.displayName || port?.portName || port?.portId || 'Unknown port';
+  const getPortLabel = (port) =>
+    port?.displayName || port?.portName || port?.portId || "Unknown port";
 
   const getPortButtonLabel = (port, isRecommended = false) => {
-    const shortId = port?.portName || port?.displayName || port?.portId || 'Unknown';
+    const shortId =
+      port?.portName || port?.displayName || port?.portId || "Unknown";
     return isRecommended ? `${shortId} (Recommended)` : shortId;
   };
 
   const toHexId = (value) =>
-    typeof value === 'number' ? `0x${value.toString(16).toUpperCase().padStart(4, '0')}` : null;
+    typeof value === "number"
+      ? `0x${value.toString(16).toUpperCase().padStart(4, "0")}`
+      : null;
 
   // Guard against Electron re-firing select-serial-port while a dialog is open
   let activeSelectionId = 0;
 
   // Handle serial port selection - shows when navigator.serial.requestPort() is called
-  ses.on('select-serial-port', (event, portList, webContents, callback) => {
+  ses.on("select-serial-port", (event, portList, webContents, callback) => {
     event.preventDefault();
 
     // Filter to only show ESP-compatible ports
     const espPorts = (portList || []).filter(isLikelyEspPort);
 
     if (espPorts.length === 0) {
-      callback('');
+      callback("");
       return;
     }
 
@@ -113,35 +125,38 @@ function setupSerialPortHandlers(ses) {
     const buttonLabels = espPorts.map((port) => getPortButtonLabel(port));
     const cancelIndex = buttonLabels.length;
 
-    const ownerWindow = BrowserWindow.fromWebContents(webContents) || mainWindow;
-    dialog.showMessageBox(ownerWindow, {
-      type: 'question',
-      title: 'ESP32Tool',
-      message: 'Select the serial port for your ESP device.',
-      buttons: [...buttonLabels, 'Cancel'],
-      defaultId: 0,
-      cancelId: cancelIndex,
-      noLink: true,
-    }).then((result) => {
-      // Ignore if a newer select-serial-port event superseded this one
-      if (mySelectionId !== activeSelectionId) return;
-      const selectedPort = espPorts[result.response];
-      callback(selectedPort ? selectedPort.portId : '');
-    });
+    const ownerWindow =
+      BrowserWindow.fromWebContents(webContents) || mainWindow;
+    dialog
+      .showMessageBox(ownerWindow, {
+        type: "question",
+        title: "ESP32Tool",
+        message: "Select the serial port for your ESP device.",
+        buttons: [...buttonLabels, "Cancel"],
+        defaultId: 0,
+        cancelId: cancelIndex,
+        noLink: true,
+      })
+      .then((result) => {
+        // Ignore if a newer select-serial-port event superseded this one
+        if (mySelectionId !== activeSelectionId) return;
+        const selectedPort = espPorts[result.response];
+        callback(selectedPort ? selectedPort.portId : "");
+      });
   });
 
-  ses.on('serial-port-added', (event, port) => {
-    console.log('Serial port added:', port);
+  ses.on("serial-port-added", (event, port) => {
+    console.log("Serial port added:", port);
   });
 
-  ses.on('serial-port-removed', (event, port) => {
-    console.log('Serial port removed:', port);
+  ses.on("serial-port-removed", (event, port) => {
+    console.log("Serial port removed:", port);
   });
 
   ses.setPermissionCheckHandler(() => true);
 
   ses.setDevicePermissionHandler((details) => {
-    if (details.deviceType === 'serial' && details.device) {
+    if (details.deviceType === "serial" && details.device) {
       grantedDevices.set(details.device.deviceId, details.device);
     }
     return true;
@@ -152,73 +167,71 @@ function setupSerialPortHandlers(ses) {
 function createMenu() {
   const template = [
     {
-      label: 'File',
-      submenu: [
-        { role: 'quit' }
-      ]
+      label: "File",
+      submenu: [{ role: "quit" }],
     },
     {
-      label: 'Edit',
+      label: "Edit",
       submenu: [
-        { role: 'undo' },
-        { role: 'redo' },
-        { type: 'separator' },
-        { role: 'cut' },
-        { role: 'copy' },
-        { role: 'paste' },
-        { role: 'selectAll' }
-      ]
+        { role: "undo" },
+        { role: "redo" },
+        { type: "separator" },
+        { role: "cut" },
+        { role: "copy" },
+        { role: "paste" },
+        { role: "selectAll" },
+      ],
     },
     {
-      label: 'View',
+      label: "View",
       submenu: [
-        { role: 'reload' },
-        { role: 'forceReload' },
-        { role: 'toggleDevTools' },
-        { type: 'separator' },
-        { role: 'resetZoom' },
-        { role: 'zoomIn' },
-        { role: 'zoomOut' },
-        { type: 'separator' },
-        { role: 'togglefullscreen' }
-      ]
+        { role: "reload" },
+        { role: "forceReload" },
+        { role: "toggleDevTools" },
+        { type: "separator" },
+        { role: "resetZoom" },
+        { role: "zoomIn" },
+        { role: "zoomOut" },
+        { type: "separator" },
+        { role: "togglefullscreen" },
+      ],
     },
     {
-      label: 'Help',
+      label: "Help",
       submenu: [
         {
-          label: 'About ESP32Tool',
+          label: "About ESP32Tool",
           click: async () => {
-            const { shell } = require('electron');
-            await shell.openExternal('https://github.com/Jason2866/esp32tool');
-          }
+            const { shell } = require("electron");
+            await shell.openExternal("https://github.com/Jason2866/esp32tool");
+          },
         },
         {
-          label: 'ESP32 Documentation',
+          label: "ESP32 Documentation",
           click: async () => {
-            const { shell } = require('electron');
-            await shell.openExternal('https://docs.espressif.com/');
-          }
-        }
-      ]
-    }
+            const { shell } = require("electron");
+            await shell.openExternal("https://docs.espressif.com/");
+          },
+        },
+      ],
+    },
   ];
 
   // macOS specific menu adjustments
-  if (process.platform === 'darwin') {
+  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' }
-      ]
+        { role: "about" },
+        { type: "separator" },
+        { role: "services" },
+        { type: "separator" },
+        { role: "hide" },
+        { role: "hideOthers" },
+        { role: "unhide" },
+        { type: "separator" },
+        { role: "quit" },
+      ],
     });
   }
 
@@ -231,7 +244,7 @@ app.whenReady().then(() => {
   createMenu();
   createWindow();
 
-  app.on('activate', () => {
+  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();
@@ -240,8 +253,8 @@ app.whenReady().then(() => {
 });
 
 // Quit when all windows are closed, except on macOS
-app.on('window-all-closed', () => {
-  if (process.platform !== 'darwin') {
+app.on("window-all-closed", () => {
+  if (process.platform !== "darwin") {
     app.quit();
   }
 });
@@ -251,37 +264,40 @@ app.on('window-all-closed', () => {
 // ============================================
 
 // 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: ['*'] }
-    ]
-  });
+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 };
-  }
+    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 };
-  }
-});
+    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 }) => {
+ipcMain.handle("open-file", async (event, { filters }) => {
   const result = await dialog.showOpenDialog(mainWindow, {
-    properties: ['openFile'],
+    properties: ["openFile"],
     filters: filters || [
-      { name: 'Binary Files', extensions: ['bin'] },
-      { name: 'All Files', extensions: ['*'] }
-    ]
+      { name: "Binary Files", extensions: ["bin"] },
+      { name: "All Files", extensions: ["*"] },
+    ],
   });
 
   if (result.canceled || result.filePaths.length === 0) {
@@ -292,11 +308,11 @@ ipcMain.handle('open-file', async (event, { filters }) => {
     const filePath = result.filePaths[0];
     const data = fs.readFileSync(filePath);
     const filename = path.basename(filePath);
-    return { 
-      success: true, 
-      filePath, 
+    return {
+      success: true,
+      filePath,
       filename,
-      data: Array.from(data) // Convert Buffer to array for IPC transfer
+      data: Array.from(data), // Convert Buffer to array for IPC transfer
     };
   } catch (error) {
     return { success: false, error: error.message };
@@ -304,30 +320,33 @@ ipcMain.handle('open-file', async (event, { filters }) => {
 });
 
 // Show input dialog (replacement for prompt())
-ipcMain.handle('show-prompt', async (event, { message, defaultValue }) => {
+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;
-});
+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 }) => {
+ipcMain.handle("show-confirm", async (event, { message }) => {
   const result = await dialog.showMessageBox(mainWindow, {
-    type: 'question',
-    title: 'Confirm',
+    type: "question",
+    title: "Confirm",
     message: message,
-    buttons: ['OK', 'Cancel']
+    buttons: ["OK", "Cancel"],
   });
   return result.response === 0; // true if OK clicked
 });

package/electron/preload.js

@@ -1,10 +1,10 @@
 // Preload script for Electron
 // This runs in a sandboxed environment with access to some Node.js APIs
 
-const { contextBridge, ipcRenderer } = require('electron');
+const { contextBridge, ipcRenderer } = require("electron");
 
 // Expose platform info and file APIs to renderer
-contextBridge.exposeInMainWorld('electronAPI', {
+contextBridge.exposeInMainWorld("electronAPI", {
   platform: process.platform,
   isElectron: true,
   versions: {
@@ -12,26 +12,24 @@ contextBridge.exposeInMainWorld('electronAPI', {
     chrome: process.versions.chrome,
     electron: process.versions.electron,
   },
-  
+
   // File operations
-  saveFile: (data, defaultFilename, filters) => 
-    ipcRenderer.invoke('save-file', { data, defaultFilename, filters }),
-  
-  openFile: (filters) => 
-    ipcRenderer.invoke('open-file', { filters }),
-  
+  saveFile: (data, defaultFilename, filters) =>
+    ipcRenderer.invoke("save-file", { data, defaultFilename, filters }),
+
+  openFile: (filters) => ipcRenderer.invoke("open-file", { filters }),
+
   // Dialog operations
   showPrompt: (message, defaultValue) =>
-    ipcRenderer.invoke('show-prompt', { message, defaultValue }),
-  
+    ipcRenderer.invoke("show-prompt", { message, defaultValue }),
+
   showMessage: (type, title, message, buttons) =>
-    ipcRenderer.invoke('show-message', { type, title, message, buttons }),
-  
-  showConfirm: (message) =>
-    ipcRenderer.invoke('show-confirm', { message })
+    ipcRenderer.invoke("show-message", { type, title, message, buttons }),
+
+  showConfirm: (message) => ipcRenderer.invoke("show-confirm", { message }),
 });
 
 // Log when preload script runs
-console.log('Electron preload script loaded');
-console.log('Platform:', process.platform);
-console.log('Electron version:', process.versions.electron);
+console.log("Electron preload script loaded");
+console.log("Platform:", process.platform);
+console.log("Electron version:", process.versions.electron);

package/js/console.js

@@ -133,7 +133,7 @@ export class ESP32ToolConsole {
     `;
 
     this.console = new ColoredConsole(
-      this.containerElement.querySelector(".log")
+      this.containerElement.querySelector(".log"),
     );
 
     // Setup event listeners
@@ -152,18 +152,22 @@ export class ESP32ToolConsole {
       closeBtn.addEventListener("click", () => {
         // Dispatch close event to parent
         this.containerElement.dispatchEvent(
-          new CustomEvent("console-close", { bubbles: true })
+          new CustomEvent("console-close", { bubbles: true }),
         );
       });
     }
 
-    const improvBtn = this.containerElement.querySelector("#console-improv-btn");
+    const improvBtn = this.containerElement.querySelector(
+      "#console-improv-btn",
+    );
     if (improvBtn) {
       improvBtn.addEventListener("click", () => this._openImprov());
     }
 
     if (this.allowInput) {
-      const input = this.containerElement.querySelector(".esp32tool-console-input");
+      const input = this.containerElement.querySelector(
+        ".esp32tool-console-input",
+      );
 
       this.containerElement.addEventListener("click", () => {
         // Only focus input if user didn't select some text
@@ -217,10 +221,10 @@ export class ESP32ToolConsole {
       this.console.addLine("");
       this.console.addLine("");
       this.console.addLine(
-        `Terminal disconnected: Port readable stream not available`
+        `Terminal disconnected: Port readable stream not available`,
       );
       console.error(
-        "Port readable stream not available - port may need to be reopened at correct baudrate"
+        "Port readable stream not available - port may need to be reopened at correct baudrate",
       );
       return;
     }
@@ -248,14 +252,14 @@ export class ESP32ToolConsole {
                   if (pat.test(chunk)) {
                     bootloaderDetected = true;
                     this.containerElement.dispatchEvent(
-                      new CustomEvent("console-bootloader", { bubbles: true })
+                      new CustomEvent("console-bootloader", { bubbles: true }),
                     );
                     break;
                   }
                 }
               }
             },
-          })
+          }),
         );
       if (!abortSignal.aborted) {
         this.console.addLine("");
@@ -264,7 +268,10 @@ export class ESP32ToolConsole {
       }
     } catch (e) {
       // Only log disconnect errors if the abort was NOT intentional
-      if (!abortSignal.aborted && !(e instanceof DOMException && e.name === 'AbortError')) {
+      if (
+        !abortSignal.aborted &&
+        !(e instanceof DOMException && e.name === "AbortError")
+      ) {
         this.console.addLine("");
         this.console.addLine("");
         this.console.addLine(`Terminal disconnected: ${e}`);
@@ -297,7 +304,9 @@ export class ESP32ToolConsole {
   }
 
   async _sendCommand() {
-    const input = this.containerElement.querySelector(".esp32tool-console-input");
+    const input = this.containerElement.querySelector(
+      ".esp32tool-console-input",
+    );
     const command = input.value;
 
     if (command.trim() !== "") {
@@ -347,8 +356,8 @@ export class ESP32ToolConsole {
 
     // Only check the first 30 lines (same as _connect) to avoid false positives
     // from bootloader patterns appearing later in normal firmware output
-    const lines = text.split('\n');
-    const firstLines = lines.slice(0, 30).join('\n');
+    const lines = text.split("\n");
+    const firstLines = lines.slice(0, 30).join("\n");
 
     for (const pat of BOOTLOADER_PATTERNS) {
       if (pat.test(firstLines)) {