launchpd 0.1.4 → 0.1.6

package/bin/cli.js

@@ -21,6 +21,7 @@ program
     .option('--dry-run', 'Simulate deployment without uploading to R2')
     .option('--name <subdomain>', 'Use a custom subdomain (optional)')
     .option('--expires <time>', 'Auto-delete after time (e.g., 30m, 2h, 1d). Minimum: 30m')
+    .option('--verbose', 'Show detailed error information')
     .action(async (folder, options) => {
         await deploy(folder, options);
     });
@@ -29,6 +30,8 @@ program
     .command('list')
     .description('List your past deployments')
     .option('--json', 'Output as JSON')
+    .option('--local', 'Only show local deployments')
+    .option('--verbose', 'Show detailed error information')
     .action(async (options) => {
         await list(options);
     });
@@ -38,6 +41,7 @@ program
     .description('List all versions for a subdomain')
     .argument('<subdomain>', 'The subdomain to list versions for')
     .option('--json', 'Output as JSON')
+    .option('--verbose', 'Show detailed error information')
     .action(async (subdomain, options) => {
         await versions(subdomain, options);
     });
@@ -47,6 +51,7 @@ program
     .description('Rollback a subdomain to a previous version')
     .argument('<subdomain>', 'The subdomain to rollback')
     .option('--to <n>', 'Specific version number to rollback to')
+    .option('--verbose', 'Show detailed error information')
     .action(async (subdomain, options) => {
         await rollback(subdomain, options);
     });

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "launchpd",
-    "version": "0.1.4",
+    "version": "0.1.6",
     "description": "Deploy static sites instantly to a live URL",
     "type": "module",
     "bin": {
@@ -53,7 +53,8 @@
         "chalk": "^5.4.0",
         "commander": "^14.0.0",
         "mime-types": "^2.1.35",
-        "nanoid": "^5.1.0"
+        "nanoid": "^5.1.0",
+        "ora": "^8.0.1"
     },
     "devDependencies": {
         "@eslint/js": "^9.39.2",

package/src/commands/auth.js

@@ -7,7 +7,8 @@ import { createInterface } from 'node:readline';
 import { exec } from 'node:child_process';
 import { config } from '../config.js';
 import { getCredentials, saveCredentials, clearCredentials, isLoggedIn } from '../utils/credentials.js';
-import { success, error, info, warning } from '../utils/logger.js';
+import { success, error, errorWithSuggestions, info, warning, spinner } from '../utils/logger.js';
+import chalk from 'chalk';
 
 const API_BASE_URL = `https://api.${config.domain}`;
 const REGISTER_URL = `https://portal.${config.domain}/auth/register`;
@@ -49,8 +50,7 @@ async function validateApiKey(apiKey) {
             return data;
         }
         return null;
-    } catch (err) {
-        error(`Failed to validate API key: ${err.message}`);
+    } catch {
         return null;
     }
 }
@@ -62,29 +62,37 @@ export async function login() {
     // Check if already logged in
     if (await isLoggedIn()) {
         const creds = await getCredentials();
-        warning(`Already logged in as ${creds.email || creds.userId}`);
+        warning(`Already logged in as ${chalk.cyan(creds.email || creds.userId)}`);
         info('Run "launchpd logout" to switch accounts');
         return;
     }
 
-    console.log('\n🔐 Launchpd Login\n');
+    console.log('\nLaunchpd Login\n');
     console.log('Enter your API key from the dashboard.');
-    console.log(`Don't have one? Run "launchpd register" first.\n`);
+    console.log(`Don't have one? Run ${chalk.cyan('"launchpd register"')} first.\n`);
 
     const apiKey = await prompt('API Key: ');
 
     if (!apiKey) {
-        error('API key is required');
+        errorWithSuggestions('API key is required', [
+            'Get your API key from the dashboard',
+            `Visit: https://portal.${config.domain}/api-keys`,
+            'Run "launchpd register" if you don\'t have an account',
+        ]);
         process.exit(1);
     }
 
-    info('Validating API key...');
+    const validateSpinner = spinner('Validating API key...');
 
     const result = await validateApiKey(apiKey);
 
     if (!result) {
-        error('Invalid API key. Please check and try again.');
-        console.log(`\nGet your API key at: https://portal.${config.domain}/api-keys`);
+        validateSpinner.fail('Invalid API key');
+        errorWithSuggestions('Please check and try again.', [
+            `Get your API key at: https://portal.${config.domain}/api-keys`,
+            'Make sure you copied the full key',
+            'API keys start with "lpd_"',
+        ]);
         process.exit(1);
     }
 
@@ -96,11 +104,13 @@ export async function login() {
         tier: result.tier,
     });
 
