authup 1.0.0-beta.4 → 1.0.0-beta.41

package/dist/index.mjs

@@ -1,416 +1,336 @@
 #!/usr/bin/env node
-import cac from 'cac';
-import { deserializeKey, Container, EnvKey } from '@authup/config';
-import consola from 'consola';
-import { buildConfig } from '@authup/client-web-config';
-import { makeURLPublicAccessible } from '@authup/core';
-import path from 'node:path';
-import { exec } from 'node:child_process';
-import process from 'node:process';
-import { isObject, hasOwnProperty } from 'smob';
-import findUpPackagePath from 'resolve-package-path';
-import { parseConfig, buildConfig as buildConfig$1 } from '@authup/server-core';
-import readline from 'node:readline';
-import chalk from 'chalk';
-
-function isServiceValid(input) {
-    let key;
-    if (typeof input === 'string') {
-        key = deserializeKey(input);
-    } else {
-        key = input;
-    }
-    if (key.group !== 'client' && key.group !== 'server') {
-        return false;
-    }
-    if (key.group === 'client') {
-        return key.name === 'web';
-    }
-    return key.name === 'core';
+import { defineCommand, runMain } from "citty";
+import fs from "node:fs";
+import path from "node:path";
+import process from "node:process";
+import { extendObject, hasOwnProperty, isObject, makeURLPublicAccessible } from "@authup/kit";
+import { defineGetter, dycraft } from "dycraft";
+import zod from "zod";
+import { merge } from "smob";
+import { oneOf, read, readInt } from "envix";
+import { Container } from "confinity";
+import consola from "consola";
+import { exec } from "node:child_process";
+import findUpPackagePath from "resolve-package-path";
+//#region src/packages/client-web/config/parse.ts
+function parseClientWebConfig(input = {}) {
+	return zod.object({
+		port: zod.number().nonnegative().optional(),
+		host: zod.string().optional(),
+		apiUrl: zod.string().url().optional(),
+		publicUrl: zod.string().url().optional()
+	}).parse(input);
 }
-
-async function buildClientWebConfig(container) {
-    const client = container.getData('client/web');
-    const server = container.getData('server/core');
-    if (server) {
-        if (!client.apiUrl && typeof server.publicUrl === 'string') {
-            client.apiUrl = makeURLPublicAccessible(server.publicUrl);
-        }
-        if (!client.publicUrl && typeof server.authorizeRedirectUrl === 'string') {
-            client.apiUrl = makeURLPublicAccessible(server.authorizeRedirectUrl);
-        }
-    }
-    return buildConfig({
-        data: client,
-        env: true
-    });
+//#endregion
+//#region src/packages/client-web/config/build.ts
+function buildClientWebConfig(raw) {
+	return extendObject(dycraft({
+		defaults: {
+			port: 3e3,
+			host: "0.0.0.0",
+			apiUrl: "http://127.0.0.1:3001/"
+		},
+		getters: { publicUrl: defineGetter((context) => `http://${makeURLPublicAccessible(context.get("host"))}:${context.get("port")}/`) }
+	}), parseClientWebConfig(raw));
 }
-
-/*
- * Copyright (c) 2023.
- * Author Peter Placzek (tada5hi)
- * For the full copyright and license information,
- * view the LICENSE file that was distributed with this source code.
- */ var ServicePackageName;
-(function(ServicePackageName) {
-    ServicePackageName["CLIENT_WEB"] = "@authup/client-web";
-    ServicePackageName["SERVER_CORE"] = "@authup/server-core";
-})(ServicePackageName || (ServicePackageName = {}));
-var ServiceCommand;
-(function(ServiceCommand) {
-    ServiceCommand["START"] = "start";
-    ServiceCommand["CLEANUP"] = "cleanup";
-})(ServiceCommand || (ServiceCommand = {}));
-
-/*
- * Copyright (c) 2022.
- * Author Peter Placzek (tada5hi)
- * For the full copyright and license information,
- * view the LICENSE file that was distributed with this source code.
- */ function removeLineBreaks(input) {
-    return input.replace(/(\r\n|\n|\r)/gm, '');
+//#endregion
+//#region src/packages/client-web/config/read/env.ts
+function readClientWebConfigFromEnv() {
+	const config = {};
+	const port = oneOf([
+		readInt("UI_PORT"),
+		readInt("NITRO_UI_PORT"),
+		readInt("NUXT_UI_PORT"),
+		readInt("NUXT_PUBLIC_UI_PORT"),
+		readInt("PORT"),
+		readInt("NITRO_PORT"),
+		readInt("NUXT_PORT"),
+		readInt("NUXT_PUBLIC_PORT")
+	]);
+	if (typeof port !== "undefined") config.port = port;
+	const host = oneOf([
+		read("HOST"),
+		read("NITRO_HOST"),
+		read("NUXT_HOST")
+	]);
+	if (host) config.host = host;
+	const apiUrl = oneOf([
+		read("API_URL"),
+		read("NUXT_API_URL"),
+		read("NUXT_PUBLIC_API_URL")
+	]);
+	if (apiUrl) config.apiUrl = apiUrl;
+	const publicURL = oneOf([
+		read("PUBLIC_URL"),
+		read("NUXT_PUBLIC_URL"),
+		read("NUXT_PUBLIC_PUBLIC_URL")
+	]);
+	if (publicURL) config.publicUrl = publicURL;
+	return config;
 }
-
-function parseProcessOutputData(input) {
-    if (typeof input !== 'string') {
-        return [];
-    }
-    const lines = input.split(/\r?\n/).filter((element)=>element);
-    const items = [];
-    for(let i = 0; i < lines.length; i++){
-        const line = removeLineBreaks(lines[i]).trim();
-        if (line.length === 0) {
-            continue;
-        }
-        try {
-            const parsed = JSON.parse(line);
-            if (isObject(parsed) && hasOwnProperty(parsed, 'message') && typeof parsed.message === 'string') {
-                items.push(parsed.message);
-                continue;
-            }
-        } catch (e) {
-        // no json :/
-        }
-        items.push(line);
-    }
-    return items;
+//#endregion
+//#region src/packages/client-web/config/read/fs.ts
+async function readClientWebConfigFromFS(options = {}) {
+	const container = new Container({
+		prefix: "authup",
+		cwd: options.cwd
+	});
+	if (options.file) await container.loadFile(options.file);
+	else await container.load();
+	const clientRaw = container.get("client.web") || {};
+	const serverRaw = container.get("server.core") || {};
+	if (serverRaw) {
+		if (!clientRaw.apiUrl && typeof serverRaw.publicUrl === "string") clientRaw.apiUrl = makeURLPublicAccessible(serverRaw.publicUrl);
+		if (!clientRaw.publicUrl && typeof serverRaw.authorizeRedirectUrl === "string") clientRaw.apiUrl = makeURLPublicAccessible(serverRaw.authorizeRedirectUrl);
+	}
+	return clientRaw;
 }
-
-/*
- * Copyright (c) 2022.
- * Author Peter Placzek (tada5hi)
- * For the full copyright and license information,
- * view the LICENSE file that was distributed with this source code.
- */ function stringifyObjectArgs(ob) {
-    const parts = [];
-    const keys = Object.keys(ob);
-    for(let i = 0; i < keys.length; i++){
-        parts.push(`--${keys[i]} ${ob[keys[i]]}`);
-    }
-    return parts.join(' ');
-}
-
-async function execShellCommand(ctx) {
-    ctx.env = ctx.env || {};
-    ctx.args = ctx.args || {};
-    return new Promise((resolve, reject)=>{
-        const childProcess = exec(`${ctx.command} ${stringifyObjectArgs(ctx.args)}`, {
-            env: {
-                PATH: process.env.PATH,
-                ...ctx.envFromProcess ? process.env : {},
-                ...ctx.env
-            }
-        });
-        childProcess.on('error', (data)=>{
-            reject(data);
-        });
-        childProcess.on('spawn', ()=>{
-            resolve(childProcess);
-        });
-        childProcess.stderr.setEncoding('utf-8');
-        childProcess.stderr.on('data', (data)=>{
-            if (typeof data !== 'string' || data.length === 0) {
-                return;
-            }
-            if (ctx.logErrorStream) {
-                ctx.logErrorStream(data);
-            }
-        });
-        childProcess.stdout.on('data', (data)=>{
-            if (typeof data !== 'string' || data.length === 0) {
-                return;
-            }
-            if (!ctx.logDataStream) {
-                return;
-            }
-            const lines = parseProcessOutputData(data);
-            for(let i = 0; i < lines.length; i++){
-                ctx.logDataStream(lines[i]);
-            }
-        });
-    });
-}
-
-const PACKAGE_DIRECTORY = path.join(__dirname, '..');
-
-function findModulePath(module) {
-    let modulePath = findUpPackagePath(module, PACKAGE_DIRECTORY);
-    if (PACKAGE_DIRECTORY !== process.cwd()) {
-        modulePath = findUpPackagePath(module, process.cwd());
-    }
-    if (!modulePath) {
-        return undefined;
-    }
-    return modulePath;
+//#endregion
+//#region src/packages/client-web/config/read/module.ts
+async function readClientWebConfigRaw(options = {}) {
+	if (options.fs && options.env) {
+		const fs = await readClientWebConfigFromFS(boolableToObject(options.fs));
+		return merge(readClientWebConfigFromEnv(), fs);
+	}
+	if (options.fs) return readClientWebConfigFromFS(boolableToObject(options.fs));
+	if (options.env) return readClientWebConfigFromEnv();
+	return {};
 }
-
-function extendEnv(input) {
-    const env = {};
-    const keys = Object.keys(input);
-    for(let i = 0; i < keys.length; i++){
-        env[keys[i]] = input[keys[i]];
-        if (!keys[i].match(/^(?:NUXT|NITRO)_.*$/)) {
-            env[`NUXT_PUBLIC_${keys[i]}`] = input[keys[i]];
-        }
-    }
-    return env;
+function boolableToObject(input) {
+	if (typeof input === "boolean") return {};
+	return input;
 }
-function buildWebAppExecutionContext(ctx) {
-    if (ctx.command !== ServiceCommand.START) {
-        throw new Error(`The command ${ctx.command} is not supported`);
-    }
-    const env = ctx.env || {};
-    const data = ctx.container.getData('client/web');
-    const config = buildConfig({
-        data,
-        env: true
-    });
-    if (config.host) {
-        env.HOST = config.host;
-    }
-    if (config.port) {
-        env.PORT = `${config.port}`;
-    }
-    if (config.apiUrl) {
-        env.API_URL = config.apiUrl;
-    }
-    if (config.publicUrl) {
-        env.PUBLIC_URL = config.publicUrl;
-    }
-    let command;
-    const modulePath = findModulePath(ServicePackageName.CLIENT_WEB);
-    if (typeof modulePath === 'string') {
-        const directory = path.dirname(modulePath);
-        const outputPath = path.join(directory, '.output', 'server', 'index.mjs');
-        command = `node ${outputPath}`;
-    } else {
-        command = `npx ${ServicePackageName.CLIENT_WEB}`;
-    }
-    return {
-        ...ctx,
-        command,
-        env: extendEnv(env)
-    };
+//#endregion
+//#region src/utils/line-breaks.ts
+function removeLineBreaks(input) {
+	return input.replace(/(\r\n|\n|\r)/gm, "");
 }
-
-async function buildServerCoreConfig(container) {
-    const data = parseConfig(container.getData('server/core'));
-    return buildConfig$1({
-        data,
-        env: true
-    });
+//#endregion
+//#region src/utils/process-output.ts
+function parseProcessOutputData(input) {
+	if (typeof input !== "string") return [];
+	const lines = input.split(/\r?\n/).filter((element) => element);
+	const items = [];
+	for (const line_ of lines) {
+		const line = removeLineBreaks(line_).trim();
+		if (line.length === 0) continue;
+		try {
+			const parsed = JSON.parse(line);
+			if (isObject(parsed) && hasOwnProperty(parsed, "message") && typeof parsed.message === "string") {
+				items.push(parsed.message);
+				continue;
+			}
+		} catch {}
+		items.push(line);
+	}
+	return items;
 }
-
-function buildServerCoreExecutionContext(ctx) {
-    let command;
-    const modulePath = findModulePath(ServicePackageName.SERVER_CORE);
-    if (typeof modulePath === 'string') {
-        const directory = path.dirname(modulePath);
-        const outputPath = path.join(directory, 'dist', 'cli', 'index.js');
-        command = `node ${outputPath}`;
-    } else {
-        command = `npx ${ServicePackageName.SERVER_CORE}`;
-    }
-    switch(ctx.command){
-        case ServiceCommand.START:
-            {
-                command += ' start';
-                break;
-            }
-        case ServiceCommand.CLEANUP:
-            {
-                command += ' reset';
-                break;
-            }
-        default:
-            {
-                throw new Error(`The command ${ctx.command} is not supported.`);
-            }
-    }
-    return {
-        ...ctx,
-        command
-    };
+//#endregion
+//#region src/utils/stringify-object-args.ts
+function stringifyObjectArgs(ob) {
+	const parts = [];
+	const keys = Object.keys(ob);
+	for (const key of keys) parts.push(`--${key} ${ob[key]}`);
+	return parts.join(" ");
 }
-
-function buildInfoCommand(cac) {
-    cac.command('info', 'Get information about the configuration.').option('-c, --config [config]', 'Specify a configuration file').action(async (ctx)=>{
-        const container = new Container({
-            prefix: 'authup',
-            keys: [
-                'client/web',
-                'server/core'
-            ]
-        });
-        if (ctx.config) {
-            await container.loadFromFilePath(ctx.config);
-        } else {
-            await container.load();
-        }
-        const clientWeb = await buildClientWebConfig(container);
-        consola.info(`Host: ${clientWeb.host}`);
-        consola.info(`Port: ${clientWeb.port}`);
-        consola.info('------------');
-        const serverCore = await buildServerCoreConfig(container);
-        consola.info(`Host: ${serverCore.host}`);
-        consola.info(`Port: ${serverCore.port}`);
-        consola.info(`Environment: ${serverCore.env}`);
-        consola.info(`RootPath: ${serverCore.rootPath}`);
-        consola.info(`WritableDirectoryPath: ${serverCore.writableDirectoryPath}`);
-        consola.info('------------');
-        consola.info('Report an issue: https://github.com/authup/authup/issues/new');
-        consola.info('Suggest an improvement: https://github.com/authup/authup/discussions/new');
-        consola.info('Read documentation: https://authup.org');
-    });
+//#endregion
+//#region src/utils/shell.ts
+async function execShellCommand(command, ctx = {}) {
+	return new Promise((resolve, reject) => {
+		const childProcess = exec(`${command} ${stringifyObjectArgs(ctx.args || {})}`, { env: {
+			PATH: process.env.PATH,
+			...ctx.envFromProcess ? process.env : {},
+			...ctx.env ? ctx.env : {}
+		} });
+		childProcess.on("error", (data) => {
+			reject(data);
+		});
+		childProcess.on("spawn", () => {
+			resolve(childProcess);
+		});
+		if (childProcess.stderr) {
+			childProcess.stderr.setEncoding("utf-8");
+			childProcess.stderr.on("data", (data) => {
+				if (typeof data !== "string" || data.length === 0) return;
+				if (ctx.logErrorStream) ctx.logErrorStream(data);
+			});
+		}
+		if (childProcess.stdout) childProcess.stdout.on("data", (data) => {
+			if (typeof data !== "string" || data.length === 0) return;
+			if (!ctx.logDataStream) return;
+			const lines = parseProcessOutputData(data);
+			for (const line of lines) ctx.logDataStream(line);
+		});
+	});
 }
-
-async function executeServiceCommand(context) {
-    let service;
-    if (typeof context.service === 'string') {
-        service = deserializeKey(context.service);
-    } else {
-        service = context.service;
-    }
-    const env = {};
-    const config = context.container.get(`${service.group}/${service.name}`);
-    if (config) {
-        const paths = config.paths.join(',');
-        if (paths.length > 0) {
-            env[EnvKey.CONFIG_FILE] = paths;
-        }
-    }
-    let shellExecContext;
-    try {
-        if (service.group === 'server' && service.name === 'core') {
-            shellExecContext = buildServerCoreExecutionContext({
-                command: context.command,
-                env
-            });
-        }
-        if (service.group === 'client' && service.name === 'web') {
-            shellExecContext = buildWebAppExecutionContext({
-                container: context.container,
-                command: context.command,
-                env
-            });
-        }
-    } catch (e) {
-        consola.error(`${service.group}/${service.name}: The service command ${context.command} not supported.`);
-        process.exit(1);
-    }
-    if (!shellExecContext) {
-        consola.error(`${service.group}/${service.name}: The service is not supported.`);
-        process.exit(1);
-    }
-    return execShellCommand({
-        ...shellExecContext,
-        logDataStream (line) {
-            consola.info(`${service.group}/${service.name}: ${line}`);
-        },
-        logErrorStream (line) {
-            consola.warn(`${service.group}/${service.name}: ${line}`);
-        }
-    });
+//#endregion
+//#region src/constants.ts
+const PACKAGE_DIRECTORY = path.join(__dirname, "..");
+//#endregion
+//#region src/utils/modules-path.ts
+function findModulePath(module) {
+	let modulePath = findUpPackagePath(module, PACKAGE_DIRECTORY);
+	if (PACKAGE_DIRECTORY !== process.cwd()) modulePath = findUpPackagePath(module, process.cwd());
+	if (!modulePath) return;
+	return modulePath;
 }
-async function executeServicesCommand(context) {
-    const container = new Container({
-        prefix: 'authup',
-        keys: context.servicesAllowed || context.services
-    });
-    if (context.config) {
-        await container.loadFromFilePath(context.config);
-    } else {
-        await container.load();
-    }
-    const promises = [];
-    for(let i = 0; i < context.services.length; i++){
-        const service = deserializeKey(context.services[i]);
-        if (!isServiceValid(service)) {
-            consola.error(`${chalk.red(`${service.group}/${service.name}`)}: The service does not exist.`);
-            process.exit(1);
-        }
-        if (context.servicesAllowed && context.servicesAllowed.indexOf(`${service.group}/${service.name}`) === -1) {
-            consola.error(`${chalk.red(`${service.group}/${service.name}`)}: The service does not support the ${context.command} command.`);
-            process.exit(1);
-        }
-        promises.push(executeServiceCommand({
-            command: context.command,
-            service,
-            container
-        }));
-    }
-    const childProcesses = await Promise.all(promises);
-    const readLine = readline.createInterface({
-        input: process.stdin,
-        output: process.stdout
-    });
-    readLine.on('SIGINT', ()=>{
-        for(let i = 0; i < childProcesses.length; i++){
-            childProcesses[i].kill();
-        }
-        process.exit();
-    });
+//#endregion
+//#region src/packages/constants.ts
+let PackageID = /* @__PURE__ */ function(PackageID) {
+	PackageID["CLIENT_WEB"] = "client.web";
+	PackageID["SERVER_CORE"] = "server.core";
+	return PackageID;
+}({});
+//#endregion
+//#region src/packages/client-web/module.ts
+var ClientWebPackage = class {
+	async execute(command, options = {}) {
+		return execShellCommand(await this.buildShellCommand(), {
+			env: await this.buildEnv({
+				configDirectory: options.configDirectory,
+				configFile: options.configFile
+			}),
+			logDataStream(line) {
+				consola.info(`client.web: ${line}`);
+			},
+			logErrorStream(line) {
+				consola.warn(`client.web: ${line}`);
+			}
+		});
+	}
+	async buildShellCommand() {
+		let shellCommand;
+		const modulePath = findModulePath("@authup/client-web");
+		if (typeof modulePath === "string") {
+			const directory = path.dirname(modulePath);
+			shellCommand = `node ${path.join(directory, ".output", "server", "index.mjs")}`;
+		} else shellCommand = `npx @authup/client-web`;
+		return shellCommand;
+	}
+	async buildEnv(ctx) {
+		const env = {};
+		const config = buildClientWebConfig(await readClientWebConfigRaw({ fs: {
+			file: ctx.configFile,
+			cwd: ctx.configDirectory
+		} }));
+		if (config.host) env.HOST = config.host;
+		if (config.port) env.PORT = `${config.port}`;
+		if (config.apiUrl) env.API_URL = config.apiUrl;
+		if (config.publicUrl) env.PUBLIC_URL = config.publicUrl;
+		return this.extendEnvKeys(env);
+	}
+	extendEnvKeys(input) {
+		const env = {};
+		const keys = Object.keys(input);
+		for (const key of keys) {
+			env[key] = input[key];
+			if (!key.match(/^(?:NUXT|NITRO)_.*$/)) env[`NUXT_PUBLIC_${key}`] = input[key];
+		}
+		return env;
+	}
+};
+//#endregion
+//#region src/packages/server-core/module.ts
+var ServerCorePackage = class {
+	async execute(command, options = {}) {
+		return execShellCommand(await this.buildShellCommand(command, {
+			configDirectory: options.configDirectory,
+			configFile: options.configFile
+		}), {
+			logDataStream(line) {
+				consola.info(`server.core: ${line}`);
+			},
+			logErrorStream(line) {
+				consola.warn(`server.core: ${line}`);
+			}
+		});
+	}
+	async buildShellCommand(command, options) {
+		const parts = [];
+		const modulePath = findModulePath("@authup/server-core");
+		if (typeof modulePath === "string") {
+			const directory = path.dirname(modulePath);
+			const outputPath = path.join(directory, "dist", "cli.mjs");
+			parts.push(`node ${outputPath}`);
+		} else parts.push(`npx @authup/server-core`);
+		parts.push(command);
+		if (options.configFile) parts.push(`--configFile=${options.configFile}`);
+		if (options.configDirectory) parts.push(`--configDirectory=${options.configDirectory}`);
+		return parts.join(" ");
+	}
+};
+//#endregion
+//#region src/packages/execute.ts
+async function executePackageCommand(pkg, command, options = {}) {
+	switch (pkg) {
+		case "client.web": return new ClientWebPackage().execute(command, options);
+		case "server.core": return new ServerCorePackage().execute(command, options);
+	}
+	throw new Error(`The package ${pkg} is not supported.`);
 }
-
-function buildCleanupCommand(cac) {
-    cac.command('cleanup [...services]', 'Cleanup a service').option('-c, --config [config]', 'Specify a configuration file').action(async (keysInput, ctx)=>{
-        const servicesAllowed = [
-            'server/core'
-        ];
-        if (!keysInput || keysInput.length === 0) {
-            keysInput = servicesAllowed;
-        }
-        await executeServicesCommand({
-            config: ctx.config,
-            command: ServiceCommand.CLEANUP,
-            services: keysInput,
-            servicesAllowed
-        });
-    });
+//#endregion
+//#region src/packages/normalize.ts
+function normalizePackageID(input) {
+	switch (input.trim().toLowerCase()) {
+		case "client.web":
+		case "client/web":
+		case "client-web": return "client.web";
+		case "server.core":
+		case "server/core":
+		case "server-core": return "server.core";
+	}
+	return null;
 }
-
-function buildStartCommand(cac) {
-    cac.command('start [...services]', 'Start a service').option('-c, --config [config]', 'Specify a configuration file').action(async (keysInput, ctx)=>{
-        const servicesAllowed = [
-            'client/web',
-            'server/core'
-        ];
-        if (!keysInput || keysInput.length === 0) {
-            keysInput = servicesAllowed;
-        }
-        await executeServicesCommand({
-            config: ctx.config,
-            command: ServiceCommand.START,
-            services: keysInput,
-            servicesAllowed
-        });
-    });
+//#endregion
+//#region src/module.ts
+async function createCLIEntryPointCommand() {
+	const pkgRaw = await fs.promises.readFile(path.join(process.cwd(), "package.json"), { encoding: "utf8" });
+	const pkg = JSON.parse(pkgRaw);
+	return defineCommand({
+		meta: {
+			name: pkg.name,
+			version: pkg.version,
+			description: pkg.description
+		},
+		args: {
+			command: {
+				type: "positional",
+				description: "The command which should be forwarded to the package.",
+				required: true
+			},
+			package: {
+				type: "positional",
+				description: "The package, which should be targeted.",
+				required: false
+			},
+			configDirectory: {
+				type: "string",
+				description: "Config directory path",
+				alias: "cD"
+			},
+			configFile: {
+				type: "string",
+				description: "Name of one or more configuration files.",
+				alias: "cF"
+			}
+		},
+		async run(ctx) {
+			let packages = ctx.args.package ? ctx.args.package.split(",") : [];
+			if (packages.length > 0) packages = packages.map((pkg) => normalizePackageID(pkg)).filter((pkg) => Boolean(pkg)).map((pkg) => `${pkg}`);
+			if (packages.length === 0) packages = Object.values(PackageID);
+			const promises = [];
+			for (const package_ of packages) promises.push(executePackageCommand(package_, ctx.args.command, {
+				configFile: ctx.args.configFile,
+				configDirectory: ctx.args.configDirectory
+			}));
+			await Promise.all(promises);
+		}
+	});
 }
+//#endregion
+//#region src/index.ts
+Promise.resolve().then(() => createCLIEntryPointCommand()).then((command) => runMain(command));
+//#endregion
+export {};
 
-const cli = cac();
-buildInfoCommand(cli);
-buildStartCommand(cli);
-buildCleanupCommand(cli);
-cli.help();
-cli.parse();
-//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map