@clubedge/create-clubedge-app 0.45.0 → 0.46.0

package/dist/modify.js

@@ -1,17 +1,19 @@
 // `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).
+// commit, apps, and modules (base) and the new state (target: other modules or apps, or a newer
+// Starter) are rendered in memory, and the difference is merged into the project (see
+// core/update.ts).
 import { confirm, isCancel, log, multiselect, outro, select, spinner } from "@clack/prompts";
-import { readFile } from "node:fs/promises";
+import { readdir, readFile } from "node:fs/promises";
 import { join } from "node:path";
 import process from "node:process";
 import { UsageError } from "./cli/args.js";
 import { dim } from "./cli/ui.js";
+import { runsServer } from "./core/manifest-fields.js";
 import { readTemplateManifest } from "./core/manifest.js";
 import { compareVersions } from "./core/health.js";
 import { countConflicts } from "./core/merge.js";
 import { describeReleases, fetchReleases, releasesBetween } from "./core/releases.js";
-import { moduleChoices, selectModules, selectStacks } from "./core/plan.js";
+import { moduleChoices, NO_STACK, selectModules, selectStacks, slotChoices, stacksIn } from "./core/plan.js";
 import { readProject } from "./core/project.js";
 import { downloadGitHubTemplate, readDirectoryTemplate, resolveTemplateSource, } from "./core/source.js";
 import { applyUpdate, INCOMING_DIR, planUpdate } from "./core/update.js";
@@ -19,8 +21,27 @@ import { cliVersion, starterPin } from "./package-info.js";
 import { parseEnvFile } from "./core/deploy.js";
 import { describeNewDatabase, projectDatabaseEnv, provisionNeonDatabase } from "./neon.js";
 import { detectPnpm, installDependencies } from "./steps/install.js";
-import { listTemplateFiles } from "./utils/fs.js";
+import { listTemplateFiles, pathExists } from "./utils/fs.js";
 import { commandSucceeds, runCapture } from "./utils/process.js";
