@phystack/cli 5.0.3 → 5.1.0

package/dist/commands/vm/create.js

@@ -1,959 +0,0 @@
-"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 crypto_1 = __importDefault(require("crypto"));
-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}. Please wait while we verify the checksum...`));
-        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}`));
-        });
-    });
-}
-/**
- * Gets the SHA256 checksum URL for the tar file
- */
-function getSha256Url(tarUrl) {
-    return `${tarUrl}.sha256`;
-}
-/**
- * Verifies the SHA256 checksum of a file
- */
-async function verifySha256(filePath, sha256Path) {
-    try {
-        const sha256Content = fs_1.default.readFileSync(sha256Path, 'utf8').trim();
-        const expectedHash = sha256Content.split(/\s+/)[0].trim();
-        if (!expectedHash || expectedHash.length !== 64)
-            return false;
-        const fileBuffer = fs_1.default.readFileSync(filePath);
-        const hash = crypto_1.default.createHash('sha256');
-        hash.update(fileBuffer);
-        const actualHash = hash.digest('hex');
-        return actualHash.toLowerCase() === expectedHash.toLowerCase();
-    }
-    catch (error) {
-        console.warn(chalk_1.default.yellow(`Warning: Failed to verify SHA256 checksum: ${error.message}`));
-        return false;
-    }
-}
-/**
- * Computes and saves SHA256 hash for a file
- */
-function computeAndSaveSha256(filePath, sha256Path) {
-    return new Promise((resolve, reject) => {
-        const hash = crypto_1.default.createHash('sha256');
-        let fileStream;
-        try {
-            fileStream = fs_1.default.createReadStream(filePath, { highWaterMark: 1024 * 1024 }); // 1MB chunks
-        }
-        catch (error) {
-            console.warn(chalk_1.default.yellow(`Warning: Failed to create read stream for ${path_1.default.basename(filePath)}: ${error.message}`));
-            reject(error);
-            return;
-        }
-        fileStream.on('data', (chunk) => {
-            hash.update(chunk);
-        });
-        fileStream.on('end', () => {
-            try {
-                const computedHash = hash.digest('hex');
-                fs_1.default.writeFileSync(sha256Path, computedHash);
-                resolve();
-            }
-            catch (error) {
-                console.warn(chalk_1.default.yellow(`Warning: Failed to write SHA256 file for ${path_1.default.basename(filePath)}: ${error.message}`));
-                reject(error);
-            }
-        });
-        fileStream.on('error', (error) => {
-            console.warn(chalk_1.default.yellow(`Warning: Failed to compute SHA256 for ${path_1.default.basename(filePath)}: ${error.message}`));
-            reject(error);
-        });
-    });
-}
-/**
- * Verifies a file against its saved SHA256 hash (handles large files by reading in chunks)
- */
-function verifyFileSha256(filePath, sha256Path) {
-    return new Promise((resolve) => {
-        try {
-            if (!fs_1.default.existsSync(sha256Path)) {
-                resolve(false);
-                return;
-            }
-            const expectedHash = fs_1.default.readFileSync(sha256Path, 'utf8').trim();
-            if (!expectedHash || expectedHash.length !== 64) {
-                resolve(false);
-                return;
-            }
-            const hash = crypto_1.default.createHash('sha256');
-            const fileStream = fs_1.default.createReadStream(filePath);
-            fileStream.on('data', (chunk) => {
-                hash.update(chunk);
-            });
-            fileStream.on('end', () => {
-                const actualHash = hash.digest('hex');
-                resolve(actualHash.toLowerCase() === expectedHash.toLowerCase());
-            });
-            fileStream.on('error', () => {
-                resolve(false);
-            });
-        }
-        catch {
-            resolve(false);
-        }
-    });
-}
-/**
- * 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}...`));
-        let stderrOutput = '';
-        const tar = (0, child_process_1.spawn)('tar', [
-            '-xzf', // Extract gzipped tar
-            tarFilePath, // Input file
-            '-C', outputDir // Output directory
-        ], {
-            stdio: ['ignore', 'inherit', 'pipe']
-        });
-        tar.stderr?.on('data', (data) => {
-            stderrOutput += data.toString();
-            process.stderr.write(data);
-        });
-        tar.on('close', (code) => {
-            if (code === 0) {
-                resolve();
-            }
-            else {
-                const errorMsg = stderrOutput.trim()
-                    ? `tar extraction failed with code ${code}: ${stderrOutput.trim()}`
-                    : `tar extraction failed with code ${code}`;
-                reject(new Error(errorMsg));
-            }
-        });
-        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, retryCount = 0, silent = false) {
-    if (!silent) {
-        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 cacheSha256Path = `${cacheTarPath}.sha256`;
-    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)) {
-        if (!silent) {
-            console.log(chalk_1.default.green(`Found cached PhyOS ${detectedVersion} files, verifying checksums...`));
-        }
-        // Verify each cached file against its saved hash
-        const imageSha256Path = `${cacheImagePath}.sha256`;
-        const diskSha256Path = `${cacheDiskPath}.sha256`;
-        const initramfsSha256Path = `${cacheInitramfsPath}.sha256`;
-        const imageValid = await verifyFileSha256(cacheImagePath, imageSha256Path);
-        const diskValid = await verifyFileSha256(cacheDiskPath, diskSha256Path);
-        const initramfsValid = await verifyFileSha256(cacheInitramfsPath, initramfsSha256Path);
-        if (!imageValid || !diskValid || !initramfsValid) {
-            if (!silent) {
-                console.log(chalk_1.default.yellow(`Cached files verification failed, will redownload...`));
-            }
-            try {
-                if (fs_1.default.existsSync(cacheImagePath))
-                    fs_1.default.unlinkSync(cacheImagePath);
-                if (fs_1.default.existsSync(cacheDiskPath))
-                    fs_1.default.unlinkSync(cacheDiskPath);
-                if (fs_1.default.existsSync(cacheInitramfsPath))
-                    fs_1.default.unlinkSync(cacheInitramfsPath);
-                if (fs_1.default.existsSync(imageSha256Path))
-                    fs_1.default.unlinkSync(imageSha256Path);
-                if (fs_1.default.existsSync(diskSha256Path))
-                    fs_1.default.unlinkSync(diskSha256Path);
-                if (fs_1.default.existsSync(initramfsSha256Path))
-                    fs_1.default.unlinkSync(initramfsSha256Path);
-            }
-            catch (error) {
-                if (!silent) {
-                    console.warn(chalk_1.default.yellow(`Warning: Failed to remove invalid cache files: ${error.message}`));
-                }
-            }
-            // Continue to download/extract flow
-        }
-        else {
-            if (!silent) {
-                console.log(chalk_1.default.green('Checksum verification passed!'));
-                console.log(chalk_1.default.blue('Copying files from cache to VM directory...'));
-            }
-            needsDownload = false;
-            needsExtract = false;
-            // Copy 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, verifying checksum...`));
-        // Verify cached tar file
-        let isValid = false;
-        if (fs_1.default.existsSync(cacheSha256Path)) {
-            isValid = await verifySha256(cacheTarPath, cacheSha256Path);
-        }
-        else {
-            // Download SHA256 and verify
-            const sha256Url = getSha256Url(url);
-            try {
-                await downloadWithCurl(sha256Url, cacheSha256Path);
-                isValid = await verifySha256(cacheTarPath, cacheSha256Path);
-            }
-            catch {
-                isValid = false;
-            }
-        }
-        if (!isValid) {
-            console.log(chalk_1.default.yellow(`Cached tar file verification failed, will redownload...`));
-            try {
-                if (fs_1.default.existsSync(cacheTarPath))
-                    fs_1.default.unlinkSync(cacheTarPath);
-                if (fs_1.default.existsSync(cacheSha256Path))
-                    fs_1.default.unlinkSync(cacheSha256Path);
-            }
-            catch (error) {
-                console.warn(chalk_1.default.yellow(`Warning: Failed to remove invalid cache files: ${error.message}`));
-            }
-            needsDownload = true;
-        }
-        else {
-            console.log(chalk_1.default.green('Checksum verification passed!'));
-            needsDownload = false;
-            copyFile(cacheTarPath, tarFile);
-        }
-    }
-    // Download if needed
-    if (needsDownload) {
-        // Download SHA256 checksum file first to verify the file integrity
-        const sha256Url = getSha256Url(url);
-        await downloadWithCurl(sha256Url, cacheSha256Path);
-        // 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');
-        }
-        // Verify SHA256 checksum
-        console.log(chalk_1.default.blue('Verifying SHA256 checksum...'));
-        if (!(await verifySha256(cacheTarPath, cacheSha256Path))) {
-            // Delete invalid files and retry once
-            try {
-                if (fs_1.default.existsSync(cacheTarPath))
-                    fs_1.default.unlinkSync(cacheTarPath);
-                if (fs_1.default.existsSync(cacheSha256Path))
-                    fs_1.default.unlinkSync(cacheSha256Path);
-            }
-            catch (error) {
-                console.warn(chalk_1.default.yellow(`Warning: Failed to remove invalid files: ${error.message}`));
-            }
-            console.log(chalk_1.default.yellow('Checksum verification failed, redownloading...'));
-            await downloadWithCurl(sha256Url, cacheSha256Path);
-            await downloadWithCurl(url, cacheTarPath);
-            if (!(await verifySha256(cacheTarPath, cacheSha256Path))) {
-                throw new Error('SHA256 checksum verification failed after retry');
-            }
-        }
-        console.log(chalk_1.default.green('Checksum verification passed!'));
-        // 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 and compute their SHA256 hashes
-            console.log(chalk_1.default.green('Caching extracted files for future use...'));
-            copyFile(imageFile, cacheImagePath);
-            copyFile(diskFile, cacheDiskPath);
-            copyFile(initramfsFile, cacheInitramfsPath);
-            // Compute and save SHA256 hashes for verification (using streams for large files)
-            console.log(chalk_1.default.blue('Computing checksums for cached files...'));
-            try {
-                await computeAndSaveSha256(cacheImagePath, `${cacheImagePath}.sha256`);
-            }
-            catch (error) {
-                console.warn(chalk_1.default.yellow(`Warning: Failed to compute SHA256 for image file: ${error.message}`));
-            }
-            try {
-                await computeAndSaveSha256(cacheDiskPath, `${cacheDiskPath}.sha256`);
-            }
-            catch (error) {
-                console.warn(chalk_1.default.yellow(`Warning: Failed to compute SHA256 for disk file: ${error.message}`));
-            }
-            try {
-                await computeAndSaveSha256(cacheInitramfsPath, `${cacheInitramfsPath}.sha256`);
-            }
-            catch (error) {
-                console.warn(chalk_1.default.yellow(`Warning: Failed to compute SHA256 for initramfs file: ${error.message}`));
-            }
-        }
-        catch (extractError) {
-            // Check for corruption errors and retry once
-            const errorMsg = extractError.message.toLowerCase();
-            const isCorruption = errorMsg.includes('truncated') || errorMsg.includes('corrupt') ||
-                errorMsg.includes('gzip') || errorMsg.includes('invalid') ||
-                errorMsg.includes('unexpected end');
-            if (isCorruption && retryCount < 1) {
-                console.error(chalk_1.default.red(`Corrupted file detected: ${extractError.message}`));
-                console.log(chalk_1.default.yellow('Removing corrupted file and redownloading...'));
-                try {
-                    if (fs_1.default.existsSync(tarFile))
-                        fs_1.default.unlinkSync(tarFile);
-                    if (fs_1.default.existsSync(cacheTarPath))
-                        fs_1.default.unlinkSync(cacheTarPath);
-                    if (fs_1.default.existsSync(cacheSha256Path))
-                        fs_1.default.unlinkSync(cacheSha256Path);
-                }
-                catch (error) {
-                    console.warn(chalk_1.default.yellow(`Warning: Failed to remove corrupted files: ${error.message}`));
-                }
-                return downloadPhyOS(name, arch, versionStr, retryCount + 1);
-            }
-            console.error(chalk_1.default.red(`Error during extraction: ${extractError.message}`));
-            throw extractError;
-        }
-        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}`));
-                }
-            }
-        }
-    }
-    if (!silent) {
-        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, 0, true);
-                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 Phystack 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 Phystack 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 Phystack 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 Phystack console.${startupInfo}
-      `));
-        }
-    }
-    catch (error) {
-        console.error(chalk_1.default.red(`❗️There was an error: ${error.message}`));
-        throw error;
-    }
-}
-//# sourceMappingURL=create.js.map