esp32tool 1.1.8 → 1.2.0

package/README.md

@@ -2,9 +2,43 @@
 
 # 🚀 ESP32Tool – The Ultimate ESP Filesystem Powerhouse
 
-**Flash. Manage. Dominate. All in your browser.**
+**Flash. Manage. Dominate. In your browser, on desktop, mobile, or command line.**
 
-Meet **ESP32Tool** – your all-in-one, next-gen solution for ESP device management. Experience seamless firmware flashing, backup, and now, full filesystem control with just a few clicks. No drivers, no command line, no limits!
+Meet **ESP32Tool** – your all-in-one, next-gen solution for ESP device management. Experience seamless firmware flashing, backup, and now, full filesystem control with just a few clicks. No drivers, no command line hassle, no limits!
+
+---
+
+## 📦 Available Versions
+
+**Choose the version that fits your workflow:**
+
+### 🌐 Web App (Browser)
+- **Zero installation** – runs directly in your browser
+- Works on any modern desktop or mobile browser
+- Perfect for quick tasks and on-the-go management
+- **Try it now:** [jason2866.github.io/esp32tool](https://jason2866.github.io/esp32tool)
+
+### 📱 Mobile App (Android PWA)
+- **Install as native app** on Android devices
+- Works with USB OTG adapters via WebUSB
+- Full ESP management on your phone or tablet
+- **Install:** Visit [jason2866.github.io/esp32tool](https://jason2866.github.io/esp32tool) in Chrome → "Add to Home screen"
+- **Details:** See [Android Installation](#-android-installation-pwa) below
+
+### 💻 Desktop App (Electron GUI)
+- **Full-featured GUI** with all web capabilities
+- Offline-ready, no internet required
+- Native desktop integration
+- **Download:** [Latest Release](https://github.com/Jason2866/esp32tool/releases)
+- Available for: macOS (Intel & Apple Silicon), Windows, Linux
+
+### ⌨️ Command Line Interface (CLI)
+- **Standalone executable** – no Node.js required!
+- Perfect for automation and scripting
+- esptool.py-compatible commands
+- **Download:** [Latest Release](https://github.com/Jason2866/esp32tool/releases)
+- **Documentation:** [CLI-README.md](CLI-README.md)
+- Available for: macOS (Intel & Apple Silicon), Windows, Linux
 
 ---
 
@@ -18,7 +52,9 @@ ESP32Tool is designed first and foremost for the entire ESP32 family – deliver
 - **Lightning Fast:** Custom, high-performance flash access – up to 10x faster than esptool.py!
 - **Rock-Solid Reliability:** Automatic resume on read errors. No more broken operations, ever.
 - **Plug & Play:** Manage your ESP directly in the browser. No software installation needed.
-- **Offline Ready:** Prefer desktop? Grab the Electron app from our [releases](https://github.com/Jason2866/esp32tool/releases).
+- **Multi-Platform:** Available as web app, desktop app (Electron), and standalone CLI
+- **Offline Ready:** Desktop and CLI versions work completely offline
+- **📱 Android Ready:** Install as Progressive Web App (PWA) on Android! Works with USB OTG adapters via WebUSB.
 
 - **Bonus:** ESP8266 support is now included! Manage filesystems on ESP8266 devices with the same ease.
 
@@ -26,6 +62,60 @@ ESP32Tool is designed first and foremost for the entire ESP32 family – deliver
 
 ---
 
+## 📦 Desktop & CLI Installation
+
+### Desktop App (GUI)
+
+**Download from [GitHub Releases](https://github.com/Jason2866/esp32tool/releases)**
+
+- **macOS:** Download `ESP32Tool-*.dmg`, open and drag to Applications
+- **Windows:** Download and run `ESP32Tool-Setup-*.exe` installer
+- **Linux:** Download `.deb` (Debian/Ubuntu) or `.rpm` (Fedora/RHEL) package
+
+### Command Line Interface
+
+**Download from [GitHub Releases](https://github.com/Jason2866/esp32tool/releases)**
+
+Look for `ESP32Tool-CLI-*` files. No Node.js installation required!
+
+**Quick Start:**
+```bash
+# macOS
+/Applications/ESP32Tool.app/Contents/MacOS/esp32tool list-ports
+/Applications/ESP32Tool.app/Contents/MacOS/esp32tool --port /dev/ttyUSB0 chip-id
+
+# Linux
+./esp32tool list-ports
+./esp32tool --port /dev/ttyUSB0 chip-id
+
+# Windows
+esp32tool.exe list-ports
+esp32tool.exe --port COM3 chip-id
+```
+
+**Full CLI documentation:** [CLI-README.md](CLI-README.md)
+
+---
+
+## 📱 Android Installation (PWA)
+
+ESP32Tool works natively on Android devices with USB OTG support!
+
+**Requirements:**
+- Android 5.0+ (Lollipop or higher)
+- Chrome for Android 61+ (recommended: latest version)
+- USB OTG adapter/cable
+- ESP32/ESP8266 device
+
+**Installation:**
+1. Open [jason2866.github.io/esp32tool](https://jason2866.github.io/esp32tool) in Chrome
+2. Tap the menu (⋮) → "Add to Home screen" or "Install app"
+3. Connect your ESP device via USB OTG adapter
+4. Grant USB permissions when prompted
+5. Flash and manage your ESP devices on the go!
+
+---
+
 ## 🛠️ Developer Quickstart
 
 1. Clone this repository
@@ -35,11 +125,15 @@ ESP32Tool is designed first and foremost for the entire ESP32 family – deliver
 
 ---
 
-## 🏆 Our Story
+## 🏆 The Story
+
+Born from the minds of [Melissa LeBlanc-Williams](https://github.com/makermelissa), Adafruit, Nabu Casa and now supercharged by Jason2866, ESP32Tool has evolved into the most advanced, browser-based ESP management suite. With every update, the boundaries are pushed of what’s possible for your ESP devices.
+
+**Latest updates:**
 
-Born from the minds of [Melissa LeBlanc-Williams](https://github.com/makermelissa), [Nabu Casa](https://www.nabucasa.com), Adafruit, and now supercharged by Jason2866, ESP32Tool has evolved into the most advanced, browser-based ESP management suite. With every update, we push the boundaries of what’s possible for your ESP devices.
+December 2025 – Now with full LittleFS, SPIFFS, and FATFS support, plus file add/delete magic! Available as web app and desktop GUI.
 
-**Latest update:** December 2025 – Now with full LittleFS, SPIFFS, and FATFS support, plus file add/delete magic!
+January 2026 – Added Android mobile devices support, standalone CLI.
 
 ---
 

package/build-electron-cli.cjs

@@ -0,0 +1,177 @@
+#!/usr/bin/env node
+
+/**
+ * Build standalone Electron-based CLI binaries
+ * Creates truly standalone executables that don't require Node.js installation
+ * 
+ * IMPORTANT: This script temporarily swaps package.json with package.cli.json
+ * during the build process, then restores the original package.json.
+ * 
+ * When releasing a new version:
+ * 1. Update version in package.json
+ * 2. Update version in package.cli.json (keep in sync!)
+ * 3. Run this script to build CLI binaries
+ */
+
+const { execSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+console.log('Building Electron-based CLI binaries...\n');
+
+// Ensure dist is built
+if (!fs.existsSync('dist/cli.js')) {
+  console.log('Building TypeScript first...');
+  execSync('npm run build', { stdio: 'inherit' });
+}
+
+// Read package files
+const originalPackage = fs.readFileSync('package.json', 'utf8');
+const cliPackageContent = fs.readFileSync('package.cli.json', 'utf8');
+
+// Parse and sync versions
+const originalPkg = JSON.parse(originalPackage);
+const cliPkg = JSON.parse(cliPackageContent);
+
+if (originalPkg.version !== cliPkg.version) {
+  console.log(`⚠️  Version mismatch detected!`);
+  console.log(`   package.json: ${originalPkg.version}`);
+  console.log(`   package.cli.json: ${cliPkg.version}`);
+  console.log(`   Syncing package.cli.json to ${originalPkg.version}...\n`);
+  
+  cliPkg.version = originalPkg.version;
+}
+
+// Sync dependencies from main package.json to CLI package.json
+if (originalPkg.dependencies) {
+  if (JSON.stringify(originalPkg.dependencies) !== JSON.stringify(cliPkg.dependencies)) {
+    console.log(`⚠️  Dependencies mismatch detected!`);
+    console.log(`   Syncing dependencies from package.json to package.cli.json...\n`);
+    cliPkg.dependencies = originalPkg.dependencies;
+  }
+}
+
+// Save synced package.cli.json if changes were made
+if (originalPkg.version !== JSON.parse(cliPackageContent).version || 
+    JSON.stringify(originalPkg.dependencies) !== JSON.stringify(JSON.parse(cliPackageContent).dependencies)) {
+  fs.writeFileSync('package.cli.json', JSON.stringify(cliPkg, null, 2) + '\n');
+}
+
+const cliPackage = JSON.stringify(cliPkg, null, 2);
+
+try {
+  // Backup original package.json
+  fs.writeFileSync('package.json.backup', originalPackage);
+  
+  // Use CLI package.json
+  fs.writeFileSync('package.json', cliPackage);
+  
+  // Temporarily swap forge configs
+  if (fs.existsSync('forge.config.cjs')) {
+    fs.renameSync('forge.config.cjs', 'forge.config.cjs.gui-backup');
+  }
+  if (fs.existsSync('forge.config.cli.cjs')) {
+    fs.renameSync('forge.config.cli.cjs', 'forge.config.cjs');
+  }
+  
+  // Build for current platform
+  const platform = process.platform;
+  const arch = process.arch;
+  
+  console.log(`\nBuilding CLI for ${platform}-${arch}...`);
+  
+  // Backup GUI builds if they exist
+  let guiBackupPath = null;
+  if (fs.existsSync('out')) {
+    guiBackupPath = 'out-gui-backup-' + Date.now();
+    console.log(`⚠️  Backing up existing GUI builds to ${guiBackupPath}...`);
+    fs.renameSync('out', guiBackupPath);
+  }
+  
+  try {
+    execSync(`npx electron-forge package --platform=${platform} --arch=${arch}`, {
+      stdio: 'inherit'
+    });
+    
+    execSync(`npx electron-forge make --platform=${platform} --arch=${arch}`, {
+      stdio: 'inherit'
+    });
+    
+    // Move CLI output to out-cli directory
+    if (fs.existsSync('out')) {
+      if (fs.existsSync('out-cli')) {
+        fs.rmSync('out-cli', { recursive: true, force: true });
+      }
+      fs.renameSync('out', 'out-cli');
+    }
+    
+    // Restore GUI builds
+    if (guiBackupPath && fs.existsSync(guiBackupPath)) {
+      console.log('✓ Restoring GUI builds...');
+      fs.renameSync(guiBackupPath, 'out');
+    }
+  } catch (error) {
+    // Restore GUI builds even on error
+    if (guiBackupPath && fs.existsSync(guiBackupPath)) {
+      console.log('⚠️  Restoring GUI builds after error...');
+      if (fs.existsSync('out')) {
+        fs.rmSync('out', { recursive: true, force: true });
+      }
+      fs.renameSync(guiBackupPath, 'out');
+    }
+    throw error;
+  }
+  
+  
+  // Rename release files to add -CLI suffix
+  const makeDir = path.join('out-cli', 'make');
+  if (fs.existsSync(makeDir)) {
+    const renameInDir = (dir) => {
+      if (!fs.existsSync(dir)) return;
+      const files = fs.readdirSync(dir, { recursive: true, withFileTypes: true });
+      files.forEach(file => {
+        if (file.isFile()) {
+          const oldPath = path.join(file.path || file.parentPath, file.name);
+          let newName = file.name;
+          
+          // Handle different file types
+          if (file.name.endsWith('.zip') || file.name.endsWith('.exe')) {
+            // Add -CLI before the platform identifier
+            newName = file.name.replace(/(ESP32Tool)(-darwin|-linux|-win32)/, '$1-CLI$2');
+          } else if (file.name.endsWith('.deb')) {
+            // esp32tool_1.2.0_amd64.deb -> esp32tool-cli_1.2.0_amd64.deb
+            newName = file.name.replace(/^esp32tool_/, 'esp32tool-cli_');
+          } else if (file.name.endsWith('.rpm')) {
+            // esp32tool-1.2.0-1.x86_64.rpm -> esp32tool-cli-1.2.0-1.x86_64.rpm
+            newName = file.name.replace(/^esp32tool-/, 'esp32tool-cli-');
+          }
+          
+          const newPath = path.join(file.path || file.parentPath, newName);
+          if (oldPath !== newPath) {
+            fs.renameSync(oldPath, newPath);
+            console.log(`Renamed: ${file.name} -> ${newName}`);
+          }
+        }
+      });
+    };
+    renameInDir(makeDir);
+  }
+  
+  console.log('\n✓ CLI binaries built successfully!');
+  console.log('Output: out-cli/make/');
+  
+} finally {
+  // Restore forge configs
+  if (fs.existsSync('forge.config.cjs')) {
+    fs.renameSync('forge.config.cjs', 'forge.config.cli.cjs');
+  }
+  if (fs.existsSync('forge.config.cjs.gui-backup')) {
+    fs.renameSync('forge.config.cjs.gui-backup', 'forge.config.cjs');
+  }
+  
+  // Restore original package.json
+  fs.writeFileSync('package.json', originalPackage);
+  if (fs.existsSync('package.json.backup')) {
+    fs.unlinkSync('package.json.backup');
+  }
+}

package/build-single-binary.cjs

@@ -0,0 +1,295 @@
+#!/usr/bin/env node
+/**
+ * Build single executable binaries for all platforms
+ * Creates self-contained executables that include Node.js + app + dependencies
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+const archiver = require('archiver');
+
+const packageJson = require('./package.json');
+const VERSION = packageJson.version;
+const NODE_VERSION = packageJson.engines.node.replace(/[^\d.]/g, '').split('.')[0]; // Extract major version
+
+console.log(`Building ESP32Tool CLI v${VERSION} single executables...\n`);
+
+// Create binaries directory
+const binariesDir = path.join(__dirname, 'binaries');
+if (!fs.existsSync(binariesDir)) {
+  fs.mkdirSync(binariesDir, { recursive: true });
+}
+
+// Build the app first
+console.log('1. Building application...');
+execSync('npm run build', { stdio: 'inherit' });
+
+/**
+ * Get all dependencies recursively from package.json
+ */
+function getAllDependencies() {
+  const dependencies = new Set();
+  
+  // Add direct dependencies from package.json
+  if (packageJson.dependencies) {
+    Object.keys(packageJson.dependencies).forEach(dep => dependencies.add(dep));
+  }
+  
+  // Add scoped packages that are dependencies of our dependencies
+  const nodeModulesDir = path.join(__dirname, 'node_modules');
+  
+  // Helper to recursively find dependencies
+  function addDepsRecursively(moduleName) {
+    const modulePath = path.join(nodeModulesDir, moduleName);
+    if (!fs.existsSync(modulePath)) return;
+    
+    const modulePackageJson = path.join(modulePath, 'package.json');
+    if (fs.existsSync(modulePackageJson)) {
+      try {
+        const pkg = JSON.parse(fs.readFileSync(modulePackageJson, 'utf8'));
+        if (pkg.dependencies) {
+          Object.keys(pkg.dependencies).forEach(dep => {
+            if (!dependencies.has(dep)) {
+              dependencies.add(dep);
+              addDepsRecursively(dep);
+            }
+          });
+        }
+      } catch (err) {
+        // Ignore invalid package.json
+      }
+    }
+  }
+  
+  // Recursively add dependencies
+  Array.from(dependencies).forEach(dep => addDepsRecursively(dep));
+  
+  return Array.from(dependencies);
+}
+
+/**
+ * Create bundle directory with all necessary files
+ */
+function createBundle() {
+  const bundleDir = path.join(__dirname, '.bundle-temp');
+  
+  // Clean up old bundle
+  if (fs.existsSync(bundleDir)) {
+    fs.rmSync(bundleDir, { recursive: true });
+  }
+  
+  fs.mkdirSync(bundleDir, { recursive: true });
+  
+  console.log('2. Creating bundle...');
+  
+  // Copy dist
+  fs.cpSync(path.join(__dirname, 'dist'), path.join(bundleDir, 'dist'), { recursive: true });
+  
+  // Get all dependencies from package.json
+  const modules = getAllDependencies();
+  
+  console.log(`   Bundling ${modules.length} dependencies...`);
+  
+  const nodeModulesDir = path.join(bundleDir, 'node_modules');
+  fs.mkdirSync(nodeModulesDir, { recursive: true });
+  
+  modules.forEach(mod => {
+    const src = path.join(__dirname, 'node_modules', mod);
+    const dest = path.join(nodeModulesDir, mod);
+    if (fs.existsSync(src)) {
+      // Ensure parent directory exists (for scoped packages like `@scope/pkg`)
+      fs.mkdirSync(path.dirname(dest), { recursive: true });
+      fs.cpSync(src, dest, { recursive: true });
+    }
+  });
+  
+  // Copy package.json
+  fs.copyFileSync(
+    path.join(__dirname, 'package.json'),
+    path.join(bundleDir, 'package.json')
+  );
+  
+  return bundleDir;
+}
+
+/**
+ * Create launcher script for Unix (macOS/Linux)
+ */
+function createUnixLauncher(bundleDir) {
+  const launcher = `#!/bin/bash
+# ESP32Tool CLI - Self-contained launcher
+
+# Get the directory where this script is located
+DIR="$(cd "$(dirname "\${BASH_SOURCE[0]}")" && pwd)"
+
+# Check for Node.js
+if ! command -v node &> /dev/null; then
+    echo "Error: Node.js not found"
+    echo "Please install Node.js ${NODE_VERSION}+ from https://nodejs.org/"
+    exit 1
+fi
+
+# Check Node.js version
+CURRENT_NODE_VERSION=$(node -v | cut -d'v' -f2 | cut -d'.' -f1)
+if [ "$CURRENT_NODE_VERSION" -lt ${NODE_VERSION} ]; then
+    echo "Error: Node.js ${NODE_VERSION}+ required (found: $(node -v))"
+    echo "Please upgrade Node.js from https://nodejs.org/"
+    exit 1
+fi
+
+# Run CLI
+cd "$DIR"
+exec node dist/cli-fixed.js "$@"
+`;
+  
+  fs.writeFileSync(path.join(bundleDir, 'esp32tool'), launcher);
+  fs.chmodSync(path.join(bundleDir, 'esp32tool'), 0o755);
+}
+
+/**
+ * Create launcher script for Windows
+ */
+function createWindowsLauncher(bundleDir) {
+  const launcher = `@echo off
+REM ESP32Tool CLI - Self-contained launcher
+
+REM Get the directory where this script is located
+set DIR=%~dp0
+
+REM Check for Node.js
+where node >nul 2>nul
+if %ERRORLEVEL% NEQ 0 (
+    echo Error: Node.js not found
+    echo Please install Node.js ${NODE_VERSION}+ from https://nodejs.org/
+    exit /b 1
+)
+
+REM Check Node.js version
+for /f "tokens=2 delims=v." %%a in ('node -v') do (
+    set NODE_MAJOR=%%a
+    goto :check_version
+)
+:check_version
+if %NODE_MAJOR% LSS ${NODE_VERSION} (
+    echo Error: Node.js ${NODE_VERSION}+ required
+    echo Please upgrade Node.js from https://nodejs.org/
+    exit /b 1
+)
+
+REM Run CLI
+cd /d "%DIR%"
+node dist\\cli-fixed.js %*
+`;
+  
+  fs.writeFileSync(path.join(bundleDir, 'esp32tool.bat'), launcher);
+}
+
+/**
+ * Create self-extracting archive for Unix using makeself
+ */
+function createUnixBinary(bundleDir, platform) {
+  console.log(`3. Creating ${platform} binary...`);
+  
+  const outputFile = path.join(binariesDir, `esp32tool-${platform}`);
+  
+  try {
+    // Check if makeself is available
+    try {
+      execSync('which makeself', { stdio: 'pipe' });
+    } catch {
+      console.error(`   ✗ Skipped: makeself not installed (install with: brew install makeself / apt install makeself)`);
+      return;
+    }
+
+    // Create makeself archive with .run extension
+    const runFile = `${outputFile}.run`;
+    execSync(
+      `makeself --notemp "${bundleDir}" "${runFile}" "ESP32Tool CLI v${VERSION}" ./esp32tool`,
+      { stdio: 'inherit' }
+    );
+    
+    // Create wrapper script that adds -- automatically
+    const runFileName = path.basename(runFile);
+    const wrapper = `#!/bin/bash
+# ESP32Tool CLI Wrapper
+
+SCRIPT_DIR="$(cd "$(dirname "\${BASH_SOURCE[0]}")" && pwd)"
+exec "$SCRIPT_DIR/${runFileName}" -- "$@"
+`;
+    
+    fs.writeFileSync(outputFile, wrapper);
+    fs.chmodSync(outputFile, 0o755);
+    
+    console.log(`   ✓ Created: ${outputFile}`);
+  } catch (err) {
+    console.error(`   ✗ Failed: ${err.message}`);
+  }
+}
+
+/**
+ * Create ZIP archive for Windows
+ */
+function createWindowsBinary(bundleDir) {
+  console.log('3. Creating Windows binary...');
+  
+  const outputFile = path.join(binariesDir, `esp32tool-win-x64.zip`);
+  
+  return new Promise((resolve, reject) => {
+    const output = fs.createWriteStream(outputFile);
+    const archive = archiver('zip', { zlib: { level: 9 } });
+    
+    output.on('close', () => {
+      console.log(`   ✓ Created: ${outputFile}`);
+      resolve();
+    });
+    
+    output.on('error', reject);
+    archive.on('error', reject);
+    archive.pipe(output);
+    archive.directory(bundleDir, false);
+    archive.finalize();
+  });
+}
+
+/**
+ * Main build process
+ */
+async function main() {
+  try {
+    // Create bundle
+    const bundleDir = createBundle();
+    
+    // Create launchers
+    createUnixLauncher(bundleDir);
+    createWindowsLauncher(bundleDir);
+    
+    // Create binaries for each platform
+    createUnixBinary(bundleDir, 'macos');
+    createUnixBinary(bundleDir, 'linux-x64');
+    await createWindowsBinary(bundleDir);
+    
+    // Clean up
+    fs.rmSync(bundleDir, { recursive: true });
+    
+    console.log('\n✓ All binaries created!\n');
+    console.log('Files in ./binaries/:');
+    fs.readdirSync(binariesDir).forEach(file => {
+      const stats = fs.statSync(path.join(binariesDir, file));
+      const sizeMB = (stats.size / 1024 / 1024).toFixed(2);
+      console.log(`  - ${file} (${sizeMB} MB)`);
+    });
+    
+    console.log('\nUsage:');
+    console.log('  macOS:   ./binaries/esp32tool-macos list-ports');
+    console.log('  Linux:   ./binaries/esp32tool-linux-x64 list-ports');
+    console.log('  Windows: Extract zip, then: esp32tool.bat list-ports');
+    console.log(`\nNote: Requires Node.js ${NODE_VERSION}+ on target system`);
+    
+  } catch (error) {
+    console.error('\nError:', error.message);
+    process.exit(1);
+  }
+}
+
+main();

package/css/light.css

@@ -154,3 +154,14 @@ button {
 .littlefs-fs-button:hover {
   background-color: #71ae1e;
 }
+
+/* ESP8266 Info Box - Light Mode */
+.esp8266-info .info-box {
+  background-color: #f8f9fa;
+  border-color: #00a7e9;
+  color: #333;
+}
+
+.esp8266-info .info-box strong {
+  color: #00a7e9;
+}