@mono-labs/cli 0.0.237 → 0.0.242

package/bin/mono.js

@@ -1,2 +1,2 @@
 #!/usr/bin/env node
-import '../lib/index.js'
+require('../dist/lib/index.js')

package/dist/index.js

@@ -1,56 +1,37 @@
 "use strict";
 // Main entry point for @mono-labs/cli package
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.filterUnwantedEnvVarsEAS = exports.filterUnwantedEnvVars = exports.generateNewEnvList = void 0;
-exports.setData = setData;
-exports.mergeData = mergeData;
-exports.getData = getData;
-exports.hasData = hasData;
-exports.replaceTokens = replaceTokens;
-const filterUnwantedEnvVars_js_1 = require("./expo-files/filterUnwantedEnvVars.js");
-Object.defineProperty(exports, "filterUnwantedEnvVars", { enumerable: true, get: function () { return filterUnwantedEnvVars_js_1.filterUnwantedEnvVars; } });
-Object.defineProperty(exports, "filterUnwantedEnvVarsEAS", { enumerable: true, get: function () { return filterUnwantedEnvVars_js_1.filterUnwantedEnvVarsEAS; } });
-Object.defineProperty(exports, "generateNewEnvList", { enumerable: true, get: function () { return filterUnwantedEnvVars_js_1.generateNewEnvList; } });
-const dataLayer = Object.create(null);
-function setData(key, value) {
-    if (value !== undefined) {
-        dataLayer[key] = value;
-    }
-}
-function mergeData(obj = {}) {
-    Object.entries(obj).forEach(([k, v]) => setData(k, v));
-    return dataLayer;
-}
-function getData(key) {
-    return key ? dataLayer[key] : dataLayer;
-}
-function hasData(key) {
-    return Object.prototype.hasOwnProperty.call(dataLayer, key);
-}
-/* ------------------------------------------------------------------
- * Token replacement
- * ------------------------------------------------------------------ */
-function replaceTokens(str, env) {
-    if (typeof str !== 'string')
-        return str;
-    return str.replace(/\$\{([^}]+)\}|\$([A-Z0-9_]+)/g, (_match, k1, k2) => {
-        const key = k1 || k2;
-        // data layer takes priority
-        if (hasData(key)) {
-            const val = getData(key);
-            return val == null ? '' : String(val);
-        }
-        // environment variables
-        if (env && Object.prototype.hasOwnProperty.call(env, key)) {
-            const val = env[key];
-            return val == null ? '' : String(val);
-        }
-        return '';
-    });
-}
+exports.verifyOptionValue = exports.runMonoCommand = exports.buildCommands = exports.getRootJson = exports.getRootDirectory = exports.getMonoConfig = exports.boot = exports.hasData = exports.getData = exports.mergeData = exports.setData = exports.replaceTokens = exports.filterUnwantedEnvVarsEAS = exports.filterUnwantedEnvVars = exports.generateNewEnvList = void 0;
+var generateNewEnvList_1 = require("./lib/generateNewEnvList");
+Object.defineProperty(exports, "generateNewEnvList", { enumerable: true, get: function () { return generateNewEnvList_1.generateNewEnvList; } });
+var filterUnwantedEnvVars_1 = require("./lib/filterUnwantedEnvVars");
+Object.defineProperty(exports, "filterUnwantedEnvVars", { enumerable: true, get: function () { return filterUnwantedEnvVars_1.filterUnwantedEnvVars; } });
+Object.defineProperty(exports, "filterUnwantedEnvVarsEAS", { enumerable: true, get: function () { return filterUnwantedEnvVars_1.filterUnwantedEnvVarsEAS; } });
+var dataLayer_1 = require("./lib/commands/build-process/dataLayer");
+Object.defineProperty(exports, "replaceTokens", { enumerable: true, get: function () { return dataLayer_1.replaceTokens; } });
+Object.defineProperty(exports, "setData", { enumerable: true, get: function () { return dataLayer_1.setData; } });
+Object.defineProperty(exports, "mergeData", { enumerable: true, get: function () { return dataLayer_1.mergeData; } });
+Object.defineProperty(exports, "getData", { enumerable: true, get: function () { return dataLayer_1.getData; } });
+Object.defineProperty(exports, "hasData", { enumerable: true, get: function () { return dataLayer_1.hasData; } });
+var boot_1 = require("./lib/commands/build-process/boot");
+Object.defineProperty(exports, "boot", { enumerable: true, get: function () { return boot_1.boot; } });
+var loadFromRoot_1 = require("./lib/commands/loadFromRoot");
+Object.defineProperty(exports, "getMonoConfig", { enumerable: true, get: function () { return loadFromRoot_1.getMonoConfig; } });
+Object.defineProperty(exports, "getRootDirectory", { enumerable: true, get: function () { return loadFromRoot_1.getRootDirectory; } });
+Object.defineProperty(exports, "getRootJson", { enumerable: true, get: function () { return loadFromRoot_1.getRootJson; } });
+var cliFactory_1 = require("./lib/commands/build-process/cliFactory");
+Object.defineProperty(exports, "buildCommands", { enumerable: true, get: function () { return cliFactory_1.buildCommands; } });
+var runMonoCommand_1 = require("./lib/commands/build-process/runMonoCommand");
+Object.defineProperty(exports, "runMonoCommand", { enumerable: true, get: function () { return runMonoCommand_1.runMonoCommand; } });
+var validators_1 = require("./lib/commands/build-process/validators");
+Object.defineProperty(exports, "verifyOptionValue", { enumerable: true, get: function () { return validators_1.verifyOptionValue; } });
+const generateNewEnvList_2 = require("./lib/generateNewEnvList");
+const filterUnwantedEnvVars_2 = require("./lib/filterUnwantedEnvVars");
+const dataLayer_2 = require("./lib/commands/build-process/dataLayer");
+// Default export for convenience
 exports.default = {
-    generateNewEnvList: filterUnwantedEnvVars_js_1.generateNewEnvList,
-    replaceTokens,
-    filterUnwantedEnvVars: filterUnwantedEnvVars_js_1.filterUnwantedEnvVars,
-    filterUnwantedEnvVarsEAS: filterUnwantedEnvVars_js_1.filterUnwantedEnvVarsEAS,
+    replaceTokens: dataLayer_2.replaceTokens,
+    generateNewEnvList: generateNewEnvList_2.generateNewEnvList,
+    filterUnwantedEnvVars: filterUnwantedEnvVars_2.filterUnwantedEnvVars,
+    filterUnwantedEnvVarsEAS: filterUnwantedEnvVars_2.filterUnwantedEnvVarsEAS,
 };

