launchpd 1.0.1 → 1.0.2

package/README.md

@@ -49,6 +49,7 @@ npm install -g launchpd
 | `launchpd deploy . -m "Fix layout"` | Deploy with a message (like a git commit) |
 | `launchpd deploy . --name site` | Deploy with a custom subdomain explicitly |
 | `launchpd deploy . --expires 2h` | Set auto-deletion (e.g., `30m`, `1d`, `7d`) |
+| `launchpd deploy . --open` | Deploy and immediately open the site in your browser |
 
 ### Management
 | Command | Description |
@@ -57,7 +58,7 @@ npm install -g launchpd
 | `launchpd list` | View your active deployments |
 | `launchpd versions <subdomain>` | See version history with messages |
 | `launchpd rollback <subdomain>` | Rollback to the previous version |
-| `launchpd rollback <id> --to <v>` | Rollback to a specific version number |
+| `launchpd rollback <subdomain> --to <v>` | Rollback to a specific version number |
 
 ### Identity & Auth
 | Command | Description |

package/bin/cli.js

@@ -3,6 +3,7 @@
 import { Command } from 'commander';
 import { deploy, list, rollback, versions, init, status, login, logout, register, whoami, quota } from '../src/commands/index.js';
 
+
 const program = new Command();
 
 program
@@ -13,13 +14,16 @@ program
 program
     .command('deploy')
     .description('Deploy a folder to a live URL')
-    .argument('<folder>', 'Path to the folder to deploy')
+    .argument('[folder]', 'Path to the folder to deploy', '.')
     .option('--name <subdomain>', 'Use a custom subdomain (optional)')
     .option('-m, --message <text>', 'Deployment message (optional)')
     .option('--expires <time>', 'Auto-delete after time (e.g., 30m, 2h, 1d). Minimum: 30m')
+    .option('-y, --yes', 'Auto-confirm all prompts')
+    .option('--force', 'Force deployment even with warnings')
+    .option('-o, --open', 'Open the site URL in the default browser after deployment')
     .option('--verbose', 'Show detailed error information')
     .action(async (folder, options) => {
-        await deploy(folder, options);
+        await deploy(folder || '.', options);
     });
 
 program
@@ -37,6 +41,7 @@ program
     .description('List all versions for a subdomain')
     .argument('<subdomain>', 'The subdomain to list versions for')
     .option('--json', 'Output as JSON')
