@mainset/cli 0.1.0-rc.1

package/LICENSE

@@ -0,0 +1,2 @@
+This work is licensed under the Creative Commons Attribution-NonCommercial 4.0 International License.
+To view a copy of this license, visit http://creativecommons.org/licenses/by-nc/4.0/

package/dist/esm/@types/process.env.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/commands/index.mjs

@@ -0,0 +1,3 @@
+export * from './node-package.mjs';
+export * from './source-code.mjs';
+export * from './web-app.mjs';

package/dist/esm/commands/node-package.mjs

@@ -0,0 +1,64 @@
+import fs from 'fs';
+import path from 'path';
+import { runtimePathById } from '../runtime/index.mjs';
+import { consoleColorize, initProcessCatchErrorLogger, } from '../utils/index.mjs';
+import { execPurgeDist, execRslibCLICommand, execTypeScriptCompileTypeOnly, runRslibCLICommand, runTypeScriptCompileTypeOnly, } from './process-runner-chunks/index.mjs';
+function registerNodePackageCommand(program) {
+    program
+        .command('node-package')
+        .description('Run node package build or watch using Rslib')
+        .requiredOption('-e, --exec <type>', 'Execution mode: build or watch')
+        // .option('-b, --builder <builder>', 'Builder tool (default: rslib)', 'rslib')
+        .option('-c, --config <path>', 'Path to config file', './rslib.config.mts')
+        .action(async (options) => {
+        // Step 0: determinate command params
+        const customRslibConfigPath = path.resolve(runtimePathById.root, options.config);
+        const rslibConfigPath = fs.existsSync(customRslibConfigPath)
+            ? customRslibConfigPath
+            : path.resolve(runtimePathById.root, 
+            // NOTE: possibility to check if package is installed, otherwise throw error
+            'node_modules', '@mainset/builder-rslib/dist/esm/rslib.node-package.config.mjs');
+        if (options.exec === 'build') {
+            // ========== Build mode ==========
+            console.log('\n🏗️  [mainset cli] node-package: build');
+            try {
+                // Step 1: purge dist folder
+                execPurgeDist();
+                // Step 2: build source code
+                console.log('\n📦 Compiling Source Code with Rslib ...');
+                await execRslibCLICommand(`build --config ${rslibConfigPath}`);
+                // Step 3: build type only
+                await execTypeScriptCompileTypeOnly();
+                console.log('\n✅ Build completed successfully\n');
+            }
+            catch (error) {
+                initProcessCatchErrorLogger('node-package', error, 'build');
+            }
+        }
+        else if (options.exec === 'watch') {
+            // ========== Watch mode ==========
+            console.log('\n🏗️  [mainset cli] node-package: watch');
+            try {
+                // Step 1: purge dist folder
+                execPurgeDist();
+                // Step 2: watch source code
+                await runRslibCLICommand([
+                    'build',
+                    '--config',
+                    rslibConfigPath,
+                    '--watch',
+                ]);
+                // Step 3: watch type only
+                await runTypeScriptCompileTypeOnly();
+            }
+            catch (error) {
+                initProcessCatchErrorLogger('node-package', error, 'watch');
+            }
+        }
+        else {
+            console.error(consoleColorize('BRIGHT_YELLOW', `[mainset cli][node-package] Unknown exec mode: "${options.exec}"`));
+            process.exit(1);
+        }
+    });
+}
+export { registerNodePackageCommand };

package/dist/esm/commands/process-runner-chunks/index.mjs

@@ -0,0 +1,3 @@
+export * from './rslib.chunk.mjs';
+export * from './system.chunk.mjs';
+export * from './typescript.chunk.mjs';

package/dist/esm/commands/process-runner-chunks/rslib.chunk.mjs

@@ -0,0 +1,15 @@
+import { resolveHostPackageBinForCLICommandPath } from '../../runtime/index.mjs';
+import { execImmediateCommand, runStreamingCommand, } from '../../utils/index.mjs';
+async function getRslibCLICommandPath() {
+    const rslibCLICommandPath = await resolveHostPackageBinForCLICommandPath('@mainset/builder-rslib', '@rslib/core', 'rslib');
+    return rslibCLICommandPath;
+}
+async function execRslibCLICommand(command) {
+    const rslibCLICommandPath = await getRslibCLICommandPath();
+    return execImmediateCommand(`node ${rslibCLICommandPath} ${command}`);
+}
+async function runRslibCLICommand(commandParams) {
+    const rslibCLICommandPath = await getRslibCLICommandPath();
+    return runStreamingCommand('node', [rslibCLICommandPath, ...commandParams]);
+}
+export { execRslibCLICommand, runRslibCLICommand };

package/dist/esm/commands/process-runner-chunks/system.chunk.mjs

@@ -0,0 +1,8 @@
+import { runtimePathById } from '../../runtime/index.mjs';
+import { execImmediateCommand } from '../../utils/index.mjs';
+// Cleanup
+function execPurgeDist() {
+    console.log('🧹 Cleaning dist folder ...');
+    execImmediateCommand(`rm -rf ${runtimePathById.dist}`);
+}
+export { execPurgeDist };

package/dist/esm/commands/process-runner-chunks/typescript.chunk.mjs

