@mirta/cli 0.3.0

package/dist/package.mjs

@@ -0,0 +1,256 @@
+import chalk from 'chalk';
+import { a as getLocale, g as getLocalized, u as useLogger, r as runCommandAsync } from './shell.mjs';
+import nodePath from 'node:path';
+import { readdirSync, statSync, readFileSync, existsSync, writeFileSync } from 'node:fs';
+
+const { dim, yellow: yellow$1 } = chalk;
+const locale = getLocale();
+const helpMessageEn = `\
+Performs operations over monorepo projects powered by the Mirta Framework.
+
+${yellow$1('Usage:')}
+  mirta [command] [options...]
+
+${yellow$1('Commands:')}
+- release:
+  ${dim('Increase package versions following semantic versioning rules.')}
+- publish:
+  ${dim('Builds and publishes packages to npm registry.')}
+
+${yellow$1(`Options for 'release':`)}
+  --dry
+    ${dim('Runs the command in dry run mode, showing what would be done but not performing any actual changes. Useful for previewing changes before applying them.')}
+  --preid <custom-pre-release-id>
+    ${dim('Sets a custom pre-release identifier that will be appended to the version string (for example, beta.1). This option allows creating pre-release versions like alpha, beta, rc etc., prior to official stable releases.')}
+  --skipPrompts
+    ${dim('Skips user interaction prompts entirely. The command runs non-interactively, automatically proceeding with defaults or configured values where applicable.')}
+  --skipGit
+    ${dim('Omits Git-related actions such as committing changes, tagging commits, or pushing updates to remote repositories. This can be useful if you want to manually manage Git operations later.')}
+
+${yellow$1(`Options for 'publish':`)}
+  --dry
+    ${dim('Runs the command in dry run mode, showing what would be done but not performing any actual changes. Useful for previewing changes before applying them.')}
+  --skipBuild
+    ${dim('Excludes running the build process after version bumps. Bypasses execution of tasks defined in the build pipeline, allowing users to control whether they need a rebuild after updating package versions.')}
+  --skipGit
+    ${dim('Omits Git-related actions such as committing changes, tagging commits, or pushing updates to remote repositories. This can be useful if you want to manually manage Git operations later.')}
+    
+`;
+const helpMessageRu = `\
+Выполняет операции над проектами монорепозитория, работающими на базе фреймворка Mirta.
+
+${yellow$1('Использование:')}
+  mirta [command] [options...]
+
+${yellow$1('Команды:')}
+- release:
+  ${dim('Повышение версий пакетов согласно правилам семантического версионирования.')}
+- publish:
+  ${dim('Сборка и публикация пакетов в реестр npm.')}
+
+${yellow$1(`Опции для 'release':`)}
+  --dry
+    ${dim('Запускает команду в режиме симуляции ("dry run"), показывая изменения, которые будут произведены, но фактически ничего не меняя. Полезно для предварительного просмотра изменений перед применением.')}
+  --preid <custom-pre-release-id>
+    ${dim('Устанавливает кастомный префикс для предварительной версии, который добавляется к номеру версии пакета (например, beta.1). Эта опция позволяет создавать предварительные версии типа альфа, бета, RC и др. перед официальным стабильным выпуском.')}
+  --skipPrompts
+    ${dim('Пропускает интерактивные запросы пользователя. Команда выполняется автоматически, используя значения по умолчанию или заданные настройки.')}
+  --skipGit
+    ${dim('Игнорирует действия, связанные с системой контроля версий Git, такие как фиксация изменений, создание меток коммитов или отправка изменений на удалённый репозиторий. Может пригодиться, если вы хотите самостоятельно управлять операциями с Git позже.')}
+
+${yellow$1(`Опции для 'publish':`)}
+  --dry
+    ${dim('Запускает команду в режиме симуляции ("dry run"), показывая изменения, которые будут произведены, но фактически ничего не меняя. Полезно для предварительного просмотра изменений перед применением.')}
+  --skipBuild
+    ${dim('Исключает запуск процесса сборки после обновления версий пакетов. Пропускает выполнение заданий, указанных в конвейере сборки, позволяя вам самим решать, необходима ли повторная компиляция после изменения номеров версий.')}
+  --skipGit
+    ${dim('Игнорирует действия, связанные с системой контроля версий Git, такие как фиксация изменений, создание меток коммитов или отправка изменений на удалённый репозиторий. Может пригодиться, если вы хотите самостоятельно управлять операциями с Git позже.')}
+`;
+const helpMessage = locale === 'ru-RU'
+    ? helpMessageRu
+    : helpMessageEn;
+
+const { yellow } = chalk;
+const messages = await getLocalized();
+const logger = useLogger(messages);
+const rootDir = process.cwd();
+const packagesDir = nodePath.join(rootDir, 'packages');
+const getPackageRoot = (packageName) => nodePath.join(packagesDir, packageName);
+// Перечисляем пакеты, которые должны выйти в релиз.
+const packages = readdirSync(packagesDir)
+    .filter((pkgName) => {
+    const pkgRoot = getPackageRoot(pkgName);
+    if (!statSync(pkgRoot).isDirectory())
+        return;
+    const pkg = JSON.parse(readFileSync(nodePath.join(pkgRoot, 'package.json'), 'utf-8'));
+    return !pkg.private;
+});
+const templatePackages = {};
+/** Имя пользователя или организации, владеющей пакетом. */
+let scope;
+/** Форматированный scope пакета. */
+let scoped;
+/** Использовать scope в качестве префикса в названиях пакетов. */
+let scopeAsPackagePrefix = false;
+const mirtaConfigFilePath = nodePath.join(rootDir, 'mirta.config.json');
+const rootPackage = JSON.parse(readFileSync(nodePath.join(rootDir, 'package.json'), 'utf-8'));
+if (rootPackage.name) {
+    const match = /^@([^/]+)\//i.exec(rootPackage.name);
+    if (match?.[1]) {
+        scope = match[1];
+        scoped = `@${match[1]}/`;
+    }
+}
+/** Возвращает текущую версию корневого проекта. */
+function getCurrentVersion() {
+    return rootPackage.version;
+}
+function hasScript(name) {
+    return rootPackage.scripts?.[name] !== void 0;
+}
+if (existsSync(mirtaConfigFilePath)) {
+    const config = JSON.parse(readFileSync(mirtaConfigFilePath, 'utf-8'));
+    scope = config.scope;
+    scopeAsPackagePrefix = config.scopedPackagePrefix === true;
+    if (scope?.startsWith('@'))
+        scope = scope.slice(1);
+    if (scope)
+        scoped = `@${scope}/`;
+    if (config.templates && Array.isArray(config.templates)) {
+        config.templates.forEach((template) => {
+            const templatesDir = nodePath.resolve(rootDir, template);
+            // Предохранитель от выхода за пределы рабочей директории.
+            if (!templatesDir.startsWith(rootDir))
+                return;
+            // Обрабатываем только существующие директории.
+            if (!statSync(templatesDir).isDirectory())
+                return;
+            const localTemplatePackages = readdirSync(templatesDir, {
+                withFileTypes: true,
+                recursive: true,
+            })
+                .reduce((items, nextEntry) => {
+                if (nextEntry.name === 'package.json')
+                    items.push(nextEntry.parentPath);
+                return items;
+            }, []);
+            templatePackages[templatesDir] = localTemplatePackages;
+        });
+    }
+}
+const isWorkspacePackage = (pkgName) => {
+    if (!pkgName)
+        return false;
+    if (packages.includes(pkgName))
+        return true;
+    if (!scoped || !pkgName.startsWith(scoped))
+        return false;
+    pkgName = pkgName.slice(scoped.length);
+    if (scopeAsPackagePrefix)
+        pkgName = `${scope}-${pkgName}`;
+    return packages.includes(pkgName);
+};
+function updateDependencies(pkg, depType, version) {
+    const deps = pkg[depType];
+    if (!deps)
+        return;
+    Object.keys(deps).forEach((dep) => {
+        if (!isWorkspacePackage(dep))
+            return;
+        deps[dep] = version;
+    });
+}
+function updateTemplateDependencies(templateRoot, version) {
+    logger.step(`Template: ${nodePath.relative(rootDir, templateRoot)}`);
+    const pkgPath = nodePath.join(templateRoot, 'package.json');
+    const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+    updateDependencies(pkg, 'dependencies', version);
+    updateDependencies(pkg, 'devDependencies', version);
+    writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + '\n');
+}
+function updatePackageVersion(pkgRoot, version) {
+    const pkgPath = nodePath.join(pkgRoot, 'package.json');
+    const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+    logger.step(pkgRoot === rootDir
+        ? 'Root package'
+        : `Package: ${pkg.name ?? nodePath.basename(pkgRoot)}`);
+    pkg.version = version;
+    writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + '\n');
+}
+function updateVersion(version) {
+    logger.log(`Patching all packages to version ${version}`);
+    // Update root package.json
+    updatePackageVersion(rootDir, version);
+    // Update all packages
+    packages.forEach((pkgDirName) => {
+        updatePackageVersion(nodePath.join(packagesDir, pkgDirName), version);
+    });
+    const templateKeys = Object.keys(templatePackages);
+    if (templateKeys.length > 0) {
+        logger.log(`Patching template packages`);
+        Object.keys(templatePackages).forEach((templatesDir) => {
+            templatePackages[templatesDir].forEach((templateRoot) => {
+                updateTemplateDependencies(templateRoot, version);
+            });
+        });
+    }
+}
+/** Выполняет сборку пакетов стандартной командой `pnpm run build`. */
+async function buildPackagesAsync(skipBuild) {
+    if (!skipBuild) {
+        logger.log('Building packages...');
+        await runCommandAsync('pnpm', ['run', 'build']);
+    }
+    else {
+        logger.log(`${yellow('Skip')} building packages`);
+    }
+}
+async function publishSinglePackageAsync(pkgName, version, flags) {
+    let releaseTag = void 0;
+    if (version.includes('alpha')) {
+        releaseTag = 'alpha';
+    }
+    else if (version.includes('beta')) {
+        releaseTag = 'beta';
+    }
+    else if (version.includes('rc')) {
+        releaseTag = 'rc';
+    }
+    logger.step(`Publishing ${pkgName}`);
+    try {
+        await runCommandAsync('pnpm', [
+            'publish',
+            ...(releaseTag ? ['--tag', releaseTag] : []),
+            '--access',
+            'public',
+            ...(flags),
+        ], {
+            cwd: getPackageRoot(pkgName),
+            stdio: 'pipe',
+        });
+        logger.success(`Published ${pkgName}@${version}`);
+    }
+    catch (e) {
+        if (e instanceof Error && /previously published/.exec(e.message)) {
+            logger.warn(`Skipping already published ${pkgName}`);
+        }
+        else {
+            throw e;
+        }
+    }
+}
+/** Выполняет публикацию пакетов монорепозитория в NPM. */
+async function publishPackagesAsync(version, skipGitChecks, isDryRun) {
+    logger.log('Publishing packages...');
+    const flags = [];
+    if (isDryRun)
+        flags.push('--dry-run');
+    if (isDryRun || skipGitChecks || process.env.CI)
+        flags.push('--no-git-checks');
+    if (process.env.CI)
+        flags.push('--provenance');
+    for (const pkgName of packages)
+        await publishSinglePackageAsync(pkgName, version, flags);
+}
+
+export { hasScript as a, buildPackagesAsync as b, getCurrentVersion as g, helpMessage as h, publishPackagesAsync as p, updateVersion as u };

