@phystack/cli 4.3.40-dev

package/dist/commands/vm/create.js

@@ -0,0 +1,718 @@
+"use strict";
+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.default = createVm;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const child_process_1 = require("child_process");
+const chalk_1 = __importDefault(require("chalk"));
+const uuid_1 = require("uuid");
+const rimraf_1 = require("rimraf");
+const vm_1 = require("../../utils/vm");
+/**
+ * Determines the architecture to use for the VM
+ * Returns the specified architecture if it's valid, or null if no valid arch was provided
+ */
+function validateArch(userArch) {
+    if (userArch) {
+        if (['amd64', 'arm64'].includes(userArch)) {
+            return userArch;
+        }
+        console.warn(chalk_1.default.yellow(`Unsupported architecture: ${userArch}, please choose a supported option`));
+    }
+    return null;
+}
+/**
+ * Detect the host system architecture
+ */
+function getHostArch() {
+    const systemArch = process.arch;
+    if (systemArch === 'x64')
+        return 'amd64';
+    if (systemArch === 'arm64')
+        return 'arm64';
+    console.warn(chalk_1.default.yellow(`Unusual host architecture detected: ${systemArch}`));
+    return 'amd64'; // Default to amd64 as fallback
+}
+/**
+ * Gets the download URL and version for PhyOS based on architecture
+ */
+async function getPhyOsDownloadUrl(arch, versionStr) {
+    // If a specific version is provided, use it directly (only if it's a valid string)
+    if (versionStr && typeof versionStr === 'string' && /^\d+\.\d+\.\d+$/.test(versionStr)) {
+        const url = `https://os.phygrid.com/phyos.${versionStr}.qemu${arch}.tar.gz`;
+        return { url, version: versionStr };
+    }
+    // Otherwise, use the short URL and follow redirects to get the latest version
+    const shortUrl = `https://qr.run/phyos-qemu${arch}-latest`;
+    console.log(chalk_1.default.blue(`Getting latest version URL from ${shortUrl}...`));
+    try {
+        // Use curl to follow redirect and get the final URL
+        const curlOutput = (0, child_process_1.execSync)(`curl -sI "${shortUrl}" | grep -i "^location:" | tail -n1`, { encoding: 'utf8' });
+        const redirectUrl = curlOutput.trim().split(/:\s+/)[1];
+        if (!redirectUrl) {
+            throw new Error('Failed to get redirect URL for PhyOS');
+        }
+        console.log(chalk_1.default.blue(`Redirect URL: ${redirectUrl}`));
+        // Extract version from the URL (format: phyos.1.2.3.qemuXXX.tar.gz)
+        const versionMatch = redirectUrl.match(/phyos\.([0-9]+\.[0-9]+\.[0-9]+)\.qemu/i);
+        if (!versionMatch || !versionMatch[1]) {
+            throw new Error(`Failed to extract version from URL: ${redirectUrl}`);
+        }
+        const version = versionMatch[1];
+        console.log(chalk_1.default.blue(`Detected version: ${version}`));
+        return { url: redirectUrl, version };
+    }
+    catch (error) {
+        console.error(chalk_1.default.red(`Error following redirect: ${error.message}`));
+        throw new Error(`Failed to determine latest PhyOS version: ${error.message}`);
+    }
+}
+/**
+ * Downloads a file using curl with progress bar
+ */
+function downloadWithCurl(url, outputPath) {
+    return new Promise((resolve, reject) => {
+        console.log(chalk_1.default.blue(`Downloading from ${url}...`));
+        // Create curl process 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(`curl exited with code ${code}`));
+            }
+        });
+        curl.on('error', (err) => {
+            reject(new Error(`Failed to execute curl: ${err.message}`));
+        });
+    });
+}
+/**
+ * Copy a file from source to destination
+ */
+function copyFile(sourcePath, destinationPath) {
+    fs_1.default.copyFileSync(sourcePath, destinationPath);
+}
+/**
+ * Extract tar file using system tar command
+ */
+function extractTarFile(tarFilePath, outputDir) {
+    return new Promise((resolve, reject) => {
+        console.log(chalk_1.default.blue(`Extracting ${path_1.default.basename(tarFilePath)} to ${outputDir}...`));
+        // Use system tar command which handles large files better than the Node.js tar library
+        const tar = (0, child_process_1.spawn)('tar', [
+            '-xzf', // Extract gzipped tar
+            tarFilePath, // Input file
+            '-C', outputDir // Output directory
+        ], {
+            stdio: ['ignore', 'inherit', 'inherit'] // Show output in terminal
+        });
+        tar.on('close', (code) => {
+            if (code === 0) {
+                resolve();
+            }
+            else {
+                reject(new Error(`tar extraction failed with code ${code}`));
+            }
+        });
+        tar.on('error', (err) => {
+            reject(new Error(`Failed to execute tar: ${err.message}`));
+        });
+    });
+}
+/**
+ * Gets the current disk size in GB
+ */
+function getCurrentDiskSizeGB(diskFilePath) {
+    if (!fs_1.default.existsSync(diskFilePath)) {
+        return 0;
+    }
+    const stats = fs_1.default.statSync(diskFilePath);
+    const sizeInBytes = stats.size;
+    const sizeInGB = sizeInBytes / (1024 * 1024 * 1024);
+    return Math.round(sizeInGB * 100) / 100; // Round to 2 decimal places
+}
+/**
+ * Expands the disk size using dd command
+ */
+function expandDiskSize(diskFilePath, targetSizeGB) {
+    return new Promise((resolve, reject) => {
+        console.log(chalk_1.default.blue(`Expanding disk to ${targetSizeGB}GB...`));
+        // Calculate the additional size needed in bytes
+        const currentSizeGB = getCurrentDiskSizeGB(diskFilePath);
+        const additionalSizeBytes = Math.ceil((targetSizeGB - currentSizeGB) * 1024 * 1024 * 1024);
+        if (additionalSizeBytes <= 0) {
+            resolve(); // No expansion needed
+            return;
+        }
+        // Use a more compatible dd command approach
+        // Calculate block size and count to avoid the '1m' format issue
+        const blockSize = 1024 * 1024; // 1MB in bytes
+        const count = Math.ceil(additionalSizeBytes / blockSize);
+        const dd = (0, child_process_1.spawn)('dd', [
+            'if=/dev/zero',
+            `bs=${blockSize}`,
+            `count=${count}`,
+            '>>',
+            diskFilePath
+        ], {
+            stdio: ['ignore', 'inherit', 'inherit'],
+            shell: true
+        });
+        dd.on('close', (code) => {
+            if (code === 0) {
+                console.log(chalk_1.default.green(`✅ Disk expanded to ${targetSizeGB}GB`));
+                resolve();
+            }
+            else {
+                reject(new Error(`dd command failed with code ${code}`));
+            }
+        });
+        dd.on('error', (err) => {
+            reject(new Error(`Failed to execute dd: ${err.message}`));
+        });
+    });
+}
+/**
+ * Downloads and extracts a PhyOS image
+ */
+async function downloadPhyOS(name, arch, versionStr) {
+    console.log(chalk_1.default.blue('Determining PhyOS version and download URL...'));
+    // Get the download URL and version
+    const { url, version: detectedVersion } = await getPhyOsDownloadUrl(arch, versionStr);
+    // Get paths for cache and target VM
+    const vmDir = (0, vm_1.getVmDir)(name);
+    const cacheTarPath = (0, vm_1.getPhyOsCachePath)(detectedVersion, arch, 'tar');
+    const cacheImagePath = (0, vm_1.getPhyOsCachePath)(detectedVersion, arch, 'image');
+    const cacheDiskPath = (0, vm_1.getPhyOsCachePath)(detectedVersion, arch, 'disk', 'zfs');
+    const cacheInitramfsPath = (0, vm_1.getPhyOsCachePath)(detectedVersion, arch, 'initramfs');
+    const tarFile = path_1.default.join(vmDir, `phyos.${detectedVersion}.qemu${arch}.tar.gz`);
+    const imageFile = path_1.default.join(vmDir, `phyos.${detectedVersion}.qemu${arch}.Image`);
+    const diskFile = path_1.default.join(vmDir, `phyos.${detectedVersion}.qemu${arch}.zfs`);
+    const initramfsFile = path_1.default.join(vmDir, `phyos.${detectedVersion}.qemu${arch}.cpio.gz`);
+    // Ensure the VM directory exists
+    if (!fs_1.default.existsSync(vmDir)) {
+        fs_1.default.mkdirSync(vmDir, { recursive: true });
+    }
+    // Check if we need to download or can use cache
+    let needsDownload = true;
+    let needsExtract = true;
+    // Check if cache has the files already
+    if (fs_1.default.existsSync(cacheImagePath) && fs_1.default.existsSync(cacheDiskPath) && fs_1.default.existsSync(cacheInitramfsPath)) {
+        console.log(chalk_1.default.green(`Found cached PhyOS ${detectedVersion} files, using cache...`));
+        needsDownload = false;
+        needsExtract = false;
+        // Copy files from cache to VM directory
+        console.log(chalk_1.default.blue('Copying files from cache to VM directory...'));
+        copyFile(cacheImagePath, imageFile);
+        copyFile(cacheDiskPath, diskFile);
+        copyFile(cacheInitramfsPath, initramfsFile);
+    }
+    // Check if we have the tar file but still need to extract
+    else if (fs_1.default.existsSync(cacheTarPath)) {
+        console.log(chalk_1.default.green(`Found cached PhyOS ${detectedVersion} tar file, extracting...`));
+        needsDownload = false;
+        // Copy tar file from cache to VM directory for extraction
+        copyFile(cacheTarPath, tarFile);
+    }
+    // Download if needed
+    if (needsDownload) {
+        // Download the tar.gz file using curl with progress bar
+        console.log(chalk_1.default.blue(`Downloading PhyOS ${detectedVersion}...`));
+        await downloadWithCurl(url, cacheTarPath);
+        // Verify the download was successful
+        if (!fs_1.default.existsSync(cacheTarPath) || fs_1.default.statSync(cacheTarPath).size === 0) {
+            throw new Error('Download failed or resulted in an empty file');
+        }
+        // Copy to VM directory for extraction
+        copyFile(cacheTarPath, tarFile);
+    }
+    // Extract if needed
+    if (needsExtract) {
+        console.log(chalk_1.default.green('Extracting files...'));
+        try {
+            // Extract the tar.gz file using system tar command
+            await extractTarFile(tarFile, vmDir);
+            // Check if the expected files exist after extraction
+            if (!fs_1.default.existsSync(imageFile) || !fs_1.default.existsSync(diskFile) || !fs_1.default.existsSync(initramfsFile)) {
+                console.error(chalk_1.default.red(`❗️Required files (${path_1.default.basename(imageFile)}, ${path_1.default.basename(diskFile)}, ${path_1.default.basename(initramfsFile)}) not found in the extracted archive at ${vmDir}`));
+                // Clean up potentially corrupt extraction? Maybe remove extracted files or vmDir?
+                try {
+                    if (fs_1.default.existsSync(imageFile))
+                        fs_1.default.unlinkSync(imageFile);
+                    if (fs_1.default.existsSync(diskFile))
+                        fs_1.default.unlinkSync(diskFile);
+                    if (fs_1.default.existsSync(initramfsFile))
+                        fs_1.default.unlinkSync(initramfsFile);
+                    // Consider removing tarFile as well if it came from cache but extraction failed
+                    // if (!needsDownload && fs.existsSync(tarFile)) fs.unlinkSync(tarFile);
+                }
+                catch (cleanupError) {
+                    console.warn(chalk_1.default.yellow(`Warning: Failed to clean up incomplete files: ${cleanupError.message}`));
+                }
+                throw new Error('Required files not found after extraction');
+            }
+            // Cache the extracted files
+            console.log(chalk_1.default.green('Caching extracted files for future use...'));
+            copyFile(imageFile, cacheImagePath);
+            copyFile(diskFile, cacheDiskPath);
+            copyFile(initramfsFile, cacheInitramfsPath); // Cache initramfs
+        }
+        catch (extractError) {
+            // Log extraction error and re-throw
+            console.error(chalk_1.default.red(`Error during extraction: ${extractError.message}`));
+            throw extractError; // Re-throw the error to be caught by the caller
+        }
+        finally {
+            // Clean up the downloaded tar file from the VM directory regardless of extraction success/failure
+            // unless it was copied from cache initially
+            if (needsDownload && fs_1.default.existsSync(tarFile)) {
+                try {
+                    fs_1.default.unlinkSync(tarFile);
+                }
+                catch (unlinkError) {
+                    console.warn(chalk_1.default.yellow(`Warning: Failed to remove temporary tar file ${tarFile}: ${unlinkError.message}`));
+                }
+            }
+        }
+    }
+    console.log(chalk_1.default.green(`PhyOS ${detectedVersion} ready in ${vmDir}`));
+    // Return paths to the main files
+    return { version: detectedVersion, imageFile, diskFile, initramfsFile }; // Return initramfs path
+}
+/**
+ * Creates a single VM with the specified parameters
+ */
+async function createSingleVm(vmName, arch, memory, headless, versionStr, serialNumber, storageGB) {
+    console.log(chalk_1.default.blue(`Creating VM: ${vmName}...`));
+    // Download and extract PhyOS
+    const downloadedFiles = await downloadPhyOS(vmName, arch, versionStr);
+    // Get the actual disk size for display
+    let actualDiskSizeGB = getCurrentDiskSizeGB(downloadedFiles.diskFile);
+    // Expand disk size if specified
+    if (storageGB !== undefined) {
+        console.log(chalk_1.default.blue(`Current disk size: ${actualDiskSizeGB}GB`));
+        if (storageGB < actualDiskSizeGB) {
+            throw new Error(`Cannot shrink disk size. Current size: ${actualDiskSizeGB}GB, requested: ${storageGB}GB. Please specify a size larger than or equal to ${actualDiskSizeGB}GB.`);
+        }
+        if (storageGB > actualDiskSizeGB) {
+            await expandDiskSize(downloadedFiles.diskFile, storageGB);
+            // Update the actual disk size for display
+            const finalDiskSizeGB = getCurrentDiskSizeGB(downloadedFiles.diskFile);
+            actualDiskSizeGB = finalDiskSizeGB;
+        }
+        // If storageGB === actualDiskSizeGB, no expansion needed
+    }
+    // Get timestamp for creation
+    const createdTime = new Date().toISOString();
+    // Create VM configuration (legacy, to maintain backward compatibility)
+    const vmConfig = {
+        name: vmName,
+        version: downloadedFiles.version,
+        arch,
+        memory,
+        image: path_1.default.basename(downloadedFiles.imageFile),
+        disk: path_1.default.basename(downloadedFiles.diskFile),
+        initramfs: path_1.default.basename(downloadedFiles.initramfsFile),
+        created: createdTime
+    };
+    // Save VM configuration (legacy format)
+    const configPath = (0, vm_1.getVmConfigPath)(vmName);
+    fs_1.default.writeFileSync(configPath, JSON.stringify(vmConfig, null, 2));
+    // Create and save VM settings with memory and serial in the new format
+    const vmSettings = {
+        memory,
+        serial: serialNumber,
+        arch,
+        version: downloadedFiles.version,
+        created: createdTime,
+        headless,
+        storage: storageGB
+    };
+    // Save settings to settings.json
+    const settingsPath = (0, vm_1.getVmSettingsPath)(vmName);
+    fs_1.default.writeFileSync(settingsPath, JSON.stringify(vmSettings, null, 2));
+    // For backward compatibility, also save serial to serial.txt
+    const serialPath = (0, vm_1.getVmSerialPath)(vmName);
+    fs_1.default.writeFileSync(serialPath, serialNumber);
+    return { version: downloadedFiles.version, actualDiskSizeGB };
+}
+/**
+ * Command to create one or more PhyOS VMs with interactive prompts for missing options
+ */
+async function createVm(name, options) {
+    try {
+        // Import inquirer dynamically since it's a heavy dependency
+        const inquirer = (await Promise.resolve().then(() => __importStar(require('inquirer')))).default;
+        // Ensure VM directory exists
+        (0, vm_1.ensureVmDir)();
+        // Parse count parameter (default to 1)
+        const count = options.count ? parseInt(options.count, 10) : 1;
+        if (isNaN(count) || count < 1 || count > 50) {
+            throw new Error('Count must be a number between 1 and 50');
+        }
+        // Get existing VMs for validation and suggestions
+        const existingVms = (0, vm_1.listVms)();
+        const vmNameValidator = (input) => {
+            if (!input || input.trim() === '') {
+                return 'VM name is required';
+            }
+            if (input.includes(' ')) {
+                return 'VM name cannot contain spaces';
+            }
+            if ((0, vm_1.vmExists)(input)) {
+                return `VM with name "${input}" already exists`;
+            }
+            return true;
+        };
+        // If name is not provided via command line, prompt for it
+        if (!name) {
+            const answers = await inquirer.prompt([
+                {
+                    type: 'input',
+                    name: 'name',
+                    message: count > 1 ? 'Enter a base name for the VMs:' : 'Enter a name for the VM:',
+                    validate: (input) => {
+                        if (!input || input.trim() === '') {
+                            return 'VM name is required';
+                        }
+                        if (input.includes(' ')) {
+                            return 'VM name cannot contain spaces';
+                        }
+                        // For multiple VMs, check if any of the suffixed names would conflict
+                        if (count > 1) {
+                            for (let i = 1; i <= count; i++) {
+                                const suffixedName = `${input}-${i}`;
+                                if ((0, vm_1.vmExists)(suffixedName)) {
+                                    return `VM with name "${suffixedName}" already exists`;
+                                }
+                            }
+                        }
+                        else {
+                            if ((0, vm_1.vmExists)(input)) {
+                                return `VM with name "${input}" already exists`;
+                            }
+                        }
+                        return true;
+                    }
+                }
+            ]);
+            name = answers.name;
+        }
+        else {
+            // Validate the base name and check for conflicts with suffixed names
+            if (count > 1) {
+                for (let i = 1; i <= count; i++) {
+                    const suffixedName = `${name}-${i}`;
+                    if ((0, vm_1.vmExists)(suffixedName)) {
+                        throw new Error(`VM with name "${suffixedName}" already exists`);
+                    }
+                }
+            }
+            else {
+                if (vmNameValidator(name) !== true) {
+                    throw new Error(typeof vmNameValidator(name) === 'string' ? vmNameValidator(name) : 'Invalid VM name');
+                }
+            }
+        }
+        console.log(chalk_1.default.blue(`Creating ${count} PhyOS VM${count > 1 ? 's' : ''} with base name: ${name}`));
+        // Prompt for architecture if not provided
+        let arch;
+        if (!options.arch) {
+            const hostArch = getHostArch();
+            const answers = await inquirer.prompt([
+                {
+                    type: 'list',
+                    name: 'arch',
+                    message: 'Select VM architecture (can be different from host):',
+                    default: hostArch,
+                    choices: [
+                        {
+                            name: `amd64 (x86_64) ${hostArch === 'amd64' ? '[Host Architecture]' : '[Emulated]'}`,
+                            value: 'amd64'
+                        },
+                        {
+                            name: `arm64 (AArch64) ${hostArch === 'arm64' ? '[Host Architecture]' : '[Emulated]'}`,
+                            value: 'arm64'
+                        }
+                    ]
+                }
+            ]);
+            arch = answers.arch;
+        }
+        else {
+            const validArch = validateArch(options.arch);
+            if (!validArch) {
+                throw new Error(`Unsupported architecture: ${options.arch}. Supported values are: amd64, arm64`);
+            }
+            arch = validArch;
+        }
+        const hostArch = getHostArch();
+        const isEmulated = arch !== hostArch;
+        console.log(chalk_1.default.blue(`Using architecture: ${arch}${isEmulated ? ' (emulated)' : ' (native)'}`));
+        // Force headless mode for cross-architecture emulation in both directions
+        const forceHeadless = isEmulated && ((arch === 'amd64' && hostArch === 'arm64') ||
+            (arch === 'arm64' && hostArch === 'amd64'));
+        // If we're going to force headless mode, inform the user
+        if (forceHeadless) {
+            console.log(chalk_1.default.yellow(`⚠️  Note: Cross-architecture emulation (${arch} on ${hostArch}) requires headless mode`));
+            console.log(chalk_1.default.yellow(`   This VM will be configured as headless automatically`));
+        }
+        // Prompt for version if not provided
+        let versionStr;
+        if (!options.phyosVersion) {
+            const answers = await inquirer.prompt([
+                {
+                    type: 'confirm',
+                    name: 'useLatest',
+                    message: 'Use latest PhyOS version?',
+                    default: true
+                },
+                {
+                    type: 'input',
+                    name: 'version',
+                    message: 'Enter specific PhyOS version (e.g. 5.0.127):',
+                    when: (answers) => !answers.useLatest,
+                    validate: (input) => {
+                        if (!input || !/^\d+\.\d+\.\d+$/.test(input)) {
+                            return 'Please enter a valid version number (format: X.Y.Z)';
+                        }
+                        return true;
+                    }
+                }
+            ]);
+            versionStr = answers.useLatest ? undefined : answers.version;
+        }
+        else {
+            versionStr = options.phyosVersion;
+        }
+        // Prompt for memory if not provided
+        let memory;
+        if (!options.memory) {
+            const answers = await inquirer.prompt([
+                {
+                    type: 'input',
+                    name: 'memory',
+                    message: 'Enter memory allocation in MB:',
+                    default: '2048',
+                    validate: (input) => {
+                        const mem = parseInt(input, 10);
+                        if (isNaN(mem) || mem < 512 || mem > 32768) {
+                            return 'Please enter a valid memory size between 512MB and 32GB';
+                        }
+                        return true;
+                    }
+                }
+            ]);
+            memory = parseInt(answers.memory, 10);
+        }
+        else {
+            memory = parseInt(options.memory, 10);
+            if (isNaN(memory) || memory < 512 || memory > 32768) {
+                throw new Error('Memory must be a number between 512MB and 32GB');
+            }
+        }
+        // Prompt for storage if not provided
+        let storageGB;
+        if (!options.storage) {
+            // For multiple VMs, don't prompt - use current image size
+            if (count > 1) {
+                storageGB = undefined; // Use current size, no expansion
+            }
+            else {
+                // Get the actual disk size for the default value
+                // We need to download/extract first to know the current size
+                const tempDownloadedFiles = await downloadPhyOS('temp', arch, versionStr);
+                const currentDiskSizeGB = getCurrentDiskSizeGB(tempDownloadedFiles.diskFile);
+                // Clean up temp files
+                const tempDir = (0, vm_1.getVmDir)('temp');
+                if (fs_1.default.existsSync(tempDir)) {
+                    (0, rimraf_1.rimrafSync)(tempDir);
+                }
+                const answers = await inquirer.prompt([
+                    {
+                        type: 'input',
+                        name: 'storage',
+                        message: 'Enter storage allocation in GB (press Enter to use current size):',
+                        default: String(currentDiskSizeGB),
+                        validate: (input) => {
+                            if (!input || input.trim() === '') {
+                                return true; // Allow empty input to use default
+                            }
+                            const storage = parseFloat(input);
+                            if (isNaN(storage) || storage < 1 || storage > 100) {
+                                return 'Please enter a valid storage size between 1GB and 100GB';
+                            }
+                            return true;
+                        }
+                    }
+                ]);
+                // If user left it empty or entered the same as current size, don't expand
+                if (!answers.storage || answers.storage.trim() === '' || parseFloat(answers.storage) === currentDiskSizeGB) {
+                    storageGB = undefined; // Use current size, no expansion
+                }
+                else {
+                    storageGB = parseFloat(answers.storage);
+                }
+            }
+        }
+        else {
+            storageGB = parseFloat(options.storage);
+            if (isNaN(storageGB) || storageGB < 1 || storageGB > 100) {
+                throw new Error('Storage must be a number between 1GB and 100GB');
+            }
+        }
+        // Determine headless mode setting
+        let headless;
+        // If x86 on ARM, force headless mode
+        if (forceHeadless) {
+            headless = true;
+        }
+        // Otherwise use options or default to non-headless
+        else if (options.headless !== undefined) {
+            headless = options.headless;
+        }
+        else {
+            headless = false; // Default to non-headless mode
+            console.log(chalk_1.default.yellow(`⚠️  VM will run with graphical interface (non-headless mode by default)`));
+            console.log(chalk_1.default.yellow(`   Use --headless flag to run without display`));
+        }
+        // Create VMs in a loop
+        const createdVms = [];
+        for (let i = 1; i <= count; i++) {
+            const vmName = count > 1 ? `${name}-${i}` : name;
+            const serialNumber = `PHY${(0, uuid_1.v4)().replace(/-/g, '').toUpperCase()}`;
+            console.log(chalk_1.default.blue(`\n[${i}/${count}] Generating unique serial number for ${vmName}: ${serialNumber}`));
+            try {
+                const result = await createSingleVm(vmName, arch, memory, headless, versionStr, serialNumber, storageGB);
+                createdVms.push({
+                    name: vmName,
+                    serial: serialNumber,
+                    version: result.version,
+                    diskSizeGB: result.actualDiskSizeGB
+                });
+                console.log(chalk_1.default.green(`✅ VM "${vmName}" created successfully!`));
+            }
+            catch (error) {
+                console.error(chalk_1.default.red(`❗️Failed to create VM "${vmName}": ${error.message}`));
+                // Attempt to clean up VM directory if creation failed
+                const vmDir = (0, vm_1.getVmDir)(vmName);
+                if (fs_1.default.existsSync(vmDir)) {
+                    try {
+                        (0, rimraf_1.rimrafSync)(vmDir);
+                        console.log(chalk_1.default.yellow(`Cleaned up incomplete VM directory: ${vmDir}`));
+                    }
+                    catch (cleanupError) {
+                        console.warn(chalk_1.default.yellow(`Warning: Failed to clean up VM directory ${vmDir}: ${cleanupError.message}`));
+                    }
+                }
+                // Continue with other VMs instead of exiting
+                continue;
+            }
+        }
+        if (createdVms.length === 0) {
+            throw new Error('Failed to create any VMs');
+        }
+        // Show success message(s)
+        if (count === 1) {
+            const vm = createdVms[0];
+            const startupInfo = headless
+                ? `\nSince this VM is in headless mode:
+- Use 'phy vm shell ${vm.name}' to connect to the console
+- Use 'phy vm logs ${vm.name}' to view logs`
+                : `\nTo view logs: phy vm logs ${vm.name}`;
+            console.log(chalk_1.default.green(`
+✅ PhyOS VM "${vm.name}" (v${vm.version}) has been successfully created!
+
+📋 VM Details:
+Memory allocated: ${memory}MB
+Storage allocated: ${vm.diskSizeGB}GB
+Architecture: ${arch}
+Headless mode: ${headless ? 'Yes' : 'No'}
+
+🚀 Next steps:
+1. Start the VM: ${chalk_1.default.cyan(`phy vm start ${vm.name}`)}
+2. Add the VM to Phygrid console using this serial number:
+
+🆔 Serial Number: ${chalk_1.default.bold(vm.serial)}
+
+💡 Use this serial number or the 6 letter provisioning code to connect the VM in the Phygrid console.${startupInfo}
+      `));
+        }
+        else {
+            // Multiple VMs success message
+            const startupInfo = headless
+                ? `\nSince these VMs are in headless mode:
+- Use 'phy vm shell <vm-name>' to connect to each console
+- Use 'phy vm logs <vm-name>' to view logs`
+                : `\nTo view logs: phy vm logs <vm-name>`;
+            console.log(chalk_1.default.green(`
+✅ Successfully created ${createdVms.length} PhyOS VM${createdVms.length > 1 ? 's' : ''}!
+
+📋 VM Details:
+Memory allocated: ${memory}MB (each)
+Storage allocated: ${createdVms[0].diskSizeGB}GB (each)
+Architecture: ${arch}
+Headless mode: ${headless ? 'Yes' : 'No'}
+
+🚀 Next steps:
+1. Start VMs using: ${chalk_1.default.cyan('phy vm start <vm-name>')}
+2. Add VMs to Phygrid console using their respective serial numbers:
+
+🆔 Serial Numbers:
+${createdVms.map(vm => `   ${chalk_1.default.bold(vm.name)}: ${chalk_1.default.bold(vm.serial)}`).join('\n')}
+
+💡 Use these serial numbers or the 6 letter provisioning codes to connect the VMs in the Phygrid console.${startupInfo}
+      `));
+        }
+    }
+    catch (error) {
+        console.error(chalk_1.default.red(`❗️There was an error: ${error.message}`));
+        throw error;
+    }
+}
+//# sourceMappingURL=create.js.map