@clubedge/create-clubedge-app 0.19.1 → 0.20.0

package/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 All notable changes to `create-clubedge-app` are documented here.
 
+## 0.20.0
+
+- Conflicts are easier to resolve after `add`, `remove`, and `upgrade`:
+  - The Starter's whole new version of each conflicted file is saved in `.clubedge/incoming/<file>`, and the report prints a `git diff --no-index` command to compare it with yours. Files left for you to check by hand get theirs too, when the Starter has one. Git ignores the folder; each change replaces the previous change's files.
+  - Without a module on the command line, the `add` and `remove` menus pick several modules at once; `add` then asks for each one's option, and the changes apply together.
+- Sharing a `try` preview:
+  - When the app is ready, `try` asks whether to share it. Claiming the VM, a free Railway sign-up, is what makes the URL work for anyone, so it opens the claim page. `--claim` does that without asking; scripts are never asked.
+  - The closing message explains Railway's "Access denied" page and prints a port-forward command that opens the app at http://localhost:3000 from any network.
+  - `try --status` shows the last VM's preview, time left, and claim link. It connects only while the VM is running, so it never creates a new one.
+- Release workflow: GitHub Actions on their Node 24 versions, Linux jobs on Ubuntu 24.04, a sturdier wait for npm in the smoke tests, and GitHub Release pages created from this changelog.
+- Still on Starter `v0.15.0`.
+
 ## 0.19.1
 
 - `try` now says who can open the preview as Railway does: until the VM is claimed, only the IP address that created it. Another device on mobile data, a VPN, or anyone you send the link to gets Railway's "Access denied" page; claiming makes the URL shareable.

package/README.md

@@ -136,7 +136,7 @@ pnpm dlx @clubedge/create-clubedge-app my-app --template-dir ../clubedge-starter
 
 ## Change an existing project
 
-Inside a project created by the CLI, `add` and `remove` change modules, and `upgrade` moves the project to a newer Starter release. Projects from Starter v0.8.0 on have a `clubedge` script, so `pnpm clubedge add cache redis` works too. Without a module or option, `add` and `remove` ask for them:
+Inside a project created by the CLI, `add` and `remove` change modules, and `upgrade` moves the project to a newer Starter release. Projects from Starter v0.8.0 on have a `clubedge` script, so `pnpm clubedge add cache redis` works too. Without a module or option, `add` and `remove` ask for them, with a list where you can pick several modules at once:
 
 ```sh
 pnpm clubedge add                                            # choose a module and option from a list
@@ -152,7 +152,7 @@ pnpm dlx @clubedge/create-clubedge-app upgrade --ref v0.15.0 # or a specific tag
 The CLI renders the project twice, from the Starter commit and modules recorded in your `package.json` and from the new state, and merges the difference into your project. The new state has other modules for `add` and `remove`, and the newer Starter with the same modules for `upgrade`. Modules a newer Starter introduces start as `none` where possible, so an upgrade never adds a service on its own.
 
 - Files you never changed are updated, added, or deleted.
-- Files you changed keep your edits. Where the module change touches the same lines, the file gets conflict markers (`<<<<<<< yours` ... `>>>>>>> clubedge`) for you to resolve.
+- Files you changed keep your edits. Where the module change touches the same lines, the file gets conflict markers (`<<<<<<< yours` ... `>>>>>>> clubedge`) for you to resolve. The Starter's whole new version of each such file is saved in `.clubedge/incoming/` to compare with yours (`git diff --no-index <file> .clubedge/incoming/<file>`); Git ignores that folder, so delete it when you are done.
 - Your own files are never touched.
 - `apps/web/.env.local` keeps your values. Values still at their generated defaults follow the new selection, and new variables are added.
 - `pnpm-lock.yaml` is replaced if you never changed your dependencies; otherwise `pnpm install` reconciles it.
@@ -187,14 +187,14 @@ The VM has no Docker, so the project uses `--infra local` (PGlite) and Better Au
 
 Inside a project, `pnpm clubedge try` uploads that project instead, to share work in progress without deploying it. It sends what Git would commit (tracked files, plus untracked ones that are not ignored) and never `.env` files other than examples, `node_modules`, or build output; on the VM, the env file is made from `.env.example` as `create` does. The project must use `infra local` or `none`, and not Supabase Auth; `pnpm clubedge add infra local` switches a Docker project. Add `--dry-run` to list the files without uploading anything.
 
-When the app is ready, the CLI opens the preview in your browser; `--no-open` turns that off. The CLI asks before creating anything (`--yes` agrees), keeps its own SSH key in your config directory (`~/.config/clubedge`, or `%APPDATA%\clubedge` on Windows) apart from `~/.ssh`, and connects only to Railway's known host key. Railway's [terms](https://railway.com/legal/terms) apply, and Railway can change or pause its free VM.
+When the app is ready, the CLI opens the preview in your browser (`--no-open` turns that off) and asks whether to share it: claiming the VM, a free Railway sign-up, is what makes the URL work for anyone. `--claim` opens the claim page without asking. `try --status` shows the last VM's preview, time left, and claim link; it connects only while the VM is running, so it never creates a new one. To open the app from another network yourself, forward it: `ssh -i <key> -N -L 3000:127.0.0.1:3000 railway.new`, then http://localhost:3000 (the CLI prints the exact command). The CLI asks before creating anything (`--yes` agrees), keeps its own SSH key in your config directory (`~/.config/clubedge`, or `%APPDATA%\clubedge` on Windows) apart from `~/.ssh`, and connects only to Railway's known host key. Railway's [terms](https://railway.com/legal/terms) apply, and Railway can change or pause its free VM.
 
 ## Version relationship
 
 Each CLI release is tested against one specific Starter release:
 
 ```text
