launchpd 1.0.0

package/src/commands/deploy.js

@@ -0,0 +1,242 @@
+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, 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, 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';
+
+/**
+ * Calculate total size of a folder
+ */
+async function calculateFolderSize(folderPath) {
+    const files = await readdir(folderPath, { recursive: true, withFileTypes: true });
+    let totalSize = 0;
+
+    for (const file of files) {
+        if (file.isFile()) {
+            const fullPath = file.parentPath
+                ? join(file.parentPath, file.name)
+                : join(folderPath, file.name);
+            try {
+                const stats = statSync(fullPath);
+                totalSize += stats.size;
+            } catch {
+                // File may have been deleted
+            }
+        }
+    }
+
+    return totalSize;
+}
+
+/**
+ * Deploy a local folder to StaticLaunch
+ * @param {string} folder - Path to folder to deploy
+ * @param {object} options - Command options
+ * @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;
+    if (options.expires) {
+        try {
+            expiresAt = calculateExpiresAt(options.expires);
+        } catch (err) {
+            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)) {
+        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) {
+        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
+    // Anonymous users cannot use custom subdomains
+    const creds = await getCredentials();
+    if (options.name && !creds?.email) {
+        warning('Custom subdomains require registration!');
+        info('Anonymous deployments use random subdomains.');
+        info('Run "launchpd register" to use --name option.');
+        console.log('');
+    }
+
+    const subdomain = (options.name && creds?.email) ? options.name.toLowerCase() : generateSubdomain();
+    const url = `https://${subdomain}.launchpd.cloud`;
+
+    // Check if custom subdomain is taken
+    if (options.name && creds?.email) {
+        const checkSpinner = spinner('Checking subdomain availability...');
+        try {
+            const { checkSubdomainAvailable, listSubdomains } = await import('../utils/api.js');
+            const isAvailable = await checkSubdomainAvailable(subdomain);
+
+            if (!isAvailable) {
+                // Check if the current user owns it
+                const result = await listSubdomains();
+                const owned = result?.subdomains?.some(s => s.subdomain === subdomain);
+
+                if (owned) {
+                    checkSpinner.succeed(`Deploying new version to your subdomain: "${subdomain}"`);
+                } else {
+                    checkSpinner.fail(`Subdomain "${subdomain}" is already taken`);
+                    warning('Choose a different subdomain name with --name or deployment without it.');
+                    process.exit(1);
+                }
+            } else {
+                checkSpinner.succeed(`Subdomain "${subdomain}" is available`);
+            }
+        } catch {
+            checkSpinner.warn('Could not verify subdomain availability');
+        }
+    }
+
+    // Calculate estimated upload size
+    const sizeSpinner = spinner('Calculating folder size...');
+    const estimatedBytes = await calculateFolderSize(folderPath);
+    sizeSpinner.succeed(`Size: ${formatSize(estimatedBytes)}`);
+
+    // Check quota before deploying
+    const quotaSpinner = spinner('Checking quota...');
+    const quotaCheck = await checkQuota(subdomain, estimatedBytes);
+
+    if (!quotaCheck.allowed) {
+        quotaSpinner.fail('Deployment blocked due to quota limits');
+        process.exit(1);
+    }
+    quotaSpinner.succeed('Quota check passed');
+
+    // Display any warnings
+    displayQuotaWarnings(quotaCheck.warnings);
+
+    // Show current user status (creds already fetched above)
+    if (creds?.email) {
+        info(`Deploying as: ${creds.email}`);
+    } else {
+        info('Deploying as: anonymous (run "launchpd login" for more quota)');
+    }
+
+    info(`Deploying ${fileCount} file(s) from ${folderPath}`);
+    info(`Target: ${url}`);
+
+    // 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);
+        }
+        versionSpinner.succeed(`Deploying as version ${version}`);
+
+        // Upload all files via API proxy
+        const folderName = basename(folderPath);
+        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
+        const finalizeSpinner = spinner('Finalizing deployment...');
+        await finalizeUpload(
+            subdomain,
+            version,
+            fileCount,
+            totalBytes,
+            folderName,
+            expiresAt?.toISOString() || null
+        );
+        finalizeSpinner.succeed('Deployment finalized');
+
+        // Save locally for quick access
+        await saveLocalDeployment({
+            subdomain,
+            folderName,
+            fileCount,
+            totalBytes,
+            version,
+            timestamp: new Date().toISOString(),
+            expiresAt: expiresAt?.toISOString() || null,
+        });
+
+        success(`Deployed successfully! (v${version})`);
+        console.log(`\n${url}`);
+        if (expiresAt) {
+            warning(`Expires: ${formatTimeRemaining(expiresAt)}`);
+        }
+
+        // Show anonymous limit warnings
+        if (!creds?.email) {
+            console.log('');
+            warning('Anonymous deployment limits:');
+            console.log('   • 3 active sites per IP');
+            console.log('   • 50MB total storage');
+            console.log('   • 7-day site expiration');
+            console.log('');
+            info('Run "launchpd register" to unlock unlimited sites and permanent storage!');
+        }
+        console.log('');
+    } catch (err) {
+        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/index.js

@@ -0,0 +1,9 @@
+/**
+ * Commands index - exports all CLI commands
+ */
+
+export { deploy } from './deploy.js';
+export { list } from './list.js';
+export { rollback } from './rollback.js';
+export { versions } from './versions.js';
+export { login, logout, register, whoami, quota } from './auth.js';

