@solcreek/cli 0.4.5 → 0.4.7

package/CHANGELOG.md

@@ -1,5 +1,35 @@
 # @solcreek/cli
 
+## 0.4.6
+
+### Features
+
+- **`creek deploy gh:owner/repo` shorthand** — a shorter alias for
+  `https://github.com/owner/repo`. Matches the GitHub CLI convention.
+  `gh:`, `gl:` (GitLab), and `bb:` (Bitbucket) are now all registered
+  alongside the longer `github:` / `gitlab:` / `bitbucket:` forms.
+  Example: `npx creek deploy gh:jiseeeh/serene-ink`.
+
+### Fixes / DX
+
+- **Install size cut from ~170MB to ~25MB** by moving `miniflare` out of
+  runtime dependencies entirely. Miniflare plus its transitive deps
+  (workerd, sharp) was adding ~146MB to every `npm install creek` — a
+  pure penalty on the `creek deploy` flow, which never touches
+  miniflare. `miniflare` is now listed in `devDependencies` only, so
+  the published package is free of it. First-time `npx creek deploy`
+  goes from ~20s install to ~3–5s, and the postinstall warnings that
+  used to appear on systems without build tools (sharp's node-gyp
+  fallback) are gone entirely.
+
+- **`creek dev` loads miniflare from multiple locations** via
+  `createRequire` — the user's current project (`npm install --save-dev
+  miniflare`), a creek-managed cache directory at `~/.creek/deps`, or
+  the global npm root (`npm install -g miniflare`). If none of those
+  have it, a jargon-free error explains what to install and where.
+  Users who only want to deploy never see this error because
+  `creek deploy` doesn't load the local runtime at all.
+
 ## 0.4.5
 
 ### Features

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/dev/worker-runner.d.ts

@@ -1,4 +1,14 @@
 import type { BindingDeclaration } from "@solcreek/sdk";
+/**
+ * Thrown by `creek dev` when no local runtime package can be resolved from
+ * the user's project, global npm root, or creek's dep cache. The message
+ * is deliberately jargon-free: it talks about "a local runtime" instead of
+ * naming miniflare in the explanation, and only mentions the package name
+ * as part of the exact npm command the user needs to run.
+ */
+export declare class MiniflareNotInstalledError extends Error {
+    constructor();
+}
 export interface WorkerRunnerOptions {
     /** User's worker entry point (e.g. "worker/index.ts"). */
     entryPoint: string;

package/dist/dev/worker-runner.js

@@ -1,11 +1,93 @@
-// Worker execution for `creek dev` — bundles user code and runs it via Miniflare.
+// Worker execution for `creek dev` — bundles user code and runs it via
+// Miniflare for local D1 / KV / R2 / Queues / Durable Objects simulation.
 //
-// Uses esbuild watch mode for hot reload and Miniflare for D1/KV/R2 simulation.
+// `miniflare` is intentionally NOT in @solcreek/cli's runtime dependencies —
+// it (plus its transitive deps workerd and sharp) adds ~146MB to every
+// install of `creek`. Since `creek deploy` never touches miniflare, it's
+// a pure penalty on the aha-moment flow: paste a command, see a live URL.
+//
+// Instead, `creek dev` resolves miniflare at runtime from the caller's
+// project (npm install --save-dev miniflare in their own package.json),
+// the global npm root, or a creek-managed cache dir. If none of those
+// have miniflare, we throw a zero-jargon error that tells the user
+// exactly one command to run.
 import { writeFileSync, mkdirSync } from "node:fs";
 import { join, resolve } from "node:path";
+import { createRequire } from "node:module";
+import { homedir } from "node:os";
+import { execSync } from "node:child_process";
 import { context } from "esbuild";
-import { Miniflare } from "miniflare";
 import { generateWorkerWrapper } from "../utils/worker-bundle.js";
+/**
+ * Thrown by `creek dev` when no local runtime package can be resolved from
+ * the user's project, global npm root, or creek's dep cache. The message
+ * is deliberately jargon-free: it talks about "a local runtime" instead of
+ * naming miniflare in the explanation, and only mentions the package name
+ * as part of the exact npm command the user needs to run.
+ */
+export class MiniflareNotInstalledError extends Error {
+    constructor() {
+        super([
+            "`creek dev` needs a local runtime to simulate the edge environment,",
+            "and it isn't installed yet.",
+            "",
+            "  One-time setup — run this in your project directory:",
+            "    npm install --save-dev miniflare",
+            "",
+            "  This downloads ~150MB but only needs to happen once per project.",
+            "  `creek deploy` already works without it — you can skip this step",
+            "  entirely if you only want to deploy.",
+        ].join("\n"));
+        this.name = "MiniflareNotInstalledError";
+    }
+}
+/**
+ * Try to load miniflare from several plausible locations, in order of
+ * preference:
+ *
+ *   1. The user's current project (npm install --save-dev miniflare)
+ *   2. Creek-managed dep cache at ~/.creek/deps/miniflare (for future
+ *      auto-install support — not wired up yet but already searched here
+ *      so a future `creek dev install` command can drop files there)
+ *   3. Global npm root (for users who `npm install -g miniflare`)
+ *
+ * Each location is attempted with a fresh `createRequire` rooted at a
+ * dummy file in that directory, then `require.resolve("miniflare")` is
+ * used to find the package. If all three fail, throws
+ * MiniflareNotInstalledError with a zero-jargon explanation.
+ */
+async function loadMiniflare() {
+    const searchRoots = [];
+    // 1. User's current project
+    searchRoots.push(process.cwd());
+    // 2. Creek-managed cache
+    searchRoots.push(join(homedir(), ".creek", "deps"));
+    // 3. Global npm root (best-effort — may be slow on first call)
+    try {
+        const globalRoot = execSync("npm root -g", {
+            encoding: "utf-8",
+            stdio: ["ignore", "pipe", "ignore"],
+        }).trim();
+        if (globalRoot)
+            searchRoots.push(globalRoot);
+    }
+    catch {
+        // No npm on PATH, or command failed — skip this search path silently.
+    }
+    for (const root of searchRoots) {
+        try {
+            // createRequire needs a file path — use a dummy file inside the root
+            // (the file doesn't have to exist for node_modules lookup to work).
+            const req = createRequire(join(root, "__creek_resolver__.js"));
+            const resolved = req.resolve("miniflare");
+            return (await import(resolved));
+        }
+        catch {
+            // Try the next root.
+        }
+    }
+    throw new MiniflareNotInstalledError();
+}
 const NODE_BUILTINS = [
     "node:async_hooks",
     "node:stream",
@@ -52,9 +134,14 @@ export class WorkerRunner {
         writeFileSync(wrapperPath, wrapper);
         // 2. Initial bundle with esbuild
         const bundledScript = await this.bundle(wrapperPath);
-        // 3. Start Miniflare
+        // 3. Start Miniflare — loaded from the user's project / cache / global
+        //    so `creek deploy` can ship without miniflare in @solcreek/cli's
+        //    runtime dependencies. See loadMiniflare() above for the search
+        //    order and the MiniflareNotInstalledError message.
+        const miniflareModule = await loadMiniflare();
+        const MiniflareCtor = miniflareModule.Miniflare;
         this.mfOptions = this.buildMiniflareOptions(bundledScript, persistDir);
-        this.mf = new Miniflare(this.mfOptions);
+        this.mf = new MiniflareCtor(this.mfOptions);
         // Wait for Miniflare to be ready and get the port
         const readyUrl = await this.mf.ready;
         // mf.ready returns a URL object

package/dist/utils/repo-url.d.ts

@@ -28,8 +28,11 @@ export declare function isRepoUrl(input: string): boolean;
  *   https://github.com/owner/repo.git
  *   https://github.com/owner/repo#branch
  *   https://github.com/owner/repo/tree/branch
- *   github:owner/repo
- *   github:owner/repo#branch
+ *   github:owner/repo           (long-form shorthand)
+ *   gh:owner/repo               (short alias — matches gh CLI convention)
+ *   gh:owner/repo#branch
+ *   gitlab:owner/repo           gl:owner/repo
+ *   bitbucket:owner/repo        bb:owner/repo
  */
 export declare function parseRepoUrl(input: string): ParsedRepoUrl;
 /**

package/dist/utils/repo-url.js

@@ -17,10 +17,17 @@ const PROVIDER_HOSTS = {
     "bitbucket.org": "bitbucket",
     "www.bitbucket.org": "bitbucket",
 };
+// Shorthand prefixes. Short aliases (gh:/gl:/bb:) match the conventions
+// established by the GitHub CLI, GitLab CLI, and other tooling — they're
+// the shortest safe way to reference a repo without colliding with local
+// path syntax (local paths never have ':' before any '/').
 const SHORTHAND_PREFIXES = {
     "github:": "github",
+    "gh:": "github",
     "gitlab:": "gitlab",
+    "gl:": "gitlab",
     "bitbucket:": "bitbucket",
+    "bb:": "bitbucket",
 };
 // Strict character set for owner and repo names
 const SAFE_NAME = /^[a-zA-Z0-9._-]+$/;
@@ -53,8 +60,11 @@ export function isRepoUrl(input) {
  *   https://github.com/owner/repo.git
  *   https://github.com/owner/repo#branch
  *   https://github.com/owner/repo/tree/branch
- *   github:owner/repo
- *   github:owner/repo#branch
+ *   github:owner/repo           (long-form shorthand)
+ *   gh:owner/repo               (short alias — matches gh CLI convention)
+ *   gh:owner/repo#branch
+ *   gitlab:owner/repo           gl:owner/repo
+ *   bitbucket:owner/repo        bb:owner/repo
  */
 export function parseRepoUrl(input) {
     if (!input || typeof input !== "string") {

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.5",
+  "version": "0.4.7",
   "description": "CLI for the Creek deployment platform",
   "type": "module",
   "main": "./dist/index.js",
@@ -31,7 +31,6 @@
     "citty": "^0.1.6",
     "consola": "^3.4.2",
     "esbuild": "^0.25.0",
-    "miniflare": "^4.20260317.3",
     "smol-toml": "^1.3.1",
     "ws": "^8.20.0",
     "@solcreek/sdk": "0.4.2"
@@ -44,6 +43,7 @@
     "@types/ws": "^8.18.1",
     "hono": "^4.7.4",
     "jsdom": "^29.0.1",
+    "miniflare": "^4.20260317.3",
     "react": "^19.2.4",
     "react-dom": "^19.2.4",
     "typescript": "^5.8.2",