+/**
+ * The slots add and remove can fill or empty: those of the apps installed on devices, a shell or a
+ * mobile app, which run no server. The framework and the API are chosen when a project is
+ * created, since its deployment, database, and data are built around them.
+ */
+export function appSlots(manifest) {
+    return Object.keys(manifest.slots).filter((id) => manifest.slots[id].roles.every((role) => !runsServer(role)));
+}
+/** Choices in a sentence: "a", "a or b", or "a, b, or c". */
+const orList = (names) => (names.length > 2 ? `${names.slice(0, -1).join(", ")}, or ${names.at(-1)}` : names.join(" or "));
+/** A slot's name inside a sentence: "the framework", "the mobile app", but "the API". */
+const lowerName = (name) => (/^[A-Z]{2,}$/.test(name) ? name : name.toLowerCase());
+/** The stack a project, or one side of a change, has in a slot, or none. */
+const stackIn = (side, slotId) => side.stacks?.[slotId] ?? NO_STACK;
+/** The stacks of an app slot that fit the project's other apps, for prompts. */
+function addableStacks(manifest, project, slotId) {
+    const { [slotId]: _, ...others } = selectStacks(manifest, project.stacks);
+    return slotChoices(manifest, slotId, others).filter((id) => id !== NO_STACK && id !== stackIn(project, slotId));
+}
 /** How to run the CLI in this project: its `clubedge` script when it has one. */
 export async function cliCommand(project) {
     try {
@@ -100,25 +121,33 @@ export async function completeCommand(manifest, project, command, interactive) {
         return { name: "remove", modules: command.modules };
     if (!interactive) {
         throw new UsageError(command.name === "add"
-            ? "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.");
+            ? "Usage: add <module> <option>, for example: add cache redis, or add mobile expo. Run it in a terminal to choose from a list."
+            : "Usage: remove <module>, for example: remove storage, or remove mobile. Run it in a terminal to choose from a list.");
     }
-    // The modules: named on the command line, or picked from a list (several at once).
+    // The apps and 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 apps = appSlots(manifest).filter((id) => command.name === "add" ? addableStacks(manifest, project, id).length > 0 : stackIn(project, id) !== NO_STACK);
         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.");
+        if (!choices.length && !apps.length)
+            throw new UsageError("Nothing can be removed: every removable module is already none, and the project has no app 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)",
+                ? "What do you want to add or switch? (space to pick, enter to confirm)"
+                : "What do you want to remove? (space to pick, enter to confirm)",
             required: true,
-            options: choices.map(([id, module]) => ({
-                value: id,
-                label: module.name,
-                hint: `now: ${module.options[project.modules[id] ?? ""]?.name ?? project.modules[id] ?? "not set"}`,
-            })),
+            options: [
+                ...apps.map((id) => ({
+                    value: id,
+                    label: manifest.slots[id].name,
+                    hint: `now: ${manifest.stacks[stackIn(project, id)]?.name ?? "none"}`,
+                })),
+                ...choices.map(([id, module]) => ({
+                    value: id,
+                    label: module.name,
+                    hint: `now: ${module.options[project.modules[id] ?? ""]?.name ?? project.modules[id] ?? "not set"}`,
+                })),
+            ],
         });
         if (isCancel(value))
             return null;
@@ -126,8 +155,9 @@ export async function completeCommand(manifest, project, command, interactive) {
     }
     if (command.name === "remove")
         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.
+    // Then an option for each module, or a stack for each app, 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;
@@ -135,6 +165,24 @@ export async function completeCommand(manifest, project, command, interactive) {
             changes.push({ module: moduleId, option: given });
             continue;
         }
+        const slot = appSlots(manifest).includes(moduleId) ? manifest.slots[moduleId] : undefined;
+        if (slot) {
+            // With one stack that fits, there is nothing to ask; with none, the change says why.
+            const stacks = addableStacks(manifest, project, moduleId);
+            if (stacks.length > 1) {
+                const stack = await select({
+                    message: `${slot.name}: which one?`,
+                    options: stacks.map((id) => ({ value: id, label: manifest.stacks[id].name })),
+                });
+                if (isCancel(stack))
+                    return null;
+                changes.push({ module: moduleId, option: stack });
+            }
+            else {
+                changes.push({ module: moduleId, option: stacks[0] ?? stacksIn(manifest, moduleId)[0] ?? NO_STACK });
+            }
+            continue;
+        }
         const module = manifest.modules[moduleId];
         if (!module) {
             throw new UsageError(`Unknown module "${moduleId}". Choose one of: ${Object.keys(manifest.modules).join(", ")}.`);
@@ -157,17 +205,63 @@ export async function completeCommand(manifest, project, command, interactive) {
     return { name: "add", changes };
 }
 /**
- * The selection after add or remove, validated against the Starter's manifest. Every change
- * applies before requirements are checked, so changes that only work together, such as Supabase
- * Auth with Supabase Storage, can be made in one command.
+ * Why a project cannot take the app added to `slotId`, in terms of what it would need: add and
+ * remove never change the framework or the API, so the way there is a new project. Null when
+ * the app fits its role, and the Starter's own rules decide.
  */
-export function changedModules(manifest, project, command, cli) {
-    const changes = command.name === "add" ? command.changes : command.modules.map((module) => ({ module, option: "none" }));
+function appConflict(manifest, stacks, slotId) {
+    const app = manifest.stacks[stacks[slotId] ?? ""];
+    if (!app)
+        return null;
+    const selected = Object.values(selectStacksLoosely(manifest, stacks)).flatMap((id) => manifest.stacks[id] ?? []);
+    const withRole = (role) => selected.find((stack) => stack.role === role);
+    const ids = (role) => Object.keys(manifest.stacks).filter((id) => manifest.stacks[id].role === role);
+    const fixed = "A project's framework and API are chosen when it is created, so add cannot change them";
+    if (app.role === "mobile" && !withRole("api")) {
+        const site = withRole("fullstack");
+        return (`${app.name} calls the project's API, and this project has none${site ? `: ${site.name} serves its own pages` : ""}. ` +
+            `${fixed}: for ${app.name}, create a project with --framework ${orList([...ids("frontend"), NO_STACK])}, and --api ${orList(ids("api"))}.`);
+    }
+    if (app.role === "shell" && !withRole("frontend")) {
+        const site = withRole("fullstack");
+        return (`${app.name} packages a frontend's static files, and ${site ? `${site.name} renders its pages on its server` : "this project has no website"}. ` +
+            `${fixed}: for ${app.name}, create a project with --framework ${orList(ids("frontend"))}.`);
+    }
+    return null;
+}
+/** The stack per slot as recorded, with each empty slot's default, without checking roles. */
+function selectStacksLoosely(manifest, stacks) {
+    return Object.fromEntries(Object.entries(manifest.slots).map(([id, slot]) => [id, stacks[id] ?? slot.default ?? NO_STACK]));
+}
+/**
+ * The apps and modules after add or remove, validated against the Starter's manifest. Every
+ * change applies before requirements are checked, so changes that only work together, such as
+ * Supabase Auth with Supabase Storage, or the native app with an auth it implements, can be made
+ * in one command. `stacks` keeps the project's recorded form, with the changed app slots set.
+ */
+export function changedSelection(manifest, project, command, cli) {
+    const changes = command.name === "add" ? command.changes : command.modules.map((module) => ({ module, option: NO_STACK }));
+    const apps = appSlots(manifest);
+    const stacks = { ...project.stacks };
+    const changedApps = [];
     const requested = { ...project.modules };
     for (const { module: id, option } of changes) {
+        const slot = manifest.slots[id];
+        if (slot) {
+            if (!apps.includes(id)) {
+                throw new UsageError(`The ${lowerName(slot.name)} is chosen when a project is created: add and remove change modules${apps.length ? ` and the apps installed on devices (${apps.join(", ")})` : ""}.`);
+            }
+            const offered = stacksIn(manifest, id);
+            if (option !== NO_STACK && !offered.includes(option)) {
+                throw new UsageError(`Unknown ${lowerName(slot.name)} "${option}". Choose one of: ${offered.join(", ")}.`);
+            }
+            stacks[id] = option;
+            changedApps.push(id);
+            continue;
+        }
         const module = manifest.modules[id];
         if (!module) {
-            throw new UsageError(`Unknown module "${id}". Choose one of: ${Object.keys(manifest.modules).join(", ")}.`);
+            throw new UsageError(`Unknown module "${id}". Choose one of: ${Object.keys(manifest.modules).join(", ")}${apps.length ? `, or an app: ${apps.join(", ")}` : ""}.`);
         }
         if (command.name === "remove" && !module.options.none) {
             const others = Object.keys(module.options).filter((other) => other !== project.modules[id]);
@@ -178,9 +272,30 @@ export function changedModules(manifest, project, command, cli) {
         }
         requested[id] = option;
     }
-    // Validates requirements between modules, such as Supabase Storage needing Supabase Auth, and
-    // that the project's stacks implement the new options.
-    return selectModules(manifest, requested, selectStacks(manifest, project.stacks));
+    // An added app must fit the project's other apps, and implement the modules it uses: a module
+    // option it lacks can be switched in the same command.
+    for (const slotId of changedApps) {
+        const conflict = appConflict(manifest, stacks, slotId);
+        if (conflict)
+            throw new UsageError(conflict);
+        const app = manifest.stacks[stacks[slotId]];
+        for (const [moduleId, implemented] of Object.entries(app?.modules ?? {})) {
+            const option = requested[moduleId];
+            if (option === undefined || implemented.includes(option))
+                continue;
+            const module = manifest.modules[moduleId];
+            throw new UsageError(`${app.name} does not implement ${module.options[option]?.name ?? option} (${moduleId} ${option}). It implements: ${implemented.join(", ")}. ` +
+                `Switch it in the same command, for example: ${cli} add ${slotId} ${stacks[slotId]} ${moduleId} ${implemented.find((id) => id !== NO_STACK) ?? implemented[0]}`);
+        }
+    }
+    // Validates the Starter's rules for the apps, requirements between modules, such as Supabase
+    // Storage needing Supabase Auth, and that the project's stacks implement the new options.
+    const selection = selectStacks(manifest, stacks);
+    return { stacks, modules: selectModules(manifest, requested, selection), apps: changedApps };
+}
+/** The modules after add or remove (see changedSelection). */
+export function changedModules(manifest, project, command, cli) {
+    return changedSelection(manifest, project, command, cli).modules;
 }
 /**
  * The project's selection in a newer Starter. Modules the project predates get their "none"
@@ -219,7 +334,9 @@ function describe(plan) {
         lines.push(`${"update".padEnd(8)} pnpm-lock.yaml`);
     if (plan.lockfile.kind === "install")
         lines.push(`${"install".padEnd(8)} pnpm-lock.yaml ${dim("(pnpm install reconciles your dependency changes)")}`);
-    for (const { path, update: env, changed } of plan.envs) {
+    for (const { path, update: env, changed, create } of plan.envs) {
+        if (create)
+            lines.push(`${"add".padEnd(8)} ${path} ${dim("(from its example)")}`);
         if (!env || !changed)
             continue;
         const parts = [
@@ -227,7 +344,7 @@ function describe(plan) {
             env.updated.length ? `updates ${env.updated.join(", ")}` : "",
             env.removed.length ? `removes ${env.removed.join(", ")}` : "",
         ].filter(Boolean);
-        lines.push(`${"update".padEnd(8)} ${path} ${dim(`(${parts.join("; ")})`)}`);
+        lines.push(`${"update".padEnd(8)} ${path} ${dim(`(${parts.length ? parts.join("; ") : "comments follow the example"})`)}`);
     }
     return lines.join("\n");
 }
@@ -272,9 +389,10 @@ function report(plan) {
             .map((action) => `  ${action.path}: ${action.reason}${action.incoming ? dim(` The Starter's version: ${incoming(action.path)}`) : ""}`)
             .join("\n")}`);
     }
-    for (const { path, update: env } of plan.envs) {
+    for (const { path, update: env, create } of plan.envs) {
         if (!env) {
-            log.info(`${path} does not exist yet; create it from the example file.`);
+            if (!create)
+                log.info(`${path} does not exist yet; create it from the example file.`);
             continue;
         }
         if (env.customized.length) {
@@ -287,17 +405,29 @@ function report(plan) {
 }
 /** Works out what the command changes; resolves null when the project is already there. */
 async function planChange(project, command, base, baseManifest, target, cli) {
-    const baseSide = { source: asRecorded(base, project), manifest: baseManifest, modules: project.modules, cliVersion: project.cliVersion };
+    const baseSide = {
+        source: asRecorded(base, project),
+        manifest: baseManifest,
+        stacks: project.stacks,
+        modules: project.modules,
+        cliVersion: project.cliVersion,
+    };
     if (command.name !== "upgrade") {
-        const modules = changedModules(baseManifest, project, command, cli);
+        const { stacks, modules, apps } = changedSelection(baseManifest, project, command, cli);
+        const changedApps = apps.filter((id) => stackIn({ stacks }, id) !== stackIn(project, id));
         const changed = Object.keys(modules).filter((id) => modules[id] !== project.modules[id]);
-        if (!changed.length)
+        if (!changed.length && !changedApps.length)
             return null;
+        const stackName = (id) => baseManifest.stacks[id]?.name ?? NO_STACK;
         return {
             base: baseSide,
-            target: { ...baseSide, modules, cliVersion },
-            summary: changed.map((id) => `${baseManifest.modules[id].name}: ${project.modules[id]} -> ${modules[id]}`).join(", "),
+            target: { ...baseSide, stacks, modules, cliVersion },
+            summary: [
+                ...changedApps.map((id) => `${baseManifest.slots[id].name}: ${stackName(stackIn(project, id))} -> ${stackName(stackIn({ stacks }, id))}`),
+                ...changed.map((id) => `${baseManifest.modules[id].name}: ${project.modules[id]} -> ${modules[id]}`),
+            ].join(", "),
             notes: [],
+            apps: changedApps,
         };
     }
     if (!target)
@@ -328,10 +458,11 @@ async function planChange(project, command, base, baseManifest, target, cli) {
     }
     return {
         base: baseSide,
-        target: { source: target, manifest: targetManifest, modules, cliVersion },
+        target: { source: target, manifest: targetManifest, stacks: project.stacks, modules, cliVersion },
         summary: `Starter ${project.starterRef} -> ${target.ref}`,
         notes,
         releases,
+        apps: [],
     };
 }
 /**
@@ -360,6 +491,27 @@ async function addNeonDatabase(project, args, cli) {
         log.warn(`${error instanceof Error ? error.message : String(error)} Run \`${cli} neon create\` to try again.`);
     }
 }
+/**
+ * Where an app the change adds is, and what is left of one it removes: the files that were never
+ * the Starter's, such as its env file, its dependencies, or native projects, stay.
+ */
+async function reportApps(project, change) {
+    const { manifest } = change.target;
+    for (const slotId of change.apps) {
+        const slot = manifest.slots[slotId];
+        const stack = manifest.stacks[stackIn(change.target, slotId)];
+        if (stack) {
+            log.info(`${stack.name} is in ${slot.path}, with its settings in ${slot.env.target}. SETUP.md now has the steps to run and build it.`);
+            continue;
+        }
+        const folder = join(project.root, slot.path);
+        const left = (await pathExists(folder)) ? (await readdir(folder)).sort() : [];
+        if (!left.length)
+            continue;
+        const shown = `${left.slice(0, 4).join(", ")}${left.length > 4 ? ", ..." : ""}`;
+        log.info(`${slot.path} still holds what was never the Starter's (${shown}): its settings, dependencies, or native projects. Delete the folder once you no longer need them.`);
+    }
+}
 export async function changeProject(args) {
     const command = args.command;
     if (command.name !== "add" && command.name !== "remove" && command.name !== "upgrade")
@@ -376,7 +528,7 @@ export async function changeProject(args) {
     }
     if (command.name === "add" &&
         command.changes.length > 0 &&
-        command.changes.every((c) => c.option && project.modules[c.module] === c.option)) {
+        command.changes.every((c) => c.option && (project.modules[c.module] ?? project.stacks[c.module]) === c.option)) {
         outro("The project already uses that selection; nothing to change.");
         return "unchanged";
     }
@@ -452,6 +604,7 @@ export async function changeProject(args) {
             log.info("Run `pnpm install` to update dependencies.");
         }
         report(plan);
+        await reportApps(project, change);
         for (const note of change.notes)
             log.info(note);
         if (installError) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clubedge/create-clubedge-app",
-  "version": "0.45.0",
+  "version": "0.46.0",
   "description": "Create React apps from Clubedge Starter with a CLI or local MCP server.",
   "type": "module",
   "packageManager": "pnpm@10.9.0",
@@ -24,8 +24,8 @@
   },
   "clubedge": {
     "starterRepository": "Clubedge/clubedge-starter",
-    "starterRef": "v0.29.0",
-    "starterCommit": "29350332db4bc44acc1e7b989c04825ff4c0f7b7"
+    "starterRef": "v0.30.0",
+    "starterCommit": "4d341955bd13cb170c7385acb745c3d374259897"
   },
   "license": "Apache-2.0",
   "repository": {

package/skills/clubedge-starter/SKILL.md

@@ -43,11 +43,14 @@ Run the CLI from the generated project directory:
 ```sh
 pnpm clubedge add payments stripe
 pnpm clubedge remove storage
+pnpm clubedge add mobile expo
 pnpm clubedge upgrade
 ```
 
 Check the project's Git state first. These commands preserve user edits and can report merge conflicts that need review. After a change, follow the CLI's instructions and run relevant checks, migrations, or service setup for the modules involved.
 
+`add` and `remove` also take the apps installed on devices: the native app (`mobile expo`) and the shell that packages the Vite frontend (`shell capacitor`). The framework and the API stay as the project was created; when the project cannot take an app, the CLI says which project can.
+
 ## Project guidance
 
 - Keep secrets in the project's environment files and never print or commit secret values. With a separate API, the database URLs belong in `apps/api/.env.local`, since the API owns the database.

package/template/.github/workflows/expo-release.yml

@@ -0,0 +1,65 @@
+name: Native app release
+
+# Builds the native app (apps/mobile) in Expo's cloud with EAS Build, signed with the credentials
+# EAS keeps for the project, and can submit the builds to the App Store and Google Play. It needs
+# an EXPO_TOKEN repository secret (expo.dev, Account settings, Access tokens), the app linked to an
+# EAS project with `eas init`, and its signing credentials set up once by an interactive
+# `eas build` or `eas credentials` (SETUP.md, "Store releases").
+on:
+  workflow_dispatch:
+    inputs:
+      platform:
+        description: The stores to build for
+        type: choice
+        options: [all, android, ios]
+        default: all
+      profile:
+        description: The build profile in apps/mobile/eas.json
+        type: choice
+        options: [production, preview]
+        default: production
+      submit:
+        description: Submit production builds to the stores once they are done
+        type: boolean
+        default: false
+
+permissions:
+  contents: read
+
+jobs:
+  build:
+    runs-on: ubuntu-24.04
+    defaults:
+      run:
+        working-directory: apps/mobile
+    steps:
+      - uses: actions/checkout@v7
+        with:
+          persist-credentials: false
+      - uses: pnpm/action-setup@v6
+      - uses: actions/setup-node@v7
+        with:
+          node-version: 22
+          cache: pnpm
+      - run: pnpm install --frozen-lockfile
+      - name: Check the Expo token
+        env:
+          EXPO_TOKEN: ${{ secrets.EXPO_TOKEN }}
+        run: |
+          if [ -z "$EXPO_TOKEN" ]; then
+            echo "::error::Set an EXPO_TOKEN repository secret, from expo.dev (Account settings, Access tokens)."
+            exit 1
+          fi
+      # The builds run in Expo's cloud, with the variables of the profile's EAS environment, such
+      # as EXPO_PUBLIC_API_URL: this job queues them, and expo.dev shows their progress.
+      - name: Queue the builds
+        env:
+          EXPO_TOKEN: ${{ secrets.EXPO_TOKEN }}
+          PLATFORM: ${{ inputs.platform }}
+          PROFILE: ${{ inputs.profile }}
+          SUBMIT: ${{ inputs.submit && inputs.profile == 'production' }}
+        run: |
+          set -euo pipefail
+          args=(build --platform "$PLATFORM" --profile "$PROFILE" --non-interactive --no-wait)
+          if [ "$SUBMIT" = true ]; then args+=(--auto-submit); fi
+          pnpm dlx eas-cli@latest "${args[@]}"

package/template/.github/workflows/expo-update.yml

@@ -0,0 +1,56 @@
+name: Native app update
+
+# Publishes the native app's JavaScript and assets over the air with EAS Update, to the installed
+# apps of the same version on the channel you choose: each build profile in apps/mobile/eas.json
+# names its channel. A change to native code or to app.config.ts needs a store release instead
+# (Native app release). It needs the EXPO_TOKEN secret too (SETUP.md, "Over-the-air updates").
+on:
+  workflow_dispatch:
+    inputs:
+      channel:
+        description: The channel whose builds get the update
+        type: choice
+        options: [production, preview]
+        default: production
+      message:
+        description: What the update changes, as expo.dev shows it
+        type: string
+        required: true
+
+permissions:
+  contents: read
+
+jobs:
+  update:
+    runs-on: ubuntu-24.04
+    defaults:
+      run:
+        working-directory: apps/mobile
+    steps:
+      - uses: actions/checkout@v7
+        with:
+          persist-credentials: false
+      - uses: pnpm/action-setup@v6
+      - uses: actions/setup-node@v7
+        with:
+          node-version: 22
+          cache: pnpm
+      - run: pnpm install --frozen-lockfile
+      - name: Check the Expo token
+        env:
+          EXPO_TOKEN: ${{ secrets.EXPO_TOKEN }}
+        run: |
+          if [ -z "$EXPO_TOKEN" ]; then
+            echo "::error::Set an EXPO_TOKEN repository secret, from expo.dev (Account settings, Access tokens)."
+            exit 1
+          fi
+      # The bundle is built here, with the variables of the channel's EAS environment, such as
+      # EXPO_PUBLIC_API_URL, which it carries as the store builds do.
+      - name: Publish the update
+        env:
+          EXPO_TOKEN: ${{ secrets.EXPO_TOKEN }}
+          CHANNEL: ${{ inputs.channel }}
+          MESSAGE: ${{ inputs.message }}
+        run: |
+          pnpm dlx eas-cli@latest update --channel "$CHANNEL" --environment "$CHANNEL" \
+            --message "$MESSAGE" --non-interactive