@mainset/cli 0.1.0 → 0.2.0-rc.1

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

@@ -2,7 +2,7 @@ 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';
+import { execImmediatePurgeDist, execImmediateRslibCLICommand, execImmediateTypeScriptCompileTypeOnly, runStreamingRslibCLICommand, runStreamingTypeScriptCompileTypeOnly, } from './process-runner-chunks/index.mjs';
 function registerNodePackageCommand(program) {
     program
         .command('node-package')
@@ -10,7 +10,7 @@ function registerNodePackageCommand(program) {
         .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) => {
+        .action((options) => {
         // Step 0: determinate command params
         const customRslibConfigPath = path.resolve(runtimePathById.root, options.config);
         const rslibConfigPath = fs.existsSync(customRslibConfigPath)
@@ -23,12 +23,12 @@ function registerNodePackageCommand(program) {
             console.log('\n🏗️  [mainset cli] node-package: build');
             try {
                 // Step 1: purge dist folder
-                execPurgeDist();
+                execImmediatePurgeDist();
                 // Step 2: build source code
                 console.log('\n📦 Compiling Source Code with Rslib ...');
-                await execRslibCLICommand(`build --config ${rslibConfigPath}`);
+                execImmediateRslibCLICommand(`build --config ${rslibConfigPath}`);
                 // Step 3: build type only
-                await execTypeScriptCompileTypeOnly();
+                execImmediateTypeScriptCompileTypeOnly();
                 console.log('\n✅ Build completed successfully\n');
             }
             catch (error) {
@@ -40,16 +40,16 @@ function registerNodePackageCommand(program) {
             console.log('\n🏗️  [mainset cli] node-package: watch');
             try {
                 // Step 1: purge dist folder
-                execPurgeDist();
+                execImmediatePurgeDist();
                 // Step 2: watch source code
-                await runRslibCLICommand([
+                runStreamingRslibCLICommand([
                     'build',
                     '--config',
                     rslibConfigPath,
                     '--watch',
                 ]);
                 // Step 3: watch type only
-                await runTypeScriptCompileTypeOnly();
+                runStreamingTypeScriptCompileTypeOnly();
             }
             catch (error) {
                 initProcessCatchErrorLogger('node-package', error, 'watch');

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

@@ -1,15 +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');
+function getRslibCLICommandPath() {
+    const rslibCLICommandPath = resolveHostPackageBinForCLICommandPath('@mainset/builder-rslib', 'rslib');
     return rslibCLICommandPath;
 }
-async function execRslibCLICommand(command) {
-    const rslibCLICommandPath = await getRslibCLICommandPath();
-    return execImmediateCommand(`node ${rslibCLICommandPath} ${command}`);
+function execImmediateRslibCLICommand(command) {
+    const rslibCLICommandPath = getRslibCLICommandPath();
+    return execImmediateCommand(`${rslibCLICommandPath} ${command}`);
 }
-async function runRslibCLICommand(commandParams) {
-    const rslibCLICommandPath = await getRslibCLICommandPath();
-    return runStreamingCommand('node', [rslibCLICommandPath, ...commandParams]);
+function runStreamingRslibCLICommand(commandParams) {
+    const rslibCLICommandPath = getRslibCLICommandPath();
+    return runStreamingCommand(rslibCLICommandPath, [...commandParams]);
 }
-export { execRslibCLICommand, runRslibCLICommand };
+export { execImmediateRslibCLICommand, runStreamingRslibCLICommand };

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

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

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

@@ -1,25 +1,20 @@
 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');
+function getTscCLICommandPath() {
+    const tscCLICommandPath = resolveHostPackageBinForCLICommandPath('@mainset/dev-stack-fe', 'tsc');
     return tscCLICommandPath;
 }
 // Source code
-async function execTypeScriptCompileSourceCode({ configPath, }) {
-    const tscCLICommandPath = await getTscCLICommandPath();
+function execImmediateTypeScriptCompileSourceCode({ configPath, }) {
+    const tscCLICommandPath = getTscCLICommandPath();
     console.log('\n📦 Compiling Source Code with TypeScript ...');
-    execImmediateCommand(`node ${tscCLICommandPath} --project ${configPath}`);
+    execImmediateCommand(`${tscCLICommandPath} --project ${configPath}`);
 }
-async function runTypeScriptCompileSourceCode({ configPath, }) {
-    const tscCLICommandPath = await getTscCLICommandPath();
+function runStreamingTypeScriptCompileSourceCode({ configPath, }) {
+    const tscCLICommandPath = getTscCLICommandPath();
     console.log('\n📝 Compiling .d.ts Types in watch mode ...');
-    runStreamingCommand('node', [
-        tscCLICommandPath,
-        '--project',
-        configPath,
-        '--watch',
-    ]);
+    runStreamingCommand(tscCLICommandPath, ['--project', configPath, '--watch']);
 }
 // Type only
 function getTypeScriptTypeOnlyConfigPath() {
@@ -28,21 +23,16 @@ function getTypeScriptTypeOnlyConfigPath() {
         configPath: customTypeScriptTypeOnlyConfigPath,
     };
 }
-async function execTypeScriptCompileTypeOnly() {
+function execImmediateTypeScriptCompileTypeOnly() {
     const { configPath } = getTypeScriptTypeOnlyConfigPath();
-    const tscCLICommandPath = await getTscCLICommandPath();
+    const tscCLICommandPath = getTscCLICommandPath();
     console.log('\n📝 Compiling .d.ts Types in build mode ...');
-    execImmediateCommand(`node ${tscCLICommandPath} --project ${configPath}`);
+    execImmediateCommand(`${tscCLICommandPath} --project ${configPath}`);
 }
-async function runTypeScriptCompileTypeOnly() {
+function runStreamingTypeScriptCompileTypeOnly() {
     const { configPath } = getTypeScriptTypeOnlyConfigPath();
-    const tscCLICommandPath = await getTscCLICommandPath();
+    const tscCLICommandPath = getTscCLICommandPath();
     console.log('\n📝 Compiling .d.ts Types in watch mode ...');
-    runStreamingCommand('node', [
-        tscCLICommandPath,
-        '--project',
-        configPath,
-        '--watch',
-    ]);
+    runStreamingCommand(tscCLICommandPath, ['--project', configPath, '--watch']);
 }
-export { execTypeScriptCompileSourceCode, execTypeScriptCompileTypeOnly, runTypeScriptCompileSourceCode, runTypeScriptCompileTypeOnly, };
+export { execImmediateTypeScriptCompileSourceCode, execImmediateTypeScriptCompileTypeOnly, runStreamingTypeScriptCompileSourceCode, runStreamingTypeScriptCompileTypeOnly, };

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

@@ -1,7 +1,7 @@
 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';
+import { execImmediatePurgeDist, execImmediateTypeScriptCompileSourceCode, execImmediateTypeScriptCompileTypeOnly, runStreamingTypeScriptCompileSourceCode, runStreamingTypeScriptCompileTypeOnly, } from './process-runner-chunks/index.mjs';
 function registerSourceCodeCommand(program) {
     program
         .command('source-code')
@@ -9,7 +9,7 @@ function registerSourceCodeCommand(program) {
         .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) => {
+        .action((options) => {
         // Step 0: determinate command params
         const typeScriptSourceCodeConfigPath = path.join(runtimePathById.root, options.config);
         if (options.exec === 'compile') {
@@ -17,13 +17,13 @@ function registerSourceCodeCommand(program) {
             console.log('\n🏗️  [mainset cli] source-code: compile');
             try {
                 // Step 1: purge dist folder
-                execPurgeDist();
+                execImmediatePurgeDist();
                 // Step 2: compile source code
-                await execTypeScriptCompileSourceCode({
+                execImmediateTypeScriptCompileSourceCode({
                     configPath: typeScriptSourceCodeConfigPath,
                 });
                 // Step 3: compile type only
-                await execTypeScriptCompileTypeOnly();
+                execImmediateTypeScriptCompileTypeOnly();
                 console.log('\n✅ Build completed successfully\n');
             }
             catch (error) {
@@ -35,13 +35,13 @@ function registerSourceCodeCommand(program) {
             console.log('\n🏗️  [mainset cli] source-code: watch');
             try {
                 // Step 1: purge dist folder
-                execPurgeDist();
+                execImmediatePurgeDist();
                 // Step 2: watch source code
-                await runTypeScriptCompileSourceCode({
+                runStreamingTypeScriptCompileSourceCode({
                     configPath: typeScriptSourceCodeConfigPath,
                 });
                 // Step 3: watch type only
-                await runTypeScriptCompileTypeOnly();
+                runStreamingTypeScriptCompileTypeOnly();
             }
             catch (error) {
                 initProcessCatchErrorLogger('source-code', error, 'watch');

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

@@ -1,8 +1,8 @@
 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';
+import { consoleColorize, execImmediateCommand, initProcessCatchErrorLogger, runStreamingCommand, runStreamingInSync, } from '../utils/index.mjs';
+import { execImmediatePurgeDist } from './process-runner-chunks/index.mjs';
 function registerWebAppCommand(program) {
     program
         .command('web-app')
@@ -15,15 +15,25 @@ function registerWebAppCommand(program) {
         // )
         .option('-c, --config <path>', 'Path to config file')
         .option('--serveMode <mode>', 'Serve mode: ssr or csr (default: ssr)', 'ssr')
-        .action(async (options) => {
+        .action((options) => {
         // Step 0: determinate command params
         const customWebpackConfigPath = path.resolve(runtimePathById.root, options.config || './config/webpack.config.mjs');
+        // SSR server path
+        const ssrServerEntryPath = path.resolve(runtimePathById.msCLISrc, '../services/ssr-server/ssr-server.mjs');
+        const ssrServerConfigCompiledPath = path.resolve(runtimePathById.dist, './private/ssr-server.config.mjs');
         // Webpack paths
-        const webpackCLICommandPath = await resolveHostPackageBinForCLICommandPath('@mainset/bundler-webpack', 'webpack', 'webpack');
+        const webpackCLICommandPath = resolveHostPackageBinForCLICommandPath('@mainset/bundler-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');
+        /*
+        // Rslib paths
+        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');
@@ -31,13 +41,15 @@ function registerWebAppCommand(program) {
                 if (options.serveMode === 'ssr') {
                     // ========== [Build] SSR mode ==========
                     // Step 1: purge dist folder
-                    execPurgeDist();
+                    execImmediatePurgeDist();
                     // Step 2: build:ssr-webapp source code
                     console.log('\n📦 Compiling SSR WebApp with Webpack ...');
-                    execImmediateCommand(`node ${webpackCLICommandPath} --config ${webpackSSRConfigPath}`);
+                    execImmediateCommand(`${webpackCLICommandPath} --config ${webpackSSRConfigPath}`);
+                    /*
                     // Step 3: build:ssr-server source code
                     console.log('\n📦 Compiling SSR Server with Rslib ...');
-                    await execRslibCLICommand(`build --config ${rslibSSRConfigPath}`);
+                    execImmediateRslibCLICommand(`build --config ${rslibSSRConfigPath}`);
+                    */
                     console.log('\n✅ SSR Build completed successfully\n');
                 }
                 else {
@@ -46,10 +58,10 @@ function registerWebAppCommand(program) {
                         ? customWebpackConfigPath
                         : path.resolve(runtimePathById.root, 'node_modules', '@mainset/bundler-webpack/dist/esm/webpack-config/webapp.csr.config.mjs');
                     // Step 1: purge dist folder
-                    execPurgeDist();
+                    execImmediatePurgeDist();
                     // Step 2: build:csr-webapp source code
                     console.log('\n📦 Compiling CSR WebApp with Webpack ...');
-                    execImmediateCommand(`node ${webpackCLICommandPath} --config ${webpackCSRConfigPath}`);
+                    execImmediateCommand(`${webpackCLICommandPath} --config ${webpackCSRConfigPath}`);
                     console.log('\n✅ CSR Build completed successfully\n');
                 }
             }
@@ -63,39 +75,45 @@ function registerWebAppCommand(program) {
             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',
+                    runStreamingRslibCLICommand([
+                      '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,
+                    */
+                    // NOTE: node SSR server requires webpack to compile web app files first
+                    runStreamingInSync([
+                        // Step 2: watch:ssr-webapp source code of web app
+                        {
+                            runCommand: () => runStreamingCommand(webpackCLICommandPath, [
+                                '--config',
+                                webpackSSRConfigPath,
+                                '--watch',
+                            ]),
+                            waitForOutput: 'compiled successfully',
+                        },
+                        // Step 3: start:ssr-server which is compiled web app and ssr-server code
+                        {
+                            runCommand: () => 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,
+                    runStreamingCommand(webpackCLICommandPath, [
+                        'serve',
                         '--config',
                         webpackDevServerConfigPath,
                         '--open',
@@ -110,18 +128,31 @@ function registerWebAppCommand(program) {
             // ========== 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,
-                ]);
+                if (options.serveMode === 'ssr') {
+                    // ========== [Serve Static] SSR mode ==========
+                    // Step 1: 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 Static] CSR mode ==========
+                    // 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');

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

@@ -3,18 +3,41 @@ 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);
+    const hostPackageDependencyPackagePath = path.join(hostPackageNodeModulesPath, dependencyPackageName);
+    const isNodeModulesLinkedOrWorkspace = fs.existsSync(hostPackageDependencyPackagePath);
+    // If the package is linked or part of a workspace, return the full path
+    // Otherwise, return just the package name (for packages installed from the registry)
+    return isNodeModulesLinkedOrWorkspace
+        ? hostPackageDependencyPackagePath
+        : dependencyPackageName;
 }
-async function resolveHostPackageBinForCLICommandPath(hostPackageName, dependencyPackageName, cliCommandName) {
+function resolveHostPackageBinForCLICommandPath(hostPackageName, 
+// dependencyPackageName: string,
+cliCommandName) {
+    /* Previous implementation
     // Pnpm node_modules structure
-    const dependencyPackageNodeModulesPath = resolveHostPackageNodeModulesPath(hostPackageName, dependencyPackageName);
-    const packageJson = await import(path.join(dependencyPackageNodeModulesPath, 'package.json'), { with: { type: 'json' } });
+    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;
+      ? packageJson.default.bin[cliCommandName]
+      : packageJson.default.bin;
+  
     return path.join(dependencyPackageNodeModulesPath, binPath);
+    */
+    // installed from the registry
+    const dependencyPackageNodeModulesPath = path.resolve(runtimePathById.root, `node_modules/.bin/${cliCommandName}`);
+    // linked / workspace:^ package
+    const dependencyWorkspacePackageNodeModulesPath = path.resolve(runtimePathById.root, `node_modules/${hostPackageName}/node_modules/.bin/${cliCommandName}`);
+    return fs.existsSync(dependencyPackageNodeModulesPath)
+        ? dependencyPackageNodeModulesPath
+        : dependencyWorkspacePackageNodeModulesPath;
 }
 export { resolveHostPackageBinForCLICommandPath, resolveHostPackageNodeModulesPath, };

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

@@ -27,7 +27,7 @@ class ExpressBaseApp {
     //   app.use('/api-boilerplate', createProxyMiddleware(proxyConfig['/api-boilerplate/']));
     // }
     // ========== Public ==========
-    async startListening() {
+    startListening() {
         this.app.listen(this.listenPort, async () => {
             var _a;
             const packageJson = await import(path.resolve(runtimePathById.root, 'package.json'), { with: { type: 'json' } });

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

@@ -48,9 +48,45 @@ function runStreamingCommand(command, args) {
         // 2. rm -rf ./node_modules
         processManager.trackProcess(child);
         child.on('exit', (code) => process.exit(code !== null && code !== void 0 ? code : 1));
+        // NOTE: return isn't required, but it uses in combination with {runStreamingInSync} func
+        return child;
     }
     catch (error) {
         initProcessCatchErrorLogger('runStreamingCommand', error);
     }
 }
-export { execImmediateCommand, initProcessCatchErrorLogger, runStreamingCommand, };
+/**
+ * Runs a streaming command in sync mode.
+ * This is a placeholder function and does not execute any command.
+ * It is used to maintain compatibility with the existing code structure.
+ *
+ * Example: runStreamingInSync([{ runCommand: () => runStreamingCommand(), waitForOutput: 'compiled successfully' }]);
+ */
+async function runStreamingInSync(streamings) {
+    for (const streaming of streamings) {
+        // eslint-disable-next-line no-await-in-loop
+        await new Promise((resolve, reject) => {
+            const child = streaming.runCommand();
+            if (!child) {
+                reject(new Error('[mainset cli][runStreamingInSync] Previous command failed, aborting sequence.'));
+                return;
+            }
+            if (streaming.waitForOutput && child.stdout) {
+                child.stdout.on('data', (data) => {
+                    const text = data.toString();
+                    if (text.includes(streaming.waitForOutput)) {
+                        resolve();
+                    }
+                });
+            }
+            else {
+                resolve();
+            }
+            child.on('error', reject);
+        }).catch((err) => {
+            // Stop further execution if a command fails
+            throw err;
+        });
+    }
+}
+export { execImmediateCommand, initProcessCatchErrorLogger, runStreamingCommand, runStreamingInSync, };

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

@@ -1,3 +1,3 @@
-declare function execRslibCLICommand(command: string): Promise<void>;
-declare function runRslibCLICommand(commandParams: string[]): Promise<void>;
-export { execRslibCLICommand, runRslibCLICommand };
+declare function execImmediateRslibCLICommand(command: string): void;
+declare function runStreamingRslibCLICommand(commandParams: string[]): import("child_process").ChildProcess | undefined;
+export { execImmediateRslibCLICommand, runStreamingRslibCLICommand };

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

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

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

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

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

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

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

@@ -12,7 +12,7 @@ declare class ExpressBaseApp {
     readonly app: Express;
     constructor(customExpressConfig?: Partial<ExpressBaseAppConfig>);
     private appUseStatic;
-    startListening(): Promise<void>;
+    startListening(): void;
 }
 export { ExpressBaseApp };
 export type { ExpressBaseAppConfig };

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

@@ -12,5 +12,16 @@ declare function execImmediateCommand(fullCommandString: string): void;
  *
  * Example: runStreamingCommand('rspack', ['serve', '--config', './config/rspack.config.ts']);
  */
-declare function runStreamingCommand(command: string, args: string[]): void;
-export { execImmediateCommand, initProcessCatchErrorLogger, runStreamingCommand, };
+declare function runStreamingCommand(command: string, args: string[]): import("child_process").ChildProcess | undefined;
+/**
+ * Runs a streaming command in sync mode.
+ * This is a placeholder function and does not execute any command.
+ * It is used to maintain compatibility with the existing code structure.
+ *
+ * Example: runStreamingInSync([{ runCommand: () => runStreamingCommand(), waitForOutput: 'compiled successfully' }]);
+ */
+declare function runStreamingInSync(streamings: {
+    runCommand: () => ReturnType<typeof runStreamingCommand>;
+    waitForOutput?: string;
+}[]): Promise<void>;
+export { execImmediateCommand, initProcessCatchErrorLogger, runStreamingCommand, runStreamingInSync, };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mainset/cli",
-  "version": "0.1.0",
+  "version": "0.2.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": {
@@ -42,10 +42,10 @@
     "@types/cors": "^2.8.19",
     "@types/express": "^5.0.3",
     "@types/node": "^24.0.3",
-    "@mainset/dev-stack-fe": "^0.1.0"
+    "@mainset/dev-stack-fe": "^0.1.1"
   },
   "peerDependencies": {
-    "@mainset/dev-stack-fe": "0.1.0"
+    "@mainset/dev-stack-fe": "^0.1.1"
   },
   "scripts": {
     "build:source": "node ./node_modules/@mainset/dev-stack-fe/node_modules/typescript/bin/tsc --project ./tsconfig.json",