@nocobase/cli 2.1.0-alpha.1 → 2.1.0-alpha.11

package/src/commands/dev.js

@@ -8,7 +8,17 @@
  */
 const _ = require('lodash');
 const { Command } = require('commander');
-const { generatePlugins, run, postCheck, nodeCheck, promptForTs, isPortReachable, checkDBDialect } = require('../util');
+const {
+  generatePlugins,
+  run,
+  runWithPrefix,
+  postCheck,
+  nodeCheck,
+  promptForTs,
+  isPortReachable,
+  buildWSURL,
+  checkDBDialect,
+} = require('../util');
 const { getPortPromise } = require('portfinder');
 const chokidar = require('chokidar');
 const { uid } = require('@formily/shared');
@@ -21,6 +31,15 @@ function sleep(ms = 1000) {
   });
 }
 
+async function buildBundleStatusHtml() {
+  const data = await fs.promises.readFile(path.resolve(__dirname, '../../templates/bundle-status.html'), 'utf-8');
+  await fs.promises.writeFile(
+    path.resolve(process.cwd(), 'node_modules/@umijs/preset-umi/assets/bundle-status.html'),
+    data,
+    'utf-8',
+  );
+}
+
 /**
  *
  * @param {Command} cli
@@ -33,73 +52,13 @@ module.exports = (cli) => {
     .option('-c, --client')
     .option('-s, --server')
     .option('--db-sync')
+    .option('--rsbuild')
+    .option('--client-v2-only')
     .option('-i, --inspect [port]')
     .allowUnknownOption()
     .action(async (opts) => {
       checkDBDialect();
-      let subprocess;
-      const runDevClient = () => {
-        console.log('starting client', 1 * clientPort);
-        subprocess = run('umi', ['dev'], {
-          env: {
-            ...process.env,
-            stdio: 'inherit',
-            shell: true,
-            PORT: clientPort,
-            APP_ROOT: `${APP_PACKAGE_ROOT}/client`,
-            WEBSOCKET_URL:
-              process.env.WEBSOCKET_URL ||
-              (serverPort ? `ws://localhost:${serverPort}${process.env.WS_PATH}` : undefined),
-            PROXY_TARGET_URL:
-              process.env.PROXY_TARGET_URL || (serverPort ? `http://127.0.0.1:${serverPort}` : undefined),
-          },
-        });
-      };
-      const watcher = chokidar.watch('./storage/plugins/**/*', {
-        cwd: process.cwd(),
-        ignored: /(^|[\/\\])\../, // 忽略隐藏文件
-        persistent: true,
-        depth: 1, // 只监听第一层目录
-      });
-
-      await fs.promises.mkdir(path.dirname(process.env.WATCH_FILE), { recursive: true });
-      let isReady = false;
-
-      const restartClient = _.debounce(async () => {
-        if (!isReady) return;
-        generatePlugins();
-        if (subprocess) {
-          console.log('client restarting...');
-          subprocess.cancel();
-          let i = 0;
-          while (true) {
-            ++i;
-            const result = await isPortReachable(clientPort);
-            if (!result) {
-              break;
-            }
-            await sleep(500);
-            if (i > 10) {
-              break;
-            }
-          }
-          runDevClient();
-          await fs.promises.writeFile(process.env.WATCH_FILE, `export const watchId = '${uid()}';`, 'utf-8');
-        }
-      }, 500);
-
-      watcher
-        .on('ready', () => {
-          isReady = true;
-        })
-        .on('addDir', async (pathname) => {
-          if (!isReady) return;
-          restartClient();
-        })
-        .on('unlinkDir', async (pathname) => {
-          if (!isReady) return;
-          restartClient();
-        });
+      await buildBundleStatusHtml();
 
       promptForTs();
       const { SERVER_TSCONFIG_PATH } = process.env;
@@ -117,30 +76,167 @@ module.exports = (cli) => {
         return;
       }
 
-      const { port, client, server, inspect } = opts;
+      const { port, client, server, inspect, clientV2Only, rsbuild } = opts;
 
       if (port) {
         process.env.APP_PORT = opts.port;
       }
 
-      const { APP_PORT } = process.env;
+      const APP_PORT = Number(process.env.APP_PORT);
 
       let clientPort = APP_PORT;
       let serverPort;
+      let clientV2Port = APP_PORT;
 
       nodeCheck();
-
       await postCheck(opts);
 