+    .option('--to <n>', 'Specific version number to rollback to (use with rollback)')
     .option('--verbose', 'Show detailed error information')
     .action(async (subdomain, options) => {
         await versions(subdomain, options);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "launchpd",
-    "version": "1.0.1",
+    "version": "1.0.2",
     "description": "Deploy static sites instantly to a live URL",
     "keywords": [
         "static",

package/src/commands/deploy.js

@@ -1,18 +1,21 @@
 import { existsSync, statSync } from 'node:fs';
+import { exec } from 'node:child_process';
 import chalk from 'chalk';
 import { readdir } from 'node:fs/promises';
-import { resolve, basename, join } from 'node:path';
+import { resolve, basename, join, relative, sep } 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, checkSubdomainAvailable, listSubdomains } from '../utils/api.js';
-import { getProjectConfig, findProjectRoot } from '../utils/projectConfig.js';
+import { getProjectConfig, findProjectRoot, updateProjectConfig } from '../utils/projectConfig.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';
 import { validateStaticOnly } from '../utils/validator.js';
+import { isIgnored } from '../utils/ignore.js';
+import { prompt } from '../utils/prompt.js';
 
 /**
  * Calculate total size of a folder
@@ -22,10 +25,17 @@ async function calculateFolderSize(folderPath) {
     let totalSize = 0;
 
     for (const file of files) {
+        const parentDir = file.parentPath || file.path;
+        const relativePath = relative(folderPath, join(parentDir, file.name));
+        const pathParts = relativePath.split(sep);
+
+        // Skip ignored directories/files in the path
+        if (pathParts.some(part => isIgnored(part, file.isDirectory()))) {
+            continue;
+        }
+
         if (file.isFile()) {
-            const fullPath = file.parentPath
-                ? join(file.parentPath, file.name)
-                : join(folderPath, file.name);
+            const fullPath = join(parentDir, file.name);
             try {
                 const stats = statSync(fullPath);
                 totalSize += stats.size;
@@ -65,6 +75,16 @@ export async function deploy(folder, options) {
         }
     }
 
+    // Validate deployment message is provided
+    if (!options.message) {
+        errorWithSuggestions('Deployment message is required.', [
+            'Use -m or --message to provide a description',
+            'Example: launchpd deploy . -m "Fix layout"',
+            'Example: launchpd deploy . -m "Initial deployment"'
+        ], { verbose });
+        process.exit(1);
+    }
+
     // Validate folder exists
     if (!existsSync(folderPath)) {
         errorWithSuggestions(`Folder not found: ${folderPath}`, [
@@ -78,33 +98,52 @@ export async function deploy(folder, options) {
     // 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;
+
+    // Filter out ignored files for the count
+    const activeFiles = files.filter(file => {
+        if (!file.isFile()) return false;
+        const parentDir = file.parentPath || file.path;
+        const relativePath = relative(folderPath, join(parentDir, file.name));
+        const pathParts = relativePath.split(sep);
+        return !pathParts.some(part => isIgnored(part, file.isDirectory()));
+    });
+
+    const fileCount = activeFiles.length;
 
     if (fileCount === 0) {
-        scanSpinner.fail('Folder is empty');
+        scanSpinner.fail('Folder is empty or only contains ignored files');
         errorWithSuggestions('Nothing to deploy.', [
             'Add some files to your folder',
+            'Make sure your files are not in ignored directories (like node_modules)',
             'Make sure index.html exists for static sites',
         ], { verbose });
         process.exit(1);
     }
-    scanSpinner.succeed(`Found ${fileCount} file(s)`);
+    scanSpinner.succeed(`Found ${fileCount} file(s) (ignored system files skipped)`);
 
     // Static-Only Validation
     const validationSpinner = spinner('Validating files...');
     const validation = await validateStaticOnly(folderPath);
     if (!validation.success) {
-        validationSpinner.fail('Deployment blocked: Non-static files detected');
-        errorWithSuggestions('Your project contains files that are not allowed.', [
-            'Launchpd only supports static files (HTML, CSS, JS, images, etc.)',
-            'Remove framework files, backend code, and build metadata:',
-            ...validation.violations.map(v => `   - ${v}`).slice(0, 10),
-            validation.violations.length > 10 ? `   - ...and ${validation.violations.length - 10} more` : '',
-            'If you use a framework (React, Vue, etc.), deploy the "dist" or "build" folder instead.'
-        ], { verbose });
-        process.exit(1);
+        if (options.force) {
+            validationSpinner.warn('Static-only validation failed, but proceeding due to --force');
+            warning('Non-static files detected.');
+            warning(chalk.bold.red('IMPORTANT: Launchpd only hosts STATIC files.'));
+            warning('Backend code (Node.js, PHP, etc.) will NOT be executed on the server.');
+        } else {
+            validationSpinner.fail('Deployment blocked: Non-static files detected');
+            errorWithSuggestions('Your project contains files that are not allowed.', [
+                'Launchpd only supports static files (HTML, CSS, JS, images, etc.)',
+                'Remove framework files, backend code, and build metadata:',
+                ...validation.violations.map(v => `   - ${v}`).slice(0, 10),
+                validation.violations.length > 10 ? `   - ...and ${validation.violations.length - 10} more` : '',
+                'If you use a framework (React, Vue, etc.), deploy the "dist" or "build" folder instead.',
+            ], { verbose });
+            process.exit(1);
+        }
+    } else {
+        validationSpinner.succeed('Project validated (Static files only)');
     }
-    validationSpinner.succeed('Project validated (Static files only)');
 
     // Generate or use provided subdomain
     // Anonymous users cannot use custom subdomains
@@ -118,18 +157,34 @@ export async function deploy(folder, options) {
 
     // Detect project config if no name provided
     let subdomain = (options.name && creds?.email) ? options.name.toLowerCase() : null;
+    let configSubdomain = null;
+
+    const projectRoot = findProjectRoot(folderPath);
+    const config = await getProjectConfig(projectRoot);
+    if (config?.subdomain) {
+        configSubdomain = config.subdomain;
+    }
 
     if (!subdomain) {
-        const projectRoot = findProjectRoot(folderPath);
-        const config = await getProjectConfig(projectRoot);
-        if (config?.subdomain) {
-            subdomain = config.subdomain;
+        if (configSubdomain) {
+            subdomain = configSubdomain;
             info(`Using project subdomain: ${chalk.bold(subdomain)}`);
+        } else {
+            subdomain = generateSubdomain();
         }
-    }
+    } else if (configSubdomain && subdomain !== configSubdomain) {
+        warning(`Mismatch: This project is linked to ${chalk.bold(configSubdomain)} but you are deploying to ${chalk.bold(subdomain)}`);
 
-    if (!subdomain) {
-        subdomain = generateSubdomain();
+        let shouldUpdate = options.yes;
+        if (!shouldUpdate) {
+            const confirm = await prompt(`Would you like to update this project's default subdomain to "${subdomain}"? (Y/N): `);
+            shouldUpdate = (confirm.toLowerCase() === 'y' || confirm.toLowerCase() === 'yes');
+        }
+
+        if (shouldUpdate) {
+            await updateProjectConfig({ subdomain }, projectRoot);
+            success(`Project configuration updated to: ${subdomain}`);
+        }
     }
 
     const url = `https://${subdomain}.launchpd.cloud`;
@@ -167,13 +222,23 @@ export async function deploy(folder, options) {
 
     // Check quota before deploying
     const quotaSpinner = spinner('Checking quota...');
-    const quotaCheck = await checkQuota(subdomain, estimatedBytes);
+    const isUpdate = (configSubdomain && subdomain === configSubdomain);
+
+    const quotaCheck = await checkQuota(subdomain, estimatedBytes, { isUpdate });
 
     if (!quotaCheck.allowed) {
-        quotaSpinner.fail('Deployment blocked due to quota limits');
-        process.exit(1);
+        if (options.force) {
+            quotaSpinner.warn('Deployment blocked due to quota limits, but proceeding due to --force');
+            warning('Uploading anyway... (server might still reject if physical limit is hit)');
+        } else {
+            quotaSpinner.fail('Deployment blocked due to quota limits');
+            info('Try running "launchpd quota" to check your storage.');
+            info('Use --force to try anyway (if you think this is a mistake)');
+            process.exit(1);
+        }
+    } else {
+        quotaSpinner.succeed('Quota check passed');
     }
-    quotaSpinner.succeed('Quota check passed');
 
     // Display any warnings
     displayQuotaWarnings(quotaCheck.warnings);
@@ -217,7 +282,7 @@ export async function deploy(folder, options) {
             totalBytes,
             folderName,
             expiresAt?.toISOString() || null,
-            options.message || null
+            options.message
         );
         finalizeSpinner.succeed('Deployment finalized');
 
@@ -234,6 +299,17 @@ export async function deploy(folder, options) {
 
         success(`Deployed successfully! (v${version})`);
         console.log(`\n${url}`);
+
+        if (options.open) {
+            const platform = process.platform;
+            let cmd;
+            if (platform === 'darwin') cmd = `open "${url}"`;
+            else if (platform === 'win32') cmd = `start "" "${url}"`;
+            else cmd = `xdg-open "${url}"`;
+
+            exec(cmd);
+        }
+
         if (expiresAt) {
             warning(`Expires: ${formatTimeRemaining(expiresAt)}`);
         }

package/src/commands/index.js

@@ -9,3 +9,4 @@ export { versions } from './versions.js';
 export { init } from './init.js';
 export { status } from './status.js';
 export { login, logout, register, whoami, quota } from './auth.js';
+

package/src/commands/init.js

@@ -1,9 +1,9 @@
-import { initProjectConfig, findProjectRoot } from '../utils/projectConfig.js';
-import { checkSubdomainAvailable, reserveSubdomain } from '../utils/api.js';
+import { initProjectConfig, findProjectRoot, getProjectConfig, saveProjectConfig } from '../utils/projectConfig.js';
+import { checkSubdomainAvailable, reserveSubdomain, listSubdomains } from '../utils/api.js';
 import { isLoggedIn } from '../utils/credentials.js';
 import { success, errorWithSuggestions, info, spinner, warning } from '../utils/logger.js';
-import readline from 'node:readline/promises';
-import { stdin as input, stdout as output } from 'node:process';
+import { prompt } from '../utils/prompt.js';
+import chalk from 'chalk';
 
 /**
  * Initialize a new project in the current directory
@@ -13,9 +13,13 @@ import { stdin as input, stdout as output } from 'node:process';
 export async function init(options) {
     const projectRoot = findProjectRoot();
     if (projectRoot) {
-        warning('This directory is already part of a Launchpd project.');
-        info(`Project root: ${projectRoot}`);
-        return;
+        const config = await getProjectConfig(projectRoot);
+        warning(`This directory is already part of a Launchpd project linked to: ${chalk.bold(config?.subdomain)}`);
+
+        const confirm = await prompt('Would you like to re-link this project to a different subdomain? (y/N): ');
+        if (confirm.toLowerCase() !== 'y' && confirm.toLowerCase() !== 'yes') {
+            return;
+        }
     }
 
     if (!await isLoggedIn()) {
@@ -23,40 +27,57 @@ export async function init(options) {
             'Run "launchpd login" to log in',
             'Run "launchpd register" to create an account'
         ]);
-        process.exit(1);
+        return;
     }
 
-    const rl = readline.createInterface({ input, output });
     let subdomain = options.name;
 
     if (!subdomain) {
         info('Linking this directory to a Launchpd subdomain...');
-        subdomain = await rl.question('Enter subdomain name (e.g. my-awesome-site): ');
+        subdomain = await prompt('Enter subdomain name (e.g. my-awesome-site): ');
     }
 
     if (!subdomain || !/^[a-z0-9-]+$/.test(subdomain)) {
-        rl.close();
         errorWithSuggestions('Invalid subdomain. Use lowercase alphanumeric and hyphens only.', [
             'Example: my-site-123',
             'No spaces or special characters'
         ]);
-        process.exit(1);
+        return;
     }
 
     const checkSpinner = spinner(`Checking if "${subdomain}" is available...`);
     try {
         const isAvailable = await checkSubdomainAvailable(subdomain);
+        let owned = false;
+
         if (!isAvailable) {
-            checkSpinner.fail(`Subdomain "${subdomain}" is already taken.`);
-            rl.close();
-            process.exit(1);
+            // Check if user owns it
+            const apiResult = await listSubdomains();
+            const ownedSubdomains = apiResult?.subdomains || [];
+            owned = ownedSubdomains.some(s => s.subdomain === subdomain);
+
+            if (!owned) {
+                checkSpinner.fail(`Subdomain "${subdomain}" is already taken.`);
+                return;
+            }
+            checkSpinner.info(`Subdomain "${subdomain}" is already yours.`);
+        } else {
+            checkSpinner.succeed(`Subdomain "${subdomain}" is available!`);
         }
-        checkSpinner.succeed(`Subdomain "${subdomain}" is available!`);
 
-        const reserveStatus = await reserveSubdomain(subdomain);
+        const reserveStatus = owned ? true : await reserveSubdomain(subdomain);
         if (reserveStatus) {
-            await initProjectConfig(subdomain);
-            success(`Project initialized! Linked to: ${subdomain}.launchpd.cloud`);
+            if (projectRoot) {
+                // Re-link
+                const config = await getProjectConfig(projectRoot);
+                config.subdomain = subdomain;
+                config.updatedAt = new Date().toISOString();
+                await saveProjectConfig(config, projectRoot);
+                success(`Project re-linked! New subdomain: ${subdomain}.launchpd.cloud`);
+            } else {
+                await initProjectConfig(subdomain);
+                success(`Project initialized! Linked to: ${subdomain}.launchpd.cloud`);
+            }
             info('Now you can run "launchpd deploy" without specifying a name.');
         }
     } catch (err) {
@@ -65,7 +86,5 @@ export async function init(options) {
             'Check your internet connection',
             'Try a different subdomain name'
         ]);
-    } finally {
-        rl.close();
     }
 }

package/src/commands/list.js

@@ -32,6 +32,7 @@ export async function list(options) {
                     version: d.version,
                     timestamp: d.created_at,
                     expiresAt: d.expires_at,
+                    message: d.message,
                     isActive: d.active_version === d.version,
                 }));
                 source = 'api';
@@ -65,12 +66,13 @@ export async function list(options) {
         // Header
         console.log(
             chalk.gray(
-                padRight('URL', 40) +
-                padRight('Folder', 15) +
-                padRight('Files', 7) +
-                padRight('Size', 12) +
-                padRight('Date', 12) +
-                'Status'
+                padRight('URL', 35) +
+                padRight('VER', 6) +
+                padRight('FOLDER', 15) +
+                padRight('FILES', 7) +
+                padRight('SIZE', 10) +
+                padRight('DATE', 12) +
+                'STATUS'
             )
         );
         console.log(chalk.gray('─'.repeat(100)));
@@ -84,26 +86,28 @@ export async function list(options) {
 
             // 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 {
+            if (dep.expiresAt && isExpired(dep.expiresAt)) {
+                status = chalk.red.bold('● expired');
+            } else if (dep.isActive) {
                 status = chalk.green.bold('● active');
+            } else if (dep.expiresAt) {
+                status = chalk.yellow(`⏱ ${formatTimeRemaining(dep.expiresAt)}`);
+            } else {
+                status = chalk.gray('○ inactive');
             }
 
-            // Version badge
-            const versionBadge = chalk.magenta(`v${dep.version || 1}`);
+            // Version info
+            const versionStr = `v${dep.version || 1}`;
 
             console.log(
-                chalk.cyan(padRight(url, 40)) +
+                chalk.cyan(padRight(url, 35)) +
+                chalk.magenta(padRight(versionStr, 6)) +
                 chalk.white(padRight(dep.folderName || '-', 15)) +
                 chalk.white(padRight(String(dep.fileCount), 7)) +
-                chalk.white(padRight(size, 12)) +
+                chalk.white(padRight(size, 10)) +
                 chalk.gray(padRight(date, 12)) +
-                status + ' ' + versionBadge
+                status +
+                (dep.message ? chalk.gray(` - ${dep.message}`) : '')
             );
         }
 

package/src/commands/status.js

@@ -1,6 +1,7 @@
 import { getProjectConfig, findProjectRoot } from '../utils/projectConfig.js';
 import { getDeployment } from '../utils/api.js';
 import { errorWithSuggestions, info, spinner, warning, formatSize } from '../utils/logger.js';
+import { formatTimeRemaining } from '../utils/expiration.js';
 import chalk from 'chalk';
 
 /**
@@ -41,6 +42,14 @@ export async function status(_options) {
             }
             console.log(`  File Count:      ${active.file_count || active.fileCount}`);
             console.log(`  Total Size:      ${formatSize(active.total_bytes || active.totalBytes)}`);
+
+            // Show expiration if set
+            if (active.expires_at || active.expiresAt) {
+                const expiryStr = formatTimeRemaining(active.expires_at || active.expiresAt);
+                const expiryColor = expiryStr === 'expired' ? chalk.red : chalk.yellow;
+                console.log(`  Expires:         ${expiryColor(expiryStr)}`);
+            }
+
             console.log(`  URL:             ${chalk.underline.blue(`https://${config.subdomain}.launchpd.cloud`)}`);
             console.log('');
         } else {

package/src/commands/versions.js

@@ -1,7 +1,7 @@
 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 { success, errorWithSuggestions, info, spinner, warning, formatSize } from '../utils/logger.js';
 import chalk from 'chalk';
 
 /**
@@ -23,6 +23,12 @@ export async function versions(subdomainInput, options) {
         process.exit(1);
     }
 
+    if (options.to) {
+        warning(`The --to option is for the ${chalk.bold('rollback')} command.`);
+        info(`Try: ${chalk.cyan(`launchpd rollback ${subdomain} --to ${options.to}`)}`);
+        console.log('');
+    }
+
     try {
         const fetchSpinner = spinner(`Fetching versions for ${subdomain}...`);
 

package/src/utils/expiration.js

@@ -2,10 +2,9 @@
  * 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 const MIN_EXPIRATION_MS = 30 * 60 * 1000;
 export function parseTimeString(timeStr) {
     const regex = /^(\d+)([mhd])$/i;
     const match = regex.exec(timeStr);
@@ -33,8 +32,7 @@ export function parseTimeString(timeStr) {
     }
 
     // Minimum 30 minutes
-    const minMs = 30 * 60 * 1000;
-    if (ms < minMs) {
+    if (ms < MIN_EXPIRATION_MS) {
         throw new Error('Minimum expiration time is 30 minutes (30m)');
     }
 

package/src/utils/ignore.js

@@ -0,0 +1,53 @@
+
+/**
+ * Shared ignore lists for Launchpd CLI
+ */
+
+// Directories to ignore during scanning, validation, and upload
+export const IGNORE_DIRECTORIES = new Set([
+    'node_modules',
+    '.git',
+    '.svn',
+    '.hg',
+    'vendor',
+    'composer',
+    '.env',
+    '.env.local',
+    '.env.production',
+    '.env.development',
+    'dist',
+    'build',
+    '.next',
+    '.nuxt',
+    '.svelte-kit',
+    'coverage',
+    '.cache'
+]);
+
+// Files to ignore during scanning, validation, and upload
+export const IGNORE_FILES = new Set([
+    '.launchpd.json',
+    'package-lock.json',
+    'yarn.lock',
+    'pnpm-lock.yaml',
+    '.DS_Store',
+    'Thumbs.db',
+    'desktop.ini',
+    '.gitignore',
+    '.npmignore',
+    'README.md',
+    'LICENSE'
+]);
+
+/**
+ * Check if a path or filename should be ignored
+ * @param {string} name - Base name of the file or directory
+ * @param {boolean} isDir - Whether the path is a directory
+ * @returns {boolean}
+ */
+export function isIgnored(name, isDir = false) {
+    if (isDir) {
+        return IGNORE_DIRECTORIES.has(name);
+    }
+    return IGNORE_FILES.has(name) || IGNORE_DIRECTORIES.has(name);
+}

package/src/utils/projectConfig.js

@@ -46,6 +46,20 @@ export async function saveProjectConfig(config, projectDir = process.cwd()) {
     return configPath;
 }
 
+/**
+ * Update project configuration
+ */
+export async function updateProjectConfig(updates, projectDir = findProjectRoot()) {
+    if (!projectDir) return null;
+    const config = await getProjectConfig(projectDir);
+    const newConfig = {
+        ...config,
+        ...updates,
+        updatedAt: new Date().toISOString()
+    };
+    return await saveProjectConfig(newConfig, projectDir);
+}
+
 /**
  * Initialize a new project config
  */

package/src/utils/prompt.js

@@ -8,12 +8,15 @@ export function prompt(question) {
     const rl = createInterface({
         input: process.stdin,
         output: process.stdout,
+        terminal: true
     });
 
     return new Promise((resolve) => {
         rl.question(question, (answer) => {
             rl.close();
-            resolve(answer.trim());
+            // Small delay to allow Windows handles to cleanup before process.exit might be called
+            // Increased to 100ms to be safer against UV_HANDLE_CLOSING assertion on Windows
+            setTimeout(() => resolve(answer.trim()), 100);
         });
     });
 }

package/src/utils/quota.js

@@ -15,20 +15,49 @@ const API_BASE_URL = `https://api.${config.domain}`;
  *
  * @param {string} subdomain - Target subdomain (null for new site)
  * @param {number} estimatedBytes - Estimated upload size in bytes
+ * @param {object} options - Options
+ * @param {boolean} options.isUpdate - Whether this is known to be an update
  * @returns {Promise<{allowed: boolean, isNewSite: boolean, quota: object, warnings: string[]}>}
  */
-export async function checkQuota(subdomain, estimatedBytes = 0) {
+export async function checkQuota(subdomain, estimatedBytes = 0, options = {}) {
     const creds = await getCredentials();
 
     let quotaData;
 
     if (creds?.apiKey) {
         // Authenticated user
-        quotaData = await checkAuthenticatedQuota(creds.apiKey);
+        quotaData = await checkAuthenticatedQuota(creds.apiKey, options.isUpdate);
     } else {
         // Anonymous user
         quotaData = await checkAnonymousQuota();
     }
+    // ... skipped ...
+    /**
+     * Check quota for authenticated user
+     */
+    async function checkAuthenticatedQuota(apiKey, isUpdate = false) {
+        try {
+            const url = new URL(`${API_BASE_URL}/api/quota`);
+            if (isUpdate) {
+                url.searchParams.append('is_update', 'true');
+            }
+
+            const response = await fetch(url.toString(), {
+                headers: {
+                    'X-API-Key': apiKey,
+                },
+            });
+
+            if (!response.ok) {
+                return null;
+            }
+
+            return await response.json();
+        } catch {
+            return null;
+        }
+    }
+    // ... skipped ...
 
     if (!quotaData) {
         // API unavailable, allow deployment (fail-open for MVP)
@@ -40,10 +69,25 @@ export async function checkQuota(subdomain, estimatedBytes = 0) {
         };
     }
 
+    // DEBUG: Write input options to file
+    try {
+        const { appendFileSync } = await import('node:fs');
+        appendFileSync('quota_debug_trace.txt', `\n[${new Date().toISOString()}] Check: ${subdomain}, isUpdate: ${options.isUpdate}, type: ${typeof options.isUpdate}`);
+    } catch {
+        // Ignore trace errors
+    }
+
     // Check if this is an existing site the user owns
-    const isNewSite = subdomain ? !await userOwnsSite(creds?.apiKey, subdomain) : true;
+    // If explicitly marked as update, assume user owns it
+    let isNewSite = true;
+    if (options.isUpdate) {
+        isNewSite = false;
+    } else if (subdomain) {
+        isNewSite = !await userOwnsSite(creds?.apiKey, subdomain);
+    }
 
     const warnings = [...(quotaData.warnings || [])];
+
     const allowed = true;
 
     // Check if blocked (anonymous limit reached)
@@ -107,6 +151,8 @@ export async function checkQuota(subdomain, estimatedBytes = 0) {
         }
     }
 
+
+
     return {
         allowed,
         isNewSite,
@@ -115,26 +161,6 @@ export async function checkQuota(subdomain, estimatedBytes = 0) {
     };
 }
 
-/**
- * Check quota for authenticated user
- */
-async function checkAuthenticatedQuota(apiKey) {
-    try {
-        const response = await fetch(`${API_BASE_URL}/api/quota`, {
-            headers: {
-                'X-API-Key': apiKey,
-            },
-        });
-
-        if (!response.ok) {
-            return null;
-        }
-
-        return await response.json();
-    } catch {
-        return null;
-    }
-}
 
 /**
  * Check quota for anonymous user
@@ -180,12 +206,18 @@ async function userOwnsSite(apiKey, subdomain) {
         });
 
         if (!response.ok) {
+            console.log('Fetch subdomains failed:', response.status);
             return false;
         }
 
         const data = await response.json();
-        return data.subdomains?.some(s => s.subdomain === subdomain) || false;
-    } catch {
+        console.log('User subdomains:', data.subdomains?.map(s => s.subdomain));
+        console.log('Checking for:', subdomain);
+        const owns = data.subdomains?.some(s => s.subdomain === subdomain) || false;
+        console.log('Owns site?', owns);
+        return owns;
+    } catch (err) {
+        console.log('Error checking ownership:', err);
         return false;
     }
 }

package/src/utils/upload.js

@@ -4,6 +4,7 @@ import mime from 'mime-types';
 import { config } from '../config.js';
 import { getApiKey, getApiSecret } from './credentials.js';
 import { createHmac } from 'node:crypto';
+import { isIgnored } from './ignore.js';
 
 const API_BASE_URL = config.apiUrl;
 
@@ -141,11 +142,26 @@ export async function uploadFolder(localPath, subdomain, version = 1, onProgress
     for (const file of files) {
         if (!file.isFile()) continue;
 
+        const fileName = file.name;
+        const parentDir = file.parentPath || file.path;
+
+        // Skip ignored directories in the path
+        const relativePath = relative(localPath, join(parentDir, fileName));
+        const pathParts = relativePath.split(sep);
+
+        if (pathParts.some(part => isIgnored(part, true))) {
+            continue;
+        }
+
+        // Skip ignored files
+        if (isIgnored(fileName, false)) {
+            continue;
+        }
+
         // Build full local path
-        const fullPath = join(file.parentPath || file.path, file.name);
+        const fullPath = join(parentDir, fileName);
 
         // Build relative path for R2 key
-        const relativePath = relative(localPath, fullPath);
         const posixPath = toPosixPath(relativePath);
 
         // Detect content type

package/src/utils/validator.js

@@ -1,5 +1,6 @@
 import { readdir } from 'node:fs/promises';
 import { extname } from 'node:path';
+import { isIgnored } from './ignore.js';
 
 // Allowed static file extensions
 const ALLOWED_EXTENSIONS = new Set([
@@ -65,6 +66,11 @@ export async function validateStaticOnly(folderPath) {
                 continue;
             }
 
+            // 2. Skip ignored files and directories
+            if (isIgnored(fileName, file.isDirectory())) {
+                continue;
+            }
+
             // 2. Check extension for non-allowed types (only for files)
             if (file.isFile()) {
                 // Ignore files without extensions or if they start with a dot (but handle indicators above)