@solcreek/cli 0.3.8 → 0.3.9

package/dist/commands/deploy.d.ts

@@ -4,6 +4,11 @@ export declare const deployCommand: import("citty").CommandDef<{
         description: string;
         required: false;
     };
+    data: {
+        type: "string";
+        description: string;
+        required: false;
+    };
     path: {
         type: "string";
         description: string;

package/dist/commands/deploy.js

@@ -1,6 +1,7 @@
 import { defineCommand } from "citty";
 import consola from "consola";
-import { existsSync, readFileSync, readdirSync, statSync, rmSync } from "node:fs";
+import { existsSync, readFileSync, writeFileSync, readdirSync, statSync, 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, detectNextjsMode, detectMonorepo, } from "@solcreek/sdk";
@@ -48,7 +49,12 @@ export const deployCommand = defineCommand({
         ...globalArgs,
         template: {
             type: "string",
-            description: "Deploy a template (e.g., react-dashboard, astro-landing)",
+            description: "Deploy a template (e.g., landing, blog, todo)",
+            required: false,
+        },
+        data: {
+            type: "string",
+            description: "JSON data for template params (used with --template)",
             required: false,
         },
         path: {
@@ -64,7 +70,17 @@ export const deployCommand = defineCommand({
         const tos = await ensureTosAccepted(autoConfirm);
         // --- Template deploy ---
         if (args.template) {
-            return await deployTemplate(args.template);
+            let templateData;
+            if (args.data) {
+                try {
+                    templateData = JSON.parse(args.data);
+                }
+                catch {
+                    consola.error("Invalid JSON in --data");
+                    process.exit(1);
+                }
+            }
+            return await deployTemplate(args.template, templateData);
         }
         // --- Repo URL deploy (creek deploy https://github.com/user/repo) ---
         if (args.dir && isRepoUrl(args.dir)) {
@@ -383,7 +399,7 @@ async function deploySandbox(cwd, skipBuild, jsonMode = false, resolved, tos) {
 // ============================================================================
 // Template deploy — clone + build + deploy to sandbox
 // ============================================================================
-async function deployTemplate(templateId) {
+async function deployTemplate(templateId, data) {
     // Validate template ID — alphanumeric, hyphens, underscores only (no path traversal)
     if (!/^[a-zA-Z0-9_-]+$/.test(templateId)) {
         consola.error("Invalid template name. Use only letters, numbers, hyphens, and underscores.");
@@ -404,7 +420,7 @@ async function deployTemplate(templateId) {
     }
     catch {
         consola.error(`Template '${templateId}' not found.`);
-        consola.info("Available templates: creek deploy --template");
+        consola.info("Available templates: npx create-creek-app --list");
         cleanupDir(tmpDir);
         process.exit(1);
     }
@@ -420,6 +436,43 @@ async function deployTemplate(templateId) {
         cleanupDir(tmpDir);
         process.exit(1);
     }
+    // Apply --data: validate against schema + merge into creek-data.json
+    if (data) {
+        const configPath = join(templateDir, "creek-template.json");
+        const dataPath = join(templateDir, "creek-data.json");
+        // Read defaults
+        let defaults = {};
+        if (existsSync(dataPath)) {
+            defaults = JSON.parse(readFileSync(dataPath, "utf-8"));
+        }
+        const merged = { ...defaults, ...data };
+        // Validate against schema if creek-template.json exists
+        if (existsSync(configPath)) {
+            const templateConfig = JSON.parse(readFileSync(configPath, "utf-8"));
+            if (templateConfig.schema) {
+                const { default: Ajv } = await import("ajv");
+                const ajv = new Ajv({ allErrors: true, useDefaults: true });
+                const { $schema: _, ...schemaWithoutMeta } = templateConfig.schema;
+                const validate = ajv.compile(schemaWithoutMeta);
+                if (!validate(merged)) {
+                    consola.error("Data validation failed:");
+                    for (const err of (validate.errors ?? [])) {
+                        consola.error(`  ${err.instancePath || "/"}: ${err.message}`);
+                    }
+                    cleanupDir(tmpDir);
+                    process.exit(1);
+                }
+            }
+        }
+        // Write merged data into creek-data.json
+        writeFileSync(dataPath, JSON.stringify(merged, null, 2) + "\n");
+        consola.success("Applied custom data");
+    }
+    // Remove creek-template.json (metadata, not project file)
+    const templateConfigPath = join(templateDir, "creek-template.json");
+    if (existsSync(templateConfigPath)) {
+        rmSync(templateConfigPath);
+    }
     consola.start("Installing dependencies...");
     try {
         execFileSync("npm", ["install"], { cwd: templateDir, stdio: "pipe" });

package/dist/commands/ops.d.ts

@@ -0,0 +1,18 @@
+export declare const opsCommand: import("citty").CommandDef<{
+    json: {
+        type: "boolean";
+        description: string;
+        default: boolean;
+    };
+    yes: {
+        type: "boolean";
+        description: string;
+        default: boolean;
+    };
+    sub: {
+        type: "positional";
+        description: string;
+        required: false;
+    };
+}>;
+//# sourceMappingURL=ops.d.ts.map

package/dist/commands/ops.js

@@ -0,0 +1,122 @@
+import { defineCommand } from "citty";
+import { getToken, getApiUrl } from "../utils/config.js";
+import { globalArgs, resolveJsonMode, jsonOutput } from "../utils/output.js";
+export const opsCommand = defineCommand({
+    meta: {
+        name: "ops",
+        description: "Platform admin (self-hosted) — deployments, health",
+    },
+    args: {
+        sub: {
+            type: "positional",
+            description: "Subcommand: deployments | health",
+            required: false,
+        },
+        ...globalArgs,
+    },
+    async run({ args }) {
+        const jsonMode = resolveJsonMode(args);
+        const sub = args.sub || "deployments";
+        if (sub === "deployments") {
+            return await listDeployments(jsonMode);
+        }
+        if (sub === "health") {
+            return await health(jsonMode);
+        }
+        jsonOutput({ error: `Unknown subcommand: ${sub}`, usage: "creek ops [deployments|health]" }, 1);
+    },
+});
+async function listDeployments(jsonMode) {
+    const apiUrl = getApiUrl();
+    const token = getToken();
+    if (!token) {
+        jsonOutput({ error: "Not authenticated", hint: "Run `creek login` first" }, 1);
+    }
+    const res = await fetch(`${apiUrl}/web-deploy/list`, {
+        headers: { Authorization: `Bearer ${token}` },
+    });
+    if (!res.ok) {
+        jsonOutput({ error: `Failed to fetch deployments: ${res.status}` }, 1);
+    }
+    const deploys = await res.json();
+    if (jsonMode) {
+        jsonOutput({
+            ok: true,
+            count: deploys.length,
+            deploys,
+            breadcrumbs: [
+                { command: "creek ops health", description: "Check platform health" },
+            ],
+        });
+    }
+    // Human-readable output
+    if (deploys.length === 0) {
+        console.log("\n  No recent deployments (last 1 hour)\n");
+        return;
+    }
+    console.log(`\n  Web Deploys (${deploys.length} in last hour)\n`);
+    const statusColors = {
+        active: "\x1b[32m", // green
+        building: "\x1b[34m", // blue
+        deploying: "\x1b[33m", // yellow
+        failed: "\x1b[31m", // red
+    };
+    const reset = "\x1b[0m";
+    for (const d of deploys) {
+        const color = statusColors[d.status] || "";
+        const time = d.createdAt ? timeAgo(d.createdAt) : "";
+        const preview = d.previewUrl ? ` → ${d.previewUrl}` : "";
+        const error = d.error ? `\n           ${"\x1b[31m"}${d.error.slice(0, 80)}${reset}` : "";
+        console.log(`  ${color}●${reset} ${d.buildId}  ${color}${d.status.padEnd(9)}${reset}  ${d.type || ""}  ${time}${preview}${error}`);
+    }
+    console.log();
+    // Summary
+    const active = deploys.filter((d) => d.status === "active").length;
+    const failed = deploys.filter((d) => d.status === "failed").length;
+    const building = deploys.filter((d) => d.status === "building" || d.status === "deploying").length;
+    console.log(`  Active: ${active}  Failed: ${failed}  In progress: ${building}\n`);
+}
+async function health(jsonMode) {
+    const apiUrl = getApiUrl();
+    const checks = {};
+    // Control plane
+    try {
+        const res = await fetch(`${apiUrl}/web-deploy/nonexistent`);
+        checks["control-plane"] = res.status === 404 ? "ok" : `unexpected ${res.status}`;
+    }
+    catch (err) {
+        checks["control-plane"] = `unreachable: ${err instanceof Error ? err.message : String(err)}`;
+    }
+    // Sandbox API — probe with empty POST (expect 400 validation error = alive)
+    try {
+        const res = await fetch("https://sandbox-api.creek.dev/api/sandbox/deploy", {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: "{}",
+        });
+        checks["sandbox-api"] = res.status === 400 || res.status === 429 ? "ok" : `unexpected ${res.status}`;
+    }
+    catch (err) {
+        checks["sandbox-api"] = `unreachable: ${err instanceof Error ? err.message : String(err)}`;
+    }
+    if (jsonMode) {
+        const allOk = Object.values(checks).every((v) => v === "ok");
+        jsonOutput({ ok: allOk, checks });
+    }
+    console.log("\n  Platform Health\n");
+    for (const [name, status] of Object.entries(checks)) {
+        const icon = status === "ok" ? "\x1b[32m✓\x1b[0m" : "\x1b[31m✗\x1b[0m";
+        console.log(`  ${icon} ${name}: ${status}`);
+    }
+    console.log();
+}
+function timeAgo(iso) {
+    const seconds = Math.floor((Date.now() - new Date(iso).getTime()) / 1000);
+    if (seconds < 60)
+        return `${seconds}s ago`;
+    const minutes = Math.floor(seconds / 60);
+    if (minutes < 60)
+        return `${minutes}m ago`;
+    return `${Math.floor(minutes / 60)}h ago`;
+}
+//# sourceMappingURL=ops.js.map

package/dist/index.js

@@ -16,6 +16,7 @@ import { deploymentsCommand } from "./commands/deployments.js";
 import { statusCommand } from "./commands/status.js";
 import { devCommand } from "./commands/dev.js";
 import { rollbackCommand } from "./commands/rollback.js";
+import { opsCommand } from "./commands/ops.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),
@@ -48,6 +49,7 @@ const main = defineCommand({
         env: envCommand,
         domains: domainsCommand,
         rollback: rollbackCommand,
+        ops: opsCommand,
     },
 });
 runMain(main);

package/dist/utils/nextjs.js

@@ -99,8 +99,10 @@ export function hasAdapterOutput(cwd) {
  * the Creek adapter handles middleware via typed AdapterOutputs.
  */
 export function patchBundledWorker(bundleDir, openNextDir) {
-    const workerPath = join(bundleDir, "worker.js");
-    if (!existsSync(workerPath))
+    // Try worker.js (wrangler --dry-run output) and handler.mjs (opennext server function)
+    const candidates = [join(bundleDir, "worker.js"), join(bundleDir, "handler.mjs")];
+    const workerPath = candidates.find((p) => existsSync(p));
+    if (!workerPath)
         return;
     let code = readFileSync(workerPath, "utf-8");
     let patched = false;
@@ -110,9 +112,10 @@ export function patchBundledWorker(bundleDir, openNextDir) {
     if (existsSync(manifestPath)) {
         manifest = readFileSync(manifestPath, "utf-8").trim();
     }
-    // Patch: getMiddlewareManifest() { return __require(this.middlewareManifestPath); }
+    // Patch: getMiddlewareManifest() { return [__]require(this.middlewareManifestPath); }
     // →      getMiddlewareManifest() { return <inline manifest>; }
-    const pattern = /getMiddlewareManifest\(\)\s*\{[^}]*__require\(this\.middlewareManifestPath\)[^}]*\}/;
+    // Note: Next.js versions may use `require()` or `__require()` — match both
+    const pattern = /getMiddlewareManifest\(\)\s*\{[^}]*(?:__)?require\(this\.middlewareManifestPath\)[^}]*\}/;
     if (pattern.test(code)) {
         code = code.replace(pattern, `getMiddlewareManifest() { return ${manifest}; }`);
         patched = true;
@@ -359,6 +362,8 @@ export function buildNextjsForWorkers(cwd, isMonorepo, projectName = "app") {
             cwd,
             stdio: "inherit",
         });
+        // Step 6: Patch handler.mjs to fix dynamic require issues in Workers runtime
+        patchBundledWorker(join(cwd, ".open-next/server-functions/default"), join(cwd, ".open-next"));
     }
     finally {
         // Restore original next.config

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solcreek/cli",
-  "version": "0.3.8",
+  "version": "0.3.9",
   "description": "CLI for the Creek deployment platform",
   "type": "module",
   "main": "./dist/index.js",
@@ -32,7 +32,8 @@
     "directory": "packages/cli"
   },
   "dependencies": {
-    "@solcreek/sdk": ">=0.1.0-alpha.4",
+    "@solcreek/sdk": ">=0.1.0-alpha.5",
+    "ajv": "^8.17.1",
     "citty": "^0.1.6",
     "consola": "^3.4.2",
     "esbuild": "^0.25.0",