genbox 1.0.198 → 1.0.199

package/dist/commands/destroy.js

@@ -43,6 +43,7 @@ const confirm_1 = __importDefault(require("@inquirer/confirm"));
 const select_1 = __importDefault(require("@inquirer/select"));
 const prompts = __importStar(require("@inquirer/prompts"));
 const ora_1 = __importDefault(require("ora"));
+const child_process_1 = require("child_process");
 const api_1 = require("../api");
 const genbox_selector_1 = require("../genbox-selector");
 const ssh_config_1 = require("../ssh-config");
@@ -260,10 +261,51 @@ async function handleBulkDelete(options) {
         }
     }
     // Delete local genboxes
+    const sessionManager = (0, unified_session_1.getUnifiedSessionManager)();
     for (const session of selectedLocalSessions) {
         const spinner = (0, ora_1.default)(`Destroying ${session.name} (local)...`).start();
         try {
-            await provisioner.destroy(session.id);
+            // Check if this is a UnifiedSessionManager session (wizard-created VM)
+            const unifiedSession = sessionManager.getSession(session.id);
+            if (unifiedSession) {
+                // Delete the actual VM/container based on type
+                if (unifiedSession.type === 'multipass') {
+                    const vmName = unifiedSession.infrastructure?.vmName || unifiedSession.name;
+                    try {
+                        (0, child_process_1.execSync)(`multipass delete ${vmName} --purge`, { stdio: 'pipe' });
+                    }
+                    catch {
+                        // VM might already be deleted
+                    }
+                }
+                else if (unifiedSession.type === 'docker') {
+                    // Try containerId first, then fall back to container name
+                    const containerId = unifiedSession.infrastructure?.containerId;
+                    const containerName = unifiedSession.infrastructure?.containerName || unifiedSession.name;
+                    if (containerId) {
+                        try {
+                            (0, child_process_1.execSync)(`docker rm -f ${containerId}`, { stdio: 'pipe' });
+                        }
+                        catch {
+                            // Container might already be deleted
+                        }
+                    }
+                    else if (containerName) {
+                        try {
+                            (0, child_process_1.execSync)(`docker rm -f ${containerName}`, { stdio: 'pipe' });
+                        }
+                        catch {
+                            // Container might not exist or already be deleted
+                        }
+                    }
+                }
+                // Delete from UnifiedSessionManager
+                await sessionManager.deleteSession(session.id);
+            }
+            else {
+                // Fallback to LocalGenboxProvisioner for legacy sessions
+                await provisioner.destroy(session.id);
+            }
             spinner.succeed(chalk_1.default.green(`Destroyed '${session.name}' (local)`));
             successCount++;
         }

package/dist/lib/genbox-wizard.js

@@ -42,6 +42,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.promptForSize = promptForSize;
 exports.showDirectModeWarning = showDirectModeWarning;
 exports.promptForLocation = promptForLocation;
 exports.promptForName = promptForName;
@@ -61,6 +62,285 @@ const genbox_progress_1 = require("./genbox-progress");
 const ssh_keys_1 = require("../utils/ssh-keys");
 const config_store_1 = require("../config-store");
 const unified_session_1 = require("./unified-session");
+const VM_SIZE_REQUIREMENTS = {
+    small: {
+        cpus: 2,
+        memoryGB: 4,
+        diskGB: 20,
+        label: 'Small',
+        description: 'Basic development tasks',
+    },
+    medium: {
+        cpus: 4,
+        memoryGB: 8,
+        diskGB: 40,
+        label: 'Medium',
+        description: 'Standard development',
+    },
+    large: {
+        cpus: 6,
+        memoryGB: 12,
+        diskGB: 60,
+        label: 'Large',
+        description: 'Heavy workloads, multiple services',
+    },
+    xl: {
+        cpus: 8,
+        memoryGB: 16,
+        diskGB: 80,
+        label: 'XL',
+        description: 'Intensive tasks, large projects',
+    },
+};
+const DOCKER_SIZE_REQUIREMENTS = {
+    small: {
+        cpus: 1,
+        memoryGB: 2,
+        diskGB: 5,
+        label: 'Small',
+        description: 'Basic development tasks',
+    },
+    medium: {
+        cpus: 2,
+        memoryGB: 4,
+        diskGB: 10,
+        label: 'Medium',
+        description: 'Standard development',
+    },
+    large: {
+        cpus: 4,
+        memoryGB: 8,
+        diskGB: 20,
+        label: 'Large',
+        description: 'Heavy workloads',
+    },
+    xl: {
+        cpus: 6,
+        memoryGB: 12,
+        diskGB: 30,
+        label: 'XL',
+        description: 'Intensive tasks',
+    },
+};
+/**
+ * Get current system resources
+ */
+function getSystemResources() {
+    const cpuCores = os.cpus().length;
+    const totalMemoryGB = Math.round(os.totalmem() / (1024 * 1024 * 1024) * 10) / 10;
+    // Get available memory (platform-specific)
+    let availableMemoryGB;
+    if (process.platform === 'darwin') {
+        try {
+            // On macOS, use vm_stat for more accurate available memory
+            const vmStat = (0, child_process_1.execSync)('vm_stat', { encoding: 'utf8' });
+            const pageSize = 16384; // Default page size on Apple Silicon
+            const freeMatch = vmStat.match(/Pages free:\s+(\d+)/);
+            const inactiveMatch = vmStat.match(/Pages inactive:\s+(\d+)/);
+            const speculativeMatch = vmStat.match(/Pages speculative:\s+(\d+)/);
+            const freePages = parseInt(freeMatch?.[1] || '0', 10);
+            const inactivePages = parseInt(inactiveMatch?.[1] || '0', 10);
+            const speculativePages = parseInt(speculativeMatch?.[1] || '0', 10);
+            const reclaimableBytes = (freePages + inactivePages + speculativePages) * pageSize;
+            availableMemoryGB = Math.round(reclaimableBytes / (1024 * 1024 * 1024) * 10) / 10;
+        }
+        catch {
+            availableMemoryGB = Math.round(os.freemem() / (1024 * 1024 * 1024) * 10) / 10;
+        }
+    }
+    else {
+        availableMemoryGB = Math.round(os.freemem() / (1024 * 1024 * 1024) * 10) / 10;
+    }
+    // Get available disk space
+    let diskSpaceGB = 0;
+    try {
+        if (process.platform === 'darwin' || process.platform === 'linux') {
+            const df = (0, child_process_1.execSync)('df -k / | tail -1', { encoding: 'utf8' });
+            const parts = df.trim().split(/\s+/);
+            const availableKb = parseInt(parts[3], 10);
+            diskSpaceGB = Math.round(availableKb / (1024 * 1024) * 10) / 10;
+        }
+    }
+    catch {
+        diskSpaceGB = 50; // Assume 50GB if we can't detect
+    }
+    // Check Docker status
+    let dockerRunning = false;
+    try {
+        (0, child_process_1.execSync)('docker info', { stdio: 'pipe' });
+        dockerRunning = true;
+    }
+    catch {
+        dockerRunning = false;
+    }
+    // Check Multipass status
+    let multipassRunning = false;
+    try {
+        (0, child_process_1.execSync)('multipass version', { stdio: 'pipe' });
+        multipassRunning = true;
+    }
+    catch {
+        multipassRunning = false;
+    }
+    // Count existing VMs
+    let existingVms = 0;
+    try {
+        const vmList = (0, child_process_1.execSync)('multipass list --format json 2>/dev/null', { encoding: 'utf8' });
+        const vms = JSON.parse(vmList);
+        existingVms = vms.list?.length || 0;
+    }
+    catch {
+        existingVms = 0;
+    }
+    // Count existing Docker containers (genbox-related)
+    let existingContainers = 0;
+    try {
+        const containerList = (0, child_process_1.execSync)('docker ps -a --filter "name=genbox" --format "{{.Names}}" 2>/dev/null', { encoding: 'utf8' });
+        existingContainers = containerList.trim().split('\n').filter(Boolean).length;
+    }
+    catch {
+        existingContainers = 0;
+    }
+    return {
+        cpuCores,
+        totalMemoryGB,
+        availableMemoryGB,
+        diskSpaceGB,
+        dockerRunning,
+        multipassRunning,
+        existingVms,
+        existingContainers,
+    };
+}
+/**
+ * Format bytes to human-readable string
+ */
+function formatGB(gb) {
+    return `${gb.toFixed(1)} GB`;
+}
+/**
+ * Prompt user to select a genbox size
+ */
+async function promptForSize(type, resources) {
+    const sizeRequirements = type === 'vm' ? VM_SIZE_REQUIREMENTS : DOCKER_SIZE_REQUIREMENTS;
+    console.log('');
+    console.log(chalk_1.default.cyan('  Select a size for your genbox:'));
+    console.log('');
+    try {
+        const choices = Object.entries(sizeRequirements).map(([size, req]) => {
+            // Check if system has enough resources
+            const hasEnoughMemory = resources.totalMemoryGB >= req.memoryGB * 1.5;
+            const hasEnoughCpus = resources.cpuCores >= req.cpus + 1;
+            const hasEnoughDisk = resources.diskSpaceGB >= req.diskGB;
+            const canFit = hasEnoughMemory && hasEnoughCpus && hasEnoughDisk;
+            const warning = !canFit ? chalk_1.default.yellow(' ⚠') : '';
+            const disabled = resources.totalMemoryGB < req.memoryGB || resources.cpuCores < req.cpus;
+            return {
+                name: `${req.label}${warning} ${chalk_1.default.dim(`(${req.cpus} CPU, ${req.memoryGB}GB RAM, ${req.diskGB}GB disk)`)} ${chalk_1.default.dim('- ' + req.description)}`,
+                value: size,
+                disabled: disabled ? chalk_1.default.red('(insufficient resources)') : false,
+            };
+        });
+        const selected = await (0, select_1.default)({
+            message: 'Size:',
+            choices,
+        });
+        return selected;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Show resource summary and get user confirmation before creating local genbox
+ */
+async function confirmResourceUsage(type, resources, size = 'small') {
+    const sizeRequirements = type === 'vm' ? VM_SIZE_REQUIREMENTS : DOCKER_SIZE_REQUIREMENTS;
+    const requirements = sizeRequirements[size];
+    const warnings = [];
+    const isVm = type === 'vm';
+    console.log('');
+    console.log(chalk_1.default.blue('═══════════════════════════════════════════════════════════'));
+    console.log(chalk_1.default.blue.bold(`  ${isVm ? 'Multipass VM' : 'Docker Container'} Resource Requirements`));
+    console.log(chalk_1.default.blue('═══════════════════════════════════════════════════════════'));
+    console.log('');
+    // Show what will be allocated
+    console.log(chalk_1.default.cyan('  This genbox will use:'));
+    console.log(`    CPUs:    ${chalk_1.default.yellow(requirements.cpus)} cores`);
+    console.log(`    Memory:  ${chalk_1.default.yellow(formatGB(requirements.memoryGB))}`);
+    console.log(`    Disk:    ${chalk_1.default.yellow(formatGB(requirements.diskGB))}`);
+    console.log('');
+    // Show current system state
+    console.log(chalk_1.default.cyan('  Your system:'));
+    console.log(`    CPUs:           ${chalk_1.default.green(resources.cpuCores)} cores`);
+    console.log(`    Total Memory:   ${chalk_1.default.green(formatGB(resources.totalMemoryGB))}`);
+    console.log(`    Free Memory:    ${resources.availableMemoryGB < requirements.memoryGB ? chalk_1.default.red(formatGB(resources.availableMemoryGB)) : chalk_1.default.green(formatGB(resources.availableMemoryGB))}`);
+    console.log(`    Free Disk:      ${resources.diskSpaceGB < requirements.diskGB ? chalk_1.default.red(formatGB(resources.diskSpaceGB)) : chalk_1.default.green(formatGB(resources.diskSpaceGB))}`);
+    if (isVm && resources.existingVms > 0) {
+        console.log(`    Existing VMs:   ${chalk_1.default.yellow(resources.existingVms)}`);
+    }
+    if (!isVm && resources.existingContainers > 0) {
+        console.log(`    Existing Containers: ${chalk_1.default.yellow(resources.existingContainers)}`);
+    }
+    console.log('');
+    // Check for issues
+    if (resources.availableMemoryGB < requirements.memoryGB) {
+        warnings.push(`Low memory: ${formatGB(resources.availableMemoryGB)} available, ${formatGB(requirements.memoryGB)} needed`);
+    }
+    if (resources.diskSpaceGB < requirements.diskGB) {
+        warnings.push(`Low disk space: ${formatGB(resources.diskSpaceGB)} available, ${formatGB(requirements.diskGB)} needed`);
+    }
+    if (resources.cpuCores < requirements.cpus + 2) {
+        warnings.push(`Limited CPUs: ${resources.cpuCores} cores total, allocating ${requirements.cpus} may slow your system`);
+    }
+    if (isVm && !resources.multipassRunning) {
+        warnings.push('Multipass is not installed');
+    }
+    if (!isVm && !resources.dockerRunning) {
+        warnings.push('Docker is not running');
+    }
+    // Show warnings if any
+    if (warnings.length > 0) {
+        console.log(chalk_1.default.yellow('  ⚠️  Warnings:'));
+        for (const warning of warnings) {
+            console.log(chalk_1.default.yellow(`    • ${warning}`));
+        }
+        console.log('');
+    }
+    // Block creation if critical resources missing
+    if ((isVm && !resources.multipassRunning) || (!isVm && !resources.dockerRunning)) {
+        console.log(chalk_1.default.red(`  ✗ Cannot create ${isVm ? 'VM' : 'container'}: ${isVm ? 'Multipass' : 'Docker'} is not available.`));
+        if (isVm) {
+            console.log(chalk_1.default.dim('    Install from: https://canonical.com/multipass/install'));
+        }
+        else {
+            console.log(chalk_1.default.dim('    Start Docker Desktop or run: sudo systemctl start docker'));
+        }
+        console.log('');
+        return { confirmed: false, cancelled: false };
+    }
+    // Block if truly insufficient resources
+    if (resources.diskSpaceGB < requirements.diskGB * 0.5) {
+        console.log(chalk_1.default.red('  ✗ Insufficient disk space. Please free up disk space before creating a genbox.'));
+        console.log('');
+        return { confirmed: false, cancelled: false };
+    }
+    console.log(chalk_1.default.blue('═══════════════════════════════════════════════════════════'));
+    console.log('');
+    // Ask for confirmation
+    try {
+        const proceed = await (0, prompts_1.confirm)({
+            message: warnings.length > 0
+                ? 'Continue despite warnings?'
+                : 'Create this genbox?',
+            default: warnings.length === 0,
+        });
+        return { confirmed: proceed, cancelled: false };
+    }
+    catch {
+        return { confirmed: false, cancelled: true };
+    }
+}
 /**
  * Get SSH key paths
  */
@@ -298,12 +578,22 @@ function showProgress(status, elapsed, percent) {
  * Create a local Docker genbox
  */
 async function createLocalDockerGenbox(name, provider = 'claude') {
-    // Check Docker availability
-    if (!isDockerAvailable()) {
-        console.log(chalk_1.default.red('\nDocker is not running.'));
-        console.log(chalk_1.default.dim('Please start Docker Desktop and try again.'));
-        return { success: false, error: 'Docker not available' };
+    // Get system resources
+    const resources = getSystemResources();
+    // Prompt for size selection
+    const selectedSize = await promptForSize('docker', resources);
+    if (!selectedSize) {
+        return { success: false, error: 'Cancelled' };
+    }
+    // Show resource summary and get confirmation
+    const { confirmed, cancelled } = await confirmResourceUsage('docker', resources, selectedSize);
+    if (cancelled) {
+        return { success: false, error: 'Cancelled' };
+    }
+    if (!confirmed) {
+        return { success: false, error: 'Resource check failed or user declined' };
     }
+    const sizeReqs = DOCKER_SIZE_REQUIREMENTS[selectedSize];
     const startTime = Date.now();
     showProgress('Creating Docker container', 0, 10);
     try {
@@ -330,6 +620,7 @@ async function createLocalDockerGenbox(name, provider = 'claude') {
         console.log(chalk_1.default.dim('───────────────────────────────────────────────'));
         console.log(`  ${chalk_1.default.bold('Name:')}      ${session.name}`);
         console.log(`  ${chalk_1.default.bold('Type:')}      Docker container`);
+        console.log(`  ${chalk_1.default.bold('Size:')}      ${sizeReqs.label} (${sizeReqs.cpus} CPU, ${sizeReqs.memoryGB}GB RAM)`);
         console.log(`  ${chalk_1.default.bold('Provider:')}  ${provider}`);
         console.log(`  ${chalk_1.default.bold('Status:')}    ${chalk_1.default.green('running')}`);
         console.log(chalk_1.default.dim('───────────────────────────────────────────────'));
@@ -355,12 +646,22 @@ async function createLocalDockerGenbox(name, provider = 'claude') {
  * Create a local VM genbox (Multipass)
  */
 async function createLocalVmGenbox(name, provider = 'claude') {
-    // Check Multipass availability
-    if (!isMultipassAvailable()) {
-        console.log(chalk_1.default.red('\nMultipass is not installed.'));
-        console.log(chalk_1.default.dim('Install from: https://canonical.com/multipass/install'));
-        return { success: false, error: 'Multipass not available' };
+    // Get system resources
+    const resources = getSystemResources();
+    // Prompt for size selection
+    const selectedSize = await promptForSize('vm', resources);
+    if (!selectedSize) {
+        return { success: false, error: 'Cancelled' };
+    }
+    // Show resource summary and get confirmation
+    const { confirmed, cancelled } = await confirmResourceUsage('vm', resources, selectedSize);
+    if (cancelled) {
+        return { success: false, error: 'Cancelled' };
+    }
+    if (!confirmed) {
+        return { success: false, error: 'Resource check failed or user declined' };
     }
+    const sizeReqs = VM_SIZE_REQUIREMENTS[selectedSize];
     const startTime = Date.now();
     // Progress stages with estimated percentages
     const stages = [
@@ -401,13 +702,13 @@ packages:
         // Write cloud-init to temp file
         const cloudInitPath = path.join(os.tmpdir(), `genbox-cloud-init-${name}.yaml`);
         fs.writeFileSync(cloudInitPath, cloudInitConfig);
-        // Create Multipass VM with cloud-init
+        // Create Multipass VM with cloud-init (using selected size)
         const vmProcess = (0, child_process_1.spawn)('multipass', [
             'launch',
             '--name', name,
-            '--cpus', '2',
-            '--memory', '4G',
-            '--disk', '20G',
+            '--cpus', String(sizeReqs.cpus),
+            '--memory', `${sizeReqs.memoryGB}G`,
+            '--disk', `${sizeReqs.diskGB}G`,
             '--cloud-init', cloudInitPath,
         ], {
             stdio: 'pipe',
@@ -490,6 +791,7 @@ packages:
         console.log(chalk_1.default.dim('───────────────────────────────────────────────'));
         console.log(`  ${chalk_1.default.bold('Name:')}      ${session.name}`);
         console.log(`  ${chalk_1.default.bold('Type:')}      Multipass VM`);
+        console.log(`  ${chalk_1.default.bold('Size:')}      ${sizeReqs.label} (${sizeReqs.cpus} CPU, ${sizeReqs.memoryGB}GB RAM, ${sizeReqs.diskGB}GB disk)`);
         console.log(`  ${chalk_1.default.bold('Provider:')}  ${provider}`);
         if (vmIp) {
             console.log(`  ${chalk_1.default.bold('IP:')}        ${vmIp}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "genbox",
-  "version": "1.0.198",
+  "version": "1.0.199",
   "description": "Genbox CLI - AI-Powered Development Environments",
   "main": "dist/index.js",
   "bin": {