package/dist/publish.mjs

@@ -0,0 +1,54 @@
+import { parseArgs } from 'node:util';
+import { g as getCurrentVersion, h as helpMessage, b as buildPackagesAsync, p as publishPackagesAsync } from './package.mjs';
+import cliPackage from '../package.json' with { type: 'json' };
+import 'chalk';
+import './shell.mjs';
+import 'node:child_process';
+import 'node:url';
+import 'node:fs';
+import 'node:path';
+import 'lodash.merge';
+
+const currentVersion = getCurrentVersion();
+const allOptions = ({
+    dry: {
+        type: 'boolean',
+        default: false,
+    },
+    skipGit: {
+        type: 'boolean',
+        default: false,
+    },
+    skipBuild: {
+        type: 'boolean',
+        default: false,
+    },
+    help: {
+        type: 'boolean',
+        short: 'h',
+        default: false,
+    },
+    version: {
+        type: 'boolean',
+        short: 'v',
+        default: false,
+    },
+});
+const args = process.argv.slice(2);
+const { values: argv } = parseArgs({
+    args,
+    options: allOptions,
+    allowPositionals: true,
+});
+if (argv.help) {
+    console.log(helpMessage);
+    process.exit(0);
+}
+if (argv.version) {
+    console.log(`${cliPackage.name} v${cliPackage.version}`);
+    process.exit(0);
+}
+const skipGit = argv.skipGit;
+const isDryRun = argv.dry;
+await buildPackagesAsync(argv.skipBuild);
+await publishPackagesAsync(currentVersion, skipGit, isDryRun);