package/dist/lib/app.js

@@ -0,0 +1,52 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateEnvValues = exports.program = void 0;
+const commander_1 = require("commander");
+const config_1 = require("./config");
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = require("node:path");
+function findNearestPackageJson(startDir) {
+    let current = startDir;
+    while (true) {
+        const candidate = (0, node_path_1.join)(current, 'package.json');
+        if (node_fs_1.default.existsSync(candidate))
+            return candidate;
+        const parent = (0, node_path_1.dirname)(current);
+        if (parent === current) {
+            throw new Error('Unable to locate package.json for CLI');
+        }
+        current = parent;
+    }
+}
+const pkgPath = findNearestPackageJson(__dirname);
+const pkg = JSON.parse(node_fs_1.default.readFileSync(pkgPath, 'utf8'));
+const version = pkg.version || '0.0.1';
+exports.program = new commander_1.Command();
+const getBinFromPackageJSON = () => {
+    const keyList = Object.keys(pkg.bin ?? {});
+    if (keyList.length === 0) {
+        throw new Error('No bin field found in package.json');
+    }
+    return keyList[0];
+};
+const programName = getBinFromPackageJSON();
+exports.program
+    .name(programName)
+    .description(pkg.description || '')
+    .version(version);
+const NEXT_PUBLIC_API_URL = ((process.env.NEXT_PUBLIC_API_URL &&
+    process.env.NEXT_PUBLIC_API_URL.length > 0) ||
+    config_1.STAGING_URL);
+const generateEnvValues = (forceProd = false, ngrokUrl = 'localhost:3000', useAtlas = false) => {
+    return {
+        ...process.env,
+        NEXT_PUBLIC_API_URL,
+        NEXT_FORCE_PROD: String(forceProd),
+        EXPO_PRIVATE_API_URL: ngrokUrl,
+        EXPO_UNSTABLE_ATLAS: String(useAtlas),
+    };
+};
+exports.generateEnvValues = generateEnvValues;