@@ -0,0 +1,48 @@
+import path from 'path';
+import { resolveHostPackageBinForCLICommandPath, runtimePathById, } from '../../runtime/index.mjs';
+import { execImmediateCommand, runStreamingCommand, } from '../../utils/index.mjs';
+async function getTscCLICommandPath() {
+    const tscCLICommandPath = await resolveHostPackageBinForCLICommandPath('@mainset/dev-stack-fe', 'typescript', 'tsc');
+    return tscCLICommandPath;
+}
+// Source code
+async function execTypeScriptCompileSourceCode({ configPath, }) {
+    const tscCLICommandPath = await getTscCLICommandPath();
+    console.log('\n📦 Compiling Source Code with TypeScript ...');
+    execImmediateCommand(`node ${tscCLICommandPath} --project ${configPath}`);
+}
+async function runTypeScriptCompileSourceCode({ configPath, }) {
+    const tscCLICommandPath = await getTscCLICommandPath();
+    console.log('\n📝 Compiling .d.ts Types in watch mode ...');
+    runStreamingCommand('node', [
+        tscCLICommandPath,
+        '--project',
+        configPath,
+        '--watch',
+    ]);
+}
+// Type only
+function getTypeScriptTypeOnlyConfigPath() {
+    const customTypeScriptTypeOnlyConfigPath = path.join(runtimePathById.root, './tsconfig.build-type.json');
+    return {
+        configPath: customTypeScriptTypeOnlyConfigPath,
+    };
+}
+async function execTypeScriptCompileTypeOnly() {
+    const { configPath } = getTypeScriptTypeOnlyConfigPath();
+    const tscCLICommandPath = await getTscCLICommandPath();
+    console.log('\n📝 Compiling .d.ts Types in build mode ...');
+    execImmediateCommand(`node ${tscCLICommandPath} --project ${configPath}`);
+}
+async function runTypeScriptCompileTypeOnly() {
+    const { configPath } = getTypeScriptTypeOnlyConfigPath();
+    const tscCLICommandPath = await getTscCLICommandPath();
+    console.log('\n📝 Compiling .d.ts Types in watch mode ...');
+    runStreamingCommand('node', [
+        tscCLICommandPath,
+        '--project',
+        configPath,
+        '--watch',
+    ]);
+}
+export { execTypeScriptCompileSourceCode, execTypeScriptCompileTypeOnly, runTypeScriptCompileSourceCode, runTypeScriptCompileTypeOnly, };

package/dist/esm/commands/source-code.mjs

@@ -0,0 +1,56 @@
+import path from 'path';
+import { runtimePathById } from '../runtime/index.mjs';
+import { consoleColorize, initProcessCatchErrorLogger, } from '../utils/index.mjs';
+import { execPurgeDist, execTypeScriptCompileSourceCode, execTypeScriptCompileTypeOnly, runTypeScriptCompileSourceCode, runTypeScriptCompileTypeOnly, } from './process-runner-chunks/index.mjs';
+function registerSourceCodeCommand(program) {
+    program
+        .command('source-code')
+        .description('Run source code compile or watch using TypeScript')
+        .requiredOption('-e, --exec <type>', 'Execution mode: compile or watch')
+        // .option('-b, --builder <builder>', 'Compiler tool (default: tsc)', 'tsc')
+        .option('-c, --config <path>', 'Path to config file', './tsconfig.json')
+        .action(async (options) => {
+        // Step 0: determinate command params
+        const typeScriptSourceCodeConfigPath = path.join(runtimePathById.root, options.config);
+        if (options.exec === 'compile') {
+            // ========== Compile mode ==========
+            console.log('\n🏗️  [mainset cli] source-code: compile');
+            try {
+                // Step 1: purge dist folder
+                execPurgeDist();
+                // Step 2: compile source code
+                await execTypeScriptCompileSourceCode({
+                    configPath: typeScriptSourceCodeConfigPath,
+                });
+                // Step 3: compile type only
+                await execTypeScriptCompileTypeOnly();
+                console.log('\n✅ Build completed successfully\n');
+            }
+            catch (error) {
+                initProcessCatchErrorLogger('source-code', error, 'compile');
+            }
+        }
+        else if (options.exec === 'watch') {
+            // ========== Watch mode ==========
+            console.log('\n🏗️  [mainset cli] source-code: watch');
+            try {
+                // Step 1: purge dist folder
+                execPurgeDist();
+                // Step 2: watch source code
+                await runTypeScriptCompileSourceCode({
+                    configPath: typeScriptSourceCodeConfigPath,
+                });
+                // Step 3: watch type only
+                await runTypeScriptCompileTypeOnly();
+            }
+            catch (error) {
+                initProcessCatchErrorLogger('source-code', error, 'watch');
+            }
+        }
+        else {
+            console.error(consoleColorize('BRIGHT_YELLOW', `[mainset cli][source-code] Unknown exec mode: "${options.exec}"`));
+            process.exit(1);
+        }
+    });
+}
+export { registerSourceCodeCommand };

package/dist/esm/commands/web-app.mjs

