launchpd 0.1.0

package/src/commands/auth.js

@@ -0,0 +1,324 @@
+/**
+ * Authentication commands for StaticLaunch CLI
+ * login, logout, register, whoami
+ */
+
+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';
+
+const API_BASE_URL = `https://api.${config.domain}`;
+const REGISTER_URL = `https://portal.${config.domain}/auth/register`;
+
+/**
+ * Prompt for user input
+ */
+function prompt(question) {
+    const rl = createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+
+    return new Promise((resolve) => {
+        rl.question(question, (answer) => {
+            rl.close();
+            resolve(answer.trim());
+        });
+    });
+}
+
+/**
+ * Validate API key with the server
+ */
+async function validateApiKey(apiKey) {
+    try {
+        const response = await fetch(`${API_BASE_URL}/api/quota`, {
+            headers: {
+                'X-API-Key': apiKey,
+            },
+        });
+
+        if (!response.ok) {
+            return null;
+        }
+
+        const data = await response.json();
+        if (data.authenticated) {
+            return data;
+        }
+        return null;
+    } catch (err) {
+        error(`Failed to validate API key: ${err.message}`);
+        return null;
+    }
+}
+
+/**
+ * Login command - prompts for API key and validates it
+ */
+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}`);
+        info('Run "launchpd logout" to switch accounts');
+        return;
+    }
+
+    console.log('\n🔐 Launchpd Login\n');
+    console.log('Enter your API key from the dashboard.');
+    console.log(`Don't have one? Run "launchpd register" first.\n`);
+
+    const apiKey = await prompt('API Key: ');
+
+    if (!apiKey) {
+        error('API key is required');
+        process.exit(1);
+    }
+
+    info('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`);
+        process.exit(1);
+    }
+
+    // Save credentials
+    await saveCredentials({
+        apiKey,
+        userId: result.user?.id,
+        email: result.user?.email,
+        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`);
+}
+
+/**
+ * Logout command - clears stored credentials
+ */
+export async function logout() {
+    const loggedIn = await isLoggedIn();
+
+    if (!loggedIn) {
+        warning('Not currently logged in');
+        return;
+    }
+
+    const creds = await getCredentials();
+    await clearCredentials();
+
+    success(`Logged out successfully`);
+    if (creds?.email) {
+        info(`Was logged in as: ${creds.email}`);
+    }
+    console.log(`\nYou can still deploy anonymously (limited to 3 sites, 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`);
+
+    // Open browser based on platform
+    const platform = process.platform;
+    let cmd;
+
+    if (platform === 'darwin') {
+        cmd = `open "${REGISTER_URL}"`;
+    } else if (platform === 'win32') {
+        cmd = `start "" "${REGISTER_URL}"`;
+    } else {
+        cmd = `xdg-open "${REGISTER_URL}"`;
+    }
+
+    exec(cmd, (err) => {
+        if (err) {
+            console.log(`Please open this URL in your browser:\n  ${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('');
+
+    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('');
+}
+
+/**
+ * Whoami command - shows current user info and quota status
+ */
+export async function whoami() {
+    const creds = await getCredentials();
+
+    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`);
+        return;
+    }
+
+    info('Fetching account status...');
+
+    // Validate and get current quota
+    const result = await validateApiKey(creds.apiKey);
+
+    if (!result) {
+        warning('Session expired or API key invalid');
+        await clearCredentials();
+        error('Please login again with: launchpd login');
+        process.exit(1);
+    }
+
+    console.log(`\n👤 Logged in as: ${result.user?.email || result.user?.id}\n`);
+
+    console.log('Account Info:');
+    console.log(`  User ID: ${result.user?.id}`);
+    console.log(`  Email: ${result.user?.email || 'Not set'}`);
+    console.log(`  Tier: ${result.tier}`);
+    console.log('');
+
+    console.log('Usage:');
+    console.log(`  Sites: ${result.usage?.siteCount || 0} / ${result.limits?.maxSites}`);
+    console.log(`  Storage: ${result.usage?.storageUsedMB || 0}MB / ${result.limits?.maxStorageMB}MB`);
+    console.log(`  Sites remaining: ${result.usage?.sitesRemaining || 0}`);
+    console.log(`  Storage remaining: ${result.usage?.storageRemainingMB || 0}MB`);
+    console.log('');
+
+    console.log('Limits:');
+    console.log(`  Max versions per site: ${result.limits?.maxVersionsPerSite}`);
+    console.log(`  Retention: ${result.limits?.retentionDays} days`);
+    console.log('');
+
+    // Show warnings
+    if (result.warnings && result.warnings.length > 0) {
+        console.log('⚠️ Warnings:');
+        result.warnings.forEach(w => console.log(`  ${w}`));
+        console.log('');
+    }
+
+    if (!result.canCreateNewSite) {
+        warning('You cannot create new sites (limit reached)');
+        info('You can still update existing sites');
+    }
+}
+
+/**
+ * Quota command - shows detailed quota information
+ */
+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('');
+        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('');
+        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('');
+        console.log('Run: launchpd register');
+        console.log('');
+        return;
+    }
+
+    info('Fetching quota status...');
+
+    const result = await validateApiKey(creds.apiKey);
+
+    if (!result) {
+        error('Failed to fetch quota. API key may be invalid.');
+        process.exit(1);
+    }
+
+    console.log(`\n📊 Quota Status for: ${result.user?.email || creds.email}\n`);
+
+    // Sites usage
+    const sitesUsed = result.usage?.siteCount || 0;
+    const sitesMax = result.limits?.maxSites || 10;
+    const sitesPercent = Math.round((sitesUsed / sitesMax) * 100);
+    const sitesBar = createProgressBar(sitesUsed, sitesMax);
+
+    console.log(`Sites:    ${sitesBar} ${sitesUsed}/${sitesMax} (${sitesPercent}%)`);
+
+    // Storage usage
+    const storageMB = result.usage?.storageUsedMB || 0;
+    const storageMaxMB = result.limits?.maxStorageMB || 100;
+    const storagePercent = Math.round((storageMB / storageMaxMB) * 100);
+    const storageBar = createProgressBar(storageMB, storageMaxMB);
+
+    console.log(`Storage:  ${storageBar} ${storageMB}MB/${storageMaxMB}MB (${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('');
+
+    // Status indicators
+    if (result.canCreateNewSite === false) {
+        warning('⚠️ Site limit reached - cannot create new sites');
+    }
+
+    if (storagePercent > 80) {
+        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');
+    }
+    console.log('');
+}
+
+/**
+ * Create a simple progress bar
+ */
+function createProgressBar(current, max, width = 20) {
+    const filled = Math.round((current / max) * width);
+    const empty = width - filled;
+    const percent = (current / max) * 100;
+
+    let bar = '';
+    if (percent >= 90) {
+        bar = '█'.repeat(filled) + '░'.repeat(empty);
+    } else if (percent >= 70) {
+        bar = '█'.repeat(filled) + '░'.repeat(empty);
+    } else {
+        bar = '█'.repeat(filled) + '░'.repeat(empty);
+    }
+
+    return `[${bar}]`;
+}

package/src/commands/deploy.js

@@ -0,0 +1,194 @@
+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 { saveLocalDeployment } from '../utils/localConfig.js';
+import { recordDeployment as recordToAPI, getNextVersionFromAPI } from '../utils/api.js';
+import { success, error, info, warning } 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 {boolean} options.dryRun - Skip actual upload
+ * @param {string} options.name - Custom subdomain
+ * @param {string} options.expires - Expiration time (e.g., "30m", "2h", "1d")
+ */
+export async function deploy(folder, options) {
+    const folderPath = resolve(folder);
+
+    // Parse expiration if provided
+    let expiresAt = null;
+    if (options.expires) {
+        try {
+            expiresAt = calculateExpiresAt(options.expires);
+        } catch (err) {
+            error(err.message);
+            process.exit(1);
+        }
+    }
+
+    // Validate folder exists
+    if (!existsSync(folderPath)) {
+        error(`Folder not found: ${folderPath}`);
+        process.exit(1);
+    }
+
+    // Check folder is not empty
+    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.');
+        process.exit(1);
+    }
+
+    // Generate or use provided subdomain
+    const subdomain = options.name || generateSubdomain();
+    const url = `https://${subdomain}.launchpd.cloud`;
+
+    // Calculate estimated upload size
+    const estimatedBytes = await calculateFolderSize(folderPath);
+
+    // Check quota before deploying
+    info('Checking quota...');
+    const quotaCheck = await checkQuota(subdomain, estimatedBytes);
+
+    if (!quotaCheck.allowed) {
+        error('Deployment blocked due to quota limits');
+        process.exit(1);
+    }
+
+    // Display any warnings
+    displayQuotaWarnings(quotaCheck.warnings);
+
+    // Show current user status
+    const creds = await getCredentials();
+    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}`);
+    info(`Size: ${(estimatedBytes / 1024 / 1024).toFixed(2)}MB`);
+
+    if (options.dryRun) {
+        warning('Dry run mode - skipping upload');
+
+        // List files that would be uploaded
+        for (const file of files) {
+            if (file.isFile()) {
+                const relativePath = file.parentPath
+                    ? `${file.parentPath.replace(folderPath, '')}/${file.name}`.replace(/^[\\/]/, '')
+                    : file.name;
+                info(`  Would upload: ${relativePath.replaceAll('\\', '/')}`);
+            }
+        }
+
+        success(`Dry run complete. ${fileCount} file(s) would be deployed to:`);
+        console.log(`\n  ${url}\n`);
+
+        // Show quota status after dry run
+        if (quotaCheck.quota) {
+            console.log('Quota after this deploy:');
+            const storageAfter = (quotaCheck.quota.usage?.storageUsed || 0) + estimatedBytes;
+            const sitesAfter = quotaCheck.isNewSite
+                ? (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('');
+        }
+        return;
+    }
+
+    // Perform actual upload
+    try {
+        // Get next version number for this subdomain (try API first, fallback to R2)
+        let version = await getNextVersionFromAPI(subdomain);
+        if (version === null) {
+            version = await getNextVersion(subdomain);
+        }
+        info(`Deploying as version ${version}...`);
+
+        const { totalBytes } = await uploadFolder(folderPath, subdomain, version);
+
+        // Set this version as active
+        await setActiveVersion(subdomain, version);
+
+        // Record deployment metadata
+        info('Recording deployment metadata...');
+
+        // Try API first for centralized storage
+        const folderName = basename(folderPath);
+        const apiResult = await recordToAPI({
+            subdomain,
+            folderName,
+            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);
+        }
+
+        // Always 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)}`);
+        }
+        console.log('');
+    } catch (err) {
+        error(`Upload failed: ${err.message}`);
+        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,111 @@
+import { getLocalDeployments } from '../utils/localConfig.js';
+import { listDeployments as listFromAPI } from '../utils/api.js';
+import { error, info, warning } 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
+ */
+export async function list(options) {
+    try {
+        let deployments = [];
+        let source = 'local';
+
+        // 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) {
+            warning('No deployments found.');
+            info('Deploy a folder with: launchpd deploy ./my-folder');
+            return;
+        }
+
+        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(95)));
+
+        // Header
+        console.log(
+            chalk.gray(
+                padRight('URL', 40) +
+                padRight('Folder', 15) +
+                padRight('Files', 7) +
+                padRight('Date', 12) +
+                'Status'
+            )
+        );
+        console.log(chalk.gray('─'.repeat(95)));
+
+        // 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();
+
+            // Determine status
+            let status = chalk.green('active');
+            if (dep.expiresAt) {
+                if (isExpired(dep.expiresAt)) {
+                    status = chalk.red('expired');
+                } else {
+                    status = chalk.yellow(formatTimeRemaining(dep.expiresAt));
+                }
+            }
+
+            console.log(
+                chalk.cyan(padRight(url, 40)) +
+                padRight(dep.folderName || '-', 15) +
+                padRight(String(dep.fileCount), 7) +
+                chalk.gray(padRight(date, 12)) +
+                status
+            );
+        }
+
+        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('');
+
+    } catch (err) {
+        error(`Failed to list deployments: ${err.message}`);
+        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);
+}