@solcreek/cli 0.4.9 → 0.4.11

package/dist/commands/deploy.js

@@ -1,18 +1,17 @@
 import { defineCommand } from "citty";
 import consola from "consola";
-import { existsSync, readFileSync, writeFileSync, readdirSync, statSync, rmSync } from "node:fs";
+import { existsSync, readFileSync, writeFileSync, rmSync } from "node:fs";
 // ajv is lazy-imported only when --template --data is used (avoid top-level crash if deps missing)
 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, detectAstroCloudflareBuild, detectNextjsMode, detectMonorepo, planDeploy, } from "@solcreek/sdk";
+import { CreekClient, CreekAuthError, detectFramework, resolveConfig, formatDetectionSummary, resolvedConfigToResources, resolvedConfigToBindingRequirements, ConfigNotFoundError, 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 { prepareDeployBundle } from "../utils/prepare-bundle.js";
 import { isTTY, jsonOutput, resolveJsonMode, globalArgs, shouldAutoConfirm, AUTH_BREADCRUMBS, NO_PROJECT_BREADCRUMBS } from "../utils/output.js";
 import { ensureTosAccepted } from "../utils/tos.js";
-import { buildNextjs, patchBundledWorker, hasAdapterOutput } from "../utils/nextjs.js";
+import { 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) {
@@ -676,7 +675,6 @@ async function deploySandbox(cwd, skipBuild, jsonMode = false, resolved, tos) {
     }
     const pkg = JSON.parse(readFileSync(pkgJsonPath, "utf-8"));
     const framework = resolved?.framework ?? detectFramework(pkg);
-    // Detect Next.js mode (static vs opennext SSR)
     const nextjsMode = framework === "nextjs" ? detectNextjsMode(pkg, cwd) : null;
     const monorepo = detectMonorepo(cwd);
     section("Detect");
@@ -684,133 +682,22 @@ async function deploySandbox(cwd, skipBuild, jsonMode = false, resolved, tos) {
     if (nextjsMode)
         consola.info(`  Next.js mode: ${nextjsMode}${monorepo.isMonorepo ? " (monorepo)" : ""}`);
     consola.info("  Mode: sandbox (60 min preview)");
-    // Build
-    if (!skipBuild) {
+    // Pre-build header so the section banner ("Build") still appears
+    // before build output streams. Then prepareDeployBundle owns the
+    // actual build + plan + collect + bundle pipeline.
+    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));
-    // Whether buildOutput exists is now an INPUT to planDeploy, not a
-    // hard precondition — pure-Worker projects legitimately have no
-    // build output directory, and planDeploy returns an explicit error
-    // for the cases that genuinely need one.
-    // Resolve deploy shape via the SDK's pure planner. All branching
-    // (SPA vs SSR vs Worker, with-or-without coexisting static assets,
-    // bundled vs source worker entry) lives in deploy-plan.ts and is
-    // table-tested. Don't re-derive these conditions inline.
-    const planResult = planDeploy({
-        framework,
-        workerEntry: resolved?.workerEntry ?? null,
-        workerEntryExists: !!resolved?.workerEntry &&
-            existsSync(resolve(cwd, resolved.workerEntry)),
-        buildOutput: resolved?.buildOutput ?? "dist",
-        buildOutputExists: existsSync(outputDir),
-        astroCF: null, // sandbox path doesn't run post-build adapter detection (yet)
+    const prepared = await prepareDeployBundle({
+        cwd,
+        resolved: resolved ?? {}, // sandbox path can be called without resolved when delegating; guarded above
+        skipBuild,
     });
-    if (!planResult.ok) {
-        consola.error(planResult.reason);
-        process.exit(1);
-    }
-    const plan = planResult.plan;
-    const renderMode = plan.renderMode;
-    let clientAssets = {};
-    let fileList = [];
-    if (plan.assets.enabled && plan.assets.dir) {
-        let clientAssetsDir = useAdapterOutput
-            ? resolve(outputDir, "assets")
-            : resolve(cwd, plan.assets.dir);
-        if (!useAdapterOutput && isSSRFramework(framework) && framework) {
-            const subdir = getClientAssetsDir(framework);
-            if (subdir)
-                clientAssetsDir = resolve(clientAssetsDir, subdir);
-        }
-        const collected = collectAssets(clientAssetsDir);
-        clientAssets = collected.assets;
-        fileList = collected.fileList;
-        if (plan.assets.excludeFile) {
-            delete clientAssets["/" + plan.assets.excludeFile];
-            delete clientAssets[plan.assets.excludeFile];
-            fileList = fileList.filter((p) => p !== plan.assets.excludeFile && p !== "/" + plan.assets.excludeFile);
-        }
-    }
+    const { plan, fileList, assets: clientAssets, serverFiles, effectiveRenderMode } = prepared;
     section("Upload");
-    consola.info(`  Mode: ${renderMode}${plan.worker.entry ? ` (worker: ${plan.worker.entry})` : ""}`);
+    consola.info(`  Mode: ${effectiveRenderMode}${plan.worker.entry ? ` (worker: ${plan.worker.entry})` : ""}`);
     if (plan.assets.enabled) {
         consola.info(`  ${fileList.length} assets (${assetSummary(fileList)})`);
     }
-    let serverFiles;
-    switch (plan.worker.strategy) {
-        case "none":
-            break;
-        case "ssr-framework": {
-            // Sandbox path doesn't currently support pre-bundled SSR
-            // frameworks (Nuxt/SvelteKit/Astro CF); planDeploy only returns
-            // this strategy for SSR frameworks, which we still bundle via
-            // the legacy single-file path below to keep diff small.
-            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)`);
-                }
-            }
-            break;
-        }
-        case "esbuild-bundle": {
-            const workerEntryPath = resolve(cwd, plan.worker.entry);
-            consola.start("  Bundling worker...");
-            const bundled = await bundleWorker(workerEntryPath, cwd, {
-                hasClientAssets: plan.assets.enabled,
-            });
-            serverFiles = { "worker.js": Buffer.from(bundled).toString("base64") };
-            consola.success(`  Worker bundled (${Math.round(bundled.length / 1024)}KB)`);
-            break;
-        }
-        case "upload-asis": {
-            const workerEntryPath = resolve(cwd, plan.worker.entry);
-            const bytes = readFileSync(workerEntryPath);
-            serverFiles = { "worker.js": bytes.toString("base64") };
-            consola.success(`  Worker (pre-bundled, ${Math.round(bytes.length / 1024)}KB)`);
-            break;
-        }
-    }
     // Deploy to sandbox
     if (!jsonMode) {
         section("Deploy");
@@ -820,13 +707,13 @@ async function deploySandbox(cwd, skipBuild, jsonMode = false, resolved, tos) {
         const result = await sandboxDeploy({
             manifest: {
                 assets: fileList,
-                hasWorker: plan.worker.strategy !== "none",
-                entrypoint: resolved?.workerEntry ?? null,
-                renderMode,
+                hasWorker: prepared.serverFiles !== undefined,
+                entrypoint: prepared.effectiveEntrypoint,
+                renderMode: effectiveRenderMode,
             },
             assets: clientAssets,
             serverFiles,
-            framework: framework ?? undefined,
+            framework: prepared.framework ?? undefined,
             source: "cli",
             ...(resolved
                 ? { bindings: resolvedConfigToBindingRequirements(resolved) }
@@ -1000,43 +887,19 @@ async function deployAuthenticated(cwd, resolved, token, skipBuild, jsonMode = f
             if (!jsonMode)
                 consola.success(`  Created project: ${project.slug}`);
         }
-        // Determine deploy mode via the SDK's pure planner. The downstream
-        // framework-specific branches (Astro CF, Next.js adapter, Nuxt, etc.)
-        // are kept as-is — planDeploy decides the SHAPE (spa / ssr / worker
-        // and whether the worker is source vs prebundled), and the legacy
-        // collection logic decides WHERE to read the bytes from for each
-        // framework. astroCF detection happens post-build below; for the
-        // initial plan we conservatively pass null and the framework SSR
-        // branch handles the adapter case.
+        // Framework is resolved upstream; everything else (SSR / worker /
+        // assets / bundling) is decided inside prepareDeployBundle via the
+        // SDK's planDeploy resolver.
         const framework = resolved.framework;
-        const isSSR = isSSRFramework(framework);
-        const initialPlan = planDeploy({
-            framework,
-            workerEntry: resolved.workerEntry ?? null,
-            workerEntryExists: !!resolved.workerEntry &&
-                existsSync(resolve(cwd, resolved.workerEntry)),
-            buildOutput: resolved.buildOutput,
-            buildOutputExists: existsSync(resolve(cwd, resolved.buildOutput)),
-            astroCF: null,
-        });
-        if (!initialPlan.ok) {
-            consola.error(initialPlan.reason);
-            process.exit(1);
-        }
-        const isWorker = initialPlan.plan.worker.strategy === "esbuild-bundle" ||
-            initialPlan.plan.worker.strategy === "upload-asis";
-        const workerIsPrebundled = initialPlan.plan.worker.strategy === "upload-asis";
-        const workerExcludeFromAssets = initialPlan.plan.assets.excludeFile;
-        const renderMode = initialPlan.plan.renderMode;
-        // Detect Next.js mode for special build handling
+        // Detect Next.js mode for the info banner only — actual handling is
+        // inside prepareDeployBundle.
         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)" : ""}`);
+        if (nextjsMode && !jsonMode) {
+            consola.info(`  Next.js mode: ${nextjsMode}${monorepo.isMonorepo ? " (monorepo)" : ""}`);
         }
         // --- ⚡ Turbo deploy: check if server has a cached build for this commit ---
         // Read the local git HEAD SHA. If the working tree is clean and the
@@ -1046,214 +909,21 @@ async function deployAuthenticated(cwd, resolved, token, skipBuild, jsonMode = f
         if (turboResult) {
             return; // ⚡ done — server deployed from cache
         }
-        // Build (skip for pure Workers with no build command)
-        if (!skipBuild && resolved.buildCommand) {
+        // Single source of truth for build → plan → collect → bundle. Both
+        // sandbox and authenticated paths call the same function; they
+        // diverge only in where the bundle gets POSTed.
+        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");
-            }
-        }
-        // Post-build detection: Astro + @astrojs/cloudflare produces a
-        // pre-bundled Worker (dist/server/entry.mjs) + split client assets
-        // (dist/client/). We can only detect this after build — before
-        // build `framework === "astro"` could mean SSG or CF-adapter-SSR.
-        const astroCF = framework === "astro" ? detectAstroCloudflareBuild(cwd) : null;
-        // 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 if (astroCF) {
-                // Astro CF adapter splits its output: client assets live in
-                // dist/client/ (not dist/), so redirect the collector there.
-                clientAssetsDir = resolve(cwd, astroCF.assetsDir);
-            }
-            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 (astroCF) {
-            // Astro CF adapter: upload dist/server/ as worker modules
-            // (same shape Nuxt/SolidStart use — pre-bundled, do not re-bundle).
-            const serverDir = resolve(cwd, astroCF.serverDir);
-            if (existsSync(serverDir)) {
-                consola.start("  Collecting Astro CF 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(`  Astro CF worker: ${fileCount} files`);
-            }
-        }
-        else 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;
-                        let content = readFileSync(fp);
-                        // Patch bare Node.js module imports → node: prefix (workerd requires it)
-                        // Note: nodejs_compat_v2 handles most modules, but bare specifiers
-                        // (without node: prefix) still need patching.
-                        if (f.endsWith(".js") || f.endsWith(".mjs")) {
-                            content = Buffer.from(patchBareNodeImports(content.toString("utf-8")));
-                        }
-                        collected[f] = content;
-                    }
-                }
-                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) {
-            const workerEntryPath = resolve(cwd, resolved.workerEntry);
-            if (!existsSync(workerEntryPath)) {
-                consola.error(`Worker entry not found: ${resolved.workerEntry}`);
-                process.exit(1);
-            }
-            section("Bundle");
-            if (workerIsPrebundled) {
-                // User's build script already produced a fully self-contained
-                // bundle inside buildOutput; ship the bytes verbatim. No wrapper,
-                // no Creek runtime injection — keeps the deployed Worker free of
-                // any @solcreek/* dependency.
-                const bytes = readFileSync(workerEntryPath);
-                serverFiles = { "worker.js": bytes.toString("base64") };
-                consola.success(`  Worker (pre-bundled, ${Math.round(bytes.length / 1024)}KB)`);
-            }
-            else {
-                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)`);
-            }
-        }
-        // When the worker bundle lives INSIDE the static asset dir
-        // (e.g. dist/_worker.mjs), drop it from clientAssets so it isn't
-        // double-uploaded as a publicly accessible file.
-        if (workerExcludeFromAssets) {
-            delete clientAssets[workerExcludeFromAssets];
-            delete clientAssets["/" + workerExcludeFromAssets];
-            fileList = fileList.filter((p) => p !== workerExcludeFromAssets && p !== "/" + workerExcludeFromAssets);
-        }
+        const prepared = await prepareDeployBundle({ cwd, resolved, skipBuild });
+        const { plan, framework: detectedFramework, effectiveRenderMode, effectiveEntrypoint, fileList, assets: clientAssets, serverFiles, } = prepared;
+        void detectedFramework; // framework var above is the source of truth here
+        section("Upload");
+        consola.info(`  ${fileList.length} assets (${assetSummary(fileList)})`);
         section("Deploy");
         consola.start("  Creating deployment...");
         const { deployment } = await client.createDeployment(project.id);
         consola.start("  Uploading bundle...");
-        // If the Astro CF adapter fired post-build, the project is actually
-        // SSR (not SPA): overwrite the pre-build-computed renderMode and
-        // point the entrypoint at the adapter-emitted entry.mjs.
-        const effectiveRenderMode = astroCF ? "ssr" : renderMode;
-        const effectiveHasWorker = astroCF ? true : (isSSR || isWorker);
-        const effectiveEntrypoint = astroCF ? "entry.mjs" : resolved.workerEntry;
+        const effectiveHasWorker = serverFiles !== undefined;
         const bundle = {
             manifest: {
                 assets: fileList,

package/dist/commands/logs.d.ts

@@ -0,0 +1,75 @@
+/**
+ * `creek logs` — read structured tenant logs from R2 archive.
+ *
+ * Auth: requires `creek login`. Server is responsible for tenant
+ * isolation — the CLI simply targets the project slug, the
+ * authenticated session decides which team's logs are visible.
+ *
+ * Project resolution: --project flag wins; otherwise resolve from
+ * cwd creek.toml / wrangler.*. If neither, error with hint.
+ *
+ * `--follow` is reserved for Step 7 (WebSocket subscribe). For now
+ * the command is one-shot historical query.
+ *
+ * Output:
+ *   default → human-friendly multi-line per entry, colored by
+ *             outcome (ok=dim, exception=red, etc.)
+ *   --json  → newline-delimited LogEntry JSON, suitable for `| jq`
+ */
+export declare const logsCommand: import("citty").CommandDef<{
+    json: {
+        type: "boolean";
+        description: string;
+        default: boolean;
+    };
+    yes: {
+        type: "boolean";
+        description: string;
+        default: boolean;
+    };
+    project: {
+        type: "string";
+        description: string;
+    };
+    since: {
+        type: "string";
+        description: string;
+    };
+    until: {
+        type: "string";
+        description: string;
+    };
+    outcome: {
+        type: "string";
+        description: string;
+    };
+    "script-type": {
+        type: "string";
+        description: string;
+    };
+    deployment: {
+        type: "string";
+        description: string;
+    };
+    branch: {
+        type: "string";
+        description: string;
+    };
+    level: {
+        type: "string";
+        description: string;
+    };
+    search: {
+        type: "string";
+        description: string;
+    };
+    limit: {
+        type: "string";
+        description: string;
+    };
+    follow: {
+        type: "boolean";
+        description: string;
+    };
+}>;
+//# sourceMappingURL=logs.d.ts.map

package/dist/commands/logs.js

@@ -0,0 +1,233 @@
+import { defineCommand } from "citty";
+import consola from "consola";
+import { CreekClient, resolveConfig, ConfigNotFoundError, } from "@solcreek/sdk";
+import { getToken, getApiUrl } from "../utils/config.js";
+import { globalArgs, resolveJsonMode, jsonOutput, AUTH_BREADCRUMBS, NO_PROJECT_BREADCRUMBS, } from "../utils/output.js";
+/**
+ * `creek logs` — read structured tenant logs from R2 archive.
+ *
+ * Auth: requires `creek login`. Server is responsible for tenant
+ * isolation — the CLI simply targets the project slug, the
+ * authenticated session decides which team's logs are visible.
+ *
+ * Project resolution: --project flag wins; otherwise resolve from
+ * cwd creek.toml / wrangler.*. If neither, error with hint.
+ *
+ * `--follow` is reserved for Step 7 (WebSocket subscribe). For now
+ * the command is one-shot historical query.
+ *
+ * Output:
+ *   default → human-friendly multi-line per entry, colored by
+ *             outcome (ok=dim, exception=red, etc.)
+ *   --json  → newline-delimited LogEntry JSON, suitable for `| jq`
+ */
+export const logsCommand = defineCommand({
+    meta: {
+        name: "logs",
+        description: "Read recent log entries for a project",
+    },
+    args: {
+        project: {
+            type: "string",
+            description: "Project slug. Defaults to creek.toml in cwd.",
+        },
+        since: {
+            type: "string",
+            description: "Time window start. Relative (1h, 30m, 2d) or ISO. Default: 1h",
+        },
+        until: {
+            type: "string",
+            description: 'Time window end. "now" or ISO. Default: now',
+        },
+        outcome: {
+            type: "string",
+            description: "Filter by tail outcome. Repeatable via comma (ok,exception).",
+        },
+        "script-type": {
+            type: "string",
+            description: "Filter by production/branch/deployment. Repeatable via comma.",
+        },
+        deployment: {
+            type: "string",
+            description: "8-hex deploy id — scopes to that single deployment preview.",
+        },
+        branch: {
+            type: "string",
+            description: "Branch name — scopes to that branch preview.",
+        },
+        level: {
+            type: "string",
+            description: "Filter by console level (error,warn,...). Entry needs at least one matching log line.",
+        },
+        search: {
+            type: "string",
+            description: "Substring match against console messages, exceptions, and request URLs.",
+        },
+        limit: {
+            type: "string",
+            description: "Max entries to print. Default 100, max 1000.",
+        },
+        follow: {
+            type: "boolean",
+            description: "(Step 7 — not yet implemented) Live tail via WebSocket.",
+        },
+        ...globalArgs,
+    },
+    async run({ args }) {
+        if (args.follow) {
+            consola.warn("--follow is not yet implemented (Phase 8 Step 7).");
+            consola.info("This command currently returns historical entries only.");
+        }
+        const jsonMode = resolveJsonMode(args);
+        const token = getToken();
+        if (!token) {
+            if (jsonMode)
+                jsonOutput({ ok: false, error: "not_authenticated" }, 1, AUTH_BREADCRUMBS);
+            consola.error("Not authenticated. Run `creek login` first.");
+            process.exit(1);
+        }
+        const projectSlug = await resolveProjectSlug(args.project, jsonMode);
+        const client = new CreekClient(getApiUrl(), token);
+        const filters = {
+            ...(args.since ? { since: args.since } : {}),
+            ...(args.until ? { until: args.until } : {}),
+            ...(args.deployment ? { deployment: args.deployment } : {}),
+            ...(args.branch ? { branch: args.branch } : {}),
+            ...(args.search ? { search: args.search } : {}),
+            ...(args.limit ? { limit: Number(args.limit) } : {}),
+            ...(args.outcome
+                ? { outcomes: parseList(args.outcome) }
+                : {}),
+            ...(args["script-type"]
+                ? {
+                    scriptTypes: parseList(args["script-type"]),
+                }
+                : {}),
+            ...(args.level
+                ? { levels: parseList(args.level) }
+                : {}),
+        };
+        let response;
+        try {
+            response = await client.getLogs(projectSlug, filters);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            if (jsonMode)
+                jsonOutput({ ok: false, error: "logs_failed", message: msg }, 1, []);
+            consola.error(`Failed to read logs: ${msg}`);
+            process.exit(1);
+        }
+        if (jsonMode) {
+            // ndjson — easy to pipe to jq
+            for (const entry of response.entries) {
+                process.stdout.write(JSON.stringify(entry) + "\n");
+            }
+            if (response.truncated) {
+                process.stderr.write(`# truncated — more entries match. Refine --since/--limit to narrow.\n`);
+            }
+            return;
+        }
+        if (response.entries.length === 0) {
+            consola.info("No log entries match the query.");
+            return;
+        }
+        // Human output: oldest at top so the latest entry is closest to the prompt.
+        const ordered = [...response.entries].reverse();
+        for (const entry of ordered) {
+            printEntry(entry);
+        }
+        if (response.truncated) {
+            consola.warn(`Truncated to ${response.entries.length} entries — refine --since/--limit to see more.`);
+        }
+    },
+});
+async function resolveProjectSlug(override, jsonMode) {
+    if (override)
+        return override;
+    let resolved;
+    try {
+        resolved = resolveConfig(process.cwd());
+    }
+    catch (err) {
+        if (err instanceof ConfigNotFoundError) {
+            if (jsonMode)
+                jsonOutput({ ok: false, error: "no_project", message: "No project config in cwd" }, 1, NO_PROJECT_BREADCRUMBS);
+            consola.error("No project config in cwd. Pass --project <slug>.");
+            process.exit(1);
+        }
+        throw err;
+    }
+    return resolved.projectName;
+}
+function parseList(input) {
+    return input
+        .split(",")
+        .map((s) => s.trim())
+        .filter(Boolean);
+}
+const COLOR = {
+    reset: "\x1b[0m",
+    dim: "\x1b[2m",
+    red: "\x1b[31m",
+    yellow: "\x1b[33m",
+    green: "\x1b[32m",
+    cyan: "\x1b[36m",
+    gray: "\x1b[90m",
+};
+function color(s, c) {
+    return process.stdout.isTTY ? `${COLOR[c]}${s}${COLOR.reset}` : s;
+}
+function printEntry(entry) {
+    const ts = new Date(entry.timestamp).toISOString().replace("T", " ").slice(0, 19);
+    const outcomeColor = entry.outcome === "ok"
+        ? "gray"
+        : entry.outcome === "exception"
+            ? "red"
+            : "yellow";
+    const status = entry.request?.status;
+    const statusStr = status === undefined
+        ? ""
+        : status >= 500
+            ? color(String(status), "red")
+            : status >= 400
+                ? color(String(status), "yellow")
+                : color(String(status), "green");
+    const variant = entry.scriptType === "production"
+        ? ""
+        : entry.scriptType === "branch"
+            ? ` [branch ${entry.branch}]`
+            : ` [deploy ${entry.deployId}]`;
+    const headline = [
+        color(ts, "dim"),
+        color(entry.outcome, outcomeColor),
+        entry.request?.method ?? "—",
+        entry.request?.url
+            ? new URL(entry.request.url).pathname + new URL(entry.request.url).search
+            : "—",
+        statusStr,
+        color(variant, "dim"),
+    ]
+        .filter(Boolean)
+        .join(" ");
+    process.stdout.write(headline + "\n");
+    for (const log of entry.logs) {
+        const levelColor = log.level === "error" ? "red" : log.level === "warn" ? "yellow" : "cyan";
+        const msg = log.message
+            .map((m) => (typeof m === "string" ? m : safeStringify(m)))
+            .join(" ");
+        process.stdout.write(`  ${color(log.level.padEnd(5), levelColor)} ${msg}\n`);
+    }
+    for (const ex of entry.exceptions) {
+        process.stdout.write(`  ${color("exc", "red")} ${color(ex.name, "red")}: ${ex.message}\n`);
+    }
+}
+function safeStringify(v) {
+    try {
+        return JSON.stringify(v);
+    }
+    catch {
+        return String(v);
+    }
+}
+//# sourceMappingURL=logs.js.map

