@amxts/cli 0.2.0 → 0.3.0

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@amxts/cli",
 	"type": "module",
-	"version": "0.2.0",
+	"version": "0.3.0",
 	"description": "The amxts command: create a project or a module, add modules, build, deploy, type-check and test",
 	"author": {
 		"name": "kukson777",

package/src/core.mjs

@@ -9,14 +9,14 @@
 //
 // Creating a project or a module needs no core: they run on their own.
 // `--local` takes the core from this machine instead of npm (localCore()).
-import { spawnSync } from 'node:child_process';
+import { spawn, spawnSync } from 'node:child_process';
 import { existsSync, readFileSync } from 'node:fs';
 import { createRequire } from 'node:module';
 import { dirname, join, resolve } from 'node:path';
 import process from 'node:process';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import { addArgs, commandLine, detectPackageManager, execAmxts, versionOf } from './pm.mjs';
-import { CliError, debug } from './ui.mjs';
+import { CliError, debug, report } from './ui.mjs';
 
 /** The command's own package folder: packages/cli in its repository. */
 export const CLI_DIR = join(dirname(fileURLToPath(import.meta.url)), '..');
@@ -24,7 +24,7 @@ export const CLI_PACKAGE = readJson(join(CLI_DIR, 'package.json'));
 export const VERSION = String(CLI_PACKAGE.version);
 
 /** The cores this command works with: the range a new project asks for. */
-export const CORE_RANGE = '^0.2.0';
+export const CORE_RANGE = '^0.3.0';
 /** The version of `@amxts/core/cli-api` this command speaks. */
 export const CLI_API = 5;
 
@@ -275,19 +275,42 @@ export function needBun(core, what = 'builds plugins') {
  * @param {string[]} [args]
  */
 export function runTask(core, name, args = []) {
+	const result = spawnSync(...taskSpawn(core, name, args, { stdio: 'inherit' }));
+	if (result.error) throw new CliError(`Bun did not start: ${result.error.message}`, BUN_HINT);
+	return result.status ?? 1;
+}
+
+/** A task as spawn takes it: the file, its arguments (none when it goes through the shell) and the options. */
+function taskSpawn(core, name, args, options) {
 	const task = core.api.task(name, args);
-	const env = { ...process.env, ...(debug() ? { AMXTS_DEBUG: '1' } : {}) };
-	if (task.runtime === 'node') {
-		return spawnSync(process.execPath, task.args, { stdio: 'inherit', env }).status ?? 1;
-	}
+	const env = { ...process.env, ...(debug() ? { AMXTS_DEBUG: '1' } : {}), ...options.env };
+	if (task.runtime === 'node') return [process.execPath, task.args, { ...options, env }];
 	const binary = needBun(core);
 	// A Bun on PATH goes through the shell on Windows, where it may be
 	// bun.cmd; a path with a space is quoted for it.
-	const result = binary === 'bun' && process.platform === 'win32'
-		? spawnSync(commandLine(['bun', ...task.args]), { stdio: 'inherit', shell: true, env })
-		: spawnSync(binary, task.args, { stdio: 'inherit', env });
-	if (result.error) throw new CliError(`Bun did not start: ${result.error.message}`, BUN_HINT);
-	return result.status ?? 1;
+	return binary === 'bun' && process.platform === 'win32'
+		? [commandLine(['bun', ...task.args]), { ...options, shell: true, env }]
+		: [binary, task.args, { ...options, env }];
+}
+
+/**
+ * Starts one of the core's tasks and leaves it running: `dev`'s build, which
+ * watches. `pipe` takes its output instead of the terminal, with its colours.
+ * @param {Core} core
+ * @param {string} name
+ * @param {string[]} args
+ * @param {{ pipe?: boolean }} [options]
+ * @returns {import('node:child_process').ChildProcess} the task
+ */
+export function startTask(core, name, args, { pipe = false } = {}) {
+	const child = pipe
+		? spawn(...taskSpawn(core, name, args, { stdio: ['ignore', 'pipe', 'pipe'], env: { FORCE_COLOR: process.env.NO_COLOR === undefined ? '1' : '0' } }))
+		: spawn(...taskSpawn(core, name, args, { stdio: 'inherit' }));
+	child.on('error', (error) => {
+		report(new CliError(`Bun did not start: ${error.message}`, BUN_HINT));
+		process.exit(1);
+	});
+	return child;
 }
 
 /** Runs a task and stops with its exit code when it fails. */

package/src/dev-feed.mjs

@@ -0,0 +1,147 @@
+// What the dev panel knows of the build: read off the lines the core's build
+// task prints, the one place that reads them. The words are the core's; a
+// structured feed from the core would replace this file, and the panel would
+// stay as it is.
+//
+//   Plugins   3 in plugins/                             the header
+//   ◇ compiling hello 1/2                               a compile starts (no TTY)
+//   ✔ hello · 1.2s                                      one is compiled
+//   ✖ hello does not compile: ...                       an error, its lines under it
+//   ✔ 12:01:33 plugins/hello.ts changed: deployed, the server reloaded hello (2.1s)
+//   ◇ watching plugins - save a plugin and ...          the first build is done
+
+/** A line without its colours. */
+export function plain(line) {
+	// eslint-disable-next-line no-control-regex
+	return line.replace(/\x1B\[[\d;?]*[a-z]|\x1B\]8;[^\x1B]*\x1B\\/gi, '').replace(/\r/g, '');
+}
+
+/** The marks a line of the build starts with: a line without one belongs to the error above it. */
+const MARK = /^[✔◇▲✖i] /;
+
+/**
+ * @typedef {object} Rebuild
+ * @property {string[]} files the saved files that started it; none for a start
+ * @property {string[]} plugins what it built
+ * @property {number | undefined} compile seconds of compiling, the longest one (they compile side by side); undefined when nothing compiled
+ * @property {number} total seconds, all of it
+ * @property {string} outcome what the deploy did, as the core says it
+ * @property {boolean} reloaded whether the server reloaded them all
+ * @property {string} at the time it ended, as printed
+ * @property {number | undefined} boot seconds before the core counts, for a build the panel started
+ */
+
+/** Each plugin a line names as not compiling is failed. */
+function markFailed(feed, text) {
+	for (const [, name] of text.matchAll(/(\S+) does not compile:/g)) feed.plugins.set(name, 'failed');
+}
+
+/** The lines the feed reads: what each is, and what it changes. */
+const RULES = [
+	[/^ {2}(Core|Modules|Server|Plugins) +(\S.*)$/, 'header', (feed, [, row, value]) => {
+		feed.header[row] = value;
+		if (row === 'Plugins') feed.count = Number.parseInt(value, 10) || 0;
+	}],
+	[/^◇ compiling (.+?) (\d+)\/(\d+)$/, 'compiling', (feed, [, what, , total]) => {
+		feed.building ??= { what, done: 0, total: 0, since: Date.now() };
+		feed.building.what = what;
+		feed.building.total = Number(total);
+	}],
+	[/^✔ (\S+) · (?:(\d+(?:\.\d+)?)s|prebuilt|unchanged)$/, 'compiled', (feed, [, name, time]) => {
+		if (!time) return;
+		feed.times.set(name, Number(time));
+		feed.expected = Number(time);
+		if (feed.building) feed.building.done++;
+	}],
+	[/^✖ (.*)$/, 'error', (feed, [, text]) => {
+		feed.error = [text];
+		feed.inError = true;
+		feed.broken = true;
+		feed.building = null;
+		markFailed(feed, text);
+	}],
+	[/^✔ (?:(\d{1,2}:\d{2}:\d{2}(?: ?[AP]M)?) )?(?:(.+?) changed: )?(.+) \((\d+(?:\.\d+)?)s\)$/, 'rebuilt', (feed, [, at = '', files = '', outcome, total]) => {
+		const named = /reloaded (.+)$/.exec(outcome)?.[1]
+			?? /^(?:deployed|built|rebuilt) (.+?)(?: into .*| - .*)?$/.exec(outcome)?.[1]
+			?? /^(.+?) not deployed/.exec(outcome)?.[1] ?? '';
+		const plugins = named.split(', ').filter(Boolean);
+		for (const name of plugins) feed.plugins.set(name, 'built');
+		const times = [...feed.times.values()];
+		feed.last = {
+			files: files ? files.split(', ') : [],
+			plugins,
+			compile: times.length ? Math.max(...times) : undefined,
+			total: Number(total),
+			outcome,
+			reloaded: outcome.startsWith('deployed, the server reloaded '),
+			at,
+			// A build the panel started: the time before the core's own count - Bun, the project, the server asked.
+			boot: feed.started === null ? undefined : Math.max(0, (Date.now() - feed.started) / 1000 - Number(total)),
+		};
+		feed.started = null;
+		feed.times.clear();
+		feed.broken = false;
+		feed.building = null;
+	}],
+	[/^◇ watching /, 'watching', (feed) => {
+		feed.watching = true;
+	}],
+];
+
+/** The parser's state, which the panel shows. */
+export function createFeed() {
+	const feed = {
+		/** @type {Record<string, string>} the header's rows: Core, Modules, Server, Plugins */
+		header: {},
+		/** How many plugins the project has, from the header. */
+		count: 0,
+		/** @type {Map<string, 'built' | 'failed'>} each plugin a build has named */
+		plugins: new Map(),
+		/** @type {{ what: string, done: number, total: number, since: number } | null} the build that compiles now: what started last, how many of how many are done, since when (ms) */
+		building: null,
+		/** Seconds the last plugin took to compile: what the next one is expected to take. */
+		expected: 10,
+		/** @type {number | null} when the panel started the build that runs (ms), till it ends; null for one a save started */
+		started: null,
+		/** @type {Rebuild | null} */
+		last: null,
+		/** @type {string[]} the last error's lines */
+		error: [],
+		watching: false,
+		/** @type {Map<string, number>} seconds of each plugin compiled since the last summary */
+		times: new Map(),
+		/** Whether the lines that follow belong to the last error. */
+		inError: false,
+		/** Whether the last build failed: the server keeps the one before. */
+		broken: false,
+
+		/**
+		 * Takes one line of the build's output.
+		 * @returns {string | null} what it was - `header`, `compiling`, `compiled`, `error`, `rebuilt`, `watching` - or null for anything else
+		 */
+		push(raw) {
+			const line = plain(raw);
+			if (feed.inError && line && !MARK.test(line)) {
+				feed.error.push(line);
+				markFailed(feed, line);
+				return 'error';
+			}
+			feed.inError = false;
+			for (const [pattern, kind, take] of RULES) {
+				const match = pattern.exec(line);
+				if (match) {
+					take(feed, match);
+					return kind;
+				}
+			}
+			return null;
+		},
+
+		/** How many plugins are built and how many failed. */
+		counts() {
+			const states = [...feed.plugins.values()];
+			return { built: states.filter(each => each === 'built').length, failed: states.filter(each => each === 'failed').length };
+		},
+	};
+	return feed;
+}