nodefony 7.0.2 → 10.0.0-alpha.2

package/dist/node/Cli.js

@@ -0,0 +1,750 @@
+import clc from "./colors.js";
+import Container from "./Container.js";
+import { extend } from "./Tools.js";
+import FileClass from "./FileClass.js";
+import { DEFAULT_ENGINE_ENVIRONMENT, defaultEngineEnvironment } from "./runtime/engineEnvironment.js";
+import Event from "./Event.js";
+import Service from "./Service.js";
+import fs from "node:fs";
+import path from "node:path";
+import { Command } from "commander";
+import { spawn, spawnSync } from "node:child_process";
+import semver from "semver";
+import Table from "cli-table3";
+//#region src/Cli.ts
+let figletModule = null;
+/**
+* Charge `figlet` à la demande (import dynamique, idempotent) — la bannière ASCII est
+* cosmétique : les commandes qui ne l'affichent pas ne paient pas son chargement au boot.
+*/
+const loadFiglet = async () => {
+	if (!figletModule) figletModule = (await import("figlet")).default;
+	return figletModule;
+};
+const blue = clc.blueBright.bold;
+const { green } = clc;
+const magenta = clc.magenta.bold;
+const { reset } = clc;
+let processName = null;
+if (process.argv && process.argv[1]) processName = path.basename(process.argv[1]);
+else processName = process.title || "nodefony";
+const defaultTableCli = { style: {
+	head: ["cyan"],
+	border: ["grey"]
+} };
+const defaultOptions = {
+	processName,
+	autostart: true,
+	asciify: true,
+	clear: true,
+	color: blue,
+	prompt: "default",
+	commander: true,
+	signals: true,
+	autoLogger: true,
+	resize: false,
+	version: "1.0.0",
+	warning: false,
+	pid: false,
+	promiseRejection: true
+};
+/**
+* Traduit un `NODE_ENV` brut en mode MOTEUR, ou `null` s'il n'en désigne aucun.
+*
+* `NODE_ENV` est un axe LIBRE (`test`, `staging`, `canary`, `prod-eu`…) tandis que
+* {@link EnvironmentType} n'a que deux modes moteur : dev et prod. Les caster l'un
+* dans l'autre est un mensonge au compilateur — sous vitest, `environment` valait
+* `"test"`, une valeur ABSENTE de son propre type, propagée telle quelle à
+* `initSyslog()` et au `Kernel`.
+*
+* `null` (valeur non-moteur) fait retomber l'appelant sur son défaut explicite,
+* exactement comme si `NODE_ENV` n'était pas défini. C'est le choix CONSERVATEUR :
+* un `test` se comportait déjà comme la production (le filtre syslog teste
+* `=== "development"`, tout le reste tombe dans la branche prod). Le forcer en
+* `"development"` aurait rendu toute la suite de tests verbeuse ; le forcer en
+* `"production"` aurait fait installer `--omit=dev` sous `NODE_ENV=test`. Un axe
+* qui ne désigne pas de moteur ne doit pas en élire un à la place de l'appelant.
+*
+* L'axe de déploiement, lui, reste ENTIER : le kernel lit `process.env.NODE_ENV`
+* directement pour `runtimeEnv`/`isTest` (`buildConfigContext`) — jamais via cette
+* fonction, qui ne réécrit rien.
+*/
+const toEngineEnvironment = (raw) => {
+	switch (raw) {
+		case "dev":
+		case "development":
+		case "prod":
+		case "production": return raw;
+		default: return null;
+	}
+};
+/**
+* Délai au-delà duquel on sort sans attendre le vidage des sorties.
+*
+* Le cas qu'il couvre : le destinataire du tuyau a fermé (`| head -5`), aucun
+* `drain` n'arrivera jamais, et attendre serait un blocage franc. Une seconde
+* suffit très largement — vider 100 Ko vers un tuyau vivant prend des
+* millisecondes.
+*/
+const EXIT_FLUSH_DEADLINE_MS = 1e3;
+/**
+* Sort du process APRÈS avoir vidé les sorties standard.
+*
+* 🔴 **`process.exit()` TRONQUE la sortie, et ne le dit pas.** Vers un fichier
+* ou un terminal, `process.stdout.write` est synchrone : tout part. Vers un
+* TUYAU, il est asynchrone — au-delà du tampon du système (64 Ko), le reste
+* attend dans la file, et `process.exit()` part avec. Mesuré sur
+* `nodefony inspect routes --json` : 97 825 octets vers un fichier, très
+* exactement 65 536 vers un `| jq`, qui casse alors sur un JSON incomplet.
+* L'usage était pourtant celui que la commande DOCUMENTE.
+*
+* Le défaut ne se voit pas sur une petite sortie : il apparaît le jour où
+* l'application grossit, sur la machine de quelqu'un d'autre, et il se lit
+* comme une donnée corrompue plutôt que comme une sortie coupée.
+*
+* @param code - code de sortie du process
+*/
+function exitWhenFlushed(code) {
+	const streams = [process.stdout, process.stderr].filter((s) => typeof s.writableLength === "number" && s.writableLength > 0);
+	if (streams.length === 0) return process.exit(code);
+	let pending = streams.length;
+	const done = () => {
+		pending -= 1;
+		if (pending === 0) process.exit(code);
+	};
+	for (const s of streams) s.once("drain", done);
+	setTimeout(() => process.exit(code), EXIT_FLUSH_DEADLINE_MS).unref();
+}
+var Cli = class Cli extends Service {
+	options = extend({}, defaultOptions);
+	debug = false;
+	environment = DEFAULT_ENGINE_ENVIRONMENT;
+	commander = null;
+	commands = {};
+	pid = null;
+	interactive = false;
+	unhandledRejections = /* @__PURE__ */ new Map();
+	response = {};
+	timers = {};
+	version = "";
+	clc = clc;
+	blankLine = () => {};
+	columns = 0;
+	rows = 0;
+	/**
+	* Vrai dès le 1ᵉʳ signal d'arrêt reçu. Empêche un 2ᵉ signal de relancer un
+	* `terminate()` gracieux complet (re-fire `onTerminate`, double SHUTDOWN des
+	* serveurs). Le 2ᵉ signal force la sortie immédiate — cf {@link handleSignals}.
+	*/
+	shuttingDown = false;
+	/**
+	* Retraits des listeners posés sur `process` — `null` tant qu'aucun n'est
+	* attaché (une instance qui n'écoute rien n'alloue rien).
+	*
+	* Chaque entrée est le retrait de SON listener, fermé sur la référence exacte :
+	* un handler anonyme passé à `process.on` ne peut plus jamais être retiré, et
+	* c'est ce qui faisait de chaque instance une fuite. En production le process
+	* meurt avec son unique `Cli`, mais un runner de tests en crée des dizaines
+	* dans le MÊME process : au 11ᵉ, Node crie `MaxListenersExceededWarning` — et
+	* comme le warning porte l'objet `process` entier, chacun coûtait ~500 lignes
+	* de journal (216 000 lignes sur un seul job de CI, tronqué par GitHub).
+	*
+	* @see {@link releaseProcessListeners}
+	*/
+	#detachProcess = null;
+	/** Numéros POSIX → code de sortie forcé `128 + signum` au 2ᵉ signal. */
+	static SIGNUM = {
+		SIGHUP: 1,
+		SIGINT: 2,
+		SIGQUIT: 3,
+		SIGTERM: 15
+	};
+	constructor(name, ...args) {
+		const container = args[0] instanceof Container ? args[0] : void 0;
+		const notificationsCenter = args[1] instanceof Event ? args[1] : args[1] === false ? false : void 0;
+		const last = args[args.length - 1];
+		let options = null;
+		if (last instanceof Container || last instanceof Event || last === false) options = extend({}, defaultOptions);
+		else options = extend({}, defaultOptions, last || {});
+		super(name || options.processName, container, notificationsCenter, options);
+		this.options = options;
+		this.environment = toEngineEnvironment(process.env.NODE_ENV) ?? this.options.environment ?? defaultEngineEnvironment(process.env.NODE_ENV);
+		this.setProcessTitle();
+		this.pid = this.options.pid ? this.setPid() : null;
+		if (this.options.autoLogger) this.initSyslog();
+		this.initUi();
+		this.prependOnceListener("onStart", async () => {
+			try {
+				await this.fireAsync("onStart", this);
+			} catch (e) {
+				this.log(e, "ERROR");
+			}
+		});
+		this.initCommander();
+		if (this.options.warning) this.handleWarnings();
+		else process.env.NODE_NO_WARNINGS = "1";
+		if (this.options.signals) this.handleSignals();
+		if (this.options.promiseRejection) this.listenRejection();
+		if (name && this.options.asciify) this.showAsciify(name).then(async () => {
+			if (this.options.autostart) await this.fireAsync("onStart", this);
+		}).catch((e) => this.log(e, "ERROR"));
+		else if (this.options.autostart) try {
+			const func = async function() {
+				await this.fireAsync("onStart", this);
+			};
+			func.call(this);
+		} catch (e) {
+			this.log(e, "ERROR");
+		}
+	}
+	handleSignals() {
+		const signalHandler = (signal) => {
+			if (this.shuttingDown) {
+				this.log(`${signal} received again — force exit`, "WARNING");
+				process.exit(128 + (Cli.SIGNUM[signal] ?? 0));
+			}
+			this.shuttingDown = true;
+			if (this.blankLine) this.blankLine();
+			this.log(signal, "CRITIC");
+			this.fire("onSignal", signal, this);
+			process.nextTick(() => {
+				this.terminate();
+			});
+		};
+		for (const signal of [
+			"SIGINT",
+			"SIGTERM",
+			"SIGHUP",
+			"SIGQUIT"
+		]) {
+			const handler = () => signalHandler(signal);
+			process.on(signal, handler);
+			this.trackProcessListener(() => process.removeListener(signal, handler), true);
+		}
+	}
+	/**
+	* Mémorise DE QUOI retirer un listener de `process`.
+	*
+	* Prend le retrait déjà fermé sur la référence du handler, plutôt que le
+	* couple (événement, handler) : c'est ce qui permet de garder chaque listener
+	* typé exactement (`NodeJS.Signals`, `Error`, `Promise<unknown>`) sans un seul
+	* cast au moment de le retirer.
+	*
+	* @param off - retire le listener correspondant, et rien d'autre.
+	* @param signal - `true` s'il s'agit d'un gestionnaire de SIGNAL. Ce n'est
+	*   pas une étiquette de confort : le mode cluster doit reprendre la main sur
+	*   les signaux SANS toucher aux autres listeners de cette instance
+	*   (`warning`, `unhandledRejection`), que le master garde. Cf
+	*   {@link releaseSignalListeners}.
+	*/
+	trackProcessListener(off, signal = false) {
+		(this.#detachProcess ??= []).push({
+			off,
+			signal
+		});
+	}
+	/**
+	* Retire tous les listeners que cette instance a posés sur `process`.
+	*
+	* Sans effet utile en production — le process meurt avec son `Cli` — mais
+	* indispensable dès qu'un même process en instancie plusieurs (tests, outils
+	* qui enchaînent des commandes) : sinon chaque instance ajoute sept listeners
+	* que personne ne peut plus retirer.
+	*
+	* Idempotent : un second appel ne retire rien et rend `0`.
+	*
+	* @returns le nombre de listeners effectivement retirés.
+	*/
+	releaseProcessListeners() {
+		if (!this.#detachProcess) return 0;
+		const released = this.#detachProcess.length;
+		for (const { off } of this.#detachProcess) off();
+		this.#detachProcess = null;
+		return released;
+	}
+	/**
+	* Retire les gestionnaires de SIGNAUX de cette instance — et rien d'autre.
+	*
+	* 🔴 Il existe pour remplacer un `process.removeAllListeners(sig)`, qui
+	* arrachait AUSSI les gestionnaires qu'un module tiers avait posés sur
+	* `SIGTERM` pour son propre arrêt propre. Ce module ne recevait plus rien, et
+	* rien ne le lui disait : son code était juste, ses tests passaient, et son
+	* nettoyage cessait simplement de s'exécuter le jour où l'application passait
+	* en cluster — au moment le plus coûteux, l'arrêt.
+	*
+	* On ne retire donc que ce qu'on a posé soi-même. Les autres listeners de
+	* cette instance (`warning`, `unhandledRejection`, `uncaughtException`)
+	* restent : le master cluster en a besoin autant que n'importe quel process.
+	*
+	* @returns le nombre de gestionnaires de signaux retirés.
+	*/
+	releaseSignalListeners() {
+		if (!this.#detachProcess) return 0;
+		const signaux = this.#detachProcess.filter((e) => e.signal);
+		for (const { off } of signaux) off();
+		this.#detachProcess = this.#detachProcess.filter((e) => !e.signal);
+		return signaux.length;
+	}
+	handleWarnings() {
+		const handler = (warning) => {
+			this.log(warning, "WARNING");
+			this.fire("onNodeWarning", warning, this);
+		};
+		process.on("warning", handler);
+		this.trackProcessListener(() => process.removeListener("warning", handler));
+	}
+	start() {
+		return new Promise((resolve, reject) => {
+			const run = async () => {
+				if (this.options.autostart) {
+					if (this.options.asciify) {
+						this.once("onStart", () => resolve(this));
+						return;
+					}
+					await this.fireAsync("onStart", this);
+					resolve(this);
+					return;
+				}
+				if (this.options.asciify) {
+					this.once("onAsciify", () => {
+						this.fireAsync("onStart", this).then(() => resolve(this), reject);
+					});
+					return;
+				}
+				await this.fireAsync("onStart", this);
+				resolve(this);
+			};
+			run().catch(reject);
+		});
+	}
+	idle() {
+		let resolve = null;
+		let reject = null;
+		const promise = new Promise((res, rej) => {
+			resolve = res;
+			reject = rej;
+		});
+		return (function() {
+			return {
+				resolve,
+				promise,
+				reject
+			};
+		})();
+	}
+	checkVersion(version = null) {
+		if (!version) version = this.version;
+		const res = semver.valid(version);
+		if (res) return res;
+		throw new Error(`Not valid version : ${version} check  http://semver.org `);
+	}
+	async showAsciify(name = null) {
+		if (!name) name = this.name;
+		return await this.asciify(`      ${name}`, { font: this.options.font || "Standard" }).then((data) => {
+			this.fire("onAsciify", data);
+			if (this.options.clear) this.clear();
+			const color = this.options.color || blue;
+			console.log(color(data));
+			return this;
+		}).catch((err) => {
+			this.log(err, "ERROR");
+			throw err;
+		});
+	}
+	showBanner() {
+		const version = (this.commander ? this.commander.version() : this.options.version) || "1.0.0";
+		let banner = null;
+		if (this.options.version) {
+			banner = `          Version : ${blue(version)}   Platform : ${green(process.platform)}   Process : ${green(process.title)}   Pid : ${process.pid}`;
+			if (this.blankLine) this.blankLine();
+			console.log(banner);
+		}
+		return banner;
+	}
+	listenRejection() {
+		const onHandled = (promise) => {
+			this.log("PROMISE REJECTION EVENT ", "CRITIC", "rejectionHandled");
+			this.unhandledRejections.delete(promise);
+		};
+		process.on("rejectionHandled", onHandled);
+		this.trackProcessListener(() => process.removeListener("rejectionHandled", onHandled));
+		const onUnhandled = (reason, promise) => {
+			this.log(`WARNING  !!! PROMISE CHAIN BREAKING : ${reason}`, "WARNING", "unhandledRejection");
+			console.trace(promise);
+			this.unhandledRejections.set(promise, reason);
+		};
+		process.on("unhandledRejection", onUnhandled);
+		this.trackProcessListener(() => process.removeListener("unhandledRejection", onUnhandled));
+	}
+	setPid() {
+		return this.pid = process.pid;
+	}
+	setProcessTitle(name) {
+		if (name) process.title = name.replace(/* @__PURE__ */ new RegExp("\\s", "gi"), "").toLowerCase();
+		else process.title = this.name.replace(/* @__PURE__ */ new RegExp("\\s", "gi"), "").toLowerCase();
+		return process.title;
+	}
+	logEnv() {
+		return `${blue(`      \x1b ${this.name}`)} Nodefony Environment : ${magenta(this.environment)}`;
+	}
+	initCommander() {
+		if (this.options.commander) {
+			this.commander = new Command();
+			if (!this.commander.options.some((opt) => opt.short === "-i" || opt.long === "--interactive")) this.commander.option("-i, --interactive", "mode interactif (questions au terminal)");
+			if (!this.commander.options.some((opt) => opt.short === "-d" || opt.long === "--debug")) this.commander.option("-d, --debug", "mode débogage : journal détaillé");
+			if (!this.commander.options.some((opt) => opt.short === "-v" || opt.long === "--version") && this.options.version) this.setCommandVersion(this.options.version);
+			return this.commander;
+		}
+		return null;
+	}
+	initUi() {
+		this.blankLine = () => {
+			process.stdout.write("\n");
+		};
+		if (this.options.resize) this.resize();
+	}
+	async getFonts() {
+		(await loadFiglet()).fonts((_err, fonts) => {
+			fonts?.forEach((ele) => {
+				this.log(ele);
+			});
+		});
+	}
+	async asciify(txt, options, callback) {
+		const figlet = await loadFiglet();
+		return new Promise((resolve, reject) => {
+			figlet(txt, extend({ font: "Standard" }, options), (error, data) => {
+				if (callback && typeof callback === "function") return callback(error, data ?? "");
+				if (error) return reject(error);
+				return resolve(data ?? "");
+			});
+		});
+	}
+	parse(argv, options) {
+		if (this.commander) return this.commander?.parse(argv, options);
+		throw new Error(`Commander not found`);
+	}
+	parseAsync(argv, options) {
+		if (this.commander) return this.commander?.parseAsync(argv, options).catch((e) => {
+			throw e;
+		});
+		throw new Error(`Commander not found`);
+	}
+	clearCommand() {
+		this.commander?.setOptionValue("interactive", false);
+		this.commander?.setOptionValue("debug", false);
+		while (process.argv.length > 2) process.argv.pop();
+	}
+	runCommand(cmd, args = []) {
+		this.clearCommand();
+		if (cmd) process.argv.push(cmd);
+		return this.parse(process.argv.concat(args));
+	}
+	runCommandAsync(cmd, args = []) {
+		this.clearCommand();
+		if (cmd) process.argv.push(cmd);
+		return this.parseAsync(process.argv.concat(args));
+	}
+	setCommandOption(flags, description, defaultValue) {
+		if (this.commander) return this.commander.option(flags, description, defaultValue);
+		throw new Error(`Commender not found`);
+	}
+	setCommandVersion(version) {
+		if (this.commander && typeof this.commander.version === "function") return this.commander.version(version, "-v, --version", "affiche la version de Nodefony");
+		throw new Error(`Commender not found`);
+	}
+	setCommand(nameAndArgs, description, options) {
+		if (this.commander) return this.commander.command(nameAndArgs, description, options);
+		throw new Error(`Commander not found`);
+	}
+	addCommand(cliCommand) {
+		const command = new cliCommand(this);
+		this.commands[command.name] = command;
+		return command;
+	}
+	hasCommand(name) {
+		if (this.commands[name]) return true;
+		return false;
+	}
+	getCommand(name) {
+		if (this.commands[name]) return this.commands[name];
+		return null;
+	}
+	showHelp(quit, context) {
+		if (!this.commander) throw new Error(`Commender not found`);
+		if (quit) return this.commander.help(context);
+		return this.commander.outputHelp(context);
+	}
+	displayTable(datas, options, syslog = null) {
+		if (!datas || !datas.length) return new Table(extend({}, defaultTableCli, options));
+		const table = new Table(extend({}, defaultTableCli, options));
+		if (datas) {
+			for (let i = 0; i < datas.length; i++) table.push(datas[i]);
+			if (syslog) syslog.log(`\n${table.toString()}`);
+			else console.log(table.toString());
+		}
+		return table;
+	}
+	static niceBytes(x) {
+		const units = [
+			"bytes",
+			"KB",
+			"MB",
+			"GB",
+			"TB",
+			"PB",
+			"EB",
+			"ZB",
+			"YB"
+		];
+		let n = parseInt(x, 10) || 0, l = 0;
+		while (n >= 1024) {
+			n /= 1024;
+			l++;
+		}
+		return `${n.toFixed(n >= 10 || l < 1 ? 0 : 1)} ${units[l]}`;
+	}
+	/**
+	* Temps relatif lisible ("a few seconds ago", "24 years ago") — natif via
+	* `Intl.RelativeTimeFormat` (remplace `moment().fromNow()`, dep supprimée).
+	*
+	* @param date - instant de référence (Date, timestamp ms, ou string parsable).
+	* @param suffix - `true` = sans suffixe "ago"/"in" (parité `moment.fromNow(true)`).
+	*/
+	static niceUptime(date, suffix) {
+		const deltaSec = ((date instanceof Date ? date.getTime() : new Date(date).getTime()) - Date.now()) / 1e3;
+		const abs = Math.abs(deltaSec);
+		const ladder = [
+			["year", 31536e3],
+			["month", 2592e3],
+			["day", 86400],
+			["hour", 3600],
+			["minute", 60],
+			["second", 1]
+		];
+		let unit = "second";
+		let value = 0;
+		for (const [u, s] of ladder) if (abs >= s || u === "second") {
+			unit = u;
+			value = Math.round(deltaSec / s);
+			break;
+		}
+		if (suffix) {
+			const n = Math.abs(value);
+			return `${n} ${unit}${n === 1 ? "" : "s"}`;
+		}
+		return new Intl.RelativeTimeFormat("en", { numeric: "auto" }).format(value, unit);
+	}
+	/**
+	* Formate une date selon des tokens `moment`-like (`YYYY MM DD HH mm ss SSS`)
+	* en heure **locale** — natif (remplace `moment().format()`, dep supprimée).
+	*
+	* @param date - Date, timestamp ms, ou string parsable.
+	* @param format - patron (défaut `"YYYY-MM-DD HH:mm:ss"`).
+	*/
+	static niceDate(date, format) {
+		const d = date instanceof Date ? date : new Date(date);
+		const pad = (n, len = 2) => String(n).padStart(len, "0");
+		const map = {
+			YYYY: String(d.getFullYear()),
+			MM: pad(d.getMonth() + 1),
+			DD: pad(d.getDate()),
+			HH: pad(d.getHours()),
+			mm: pad(d.getMinutes()),
+			ss: pad(d.getSeconds()),
+			SSS: pad(d.getMilliseconds(), 3)
+		};
+		return (format || "YYYY-MM-DD HH:mm:ss").replace(/YYYY|SSS|MM|DD|HH|mm|ss/g, (t) => map[t]);
+	}
+	clear() {
+		console.clear();
+	}
+	reset() {
+		process.stdout.write(reset);
+	}
+	resize() {
+		process.stdout.on("resize", () => {
+			this.columns = process.stdout.columns;
+			this.rows = process.stdout.rows;
+			this.fire("onResize", this.columns, this.rows, this);
+		});
+	}
+	async createDirectory(myPath, mode, force = false) {
+		try {
+			await fs.promises.mkdir(myPath, mode);
+			return new FileClass(myPath);
+		} catch (e) {
+			switch (e.code) {
+				case "EEXIST": if (force) return new FileClass(myPath);
+			}
+			throw e;
+		}
+	}
+	existsSync(myPath) {
+		if (!myPath) throw new Error("existsSync no path found");
+		return fs.existsSync(myPath);
+	}
+	exists(myPath, mode, callback) {
+		if (!myPath) throw new Error("exists no path found");
+		if (!mode) mode = fs.constants.R_OK | fs.constants.W_OK;
+		if (callback) return fs.access(myPath, mode, callback);
+		return fs.existsSync(myPath);
+	}
+	async terminate(code = 0, quiet) {
+		this.releaseProcessListeners();
+		if (quiet) return;
+		if (code === 0) process.exitCode = code;
+		exitWhenFlushed(code);
+	}
+	static quit(code) {
+		if (code === 0) process.exitCode = code;
+		return exitWhenFlushed(code);
+	}
+	startTimer(name) {
+		if (name in this.timers) throw new Error(`Timer : ${name} already exist !! stopTimer to clear`);
+		try {
+			this.log(`BEGIN TIMER : ${name}`, "INFO");
+			this.timers[name] = name;
+			return console.time(name);
+		} catch (e) {
+			if (name in this.timers) delete this.timers[name];
+			throw e;
+		}
+	}
+	stopTimer(name) {
+		if (!name) for (const timer in this.timers) this.stopTimer(this.timers[timer]);
+		try {
+			if (name in this.timers) {
+				this.log(`END TIMER : ${name}`, "INFO");
+				delete this.timers[name];
+				return console.timeEnd(name);
+			}
+			throw new Error(`Timer : ${name} not exist !! startTimer before`);
+		} catch (e) {
+			if (name in this.timers) delete this.timers[name];
+			throw e;
+		}
+	}
+	getCommandManager(manager) {
+		if (process.platform === "win32") switch (manager) {
+			case "npm": return "npm.cmd";
+			case "yarn": return "yarn.cmd";
+			case "pnpm": return "pnpm.cmd";
+			default: throw new Error(`bad manager : ${manager}`);
+		}
+		else switch (manager) {
+			case "npm": return "npm";
+			case "yarn": return "yarn";
+			case "pnpm": return "pnpm";
+			default: throw new Error(`bad manager : ${manager}`);
+		}
+	}
+	runPackageManager(argv = [], cwd = path.resolve("."), env, manager) {
+		const currentenv = process.env.NODE_ENV;
+		switch (env) {
+			case "dev":
+			case "development":
+				process.env.NODE_ENV = "development";
+				break;
+			case "prod":
+			case "production":
+				switch (manager) {
+					case "npm":
+						argv.push("--omit=dev");
+						break;
+					case "yarn":
+						argv.push("--production");
+						break;
+					case "pnpm": argv.push("--prod");
+				}
+				process.env.NODE_ENV = "production";
+				break;
+			default: process.env.NODE_ENV = this.environment;
+		}
+		return new Promise((resolve, reject) => {
+			try {
+				this.debug = Boolean(this.commander?.opts().debug) || false;
+				this.log(`Command : ${manager} ${argv.join(" ")} in cwd : ${cwd}`);
+				const exe = this.getCommandManager(manager);
+				this.spawn(exe, argv, {
+					cwd,
+					env: process.env,
+					stdio: "inherit"
+				}, (code) => {
+					process.env.NODE_ENV = currentenv;
+					if (code === 0) return resolve(code);
+					return resolve(/* @__PURE__ */ new Error(`Command : ${manager} ${argv.join(" ")}  cwd : ${cwd} Error Code : ${code}`));
+				});
+			} catch (e) {
+				process.env.NODE_ENV = currentenv;
+				this.log(e, "ERROR");
+				return reject(e);
+			}
+		});
+	}
+	async npm(argv = [], cwd = path.resolve("."), env = "dev") {
+		return this.runPackageManager(argv, cwd, env, "npm");
+	}
+	async yarn(argv = [], cwd = path.resolve("."), env = "dev") {
+		return this.runPackageManager(argv, cwd, env, "yarn");
+	}
+	async pnpm(argv = [], cwd = path.resolve("."), env = "dev") {
+		return this.runPackageManager(argv, cwd, env, "pnpm");
+	}
+	spawn(command, args, options, close = null) {
+		return new Promise((resolve, reject) => {
+			let cmd = null;
+			try {
+				if (!args) args = [];
+				this.log(`Spawn : ${command} ${args.join(" ")}`, "INFO");
+				cmd = spawn(command, args, options || {});
+				if (cmd.stdout) cmd.stdout.on("data", (data) => {
+					const str = data.toString();
+					if (str) {
+						if (this.debug) this.log(`${command} :\n`, "INFO", "STDOUT");
+						process.stdout.write(str);
+					}
+				});
+				if (cmd.stderr) cmd.stderr.on("data", (data) => {
+					const str = data.toString();
+					if (str) {
+						if (this.debug) this.log(`${command} :\n`, "INFO", "STDERR");
+						process.stdout.write(str);
+					}
+				});
+				cmd.on("close", (code) => {
+					if (this.debug) this.log(`Child Process exited with code ${code}`, "DEBUG");
+					if (close) close(code);
+					if (code !== 0) {
+						if (!args) args = [];
+						this.log(`Spawn : ${command} ${args.join(" ")} Error Code : ${code}`, "ERROR");
+					}
+					return resolve(code);
+				});
+				cmd.on("error", (err) => {
+					this.log(err, "ERROR");
+					return reject(err);
+				});
+				if (cmd.stdin) process.stdin.pipe(cmd.stdin);
+			} catch (e) {
+				this.log(e, "ERROR");
+				return reject(e);
+			}
+		});
+	}
+	spawnSync(command, args, options) {
+		let cmd = null;
+		try {
+			cmd = spawnSync(command, args, options);
+			if (cmd.error) throw cmd.error;
+			if (cmd.stderr) this.log(cmd.stderr.toString(), "ERROR");
+			if (cmd.stdout) this.log(cmd.stdout.toString(), "INFO");
+		} catch (e) {
+			this.log(e, "ERROR");
+			throw e;
+		}
+		return cmd;
+	}
+};
+//#endregion
+export { Cli as default };