package/src/commands/list.js

@@ -0,0 +1,133 @@
+import { getLocalDeployments } from '../utils/localConfig.js';
+import { listDeployments as listFromAPI } from '../utils/api.js';
+import { errorWithSuggestions, info, spinner, formatSize } from '../utils/logger.js';
+import { formatTimeRemaining, isExpired } from '../utils/expiration.js';
+import chalk from 'chalk';
+
+/**
+ * List all deployments (from API or local storage)
+ * @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();
+            if (apiResult && apiResult.deployments) {
+                deployments = apiResult.deployments.map(d => ({
+                    subdomain: d.subdomain,
+                    folderName: d.folder_name,
+                    fileCount: d.file_count,
+                    totalBytes: d.total_bytes,
+                    version: d.version,
+                    timestamp: d.created_at,
+                    expiresAt: d.expires_at,
+                    isActive: d.active_version === d.version,
+                }));
+                source = 'api';
+            }
+        }
+
+        // Fallback to local storage if API unavailable
+        if (deployments.length === 0) {
+            deployments = await getLocalDeployments();
+            source = 'local';
+        }
+
+        if (deployments.length === 0) {
+            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;
+        }
+
+        // Display as table
+        console.log('');
+        console.log(chalk.bold('Your Deployments:'));
+        console.log(chalk.gray('─'.repeat(100)));
+
+        // Header
+        console.log(
+            chalk.gray(
+                padRight('URL', 40) +
+                padRight('Folder', 15) +
+                padRight('Files', 7) +
+                padRight('Size', 12) +
+                padRight('Date', 12) +
+                'Status'
+            )
+        );
+        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 with colors
+            let status;
+            if (dep.expiresAt) {
+                if (isExpired(dep.expiresAt)) {
+                    status = chalk.red.bold('● expired');
+                } else {
+                    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)) +
+                chalk.white(padRight(dep.folderName || '-', 15)) +
+                chalk.white(padRight(String(dep.fileCount), 7)) +
+                chalk.white(padRight(size, 12)) +
+                chalk.gray(padRight(date, 12)) +
+                status + ' ' + versionBadge
+            );
+        }
+
+        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) {
+        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);
+    }
+}
+
+/**
+ * Pad string to the right
+ */
+function padRight(str, len) {
+    if (str.length >= len) return str.substring(0, len - 1) + ' ';
+    return str + ' '.repeat(len - str.length);
+}

package/src/commands/rollback.js

