create-strapi-launchpad 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Paul Bratslavsky
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,82 @@
+# create-strapi-launchpad
+
+Scaffold [LaunchPad](https://github.com/strapi/LaunchPad), Strapi's official
+demo application, with the frontend you want to work in.
+
+```bash
+npx create-strapi-launchpad my-app
+```
+
+That clones LaunchPad, installs it, seeds the demo content, and starts the
+dev servers. With no `--framework` it asks which frontend to run.
+
+## Frontends
+
+LaunchPad ships four frontends against one Strapi backend.
+
+| Frontend       | Flag                         | Port |
+| -------------- | ---------------------------- | ---- |
+| Next.js        | `--framework next` (default) | 3000 |
+| Nuxt 4         | `--framework nuxt`           | 3001 |
+| TanStack Start | `--framework tanstack`       | 3002 |
+| Astro          | `--framework astro`          | 4321 |
+
+Strapi runs on **1337** for all of them.
+
+```bash
+npx create-strapi-launchpad my-app --framework astro
+```
+
+## Options
+
+| Option                   | Description                                          |
+| ------------------------ | ---------------------------------------------------- |
+| `-f, --framework <name>` | Frontend to run. Prompts if omitted.                 |
+| `-r, --ref <ref>`        | Branch or tag of the LaunchPad repo to clone.        |
+| `--no-seed`              | Skip seeding the demo content.                       |
+| `--no-start`             | Set everything up, but do not start the dev servers. |
+| `--no-git`               | Do not initialize a git repository.                  |
+| `--dry-run`              | Print what would happen and exit.                    |
+
+## Requirements
+
+- Node.js 20.19 or newer
+- Git
+
+Yarn is required — LaunchPad pins `yarn@4.5.0` in its root `package.json`, so
+npm and pnpm will not work. If yarn is missing, the CLI enables it through
+Corepack for you.
+
+## What it does
+
+1. Clones LaunchPad (shallow) and removes its history
+2. Initializes a fresh git repository with one commit
+3. `yarn install && yarn setup` — installs every workspace and writes `.env` files
+4. `yarn seed` — imports the demo content into SQLite
+5. `yarn dev` (or `dev:astro`, `dev:nuxt`, `dev:tanstack`)
+
+Use `--dry-run` to see the plan for any combination of flags without touching
+the disk.
+
+## Development
+
+```bash
+npm install
+npm test
+node ./bin/cli.js my-app --dry-run
+```
+
+Frontends are declared in one place, [`src/frameworks.js`](src/frameworks.js).
+
+It has to be a separate copy, because the CLI runs before the repo is cloned.
+That copy can drift, and when it does the CLI checks the wrong port or calls a
+dev script that does not exist. `test/registry-matches-launchpad.test.js`
+reads the real sources — `../scripts/frontends.mts`, the root `package.json`
+scripts and the frontend directories — and fails if they disagree.
+
+That test is why this package lives in the LaunchPad repo rather than its own.
+Run it from the repo root with `yarn test:cli`.
+
+## License
+
+MIT

package/bin/cli.js

@@ -0,0 +1,60 @@
+#!/usr/bin/env node
+import { program } from 'commander';
+import { createRequire } from 'node:module';
+
+import { createLaunchpadApp } from '../src/commands/create.js';
+import { FRAMEWORKS, frameworkNames } from '../src/frameworks.js';
+
+// Read the version from package.json rather than repeating it here, so the
+// two cannot drift.
+const require = createRequire(import.meta.url);
+const { version } = require('../package.json');
+
+const frameworkList = FRAMEWORKS.map(
+  (f) => `    ${f.name.padEnd(9)} ${f.label} (port ${f.port})`
+).join('\n');
+
+program
+  .name('create-strapi-launchpad')
+  .description('Scaffold the official Strapi LaunchPad demo application')
+  .version(version)
+  .argument('[directory]', 'directory to create the project in', 'launchpad')
+  .option(
+    '-f, --framework <name>',
+    `frontend to run (${frameworkNames().join(', ')}) — prompts if omitted`
+  )
+  .option('-r, --ref <ref>', 'branch or tag of the LaunchPad repo to clone')
+  .option(
+    '--repo <url|path>',
+    'clone from somewhere else — a fork, or a local checkout for testing'
+  )
+  .option('--no-seed', 'skip seeding demo data')
+  .option('--no-start', 'skip starting dev servers after setup')
+  .option('--no-git', 'skip initializing a git repository')
+  .option('--dry-run', 'print what would happen without doing it')
+  .addHelpText(
+    'after',
+    `
+Frontends:
+${frameworkList}
+
+Examples:
+  $ create-strapi-launchpad my-app
+  $ create-strapi-launchpad my-app --framework astro
+  $ create-strapi-launchpad my-app --framework nuxt --no-start
+  $ create-strapi-launchpad my-app --dry-run
+  $ create-strapi-launchpad my-app --repo ../LaunchPad --framework nuxt
+
+All frontends share one Strapi backend on port ${1337}.
+`
+  )
+  .action(async (directory, options) => {
+    try {
+      await createLaunchpadApp(directory, options);
+    } catch (error) {
+      console.error(error?.message ?? error);
+      process.exit(1);
+    }
+  });
+
+program.parse();

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "create-strapi-launchpad",
+  "version": "0.1.0",
+  "description": "CLI to scaffold the official Strapi LaunchPad demo application with the frontend of your choice",
+  "type": "module",
+  "bin": {
+    "create-strapi-launchpad": "./bin/cli.js"
+  },
+  "scripts": {
+    "dev": "node ./bin/cli.js",
+    "test": "node --test \"test/**/*.test.js\""
+  },
+  "keywords": [
+    "strapi",
+    "launchpad",
+    "demo",
+    "cli",
+    "scaffold",
+    "astro",
+    "nuxt",
+    "tanstack",
+    "nextjs"
+  ],
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "@clack/prompts": "^1.8.0",
+    "chalk": "^5.4.1",
+    "commander": "^13.1.0",
+    "execa": "^9.5.2",
+    "ora": "^8.2.0"
+  },
+  "engines": {
+    "node": ">=20.19.0"
+  },
+  "files": [
+    "bin",
+    "src",
+    "README.md",
+    "LICENSE"
+  ]
+}

