launchpd 0.1.2 → 0.1.5

package/src/commands/deploy.js

@@ -2,11 +2,11 @@ import { existsSync, statSync } from 'node:fs';
 import { readdir } from 'node:fs/promises';
 import { resolve, basename, join } from 'node:path';
 import { generateSubdomain } from '../utils/id.js';
-import { uploadFolder } from '../utils/upload.js';
-import { recordDeployment as recordMetadata, getNextVersion, setActiveVersion } from '../utils/metadata.js';
+import { uploadFolder, finalizeUpload } from '../utils/upload.js';
+import { getNextVersion } from '../utils/metadata.js';
 import { saveLocalDeployment } from '../utils/localConfig.js';
-import { recordDeployment as recordToAPI, getNextVersionFromAPI } from '../utils/api.js';
-import { success, error, info, warning } from '../utils/logger.js';
+import { getNextVersionFromAPI } from '../utils/api.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;
@@ -135,42 +153,37 @@ export async function deploy(folder, options) {
 
     // Perform actual upload
     try {
-        // Get next version number for this subdomain (try API first, fallback to R2)
+        // 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}`);
 
-        const { totalBytes } = await uploadFolder(folderPath, subdomain, version);
+        // Upload all files via API proxy
+        const folderName = basename(folderPath);
+        const uploadSpinner = spinner(`Uploading files... 0/${fileCount}`);
 
-        // Set this version as active
-        await setActiveVersion(subdomain, version);
+        const { totalBytes } = await uploadFolder(folderPath, subdomain, version, (uploaded, total, fileName) => {
+            uploadSpinner.update(`Uploading files... ${uploaded}/${total} (${fileName})`);
+        });
 
-        // Record deployment metadata
-        info('Recording deployment metadata...');
+        uploadSpinner.succeed(`Uploaded ${fileCount} files (${formatSize(totalBytes)})`);
 
-        // Try API first for centralized storage
-        const folderName = basename(folderPath);
-        const apiResult = await recordToAPI({
+        // Finalize upload: set active version and record metadata
+        const finalizeSpinner = spinner('Finalizing deployment...');
+        await finalizeUpload(
             subdomain,
-            folderName,
+            version,
             fileCount,
             totalBytes,
-            version,
-            expiresAt: expiresAt?.toISOString() || null,
-        });
-
-        if (apiResult) {
-            // API succeeded - deployment is centrally tracked
-            info('Deployment recorded to central API');
-        } else {
-            // API unavailable - fallback to R2 metadata
-            warning('Central API unavailable, using local fallback');
-            await recordMetadata(subdomain, folderPath, fileCount, totalBytes, version, expiresAt);
-        }
+            folderName,
+            expiresAt?.toISOString() || null
+        );
+        finalizeSpinner.succeed('Deployment finalized');
 
-        // Always save locally for quick access
+        // Save locally for quick access
         await saveLocalDeployment({
             subdomain,
             folderName,
@@ -182,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/config.js

@@ -1,36 +1,14 @@
-import 'dotenv/config';
-
 /**
- * Application configuration loaded from environment variables
+ * Application configuration for Launchpd CLI
+ * No credentials needed - uploads go through the API proxy
  */
 export const config = {
-    r2: {
-        accountId: process.env.R2_ACCOUNT_ID || '',
-        accessKeyId: process.env.R2_ACCESS_KEY_ID || '',
-        secretAccessKey: process.env.R2_SECRET_ACCESS_KEY || '',
-        bucketName: process.env.R2_BUCKET_NAME || 'launchpd',
-    },
-
     // Base domain for deployments
-    domain: process.env.STATICLAUNCH_DOMAIN || 'launchpd.cloud',
-};
-
-/**
- * Validate required configuration
- * @returns {boolean} true if all required config is present
- */
-export function validateConfig() {
-    const required = [
-        'R2_ACCOUNT_ID',
-        'R2_ACCESS_KEY_ID',
-        'R2_SECRET_ACCESS_KEY',
-    ];
+    domain: 'launchpd.cloud',
 
-    const missing = required.filter(key => !process.env[key]);
+    // API endpoint
+    apiUrl: 'https://api.launchpd.cloud',
 
-    if (missing.length > 0) {
-        return { valid: false, missing };
-    }
-
-    return { valid: true, missing: [] };
-}
+    // CLI version
+    version: '0.1.1',
+};