genbox 1.0.99 → 1.0.101

package/dist/commands/cleanup-ssh.js

@@ -36,8 +36,9 @@ async function cleanupOrphanedSshConfigs(options = {}) {
         }
         throw error;
     }
-    // Get names of existing genboxes (both running and terminated but recent)
-    const existingNames = new Set(existingGenboxes.map(g => g.name));
+    // Keep SSH configs for any non-terminated genbox (running, error, provisioning, stopped)
+    const activeGenboxes = existingGenboxes.filter(g => g.status !== 'terminated');
+    const existingNames = new Set(activeGenboxes.map(g => g.name));
     // Find orphaned entries (SSH configs for genboxes that don't exist anymore)
     const orphaned = sshEntries.filter(name => !existingNames.has(name));
     if (orphaned.length === 0) {

package/dist/commands/extend.js

@@ -92,13 +92,18 @@ exports.extendCommand = new commander_1.Command('extend')
         spinner.stop();
         if (result.success) {
             console.log(chalk_1.default.green(`✓ ${result.message}`));
-            if (result.currentHourEnd) {
-                const endTime = new Date(result.currentHourEnd);
-                const minutesUntil = Math.ceil((endTime.getTime() - Date.now()) / (60 * 1000));
-                console.log(chalk_1.default.dim(`  Current hour ends in: ${minutesUntil} minutes`));
+            if (result.protectedUntil && result.autoDestroyEnabled) {
+                const protectedTime = new Date(result.protectedUntil);
+                const minutesUntil = Math.ceil((protectedTime.getTime() - Date.now()) / (60 * 1000));
+                const hoursUntil = Math.floor(minutesUntil / 60);
+                const remainingMins = minutesUntil % 60;
+                const timeStr = hoursUntil > 0
+                    ? `${hoursUntil}h ${remainingMins}m`
+                    : `${minutesUntil} min`;
+                console.log(chalk_1.default.dim(`  Protected from auto-destroy for: ${timeStr}`));
             }
             console.log(chalk_1.default.dim(`  Auto-destroy: ${result.autoDestroyEnabled ? 'enabled' : 'disabled'}`));
-            console.log(chalk_1.default.dim(`  Note: Credits charged at the end of each hour`));
+            console.log(chalk_1.default.dim(`  Note: Credits charged at the end of each billing hour`));
         }
         else {
             console.error(chalk_1.default.red(`Error: ${result.message}`));

package/dist/commands/profiles.js

@@ -337,3 +337,136 @@ exports.profilesCommand
         console.error(chalk_1.default.red(`Error: ${error.message}`));
     }
 });