package/dist/release.mjs

@@ -0,0 +1,195 @@
+import { parseArgs } from 'node:util';
+import { prerelease, inc, valid } from 'semver';
+import { h as helpMessage, g as getCurrentVersion, u as updateVersion, a as hasScript } from './package.mjs';
+import { c as checkIsInWorkTreeAsync, g as getRepositoryDetails, e as ensureIsSyncedWithRemoteAsync, p as prompts, b as ensureWorkflowResultAsync } from './github.mjs';
+import { g as getLocalized, u as useLogger, r as runCommandAsync } from './shell.mjs';
+import chalk from 'chalk';
+import cliPackage from '../package.json' with { type: 'json' };
+import 'node:path';
+import 'node:fs';
+import 'prompts';
+import 'node:child_process';
+import 'node:url';
+import 'lodash.merge';
+
+const { yellow } = chalk;
+const allOptions = ({
+    dry: {
+        type: 'boolean',
+        default: false,
+    },
+    preid: {
+        type: 'string',
+    },
+    skipPrompts: {
+        type: 'boolean',
+        default: false,
+    },
+    skipGit: {
+        type: 'boolean',
+        default: false,
+    },
+    skipBuild: {
+        type: 'boolean',
+        default: false,
+    },
+    help: {
+        type: 'boolean',
+        short: 'h',
+        default: false,
+    },
+    version: {
+        type: 'boolean',
+        short: 'v',
+        default: false,
+    },
+});
+const args = process.argv.slice(2);
+const { values: argv, positionals } = parseArgs({
+    args,
+    options: allOptions,
+    allowPositionals: true,
+});
+if (argv.help) {
+    console.log(helpMessage);
+    process.exit(0);
+}
+if (argv.version) {
+    console.log(`${cliPackage.name} v${cliPackage.version}`);
+    process.exit(0);
+}
+const messages = await getLocalized();
+const logger = useLogger(messages);
+const currentVersion = getCurrentVersion();
+const preid = argv.preid ?? prerelease(currentVersion)?.[0];
+/** Возможные типы релиза. */
+const releaseTypes = [
+    'patch',
+    'minor',
+    'major',
+    ...(preid
+        ? (['prepatch', 'preminor', 'premajor', 'prerelease'])
+        : []),
+];
+const isDryRun = argv.dry;
+const skipGit = argv.skipGit;
+const skipPrompts = argv.skipPrompts;
+// Параметр командной строки:
+// конкретный номер версии, либо тип релиза (см. releaseTypes).
+//
+let targetVersion = positionals[1];
+const getIncremented = (release) => inc(currentVersion, release, void 0, preid);
+const inWorkTree = await checkIsInWorkTreeAsync();
+let repository;
+let connectionType;
+if (inWorkTree) {
+    const { name: repoName, connectionType: connType } = await getRepositoryDetails();
+    // Репозиторий, в котором выполняется релиз.
+    repository = repoName;
+    // Тип подключения к удалённому репозиторию.
+    connectionType = connType;
+    if (repository)
+        logger.info(`Repository: ${repository}`);
+    await ensureIsSyncedWithRemoteAsync(repository);
+}
+else {
+    logger.info('Repository: not in git work tree');
+}
+// Если версия не указана, предоставить возможность выбора.
+if (!targetVersion) {
+    const choices = releaseTypes
+        .map((item) => {
+        const version = getIncremented(item);
+        return { title: `${item} (${version})`, value: version };
+    })
+        .concat([{ title: 'custom', value: 'custom' }]);
+    const { release } = await prompts({
+        type: 'select',
+        name: 'release',
+        message: 'Select release type',
+        choices,
+    });
+    if (release === 'custom') {
+        const { version } = await prompts({
+            type: 'text',
+            name: 'version',
+            message: 'Type custom version',
+            initial: currentVersion,
+        });
+        // Номер версии вводится вручную.
+        targetVersion = version;
+    }
+    else {
+        // Номер версии извлекается из предложенной ранее строки.
+        targetVersion = release;
+    }
+}
+// Вместо номера версии передан компонент для инкремента?
+//
+if (releaseTypes.includes(targetVersion))
+    targetVersion = getIncremented(targetVersion) ?? '';
+if (!valid(targetVersion))
+    throw new Error(`Target version is not valid: ${targetVersion}`);
+const runCommandIfNotDryAsync = runCommandAsync.ifNotDry(isDryRun);
+let isVersionUpdated = false;
+async function runAsync() {
+    if (skipPrompts) {
+        logger.info(`Releasing v${targetVersion}`);
+    }
+    else {
+        const { confirmRelease } = await prompts({
+            type: 'confirm',
+            name: 'confirmRelease',
+            message: `Releasing v${targetVersion}. Continue?`,
+        });
+        if (!confirmRelease) {
+            logger.cancel('No changes was made.');
+            return;
+        }
+    }
+    if (inWorkTree) {
+        logger.log('Ensuring CI status for HEAD...');
+        await ensureWorkflowResultAsync(repository, 'build');
+    }
+    updateVersion(targetVersion);
+    isVersionUpdated = true;
+    if (inWorkTree && hasScript('changelog')) {
+        logger.log('Generating changelog...');
+        await runCommandAsync('pnpm', ['run', 'changelog']);
+        if (!skipPrompts) {
+            const { isContinue } = await prompts({
+                type: 'confirm',
+                name: 'isContinue',
+                message: 'Changelog generated. Does it look good?',
+            });
+            if (!isContinue)
+                return;
+        }
+    }
+    logger.log('Updating lock-file...');
+    await runCommandAsync('pnpm', ['install', '--prefer-offline']);
+    if (!skipGit && connectionType === 'ssh') {
+        const { stdout } = await runCommandAsync('git', ['diff'], { stdio: 'pipe' });
+        if (stdout) {
+            logger.step('Committing version changes...');
+            await runCommandIfNotDryAsync('git', ['add', '-A']);
+            await runCommandIfNotDryAsync('git', ['commit', '-m', `release: v${targetVersion}`]);
+            logger.step('Pushing to GitHub');
+            await runCommandIfNotDryAsync('git', ['tag', `v${targetVersion}`]);
+            await runCommandIfNotDryAsync('git', ['push', 'origin', `refs/tags/v${targetVersion}`]);
+            await runCommandIfNotDryAsync('git', ['push']);
+            logger.note(yellow('Release will be done via GitHub Actions.')
+                + `\nCheck status at https://github.com/${repository}/actions/workflows/release.yml`);
+        }
+        else {
+            logger.info('No changes to commit.');
+        }
+    }
+}
+await runAsync().catch((e) => {
+    if (isVersionUpdated) {
+        // Revert version changes on failed release
+        updateVersion(currentVersion);
+    }
+    throw e;
+});

