@solcreek/cli 0.4.6 → 0.4.7

package/dist/commands/deploy.d.ts

@@ -14,6 +14,11 @@ export declare const deployCommand: import("citty").CommandDef<{
         description: string;
         required: false;
     };
+    "no-cache": {
+        type: "boolean";
+        description: string;
+        default: false;
+    };
     "from-github": {
         type: "boolean";
         description: string;

package/dist/commands/deploy.js

@@ -4,7 +4,7 @@ import { existsSync, readFileSync, writeFileSync, readdirSync, statSync, rmSync
 // 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, detectNextjsMode, detectMonorepo, } from "@solcreek/sdk";
+import { CreekClient, CreekAuthError, isSSRFramework, getSSRServerEntry, getClientAssetsDir, getDefaultBuildOutput, detectFramework, resolveConfig, formatDetectionSummary, resolvedConfigToResources, resolvedConfigToBindingRequirements, ConfigNotFoundError, getSSRServerDir, collectServerFiles, isPreBundledFramework, detectAstroCloudflareBuild, 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";
@@ -201,6 +201,11 @@ export const deployCommand = defineCommand({
             description: "Subdirectory within the repo to deploy, for monorepos. Example: --path apps/web",
             required: false,
         },
+        "no-cache": {
+            type: "boolean",
+            description: "Skip build cache check — always build locally. Use when you suspect cached output is stale or you changed build config without changing source files.",
+            default: false,
+        },
         "from-github": {
             type: "boolean",
             description: "Skip local build; trigger a remote deploy of the latest commit on the project's production branch via its GitHub connection.",
@@ -287,7 +292,7 @@ export const deployCommand = defineCommand({
                 }
             }
             if (token) {
-                return await deployAuthenticated(cwd, resolved, token, args["skip-build"], jsonMode);
+                return await deployAuthenticated(cwd, resolved, token, args["skip-build"], jsonMode, args["no-cache"]);
             }
             return await deploySandbox(cwd, args["skip-build"], jsonMode, resolved, tos);
         }
@@ -726,24 +731,47 @@ async function deploySandbox(cwd, skipBuild, jsonMode = false, resolved, tos) {
         }
         process.exit(1);
     }
-    // Collect assets
+    // Collect assets + determine render mode.
+    //
+    // Three shapes, mirroring the authenticated deploy path:
+    //   1. Framework-detected SSR (Astro/Nuxt/etc.) → bundle the framework's
+    //      server entry, upload dist/ as assets.
+    //   2. User-declared Worker (`[build].worker` in creek.toml, no framework)
+    //      → bundle the Worker entry with esbuild, serverFiles = { worker.js }.
+    //      `dist/` assets are skipped for now — the "Workers + Static Assets
+    //      coexist" zero-config pattern is tracked separately and requires
+    //      build-pipeline changes; until it lands, users inline HTML/JS/CSS
+    //      into the Worker (see docs).
+    //   3. Neither → plain SPA/static, everything goes as 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);
+    const isWorker = !framework && !!resolved?.workerEntry;
+    const renderMode = isWorker ? "worker" : (isSSR ? "ssr" : "spa");
+    let clientAssets = {};
+    let fileList = [];
+    if (!isWorker) {
+        let clientAssetsDir;
+        if (useAdapterOutput) {
+            clientAssetsDir = resolve(outputDir, "assets");
         }
+        else {
+            clientAssetsDir = outputDir;
+            if (isSSR && framework) {
+                const subdir = getClientAssetsDir(framework);
+                if (subdir)
+                    clientAssetsDir = resolve(outputDir, subdir);
+            }
+        }
+        const collected = collectAssets(clientAssetsDir);
+        clientAssets = collected.assets;
+        fileList = collected.fileList;
     }
     section("Upload");
-    const { assets: clientAssets, fileList } = collectAssets(clientAssetsDir);
-    consola.info(`  ${fileList.length} assets (${assetSummary(fileList)})`);
+    if (isWorker) {
+        consola.info(`  Worker mode (${resolved.workerEntry})`);
+    }
+    else {
+        consola.info(`  ${fileList.length} assets (${assetSummary(fileList)})`);
+    }
     let serverFiles;
     if (isSSR && framework) {
         const serverEntry = getSSRServerEntry(framework);
@@ -757,6 +785,19 @@ async function deploySandbox(cwd, skipBuild, jsonMode = false, resolved, tos) {
             }
         }
     }
+    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);
+        }
+        consola.start("  Bundling worker...");
+        const bundled = await bundleWorker(workerEntryPath, cwd, {
+            hasClientAssets: false,
+        });
+        serverFiles = { "worker.js": Buffer.from(bundled).toString("base64") };
+        consola.success(`  Worker bundled (${Math.round(bundled.length / 1024)}KB)`);
+    }
     // Deploy to sandbox
     if (!jsonMode) {
         section("Deploy");
@@ -764,10 +805,25 @@ async function deploySandbox(cwd, skipBuild, jsonMode = false, resolved, tos) {
     }
     try {
         const result = await sandboxDeploy({
+            manifest: {
+                assets: fileList,
+                hasWorker: isSSR || isWorker,
+                entrypoint: resolved?.workerEntry ?? null,
+                renderMode,
+            },
             assets: clientAssets,
             serverFiles,
             framework: framework ?? undefined,
             source: "cli",
+            ...(resolved
+                ? { bindings: resolvedConfigToBindingRequirements(resolved) }
+                : {}),
+            ...(resolved?.compatibilityDate
+                ? { compatibilityDate: resolved.compatibilityDate }
+                : {}),
+            ...(resolved && resolved.compatibilityFlags.length > 0
+                ? { compatibilityFlags: resolved.compatibilityFlags }
+                : {}),
         }, { tos });
         const status = await pollSandboxStatus(result.statusUrl);
         if (jsonMode) {
@@ -899,7 +955,7 @@ function cleanupDir(dir) {
 // ============================================================================
 // Authenticated deploy — existing flow
 // ============================================================================
-async function deployAuthenticated(cwd, resolved, token, skipBuild, jsonMode = false) {
+async function deployAuthenticated(cwd, resolved, token, skipBuild, jsonMode = false, noCache = false) {
     try {
         const client = new CreekClient(getApiUrl(), token);
         section("Auth");
@@ -946,6 +1002,14 @@ async function deployAuthenticated(cwd, resolved, token, skipBuild, jsonMode = f
             if (!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
+        // server has a cached bundle for this exact commit, skip the entire
+        // local build + upload and let the server deploy from cache.
+        const turboResult = await tryTurboDeploy(cwd, client, project, noCache, jsonMode);
+        if (turboResult) {
+            return; // ⚡ done — server deployed from cache
+        }
         // Build (skip for pure Workers with no build command)
         if (!skipBuild && resolved.buildCommand) {
             section("Build");
@@ -976,6 +1040,11 @@ async function deployAuthenticated(cwd, resolved, token, skipBuild, jsonMode = f
                 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 = {};
@@ -988,6 +1057,11 @@ async function deployAuthenticated(cwd, resolved, token, skipBuild, jsonMode = f
             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)) {
@@ -1008,7 +1082,19 @@ async function deployAuthenticated(cwd, resolved, token, skipBuild, jsonMode = f
         }
         // Bundle server/worker files
         let serverFiles;
-        if (isSSR && framework) {
+        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");
@@ -1110,12 +1196,18 @@ async function deployAuthenticated(cwd, resolved, token, skipBuild, jsonMode = f
         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 bundle = {
             manifest: {
                 assets: fileList,
-                hasWorker: isSSR || isWorker,
-                entrypoint: resolved.workerEntry,
-                renderMode,
+                hasWorker: effectiveHasWorker,
+                entrypoint: effectiveEntrypoint,
+                renderMode: effectiveRenderMode,
                 framework: framework ?? undefined,
             },
             workerScript: null,
@@ -1192,7 +1284,7 @@ async function deployAuthenticated(cwd, resolved, token, skipBuild, jsonMode = f
                 }
                 // Contextual next-step hints (non-JSON only)
                 if (!jsonMode) {
-                    printNextStepHint(renderMode, resolved);
+                    printNextStepHint(effectiveRenderMode, resolved);
                 }
                 return;
             }
@@ -1272,4 +1364,117 @@ export function patchBareNodeImports(code) {
         .replace(/from\s+["']([a-z_]+)["']/g, (match, mod) => NODE_BUILTINS.has(mod) ? match.replace(`"${mod}"`, `"node:${mod}"`).replace(`'${mod}'`, `'node:${mod}'`) : match)
         .replace(/require\(["']([a-z_]+)["']\)/g, (match, mod) => NODE_BUILTINS.has(mod) ? match.replace(`"${mod}"`, `"node:${mod}"`).replace(`'${mod}'`, `'node:${mod}'`) : match);
 }
+// --- ⚡ Turbo deploy ---
+/**
+ * Attempt a Turbo deploy: read the local git HEAD SHA, send it to
+ * the server with cacheCheck, and if the server has a cached bundle
+ * for this exact commit, let it deploy from cache. Returns true if
+ * Turbo succeeded (caller should return), false if caller should
+ * proceed with normal build + upload.
+ *
+ * Graceful: any failure (no git, dirty tree, API error, cache miss)
+ * silently returns false → normal deploy. Turbo is always opt-in bonus.
+ */
+async function tryTurboDeploy(cwd, client, project, noCache, jsonMode) {
+    if (noCache)
+        return false;
+    // 1. Read git HEAD SHA
+    let sha;
+    try {
+        sha = execSync("git rev-parse HEAD", { cwd, encoding: "utf-8" }).trim();
+        if (!sha || sha.length < 12)
+            return false;
+    }
+    catch {
+        return false; // not a git repo or git not installed
+    }
+    // 2. Check working tree is clean
+    try {
+        const dirty = execSync("git status --porcelain", { cwd, encoding: "utf-8" }).trim();
+        if (dirty) {
+            // Uncommitted changes → can't trust cache (source differs from commit)
+            return false;
+        }
+    }
+    catch {
+        return false;
+    }
+    // 3. Detect branch
+    let branch = "main";
+    try {
+        branch = execSync("git rev-parse --abbrev-ref HEAD", { cwd, encoding: "utf-8" }).trim();
+    }
+    catch {
+        // default to main
+    }
+    // 4. Ask server to create deployment with cache check
+    const shortSha = sha.slice(0, 12);
+    if (!jsonMode) {
+        consola.info(`  Commit: ${shortSha} (${branch}, clean)`);
+        consola.start("  \x1b[33m⚡\x1b[0m Checking build cache...");
+    }
+    try {
+        const res = await client.createDeployment(project.id, {
+            branch,
+            commitSha: shortSha,
+        });
+        if (!res.cacheHit) {
+            if (!jsonMode)
+                consola.info("  \x1b[2mFirst-time build — building from source\x1b[0m");
+            return false;
+        }
+        // ⚡ Turbo build — server is deploying from cache.
+        if (!jsonMode) {
+            consola.success("  \x1b[33m⚡\x1b[0m \x1b[1mTurbo build — ready\x1b[0m");
+        }
+        // Poll until deployment is active (same as normal deploy path)
+        const POLL_INTERVAL = 1000;
+        const POLL_TIMEOUT = 30_000; // Turbo should be fast — 30s max
+        const TERMINAL = new Set(["active", "failed", "cancelled"]);
+        let lastStatus = "";
+        const start = Date.now();
+        while (Date.now() - start < POLL_TIMEOUT) {
+            const status = await client.getDeploymentStatus(project.id, res.deployment.id);
+            const { status: s } = status.deployment;
+            if (s !== lastStatus && !jsonMode) {
+                if (s === "deploying")
+                    consola.start("  Deploying to edge...");
+                lastStatus = s;
+            }
+            if (TERMINAL.has(s)) {
+                if (s === "active") {
+                    const elapsed = ((Date.now() - start) / 1000).toFixed(1);
+                    if (jsonMode) {
+                        jsonOutput({
+                            ok: true,
+                            url: status.url ?? status.previewUrl,
+                            previewUrl: status.previewUrl,
+                            deploymentId: res.deployment.id,
+                            project: project.slug,
+                            mode: "production",
+                            turbo: true,
+                            elapsed: `${elapsed}s`,
+                        }, 0, []);
+                    }
+                    consola.success(`  ⬡ Deployed! ${status.url ?? status.previewUrl}`);
+                    consola.log(`\n  \x1b[33m⚡ Turbo deploy\x1b[0m  ${elapsed}s\n`);
+                    return true;
+                }
+                // Failed — don't fall back to normal build (server already tried)
+                if (!jsonMode)
+                    consola.error(`  Deploy from cache failed: ${status.deployment.error_message || "unknown"}`);
+                return true; // return true to prevent double-deploy attempt
+            }
+            await new Promise((r) => setTimeout(r, POLL_INTERVAL));
+        }
+        // Timeout — deploy might still complete, but CLI gives up waiting
+        if (!jsonMode)
+            consola.warn("  Cache deploy timed out — check `creek status`");
+        return true;
+    }
+    catch {
+        // API error — fall through to normal build
+        return false;
+    }
+}
 //# sourceMappingURL=deploy.js.map

package/dist/utils/sandbox.d.ts

@@ -34,6 +34,24 @@ export declare function sandboxDeploy(bundle: {
     framework?: string;
     templateId?: string;
     source: string;
+    /**
+     * Binding declarations from creek.toml / wrangler.*. Sandbox-api
+     * provisions ephemeral D1/R2/KV per entry so `env.DB` etc. work
+     * in the user's Worker without any auth or extra setup.
+     */
+    bindings?: Array<{
+        type: string;
+        bindingName: string;
+    }>;
+    /** Compat overrides — required for Node-API-heavy bundles. */
+    compatibilityDate?: string;
+    compatibilityFlags?: string[];
+    /** Framework-aware hint (admin URL, warnings) for the UI layer. */
+    hint?: {
+        adminPath?: string;
+        adminLabel?: string;
+        warnings?: string[];
+    };
 }, opts?: {
     tos?: TosAcceptance;
     agentToken?: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solcreek/cli",
-  "version": "0.4.6",
+  "version": "0.4.7",
   "description": "CLI for the Creek deployment platform",
   "type": "module",
   "main": "./dist/index.js",