package/dist/index.js

@@ -18,6 +18,7 @@ import { devCommand } from "./commands/dev.js";
 import { rollbackCommand } from "./commands/rollback.js";
 import { opsCommand } from "./commands/ops.js";
 import { queueCommand } from "./commands/queue.js";
+import { logsCommand } from "./commands/logs.js";
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const cliPkg = JSON.parse(readFileSync(join(__dirname, "..", "package.json"), "utf-8"));
 // Read version from the "creek" facade package (what users install),
@@ -43,6 +44,7 @@ const main = defineCommand({
         status: statusCommand,
         projects: projectsCommand,
         deployments: deploymentsCommand,
+        logs: logsCommand,
         login: loginCommand,
         whoami: whoamiCommand,
         init: initCommand,

package/dist/utils/prepare-bundle.d.ts

@@ -0,0 +1,63 @@
+/**
+ * prepareDeployBundle — single source of truth for "given a project,
+ * produce the bundle that gets shipped to either sandbox-api or
+ * control-plane". Both `deploySandbox` and `deployAuthenticated` call
+ * this; they only differ in (a) whether they auth/look-up a project
+ * and (b) which API receives the bundle.
+ *
+ * Historically these two paths each rolled their own copy of the
+ * detect → build → collect → bundle pipeline. They drifted: the
+ * sandbox path was missing the worker branch for ~2 weeks (cli@0.4.6
+ * regression) and again missed the workers+assets coexist pattern.
+ * That divergence is the architectural smell — this file kills it.
+ *
+ * The function:
+ *   1. Reads framework from package.json (or accepts pre-resolved one)
+ *   2. Runs the build script (skip with skipBuild: true)
+ *   3. Calls SDK's planDeploy() to decide spa/ssr/worker shape
+ *   4. Detects post-build framework adapters (Astro CF) and refines
+ *   5. Collects static assets per the plan
+ *   6. Bundles the worker per the plan (5 framework-aware strategies)
+ *   7. Filters worker file out of clientAssets when it lives inside
+ *   8. Returns the canonical bundle envelope
+ *
+ * IO is not abstracted — the function calls execSync, readFileSync,
+ * esbuild. Callers needing test isolation should use fixture dirs.
+ */
+import { type DeployPlan, type Framework, type ResolvedConfig } from "@solcreek/sdk";
+export interface PrepareDeployBundleInput {
+    /** Absolute project directory. */
+    cwd: string;
+    /** Pre-resolved config (creek.toml or wrangler.* parse). Required. */
+    resolved: ResolvedConfig;
+    /** When true, skip the build script. Caller is asserting dist/ is current. */
+    skipBuild: boolean;
+}
+export interface PreparedDeployBundle {
+    /** The plan that drove preparation — passed back so callers can
+     *  inspect renderMode / worker strategy without re-deriving. */
+    plan: DeployPlan;
+    /** Framework detected (or pre-resolved). null = static / vanilla worker. */
+    framework: Framework | null;
+    /** Whether Astro `@astrojs/cloudflare` adapter fired post-build. */
+    astroAdapter: {
+        serverDir: string;
+        assetsDir: string;
+    } | null;
+    /**
+     * Render mode after post-build refinement. Equal to plan.renderMode
+     * unless an adapter (e.g. Astro CF) upgraded an SPA-classified
+     * project to true SSR.
+     */
+    effectiveRenderMode: "spa" | "ssr" | "worker";
+    /** Main module name the deploy API should treat as the worker entry. */
+    effectiveEntrypoint: string | null;
+    /** Asset list (paths relative to root, with leading `/`). */
+    fileList: string[];
+    /** Asset bytes, base64-encoded, keyed by path. */
+    assets: Record<string, string>;
+    /** Server / worker files, base64-encoded. Undefined for pure SPA. */
+    serverFiles?: Record<string, string>;
+}
+export declare function prepareDeployBundle(input: PrepareDeployBundleInput): Promise<PreparedDeployBundle>;
+//# sourceMappingURL=prepare-bundle.d.ts.map

package/dist/utils/prepare-bundle.js

@@ -0,0 +1,266 @@
+/**
+ * prepareDeployBundle — single source of truth for "given a project,
+ * produce the bundle that gets shipped to either sandbox-api or
+ * control-plane". Both `deploySandbox` and `deployAuthenticated` call
+ * this; they only differ in (a) whether they auth/look-up a project
+ * and (b) which API receives the bundle.
+ *
+ * Historically these two paths each rolled their own copy of the
+ * detect → build → collect → bundle pipeline. They drifted: the
+ * sandbox path was missing the worker branch for ~2 weeks (cli@0.4.6
+ * regression) and again missed the workers+assets coexist pattern.
+ * That divergence is the architectural smell — this file kills it.
+ *
+ * The function:
+ *   1. Reads framework from package.json (or accepts pre-resolved one)
+ *   2. Runs the build script (skip with skipBuild: true)
+ *   3. Calls SDK's planDeploy() to decide spa/ssr/worker shape
+ *   4. Detects post-build framework adapters (Astro CF) and refines
+ *   5. Collects static assets per the plan
+ *   6. Bundles the worker per the plan (5 framework-aware strategies)
+ *   7. Filters worker file out of clientAssets when it lives inside
+ *   8. Returns the canonical bundle envelope
+ *
+ * IO is not abstracted — the function calls execSync, readFileSync,
+ * esbuild. Callers needing test isolation should use fixture dirs.
+ */
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { execSync } from "node:child_process";
+import consola from "consola";
+import { detectFramework, detectAstroCloudflareBuild, detectMonorepo, detectNextjsMode, getSSRServerDir, getSSRServerEntry, getClientAssetsDir, getDefaultBuildOutput, isSSRFramework, isPreBundledFramework, collectServerFiles, planDeploy, } from "@solcreek/sdk";
+import { collectAssets } from "./bundle.js";
+import { bundleSSRServer } from "./ssr-bundle.js";
+import { bundleWorker } from "./worker-bundle.js";
+import { hasAdapterOutput, buildNextjs, patchBundledWorker } from "./nextjs.js";
+import { patchBareNodeImports } from "../commands/deploy.js";
+export async function prepareDeployBundle(input) {
+    const { cwd, resolved, skipBuild } = input;
+    // 1. Framework detection. Trust the resolved config if it carries
+    // one (creek.toml can pin it); otherwise re-read package.json. We
+    // re-read here rather than rely solely on resolved so that a project
+    // without creek.toml still gets the auto-detected framework when
+    // running against a pre-existing wrangler.* config.
+    const pkgJsonPath = join(cwd, "package.json");
+    const pkg = existsSync(pkgJsonPath)
+        ? JSON.parse(readFileSync(pkgJsonPath, "utf-8"))
+        : null;
+    const framework = resolved.framework ?? (pkg ? detectFramework(pkg) : null);
+    const nextjsMode = framework === "nextjs" && pkg ? detectNextjsMode(pkg, cwd) : null;
+    const monorepo = framework === "nextjs" ? detectMonorepo(cwd) : { isMonorepo: false, root: null };
+    // 2. Build (when not skipped). Framework-specific build for Next.js
+    // adapter; otherwise the user's build script.
+    if (!skipBuild && resolved.buildCommand) {
+        if (nextjsMode === "opennext") {
+            try {
+                buildNextjs(cwd, monorepo.isMonorepo);
+            }
+            catch {
+                consola.error("Next.js build failed");
+                process.exit(1);
+            }
+        }
+        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");
+        }
+    }
+    // 3. Compute output dir. Next.js adapter writes to .creek/adapter-output;
+    // everything else honours [build].output.
+    const useAdapterOutput = framework === "nextjs" && hasAdapterOutput(cwd);
+    const outputDir = useAdapterOutput
+        ? resolve(cwd, ".creek/adapter-output")
+        : resolve(cwd, resolved.buildOutput || getDefaultBuildOutput(framework));
+    // 4. Post-build framework adapter detection. Astro can be either SSG
+    // or CF-adapter-SSR; we only know which after build.
+    const astroAdapter = framework === "astro" ? detectAstroCloudflareBuild(cwd) : null;
+    // 5. Plan the deploy shape. planDeploy is a pure function — pass in
+    // detection results, get out a structured plan with explicit error
+    // cases. All branching that used to be inline in deploy.ts lives in
+    // deploy-plan.ts now (table-tested).
+    const planResult = planDeploy({
+        framework,
+        workerEntry: resolved.workerEntry ?? null,
+        workerEntryExists: !!resolved.workerEntry &&
+            existsSync(resolve(cwd, resolved.workerEntry)),
+        buildOutput: resolved.buildOutput || "dist",
+        buildOutputExists: existsSync(outputDir),
+        astroCF: astroAdapter,
+    });
+    if (!planResult.ok) {
+        consola.error(planResult.reason);
+        process.exit(1);
+    }
+    const plan = planResult.plan;
+    // 6. Collect client assets. The dir depends on framework (Next.js
+    // adapter, Astro CF split output) but the inclusion decision is the
+    // plan's call.
+    let clientAssets = {};
+    let fileList = [];
+    if (plan.assets.enabled && plan.assets.dir) {
+        let clientAssetsDir;
+        if (useAdapterOutput) {
+            clientAssetsDir = resolve(outputDir, "assets");
+        }
+        else if (astroAdapter) {
+            clientAssetsDir = resolve(cwd, astroAdapter.assetsDir);
+        }
+        else {
+            clientAssetsDir = resolve(cwd, plan.assets.dir);
+            // SSR frameworks split client assets into a sub-dir of buildOutput.
+            if (isSSRFramework(framework) && framework) {
+                const subdir = getClientAssetsDir(framework);
+                if (subdir)
+                    clientAssetsDir = resolve(clientAssetsDir, subdir);
+            }
+        }
+        const collected = collectAssets(clientAssetsDir);
+        clientAssets = collected.assets;
+        fileList = collected.fileList;
+    }
+    // 7. Bundle server / worker. Five strategies, dispatched by either
+    // (a) the framework when it's pre-bundled SSR, or (b) the plan's
+    // worker.strategy for user-declared workers.
+    let serverFiles;
+    if (astroAdapter) {
+        // Astro CF adapter writes a pre-bundled worker we just upload.
+        const serverDir = resolve(cwd, astroAdapter.serverDir);
+        if (existsSync(serverDir)) {
+            consola.start("  Collecting Astro CF server files...");
+            const collected = collectServerFiles(serverDir);
+            serverFiles = base64ServerFiles(collected);
+            consola.success(`  Astro CF worker: ${Object.keys(collected).length} files`);
+        }
+    }
+    else if (isSSRFramework(framework) && framework) {
+        if (framework === "nextjs" && hasAdapterOutput(cwd)) {
+            // Next.js adapter output → patch bare imports, upload as-is.
+            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() || f.endsWith(".map"))
+                        continue;
+                    let content = readFileSync(fp);
+                    if (f.endsWith(".js") || f.endsWith(".mjs")) {
+                        content = Buffer.from(patchBareNodeImports(content.toString("utf-8")));
+                    }
+                    collected[f] = content;
+                }
+            }
+            serverFiles = base64ServerFiles(collected);
+            consola.success(`  Worker bundled: ${Object.keys(collected).length} files (${kb(collected)}KB)`);
+        }
+        else if (framework === "nextjs") {
+            // Legacy Next.js: wrangler dry-run produces the bundle.
+            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() || f.endsWith(".map") || f === "README.md")
+                        continue;
+                    collected[f] = readFileSync(fp);
+                }
+            }
+            serverFiles = base64ServerFiles(collected);
+            consola.success(`  Worker bundled: ${Object.keys(collected).length} files (${kb(collected)}KB)`);
+        }
+        else if (isPreBundledFramework(framework)) {
+            // Nuxt / SvelteKit / SolidStart — the framework already produced
+            // a bundled server; we just collect.
+            const serverDirRel = getSSRServerDir(framework);
+            if (serverDirRel) {
+                const serverDir = resolve(cwd, serverDirRel);
+                if (existsSync(serverDir)) {
+                    consola.start("  Collecting SSR server files...");
+                    const collected = collectServerFiles(serverDir);
+                    serverFiles = base64ServerFiles(collected);
+                    consola.success(`  SSR server: ${Object.keys(collected).length} files`);
+                }
+            }
+        }
+        else {
+            // Fallback for SSR frameworks that emit a single entry file.
+            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 (plan.worker.strategy === "esbuild-bundle" && plan.worker.entry) {
+        const workerEntryPath = resolve(cwd, plan.worker.entry);
+        consola.start("  Bundling worker...");
+        const bundled = await bundleWorker(workerEntryPath, cwd, {
+            hasClientAssets: plan.assets.enabled,
+        });
+        serverFiles = { "worker.js": Buffer.from(bundled).toString("base64") };
+        consola.success(`  Worker bundled (${Math.round(bundled.length / 1024)}KB)`);
+    }
+    else if (plan.worker.strategy === "upload-asis" && plan.worker.entry) {
+        // Pre-bundled worker (e.g. dist/_worker.mjs from the user's own
+        // esbuild step). Ship verbatim — no Creek runtime wrapper, no
+        // re-bundle. This is the path that keeps deployed bundles free of
+        // any @solcreek/* dependency.
+        const bytes = readFileSync(resolve(cwd, plan.worker.entry));
+        serverFiles = { "worker.js": bytes.toString("base64") };
+        consola.success(`  Worker (pre-bundled, ${Math.round(bytes.length / 1024)}KB)`);
+    }
+    // 8. When the worker bundle lives INSIDE the asset dir
+    // (dist/_worker.mjs), drop it from clientAssets so it isn't also
+    // served as a publicly accessible static file.
+    if (plan.assets.excludeFile) {
+        delete clientAssets[plan.assets.excludeFile];
+        delete clientAssets["/" + plan.assets.excludeFile];
+        fileList = fileList.filter((p) => p !== plan.assets.excludeFile && p !== "/" + plan.assets.excludeFile);
+    }
+    // 9. Resolve effective render mode + entrypoint. Astro CF post-build
+    // detection upgrades a pre-build "spa" classification to true SSR.
+    const effectiveRenderMode = astroAdapter
+        ? "ssr"
+        : plan.renderMode;
+    const effectiveEntrypoint = astroAdapter
+        ? "entry.mjs"
+        : (plan.worker.entry ?? null);
+    return {
+        plan,
+        framework,
+        astroAdapter,
+        effectiveRenderMode,
+        effectiveEntrypoint,
+        fileList,
+        assets: clientAssets,
+        serverFiles,
+    };
+}
+// --- helpers ---
+function base64ServerFiles(collected) {
+    return Object.fromEntries(Object.entries(collected).map(([p, buf]) => [p, buf.toString("base64")]));
+}
+function kb(collected) {
+    return Math.round(Object.values(collected).reduce((s, b) => s + b.length, 0) / 1024);
+}
+//# sourceMappingURL=prepare-bundle.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solcreek/cli",
-  "version": "0.4.9",
+  "version": "0.4.11",
   "description": "CLI for the Creek deployment platform",
   "type": "module",
   "main": "./dist/index.js",
@@ -33,7 +33,7 @@
     "esbuild": "^0.25.0",
     "smol-toml": "^1.3.1",
     "ws": "^8.20.0",
-    "@solcreek/sdk": "0.4.4"
+    "@solcreek/sdk": "0.4.5"
   },
   "devDependencies": {
     "@testing-library/dom": "^10.4.1",