package/src/commands/create.js

@@ -0,0 +1,345 @@
+import * as p from '@clack/prompts';
+import chalk from 'chalk';
+import { execa } from 'execa';
+import fs from 'node:fs';
+import path from 'node:path';
+import ora from 'ora';
+
+import {
+  DEFAULT_FRAMEWORK,
+  FRAMEWORKS,
+  STRAPI_PORT,
+  frameworkNames,
+  getFramework,
+} from '../frameworks.js';
+import { log } from '../utils/logger.js';
+import { isPortAvailable, portOwner } from '../utils/ports.js';
+import { checkPrerequisites } from '../utils/prerequisites.js';
+
+const DEFAULT_REPO = 'https://github.com/strapi/LaunchPad.git';
+
+/**
+ * git treats a local path as a clone source, which is far quicker than going
+ * to GitHub and works offline. `--depth` is ignored for a plain path, so a
+ * local source is rewritten to a file:// URL to keep the clone shallow.
+ */
+function normalizeRepo(repo) {
+  if (!repo) return { url: DEFAULT_REPO, local: false };
+  if (/^[a-z]+:\/\//i.test(repo) || repo.includes('@')) {
+    return { url: repo, local: false };
+  }
+  const abs = path.resolve(process.cwd(), repo);
+  if (!fs.existsSync(path.join(abs, '.git'))) {
+    console.log();
+    log.error(`No git repository at ${abs}`);
+    console.log();
+    process.exit(1);
+  }
+  return { url: `file://${abs}`, local: true };
+}
+
+// LaunchPad pins yarn in its root package.json, so Corepack will refuse any
+// other package manager. There is no point offering a choice.
+const PM = 'yarn';
+
+/**
+ * Which frontend to scaffold.
+ *
+ * All four live on LaunchPad's default branch, so every option works without
+ * a --ref.
+ */
+async function resolveFramework(flag) {
+  if (flag) {
+    const framework = getFramework(flag);
+    if (!framework) {
+      console.log();
+      log.error(
+        `Unknown framework "${flag}". Expected one of: ${frameworkNames().join(', ')}`
+      );
+      console.log();
+      process.exit(1);
+    }
+    return framework;
+  }
+
+  // Not a TTY (CI, piped input) — prompting would hang.
+  if (!process.stdin.isTTY) return getFramework(DEFAULT_FRAMEWORK);
+
+  const choice = await p.select({
+    message: 'Which frontend would you like to run?',
+    options: FRAMEWORKS.map((f) => ({
+      value: f.name,
+      label: f.label,
+      hint: `port ${f.port}`,
+    })),
+    initialValue: DEFAULT_FRAMEWORK,
+  });
+
+  if (p.isCancel(choice)) {
+    p.cancel('Cancelled.');
+    process.exit(0);
+  }
+
+  return getFramework(choice);
+}
+
+/** The frontends present in a cloned LaunchPad tree. */
+function detectFrameworks(targetDir) {
+  return FRAMEWORKS.filter((f) =>
+    fs.existsSync(path.join(targetDir, f.name, 'package.json'))
+  );
+}
+
+/**
+ * Ports the chosen frontend needs, and who currently holds them.
+ *
+ * Reported before anything is cloned. A second LaunchPad checkout left
+ * running is the awkward case: it answers on the right port with its own
+ * PREVIEW_SECRET, so the admin's preview fails with "Invalid token" rather
+ * than anything that points at a port conflict.
+ */
+async function findBlockedPorts(framework) {
+  const wanted = [
+    { port: STRAPI_PORT, label: 'Strapi' },
+    { port: framework.port, label: framework.label },
+  ];
+
+  const blocked = [];
+  for (const { port, label } of wanted) {
+    if (await isPortAvailable(port)) continue;
+    blocked.push({ port, label, owner: await portOwner(port) });
+  }
+  return blocked;
+}
+
+function reportBlockedPorts(blocked) {
+  for (const { port, label, owner } of blocked) {
+    log.warn(`Port ${port} (${label}) is already in use.`);
+    if (owner) console.log(`    held by: ${owner}`);
+  }
+}
+
+function printPlan(targetDir, framework, options, ref, repoUrl) {
+  const steps = [
+    `clone ${repoUrl}${ref ? ` (ref ${ref})` : ''} into ${targetDir}`,
+    options.git ? 'git init' : 'skip git init (--no-git)',
+    `${PM} install && ${PM} setup`,
+    options.seed ? `${PM} seed` : 'skip seed (--no-seed)',
+    options.start
+      ? `${PM} ${framework.devScript}  → Strapi :${STRAPI_PORT}, ${framework.label} :${framework.port}`
+      : 'skip dev start (--no-start)',
+  ];
+
+  console.log();
+  log.info(`Plan for ${chalk.bold(framework.label)}:`);
+  steps.forEach((s, i) => console.log(`  ${chalk.cyan(`${i + 1}.`)} ${s}`));
+  console.log();
+  log.info('Dry run — nothing was changed.');
+  console.log();
+}
+
+export async function createLaunchpadApp(directory, options) {
+  const targetDir = path.resolve(process.cwd(), directory);
+
+  console.log();
+
+  const framework = await resolveFramework(options.framework);
+  const repo = normalizeRepo(options.repo);
+  const ref = options.ref;
+
+  if (options.dryRun) {
+    printPlan(targetDir, framework, options, ref, repo.url);
+    return;
+  }
+
+  log.info(`Creating LaunchPad app in ${targetDir}`);
+  log.info(`Frontend: ${chalk.bold(framework.label)}`);
+
+  // Checked here rather than only before starting, so a conflict surfaces now
+  // instead of after a clone and an install — and so it is still reported when
+  // --no-start means nothing will be started at all.
+  const blockedUpFront = await findBlockedPorts(framework);
+  if (blockedUpFront.length > 0) {
+    console.log();
+    reportBlockedPorts(blockedUpFront);
+    console.log(
+      `    another LaunchPad on that port has its own PREVIEW_SECRET, which makes preview fail with "Invalid token"`
+    );
+  }
+
+  await checkPrerequisites(PM);
+  console.log();
+
+  // Steps vary with the flags, so count them rather than hardcoding a total
+  // that drifts every time one becomes conditional.
+  const stepLabels = [
+    'Cloning LaunchPad repository',
+    'Installing dependencies',
+    options.seed && 'Seeding demo data',
+    options.start ? 'Starting development servers' : 'Finishing up',
+  ].filter(Boolean);
+  const total = stepLabels.length;
+  let step = 0;
+  const nextStep = (msg) => log.step(++step, total, msg);
+
+  // --- Clone ---
+  nextStep('Cloning LaunchPad repository...');
+
+  if (fs.existsSync(targetDir)) {
+    log.error(
+      `Directory "${directory}" already exists. Pick a different name.`
+    );
+    process.exit(1);
+  }
+
+  // LaunchPad is ~54MB, so this takes roughly 20 seconds over the network.
+  // A bare spinner for that long reads as a hang, so the elapsed time is
+  // shown. git's own --progress is not used: it emits thousands of
+  // carriage-return updates that do not collapse when stdout is not a TTY.
+  const started = Date.now();
+  const cloneSpinner = ora('Cloning (about 20s, ~54MB)...').start();
+  const tick = setInterval(() => {
+    const secs = Math.round((Date.now() - started) / 1000);
+    cloneSpinner.text = `Cloning (about 20s, ~54MB)... ${secs}s`;
+  }, 1000);
+
+  try {
+    const args = ['clone', '--depth=1'];
+    if (ref) args.push('--branch', ref);
+    args.push(repo.url, targetDir);
+    await execa('git', args);
+    fs.rmSync(path.join(targetDir, '.git'), { recursive: true, force: true });
+    clearInterval(tick);
+    cloneSpinner.succeed(`Repository cloned${ref ? ` (${ref})` : ''}`);
+  } catch (error) {
+    clearInterval(tick);
+    cloneSpinner.fail('Failed to clone repository');
+    log.error(
+      ref
+        ? `Could not clone ref "${ref}". Check the branch or tag exists.`
+        : error.message
+    );
+    process.exit(1);
+  }
+
+  // Safety net: the ref resolved above should always carry the chosen
+  // frontend, but a stale --ref or a renamed directory would slip through and
+  // fail much later on a dev script that does not exist.
+  const available = detectFrameworks(targetDir);
+  if (!available.some((f) => f.name === framework.name)) {
+    console.log();
+    log.error(
+      `This ref has no ${framework.name}/ directory, so ${framework.label} cannot run.`
+    );
+    console.log(
+      `  Available here: ${available.map((f) => f.name).join(', ') || 'none'}`
+    );
+    if (options.ref)
+      console.log('  Try omitting --ref, or pick a ref that has it.');
+    console.log();
+    process.exit(1);
+  }
+
+  // The clone's history is removed above, so give the user a repo of their own
+  // rather than leaving the directory untracked.
+  if (options.git) {
+    try {
+      await execa('git', ['init', '-q'], { cwd: targetDir });
+      await execa('git', ['add', '-A'], { cwd: targetDir });
+      await execa(
+        'git',
+        ['commit', '-q', '-m', 'Initial commit from create-strapi-launchpad'],
+        { cwd: targetDir }
+      );
+      log.success('Initialized a git repository');
+    } catch {
+      // A missing git identity is the usual cause. Not worth failing the run.
+      log.warn('Could not create the initial commit — continuing');
+    }
+  }
+
+  // --- Install ---
+  nextStep('Installing dependencies...');
+  const installSpinner = ora('Running setup...').start();
+  try {
+    await execa(PM, ['install'], { cwd: targetDir });
+    await execa(PM, ['setup'], { cwd: targetDir });
+
+    // setup writes the shared PREVIEW_SECRET to every frontend, but leaves
+    // CLIENT_URL at its default of Next. Strapi reads CLIENT_URL to build the
+    // admin's Preview link, so without this the Preview button opens Next
+    // whatever frontend was chosen.
+    await execa(PM, ['use', framework.name], { cwd: targetDir });
+
+    installSpinner.succeed('Dependencies installed');
+  } catch (error) {
+    installSpinner.fail('Failed to install dependencies');
+    log.error(error.message);
+    process.exit(1);
+  }
+
+  // --- Seed ---
+  if (options.seed) {
+    nextStep('Seeding demo data...');
+    const seedSpinner = ora('Seeding...').start();
+    try {
+      await execa(PM, ['seed'], { cwd: targetDir });
+      seedSpinner.succeed('Demo data seeded');
+    } catch (error) {
+      seedSpinner.fail('Failed to seed data');
+      log.error(error.message);
+      process.exit(1);
+    }
+  }
+
+  // --- Start ---
+  if (!options.start) {
+    nextStep('Finishing up');
+    console.log();
+    log.success('LaunchPad is ready! To start:');
+    console.log(`\n  cd ${directory}`);
+    console.log(`  ${PM} ${framework.devScript}\n`);
+    return;
+  }
+
+  nextStep('Starting development servers...');
+
+  const blocked = await findBlockedPorts(framework);
+
+  if (blocked.length > 0) {
+    console.log();
+    reportBlockedPorts(blocked);
+    console.log();
+    console.log(
+      '  Either stop whatever is using them, or change the ports in:'
+    );
+    const envPaths = [
+      [`${directory}/strapi/.env`, 'Strapi'],
+      [`${directory}/${framework.name}/.env`, framework.label],
+    ];
+    const width = Math.max(...envPaths.map(([envPath]) => envPath.length));
+    for (const [envPath, label] of envPaths) {
+      console.log(`    ${envPath.padEnd(width)}  → ${label}`);
+    }
+    console.log();
+    console.log('  Then start it yourself:');
+    console.log(`    cd ${directory}`);
+    console.log(`    ${PM} ${framework.devScript}`);
+    console.log();
+    process.exit(1);
+  }
+
+  console.log();
+  log.info(`Strapi admin  → http://localhost:${STRAPI_PORT}/admin`);
+  log.info(`${framework.label} → http://localhost:${framework.port}`);
+  console.log();
+
+  try {
+    await execa(PM, [framework.devScript], {
+      cwd: targetDir,
+      stdio: 'inherit',
+    });
+  } catch {
+    // Ctrl+C is the normal way out of a dev server.
+  }
+}

