launchpd 0.1.0

package/src/commands/rollback.js

@@ -0,0 +1,101 @@
+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';
+
+/**
+ * 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)
+ */
+export async function rollback(subdomain, options) {
+    try {
+        info(`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) {
+            error(`No deployments found for subdomain: ${subdomain}`);
+            process.exit(1);
+        }
+
+        if (versions.length === 1) {
+            warning('Only one version exists. Nothing to rollback to.');
+            process.exit(1);
+        }
+
+        info(`Current active version: 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.`);
+                info('Available versions:');
+                versions.forEach(v => {
+                    info(`  v${v.version} - ${v.timestamp}`);
+                });
+                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 ${targetVersion} is already active.`);
+            process.exit(0);
+        }
+
+        info(`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');
+                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);
+
+        success(`Rolled back to v${targetVersion} successfully!`);
+        console.log(`\n  🔄 https://${subdomain}.launchpd.cloud\n`);
+        info(`Restored deployment from: ${targetDeployment?.timestamp || 'unknown'}`);
+
+    } catch (err) {
+        error(`Rollback failed: ${err.message}`);
+        process.exit(1);
+    }
+}

package/src/commands/versions.js

@@ -0,0 +1,75 @@
+import { getVersionsForSubdomain, getActiveVersion } from '../utils/metadata.js';
+import { getVersions as getVersionsFromAPI } from '../utils/api.js';
+import { success, error, info } from '../utils/logger.js';
+
+/**
+ * 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
+ */
+export async function versions(subdomain, options) {
+    try {
+        info(`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) {
+            error(`No deployments found for subdomain: ${subdomain}`);
+            process.exit(1);
+        }
+
+        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 ${subdomain}.launchpd.cloud:`);
+        console.log('');
+
+        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();
+
+            console.log(`  v${v.version}  │  ${date}  │  ${v.fileCount} files  │  ${sizeKB}${activeMarker}`);
+        }
+
+        console.log('');
+        info(`Use 'launchpd rollback ${subdomain} --to <n>' to restore a version.`);
+        console.log('');
+
+    } catch (err) {
+        error(`Failed to list versions: ${err.message}`);
+        process.exit(1);
+    }
+}

package/src/config.js

@@ -0,0 +1,36 @@
+import 'dotenv/config';
+
+/**
+ * Application configuration loaded from environment variables
+ */
+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',
+    ];
+
+    const missing = required.filter(key => !process.env[key]);
+
+    if (missing.length > 0) {
+        return { valid: false, missing };
+    }
+
+    return { valid: true, missing: [] };
+}

package/src/utils/api.js

@@ -0,0 +1,158 @@
+/**
+ * API Client for StaticLaunch Metadata API
+ * Communicates with the Cloudflare Worker API endpoints
+ */
+
+import { config } from '../config.js';
+
+const API_BASE_URL = `https://api.${config.domain}`;
+const API_KEY = process.env.STATICLAUNCH_API_KEY || 'public-beta-key';
+
+/**
+ * Make an authenticated API request
+ */
+async function apiRequest(endpoint, options = {}) {
+    const url = `${API_BASE_URL}${endpoint}`;
+
+    const headers = {
+        'Content-Type': 'application/json',
+        'X-API-Key': API_KEY,
+        ...options.headers,
+    };
+
+    try {
+        const response = await fetch(url, {
+            ...options,
+            headers,
+        });
+
+        const data = await response.json();
+
+        if (!response.ok) {
+            throw new Error(data.error || `API error: ${response.status}`);
+        }
+
+        return data;
+    } catch (err) {
+        // If API is unavailable, return null to allow fallback to local storage
+        if (err.message.includes('fetch failed') || err.message.includes('ENOTFOUND')) {
+            return null;
+        }
+        throw err;
+    }
+}
+
+/**
+ * Get the next version number for a subdomain
+ */
+export async function getNextVersionFromAPI(subdomain) {
+    const result = await apiRequest(`/api/versions/${subdomain}`);
+    if (!result || !result.versions || result.versions.length === 0) {
+        return 1;
+    }
+    const maxVersion = Math.max(...result.versions.map(v => v.version));
+    return maxVersion + 1;
+}
+
+/**
+ * Record a new deployment in the API
+ */
+export async function recordDeployment(deploymentData) {
+    const { subdomain, folderName, fileCount, totalBytes, version, expiresAt } = deploymentData;
+
+    return apiRequest('/api/deployments', {
+        method: 'POST',
+        body: JSON.stringify({
+            subdomain,
+            folderName,
+            fileCount,
+            totalBytes,
+            version,
+            cliVersion: '0.1.0',
+            expiresAt,
+        }),
+    });
+}
+
+/**
+ * Get list of user's deployments
+ */
+export async function listDeployments(limit = 50, offset = 0) {
+    return apiRequest(`/api/deployments?limit=${limit}&offset=${offset}`);
+}
+
+/**
+ * Get deployment details for a subdomain
+ */
+export async function getDeployment(subdomain) {
+    return apiRequest(`/api/deployments/${subdomain}`);
+}
+
+/**
+ * Get version history for a subdomain
+ */
+export async function getVersions(subdomain) {
+    return apiRequest(`/api/versions/${subdomain}`);
+}
+
+/**
+ * Rollback to a specific version
+ */
+export async function rollbackVersion(subdomain, version) {
+    return apiRequest(`/api/versions/${subdomain}/rollback`, {
+        method: 'PUT',
+        body: JSON.stringify({ version }),
+    });
+}
+
+/**
+ * Check if a subdomain is available
+ */
+export async function checkSubdomainAvailable(subdomain) {
+    const result = await apiRequest(`/api/public/check/${subdomain}`);
+    return result?.available ?? true;
+}
+
+/**
+ * Reserve a subdomain
+ */
+export async function reserveSubdomain(subdomain) {
+    return apiRequest('/api/subdomains/reserve', {
+        method: 'POST',
+        body: JSON.stringify({ subdomain }),
+    });
+}
+
+/**
+ * Get user's subdomains
+ */
+export async function listSubdomains() {
+    return apiRequest('/api/subdomains');
+}
+
+/**
+ * Get current user info
+ */
+export async function getCurrentUser() {
+    return apiRequest('/api/users/me');
+}
+
+/**
+ * Health check
+ */
+export async function healthCheck() {
+    return apiRequest('/api/health');
+}
+
+export default {
+    recordDeployment,
+    listDeployments,
+    getDeployment,
+    getVersions,
+    rollbackVersion,
+    checkSubdomainAvailable,
+    reserveSubdomain,
+    listSubdomains,
+    getCurrentUser,
+    healthCheck,
+};