-      if (server) {
+      const shouldRunClientV2 = clientV2Only || client || !server;
+      const shouldRunClient = !clientV2Only && (client || !server);
+      const shouldRunServer = !clientV2Only && (server || !client);
+      const shouldRunClientWithRsbuild = shouldRunClient && !!rsbuild;
+
+      if (shouldRunServer && server) {
         serverPort = APP_PORT;
-      } else if (!server && !client) {
+      } else if (shouldRunServer) {
         serverPort = await getPortPromise({
           port: 1 * clientPort + 1,
         });
       }
 
-      if (server || !client) {
+      if (shouldRunClientV2 && !clientV2Only) {
+        clientV2Port = await getPortPromise({
+          port: 1 * clientPort + 2,
+        });
+      }
+
+      let subprocessClient;
+      let subprocessClientV2;
+
+      const runDevClientV2 = () => {
+        console.log('starting client-v2', 1 * clientV2Port);
+        subprocessClientV2 = runWithPrefix(
+          'rsbuild',
+          ['dev', '--config', `${APP_PACKAGE_ROOT}/client-v2/rsbuild.config.ts`],
+          {
+            prefix: 'client-v2',
+            color: 'magenta',
+            env: {
+              ...process.env,
+              APP_V2_PORT: `${clientV2Port}`,
+              NODE_ENV: 'development',
+              RSPACK_HMR_CLIENT_PORT: `${clientV2Only ? clientV2Port : clientPort}`,
+              API_BASE_URL: process.env.API_BASE_URL || process.env.API_BASE_PATH,
+              API_CLIENT_STORAGE_PREFIX: process.env.API_CLIENT_STORAGE_PREFIX,
+              API_CLIENT_STORAGE_TYPE: process.env.API_CLIENT_STORAGE_TYPE,
+              API_CLIENT_SHARE_TOKEN: process.env.API_CLIENT_SHARE_TOKEN || 'false',
+              WEBSOCKET_URL: process.env.WEBSOCKET_URL || buildWSURL(process.env.API_BASE_URL, serverPort),
+              WS_PATH: process.env.WS_PATH,
+              ESM_CDN_BASE_URL: process.env.ESM_CDN_BASE_URL || 'https://esm.sh',
+              ESM_CDN_SUFFIX: process.env.ESM_CDN_SUFFIX || '',
+              PROXY_TARGET_URL:
+                process.env.PROXY_TARGET_URL || (serverPort ? `http://127.0.0.1:${serverPort}` : undefined),
+            },
+          },
+        );
+      };
+
+      if (clientV2Only) {
+        runDevClientV2();
+        return;
+      }
+
+      const runDevClient = () => {
+        console.log('starting client', 1 * clientPort);
+        const command = shouldRunClientWithRsbuild ? 'rsbuild' : 'umi';
+        const args = shouldRunClientWithRsbuild
+          ? ['dev', '--config', `${APP_PACKAGE_ROOT}/client/rsbuild.config.ts`]
+          : ['dev'];
+        subprocessClient = runWithPrefix(command, args, {
+          prefix: 'client',
+          color: 'cyan',
+          env: {
+            ...process.env,
+            stdio: 'inherit',
+            shell: true,
+            PORT: clientPort,
+            APP_PORT: `${clientPort}`,
+            APP_ROOT: `${APP_PACKAGE_ROOT}/client`,
+            APP_V2_PORT: `${clientV2Port}`,
+            NODE_ENV: 'development',
+            RSPACK_HMR_CLIENT_PORT: `${clientPort}`,
+            API_BASE_URL: process.env.API_BASE_URL || process.env.API_BASE_PATH,
+            API_CLIENT_STORAGE_PREFIX: process.env.API_CLIENT_STORAGE_PREFIX,
+            API_CLIENT_STORAGE_TYPE: process.env.API_CLIENT_STORAGE_TYPE,
+            API_CLIENT_SHARE_TOKEN: process.env.API_CLIENT_SHARE_TOKEN || 'false',
+            WEBSOCKET_URL: process.env.WEBSOCKET_URL || buildWSURL(process.env.API_BASE_URL, serverPort),
+            PROXY_TARGET_URL:
+              process.env.PROXY_TARGET_URL || (serverPort ? `http://127.0.0.1:${serverPort}` : undefined),
+          },
+        });
+      };
+
+      const restartSubprocess = async (subprocessRef, port, start) => {
+        if (!subprocessRef) {
+          start();
+          return;
+        }
+        subprocessRef.cancel();
+        let i = 0;
+        while (true) {
+          ++i;
+          const result = await isPortReachable(port);
+          if (!result) {
+            break;
+          }
+          await sleep(500);
+          if (i > 10) {
+            break;
+          }
+        }
+        start();
+      };
+
+      if (shouldRunClient) {
+        const storagePluginPath = path.resolve(process.cwd(), 'storage/plugins');
+        const watcher = chokidar.watch(`${storagePluginPath}/**/*`, {
+          cwd: process.cwd(),
+          ignored: /(^|[\/\\])\../, // 忽略隐藏文件
+          persistent: true,
+          depth: 1, // 只监听第一层目录
+        });
+
+        await fs.promises.mkdir(path.dirname(process.env.WATCH_FILE), { recursive: true });
+        let isReady = false;
+
+        const restartClient = _.debounce(async () => {
+          if (!isReady) return;
+          generatePlugins();
+          if (shouldRunClient) {
+            await restartSubprocess(subprocessClient, clientPort, runDevClient);
+          }
+          if (shouldRunClientV2) {
+            await restartSubprocess(subprocessClientV2, clientV2Port, runDevClientV2);
+          }
+          await fs.promises.writeFile(process.env.WATCH_FILE, `export const watchId = '${uid()}';`, 'utf-8');
+        }, 500);
+
+        watcher
+          .on('ready', () => {
+            console.log('watching plugin folder changes...');
+            isReady = true;
+          })
+          .on('addDir', async () => {
+            if (!isReady) return;
+            restartClient();
+          })
+          .on('unlinkDir', async () => {
+            if (!isReady) return;
+            restartClient();
+          });
+      }
+
+      if (shouldRunServer) {
         console.log('starting server', serverPort);
 
         const filteredArgs = process.argv.filter(
@@ -183,8 +279,12 @@ module.exports = (cli) => {
         runDevServer();
       }
 
-      if (client || !server) {
+      if (shouldRunClient) {
         runDevClient();
       }
+
+      if (shouldRunClientV2) {
+        runDevClientV2();
+      }
     });
 };

package/src/commands/index.js

@@ -38,6 +38,7 @@ module.exports = (cli) => {
   require('./pkg')(cli);
   require('./instance-id')(cli);
   require('./view-license-key')(cli);
+  require('./client')(cli);
   if (isPackageValid('@umijs/utils')) {
     require('./create-plugin')(cli);
   }

package/src/commands/pkg.js

@@ -208,7 +208,7 @@ class PackageManager {
         showLicenseInfo(LicenseKeyError.notValid);
       }
       logger.error(`Login failed: ${this.baseURL}`);
-      logger.error(error?.message || error);
+      logger.error(error?.message, { error });
     }
   }
 
@@ -283,7 +283,12 @@ module.exports = (cli) => {
         NOCOBASE_PKG_URL = 'https://pkg.nocobase.com/',
         NOCOBASE_PKG_USERNAME,
         NOCOBASE_PKG_PASSWORD,
+        DISABLE_PKG_DOWNLOAD,
       } = process.env;
+      if (DISABLE_PKG_DOWNLOAD === 'true') {
+        logger.info('Package download is disabled.');
+        return;
+      }
       let accessKeyId;
       let accessKeySecret;
       try {

package/src/commands/pm2.js

@@ -32,6 +32,6 @@ module.exports = (cli) => {
     .command('pm2-stop')
     .allowUnknownOption()
     .action(() => {
-      run('pm2', ['stop', 'all']);
+      run('pm2', ['kill']);
     });
 };

package/src/commands/update-deps.js

@@ -62,6 +62,7 @@ module.exports = (cli) => {
       if (descJson['devDependencies']?.['@nocobase/devtools']) {
         descJson['devDependencies']['@nocobase/devtools'] = stdout;
       }
+      descJson['resolutions'] = sourceJson['resolutions'];
       const json = deepmerge(descJson, sourceJson);
       await writeJSON(descPath, json, { spaces: 2, encoding: 'utf8' });
       await run('yarn', ['install']);

package/src/license.js

@@ -18,7 +18,7 @@ const { pick } = require('lodash');
 exports.getAccessKeyPair = async function () {
   const keyFile = resolve(process.cwd(), 'storage/.license/license-key');
   if (!fs.existsSync(keyFile)) {
-    logger.error('License key not found');
+    logger.info('License key not found');
     return {};
   }
   logger.info('License key found');

package/src/util.js

@@ -83,6 +83,44 @@ exports.run = (command, args, options = {}) => {
   });
 };
 
+exports.runWithPrefix = (command, args, options = {}) => {
+  if (command === 'tsx') {
+    command = 'node';
+    args = ['./node_modules/tsx/dist/cli.mjs'].concat(args || []);
+  }
+
+  const prefix = options.prefix || 'process';
+  const color = options.color || 'cyan';
+  const label = chalk[color](`[${prefix}]`);
+  const subprocess = execa(command, args, {
+    shell: true,
+    stdio: 'pipe',
+    ...options,
+    env: {
+      ...process.env,
+      ...options.env,
+    },
+  });
+
+  const writePrefixed = (chunk, writer) => {
+    const text = chunk.toString();
+    const lines = text.split(/\r?\n/);
+    const trailingNewline = text.endsWith('\n') || text.endsWith('\r');
+
+    lines.forEach((line, index) => {
+      if (!line && index === lines.length - 1 && trailingNewline) {
+        return;
+      }
+      writer.write(`${label} ${line}\n`);
+    });
+  };
+
+  subprocess.stdout?.on('data', (chunk) => writePrefixed(chunk, process.stdout));
+  subprocess.stderr?.on('data', (chunk) => writePrefixed(chunk, process.stderr));
+
+  return subprocess;
+};
+
 exports.isPortReachable = async (port, { timeout = 1000, host } = {}) => {
   const promise = new Promise((resolve, reject) => {
     const socket = new net.Socket();
@@ -232,6 +270,7 @@ exports.genTsConfigPaths = function genTsConfigPaths() {
       .split(sep)
       .join('/');
     paths[`${packageJsonName}/client`] = [`${relativePath}/src/client`];
+    paths[`${packageJsonName}/client-v2`] = [`${relativePath}/src/client-v2`];
     paths[`${packageJsonName}/package.json`] = [`${relativePath}/package.json`];
     paths[packageJsonName] = [`${relativePath}/src`];
     if (packageJsonName === '@nocobase/test') {
@@ -282,6 +321,21 @@ function parseEnv(name) {
   }
 }
 
+function resolvePublicPath(appPublicPath = '/') {
+  const normalized = String(appPublicPath || '/').trim() || '/';
+  const withLeadingSlash = normalized.startsWith('/') ? normalized : `/${normalized}`;
+  return withLeadingSlash.endsWith('/') ? withLeadingSlash : `${withLeadingSlash}/`;
+}
+
+exports.resolvePublicPath = resolvePublicPath;
+
+function resolveV2PublicPath(appPublicPath = '/') {
+  const publicPath = resolvePublicPath(appPublicPath);
+  return `${publicPath.replace(/\/$/, '')}/v2/`;
+}
+
+exports.resolveV2PublicPath = resolveV2PublicPath;
+
 function buildIndexHtml(force = false) {
   const file = `${process.env.APP_PACKAGE_ROOT}/dist/client/index.html`;
   if (!fs.existsSync(file)) {
@@ -295,14 +349,26 @@ function buildIndexHtml(force = false) {
     fs.copyFileSync(file, tpl);
   }
   const data = fs.readFileSync(tpl, 'utf-8');
-  const replacedData = data
+  let replacedData = data
+    .replace(/\{\{env.CDN_BASE_URL\}\}/g, process.env.CDN_BASE_URL)
     .replace(/\{\{env.APP_PUBLIC_PATH\}\}/g, process.env.APP_PUBLIC_PATH)
+    .replace(/\{\{env.API_CLIENT_SHARE_TOKEN\}\}/g, process.env.API_CLIENT_SHARE_TOKEN || 'false')
     .replace(/\{\{env.API_CLIENT_STORAGE_TYPE\}\}/g, process.env.API_CLIENT_STORAGE_TYPE)
     .replace(/\{\{env.API_CLIENT_STORAGE_PREFIX\}\}/g, process.env.API_CLIENT_STORAGE_PREFIX)
     .replace(/\{\{env.API_BASE_URL\}\}/g, process.env.API_BASE_URL || process.env.API_BASE_PATH)
     .replace(/\{\{env.WS_URL\}\}/g, process.env.WEBSOCKET_URL || '')
     .replace(/\{\{env.WS_PATH\}\}/g, process.env.WS_PATH)
+    .replace(/\{\{env.ESM_CDN_BASE_URL\}\}/g, process.env.ESM_CDN_BASE_URL || '')
+    .replace(/\{\{env.ESM_CDN_SUFFIX\}\}/g, process.env.ESM_CDN_SUFFIX || '')
     .replace('src="/umi.', `src="${process.env.APP_PUBLIC_PATH}umi.`);
+
+  if (process.env.CDN_BASE_URL) {
+    const appBaseUrl = process.env.CDN_BASE_URL.replace(/\/+$/, '');
+    const appPublicPath = process.env.APP_PUBLIC_PATH.replace(/\/+$/, '');
+    const re1 = new RegExp(`src="${appPublicPath}/`, 'g');
+    const re2 = new RegExp(`href="${appPublicPath}/`, 'g');
+    replacedData = replacedData.replace(re1, `src="${appBaseUrl}/`).replace(re2, `href="${appBaseUrl}/`);
+  }
   fs.writeFileSync(file, replacedData, 'utf-8');
 }
 
@@ -360,6 +426,7 @@ exports.initEnv = function initEnv() {
     APP_PORT: 13000,
     API_BASE_PATH: '/api/',
     API_CLIENT_STORAGE_PREFIX: 'NOCOBASE_',
+    API_CLIENT_SHARE_TOKEN: 'false',
     API_CLIENT_STORAGE_TYPE: 'localStorage',
     // DB_DIALECT: 'sqlite',
     DB_STORAGE: 'storage/db/nocobase.sqlite',
@@ -383,8 +450,12 @@ exports.initEnv = function initEnv() {
     PLUGIN_STATICS_PATH: '/static/plugins/',
     LOGGER_BASE_PATH: 'storage/logs',
     APP_SERVER_BASE_URL: '',
+    APP_BASE_URL: '',
+    CDN_BASE_URL: '',
     APP_PUBLIC_PATH: '/',
     WATCH_FILE: resolve(process.cwd(), 'storage/app.watch.ts'),
+    ESM_CDN_BASE_URL: 'https://esm.sh',
+    ESM_CDN_SUFFIX: '',
   };
 
   if (
@@ -438,6 +509,16 @@ exports.initEnv = function initEnv() {
     process.env.__env_modified__ = true;
   }
 
+  if (!process.env.CDN_BASE_URL && process.env.APP_PUBLIC_PATH !== '/') {
+    process.env.CDN_BASE_URL = process.env.APP_PUBLIC_PATH;
+  }
+
+  if (process.env.CDN_BASE_URL.includes('http') && process.env.CDN_VERSION === 'auto') {
+    const version = require('../package.json').version;
+    process.env.CDN_BASE_URL = process.env.CDN_BASE_URL.replace(/\/+$/, '') + '/' + version + '/';
+    process.env.CDN_VERSION = '';
+  }
+
   if (!process.env.TZ) {
     const timeZone = Intl.DateTimeFormat().resolvedOptions().timeZone;
     process.env.TZ = getTimezonesByOffset(process.env.DB_TIMEZONE || timeZone);
@@ -481,10 +562,40 @@ exports.checkDBDialect = function () {
 
 exports.generatePlugins = function () {
   try {
-    require.resolve('@nocobase/devtools/umiConfig');
-    const { generatePlugins } = require('@nocobase/devtools/umiConfig');
-    generatePlugins();
+    require.resolve('@nocobase/devtools/common');
+    const { generateAllPlugins, generatePlugins, generateV2Plugins } = require('@nocobase/devtools/common');
+    if (typeof generateAllPlugins === 'function') {
+      generateAllPlugins();
+      return;
+    }
+    generatePlugins?.();
+    generateV2Plugins?.();
   } catch (error) {
     return;
   }
 };
+
+exports.isURL = function isURL(str) {
+  let url;
+
+  try {
+    url = new URL(str);
+  } catch (e) {
+    return false;
+  }
+
+  return url.protocol === 'http:' || url.protocol === 'https:';
+};
+
+exports.buildWSURL = function buildWSURL(urlString, serverPort) {
+  if (exports.isURL(urlString)) {
+    const parsedUrl = new URL(urlString);
+    parsedUrl.protocol = parsedUrl.protocol === 'https:' ? 'wss:' : 'ws:';
+    parsedUrl.pathname =
+      process.env.WS_PATH || (process.env.APP_PUBLIC_PATH ? process.env.APP_PUBLIC_PATH + 'ws' : '/ws');
+    const url = parsedUrl.toString();
+    return url;
+  }
+
+  return serverPort ? `ws://localhost:${serverPort}${process.env.WS_PATH}` : undefined;
+};