esp32tool 1.1.9 → 1.3.0

package/electron/main.cjs

@@ -0,0 +1,338 @@
+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
+});

package/electron/main.js

@@ -70,8 +70,13 @@ function setupSerialPortHandlers(ses) {
       // Try to find ESP-compatible port
       const espPort = portList.find(port => {
         const name = (port.displayName || port.portName || '').toLowerCase();
-        return name.includes('cp210') ||
-               name.includes('ch910') ||
+        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') ||

package/fix-cli-imports.cjs

@@ -0,0 +1,127 @@
+const fs = require('fs');
+const path = require('path');
+
+if (!fs.existsSync('dist/cli.js')) {
+  console.error('Run npm run build first!');
+  process.exit(1);
+}
+
+function fixImportsInFile(filePath) {
+  let content = fs.readFileSync(filePath, 'utf8');
+  
+  // Determine the relative path depth (how many ../ we need)
+  const depth = filePath.split(path.sep).length - 2; // -2 for 'dist' and filename
+  const prefix = depth > 0 ? '../'.repeat(depth) : './';
+  
+  // Fix imports with single quotes: add .js extension to relative imports
+  content = content.replace(/from '\.\.\/([^']+)'/g, function(match, moduleName) {
+    if (moduleName.endsWith('.js') || moduleName.endsWith('.json')) {
+      return match;
+    }
+    if (moduleName === 'stubs') {
+      return `from '../stubs/index.js'`;
+    }
+    return `from '../${moduleName}.js'`;
+  });
+  
+  content = content.replace(/from '\.\/([^']+)'/g, function(match, moduleName) {
+    if (moduleName.endsWith('.js') || moduleName.endsWith('.json')) {
+      return match;
+    }
+    if (moduleName === 'stubs') {
+      return `from './stubs/index.js'`;
+    }
+    return `from './${moduleName}.js'`;
+  });
+  
+  // Fix imports with double quotes
+  content = content.replace(/from "\.\.\/([^"]+)"/g, function(match, moduleName) {
+    if (moduleName.endsWith('.js') || moduleName.endsWith('.json')) {
+      return match;
+    }
+    if (moduleName === 'stubs') {
+      return `from "../stubs/index.js"`;
+    }
+    return `from "../${moduleName}.js"`;
+  });
+  
+  content = content.replace(/from "\.\/([^"]+)"/g, function(match, moduleName) {
+    if (moduleName.endsWith('.js') || moduleName.endsWith('.json')) {
+      return match;
+    }
+    if (moduleName === 'stubs') {
+      return `from "./stubs/index.js"`;
+    }
+    return `from "./${moduleName}.js"`;
+  });
+  
+  // Fix dynamic JSON imports and add .default access
+  // Pattern: stubcode = await import("./esp32c3.json", { with: { type: "json" } });
+  // Replace with: stubcode = (await import("./esp32c3.json", { with: { type: "json" } })).default;
+  content = content.replace(
+    /(\w+)\s*=\s*await\s+import\("\.\/([^"]+\.json)",\s*\{\s*with:\s*\{\s*type:\s*"json"\s*\}\s*\}\);/g,
+    function(match, varName, jsonFile) {
+      return `${varName} = (await import("./${jsonFile}", { with: { type: "json" } })).default;`;
+    }
+  );
+  
+  // Also handle JSON imports without .default that were already processed
+  // Pattern: stubcode = await import("./esp32c3.json", { with: { type: "json" } });
+  // This catches cases where the import is already formatted but missing .default
+  content = content.replace(
+    /(\w+)\s*=\s*await\s+import\(([^)]+\.json[^)]*)\);/g,
+    function(match, varName, importPath) {
+      // Skip if already has .default
+      if (match.includes('.default')) {
+        return match;
+      }
+      return `${varName} = (await import(${importPath})).default;`;
+    }
+  );
+  
+  // Also fix dynamic imports for .js files
+  content = content.replace(/import\("\.\/([^"]+)"\)/g, function(match, moduleName) {
+    if (moduleName.endsWith('.js')) {
+      return match;
+    }
+    if (moduleName.endsWith('.json')) {
+      // Add JSON import assertion for Node.js ES modules
+      return `import("./${moduleName}", { with: { type: "json" } })`;
+    }
+    return `import("./${moduleName}.js")`;
+  });
+  
+  fs.writeFileSync(filePath, content);
+}
+
+function fixAllJsFiles(dir) {
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+  
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+    
+    if (entry.isDirectory()) {
+      // Recursively fix subdirectories
+      fixAllJsFiles(fullPath);
+    } else if (entry.isFile() && entry.name.endsWith('.js') && entry.name !== 'cli-fixed.js') {
+      fixImportsInFile(fullPath);
+    }
+  }
+}
+
+console.log('Fixing imports in all .js files...');
+fixAllJsFiles('dist');
+
+// Now create cli-fixed.js with shebang
+let cliSrc = fs.readFileSync('dist/cli.js', 'utf8');
+
+// Remove shebang if present
+if (cliSrc.startsWith('#!')) {
+  cliSrc = cliSrc.substring(cliSrc.indexOf('\n') + 1);
+}
+
+// Write fixed version with shebang
+fs.writeFileSync('dist/cli-fixed.js', '#!/usr/bin/env node\n' + cliSrc);
+fs.chmodSync('dist/cli-fixed.js', 0o755);
+
+console.log('CLI built: dist/cli-fixed.js');