package/src/frameworks.js

@@ -0,0 +1,35 @@
+/**
+ * The frontends LaunchPad ships.
+ *
+ * This mirrors `scripts/frontends.mts` in the LaunchPad repo. Keep the two in
+ * step: the ports and dev scripts here have to match what that repo actually
+ * runs, or the CLI will check the wrong port and call a script that does not
+ * exist.
+ *
+ * Adding a frontend should be one entry — the prompt, the `--framework`
+ * choices, the port check, the dev command and the help text all read from
+ * this list.
+ */
+export const FRAMEWORKS = [
+  { name: 'next', label: 'Next.js', port: 3000, devScript: 'dev' },
+  { name: 'astro', label: 'Astro', port: 4321, devScript: 'dev:astro' },
+  { name: 'nuxt', label: 'Nuxt 4', port: 3001, devScript: 'dev:nuxt' },
+  {
+    name: 'tanstack',
+    label: 'TanStack Start',
+    port: 3002,
+    devScript: 'dev:tanstack',
+  },
+];
+
+/** Port Strapi listens on. Shared by every frontend. */
+export const STRAPI_PORT = 1337;
+
+/** The frontend used when none is chosen. */
+export const DEFAULT_FRAMEWORK = 'next';
+
+export const frameworkNames = () => FRAMEWORKS.map((f) => f.name);
+
+export function getFramework(name) {
+  return FRAMEWORKS.find((f) => f.name === name) ?? null;
+}

