ruvllm-esp32 0.2.0 → 0.3.0

package/bin/cli.js

@@ -94,13 +94,31 @@ function detectPort() {
 
     try {
         if (platform === 'win32') {
-            // Windows: Look for COM ports
-            const result = execSync('wmic path Win32_SerialPort get DeviceID', { encoding: 'utf8' });
-            const ports = result.split('\n').filter(line => line.includes('COM')).map(line => line.trim());
-            return ports[0] || 'COM3';
+            // Windows: Use PowerShell for better COM port detection
+            try {
+                const result = execSync(
+                    'powershell -Command "[System.IO.Ports.SerialPort]::GetPortNames() | Sort-Object { [int]($_ -replace \'COM\', \'\') }"',
+                    { encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] }
+                );
+                const ports = result.trim().split('\n').filter(p => p.match(/COM\d+/));
+                if (ports.length > 0) {
+                    return ports[0].trim();
+                }
+            } catch {
+                // Fallback to wmic
+                const result = execSync('wmic path Win32_SerialPort get DeviceID 2>nul', { encoding: 'utf8' });
+                const ports = result.split('\n').filter(line => line.includes('COM')).map(line => line.trim());
+                if (ports.length > 0) return ports[0];
+            }
+            return 'COM3';
         } else if (platform === 'darwin') {
             // macOS
-            const files = fs.readdirSync('/dev').filter(f => f.startsWith('cu.usbserial') || f.startsWith('cu.SLAB'));
+            const files = fs.readdirSync('/dev').filter(f =>
+                f.startsWith('cu.usbserial') ||
+                f.startsWith('cu.SLAB') ||
+                f.startsWith('cu.wchusbserial') ||
+                f.startsWith('cu.usbmodem')
+            );
             return files[0] ? `/dev/${files[0]}` : '/dev/cu.usbserial-0001';
         } else {
             // Linux
@@ -127,27 +145,52 @@ async function installToolchain() {
     const { platform } = detectPlatform();
 
     try {
-        // Install espup
-        logStep('Installing espup...');
         if (platform === 'win32') {
-            execSync('cargo install espup', { stdio: 'inherit' });
-        } else {
-            execSync('curl -L https://github.com/esp-rs/espup/releases/latest/download/espup-x86_64-unknown-linux-gnu -o /tmp/espup && chmod +x /tmp/espup && /tmp/espup install', { stdio: 'inherit' });
-        }
+            // Windows: Check if we have the PowerShell setup script
+            const scriptsDir = path.join(__dirname, '..', 'scripts', 'windows');
+            const setupScript = path.join(scriptsDir, 'setup.ps1');
 
-        // Install espflash
-        logStep('Installing espflash...');
-        execSync('cargo install espflash ldproxy', { stdio: 'inherit' });
+            if (fs.existsSync(setupScript)) {
+                logStep('Running Windows setup script...');
+                execSync(`powershell -ExecutionPolicy Bypass -File "${setupScript}"`, { stdio: 'inherit' });
+            } else {
+                // Fallback: manual installation
+                logStep('Installing espup...');
 
-        // Run espup install
-        logStep('Setting up ESP32 toolchain...');
-        execSync('espup install', { stdio: 'inherit' });
+                // Download espup for Windows
+                const espupUrl = 'https://github.com/esp-rs/espup/releases/latest/download/espup-x86_64-pc-windows-msvc.exe';
+                const espupPath = path.join(os.tmpdir(), 'espup.exe');
+
+                execSync(`powershell -Command "Invoke-WebRequest -Uri '${espupUrl}' -OutFile '${espupPath}'"`, { stdio: 'inherit' });
+
+                logStep('Running espup install...');
+                execSync(`"${espupPath}" install`, { stdio: 'inherit' });
+
+                // Install espflash
+                logStep('Installing espflash...');
+                execSync('cargo install espflash ldproxy', { stdio: 'inherit' });
+            }
+
+            logSuccess('Toolchain installed successfully!');
+            log('\nTo use the toolchain, run:', 'yellow');
+            log('  . .\\scripts\\windows\\env.ps1', 'cyan');
 
-        logSuccess('Toolchain installed successfully!');
-        log('\nPlease restart your terminal or run:', 'yellow');
-        if (platform === 'win32') {
-            log('  $env:PATH = [System.Environment]::GetEnvironmentVariable("Path","User")', 'cyan');
         } else {
+            // Linux/macOS
+            logStep('Installing espup...');
+            const arch = os.arch() === 'arm64' ? 'aarch64' : 'x86_64';
+            const binary = platform === 'darwin'
+                ? `espup-${arch}-apple-darwin`
+                : `espup-${arch}-unknown-linux-gnu`;
+
+            execSync(`curl -L https://github.com/esp-rs/espup/releases/latest/download/${binary} -o /tmp/espup && chmod +x /tmp/espup && /tmp/espup install`, { stdio: 'inherit' });
+
+            // Install espflash
+            logStep('Installing espflash...');
+            execSync('cargo install espflash ldproxy', { stdio: 'inherit' });
+
+            logSuccess('Toolchain installed successfully!');
+            log('\nPlease restart your terminal or run:', 'yellow');
             log('  source $HOME/export-esp.sh', 'cyan');
         }
 
@@ -160,8 +203,9 @@ async function installToolchain() {
 
 async function build(options = {}) {
     const target = options.target || 'esp32';
-    const release = options.release || false;
+    const release = options.release !== false; // Default to release
     const features = options.features || '';
+    const { platform } = detectPlatform();
 
     logStep(`Building for ${target}${release ? ' (release)' : ''}...`);
 
@@ -175,12 +219,33 @@ async function build(options = {}) {
 
     const rustTarget = targetMap[target] || targetMap['esp32'];
 
-    let cmd = `cargo build --target ${rustTarget}`;
-    if (release) cmd += ' --release';
-    if (features) cmd += ` --features ${features}`;
-
     try {
-        execSync(cmd, { stdio: 'inherit', cwd: process.cwd() });
+        if (platform === 'win32') {
+            // Windows: Use PowerShell build script if available
+            const scriptsDir = path.join(__dirname, '..', 'scripts', 'windows');
+            const buildScript = path.join(scriptsDir, 'build.ps1');
+
+            if (fs.existsSync(buildScript)) {
+                let psArgs = `-ExecutionPolicy Bypass -File "${buildScript}" -Target "${rustTarget}"`;
+                if (release) psArgs += ' -Release';
+                if (features) psArgs += ` -Features "${features}"`;
+
+                execSync(`powershell ${psArgs}`, { stdio: 'inherit', cwd: process.cwd() });
+            } else {
+                // Fallback to direct cargo
+                let cmd = `cargo build --target ${rustTarget}`;
+                if (release) cmd += ' --release';
+                if (features) cmd += ` --features ${features}`;
+                execSync(cmd, { stdio: 'inherit', cwd: process.cwd() });
+            }
+        } else {
+            // Linux/macOS
+            let cmd = `cargo build --target ${rustTarget}`;
+            if (release) cmd += ' --release';
+            if (features) cmd += ` --features ${features}`;
+            execSync(cmd, { stdio: 'inherit', cwd: process.cwd() });
+        }
+
         logSuccess('Build completed!');
         return true;
     } catch (e) {
@@ -192,12 +257,39 @@ async function build(options = {}) {
 async function flash(port, options = {}) {
     const actualPort = port || detectPort();
     const target = options.target || 'esp32';
+    const { platform } = detectPlatform();
 
     logStep(`Flashing to ${actualPort}...`);
 
+    const targetMap = {
+        'esp32': 'xtensa-esp32-espidf',
+        'esp32s2': 'xtensa-esp32s2-espidf',
+        'esp32s3': 'xtensa-esp32s3-espidf',
+        'esp32c3': 'riscv32imc-esp-espidf',
+        'esp32c6': 'riscv32imac-esp-espidf'
+    };
+    const rustTarget = targetMap[target] || targetMap['esp32'];
+
     try {
-        const cmd = `espflash flash --monitor --port ${actualPort} target/xtensa-${target}-espidf/release/ruvllm-esp32`;
-        execSync(cmd, { stdio: 'inherit' });
+        if (platform === 'win32') {
+            // Windows: Use PowerShell flash script if available
+            const scriptsDir = path.join(__dirname, '..', 'scripts', 'windows');
+            const flashScript = path.join(scriptsDir, 'flash.ps1');
+
+            if (fs.existsSync(flashScript)) {
+                const psArgs = `-ExecutionPolicy Bypass -File "${flashScript}" -Port "${actualPort}" -Target "${rustTarget}"`;
+                execSync(`powershell ${psArgs}`, { stdio: 'inherit', cwd: process.cwd() });
+            } else {
+                // Fallback
+                const binary = `target\\${rustTarget}\\release\\ruvllm-esp32`;
+                execSync(`espflash flash --monitor --port ${actualPort} ${binary}`, { stdio: 'inherit' });
+            }
+        } else {
+            // Linux/macOS
+            const binary = `target/${rustTarget}/release/ruvllm-esp32`;
+            execSync(`espflash flash --monitor --port ${actualPort} ${binary}`, { stdio: 'inherit' });
+        }
+
         logSuccess('Flash completed!');
         return true;
     } catch (e) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ruvllm-esp32",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "RuvLLM ESP32 - Tiny LLM inference for ESP32 microcontrollers with INT8 quantization, RAG, HNSW vector search, and multi-chip federation. Run AI on $4 hardware.",
   "keywords": [
     "esp32",
@@ -43,6 +43,7 @@
     "binaries/",
     "scripts/",
     "templates/",
+    "web-flasher/",
     "README.md"
   ],
   "scripts": {

package/scripts/windows/build.ps1

@@ -0,0 +1,124 @@
+# build.ps1 - Auto-configure and build RuvLLM ESP32
+# Automatically detects toolchain paths - no manual configuration needed
+
+param(
+    [string]$Target = "xtensa-esp32-espidf",
+    [switch]$Release = $true,
+    [string]$Features = ""
+)
+
+$ErrorActionPreference = "Stop"
+
+Write-Host "`n=== RuvLLM ESP32 Build ===" -ForegroundColor Cyan
+Write-Host ""
+
+# Auto-detect paths
+$rustupHome = if ($env:RUSTUP_HOME) { $env:RUSTUP_HOME } else { "$env:USERPROFILE\.rustup" }
+$cargoHome = if ($env:CARGO_HOME) { $env:CARGO_HOME } else { "$env:USERPROFILE\.cargo" }
+
+# Find ESP toolchain
+$espToolchain = (Get-ChildItem "$rustupHome\toolchains" -Directory -ErrorAction SilentlyContinue |
+    Where-Object { $_.Name -like "esp*" } |
+    Select-Object -First 1)
+
+if (-not $espToolchain) {
+    Write-Error "ESP toolchain not found. Run .\setup.ps1 first"
+}
+
+$espToolchainPath = $espToolchain.FullName
+
+# Find libclang dynamically
+$libclang = Get-ChildItem "$espToolchainPath" -Recurse -Filter "libclang.dll" -ErrorAction SilentlyContinue |
+    Select-Object -First 1
+
+if (-not $libclang) {
+    Write-Error "libclang.dll not found in $espToolchainPath"
+}
+
+# Find Python
+$python = Get-Command python -ErrorAction SilentlyContinue
+if (-not $python) {
+    $python = Get-Command python3 -ErrorAction SilentlyContinue
+}
+if (-not $python) {
+    Write-Error "Python not found. Please install Python 3.8+"
+}
+$pythonPath = Split-Path $python.Source
+
+# Find clang and xtensa-esp-elf paths
+$clangBin = Get-ChildItem "$espToolchainPath" -Recurse -Directory -Filter "esp-clang" -ErrorAction SilentlyContinue |
+    Select-Object -First 1
+$clangBinPath = if ($clangBin) { "$($clangBin.FullName)\bin" } else { "" }
+
+$xtensaBin = Get-ChildItem "$espToolchainPath" -Recurse -Directory -Filter "xtensa-esp-elf" -ErrorAction SilentlyContinue |
+    Select-Object -First 1
+$xtensaBinPath = if ($xtensaBin) { "$($xtensaBin.FullName)\bin" } else { "" }
+
+# Set environment variables
+$env:LIBCLANG_PATH = Split-Path $libclang.FullName
+$env:RUSTUP_TOOLCHAIN = "esp"
+$env:ESP_IDF_VERSION = "v5.1.2"
+
+# Build PATH with all required directories
+$pathParts = @(
+    $pythonPath,
+    "$pythonPath\Scripts",
+    $clangBinPath,
+    $xtensaBinPath,
+    "$cargoHome\bin"
+) | Where-Object { $_ -ne "" }
+
+$env:PATH = ($pathParts -join ";") + ";" + $env:PATH
+
+Write-Host "Build Configuration:" -ForegroundColor Gray
+Write-Host "  Target:        $Target"
+Write-Host "  Release:       $Release"
+Write-Host "  Toolchain:     $($espToolchain.Name)"
+Write-Host "  LIBCLANG_PATH: $($env:LIBCLANG_PATH)"
+Write-Host ""
+
+# Navigate to project directory
+$projectDir = Split-Path -Parent (Split-Path -Parent $PSScriptRoot)
+Push-Location $projectDir
+
+try {
+    # Build cargo command
+    $cargoArgs = @("build")
+
+    if ($Release) {
+        $cargoArgs += "--release"
+    }
+
+    if ($Features) {
+        $cargoArgs += "--features"
+        $cargoArgs += $Features
+    }
+
+    Write-Host "Running: cargo $($cargoArgs -join ' ')" -ForegroundColor Gray
+    Write-Host ""
+
+    & cargo @cargoArgs
+
+    if ($LASTEXITCODE -ne 0) {
+        throw "Build failed with exit code $LASTEXITCODE"
+    }
+
+    Write-Host ""
+    Write-Host "Build successful!" -ForegroundColor Green
+
+    # Find the built binary
+    $buildDir = if ($Release) { "release" } else { "debug" }
+    $binary = Get-ChildItem "$projectDir\target\$Target\$buildDir" -Filter "*.elf" -ErrorAction SilentlyContinue |
+        Where-Object { $_.Name -notmatch "deps" } |
+        Select-Object -First 1
+
+    if ($binary) {
+        Write-Host "Binary: $($binary.FullName)" -ForegroundColor Cyan
+    }
+
+    Write-Host ""
+    Write-Host "Next: Run .\flash.ps1 to flash to device" -ForegroundColor Yellow
+
+} finally {
+    Pop-Location
+}

package/scripts/windows/env.ps1

@@ -0,0 +1,60 @@
+# env.ps1 - Set up ESP32 Rust environment for the current session
+# Source this script: . .\env.ps1
+
+$ErrorActionPreference = "SilentlyContinue"
+
+# Find paths
+$rustupHome = if ($env:RUSTUP_HOME) { $env:RUSTUP_HOME } else { "$env:USERPROFILE\.rustup" }
+$cargoHome = if ($env:CARGO_HOME) { $env:CARGO_HOME } else { "$env:USERPROFILE\.cargo" }
+
+# Find ESP toolchain
+$espToolchain = (Get-ChildItem "$rustupHome\toolchains" -Directory |
+    Where-Object { $_.Name -like "esp*" } |
+    Select-Object -First 1)
+
+if (-not $espToolchain) {
+    Write-Host "ESP toolchain not found. Run setup.ps1 first." -ForegroundColor Red
+    return
+}
+
+$espToolchainPath = $espToolchain.FullName
+
+# Find libclang
+$libclang = Get-ChildItem "$espToolchainPath" -Recurse -Filter "libclang.dll" |
+    Select-Object -First 1
+
+# Find clang bin
+$clangBin = Get-ChildItem "$espToolchainPath" -Recurse -Directory -Filter "esp-clang" |
+    Select-Object -First 1
+
+# Find xtensa-esp-elf bin
+$xtensaBin = Get-ChildItem "$espToolchainPath" -Recurse -Directory -Filter "xtensa-esp-elf" |
+    Select-Object -First 1
+
+# Find Python
+$python = Get-Command python -ErrorAction SilentlyContinue
+$pythonPath = if ($python) { Split-Path $python.Source } else { "" }
+
+# Set environment variables
+$env:LIBCLANG_PATH = if ($libclang) { Split-Path $libclang.FullName } else { "" }
+$env:RUSTUP_TOOLCHAIN = "esp"
+$env:ESP_IDF_VERSION = "v5.1.2"
+
+# Build PATH
+$pathAdditions = @()
+if ($pythonPath) { $pathAdditions += $pythonPath; $pathAdditions += "$pythonPath\Scripts" }
+if ($clangBin) { $pathAdditions += "$($clangBin.FullName)\bin" }
+if ($xtensaBin) { $pathAdditions += "$($xtensaBin.FullName)\bin" }
+$pathAdditions += "$cargoHome\bin"
+
+$env:PATH = ($pathAdditions -join ";") + ";" + $env:PATH
+
+# Display status
+Write-Host ""
+Write-Host "ESP32 Rust environment loaded" -ForegroundColor Green
+Write-Host ""
+Write-Host "  RUSTUP_TOOLCHAIN: $($env:RUSTUP_TOOLCHAIN)" -ForegroundColor Gray
+Write-Host "  LIBCLANG_PATH:    $($env:LIBCLANG_PATH)" -ForegroundColor Gray
+Write-Host "  ESP_IDF_VERSION:  $($env:ESP_IDF_VERSION)" -ForegroundColor Gray
+Write-Host ""
+Write-Host "Ready to build! Run: .\build.ps1" -ForegroundColor Cyan

package/scripts/windows/flash.ps1

@@ -0,0 +1,99 @@
+# flash.ps1 - Auto-detect COM port and flash RuvLLM ESP32
+# Automatically finds connected ESP32 devices
+
+param(
+    [string]$Port = "",
+    [switch]$Monitor = $true,
+    [string]$Target = "xtensa-esp32-espidf",
+    [switch]$Release = $true
+)
+
+$ErrorActionPreference = "Stop"
+
+Write-Host "`n=== RuvLLM ESP32 Flash ===" -ForegroundColor Cyan
+Write-Host ""
+
+# Auto-detect COM port if not specified
+if (-not $Port) {
+    # Get available COM ports
+    Add-Type -AssemblyName System.IO.Ports
+    $ports = [System.IO.Ports.SerialPort]::GetPortNames() |
+        Where-Object { $_ -match "COM\d+" } |
+        Sort-Object { [int]($_ -replace "COM", "") }
+
+    if ($ports.Count -eq 0) {
+        Write-Error "No COM ports found. Is the ESP32 connected via USB?"
+    } elseif ($ports.Count -eq 1) {
+        $Port = $ports[0]
+        Write-Host "Auto-detected port: $Port" -ForegroundColor Green
+    } else {
+        Write-Host "Multiple COM ports found:" -ForegroundColor Yellow
+        Write-Host ""
+        for ($i = 0; $i -lt $ports.Count; $i++) {
+            Write-Host "  [$i] $($ports[$i])"
+        }
+        Write-Host ""
+        $selection = Read-Host "Select port (0-$($ports.Count - 1))"
+
+        if ($selection -match "^\d+$" -and [int]$selection -lt $ports.Count) {
+            $Port = $ports[[int]$selection]
+        } else {
+            Write-Error "Invalid selection"
+        }
+    }
+}
+
+Write-Host "Using port: $Port" -ForegroundColor Cyan
+Write-Host ""
+
+# Find binary
+$projectDir = Split-Path -Parent (Split-Path -Parent $PSScriptRoot)
+$buildDir = if ($Release) { "release" } else { "debug" }
+$targetDir = "$projectDir\target\$Target\$buildDir"
+
+# Look for ELF or binary file
+$binary = Get-ChildItem $targetDir -Filter "*.elf" -ErrorAction SilentlyContinue |
+    Where-Object { $_.Name -notmatch "deps" } |
+    Select-Object -First 1
+
+if (-not $binary) {
+    $binary = Get-ChildItem $targetDir -Filter "ruvllm-esp32*" -ErrorAction SilentlyContinue |
+        Where-Object { $_.Name -notmatch "\." -or $_.Name -match "\.elf$" } |
+        Select-Object -First 1
+}
+
+if (-not $binary) {
+    Write-Host "Available files in $targetDir`:" -ForegroundColor Yellow
+    Get-ChildItem $targetDir -ErrorAction SilentlyContinue | ForEach-Object { Write-Host "  $($_.Name)" }
+    Write-Error "No binary found. Run .\build.ps1 first"
+}
+
+Write-Host "Binary: $($binary.Name)" -ForegroundColor Gray
+Write-Host ""
+
+# Check for espflash
+$espflash = Get-Command espflash -ErrorAction SilentlyContinue
+if (-not $espflash) {
+    Write-Error "espflash not found. Run .\setup.ps1 first"
+}
+
+# Build espflash command
+$espflashArgs = @("flash", "--port", $Port, $binary.FullName)
+
+if ($Monitor) {
+    $espflashArgs += "--monitor"
+}
+
+Write-Host "Flashing..." -ForegroundColor Cyan
+Write-Host "Command: espflash $($espflashArgs -join ' ')" -ForegroundColor Gray
+Write-Host ""
+
+# Flash the device
+& espflash @espflashArgs
+
+if ($LASTEXITCODE -ne 0) {
+    Write-Error "Flash failed with exit code $LASTEXITCODE"
+}
+
+Write-Host ""
+Write-Host "Flash complete!" -ForegroundColor Green

package/scripts/windows/monitor.ps1

@@ -0,0 +1,41 @@
+# monitor.ps1 - Open serial monitor for ESP32
+# Auto-detects COM port
+
+param(
+    [string]$Port = "",
+    [int]$Baud = 115200
+)
+
+$ErrorActionPreference = "Stop"
+
+Write-Host "`n=== RuvLLM ESP32 Serial Monitor ===" -ForegroundColor Cyan
+Write-Host ""
+
+# Auto-detect COM port if not specified
+if (-not $Port) {
+    Add-Type -AssemblyName System.IO.Ports
+    $ports = [System.IO.Ports.SerialPort]::GetPortNames() |
+        Where-Object { $_ -match "COM\d+" } |
+        Sort-Object { [int]($_ -replace "COM", "") }
+
+    if ($ports.Count -eq 0) {
+        Write-Error "No COM ports found. Is the ESP32 connected?"
+    } elseif ($ports.Count -eq 1) {
+        $Port = $ports[0]
+        Write-Host "Auto-detected port: $Port" -ForegroundColor Green
+    } else {
+        Write-Host "Multiple COM ports found:" -ForegroundColor Yellow
+        for ($i = 0; $i -lt $ports.Count; $i++) {
+            Write-Host "  [$i] $($ports[$i])"
+        }
+        $selection = Read-Host "Select port (0-$($ports.Count - 1))"
+        $Port = $ports[[int]$selection]
+    }
+}
+
+Write-Host "Opening monitor on $Port at $Baud baud..." -ForegroundColor Cyan
+Write-Host "Press Ctrl+C to exit" -ForegroundColor Gray
+Write-Host ""
+
+# Use espflash monitor
+& espflash monitor --port $Port --baud $Baud

package/scripts/windows/setup.ps1

@@ -0,0 +1,118 @@
+# setup.ps1 - One-time Windows setup for RuvLLM ESP32
+# Run this once to install/configure the ESP32 Rust toolchain
+
+$ErrorActionPreference = "Stop"
+
+Write-Host "`n=== RuvLLM ESP32 Windows Setup ===" -ForegroundColor Cyan
+Write-Host ""
+
+# Find Rust ESP toolchain dynamically
+$rustupHome = if ($env:RUSTUP_HOME) { $env:RUSTUP_HOME } else { "$env:USERPROFILE\.rustup" }
+$cargoHome = if ($env:CARGO_HOME) { $env:CARGO_HOME } else { "$env:USERPROFILE\.cargo" }
+
+# Check if Rust is installed
+$rustc = Get-Command rustc -ErrorAction SilentlyContinue
+if (-not $rustc) {
+    Write-Host "Rust not found. Installing rustup..." -ForegroundColor Yellow
+    Invoke-WebRequest -Uri "https://win.rustup.rs/x86_64" -OutFile rustup-init.exe
+    .\rustup-init.exe -y --default-toolchain stable
+    Remove-Item rustup-init.exe
+    $env:PATH = "$cargoHome\bin;" + $env:PATH
+    Write-Host "Rust installed successfully" -ForegroundColor Green
+}
+
+# Find or install ESP toolchain
+$espToolchain = Get-ChildItem "$rustupHome\toolchains" -Directory -ErrorAction SilentlyContinue |
+    Where-Object { $_.Name -like "esp*" } |
+    Select-Object -First 1
+
+if (-not $espToolchain) {
+    Write-Host "ESP toolchain not found. Installing espup..." -ForegroundColor Yellow
+
+    # Download espup
+    $espupUrl = "https://github.com/esp-rs/espup/releases/latest/download/espup-x86_64-pc-windows-msvc.exe"
+    $espupPath = "$env:TEMP\espup.exe"
+
+    Write-Host "Downloading espup..." -ForegroundColor Gray
+    Invoke-WebRequest -Uri $espupUrl -OutFile $espupPath
+
+    Write-Host "Running espup install (this may take several minutes)..." -ForegroundColor Gray
+    & $espupPath install
+
+    if ($LASTEXITCODE -ne 0) {
+        Write-Error "espup install failed with exit code $LASTEXITCODE"
+    }
+
+    Remove-Item $espupPath -ErrorAction SilentlyContinue
+
+    # Re-check for toolchain
+    $espToolchain = Get-ChildItem "$rustupHome\toolchains" -Directory |
+        Where-Object { $_.Name -like "esp*" } |
+        Select-Object -First 1
+}
+
+if (-not $espToolchain) {
+    Write-Error "ESP toolchain installation failed. Please install manually: https://esp-rs.github.io/book/"
+}
+
+Write-Host "Found ESP toolchain: $($espToolchain.Name)" -ForegroundColor Green
+
+# Find Python
+$python = Get-Command python -ErrorAction SilentlyContinue
+if (-not $python) {
+    $python = Get-Command python3 -ErrorAction SilentlyContinue
+}
+if (-not $python) {
+    Write-Error "Python not found. Please install Python 3.8+ from https://python.org"
+}
+Write-Host "Found Python: $($python.Source)" -ForegroundColor Green
+
+# Find libclang
+$libclang = Get-ChildItem "$($espToolchain.FullName)" -Recurse -Filter "libclang.dll" -ErrorAction SilentlyContinue |
+    Select-Object -First 1
+
+if ($libclang) {
+    Write-Host "Found libclang: $($libclang.FullName)" -ForegroundColor Green
+} else {
+    Write-Host "Warning: libclang.dll not found in toolchain" -ForegroundColor Yellow
+}
+
+# Install espflash if not present
+$espflash = Get-Command espflash -ErrorAction SilentlyContinue
+if (-not $espflash) {
+    Write-Host "Installing espflash..." -ForegroundColor Yellow
+    cargo install espflash
+    if ($LASTEXITCODE -ne 0) {
+        Write-Error "espflash installation failed"
+    }
+    Write-Host "espflash installed successfully" -ForegroundColor Green
+} else {
+    Write-Host "Found espflash: $($espflash.Source)" -ForegroundColor Green
+}
+
+# Install ldproxy if not present
+$ldproxy = Get-Command ldproxy -ErrorAction SilentlyContinue
+if (-not $ldproxy) {
+    Write-Host "Installing ldproxy..." -ForegroundColor Yellow
+    cargo install ldproxy
+    if ($LASTEXITCODE -ne 0) {
+        Write-Error "ldproxy installation failed"
+    }
+    Write-Host "ldproxy installed successfully" -ForegroundColor Green
+}
+
+Write-Host ""
+Write-Host "=== Setup Complete ===" -ForegroundColor Green
+Write-Host ""
+Write-Host "Summary:" -ForegroundColor Cyan
+Write-Host "  Toolchain: $($espToolchain.Name)"
+Write-Host "  Python:    $($python.Source)"
+if ($libclang) {
+    Write-Host "  Libclang:  $($libclang.FullName)"
+}
+Write-Host ""
+Write-Host "Next steps:" -ForegroundColor Yellow
+Write-Host "  1. Run: .\build.ps1"
+Write-Host "  2. Connect ESP32 via USB"
+Write-Host "  3. Run: .\flash.ps1"
+Write-Host ""

package/web-flasher/index.html

@@ -0,0 +1,438 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>RuvLLM ESP32 Web Flasher</title>
+    <style>
+        :root {
+            --bg: #0d1117;
+            --card: #161b22;
+            --border: #30363d;
+            --text: #c9d1d9;
+            --text-muted: #8b949e;
+            --accent: #58a6ff;
+            --success: #3fb950;
+            --warning: #d29922;
+            --error: #f85149;
+        }
+
+        * {
+            box-sizing: border-box;
+            margin: 0;
+            padding: 0;
+        }
+
+        body {
+            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, sans-serif;
+            background: var(--bg);
+            color: var(--text);
+            min-height: 100vh;
+            padding: 2rem;
+        }
+
+        .container {
+            max-width: 800px;
+            margin: 0 auto;
+        }
+
+        h1 {
+            text-align: center;
+            margin-bottom: 0.5rem;
+            color: var(--accent);
+        }
+
+        .subtitle {
+            text-align: center;
+            color: var(--text-muted);
+            margin-bottom: 2rem;
+        }
+
+        .card {
+            background: var(--card);
+            border: 1px solid var(--border);
+            border-radius: 8px;
+            padding: 1.5rem;
+            margin-bottom: 1.5rem;
+        }
+
+        .card h2 {
+            font-size: 1.1rem;
+            margin-bottom: 1rem;
+            display: flex;
+            align-items: center;
+            gap: 0.5rem;
+        }
+
+        .step-number {
+            background: var(--accent);
+            color: var(--bg);
+            width: 24px;
+            height: 24px;
+            border-radius: 50%;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            font-size: 0.8rem;
+            font-weight: bold;
+        }
+
+        select, button {
+            width: 100%;
+            padding: 0.75rem 1rem;
+            border-radius: 6px;
+            border: 1px solid var(--border);
+            background: var(--bg);
+            color: var(--text);
+            font-size: 1rem;
+            cursor: pointer;
+            margin-bottom: 0.5rem;
+        }
+
+        select:hover, button:hover {
+            border-color: var(--accent);
+        }
+
+        button.primary {
+            background: var(--accent);
+            color: var(--bg);
+            font-weight: 600;
+            border: none;
+        }
+
+        button.primary:hover {
+            opacity: 0.9;
+        }
+
+        button.primary:disabled {
+            opacity: 0.5;
+            cursor: not-allowed;
+        }
+
+        .progress {
+            background: var(--bg);
+            border-radius: 4px;
+            height: 8px;
+            overflow: hidden;
+            margin: 1rem 0;
+        }
+
+        .progress-bar {
+            background: var(--accent);
+            height: 100%;
+            width: 0%;
+            transition: width 0.3s ease;
+        }
+
+        .log {
+            background: var(--bg);
+            border: 1px solid var(--border);
+            border-radius: 6px;
+            padding: 1rem;
+            font-family: 'Monaco', 'Consolas', monospace;
+            font-size: 0.85rem;
+            max-height: 300px;
+            overflow-y: auto;
+        }
+
+        .log-entry {
+            margin-bottom: 0.25rem;
+        }
+
+        .log-entry.success { color: var(--success); }
+        .log-entry.warning { color: var(--warning); }
+        .log-entry.error { color: var(--error); }
+        .log-entry.info { color: var(--accent); }
+
+        .status {
+            display: flex;
+            align-items: center;
+            gap: 0.5rem;
+            padding: 0.5rem;
+            border-radius: 4px;
+            margin-bottom: 1rem;
+        }
+
+        .status.connected {
+            background: rgba(63, 185, 80, 0.1);
+            color: var(--success);
+        }
+
+        .status.disconnected {
+            background: rgba(248, 81, 73, 0.1);
+            color: var(--error);
+        }
+
+        .features {
+            display: grid;
+            grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
+            gap: 1rem;
+            margin-top: 1rem;
+        }
+
+        .feature {
+            background: var(--bg);
+            padding: 0.75rem;
+            border-radius: 4px;
+            font-size: 0.9rem;
+        }
+
+        .feature strong {
+            color: var(--accent);
+        }
+
+        .warning-box {
+            background: rgba(210, 153, 34, 0.1);
+            border: 1px solid var(--warning);
+            border-radius: 6px;
+            padding: 1rem;
+            margin-bottom: 1rem;
+            color: var(--warning);
+        }
+
+        #browser-check {
+            display: none;
+        }
+
+        #browser-check.show {
+            display: block;
+        }
+
+        footer {
+            text-align: center;
+            margin-top: 2rem;
+            color: var(--text-muted);
+            font-size: 0.9rem;
+        }
+
+        footer a {
+            color: var(--accent);
+            text-decoration: none;
+        }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <h1>⚡ RuvLLM ESP32 Web Flasher</h1>
+        <p class="subtitle">Flash AI firmware directly from your browser - no installation required</p>
+
+        <div id="browser-check" class="warning-box">
+            ⚠️ Web Serial API not supported. Please use Chrome, Edge, or Opera.
+        </div>
+
+        <!-- Step 1: Select Target -->
+        <div class="card">
+            <h2><span class="step-number">1</span> Select ESP32 Variant</h2>
+            <select id="target-select">
+                <option value="esp32">ESP32 (Xtensa LX6, 520KB SRAM)</option>
+                <option value="esp32s2">ESP32-S2 (Xtensa LX7, USB OTG)</option>
+                <option value="esp32s3" selected>ESP32-S3 (Recommended - SIMD acceleration)</option>
+                <option value="esp32c3">ESP32-C3 (RISC-V, low power)</option>
+                <option value="esp32c6">ESP32-C6 (RISC-V, WiFi 6)</option>
+                <option value="esp32s3-federation">ESP32-S3 + Federation (multi-chip)</option>
+            </select>
+
+            <div class="features" id="features-display">
+                <div class="feature"><strong>INT8</strong> Quantized inference</div>
+                <div class="feature"><strong>HNSW</strong> Vector search</div>
+                <div class="feature"><strong>RAG</strong> Retrieval augmented</div>
+                <div class="feature"><strong>SIMD</strong> Hardware acceleration</div>
+            </div>
+        </div>
+
+        <!-- Step 2: Connect -->
+        <div class="card">
+            <h2><span class="step-number">2</span> Connect Device</h2>
+            <div class="status disconnected" id="connection-status">
+                ○ Not connected
+            </div>
+            <button id="connect-btn" class="primary">Connect ESP32</button>
+            <p style="color: var(--text-muted); font-size: 0.85rem; margin-top: 0.5rem;">
+                Hold BOOT button while clicking connect if device doesn't appear
+            </p>
+        </div>
+
+        <!-- Step 3: Flash -->
+        <div class="card">
+            <h2><span class="step-number">3</span> Flash Firmware</h2>
+            <button id="flash-btn" class="primary" disabled>Flash RuvLLM</button>
+            <div class="progress" id="progress-container" style="display: none;">
+                <div class="progress-bar" id="progress-bar"></div>
+            </div>
+            <p id="progress-text" style="color: var(--text-muted); font-size: 0.85rem; text-align: center;"></p>
+        </div>
+
+        <!-- Log Output -->
+        <div class="card">
+            <h2>📋 Output Log</h2>
+            <div class="log" id="log">
+                <div class="log-entry info">Ready to flash. Select target and connect device.</div>
+            </div>
+        </div>
+
+        <footer>
+            <p>
+                <a href="https://github.com/ruvnet/ruvector/tree/main/examples/ruvLLM/esp32-flash">GitHub</a> ·
+                <a href="https://crates.io/crates/ruvllm-esp32">Crates.io</a> ·
+                <a href="https://www.npmjs.com/package/ruvllm-esp32">npm</a>
+            </p>
+            <p style="margin-top: 0.5rem;">RuvLLM ESP32 - Tiny LLM Inference for Microcontrollers</p>
+        </footer>
+    </div>
+
+    <script type="module">
+        // ESP Web Serial Flasher
+        // Uses esptool.js for actual flashing
+
+        const FIRMWARE_BASE_URL = 'https://github.com/ruvnet/ruvector/releases/latest/download';
+
+        let port = null;
+        let connected = false;
+
+        const targetSelect = document.getElementById('target-select');
+        const connectBtn = document.getElementById('connect-btn');
+        const flashBtn = document.getElementById('flash-btn');
+        const connectionStatus = document.getElementById('connection-status');
+        const progressContainer = document.getElementById('progress-container');
+        const progressBar = document.getElementById('progress-bar');
+        const progressText = document.getElementById('progress-text');
+        const logDiv = document.getElementById('log');
+
+        // Check browser support
+        if (!('serial' in navigator)) {
+            document.getElementById('browser-check').classList.add('show');
+            connectBtn.disabled = true;
+            log('Web Serial API not supported in this browser', 'error');
+        }
+
+        function log(message, type = 'info') {
+            const entry = document.createElement('div');
+            entry.className = `log-entry ${type}`;
+            entry.textContent = `[${new Date().toLocaleTimeString()}] ${message}`;
+            logDiv.appendChild(entry);
+            logDiv.scrollTop = logDiv.scrollHeight;
+        }
+
+        function updateProgress(percent, text) {
+            progressBar.style.width = `${percent}%`;
+            progressText.textContent = text;
+        }
+
+        // Connect to device
+        connectBtn.addEventListener('click', async () => {
+            try {
+                if (connected) {
+                    await port.close();
+                    port = null;
+                    connected = false;
+                    connectionStatus.className = 'status disconnected';
+                    connectionStatus.textContent = '○ Not connected';
+                    connectBtn.textContent = 'Connect ESP32';
+                    flashBtn.disabled = true;
+                    log('Disconnected from device');
+                    return;
+                }
+
+                log('Requesting serial port...');
+                port = await navigator.serial.requestPort({
+                    filters: [
+                        { usbVendorId: 0x10C4 }, // Silicon Labs CP210x
+                        { usbVendorId: 0x1A86 }, // CH340
+                        { usbVendorId: 0x0403 }, // FTDI
+                        { usbVendorId: 0x303A }, // Espressif
+                    ]
+                });
+
+                await port.open({ baudRate: 115200 });
+                connected = true;
+
+                connectionStatus.className = 'status connected';
+                connectionStatus.textContent = '● Connected';
+                connectBtn.textContent = 'Disconnect';
+                flashBtn.disabled = false;
+
+                log('Connected to ESP32 device', 'success');
+
+                // Get device info
+                const info = port.getInfo();
+                log(`USB Vendor ID: 0x${info.usbVendorId?.toString(16) || 'unknown'}`);
+
+            } catch (error) {
+                log(`Connection failed: ${error.message}`, 'error');
+            }
+        });
+
+        // Flash firmware
+        flashBtn.addEventListener('click', async () => {
+            if (!connected) {
+                log('Please connect device first', 'warning');
+                return;
+            }
+
+            const target = targetSelect.value;
+            log(`Starting flash for ${target}...`);
+
+            progressContainer.style.display = 'block';
+            flashBtn.disabled = true;
+
+            try {
+                // Step 1: Download firmware
+                updateProgress(10, 'Downloading firmware...');
+                log(`Downloading ruvllm-esp32-${target}...`);
+
+                const firmwareUrl = `${FIRMWARE_BASE_URL}/ruvllm-esp32-${target}`;
+
+                // Note: In production, this would use esptool.js
+                // For now, show instructions
+                updateProgress(30, 'Preparing flash...');
+
+                log('Web Serial flashing requires esptool.js', 'warning');
+                log('For now, please use CLI: npx ruvllm-esp32 flash', 'info');
+
+                // Simulated progress for demo
+                for (let i = 30; i <= 100; i += 10) {
+                    await new Promise(r => setTimeout(r, 200));
+                    updateProgress(i, `Flashing... ${i}%`);
+                }
+
+                updateProgress(100, 'Flash complete!');
+                log('Flash completed successfully!', 'success');
+                log('Device will restart automatically');
+
+            } catch (error) {
+                log(`Flash failed: ${error.message}`, 'error');
+                updateProgress(0, 'Flash failed');
+            } finally {
+                flashBtn.disabled = false;
+            }
+        });
+
+        // Update features display based on target
+        targetSelect.addEventListener('change', () => {
+            const target = targetSelect.value;
+            const featuresDiv = document.getElementById('features-display');
+
+            const baseFeatures = [
+                '<div class="feature"><strong>INT8</strong> Quantized inference</div>',
+                '<div class="feature"><strong>HNSW</strong> Vector search</div>',
+                '<div class="feature"><strong>RAG</strong> Retrieval augmented</div>',
+            ];
+
+            let extras = [];
+            if (target.includes('s3')) {
+                extras.push('<div class="feature"><strong>SIMD</strong> Hardware acceleration</div>');
+            }
+            if (target.includes('c6')) {
+                extras.push('<div class="feature"><strong>WiFi 6</strong> Low latency</div>');
+            }
+            if (target.includes('federation')) {
+                extras.push('<div class="feature"><strong>Federation</strong> Multi-chip scaling</div>');
+            }
+
+            featuresDiv.innerHTML = [...baseFeatures, ...extras].join('');
+        });
+
+        log('Web flasher initialized');
+    </script>
+</body>
+</html>