package/dist/lib/commands/build-process/boot.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.boot = boot;
+// Boot logic: load root + mono configuration
+const loadFromRoot_1 = require("../loadFromRoot");
+function boot() {
+    const rootDir = (0, loadFromRoot_1.getRootDirectory)();
+    const rootJson = (0, loadFromRoot_1.getRootJson)();
+    const { files, config } = (0, loadFromRoot_1.getMonoConfig)();
+    return { rootDir, rootJson, files, config };
+}
+exports.default = boot;

package/dist/lib/commands/build-process/cliFactory.js

@@ -0,0 +1,145 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createConfigCommands = createConfigCommands;
+exports.createCliCommands = createCliCommands;
+exports.buildCommands = buildCommands;
+const app_1 = require("../../app");
+const commander_1 = require("commander");
+const runMonoCommand_1 = __importDefault(require("./runMonoCommand"));
+const validators_1 = require("./validators");
+const dataLayer_1 = require("./dataLayer");
+const loadFromRoot_1 = require("../loadFromRoot");
+const prune_1 = require("../prune/prune");
+const testflag_1 = require("./testflag");
+function buildDefaultLookup(config) {
+    const defaults = {};
+    // Handle argument default
+    if (config.argument?.default !== undefined) {
+        defaults.arg = config.argument.default;
+    }
+    // Handle options defaults
+    if (config.options) {
+        for (const [key, option] of Object.entries(config.options)) {
+            if (option.default !== undefined) {
+                defaults[key] = option.default;
+            }
+        }
+    }
+    return defaults;
+}
+/**
+ * Register commander commands for each mono file definition.
+ * Handles argument, options, validation, and action wiring.
+ */
+function createConfigCommands() {
+    const config = new commander_1.Command('config').description('Manage configuration');
+    config
+        .command('set <key> <value>')
+        .description('Set a configuration value')
+        .action((_key, _value) => { });
+    config
+        .command('get <key>')
+        .description('Get a configuration value')
+        .action((_key) => { });
+    config
+        .command('list')
+        .description('List all configuration values')
+        .action(() => { });
+    return config;
+}
+function createCliCommands() {
+    const tools = new commander_1.Command('tools').description('Manage tools');
+    tools
+        .command('prune')
+        .description('Prune unused branches in git')
+        .action(() => {
+        (0, prune_1.pruneRepo)();
+    });
+    return tools;
+}
+function buildCommands(files) {
+    try {
+        const { config } = (0, loadFromRoot_1.getMonoConfig)();
+        Object.entries(files).forEach(([commandName, configObject]) => {
+            const optionsData = configObject.options || {};
+            let current = app_1.program
+                .command(commandName)
+                .description(configObject.description || 'Mono command');
+            const argInfo = configObject.argument;
+            // Argument
+            if (argInfo) {
+                const required = !!argInfo.required;
+                const type = argInfo.type || 'string';
+                const argSpec = required ? `<${type}>` : `[${type}]`;
+                current = current.argument(argSpec, argInfo.description || '');
+            }
+            // Options
+            Object.entries(optionsData).forEach(([optionKey, meta]) => {
+                const type = meta.type || 'boolean';
+                const shortcut = meta.shortcut ? `-${meta.shortcut}, ` : '';
+                if (type === 'string') {
+                    current = current.option(`${shortcut}--${optionKey} <${optionKey}>`, meta.description || '');
+                }
+                else {
+                    current = current.option(`${shortcut}--${optionKey}`, meta.description || '');
+                }
+            });
+            config.prodFlag = config.prodFlag || 'prod';
+            current = current.option(`--${config.prodFlag}`, 'Process execution mode: prduction or dev', false);
+            current.action(async (arg, cmd) => {
+                const envDefaults = {};
+                const optionValueList = argInfo?.options;
+                let actualOptions = optionValueList;
+                if (optionValueList) {
+                    actualOptions = argInfo?.allowAll ? [...optionValueList, 'all'] : [...optionValueList];
+                }
+                if (argInfo) {
+                    if (argInfo &&
+                        optionValueList &&
+                        actualOptions &&
+                        !actualOptions.includes(String(arg ?? argInfo.default))) {
+                        throw new Error(`Invalid argument value for ${commandName}, must be one of: ${actualOptions.join(', ')}`);
+                    }
+                }
+                const optionsDataList = Object.keys(optionsData).map((key) => ({
+                    ...optionsData[key],
+                    name: key,
+                }));
+                optionsDataList.forEach((item) => {
+                    if (item.default) {
+                        envDefaults[item.name] = item.default;
+                    }
+                });
+                try {
+                    const optionVals = {
+                        ...envDefaults,
+                        ...(cmd.opts ? cmd.opts() : cmd),
+                    };
+                    Object.keys(optionVals).forEach((k) => {
+                        optionVals[k] = (0, validators_1.verifyOptionValue)(k, optionVals[k], optionsData);
+                    });
+                    optionVals['prod'] = optionVals[config.prodFlag] || false;
+                    const defaultLookups = buildDefaultLookup(configObject);
+                    const argVal = arg || configObject.argument?.default;
+                    const args = { ...defaultLookups, arg: argVal };
+                    if (testflag_1.testFlag) {
+                        console.log('defaults', optionVals);
+                        console.log('object', { ...optionVals, ...args });
+                    }
+                    (0, dataLayer_1.mergeData)({ ...optionVals, ...args });
+                    await (0, runMonoCommand_1.default)(configObject, optionVals);
+                }
+                catch (err) {
+                    console.error('Error executing mono command:', err?.message);
+                }
+            });
+        });
+    }
+    catch (err) {
+        console.error('Error executing mono command:', err?.message);
+    }
+}
+exports.default = buildCommands;