+// Subcommand: profiles edit [name]
+exports.profilesCommand
+    .command('edit [name]')
+    .description('Interactively edit a profile')
+    .action(async (name) => {
+    try {
+        const configLoader = new config_loader_1.ConfigLoader();
+        const loadResult = await configLoader.load();
+        if (!loadResult.config) {
+            console.log(chalk_1.default.red('Not a genbox project'));
+            console.log(chalk_1.default.dim('No genbox.yaml found in current directory.'));
+            return;
+        }
+        const configVersion = (0, schema_v4_1.getConfigVersion)(loadResult.config);
+        if (configVersion === 'invalid') {
+            console.log(chalk_1.default.red('Unknown config version'));
+            return;
+        }
+        const config = loadResult.config;
+        const profiles = configLoader.listProfiles(config);
+        if (profiles.length === 0) {
+            console.log(chalk_1.default.yellow('No profiles defined'));
+            console.log(chalk_1.default.dim('Run "genbox profiles create" to create a profile first'));
+            return;
+        }
+        // If no name provided, let user select from list
+        let profileName = name;
+        if (!profileName) {
+            const profileChoices = profiles.map(p => ({
+                name: `${p.name}${p.description ? ` - ${p.description}` : ''}`,
+                value: p.name,
+            }));
+            profileName = await prompts.select({
+                message: 'Select profile to edit:',
+                choices: profileChoices,
+            });
+        }
+        // Check if profile exists
+        if (!config.profiles?.[profileName]) {
+            console.log(chalk_1.default.red(`Profile '${profileName}' not found in genbox.yaml`));
+            return;
+        }
+        const existingProfile = config.profiles[profileName];
+        console.log(chalk_1.default.blue(`\nEditing Profile: ${profileName}\n`));
+        // Description
+        const description = await prompts.input({
+            message: 'Description:',
+            default: existingProfile.description || '',
+        });
+        // Apps selection
+        const appChoices = Object.entries(config.apps)
+            .filter(([_, app]) => app.type !== 'library')
+            .map(([appName, app]) => ({
+            name: `${appName} (${app.type})`,
+            value: appName,
+            checked: existingProfile.apps?.includes(appName) ?? false,
+        }));
+        const selectedApps = await prompts.checkbox({
+            message: 'Select apps to include:',
+            choices: appChoices,
+        });
+        // Size
+        const currentSize = existingProfile.size || 'medium';
+        const size = await prompts.select({
+            message: 'Server size:',
+            choices: [
+                { name: 'Small', value: 'small' },
+                { name: 'Medium', value: 'medium' },
+                { name: 'Large', value: 'large' },
+                { name: 'XL', value: 'xl' },
+            ],
+            default: currentSize,
+        });
+        // Connect to environment
+        const currentConnection = existingProfile.default_connection || 'local';
+        const connectTo = await prompts.select({
+            message: 'How should dependencies be resolved?',
+            choices: [
+                { name: 'Include locally', value: 'local' },
+                { name: 'Connect to staging', value: 'staging' },
+                { name: 'Connect to production', value: 'production' },
+            ],
+            default: currentConnection,
+        });
+        // Database mode - determine current setting
+        let currentDbMode = 'none';
+        if (existingProfile.database) {
+            if (existingProfile.database.mode === 'local') {
+                currentDbMode = 'local';
+            }
+            else if (existingProfile.database.mode === 'copy') {
+                currentDbMode = `copy-${existingProfile.database.source || 'staging'}`;
+            }
+            else if (existingProfile.database.mode === 'remote') {
+                currentDbMode = `remote-${existingProfile.database.source || 'staging'}`;
+            }
+        }
+        const dbMode = await prompts.select({
+            message: 'Database mode:',
+            choices: [
+                { name: 'None', value: 'none' },
+                { name: 'Fresh (empty)', value: 'local' },
+                { name: 'Copy from staging', value: 'copy-staging' },
+                { name: 'Connect to staging', value: 'remote-staging' },
+            ],
+            default: currentDbMode,
+        });
+        // Build updated profile
+        const updatedProfile = {
+            description: description || undefined,
+            size: size,
+            apps: selectedApps,
+            default_connection: connectTo !== 'local' ? connectTo : undefined,
+            database: dbMode !== 'none' ? {
+                mode: dbMode.startsWith('copy') ? 'copy' : dbMode.startsWith('remote') ? 'remote' : 'local',
+                source: dbMode.includes('staging') ? 'staging' : dbMode.includes('production') ? 'production' : undefined,
+            } : undefined,
+        };
+        // Update and save
+        config.profiles[profileName] = updatedProfile;
+        const configPath = configLoader.getConfigPath();
+        const yamlContent = yaml.dump(config, { lineWidth: 120, noRefs: true });
+        fs.writeFileSync(configPath, yamlContent);
+        console.log(chalk_1.default.green(`\n✔ Profile '${profileName}' updated in genbox.yaml`));
+    }
+    catch (error) {
+        if (error.name === 'ExitPromptError') {
+            console.log(chalk_1.default.dim('\nCancelled.'));
+            return;
+        }
+        console.error(chalk_1.default.red(`Error: ${error.message}`));
+    }
+});

package/dist/commands/restart.js