@@ -0,0 +1,136 @@
+import fs from 'fs';
+import path from 'path';
+import { resolveHostPackageBinForCLICommandPath, runtimePathById, } from '../runtime/index.mjs';
+import { consoleColorize, execImmediateCommand, initProcessCatchErrorLogger, runStreamingCommand, } from '../utils/index.mjs';
+import { execPurgeDist, execRslibCLICommand, runRslibCLICommand, } from './process-runner-chunks/index.mjs';
+function registerWebAppCommand(program) {
+    program
+        .command('web-app')
+        .description('Run web app build or serve using bundler')
+        .requiredOption('-e, --exec <type>', 'Execution mode: build, serve, serve-static')
+        // .option(
+        //   '-b, --bundler <bundler>',
+        //   'Bundler tool: webpack or rslib (default: webpack)',
+        //   'webpack'
+        // )
+        .option('-c, --config <path>', 'Path to config file')
+        .option('--serveMode <mode>', 'Serve mode: ssr or csr (default: ssr)', 'ssr')
+        .action(async (options) => {
+        // Step 0: determinate command params
+        const customWebpackConfigPath = path.resolve(runtimePathById.root, options.config || './config/webpack.config.mjs');
+        // Webpack paths
+        const webpackCLICommandPath = await resolveHostPackageBinForCLICommandPath('@mainset/bundler-webpack', 'webpack', 'webpack');
+        const webpackSSRConfigPath = fs.existsSync(customWebpackConfigPath)
+            ? customWebpackConfigPath
+            : path.resolve(runtimePathById.root, 'node_modules', '@mainset/bundler-webpack/dist/esm/webpack-config/webapp.ssr.config.mjs');
+        const rslibSSRConfigPath = path.resolve(runtimePathById.root, 'node_modules', '@mainset/builder-rslib/dist/esm/rslib.ssr-server.config.mjs');
+        if (options.exec === 'build') {
+            // ========== Build mode ==========
+            console.log('\n🏗️  [mainset cli] web-app: build');
+            try {
+                if (options.serveMode === 'ssr') {
+                    // ========== [Build] SSR mode ==========
+                    // Step 1: purge dist folder
+                    execPurgeDist();
+                    // Step 2: build:ssr-webapp source code
+                    console.log('\n📦 Compiling SSR WebApp with Webpack ...');
+                    execImmediateCommand(`node ${webpackCLICommandPath} --config ${webpackSSRConfigPath}`);
+                    // Step 3: build:ssr-server source code
+                    console.log('\n📦 Compiling SSR Server with Rslib ...');
+                    await execRslibCLICommand(`build --config ${rslibSSRConfigPath}`);
+                    console.log('\n✅ SSR Build completed successfully\n');
+                }
+                else {
+                    // ========== [Build] CSR mode ==========
+                    const webpackCSRConfigPath = fs.existsSync(customWebpackConfigPath)
+                        ? customWebpackConfigPath
+                        : path.resolve(runtimePathById.root, 'node_modules', '@mainset/bundler-webpack/dist/esm/webpack-config/webapp.csr.config.mjs');
+                    // Step 1: purge dist folder
+                    execPurgeDist();
+                    // Step 2: build:csr-webapp source code
+                    console.log('\n📦 Compiling CSR WebApp with Webpack ...');
+                    execImmediateCommand(`node ${webpackCLICommandPath} --config ${webpackCSRConfigPath}`);
+                    console.log('\n✅ CSR Build completed successfully\n');
+                }
+            }
+            catch (error) {
+                initProcessCatchErrorLogger('web-app', error, 'build');
+            }
+        }
+        else if (options.exec === 'serve') {
+            // ========== Serve mode ==========
+            console.log('\n🏗️  [mainset cli] web-app: serve');
+            try {
+                if (options.serveMode === 'ssr') {
+                    // ========== [Serve] SSR mode ==========
+                    const ssrServerEntryPath = path.resolve(runtimePathById.msCLISrc, '../services/ssr-server/ssr-server.mjs');
+                    const ssrServerConfigCompiledPath = path.resolve(runtimePathById.dist, './private/ssr-server.config.mjs');
+                    // Step 1: watch:ssr-server start ssr server
+                    await runRslibCLICommand([
+                        'build',
+                        '--config',
+                        rslibSSRConfigPath,
+                        '--watch',
+                    ]);
+                    // Step 2: watch:ssr-webapp source code of web app
+                    runStreamingCommand('node', [
+                        webpackCLICommandPath,
+                        '--config',
+                        webpackSSRConfigPath,
+                        '--watch',
+                    ]);
+                    // Step 3: start:ssr-server which is compiled web app and ssr-server code
+                    runStreamingCommand('node', [
+                        '--watch', // Enable watch mode for {node}
+                        ssrServerEntryPath,
+                        '--ssrServerConfig',
+                        ssrServerConfigCompiledPath,
+                    ]);
+                }
+                else {
+                    // ========== [Serve] CSR mode ==========
+                    const webpackDevServerCLICommandPath = await resolveHostPackageBinForCLICommandPath('@mainset/bundler-webpack', 'webpack-dev-server');
+                    const webpackDevServerConfigPath = fs.existsSync(customWebpackConfigPath)
+                        ? customWebpackConfigPath
+                        : path.resolve(runtimePathById.root, 'node_modules', '@mainset/bundler-webpack/dist/esm/webpack-config/dev-server.csr.config.mjs');
+                    // Step 1: watch:csr-server / start:csr-server source code
+                    runStreamingCommand('node', [
+                        webpackDevServerCLICommandPath,
+                        '--config',
+                        webpackDevServerConfigPath,
+                        '--open',
+                    ]);
+                }
+            }
+            catch (error) {
+                initProcessCatchErrorLogger('web-app', error, 'watch');
+            }
+        }
+        else if (options.exec === 'serve-static') {
+            // ========== Serve static mode ==========
+            console.log('\n🏗️  [mainset cli] web-app: serve-static');
+            try {
+                // Step 1: determinate command params
+                const serverEntryPath = path.resolve(runtimePathById.msCLISrc, '../services/serve-static/serve-static.mjs');
+                const customServeStaticConfigPath = path.resolve(runtimePathById.root, options.config || './config/serve-static.config.json');
+                const serveStaticConfigPath = fs.existsSync(customServeStaticConfigPath)
+                    ? customServeStaticConfigPath
+                    : path.resolve(runtimePathById.msCLISrc, '../services/express-base-app/express-base-app.config.json');
+                // Step 2: serve static compiled files
+                runStreamingCommand('node', [
+                    serverEntryPath,
+                    '--serveStaticConfig',
+                    serveStaticConfigPath,
+                ]);
+            }
+            catch (error) {
+                initProcessCatchErrorLogger('web-app', error, 'serve-static');
+            }
+        }
+        else {
+            console.error(consoleColorize('BRIGHT_YELLOW', `[mainset cli][web-app] Unknown exec mode: "${options.exec}"`));
+            process.exit(1);
+        }
+    });
+}
+export { registerWebAppCommand };