package/dist/lib/commands/build-process/dataLayer.js

@@ -0,0 +1,56 @@
+"use strict";
+// Shared mutable key/value store for build-process commands.
+// Extracts dynamic values from preactions and holds defaults from options.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setData = setData;
+exports.mergeData = mergeData;
+exports.getData = getData;
+exports.hasData = hasData;
+exports.replaceTokens = replaceTokens;
+const testflag_1 = require("./testflag");
+const dataLayer = {};
+function setData(key, value) {
+    if (testflag_1.testFlag) {
+        console.log(`→ dataLayer set: ${key} = ${String(value)}`);
+    }
+    if (value !== undefined)
+        dataLayer[key] = value;
+}
+function mergeData(obj = {}) {
+    if (testflag_1.testFlag) {
+        console.log(`→ dataLayer mergeData: ${JSON.stringify(obj)}`);
+    }
+    Object.entries(obj).forEach(([k, v]) => setData(k, v));
+    return dataLayer;
+}
+function getData(key) {
+    if (testflag_1.testFlag) {
+        console.log(`→ dataLayer get: ${String(key)}`);
+    }
+    return key ? dataLayer[key] : dataLayer;
+}
+function hasData(key) {
+    return Object.prototype.hasOwnProperty.call(dataLayer, key);
+}
+function replaceTokens(str, env) {
+    if (typeof str !== 'string')
+        return str;
+    console.log('→ replaceTokens called');
+    console.log('dataLayer:', dataLayer);
+    return str.replace(/\$\{([^}]+)\}|\$([A-Z0-9_]+)/g, (_m, k1, k2) => {
+        const k = (k1 || k2);
+        // existing data layer takes priority
+        if (hasData(k)) {
+            const val = getData(k);
+            return val == null ? '' : String(val);
+        }
+        // environment variables
+        if (env && Object.prototype.hasOwnProperty.call(env, k)) {
+            const val = env[k];
+            return val == null ? '' : String(val);
+        }
+        // fallback
+        return '';
+    });
+}
+exports.default = dataLayer;