package/src/utils/logger.js

@@ -0,0 +1,10 @@
+import chalk from 'chalk';
+
+export const log = {
+  info: (msg) => console.log(chalk.blue('ℹ'), msg),
+  success: (msg) => console.log(chalk.green('✔'), msg),
+  warn: (msg) => console.log(chalk.yellow('⚠'), msg),
+  error: (msg) => console.error(chalk.red('✖'), msg),
+  step: (step, total, msg) =>
+    console.log(chalk.cyan(`[${step}/${total}]`), msg),
+};

package/src/utils/ports.js

@@ -0,0 +1,78 @@
+import { execa } from 'execa';
+import net from 'node:net';
+
+/**
+ * Whether a port is free.
+ *
+ * This connects rather than binds. Binding looks obvious but is unreliable
+ * here: servers pick different addresses (Strapi takes IPv4 `0.0.0.0`, Astro
+ * takes IPv6 `[::1]`), and on BSD a wildcard bind happily coexists with a
+ * loopback one — so a bind probe reported a busy port as free. If something
+ * accepts a connection, the port is taken, whatever it bound to.
+ */
+function canConnect(port, host, timeout = 400) {
+  return new Promise((resolve) => {
+    const socket = new net.Socket();
+    const done = (result) => {
+      socket.destroy();
+      resolve(result);
+    };
+    socket.setTimeout(timeout);
+    socket.once('connect', () => done(true));
+    socket.once('timeout', () => done(false));
+    socket.once('error', () => done(false));
+    socket.connect(port, host);
+  });
+}
+
+export async function isPortAvailable(port) {
+  const reachable = await Promise.all([
+    canConnect(port, '127.0.0.1'),
+    canConnect(port, '::1'),
+  ]);
+  return !reachable.some(Boolean);
+}
+
+/**
+ * The working directory of whatever is listening on a port, if it can be
+ * determined.
+ *
+ * Knowing a port is busy is much less useful than knowing which project owns
+ * it. Two LaunchPad checkouts each have their own PREVIEW_SECRET, so a
+ * frontend left running from a different one answers the admin's preview
+ * request and fails it with "Invalid token" — a confusing way to discover a
+ * port conflict.
+ *
+ * Best effort: lsof is not available everywhere, and the answer is only a
+ * hint, so any failure returns null rather than interrupting the run.
+ */
+export async function portOwner(port) {
+  try {
+    // -sTCP:LISTEN matters: without it lsof also returns clients *connected*
+    // to the port, and a browser tab's connection would be reported as the
+    // owner.
+    const { stdout: pids } = await execa('lsof', [
+      '-nP',
+      '-tiTCP:' + port,
+      '-sTCP:LISTEN',
+    ]);
+    const pid = pids.split('\n')[0]?.trim();
+    if (!pid) return null;
+
+    const { stdout } = await execa('lsof', [
+      '-a',
+      '-p',
+      pid,
+      '-d',
+      'cwd',
+      '-Fn',
+    ]);
+    const cwd = stdout
+      .split('\n')
+      .find((line) => line.startsWith('n'))
+      ?.slice(1);
+    return cwd ?? null;
+  } catch {
+    return null;
+  }
+}

