@mainset/cli 0.1.0 → 0.1.1

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

@@ -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)
@@ -26,9 +26,9 @@ function registerNodePackageCommand(program) {
                 execPurgeDist();
                 // Step 2: build source code
                 console.log('\n📦 Compiling Source Code with Rslib ...');
-                await execRslibCLICommand(`build --config ${rslibConfigPath}`);
+                execRslibCLICommand(`build --config ${rslibConfigPath}`);
                 // Step 3: build type only
-                await execTypeScriptCompileTypeOnly();
+                execTypeScriptCompileTypeOnly();
                 console.log('\n✅ Build completed successfully\n');
             }
             catch (error) {
@@ -42,14 +42,9 @@ function registerNodePackageCommand(program) {
                 // Step 1: purge dist folder
                 execPurgeDist();
                 // Step 2: watch source code
-                await runRslibCLICommand([
-                    'build',
-                    '--config',
-                    rslibConfigPath,
-                    '--watch',
-                ]);
+                runRslibCLICommand(['build', '--config', rslibConfigPath, '--watch']);
                 // Step 3: watch type only
-                await runTypeScriptCompileTypeOnly();
+                runTypeScriptCompileTypeOnly();
             }
             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 execRslibCLICommand(command) {
+    const rslibCLICommandPath = getRslibCLICommandPath();
+    return execImmediateCommand(`${rslibCLICommandPath} ${command}`);
 }
-async function runRslibCLICommand(commandParams) {
-    const rslibCLICommandPath = await getRslibCLICommandPath();
-    return runStreamingCommand('node', [rslibCLICommandPath, ...commandParams]);
+function runRslibCLICommand(commandParams) {
+    const rslibCLICommandPath = getRslibCLICommandPath();
+    return runStreamingCommand(rslibCLICommandPath, [...commandParams]);
 }
 export { execRslibCLICommand, runRslibCLICommand };

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 execTypeScriptCompileSourceCode({ 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 runTypeScriptCompileSourceCode({ 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 execTypeScriptCompileTypeOnly() {
     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 runTypeScriptCompileTypeOnly() {
     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, };

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

@@ -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') {
@@ -19,11 +19,11 @@ function registerSourceCodeCommand(program) {
                 // Step 1: purge dist folder
                 execPurgeDist();
                 // Step 2: compile source code
-                await execTypeScriptCompileSourceCode({
+                execTypeScriptCompileSourceCode({
                     configPath: typeScriptSourceCodeConfigPath,
                 });
                 // Step 3: compile type only
-                await execTypeScriptCompileTypeOnly();
+                execTypeScriptCompileTypeOnly();
                 console.log('\n✅ Build completed successfully\n');
             }
             catch (error) {
@@ -37,11 +37,11 @@ function registerSourceCodeCommand(program) {
                 // Step 1: purge dist folder
                 execPurgeDist();
                 // Step 2: watch source code
-                await runTypeScriptCompileSourceCode({
+                runTypeScriptCompileSourceCode({
                     configPath: typeScriptSourceCodeConfigPath,
                 });
                 // Step 3: watch type only
-                await runTypeScriptCompileTypeOnly();
+                runTypeScriptCompileTypeOnly();
             }
             catch (error) {
                 initProcessCatchErrorLogger('source-code', error, 'watch');

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

@@ -15,11 +15,11 @@ 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');
         // 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');
@@ -34,10 +34,10 @@ function registerWebAppCommand(program) {
                     execPurgeDist();
                     // 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}`);
+                    execRslibCLICommand(`build --config ${rslibSSRConfigPath}`);
                     console.log('\n✅ SSR Build completed successfully\n');
                 }
                 else {
@@ -49,7 +49,7 @@ function registerWebAppCommand(program) {
                     execPurgeDist();
                     // 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');
                 }
             }
@@ -66,15 +66,14 @@ function registerWebAppCommand(program) {
                     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([
+                    runRslibCLICommand([
                         'build',
                         '--config',
                         rslibSSRConfigPath,
                         '--watch',
                     ]);
                     // Step 2: watch:ssr-webapp source code of web app
-                    runStreamingCommand('node', [
-                        webpackCLICommandPath,
+                    runStreamingCommand(webpackCLICommandPath, [
                         '--config',
                         webpackSSRConfigPath,
                         '--watch',
@@ -89,13 +88,12 @@ function registerWebAppCommand(program) {
                 }
                 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',

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/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>;
+declare function execRslibCLICommand(command: string): void;
+declare function runRslibCLICommand(commandParams: string[]): void;
 export { execRslibCLICommand, runRslibCLICommand };

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

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

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mainset/cli",
-  "version": "0.1.0",
+  "version": "0.1.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",