package/dist/lib/commands/build-process/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// Orchestrator for modular build-process command system.
+const boot_1 = require("./boot");
+const cliFactory_1 = require("./cliFactory");
+const processManager_1 = require("./runners/processManager");
+const app_1 = require("../../app");
+const { files } = (0, boot_1.boot)();
+(0, processManager_1.ensureSignalHandlers)();
+(0, cliFactory_1.buildCommands)(files);
+app_1.program.addCommand((0, cliFactory_1.createCliCommands)());

package/dist/lib/commands/build-process/readEnv.js

@@ -0,0 +1,34 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseEnvFile = parseEnvFile;
+// scripts/read-env.mjs
+const node_fs_1 = __importDefault(require("node:fs"));
+function parseEnvFile(filePath) {
+    if (!node_fs_1.default.existsSync(filePath)) {
+        return {};
+    }
+    const content = node_fs_1.default.readFileSync(filePath, 'utf8');
+    const keymap = {};
+    for (const line of content.split(/\r?\n/)) {
+        const trimmed = line.trim();
+        // skip empty lines and comments
+        if (!trimmed || trimmed.startsWith('#'))
+            continue;
+        // split on first "=" only
+        const idx = trimmed.indexOf('=');
+        if (idx === -1)
+            continue;
+        const key = trimmed.slice(0, idx).trim();
+        let value = trimmed.slice(idx + 1).trim();
+        // strip surrounding quotes if present
+        if ((value.startsWith('"') && value.endsWith('"')) ||
+            (value.startsWith("'") && value.endsWith("'"))) {
+            value = value.slice(1, -1);
+        }
+        keymap[key] = value;
+    }
+    return keymap;
+}

package/dist/lib/commands/build-process/runMonoCommand.js

