@samebase/convex-hosting 0.3.2 → 0.4.1

package/dist/cli/upload.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"upload.d.ts","sourceRoot":"","sources":["../../src/cli/upload.ts"],"names":[],"mappings":";AACA;;;;;;;;;;;;;;;;;;GAkBG"}

package/dist/cli/upload.js

@@ -1,630 +0,0 @@
-#!/usr/bin/env node
-/**
- * CLI tool to upload static files to a Convex convex-hosting component.
- *
- * Usage:
- *   npx @samebase/convex-hosting upload [options]
- *
- * Options:
- *   --dist <path>            Path to dist directory (default: ./dist)
- *   --component <name>       Component instance name (default: hosting)
- *   --prod                   Deploy to production deployment
- *   --preview-name <name>    Upload to the named preview deployment
- *   --build                  Run the frontend build before uploading
- *   --build-command <cmd>    Override the frontend build command
- *   --spa / --no-spa         Enable or disable SPA fallback
- *   --cdn                    Use the legacy convex-fs integration
- *   --cdn-delete-function    App function that deletes old CDN blobs
- *   --concurrency <n>        Parallel upload workers (default: 5)
- *   --help                   Show help
- */
-import { readFileSync, existsSync } from "fs";
-import { resolve } from "path";
-import { randomUUID } from "crypto";
-import { runConvexAsync, spawnShell } from "./commands.js";
-import { chunkBySerializedArgument, MAX_CONVEX_ARGUMENT_BYTES } from "./argumentChunks.js";
-import { parseUploadArgs } from "./args.js";
-import { componentNameCandidates, isLegacyAutoDetected, legacyComponentNameWarning, } from "./componentName.js";
-import { collectFiles } from "./collectFiles.js";
-function showHelp() {
-    console.log(`
-Usage: npx @samebase/convex-hosting upload [options]
-
-Upload static files from a dist directory to Convex storage.
-
-Options:
-  -d, --dist <path>           Path to dist directory (default: ./dist)
-  -c, --component <name>      Static-hosting component instance name (default: hosting)
-      --prod                  Deploy to production deployment
-      --preview-name <name>   Upload to the named preview deployment
-  -b, --build                 Run the build command with VITE_CONVEX_URL +
-                              CONVEX_HOSTING_BASE_PATH set before uploading
-      --build-command <cmd>   Build command to run (default: 'npm run build').
-                              Implies --build.
-      --no-spa                Disable SPA fallback for this deployment (return a
-                              404 instead of falling back to /index.html)
-      --spa                   Enable SPA fallback for this deployment (default)
-      --cdn                   Use the legacy convex-fs integration
-      --cdn-delete-function <name>  Legacy app function that deletes CDN blobs
-  -j, --concurrency <n>       Number of parallel uploads (default: 5)
-  -h, --help                  Show this help message
-
-Examples:
-  # Upload to Convex storage
-  npx @samebase/convex-hosting upload
-  npx @samebase/convex-hosting upload --dist ./build --prod
-  npx @samebase/convex-hosting upload --build --prod
-
-  # Upload through an existing legacy convex-fs integration
-  npx @samebase/convex-hosting upload --cdn --prod
-`);
-}
-// Global flag for production mode
-let useProd = true;
-let previewName = null;
-const MAX_ASSETS_PER_DEPLOYMENT = 1800;
-const MAX_MANIFEST_SERIALIZED_BYTES = 2 * 1024 * 1024;
-// A Convex CLI function result can be truncated around 64 KiB. Signed upload
-// URLs are long enough that 250 sometimes crosses that boundary.
-const UPLOAD_URL_BATCH_SIZE = 100;
-const MAINTENANCE_PAGE_SIZE = 256;
-const MAX_MAINTENANCE_PAGES = 20;
-/**
- * Resolve the component's deployment URLs and the instance name that answered.
- *
- * When the caller relied on the default name we also probe the
- * @convex-dev/static-hosting name, so an app that kept that instance works without
- * `--component staticHosting`
- * on every command; landing on the legacy name prints a one-time warning. Bails
- * the CLI if no candidate is deployed. Uploading wouldn't work either, so a
- * fallback would only hide the real problem.
- */
-async function fetchUrls(requested) {
-    const candidates = componentNameCandidates(requested);
-    for (const name of candidates) {
-        try {
-            const out = await convexRunAsync(name, "lib:getUrls", {}, { quiet: true });
-            const urls = JSON.parse(out);
-            if (isLegacyAutoDetected(requested, name)) {
-                console.warn(legacyComponentNameWarning(name));
-            }
-            return { urls, componentName: name };
-        }
-        catch {
-            // Try the next candidate name.
-        }
-    }
-    console.error(`Could not reach component ${candidates
-        .map((name) => `"${name}"`)
-        .join(" or ")}. Deploy the Convex backend first and ensure --component ` +
-        `matches the name in convex.config.ts.`);
-    process.exit(1);
-}
-function convexRunAsync(componentName, functionPath, args = {}, options = {}) {
-    const serializedArgs = JSON.stringify(args);
-    const argumentBytes = Buffer.byteLength(serializedArgs);
-    if (argumentBytes > MAX_CONVEX_ARGUMENT_BYTES) {
-        throw new Error("The Convex function argument is " +
-            argumentBytes +
-            " bytes, which exceeds the portable command-line limit. " +
-            "This is an internal chunking error; please report it.");
-    }
-    return runConvexAsync([
-        "run",
-        ...(componentName ? ["--component", componentName] : []),
-        functionPath,
-        serializedArgs,
-        "--typecheck=disable",
-        "--codegen=disable",
-        ...(useProd ? ["--prod"] : []),
-        ...(previewName === null ? [] : ["--preview-name", previewName]),
-    ], options);
-}
-function errorMessage(error) {
-    return error instanceof Error ? error.message : String(error);
-}
-async function cleanUpPendingCdnBlobs(componentName, cdnDeleteFunction) {
-    if (!cdnDeleteFunction)
-        return 0;
-    let cleaned = 0;
-    for (let page = 0; page < MAX_MAINTENANCE_PAGES; page++) {
-        const output = await convexRunAsync(componentName, "lib:listPendingBlobCleanup", {
-            limit: 250,
-        });
-        const blobIds = JSON.parse(output);
-        if (!Array.isArray(blobIds) || !blobIds.every((blobId) => typeof blobId === "string")) {
-            throw new Error("Component returned invalid pending CDN cleanup data");
-        }
-        if (blobIds.length === 0)
-            return cleaned;
-        const deleteChunks = chunkBySerializedArgument(blobIds, (chunk) => ({
-            blobIds: chunk,
-        }));
-        for (const chunk of deleteChunks) {
-            await convexRunAsync(undefined, cdnDeleteFunction, { blobIds: chunk });
-            await convexRunAsync(componentName, "lib:acknowledgeBlobCleanup", {
-                blobIds: chunk,
-            });
-            cleaned += chunk.length;
-        }
-    }
-    console.warn("Warning: CDN cleanup reached its per-run maintenance limit; a later upload will continue it.");
-    return cleaned;
-}
-async function cleanUpAbandonedUploads(componentName, cdnDeleteFunction) {
-    let discarded = 0;
-    let deletedFiles = 0;
-    let queuedBlobIds = 0;
-    try {
-        let stagingDrained = false;
-        for (let page = 0; page < MAX_MAINTENANCE_PAGES; page++) {
-            const output = await convexRunAsync(componentName, "lib:cleanupAbandonedStaging", {
-                limit: MAINTENANCE_PAGE_SIZE,
-            });
-            const result = JSON.parse(output);
-            if (typeof result.discarded !== "number" ||
-                typeof result.deletedFiles !== "number" ||
-                typeof result.queuedBlobIds !== "number") {
-                throw new Error("Component returned invalid staging cleanup data");
-            }
-            discarded += result.discarded;
-            deletedFiles += result.deletedFiles;
-            queuedBlobIds += result.queuedBlobIds;
-            if (result.discarded < MAINTENANCE_PAGE_SIZE) {
-                stagingDrained = true;
-                break;
-            }
-        }
-        if (!stagingDrained) {
-            console.warn("Warning: Staging cleanup reached its per-run maintenance limit; a later upload will continue it.");
-        }
-        deletedFiles += await cleanUpPendingStorage(componentName);
-        deletedFiles += await cleanUpUnreferencedStorage(componentName, undefined, "desc");
-        deletedFiles += await cleanUpUnreferencedStorage(componentName, undefined, "asc");
-        if (discarded > 0 || deletedFiles > 0 || queuedBlobIds > 0) {
-            console.log(`Recovered ${discarded} abandoned manifest record(s), removed ${deletedFiles} old unreferenced file(s), and queued ${queuedBlobIds} CDN blob(s) for cleanup.`);
-        }
-        if (cdnDeleteFunction) {
-            const cleaned = await cleanUpPendingCdnBlobs(componentName, cdnDeleteFunction);
-            if (cleaned > 0) {
-                console.log(`Cleaned up ${cleaned} pending CDN blob(s).`);
-            }
-        }
-    }
-    catch (cleanupError) {
-        console.warn("Warning: Could not finish abandoned-upload maintenance: " + errorMessage(cleanupError));
-    }
-}
-async function cleanUpUnreferencedStorage(componentName, before, order = "asc") {
-    let deleted = 0;
-    for (let page = 0; page < MAX_MAINTENANCE_PAGES; page++) {
-        const output = await convexRunAsync(componentName, "lib:cleanupUnreferencedStorage", {
-            limit: MAINTENANCE_PAGE_SIZE,
-            order,
-            ...(before === undefined ? {} : { before }),
-        });
-        const result = JSON.parse(output);
-        if (typeof result.deleted !== "number" || typeof result.needsAnotherPass !== "boolean") {
-            throw new Error("Component returned invalid storage cleanup data");
-        }
-        deleted += result.deleted;
-        if (!result.needsAnotherPass)
-            return deleted;
-    }
-    console.warn("Warning: Orphan storage cleanup reached its per-run maintenance limit; a later upload will continue it.");
-    return deleted;
-}
-async function cleanUpPendingStorage(componentName) {
-    let deleted = 0;
-    for (let page = 0; page < MAX_MAINTENANCE_PAGES; page++) {
-        const output = await convexRunAsync(componentName, "lib:cleanupPendingStorage", {
-            limit: MAINTENANCE_PAGE_SIZE,
-        });
-        const result = JSON.parse(output);
-        if (typeof result.deleted !== "number" || typeof result.needsAnotherPass !== "boolean") {
-            throw new Error("Component returned invalid pending-storage cleanup data");
-        }
-        deleted += result.deleted;
-        if (!result.needsAnotherPass)
-            return deleted;
-    }
-    console.warn("Warning: Published storage cleanup reached its per-run maintenance limit; a later upload will continue it.");
-    return deleted;
-}
-async function forEachWithConcurrency(items, concurrency, worker) {
-    let nextIndex = 0;
-    let firstError;
-    async function runWorker() {
-        while (firstError === undefined) {
-            const index = nextIndex++;
-            if (index >= items.length)
-                return;
-            try {
-                await worker(items[index], index);
-            }
-            catch (error) {
-                firstError ??= error;
-            }
-        }
-    }
-    const workerCount = Math.min(concurrency, items.length);
-    await Promise.all(Array.from({ length: workerCount }, () => runWorker()));
-    if (firstError !== undefined)
-        throw firstError;
-}
-async function cleanUpFailedUpload(componentName, deploymentId, uploaded, cdnDeleteFunction, publishAttempted) {
-    let discardSucceeded = false;
-    let discarded = 0;
-    try {
-        const output = await convexRunAsync(componentName, "lib:discardStagedDeployment", {
-            deploymentId,
-        });
-        const result = JSON.parse(output);
-        if (typeof result.discarded !== "number") {
-            throw new Error("Component returned an invalid discard result");
-        }
-        discardSucceeded = true;
-        discarded = result.discarded;
-    }
-    catch (cleanupError) {
-        console.warn("Warning: Could not discard the staged manifest: " + errorMessage(cleanupError));
-    }
-    // Convex mutations have a single transaction order. If discard succeeds,
-    // either it removed the staged rows before a late publish could use them, or
-    // publish already committed and removed them first. In the latter case the
-    // component cleanup below sees the live references and keeps those files.
-    const canCleanComponentFiles = !publishAttempted || discardSucceeded;
-    if (uploaded.storageIds.length > 0 && canCleanComponentFiles) {
-        try {
-            let deleted = 0;
-            let stillReferenced = 0;
-            const chunks = chunkBySerializedArgument(uploaded.storageIds, (storageIds) => ({
-                storageIds,
-            }));
-            for (const storageIds of chunks) {
-                const output = await convexRunAsync(componentName, "lib:deleteUploadedFiles", {
-                    storageIds,
-                });
-                const result = JSON.parse(output);
-                if (typeof result.deleted === "number")
-                    deleted += result.deleted;
-                if (typeof result.stillReferenced === "number") {
-                    stillReferenced += result.stillReferenced;
-                }
-            }
-            console.log(`Removed ${deleted} file(s) from the failed upload.`);
-            if (stillReferenced > 0) {
-                console.warn(`Kept ${stillReferenced} file(s) because the live deployment references them. The publish may have completed even though its response was lost.`);
-            }
-        }
-        catch (cleanupError) {
-            console.warn("Warning: Could not remove component files from the failed upload: " +
-                errorMessage(cleanupError));
-        }
-    }
-    else if (uploaded.storageIds.length > 0) {
-        console.warn(`${uploaded.storageIds.length} component file(s) were left in place because the CLI could not cancel or confirm the publish.`);
-    }
-    // The app-level CDN delete function cannot inspect component-private live
-    // references. Only delete CDN blobs when no publish was attempted, or when
-    // discard removed staged rows and therefore won the transaction race.
-    const canDeleteCdnBlobs = !publishAttempted || (discardSucceeded && discarded > 0);
-    if (uploaded.blobIds.length > 0 && canDeleteCdnBlobs) {
-        try {
-            // Record these IDs before calling app-owned deletion. If that call fails
-            // or only partially completes, the next upload can retry safely.
-            const chunks = chunkBySerializedArgument(uploaded.blobIds, (blobIds) => ({
-                blobIds,
-            }));
-            for (const blobIds of chunks) {
-                await convexRunAsync(componentName, "lib:queueBlobCleanup", {
-                    blobIds,
-                });
-            }
-            if (cdnDeleteFunction) {
-                const cleaned = await cleanUpPendingCdnBlobs(componentName, cdnDeleteFunction);
-                console.log(`Removed ${cleaned} pending CDN blob(s).`);
-            }
-            else {
-                console.warn(`${uploaded.blobIds.length} CDN blob(s) from the failed upload were queued for cleanup. Pass --cdn-delete-function on a later upload to delete them.`);
-            }
-        }
-        catch (cleanupError) {
-            console.warn("Warning: Could not finish queuing or deleting CDN blobs from the failed upload: " +
-                errorMessage(cleanupError));
-        }
-    }
-    else if (uploaded.blobIds.length > 0 && !canDeleteCdnBlobs) {
-        console.warn(`${uploaded.blobIds.length} CDN blob(s) were left in place because the CLI could not determine whether the publish completed.`);
-    }
-}
-async function uploadWithConcurrency(files, componentName, deploymentId, useCdn, cdnUploadBase, concurrency, spaFallback, cdnDeleteFunction) {
-    const total = files.length;
-    const uploaded = { storageIds: [], blobIds: [] };
-    // Separate CDN and storage files
-    const cdnFiles = [];
-    const storageFiles = [];
-    for (const file of files) {
-        const isHtml = file.contentType.startsWith("text/html");
-        if (useCdn && !isHtml && cdnUploadBase) {
-            cdnFiles.push(file);
-        }
-        else {
-            storageFiles.push(file);
-        }
-    }
-    // Upload storage files using batch operations
-    let completed = 0;
-    const allAssets = [];
-    let publishAttempted = false;
-    try {
-        if (storageFiles.length > 0) {
-            // Keep both the Convex array value and the child-process stdout buffer
-            // bounded, even for a deployment with thousands of files.
-            console.log(`  Generating ${storageFiles.length} upload URLs...`);
-            const uploadUrls = [];
-            for (let offset = 0; offset < storageFiles.length; offset += UPLOAD_URL_BATCH_SIZE) {
-                const count = Math.min(UPLOAD_URL_BATCH_SIZE, storageFiles.length - offset);
-                const urlsOutput = await convexRunAsync(componentName, "lib:generateUploadUrls", { count });
-                const batch = JSON.parse(urlsOutput);
-                if (!Array.isArray(batch) ||
-                    batch.length !== count ||
-                    !batch.every((url) => typeof url === "string")) {
-                    throw new Error("Component returned invalid upload URLs");
-                }
-                uploadUrls.push(...batch);
-            }
-            // Step 2: Upload all files in parallel via fetch
-            const storageIds = new Array(storageFiles.length);
-            await forEachWithConcurrency(storageFiles, concurrency, async (file, idx) => {
-                const content = readFileSync(file.localPath);
-                const response = await fetch(uploadUrls[idx], {
-                    method: "POST",
-                    headers: { "Content-Type": file.contentType },
-                    body: content,
-                });
-                if (!response.ok) {
-                    throw new Error("Storage upload failed for " +
-                        file.path +
-                        ": " +
-                        response.status +
-                        " " +
-                        response.statusText);
-                }
-                const { storageId } = (await response.json());
-                if (typeof storageId !== "string") {
-                    throw new Error("Storage upload returned no storageId for " + file.path);
-                }
-                storageIds[idx] = storageId;
-                uploaded.storageIds.push(storageId);
-                completed++;
-                const isHtml = file.contentType.startsWith("text/html");
-                console.log(`  [${completed}/${total}] ${file.path} (${isHtml ? "storage/html" : "storage"})`);
-            });
-            for (let i = 0; i < storageFiles.length; i++) {
-                allAssets.push({
-                    path: storageFiles[i].path,
-                    storageId: storageIds[i],
-                    contentType: storageFiles[i].contentType,
-                    deploymentId,
-                });
-            }
-        }
-        // Upload CDN files (still uses per-file calls since CDN has its own upload endpoint)
-        if (cdnFiles.length > 0 && cdnUploadBase) {
-            await forEachWithConcurrency(cdnFiles, concurrency, async (file) => {
-                const content = readFileSync(file.localPath);
-                const uploadResponse = await fetch(`${cdnUploadBase}/fs/upload`, {
-                    method: "POST",
-                    headers: { "Content-Type": file.contentType },
-                    body: content,
-                });
-                if (!uploadResponse.ok) {
-                    throw new Error(`CDN upload failed for ${file.path}: ${uploadResponse.status}`);
-                }
-                const { blobId } = (await uploadResponse.json());
-                if (typeof blobId !== "string") {
-                    throw new Error("CDN upload returned no blobId for " + file.path);
-                }
-                uploaded.blobIds.push(blobId);
-                allAssets.push({
-                    path: file.path,
-                    blobId,
-                    contentType: file.contentType,
-                    deploymentId,
-                });
-                completed++;
-                console.log(`  [${completed}/${total}] ${file.path} (cdn)`);
-            });
-        }
-        // Stage the manifest in portable command-line chunks. These rows are not
-        // served, so the previous deployment stays intact until publish succeeds.
-        const manifestChunks = chunkBySerializedArgument(allAssets, (assets) => ({
-            assets,
-        }));
-        for (let index = 0; index < manifestChunks.length; index++) {
-            console.log(`  Staging manifest chunk ${index + 1}/${manifestChunks.length}...`);
-            await convexRunAsync(componentName, "lib:stageAssets", {
-                assets: manifestChunks[index],
-            });
-        }
-        // Publish the staged manifest, SPA setting, and old-asset GC in one
-        // mutation. The previous deployment stays intact if this call fails.
-        console.log("  Publishing deployment...");
-        publishAttempted = true;
-        const output = await convexRunAsync(componentName, "lib:publishDeployment", {
-            currentDeploymentId: deploymentId,
-            expectedAssetCount: allAssets.length,
-            spaFallback,
-        });
-        const result = JSON.parse(output);
-        if (typeof result.deleted !== "number" || typeof result.pendingBlobCleanup !== "number") {
-            throw new Error("Component returned an invalid publish result");
-        }
-        return {
-            deleted: result.deleted,
-            pendingBlobCleanup: result.pendingBlobCleanup,
-        };
-    }
-    catch (error) {
-        if (publishAttempted) {
-            try {
-                const output = await convexRunAsync(componentName, "lib:getCurrentDeployment");
-                const current = JSON.parse(output);
-                if (current?.currentDeploymentId === deploymentId) {
-                    console.warn("The publish completed, but the CLI could not read a valid response. The new deployment is live and its files were kept.");
-                    return {
-                        deleted: 0,
-                        pendingBlobCleanup: typeof current.pendingBlobCleanupCount === "number"
-                            ? current.pendingBlobCleanupCount
-                            : 0,
-                    };
-                }
-            }
-            catch (reconcileError) {
-                console.warn("Warning: Could not determine whether the publish completed: " +
-                    errorMessage(reconcileError));
-            }
-        }
-        await cleanUpFailedUpload(componentName, deploymentId, uploaded, cdnDeleteFunction, publishAttempted);
-        throw error;
-    }
-}
-function estimateManifestBytes(files, deploymentId) {
-    // IDs returned by Convex storage and convex-fs are much shorter than this.
-    // The generous placeholder lets us reject oversized path metadata before
-    // uploading while the component still enforces the exact serialized size.
-    const locationPlaceholder = "x".repeat(128);
-    return Buffer.byteLength(JSON.stringify(files.map((file) => ({
-        path: file.path,
-        storageId: locationPlaceholder,
-        contentType: file.contentType,
-        deploymentId,
-    }))));
-}
-async function main() {
-    const args = parseUploadArgs(process.argv.slice(2));
-    if (args.help) {
-        showHelp();
-        process.exit(0);
-    }
-    // Set global prod flag
-    useProd = args.prod;
-    previewName = args.previewName;
-    // The component knows both its CONVEX_SITE_URL (where the app is served,
-    // including the mount prefix) and CONVEX_CLOUD_URL (what the frontend
-    // connects to). We fetch both in one call and trust neither hostname. This
-    // also resolves the instance name actually mounted (default or legacy).
-    const { urls: { siteUrl: componentSiteUrl, cloudUrl: convexUrl }, componentName: resolvedComponentName, } = await fetchUrls(args.component);
-    // Run build if requested
-    if (args.build) {
-        const basePath = new URL(componentSiteUrl).pathname || "/";
-        const envLabel = previewName === null ? (useProd ? "production" : "development") : `preview (${previewName})`;
-        console.log(`🔨 Building for ${envLabel}...`);
-        console.log(`   Build command: ${args.buildCommand}`);
-        console.log(`   VITE_CONVEX_URL=${convexUrl}`);
-        console.log(`   CONVEX_HOSTING_BASE_PATH=${basePath}`);
-        console.log("");
-        const buildResult = spawnShell(args.buildCommand, {
-            ...process.env,
-            VITE_CONVEX_URL: convexUrl,
-            CONVEX_HOSTING_BASE_PATH: basePath,
-        });
-        if (buildResult !== 0) {
-            console.error("Build failed.");
-            process.exit(1);
-        }
-        console.log("");
-    }
-    const distDir = resolve(args.dist);
-    const componentName = resolvedComponentName;
-    const useCdn = args.cdn;
-    // Convex storage deployment
-    if (!existsSync(distDir)) {
-        console.error(`Error: dist directory not found: ${distDir}`);
-        console.error("Run your build command first (e.g., 'npm run build' or add --build flag)");
-        process.exit(1);
-    }
-    // /fs/upload lives at the deployment root, not under the component's
-    // mount prefix.
-    const cdnUploadBase = useCdn ? new URL(componentSiteUrl).origin : null;
-    const deploymentId = randomUUID();
-    const { files, skipped } = collectFiles(distDir);
-    for (const path of skipped) {
-        console.log(`Skipping ${path}: convex-hosting does not apply hosting rule files.`);
-    }
-    if (files.length === 0) {
-        console.error(`Error: dist directory is empty: ${distDir}`);
-        console.error("Refusing to replace the live deployment with no files.");
-        process.exit(1);
-    }
-    if (!files.some((file) => file.path === "/index.html")) {
-        console.error(`Error: dist directory has no index.html: ${distDir}`);
-        console.error("Refusing to publish a static site without its entry point.");
-        process.exit(1);
-    }
-    if (files.length > MAX_ASSETS_PER_DEPLOYMENT) {
-        console.error(`Error: dist directory contains ${files.length} files; the supported maximum is ${MAX_ASSETS_PER_DEPLOYMENT}.`);
-        console.error("Reduce the number of emitted files so publication stays within Convex transaction limits.");
-        process.exit(1);
-    }
-    const estimatedManifestBytes = estimateManifestBytes(files, deploymentId);
-    if (estimatedManifestBytes > MAX_MANIFEST_SERIALIZED_BYTES) {
-        console.error(`Error: asset manifest metadata is approximately ${estimatedManifestBytes} bytes; the supported maximum is ${MAX_MANIFEST_SERIALIZED_BYTES}.`);
-        console.error("Shorten emitted asset paths or reduce the number of files so publication stays within Convex transaction byte limits.");
-        process.exit(1);
-    }
-    await cleanUpAbandonedUploads(componentName, args.cdnDeleteFunction);
-    const envLabel = previewName === null ? (useProd ? "production" : "development") : `preview (${previewName})`;
-    console.log(`🚀 Deploying to ${envLabel} environment`);
-    if (useCdn) {
-        console.log("☁️  CDN mode: non-HTML assets will be uploaded to convex-fs");
-    }
-    console.log("🔒 Using secure internal functions (requires Convex CLI auth)");
-    console.log(`Uploading ${files.length} files with deployment ID: ${deploymentId}`);
-    console.log(`Component: ${componentName}`);
-    console.log("");
-    const publishResult = await uploadWithConcurrency(files, componentName, deploymentId, useCdn, cdnUploadBase, args.concurrency, args.spaFallback, args.cdnDeleteFunction);
-    console.log("");
-    let deletedCount = publishResult.deleted;
-    try {
-        // Publish queues only IDs from the old live manifest. Deleting that queue
-        // cannot race with files from another uploader that are not staged yet.
-        deletedCount += await cleanUpPendingStorage(componentName);
-    }
-    catch (cleanupError) {
-        console.warn("Warning: The new deployment is live, but old component storage could not be fully removed: " +
-            errorMessage(cleanupError));
-    }
-    if (deletedCount > 0) {
-        console.log(`Cleaned up ${deletedCount} old storage file(s) from previous deployments`);
-    }
-    // Old CDN IDs are persisted by the component until the app-level delete
-    // function succeeds, including when the publish response was lost.
-    if (args.cdnDeleteFunction) {
-        try {
-            const cleaned = await cleanUpPendingCdnBlobs(componentName, args.cdnDeleteFunction);
-            if (cleaned > 0) {
-                console.log(`Cleaned up ${cleaned} old CDN blob(s) from previous deployments`);
-            }
-        }
-        catch (error) {
-            console.warn("Warning: Could not delete old CDN blobs via " +
-                args.cdnDeleteFunction +
-                ": " +
-                errorMessage(error));
-        }
-    }
-    else if (publishResult.pendingBlobCleanup > 0) {
-        console.log(`${publishResult.pendingBlobCleanup} CDN blob(s) are pending cleanup. Pass --cdn-delete-function to delete them.`);
-    }
-    console.log("");
-    console.log("✨ Upload complete!");
-    console.log("");
-    console.log(`Your app is now available at: ${componentSiteUrl}`);
-}
-main().catch((error) => {
-    console.error("Upload failed:", error);
-    process.exit(1);
-});
-//# sourceMappingURL=upload.js.map