package/src/utils/credentials.js

@@ -0,0 +1,143 @@
+/**
+ * Credentials management for StaticLaunch CLI
+ * Stores API key and user info in ~/.staticlaunch/credentials.json
+ */
+
+import { existsSync } from 'node:fs';
+import { readFile, writeFile, mkdir, unlink } from 'node:fs/promises';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { randomBytes } from 'node:crypto';
+
+/**
+ * Get the credentials directory path
+ */
+function getConfigDir() {
+    return join(homedir(), '.staticlaunch');
+}
+
+/**
+ * Get the credentials file path
+ */
+function getCredentialsPath() {
+    return join(getConfigDir(), 'credentials.json');
+}
+
+/**
+ * Get the client token path (for anonymous tracking)
+ */
+function getClientTokenPath() {
+    return join(getConfigDir(), 'client_token');
+}
+
+/**
+ * Ensure config directory exists
+ */
+async function ensureConfigDir() {
+    const dir = getConfigDir();
+    if (!existsSync(dir)) {
+        await mkdir(dir, { recursive: true });
+    }
+}
+
+/**
+ * Get or create a persistent client token for anonymous tracking
+ * This helps identify the same anonymous user across sessions
+ */
+export async function getClientToken() {
+    await ensureConfigDir();
+    const tokenPath = getClientTokenPath();
+
+    try {
+        if (existsSync(tokenPath)) {
+            return await readFile(tokenPath, 'utf-8');
+        }
+    } catch {
+        // Token file corrupted, regenerate
+    }
+
+    // Generate new token
+    const token = `cli_${randomBytes(16).toString('hex')}`;
+    await writeFile(tokenPath, token, 'utf-8');
+    return token;
+}
+
+/**
+ * Get stored credentials
+ * @returns {Promise<{apiKey: string, userId: string, email: string, tier: string} | null>}
+ */
+export async function getCredentials() {
+    const filePath = getCredentialsPath();
+    try {
+        if (existsSync(filePath)) {
+            const text = await readFile(filePath, 'utf-8');
+            const data = JSON.parse(text);
+
+            // Validate the structure
+            if (data.apiKey) {
+                return {
+                    apiKey: data.apiKey,
+                    userId: data.userId || null,
+                    email: data.email || null,
+                    tier: data.tier || 'free',
+                    savedAt: data.savedAt || null,
+                };
+            }
+        }
+    } catch {
+        // Corrupted or invalid JSON file
+    }
+    return null;
+}
+
+/**
+ * Save credentials
+ * @param {object} credentials - Credentials to save
+ */
+export async function saveCredentials(credentials) {
+    await ensureConfigDir();
+
+    const data = {
+        apiKey: credentials.apiKey,
+        userId: credentials.userId || null,
+        email: credentials.email || null,
+        tier: credentials.tier || 'free',
+        savedAt: new Date().toISOString(),
+    };
+
+    await writeFile(
+        getCredentialsPath(),
+        JSON.stringify(data, null, 2),
+        'utf-8'
+    );
+}
+
+/**
+ * Delete stored credentials (logout)
+ */
+export async function clearCredentials() {
+    const filePath = getCredentialsPath();
+    try {
+        if (existsSync(filePath)) {
+            await unlink(filePath);
+        }
+    } catch {
+        // File doesn't exist or can't be deleted
+    }
+}
+
+/**
+ * Check if user is logged in
+ */
+export async function isLoggedIn() {
+    const creds = await getCredentials();
+    return creds !== null && creds.apiKey !== null;
+}
+
+/**
+ * Get the API key for requests (falls back to public beta key)
+ */
+export async function getApiKey() {
+    const creds = await getCredentials();
+    return creds?.apiKey || process.env.STATICLAUNCH_API_KEY || 'public-beta-key';
+}

