@clubedge/create-clubedge-app 0.24.1 → 0.25.0

package/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 All notable changes to `create-clubedge-app` are documented here.
 
+## 0.25.0
+
+- `deploy` for Fly.io (experimental) (#71): in a project with `deploy fly`, `pnpm clubedge deploy` uses Fly's CLI and your Fly login.
+  - It creates or reuses 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`.
+  - It imports the secrets through stdin: the public URL `https://<app>.fly.dev`, a `BETTER_AUTH_SECRET` kept on later runs, and `--env-file` values; the ones still unset are listed before the build.
+  - `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's Managed Postgres (from $38/month) is a manual choice: create and attach it before deploying.
+- Weekly Dependabot updates for the CLI's npm dependencies and GitHub Actions (#67). The Starter gets the same, without passing it on to generated projects, which receive updates as upgrade pull requests.
+- Still on Starter `v0.17.1`.
+
 ## 0.24.1
 
 - Default to Starter `v0.17.1` (#65), which fixes deployed Next.js apps sending sign-in email links and Stripe return URLs to `http://localhost:3000`: the Dockerfile now takes `NEXT_PUBLIC_APP_URL` as a build argument, which Railway and Render pass from the service's variables. `pnpm clubedge deploy` already sets it on Railway.

package/README.md

@@ -201,12 +201,16 @@ pnpm clubedge deploy --dry-run                    # show the plan, create nothin
 
 With [Railway's CLI](https://docs.railway.com/cli) (the installed `railway`, or `npx @railway/cli`) and your Railway login, it creates or reuses a project named after the package, Postgres (and Redis with `cache redis`), the app's service, and a `*.up.railway.app` domain. It sets the variables it can: `DATABASE_URL` and `REDIS_URL` as references to those databases, `APP_URL` and `NEXT_PUBLIC_APP_URL`, `PORT`, and a generated `BETTER_AUTH_SECRET` that later runs keep. Values from `--env-file` come on top; the variables `.env.example` lists that nothing sets are reported, for the modules that need them (storage, email, payments). The service's settings (the migrations before each release, the `/api/health` check) go in `.railway/railway.ts`, Railway's configuration as code, which replaces `railway.json` (Railway stops reading it on 2026-12-01): `deploy` writes it when the project has none, adds Railway's TypeScript SDK (`railway`) as a dev dependency, and applies it with `railway config apply`; commit them. Then `railway up` builds the Dockerfile, and `deploy` waits for Railway's final status before printing the URL. It needs Railway CLI 5.42.1 or newer: an installed `railway`, else one npx already downloaded, else it downloads one. Running `deploy` again reuses everything, so it also adds variables and ships a new release. Railway bills usage on your plan.
 
+### Deploy to Fly.io (experimental)
+
+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), Upstash Redis with `cache redis`, 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.
+
 ## Version relationship
 
 Each CLI release is tested against one specific Starter release:
 
 ```text
-create-clubedge-app v0.24.1
+create-clubedge-app v0.25.0
         |
         v
 Clubedge Starter v0.17.1
@@ -217,7 +221,7 @@ The current relationship is:
 
 | CLI release | Default Starter release | Meaning |
 | --- | --- | --- |
-| `create-clubedge-app@0.24.1` | `clubedge-starter@v0.17.1` | The CLI's required, tested default |
+| `create-clubedge-app@0.25.0` | `clubedge-starter@v0.17.1` | 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`.
 
@@ -315,6 +319,7 @@ Each phase ends with a Starter release and a CLI release pinned to it. The full
 | 0.22.0 | v0.16.1 | `pnpm clubedge deploy`: a guided first deploy to Railway; faster Docker builds |
 | 0.23.0 | v0.16.1 | `deploy` moves Railway projects to `.railway/railway.ts` before Railway stops reading `railway.json` |
 | 0.24.0 | v0.17.0 | Starter v0.17.0: Railway configuration as code (`.railway/railway.ts`) instead of `railway.json` |
+| 0.25.0 | v0.17.1 | `deploy` to Fly.io (experimental); weekly Dependabot updates |
 | next | | Show the Starter's version of a conflicted file next to yours |
 
 ## Community

package/dist/cli/ui.js

@@ -127,7 +127,7 @@ ${selectionHelp(manifest)}
   --no-open               try: do not open the preview 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 for the service, such as .env.production
+  --env-file <path>       deploy (Railway, Fly.io): production values, such as .env.production
   -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

@@ -43,14 +43,14 @@ export function parseEnvFile(text) {
  * reported as unset; values the service already has count as set.
  */
 export function planVariables(input) {
-    const { modules, keys, url, existing, envFile, secret } = input;
+    const { modules, keys, url, envFile, secret, attached = [] } = input;
+    const existing = { ...input.existing, ...Object.fromEntries(attached.map((key) => [key, "(attached)"])) };
     const reference = (database, variable) => `\${{${database}.${variable}}}`;
-    const provided = {
-        NODE_ENV: "production",
-        PORT: String(appPort),
+    const databases = input.databases ?? {
         DATABASE_URL: reference(railwayDatabases.postgres, "DATABASE_URL"),
         ...(modules.cache === "redis" ? { REDIS_URL: reference(railwayDatabases.redis, "REDIS_URL") } : {}),
     };
+    const provided = { NODE_ENV: "production", PORT: String(appPort), ...databases };
     // The public URL under both names: TanStack Start reads APP_URL, Next.js NEXT_PUBLIC_APP_URL.
     const set = { ...provided, APP_URL: url, NEXT_PUBLIC_APP_URL: url };
     if (modules.auth === "better-auth" && !existing.BETTER_AUTH_SECRET)
@@ -174,3 +174,45 @@ export default defineRailway(() => {
 });
 `;
 }
+/* ------------------------------------ Fly.io ------------------------------------ */
+/** The public URL Fly gives an app. */
+export const flyAppUrl = (app) => `https://${app}.fly.dev`;
+/** A top-level `key = "value"` in fly.toml, which `fly launch` writes (app, primary_region). */
+export function flyTomlValue(toml, key) {
+    for (const line of toml.split(/\r?\n/)) {
+        if (/^\s*\[/.test(line))
+            return null; // top-level keys come before the first table
+        const match = new RegExp(`^\\s*${key}\\s*=\\s*["']([^"']+)["']`).exec(line);
+        if (match)
+            return match[1];
+    }
+    return null;
+}
+/** The Redis URL in `fly redis create` or `fly redis status` output. */
+export function parseRedisUrl(output) {
+    return /\b(rediss?:\/\/[^\s"'`]+)/.exec(output)?.[1] ?? null;
+}
+/** The secret names in `fly secrets list --json`: objects with Name (or name), or a plain list. */
+export function flySecretNames(output) {
+    try {
+        const value = JSON.parse(output);
+        if (!Array.isArray(value))
+            return [];
+        return value
+            .map((item) => (typeof item === "string" ? item : (item?.Name ?? item?.name)))
+            .filter((name) => typeof name === "string");
+    }
+    catch {
+        return [];
+    }
+}
+/** `fly secrets import` input: NAME=VALUE lines. A value with a line break can't be imported this way. */
+export function flySecretsInput(values) {
+    for (const [key, value] of Object.entries(values)) {
+        if (/[\r\n]/.test(value))
+            throw new Error(`${key} has a line break, which Fly's secrets import can't take. Set it with fly secrets set.`);
+    }
+    return Object.entries(values)
+        .map(([key, value]) => `${key}=${value}`)
+        .join("\n");
+}

package/dist/deploy-fly.js

@@ -0,0 +1,167 @@
+// `deploy` for Fly.io (experimental): creates or reuses the app (written to fly.toml), an
+// unmanaged Postgres attached as DATABASE_URL, Upstash Redis with cache redis, sets the secrets,
+// and runs `fly deploy`, which waits for the release command (migrations) and the health checks.
+import { cancel, confirm, isCancel, log, note, outro, spinner } from "@clack/prompts";
+import { randomBytes } from "node:crypto";
+import { readFile } from "node:fs/promises";
+import { join, resolve } from "node:path";
+import process from "node:process";
+import { UsageError } from "./cli/args.js";
+import { bold, dim } from "./cli/ui.js";
+import { exampleKeys, flyAppUrl, flySecretNames, flySecretsInput, flyTomlValue, parseEnvFile, parseRedisUrl, planVariables, serviceName, } from "./core/deploy.js";
+import { spawnCommand } from "./utils/process.js";
+const flyInstallUrl = "https://fly.io/docs/flyctl/install/";
+const flyPricingUrl = "https://fly.io/docs/about/pricing/";
+/** Runs Fly's CLI (a binary, so no shell); values go through stdin. */
+async function fly(command, args, cwd, options = {}) {
+    return await new Promise((resolvePromise, reject) => {
+        const child = spawnCommand(command, args, { cwd, stdio: options.inherit ? "inherit" : ["pipe", "pipe", "pipe"] }, false);
+        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}\n${stderr}`.trim());
+            else
+                reject(new Error(`fly ${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);
+/** Fly's CLI: `fly`, or its other name `flyctl`. */
+async function flyCli(cwd) {
+    for (const name of ["fly", "flyctl"]) {
+        if (await attempt(() => fly(name, ["version"], cwd)))
+            return name;
+    }
+    throw new UsageError(`deploy to Fly.io needs Fly's CLI. Install it (${flyInstallUrl}), then run deploy again.`);
+}
+export async function deployToFly(args, project, cli) {
+    const root = project.root;
+    const tomlPath = join(root, "fly.toml");
+    const toml = await readFile(tomlPath, "utf8").catch(() => "");
+    if (!toml)
+        throw new UsageError(`This project has no fly.toml. Switch with \`${cli} add deploy fly\`.`);
+    const named = flyTomlValue(toml, "app");
+    // Fly app names are global: a new app gets a short random suffix.
+    const app = named ?? `${serviceName(project.identity.packageName)}-${randomBytes(2).toString("hex")}`;
+    const redis = project.modules.cache === "redis";
+    const keys = exampleKeys(await readFile(join(root, ".env.example"), "utf8").catch(() => ""));
+    const envFile = args.envFile ? parseEnvFile(await readFile(resolve(process.cwd(), args.envFile), "utf8")) : {};
+    const secret = () => randomBytes(32).toString("hex");
+    const url = flyAppUrl(app);
+    if (args.dryRun) {
+        const preview = planVariables({ modules: project.modules, keys, url, existing: {}, envFile, secret: () => "<generated>", databases: {}, attached: ["DATABASE_URL", ...(redis ? ["REDIS_URL"] : [])] });
+        log.message([
+            `• Fly app "${app}"${named ? " (from fly.toml)" : ", written to fly.toml"}, at ${url}`,
+            `• Postgres "${app}-db" (unmanaged, one small machine), attached as DATABASE_URL${redis ? `; Upstash Redis "${app}-redis" as REDIS_URL` : ""}`,
+            `• Secrets: ${Object.keys(preview.set).join(", ")}`,
+            ...(preview.unset.length ? [`• Not set: ${preview.unset.join(", ")}`] : []),
+            `• fly deploy, with NEXT_PUBLIC_APP_URL as a build argument: migrations, then health checks`,
+        ].join("\n"));
+        outro("Dry run: nothing was created. Run again without --dry-run to deploy.");
+        return;
+    }
+    note([
+        "This deploys the project to Fly.io, in your Fly account (experimental):",
+        "",
+        `• The app "${app}", a Postgres app "${app}-db" (unmanaged: one shared-cpu-1x machine and a 1 GB volume)${redis ? `, and Upstash Redis "${app}-redis"` : ""}.`,
+        "• The secrets Fly can't provide come from --env-file; the ones still unset are listed before the build.",
+        "• fly deploy builds the Dockerfile, runs the migrations as the release command, and waits for the health checks.",
+        "",
+        `Fly bills these on your plan (${flyPricingUrl}). For Fly's Managed Postgres instead, create it yourself and attach it before deploying.`,
+    ].join("\n"), "Deploy to Fly.io");
+    if (!args.yes) {
+        if (!process.stdin.isTTY)
+            throw new UsageError("deploy creates resources in your Fly 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("Finding Fly's CLI");
+    const flyBin = await flyCli(root);
+    if (!(await attempt(() => fly(flyBin, ["auth", "whoami"], root)))) {
+        progress.stop("Signing in to Fly.io");
+        if (!process.stdin.isTTY)
+            throw new UsageError("Sign in to Fly.io first with `fly auth login`, or set FLY_API_TOKEN.");
+        await fly(flyBin, ["auth", "login"], root, { inherit: true });
+        progress.start("Signed in");
+    }
+    let launched = false;
+    if (!named) {
+        progress.message(`Creating the app "${app}"`);
+        await fly(flyBin, ["launch", "--no-deploy", "--copy-config", "--name", app, "--org", "personal", "--yes", "--no-db", "--no-redis", "--no-object-storage", "--ha=false"], root);
+        launched = true;
+    }
+    const region = flyTomlValue(await readFile(tomlPath, "utf8"), "primary_region");
+    const regionArgs = region ? ["--region", region] : [];
+    const secrets = new Set(flySecretNames((await attempt(() => fly(flyBin, ["secrets", "list", "--app", app, "--json"], root))) ?? ""));
+    const database = `${app}-db`;
+    if (!(await attempt(() => fly(flyBin, ["status", "--app", database], root)))) {
+        progress.message(`Creating Postgres "${database}"`);
+        await fly(flyBin, ["postgres", "create", "--name", database, "--org", "personal", ...regionArgs, "--initial-cluster-size", "1", "--vm-size", "shared-cpu-1x", "--volume-size", "1", "--autostart"], root);
+    }
+    if (!secrets.has("DATABASE_URL")) {
+        progress.message("Attaching Postgres (DATABASE_URL)");
+        await fly(flyBin, ["postgres", "attach", database, "--app", app, "--yes"], root);
+    }
+    let redisUrl = null;
+    if (redis && !secrets.has("REDIS_URL")) {
+        progress.message(`Creating Upstash Redis "${app}-redis"`);
+        redisUrl = parseRedisUrl(await fly(flyBin, ["redis", "create", "--name", `${app}-redis`, "--org", "personal", ...regionArgs, "--no-replicas", "--enable-eviction"], root));
+    }
+    progress.message("Setting the secrets");
+    const plan = planVariables({
+        modules: project.modules,
+        keys,
+        url,
+        existing: Object.fromEntries([...secrets].map((name) => [name, "(set)"])),
+        envFile,
+        secret,
+        databases: redisUrl ? { REDIS_URL: redisUrl } : {},
+        attached: ["DATABASE_URL", ...(redis && !redisUrl && secrets.has("REDIS_URL") ? ["REDIS_URL"] : [])],
+    });
+    // The image sets NODE_ENV and fly.toml the port: the rest are secrets, staged for the deploy.
+    const { NODE_ENV: _node, PORT: _port, ...values } = plan.set;
+    await fly(flyBin, ["secrets", "import", "--app", app, "--stage"], root, { input: flySecretsInput(values) });
+    progress.stop(`Fly.io is ready: ${url}`);
+    if (launched)
+        log.info(`Commit fly.toml: fly launch wrote the app's name ("${app}") and region into it.`);
+    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: pass --env-file, or run fly secrets set.`);
+        if (process.stdin.isTTY && !args.yes) {
+            const proceed = await confirm({ message: "Deploy anyway?", initialValue: true });
+            if (isCancel(proceed) || !proceed) {
+                cancel("Nothing was deployed. Set them, then run deploy again: it reuses everything.");
+                return;
+            }
+        }
+    }
+    log.step("Deploying with fly deploy (build logs follow; the migrations run as the release command)");
+    try {
+        // Next.js compiles the public URL into the build, so it goes in as a build argument too.
+        await fly(flyBin, ["deploy", "--app", app, "--remote-only", "--build-arg", `NEXT_PUBLIC_APP_URL=${url}`], root, { inherit: true });
+    }
+    catch {
+        throw new Error(`The deploy did not finish. Read the logs with \`fly logs --app ${app}\`, fix the cause, and run deploy again: it reuses what exists.`);
+    }
+    note([
+        `${bold("URL")}  ${url}`,
+        `${bold("App")}  ${app}`,
+        ...(plan.unset.length ? ["", `${bold("Not set")}  ${plan.unset.join(", ")}`] : []),
+    ].join("\n"), "Deployed to Fly.io");
+    outro([
+        `${dim("Logs")}   fly logs --app ${app}`,
+        `${dim("Status")} fly status --app ${app}`,
+        `${dim("Again")}  ${cli} deploy   ${dim("(reuses the app; --env-file to add secrets)")}`,
+    ].join("\n"));
+}

package/dist/deploy.js

@@ -12,6 +12,7 @@ import { UsageError } from "./cli/args.js";
 import { bold, dim } from "./cli/ui.js";
 import { appPort, databasesFor, deploymentStatus, exampleKeys, finalStatuses, meetsMinimumCli, minimumRailwayCli, parseDeploymentId, parseEnvFile, parseRailwayDomain, parseVariables, planVariables, railwayCliVersion, railwayDatabases, railwayIacPath, railwayIacSource, serviceName, serviceNames, } from "./core/deploy.js";
 import { readProject } from "./core/project.js";
+import { deployToFly } from "./deploy-fly.js";
 import { cliCommand } from "./modify.js";
 import { resolvePnpm } from "./steps/install.js";
 import { pathExists } from "./utils/fs.js";
@@ -132,8 +133,10 @@ export async function deployProject(args) {
     const project = await readProject(process.cwd());
     const cli = await cliCommand(project);
     const platform = project.modules.deploy ?? "docker";
+    if (platform === "fly")
+        return await deployToFly(args, project, cli);
     if (platform !== "railway") {
-        throw new UsageError(`deploy sets up Railway for now, and this project deploys with "${platform}". Switch with \`${cli} add deploy railway\`, or follow ${deployDocsUrl} for ${platform}.`);
+        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}.`);
     }
     const service = serviceName(project.identity.packageName);
     const databases = databasesFor(project.modules);

package/package.json

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