@phystack/cli 4.3.40-dev

package/dist/commands/vm/start.js

@@ -0,0 +1,861 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = startVm;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const chalk_1 = __importDefault(require("chalk"));
+const child_process_1 = require("child_process");
+const vm_1 = require("../../utils/vm");
+const inquirer_1 = __importDefault(require("inquirer"));
+/**
+ * Starts a single PhyOS VM with QEMU (helper function)
+ */
+async function startSingleVm(name, options) {
+    const runningOnMac = isMacOS();
+    const needsSudo = runningOnMac && process.getuid && process.getuid() !== 0;
+    // If on macOS and needs bridged networking (default) but not running as root, re-run with sudo
+    if (needsSudo) {
+        console.log(chalk_1.default.yellow('Bridged networking on macOS requires root privileges. Attempting to re-run with sudo...'));
+        // Get the original arguments passed to the phy command
+        // process.argv is typically [node executable, script path, ...args]
+        // We want to run 'sudo phy ...args'
+        const originalArgs = process.argv.slice(2); // e.g., ['vm', 'start', 'myvm', '--headless']
+        const phyCommand = process.argv[1]; // Path to the phy script being executed
+        const sudoArgs = [phyCommand, ...originalArgs]; // Explicitly typed array
+        try {
+            // Explicitly use the string 'sudo' as the command
+            const sudoProcess = (0, child_process_1.spawn)('sudo', sudoArgs, { stdio: 'inherit' });
+            sudoProcess.on('error', (err) => {
+                console.error(chalk_1.default.red(`Failed to execute sudo: ${err.message}`));
+                console.error(chalk_1.default.red('Please ensure \'sudo\' is available and try running the command manually with sudo:'));
+                console.error(chalk_1.default.cyan(`  sudo phy ${originalArgs.join(' ')}`));
+                process.exit(1);
+            });
+            // Wait for the sudo process to exit and exit this script with the same code
+            sudoProcess.on('close', (code) => {
+                process.exit(code === null ? 1 : code);
+            });
+            // Prevent the non-sudo version from continuing
+            return;
+        }
+        catch (error) {
+            console.error(chalk_1.default.red(`Error attempting to spawn sudo: ${error.message}`));
+            process.exit(1);
+        }
+    }
+    // Check if VM exists (do this *after* potential sudo relaunch)
+    if (!(0, vm_1.vmExists)(name)) {
+        throw new Error(`VM "${name}" not found`);
+    }
+    // Check if VM is already running
+    if ((0, vm_1.isVmRunning)(name)) {
+        console.log(chalk_1.default.yellow(`VM "${name}" is already running`));
+        return;
+    }
+    // Read VM configuration and settings
+    const config = (0, vm_1.readVmConfig)(name);
+    const settings = (0, vm_1.readVmSettings)(name);
+    const vmDir = (0, vm_1.getVmDir)(name);
+    // Determine memory to use - priority: command option > settings.json > config.json
+    const memory = options.memory
+        ? parseInt(options.memory, 10)
+        : settings.memory
+            ? settings.memory
+            : config.memory || 2048;
+    // Get host architecture to determine emulation status
+    const hostArch = getHostArch();
+    const isEmulated = config.arch !== hostArch;
+    // Force headless mode for cross-architecture emulation due to compatibility issues
+    let headless = options.headless !== undefined
+        ? options.headless
+        : settings.headless || false;
+    // Force headless mode for cross-architecture emulation (both directions)
+    if (isEmulated && ((config.arch === 'amd64' && hostArch === 'arm64') ||
+        (config.arch === 'arm64' && hostArch === 'amd64'))) {
+        const wasHeadless = headless;
+        headless = true; // Force headless mode
+        // If user explicitly requested non-headless mode, inform them
+        if (options.headless === false || (!options.headless && !settings.headless)) {
+            console.log(chalk_1.default.yellow(`⚠️  Running ${config.arch} VM on ${hostArch} architecture requires headless mode`));
+            console.log(chalk_1.default.yellow(`   GUI mode has been disabled and switched to headless operation`));
+            console.log(chalk_1.default.blue(`   Use 'phy vm shell ${name}' to access the console`));
+        }
+    }
+    // Build paths to image and disk files
+    const imageFile = path_1.default.join(vmDir, config.image);
+    const diskFile = path_1.default.join(vmDir, config.disk);
+    // Construct initramfs path if the filename exists in config
+    const initramfsFile = config.initramfs
+        ? path_1.default.join(vmDir, config.initramfs)
+        : undefined;
+    // Check if image and disk files exist
+    if (!fs_1.default.existsSync(imageFile) || !fs_1.default.existsSync(diskFile)) {
+        throw new Error(`VM image or disk file not found for "${name}"`);
+    }
+    // Also check initramfs file if it exists in config
+    if (config.initramfs && !fs_1.default.existsSync(initramfsFile)) {
+        throw new Error(`VM initramfs file not found for "${name}": ${initramfsFile}`);
+    }
+    // Get serial number from settings.json or serial.txt for backward compatibility
+    let serialNumber = settings.serial;
+    // If serial not in settings, try reading from serial.txt (backward compatibility)
+    if (!serialNumber) {
+        const serialPath = (0, vm_1.getVmSerialPath)(name);
+        if (fs_1.default.existsSync(serialPath)) {
+            serialNumber = fs_1.default.readFileSync(serialPath, 'utf8').trim();
+        }
+    }
+    if (serialNumber) {
+        console.log(chalk_1.default.blue(`Using serial number: ${serialNumber}`));
+    }
+    else {
+        console.log(chalk_1.default.yellow(`No serial number found for VM "${name}"`));
+    }
+    // Determine QEMU binary based on architecture
+    const qemuBin = config.arch === 'amd64'
+        ? 'qemu-system-x86_64'
+        : 'qemu-system-aarch64';
+    // Check if QEMU is installed first
+    try {
+        await checkQemuInstalled(qemuBin);
+    }
+    catch (error) {
+        // Attempt to install QEMU automatically
+        const installed = await attemptQemuInstall(qemuBin);
+        if (!installed) {
+            throw new Error(`QEMU binary '${qemuBin}' not found. Please install QEMU: ${error.message}`);
+        }
+    }
+    // Build QEMU command arguments - must exactly match the bash script format
+    const args = buildExactQemuArgs(config.arch, imageFile, diskFile, initramfsFile, memory, serialNumber, headless, null);
+    console.log(chalk_1.default.blue(`Starting PhyOS VM "${name}"...`));
+    console.log(chalk_1.default.blue(`Memory allocation: ${memory}MB`));
+    if (isEmulated) {
+        console.log(chalk_1.default.yellow(`Running in cross-architecture emulation mode: ${config.arch} VM on ${hostArch} host`));
+        if (process.platform === 'darwin') {
+            console.log(chalk_1.default.yellow(`Note: Cross-architecture emulation on macOS can be significantly slower than native.`));
+            if (config.arch === 'amd64') {
+                console.log(chalk_1.default.yellow(`Tip: On Apple Silicon Macs, install Rosetta 2 for better x86 emulation performance.`));
+            }
+        }
+        else {
+            console.log(chalk_1.default.yellow(`Note: Performance may be reduced in emulation mode`));
+        }
+    }
+    else {
+        console.log(chalk_1.default.green(`Running with native architecture: ${config.arch}`));
+    }
+    // Log the exact command being run
+    console.log(chalk_1.default.gray(`Running: ${qemuBin} ${args.join(' ')}`));
+    // Show headless status
+    if (headless) {
+        console.log(chalk_1.default.blue(`Running in headless mode - no GUI display`));
+    }
+    else {
+        console.log(chalk_1.default.blue(`Running with GUI display`));
+    }
+    // Open log file for writing
+    const logPath = (0, vm_1.getVmLogPath)(name);
+    const timestamp = new Date().toISOString();
+    const logFile = fs_1.default.openSync(logPath, 'a');
+    // Add startup timestamp to log
+    fs_1.default.writeSync(logFile, `\n\n========== Starting VM at ${timestamp} ==========\n\n`);
+    fs_1.default.writeSync(logFile, `Command: ${qemuBin} ${args.join(' ')}\n\n`);
+    // Create temporary file to capture error output
+    const errorLogPath = path_1.default.join((0, vm_1.getVmDir)(name), 'error.log');
+    const errorLogFile = fs_1.default.openSync(errorLogPath, 'w');
+    // Spawn QEMU process in detached mode, but capture stderr to help with debugging
+    const qemuProcess = (0, child_process_1.spawn)(qemuBin, args, {
+        detached: true,
+        stdio: ['ignore', logFile, errorLogFile]
+    });
+    // Handle process startup errors
+    qemuProcess.on('error', (err) => {
+        fs_1.default.writeSync(errorLogFile, `Process startup error: ${err.message}\n`);
+        console.error(chalk_1.default.red(`Failed to start QEMU: ${err.message}`));
+        throw err;
+    });
+    // Wait briefly to see if process starts successfully
+    await new Promise(resolve => setTimeout(resolve, 500));
+    // Check if process is still running
+    const pid = qemuProcess.pid;
+    if (!pid) {
+        // Read any error output to diagnose the issue
+        let errorOutput = '';
+        try {
+            fs_1.default.closeSync(errorLogFile);
+            if (fs_1.default.existsSync(errorLogPath)) {
+                errorOutput = fs_1.default.readFileSync(errorLogPath, 'utf8');
+            }
+        }
+        catch (e) {
+            // Ignore errors reading the error log
+        }
+        if (errorOutput) {
+            console.error(chalk_1.default.red(`QEMU Error Output: ${errorOutput}`));
+            throw new Error(`Failed to start VM process. QEMU Error: ${errorOutput}`);
+        }
+        else {
+            throw new Error('Failed to start VM process - no PID returned. Check if QEMU is properly installed.');
+        }
+    }
+    // Save PID to file atomically
+    const pidPath = (0, vm_1.getVmPidPath)(name);
+    const tempPidPath = `${pidPath}.tmp`;
+    try {
+        // Write to a temporary file first
+        fs_1.default.writeFileSync(tempPidPath, String(pid));
+        // Verify the temp file was actually created
+        if (!fs_1.default.existsSync(tempPidPath)) {
+            throw new Error('Failed to create temporary PID file');
+        }
+        // Ensure it's written to disk by syncing the file descriptor
+        const tempFd = fs_1.default.openSync(tempPidPath, 'r');
+        fs_1.default.fsyncSync(tempFd);
+        fs_1.default.closeSync(tempFd);
+        // Atomically rename the temporary file to the final file
+        fs_1.default.renameSync(tempPidPath, pidPath);
+    }
+    catch (error) {
+        // Clean up temp file if it exists
+        try {
+            if (fs_1.default.existsSync(tempPidPath)) {
+                fs_1.default.unlinkSync(tempPidPath);
+            }
+        }
+        catch (e) {
+            // Ignore cleanup errors
+        }
+        // If the PID file already exists (race condition), check if the process is actually running
+        if (fs_1.default.existsSync(pidPath)) {
+            try {
+                const existingPid = parseInt(fs_1.default.readFileSync(pidPath, 'utf8').trim(), 10);
+                // Check if the process is actually running
+                process.kill(existingPid, 0);
+                // If we get here, the process is running, so this is a legitimate "already running" case
+                console.log(chalk_1.default.yellow(`VM "${name}" is already running (PID: ${existingPid})`));
+                return;
+            }
+            catch (pidError) {
+                // Process is not running, remove stale PID file and retry
+                try {
+                    fs_1.default.unlinkSync(pidPath);
+                    // Retry writing the PID file once
+                    fs_1.default.writeFileSync(tempPidPath, String(pid));
+                    // Verify the temp file was created
+                    if (!fs_1.default.existsSync(tempPidPath)) {
+                        throw new Error('Failed to create temporary PID file on retry');
+                    }
+                    const tempFd = fs_1.default.openSync(tempPidPath, 'r');
+                    fs_1.default.fsyncSync(tempFd);
+                    fs_1.default.closeSync(tempFd);
+                    fs_1.default.renameSync(tempPidPath, pidPath);
+                }
+                catch (retryError) {
+                    // If we still can't write the PID file, but the process is running,
+                    // we can still consider it a success
+                    try {
+                        process.kill(pid, 0);
+                        console.log(chalk_1.default.yellow(`VM "${name}" started successfully but PID file could not be written`));
+                        console.log(chalk_1.default.yellow(`Process is running with PID: ${pid}`));
+                        return;
+                    }
+                    catch (killError) {
+                        throw new Error(`Failed to write PID file after cleanup: ${retryError.message}`);
+                    }
+                }
+            }
+        }
+        else {
+            // If we can't write the PID file but the process is running, consider it a success
+            try {
+                process.kill(pid, 0);
+                console.log(chalk_1.default.yellow(`VM "${name}" started successfully but PID file could not be written`));
+                console.log(chalk_1.default.yellow(`Process is running with PID: ${pid}`));
+                return;
+            }
+            catch (killError) {
+                throw new Error(`Failed to write PID file: ${error.message}`);
+            }
+        }
+    }
+    // Now that we have the PID, generate the real args with proper socket paths
+    const finalArgs = buildExactQemuArgs(config.arch, imageFile, diskFile, initramfsFile, memory, serialNumber, headless, pid);
+    // Log the actual command that should be used for debugging
+    const actualCommand = `${qemuBin} ${finalArgs.join(' ')}`;
+    fs_1.default.writeSync(logFile, `Actual command (with PID): ${actualCommand}\n\n`);
+    // Create socket paths with actual PID (not placeholder) and VM name
+    // Ensure pid is a valid value before using it
+    const safePid = pid || 'temp';
+    const vmName = path_1.default.basename(path_1.default.dirname(imageFile || '.'));
+    const monitorSocketPath = pid ? `/tmp/qemu-monitor-${vmName}-${safePid}.sock` : `/tmp/qemu-monitor-${vmName}-temp.sock`;
+    const serialSocketPath = pid ? `/tmp/qemu-serial-${vmName}-${safePid}.sock` : `/tmp/qemu-serial-${vmName}-temp.sock`;
+    // Unref the process so it can run in the background
+    qemuProcess.unref();
+    // Log the actual socket paths for debugging
+    fs_1.default.writeSync(logFile, `Monitor socket: ${monitorSocketPath}\n`);
+    fs_1.default.writeSync(logFile, `Serial socket: ${serialSocketPath}\n\n`);
+    // Log troubleshooting info
+    fs_1.default.writeSync(logFile, `To connect to this VM: phy vm shell ${name}\n`);
+    fs_1.default.writeSync(logFile, `Socket must exist at: ${serialSocketPath}\n\n`);
+    // Remove the existing dummy file creation that causes "Socket operation on non-socket" error
+    // QEMU will create the proper socket files when it starts up
+    try {
+        // If dummy socket files already exist from a previous run, delete them first
+        if (fs_1.default.existsSync(serialSocketPath)) {
+            fs_1.default.unlinkSync(serialSocketPath);
+        }
+        if (fs_1.default.existsSync(monitorSocketPath)) {
+            fs_1.default.unlinkSync(monitorSocketPath);
+        }
+        // Wait briefly for QEMU to start and potentially create the socket
+        console.log(chalk_1.default.blue(`Waiting for VM to initialize...`));
+        await new Promise(resolve => setTimeout(resolve, 2000));
+    }
+    catch (error) {
+        console.log(chalk_1.default.yellow(`Warning when cleaning up socket files: ${error.message}`));
+    }
+    console.log(chalk_1.default.green(`VM "${name}" started successfully`));
+    console.log(`To view logs: ${chalk_1.default.blue('phy vm logs')} ${name}`);
+    console.log(`To stop VM: ${chalk_1.default.blue('phy vm stop')} ${name}`);
+    // If headless, inform about shell access
+    if (headless) {
+        console.log(`To connect to console: ${chalk_1.default.blue('phy vm shell')} ${name}`);
+    }
+}
+/**
+ * Detects the host system architecture
+ */
+function getHostArch() {
+    const systemArch = process.arch;
+    if (systemArch === 'x64')
+        return 'amd64';
+    if (systemArch === 'arm64')
+        return 'arm64';
+    return 'amd64'; // Default fallback
+}
+/**
+ * Detects if running on macOS
+ */
+function isMacOS() {
+    return process.platform === 'darwin';
+}
+/**
+ * Gets the default network interface name on macOS
+ */
+function getDefaultMacInterface() {
+    if (!isMacOS()) {
+        return null; // Only applicable on macOS
+    }
+    try {
+        // Run the command to get the default route
+        const output = (0, child_process_1.execSync)('route -n get default | grep interface:').toString();
+        // Parse the output (e.g., "  interface: en8")
+        const match = output.match(/interface:\s*(\S+)/);
+        if (match && match[1]) {
+            console.log(chalk_1.default.blue(`Detected default network interface: ${match[1]}`));
+            return match[1];
+        }
+        console.log(chalk_1.default.yellow('Warning: Could not parse default interface from route command.'));
+        return null;
+    }
+    catch (error) {
+        console.log(chalk_1.default.yellow(`Warning: Failed to get default interface: ${error.message}`));
+        return null;
+    }
+}
+/**
+ * Builds QEMU command arguments to exactly match the original bash script
+ * Important: Each argument must be a separate array element without quotes
+ * Adds cross-architecture emulation support
+ */
+function buildExactQemuArgs(arch, imageFile, diskFile, initramfsFile, memory, serialNumber, headless, pid) {
+    const hostArch = getHostArch();
+    const isEmulated = arch !== hostArch;
+    const runningOnMac = isMacOS();
+    // Get VM name from the image file path
+    const vmName = path_1.default.basename(path_1.default.dirname(imageFile || '.'));
+    // Create socket paths with actual PID (not placeholder) and VM name
+    // Ensure pid is a valid value before using it
+    const safePid = pid || 'temp';
+    const monitorSocketPath = pid ? `/tmp/qemu-monitor-${vmName}-${safePid}.sock` : `/tmp/qemu-monitor-${vmName}-temp.sock`;
+    const serialSocketPath = pid ? `/tmp/qemu-serial-${vmName}-${safePid}.sock` : `/tmp/qemu-serial-${vmName}-temp.sock`;
+    // Ensure memory is valid and convert to string
+    const memoryStr = memory ? String(memory) : '2048';
+    // Function to generate network arguments based on platform
+    const getNetworkArgs = () => {
+        if (runningOnMac) {
+            const defaultInterface = getDefaultMacInterface();
+            if (defaultInterface) {
+                console.log(chalk_1.default.blue(`Using vmnet-bridged with interface: ${defaultInterface}`));
+                return [
+                    '-netdev', `vmnet-bridged,id=net0,ifname=${defaultInterface}`,
+                    '-device', 'virtio-net-pci,netdev=net0'
+                ];
+            }
+            else {
+                console.log(chalk_1.default.yellow('Warning: Falling back to default vmnet-bridged mode without specific interface.'));
+                return [
+                    '-netdev', 'vmnet-bridged,id=net0',
+                    '-device', 'virtio-net-pci,netdev=net0'
+                ];
+            }
+        }
+        else {
+            // Use user-mode networking on other platforms
+            return [
+                '-netdev', 'user,id=net0',
+                '-device', 'virtio-net-pci,netdev=net0'
+            ];
+        }
+    };
+    if (arch === 'amd64') {
+        // x86_64 architecture
+        const args = [
+            '-machine', 'q35',
+            '-cpu', isEmulated ? 'max' : 'host',
+            '-m', memoryStr,
+            '-smp', '4',
+            '-kernel', imageFile,
+            '-drive', `if=none,file=${diskFile},format=raw,id=hd0`,
+            '-device', 'virtio-blk-pci,drive=hd0',
+            ...getNetworkArgs(), // Add network args
+            '-append', 'root=/dev/vda rw console=ttyS0'
+        ];
+        // Add KVM acceleration if running on Ubuntu/Debian Linux
+        if (process.platform === 'linux') {
+            // Check if running on Ubuntu/Debian by looking for common files
+            const isUbuntuDebian = fs_1.default.existsSync('/etc/debian_version') ||
+                fs_1.default.existsSync('/etc/lsb-release') ||
+                process.env.DISTRIB_ID === 'Ubuntu';
+            if (isUbuntuDebian) {
+                args.push('-enable-kvm');
+            }
+        }
+        // Add initramfs if available
+        if (initramfsFile) {
+            args.push('-initrd', initramfsFile);
+        }
+        // Add serial number if available
+        if (serialNumber) {
+            args.push('-smbios', `type=1,serial=${serialNumber}`);
+        }
+        // Add monitor and serial sockets with actual paths
+        args.push('-monitor', `unix:${monitorSocketPath},server,nowait`);
+        args.push('-serial', `unix:${serialSocketPath},server,nowait`);
+        if (headless) {
+            args.push('-display', 'none', '-nographic');
+        }
+        else {
+            // Use appropriate display for the platform
+            if (isEmulated) {
+                if (runningOnMac) {
+                    // For macOS, use cocoa display
+                    args.push('-display', 'cocoa');
+                }
+                else {
+                    // For Linux and other platforms, try SDL
+                    args.push('-display', 'sdl');
+                }
+            }
+            else {
+                args.push('-display', 'sdl', '-device', 'virtio-gpu-pci');
+            }
+        }
+        // Always add device controllers
+        args.push('-device', 'qemu-xhci', '-device', 'usb-tablet', '-device', 'usb-kbd');
+        return args;
+    }
+    else { // arm64
+        // Build kernel command line arguments
+        let kernelAppend = 'root=/dev/vda rw console=ttyAMA0';
+        if (serialNumber) {
+            kernelAppend += ` phygrid.serial=${serialNumber}`;
+        }
+        const args = [
+            '-machine', isEmulated ? 'virt' : 'virt,accel=hvf,highmem=off',
+            '-cpu', isEmulated ? 'cortex-a72' : 'host',
+            '-m', memoryStr,
+            '-smp', '4',
+            '-kernel', imageFile,
+            '-initrd', initramfsFile,
+            '-drive', `if=none,file=${diskFile},format=raw,id=hd0`,
+            '-device', 'virtio-blk-pci,drive=hd0',
+            ...getNetworkArgs(), // Add network args
+            '-append', kernelAppend
+        ];
+        // For ARM64 virt machines, SMBIOS is not fully supported, so we pass the serial via kernel cmdline
+        // Keep SMBIOS as fallback in case future QEMU versions support it better
+        if (serialNumber) {
+            args.push('-smbios', `type=1,serial=${serialNumber}`);
+        }
+        // Add monitor and serial sockets with actual paths
+        args.push('-monitor', `unix:${monitorSocketPath},server,nowait`);
+        args.push('-serial', `unix:${serialSocketPath},server,nowait`);
+        if (headless) {
+            args.push('-display', 'none', '-nographic');
+        }
+        else {
+            // Use appropriate display for the platform and emulation mode
+            if (isEmulated) {
+                if (runningOnMac) {
+                    // For macOS emulating ARM, use cocoa display
+                    args.push('-display', 'cocoa', '-device', 'virtio-gpu-pci');
+                }
+                else {
+                    // For Linux and other platforms
+                    args.push('-display', 'sdl', '-device', 'virtio-gpu-pci');
+                }
+            }
+            else {
+                args.push('-device', 'virtio-gpu-gl-pci', '-display', 'cocoa,gl=es', '-device', 'virtio-gpu-pci');
+            }
+        }
+        args.push('-device', 'qemu-xhci', '-device', 'usb-tablet', '-device', 'usb-kbd');
+        return args;
+    }
+}
+/**
+ * Check if QEMU is installed and available, prioritizing phygrid/qemu-virgl on macOS aarch64
+ */
+async function checkQemuInstalled(qemuBin) {
+    if (qemuBin === 'qemu-system-aarch64' && isMacOS()) {
+        // macOS aarch64: Prioritize phygrid/qemu-virgl/qemu-virgl
+        try {
+            // Use the new helper for brew commands
+            (0, vm_1.runBrewCommandAsUser)(['ls', '--versions', 'phygrid/qemu-virgl/qemu-virgl']);
+            console.log(chalk_1.default.green('Found installed phygrid/qemu-virgl/qemu-virgl.'));
+            return true;
+        }
+        catch (phygridError) {
+            // phygrid/qemu-virgl/qemu-virgl is NOT installed. Check for standard qemu conflict.
+            try {
+                // Use the new helper for brew commands
+                (0, vm_1.runBrewCommandAsUser)(['ls', '--versions', 'qemu']);
+                // Standard qemu IS installed. Does it provide the binary?
+                try {
+                    await execPromise(`which ${qemuBin}`); // Keep execPromise for non-brew 'which'
+                    // Standard qemu is installed AND provides the binary - CONFLICT!
+                    throw new Error(`Conflict: Standard 'qemu' package provides ${qemuBin}. Please uninstall it ('brew uninstall qemu') and install the required 'phygrid/qemu-virgl/qemu-virgl' formula.`);
+                }
+                catch (whichError) {
+                    // Standard qemu installed, but doesn't provide the binary (unexpected?) or which failed.
+                }
+            }
+            catch (standardQemuError) {
+                // Standard qemu is also not installed. Good.
+            }
+        }
+    }
+    // Standard check using 'which' for non-macOS-aarch64 or as a fallback
+    return new Promise((resolve, reject) => {
+        (0, child_process_1.exec)(`which ${qemuBin}`, (error, stdout, stderr) => {
+            if (error) {
+                let message = `${qemuBin} is not installed or not in PATH.`;
+                if (qemuBin === 'qemu-system-aarch64' && isMacOS()) {
+                    message += ` Ensure 'phygrid/qemu-virgl/qemu-virgl' is installed via Homebrew.`;
+                }
+                reject(new Error(message));
+                return;
+            }
+            if (!(qemuBin === 'qemu-system-aarch64' && isMacOS())) {
+                console.log(chalk_1.default.green(`Found ${qemuBin} at: ${stdout.trim()}`));
+            }
+            resolve(true);
+        });
+    });
+}
+/**
+ * Attempts to install QEMU based on the current OS
+ */
+async function attemptQemuInstall(qemuBin) {
+    const platform = process.platform;
+    let targetPackageName;
+    let isPhygridFormula = false;
+    let manualInstallInstructions = `Please install ${qemuBin} manually.`;
+    if (platform === 'linux') {
+        // Determine Linux package name and manual instructions
+        try {
+            await execPromise('which apt-get');
+            if (qemuBin === 'qemu-system-x86_64') {
+                targetPackageName = 'qemu-system-x86';
+            }
+            else {
+                targetPackageName = 'qemu-system-arm qemu-efi-aarch64 qemu-system-aarch64';
+            }
+            manualInstallInstructions = `sudo apt-get update && sudo apt-get install -y ${targetPackageName.split(' ').join(' ')}`;
+        }
+        catch (e) {
+            try {
+                await execPromise('which yum');
+                if (qemuBin === 'qemu-system-x86_64') {
+                    targetPackageName = 'qemu-system-x86';
+                }
+                else {
+                    targetPackageName = 'qemu-system-aarch64';
+                }
+                manualInstallInstructions = `sudo yum install -y ${targetPackageName}`;
+            }
+            catch (e2) {
+                try {
+                    await execPromise('which pacman');
+                    targetPackageName = 'qemu';
+                    manualInstallInstructions = `sudo pacman -S ${targetPackageName}`;
+                }
+                catch (e3) {
+                    console.log(chalk_1.default.yellow('Could not detect Linux package manager for automatic installation'));
+                    return false;
+                }
+            }
+        }
+    }
+    else if (platform === 'darwin') {
+        // Determine macOS package name and handle potential conflicts
+        try {
+            await execPromise('which brew');
+            if (qemuBin === 'qemu-system-aarch64') {
+                targetPackageName = 'phygrid/qemu-virgl/qemu-virgl';
+                isPhygridFormula = true;
+                manualInstallInstructions = `1. brew tap phygrid/qemu-virgl\n2. brew install ${targetPackageName}`;
+                // Check for conflicting standard qemu
+                try {
+                    (0, vm_1.runBrewCommandAsUser)(['ls', '--versions', 'qemu']);
+                    console.log(chalk_1.default.yellow("Warning: Found standard 'qemu' package installed, which may conflict."));
+                    const { confirmUninstall } = await inquirer_1.default.prompt([{
+                            type: 'confirm',
+                            name: 'confirmUninstall',
+                            message: `To install ${targetPackageName}, the standard 'qemu' package must be uninstalled first. Uninstall 'qemu' now?`,
+                            default: false
+                        }]);
+                    if (confirmUninstall) {
+                        console.log(chalk_1.default.blue('Uninstalling standard qemu (as user)...'));
+                        (0, vm_1.runBrewCommandAsUser)(['uninstall', 'qemu']);
+                        console.log(chalk_1.default.green('Standard qemu uninstalled.'));
+                    }
+                    else {
+                        console.log(chalk_1.default.red("Installation aborted. Please manually uninstall 'qemu'."));
+                        return false;
+                    }
+                }
+                catch (e) { /* Standard qemu not found, ignore */ }
+            }
+            else { // x86_64 on macOS
+                targetPackageName = 'qemu';
+                manualInstallInstructions = `brew install ${targetPackageName}`;
+            }
+        }
+        catch (e) {
+            // Handle brew check/execution errors
+            if (e.message && e.message.includes('Failed to run brew command')) {
+                console.error(chalk_1.default.red(`Brew command failed: ${e.message}`));
+            }
+            else {
+                console.log(chalk_1.default.yellow('Homebrew (brew) command not found or failed. Ensure it is installed and in PATH.'));
+                console.log(chalk_1.default.blue('Visit https://brew.sh'));
+            }
+            return false;
+        }
+    }
+    else {
+        console.log(chalk_1.default.yellow(`Automatic installation not supported on ${platform}.`));
+        return false;
+    }
+    // Ensure we determined a package name
+    if (!targetPackageName) {
+        console.log(chalk_1.default.red('Internal error: Could not determine package name for installation.'));
+        return false;
+    }
+    // Confirm installation with user
+    const { confirmInstall } = await inquirer_1.default.prompt([{
+            type: 'confirm',
+            name: 'confirmInstall',
+            message: `${targetPackageName} is required but not installed. Install now?`,
+            default: true
+        }]);
+    if (!confirmInstall) {
+        console.log(chalk_1.default.yellow('Installation cancelled by user.'));
+        console.log(chalk_1.default.blue(`Manual instructions: ${manualInstallInstructions}`));
+        return false;
+    }
+    // Perform the installation
+    console.log(chalk_1.default.blue(`Attempting to install ${targetPackageName}...`));
+    try {
+        if (platform === 'darwin') {
+            // macOS installation (using helper)
+            if (isPhygridFormula) {
+                console.log(chalk_1.default.gray('Running: brew tap phygrid/qemu-virgl (as user)'));
+                (0, vm_1.runBrewCommandAsUser)(['tap', 'phygrid/qemu-virgl']);
+            }
+            console.log(chalk_1.default.gray(`Running: brew install ${targetPackageName} (as user)`));
+            (0, vm_1.runBrewCommandAsUser)(['install', targetPackageName]);
+        }
+        else {
+            // Linux installation (requires sudo directly)
+            console.log(chalk_1.default.gray(`Running: ${manualInstallInstructions}`));
+            await new Promise((resolve, reject) => {
+                // Execute the command string which includes sudo
+                const childProcess = (0, child_process_1.spawn)(manualInstallInstructions, { shell: true, stdio: 'inherit' });
+                childProcess.on('close', (code) => code === 0 ? resolve(true) : reject(new Error(`Installation failed with code ${code}`)));
+                childProcess.on('error', reject);
+            });
+        }
+        console.log(chalk_1.default.green(`Successfully initiated installation for ${targetPackageName}`));
+        // Verify installation (may take a moment for PATH to update)
+        console.log(chalk_1.default.blue('Verifying installation...'));
+        await new Promise(resolve => setTimeout(resolve, 1500)); // Brief pause
+        try {
+            await checkQemuInstalled(qemuBin);
+            console.log(chalk_1.default.green('Verification successful.'));
+            return true;
+        }
+        catch (e) {
+            console.log(chalk_1.default.red(`Installation done, but ${qemuBin} verification failed.`));
+            console.log(chalk_1.default.yellow(e.message || 'Unknown verification error.'));
+            console.log(chalk_1.default.yellow('Check PATH or try running the phy command again.'));
+            return false;
+        }
+    }
+    catch (error) {
+        console.log(chalk_1.default.red(`Failed to install ${targetPackageName}: ${error.message}`));
+        console.log(chalk_1.default.yellow('Please try the manual installation steps:'));
+        console.log(chalk_1.default.blue(manualInstallInstructions));
+        return false;
+    }
+}
+/**
+ * Promise-based wrapper for exec
+ */
+function execPromise(command) {
+    return new Promise((resolve, reject) => {
+        (0, child_process_1.exec)(command, (error, stdout, stderr) => {
+            if (error) {
+                // Log stderr for context if available
+                if (stderr) {
+                    // console.error(`Command failed: ${command}\nstderr: ${stderr.trim()}`);
+                }
+                reject(error);
+                return;
+            }
+            resolve(stdout.trim());
+        });
+    });
+}
+/**
+ * Starts one or more PhyOS VMs
+ */
+async function startVm(names, options) {
+    // Handle single name (for backward compatibility)
+    const vmNames = Array.isArray(names) ? names : [names];
+    if (vmNames.length === 0) {
+        throw new Error('At least one VM name is required');
+    }
+    // Check which VMs exist and which don't
+    const existingVms = [];
+    const missingVms = [];
+    const alreadyRunningVms = [];
+    vmNames.forEach(name => {
+        if (!(0, vm_1.vmExists)(name)) {
+            missingVms.push(name);
+        }
+        else if ((0, vm_1.isVmRunning)(name)) {
+            alreadyRunningVms.push(name);
+        }
+        else {
+            existingVms.push(name);
+        }
+    });
+    // Report status
+    if (missingVms.length > 0) {
+        console.error(chalk_1.default.red(`❗️ The following VMs were not found: ${missingVms.join(', ')}`));
+    }
+    if (alreadyRunningVms.length > 0) {
+        console.log(chalk_1.default.yellow(`⚠️  The following VMs are already running: ${alreadyRunningVms.join(', ')}`));
+    }
+    // If no VMs to start, exit
+    if (existingVms.length === 0) {
+        if (alreadyRunningVms.length > 0 && missingVms.length === 0) {
+            console.log(chalk_1.default.green('All specified VMs are already running'));
+            return;
+        }
+        throw new Error('No VMs found to start');
+    }
+    // Show what will be started
+    console.log(chalk_1.default.blue(`Starting ${existingVms.length} VM${existingVms.length > 1 ? 's' : ''}: ${existingVms.join(', ')}`));
+    // Start VMs sequentially to avoid resource conflicts
+    const startedVms = [];
+    const failedVms = [];
+    for (const name of existingVms) {
+        try {
+            console.log(chalk_1.default.blue(`\n[${startedVms.length + failedVms.length + alreadyRunningVms.length + 1}/${existingVms.length}] Starting VM: ${name}`));
+            // Double-check if VM is running before starting (in case it was started by another process)
+            if ((0, vm_1.isVmRunning)(name)) {
+                console.log(chalk_1.default.yellow(`VM "${name}" is already running`));
+                alreadyRunningVms.push(name);
+                continue;
+            }
+            await startSingleVm(name, options);
+            startedVms.push(name);
+            console.log(chalk_1.default.green(`✅ VM "${name}" started successfully`));
+        }
+        catch (error) {
+            // Check if the VM is actually running despite the error (race condition)
+            if ((0, vm_1.isVmRunning)(name)) {
+                console.log(chalk_1.default.yellow(`VM "${name}" is already running (detected after start attempt)`));
+                alreadyRunningVms.push(name);
+            }
+            else {
+                // Check if the process is running by trying to find it in the process list
+                // This handles cases where PID file operations failed but the VM is actually running
+                try {
+                    const config = (0, vm_1.readVmConfig)(name);
+                    const qemuBin = config.arch === 'amd64' ? 'qemu-system-x86_64' : 'qemu-system-aarch64';
+                    // Use ps to check if the QEMU process is running for this VM
+                    const psOutput = (0, child_process_1.execSync)(`ps aux | grep "${qemuBin}" | grep "${name}" | grep -v grep`, { encoding: 'utf8' });
+                    if (psOutput.trim()) {
+                        console.log(chalk_1.default.yellow(`VM "${name}" is running (detected via process list) but PID file is missing`));
+                        console.log(chalk_1.default.yellow(`This may be due to permission issues with PID file creation`));
+                        // Try to create the PID file manually
+                        if ((0, vm_1.createPidFileForRunningVm)(name)) {
+                            console.log(chalk_1.default.green(`✅ Successfully created PID file for VM "${name}"`));
+                        }
+                        else {
+                            console.log(chalk_1.default.yellow(`⚠️  Could not create PID file for VM "${name}" - VM status may be inconsistent`));
+                        }
+                        alreadyRunningVms.push(name);
+                    }
+                    else {
+                        console.error(chalk_1.default.red(`❗️ Failed to start VM "${name}": ${error.message}`));
+                        failedVms.push({ name, error: error.message });
+                    }
+                }
+                catch (psError) {
+                    // If we can't check the process list, fall back to the original error
+                    console.error(chalk_1.default.red(`❗️ Failed to start VM "${name}": ${error.message}`));
+                    failedVms.push({ name, error: error.message });
+                }
+            }
+        }
+    }
+    // Summary
+    console.log(chalk_1.default.blue('\n📊 Summary:'));
+    if (startedVms.length > 0) {
+        console.log(chalk_1.default.green(`✅ Successfully started ${startedVms.length} VM${startedVms.length > 1 ? 's' : ''}: ${startedVms.join(', ')}`));
+    }
+    if (alreadyRunningVms.length > 0) {
+        console.log(chalk_1.default.yellow(`⚠️  Already running: ${alreadyRunningVms.join(', ')}`));
+    }
+    if (failedVms.length > 0) {
+        console.log(chalk_1.default.red(`❌ Failed to start ${failedVms.length} VM${failedVms.length > 1 ? 's' : ''}: ${failedVms.map(f => f.name).join(', ')}`));
+    }
+    if (missingVms.length > 0) {
+        console.log(chalk_1.default.yellow(`⚠️  VMs not found: ${missingVms.join(', ')}`));
+    }
+    // Throw error if any operations failed
+    if (failedVms.length > 0 || missingVms.length > 0) {
+        throw new Error(`Some VM start operations failed or VMs were not found`);
+    }
+}
+//# sourceMappingURL=start.js.map