package/dist/esm/mainset-cli.mjs

@@ -0,0 +1,15 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import { registerNodePackageCommand, registerSourceCodeCommand, registerWebAppCommand, } from './commands/index.mjs';
+import { verifyOrSetNodeEnv } from './utils/index.mjs';
+// !IMPORTANT: Set NODE_ENV is case it is not passed
+verifyOrSetNodeEnv();
+const program = new Command();
+program
+    .name('ms-cli')
+    .description('CLI to manage frontend tooling and infrastructure')
+    .version('0.1.0');
+registerSourceCodeCommand(program);
+registerNodePackageCommand(program);
+registerWebAppCommand(program);
+program.parse(process.argv);

package/dist/esm/runtime/constants.mjs

@@ -0,0 +1,5 @@
+const NODE_ENV = {
+    DEVELOPMENT: 'development',
+    PRODUCTION: 'production',
+};
+export { NODE_ENV };

package/dist/esm/runtime/index.mjs

@@ -0,0 +1,3 @@
+export { NODE_ENV } from './constants.mjs';
+export { runtimePathById } from './path.mjs';
+export { resolveHostPackageBinForCLICommandPath, resolveHostPackageNodeModulesPath, } from './resolve-host-package.mjs';

package/dist/esm/runtime/path.mjs

@@ -0,0 +1,13 @@
+import path from 'path';
+import { fileURLToPath } from 'url';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const root = process.cwd();
+const runtimePathById = {
+    // Relative to executable project
+    root,
+    dist: path.join(root, 'dist'),
+    src: path.join(root, 'src'),
+    // Relative to file being executed
+    msCLISrc: __dirname,
+};
+export { runtimePathById };

package/dist/esm/runtime/resolve-host-package.mjs

@@ -0,0 +1,20 @@
+import fs from 'fs';
+import path from 'path';
+import { runtimePathById } from './path.mjs';
+function resolveHostPackageNodeModulesPath(hostPackageName, dependencyPackageName) {
+    const hostPackageNodeModulesPath = path.resolve(runtimePathById.root, `node_modules/${hostPackageName}/node_modules`);
+    const isNodeModulesDeepNested = fs.existsSync(hostPackageNodeModulesPath);
+    return isNodeModulesDeepNested // Pnpm uses such a structure
+        ? path.join(hostPackageNodeModulesPath, dependencyPackageName)
+        : path.join(runtimePathById.root, 'node_modules', dependencyPackageName);
+}
+async function resolveHostPackageBinForCLICommandPath(hostPackageName, dependencyPackageName, cliCommandName) {
+    // Pnpm node_modules structure
+    const dependencyPackageNodeModulesPath = resolveHostPackageNodeModulesPath(hostPackageName, dependencyPackageName);
+    const packageJson = await import(path.join(dependencyPackageNodeModulesPath, 'package.json'), { with: { type: 'json' } });
+    const binPath = cliCommandName
+        ? packageJson.default.bin[cliCommandName]
+        : packageJson.default.bin;
+    return path.join(dependencyPackageNodeModulesPath, binPath);
+}
+export { resolveHostPackageBinForCLICommandPath, resolveHostPackageNodeModulesPath, };

package/dist/esm/services/express-base-app/express-base-app.config.json

@@ -0,0 +1,9 @@
+{
+    "listenPort": 3000,
+    "serveStatics": [
+        {
+            "rootPath": "./dist",
+            "publicPath": "/"
+        }
+    ]
+}

package/dist/esm/services/express-base-app/express-base-app.mjs

@@ -0,0 +1,38 @@
+import express from 'express';
+import path from 'path';
+// Import type { Options } from 'http-proxy-middleware';
+import { runtimePathById } from '../../runtime/index.mjs';
+import defaultExpressConfig from './express-base-app.config.json' with { type: 'json' };
+class ExpressBaseApp {
+    // ========== Constructor ==========
+    constructor(customExpressConfig = {}) {
+        const { listenPort = defaultExpressConfig.listenPort, serveStatics } = customExpressConfig;
+        this.listenPort = listenPort;
+        this.app = express();
+        this.appUseStatic({
+            serveStatics,
+        });
+        this.startListening = this.startListening.bind(this);
+    }
+    // ========== Private ==========
+    appUseStatic({ serveStatics, }) {
+        serveStatics === null || serveStatics === void 0 ? void 0 : serveStatics.forEach((customServeStaticConfig) => {
+            const serveStaticConfig = Object.assign(Object.assign({}, defaultExpressConfig.serveStatics[0]), customServeStaticConfig);
+            this.app.use(serveStaticConfig.publicPath, express.static(serveStaticConfig.rootPath));
+        });
+    }
+    // Private appUseProxy() {
+    //   app.use('/api', createProxyMiddleware(proxyConfig['/api/']));
+    //   app.use('/api-local', createProxyMiddleware(proxyConfig['/api-local/']));
+    //   app.use('/api-boilerplate', createProxyMiddleware(proxyConfig['/api-boilerplate/']));
+    // }
+    // ========== Public ==========
+    async startListening() {
+        this.app.listen(this.listenPort, async () => {
+            var _a;
+            const packageJson = await import(path.resolve(runtimePathById.root, 'package.json'), { with: { type: 'json' } });
+            console.log(`${((_a = packageJson === null || packageJson === void 0 ? void 0 : packageJson.default) === null || _a === void 0 ? void 0 : _a.name) || 'Web App'} listening at http://localhost:${this.listenPort}`);
+        });
+    }
+}
+export { ExpressBaseApp };

