@phystack/cli 4.4.29

package/dist/commands/flash.js

@@ -0,0 +1,1120 @@
+"use strict";
+/**
+ * # PhyOS Flash Tool
+ *
+ * This command allows users to easily flash PhyOS images to USB drives or SD cards.
+ * It works similarly to tools like Balena Etcher but via CLI.
+ *
+ * ## Features:
+ * - Downloads images from https://os.phygrid.com/ if not found in cache
+ * - Uses the same cache directory as VM commands (~/.config/phygrid-cli/cache/)
+ * - Detects removable drives on both macOS and Linux
+ * - Supports compressed images (gzip, xz)
+ * - Safety checks to avoid accidental flashing of system disks
+ * - Optional raw mode for advanced users who need to see all disks
+ *
+ * ## Usage:
+ * ```
+ * phy flash phyos.5.0.127.img.gz  # Flash a gzipped image
+ * phy flash phyos.5.0.127.img.xz  # Flash an xz compressed image
+ * phy flash phyos.5.0.127.img     # Flash an uncompressed image
+ * phy flash phyos-latest.img.gz --raw  # Show all disks including system disks
+ * ```
+ *
+ * ## Workflow:
+ * 1. Checks if the image exists in cache, downloads if needed
+ * 2. Lists available removable drives
+ * 3. Prompts user to select a drive
+ * 4. Confirms before flashing (requires typing 'yes')
+ * 5. Flashes the image with appropriate compression handling
+ * 6. Shows progress during flashing
+ *
+ * ## Supported Platforms:
+ * - macOS: Uses diskutil to list and manage drives
+ * - Linux: Uses lsblk to list drives and dd for flashing
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.flashImageToDevice = flashImageToDevice;
+const commander_1 = require("commander");
+const chalk_1 = __importDefault(require("chalk"));
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const child_process_1 = require("child_process");
+const vm_1 = require("../utils/vm");
+const utils_1 = require("../utils");
+// Main flash command function
+async function flashImage(filename, options = {}) {
+    try {
+        // Import inquirer dynamically since it's a heavy dependency
+        const inquirer = (await Promise.resolve().then(() => __importStar(require('inquirer')))).default;
+        // Determine cache path
+        const cacheDir = (0, vm_1.getVmsCacheDir)();
+        // Ensure cache directory exists
+        if (!fs_1.default.existsSync(cacheDir)) {
+            fs_1.default.mkdirSync(cacheDir, { recursive: true });
+        }
+        // If no filename provided, prompt user to select architecture
+        if (!filename) {
+            console.log(chalk_1.default.blue("No image specified. Please select device architecture:"));
+            const { architecture } = await inquirer.prompt([
+                {
+                    type: 'list',
+                    name: 'architecture',
+                    message: 'Select the architecture for your target device:',
+                    choices: [
+                        { name: 'Intel based systems (AMD64)', value: 'amd64' },
+                        { name: 'Giada DN74 (ARM64)', value: 'arm64' }
+                    ]
+                }
+            ]);
+            // Get the URL for the selected architecture
+            const url = architecture === 'amd64'
+                ? 'https://qr.run/phyos-bundle-amd64-latest'
+                : 'https://qr.run/phyos-bundle-arm64-latest';
+            console.log(chalk_1.default.blue(`Resolving ${architecture} image from ${url}...`));
+            // Get the actual filename from the redirect
+            filename = await resolveRedirectFilename(url);
+            console.log(chalk_1.default.blue(`Selected ${architecture} image: ${filename}`));
+        }
+        // Generate path for the cached file
+        const cachePath = path_1.default.join(cacheDir, filename);
+        // Check if file exists in cache or download it
+        if (!fs_1.default.existsSync(cachePath)) {
+            console.log(chalk_1.default.blue(`Image ${filename} not found in cache. Downloading...`));
+            // If it's one of our shortlink URLs, use the resolved URL
+            if (filename.startsWith('phyos-bundle-')) {
+                const url = filename.includes('amd64')
+                    ? 'https://qr.run/phyos-bundle-amd64-latest'
+                    : 'https://qr.run/phyos-bundle-arm64-latest';
+                await downloadImageFromUrl(url, cachePath);
+            }
+            else {
+                // Normal download from phygrid.com
+                await downloadImage(filename, cachePath);
+            }
+        }
+        else {
+            console.log(chalk_1.default.green(`Found cached image: ${filename}`));
+        }
+        // Verify file exists
+        if (!fs_1.default.existsSync(cachePath)) {
+            throw new Error(`Failed to download or find image: ${filename}`);
+        }
+        // Determine if this is a compressed file
+        const isGzipped = filename.endsWith('.gz');
+        const isXz = filename.endsWith('.xz');
+        // Inform about raw disk option if set
+        if (options.raw) {
+            console.log(chalk_1.default.yellow('Raw disk mode enabled. Use this only if you know what you are doing.'));
+            console.log(chalk_1.default.yellow('This mode will show all disks, including system disks that should NOT be flashed.'));
+        }
+        // Check for required tools and install if needed
+        console.log(chalk_1.default.blue('Checking required tools...'));
+        const toolsAvailable = await checkAndInstallRequiredTools();
+        if (!toolsAvailable) {
+            throw new Error('Required tools are missing. Please install them as instructed above.');
+        }
+        // Process for selecting and flashing drive
+        let selectedDrive = null;
+        let selectedDriveName = null;
+        let exitLoop = false;
+        while (!exitLoop) {
+            // Get list of removable drives
+            const drives = await listRemovableDrives(options.raw);
+            if (drives.length === 0) {
+                console.log(chalk_1.default.yellow('No removable drives detected.'));
+                const { retry } = await inquirer.prompt([
+                    {
+                        type: 'confirm',
+                        name: 'retry',
+                        message: 'Would you like to scan for drives again?',
+                        default: true
+                    }
+                ]);
+                if (!retry) {
+                    exitLoop = true;
+                    throw new Error('No drives available for flashing. Operation cancelled.');
+                }
+                continue;
+            }
+            // Add an option to rescan in the choices
+            const choices = [
+                {
+                    name: 'Rescan for drives',
+                    value: 'rescan'
+                },
+                ...drives.map(drive => ({
+                    name: drive.displayName,
+                    value: drive
+                })),
+                {
+                    name: 'Cancel operation',
+                    value: 'cancel'
+                }
+            ];
+            // Prompt user to select a drive
+            const { drive } = await inquirer.prompt([
+                {
+                    type: 'list',
+                    name: 'drive',
+                    message: 'Select a drive to flash:',
+                    choices
+                }
+            ]);
+            if (drive === 'rescan') {
+                console.log(chalk_1.default.blue('Rescanning for drives...'));
+                continue;
+            }
+            if (drive === 'cancel') {
+                exitLoop = true;
+                throw new Error('Operation cancelled by user.');
+            }
+            // Final confirmation before flashing
+            const { confirmation } = await inquirer.prompt([
+                {
+                    type: 'input',
+                    name: 'confirmation',
+                    message: chalk_1.default.red(`WARNING: This will erase ALL data on ${drive.displayName}. Type 'yes' to confirm:`),
+                    validate: (input) => {
+                        if (input.toLowerCase() === 'yes')
+                            return true;
+                        return 'You must type \'yes\' to confirm';
+                    }
+                }
+            ]);
+            if (confirmation.toLowerCase() === 'yes') {
+                selectedDrive = drive.path;
+                selectedDriveName = drive.displayName;
+                exitLoop = true;
+            }
+        }
+        if (!selectedDrive) {
+            throw new Error('No drive selected for flashing. Operation cancelled.');
+        }
+        // Ask if verification is desired
+        const { verify } = await inquirer.prompt([
+            {
+                type: 'confirm',
+                name: 'verify',
+                message: 'Would you like to verify the flashed image after writing? (recommended but takes longer)',
+                default: true
+            }
+        ]);
+        // Special handling for macOS - unmount disk before flashing
+        const platform = os_1.default.platform();
+        if (platform === 'darwin' && selectedDrive) {
+            try {
+                // Extract disk identifier (e.g., disk2 from /dev/disk2)
+                const diskName = path_1.default.basename(selectedDrive);
+                console.log(chalk_1.default.blue(`Unmounting disk ${diskName}...`));
+                (0, child_process_1.execSync)(`diskutil unmountDisk ${diskName}`, { stdio: 'inherit' });
+            }
+            catch (error) {
+                console.warn(chalk_1.default.yellow(`Warning: Failed to unmount disk: ${error.message}`));
+                console.warn(chalk_1.default.yellow(`Continuing anyway, but flashing may fail if the disk is mounted.`));
+            }
+        }
+        // Start flashing
+        console.log(chalk_1.default.blue(`\nPreparing to flash ${filename} to ${selectedDriveName} (${selectedDrive})...`));
+        console.log(chalk_1.default.yellow('This may take several minutes. Do not disconnect the drive.'));
+        // Flash image to device with new method - pass cache directory
+        await flashImageToDevice(cachePath, selectedDrive, isGzipped, isXz, verify, cacheDir);
+        console.log(chalk_1.default.green('\n✓ Operation completed successfully!'));
+        console.log(chalk_1.default.blue('It is now safe to eject the drive.'));
+    }
+    catch (error) {
+        console.error(chalk_1.default.red(`\n❗️Error: ${error.message}`));
+        throw error;
+    }
+}
+/**
+ * Download the image file from the server
+ */
+async function downloadImage(filename, outputPath) {
+    return new Promise((resolve, reject) => {
+        // Use omborigrid.com for griddevice files, phygrid.com for others
+        const baseUrl = filename.startsWith('griddevice')
+            ? 'https://os.omborigrid.com'
+            : 'https://os.phygrid.com';
+        const url = `${baseUrl}/${filename}`;
+        console.log(chalk_1.default.blue(`Downloading from ${url}...`));
+        // Use curl for download with progress bar
+        const curl = (0, child_process_1.spawn)('curl', [
+            '--progress-bar', // Show progress bar
+            '-L', // Follow redirects
+            '-o', outputPath, // Output file
+            url // URL to download
+        ], {
+            stdio: ['ignore', 'inherit', 'inherit'] // Show progress in terminal
+        });
+        curl.on('close', (code) => {
+            if (code === 0) {
+                resolve();
+            }
+            else {
+                reject(new Error(`Download failed with code ${code}`));
+            }
+        });
+        curl.on('error', (err) => {
+            reject(new Error(`Failed to execute curl: ${err.message}`));
+        });
+    });
+}
+/**
+ * Download an image file from a complete URL
+ */
+async function downloadImageFromUrl(url, outputPath) {
+    return new Promise((resolve, reject) => {
+        console.log(chalk_1.default.blue(`Downloading from ${url}...`));
+        // Use curl for download with progress bar
+        const curl = (0, child_process_1.spawn)('curl', [
+            '--progress-bar', // Show progress bar
+            '-L', // Follow redirects
+            '-o', outputPath, // Output file
+            url // URL to download
+        ], {
+            stdio: ['ignore', 'inherit', 'inherit'] // Show progress in terminal
+        });
+        curl.on('close', (code) => {
+            if (code === 0) {
+                resolve();
+            }
+            else {
+                reject(new Error(`Download failed with code ${code}`));
+            }
+        });
+        curl.on('error', (err) => {
+            reject(new Error(`Failed to execute curl: ${err.message}`));
+        });
+    });
+}
+/**
+ * Resolve a redirect URL to get the actual filename
+ */
+async function resolveRedirectFilename(url) {
+    return new Promise((resolve, reject) => {
+        // Use curl to follow redirects and get the final URL
+        const curl = (0, child_process_1.spawn)('curl', [
+            '-s', // Silent mode
+            '-I', // Headers only
+            '-L', // Follow redirects
+            url // URL to check
+        ]);
+        let output = '';
+        curl.stdout.on('data', (data) => {
+            output += data.toString();
+        });
+        curl.on('close', (code) => {
+            if (code === 0) {
+                // Extract the filename from the Location header
+                const locationMatch = output.match(/location: (.+?)[\r\n]/i);
+                if (locationMatch && locationMatch[1]) {
+                    const finalUrl = locationMatch[1].trim();
+                    const filename = path_1.default.basename(finalUrl);
+                    resolve(filename);
+                }
+                else {
+                    reject(new Error('Could not resolve redirect URL'));
+                }
+            }
+            else {
+                reject(new Error(`Failed to follow redirect with code ${code}`));
+            }
+        });
+        curl.on('error', (err) => {
+            reject(new Error(`Failed to execute curl: ${err.message}`));
+        });
+    });
+}
+/**
+ * List removable drives on the system
+ */
+async function listRemovableDrives(showAllDisks = false) {
+    const platform = os_1.default.platform();
+    if (platform === 'darwin') {
+        // macOS - use diskutil
+        try {
+            // Get internal and external disks based on option
+            const diskutilCmd = showAllDisks ? 'diskutil list' : 'diskutil list external';
+            const output = (0, child_process_1.execSync)(diskutilCmd, { encoding: 'utf8' });
+            // Find physical disk devices (not partitions)
+            const diskRegex = /\/dev\/(disk\d+)\s+\((external|internal),\s+physical\):/g;
+            let match;
+            const drives = [];
+            while ((match = diskRegex.exec(output)) !== null) {
+                const diskId = match[1]; // e.g., "disk4"
+                const diskType = match[2]; // "external" or "internal"
+                // Skip internal disks unless in raw mode
+                if (!showAllDisks && diskType === 'internal') {
+                    console.log(chalk_1.default.yellow(`Skipping internal disk: /dev/${diskId}`));
+                    continue;
+                }
+                // For system protection, skip the boot disk unless in raw mode
+                if (!showAllDisks) {
+                    try {
+                        const bootDisk = (0, child_process_1.execSync)('diskutil info /', { encoding: 'utf8' });
+                        const bootDiskMatch = bootDisk.match(/Device Identifier:\s+([^\s]+)/);
+                        if (bootDiskMatch && bootDiskMatch[1] === diskId) {
+                            console.log(chalk_1.default.yellow(`Skipping boot disk: /dev/${diskId}`));
+                            continue;
+                        }
+                    }
+                    catch (error) {
+                        // If we can't determine the boot disk, proceed anyway
+                    }
+                }
+                // Get additional disk information
+                let vendor = '';
+                let model = '';
+                let size = '';
+                try {
+                    // Get more detailed information about the disk
+                    const diskInfo = (0, child_process_1.execSync)(`diskutil info ${diskId}`, { encoding: 'utf8' });
+                    // Extract size
+                    const sizeMatch = diskInfo.match(/Disk Size:\s+([^(]+)/);
+                    if (sizeMatch && sizeMatch[1]) {
+                        size = sizeMatch[1].trim();
+                    }
+                    // Extract model/vendor
+                    const deviceModel = diskInfo.match(/Device Model:\s+(.+?)$/m);
+                    if (deviceModel && deviceModel[1]) {
+                        model = deviceModel[1].trim();
+                    }
+                    // Extract media name
+                    const mediaName = diskInfo.match(/Media Name:\s+(.+?)$/m);
+                    if (mediaName && mediaName[1]) {
+                        vendor = mediaName[1].trim();
+                    }
+                }
+                catch (error) {
+                    // Fallback to basic information if detailed info not available
+                    console.log(chalk_1.default.yellow(`Couldn't get detailed info for /dev/${diskId}: ${error.message}`));
+                }
+                // Prepare display name with detailed information
+                const displayDetails = [];
+                if (size)
+                    displayDetails.push(size);
+                if (vendor)
+                    displayDetails.push(vendor);
+                if (model && model !== vendor)
+                    displayDetails.push(model);
+                // Add this disk to our list
+                drives.push({
+                    path: `/dev/${diskId}`,
+                    displayName: `/dev/${diskId} (${displayDetails.join(' • ')})`,
+                    vendor,
+                    model,
+                    size
+                });
+            }
+            return drives;
+        }
+        catch (error) {
+            console.error(chalk_1.default.red(`Error listing drives: ${error.message}`));
+            return [];
+        }
+    }
+    else if (platform === 'linux') {
+        // Linux - use lsblk
+        try {
+            // Use lsblk with different options depending on whether we want all disks
+            const lsblkCmd = showAllDisks
+                ? 'lsblk -d -o NAME,SIZE,MODEL,VENDOR,SERIAL,TRAN --noheadings'
+                : 'lsblk -d -o NAME,SIZE,RM,MODEL,VENDOR,SERIAL,TRAN --noheadings';
+            const output = (0, child_process_1.execSync)(lsblkCmd, { encoding: 'utf8' });
+            const drives = [];
+            // Parse lsblk output
+            output.split('\n').forEach(line => {
+                const fields = line.trim().split(/\s+/);
+                if (fields.length < 2)
+                    return; // Skip empty lines
+                const name = fields[0];
+                const size = fields[1];
+                // If we're only showing removable drives, check the RM flag
+                if (!showAllDisks) {
+                    const isRemovable = fields.length >= 3 && fields[2] === '1';
+                    if (!isRemovable)
+                        return;
+                    // Move to next position after RM flag
+                    fields.splice(2, 1);
+                }
+                // Skip known system disks if not in raw mode
+                if (!showAllDisks && (name === 'sda' || name === 'nvme0n1')) {
+                    try {
+                        // Check if this is the boot disk
+                        const mountInfo = (0, child_process_1.execSync)(`findmnt -n -o SOURCE /`, { encoding: 'utf8' });
+                        if (mountInfo.includes(name)) {
+                            console.log(chalk_1.default.yellow(`Skipping boot disk: /dev/${name}`));
+                            return;
+                        }
+                    }
+                    catch (error) {
+                        // If we can't determine boot disk, still include this disk
+                    }
+                }
+                // Extract additional information
+                const model = fields.length >= 3 ? fields[2] : '';
+                const vendor = fields.length >= 4 ? fields[3] : '';
+                const serial = fields.length >= 5 ? fields[4] : '';
+                const transport = fields.length >= 6 ? fields[5] : '';
+                // Prepare display name with rich information
+                const displayDetails = [];
+                if (size)
+                    displayDetails.push(size);
+                if (vendor)
+                    displayDetails.push(vendor);
+                if (model)
+                    displayDetails.push(model);
+                if (transport)
+                    displayDetails.push(transport);
+                if (serial && serial !== '0')
+                    displayDetails.push(`S/N: ${serial.substring(0, 8)}...`);
+                drives.push({
+                    path: `/dev/${name}`,
+                    displayName: `/dev/${name} (${displayDetails.join(' • ')})`,
+                    vendor,
+                    model,
+                    size
+                });
+            });
+            return drives;
+        }
+        catch (error) {
+            console.error(chalk_1.default.red(`Error listing drives: ${error.message}`));
+            return [];
+        }
+    }
+    else {
+        console.log(chalk_1.default.red(`Unsupported platform: ${platform}`));
+        return [];
+    }
+}
+/**
+ * Enhanced checkRequiredTools function that installs missing dependencies
+ */
+async function checkAndInstallRequiredTools() {
+    const platform = process.platform;
+    const inquirer = (await Promise.resolve().then(() => __importStar(require('inquirer')))).default;
+    let allToolsAvailable = true;
+    // Tool definitions with installation commands per platform
+    const requiredTools = [
+        {
+            name: 'dd',
+            description: 'Basic disk writing utility',
+            required: true,
+            package: {
+                darwin: 'coreutils',
+                debian: 'coreutils',
+                fedora: 'coreutils',
+                arch: 'coreutils'
+            }
+        },
+        {
+            name: 'gzip',
+            aliases: ['gunzip'],
+            description: 'Compression utility for .gz files',
+            required: true,
+            package: {
+                darwin: 'gzip',
+                debian: 'gzip',
+                fedora: 'gzip',
+                arch: 'gzip'
+            }
+        },
+        {
+            name: 'xz',
+            description: 'Compression utility for .xz files',
+            required: true,
+            package: {
+                darwin: 'xz',
+                debian: 'xz-utils',
+                fedora: 'xz',
+                arch: 'xz'
+            }
+        },
+        {
+            name: 'pv',
+            description: 'Pipe Viewer for progress reporting',
+            required: false,
+            package: {
+                darwin: 'pv',
+                debian: 'pv',
+                fedora: 'pv',
+                arch: 'pv'
+            }
+        },
+        {
+            name: 'ddrescue',
+            aliases: ['gddrescue'],
+            description: 'Enhanced dd with better progress and error handling',
+            required: false,
+            package: {
+                darwin: 'ddrescue',
+                debian: 'gddrescue',
+                fedora: 'ddrescue',
+                arch: 'ddrescue'
+            }
+        },
+        {
+            name: 'cmp',
+            description: 'Binary comparison utility (for verification)',
+            required: false,
+            package: {
+                darwin: 'diffutils',
+                debian: 'diffutils',
+                fedora: 'diffutils',
+                arch: 'diffutils'
+            }
+        }
+    ];
+    // Detect distribution type (for Linux)
+    const getDistroType = async () => {
+        try {
+            if (platform !== 'linux')
+                return null;
+            if (isCommandAvailable('apt') || isCommandAvailable('apt-get')) {
+                return 'debian';
+            }
+            else if (isCommandAvailable('dnf') || isCommandAvailable('yum')) {
+                return 'fedora';
+            }
+            else if (isCommandAvailable('pacman')) {
+                return 'arch';
+            }
+            return null;
+        }
+        catch (error) {
+            return null;
+        }
+    };
+    // Detect package manager
+    const distroType = platform === 'darwin' ? 'darwin' : await getDistroType();
+    if (!distroType) {
+        console.log(chalk_1.default.yellow('Could not detect your Linux distribution. Automatic installation is not available.'));
+        console.log(chalk_1.default.yellow('Please install the required tools manually.'));
+        // Still check and report missing tools
+        for (const tool of requiredTools) {
+            const isAvailable = isCommandAvailable(tool.name) ||
+                (tool.aliases && tool.aliases.some(alias => isCommandAvailable(alias)));
+            if (!isAvailable) {
+                console.log(chalk_1.default.red(`Required tool "${tool.name}" is not available.`));
+                if (tool.required)
+                    allToolsAvailable = false;
+            }
+        }
+        return allToolsAvailable;
+    }
+    // Determine installation command prefix based on platform and distro
+    let installCmdPrefix = '';
+    if (platform === 'darwin') {
+        if (!isCommandAvailable('brew')) {
+            console.log(chalk_1.default.yellow('Homebrew not found. Please install it to automatically install dependencies.'));
+            console.log(chalk_1.default.blue('Visit https://brew.sh for installation instructions.'));
+            return false;
+        }
+        installCmdPrefix = 'brew install';
+    }
+    else if (distroType === 'debian') {
+        installCmdPrefix = 'apt-get update && apt-get install -y';
+    }
+    else if (distroType === 'fedora') {
+        installCmdPrefix = 'dnf install -y';
+    }
+    else if (distroType === 'arch') {
+        installCmdPrefix = 'pacman -S --noconfirm';
+    }
+    // Check each tool and ask to install if missing
+    for (const tool of requiredTools) {
+        const isAvailable = isCommandAvailable(tool.name) ||
+            (tool.aliases && tool.aliases.some(alias => isCommandAvailable(alias)));
+        if (!isAvailable) {
+            const packageName = tool.package[distroType];
+            if (!packageName) {
+                console.log(chalk_1.default.yellow(`No package information available for ${tool.name} on your system.`));
+                if (tool.required)
+                    allToolsAvailable = false;
+                continue;
+            }
+            const installCmd = `${installCmdPrefix} ${packageName}`;
+            const needsSudo = platform !== 'darwin' && !installCmd.startsWith('sudo');
+            const fullInstallCmd = needsSudo ? `sudo ${installCmd}` : installCmd;
+            console.log(chalk_1.default.yellow(`${tool.required ? 'Required' : 'Recommended'} tool "${tool.name}" (${tool.description}) is not available.`));
+            const { confirmInstall } = await inquirer.prompt([{
+                    type: 'confirm',
+                    name: 'confirmInstall',
+                    message: `Would you like to install ${tool.name} (${packageName}) now?`,
+                    default: tool.required // Default to yes for required tools
+                }]);
+            if (confirmInstall) {
+                console.log(chalk_1.default.blue(`Installing ${packageName}...`));
+                try {
+                    // Execute the installation command
+                    await new Promise((resolve, reject) => {
+                        const childProcess = (0, child_process_1.spawn)(fullInstallCmd, {
+                            shell: true,
+                            stdio: 'inherit' // Use inherit for all stdio to properly handle sudo password
+                        });
+                        childProcess.on('close', (code) => {
+                            if (code === 0) {
+                                resolve();
+                            }
+                            else {
+                                reject(new Error(`Installation failed with code ${code}`));
+                            }
+                        });
+                        childProcess.on('error', (error) => {
+                            reject(error);
+                        });
+                    });
+                    console.log(chalk_1.default.green(`Successfully installed ${packageName}`));
+                    // Verify installation
+                    const isNowAvailable = isCommandAvailable(tool.name) ||
+                        (tool.aliases && tool.aliases.some(alias => isCommandAvailable(alias)));
+                    if (!isNowAvailable) {
+                        console.log(chalk_1.default.red(`Installation completed, but ${tool.name} is still not available in PATH.`));
+                        console.log(chalk_1.default.yellow('You may need to restart your terminal or update your PATH.'));
+                        if (tool.required)
+                            allToolsAvailable = false;
+                    }
+                }
+                catch (error) {
+                    console.log(chalk_1.default.red(`Failed to install ${packageName}: ${error.message}`));
+                    console.log(chalk_1.default.yellow('Please try to install it manually:'));
+                    console.log(chalk_1.default.blue(fullInstallCmd));
+                    if (tool.required)
+                        allToolsAvailable = false;
+                }
+            }
+            else if (tool.required) {
+                console.log(chalk_1.default.yellow(`${tool.name} is required and was not installed. Please install it manually.`));
+                allToolsAvailable = false;
+            }
+        }
+    }
+    return allToolsAvailable;
+}
+/**
+ * Extract a compressed file to a temporary location
+ */
+async function extractCompressedFile(sourcePath, isGzipped, isXz, cacheDir) {
+    // Generate cache file path with predictable naming
+    const sourceFilename = path_1.default.basename(sourcePath);
+    const extractedFilename = sourceFilename.replace(/\.(gz|xz)$/, '.extracted');
+    const extractedPath = path_1.default.join(cacheDir, extractedFilename);
+    // Check if extracted file already exists in the cache
+    if (fs_1.default.existsSync(extractedPath)) {
+        console.log(chalk_1.default.green(`Found extracted image in cache: ${extractedFilename}`));
+        return extractedPath;
+    }
+    console.log(chalk_1.default.blue(`Extracting compressed file...`));
+    // Get source file size for progress estimation
+    const sourceSize = fs_1.default.statSync(sourcePath).size;
+    const sizeMB = (sourceSize / 1024 / 1024).toFixed(2);
+    console.log(chalk_1.default.dim(`Source file size: ${sizeMB} MB`));
+    return new Promise((resolve, reject) => {
+        let command = '';
+        if (isGzipped) {
+            // Use pv to show progress if available
+            command = isCommandAvailable('pv')
+                ? `pv --force --progress --timer --rate --bytes --width 70 "${sourcePath}" | gunzip > "${extractedPath}"`
+                : `gunzip -c "${sourcePath}" > "${extractedPath}"`;
+        }
+        else if (isXz) {
+            // Use pv to show progress if available
+            command = isCommandAvailable('pv')
+                ? `pv --force --progress --timer --rate --bytes --width 70 "${sourcePath}" | xz -dc > "${extractedPath}"`
+                : `xz -dc "${sourcePath}" > "${extractedPath}"`;
+        }
+        else {
+            // Not compressed, just return the original
+            resolve(sourcePath);
+            return;
+        }
+        // Execute extraction command with proper output handling
+        const proc = (0, child_process_1.spawn)('sh', ['-c', command], {
+            stdio: ['ignore', 'inherit', 'inherit'] // This will show pv's output directly on the terminal
+        });
+        // Only show spinner if pv is not available
+        let spinnerInterval = null;
+        if (!isCommandAvailable('pv')) {
+            // Simple progress spinner
+            const spinnerChars = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+            let spinnerIndex = 0;
+            const startTime = Date.now();
+            spinnerInterval = setInterval(() => {
+                const elapsed = Math.floor((Date.now() - startTime) / 1000);
+                const minutes = Math.floor(elapsed / 60);
+                const seconds = elapsed % 60;
+                const timeStr = `${minutes}:${seconds.toString().padStart(2, '0')}`;
+                process.stdout.write(`\r${spinnerChars[spinnerIndex]} Extracting compressed file... (${timeStr} elapsed)`);
+                spinnerIndex = (spinnerIndex + 1) % spinnerChars.length;
+            }, 100);
+            proc.on('close', () => {
+                if (spinnerInterval) {
+                    clearInterval(spinnerInterval);
+                    spinnerInterval = null;
+                    process.stdout.write('\r✓ Extraction complete!                                   \n');
+                }
+            });
+        }
+        proc.on('close', (code) => {
+            if (spinnerInterval) {
+                clearInterval(spinnerInterval);
+            }
+            if (code === 0) {
+                console.log(chalk_1.default.green(`Extracted file saved to cache for future use: ${extractedFilename}`));
+                resolve(extractedPath);
+            }
+            else {
+                // Clean up failed extraction
+                try {
+                    if (fs_1.default.existsSync(extractedPath)) {
+                        fs_1.default.unlinkSync(extractedPath);
+                    }
+                }
+                catch (e) {
+                    // Ignore cleanup errors
+                }
+                reject(new Error(`Extraction failed with code ${code}`));
+            }
+        });
+        proc.on('error', (err) => {
+            if (spinnerInterval) {
+                clearInterval(spinnerInterval);
+            }
+            console.error(chalk_1.default.red(`\nError during extraction: ${err.message}`));
+            reject(err);
+        });
+    });
+}
+/**
+ * Check if a command is available
+ */
+function isCommandAvailable(command) {
+    try {
+        (0, child_process_1.execSync)(`which ${command}`, { stdio: 'ignore' });
+        return true;
+    }
+    catch (error) {
+        return false;
+    }
+}
+/**
+ * Verify the flashed image against the original
+ */
+async function verifyFlashedImage(sourcePath, devicePath) {
+    console.log(chalk_1.default.blue('\nVerifying flashed image...'));
+    return new Promise((resolve, reject) => {
+        // Get source file size for verification bounds
+        const sourceSize = fs_1.default.statSync(sourcePath).size;
+        console.log(chalk_1.default.dim(`Source size: ${(sourceSize / 1024 / 1024).toFixed(2)} MB`));
+        let command = '';
+        const platform = os_1.default.platform();
+        // Use pv if available to show read progress during verification
+        if (isCommandAvailable('pv')) {
+            if (platform === 'darwin') {
+                // macOS: use ddrescue to read from device with pv showing progress
+                command = `pv -pterb "${devicePath}" | cmp -n ${sourceSize} "${sourcePath}" -`;
+            }
+            else {
+                // Linux: direct with pv
+                command = `pv -pterb < "${devicePath}" | cmp -n ${sourceSize} "${sourcePath}" -`;
+            }
+        }
+        else {
+            // Fallback without progress indication
+            command = `cmp -n ${sourceSize} "${sourcePath}" "${devicePath}"`;
+        }
+        console.log(chalk_1.default.dim(`Running: ${command}`));
+        const proc = (0, child_process_1.spawn)('sudo', ['sh', '-c', command], {
+            stdio: 'inherit' // Use inherit for all stdio to ensure password prompt and progress work correctly
+        });
+        // Only show spinner if pv is not available
+        let spinnerInterval = null;
+        if (!isCommandAvailable('pv')) {
+            // Simple progress spinner
+            const spinnerChars = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+            let spinnerIndex = 0;
+            const startTime = Date.now();
+            spinnerInterval = setInterval(() => {
+                const elapsed = Math.floor((Date.now() - startTime) / 1000);
+                const minutes = Math.floor(elapsed / 60);
+                const seconds = elapsed % 60;
+                const timeStr = `${minutes}:${seconds.toString().padStart(2, '0')}`;
+                process.stdout.write(`\r${spinnerChars[spinnerIndex]} Verifying data... (${timeStr} elapsed)`);
+                spinnerIndex = (spinnerIndex + 1) % spinnerChars.length;
+            }, 100);
+        }
+        // If verification takes more than 30 seconds, show a message explaining this can take time
+        const timeoutId = setTimeout(() => {
+            console.log(chalk_1.default.yellow('\nVerification is still running. This can take several minutes for large images...'));
+        }, 30000);
+        // When using stdio: 'inherit', we don't need these handlers
+        // as stdout and stderr are connected directly to the parent process
+        proc.on('close', (code) => {
+            if (spinnerInterval) {
+                clearInterval(spinnerInterval);
+            }
+            clearTimeout(timeoutId);
+            if (code === 0) {
+                if (!isCommandAvailable('pv')) {
+                    process.stdout.write('\r✓ Verification successful! Data was written correctly.   \n');
+                }
+                else {
+                    console.log(chalk_1.default.green('Verification successful! Data was written correctly.'));
+                }
+                resolve();
+            }
+            else {
+                if (!isCommandAvailable('pv')) {
+                    process.stdout.write('\r✗ Verification failed! Flashed data does not match source.\n');
+                }
+                else {
+                    console.log(chalk_1.default.red('Verification failed! Flashed data does not match source.'));
+                }
+                reject(new Error('Verification failed - flashed data does not match source image'));
+            }
+        });
+        proc.on('error', (err) => {
+            if (spinnerInterval) {
+                clearInterval(spinnerInterval);
+            }
+            clearTimeout(timeoutId);
+            console.error(chalk_1.default.red(`\nError during verification: ${err.message}`));
+            reject(err);
+        });
+    });
+}
+/**
+ * Flash the image to the selected device
+ */
+async function flashImageToDevice(imagePath, devicePath, isGzipped, isXz, verify, cacheDir) {
+    try {
+        const platform = os_1.default.platform();
+        const startTime = Date.now();
+        // 1. Extract the compressed file if needed
+        let extractedPath = imagePath;
+        let isExtracted = false;
+        if (isGzipped || isXz) {
+            extractedPath = await extractCompressedFile(imagePath, isGzipped, isXz, cacheDir);
+            isExtracted = extractedPath !== imagePath;
+        }
+        try {
+            // 2. Flash the image
+            console.log(chalk_1.default.blue(`\nFlashing image to ${devicePath}...`));
+            // Prepare command based on available tools
+            let command = '';
+            // On macOS, use the raw disk device path (rdiskX instead of diskX)
+            let targetDevice = devicePath;
+            if (platform === 'darwin' && devicePath.match(/\/dev\/disk\d+$/)) {
+                targetDevice = devicePath.replace(/\/dev\/disk(\d+)$/, '/dev/rdisk$1');
+                console.log(chalk_1.default.blue(`Using raw device path for macOS: ${targetDevice}`));
+            }
+            // Determine which tool to use for flashing
+            const isOnMacOS = platform === 'darwin';
+            const isPvAvailable = isCommandAvailable('pv');
+            let ddCommand = '';
+            // Always use dd on macOS, regardless of ddrescue availability
+            if (isOnMacOS) {
+                console.log(chalk_1.default.yellow(`Using dd on macOS for better compatibility...`));
+                // On macOS, use the raw disk device (rdiskX instead of diskX) for better performance
+                if (isPvAvailable) {
+                    ddCommand = `pv -pterb "${extractedPath}" | dd of="${targetDevice}" bs=4M`;
+                }
+                else {
+                    ddCommand = `dd if="${extractedPath}" of="${targetDevice}" bs=4M`;
+                }
+            }
+            else {
+                // On Linux, prefer ddrescue if available
+                let ddrescueAvailable = false;
+                try {
+                    ddrescueAvailable = isCommandAvailable('ddrescue') || isCommandAvailable('gddrescue');
+                }
+                catch (e) {
+                    ddrescueAvailable = false;
+                }
+                if (ddrescueAvailable) {
+                    console.log(chalk_1.default.yellow(`Using ddrescue for enhanced reliability...`));
+                    ddCommand = await getDdrescueCommand(extractedPath, targetDevice, { isRawDevice: false, useDirectFlag: true });
+                }
+                else {
+                    console.log(chalk_1.default.yellow(`ddrescue not available, using dd instead...`));
+                    if (isPvAvailable) {
+                        ddCommand = `pv -pterb "${extractedPath}" | dd of="${targetDevice}" bs=4M oflag=direct status=progress`;
+                    }
+                    else {
+                        ddCommand = `dd if="${extractedPath}" of="${targetDevice}" bs=4M oflag=direct status=progress`;
+                    }
+                }
+            }
+            // Debug: show command
+            console.log(chalk_1.default.dim(`Running: ${ddCommand}`));
+            // Execute the command with sudo (required for both macOS and Linux)
+            try {
+                await new Promise((resolve, reject) => {
+                    // Use inherit for all stdio when using pv to ensure progress display works properly
+                    const ddProc = (0, child_process_1.spawn)('sudo', ['sh', '-c', ddCommand], {
+                        stdio: 'inherit' // Use inherit for all stdio to ensure progress display works
+                    });
+                    ddProc.on('close', (code) => {
+                        if (code === 0) {
+                            console.log(chalk_1.default.green('Flashing completed!'));
+                            resolve();
+                        }
+                        else {
+                            reject(new Error(`Flashing failed with code ${code}`));
+                        }
+                    });
+                    ddProc.on('error', (err) => {
+                        reject(new Error(`Error executing command: ${err.message}`));
+                    });
+                });
+            }
+            catch (error) {
+                // If ddrescue failed with direct disk access error, try with dd instead
+                if (error.message === 'DDRESCUE_DIRECT_ACCESS_ERROR') {
+                    console.log(chalk_1.default.yellow('ddrescue could not access disk directly. Falling back to dd...'));
+                    // Build a dd command as fallback
+                    let fallbackCommand;
+                    if (isPvAvailable) {
+                        fallbackCommand = `pv -pterb "${extractedPath}" | dd of="${targetDevice}" bs=4M`;
+                    }
+                    else if (platform === 'darwin') {
+                        fallbackCommand = `dd if="${extractedPath}" of="${targetDevice}" bs=4M`;
+                    }
+                    else {
+                        fallbackCommand = `dd if="${extractedPath}" of="${targetDevice}" bs=4M status=progress`;
+                    }
+                    console.log(chalk_1.default.dim(`Running fallback command: ${fallbackCommand}`));
+                    // Execute dd command
+                    await new Promise((resolve, reject) => {
+                        const ddProc = (0, child_process_1.spawn)('sudo', ['sh', '-c', fallbackCommand], {
+                            stdio: 'inherit' // Use inherit for all stdio
+                        });
+                        ddProc.on('close', (code) => {
+                            if (code === 0) {
+                                console.log(chalk_1.default.green('Flashing with dd completed!'));
+                                resolve();
+                            }
+                            else {
+                                reject(new Error(`Fallback dd command failed with code ${code}`));
+                            }
+                        });
+                        ddProc.on('error', (err) => {
+                            reject(new Error(`Error executing dd: ${err.message}`));
+                        });
+                    });
+                }
+                else {
+                    // Re-throw any other errors
+                    throw error;
+                }
+            }
+            // Verify the flashed image
+            if (verify) {
+                await verifyFlashedImage(extractedPath, targetDevice);
+            }
+        }
+        catch (error) {
+            console.error(chalk_1.default.red(`\n❗️Error: ${error.message}`));
+            throw error;
+        }
+    }
+    catch (error) {
+        console.error(chalk_1.default.red(`\n❗️Error: ${error.message}`));
+        throw error;
+    }
+}
+/**
+ * Get the ddrescue command for enhanced reliability
+ */
+async function getDdrescueCommand(sourcePath, targetDevice, options) {
+    const platform = os_1.default.platform();
+    const inquirer = (await Promise.resolve().then(() => __importStar(require('inquirer')))).default;
+    // Get source file size for progress estimation
+    const sourceSize = fs_1.default.statSync(sourcePath).size;
+    const sizeMB = (sourceSize / 1024 / 1024).toFixed(2);
+    console.log(chalk_1.default.dim(`Source file size: ${sizeMB} MB`));
+    // Get target device size for verification
+    const targetSize = fs_1.default.statSync(targetDevice).size;
+    const targetSizeMB = (targetSize / 1024 / 1024).toFixed(2);
+    console.log(chalk_1.default.dim(`Target device size: ${targetSizeMB} MB`));
+    // Get user confirmation for flashing
+    const { confirmFlash } = await inquirer.prompt([{
+            type: 'confirm',
+            name: 'confirmFlash',
+            message: `Are you sure you want to flash ${sizeMB} MB of data to ${targetSizeMB} MB of device?`,
+            default: false
+        }]);
+    if (!confirmFlash) {
+        throw new Error('User cancelled flashing');
+    }
+    // Build the ddrescue command
+    let command = '';
+    if (platform === 'darwin') {
+        // macOS: use the raw device path (rdiskX instead of diskX)
+        const rawDevice = targetDevice.replace(/\/dev\/disk(\d+)$/, '/dev/rdisk$1');
+        command = `ddrescue -d -f -b 4M "${sourcePath}" "${rawDevice}" "${targetDevice}"`;
+    }
+    else {
+        // Linux: use the raw device path (rdiskX instead of diskX)
+        const rawDevice = targetDevice.replace(/\/dev\/disk(\d+)$/, '/dev/rdisk$1');
+        command = `ddrescue -d -f -b 4M "${sourcePath}" "${rawDevice}" "${targetDevice}"`;
+    }
+    // Add direct flag if specified
+    if (options.useDirectFlag) {
+        command += ' -D';
+    }
+    // Add raw device flag if specified
+    if (options.isRawDevice) {
+        command += ' -r';
+    }
+    return command;
+}
+// Create command
+const flash = new commander_1.Command('flash')
+    .description('Flash PhyOS image to a removable drive')
+    .arguments('[filename]') // Make argument optional with []
+    .option('--raw', 'Show all disks, including system disks (use with caution)')
+    .option('--no-verify', 'Skip verification after flashing')
+    .action((0, utils_1.handleError)(flashImage));
+exports.default = flash;
+//# sourceMappingURL=flash.js.map