launchpd 1.0.0

package/src/utils/api.js

@@ -0,0 +1,182 @@
+/**
+ * API Client for StaticLaunch Metadata API
+ * Communicates with the Cloudflare Worker API endpoints
+ */
+
+import { config } from '../config.js';
+import { getApiKey, getApiSecret } from './credentials.js';
+import { createHmac } from 'node:crypto';
+import { getMachineId } from './machineId.js';
+
+const API_BASE_URL = config.apiUrl;
+
+/**
+ * Make an authenticated API request
+ */
+async function apiRequest(endpoint, options = {}) {
+    const url = `${API_BASE_URL}${endpoint}`;
+
+    const apiKey = await getApiKey();
+    const apiSecret = await getApiSecret();
+    const headers = {
+        'Content-Type': 'application/json',
+        'X-API-Key': apiKey,
+        'X-Device-Fingerprint': getMachineId(),
+        ...options.headers,
+    };
+
+    // Add HMAC signature if secret is available
+    if (apiSecret) {
+        const timestamp = Date.now().toString();
+        const method = (options.method || 'GET').toUpperCase();
+        const body = options.body || '';
+
+        // HMAC-SHA256(secret, method + path + timestamp + body)
+        const hmac = createHmac('sha256', apiSecret);
+        hmac.update(method);
+        hmac.update(endpoint);
+        hmac.update(timestamp);
+        hmac.update(body);
+
+        const signature = hmac.digest('hex');
+
+        headers['X-Timestamp'] = timestamp;
+        headers['X-Signature'] = signature;
+    }
+
+    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,153 @@
+/**
+ * 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,
+                    apiSecret: data.apiSecret || null,
+                    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,
+        apiSecret: credentials.apiSecret || null,
+        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';
+}
+
+/**
+ * Get the API secret for requests
+ */
+export async function getApiSecret() {
+    const creds = await getCredentials();
+    return creds?.apiSecret || process.env.STATICLAUNCH_API_SECRET || null;
+}

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 {Date} Date object of expiration
+ */
+export function calculateExpiresAt(timeStr) {
+    const ms = parseTimeString(timeStr);
+    return new Date(Date.now() + ms);
+}
+
+/**
+ * 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,14 @@
+/**
+ * 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 './prompt.js';
+export * from './upload.js';

package/src/utils/localConfig.js

@@ -0,0 +1,85 @@
+import { existsSync } from 'node:fs';
+import { readFile, writeFile, mkdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+
+/**
+ * Get the local config directory path
+ * ~/.staticlaunch/ on Unix, %USERPROFILE%\.staticlaunch\ on Windows
+ */
+function getConfigDir() {
+    return join(homedir(), '.staticlaunch');
+}
+
+/**
+ * Get the local deployments file path
+ */
+function getDeploymentsPath() {
+    return join(getConfigDir(), 'deployments.json');
+}
+
+/**
+ * Ensure config directory exists
+ */
+async function ensureConfigDir() {
+    const dir = getConfigDir();
+    if (!existsSync(dir)) {
+        await mkdir(dir, { recursive: true });
+    }
+}
+
+/**
+ * Get local deployments data
+ * @returns {Promise<{version: number, deployments: Array}>}
+ */
+async function getLocalData() {
+    const filePath = getDeploymentsPath();
+    try {
+        if (existsSync(filePath)) {
+            const text = await readFile(filePath, 'utf-8');
+            return JSON.parse(text);
+        }
+    } catch {
+        // Corrupted or invalid JSON file, return empty structure
+    }
+    return { version: 1, deployments: [] };
+}
+
+/**
+ * Save a deployment record locally
+ * This provides quick access to user's own deployments without R2 read
+ * @param {object} deployment - Deployment record
+ */
+export async function saveLocalDeployment(deployment) {
+    await ensureConfigDir();
+
+    const data = await getLocalData();
+    data.deployments.push(deployment);
+
+    await writeFile(
+        getDeploymentsPath(),
+        JSON.stringify(data, null, 2),
+        'utf-8'
+    );
+}
+
+/**
+ * Get all local deployments (user's own deployments from this machine)
+ * @returns {Promise<Array>} Array of deployment records
+ */
+export async function getLocalDeployments() {
+    const data = await getLocalData();
+    return data.deployments;
+}
+
+/**
+ * Clear local deployments history
+ */
+export async function clearLocalDeployments() {
+    await ensureConfigDir();
+    await writeFile(
+        getDeploymentsPath(),
+        JSON.stringify({ version: 1, deployments: [] }, null, 2),
+        'utf-8'
+    );
+}

package/src/utils/logger.js

@@ -0,0 +1,152 @@
+import chalk from 'chalk';
+import ora from 'ora';
+
+// Store active spinner reference
+let activeSpinner = null;
+
+/**
+ * Log a success message
+ * @param {string} message
+ */
+export function success(message) {
+    console.log(chalk.green.bold('✓'), chalk.green(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, 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}`));
+    }
+}
+
+/**
+ * Log an info message
+ * @param {string} message
+ */
+export function info(message) {
+    console.log(chalk.blue('ℹ'), chalk.white(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}`));
+        });
+    }
+}