package/dist/esm/services/express-base-app/index.mjs

@@ -0,0 +1,2 @@
+export * from './express-base-app.mjs';
+export { default as defaultExpressConfig } from './express-base-app.config.json' with { type: 'json' };

package/dist/esm/services/serve-static/serve-static-config-loader.mjs

@@ -0,0 +1,14 @@
+import { Command } from 'commander';
+import fs from 'fs';
+// Step-1: parse CLI arguments
+const options = new Command()
+    .option('--serveStaticConfig <path>', 'Path to ./config/serve-static.config.json config file')
+    .allowUnknownOption() // Bypass {error: unknown option '--config'}
+    .allowExcessArguments() // Bypass {error: too many arguments. Expected 0 arguments but got 2.}
+    .parse(process.argv)
+    .opts();
+// Step-2: load Serve Static config from JSON file
+const serveStaticConfig = options.serveStaticConfig
+    ? JSON.parse(fs.readFileSync(options.serveStaticConfig, 'utf-8'))
+    : {};
+export { serveStaticConfig };

package/dist/esm/services/serve-static/serve-static.mjs

@@ -0,0 +1,4 @@
+import { ExpressBaseApp } from '../express-base-app/index.mjs';
+import { serveStaticConfig } from './serve-static-config-loader.mjs';
+const { startListening } = new ExpressBaseApp(serveStaticConfig);
+startListening();

package/dist/esm/services/ssr-server/global.mjs

@@ -0,0 +1,8 @@
+const global = {
+    init() {
+        if (typeof window === 'undefined') {
+            global.window = false;
+        }
+    },
+};
+export default global;

package/dist/esm/services/ssr-server/index.mjs

@@ -0,0 +1 @@
+export {};

package/dist/esm/services/ssr-server/ssr-server-config-loader.mjs

@@ -0,0 +1,12 @@
+import { Command } from 'commander';
+// Step-1: parse CLI arguments
+const options = new Command()
+    .option('--ssrServerConfig <path>', 'Path to ./config/ssr-server.config.mts config file')
+    .allowUnknownOption() // Bypass {error: unknown option '--config'}
+    .allowExcessArguments() // Bypass {error: too many arguments. Expected 0 arguments but got 2.}
+    .parse(process.argv)
+    .opts();
+// Step-2: load SSR server config from JSON file
+const ssrServerConfig = (await import(options.ssrServerConfig))
+    .default;
+export { ssrServerConfig };

package/dist/esm/services/ssr-server/ssr-server.mjs

@@ -0,0 +1,43 @@
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import cors from 'cors';
+import { ExpressBaseApp } from '../express-base-app/index.mjs';
+import global from './global.mjs';
+import { ssrServerConfig } from './ssr-server-config-loader.mjs';
+const { renderSSRContentByPath } = ssrServerConfig, customExpressConfig = __rest(ssrServerConfig, ["renderSSRContentByPath"]);
+global.init();
+const { app, startListening } = new ExpressBaseApp(customExpressConfig);
+app.use(cors());
+// Get all path which is not starts from api
+Object.keys(renderSSRContentByPath).forEach((renderSSRContentPath) => {
+    app.get(renderSSRContentPath, async (req, res) => {
+        try {
+            // Construct the full URL for the incoming request
+            const fullUrl = `${req.protocol}://${req.get('host')}${req.url}`;
+            const renderSSRContent = renderSSRContentByPath[renderSSRContentPath];
+            const htmlContent = await renderSSRContent({
+                reqUrl: req.url,
+                fullUrl,
+            });
+            res.send(htmlContent);
+        }
+        catch (error) {
+            if (error instanceof Response && error.status === 302) {
+                // Handle redirects
+                res.redirect(error.headers.get('Location') || '/');
+            }
+            console.error(error);
+            res.status(500).send('Internal Server Error');
+        }
+    });
+});
+startListening();

package/dist/esm/utils/console-colorize.mjs

@@ -0,0 +1,25 @@
+const TERMINAL_COLOR__BY_KEY = {
+    RESET: '\x1b[0m',
+    // Regular colors
+    RED: '\x1b[31m',
+    GREEN: '\x1b[32m',
+    YELLOW: '\x1b[33m',
+    BLUE: '\x1b[34m',
+    // Bright colors
+    BRIGHT_RED: '\x1b[91m',
+    BRIGHT_GREEN: '\x1b[92m',
+    BRIGHT_YELLOW: '\x1b[93m',
+};
+const EMOJI__BY_COLOR_KEY = {
+    RED: '❌',
+    BRIGHT_RED: '❌',
+    YELLOW: '⚠️',
+    BRIGHT_YELLOW: '⚠️',
+    GREEN: '✅',
+    BRIGHT_GREEN: '✅',
+};
+const consoleColorize = (color, text) => {
+    const emoji = color ? `${EMOJI__BY_COLOR_KEY[color]}  ` : '';
+    return `${emoji}${TERMINAL_COLOR__BY_KEY[color]}${text}${TERMINAL_COLOR__BY_KEY.RESET}`;
+};
+export { consoleColorize };

