@clubedge/create-clubedge-app 0.27.0 → 0.29.0

package/CHANGELOG.md

@@ -2,6 +2,23 @@
 
 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`:
+  - It signs in with `vercel login` when you are signed out, then creates or reuses the project with `apps/web` as its Root Directory and writes `.vercelignore` so `.env` files stay on your machine.
+  - It sets the production variables from `.env.production` (or `--env-file`), the public URL, and a generated `BETTER_AUTH_SECRET`, then runs `vercel deploy --prod`. `DATABASE_URL` must point at your provider (Neon, Supabase, ...), since Vercel only runs the app.
+  - When Vercel names the app something other than `<project>.vercel.app`, it sets that URL and deploys again, since the build compiles it in.
+- The README opens with the banner the CLI prints (#79).
+- Still on Starter `v0.18.0`.
+
 ## 0.27.0
 
 - Default to Starter `v0.18.0` (#77), which stops Vercel and Netlify builds when a production variable is missing:

package/README.md

@@ -1,5 +1,7 @@
 <div align="center">
 
+<img src="https://raw.githubusercontent.com/Clubedge/create-clubedge-app/main/.github/assets/cover.png" alt="Terminal running pnpm dlx @clubedge/create-clubedge-app my-app and printing the CLUBEDGE STARTER banner" width="100%">
+
 # create-clubedge-app
 
 **Create a production-ready Next.js or TanStack Start app with one command, and keep it up to date.**
@@ -205,12 +207,24 @@ With [Railway's CLI](https://docs.railway.com/cli) (the installed `railway`, or
 
 In a project with `--deploy fly`, `pnpm clubedge deploy` does the same with [Fly's CLI](https://fly.io/docs/flyctl/install/) (install it first; it is not on npm) and your Fly login: it creates the app (`fly launch`, which writes its name and region into `fly.toml`; commit it), an unmanaged Postgres app attached as `DATABASE_URL` (one `shared-cpu-1x` machine and a 1 GB volume) and Upstash Redis with `cache redis`, each unless the env file has its URL, and imports the secrets (the public URL `https://<app>.fly.dev`, a kept `BETTER_AUTH_SECRET`, and `--env-file` values). Then `fly deploy` builds the Dockerfile with `NEXT_PUBLIC_APP_URL` as a build argument, runs the migrations as the release command, and waits for the health checks. Fly bills these on your plan; for Fly's Managed Postgres, create and attach it yourself before deploying. Running it again reuses everything.
 
+### Deploy to Vercel (experimental)
+
+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.27.0
+create-clubedge-app v0.29.0
         |
         v
 Clubedge Starter v0.18.0
@@ -221,7 +235,7 @@ The current relationship is:
 
 | CLI release | Default Starter release | Meaning |
 | --- | --- | --- |
-| `create-clubedge-app@0.27.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`.
 
