@solcreek/cli 0.3.0

package/dist/commands/deploy.js

@@ -0,0 +1,820 @@
+import { defineCommand } from "citty";
+import consola from "consola";
+import { existsSync, readFileSync, readdirSync, statSync, rmSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { execSync, execFileSync } from "node:child_process";
+import { CreekClient, CreekAuthError, isSSRFramework, getSSRServerEntry, getClientAssetsDir, getDefaultBuildOutput, detectFramework, resolveConfig, formatDetectionSummary, resolvedConfigToResources, resolvedConfigToBindingRequirements, ConfigNotFoundError, getSSRServerDir, collectServerFiles, isPreBundledFramework, detectNextjsMode, detectMonorepo, } from "@solcreek/sdk";
+import { getToken, getApiUrl } from "../utils/config.js";
+import { collectAssets } from "../utils/bundle.js";
+import { bundleSSRServer } from "../utils/ssr-bundle.js";
+import { bundleWorker } from "../utils/worker-bundle.js";
+import { sandboxDeploy, pollSandboxStatus, printSandboxSuccess } from "../utils/sandbox.js";
+import { isTTY, jsonOutput, resolveJsonMode, globalArgs, shouldAutoConfirm } from "../utils/output.js";
+import { ensureTosAccepted } from "../utils/tos.js";
+import { buildNextjs, patchBundledWorker, hasAdapterOutput } from "../utils/nextjs.js";
+import { isRepoUrl, parseRepoUrl, validateRepoUrl, validateSubpath, RepoUrlError } from "../utils/repo-url.js";
+import { checkGitInstalled, cloneRepo, detectPackageManager, installDependencies, cleanupDir as cleanupCloneDir, GitCloneError } from "../utils/git-clone.js";
+function section(name) {
+    consola.log(`\n  \x1b[2m[${name}]\x1b[0m`);
+}
+function assetSummary(fileList) {
+    const byExt = {};
+    for (const f of fileList) {
+        const ext = f.includes(".") ? `.${f.split(".").pop()}` : "(other)";
+        byExt[ext] = (byExt[ext] ?? 0) + 1;
+    }
+    const parts = Object.entries(byExt)
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, 4)
+        .map(([ext, n]) => `${n} ${ext}`);
+    return parts.join(", ");
+}
+export const deployCommand = defineCommand({
+    meta: {
+        name: "deploy",
+        description: "Deploy the current project to Creek",
+    },
+    args: {
+        dir: {
+            type: "positional",
+            description: "Directory to deploy (default: current directory)",
+            required: false,
+        },
+        "skip-build": {
+            type: "boolean",
+            description: "Skip the build step",
+            default: false,
+        },
+        demo: {
+            type: "boolean",
+            description: "Deploy a sample site to see Creek in action",
+            default: false,
+        },
+        ...globalArgs,
+        template: {
+            type: "string",
+            description: "Deploy a template (e.g., react-dashboard, astro-landing)",
+            required: false,
+        },
+        path: {
+            type: "string",
+            description: "Subdirectory within repo to deploy (for monorepos)",
+            required: false,
+        },
+    },
+    async run({ args }) {
+        const jsonMode = resolveJsonMode(args);
+        // --- Demo deploy (zero-friction showcase) ---
+        if (args.demo) {
+            return await deployDemo(jsonMode);
+        }
+        // --- Ensure ToS accepted (all non-demo paths) ---
+        const autoConfirm = shouldAutoConfirm(args);
+        const tos = await ensureTosAccepted(autoConfirm);
+        // --- Template deploy ---
+        if (args.template) {
+            return await deployTemplate(args.template);
+        }
+        // --- Repo URL deploy (creek deploy https://github.com/user/repo) ---
+        if (args.dir && isRepoUrl(args.dir)) {
+            return await deployRepoUrl(args.dir, {
+                path: args.path ?? null,
+                skipBuild: args["skip-build"],
+                json: jsonMode,
+            });
+        }
+        // --- Resolve target directory ---
+        const cwd = args.dir ? resolve(args.dir) : process.cwd();
+        const token = getToken();
+        // --- Explicit directory (creek deploy ./dist) ---
+        if (args.dir) {
+            if (!existsSync(cwd)) {
+                if (jsonMode)
+                    jsonOutput({ error: "not_found", message: `Directory not found: ${args.dir}` }, 1);
+                consola.error(`Directory not found: ${args.dir}`);
+                process.exit(1);
+            }
+            return await deployDirectory(cwd, jsonMode, tos);
+        }
+        // --- Try auto-detection (creek.toml → wrangler.* → package.json → index.html) ---
+        let resolved = null;
+        try {
+            resolved = resolveConfig(cwd);
+        }
+        catch (err) {
+            if (!(err instanceof ConfigNotFoundError))
+                throw err;
+        }
+        if (resolved) {
+            if (!jsonMode) {
+                consola.info(`  Detected: ${formatDetectionSummary(resolved)}`);
+                for (const ub of resolved.unsupportedBindings) {
+                    consola.warn(`  Binding '${ub.name}' (${ub.type}) is not yet supported — will be skipped`);
+                }
+            }
+            if (token) {
+                return await deployAuthenticated(cwd, resolved, token, args["skip-build"], jsonMode);
+            }
+            return await deploySandbox(cwd, args["skip-build"], jsonMode, resolved, tos);
+        }
+        // --- Auto-detect build output dirs ---
+        for (const dir of ["dist", "build", "out", ".output/public"]) {
+            const fullPath = resolve(cwd, dir);
+            if (existsSync(fullPath)) {
+                if (!jsonMode)
+                    consola.info(`Found build output: ${dir}/`);
+                return await deployDirectory(fullPath, jsonMode, tos);
+            }
+        }
+        // --- Nothing found → guide the user ---
+        if (jsonMode)
+            jsonOutput({ error: "no_project", message: "No project found in this directory" }, 1);
+        consola.info("No project found in this directory.\n");
+        consola.info("  creek deploy ./dist        Deploy a build output directory");
+        consola.info("  creek deploy --demo        Deploy a sample site (see Creek in 5 seconds)");
+        consola.info("");
+        consola.info("Or create a project first:");
+        consola.info("  npm create vite@latest my-app && cd my-app && npx creek deploy");
+        process.exit(1);
+    },
+});
+async function deployRepoUrl(input, options) {
+    const { path: subpath, skipBuild, json: jsonMode } = options;
+    try {
+        // 1. Parse and validate URL
+        const parsed = parseRepoUrl(input);
+        validateRepoUrl(parsed);
+        if (subpath)
+            validateSubpath(subpath);
+        // 2. Check git is available
+        checkGitInstalled();
+        // 3. Clone
+        section("Clone");
+        consola.start(`  Cloning ${parsed.displayUrl}...`);
+        const { tmpDir, workDir, sizeMb } = cloneRepo(parsed, { subpath });
+        consola.success(`  Cloned (${sizeMb.toFixed(1)} MB)`);
+        try {
+            // 4. Resolve config
+            section("Detect");
+            let resolved;
+            try {
+                resolved = resolveConfig(workDir);
+            }
+            catch (err) {
+                if (err instanceof ConfigNotFoundError) {
+                    consola.error(`No supported project found in ${parsed.displayUrl}.`);
+                    consola.info("");
+                    consola.info("  If this is a monorepo, specify a subdirectory:");
+                    consola.info(`    creek deploy ${input} --path packages/app`);
+                    consola.info("");
+                    consola.info("  Creek looks for: creek.toml, wrangler.*, package.json, or index.html");
+                    process.exit(1);
+                }
+                throw err;
+            }
+            consola.info(`  Detected: ${formatDetectionSummary(resolved)}`);
+            for (const ub of resolved.unsupportedBindings) {
+                consola.warn(`  Binding '${ub.name}' (${ub.type}) is not yet supported — will be skipped`);
+            }
+            // 5. Install dependencies (if package.json exists)
+            if (existsSync(join(workDir, "package.json"))) {
+                section("Install");
+                const pm = detectPackageManager(workDir);
+                consola.start(`  Installing dependencies (${pm})...`);
+                installDependencies(workDir, pm);
+                consola.success(`  Dependencies installed`);
+            }
+            // 6. Route to authenticated or sandbox deploy
+            const token = getToken();
+            if (token) {
+                return await deployAuthenticated(workDir, resolved, token, skipBuild, jsonMode);
+            }
+            return await deploySandbox(workDir, skipBuild, jsonMode, resolved);
+        }
+        finally {
+            cleanupCloneDir(tmpDir);
+        }
+    }
+    catch (err) {
+        if (err instanceof RepoUrlError || err instanceof GitCloneError) {
+            if (jsonMode)
+                jsonOutput({ error: "repo_deploy_failed", message: err.message }, 1);
+            consola.error(err.message);
+            process.exit(1);
+        }
+        throw err;
+    }
+}
+// ============================================================================
+// Demo deploy — pre-built page, zero dependencies, instant
+// ============================================================================
+const DEMO_HTML = `<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>Creek Deploy Demo</title>
+<style>
+*{margin:0;padding:0;box-sizing:border-box}
+body{font-family:system-ui,-apple-system,sans-serif;background:#0a0a0a;color:#f5f5f5;min-height:100vh;display:flex;flex-direction:column;align-items:center;justify-content:center}
+.card{max-width:480px;text-align:center;padding:3rem 2rem}
+h1{font-size:2rem;font-weight:700;letter-spacing:-0.03em;margin-bottom:0.5rem}
+.accent{background:linear-gradient(135deg,#38bdf8,#818cf8);-webkit-background-clip:text;-webkit-text-fill-color:transparent;background-clip:text}
+p{color:#888;line-height:1.6;margin-top:1rem}
+.meta{margin-top:2rem;font-size:0.85rem;color:#555}
+.cta{display:inline-block;margin-top:1.5rem;background:linear-gradient(135deg,#2563eb,#3b82f6);color:#fff;padding:10px 24px;border-radius:8px;text-decoration:none;font-weight:600;font-size:0.9rem;transition:opacity 0.15s}
+.cta:hover{opacity:0.9}
+code{background:#1a1a2e;padding:2px 8px;border-radius:4px;font-size:0.85rem;color:#a5b4fc}
+.pulse{width:12px;height:12px;background:#22c55e;border-radius:50%;display:inline-block;margin-right:8px;animation:pulse 2s infinite}
+@keyframes pulse{0%,100%{opacity:1}50%{opacity:0.4}}
+</style>
+</head>
+<body>
+<div class="card">
+<h1><span class="accent">Creek</span> is live.</h1>
+<p>This site was deployed to the edge in seconds — no build step, no config, no account.</p>
+<p style="margin-top:1.5rem"><span class="pulse"></span>Running on Cloudflare's global network</p>
+<p class="meta">Now try it with your own project:</p>
+<p style="margin-top:0.5rem"><code>cd your-project && npx creek deploy</code></p>
+<a href="https://creek.dev" class="cta">Learn more about Creek</a>
+</div>
+<script>document.title="Creek Deploy Demo — "+new Date().toLocaleTimeString()</script>
+</body>
+</html>`;
+async function deployDemo(jsonMode) {
+    if (!jsonMode)
+        consola.start("Deploying demo site...");
+    try {
+        const result = await sandboxDeploy({
+            assets: { "index.html": Buffer.from(DEMO_HTML).toString("base64") },
+            source: "cli-demo",
+        });
+        if (!jsonMode)
+            consola.start("Waiting for deployment...");
+        const status = await pollSandboxStatus(result.statusUrl);
+        if (jsonMode) {
+            jsonOutput({
+                ok: true,
+                sandboxId: result.sandboxId,
+                url: status.previewUrl,
+                deployDurationMs: status.deployDurationMs,
+                expiresAt: result.expiresAt,
+                mode: "demo",
+            });
+        }
+        const duration = status.deployDurationMs
+            ? `in ${(status.deployDurationMs / 1000).toFixed(1)}s`
+            : "in seconds";
+        consola.success(`Live ${duration} → ${status.previewUrl}`);
+        consola.info("");
+        consola.info("That's Creek. Now deploy your own project:");
+        consola.info("  cd your-project && npx creek deploy");
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : "Demo deploy failed";
+        if (jsonMode)
+            jsonOutput({ ok: false, error: "deploy_failed", message }, 1);
+        consola.error(message);
+        process.exit(1);
+    }
+}
+// ============================================================================
+// Directory deploy — deploy pre-built static files directly
+// ============================================================================
+async function deployDirectory(dir, jsonMode, tos) {
+    if (!jsonMode)
+        section("Upload");
+    const { assets, fileList } = collectAssets(dir);
+    if (fileList.length === 0) {
+        if (jsonMode)
+            jsonOutput({ ok: false, error: "no_files", message: `No files found in ${dir}` }, 1);
+        consola.error(`No files found in ${dir}\n`);
+        consola.info("  creek deploy ./dist        Deploy a build output directory");
+        consola.info("  creek deploy --demo        Deploy a sample site (see Creek in 5 seconds)");
+        process.exit(1);
+    }
+    if (!jsonMode) {
+        consola.info(`  ${fileList.length} files (${assetSummary(fileList)})`);
+        consola.info("  Mode: sandbox (60 min preview)");
+        section("Deploy");
+        consola.start("  Deploying to edge...");
+    }
+    try {
+        const result = await sandboxDeploy({ assets, source: "cli" }, { tos });
+        const status = await pollSandboxStatus(result.statusUrl);
+        if (jsonMode) {
+            jsonOutput({
+                ok: true,
+                sandboxId: result.sandboxId,
+                url: status.previewUrl,
+                deployDurationMs: status.deployDurationMs,
+                expiresAt: result.expiresAt,
+                assetCount: fileList.length,
+                mode: "sandbox",
+            });
+        }
+        printSandboxSuccess(status.previewUrl, result.expiresAt, result.sandboxId);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : "Deploy failed";
+        if (jsonMode)
+            jsonOutput({ ok: false, error: "deploy_failed", message }, 1);
+        consola.error(message);
+        process.exit(1);
+    }
+}
+// ============================================================================
+// Sandbox deploy — auto-detect framework, build, deploy
+// ============================================================================
+async function deploySandbox(cwd, skipBuild, jsonMode = false, resolved, tos) {
+    const framework = resolved?.framework ?? detectFramework(JSON.parse(readFileSync(join(cwd, "package.json"), "utf-8")));
+    // Detect Next.js mode (static vs opennext SSR)
+    const pkg = JSON.parse(readFileSync(join(cwd, "package.json"), "utf-8"));
+    const nextjsMode = framework === "nextjs" ? detectNextjsMode(pkg, cwd) : null;
+    const monorepo = detectMonorepo(cwd);
+    section("Detect");
+    consola.info(`  Framework: ${framework ?? "static site"}`);
+    if (nextjsMode)
+        consola.info(`  Next.js mode: ${nextjsMode}${monorepo.isMonorepo ? " (monorepo)" : ""}`);
+    consola.info("  Mode: sandbox (60 min preview)");
+    // Build
+    if (!skipBuild) {
+        section("Build");
+        if (nextjsMode === "opennext") {
+            // Next.js SSR on CF Workers: adapter (>= 16.2) or legacy opennext
+            try {
+                buildNextjs(cwd, monorepo.isMonorepo);
+            }
+            catch {
+                consola.error("Next.js build failed");
+                process.exit(1);
+            }
+            consola.success("  Build complete");
+        }
+        else {
+            const buildCommand = resolved?.buildCommand || "npm run build";
+            if (!buildCommand) {
+                consola.error("No build script found in package.json.");
+                consola.info("Add a 'build' script or use --skip-build if already built.");
+                process.exit(1);
+            }
+            consola.start(`  ${buildCommand}`);
+            try {
+                execSync(buildCommand, { cwd, stdio: "inherit" });
+            }
+            catch {
+                consola.error("Build failed");
+                consola.info("");
+                consola.info("  Common fixes:");
+                consola.info("    npm install (missing dependencies?)");
+                consola.info("    Check for TypeScript errors");
+                process.exit(1);
+            }
+            consola.success("  Build complete");
+        }
+    }
+    const useAdapterOutput = framework === "nextjs" && hasAdapterOutput(cwd);
+    const outputDir = useAdapterOutput
+        ? resolve(cwd, ".creek/adapter-output")
+        : resolve(cwd, resolved?.buildOutput ?? getDefaultBuildOutput(framework));
+    if (!existsSync(outputDir)) {
+        consola.error(`Build output not found: ${outputDir}`);
+        if (framework) {
+            consola.info(`Expected output for ${framework}: ${getDefaultBuildOutput(framework)}`);
+        }
+        process.exit(1);
+    }
+    // Collect assets
+    const isSSR = isSSRFramework(framework);
+    const renderMode = isSSR ? "ssr" : "spa";
+    let clientAssetsDir;
+    if (useAdapterOutput) {
+        clientAssetsDir = resolve(outputDir, "assets");
+    }
+    else {
+        clientAssetsDir = outputDir;
+        if (isSSR && framework) {
+            const subdir = getClientAssetsDir(framework);
+            if (subdir)
+                clientAssetsDir = resolve(outputDir, subdir);
+        }
+    }
+    section("Upload");
+    const { assets: clientAssets, fileList } = collectAssets(clientAssetsDir);
+    consola.info(`  ${fileList.length} assets (${assetSummary(fileList)})`);
+    let serverFiles;
+    if (isSSR && framework) {
+        const serverEntry = getSSRServerEntry(framework);
+        if (serverEntry) {
+            const serverEntryPath = resolve(outputDir, serverEntry);
+            if (existsSync(serverEntryPath)) {
+                consola.start("  Bundling SSR server...");
+                const bundled = await bundleSSRServer(serverEntryPath);
+                serverFiles = { "server.js": Buffer.from(bundled).toString("base64") };
+                consola.success(`  SSR bundled (${Math.round(bundled.length / 1024)}KB)`);
+            }
+        }
+    }
+    // Deploy to sandbox
+    if (!jsonMode) {
+        section("Deploy");
+        consola.start("  Deploying to edge...");
+    }
+    try {
+        const result = await sandboxDeploy({
+            assets: clientAssets,
+            serverFiles,
+            framework: framework ?? undefined,
+            source: "cli",
+        }, { tos });
+        const status = await pollSandboxStatus(result.statusUrl);
+        if (jsonMode) {
+            jsonOutput({
+                ok: true,
+                sandboxId: result.sandboxId,
+                url: status.previewUrl,
+                deployDurationMs: status.deployDurationMs,
+                expiresAt: result.expiresAt,
+                framework: framework ?? null,
+                assetCount: fileList.length,
+                mode: "sandbox",
+            });
+        }
+        printSandboxSuccess(status.previewUrl, result.expiresAt, result.sandboxId);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : "Sandbox deploy failed";
+        if (jsonMode)
+            jsonOutput({ ok: false, error: "deploy_failed", message }, 1);
+        consola.error(message);
+        process.exit(1);
+    }
+}
+// ============================================================================
+// Template deploy — clone + build + deploy to sandbox
+// ============================================================================
+async function deployTemplate(templateId) {
+    // Validate template ID — alphanumeric, hyphens, underscores only (no path traversal)
+    if (!/^[a-zA-Z0-9_-]+$/.test(templateId)) {
+        consola.error("Invalid template name. Use only letters, numbers, hyphens, and underscores.");
+        process.exit(1);
+    }
+    consola.info(`Deploying template: ${templateId}`);
+    // Clone template to temp dir
+    const tmpDir = join(process.env.TMPDIR ?? "/tmp", `creek-template-${Date.now()}`);
+    const repoUrl = "https://github.com/solcreek/templates";
+    consola.start("Cloning template...");
+    try {
+        execFileSync("git", [
+            "clone", "--depth", "1", "--filter=blob:none", "--sparse", repoUrl, tmpDir,
+        ], { stdio: "pipe" });
+        execFileSync("git", [
+            "sparse-checkout", "set", templateId,
+        ], { cwd: tmpDir, stdio: "pipe" });
+    }
+    catch {
+        consola.error(`Template '${templateId}' not found.`);
+        consola.info("Available templates: creek deploy --template");
+        cleanupDir(tmpDir);
+        process.exit(1);
+    }
+    const templateDir = join(tmpDir, templateId);
+    // Verify resolved path is still within tmpDir (prevent path traversal)
+    if (!resolve(templateDir).startsWith(resolve(tmpDir))) {
+        consola.error("Invalid template path.");
+        cleanupDir(tmpDir);
+        process.exit(1);
+    }
+    if (!existsSync(templateDir)) {
+        consola.error(`Template directory not found: ${templateId}`);
+        cleanupDir(tmpDir);
+        process.exit(1);
+    }
+    consola.start("Installing dependencies...");
+    try {
+        execFileSync("npm", ["install"], { cwd: templateDir, stdio: "pipe" });
+    }
+    catch {
+        consola.error("Failed to install dependencies");
+        cleanupDir(tmpDir);
+        process.exit(1);
+    }
+    // Deploy as sandbox (reuse sandbox flow)
+    await deploySandbox(templateDir, false);
+    // Cleanup
+    cleanupDir(tmpDir);
+}
+function cleanupDir(dir) {
+    try {
+        rmSync(dir, { recursive: true, force: true });
+    }
+    catch {
+        // ignore
+    }
+}
+// ============================================================================
+// Authenticated deploy — existing flow
+// ============================================================================
+async function deployAuthenticated(cwd, resolved, token, skipBuild, jsonMode = false) {
+    try {
+        const client = new CreekClient(getApiUrl(), token);
+        section("Auth");
+        const session = await client.getSession();
+        if (!session?.user) {
+            consola.error("Token is invalid or expired. Run `creek login` to re-authenticate.");
+            process.exit(1);
+        }
+        consola.info(`  Deploying as ${session.user.email}`);
+        consola.info(`  Project: ${resolved.projectName}`);
+        // Ensure project exists — confirm before auto-creating
+        let project;
+        try {
+            project = await client.getProject(resolved.projectName);
+        }
+        catch {
+            if (!jsonMode && isTTY) {
+                const confirm = await consola.prompt(`Project "${resolved.projectName}" does not exist. Create it?`, { type: "confirm" });
+                if (!confirm) {
+                    consola.info("Deploy cancelled.");
+                    process.exit(0);
+                }
+            }
+            const res = await client.createProject({
+                slug: resolved.projectName,
+                framework: resolved.framework ?? undefined,
+            });
+            project = res.project;
+            if (!jsonMode)
+                consola.success(`  Created project: ${project.slug}`);
+        }
+        // Determine deploy mode
+        const framework = resolved.framework;
+        const isSSR = isSSRFramework(framework);
+        const isWorker = !framework && !!resolved.workerEntry;
+        const renderMode = isWorker ? "worker" : (isSSR ? "ssr" : "spa");
+        // Detect Next.js mode for special build handling
+        const pkg = existsSync(join(cwd, "package.json"))
+            ? JSON.parse(readFileSync(join(cwd, "package.json"), "utf-8"))
+            : {};
+        const nextjsMode = framework === "nextjs" ? detectNextjsMode(pkg, cwd) : null;
+        const monorepo = framework === "nextjs" ? detectMonorepo(cwd) : { isMonorepo: false, root: null };
+        if (nextjsMode) {
+            if (!jsonMode)
+                consola.info(`  Next.js mode: ${nextjsMode}${monorepo.isMonorepo ? " (monorepo)" : ""}`);
+        }
+        // Build (skip for pure Workers with no build command)
+        if (!skipBuild && resolved.buildCommand) {
+            section("Build");
+            if (nextjsMode === "opennext") {
+                try {
+                    buildNextjs(cwd, monorepo.isMonorepo);
+                }
+                catch {
+                    consola.error("Next.js build failed");
+                    process.exit(1);
+                }
+                consola.success("  Build complete");
+            }
+            else {
+                const buildCmd = resolved.buildCommand;
+                if (buildCmd.length > 500) {
+                    consola.error("Invalid build command (too long)");
+                    process.exit(1);
+                }
+                consola.start(`  ${buildCmd}`);
+                try {
+                    execSync(buildCmd, { cwd, stdio: "inherit" });
+                }
+                catch {
+                    consola.error("Build failed");
+                    process.exit(1);
+                }
+                consola.success("  Build complete");
+            }
+        }
+        // Collect client assets
+        // Worker + SPA hybrid: if a Worker project has buildOutput with built files, collect them too
+        let clientAssets = {};
+        let fileList = [];
+        const workerHasClientAssets = isWorker && resolved.buildOutput && resolved.buildOutput !== "." &&
+            existsSync(resolve(cwd, resolved.buildOutput));
+        if (!isWorker || workerHasClientAssets) {
+            let clientAssetsDir;
+            // Adapter output takes precedence for Next.js
+            if (framework === "nextjs" && hasAdapterOutput(cwd)) {
+                clientAssetsDir = resolve(cwd, ".creek/adapter-output/assets");
+            }
+            else {
+                const outputDir = resolve(cwd, resolved.buildOutput);
+                if (!existsSync(outputDir)) {
+                    consola.error(`Build output directory not found: ${resolved.buildOutput}`);
+                    process.exit(1);
+                }
+                clientAssetsDir = outputDir;
+                if (isSSR && framework) {
+                    const clientSubdir = getClientAssetsDir(framework);
+                    if (clientSubdir) {
+                        clientAssetsDir = resolve(outputDir, clientSubdir);
+                    }
+                }
+            }
+            section("Upload");
+            ({ assets: clientAssets, fileList } = collectAssets(clientAssetsDir));
+            consola.info(`  ${fileList.length} assets (${assetSummary(fileList)})`);
+        }
+        // Bundle server/worker files
+        let serverFiles;
+        if (isSSR && framework) {
+            if (framework === "nextjs" && hasAdapterOutput(cwd)) {
+                // Adapter path: read pre-bundled output from .creek/adapter-output/
+                const adapterServerDir = resolve(cwd, ".creek/adapter-output/server");
+                consola.start("  Collecting adapter output...");
+                const collected = {};
+                if (existsSync(adapterServerDir)) {
+                    for (const f of readdirSync(adapterServerDir)) {
+                        const fp = join(adapterServerDir, f);
+                        if (!statSync(fp).isFile())
+                            continue;
+                        if (f.endsWith(".map"))
+                            continue;
+                        collected[f] = readFileSync(fp);
+                    }
+                }
+                const fileCount = Object.keys(collected).length;
+                serverFiles = Object.fromEntries(Object.entries(collected).map(([p, buf]) => [p, buf.toString("base64")]));
+                consola.success(`  Worker bundled: ${fileCount} files (${Math.round(Object.values(collected).reduce((s, b) => s + b.length, 0) / 1024)}KB)`);
+            }
+            else if (framework === "nextjs") {
+                // Legacy path: use wrangler to produce a single bundled worker
+                const bundleDir = resolve(cwd, ".creek/bundled");
+                consola.start("  Bundling Next.js worker (legacy)...");
+                execSync(`npx wrangler deploy --dry-run --outdir "${bundleDir}"`, { cwd, stdio: "pipe" });
+                patchBundledWorker(bundleDir, resolve(cwd, ".open-next"));
+                const collected = {};
+                if (existsSync(bundleDir)) {
+                    for (const f of readdirSync(bundleDir)) {
+                        const fp = join(bundleDir, f);
+                        if (!statSync(fp).isFile())
+                            continue;
+                        if (f.endsWith(".map") || f === "README.md")
+                            continue;
+                        collected[f] = readFileSync(fp);
+                    }
+                }
+                const fileCount = Object.keys(collected).length;
+                serverFiles = Object.fromEntries(Object.entries(collected).map(([p, buf]) => [p, buf.toString("base64")]));
+                consola.success(`  Worker bundled: ${fileCount} files (${Math.round(Object.values(collected).reduce((s, b) => s + b.length, 0) / 1024)}KB)`);
+            }
+            else if (isPreBundledFramework(framework)) {
+                // Other pre-bundled SSR frameworks (Nuxt, SvelteKit, etc.)
+                const serverDirRel = getSSRServerDir(framework);
+                if (serverDirRel) {
+                    const serverDir = resolve(cwd, serverDirRel);
+                    if (existsSync(serverDir)) {
+                        consola.start("  Collecting SSR server files...");
+                        const collected = collectServerFiles(serverDir);
+                        const fileCount = Object.keys(collected).length;
+                        serverFiles = Object.fromEntries(Object.entries(collected).map(([p, buf]) => [p, buf.toString("base64")]));
+                        consola.success(`  SSR server: ${fileCount} files`);
+                    }
+                }
+            }
+            else {
+                // Non-pre-bundled SSR: esbuild single-file bundle (fallback)
+                const outputDir = resolve(cwd, resolved.buildOutput);
+                const serverEntry = getSSRServerEntry(framework);
+                if (serverEntry) {
+                    const serverEntryPath = resolve(outputDir, serverEntry);
+                    if (existsSync(serverEntryPath)) {
+                        consola.start("  Bundling SSR server...");
+                        const bundled = await bundleSSRServer(serverEntryPath);
+                        serverFiles = {
+                            "server.js": Buffer.from(bundled).toString("base64"),
+                        };
+                        consola.success(`  SSR bundled (${Math.round(bundled.length / 1024)}KB)`);
+                    }
+                }
+            }
+        }
+        else if (isWorker && resolved.workerEntry) {
+            // Worker: auto-generate _setEnv wrapper + esbuild bundle
+            const workerEntryPath = resolve(cwd, resolved.workerEntry);
+            if (existsSync(workerEntryPath)) {
+                section("Bundle");
+                consola.start("  Bundling worker...");
+                const bundled = await bundleWorker(workerEntryPath, cwd, {
+                    hasClientAssets: !!workerHasClientAssets,
+                });
+                serverFiles = {
+                    "worker.js": Buffer.from(bundled).toString("base64"),
+                };
+                consola.success(`  Worker bundled (${Math.round(bundled.length / 1024)}KB)`);
+            }
+            else {
+                consola.error(`Worker entry not found: ${resolved.workerEntry}`);
+                process.exit(1);
+            }
+        }
+        section("Deploy");
+        consola.start("  Creating deployment...");
+        const { deployment } = await client.createDeployment(project.id);
+        consola.start("  Uploading bundle...");
+        const bundle = {
+            manifest: {
+                assets: fileList,
+                hasWorker: isSSR || isWorker,
+                entrypoint: resolved.workerEntry,
+                renderMode,
+                framework: framework ?? undefined,
+            },
+            workerScript: null,
+            assets: clientAssets,
+            serverFiles,
+            // Backward compat: boolean flags
+            resources: resolvedConfigToResources(resolved),
+            // New: binding declarations with user-defined names
+            bindings: resolvedConfigToBindingRequirements(resolved),
+            // Pass through wrangler vars and compat settings
+            ...(Object.keys(resolved.vars).length > 0 ? { vars: resolved.vars } : {}),
+            ...(resolved.compatibilityDate ? { compatibilityDate: resolved.compatibilityDate } : {}),
+            // nodejs_compat required for Creek runtime (AsyncLocalStorage).
+            // Adapter path uses nodejs_compat_v2 for full Node.js APIs.
+            ...(hasAdapterOutput(cwd)
+                ? { compatibilityFlags: ["nodejs_compat_v2"] }
+                : { compatibilityFlags: [
+                        "nodejs_compat",
+                        ...resolved.compatibilityFlags.filter((f) => f !== "nodejs_compat"),
+                    ] }),
+        };
+        await client.uploadDeploymentBundle(project.id, deployment.id, bundle);
+        // Poll for async deploy progress
+        const POLL_INTERVAL = 1000;
+        const POLL_TIMEOUT = 120_000;
+        const TERMINAL = new Set(["active", "failed", "cancelled"]);
+        const STEP_LABELS = {
+            queued: "  Waiting...",
+            uploading: "  Uploading...",
+            provisioning: "  Provisioning resources...",
+            deploying: "  Deploying to edge...",
+        };
+        let lastStatus = "";
+        const start = Date.now();
+        while (Date.now() - start < POLL_TIMEOUT) {
+            const res = await client.getDeploymentStatus(project.id, deployment.id);
+            const { status, failed_step, error_message } = res.deployment;
+            if (status !== lastStatus) {
+                if (lastStatus && STEP_LABELS[lastStatus]) {
+                    consola.success(STEP_LABELS[lastStatus].replace("...", ""));
+                }
+                if (!TERMINAL.has(status) && STEP_LABELS[status]) {
+                    consola.start(STEP_LABELS[status]);
+                }
+                lastStatus = status;
+            }
+            if (status === "active") {
+                if (jsonMode) {
+                    jsonOutput({
+                        ok: true,
+                        url: res.url ?? res.previewUrl,
+                        previewUrl: res.previewUrl,
+                        deploymentId: deployment.id,
+                        project: project.slug,
+                        mode: "production",
+                    });
+                }
+                consola.success(`  Deployed! ${res.url ?? res.previewUrl}`);
+                if (res.url && res.previewUrl) {
+                    consola.info(`  Preview: ${res.previewUrl}`);
+                }
+                return;
+            }
+            if (status === "failed") {
+                const step = failed_step ? ` at ${failed_step}` : "";
+                const msg = error_message ?? "Unknown error";
+                if (jsonMode)
+                    jsonOutput({ ok: false, error: "deploy_failed", message: msg, failedStep: failed_step }, 1);
+                consola.error(`Deploy failed${step}: ${msg}`);
+                process.exit(1);
+            }
+            if (status === "cancelled") {
+                if (jsonMode)
+                    jsonOutput({ ok: false, error: "cancelled", message: "Deploy was cancelled" }, 1);
+                consola.warn("Deploy was cancelled");
+                process.exit(1);
+            }
+            await new Promise((r) => setTimeout(r, POLL_INTERVAL));
+        }
+        if (jsonMode)
+            jsonOutput({ ok: false, error: "timeout", message: "Deploy timed out after 2 minutes" }, 1);
+        consola.error("Deploy timed out after 2 minutes");
+        process.exit(1);
+    }
+    catch (err) {
+        if (err instanceof CreekAuthError) {
+            consola.error("Authentication failed. Run `creek login` to re-authenticate.");
+            process.exit(1);
+        }
+        throw err;
+    }
+}
+//# sourceMappingURL=deploy.js.map