launchpd 0.1.2 → 0.1.4

package/LICENSE

@@ -1,6 +1,10 @@
 MIT License
 
+<<<<<<< HEAD
 Copyright (c) 2026 Launchpd
+=======
+Copyright (c) 2026 Kent Edoloverio
+>>>>>>> 12ada1bf2dcc63674c3b6955e525a51209308d45
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/README.md

@@ -107,4 +107,4 @@ launchpd logout
 
 ## License
 
-MIT
+MIT

package/bin/setup.js

@@ -1,62 +1,40 @@
 #!/usr/bin/env node
 
-import { config, validateConfig } from '../src/config.js';
-import { info, success, error } from '../src/utils/logger.js';
+import { config } from '../src/config.js';
+import { info, success } from '../src/utils/logger.js';
 import chalk from 'chalk';
 
 /**
- * Setup script to validate and display configuration status
+ * Setup script to display CLI information
  */
 async function setup() {
     console.log('\n' + chalk.bold.blue('═══════════════════════════════════════'));
-    console.log(chalk.bold.blue('  Launchpd Configuration Check'));
+    console.log(chalk.bold.blue('  Launchpd CLI'));
     console.log(chalk.bold.blue('═══════════════════════════════════════\n'));
 
-    // Check environment variables
-    info('Checking configuration...\n');
+    info('Launchpd is ready to use!\n');
 
-    const validation = validateConfig();
-
-    if (!validation.valid) {
-        error(`Missing required environment variables:`);
-        for (const missing of validation.missing) {
-            console.log(chalk.red(`  ✗ ${missing}`));
-        }
-        console.log('\n' + chalk.yellow('Setup Instructions:'));
-        console.log('  1. Copy .env.example to .env:');
-        console.log(chalk.gray('     cp .env.example .env'));
-        console.log('  2. Edit .env and add your Cloudflare R2 credentials');
-        console.log('  3. Get credentials from: https://dash.cloudflare.com → R2 → API Tokens\n');
-        process.exit(1);
-    }
-
-    // Display current configuration
-    console.log(chalk.green('✓ All required environment variables set\n'));
-
-    console.log(chalk.bold('Current Configuration:'));
+    console.log(chalk.bold('Configuration:'));
     console.log(chalk.gray('─'.repeat(50)));
     console.log(chalk.cyan('  Domain:        '), config.domain);
-    console.log(chalk.cyan('  R2 Bucket:     '), config.r2.bucketName);
-    console.log(chalk.cyan('  Account ID:    '), config.r2.accountId ? '✓ Set' : '✗ Missing');
-    console.log(chalk.cyan('  Access Key:    '), config.r2.accessKeyId ? '✓ Set' : '✗ Missing');
-    console.log(chalk.cyan('  Secret Key:    '), config.r2.secretAccessKey ? '✓ Set' : '✗ Missing');
+    console.log(chalk.cyan('  API:           '), config.apiUrl);
+    console.log(chalk.cyan('  Version:       '), config.version);
     console.log(chalk.gray('─'.repeat(50)) + '\n');
 
-    // Next steps
-    console.log(chalk.bold('Next Steps:'));
-    console.log(chalk.gray('  1. Test dry-run deployment:'));
-    console.log(chalk.cyan('     npm run dev'));
-    console.log(chalk.gray('  2. Deploy Worker:'));
-    console.log(chalk.cyan('     cd worker && wrangler deploy'));
-    console.log(chalk.gray('  3. Verify DNS settings in Cloudflare Dashboard:'));
-    console.log(chalk.cyan(`     DNS → Records → Add A record * → 192.0.2.1 (Proxied)`));
-    console.log(chalk.gray('  4. Deploy your first site:'));
+    console.log(chalk.bold('Quick Start:'));
+    console.log(chalk.gray('  Deploy your first site:'));
     console.log(chalk.cyan('     launchpd deploy ./your-folder\n'));
 
-    success('Setup validation complete!');
+    console.log(chalk.gray('  Login for more quota:'));
+    console.log(chalk.cyan('     launchpd login\n'));
+
+    console.log(chalk.gray('  List your deployments:'));
+    console.log(chalk.cyan('     launchpd list\n'));
+
+    success('No configuration needed - just deploy!');
 }
 
 setup().catch(err => {
-    error(`Setup failed: ${err.message}`);
+    console.error(`Setup failed: ${err.message}`);
     process.exit(1);
 });

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "launchpd",
-    "version": "0.1.2",
+    "version": "0.1.4",
     "description": "Deploy static sites instantly to a live URL",
     "type": "module",
     "bin": {
@@ -21,7 +21,6 @@
     "scripts": {
         "start": "node bin/cli.js",
         "dev": "node bin/cli.js deploy ../examples/test-site --dry-run",
-        "setup": "node bin/setup.js",
         "test": "vitest run",
         "test:watch": "vitest",
         "test:coverage": "vitest run --coverage",
@@ -35,7 +34,6 @@
         "deploy",
         "cli",
         "cloudflare",
-        "r2",
         "cdn",
         "website",
         "publish"
@@ -52,10 +50,8 @@
     },
     "homepage": "https://launchpd.cloud",
     "dependencies": {
-        "@aws-sdk/client-s3": "^3.700.0",
         "chalk": "^5.4.0",
         "commander": "^14.0.0",
-        "dotenv": "^16.4.0",
         "mime-types": "^2.1.35",
         "nanoid": "^5.1.0"
     },

package/src/commands/deploy.js

@@ -2,10 +2,10 @@ 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 { 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';
@@ -135,42 +135,29 @@ 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)
         let version = await getNextVersionFromAPI(subdomain);
         if (version === null) {
             version = await getNextVersion(subdomain);
         }
         info(`Deploying as version ${version}...`);
 
+        // Upload all files via API proxy
+        const folderName = basename(folderPath);
         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({
+        // Finalize upload: set active version and record metadata
+        info('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
+        );
 
-        // Always save locally for quick access
+        // Save locally for quick access
         await saveLocalDeployment({
             subdomain,
             folderName,

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',
+};

package/src/utils/metadata.js

@@ -1,114 +1,85 @@
-import { S3Client, GetObjectCommand, PutObjectCommand, ListObjectsV2Command, CopyObjectCommand, DeleteObjectCommand } from '@aws-sdk/client-s3';
+/**
+ * Metadata utilities for Launchpd CLI
+ * All operations now go through the API proxy
+ */
+
 import { config } from '../config.js';
 
-const METADATA_KEY = '_meta/deployments.json';
+const API_BASE_URL = config.apiUrl;
 
 /**
- * Create S3-compatible client for Cloudflare R2
+ * Get API key for requests
  */
-function createR2Client() {
-    return new S3Client({
-        region: 'auto',
-        endpoint: `https://${config.r2.accountId}.r2.cloudflarestorage.com`,
-        credentials: {
-            accessKeyId: config.r2.accessKeyId,
-            secretAccessKey: config.r2.secretAccessKey,
-        },
-    });
+function getApiKey() {
+    return process.env.STATICLAUNCH_API_KEY || 'public-beta-key';
 }
 
 /**
- * Get existing deployments metadata from R2
- * @returns {Promise<{version: number, deployments: Array}>}
+ * Make an authenticated API request
  */
-async function getDeploymentsData(client) {
+async function apiRequest(endpoint, options = {}) {
+    const url = `${API_BASE_URL}${endpoint}`;
+
+    const headers = {
+        'Content-Type': 'application/json',
+        'X-API-Key': getApiKey(),
+        ...options.headers,
+    };
+
     try {
-        const response = await client.send(new GetObjectCommand({
-            Bucket: config.r2.bucketName,
-            Key: METADATA_KEY,
-        }));
-        const text = await response.Body.transformToString();
-        return JSON.parse(text);
-    } catch {
-        // File doesn't exist yet, return empty structure
-        return { version: 1, deployments: [] };
-    }
-}
+        const response = await fetch(url, {
+            ...options,
+            headers,
+        });
 
-/**
- * Create a timestamped backup of the metadata before overwriting
- * @param {S3Client} client
- * @param {object} data - Current metadata to backup
- */
-async function backupMetadata(client, data) {
-    if (data.deployments.length === 0) return; // Nothing to backup
+        const data = await response.json();
 
-    const timestamp = new Date().toISOString().replaceAll(/[:.]/g, '-');
-    const backupKey = `_meta/backups/deployments-${timestamp}.json`;
+        if (!response.ok) {
+            throw new Error(data.error || `API error: ${response.status}`);
+        }
 
-    await client.send(new PutObjectCommand({
-        Bucket: config.r2.bucketName,
-        Key: backupKey,
-        Body: JSON.stringify(data, null, 2),
-        ContentType: 'application/json',
-    }));
+        return data;
+    } catch (err) {
+        if (err.message.includes('fetch failed') || err.message.includes('ENOTFOUND')) {
+            return null;
+        }
+        throw err;
+    }
 }
 
 /**
- * Record a deployment to R2 metadata
+ * Record a deployment to the API
  * @param {string} subdomain - Deployed subdomain
  * @param {string} folderPath - Original folder path
  * @param {number} fileCount - Number of files deployed
  * @param {number} totalBytes - Total bytes uploaded
  * @param {number} version - Version number for this deployment
- * @param {string|null} expiresAt - ISO timestamp for expiration, or null for no expiration
+ * @param {Date|null} expiresAt - Expiration date, or null for no expiration
  */
 export async function recordDeployment(subdomain, folderPath, fileCount, totalBytes = 0, version = 1, expiresAt = null) {
-    const client = createR2Client();
-
-    // Get existing data
-    const data = await getDeploymentsData(client);
-
-    // Backup before modifying (prevents accidental data loss)
-    await backupMetadata(client, data);
-
-    // Extract folder name from path
     const folderName = folderPath.split(/[\\/]/).pop() || 'unknown';
 
-    // Append new deployment
-    const deployment = {
-        subdomain,
-        timestamp: new Date().toISOString(),
-        folderName,
-        fileCount,
-        totalBytes,
-        cliVersion: '0.1.0',
-        version,
-        isActive: true,
-        expiresAt,
-    };
-
-    data.deployments.push(deployment);
-
-    // Write back to R2
-    await client.send(new PutObjectCommand({
-        Bucket: config.r2.bucketName,
-        Key: METADATA_KEY,
-        Body: JSON.stringify(data, null, 2),
-        ContentType: 'application/json',
-    }));
-
-    return deployment;
+    return apiRequest('/api/deployments', {
+        method: 'POST',
+        body: JSON.stringify({
+            subdomain,
+            folderName,
+            fileCount,
+            totalBytes,
+            version,
+            cliVersion: config.version,
+            expiresAt: expiresAt?.toISOString() || null,
+        }),
+    });
 }
 
 /**
- * List all deployments from R2 metadata
+ * List all deployments for the current user
  * @returns {Promise<Array>} Array of deployment records
  */
 export async function listDeploymentsFromR2() {
-    const client = createR2Client();
-    const data = await getDeploymentsData(client);
-    return data.deployments;
+    const result = await apiRequest('/api/deployments');
+    return result?.deployments || [];
 }
 
 /**
@@ -117,15 +88,13 @@ export async function listDeploymentsFromR2() {
  * @returns {Promise<number>} Next version number
  */
 export async function getNextVersion(subdomain) {
-    const client = createR2Client();
-    const data = await getDeploymentsData(client);
+    const result = await apiRequest(`/api/versions/${subdomain}`);
 
-    const existingDeployments = data.deployments.filter(d => d.subdomain === subdomain);
-    if (existingDeployments.length === 0) {
+    if (!result || !result.versions || result.versions.length === 0) {
         return 1;
     }
 
-    const maxVersion = Math.max(...existingDeployments.map(d => d.version || 1));
+    const maxVersion = Math.max(...result.versions.map(v => v.version));
     return maxVersion + 1;
 }
 
@@ -135,74 +104,20 @@ export async function getNextVersion(subdomain) {
  * @returns {Promise<Array>} Array of deployment versions
  */
 export async function getVersionsForSubdomain(subdomain) {
-    const client = createR2Client();
-    const data = await getDeploymentsData(client);
-
-    return data.deployments
-        .filter(d => d.subdomain === subdomain)
-        .sort((a, b) => (b.version || 1) - (a.version || 1));
+    const result = await apiRequest(`/api/versions/${subdomain}`);
+    return result?.versions || [];
 }
 
 /**
- * Copy files from one version to another (for rollback)
- * @param {string} subdomain - The subdomain
- * @param {number} fromVersion - Source version
- * @param {number} toVersion - Target version (new active version)
- */
-export async function copyVersionFiles(subdomain, fromVersion, toVersion) {
-    const client = createR2Client();
-
-    // List all files in the source version
-    const sourcePrefix = `${subdomain}/v${fromVersion}/`;
-    const targetPrefix = `${subdomain}/v${toVersion}/`;
-
-    const listResponse = await client.send(new ListObjectsV2Command({
-        Bucket: config.r2.bucketName,
-        Prefix: sourcePrefix,
-    }));
-
-    if (!listResponse.Contents || listResponse.Contents.length === 0) {
-        throw new Error(`No files found for version ${fromVersion}`);
-    }
-
-    let copiedCount = 0;
-
-    for (const object of listResponse.Contents) {
-        const sourceKey = object.Key;
-        const targetKey = sourceKey.replace(sourcePrefix, targetPrefix);
-
-        // Copy file to new version
-        await client.send(new CopyObjectCommand({
-            Bucket: config.r2.bucketName,
-            CopySource: `${config.r2.bucketName}/${sourceKey}`,
-            Key: targetKey,
-        }));
-
-        copiedCount++;
-    }
-
-    return { copiedCount, fromVersion, toVersion };
-}
-
-/**
- * Update the active pointer for a subdomain (for rollback)
+ * Set the active version for a subdomain (rollback)
  * @param {string} subdomain - The subdomain
  * @param {number} version - Version to make active
  */
 export async function setActiveVersion(subdomain, version) {
-    const client = createR2Client();
-
-    // Create/update an active pointer file
-    const pointerKey = `${subdomain}/_active`;
-
-    await client.send(new PutObjectCommand({
-        Bucket: config.r2.bucketName,
-        Key: pointerKey,
-        Body: JSON.stringify({ activeVersion: version, updatedAt: new Date().toISOString() }),
-        ContentType: 'application/json',
-    }));
-
-    return { subdomain, activeVersion: version };
+    return apiRequest(`/api/versions/${subdomain}/rollback`, {
+        method: 'PUT',
+        body: JSON.stringify({ version }),
+    });
 }
 
 /**
@@ -211,144 +126,76 @@ export async function setActiveVersion(subdomain, version) {
  * @returns {Promise<number>} Active version number
  */
 export async function getActiveVersion(subdomain) {
-    const client = createR2Client();
+    const result = await apiRequest(`/api/versions/${subdomain}`);
+    return result?.activeVersion || 1;
+}
 
-    try {
-        const response = await client.send(new GetObjectCommand({
-            Bucket: config.r2.bucketName,
-            Key: `${subdomain}/_active`,
-        }));
-        const text = await response.Body.transformToString();
-        const data = JSON.parse(text);
-        return data.activeVersion || 1;
-    } catch {
-        // No active pointer, default to version 1
-        return 1;
-    }
+/**
+ * Copy files from one version to another (for rollback)
+ * Note: This is now handled server-side by the API
+ * @param {string} subdomain - The subdomain
+ * @param {number} fromVersion - Source version
+ * @param {number} toVersion - Target version
+ */
+export async function copyVersionFiles(subdomain, fromVersion, toVersion) {
+    // Rollback is now handled by setActiveVersion - no need to copy files
+    // The worker serves files from the specified version directly
+    return { fromVersion, toVersion, note: 'Handled by API' };
 }
 
 /**
  * List all files for a specific version
  * @param {string} subdomain - The subdomain
  * @param {number} version - Version number
- * @returns {Promise<Array>} Array of file keys
+ * @returns {Promise<Array>} Array of file info
  */
 export async function listVersionFiles(subdomain, version) {
-    const client = createR2Client();
+    const result = await apiRequest(`/api/deployments/${subdomain}`);
 
-    const prefix = `${subdomain}/v${version}/`;
-
-    const response = await client.send(new ListObjectsV2Command({
-        Bucket: config.r2.bucketName,
-        Prefix: prefix,
-    }));
-
-    if (!response.Contents) {
+    if (!result || !result.versions) {
         return [];
     }
 
-    return response.Contents.map(obj => ({
-        key: obj.Key,
-        size: obj.Size,
-        lastModified: obj.LastModified,
-    }));
+    const versionInfo = result.versions.find(v => v.version === version);
+    return versionInfo ? [{ version, fileCount: versionInfo.file_count, totalBytes: versionInfo.total_bytes }] : [];
 }
 
 /**
  * Delete all files for a subdomain (all versions)
- * @param {string} subdomain - The subdomain to delete
- * @returns {Promise<{deletedCount: number}>}
+ * Note: This should be an admin operation, not available to CLI users
+ * @param {string} _subdomain - The subdomain to delete
  */
-export async function deleteSubdomain(subdomain) {
-    const client = createR2Client();
-
-    // List all files for this subdomain
-    const prefix = `${subdomain}/`;
-
-    let deletedCount = 0;
-    let continuationToken;
-
-    do {
-        const response = await client.send(new ListObjectsV2Command({
-            Bucket: config.r2.bucketName,
-            Prefix: prefix,
-            ContinuationToken: continuationToken,
-        }));
-
-        if (response.Contents && response.Contents.length > 0) {
-            for (const object of response.Contents) {
-                await client.send(new DeleteObjectCommand({
-                    Bucket: config.r2.bucketName,
-                    Key: object.Key,
-                }));
-                deletedCount++;
-            }
-        }
-
-        continuationToken = response.NextContinuationToken;
-    } while (continuationToken);
-
-    return { deletedCount };
+export async function deleteSubdomain(_subdomain) {
+    // This operation is not available in the consumer CLI
+    // It should be handled through the admin dashboard or worker
+    throw new Error('Subdomain deletion is not available in the CLI. Contact support.');
 }
 
 /**
  * Get all expired deployments
+ * Note: Cleanup is handled server-side automatically
  * @returns {Promise<Array>} Array of expired deployment records
  */
 export async function getExpiredDeployments() {
-    const client = createR2Client();
-    const data = await getDeploymentsData(client);
-    const now = Date.now();
-
-    return data.deployments.filter(d =>
-        d.expiresAt && new Date(d.expiresAt).getTime() < now
-    );
+    // Expiration cleanup is handled server-side
+    return [];
 }
 
 /**
  * Remove deployment records for a subdomain from metadata
- * @param {string} subdomain - The subdomain to remove
+ * Note: This should be an admin operation
+ * @param {string} _subdomain - The subdomain to remove
  */
-export async function removeDeploymentRecords(subdomain) {
-    const client = createR2Client();
-    const data = await getDeploymentsData(client);
-
-    // Backup before modifying
-    await backupMetadata(client, data);
-
-    // Filter out the subdomain's deployments
-    data.deployments = data.deployments.filter(d => d.subdomain !== subdomain);
-
-    // Write back
-    await client.send(new PutObjectCommand({
-        Bucket: config.r2.bucketName,
-        Key: METADATA_KEY,
-        Body: JSON.stringify(data, null, 2),
-        ContentType: 'application/json',
-    }));
+export async function removeDeploymentRecords(_subdomain) {
+    throw new Error('Deployment record removal is not available in the CLI. Contact support.');
 }
 
 /**
  * Clean up all expired deployments
+ * Note: This is now handled automatically by the worker
  * @returns {Promise<{cleaned: string[], errors: string[]}>}
  */
 export async function cleanupExpiredDeployments() {
-    const expired = await getExpiredDeployments();
-    const cleaned = [];
-    const errors = [];
-
-    // Get unique subdomains
-    const subdomains = [...new Set(expired.map(d => d.subdomain))];
-
-    for (const subdomain of subdomains) {
-        try {
-            await deleteSubdomain(subdomain);
-            await removeDeploymentRecords(subdomain);
-            cleaned.push(subdomain);
-        } catch (err) {
-            errors.push(`${subdomain}: ${err.message}`);
-        }
-    }
-
-    return { cleaned, errors };
+    // Cleanup is handled server-side automatically
+    return { cleaned: [], errors: [], note: 'Handled automatically by server' };
 }

package/src/utils/upload.js

@@ -1,22 +1,16 @@
-import { S3Client, PutObjectCommand } from '@aws-sdk/client-s3';
 import { readdir, readFile } from 'node:fs/promises';
 import { join, relative, posix, sep } from 'node:path';
 import mime from 'mime-types';
 import { config } from '../config.js';
 import { info } from './logger.js';
 
+const API_BASE_URL = `https://api.${config.domain}`;
+
 /**
- * Create S3-compatible client for Cloudflare R2
+ * Get API key for requests
  */
-function createR2Client() {
-    return new S3Client({
-        region: 'auto',
-        endpoint: `https://${config.r2.accountId}.r2.cloudflarestorage.com`,
-        credentials: {
-            accessKeyId: config.r2.accessKeyId,
-            secretAccessKey: config.r2.secretAccessKey,
-        },
-    });
+function getApiKey() {
+    return process.env.STATICLAUNCH_API_KEY || 'public-beta-key';
 }
 
 /**
@@ -29,13 +23,76 @@ function toPosixPath(windowsPath) {
 }
 
 /**
- * Upload a folder to R2 under a subdomain prefix with versioning
+ * Upload a single file via API proxy
+ * @param {Buffer} content - File content
+ * @param {string} subdomain - Target subdomain
+ * @param {number} version - Version number
+ * @param {string} filePath - Relative file path
+ * @param {string} contentType - MIME type
+ */
+async function uploadFile(content, subdomain, version, filePath, contentType) {
+    const response = await fetch(`${API_BASE_URL}/api/upload/file`, {
+        method: 'POST',
+        headers: {
+            'X-API-Key': getApiKey(),
+            'X-Subdomain': subdomain,
+            'X-Version': String(version),
+            'X-File-Path': filePath,
+            'X-Content-Type': contentType,
+            'Content-Type': 'application/octet-stream',
+        },
+        body: content,
+    });
+
+    if (!response.ok) {
+        const error = await response.json().catch(() => ({ error: 'Upload failed' }));
+        throw new Error(error.error || `Upload failed: ${response.status}`);
+    }
+
+    return response.json();
+}
+
+/**
+ * Mark upload complete and set active version
+ * @param {string} subdomain - Target subdomain
+ * @param {number} version - Version number
+ * @param {number} fileCount - Number of files uploaded
+ * @param {number} totalBytes - Total bytes uploaded
+ * @param {string} folderName - Original folder name
+ * @param {string|null} expiresAt - ISO expiration timestamp
+ */
+async function completeUpload(subdomain, version, fileCount, totalBytes, folderName, expiresAt) {
+    const response = await fetch(`${API_BASE_URL}/api/upload/complete`, {
+        method: 'POST',
+        headers: {
+            'X-API-Key': getApiKey(),
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+            subdomain,
+            version,
+            fileCount,
+            totalBytes,
+            folderName,
+            expiresAt,
+        }),
+    });
+
+    if (!response.ok) {
+        const error = await response.json().catch(() => ({ error: 'Complete upload failed' }));
+        throw new Error(error.error || `Complete upload failed: ${response.status}`);
+    }
+
+    return response.json();
+}
+
+/**
+ * Upload a folder to Launchpd via API proxy
  * @param {string} localPath - Local folder path
  * @param {string} subdomain - Subdomain to use as bucket prefix
  * @param {number} version - Version number for this deployment
  */
 export async function uploadFolder(localPath, subdomain, version = 1) {
-    const client = createR2Client();
     const files = await readdir(localPath, { recursive: true, withFileTypes: true });
 
     let uploaded = 0;
@@ -48,27 +105,35 @@ export async function uploadFolder(localPath, subdomain, version = 1) {
         // Build full local path
         const fullPath = join(file.parentPath || file.path, file.name);
 
-        // Build R2 key: subdomain/v{version}/relative/path/to/file.ext
+        // Build relative path for R2 key
         const relativePath = relative(localPath, fullPath);
-        const key = `${subdomain}/v${version}/${toPosixPath(relativePath)}`;
+        const posixPath = toPosixPath(relativePath);
 
         // Detect content type
         const contentType = mime.lookup(file.name) || 'application/octet-stream';
 
-        // Read file and upload
+        // Read file and upload via API
         const body = await readFile(fullPath);
         totalBytes += body.length;
 
-        await client.send(new PutObjectCommand({
-            Bucket: config.r2.bucketName,
-            Key: key,
-            Body: body,
-            ContentType: contentType,
-        }));
+        await uploadFile(body, subdomain, version, posixPath, contentType);
 
         uploaded++;
-        info(`  Uploaded (${uploaded}/${total}): ${toPosixPath(relativePath)}`);
+        info(`  Uploaded (${uploaded}/${total}): ${posixPath}`);
     }
 
     return { uploaded, subdomain, totalBytes };
 }
+
+/**
+ * Complete the upload and set active version
+ * @param {string} subdomain - Target subdomain
+ * @param {number} version - Version number
+ * @param {number} fileCount - Number of files
+ * @param {number} totalBytes - Total bytes
+ * @param {string} folderName - Folder name
+ * @param {string|null} expiresAt - Expiration ISO timestamp
+ */
+export async function finalizeUpload(subdomain, version, fileCount, totalBytes, folderName, expiresAt = null) {
+    return completeUpload(subdomain, version, fileCount, totalBytes, folderName, expiresAt);
+}