@@ -322,6 +336,8 @@ Each phase ends with a Starter release and a CLI release pinned to it. The full
 | 0.25.0 | v0.17.1 | `deploy` to Fly.io (experimental); weekly Dependabot updates |
 | 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,10 +124,10 @@ ${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: do not open the preview 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 (Railway, Fly.io): production values, such as .env.production
+  --env-file <path>       deploy: production values (default: .env.production when there is one)
   -y, --yes               Accept defaults and never prompt (default directory: my-app)
   --no-install            Skip dependency installation
   --no-git                Skip Git repository initialization

package/dist/core/deploy.js

@@ -87,6 +87,9 @@ export function planVariables(input) {
     for (const [key, value] of Object.entries(envFile)) {
         if (value === "" || databaseKeys.includes(key))
             continue;
+        // A development env file's localhost URL would send emailed links to this machine.
+        if (appUrlKeys.includes(key) && isLocalUrl(value))
+            continue;
         set[key] = value;
     }
     Object.assign(set, external);
@@ -166,10 +169,10 @@ export function railwayCliVersion(output) {
     const match = /\b(\d+)\.(\d+)\.(\d+)\b/.exec(output);
     return match ? [Number(match[1]), Number(match[2]), Number(match[3])] : null;
 }
-export function meetsMinimumCli(version) {
+export function meetsMinimumCli(version, minimum = minimumRailwayCli) {
     for (let i = 0; i < 3; i++) {
-        if (version[i] !== minimumRailwayCli[i])
-            return version[i] > minimumRailwayCli[i];
+        if (version[i] !== minimum[i])
+            return version[i] > minimum[i];
     }
     return true;
 }
@@ -246,3 +249,231 @@ export function flySecretsInput(values) {
         .map(([key, value]) => `${key}=${value}`)
         .join("\n");
 }
+// Vercel: the platform only runs the app. Databases, Redis, storage, and email come from the env file.
+/** vercel@50.5.1 added `vercel api`, which deploy uses to create the project and set its variables. */
+export const minimumVercelCli = [50, 5, 1];
+/** Where Vercel builds: the app's folder, with the whole workspace uploaded. */
+export const vercelRootDirectory = "apps/web";
+/** The variables that hold the public URL: readable on Vercel ("plain"), so a later deploy can compare them. */
+export const appUrlKeys = ["APP_URL", "NEXT_PUBLIC_APP_URL"];
+/** A project in `vercel api /v9/projects/:name` output, or null. */
+export function parseVercelProject(output) {
+    try {
+        const value = JSON.parse(output);
+        if (typeof value.id !== "string" || typeof value.name !== "string")
+            return null;
+        return { id: value.id, name: value.name, rootDirectory: typeof value.rootDirectory === "string" ? value.rootDirectory : null };
+    }
+    catch {
+        return null;
+    }
+}
+/** The project's production variables from `vercel api /v10/projects/:id/env`: plain values as they are, the rest as "(set)". */
+export function parseVercelEnv(output) {
+    const values = {};
+    try {
+        const { envs } = JSON.parse(output);
+        for (const env of envs ?? []) {
+            const targets = Array.isArray(env.target) ? env.target : [env.target];
+            if (typeof env.key !== "string" || !targets.includes("production"))
+                continue;
+            values[env.key] = env.type === "plain" && typeof env.value === "string" ? env.value : "(set)";
+        }
+    }
+    catch {
+        // Unknown output: every variable counts as unset, and the upsert sets them again.
+    }
+    return values;
+}
+/** The body of `POST /v10/projects/:id/env?upsert=true`: production variables, encrypted except the public URL. */
+export function vercelEnvBody(values) {
+    return Object.entries(values).map(([key, value]) => ({
+        key,
+        value,
+        type: appUrlKeys.includes(key) ? "plain" : "encrypted",
+        target: ["production"],
+    }));
+}
+/**
+ * The public URL Vercel gave a production deployment, from `vercel api /v13/deployments/:url`: the
+ * shortest *.vercel.app alias that isn't the deployment's own URL or a Git branch's.
+ */
+export function vercelProductionUrl(output, deploymentUrl) {
+    const own = deploymentUrl.replace(/^https?:\/\//, "").replace(/\/.*$/, "").toLowerCase();
+    try {
+        const { alias } = JSON.parse(output);
+        const names = (Array.isArray(alias) ? alias : [])
+            .filter((name) => typeof name === "string")
+            .map((name) => name.toLowerCase())
+            .filter((name) => name.endsWith(".vercel.app") && name !== own && !name.includes("-git-"))
+            .sort((a, b) => a.length - b.length);
+        return names[0] ? `https://${names[0]}` : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** The deployment URL `vercel deploy` prints on stdout (its last https URL). */
+export function parseVercelDeploymentUrl(output) {
+    const urls = output.match(/https:\/\/[a-z0-9.-]+\.vercel\.app\b/gi);
+    return urls?.at(-1)?.toLowerCase() ?? null;
+}
+/**
+ * .vercelignore for a project without one: the CLI uploads everything but a short list, which
+ * keeps .env.local out but not .env or .env.production. Uploading what Git would commit keeps
+ * secrets and build output out, as `try` does.
+ */
+export function vercelIgnoreSource(gitignore) {
+    const lines = gitignore.split(/\r?\n/).map((line) => line.trimEnd());
+    const required = [".env*", "!.env.example"].filter((line) => !lines.includes(line));
+    return [
+        "# What `vercel deploy` leaves out: what Git ignores, so secrets in .env files and build output",
+        "# stay on this machine. Vercel reads its variables from the project's settings.",
+        ...lines.filter((line, index) => line || index < lines.length - 1),
+        ...required,
+        "",
+    ].join("\n");
+}
+/** Whether a .vercelignore keeps .env files out of the upload. */
+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-vercel.js

@@ -0,0 +1,218 @@
+// `deploy` for Vercel: the platform only runs the app, so the database, Redis, storage, and email
+// come from the env file. With Vercel's CLI and your login, it creates or reuses the project (built
+// from apps/web, with the whole workspace uploaded), sets the production variables, runs
+// `vercel deploy --prod`, and prints the public URL. The build checks the variables (check:env)
+// and runs the migrations before it builds.
+import { cancel, confirm, isCancel, log, note, outro, spinner } from "@clack/prompts";
+import { randomBytes } from "node:crypto";
+import { readFile, writeFile } 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, ignoresEnvFiles, isLocalUrl, meetsMinimumCli, minimumVercelCli, parseVercelDeploymentUrl, parseVercelEnv, parseVercelProject, planVariables, railwayCliVersion, serviceName, vercelEnvBody, vercelIgnoreSource, vercelProductionUrl, vercelRootDirectory, } from "./core/deploy.js";
+import { pathExists } from "./utils/fs.js";
+import { openUrl } from "./utils/open.js";
+import { spawnCommand } from "./utils/process.js";
+const vercelCliUrl = "https://vercel.com/docs/cli";
+const vercelPricingUrl = "https://vercel.com/pricing";
+const windows = process.platform === "win32";
+/** Runs Vercel's CLI in the project's root; npm's .cmd shims need a shell on Windows. */
+async function vercel(cli, args, cwd, options = {}) {
+    const [command, ...prefix] = cli.command;
+    const mode = options.mode ?? "capture";
+    const stdio = mode === "interactive" ? "inherit" : mode === "stream" ? ["pipe", "pipe", "inherit"] : ["pipe", "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(`vercel ${args[0]} failed${stderr.trim() ? `: ${stderr.trim().split("\n").slice(-3).join(" ")}` : "."}`));
+        });
+        if (child.stdin) {
+            child.stdin.on("error", () => { });
+            child.stdin.end(options.input ?? "");
+        }
+    });
+}
+const attempt = async (run) => run().catch(() => null);
+async function vercelCli(cwd) {
+    for (const command of [["vercel"], ["npx", "--yes", "vercel@latest"]]) {
+        const cli = { command };
+        const version = railwayCliVersion((await attempt(() => vercel(cli, ["--version"], cwd))) ?? "");
+        if (version && meetsMinimumCli(version, minimumVercelCli))
+            return cli;
+    }
+    throw new UsageError(`deploy to Vercel needs Vercel's CLI ${minimumVercelCli.join(".")} or newer. Install it with \`npm install -g vercel\` (${vercelCliUrl}), then run deploy again.`);
+}
+/** The project `vercel link` recorded in .vercel/project.json, if any. */
+async function linkedProject(root) {
+    try {
+        const linked = JSON.parse(await readFile(join(root, ".vercel", "project.json"), "utf8"));
+        return typeof linked.projectId === "string" ? linked.projectId : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Writes .vercelignore when the project has none, so .env files never reach Vercel. */
+async function ensureVercelIgnore(root) {
+    const path = join(root, ".vercelignore");
+    if (await pathExists(path)) {
+        if (!ignoresEnvFiles(await readFile(path, "utf8"))) {
+            log.warn("Your .vercelignore doesn't leave out .env files, so `vercel deploy` uploads them. Add `.env*` and `!.env.example` to it.");
+        }
+        return false;
+    }
+    const gitignore = await readFile(join(root, ".gitignore"), "utf8").catch(() => "");
+    await writeFile(path, vercelIgnoreSource(gitignore));
+    return true;
+}
+/** Variables a serverless host must not get: STORAGE_DIRECTORY stores files on a disk Vercel doesn't keep. */
+const serverlessExcluded = ["STORAGE_DIRECTORY"];
+export async function deployToVercel(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 Vercel 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, vercelRootDirectory, "vercel.json")))) {
+        throw new UsageError(`This project has no ${vercelRootDirectory}/vercel.json. Switch with \`${cli} add deploy vercel\`.`);
+    }
+    const name = serviceName(project.identity.packageName);
+    const external = externalDatabaseUrls(project.modules, envFile);
+    // A public URL of your own (a custom domain) wins; otherwise the one Vercel assigns.
+    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("Vercel 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}.vercel.app`, existing: {}, envFile, secret: () => "<generated>", databases: {} });
+        const { NODE_ENV: _node, PORT: _port, ...values } = preview.set;
+        log.message([
+            `• Vercel project "${name}", built from ${vercelRootDirectory} with the whole workspace uploaded`,
+            `• Production variables: ${Object.keys(values).join(", ")}`,
+            ...(preview.unset.length ? [`• Not set: ${preview.unset.join(", ")}`] : []),
+            "• .vercelignore (when missing): what Git ignores, so .env files stay on this machine",
+            "• vercel deploy --prod: 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 Vercel, in your Vercel account:",
+        "",
+        `• A project "${name}" that builds ${vercelRootDirectory}. Vercel 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.",
+        "• vercel deploy --prod: the build checks the variables (check:env), runs the migrations against DATABASE_URL, then builds.",
+        "",
+        `Vercel bills usage on your plan (${vercelPricingUrl}). Running deploy again reuses the project.`,
+    ].join("\n"), "Deploy to Vercel");
+    if (!args.yes) {
+        if (!process.stdin.isTTY)
+            throw new UsageError("deploy creates a project in your Vercel 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 Vercel's CLI");
+    const vc = await vercelCli(root);
+    if (!(await attempt(() => vercel(vc, ["whoami"], root)))) {
+        progress.stop("Signing in to Vercel");
+        if (!process.stdin.isTTY)
+            throw new UsageError("Sign in to Vercel first with `vercel login`, or set VERCEL_TOKEN.");
+        await vercel(vc, ["login"], root, { mode: "interactive" });
+        progress.start("Signed in");
+    }
+    progress.message("Finding or creating the Vercel project");
+    const linked = await linkedProject(root);
+    let found = parseVercelProject((await attempt(() => vercel(vc, ["api", `/v9/projects/${linked ?? name}`], root))) ?? "");
+    if (!found) {
+        const created = await vercel(vc, ["api", "/v10/projects", "-X", "POST", "--input", "-"], root, {
+            input: JSON.stringify({ name, rootDirectory: vercelRootDirectory }),
+        });
+        found = parseVercelProject(created);
+        if (!found)
+            throw new Error(`Vercel created no project "${name}". Create it in the dashboard with the Root Directory ${vercelRootDirectory}, then run deploy again.`);
+    }
+    else if (found.rootDirectory !== vercelRootDirectory) {
+        progress.message(`Setting the project's Root Directory to ${vercelRootDirectory}`);
+        await vercel(vc, ["api", `/v9/projects/${found.id}`, "-X", "PATCH", "--input", "-"], root, {
+            input: JSON.stringify({ rootDirectory: vercelRootDirectory }),
+        });
+    }
+    if (!linked)
+        await vercel(vc, ["link", "--yes", "--project", found.name], root);
+    const wroteIgnore = await ensureVercelIgnore(root);
+    progress.message("Setting the production variables");
+    const existing = parseVercelEnv((await attempt(() => vercel(vc, ["api", `/v10/projects/${found.id}/env`], root))) ?? "");
+    const keptUrl = appUrlKeys.map((key) => existing[key]).find((value) => value && value !== "(set)" && !isLocalUrl(value));
+    let url = ownUrl ?? keptUrl ?? `https://${found.name}.vercel.app`;
+    const plan = planVariables({ modules: project.modules, keys, url, existing, envFile, secret, databases: {} });
+    // Vercel sets NODE_ENV and the port itself.
+    const { NODE_ENV: _node, PORT: _port, ...values } = plan.set;
+    await vercel(vc, ["api", `/v10/projects/${found.id}/env?upsert=true`, "-X", "POST", "--input", "-"], root, {
+        input: JSON.stringify(vercelEnvBody(values)),
+    });
+    progress.stop(`Vercel is ready: the project "${found.name}"`);
+    if (wroteIgnore)
+        log.info("Commit .vercelignore: it keeps .env files and build output out of `vercel deploy`.");
+    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 project.");
+                return;
+            }
+        }
+    }
+    const deploy = async () => {
+        log.step("Deploying with vercel deploy --prod (build logs follow)");
+        try {
+            const output = await vercel(vc, ["deploy", "--prod", "--yes", "--logs"], root, { mode: "stream" });
+            const deployment = parseVercelDeploymentUrl(output);
+            if (!deployment)
+                throw new Error("no URL");
+            return deployment;
+        }
+        catch {
+            throw new Error("The deploy did not finish. The build log above says why (check:env names missing variables); `vercel inspect --logs <url>` shows it again. Fix the cause and run deploy again: it reuses the project.");
+        }
+    };
+    const deployment = await deploy();
+    const details = await attempt(() => vercel(vc, ["api", `/v13/deployments/${deployment.replace(/^https:\/\//, "")}`], root));
+    const assigned = vercelProductionUrl(details ?? "", deployment);
+    // Next.js compiles the public URL into the build: when Vercel picked another name, set it and build again.
+    if (!ownUrl && assigned && assigned !== url) {
+        log.info(`Vercel named the app ${assigned}. Setting it as the public URL and deploying again, since the build compiles it in.`);
+        url = assigned;
+        await vercel(vc, ["api", `/v10/projects/${found.id}/env?upsert=true`, "-X", "POST", "--input", "-"], root, {
+            input: JSON.stringify(vercelEnvBody(Object.fromEntries(appUrlKeys.map((key) => [key, url])))),
+        });
+        await deploy();
+    }
+    note([
+        `${bold("URL")}      ${url}`,
+        `${bold("Project")}  ${found.name}`,
+        ...(plan.unset.length ? ["", `${bold("Not set")}  ${plan.unset.join(", ")}`] : []),
+    ].join("\n"), "Deployed to Vercel");
+    if (args.open && process.stdin.isTTY && !args.yes && (await openUrl(url)))
+        log.info("Opened the app in your browser.");
+    outro([
+        `${dim("Logs")}      vercel logs ${url}`,
+        `${dim("Dashboard")} vercel open`,
+        `${dim("Again")}     ${cli} deploy   ${dim("(reuses the project; .env.production adds variables)")}`,
+    ].join("\n"));
+}

package/dist/deploy.js

@@ -14,6 +14,9 @@ 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";
 import { pathExists } from "./utils/fs.js";
@@ -160,8 +163,14 @@ export async function deployProject(args) {
     const platform = project.modules.deploy ?? "docker";
     if (platform === "fly")
         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 and Fly.io for now, and this project deploys with "${platform}". Switch with \`${cli} add deploy railway\` (or fly), 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/dist/index.js

@@ -237,7 +237,7 @@ export async function main(argv = process.argv.slice(2)) {
             await runDoctor(args);
         }
         else if (args.command.name === "deploy") {
-            intro("Deploy this project to Railway");
+            intro("Deploy this project");
             await deployProject(args);
         }
         else if (args.command.name === "try") {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clubedge/create-clubedge-app",
-  "version": "0.27.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",