package/src/utils/prerequisites.js

@@ -0,0 +1,62 @@
+import { execaCommand } from 'execa';
+
+import { log } from './logger.js';
+
+// LaunchPad's frontends need this: Nuxt 4 and Astro 6 both require 20.19+.
+// The old floor of 18 let people through to a confusing failure during install.
+const MIN_NODE = [20, 19, 0];
+
+function parseVersion(version) {
+  return version.split('.').map((n) => parseInt(n, 10));
+}
+
+function isAtLeast(actual, required) {
+  for (let i = 0; i < required.length; i++) {
+    const a = actual[i] ?? 0;
+    if (a > required[i]) return true;
+    if (a < required[i]) return false;
+  }
+  return true;
+}
+
+export async function checkPrerequisites() {
+  const nodeVersion = process.versions.node;
+
+  if (!isAtLeast(parseVersion(nodeVersion), MIN_NODE)) {
+    log.error(
+      `Node.js ${MIN_NODE.join('.')} or higher is required. You are running v${nodeVersion}.`
+    );
+    process.exit(1);
+  }
+  log.success(`Node.js v${nodeVersion}`);
+
+  try {
+    await execaCommand('git --version');
+  } catch {
+    log.error('Git is not installed. Install it and try again.');
+    process.exit(1);
+  }
+
+  // LaunchPad pins yarn@4.5.0 in its root package.json, so this is the only
+  // package manager that will work. Corepack ships with Node and can provide
+  // it without a global install.
+  try {
+    await execaCommand('yarn --version');
+    log.success('Yarn available');
+  } catch {
+    log.warn('Yarn not found — enabling it through corepack...');
+    try {
+      await execaCommand('corepack enable');
+      log.success('Corepack enabled, yarn is now available');
+    } catch {
+      log.error(
+        'Could not enable yarn. Install it manually:\n' +
+          '  corepack enable\n' +
+          '  — or —\n' +
+          '  npm install -g yarn\n\n' +
+          'LaunchPad pins yarn@4.5.0, so npm and pnpm will not work.'
+      );
+      process.exit(1);
+    }
+  }
+}