-    success(`Logged in successfully!`);
-    console.log(`\n  Email: ${result.user?.email || 'N/A'}`);
-    console.log(`  Tier: ${result.tier}`);
-    console.log(`  Sites: ${result.usage?.siteCount || 0}/${result.limits?.maxSites || '?'}`);
-    console.log(`  Storage: ${result.usage?.storageUsedMB || 0}MB/${result.limits?.maxStorageMB || '?'}MB\n`);
+    validateSpinner.succeed('Logged in successfully!');
+    console.log('');
+    console.log(`  ${chalk.gray('Email:')} ${chalk.cyan(result.user?.email || 'N/A')}`);
+    console.log(`  ${chalk.gray('Tier:')} ${chalk.green(result.tier)}`);
+    console.log(`  ${chalk.gray('Sites:')} ${result.usage?.siteCount || 0}/${result.limits?.maxSites || '?'}`);
+    console.log(`  ${chalk.gray('Storage:')} ${result.usage?.storageUsedMB || 0}MB/${result.limits?.maxStorageMB || '?'}MB`);
+    console.log('');
 }
 
 /**
@@ -117,19 +127,19 @@ export async function logout() {
     const creds = await getCredentials();
     await clearCredentials();
 
-    success(`Logged out successfully`);
+    success('Logged out successfully');
     if (creds?.email) {
-        info(`Was logged in as: ${creds.email}`);
+        info(`Was logged in as: ${chalk.cyan(creds.email)}`);
     }
-    console.log(`\nYou can still deploy anonymously (limited to 3 sites, 50MB).`);
+    console.log(`\nYou can still deploy anonymously (limited to ${chalk.yellow('3 sites')}, ${chalk.yellow('50MB')}).`);
 }
 
 /**
  * Register command - opens browser to registration page
  */
 export async function register() {
-    console.log('\n🚀 Register for Launchpd\n');
-    console.log(`Opening registration page: ${REGISTER_URL}\n`);
+    console.log('\nRegister for Launchpd\n');
+    console.log(`Opening registration page: ${chalk.cyan(REGISTER_URL)}\n`);
 
     // Open browser based on platform
     const platform = process.platform;
@@ -145,20 +155,20 @@ export async function register() {
 
     exec(cmd, (err) => {
         if (err) {
-            console.log(`Please open this URL in your browser:\n  ${REGISTER_URL}\n`);
+            console.log(`Please open this URL in your browser:\n  ${chalk.cyan(REGISTER_URL)}\n`);
         }
     });
 
     console.log('After registering:');
-    console.log('  1. Get your API key from the dashboard');
-    console.log('  2. Run: launchpd login');
+    console.log(`  1. Get your API key from the dashboard`);
+    console.log(`  2. Run: ${chalk.cyan('launchpd login')}`);
     console.log('');
 
     info('Registration benefits:');
-    console.log('  ✓ 10 sites (instead of 3)');
-    console.log('  ✓ 100MB storage (instead of 50MB)');
-    console.log('  ✓ 30-day retention (instead of 7 days)');
-    console.log('  ✓ 10 versions per site');
+    console.log(`  ${chalk.green('✓')} ${chalk.white('10 sites')} ${chalk.gray('(instead of 3)')}`);
+    console.log(`  ${chalk.green('✓')} ${chalk.white('100MB storage')} ${chalk.gray('(instead of 50MB)')}`);
+    console.log(`  ${chalk.green('✓')} ${chalk.white('30-day retention')} ${chalk.gray('(instead of 7 days)')}`);
+    console.log(`  ${chalk.green('✓')} ${chalk.white('10 versions per site')}`);
     console.log('');
 }
 
@@ -171,12 +181,12 @@ export async function whoami() {
     if (!creds) {
         console.log('\n👤 Not logged in (anonymous mode)\n');
         console.log('Anonymous limits:');
-        console.log('  • 3 sites maximum');
-        console.log('  • 50MB total storage');
-        console.log('  • 7-day retention');
-        console.log('  • 1 version per site');
-        console.log(`\nRun "launchpd login" to authenticate`);
-        console.log(`Run "launchpd register" to create an account\n`);
+        console.log(`  • ${chalk.white('3 sites')} maximum`);
+        console.log(`  • ${chalk.white('50MB')} total storage`);
+        console.log(`  • ${chalk.white('7-day')} retention`);
+        console.log(`  • ${chalk.white('1 version')} per site`);
+        console.log(`\nRun ${chalk.cyan('"launchpd login"')} to authenticate`);
+        console.log(`Run ${chalk.cyan('"launchpd register"')} to create an account\n`);
         return;
     }
 
@@ -192,7 +202,7 @@ export async function whoami() {
         process.exit(1);
     }
 
-    console.log(`\n👤 Logged in as: ${result.user?.email || result.user?.id}\n`);
+    console.log(`\nLogged in as: ${result.user?.email || result.user?.id}\n`);
 
     console.log('Account Info:');
     console.log(`  User ID: ${result.user?.id}`);
@@ -232,38 +242,43 @@ export async function quota() {
     const creds = await getCredentials();
 
     if (!creds) {
-        console.log('\n📊 Anonymous Quota Status\n');
-        console.log('You are not logged in.');
+        console.log(`\n${chalk.bold('Anonymous Quota Status')}\n`);
+        console.log(chalk.gray('You are not logged in.'));
         console.log('');
-        console.log('Anonymous tier limits:');
-        console.log('  ┌─────────────────────────────────┐');
-        console.log('  │ Sites:      3 maximum           │');
-        console.log('  │ Storage:    50MB total          │');
-        console.log('  │ Retention:  7 days              │');
-        console.log('  │ Versions:   1 per site          │');
-        console.log('  └─────────────────────────────────┘');
+        console.log(chalk.bold('Anonymous tier limits:'));
+        console.log(chalk.gray('  ┌─────────────────────────────────┐'));
+        console.log(chalk.gray('  │') + ` Sites:      ${chalk.white('3 maximum')}           ` + chalk.gray('│'));
+        console.log(chalk.gray('  │') + ` Storage:    ${chalk.white('50MB total')}          ` + chalk.gray('│'));
+        console.log(chalk.gray('  │') + ` Retention:  ${chalk.white('7 days')}              ` + chalk.gray('│'));
+        console.log(chalk.gray('  │') + ` Versions:   ${chalk.white('1 per site')}          ` + chalk.gray('│'));
+        console.log(chalk.gray('  └─────────────────────────────────┘'));
         console.log('');
-        console.log('💡 Register for FREE to unlock more:');
-        console.log('   → 10 sites');
-        console.log('   → 100MB storage');
-        console.log('   → 30-day retention');
-        console.log('   → 10 versions per site');
+        console.log(`${chalk.cyan('Register for FREE')} to unlock more:`);
+        console.log(`   ${chalk.green('→')} ${chalk.white('10 sites')}`);
+        console.log(`   ${chalk.green('→')} ${chalk.white('100MB storage')}`);
+        console.log(`   ${chalk.green('→')} ${chalk.white('30-day retention')}`);
+        console.log(`   ${chalk.green('→')} ${chalk.white('10 versions per site')}`);
         console.log('');
-        console.log('Run: launchpd register');
+        console.log(`Run: ${chalk.cyan('launchpd register')}`);
         console.log('');
         return;
     }
 
-    info('Fetching quota status...');
+    const fetchSpinner = spinner('Fetching quota status...');
 
     const result = await validateApiKey(creds.apiKey);
 
     if (!result) {
-        error('Failed to fetch quota. API key may be invalid.');
+        fetchSpinner.fail('Failed to fetch quota');
+        errorWithSuggestions('API key may be invalid.', [
+            'Run "launchpd login" to re-authenticate',
+            'Check your internet connection',
+        ]);
         process.exit(1);
     }
 
-    console.log(`\n📊 Quota Status for: ${result.user?.email || creds.email}\n`);
+    fetchSpinner.succeed('Quota fetched');
+    console.log(`\n${chalk.bold('Quota Status for:')} ${chalk.cyan(result.user?.email || creds.email)}\n`);
 
     // Sites usage
     const sitesUsed = result.usage?.siteCount || 0;
@@ -271,7 +286,7 @@ export async function quota() {
     const sitesPercent = Math.round((sitesUsed / sitesMax) * 100);
     const sitesBar = createProgressBar(sitesUsed, sitesMax);
 
-    console.log(`Sites:    ${sitesBar} ${sitesUsed}/${sitesMax} (${sitesPercent}%)`);
+    console.log(`${chalk.gray('Sites:')}    ${sitesBar} ${chalk.white(sitesUsed)}/${sitesMax} (${getPercentColor(sitesPercent)})`);
 
     // Storage usage
     const storageMB = result.usage?.storageUsedMB || 0;
@@ -279,46 +294,61 @@ export async function quota() {
     const storagePercent = Math.round((storageMB / storageMaxMB) * 100);
     const storageBar = createProgressBar(storageMB, storageMaxMB);
 
-    console.log(`Storage:  ${storageBar} ${storageMB}MB/${storageMaxMB}MB (${storagePercent}%)`);
+    console.log(`${chalk.gray('Storage:')}  ${storageBar} ${chalk.white(storageMB)}MB/${storageMaxMB}MB (${getPercentColor(storagePercent)})`);
 
     console.log('');
-    console.log(`Tier:         ${result.tier || 'free'}`);
-    console.log(`Retention:    ${result.limits?.retentionDays || 30} days`);
-    console.log(`Max versions: ${result.limits?.maxVersionsPerSite || 10} per site`);
+    console.log(`${chalk.gray('Tier:')}         ${chalk.green(result.tier || 'free')}`);
+    console.log(`${chalk.gray('Retention:')}    ${chalk.white(result.limits?.retentionDays || 30)} days`);
+    console.log(`${chalk.gray('Max versions:')} ${chalk.white(result.limits?.maxVersionsPerSite || 10)} per site`);
     console.log('');
 
     // Status indicators
     if (result.canCreateNewSite === false) {
-        warning('⚠️ Site limit reached - cannot create new sites');
+        warning('Site limit reached - cannot create new sites');
     }
 
     if (storagePercent > 80) {
-        warning(`⚠️ Storage ${storagePercent}% used - consider cleaning up old deployments`);
+        warning(`Storage ${storagePercent}% used - consider cleaning up old deployments`);
     }
 
     if (result.tier === 'free') {
         console.log('');
-        info('💎 Upgrade to Pro for 50 sites, 1GB storage, and 50 versions');
+        info(`Upgrade to ${chalk.magenta('Pro')} for 50 sites, 1GB storage, and 50 versions`);
     }
     console.log('');
 }
 
 /**
- * Create a simple progress bar
+ * Create a simple progress bar with color coding
  */
 function createProgressBar(current, max, width = 20) {
     const filled = Math.round((current / max) * width);
     const empty = width - filled;
     const percent = (current / max) * 100;
 
-    let bar = '';
+    const filledChar = '█';
+    let barColor;
+
     if (percent >= 90) {
-        bar = '█'.repeat(filled) + '░'.repeat(empty);
+        barColor = chalk.red;
     } else if (percent >= 70) {
-        bar = '█'.repeat(filled) + '░'.repeat(empty);
+        barColor = chalk.yellow;
     } else {
-        bar = '█'.repeat(filled) + '░'.repeat(empty);
+        barColor = chalk.green;
     }
 
+    const bar = barColor(filledChar.repeat(filled)) + chalk.gray('░'.repeat(empty));
     return `[${bar}]`;
 }
+
+/**
+ * Get colored percentage text
+ */
+function getPercentColor(percent) {
+    if (percent >= 90) {
+        return chalk.red(`${percent}%`);
+    } else if (percent >= 70) {
+        return chalk.yellow(`${percent}%`);
+    }
+    return chalk.green(`${percent}%`);
+}

package/src/commands/deploy.js

@@ -6,7 +6,7 @@ import { uploadFolder, finalizeUpload } from '../utils/upload.js';
 import { getNextVersion } from '../utils/metadata.js';
 import { saveLocalDeployment } from '../utils/localConfig.js';
 import { getNextVersionFromAPI } from '../utils/api.js';
-import { success, error, info, warning } from '../utils/logger.js';
+import { success, errorWithSuggestions, info, warning, spinner, formatSize } from '../utils/logger.js';
 import { calculateExpiresAt, formatTimeRemaining } from '../utils/expiration.js';
 import { checkQuota, displayQuotaWarnings } from '../utils/quota.js';
 import { getCredentials } from '../utils/credentials.js';
@@ -42,9 +42,11 @@ async function calculateFolderSize(folderPath) {
  * @param {boolean} options.dryRun - Skip actual upload
  * @param {string} options.name - Custom subdomain
  * @param {string} options.expires - Expiration time (e.g., "30m", "2h", "1d")
+ * @param {boolean} options.verbose - Show verbose error details
  */
 export async function deploy(folder, options) {
     const folderPath = resolve(folder);
+    const verbose = options.verbose || false;
 
     // Parse expiration if provided
     let expiresAt = null;
@@ -52,41 +54,58 @@ export async function deploy(folder, options) {
         try {
             expiresAt = calculateExpiresAt(options.expires);
         } catch (err) {
-            error(err.message);
+            errorWithSuggestions(err.message, [
+                'Use format like: 30m, 2h, 1d, 7d',
+                'Minimum expiration is 30 minutes',
+                'Examples: --expires 1h, --expires 2d',
+            ], { verbose, cause: err });
             process.exit(1);
         }
     }
 
     // Validate folder exists
     if (!existsSync(folderPath)) {
-        error(`Folder not found: ${folderPath}`);
+        errorWithSuggestions(`Folder not found: ${folderPath}`, [
+            'Check the path is correct',
+            'Use an absolute path or path relative to current directory',
+            `Current directory: ${process.cwd()}`,
+        ], { verbose });
         process.exit(1);
     }
 
     // Check folder is not empty
+    const scanSpinner = spinner('Scanning folder...');
     const files = await readdir(folderPath, { recursive: true, withFileTypes: true });
     const fileCount = files.filter(f => f.isFile()).length;
 
     if (fileCount === 0) {
-        error('Folder is empty. Nothing to deploy.');
+        scanSpinner.fail('Folder is empty');
+        errorWithSuggestions('Nothing to deploy.', [
+            'Add some files to your folder',
+            'Make sure index.html exists for static sites',
+        ], { verbose });
         process.exit(1);
     }
+    scanSpinner.succeed(`Found ${fileCount} file(s)`);
 
     // Generate or use provided subdomain
     const subdomain = options.name || generateSubdomain();
     const url = `https://${subdomain}.launchpd.cloud`;
 
     // Calculate estimated upload size
+    const sizeSpinner = spinner('Calculating folder size...');
     const estimatedBytes = await calculateFolderSize(folderPath);
+    sizeSpinner.succeed(`Size: ${formatSize(estimatedBytes)}`);
 
     // Check quota before deploying
-    info('Checking quota...');
+    const quotaSpinner = spinner('Checking quota...');
     const quotaCheck = await checkQuota(subdomain, estimatedBytes);
 
     if (!quotaCheck.allowed) {
-        error('Deployment blocked due to quota limits');
+        quotaSpinner.fail('Deployment blocked due to quota limits');
         process.exit(1);
     }
+    quotaSpinner.succeed('Quota check passed');
 
     // Display any warnings
     displayQuotaWarnings(quotaCheck.warnings);
@@ -101,7 +120,6 @@ export async function deploy(folder, options) {
 
     info(`Deploying ${fileCount} file(s) from ${folderPath}`);
     info(`Target: ${url}`);
-    info(`Size: ${(estimatedBytes / 1024 / 1024).toFixed(2)}MB`);
 
     if (options.dryRun) {
         warning('Dry run mode - skipping upload');
@@ -127,7 +145,7 @@ export async function deploy(folder, options) {
                 ? (quotaCheck.quota.usage?.siteCount || 0) + 1
                 : quotaCheck.quota.usage?.siteCount || 0;
             console.log(`  Sites: ${sitesAfter}/${quotaCheck.quota.limits.maxSites}`);
-            console.log(`  Storage: ${(storageAfter / 1024 / 1024).toFixed(1)}MB/${quotaCheck.quota.limits.maxStorageMB}MB`);
+            console.log(`  Storage: ${formatSize(storageAfter)}/${quotaCheck.quota.limits.maxStorageMB}MB`);
             console.log('');
         }
         return;
@@ -136,18 +154,25 @@ export async function deploy(folder, options) {
     // Perform actual upload
     try {
         // Get next version number for this subdomain (try API first, fallback to local)
+        const versionSpinner = spinner('Fetching version info...');
         let version = await getNextVersionFromAPI(subdomain);
         if (version === null) {
             version = await getNextVersion(subdomain);
         }
-        info(`Deploying as version ${version}...`);
+        versionSpinner.succeed(`Deploying as version ${version}`);
 
         // Upload all files via API proxy
         const folderName = basename(folderPath);
-        const { totalBytes } = await uploadFolder(folderPath, subdomain, version);
+        const uploadSpinner = spinner(`Uploading files... 0/${fileCount}`);
+
+        const { totalBytes } = await uploadFolder(folderPath, subdomain, version, (uploaded, total, fileName) => {
+            uploadSpinner.update(`Uploading files... ${uploaded}/${total} (${fileName})`);
+        });
+
+        uploadSpinner.succeed(`Uploaded ${fileCount} files (${formatSize(totalBytes)})`);
 
         // Finalize upload: set active version and record metadata
-        info('Finalizing deployment...');
+        const finalizeSpinner = spinner('Finalizing deployment...');
         await finalizeUpload(
             subdomain,
             version,
@@ -156,6 +181,7 @@ export async function deploy(folder, options) {
             folderName,
             expiresAt?.toISOString() || null
         );
+        finalizeSpinner.succeed('Deployment finalized');
 
         // Save locally for quick access
         await saveLocalDeployment({
@@ -169,13 +195,33 @@ export async function deploy(folder, options) {
         });
 
         success(`Deployed successfully! (v${version})`);
-        console.log(`\n  🚀 ${url}`);
+        console.log(`\n${url}`);
         if (expiresAt) {
-            warning(`  ⏰ Expires: ${formatTimeRemaining(expiresAt)}`);
+            warning(`Expires: ${formatTimeRemaining(expiresAt)}`);
         }
         console.log('');
     } catch (err) {
-        error(`Upload failed: ${err.message}`);
+        const suggestions = [];
+
+        // Provide context-specific suggestions
+        if (err.message.includes('fetch failed') || err.message.includes('ENOTFOUND')) {
+            suggestions.push('Check your internet connection');
+            suggestions.push('The API server may be temporarily unavailable');
+        } else if (err.message.includes('401') || err.message.includes('Unauthorized')) {
+            suggestions.push('Run "launchpd login" to authenticate');
+            suggestions.push('Your API key may have expired');
+        } else if (err.message.includes('413') || err.message.includes('too large')) {
+            suggestions.push('Try deploying fewer or smaller files');
+            suggestions.push('Check your storage quota with "launchpd quota"');
+        } else if (err.message.includes('429') || err.message.includes('rate limit')) {
+            suggestions.push('Wait a few minutes and try again');
+            suggestions.push('You may be deploying too frequently');
+        } else {
+            suggestions.push('Try running with --verbose for more details');
+            suggestions.push('Check https://status.launchpd.cloud for service status');
+        }
+
+        errorWithSuggestions(`Upload failed: ${err.message}`, suggestions, { verbose, cause: err });
         process.exit(1);
     }
 }

package/src/commands/list.js

@@ -1,6 +1,6 @@
 import { getLocalDeployments } from '../utils/localConfig.js';
 import { listDeployments as listFromAPI } from '../utils/api.js';
-import { error, info, warning } from '../utils/logger.js';
+import { errorWithSuggestions, info, spinner, formatSize } from '../utils/logger.js';
 import { formatTimeRemaining, isExpired } from '../utils/expiration.js';
 import chalk from 'chalk';
 
@@ -9,12 +9,17 @@ import chalk from 'chalk';
  * @param {object} options - Command options
  * @param {boolean} options.json - Output as JSON
  * @param {boolean} options.local - Only show local deployments
+ * @param {boolean} options.verbose - Show verbose error details
  */
 export async function list(options) {
+    const verbose = options.verbose || false;
+
     try {
         let deployments = [];
         let source = 'local';
 
+        const fetchSpinner = spinner('Fetching deployments...');
+
         // Try API first unless --local flag is set
         if (!options.local) {
             const apiResult = await listFromAPI();
@@ -40,11 +45,13 @@ export async function list(options) {
         }
 
         if (deployments.length === 0) {
-            warning('No deployments found.');
-            info('Deploy a folder with: launchpd deploy ./my-folder');
+            fetchSpinner.warn('No deployments found');
+            info('Deploy a folder with: ' + chalk.cyan('launchpd deploy ./my-folder'));
             return;
         }
 
+        fetchSpinner.succeed(`Found ${deployments.length} deployment(s)`);
+
         if (options.json) {
             console.log(JSON.stringify(deployments, null, 2));
             return;
@@ -53,7 +60,7 @@ export async function list(options) {
         // Display as table
         console.log('');
         console.log(chalk.bold('Your Deployments:'));
-        console.log(chalk.gray('─'.repeat(95)));
+        console.log(chalk.gray('─'.repeat(100)));
 
         // Header
         console.log(
@@ -61,43 +68,58 @@ export async function list(options) {
                 padRight('URL', 40) +
                 padRight('Folder', 15) +
                 padRight('Files', 7) +
+                padRight('Size', 12) +
                 padRight('Date', 12) +
                 'Status'
             )
         );
-        console.log(chalk.gray('─'.repeat(95)));
+        console.log(chalk.gray('─'.repeat(100)));
 
         // Rows (most recent first)
         const sorted = [...deployments].reverse();
         for (const dep of sorted) {
             const url = `https://${dep.subdomain}.launchpd.cloud`;
             const date = new Date(dep.timestamp).toLocaleDateString();
+            const size = dep.totalBytes ? formatSize(dep.totalBytes) : '-';
 
-            // Determine status
-            let status = chalk.green('active');
+            // Determine status with colors
+            let status;
             if (dep.expiresAt) {
                 if (isExpired(dep.expiresAt)) {
-                    status = chalk.red('expired');
+                    status = chalk.red.bold('● expired');
                 } else {
-                    status = chalk.yellow(formatTimeRemaining(dep.expiresAt));
+                    status = chalk.yellow(`⏱ ${formatTimeRemaining(dep.expiresAt)}`);
                 }
+            } else {
+                status = chalk.green.bold('● active');
             }
 
+            // Version badge
+            const versionBadge = chalk.magenta(`v${dep.version || 1}`);
+
             console.log(
                 chalk.cyan(padRight(url, 40)) +
-                padRight(dep.folderName || '-', 15) +
-                padRight(String(dep.fileCount), 7) +
+                chalk.white(padRight(dep.folderName || '-', 15)) +
+                chalk.white(padRight(String(dep.fileCount), 7)) +
+                chalk.white(padRight(size, 12)) +
                 chalk.gray(padRight(date, 12)) +
-                status
+                status + ' ' + versionBadge
             );
         }
 
-        console.log(chalk.gray('─'.repeat(95)));
-        console.log(chalk.gray(`Total: ${deployments.length} deployment(s)`) + (source === 'api' ? chalk.green(' (synced)') : chalk.yellow(' (local only)')));
+        console.log(chalk.gray('─'.repeat(100)));
+        const syncStatus = source === 'api'
+            ? chalk.green(' ✓ synced')
+            : chalk.yellow(' ⚠ local only');
+        console.log(chalk.gray(`Total: ${deployments.length} deployment(s)`) + syncStatus);
         console.log('');
 
     } catch (err) {
-        error(`Failed to list deployments: ${err.message}`);
+        errorWithSuggestions(`Failed to list deployments: ${err.message}`, [
+            'Check your internet connection',
+            'Use --local flag to show local deployments only',
+            'Try running with --verbose for more details',
+        ], { verbose, cause: err });
         process.exit(1);
     }
 }

package/src/commands/rollback.js

@@ -1,16 +1,20 @@
 import { getVersionsForSubdomain, setActiveVersion, getActiveVersion } from '../utils/metadata.js';
 import { getVersions as getVersionsFromAPI, rollbackVersion as rollbackViaAPI } from '../utils/api.js';
-import { success, error, info, warning } from '../utils/logger.js';
+import { error, errorWithSuggestions, info, warning, spinner } from '../utils/logger.js';
+import chalk from 'chalk';
 
 /**
  * Rollback a subdomain to a previous version
  * @param {string} subdomain - Subdomain to rollback
  * @param {object} options - Command options
  * @param {number} options.to - Specific version to rollback to (optional)
+ * @param {boolean} options.verbose - Show verbose error details
  */
 export async function rollback(subdomain, options) {
+    const verbose = options.verbose || false;
+
     try {
-        info(`Checking versions for ${subdomain}...`);
+        const fetchSpinner = spinner(`Checking versions for ${subdomain}...`);
 
         // Get all versions for this subdomain (try API first)
         let versions = [];
@@ -33,16 +37,22 @@ export async function rollback(subdomain, options) {
         }
 
         if (versions.length === 0) {
-            error(`No deployments found for subdomain: ${subdomain}`);
+            fetchSpinner.fail('No deployments found');
+            errorWithSuggestions(`No deployments found for subdomain: ${subdomain}`, [
+                'Check the subdomain name is correct',
+                'Run "launchpd list" to see your deployments',
+            ], { verbose });
             process.exit(1);
         }
 
         if (versions.length === 1) {
-            warning('Only one version exists. Nothing to rollback to.');
+            fetchSpinner.warn('Only one version exists');
+            warning('Nothing to rollback to.');
             process.exit(1);
         }
 
-        info(`Current active version: v${currentActive}`);
+        fetchSpinner.succeed(`Found ${versions.length} versions`);
+        info(`Current active version: ${chalk.cyan(`v${currentActive}`)}`);
 
         // Determine target version
         let targetVersion;
@@ -51,9 +61,12 @@ export async function rollback(subdomain, options) {
             const versionExists = versions.some(v => v.version === targetVersion);
             if (!versionExists) {
                 error(`Version ${targetVersion} does not exist.`);
+                console.log('');
                 info('Available versions:');
                 versions.forEach(v => {
-                    info(`  v${v.version} - ${v.timestamp}`);
+                    const isActive = v.version === currentActive;
+                    const marker = isActive ? chalk.green(' (active)') : '';
+                    console.log(`  ${chalk.cyan(`v${v.version}`)} - ${chalk.gray(v.timestamp)}${marker}`);
                 });
                 process.exit(1);
             }
@@ -69,18 +82,18 @@ export async function rollback(subdomain, options) {
         }
 
         if (targetVersion === currentActive) {
-            warning(`Version ${targetVersion} is already active.`);
+            warning(`Version ${chalk.cyan(`v${targetVersion}`)} is already active.`);
             process.exit(0);
         }
 
-        info(`Rolling back from v${currentActive} to v${targetVersion}...`);
+        const rollbackSpinner = spinner(`Rolling back from v${currentActive} to v${targetVersion}...`);
 
         // Set the target version as active
         if (useAPI) {
             // Use API for centralized rollback (updates both D1 and R2)
             const result = await rollbackViaAPI(subdomain, targetVersion);
             if (!result) {
-                warning('API unavailable, falling back to local rollback');
+                rollbackSpinner.warn('API unavailable, using local rollback');
                 await setActiveVersion(subdomain, targetVersion);
             }
         } else {
@@ -90,12 +103,16 @@ export async function rollback(subdomain, options) {
         // Find the target version's deployment record for file count
         const targetDeployment = versions.find(v => v.version === targetVersion);
 
-        success(`Rolled back to v${targetVersion} successfully!`);
+        rollbackSpinner.succeed(`Rolled back to ${chalk.cyan(`v${targetVersion}`)}`);
         console.log(`\n  🔄 https://${subdomain}.launchpd.cloud\n`);
-        info(`Restored deployment from: ${targetDeployment?.timestamp || 'unknown'}`);
+        info(`Restored deployment from: ${chalk.gray(targetDeployment?.timestamp || 'unknown')}`);
 
     } catch (err) {
-        error(`Rollback failed: ${err.message}`);
+        errorWithSuggestions(`Rollback failed: ${err.message}`, [
+            'Check your internet connection',
+            'Verify the subdomain and version exist',
+            'Run "launchpd versions <subdomain>" to see available versions',
+        ], { verbose, cause: err });
         process.exit(1);
     }
 }

package/src/commands/versions.js

@@ -1,16 +1,20 @@
 import { getVersionsForSubdomain, getActiveVersion } from '../utils/metadata.js';
 import { getVersions as getVersionsFromAPI } from '../utils/api.js';
-import { success, error, info } from '../utils/logger.js';
+import { success, errorWithSuggestions, info, spinner, formatSize } from '../utils/logger.js';
+import chalk from 'chalk';
 
 /**
  * List all versions for a subdomain
  * @param {string} subdomain - Subdomain to list versions for
  * @param {object} options - Command options
  * @param {boolean} options.json - Output as JSON
+ * @param {boolean} options.verbose - Show verbose error details
  */
 export async function versions(subdomain, options) {
+    const verbose = options.verbose || false;
+
     try {
-        info(`Fetching versions for ${subdomain}...`);
+        const fetchSpinner = spinner(`Fetching versions for ${subdomain}...`);
 
         let versionList = [];
         let activeVersion = 1;
@@ -32,10 +36,17 @@ export async function versions(subdomain, options) {
         }
 
         if (versionList.length === 0) {
-            error(`No deployments found for subdomain: ${subdomain}`);
+            fetchSpinner.fail(`No deployments found for: ${subdomain}`);
+            errorWithSuggestions(`No deployments found for subdomain: ${subdomain}`, [
+                'Check the subdomain name is correct',
+                'Run "launchpd list" to see your deployments',
+                'Deploy a new site with "launchpd deploy ./folder"',
+            ], { verbose });
             process.exit(1);
         }
 
+        fetchSpinner.succeed(`Found ${versionList.length} version(s)`);
+
         if (options.json) {
             console.log(JSON.stringify({
                 subdomain,
@@ -52,24 +63,37 @@ export async function versions(subdomain, options) {
         }
 
         console.log('');
-        success(`Versions for ${subdomain}.launchpd.cloud:`);
+        success(`Versions for ${chalk.cyan(subdomain)}.launchpd.cloud:`);
         console.log('');
 
+        // Table header
+        console.log(chalk.gray('  Version   Date                     Files    Size         Status'));
+        console.log(chalk.gray('  ' + '─'.repeat(70)));
+
         for (const v of versionList) {
             const isActive = v.version === activeVersion;
-            const activeMarker = isActive ? ' ← active' : '';
-            const sizeKB = v.totalBytes ? `${(v.totalBytes / 1024).toFixed(1)} KB` : 'unknown size';
-            const date = new Date(v.timestamp).toLocaleString();
+            const versionStr = chalk.bold.cyan(`v${v.version}`);
+            const date = chalk.gray(new Date(v.timestamp).toLocaleString());
+            const files = chalk.white(`${v.fileCount} files`);
+            const size = v.totalBytes ? chalk.white(formatSize(v.totalBytes)) : chalk.gray('unknown');
+            const status = isActive
+                ? chalk.green.bold('● active')
+                : chalk.gray('○ inactive');
 
-            console.log(`  v${v.version}  │  ${date}  │  ${v.fileCount} files  │  ${sizeKB}${activeMarker}`);
+            console.log(`  ${versionStr.padEnd(18)}${date.padEnd(30)}${files.padEnd(12)}${size.padEnd(14)}${status}`);
         }
 
+        console.log(chalk.gray('  ' + '─'.repeat(70)));
         console.log('');
-        info(`Use 'launchpd rollback ${subdomain} --to <n>' to restore a version.`);
+        info(`Use ${chalk.cyan(`launchpd rollback ${subdomain} --to <n>`)} to restore a version.`);
         console.log('');
 
     } catch (err) {
-        error(`Failed to list versions: ${err.message}`);
+        errorWithSuggestions(`Failed to list versions: ${err.message}`, [
+            'Check your internet connection',
+            'Verify the subdomain exists',
+            'Try running with --verbose for more details',
+        ], { verbose, cause: err });
         process.exit(1);
     }
 }

package/src/utils/logger.js

@@ -1,4 +1,8 @@
 import chalk from 'chalk';
+import ora from 'ora';
+
+// Store active spinner reference
+let activeSpinner = null;
 
 /**
  * Log a success message
@@ -11,9 +15,16 @@ export function success(message) {
 /**
  * Log an error message
  * @param {string} message
+ * @param {object} options - Optional error details
+ * @param {boolean} options.verbose - Show verbose error details
+ * @param {Error} options.cause - Original error for verbose mode
  */
-export function error(message) {
+export function error(message, options = {}) {
     console.error(chalk.red.bold('✗'), chalk.red(message));
+    if (options.verbose && options.cause) {
+        console.error(chalk.gray('  Stack trace:'));
+        console.error(chalk.gray(`  ${options.cause.stack || options.cause.message}`));
+    }
 }
 
 /**
@@ -31,3 +42,115 @@ export function info(message) {
 export function warning(message) {
     console.log(chalk.yellow.bold('⚠'), chalk.yellow(message));
 }
+
+/**
+ * Create and start a spinner
+ * @param {string} text - Initial spinner text
+ * @returns {object} - Spinner instance with helper methods
+ */
+export function spinner(text) {
+    activeSpinner = ora({
+        text,
+        color: 'cyan',
+        spinner: 'dots',
+    }).start();
+
+    return {
+        /**
+         * Update spinner text
+         * @param {string} newText
+         */
+        update(newText) {
+            if (activeSpinner) {
+                activeSpinner.text = newText;
+            }
+        },
+
+        /**
+         * Mark spinner as successful and stop
+         * @param {string} text - Success message
+         */
+        succeed(text) {
+            if (activeSpinner) {
+                activeSpinner.succeed(chalk.green(text));
+                activeSpinner = null;
+            }
+        },
+
+        /**
+         * Mark spinner as failed and stop
+         * @param {string} text - Failure message
+         */
+        fail(text) {
+            if (activeSpinner) {
+                activeSpinner.fail(chalk.red(text));
+                activeSpinner = null;
+            }
+        },
+
+        /**
+         * Stop spinner with info message
+         * @param {string} text - Info message
+         */
+        info(text) {
+            if (activeSpinner) {
+                activeSpinner.info(chalk.blue(text));
+                activeSpinner = null;
+            }
+        },
+
+        /**
+         * Stop spinner with warning
+         * @param {string} text - Warning message
+         */
+        warn(text) {
+            if (activeSpinner) {
+                activeSpinner.warn(chalk.yellow(text));
+                activeSpinner = null;
+            }
+        },
+
+        /**
+         * Stop spinner without any symbol
+         */
+        stop() {
+            if (activeSpinner) {
+                activeSpinner.stop();
+                activeSpinner = null;
+            }
+        },
+    };
+}
+
+/**
+ * Format bytes to human readable size (KB/MB/GB)
+ * @param {number} bytes - Size in bytes
+ * @param {number} decimals - Number of decimal places
+ * @returns {string} - Formatted size string
+ */
+export function formatSize(bytes, decimals = 2) {
+    if (bytes === 0) return '0 Bytes';
+
+    const k = 1024;
+    const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB'];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+
+    return `${Number.parseFloat((bytes / Math.pow(k, i)).toFixed(decimals))} ${sizes[i]}`;
+}
+
+/**
+ * Log helpful error with suggestions
+ * @param {string} message - Error message
+ * @param {string[]} suggestions - Array of suggested actions
+ * @param {object} options - Error options
+ */
+export function errorWithSuggestions(message, suggestions = [], options = {}) {
+    error(message, options);
+    if (suggestions.length > 0) {
+        console.log('');
+        console.log(chalk.yellow('💡 Suggestions:'));
+        suggestions.forEach(suggestion => {
+            console.log(chalk.gray(`   • ${suggestion}`));
+        });
+    }
+}

package/src/utils/upload.js

@@ -2,7 +2,6 @@ import { readdir, readFile } from 'node:fs/promises';
 import { join, relative, posix, sep } from 'node:path';
 import mime from 'mime-types';
 import { config } from '../config.js';
-import { info } from './logger.js';
 
 const API_BASE_URL = `https://api.${config.domain}`;
 
@@ -91,8 +90,9 @@ async function completeUpload(subdomain, version, fileCount, totalBytes, folderN
  * @param {string} localPath - Local folder path
  * @param {string} subdomain - Subdomain to use as bucket prefix
  * @param {number} version - Version number for this deployment
+ * @param {function} onProgress - Progress callback (uploaded, total, fileName)
  */
-export async function uploadFolder(localPath, subdomain, version = 1) {
+export async function uploadFolder(localPath, subdomain, version = 1, onProgress = null) {
     const files = await readdir(localPath, { recursive: true, withFileTypes: true });
 
     let uploaded = 0;
@@ -119,7 +119,11 @@ export async function uploadFolder(localPath, subdomain, version = 1) {
         await uploadFile(body, subdomain, version, posixPath, contentType);
 
         uploaded++;
-        info(`  Uploaded (${uploaded}/${total}): ${posixPath}`);
+
+        // Call progress callback if provided
+        if (onProgress) {
+            onProgress(uploaded, total, posixPath);
+        }
     }
 
     return { uploaded, subdomain, totalBytes };