package/dist/esm/utils/index.mjs

@@ -0,0 +1,3 @@
+export * from './console-colorize.mjs';
+export * from './process-runner/index.mjs';
+export * from './verify-or-set-node-env.mjs';

package/dist/esm/utils/process-runner/index.mjs

@@ -0,0 +1 @@
+export * from './process-runner.mjs';

package/dist/esm/utils/process-runner/process-manager.mjs

@@ -0,0 +1,44 @@
+import { initProcessCatchErrorLogger } from './process-runner.mjs';
+class ProcessManager {
+    constructor() {
+        this.processes = new Set();
+        this.setupCleanupHandlers();
+    }
+    static getInstance() {
+        ProcessManager.instance || (ProcessManager.instance = new ProcessManager());
+        return ProcessManager.instance;
+    }
+    setupCleanupHandlers() {
+        process.on('SIGINT', () => this.cleanup('SIGINT'));
+        process.on('SIGTERM', () => this.cleanup('SIGTERM'));
+        process.on('uncaughtException', (error) => {
+            console.error('Uncaught Exception:', error);
+            this.cleanup('uncaughtException');
+        });
+    }
+    cleanup(signal) {
+        console.log(`\nCleaning up processes (signal: ${signal})...`);
+        this.processes.forEach((proc) => {
+            if (!proc.killed) {
+                proc.kill('SIGTERM');
+            }
+        });
+        this.processes.clear();
+        process.exit();
+    }
+    trackProcess(proc) {
+        this.processes.add(proc);
+        proc.on('exit', () => {
+            this.processes.delete(proc);
+        });
+        proc.on('error', (error) => {
+            initProcessCatchErrorLogger('ProcessManager.trackProcess', error);
+            this.processes.delete(proc);
+        });
+    }
+    getRunningProcessesCount() {
+        return this.processes.size;
+    }
+}
+const processManager = ProcessManager.getInstance();
+export { processManager };

package/dist/esm/utils/process-runner/process-runner.mjs

@@ -0,0 +1,56 @@
+import { execSync, spawn } from 'child_process';
+import { consoleColorize } from '../index.mjs';
+import { processManager } from './process-manager.mjs';
+function initProcessCatchErrorLogger(commandName, error, commandParam) {
+    const commandParamLog = commandParam ? ` ${commandParam} ` : ' ';
+    if (error instanceof Error) {
+        // Log
+        console.error(consoleColorize('BRIGHT_RED', `[mainset cli][${commandName}]${commandParamLog}Failed:`), error.message);
+        // Exit
+        process.exit(1);
+    }
+    else {
+        // Log
+        console.error(consoleColorize('BRIGHT_RED', `[mainset cli][${commandName}]${commandParamLog}Failed with an unknown error:`), error);
+        // Exit
+        process.exit(1);
+    }
+}
+/**
+ * Executes a short-lived command synchronously.
+ * The entire command string, including its arguments, must be passed.
+ *
+ * Example: execImmediateCommand('rspack --config ./config/rspack.config.ts');
+ */
+function execImmediateCommand(fullCommandString) {
+    try {
+        execSync(fullCommandString, { stdio: 'inherit' });
+    }
+    catch (error) {
+        initProcessCatchErrorLogger('execImmediateCommand', error);
+    }
+}
+/**
+ * Runs a long-lived streaming command asynchronously.
+ * The command and its arguments must be passed separately.
+ *
+ * Example: runStreamingCommand('rspack', ['serve', '--config', './config/rspack.config.ts']);
+ */
+function runStreamingCommand(command, args) {
+    try {
+        const child = spawn(command, args, {
+            stdio: 'inherit',
+            shell: true,
+        });
+        // Track the process using ProcessManager as it could live in the background after crashing
+        // Examples: server stacks when files removed while server is running
+        // 1. rm -rf ./dist
+        // 2. rm -rf ./node_modules
+        processManager.trackProcess(child);
+        child.on('exit', (code) => process.exit(code !== null && code !== void 0 ? code : 1));
+    }
+    catch (error) {
+        initProcessCatchErrorLogger('runStreamingCommand', error);
+    }
+}
+export { execImmediateCommand, initProcessCatchErrorLogger, runStreamingCommand, };

package/dist/esm/utils/verify-or-set-node-env.mjs

@@ -0,0 +1,13 @@
+import { NODE_ENV } from '../runtime/index.mjs';
+import { consoleColorize } from './console-colorize.mjs';
+function verifyOrSetNodeEnv() {
+    if (!process.env.NODE_ENV) {
+        console.warn(consoleColorize('BRIGHT_YELLOW', `[mainset cli] NODE_ENV is not set. Falling back to "${NODE_ENV.PRODUCTION}".`));
+        process.env.NODE_ENV = NODE_ENV.PRODUCTION;
+    }
+    else if (!Object.values(NODE_ENV).includes(process.env.NODE_ENV)) {
+        console.warn(consoleColorize('BRIGHT_YELLOW', `[mainset cli] Unsupported NODE_ENV "${process.env.NODE_ENV}". Falling back to "${NODE_ENV.PRODUCTION}".`));
+        process.env.NODE_ENV = NODE_ENV.PRODUCTION;
+    }
+}
+export { verifyOrSetNodeEnv };

package/dist/types/@types/process.env.d.ts

@@ -0,0 +1,11 @@
+import type { NodeEnv } from '../runtime/index.mjs';
+interface ProcessEnvBase {
+    NODE_ENV?: NodeEnv;
+}
+declare global {
+    namespace NodeJS {
+        interface ProcessEnv extends ProcessEnvBase {
+        }
+    }
+}
+export type { ProcessEnvBase };