package/generate-icons.sh

@@ -0,0 +1,89 @@
+#!/bin/bash
+
+# Icon Generator für ESP32Tool PWA
+# Erstellt einfache Placeholder-Icons falls ImageMagick installiert ist
+
+echo "🎨 ESP32Tool Icon Generator"
+echo ""
+
+# Prüfe ob ImageMagick installiert ist
+if ! command -v convert &> /dev/null; then
+    echo "❌ ImageMagick ist nicht installiert!"
+    echo ""
+    echo "Installation:"
+    echo "  macOS:  brew install imagemagick"
+    echo "  Linux:  sudo apt install imagemagick"
+    echo "  Windows: https://imagemagick.org/script/download.php"
+    echo ""
+    echo "Alternativ: Nutze ein Online-Tool wie https://realfavicongenerator.net/"
+    exit 1
+fi
+
+# Erstelle icons Ordner
+mkdir -p icons
+mkdir -p screenshots
+
+echo "📦 Erstelle Icon-Größen..."
+
+# Farben
+BG_COLOR="#1a1a1a"
+TEXT_COLOR="#ffffff"
+ACCENT_COLOR="#4CAF50"
+
+# Erstelle Icons mit ESP32 Text
+for size in 72 96 128 144 152 192 384 512; do
+    # Berechne Schriftgröße basierend auf Icon-Größe
+    fontsize=$((size / 6))
+    
+    convert -size ${size}x${size} xc:${BG_COLOR} \
+        -fill ${ACCENT_COLOR} -draw "circle $((size/2)),$((size/2)) $((size/2)),$((size/4))" \
+        -fill ${TEXT_COLOR} -pointsize ${fontsize} -font "DejaVu-Sans-Bold" \
+        -gravity center -annotate +0-$((size/12)) "ESP32" \
+        -pointsize $((fontsize/2)) -annotate +0+$((size/8)) "TOOL" \
+        icons/icon-${size}.png
+    
+    echo "  ✅ icon-${size}.png"
+done
+
+# Erstelle Favicon
+convert icons/icon-192.png -resize 32x32 favicon.ico
+echo "  ✅ favicon.ico"
+
+# Erstelle Apple Touch Icon
+convert icons/icon-192.png -resize 180x180 apple-touch-icon.png
+echo "  ✅ apple-touch-icon.png"
+
+# Erstelle Placeholder Screenshots
+echo ""
+echo "📸 Erstelle Placeholder Screenshots..."
+
+# Desktop Screenshot (1280x720)
+convert -size 1280x720 xc:${BG_COLOR} \
+    -fill ${TEXT_COLOR} -pointsize 48 -font "Helvetica-Bold" \
+    -gravity center -annotate +0-100 "ESP32Tool" \
+    -pointsize 24 -annotate +0+0 "Flash & Read ESP Devices" \
+    -pointsize 18 -annotate +0+50 "Desktop View" \
+    screenshots/desktop.png
+echo "  ✅ desktop.png (1280x720)"
+
+# Mobile Screenshot (540x720)
+convert -size 540x720 xc:${BG_COLOR} \
+    -fill ${TEXT_COLOR} -pointsize 36 -font "Helvetica-Bold" \
+    -gravity center -annotate +0-100 "ESP32Tool" \
+    -pointsize 18 -annotate +0+0 "Flash & Read" \
+    -pointsize 18 -annotate +0+30 "ESP Devices" \
+    -pointsize 14 -annotate +0+80 "Mobile View" \
+    screenshots/mobile.png
+echo "  ✅ mobile.png (540x720)"
+
+echo ""
+echo "✨ Fertig! Icons und Screenshots wurden erstellt."
+echo ""
+echo "📁 Dateien:"
+echo "  - icons/icon-*.png (8 Größen)"
+echo "  - favicon.ico"
+echo "  - apple-touch-icon.png"
+echo "  - screenshots/*.png"
+echo ""
+echo "💡 Tipp: Ersetze die Placeholder-Icons mit deinem eigenen Logo!"
+echo "   Nutze dazu: convert dein-logo.png -resize 512x512 icons/icon-512.png"