@@ -0,0 +1,424 @@
+"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.restartCommand = void 0;
+const commander_1 = require("commander");
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+const api_1 = require("../api");
+const genbox_selector_1 = require("../genbox-selector");
+const child_process_1 = require("child_process");
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+function getPrivateSshKey() {
+    const home = os.homedir();
+    const potentialKeys = [
+        path.join(home, '.ssh', 'id_rsa'),
+        path.join(home, '.ssh', 'id_ed25519'),
+    ];
+    for (const keyPath of potentialKeys) {
+        if (fs.existsSync(keyPath)) {
+            return keyPath;
+        }
+    }
+    throw new Error('No SSH private key found in ~/.ssh/');
+}
+function sshExec(ip, keyPath, command, timeoutSecs = 30) {
+    const sshOpts = `-i ${keyPath} -o IdentitiesOnly=yes -o StrictHostKeyChecking=no -o UserKnownHostsFile=/dev/null -o LogLevel=ERROR -o ConnectTimeout=10`;
+    try {
+        const result = (0, child_process_1.execSync)(`ssh ${sshOpts} dev@${ip} "${command}"`, {
+            encoding: 'utf8',
+            timeout: timeoutSecs * 1000,
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        return { stdout: result.trim(), success: true };
+    }
+    catch (error) {
+        const output = error.stdout?.toString().trim() || error.stderr?.toString().trim() || '';
+        return { stdout: output, success: false };
+    }
+}
+exports.restartCommand = new commander_1.Command('restart')
+    .description('Restart apps and services in a genbox')
+    .argument('[name]', 'Name of the Genbox (optional - will auto-select or prompt)')
+    .option('-a, --all', 'Select from all genboxes (not just current project)')
+    .option('--pm2', 'Restart only PM2 processes')
+    .option('--docker', 'Restart only Docker containers')
+    .action(async (name, options) => {
+    try {
+        // Select genbox
+        const { genbox: target, cancelled } = await (0, genbox_selector_1.selectGenbox)(name, {
+            all: options.all,
+            selectMessage: 'Select a genbox to restart services:',
+        });
+        if (cancelled) {
+            console.log(chalk_1.default.dim('Cancelled.'));
+            return;
+        }
+        if (!target) {
+            return;
+        }
+        if (target.status !== 'running') {
+            console.error(chalk_1.default.red(`Error: Genbox '${target.name}' is not running (status: ${target.status})`));
+            return;
+        }
+        if (!target.ipAddress) {
+            console.error(chalk_1.default.red(`Error: Genbox '${target.name}' has no IP address`));
+            return;
+        }
+        // Get SSH key
+        let keyPath;
+        try {
+            keyPath = getPrivateSshKey();
+        }
+        catch (error) {
+            console.error(chalk_1.default.red(error.message));
+            return;
+        }
+        const restartPm2 = !options.docker || options.pm2;
+        const restartDocker = !options.pm2 || options.docker;
+        // Get app configurations from genbox
+        const appConfigs = target.appConfigs || [];
+        const workspace = target.workspace || 'app';
+        // Determine PM2 apps: explicitly set as pm2, OR frontend apps without docker config
+        const pm2Apps = appConfigs.filter(app => app.runner === 'pm2' ||
+            (!app.runner && !app.docker && (app.type === 'frontend' || ['admin', 'web', 'web-new'].includes(app.name))));
+        const dockerApps = appConfigs.filter(app => app.runner === 'docker' ||
+            (!app.runner && app.docker) ||
+            (!app.runner && app.type === 'backend'));
+        console.log(chalk_1.default.blue(`Restarting services on ${target.name}...`));
+        if (appConfigs.length > 0) {
+            console.log(chalk_1.default.dim(`  Apps: ${appConfigs.map(a => a.name).join(', ')}`));
+            console.log(chalk_1.default.dim(`  PM2 apps: ${pm2Apps.length > 0 ? pm2Apps.map(a => a.name).join(', ') : 'none detected'}`));
+            console.log(chalk_1.default.dim(`  Docker apps: ${dockerApps.length > 0 ? dockerApps.map(a => a.name).join(', ') : 'none detected'}`));
+        }
+        console.log('');
+        // Start/Restart PM2 processes
+        if (restartPm2) {
+            const pm2Spinner = (0, ora_1.default)('Checking PM2 processes...').start();
+            // First check if PM2 has any processes
+            const pm2Check = sshExec(target.ipAddress, keyPath, 'source ~/.nvm/nvm.sh 2>/dev/null; pm2 jlist 2>/dev/null || echo "[]"', 15);
+            try {
+                const processes = JSON.parse(pm2Check.stdout || '[]');
+                if (processes.length === 0 && pm2Apps.length > 0) {
+                    // No processes running but we have PM2 apps configured - start them
+                    pm2Spinner.text = `Starting ${pm2Apps.length} PM2 app${pm2Apps.length > 1 ? 's' : ''} from config...`;
+                    let startedCount = 0;
+                    const startedNames = [];
+                    for (const app of pm2Apps) {
+                        // Try to resolve the correct path - check multiple possible locations
+                        let appPath = app.path.startsWith('/') ? app.path : `~/${app.path}`;
+                        // Check if path exists, if not try common variations
+                        const pathCheck = sshExec(target.ipAddress, keyPath, `test -d ${appPath} && echo "found" || (test -d ~/${workspace}/${app.name} && echo "workspace" || (test -d ~/app/${app.name} && echo "app" || echo "notfound"))`, 5);
+                        if (pathCheck.stdout === 'workspace') {
+                            appPath = `~/${workspace}/${app.name}`;
+                        }
+                        else if (pathCheck.stdout === 'app') {
+                            appPath = `~/app/${app.name}`;
+                        }
+                        else if (pathCheck.stdout === 'notfound') {
+                            // Try to find the app directory
+                            const findResult = sshExec(target.ipAddress, keyPath, `find ~ -maxdepth 3 -type d -name "${app.name}" 2>/dev/null | head -1`, 10);
+                            if (findResult.stdout && findResult.stdout.trim()) {
+                                appPath = findResult.stdout.trim();
+                            }
+                        }
+                        const startCmd = app.commands?.dev || app.commands?.start || 'npm run dev';
+                        // For frontend apps with a configured port, add port argument
+                        // This is needed for frameworks like Next.js that accept -p/--port
+                        const portArg = app.port ? ` -- -p ${app.port}` : '';
+                        // Start the app with PM2
+                        // Parse the start command - if it's "npm run X", use pm2 start npm -- run X
+                        // If it's just a script name like "dev", treat it as npm run <script>
+                        let pm2Cmd;
+                        if (startCmd.startsWith('npm run ')) {
+                            const script = startCmd.replace('npm run ', '');
+                            pm2Cmd = `pm2 start npm --name "${app.name}" -- run ${script}${portArg}`;
+                        }
+                        else if (startCmd.startsWith('pnpm ')) {
+                            const script = startCmd.replace('pnpm ', '');
+                            pm2Cmd = `pm2 start pnpm --name "${app.name}" -- ${script}${portArg}`;
+                        }
+                        else if (startCmd.startsWith('yarn ')) {
+                            const script = startCmd.replace('yarn ', '');
+                            pm2Cmd = `pm2 start yarn --name "${app.name}" -- ${script}${portArg}`;
+                        }
+                        else if (startCmd.startsWith('bun ')) {
+                            const script = startCmd.replace('bun ', '');
+                            pm2Cmd = `pm2 start bun --name "${app.name}" -- ${script}${portArg}`;
+                        }
+                        else if (/^[a-z0-9:-]+$/.test(startCmd) && !startCmd.includes('/')) {
+                            // Single word like "dev", "start", "serve" - treat as npm script name
+                            pm2Cmd = `pm2 start npm --name "${app.name}" -- run ${startCmd}${portArg}`;
+                        }
+                        else {
+                            // Assume it's a direct script/file path
+                            pm2Cmd = `pm2 start "${startCmd}" --name "${app.name}"`;
+                        }
+                        pm2Spinner.text = `Starting ${app.name}...`;
+                        const fullCmd = `source ~/.nvm/nvm.sh 2>/dev/null; cd ${appPath} && ${pm2Cmd} 2>&1`;
+                        const startResult = sshExec(target.ipAddress, keyPath, fullCmd, 60);
+                        // Check for success indicators in PM2 output
+                        const isSuccess = startResult.success ||
+                            startResult.stdout.includes('Process successfully started') ||
+                            startResult.stdout.includes('[PM2] Done') ||
+                            startResult.stdout.includes('online');
+                        if (isSuccess) {
+                            startedCount++;
+                            startedNames.push(app.name);
+                        }
+                    }
+                    if (startedCount > 0) {
+                        pm2Spinner.succeed(chalk_1.default.green(`Started ${startedCount} PM2 process${startedCount > 1 ? 'es' : ''}`));
+                        console.log(chalk_1.default.dim(`  Processes: ${startedNames.join(', ')}`));
+                    }
+                    else {
+                        pm2Spinner.warn(chalk_1.default.yellow('Failed to start PM2 processes'));
+                    }
+                }
+                else if (processes.length === 0) {
+                    // No processes and no PM2 apps configured - try ecosystem file fallback
+                    pm2Spinner.text = 'No PM2 processes running, checking for ecosystem file...';
+                    // Search in common locations
+                    const ecosystemCheck = sshExec(target.ipAddress, keyPath, 'find ~ -maxdepth 3 -name "ecosystem.config.*" -o -name "pm2.config.js" 2>/dev/null | head -1', 10);
+                    if (ecosystemCheck.stdout && ecosystemCheck.stdout.trim()) {
+                        const ecosystemFile = ecosystemCheck.stdout.trim();
+                        const ecosystemDir = ecosystemFile.substring(0, ecosystemFile.lastIndexOf('/'));
+                        pm2Spinner.text = `Starting PM2 from ${ecosystemFile.split('/').pop()}...`;
+                        const startResult = sshExec(target.ipAddress, keyPath, `source ~/.nvm/nvm.sh 2>/dev/null; cd ${ecosystemDir} && pm2 start ${ecosystemFile} 2>&1`, 60);
+                        if (startResult.success) {
+                            const newCheck = sshExec(target.ipAddress, keyPath, 'source ~/.nvm/nvm.sh 2>/dev/null; pm2 jlist 2>/dev/null || echo "[]"', 10);
+                            const newProcesses = JSON.parse(newCheck.stdout || '[]');
+                            pm2Spinner.succeed(chalk_1.default.green(`Started ${newProcesses.length} PM2 process${newProcesses.length > 1 ? 'es' : ''}`));
+                            if (newProcesses.length > 0) {
+                                const names = newProcesses.map((p) => p.name).join(', ');
+                                console.log(chalk_1.default.dim(`  Processes: ${names}`));
+                            }
+                        }
+                        else {
+                            pm2Spinner.warn(chalk_1.default.yellow('PM2 start completed with warnings'));
+                        }
+                    }
+                    else {
+                        pm2Spinner.info(chalk_1.default.dim('No PM2 processes or ecosystem file found'));
+                    }
+                }
+                else {
+                    // Processes running - check if we need to reconfigure (e.g., port changes)
+                    // If we have PM2 apps with port configs, delete and recreate to ensure correct config
+                    const appsWithPorts = pm2Apps.filter(app => app.port);
+                    if (appsWithPorts.length > 0) {
+                        pm2Spinner.text = 'Reconfiguring PM2 processes with correct ports...';
+                        // Delete all PM2 processes first
+                        sshExec(target.ipAddress, keyPath, 'source ~/.nvm/nvm.sh 2>/dev/null; pm2 delete all 2>/dev/null', 15);
+                        // Start them fresh with correct config
+                        let startedCount = 0;
+                        const startedNames = [];
+                        for (const app of pm2Apps) {
+                            let appPath = app.path.startsWith('/') ? app.path : `~/${app.path}`;
+                            // Check if path exists, if not try common variations
+                            const pathCheck = sshExec(target.ipAddress, keyPath, `test -d ${appPath} && echo "found" || (test -d ~/${workspace}/${app.name} && echo "workspace" || (test -d ~/app/${app.name} && echo "app" || echo "notfound"))`, 5);
+                            if (pathCheck.stdout === 'workspace') {
+                                appPath = `~/${workspace}/${app.name}`;
+                            }
+                            else if (pathCheck.stdout === 'app') {
+                                appPath = `~/app/${app.name}`;
+                            }
+                            else if (pathCheck.stdout === 'notfound') {
+                                const findResult = sshExec(target.ipAddress, keyPath, `find ~ -maxdepth 3 -type d -name "${app.name}" 2>/dev/null | head -1`, 10);
+                                if (findResult.stdout && findResult.stdout.trim()) {
+                                    appPath = findResult.stdout.trim();
+                                }
+                            }
+                            const startCmd = app.commands?.dev || app.commands?.start || 'npm run dev';
+                            const portArg = app.port ? ` -- -p ${app.port}` : '';
+                            let pm2Cmd;
+                            if (startCmd.startsWith('npm run ')) {
+                                const script = startCmd.replace('npm run ', '');
+                                pm2Cmd = `pm2 start npm --name "${app.name}" -- run ${script}${portArg}`;
+                            }
+                            else if (startCmd.startsWith('pnpm ')) {
+                                const script = startCmd.replace('pnpm ', '');
+                                pm2Cmd = `pm2 start pnpm --name "${app.name}" -- ${script}${portArg}`;
+                            }
+                            else if (/^[a-z0-9:-]+$/.test(startCmd) && !startCmd.includes('/')) {
+                                pm2Cmd = `pm2 start npm --name "${app.name}" -- run ${startCmd}${portArg}`;
+                            }
+                            else {
+                                pm2Cmd = `pm2 start "${startCmd}" --name "${app.name}"`;
+                            }
+                            pm2Spinner.text = `Starting ${app.name}${app.port ? ` on port ${app.port}` : ''}...`;
+                            const startResult = sshExec(target.ipAddress, keyPath, `source ~/.nvm/nvm.sh 2>/dev/null; cd ${appPath} && ${pm2Cmd} 2>&1`, 60);
+                            const isSuccess = startResult.success ||
+                                startResult.stdout.includes('Process successfully started') ||
+                                startResult.stdout.includes('[PM2] Done') ||
+                                startResult.stdout.includes('online');
+                            if (isSuccess) {
+                                startedCount++;
+                                startedNames.push(app.name);
+                            }
+                        }
+                        if (startedCount > 0) {
+                            pm2Spinner.succeed(chalk_1.default.green(`Restarted ${startedCount} PM2 process${startedCount > 1 ? 'es' : ''} with correct ports`));
+                            console.log(chalk_1.default.dim(`  Processes: ${startedNames.join(', ')}`));
+                        }
+                        else {
+                            pm2Spinner.warn(chalk_1.default.yellow('Failed to restart PM2 processes'));
+                        }
+                    }
+                    else {
+                        // No port configs, simple restart is fine
+                        pm2Spinner.text = 'Restarting PM2 processes...';
+                        const pm2Result = sshExec(target.ipAddress, keyPath, 'source ~/.nvm/nvm.sh 2>/dev/null; pm2 restart all 2>&1', 30);
+                        if (pm2Result.success) {
+                            pm2Spinner.succeed(chalk_1.default.green(`Restarted ${processes.length} PM2 process${processes.length > 1 ? 'es' : ''}`));
+                            const names = processes.map((p) => p.name).join(', ');
+                            console.log(chalk_1.default.dim(`  Processes: ${names}`));
+                        }
+                        else {
+                            pm2Spinner.warn(chalk_1.default.yellow('PM2 restart completed with warnings'));
+                        }
+                    }
+                }
+            }
+            catch {
+                pm2Spinner.info(chalk_1.default.dim('No PM2 processes found'));
+            }
+        }
+        // Start/Restart Docker containers
+        if (restartDocker) {
+            const dockerSpinner = (0, ora_1.default)('Checking Docker containers...').start();
+            // Get list of running containers
+            const dockerList = sshExec(target.ipAddress, keyPath, 'docker ps --format "{{.Names}}" 2>/dev/null', 15);
+            let containers = dockerList.stdout.split('\n').filter(c => c.trim());
+            if (containers.length === 0) {
+                // No containers running - find docker-compose file
+                dockerSpinner.text = 'No containers running, looking for docker-compose...';
+                // First check if we have docker apps configured with known paths
+                let composeDir = '';
+                if (dockerApps.length > 0) {
+                    // Use the first docker app's path to find docker-compose
+                    const firstDockerApp = dockerApps[0];
+                    const appPath = firstDockerApp.path.startsWith('/') ? firstDockerApp.path : `~/${firstDockerApp.path}`;
+                    // Check for docker-compose in the app's directory
+                    const composeCheck = sshExec(target.ipAddress, keyPath, `ls ${appPath}/docker-compose.yml ${appPath}/docker-compose.yaml 2>/dev/null | head -1`, 5);
+                    if (composeCheck.stdout && composeCheck.stdout.trim()) {
+                        composeDir = appPath;
+                    }
+                }
+                // If not found via app config, search common locations
+                if (!composeDir) {
+                    const findCompose = sshExec(target.ipAddress, keyPath, 'find ~ -maxdepth 4 \\( -name "docker-compose.yml" -o -name "docker-compose.yaml" \\) ! -path "*/security/*" 2>/dev/null | head -1', 10);
+                    if (findCompose.stdout && findCompose.stdout.trim()) {
+                        const composePath = findCompose.stdout.trim();
+                        composeDir = composePath.substring(0, composePath.lastIndexOf('/'));
+                    }
+                }
+                if (composeDir) {
+                    dockerSpinner.text = `Starting Docker services from ${composeDir.split('/').pop()}...`;
+                    const startResult = sshExec(target.ipAddress, keyPath, `cd ${composeDir} && (docker compose up -d 2>&1 || docker-compose up -d 2>&1)`, 180);
+                    // Check what containers are now running
+                    const newList = sshExec(target.ipAddress, keyPath, 'docker ps --format "{{.Names}}" 2>/dev/null', 15);
+                    containers = newList.stdout.split('\n').filter(c => c.trim());
+                    if (containers.length > 0) {
+                        dockerSpinner.succeed(chalk_1.default.green(`Started ${containers.length} Docker container${containers.length > 1 ? 's' : ''}`));
+                        console.log(chalk_1.default.dim(`  Containers: ${containers.slice(0, 5).join(', ')}${containers.length > 5 ? ` (+${containers.length - 5} more)` : ''}`));
+                    }
+                    else {
+                        dockerSpinner.warn(chalk_1.default.yellow('docker-compose up completed but no containers running'));
+                        if (startResult.stdout) {
+                            const lines = startResult.stdout.split('\n').slice(-3);
+                            lines.forEach(line => {
+                                if (line.trim())
+                                    console.log(chalk_1.default.dim(`  ${line}`));
+                            });
+                        }
+                    }
+                }
+                else {
+                    dockerSpinner.info(chalk_1.default.dim('No Docker containers or docker-compose file found'));
+                }
+            }
+            else {
+                // Containers are running - restart them
+                dockerSpinner.text = 'Restarting Docker containers...';
+                // Find the docker-compose directory for running containers
+                const findCompose = sshExec(target.ipAddress, keyPath, 'find ~ -maxdepth 4 \\( -name "docker-compose.yml" -o -name "docker-compose.yaml" \\) ! -path "*/security/*" 2>/dev/null | head -1', 10);
+                if (findCompose.stdout && findCompose.stdout.trim()) {
+                    const composePath = findCompose.stdout.trim();
+                    const composeDir = composePath.substring(0, composePath.lastIndexOf('/'));
+                    const composeResult = sshExec(target.ipAddress, keyPath, `cd ${composeDir} && (docker compose restart 2>&1 || docker-compose restart 2>&1)`, 120);
+                    if (composeResult.success) {
+                        dockerSpinner.succeed(chalk_1.default.green(`Restarted ${containers.length} Docker container${containers.length > 1 ? 's' : ''} (docker-compose)`));
+                    }
+                    else {
+                        dockerSpinner.warn(chalk_1.default.yellow('Docker restart completed with warnings'));
+                    }
+                }
+                else {
+                    // Restart containers individually
+                    const dockerResult = sshExec(target.ipAddress, keyPath, `docker restart ${containers.join(' ')} 2>&1`, 120);
+                    if (dockerResult.success) {
+                        dockerSpinner.succeed(chalk_1.default.green(`Restarted ${containers.length} Docker container${containers.length > 1 ? 's' : ''}`));
+                    }
+                    else {
+                        dockerSpinner.warn(chalk_1.default.yellow('Docker restart completed with warnings'));
+                    }
+                }
+                console.log(chalk_1.default.dim(`  Containers: ${containers.slice(0, 5).join(', ')}${containers.length > 5 ? ` (+${containers.length - 5} more)` : ''}`));
+            }
+        }
+        console.log('');
+        console.log(chalk_1.default.green('✓ Restart complete'));
+        // Show health check tip
+        console.log(chalk_1.default.dim('  Run `gb status` to check service health'));
+    }
+    catch (error) {
+        if (error.name === 'ExitPromptError' || error.message?.includes('force closed')) {
+            console.log('');
+            console.log(chalk_1.default.dim('Cancelled.'));
+            return;
+        }
+        if (error instanceof api_1.AuthenticationError) {
+            (0, api_1.handleApiError)(error);
+            return;
+        }
+        console.error(chalk_1.default.red(`Error: ${error.message}`));
+    }
+});

package/dist/commands/status.js

@@ -84,6 +84,17 @@ function formatDuration(secs) {
     const remainingSecs = secs % 60;
     return `${mins}m ${remainingSecs}s`;
 }
+function renderBar(percent, width = 10) {
+    const filled = Math.round((percent / 100) * width);
+    const empty = width - filled;
+    const bar = '█'.repeat(filled) + '░'.repeat(empty);
+    // Color based on usage level
+    if (percent >= 90)
+        return chalk_1.default.red(bar);
+    if (percent >= 70)
+        return chalk_1.default.yellow(bar);
+    return chalk_1.default.green(bar);
+}
 function getTimingBreakdown(ip, keyPath) {
     const timing = {
         sshReady: null,
@@ -294,6 +305,7 @@ exports.statusCommand = new commander_1.Command('status')
                 currentHourEnd: target.currentHourEnd,
                 lastActivityAt: target.lastActivityAt,
                 autoDestroyOnInactivity: target.autoDestroyOnInactivity ?? true,
+                protectedUntil: target.protectedUntil,
             };
             const now = new Date();
             const minutesUntilBilling = billing.currentHourEnd
@@ -302,22 +314,90 @@ exports.statusCommand = new commander_1.Command('status')
             const minutesInactive = billing.lastActivityAt
                 ? Math.floor((now.getTime() - new Date(billing.lastActivityAt).getTime()) / (60 * 1000))
                 : 0;
+            // Format time remaining - show hours if > 60 min
+            const formatTimeRemaining = (mins) => {
+                if (mins >= 60) {
+                    const hours = Math.floor(mins / 60);
+                    const remainingMins = mins % 60;
+                    return remainingMins > 0 ? `${hours}h ${remainingMins}m` : `${hours}h`;
+                }
+                return `${mins} min`;
+            };
             console.log(chalk_1.default.blue('[INFO] === Billing ==='));
             console.log(`  Size: ${target.size} (${billing.creditsPerHour} credit${billing.creditsPerHour > 1 ? 's' : ''}/hr)`);
-            console.log(`  Current hour ends in: ${chalk_1.default.cyan(minutesUntilBilling + ' min')}`);
+            console.log(`  Current hour ends in: ${chalk_1.default.cyan(formatTimeRemaining(minutesUntilBilling))}`);
             console.log(`  Last activity: ${minutesInactive < 1 ? 'just now' : minutesInactive + ' min ago'}`);
             console.log(`  Total: ${billing.totalHoursUsed} hour${billing.totalHoursUsed !== 1 ? 's' : ''}, ${billing.totalCreditsUsed} credit${billing.totalCreditsUsed !== 1 ? 's' : ''}`);
-            if (billing.autoDestroyOnInactivity && billing.currentHourEnd) {
-                // Auto-destroy happens at 58 min mark into billing hour if no activity after 50 min mark
-                const currentHourEnd = new Date(billing.currentHourEnd);
-                const currentHourStart = new Date(currentHourEnd.getTime() - 60 * 60 * 1000);
-                const minutesIntoBillingHour = Math.floor((now.getTime() - currentHourStart.getTime()) / (60 * 1000));
-                const minutesUntilDestroy = Math.max(0, 58 - minutesIntoBillingHour);
-                if (minutesInactive >= 5) {
-                    console.log(chalk_1.default.yellow(`  Auto-destroy in: ${minutesUntilDestroy} min (inactive)`));
+            // Auto-destroy protection and warning
+            if (billing.autoDestroyOnInactivity) {
+                // Check if protected from auto-destroy
+                if (billing.protectedUntil) {
+                    const protectedTime = new Date(billing.protectedUntil);
+                    const minutesUntilProtectionEnds = Math.ceil((protectedTime.getTime() - now.getTime()) / (60 * 1000));
+                    if (minutesUntilProtectionEnds > 0) {
+                        const timeStr = minutesUntilProtectionEnds >= 60
+                            ? `${Math.floor(minutesUntilProtectionEnds / 60)}h ${minutesUntilProtectionEnds % 60}m`
+                            : `${minutesUntilProtectionEnds} min`;
+                        console.log(chalk_1.default.green(`  Protected from auto-destroy for: ${timeStr}`));
+                    }
                 }
+                // Auto-destroy warning (only show if NOT protected and inactive)
+                if (billing.currentHourEnd) {
+                    const isProtected = billing.protectedUntil && new Date(billing.protectedUntil).getTime() > now.getTime();
+                    if (!isProtected) {
+                        const currentHourEnd = new Date(billing.currentHourEnd);
+                        const currentHourStart = new Date(currentHourEnd.getTime() - 60 * 60 * 1000);
+                        const minutesIntoBillingHour = Math.floor((now.getTime() - currentHourStart.getTime()) / (60 * 1000));
+                        const minutesUntilDestroy = Math.max(0, 58 - minutesIntoBillingHour);
+                        if (minutesInactive >= 5) {
+                            console.log(chalk_1.default.yellow(`  Auto-destroy in: ${minutesUntilDestroy} min (inactive)`));
+                        }
+                    }
+                }
+            }
+            else {
+                console.log(chalk_1.default.dim(`  Auto-destroy: disabled`));
             }
             console.log('');
+            // Show System Stats if available
+            const systemStats = target.systemStats;
+            if (systemStats && systemStats.updatedAt) {
+                const statsAge = Math.floor((now.getTime() - new Date(systemStats.updatedAt).getTime()) / 1000);
+                console.log(chalk_1.default.blue('[INFO] === System Stats ==='));
+                // Load average
+                if (systemStats.loadAvg && systemStats.loadAvg.length >= 3) {
+                    const [load1, load5, load15] = systemStats.loadAvg;
+                    console.log(`  Load Avg:  ${load1.toFixed(2)}, ${load5.toFixed(2)}, ${load15.toFixed(2)}`);
+                }
+                // Memory
+                if (systemStats.memoryUsagePercent !== undefined) {
+                    const memUsed = systemStats.memoryUsedMb ? `${(systemStats.memoryUsedMb / 1024).toFixed(1)}G` : '?';
+                    const memTotal = systemStats.memoryTotalMb ? `${(systemStats.memoryTotalMb / 1024).toFixed(1)}G` : '?';
+                    const memBar = renderBar(systemStats.memoryUsagePercent);
+                    console.log(`  Memory:    ${memBar} ${systemStats.memoryUsagePercent}% (${memUsed}/${memTotal})`);
+                }
+                // Disk
+                if (systemStats.diskUsagePercent !== undefined) {
+                    const diskUsed = systemStats.diskUsedGb !== undefined ? `${systemStats.diskUsedGb}G` : '?';
+                    const diskTotal = systemStats.diskTotalGb !== undefined ? `${systemStats.diskTotalGb}G` : '?';
+                    const diskBar = renderBar(systemStats.diskUsagePercent);
+                    console.log(`  Disk:      ${diskBar} ${systemStats.diskUsagePercent}% (${diskUsed}/${diskTotal})`);
+                }
+                // Uptime
+                if (systemStats.uptimeSeconds !== undefined) {
+                    const days = Math.floor(systemStats.uptimeSeconds / 86400);
+                    const hours = Math.floor((systemStats.uptimeSeconds % 86400) / 3600);
+                    const mins = Math.floor((systemStats.uptimeSeconds % 3600) / 60);
+                    const uptimeStr = days > 0 ? `${days}d ${hours}h ${mins}m` : hours > 0 ? `${hours}h ${mins}m` : `${mins}m`;
+                    console.log(`  Uptime:    ${uptimeStr}`);
+                }
+                // Process count
+                if (systemStats.processCount !== undefined) {
+                    console.log(`  Processes: ${systemStats.processCount}`);
+                }
+                console.log(chalk_1.default.dim(`  (updated ${statsAge < 60 ? 'just now' : Math.floor(statsAge / 60) + 'm ago'})`));
+                console.log('');
+            }
             // Show Docker containers status
             const dockerStatus = sshExec(target.ipAddress, keyPath, 'docker ps --format "{{.Names}}\\t{{.Status}}" 2>/dev/null', 10);
             if (dockerStatus && dockerStatus.trim()) {

package/dist/index.js

@@ -1,32 +1,8 @@
 #!/usr/bin/env node
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 const commander_1 = require("commander");
-const chalk_1 = __importDefault(require("chalk"));
 const init_1 = require("./commands/init");
-const cleanup_ssh_1 = require("./commands/cleanup-ssh");
-/**
- * Auto-cleanup orphaned SSH configs on startup (non-blocking, silent)
- * This runs in the background without affecting CLI startup time
- */
-function autoCleanupSshConfigs() {
-    // Run cleanup in background - don't await, don't block startup
-    (0, cleanup_ssh_1.cleanupOrphanedSshConfigs)({ silent: true })
-        .then(removed => {
-        // Optionally log if GENBOX_DEBUG is set
-        if (process.env.GENBOX_DEBUG && removed.length > 0) {
-            console.error(chalk_1.default.dim(`[Auto-cleanup] Removed ${removed.length} orphaned SSH config(s): ${removed.join(', ')}`));
-        }
-    })
-        .catch(() => {
-        // Silently ignore errors - this is a background cleanup
-    });
-}
-// Run auto-cleanup on startup (non-blocking)
-autoCleanupSshConfigs();
 const program = new commander_1.Command();
 // eslint-disable-next-line @typescript-eslint/no-var-requires
 const { version } = require('../package.json');
@@ -55,7 +31,8 @@ const migrate_1 = require("./commands/migrate");
 const ssh_setup_1 = require("./commands/ssh-setup");
 const rebuild_1 = require("./commands/rebuild");
 const extend_1 = require("./commands/extend");
-const cleanup_ssh_2 = require("./commands/cleanup-ssh");
+const cleanup_ssh_1 = require("./commands/cleanup-ssh");
+const restart_1 = require("./commands/restart");
 program
     .addCommand(init_1.initCommand)
     .addCommand(create_1.createCommand)
@@ -80,5 +57,6 @@ program
     .addCommand(ssh_setup_1.sshSetupCommand)
     .addCommand(rebuild_1.rebuildCommand)
     .addCommand(extend_1.extendCommand)
-    .addCommand(cleanup_ssh_2.cleanupSshCommand);
+    .addCommand(cleanup_ssh_1.cleanupSshCommand)
+    .addCommand(restart_1.restartCommand);
 program.parse(process.argv);

package/package.json

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