package/dist/types/commands/index.d.mts

@@ -0,0 +1,3 @@
+export * from './node-package.mjs';
+export * from './source-code.mjs';
+export * from './web-app.mjs';

package/dist/types/commands/node-package.d.mts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+declare function registerNodePackageCommand(program: Command): void;
+export { registerNodePackageCommand };

package/dist/types/commands/process-runner-chunks/index.d.mts

@@ -0,0 +1,3 @@
+export * from './rslib.chunk.mjs';
+export * from './system.chunk.mjs';
+export * from './typescript.chunk.mjs';

package/dist/types/commands/process-runner-chunks/rslib.chunk.d.mts

@@ -0,0 +1,3 @@
+declare function execRslibCLICommand(command: string): Promise<void>;
+declare function runRslibCLICommand(commandParams: string[]): Promise<void>;
+export { execRslibCLICommand, runRslibCLICommand };

package/dist/types/commands/process-runner-chunks/system.chunk.d.mts

@@ -0,0 +1,2 @@
+declare function execPurgeDist(): void;
+export { execPurgeDist };

package/dist/types/commands/process-runner-chunks/typescript.chunk.d.mts

@@ -0,0 +1,9 @@
+declare function execTypeScriptCompileSourceCode({ configPath, }: {
+    configPath: string;
+}): Promise<void>;
+declare function runTypeScriptCompileSourceCode({ configPath, }: {
+    configPath: string;
+}): Promise<void>;
+declare function execTypeScriptCompileTypeOnly(): Promise<void>;
+declare function runTypeScriptCompileTypeOnly(): Promise<void>;
+export { execTypeScriptCompileSourceCode, execTypeScriptCompileTypeOnly, runTypeScriptCompileSourceCode, runTypeScriptCompileTypeOnly, };

package/dist/types/commands/source-code.d.mts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+declare function registerSourceCodeCommand(program: Command): void;
+export { registerSourceCodeCommand };

package/dist/types/commands/web-app.d.mts

@@ -0,0 +1,3 @@
+import { Command } from 'commander';
+declare function registerWebAppCommand(program: Command): void;
+export { registerWebAppCommand };

package/dist/types/mainset-cli.d.mts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/types/runtime/constants.d.mts

@@ -0,0 +1,7 @@
+declare const NODE_ENV: {
+    readonly DEVELOPMENT: "development";
+    readonly PRODUCTION: "production";
+};
+type NodeEnv = (typeof NODE_ENV)[keyof typeof NODE_ENV];
+export { NODE_ENV };
+export type { NodeEnv };

package/dist/types/runtime/index.d.mts

@@ -0,0 +1,4 @@
+export { NODE_ENV } from './constants.mjs';
+export type { NodeEnv } from './constants.mjs';
+export { runtimePathById } from './path.mjs';
+export { resolveHostPackageBinForCLICommandPath, resolveHostPackageNodeModulesPath, } from './resolve-host-package.mjs';

package/dist/types/runtime/path.d.mts

@@ -0,0 +1,7 @@
+declare const runtimePathById: {
+    root: string;
+    dist: string;
+    src: string;
+    msCLISrc: string;
+};
+export { runtimePathById };

package/dist/types/runtime/resolve-host-package.d.mts

@@ -0,0 +1,3 @@
+declare function resolveHostPackageNodeModulesPath(hostPackageName: string, dependencyPackageName: string): string;
+declare function resolveHostPackageBinForCLICommandPath(hostPackageName: string, dependencyPackageName: string, cliCommandName?: string): Promise<string>;
+export { resolveHostPackageBinForCLICommandPath, resolveHostPackageNodeModulesPath, };

package/dist/types/services/express-base-app/express-base-app.d.mts

@@ -0,0 +1,18 @@
+import { Express } from 'express';
+interface ServeStaticConfig {
+    rootPath?: string;
+    publicPath?: string;
+}
+interface ExpressBaseAppConfig {
+    listenPort?: number;
+    serveStatics?: ServeStaticConfig[];
+}
+declare class ExpressBaseApp {
+    private readonly listenPort;
+    readonly app: Express;
+    constructor(customExpressConfig?: Partial<ExpressBaseAppConfig>);
+    private appUseStatic;
+    startListening(): Promise<void>;
+}
+export { ExpressBaseApp };
+export type { ExpressBaseAppConfig };

package/dist/types/services/express-base-app/index.d.mts

@@ -0,0 +1,2 @@
+export * from './express-base-app.mjs';
+export { default as defaultExpressConfig } from './express-base-app.config.json';

package/dist/types/services/serve-static/serve-static-config-loader.d.mts

@@ -0,0 +1,3 @@
+import type { ExpressBaseAppConfig } from '../express-base-app/index.mjs';
+declare const serveStaticConfig: ExpressBaseAppConfig;
+export { serveStaticConfig };

package/dist/types/services/serve-static/serve-static.d.mts

@@ -0,0 +1 @@
+export {};

package/dist/types/services/ssr-server/global.d.mts

@@ -0,0 +1,6 @@
+type GlobalBrowser = {
+    window?: boolean;
+    init: () => void;
+};
+declare const global: GlobalBrowser;
+export default global;

package/dist/types/services/ssr-server/index.d.mts

@@ -0,0 +1 @@
+export type { SSRConfigParams } from './ssr-server-config-loader.mjs';

package/dist/types/services/ssr-server/ssr-server-config-loader.d.mts