-create-clubedge-app v0.19.1
+create-clubedge-app v0.20.0
         |
         v
 Clubedge Starter v0.15.0
@@ -205,7 +205,7 @@ The current relationship is:
 
 | CLI release | Default Starter release | Meaning |
 | --- | --- | --- |
-| `create-clubedge-app@0.19.1` | `clubedge-starter@v0.15.0` | The CLI's required, tested default |
+| `create-clubedge-app@0.20.0` | `clubedge-starter@v0.15.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`.
 
@@ -298,6 +298,7 @@ Each phase ends with a Starter release and a CLI release pinned to it. The full
 | 0.17.0 | v0.15.0 | Docs-style dashboard: sidebar with a section switcher and account card, page in a scrolling card, phone drawer |
 | 0.18.0 | v0.15.0 | `try`: a new project on a free, temporary Railway VM, with a preview URL and a claim link (experimental) |
 | 0.19.0 | v0.15.0 | `pnpm clubedge try` uploads an existing project to the VM; the preview opens in the browser |
+| 0.20.0 | v0.15.0 | The Starter's version of each conflicted file in `.clubedge/incoming/`, several modules at once, sharing a `try` preview by claiming the VM, `try --status` |
 | next | | Show the Starter's version of a conflicted file next to yours |
 
 ## Community

package/dist/cli/args.js

@@ -14,6 +14,8 @@ const OPTIONS = {
     force: { type: "boolean", default: false },
     services: { type: "boolean", default: true },
     open: { type: "boolean", default: true },
+    claim: { type: "boolean", default: false },
+    status: { type: "boolean", default: false },
     help: { type: "boolean", short: "h", default: false },
     version: { type: "boolean", short: "v", default: false },
 };