@@ -0,0 +1,82 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAllowAllKeys = getAllowAllKeys;
+exports.runMonoCommand = runMonoCommand;
+const runForeground_1 = require("./runners/runForeground");
+const runBackground_1 = require("./runners/runBackground");
+const processManager_1 = require("./runners/processManager");
+const loadFromRoot_1 = require("../loadFromRoot");
+const readEnv_1 = require("./readEnv");
+const node_path_1 = __importDefault(require("node:path"));
+function getAllowAllKeys(cfg) {
+    const decls = cfg.options ?? {};
+    return Object.entries(decls)
+        .filter(([, v]) => Boolean(v?.allowAll) &&
+        Array.isArray(v?.options) &&
+        v.options.length > 0)
+        .map(([k]) => k);
+}
+/**
+ * Orchestrate execution of a single mono command definition.
+ * Phases:
+ *  1. Preactions (sequential, blocking) via runForeground
+ *  2. Actions (background except last; last attached) via runBackground
+ * Environment selection based on --stage flag and injection of AWS_PROFILE.
+ */
+async function runMonoCommand(configObject, options = {}) {
+    const { config } = (0, loadFromRoot_1.getMonoConfig)();
+    const devConfig = configObject.environments?.dev ?? {};
+    console.log('configObject:', JSON.stringify(configObject, null, 2));
+    // Usage:
+    const envPath = node_path_1.default.resolve(process.cwd(), '.env');
+    const keymap = (0, readEnv_1.parseEnvFile)(envPath);
+    const prodConfig = configObject.environments?.prod ?? {};
+    const awsProfile = process.env.CDK_DEPLOY_PROFILE || 'default';
+    const envObjBase = options.prod ? { ...prodConfig } : { ...devConfig };
+    Object.keys(envObjBase).forEach((k) => {
+        if (typeof envObjBase[k] === 'string' &&
+            envObjBase[k].startsWith('$') &&
+            !envObjBase[k].startsWith('${')) {
+            const refKey = envObjBase[k].substring(1);
+            envObjBase[k] = keymap[refKey] || '';
+        }
+    });
+    envObjBase.AWS_PROFILE = awsProfile;
+    const envKeys = Object.keys(process.env).filter((k) => k.startsWith('MONO_'));
+    const envMapList = config.envMap ?? ['FAILURE'];
+    const combinedEnv = { ...process.env, ...envObjBase };
+    const envMapVals = {};
+    envKeys.forEach((k) => {
+        envMapList.forEach((item) => {
+            envMapVals[k.replace('MONO', item)] = combinedEnv[k];
+        });
+    });
+    const envObj = { ...envObjBase, ...envMapVals };
+    const preactions = configObject.preactions ?? [];
+    const actions = configObject.actions ?? [];
+    console.log(`→ Executing mono command: ${configObject.name || 'Unnamed Command'}`);
+    console.log(`→ Using AWS profile: ${awsProfile}`);
+    console.log(`→ Using environment: ${options.stage ? 'stage' : 'dev'}`);
+    console.log('→ Environment variables:', envObj);
+    // Run preactions sequentially
+    for (const cmd of preactions) {
+        await (0, runForeground_1.runForeground)(cmd, envObj);
+    }
+    if (actions.length === 0)
+        return;
+    const bg = actions.slice(0, -1);
+    const fg = actions[actions.length - 1];
+    for (const cmd of bg) {
+        void (0, runBackground_1.runBackground)(cmd, envObj, 'background');
+    }
+    try {
+        await (0, runBackground_1.runBackground)(fg, envObj, 'foreground', true);
+    }
+    finally {
+        (0, processManager_1.killAllBackground)();
+    }
+}
+exports.default = runMonoCommand;

package/dist/lib/commands/build-process/runners/processManager.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.bgChildren = void 0;
+exports.registerBackground = registerBackground;
+exports.killAllBackground = killAllBackground;
+exports.ensureSignalHandlers = ensureSignalHandlers;
+const child_process_1 = require("child_process");
+// Track background processes so we can kill them on exit
+exports.bgChildren = new Set();
+function registerBackground(child) {
+    exports.bgChildren.add(child);
+}
+function killAllBackground() {
+    for (const child of Array.from(exports.bgChildren)) {
+        try {
+            if (process.platform === 'win32') {
+                (0, child_process_1.spawn)('taskkill', ['/PID', String(child.pid), '/T', '/F'], {
+                    shell: true,
+                    stdio: 'ignore',
+                });
+            }
+            else if (child.pid) {
+                process.kill(-child.pid, 'SIGTERM');
+            }
+        }
+        catch {
+            // ignore
+        }
+    }
+    exports.bgChildren.clear();
+}
+let signalsRegistered = false;
+function ensureSignalHandlers() {
+    if (signalsRegistered)
+        return;
+    signalsRegistered = true;
+    process.on('SIGINT', () => {
+        killAllBackground();
+        process.exit(130);
+    });
+    process.on('SIGTERM', () => {
+        killAllBackground();
+        process.exit(143);
+    });
+}

