@basaltkit/cli 1.6.0 → 1.7.0

package/README.md

@@ -41,6 +41,10 @@ app's, at its pinned versions. Arguments and the exit code pass through
 unchanged. Outside an app it says so and exits 1. The launcher loads nothing of
 the framework, only Node built-ins.
 
+`basalt new <name> [flags]` is the launcher's own command: it scaffolds an app
+with `create-basalt@latest` (through `pnpm dlx`, else `npx`; `--pm=` picks the
+manager), so it always gets the latest scaffolder.
+
 ## Get started in 5 minutes
 
 1. Create a `bin/basalt.ts` file at the root of the project — this will be the entry point for the `basalt` command:

package/dist/launcher.d.ts

@@ -7,6 +7,10 @@
  * app's own package manager — so the code that runs is always the app's, at
  * the versions its lockfile pins, never the launcher's. Node built-ins only:
  * nothing of the framework is loaded.
+ *
+ * One command is the launcher's own: `basalt new <name> [flags]` scaffolds an
+ * app through `create-basalt@latest` (`pnpm dlx`, else `npx`) — the latest
+ * scaffolder, whatever version the launcher is.
  */
 export type PackageManager = 'pnpm' | 'npm' | 'yarn' | 'bun';
 export interface LauncherProject {
@@ -41,6 +45,17 @@ export interface RunLauncherOptions {
     /** Where the launcher's own lines go (never the app's output). */
     error?: (line: string) => void;
     log?: (line: string) => void;
+    /** Whether pnpm is installed — what `basalt new` runs create-basalt with. Default: `pnpm --version` answers. */
+    hasPnpm?: () => boolean;
 }
+/**
+ * How `basalt new` runs `create-basalt@latest`: through the manager `--pm=`
+ * names, else pnpm when it is installed, else npx. create-basalt reads the
+ * manager it was started with, so the new app uses the same one.
+ */
+export declare function scaffoldCommand(args: readonly string[], hasPnpm: () => boolean): {
+    command: string;
+    args: string[];
+};
 /** Runs `basalt <argv>`: the app's `basalt` script, through the app's package manager. Resolves to the exit code. */
 export declare function runLauncher(argv: readonly string[], options?: RunLauncherOptions): Promise<number>;

package/dist/launcher.js

@@ -7,8 +7,12 @@
  * app's own package manager — so the code that runs is always the app's, at
  * the versions its lockfile pins, never the launcher's. Node built-ins only:
  * nothing of the framework is loaded.
+ *
+ * One command is the launcher's own: `basalt new <name> [flags]` scaffolds an
+ * app through `create-basalt@latest` (`pnpm dlx`, else `npx`) — the latest
+ * scaffolder, whatever version the launcher is.
  */
-import { spawn } from 'node:child_process';
+import { spawn, spawnSync } from 'node:child_process';
 import { existsSync, readFileSync } from 'node:fs';
 import { dirname, join, resolve } from 'node:path';
 /** Set on the script's environment: a `basalt` script that calls `basalt` again would loop. */
@@ -93,9 +97,24 @@ function launcherVersion() {
         return 'unknown';
     }
 }
+/**
+ * How `basalt new` runs `create-basalt@latest`: through the manager `--pm=`
+ * names, else pnpm when it is installed, else npx. create-basalt reads the
+ * manager it was started with, so the new app uses the same one.
+ */
+export function scaffoldCommand(args, hasPnpm) {
+    const pm = args.find((arg) => arg.startsWith('--pm='))?.slice('--pm='.length);
+    const pkg = 'create-basalt@latest';
+    if (pm === 'pnpm' || (pm === undefined && hasPnpm()))
+        return { command: 'pnpm', args: ['--silent', 'dlx', pkg, ...args] };
+    if (pm === 'bun')
+        return { command: 'bunx', args: [pkg, ...args] };
+    return { command: 'npx', args: ['--yes', pkg, ...args] }; // npm, and yarn (create-basalt honours --pm=yarn)
+}
+const pnpmInstalled = () => spawnSync('pnpm', ['--version'], { stdio: 'ignore', shell: process.platform === 'win32' }).status === 0;
 const NOT_AN_APP = [
     'basalt: no Basalt app here — no package.json with a "basalt" script in this directory or above it.',
-    '  Start one:   npm create basalt@latest my-app',
+    '  Start one:   basalt new my-app',
     '  Or cd into an app first; `basalt <command>` then runs `<pm> basalt <command>` there.',
 ];
 /** Runs `basalt <argv>`: the app's `basalt` script, through the app's package manager. Resolves to the exit code. */
@@ -104,6 +123,11 @@ export async function runLauncher(argv, options = {}) {
     const env = options.env ?? process.env;
     const error = options.error ?? ((line) => process.stderr.write(`${line}\n`));
     const log = options.log ?? ((line) => process.stdout.write(`${line}\n`));
+    // The launcher's own command, inside an app too: a new app is never the current one's business.
+    if (argv[0] === 'new') {
+        const scaffold = scaffoldCommand(argv.slice(1), options.hasPnpm ?? pnpmInstalled);
+        return spawnAndWait(scaffold.command, scaffold.args, { cwd, env, error, what: 'create a new app' });
+    }
     const project = findProject(cwd);
     if (!project) {
         if (argv[0] === '--version' || argv[0] === '-v') {
@@ -120,14 +144,24 @@ export async function runLauncher(argv, options = {}) {
         return 1;
     }
     const { command, args } = launchCommand(project.pm, argv);
+    return spawnAndWait(command, args, {
+        cwd: project.root,
+        env: { ...env, [LAUNCHER_ENV]: project.root },
+        error,
+        what: `run this app's basalt script (${project.root})`,
+    });
+}
+/** Runs one command with the terminal attached; resolves to its exit code. */
+function spawnAndWait(command, args, options) {
+    const { error } = options;
     return new Promise((done) => {
         const child = spawn(command, args, {
-            cwd: project.root,
-            env: { ...env, [LAUNCHER_ENV]: project.root },
+            cwd: options.cwd,
+            env: options.env,
             stdio: 'inherit',
             shell: process.platform === 'win32',
         });
-        // Ctrl-C reaches the whole foreground group: the app handles it; the
+        // Ctrl-C reaches the whole foreground group: the child handles it; the
         // launcher only waits for it to finish and reports its code.
         const ignore = () => { };
         const signals = ['SIGINT', 'SIGTERM', 'SIGHUP'];
@@ -140,7 +174,7 @@ export async function runLauncher(argv, options = {}) {
         };
         child.on('error', (cause) => {
             error(cause.code === 'ENOENT'
-                ? `basalt: ${command} is not installed, and this app uses it (${project.root}).`
+                ? `basalt: ${command} is not installed, and it is needed to ${options.what}.`
                 : `basalt: could not start ${command}: ${cause.message}`);
             settle(1);
         });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@basaltkit/cli",
-  "version": "1.6.0",
+  "version": "1.7.0",
   "engines": {
     "node": ">=22.5.0"
   },