@@ -87,6 +89,9 @@ export function parseCliArgs(argv) {
     if (!creates && command.name !== "upgrade" && values.ref !== undefined) {
         throw new UsageError("--ref only applies when creating or upgrading a project.");
     }
+    if (command.name !== "try" && (values.claim || values.status)) {
+        throw new UsageError("--claim and --status only apply to try.");
+    }
     if (command.name === "try" && values["template-dir"] !== undefined) {
         throw new UsageError("--template-dir does not apply to try: the VM downloads the Starter itself.");
     }
@@ -113,6 +118,8 @@ export function parseCliArgs(argv) {
         force: values.force,
         services: values.services,
         open: values.open,
+        claim: values.claim,
+        status: values.status,
         help: values.help,
         version: values.version,
     };

package/dist/cli/ui.js

@@ -124,6 +124,8 @@ ${selectionHelp(manifest)}
   --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
+  --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
   -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/merge.js

@@ -53,9 +53,11 @@ export function mergeText(current, base, target) {
 function merged(path, current, base, target, binaryReason) {
     const result = mergeText(current, base, target);
     if (!result)
-        return { path, kind: "keep", reason: binaryReason };
+        return { path, kind: "keep", reason: binaryReason, incoming: target };
     const content = withLineEndings(result.text, current);
-    return { path, kind: result.conflict ? "conflict" : "merge", content };
+    if (result.conflict)
+        return { path, kind: "conflict", content, incoming: withLineEndings(normalize(target), current) };
+    return { path, kind: "merge", content };
 }
 /**
  * Decides what happens to every file the base or the target contains. Files only the project
@@ -89,7 +91,12 @@ export function planMerge(base, target, current) {
         }
         if (before && after) {
             if (!mine) {
-                actions.push({ path, kind: "keep", reason: "You deleted this file, and the new selection changes it. Restore it if you need the change." });
+                actions.push({
+                    path,
+                    kind: "keep",
+                    reason: "You deleted this file, and the new selection changes it. Restore it if you need the change.",
+                    incoming: after,
+                });
             }
             else if (sameContent(mine, before)) {
                 const content = isBinary(after) ? after : withLineEndings(normalize(after), mine);

package/dist/core/railway.js

@@ -1,6 +1,6 @@
 import { createHash } from "node:crypto";
 import { homedir } from "node:os";
-import { join } from "node:path";
+import { dirname, join } from "node:path";
 import process from "node:process";
 import { UsageError } from "../cli/args.js";
 /*
@@ -61,6 +61,27 @@ export function railwayKeyPath(env = process.env, platform = process.platform) {
     const configHome = env.XDG_CONFIG_HOME || (platform === "win32" && env.APPDATA ? env.APPDATA : join(homedir(), ".config"));
     return join(configHome, "clubedge", "railway_ed25519");
 }
+/** Saved next to the CLI's key, in its config directory. */
+export function lastVmPath(env = process.env, platform = process.platform) {
+    return join(dirname(railwayKeyPath(env, platform)), "railway-vm.json");
+}
+/** Railway keeps an unclaimed VM claimable for 24 hours after its build window. */
+export const claimWindowMs = 24 * 60 * 60 * 1000;
+/**
+ * Where a VM stands: running (inside its 60 minutes), claimable (past them, still claimable), or
+ * gone. Connecting to a VM that is gone would create a new one, so status never does.
+ */
+export function vmPhase(vm, now = new Date()) {
+    const expires = new Date(vm.expiresAt).getTime();
+    const claimUntil = new Date(expires + claimWindowMs);
+    const minutesLeft = Math.max(0, Math.round((expires - now.getTime()) / 60_000));
+    const phase = now.getTime() < expires ? "running" : now.getTime() < claimUntil.getTime() ? "claimable" : "gone";
+    return { phase, minutesLeft, claimUntil };
+}
+/** A local port forward to the app on the VM: works from this machine whatever its IP, nothing shared. */
+export function portForwardCommand(keyPath) {
+    return `ssh -i "${keyPath}" -N -L 3000:127.0.0.1:3000 ${railwayHost}`;
+}
 /**
  * The modules for a project on the VM. It has no Docker, so the database is PGlite (--infra
  * local) and sign-in is Better Auth; email is off, since nothing there receives it. Flags the

package/dist/core/update.js

@@ -7,6 +7,11 @@ import { updateEnvFile } from "./env.js";
 import { planMerge, sameContent } from "./merge.js";
 import { readProjectFiles, renderProject } from "./project.js";
 const LOCKFILE = "pnpm-lock.yaml";
+/**
+ * Where the Starter's versions of files left to resolve are saved, next to the project's own,
+ * for comparing by hand. The folder ignores itself, so it never shows in git status or a commit.
+ */
+export const INCOMING_DIR = ".clubedge/incoming";
 export async function planUpdate(project, base, target) {
     const render = (side) => renderProject({
         source: side.source,
@@ -64,8 +69,28 @@ async function removeEmptyFolders(root, path) {
         folder = dirname(folder);
     }
 }
+/** The Starter's version of each file left for you: conflicts, and kept files it has a version of. */
+export function incomingFiles(plan) {
+    return plan.actions.flatMap((action) => (action.kind === "conflict" || action.kind === "keep") && action.incoming ? [{ path: action.path, content: action.incoming }] : []);
+}
+/** Replaces the previous change's incoming files with this change's. */
+async function writeIncoming(plan) {
+    const folder = join(plan.project.root, INCOMING_DIR);
+    await rm(folder, { recursive: true, force: true });
+    const files = incomingFiles(plan);
+    if (!files.length)
+        return;
+    await mkdir(dirname(folder), { recursive: true });
+    await writeFile(join(dirname(folder), ".gitignore"), "# Written by create-clubedge-app: the Starter's versions of files to compare. Delete when done.\n*\n");
+    for (const file of files) {
+        const path = join(folder, file.path);
+        await mkdir(dirname(path), { recursive: true });
+        await writeFile(path, file.content);
+    }
+}
 export async function applyUpdate(plan) {
     const { root } = plan.project;
+    await writeIncoming(plan);
     for (const action of plan.actions) {
         const path = join(root, action.path);
         if (action.kind === "delete") {

package/dist/modify.js

@@ -1,7 +1,7 @@
 // `add`, `remove`, and `upgrade` change an existing project. The project's recorded Starter
 // commit and modules (base) and the new state (target: other modules, or a newer Starter) are
 // rendered in memory, and the difference is merged into the project (see core/update.ts).
-import { confirm, isCancel, log, outro, select, spinner } from "@clack/prompts";
+import { confirm, isCancel, log, multiselect, outro, select, spinner } from "@clack/prompts";
 import { readFile } from "node:fs/promises";
 import { join } from "node:path";
 import process from "node:process";
@@ -14,7 +14,7 @@ import { describeReleases, fetchReleases, releasesBetween } from "./core/release
 import { selectModules } from "./core/plan.js";
 import { readProject } from "./core/project.js";
 import { downloadGitHubTemplate, readDirectoryTemplate, resolveTemplateSource, } from "./core/source.js";
-import { applyUpdate, planUpdate } from "./core/update.js";
+import { applyUpdate, INCOMING_DIR, planUpdate } from "./core/update.js";
 import { cliVersion, starterPin } from "./package-info.js";
 import { installDependencies, resolvePnpm } from "./steps/install.js";
 import { commandSucceeds, runCapture } from "./utils/process.js";
@@ -99,13 +99,17 @@ export async function completeCommand(manifest, project, command, interactive) {
             ? "Usage: add <module> <option>, for example: add cache redis. Run it in a terminal to choose from a list."
             : "Usage: remove <module>, for example: remove storage. Run it in a terminal to choose from a list.");
     }
-    let moduleId = command.name === "add" ? command.changes[0]?.module : undefined;
-    if (!moduleId) {
+    // The modules: named on the command line, or picked from a list (several at once).
+    let moduleIds = command.name === "add" ? command.changes.map((change) => change.module) : [];
+    if (!moduleIds.length) {
         const choices = Object.entries(manifest.modules).filter(([id, module]) => command.name === "add" ? true : Boolean(module.options.none) && project.modules[id] !== "none");
         if (!choices.length)
             throw new UsageError("No module can be removed: every removable module is already none.");
-        const value = await select({
-            message: command.name === "add" ? "Which module do you want to add or switch?" : "Which module do you want to remove?",
+        const value = await multiselect({
+            message: command.name === "add"
+                ? "Which modules do you want to add or switch? (space to pick, enter to confirm)"
+                : "Which modules do you want to remove? (space to pick, enter to confirm)",
+            required: true,
             options: choices.map(([id, module]) => ({
                 value: id,
                 label: module.name,
@@ -114,28 +118,39 @@ export async function completeCommand(manifest, project, command, interactive) {
         });
         if (isCancel(value))
             return null;
-        moduleId = value;
+        moduleIds = value;
     }
     if (command.name === "remove")
-        return { name: "remove", modules: [moduleId] };
-    const module = manifest.modules[moduleId];
-    if (!module) {
-        throw new UsageError(`Unknown module "${moduleId}". Choose one of: ${Object.keys(manifest.modules).join(", ")}.`);
+        return { name: "remove", modules: moduleIds };
+    // Then an option for each module that was not given one. They apply together, so options that
+    // only work together (Supabase Auth with Supabase Storage) can be picked in one go.
+    const changes = [];
+    for (const moduleId of moduleIds) {
+        const given = command.changes.find((change) => change.module === moduleId)?.option;
+        if (given) {
+            changes.push({ module: moduleId, option: given });
+            continue;
+        }
+        const module = manifest.modules[moduleId];
+        if (!module) {
+            throw new UsageError(`Unknown module "${moduleId}". Choose one of: ${Object.keys(manifest.modules).join(", ")}.`);
+        }
+        const options = Object.keys(module.options).filter((id) => id !== project.modules[moduleId] && (moduleIds.length > 1 || available(manifest, project, moduleId, id)));
+        if (!options.length)
+            throw new UsageError(`${module.name} has no other option this project can use.`);
+        const option = await select({
+            message: `${module.name}: which option?`,
+            options: options.map((id) => ({
+                value: id,
+                label: module.options[id].name,
+                ...(id === module.default ? { hint: "default" } : {}),
+            })),
+        });
+        if (isCancel(option))
+            return null;
+        changes.push({ module: moduleId, option });
     }
-    const options = Object.keys(module.options).filter((id) => id !== project.modules[moduleId] && available(manifest, project, moduleId, id));
-    if (!options.length)
-        throw new UsageError(`${module.name} has no other option this project can use.`);
-    const option = await select({
-        message: `${module.name}: which option?`,
-        options: options.map((id) => ({
-            value: id,
-            label: module.options[id].name,
-            ...(id === module.default ? { hint: "default" } : {}),
-        })),
-    });
-    if (isCancel(option))
-        return null;
-    return { name: "add", changes: [{ module: moduleId, option }] };
+    return { name: "add", changes };
 }
 /**
  * The selection after add or remove, validated against the Starter's manifest. Every change
@@ -213,17 +228,24 @@ function describe(plan) {
 function report(plan) {
     const conflicts = plan.actions.filter((action) => action.kind === "conflict");
     const kept = plan.actions.filter((action) => action.kind === "keep");
+    const incoming = (path) => `${INCOMING_DIR}/${path}`;
     if (conflicts.length) {
         const blocks = conflicts.map((action) => countConflicts(action.content));
         const total = blocks.reduce((sum, count) => sum + count, 0);
+        const first = conflicts[0].path;
         log.warn(`Resolve ${total} ${total === 1 ? "conflict" : "conflicts"} in ${conflicts.length} ${conflicts.length === 1 ? "file" : "files"}. ` +
             "Each is marked <<<<<<< yours ... ======= ... >>>>>>> clubedge: keep your lines, the Starter's, or a mix, then delete the markers.\n" +
             conflicts
                 .map((action, i) => `  ${action.path} ${dim(`(${blocks[i]} ${blocks[i] === 1 ? "block" : "blocks"})`)}`)
-                .join("\n"));
+                .join("\n") +
+            `\n\nThe Starter's whole new version of each is in ${INCOMING_DIR}/, to compare with yours:\n` +
+            `  git diff --no-index ${first} ${incoming(first)}\n` +
+            dim(`Git ignores ${INCOMING_DIR.split("/")[0]}/; delete it when you are done.`));
     }
     if (kept.length) {
-        log.info(`Check these files by hand:\n${kept.map((action) => `  ${action.path}: ${action.reason}`).join("\n")}`);
+        log.info(`Check these files by hand:\n${kept
+            .map((action) => `  ${action.path}: ${action.reason}${action.incoming ? dim(` The Starter's version: ${incoming(action.path)}`) : ""}`)
+            .join("\n")}`);
     }
     if (plan.env && !plan.env.update) {
         log.info(`${plan.env.path} does not exist yet; create it from the example file.`);

package/dist/try.js

@@ -1,4 +1,4 @@
-import { cancel, confirm, isCancel, log, note, outro, spinner } from "@clack/prompts";
+import { cancel, confirm, isCancel, log, note, outro, select, spinner } from "@clack/prompts";
 import { chmod, mkdir, readFile, writeFile } from "node:fs/promises";
 import { userInfo } from "node:os";
 import { dirname } from "node:path";
@@ -6,7 +6,7 @@ import process from "node:process";
 import ssh2 from "ssh2";
 import { UsageError } from "./cli/args.js";
 import { bold, dim } from "./cli/ui.js";
-import { hostKeyFingerprint, parseRailwayStatus, projectTryProblem, proxySource, railwayFreeVmUrl, railwayHost, railwayKeyPath, railwayTermsUrl, remoteArchivePath, remoteDevLog, remoteLog, remoteName, remoteProxyPath, remoteScriptPath, shellQuote, trustedHostKeys, tryCreateArgs, tryModules, tryScript, } from "./core/railway.js";
+import { hostKeyFingerprint, lastVmPath, portForwardCommand, parseRailwayStatus, projectTryProblem, proxySource, railwayFreeVmUrl, railwayHost, railwayKeyPath, railwayTermsUrl, remoteArchivePath, remoteDevLog, remoteLog, remoteName, remoteProxyPath, remoteScriptPath, shellQuote, trustedHostKeys, tryCreateArgs, tryModules, tryScript, vmPhase, } from "./core/railway.js";
 import { ProjectError, readProject } from "./core/project.js";
 import { uploadableFiles } from "./core/upload.js";
 import { cliVersion } from "./package-info.js";
@@ -177,7 +177,94 @@ async function agree(args, keyPath, what) {
     const answer = await confirm({ message: "Create the VM?", initialValue: true });
     return !isCancel(answer) && answer;
 }
+async function saveLastVm(vm) {
+    const path = lastVmPath();
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(path, `${JSON.stringify(vm, null, 2)}\n`);
+}
+async function readLastVm() {
+    try {
+        return JSON.parse(await readFile(lastVmPath(), "utf8"));
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Claiming moves the VM into a Railway account, which is what makes the preview shareable: offer
+ * it at a terminal, or open it straight away with --claim. Nothing happens in scripts without it.
+ */
+async function offerClaim(args, atTerminal, claimUrl) {
+    let claim = args.claim;
+    if (!claim && atTerminal && !args.yes) {
+        const answer = await select({
+            message: "Share the preview with others?",
+            initialValue: "later",
+            options: [
+                { value: "later", label: "Not now", hint: "only you can open it, from this connection" },
+                { value: "claim", label: "Claim the VM", hint: "free Railway sign-up; then the URL works for anyone" },
+            ],
+        });
+        claim = !isCancel(answer) && answer === "claim";
+    }
+    if (!claim)
+        return;
+    if (atTerminal && (await openUrl(claimUrl)))
+        log.info("Opened the claim page. Sign up, pick a workspace, and the VM, its files, and its URL move to your account.");
+    else
+        log.info(`Claim the VM here: ${claimUrl}`);
+}
+/**
+ * The last VM, from what the CLI saved: its preview, time left, and claim link. It connects only
+ * while the VM is inside its 60 minutes, since connecting to a VM that is gone creates a new one.
+ */
+async function showStatus(keyPath) {
+    const last = await readLastVm();
+    if (!last) {
+        outro("No VM yet. Run try to create one.");
+        return;
+    }
+    const { phase, minutesLeft: left, claimUntil } = vmPhase(last);
+    if (phase === "gone") {
+        outro(`The last VM is gone: its claim window ended ${claimUntil.toLocaleString()}. Run try to create a new one.`);
+        return;
+    }
+    let app = dim("not checked");
+    if (phase === "running") {
+        const progress = spinner();
+        progress.start("Checking the app on the VM");
+        try {
+            const connection = await connect(await readFile(keyPath, "utf8"));
+            try {
+                const { stdout } = await exec(connection, "curl -s -o /dev/null -w '%{http_code}' http://127.0.0.1:3000/ || true");
+                app = /^[1-4]\d\d$/.test(stdout.trim()) ? "running" : "not answering";
+            }
+            finally {
+                connection.end();
+            }
+            progress.stop("Checked the app");
+        }
+        catch (error) {
+            progress.stop("Could not reach the VM");
+            app = dim(error instanceof Error ? error.message : String(error));
+        }
+    }
+    note([
+        `${bold("Preview")}  ${last.previewUrl}`,
+        `${bold("Project")}  ${last.directory}`,
+        `${bold("App")}      ${phase === "running" ? app : "stopped: the 60 minutes are over"}`,
+        phase === "running"
+            ? `${bold("Time")}     ${left} minutes left (until ${new Date(last.expiresAt).toLocaleTimeString()})`
+            : `${bold("Time")}     claimable until ${claimUntil.toLocaleString()}`,
+        `${bold("Claim")}    ${last.claimUrl}`,
+    ].join("\n"), "Your VM on Railway");
+    outro(phase === "running"
+        ? "Until you claim the VM, only this IP address can open the preview. Claim it to share the URL."
+        : "Claim the VM to keep it: its files and URL move to your Railway account.");
+}
 export async function tryOnRailway(args) {
+    if (args.status)
+        return await showStatus(railwayKeyPath());
     const what = await plan(args);
     const keyPath = railwayKeyPath();
     if (args.dryRun) {
@@ -255,14 +342,19 @@ export async function tryOnRailway(args) {
             `${bold("Claim")}    ${vm.claimUrl}`,
         ].join("\n"), "Your app on Railway");
         log.warn("Keep the claim link private: whoever opens it takes over the VM, its files, and its URL.");
-        // Only for a person at a terminal: scripts and CI get the URL above, and nothing opens.
-        if (args.open && process.stdout.isTTY && (await openUrl(vm.previewUrl)))
+        await saveLastVm({ previewUrl: vm.previewUrl, claimUrl: vm.claimUrl, expiresAt: vm.expiresAt.toISOString(), directory: `/app/${directory}` });
+        // Only for a person at a terminal: scripts and CI get the URLs above, and nothing opens.
+        const atTerminal = Boolean(process.stdin.isTTY && process.stdout.isTTY);
+        if (args.open && atTerminal && (await openUrl(vm.previewUrl)))
             log.info("Opened the preview in your browser.");
+        await offerClaim(args, atTerminal, vm.claimUrl);
         outro([
-            "Until you claim the VM, the preview opens only from the IP address that created it. Claiming moves it to your Railway account and makes the URL shareable.",
+            "Until you claim the VM, only you can open the preview, from the IP address that created it. Another device on mobile data, a VPN, or anyone you send it to gets Railway's \"Access denied\" page. Claiming makes the URL shareable.",
             "",
-            `${dim("Shell")}  ssh -i "${keyPath}" ${railwayHost}`,
-            `${dim("Logs")}   ssh -i "${keyPath}" ${railwayHost} tail -f ${remoteDevLog}`,
+            `${dim("Status")}   ${dim("pnpm dlx @clubedge/create-clubedge-app try --status")}`,
+            `${dim("Local")}    ${portForwardCommand(keyPath)}  ${dim("then http://localhost:3000, from any network")}`,
+            `${dim("Shell")}    ssh -i "${keyPath}" ${railwayHost}`,
+            `${dim("Logs")}     ssh -i "${keyPath}" ${railwayHost} tail -f ${remoteDevLog}`,
         ].join("\n"));
     }
     catch (error) {

package/package.json

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