package/dist/lib/commands/build-process/runners/runBackground.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runBackground = runBackground;
+const child_process_1 = require("child_process");
+const dataLayer_1 = require("../dataLayer");
+const processManager_1 = require("./processManager");
+function createdExpandedEnv(envObj) {
+    const expandedEnv = {};
+    for (const k of Object.keys(envObj)) {
+        const v = envObj[k];
+        expandedEnv[k] = typeof v === 'string' ? (0, dataLayer_1.replaceTokens)(v) : v;
+    }
+    return expandedEnv;
+}
+function runBackground(cmd, envObj = {}, logName = 'background', attached = false) {
+    const isWin = process.platform === 'win32';
+    // Replace ${field} tokens in env values using dataLayer
+    const expandedEnv = createdExpandedEnv(envObj);
+    console.log(`→ ${logName} action ${attached ? '(attached)' : ''}: ${cmd}`);
+    // Replace in command string
+    const outCmd = (0, dataLayer_1.replaceTokens)(cmd);
+    console.log(`→ ${logName} action ${attached ? '(attached)' : ''}: ${outCmd}`);
+    return new Promise((resolve, reject) => {
+        const child = (0, child_process_1.spawn)(outCmd, {
+            shell: true,
+            stdio: attached ? 'inherit' : 'ignore',
+            env: { ...process.env, ...expandedEnv },
+            detached: !attached && !isWin,
+            windowsHide: !attached && isWin,
+        });
+        if (!attached && !isWin)
+            child.unref();
+        (0, processManager_1.registerBackground)(child);
+        child.once('error', (err) => {
+            reject(err);
+        });
+        child.once('exit', (code, signal) => {
+            if (signal)
+                return reject(new Error(`${cmd} exited via signal ${signal}`));
+            if (code === 0)
+                return resolve();
+            reject(new Error(`${cmd} exited with code ${code}`));
+        });
+    });
+}
+exports.default = runBackground;

package/dist/lib/commands/build-process/runners/runForeground.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runForeground = runForeground;
+const child_process_1 = require("child_process");
+const dataLayer_1 = require("../dataLayer");
+const filterUnwantedEnvVars_1 = require("../../../../lib/filterUnwantedEnvVars");
+// Regex to capture tokens like: {out:field value}
+const TOKEN_RX = /\{out:(?<field>[^\s}]+)\s+(?<value>[^\s}]+)\}/g;
+/**
+ * Run a command in the foreground, capturing stdout/stderr. Extracts token patterns
+ * of the form {out:field value} and stores them in the shared dataLayer.
+ */
+function runForeground(cmd, envObj = {}, _options = {}) {
+    const filteredEnv = (0, filterUnwantedEnvVars_1.filterUnwantedEnvVars)(process.env);
+    const newEnv = { ...filteredEnv, ...envObj };
+    const newCmd = (0, dataLayer_1.replaceTokens)(cmd, newEnv);
+    return new Promise((resolve, reject) => {
+        let lastLine = '';
+        let buffer = '';
+        const child = (0, child_process_1.spawn)(newCmd, [], {
+            shell: true,
+            env: { ...newEnv },
+            stdio: ['inherit', 'pipe', 'pipe'],
+        });
+        const handleData = (chunk) => {
+            const text = chunk.toString();
+            buffer += text;
+            const lines = text.trim().split(/\r?\n/);
+            if (lines.length)
+                lastLine = lines[lines.length - 1];
+            process.stdout.write(text); // echo output
+        };
+        child.stdout.on('data', handleData);
+        child.stderr.on('data', handleData);
+        child.on('error', reject);
+        child.on('exit', (code, signal) => {
+            // Extract tokens and populate dataLayer
+            for (const match of buffer.matchAll(TOKEN_RX)) {
+                const groups = match.groups;
+                if (groups?.field) {
+                    (0, dataLayer_1.setData)(groups.field, groups.value);
+                }
+            }
+            if (signal)
+                return reject(new Error(`${cmd} exited via signal ${signal}`));
+            if (code === 0)
+                return resolve(lastLine);
+            reject(new Error(`${cmd} exited with code ${code}. Last line: ${lastLine}`));
+        });
+    });
+}
+exports.default = runForeground;