package/dist/shell.mjs

@@ -0,0 +1,190 @@
+import { spawn } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import { existsSync, promises } from 'node:fs';
+import { resolve } from 'node:path';
+import merge from 'lodash.merge';
+import chalk from 'chalk';
+
+const fallbackLocale = 'en-US';
+const localesPath = './locales';
+let currentLocale = '';
+/**
+ *
+ * Used to link obtained locale with correct locale file.
+ *
+ * @param locale Obtained locale
+ * @returns locale that linked with correct name
+ */
+function linkLocale(locale) {
+    if (locale === 'C')
+        return fallbackLocale;
+    let linkedLocale;
+    try {
+        linkedLocale = Intl.getCanonicalLocales(locale)[0];
+    }
+    catch (error) {
+        console.warn(`${JSON.stringify(error)}, invalid language tag: "${locale}"`);
+    }
+    switch (linkedLocale) {
+        default:
+            linkedLocale = locale;
+    }
+    return linkedLocale;
+}
+function getLocale() {
+    if (currentLocale)
+        return currentLocale;
+    const shellLocale = process.env.LC_ALL
+        ?? process.env.LC_MESSAGES
+        ?? process.env.LANG
+        ?? Intl.DateTimeFormat().resolvedOptions().locale;
+    return currentLocale = linkLocale(shellLocale.split('.')[0].replace('_', '-'));
+}
+async function loadLanguageFile(filePath) {
+    return await promises.readFile(filePath, 'utf-8').then((content) => {
+        const data = JSON.parse(content);
+        return data;
+    });
+}
+async function loadLocale(localesRoot) {
+    currentLocale = getLocale();
+    const fallbackFilePath = resolve(localesRoot, `${fallbackLocale}.json`);
+    const targetFilePath = resolve(localesRoot, `${currentLocale}.json`);
+    const messages = await loadLanguageFile(fallbackFilePath);
+    if (!messages)
+        throw Error('Fallback locale file not found.');
+    if (existsSync(targetFilePath))
+        merge(messages, await loadLanguageFile(targetFilePath));
+    return messages;
+}
+let localized;
+async function getLocalized() {
+    const path = fileURLToPath(new URL(localesPath, import.meta.url));
+    return localized ??= await loadLocale(path);
+}
+
+const { dim, red, cyan, green, yellow, bgRed, bgCyan, bgGreen, bgYellow, } = chalk;
+const dot = '•';
+const banner = `Mirta ${dot}`;
+const redBanner = red(banner);
+const cyanBanner = cyan(banner);
+const greenBanner = green(banner);
+const yellowBanner = yellow(banner);
+const dimmedBanner = dim(banner);
+const infoPill = (message) => message ? bgCyan.black(` ${message} `) + (` ${cyan(dot)} `) : '';
+const successPill = (message) => message
+    ? bgGreen.black(` ${message} `) + ' '
+    : '';
+const warnPill = (message) => message ? bgYellow.black(` ${message} `) + (` ${yellow(dot)} `) : '';
+const errorPill = (message) => message
+    ? bgRed.white(` ${message} `) + ' '
+    : '';
+const formatMessage = (message) => message ? `${greenBanner} ${message}` : '';
+function useLogger(localized) {
+    function log(message) {
+        const formatted = formatMessage(message);
+        if (formatted)
+            console.log(formatted);
+    }
+    function step(message) {
+        if (message)
+            console.log(`${dimmedBanner} ${dim(message)}`);
+    }
+    function info(message, title = localized.status.info) {
+        if (message)
+            console.log(`${cyanBanner} ${infoPill(title)}${cyan(message)}`);
+    }
+    function note(message, title = localized.status.note) {
+        if (message)
+            console.log(`${yellowBanner} ${warnPill(title)}${message}`);
+    }
+    function success(message, title = localized.status.success) {
+        if (message)
+            console.log(`${greenBanner} ${successPill(title)}${green(dot, message)}`);
+    }
+    function warn(message, title = localized.status.warn) {
+        if (message)
+            console.log(`${yellowBanner} ${warnPill(title)}${yellow(message)}`);
+    }
+    function error(message, title = localized.status.error) {
+        if (message)
+            console.log(`${redBanner} ${errorPill(title)}${red(dot, message)}`);
+    }
+    function cancel(message, title = localized.status.canceled) {
+        if (message)
+            console.log(`${redBanner} ${errorPill(title)}${red(dot, message)}`);
+    }
+    return {
+        log,
+        step,
+        info,
+        note,
+        success,
+        warn,
+        error,
+        cancel,
+    };
+}
+
+const messages = await getLocalized();
+const logger = useLogger(messages);
+class ShellError extends Error {
+    constructor(message) {
+        super(message);
+        // Убедимся, что экземпляр имеет правильный прототип
+        Object.setPrototypeOf(this, ShellError.prototype);
+        this.name = 'ShellError';
+        this.message = message;
+        Error.captureStackTrace(this, ShellError);
+    }
+}
+/**
+ * @typedef ExecutionResult
+ * @property {boolean} isDone
+ * @property {number} code
+ * @property {string} stderr
+ * @property {string} stdout
+ */
+async function execAsync(command, args, options) {
+    args ??= [];
+    return new Promise((resolve, reject) => {
+        const runner = spawn(command, args, {
+            stdio: [
+                'ignore', // stdin
+                'pipe', // stdout
+                'pipe', // stderr
+            ],
+            ...options,
+            shell: process.platform === 'win32',
+        });
+        const stdoutChunks = [];
+        const stderrChunks = [];
+        runner.stdout?.on('data', (chunk) => {
+            stdoutChunks.push(chunk);
+        });
+        runner.stderr?.on('data', (chunk) => {
+            stderrChunks.push(chunk);
+        });
+        runner.on('error', (error) => {
+            reject(error);
+        });
+        runner.on('exit', (code) => {
+            const isDone = code === 0;
+            const stdout = Buffer.concat(stdoutChunks).toString().trim();
+            const stderr = Buffer.concat(stderrChunks).toString().trim();
+            if (isDone) {
+                resolve({ isDone, code, stdout, stderr });
+            }
+            else {
+                reject(new ShellError(`Failed to execute command ${command} ${args.join(' ')}: ${stderr}`));
+            }
+        });
+    });
+}
+const runCommandAsync = async (command, args, options = {}) => await execAsync(command, args, { ...options });
+const dryRunCommandAsync = (command, args) => {
+    logger.info(`${command} ${args?.join(' ')}`, 'Dry');
+};
+runCommandAsync.ifNotDry = (isDryRun) => isDryRun ? dryRunCommandAsync : runCommandAsync;
+
+export { ShellError as S, getLocale as a, getLocalized as g, runCommandAsync as r, useLogger as u };