@clubedge/create-clubedge-app 0.28.0 → 0.29.0

package/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 All notable changes to `create-clubedge-app` are documented here.
 
+## 0.29.0
+
+- `pnpm clubedge deploy` deploys to Netlify and Render (experimental) (#82), so it now covers Railway, Fly.io, Vercel, Netlify, and Render:
+  - Netlify: it signs in with `netlify login`, creates or reuses the site with `apps/web` as its base directory, imports the production variables from `.env.production`, the site URL, and a generated `BETTER_AUTH_SECRET`, then runs `netlify deploy --build --prod`. The build runs on your machine with the site's variables.
+  - Render: it signs in with an API key (`RENDER_API_KEY`, or pasted from the dashboard page it opens) and builds from your pushed Git branch. It creates or reuses a Docker web service that runs the migrations before each release and checks `/api/health`, as `render.yaml` does, on a starter instance, since pre-deploy commands need a paid type. It sets the variables and waits until the deploy is live.
+  - On both, `DATABASE_URL` comes from your provider (Neon, Supabase, ...).
+- Still on Starter `v0.18.0`.
+
 ## 0.28.0
 
 - `pnpm clubedge deploy` deploys to Vercel (experimental) (#80), in projects created with `--deploy vercel`:

package/README.md

@@ -211,12 +211,20 @@ In a project with `--deploy fly`, `pnpm clubedge deploy` does the same with [Fly
 
 In a project with `--deploy vercel`, `pnpm clubedge deploy` uses [Vercel's CLI](https://vercel.com/docs/cli) (the installed `vercel`, else the latest through npx) and your Vercel login, running `vercel login` first when you are signed out. Vercel only runs the app, so the database and the other services come from the env file: `DATABASE_URL` (your provider's pooled URL, for example Neon's or Supabase's) is required. It creates or reuses a project named after the package, built from `apps/web` with the whole workspace uploaded, and writes a `.vercelignore` when the project has none, so `.env` files stay on your machine (commit it). It sets the production variables: the env file's values, the public URL, and a generated `BETTER_AUTH_SECRET` with Better Auth. `STORAGE_DIRECTORY` is left out, since Vercel keeps no disk. Then `vercel deploy --prod` builds the app, after `check:env` and the migrations. When Vercel names the app something other than `https://<project>.vercel.app`, `deploy` sets that URL and deploys again, since the build compiles it in. Running it again reuses the project. Vercel bills usage on your plan.
 
+### Deploy to Netlify (experimental)
+
+In a project with `--deploy netlify`, `pnpm clubedge deploy` uses [Netlify's CLI](https://docs.netlify.com/cli/get-started/) (the installed `netlify`, else the latest through npx) and your Netlify login: `netlify login` opens the browser when you are signed out, and returns at once when you are signed in. As on Vercel, the services come from the env file, and `DATABASE_URL` (your provider's pooled URL) is required. It creates or reuses a site named after the package (with a short suffix when the name is taken, since Netlify's names are global), with `apps/web` as its base directory, and links the project to it in `.netlify/state.json`. It imports the production variables from a temporary file, so no value appears on a command line: the env file's values, the site's `https://<site>.netlify.app` URL, and a generated `BETTER_AUTH_SECRET` with Better Auth. Then `netlify deploy --build --prod` builds on your machine with the site's variables (`check:env`, the migrations, then the build) and uploads the result. Running it again reuses the site. Netlify bills usage on your plan.
+
+### Deploy to Render (experimental)
+
+In a project with `--deploy render`, `pnpm clubedge deploy` uses Render's API. Render builds the Dockerfile from your Git repository, so push the project to GitHub, GitLab, or Bitbucket first, with Render's access to it granted in the dashboard; `deploy` warns about commits that aren't pushed. It signs in with an API key: `RENDER_API_KEY`, or else it opens the dashboard's API keys page and asks you to paste one. It creates or reuses a web service named after the package, on the Docker runtime and a starter instance (pre-deploy commands need a paid type), which runs `node /app/migrate.mjs` before each release, checks `/api/health`, and deploys again on each push, as `render.yaml` describes. `DATABASE_URL` comes from the env file (Render Postgres, Neon, Supabase, ...). It sets the production variables: the env file's values, the service's `*.onrender.com` URL, and a generated `BETTER_AUTH_SECRET` that later runs keep. Then it starts a deploy and waits until it is live. When Render names the app something other than `https://<service>.onrender.com`, `deploy` sets that URL and deploys again, since the build compiles it in. Running it again reuses the service. Render bills the instance on your plan.
+
 ## Version relationship
 
 Each CLI release is tested against one specific Starter release:
 
 ```text
-create-clubedge-app v0.28.0
+create-clubedge-app v0.29.0
         |
         v
 Clubedge Starter v0.18.0
@@ -227,7 +235,7 @@ The current relationship is:
 
 | CLI release | Default Starter release | Meaning |
 | --- | --- | --- |
-| `create-clubedge-app@0.28.0` | `clubedge-starter@v0.18.0` | The CLI's required, tested default |
+| `create-clubedge-app@0.29.0` | `clubedge-starter@v0.18.0` | The CLI's required, tested default |
 
 This means the same CLI version always scaffolds the same Starter revision by default. The CLI does not silently follow Starter `main`.
 
@@ -329,6 +337,7 @@ Each phase ends with a Starter release and a CLI release pinned to it. The full
 | 0.26.0 | v0.17.1 | `deploy` uses your own databases (Supabase, Neon, Upstash) when the env file has their URLs, and reads `.env.production` |
 | 0.27.0 | v0.18.0 | Starter v0.18.0: Vercel and Netlify builds stop when a production variable is missing (`pnpm check:env`) |
 | 0.28.0 | v0.18.0 | `deploy` to Vercel (experimental) |
+| 0.29.0 | v0.18.0 | `deploy` to Netlify and Render (experimental) |
 | next | | Show the Starter's version of a conflicted file next to yours |
 
 ## Community

package/dist/cli/ui.js

@@ -124,7 +124,7 @@ ${selectionHelp(manifest)}
   --dry-run               Show what would be created or changed without writing anything
   --force                 add/remove: change a project with uncommitted changes or without Git
   --no-services           doctor: skip pnpm check:services
-  --no-open               try, deploy (Vercel): do not open the URL in the browser
+  --no-open               try, deploy (Vercel, Netlify, Render): do not open the URL in the browser
   --claim                 try: open the page that claims the VM, to share the preview
   --status                try: the last VM's preview, time left, and claim link
   --env-file <path>       deploy: production values (default: .env.production when there is one)

package/dist/core/deploy.js

@@ -338,3 +338,142 @@ export function vercelIgnoreSource(gitignore) {
 export function ignoresEnvFiles(vercelignore) {
     return vercelignore.split(/\r?\n/).some((line) => /^\/?(\*\*\/)?\.env(\*|\.\*)?\/?$/.test(line.trim()));
 }
+/* ------------------------------------ Netlify ------------------------------------ */
+// Netlify only runs the app, as Vercel does: databases, Redis, storage, and email come from the env file.
+/** Where Netlify builds: the app's folder, which holds netlify.toml. */
+export const netlifyBaseDirectory = "apps/web";
+/** A Netlify site name: lowercase letters, digits, and dashes, at most 63 characters. */
+export function netlifySiteName(name) {
+    return name.toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 63).replace(/-+$/, "") || "web";
+}
+/** A site in `netlify api getSite` or `createSiteInTeam` output, or null. */
+export function parseNetlifySite(output) {
+    try {
+        const value = JSON.parse(output);
+        if (typeof value.id !== "string" || typeof value.name !== "string")
+            return null;
+        const url = typeof value.ssl_url === "string" && value.ssl_url ? value.ssl_url : `https://${value.name}.netlify.app`;
+        const base = typeof value.build_settings?.base === "string" ? value.build_settings.base : null;
+        return { id: value.id, name: value.name, url: url.replace(/\/+$/, ""), base };
+    }
+    catch {
+        return null;
+    }
+}
+/** The team slugs in `netlify api listAccountsForUser` output. */
+export function parseNetlifyAccounts(output) {
+    try {
+        const value = JSON.parse(output);
+        if (!Array.isArray(value))
+            return [];
+        return value.map((account) => account?.slug).filter((slug) => typeof slug === "string");
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * The file `netlify env:import` reads: KEY='value' lines. Each value is quoted with a quote it
+ * doesn't contain, so dotenv keeps it as it is (#, spaces, $); a line break can't be imported.
+ */
+export function netlifyEnvFile(values) {
+    return Object.entries(values)
+        .map(([key, value]) => {
+        if (/[\r\n]/.test(value))
+            throw new Error(`${key} has a line break, which Netlify's env:import can't take. Set it in the site's settings.`);
+        const quote = ["'", '"', "`"].find((mark) => !value.includes(mark));
+        if (!quote)
+            throw new Error(`${key} contains every kind of quote, which Netlify's env:import can't take. Set it in the site's settings.`);
+        return `${key}=${quote}${value}${quote}`;
+    })
+        .join("\n")
+        .concat("\n");
+}
+/** The production URL in `netlify deploy --json` output (the last JSON object it prints). */
+export function parseNetlifyDeploy(output) {
+    for (let index = output.lastIndexOf("{"); index >= 0; index = output.lastIndexOf("{", index - 1)) {
+        try {
+            const value = JSON.parse(output.slice(index));
+            const url = typeof value.url === "string" ? value.url : typeof value.deploy_url === "string" ? value.deploy_url : null;
+            if (url)
+                return url.replace(/\/+$/, "");
+        }
+        catch {
+            // Not the start of the JSON object: try the one before.
+        }
+    }
+    return null;
+}
+/* ------------------------------------ Render ------------------------------------ */
+// Render builds the Dockerfile from the project's Git repository, through Render's API.
+export const renderApiUrl = "https://api.render.com/v1";
+/** Deploy statuses Render does not move on from. */
+export const renderFinalStatuses = ["live", "deactivated", "build_failed", "update_failed", "canceled", "pre_deploy_failed"];
+/**
+ * The https URL of a Git remote Render can build from (GitHub, GitLab, or Bitbucket), from an
+ * https or SSH remote; null for anything else.
+ */
+export function renderRepoUrl(remote) {
+    const value = remote.trim();
+    const match = /^(?:git@|ssh:\/\/git@)(github\.com|gitlab\.com|bitbucket\.org)[:/](.+?)(?:\.git)?\/?$/i.exec(value) ??
+        /^https:\/\/(?:[^@/]+@)?(github\.com|gitlab\.com|bitbucket\.org)\/(.+?)(?:\.git)?\/?$/i.exec(value);
+    return match ? `https://${match[1].toLowerCase()}/${match[2]}` : null;
+}
+/**
+ * The body of `POST /v1/services`: a Docker web service on a paid instance type, since pre-deploy
+ * commands (the migrations before each release) need one, as in render.yaml.
+ */
+export function renderServiceBody(input) {
+    return {
+        type: "web_service",
+        name: input.name,
+        ownerId: input.ownerId,
+        repo: input.repo,
+        branch: input.branch,
+        autoDeploy: "yes",
+        serviceDetails: {
+            runtime: "docker",
+            plan: "starter",
+            healthCheckPath: "/api/health",
+            preDeployCommand: "node /app/migrate.mjs",
+            envSpecificDetails: { dockerfilePath: "./Dockerfile", dockerContext: "." },
+        },
+        envVars: Object.entries(input.values).map(([key, value]) => ({ key, value })),
+    };
+}
+/** A service from Render's API: `{ service }` items in a list, or the service itself. */
+function renderService(value) {
+    const item = value?.service ?? value;
+    const service = item;
+    if (typeof service?.id !== "string" || typeof service.name !== "string")
+        return null;
+    const url = service.serviceDetails?.url;
+    return { id: service.id, name: service.name, url: typeof url === "string" && url ? url.replace(/\/+$/, "") : null };
+}
+/** The service named `name` in `GET /v1/services?name=...`, or the one `POST /v1/services` created. */
+export function parseRenderService(body, name) {
+    if (Array.isArray(body)) {
+        return body.map(renderService).find((service) => service && (!name || service.name === name)) ?? null;
+    }
+    return renderService(body);
+}
+/** The workspaces in `GET /v1/owners`: `{ owner: { id, name } }` items. */
+export function parseRenderOwners(body) {
+    if (!Array.isArray(body))
+        return [];
+    return body
+        .map((item) => item?.owner)
+        .filter((owner) => typeof owner?.id === "string" && typeof owner.name === "string");
+}
+/** The variable names and values in `GET /v1/services/:id/env-vars`: `{ envVar: { key, value } }` items. */
+export function parseRenderEnv(body) {
+    if (!Array.isArray(body))
+        return {};
+    const values = {};
+    for (const item of body) {
+        const env = item?.envVar ?? item;
+        if (typeof env?.key === "string")
+            values[env.key] = typeof env.value === "string" ? env.value : "(set)";
+    }
+    return values;
+}

package/dist/deploy-netlify.js

@@ -0,0 +1,218 @@
+// `deploy` for Netlify (experimental): the platform only runs the app, so the database, Redis,
+// storage, and email come from the env file. With Netlify's CLI and your login, it creates or
+// reuses the site (its base directory apps/web, where netlify.toml is), links the project to it,
+// imports the production variables, and runs `netlify deploy --build --prod`. The build runs on
+// this machine with the site's variables: check:env, the migrations, then Netlify's build.
+import { cancel, confirm, isCancel, log, note, outro, spinner } from "@clack/prompts";
+import { randomBytes } from "node:crypto";
+import { mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import process from "node:process";
+import { UsageError } from "./cli/args.js";
+import { bold, dim } from "./cli/ui.js";
+import { appUrlKeys, exampleKeys, externalDatabaseUrls, isLocalUrl, netlifyBaseDirectory, netlifyEnvFile, netlifySiteName, parseNetlifyAccounts, parseNetlifyDeploy, parseNetlifySite, planVariables, serviceName, } from "./core/deploy.js";
+import { pathExists } from "./utils/fs.js";
+import { openUrl } from "./utils/open.js";
+import { spawnCommand } from "./utils/process.js";
+const netlifyCliUrl = "https://docs.netlify.com/cli/get-started/";
+const netlifyPricingUrl = "https://www.netlify.com/pricing/";
+const windows = process.platform === "win32";
+/** Runs Netlify's CLI in the project's root; npm's .cmd shims need a shell on Windows. */
+async function netlify(cli, args, cwd, options = {}) {
+    const [command, ...prefix] = cli.command;
+    const mode = options.mode ?? "capture";
+    const stdio = mode === "interactive" ? "inherit" : mode === "stream" ? ["ignore", "pipe", "inherit"] : ["ignore", "pipe", "pipe"];
+    return await new Promise((resolvePromise, reject) => {
+        const child = spawnCommand(command, [...prefix, ...args], { cwd, stdio: stdio }, windows);
+        let stdout = "";
+        let stderr = "";
+        child.stdout?.on("data", (chunk) => (stdout += chunk.toString()));
+        child.stderr?.on("data", (chunk) => (stderr += chunk.toString()));
+        child.once("error", reject);
+        child.once("close", (code) => {
+            if (code === 0)
+                resolvePromise(stdout.trim());
+            else
+                reject(new Error(`netlify ${args[0]} failed${stderr.trim() ? `: ${stderr.trim().split("\n").slice(-3).join(" ")}` : "."}`));
+        });
+    });
+}
+const attempt = async (run) => run().catch(() => null);
+async function netlifyCli(cwd) {
+    for (const command of [["netlify"], ["npx", "--yes", "netlify-cli@latest"]]) {
+        const cli = { command };
+        if (await attempt(() => netlify(cli, ["--version"], cwd)))
+            return cli;
+    }
+    throw new UsageError(`deploy to Netlify needs Netlify's CLI. Install it with \`npm install -g netlify-cli\` (${netlifyCliUrl}), then run deploy again.`);
+}
+/** `netlify api <method>` with its parameters, parsed as JSON. */
+async function api(cli, method, data, cwd) {
+    return await netlify(cli, ["api", method, ...(data ? ["--data", JSON.stringify(data)] : [])], cwd);
+}
+/** The site `netlify link` recorded in .netlify/state.json, if any. */
+async function linkedSite(root) {
+    try {
+        const state = JSON.parse(await readFile(join(root, ".netlify", "state.json"), "utf8"));
+        return typeof state.siteId === "string" ? state.siteId : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** The name of the app's package, which `--filter` selects in the workspace. */
+async function appPackage(root) {
+    try {
+        const manifest = JSON.parse(await readFile(join(root, netlifyBaseDirectory, "package.json"), "utf8"));
+        return typeof manifest.name === "string" ? manifest.name : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Variables a serverless host must not get: STORAGE_DIRECTORY stores files on a disk Netlify doesn't keep. */
+const serverlessExcluded = ["STORAGE_DIRECTORY"];
+export async function deployToNetlify(args, project, cli, fileValues) {
+    const root = project.root;
+    const skipped = serverlessExcluded.filter((key) => fileValues[key]);
+    if (skipped.length)
+        log.warn(`${skipped.join(", ")} stores files on the server's disk, which Netlify doesn't keep: not set. Files go to the storage bucket.`);
+    const envFile = Object.fromEntries(Object.entries(fileValues).filter(([key]) => !serverlessExcluded.includes(key)));
+    const keys = exampleKeys(await readFile(join(root, ".env.example"), "utf8").catch(() => "")).filter((key) => !serverlessExcluded.includes(key));
+    if (!(await pathExists(join(root, netlifyBaseDirectory, "netlify.toml")))) {
+        throw new UsageError(`This project has no ${netlifyBaseDirectory}/netlify.toml. Switch with \`${cli} add deploy netlify\`.`);
+    }
+    const name = netlifySiteName(serviceName(project.identity.packageName));
+    const external = externalDatabaseUrls(project.modules, envFile);
+    // A public URL of your own (a custom domain) wins; otherwise the site's *.netlify.app URL.
+    const ownUrl = appUrlKeys.map((key) => envFile[key]).find((value) => value && !isLocalUrl(value));
+    const secret = () => randomBytes(32).toString("hex");
+    if (!external.DATABASE_URL) {
+        throw new UsageError("Netlify only runs the app, so the database comes from your provider (Supabase, Neon, ...): put DATABASE_URL in .env.production (its pooled URL), or pass --env-file, then run deploy again.");
+    }
+    if (args.dryRun) {
+        const preview = planVariables({ modules: project.modules, keys, url: ownUrl ?? `https://${name}.netlify.app`, existing: {}, envFile, secret: () => "<generated>", databases: {} });
+        const { NODE_ENV: _node, PORT: _port, ...values } = preview.set;
+        log.message([
+            `• Netlify site "${name}", built from ${netlifyBaseDirectory}, linked in .netlify/state.json`,
+            `• Variables: ${Object.keys(values).join(", ")}`,
+            ...(preview.unset.length ? [`• Not set: ${preview.unset.join(", ")}`] : []),
+            "• netlify deploy --build --prod, on this machine: check:env, the migrations, then the build",
+        ].join("\n"));
+        outro("Dry run: nothing was created. Run again without --dry-run to deploy.");
+        return;
+    }
+    note([
+        "This deploys the project to Netlify, in your Netlify account:",
+        "",
+        `• A site "${name}" that builds ${netlifyBaseDirectory}. Netlify only runs the app: the database${project.modules.cache === "redis" ? ", Redis," : ""} and the other services come from the env file.`,
+        "• The production variables from the env file, the public URL, and a generated BETTER_AUTH_SECRET when the project uses Better Auth.",
+        "• netlify deploy --build --prod builds on this machine with the site's variables: check:env, the migrations against DATABASE_URL, then the build, which it uploads.",
+        "",
+        `Netlify bills usage on your plan (${netlifyPricingUrl}). Running deploy again reuses the site.`,
+    ].join("\n"), "Deploy to Netlify");
+    if (!args.yes) {
+        if (!process.stdin.isTTY)
+            throw new UsageError("deploy creates a site in your Netlify account. Run it in a terminal to confirm, or pass --yes.");
+        const answer = await confirm({ message: "Deploy?", initialValue: true });
+        if (isCancel(answer) || !answer) {
+            cancel("Nothing was deployed.");
+            return;
+        }
+    }
+    const progress = spinner();
+    progress.start("Preparing Netlify's CLI");
+    const nl = await netlifyCli(root);
+    // `netlify login` returns at once when you are signed in; otherwise it opens the browser.
+    if (!process.env.NETLIFY_AUTH_TOKEN) {
+        progress.stop("Signing in to Netlify");
+        if (!process.stdin.isTTY && !(await attempt(() => api(nl, "getCurrentUser", null, root)))) {
+            throw new UsageError("Sign in to Netlify first with `netlify login`, or set NETLIFY_AUTH_TOKEN.");
+        }
+        await netlify(nl, ["login"], root, { mode: "interactive" });
+        progress.start("Signed in");
+    }
+    progress.message("Finding or creating the Netlify site");
+    const linked = await linkedSite(root);
+    const lookup = async (id) => parseNetlifySite((await attempt(() => api(nl, "getSite", { site_id: id }, root))) ?? "");
+    let site = linked ? await lookup(linked) : await lookup(`${name}.netlify.app`);
+    if (!site) {
+        const [team] = parseNetlifyAccounts((await attempt(() => api(nl, "listAccountsForUser", null, root))) ?? "");
+        if (!team)
+            throw new Error("Netlify listed no team for your account. Check `netlify status`, then run deploy again.");
+        // Site names are global on Netlify: when the package's is taken, add a short suffix.
+        for (const candidate of [name, `${name.slice(0, 58)}-${randomBytes(2).toString("hex")}`]) {
+            const body = { name: candidate, build_settings: { base: netlifyBaseDirectory } };
+            site = parseNetlifySite((await attempt(() => api(nl, "createSiteInTeam", { account_slug: team, body }, root))) ?? "");
+            if (site)
+                break;
+        }
+        if (!site)
+            throw new Error(`Netlify created no site "${name}". Create it in the dashboard with the base directory ${netlifyBaseDirectory}, link it with \`netlify link\`, then run deploy again.`);
+    }
+    else if (site.base !== netlifyBaseDirectory) {
+        progress.message(`Setting the site's base directory to ${netlifyBaseDirectory}`);
+        await api(nl, "updateSite", { site_id: site.id, body: { build_settings: { base: netlifyBaseDirectory } } }, root);
+    }
+    if (linked !== site.id)
+        await netlify(nl, ["link", "--id", site.id], root);
+    progress.message("Setting the production variables");
+    const existing = await attempt(() => netlify(nl, ["env:list", "--json", "--context", "production"], root));
+    let current = {};
+    try {
+        current = JSON.parse(existing ?? "{}");
+    }
+    catch {
+        // Unknown output: every variable counts as unset, and the import sets them again.
+    }
+    const url = ownUrl ?? site.url;
+    const plan = planVariables({ modules: project.modules, keys, url, existing: current, envFile, secret, databases: {} });
+    // Netlify sets NODE_ENV and the port itself.
+    const { NODE_ENV: _node, PORT: _port, ...values } = plan.set;
+    // env:import reads a file: the values never appear on a command line. It stays private and goes away after.
+    const directory = await mkdtemp(join(tmpdir(), "clubedge-netlify-"));
+    try {
+        const file = join(directory, "production.env");
+        await writeFile(file, netlifyEnvFile(values), { mode: 0o600 });
+        await netlify(nl, ["env:import", file], root);
+    }
+    finally {
+        await rm(directory, { recursive: true, force: true });
+    }
+    progress.stop(`Netlify is ready: the site "${site.name}"`);
+    if (plan.unset.length) {
+        log.warn(`Not set: ${plan.unset.join(", ")}. The build stops at check:env when one of them is required; the others only turn features off.`);
+        if (process.stdin.isTTY && !args.yes) {
+            const proceed = await confirm({ message: "Deploy anyway?", initialValue: true });
+            if (isCancel(proceed) || !proceed) {
+                cancel("Nothing was deployed. Add them to .env.production, then run deploy again: it reuses the site.");
+                return;
+            }
+        }
+    }
+    log.step("Deploying with netlify deploy --build --prod (build logs follow)");
+    const filter = await appPackage(root);
+    let deployed = null;
+    try {
+        const output = await netlify(nl, ["deploy", "--build", "--prod", "--json", ...(filter ? ["--filter", filter] : [])], root, { mode: "stream" });
+        deployed = parseNetlifyDeploy(output);
+    }
+    catch {
+        throw new Error("The deploy did not finish. The build log above says why (check:env names missing variables). Fix the cause and run deploy again: it reuses the site.");
+    }
+    if (!deployed)
+        log.warn("Netlify printed no deploy URL. Check the site's deploys with `netlify open`.");
+    note([
+        `${bold("URL")}      ${url}`,
+        `${bold("Site")}     ${site.name}`,
+        ...(plan.unset.length ? ["", `${bold("Not set")}  ${plan.unset.join(", ")}`] : []),
+    ].join("\n"), "Deployed to Netlify");
+    if (args.open && process.stdin.isTTY && !args.yes && (await openUrl(url)))
+        log.info("Opened the app in your browser.");
+    outro([
+        `${dim("Logs")}      netlify logs`,
+        `${dim("Dashboard")} netlify open`,
+        `${dim("Again")}     ${cli} deploy   ${dim("(reuses the site; .env.production adds variables)")}`,
+    ].join("\n"));
+}

package/dist/deploy-render.js

@@ -0,0 +1,204 @@
+// `deploy` for Render (experimental): Render builds the Dockerfile from the project's Git repository,
+// so the branch must be pushed. With an API key (RENDER_API_KEY, or pasted when deploy asks), it
+// creates or reuses a Docker web service that runs the migrations before each release and checks
+// /api/health, as render.yaml does, sets the production variables, deploys, and waits until the
+// release is live. Render has no database here: DATABASE_URL comes from the env file.
+import { cancel, confirm, isCancel, log, note, outro, password, select, spinner } from "@clack/prompts";
+import { randomBytes } from "node:crypto";
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import process from "node:process";
+import { UsageError } from "./cli/args.js";
+import { bold, dim } from "./cli/ui.js";
+import { appUrlKeys, exampleKeys, externalDatabaseUrls, isLocalUrl, parseRenderEnv, parseRenderOwners, parseRenderService, planVariables, renderApiUrl, renderFinalStatuses, renderRepoUrl, renderServiceBody, serviceName, } from "./core/deploy.js";
+import { openUrl } from "./utils/open.js";
+import { runCapture } from "./utils/process.js";
+const renderKeysUrl = "https://dashboard.render.com/u/settings#api-keys";
+const renderPricingUrl = "https://render.com/pricing";
+/** Calls Render's API; an error names the request and Render's message. */
+async function render(key, method, path, body) {
+    const response = await fetch(`${renderApiUrl}${path}`, {
+        method,
+        headers: { authorization: `Bearer ${key}`, accept: "application/json", ...(body === undefined ? {} : { "content-type": "application/json" }) },
+        body: body === undefined ? undefined : JSON.stringify(body),
+    });
+    const text = await response.text();
+    if (!response.ok) {
+        let message = text.trim();
+        try {
+            message = JSON.parse(text).message ?? message;
+        }
+        catch {
+            // Not JSON: Render's text as it is.
+        }
+        throw new Error(`Render's API answered ${response.status} to ${method} ${path.replace(/\?.*$/, "")}${message ? `: ${message}` : "."}`);
+    }
+    return (text ? JSON.parse(text) : null);
+}
+/** The Git remote and branch Render builds, after checking the branch is pushed. */
+async function gitSource(root) {
+    const git = (...argv) => runCapture("git", argv, root);
+    const remote = await git("remote", "get-url", "origin").catch(() => "");
+    const repo = renderRepoUrl(remote);
+    if (!repo) {
+        throw new UsageError("Render builds from your Git repository: push this project to GitHub, GitLab, or Bitbucket as `origin`, then run deploy again.");
+    }
+    const branch = await git("rev-parse", "--abbrev-ref", "HEAD").catch(() => "");
+    if (!branch || branch === "HEAD") {
+        throw new UsageError("Render builds a branch of your Git repository: commit the project on a branch and push it, then run deploy again.");
+    }
+    const ahead = await git("rev-list", "--count", `origin/${branch}..HEAD`).catch(() => null);
+    if (ahead === null)
+        throw new UsageError(`Render builds the branch ${branch} from ${repo}, which isn't pushed yet. Run \`git push -u origin ${branch}\`, then deploy again.`);
+    if (ahead !== "0")
+        log.warn(`${ahead} commit(s) on ${branch} aren't pushed: Render builds what ${repo} has. Run \`git push\` to include them.`);
+    return { repo, branch };
+}
+/** The API key: RENDER_API_KEY, else pasted from the dashboard's API keys page. */
+async function apiKey() {
+    if (process.env.RENDER_API_KEY)
+        return process.env.RENDER_API_KEY;
+    if (!process.stdin.isTTY)
+        throw new UsageError(`Set RENDER_API_KEY to a Render API key (${renderKeysUrl}), then run deploy again.`);
+    log.info(`Render signs deploy in with an API key. Create one on the page that opens (${renderKeysUrl}) and paste it here.`);
+    await openUrl(renderKeysUrl);
+    const key = await password({ message: "Render API key", validate: (value) => (value?.trim() ? undefined : "Paste the key from Render's dashboard.") });
+    if (isCancel(key))
+        throw new UsageError("Nothing was deployed.");
+    log.info("Set RENDER_API_KEY to it, and deploy won't ask next time.");
+    return key.trim();
+}
+/** The workspace for the service: the only one, or the one you pick. */
+async function workspace(key, args) {
+    const owners = parseRenderOwners(await render(key, "GET", "/owners?limit=100"));
+    if (!owners.length)
+        throw new Error("Render listed no workspace for this API key.");
+    if (owners.length === 1 || args.yes || !process.stdin.isTTY)
+        return owners[0].id;
+    const picked = await select({ message: "Render workspace", options: owners.map((owner) => ({ value: owner.id, label: owner.name })) });
+    if (isCancel(picked))
+        throw new UsageError("Nothing was deployed.");
+    return picked;
+}
+export async function deployToRender(args, project, cli, envFile) {
+    const root = project.root;
+    const keys = exampleKeys(await readFile(join(root, ".env.example"), "utf8").catch(() => ""));
+    const name = serviceName(project.identity.packageName);
+    const external = externalDatabaseUrls(project.modules, envFile);
+    // A public URL of your own (a custom domain) wins; otherwise the service's *.onrender.com URL.
+    const ownUrl = appUrlKeys.map((key) => envFile[key]).find((value) => value && !isLocalUrl(value));
+    const secret = () => randomBytes(32).toString("hex");
+    if (!external.DATABASE_URL) {
+        throw new UsageError("deploy runs the app on Render, and the database comes from your provider (Render Postgres, Neon, Supabase, ...): put DATABASE_URL in .env.production, or pass --env-file, then run deploy again.");
+    }
+    const source = await gitSource(root);
+    if (args.dryRun) {
+        const preview = planVariables({ modules: project.modules, keys, url: ownUrl ?? `https://${name}.onrender.com`, existing: {}, envFile, secret: () => "<generated>", databases: {} });
+        const { NODE_ENV: _node, PORT: _port, ...values } = preview.set;
+        log.message([
+            `• Render web service "${name}" (Docker, starter instance), built from ${source.repo} (${source.branch})`,
+            `• Variables: ${Object.keys(values).join(", ")}`,
+            ...(preview.unset.length ? [`• Not set: ${preview.unset.join(", ")}`] : []),
+            "• A deploy: the image build, the migrations before the release, the /api/health check",
+        ].join("\n"));
+        outro("Dry run: nothing was created. Run again without --dry-run to deploy.");
+        return;
+    }
+    note([
+        "This deploys the project to Render, in your Render account:",
+        "",
+        `• A web service "${name}" that builds the Dockerfile from ${source.repo} (${source.branch}), and deploys again on each push.`,
+        "• A starter instance: pre-deploy commands, which run the migrations before each release, need a paid instance type.",
+        "• The production variables from the env file, the public URL, and a generated BETTER_AUTH_SECRET when the project uses Better Auth.",
+        "• Render builds the image, runs the migrations, and checks /api/health; the first build takes several minutes.",
+        "",
+        `Render bills the instance on your plan (${renderPricingUrl}). Running deploy again reuses the service.`,
+    ].join("\n"), "Deploy to Render");
+    if (!args.yes) {
+        if (!process.stdin.isTTY)
+            throw new UsageError("deploy creates a service in your Render account. Run it in a terminal to confirm, or pass --yes.");
+        const answer = await confirm({ message: "Deploy?", initialValue: true });
+        if (isCancel(answer) || !answer) {
+            cancel("Nothing was deployed.");
+            return;
+        }
+    }
+    const key = await apiKey();
+    const owner = await workspace(key, args);
+    const progress = spinner();
+    progress.start("Finding or creating the Render service");
+    let service = parseRenderService(await render(key, "GET", `/services?name=${encodeURIComponent(name)}&ownerId=${encodeURIComponent(owner)}&limit=20`), name);
+    let deployId = null;
+    let url = ownUrl ?? service?.url ?? `https://${name}.onrender.com`;
+    const current = service ? parseRenderEnv(await render(key, "GET", `/services/${service.id}/env-vars?limit=100`)) : {};
+    const plan = planVariables({ modules: project.modules, keys, url, existing: current, envFile, secret, databases: {} });
+    // Render sets the port, and the Dockerfile NODE_ENV.
+    const { NODE_ENV: _node, PORT: _port, ...values } = plan.set;
+    if (!service) {
+        const created = await render(key, "POST", "/services", renderServiceBody({ name, ownerId: owner, ...source, values }));
+        service = parseRenderService(created);
+        if (!service)
+            throw new Error(`Render created no service "${name}". Create it in the dashboard (New, then Blueprint, with render.yaml), then run deploy again.`);
+        deployId = typeof created.deployId === "string" ? created.deployId : null;
+        // Render picks another subdomain when the name is taken: the build compiles the public URL in.
+        if (!ownUrl && service.url && service.url !== url) {
+            url = service.url;
+            log.info(`Render named the app ${url}. Setting it as the public URL and deploying again, since the build compiles it in.`);
+            for (const urlKey of appUrlKeys)
+                await render(key, "PUT", `/services/${service.id}/env-vars/${urlKey}`, { value: url });
+            // The deploy that creating the service started builds the old URL in, and would run the
+            // migrations alongside the next one: cancel it first. It may have ended already.
+            if (deployId)
+                await render(key, "POST", `/services/${service.id}/deploys/${deployId}/cancel`).catch(() => null);
+            deployId = null;
+        }
+    }
+    else {
+        progress.message("Setting the production variables");
+        for (const [envKey, value] of Object.entries(values)) {
+            if (current[envKey] === value)
+                continue;
+            await render(key, "PUT", `/services/${service.id}/env-vars/${envKey}`, { value });
+        }
+    }
+    progress.stop(`Render is ready: the service "${service.name}"`);
+    if (plan.unset.length) {
+        log.warn(`Not set: ${plan.unset.join(", ")}. The app starts without them, but the features that use them fail until they are set.`);
+    }
+    const deploying = spinner();
+    deploying.start("Starting the deploy");
+    if (!deployId) {
+        const started = await render(key, "POST", `/services/${service.id}/deploys`, { clearCache: "do_not_clear" });
+        deployId = typeof started?.id === "string" ? started.id : null;
+    }
+    if (!deployId)
+        throw new Error(`Render started no deploy. Start one in the dashboard, or run deploy again.`);
+    const begun = Date.now();
+    let status = "created";
+    while (!renderFinalStatuses.includes(status)) {
+        if (Date.now() - begun > 45 * 60_000)
+            break;
+        const elapsed = Math.round((Date.now() - begun) / 1000);
+        deploying.message(`Render: ${status.replaceAll("_", " ")} (${Math.floor(elapsed / 60)}m ${elapsed % 60}s; the first build takes several minutes)`);
+        await new Promise((wait) => setTimeout(wait, 10_000));
+        const deploy = await render(key, "GET", `/services/${service.id}/deploys/${deployId}`).catch(() => null);
+        if (typeof deploy?.status === "string")
+            status = deploy.status;
+    }
+    if (status !== "live") {
+        deploying.stop(`The deploy ended as ${status.replaceAll("_", " ")}`);
+        throw new Error(`Render's deploy ended as ${status}. Its logs in the dashboard say why (https://dashboard.render.com/web/${service.id}). Fix the cause and run deploy again: it reuses the service.`);
+    }
+    deploying.stop("Deployed: the migrations ran and /api/health answered");
+    note([
+        `${bold("URL")}      ${url}`,
+        `${bold("Service")}  ${service.name}`,
+        ...(plan.unset.length ? ["", `${bold("Not set")}  ${plan.unset.join(", ")}`, dim("Set the ones your modules use in the service's Environment settings.")] : []),
+    ].join("\n"), "Deployed to Render");
+    if (args.open && process.stdin.isTTY && !args.yes && (await openUrl(url)))
+        log.info("Opened the app in your browser.");
+    outro([
+        `${dim("Dashboard")} https://dashboard.render.com/web/${service.id}`,
+        `${dim("Again")}     ${cli} deploy   ${dim("(reuses the service; .env.production adds variables)")}`,
+    ].join("\n"));
+}

package/dist/deploy.js

@@ -14,6 +14,8 @@ import { bold, dim } from "./cli/ui.js";
 import { appPort, databaseVariables, databasesFor, deploymentStatus, exampleKeys, externalDatabaseUrls, finalStatuses, isLocalUrl, meetsMinimumCli, minimumRailwayCli, parseDeploymentId, parseEnvFile, parseRailwayDomain, parseVariables, planVariables, railwayCliVersion, railwayDatabases, railwayIacPath, railwayIacSource, railwayReferences, serviceName, serviceNames, } from "./core/deploy.js";
 import { readProject } from "./core/project.js";
 import { deployToFly } from "./deploy-fly.js";
+import { deployToNetlify } from "./deploy-netlify.js";
+import { deployToRender } from "./deploy-render.js";
 import { deployToVercel } from "./deploy-vercel.js";
 import { cliCommand } from "./modify.js";
 import { resolvePnpm } from "./steps/install.js";
@@ -163,8 +165,12 @@ export async function deployProject(args) {
         return await deployToFly(args, project, cli, await readDeployEnv(args, project));
     if (platform === "vercel")
         return await deployToVercel(args, project, cli, await readDeployEnv(args, project));
+    if (platform === "netlify")
+        return await deployToNetlify(args, project, cli, await readDeployEnv(args, project));
+    if (platform === "render")
+        return await deployToRender(args, project, cli, await readDeployEnv(args, project));
     if (platform !== "railway") {
-        throw new UsageError(`deploy sets up Railway, Fly.io, and Vercel for now, and this project deploys with "${platform}". Switch with \`${cli} add deploy railway\` (or fly, or vercel), or follow ${deployDocsUrl} for ${platform}.`);
+        throw new UsageError(`deploy sets up Railway, Fly.io, Vercel, Netlify, and Render, and this project deploys with "${platform}". Switch with \`${cli} add deploy railway\` (or fly, vercel, netlify, render), or follow ${deployDocsUrl} for ${platform}.`);
     }
     const service = serviceName(project.identity.packageName);
     const keys = exampleKeys(await readFile(join(project.root, ".env.example"), "utf8").catch(() => ""));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clubedge/create-clubedge-app",
-  "version": "0.28.0",
+  "version": "0.29.0",
   "description": "Create a Next.js or TanStack Start application from the Clubedge Starter reference implementation.",
   "type": "module",
   "packageManager": "pnpm@10.9.0",