package/src/utils/expiration.js

@@ -0,0 +1,89 @@
+/**
+ * Parse a time string into milliseconds
+ * Supports: 30m, 1h, 2h, 1d, 7d, etc.
+ * Minimum: 30 minutes
+ *
+ * @param {string} timeStr - Time string (e.g., "30m", "2h", "1d")
+ * @returns {number} Milliseconds
+ */
+export function parseTimeString(timeStr) {
+    const regex = /^(\d+)([mhd])$/i;
+    const match = regex.exec(timeStr);
+
+    if (!match) {
+        throw new Error(`Invalid time format: "${timeStr}". Use format like 30m, 2h, 1d`);
+    }
+
+    const value = Number.parseInt(match[1], 10);
+    const unit = match[2].toLowerCase();
+
+    let ms;
+    switch (unit) {
+        case 'm':
+            ms = value * 60 * 1000;
+            break;
+        case 'h':
+            ms = value * 60 * 60 * 1000;
+            break;
+        case 'd':
+            ms = value * 24 * 60 * 60 * 1000;
+            break;
+        default:
+            throw new Error(`Unknown time unit: ${unit}`);
+    }
+
+    // Minimum 30 minutes
+    const minMs = 30 * 60 * 1000;
+    if (ms < minMs) {
+        throw new Error('Minimum expiration time is 30 minutes (30m)');
+    }
+
+    return ms;
+}
+
+/**
+ * Calculate expiration timestamp from a time string
+ * @param {string} timeStr - Time string (e.g., "30m", "2h", "1d")
+ * @returns {string} ISO timestamp of expiration
+ */
+export function calculateExpiresAt(timeStr) {
+    const ms = parseTimeString(timeStr);
+    return new Date(Date.now() + ms).toISOString();
+}
+
+/**
+ * Format remaining time until expiration
+ * @param {string} expiresAt - ISO timestamp
+ * @returns {string} Human-readable time remaining
+ */
+export function formatTimeRemaining(expiresAt) {
+    const now = Date.now();
+    const expiry = new Date(expiresAt).getTime();
+    const remaining = expiry - now;
+
+    if (remaining <= 0) {
+        return 'expired';
+    }
+
+    const minutes = Math.floor(remaining / (60 * 1000));
+    const hours = Math.floor(remaining / (60 * 60 * 1000));
+    const days = Math.floor(remaining / (24 * 60 * 60 * 1000));
+
+    if (days > 0) {
+        return `${days}d ${hours % 24}h remaining`;
+    } else if (hours > 0) {
+        return `${hours}h ${minutes % 60}m remaining`;
+    } else {
+        return `${minutes}m remaining`;
+    }
+}
+
+/**
+ * Check if a deployment has expired
+ * @param {string} expiresAt - ISO timestamp or null
+ * @returns {boolean}
+ */
+export function isExpired(expiresAt) {
+    if (!expiresAt) return false;
+    return new Date(expiresAt).getTime() < Date.now();
+}

package/src/utils/id.js

@@ -0,0 +1,17 @@
+import { customAlphabet } from 'nanoid';
+
+/**
+ * Generate a subdomain-safe unique ID
+ * Uses lowercase alphanumeric characters only (valid for DNS)
+ * 12 characters provides ~62 bits of entropy
+ */
+const alphabet = 'abcdefghijklmnopqrstuvwxyz0123456789';
+const nanoid = customAlphabet(alphabet, 12);
+
+/**
+ * Generate a unique subdomain ID
+ * @returns {string} A 12-character lowercase alphanumeric string
+ */
+export function generateSubdomain() {
+    return nanoid();
+}

package/src/utils/index.js

@@ -0,0 +1,13 @@
+/**
+ * Utils index - exports all utility functions
+ */
+
+export * from './api.js';
+export * from './credentials.js';
+export * from './expiration.js';
+export * from './id.js';
+export * from './localConfig.js';
+export * from './logger.js';
+export * from './metadata.js';
+export * from './quota.js';
+export * from './upload.js';