@@ -0,0 +1,11 @@
+import type { ExpressBaseAppConfig } from '../express-base-app/index.mjs';
+interface SSRConfigParams extends Partial<ExpressBaseAppConfig> {
+    renderSSRContentByPath: Record<string, // URL path to render SSR content
+    (_params: {
+        reqUrl: string;
+        fullUrl: string;
+    }) => Promise<string>>;
+}
+declare const ssrServerConfig: SSRConfigParams;
+export { ssrServerConfig };
+export type { SSRConfigParams };

package/dist/types/services/ssr-server/ssr-server.d.mts

@@ -0,0 +1 @@
+export {};

package/dist/types/utils/console-colorize.d.mts

@@ -0,0 +1,12 @@
+declare const TERMINAL_COLOR__BY_KEY: {
+    readonly RESET: "\u001B[0m";
+    readonly RED: "\u001B[31m";
+    readonly GREEN: "\u001B[32m";
+    readonly YELLOW: "\u001B[33m";
+    readonly BLUE: "\u001B[34m";
+    readonly BRIGHT_RED: "\u001B[91m";
+    readonly BRIGHT_GREEN: "\u001B[92m";
+    readonly BRIGHT_YELLOW: "\u001B[93m";
+};
+declare const consoleColorize: (color: keyof typeof TERMINAL_COLOR__BY_KEY, text: string) => string;
+export { consoleColorize };

package/dist/types/utils/index.d.mts

@@ -0,0 +1,3 @@
+export * from './console-colorize.mjs';
+export * from './process-runner/index.mjs';
+export * from './verify-or-set-node-env.mjs';

package/dist/types/utils/process-runner/index.d.mts

@@ -0,0 +1 @@
+export * from './process-runner.mjs';

package/dist/types/utils/process-runner/process-manager.d.mts

@@ -0,0 +1,13 @@
+import { type ChildProcess } from 'child_process';
+declare class ProcessManager {
+    private static instance;
+    private processes;
+    private constructor();
+    static getInstance(): ProcessManager;
+    private setupCleanupHandlers;
+    private cleanup;
+    trackProcess(proc: ChildProcess): void;
+    getRunningProcessesCount(): number;
+}
+declare const processManager: ProcessManager;
+export { processManager };

package/dist/types/utils/process-runner/process-runner.d.mts

@@ -0,0 +1,16 @@
+declare function initProcessCatchErrorLogger(commandName: string, error: Error | unknown, commandParam?: string): void;
+/**
+ * Executes a short-lived command synchronously.
+ * The entire command string, including its arguments, must be passed.
+ *
+ * Example: execImmediateCommand('rspack --config ./config/rspack.config.ts');
+ */
+declare function execImmediateCommand(fullCommandString: string): void;
+/**
+ * Runs a long-lived streaming command asynchronously.
+ * The command and its arguments must be passed separately.
+ *
+ * Example: runStreamingCommand('rspack', ['serve', '--config', './config/rspack.config.ts']);
+ */
+declare function runStreamingCommand(command: string, args: string[]): void;
+export { execImmediateCommand, initProcessCatchErrorLogger, runStreamingCommand, };

package/dist/types/utils/verify-or-set-node-env.d.mts

@@ -0,0 +1,2 @@
+declare function verifyOrSetNodeEnv(): void;
+export { verifyOrSetNodeEnv };

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@mainset/cli",
+  "version": "0.1.0-rc.1",
+  "description": "A unified CLI tool for accelerating development, based on mainset vision of front-end infrastructure",
+  "homepage": "https://github.com/mainset/dev-stack-fe/tree/main/packages/cli",
+  "bugs": {
+    "url": "https://github.com/mainset/dev-stack-fe/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/mainset/dev-stack-fe.git"
+  },
+  "license": "CC-BY-NC-4.0",
+  "author": "yevhen uzhva",
+  "type": "module",
+  "sideEffects": false,
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    "./runtime": {
+      "types": "./dist/types/runtime/index.d.mts",
+      "import": "./dist/esm/runtime/index.mjs"
+    },
+    "./process-env-type": "./dist/types/@types/process.env.d.ts",
+    "./ssr-server": {
+      "types": "./dist/types/services/ssr-server/index.d.mts"
+    }
+  },
+  "bin": {
+    "ms-cli": "./dist/esm/mainset-cli.mjs"
+  },
+  "dependencies": {
+    "@types/node": "^24.0.3",
+    "commander": "^14.0.0",
+    "cors": "^2.8.5",
+    "cross-env": "^7.0.3",
+    "express": "^5.1.0",
+    "http-proxy-middleware": "^3.0.5"
+  },
+  "devDependencies": {
+    "@types/cors": "^2.8.19",
+    "@types/express": "^5.0.3",
+    "@types/node": "^24.0.3",
+    "@mainset/dev-stack-fe": "^0.1.0-rc.1"
+  },
+  "peerDependencies": {
+    "@mainset/dev-stack-fe": "0.1.0"
+  },
+  "scripts": {
+    "build:source": "node ./node_modules/@mainset/dev-stack-fe/node_modules/typescript/bin/tsc --project ./tsconfig.json",
+    "build:type": "node ./node_modules/@mainset/dev-stack-fe/node_modules/typescript/bin/tsc --project ./tsconfig.build-type.json",
+    "build": "npm run purge:dist && npm run build:source && npm run build:type",
+    "dev": "cross-env NODE_ENV=development npm run build && node ./dist/esm/mainset-cli.mjs source-code --exec watch",
+    "purge:dist": "rm -rf ./dist"
+  }
+}