@@ -0,0 +1,119 @@
+import { getVersionsForSubdomain, setActiveVersion, getActiveVersion } from '../utils/metadata.js';
+import { getVersions as getVersionsFromAPI, rollbackVersion as rollbackViaAPI } from '../utils/api.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(subdomainInput, options) {
+    const subdomain = subdomainInput.toLowerCase();
+    const verbose = options.verbose || false;
+
+    try {
+        const fetchSpinner = spinner(`Checking versions for ${subdomain}...`);
+
+        // Get all versions for this subdomain (try API first)
+        let versions = [];
+        let currentActive = 1;
+        let useAPI = false;
+
+        const apiResult = await getVersionsFromAPI(subdomain);
+        if (apiResult && apiResult.versions) {
+            versions = apiResult.versions.map(v => ({
+                version: v.version,
+                timestamp: v.created_at,
+                fileCount: v.file_count,
+            }));
+            currentActive = apiResult.activeVersion || 1;
+            useAPI = true;
+        } else {
+            // Fallback to R2 metadata
+            versions = await getVersionsForSubdomain(subdomain);
+            currentActive = await getActiveVersion(subdomain);
+        }
+
+        if (versions.length === 0) {
+            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) {
+            fetchSpinner.warn('Only one version exists');
+            warning('Nothing to rollback to.');
+            process.exit(1);
+        }
+
+        fetchSpinner.succeed(`Found ${versions.length} versions`);
+        info(`Current active version: ${chalk.cyan(`v${currentActive}`)}`);
+
+        // Determine target version
+        let targetVersion;
+        if (options.to) {
+            targetVersion = Number.parseInt(options.to, 10);
+            const versionExists = versions.some(v => v.version === targetVersion);
+            if (!versionExists) {
+                error(`Version ${targetVersion} does not exist.`);
+                console.log('');
+                info('Available versions:');
+                versions.forEach(v => {
+                    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);
+            }
+        } else {
+            // Default: rollback to previous version
+            const sortedVersions = versions.map(v => v.version).sort((a, b) => b - a);
+            const currentIndex = sortedVersions.indexOf(currentActive);
+            if (currentIndex === sortedVersions.length - 1) {
+                warning('Already at the oldest version. Cannot rollback further.');
+                process.exit(1);
+            }
+            targetVersion = sortedVersions[currentIndex + 1];
+        }
+
+        if (targetVersion === currentActive) {
+            warning(`Version ${chalk.cyan(`v${targetVersion}`)} is already active.`);
+            process.exit(0);
+        }
+
+        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) {
+                rollbackSpinner.warn('API unavailable, using local rollback');
+                await setActiveVersion(subdomain, targetVersion);
+            }
+        } else {
+            await setActiveVersion(subdomain, targetVersion);
+        }
+
+        // Find the target version's deployment record for file count
+        const targetDeployment = versions.find(v => v.version === targetVersion);
+
+        rollbackSpinner.succeed(`Rolled back to ${chalk.cyan(`v${targetVersion}`)}`);
+        console.log(`\n  🔄 https://${subdomain}.launchpd.cloud\n`);
+        info(`Restored deployment from: ${chalk.gray(targetDeployment?.timestamp || 'unknown')}`);
+
+    } catch (err) {
+        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

@@ -0,0 +1,117 @@
+import { getVersionsForSubdomain, getActiveVersion } from '../utils/metadata.js';
+import { getVersions as getVersionsFromAPI } from '../utils/api.js';
+import { isLoggedIn } from '../utils/credentials.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(subdomainInput, options) {
+    const subdomain = subdomainInput.toLowerCase();
+    const verbose = options.verbose || false;
+
+    if (!await isLoggedIn()) {
+        errorWithSuggestions('The versions feature is only available for authenticated users.', [
+            'Run "launchpd login" to log in to your account',
+            'Run "launchpd register" to create a new account',
+        ], { verbose });
+        process.exit(1);
+    }
+
+    try {
+        const fetchSpinner = spinner(`Fetching versions for ${subdomain}...`);
+
+        let versionList = [];
+        let activeVersion = 1;
+
+        // Try API first
+        const apiResult = await getVersionsFromAPI(subdomain);
+        if (apiResult && apiResult.versions) {
+            versionList = apiResult.versions.map(v => ({
+                version: v.version,
+                timestamp: v.created_at,
+                fileCount: v.file_count,
+                totalBytes: v.total_bytes,
+            }));
+            activeVersion = apiResult.activeVersion || 1;
+        } else {
+            // Fallback to R2 metadata
+            versionList = await getVersionsForSubdomain(subdomain);
+            activeVersion = await getActiveVersion(subdomain);
+        }
+
+        if (versionList.length === 0) {
+            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,
+                activeVersion,
+                versions: versionList.map(v => ({
+                    version: v.version,
+                    timestamp: v.timestamp,
+                    fileCount: v.fileCount,
+                    totalBytes: v.totalBytes,
+                    isActive: v.version === activeVersion,
+                })),
+            }, null, 2));
+            return;
+        }
+
+        console.log('');
+        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;
+
+            // Format raw strings for correct padding calculation
+            const versionRaw = `v${v.version}`;
+            const dateRaw = new Date(v.timestamp).toLocaleString();
+            const filesRaw = `${v.fileCount} files`;
+            const sizeRaw = v.totalBytes ? formatSize(v.totalBytes) : 'unknown';
+
+            // Apply colors and padding separately
+            const versionStr = chalk.bold.cyan(versionRaw.padEnd(12));
+            const dateStr = chalk.gray(dateRaw.padEnd(25));
+            const filesStr = chalk.white(filesRaw.padEnd(10));
+            const sizeStr = chalk.white(sizeRaw.padEnd(12));
+            const statusStr = isActive
+                ? chalk.green.bold('● active')
+                : chalk.gray('○ inactive');
+
+            console.log(`  ${versionStr}${dateStr}${filesStr}${sizeStr}${statusStr}`);
+        }
+
+        console.log(chalk.gray('  ' + '─'.repeat(70)));
+        console.log('');
+        info(`Use ${chalk.cyan(`launchpd rollback ${subdomain} --to <n>`)} to restore a version.`);
+        console.log('');
+
+    } catch (err) {
+        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

@@ -0,0 +1,14 @@
+/**
+ * Application configuration for Launchpd CLI
+ * No credentials needed - uploads go through the API proxy
+ */
+export const config = {
+    // Base domain for deployments
+    domain: 'launchpd.cloud',
+
+    // API endpoint
+    apiUrl: 'https://api.launchpd.cloud',
+
+    // CLI version
+    version: '0.1.12',
+};