@blocklet/cli 1.16.33 → 1.16.34-beta-20241120-080738-bbbe036c

package/lib/commands/server/status.js

@@ -0,0 +1,107 @@
+const chalk = require('chalk');
+const prettyMs = require('pretty-ms-i18n');
+const upperFirst = require('lodash/upperFirst');
+const isEmpty = require('lodash/isEmpty');
+const Table = require('cli-table3');
+const pm2 = require('@abtnode/util/lib/async-pm2');
+const { encode: encodeBase32 } = require('@abtnode/util/lib/base32');
+const { fromBlockletStatus } = require('@blocklet/constant');
+const { PROCESS_NAME_DAEMON, DEFAULT_DID_DOMAIN } = require('@abtnode/constant');
+
+const { print, printWarning, printSuccess, printAccessUrls, getDaemonAccessUrls } = require('../../util');
+const { getNode } = require('../../node');
+const { wrapSpinner } = require('../../ui');
+
+const getProcessInfo = (name) =>
+  new Promise((resolve, reject) => {
+    pm2.describe(name, (err, [info]) => {
+      if (err) {
+        return reject(err);
+      }
+
+      return resolve(info);
+    });
+  });
+
+const statusMap = {
+  online: 'running',
+  launching: 'starting',
+  errored: 'error',
+  stopping: 'stopping',
+  stopped: 'stopped',
+};
+
+const colorMap = {
+  running: 'green',
+  error: 'red',
+  launching: 'yellow',
+  stopping: 'orange',
+  stopped: 'gray',
+};
+
+exports.run = async () => {
+  const { node, getBaseUrls } = await getNode({ dir: process.cwd() });
+
+  try {
+    const info = await getProcessInfo(PROCESS_NAME_DAEMON);
+    if (!info) {
+      print('Blocklet Server is not started');
+      process.exit(0);
+    }
+
+    const nodeInfo = await node.getNodeInfo();
+    const status = statusMap[info.pm2_env.status];
+    const statusFn = chalk[colorMap[status]];
+    const time = status === 'running' ? ` (${statusFn(prettyMs(Date.now() - Number(info.pm2_env.pm_uptime)))})` : '';
+    print();
+    print(`Blocklet Server status: ${statusFn(upperFirst(status))}${time}`);
+    print(`Blocklet Server mode: ${chalk.cyan(upperFirst(nodeInfo.mode))}`);
+    print(`Blocklet Server Data Directory: ${chalk.cyan(info.pm2_env.env.ABT_NODE_DATA_DIR)}`);
+
+    print();
+    if (nodeInfo.initialized) {
+      let blocklets = [];
+
+      await wrapSpinner('Fetching the blocklets...', async () => {
+        blocklets = await node.getBlocklets({ includeRuntimeInfo: false });
+      });
+
+      if (blocklets.length) {
+        const table = new Table({
+          head: ['Name', 'Status', 'URL'],
+          style: { 'padding-left': 1, head: ['cyan', 'bold'] },
+          colWidths: [30, 15, 70],
+        });
+
+        print('Blocklets Status:');
+        // eslint-disable-next-line no-shadow
+        blocklets.forEach(({ meta, status }) =>
+          table.push([
+            meta.title,
+            fromBlockletStatus(status),
+            `https://${encodeBase32(meta.did)}.${DEFAULT_DID_DOMAIN}`,
+          ])
+        );
+        print(table.toString());
+      } else {
+        printWarning('No blocklets installed yet.');
+      }
+    }
+
+    if (status === 'running') {
+      print();
+      const accessUrls = await getDaemonAccessUrls({ info: nodeInfo, getBaseUrls });
+
+      if (!isEmpty(accessUrls)) {
+        printSuccess('You can access your blocklet server with either of the following URLs:');
+        printAccessUrls(accessUrls);
+      } else {
+        printWarning('No accessible URL found.');
+      }
+    }
+  } catch (err) {
+    console.error(err);
+  }
+
+  process.exit(0);
+};

package/lib/commands/server/stop.js

@@ -0,0 +1,163 @@
+const chalk = require('chalk');
+const capitalize = require('lodash/capitalize');
+
+const { clearRouterByConfigKeyword } = require('@abtnode/router-provider');
+const tryWithTimeout = require('@abtnode/util/lib/try-with-timeout');
+const sleep = require('@abtnode/util/lib/sleep');
+const pm2 = require('@abtnode/util/lib/async-pm2');
+
+const {
+  PROCESS_NAME_DAEMON,
+  PROCESS_NAME_SERVICE,
+  PROCESS_NAME_EVENT_HUB,
+  CONFIG_FOLDER_NAME,
+  CONFIG_FOLDER_NAME_OLD,
+  EVENTS,
+  SERVER_STATUS,
+} = require('@abtnode/constant');
+
+const { BLOCKLET_MODES, BlockletStatus } = require('@blocklet/constant');
+
+const debug = require('../../debug')('kill');
+const {
+  printError,
+  printInfo,
+  printSuccess,
+  printWarning,
+  stopRouting,
+  getCLICommandName,
+  killPm2Process,
+} = require('../../util');
+const { getNode } = require('../../node');
+const { checkRunning } = require('../../manager');
+const { wrapSpinner } = require('../../ui');
+
+exports.run = async ({ force = false }) => {
+  if (force) {
+    try {
+      const results = await Promise.all([
+        clearRouterByConfigKeyword(CONFIG_FOLDER_NAME),
+        clearRouterByConfigKeyword(CONFIG_FOLDER_NAME_OLD),
+      ]);
+
+      const clearedProvider = results.find(Boolean);
+      if (clearedProvider) {
+        printSuccess(`${capitalize(clearedProvider)} router is stopped successfully`);
+      }
+
+      await pm2.killDaemonAsync();
+      printSuccess('Blocklet Server related processes stopped successfully');
+    } catch (error) {
+      printError(`Blocklet Server related processes stop failed: ${error.message}`);
+    }
+
+    process.exit(0);
+  }
+
+  const { node, publishEvent } = await getNode({ dir: process.cwd() });
+
+  const isRunning = await checkRunning();
+  if (!isRunning) {
+    printWarning('Blocklet Server is not running!');
+    process.exit(0);
+  }
+
+  const stopOnReady = () =>
+    new Promise((resolve) => {
+      node.onReady(async () => {
+        let blocklets = [];
+
+        try {
+          blocklets = await node.getBlocklets({ includeRuntimeInfo: false });
+        } catch (err) {
+          printWarning('Blocklets ignored because:', err.message);
+        }
+
+        // Exit early if we have running blocklets in dev mode
+        // The node can only be stopped if no blocklet running in dev mode exist
+        const devBlocklet = blocklets.find((x) => x.mode === BLOCKLET_MODES.DEVELOPMENT);
+        if (devBlocklet && devBlocklet.status === BlockletStatus.running) {
+          printError(
+            `Unable to stop Blocklet Server, please stop the development by pressing ${chalk.cyan(
+              'Ctrl + C'
+            )} in the terminal of ${chalk.cyan(devBlocklet.meta.name)}`
+          );
+          process.exit(0);
+        }
+
+        try {
+          await wrapSpinner('Sending shutdown notification to web dashboard users', async () => {
+            await publishEvent(EVENTS.NODE_STOPPED, {});
+            await sleep(2000);
+          }); // prettier-ignore
+        } catch (err) {
+          printError(`Failed to publish stop event to socket server: ${err.message}`);
+        }
+
+        const info = await node.getNodeInfo();
+
+        debug('blocklets to kill', blocklets);
+
+        try {
+          await stopRouting({ info, routerDir: node.dataDirs.router });
+          printSuccess('Routing engine is stopped successfully');
+        } catch (err) {
+          printError('Failed to stop routing engine', err.message);
+        }
+
+        for (let i = 0; i < blocklets.length; i++) {
+          const { title, did } = blocklets[i].meta;
+          if ([BlockletStatus.running, BlockletStatus.starting].includes(blocklets[i].status) === false) {
+            // eslint-disable-next-line no-continue
+            continue;
+          }
+          try {
+            // eslint-disable-next-line no-await-in-loop
+            await node.stopBlocklet({ did, updateStatus: false, silent: true });
+            printSuccess(`Blocklet ${title} is stopped successfully`);
+          } catch (err) {
+            printError(`Failed to stop blocklet ${title}`, err.message);
+          }
+        }
+
+        const actions = [
+          { action: 'kill', processName: PROCESS_NAME_DAEMON },
+          { action: 'kill', processName: PROCESS_NAME_SERVICE },
+          { action: 'kill', processName: PROCESS_NAME_EVENT_HUB },
+          { action: 'updateStatus' },
+        ];
+
+        for (let i = 0; i < actions.length; i++) {
+          const { action, processName } = actions[i];
+          if (action === 'kill') {
+            try {
+              // eslint-disable-next-line no-await-in-loop
+              await killPm2Process(processName);
+              printSuccess(`${processName} is stopped successfully`);
+            } catch (err) {
+              printError(`Failed to stop ${processName}`, err.message);
+            }
+          }
+
+          if (action === 'updateStatus') {
+            // eslint-disable-next-line no-await-in-loop
+            await node.updateNodeStatus(SERVER_STATUS.STOPPED);
+          }
+        }
+
+        printSuccess('Done!');
+        resolve(true);
+        process.exit(0);
+      });
+    });
+
+  const timeout = 60 * 1000 * 5; // 5 minute
+  try {
+    await tryWithTimeout(stopOnReady, timeout);
+  } catch (err) {
+    printError(`Blocklet Server can not stop within ${timeout} ms`);
+    printInfo(`You can stop the node with ${chalk.cyan(`${getCLICommandName()} stop --force`)}`);
+  } finally {
+    process.exit(0);
+  }
+};

package/lib/commands/server/upgrade.js

@@ -0,0 +1,123 @@
+const path = require('path');
+const shell = require('shelljs');
+const semver = require('semver');
+const chalk = require('chalk');
+const fs = require('fs');
+
+const { canReadAndWriteDir } = require('@abtnode/util/lib/fs');
+const { getInstaller, getInstallCommands } = require('@abtnode/util/lib/get-installer');
+const {
+  print,
+  printError,
+  printInfo,
+  printSuccess,
+  printWarning,
+  getCLIBinaryName,
+  getCLICommandName,
+} = require('../../util');
+const { version, name } = require('../../../package.json');
+const { checkRunning, getRunningConfigDataDir } = require('../../manager');
+const debug = require('../../debug')('upgrade');
+
+// auto throw error when sync run shell.xxx
+// must run sync
+const wrap =
+  (shellFn) =>
+  (...args) => {
+    const { code, stdout, stderr } = shellFn.apply(shell, args);
+    if (code !== 0) {
+      throw new Error(stderr);
+    }
+    return stdout;
+  };
+
+const getLatestVersion = () => {
+  const stdout = wrap(shell.exec)(`npm show ${name} version`, {
+    silent: true,
+  });
+  return stdout.trim();
+};
+
+const checkUpdate = (current, latest) => semver.gt(latest, current);
+
+const stopNode = () => {
+  printInfo('Stopping Blocklet Server ...');
+  wrap(shell.exec)(`${getCLICommandName()} stop`, {
+    silent: true,
+  });
+};
+
+const installNode = () => {
+  const commandName = getCLICommandName();
+  const packageName = commandName === 'abtnode' ? '@abtnode/cli' : '@blocklet/cli';
+  const binaryName = getCLIBinaryName();
+  const installer = getInstaller(binaryName);
+  const commands = getInstallCommands({ packageName });
+  const command = commands[installer];
+
+  printInfo(`Installing Blocklet Server by ${chalk.cyan(command)} ...`);
+
+  wrap(shell.exec)(command, {
+    silent: false,
+  });
+};
+
+const restartNode = (originalRunningDataDir) => {
+  const currentWorkingDataDir = process.cwd();
+  debug('original running data directory', originalRunningDataDir);
+  debug('current working data directory', currentWorkingDataDir);
+
+  printInfo('Restarting Blocklet Server ...');
+
+  if (!fs.existsSync(originalRunningDataDir)) {
+    printWarning('Original running data directory does not exists, abort restart!');
+    return;
+  }
+
+  wrap(shell.exec)(`${getCLICommandName()} start`, {
+    silent: false,
+    cwd: originalRunningDataDir,
+  });
+};
+
+exports.run = async () => {
+  // save current bin path
+  const binaryName = getCLIBinaryName();
+  const commandName = getCLICommandName();
+  const curBinPath = wrap(shell.which)(binaryName, { silent: true });
+  printInfo('Using blocklet server from', chalk.cyan(curBinPath));
+
+  // Check permissions
+  printInfo('Checking permissions...');
+  if (canReadAndWriteDir(path.dirname(curBinPath)) === false) {
+    printError('Seems you do not have permission to upgrade Blocklet Server version');
+    printInfo(`Maybe you can try run ${chalk.cyan(`sudo ${commandName} upgrade`)}`);
+    process.exit(1);
+  }
+
+  const latestVersion = await getLatestVersion();
+  const needUpdate = await checkUpdate(version, latestVersion);
+  if (!needUpdate) {
+    print(`The current version ${version} is the latest version, no need to upgrade`);
+    process.exit(0);
+  }
+  print(`Current version is ${version}, found latest version ${latestVersion}`);
+  print('Begin upgrade');
+
+  // Do not start/stop the node when run as root
+  const isRunning = await checkRunning();
+  const runningDataDir = await getRunningConfigDataDir();
+
+  const needRestart = isRunning;
+  if (isRunning) {
+    await stopNode();
+  }
+  await installNode();
+
+  if (needRestart) {
+    await restartNode(runningDataDir);
+  }
+
+  printSuccess(`Blocklet Server upgrade success, current version is ${latestVersion}`);
+  process.exit(0);
+};

package/lib/constant.js

@@ -1,5 +1,24 @@
-const packageJson = require('../package.json');
+const os = require('os');
+const path = require('path');
+
+const ABT_NODE_MAX_CLUSTER_SIZE = Math.min(Math.max(Number(process.env.ABT_NODE_MAX_CLUSTER_SIZE) || 1, 1), 32);
+
+const CLI_MODE = 'blocklet';
+const NODE_ENV = process.env.NODE_ENV || 'production';
+const ABT_NODE_HOME = path.join(os.homedir(), '.arcblock');
+const PM2_HOME = path.join(ABT_NODE_HOME, 'abtnode');
+const ABT_NODE_CONFIG_FILE = path.join(ABT_NODE_HOME, 'blocklet.ini');
+const INSTALL_FILE_PATH = path.join(ABT_NODE_HOME, '.is-new-server-install');
+const HELP_DOCS_GITHUB_CODESPACES_URL =
+  'https://www.arcblock.io/docs/blocklet-developer/en/develop-with-github-codespaces';
 
 module.exports = {
-  name: packageJson.name,
+  ABT_NODE_MAX_CLUSTER_SIZE,
+  CLI_MODE,
+  NODE_ENV,
+  ABT_NODE_HOME,
+  PM2_HOME,
+  ABT_NODE_CONFIG_FILE,
+  INSTALL_FILE_PATH,
+  HELP_DOCS_GITHUB_CODESPACES_URL,
 };

package/lib/debug.js

@@ -0,0 +1,20 @@
+/* eslint-disable no-console */
+
+const debug = require('debug');
+
+if (process.env.FORGE_DEBUG) {
+  debug.enable(process.env.FORGE_DEBUG);
+}
+
+const instance = (name) => {
+  const tmp = debug(`@blocklet/cli:${name || 'info'}`);
+  tmp.error = (...args) => {
+    if (tmp.enabled) {
+      console.error(...args);
+    }
+  };
+
+  return tmp;
+};
+
+module.exports = instance;

package/lib/manager/config.js

@@ -0,0 +1,122 @@
+const fs = require('fs');
+const path = require('path');
+const expandTilde = require('expand-tilde');
+
+const {
+  CONFIG_FILENAME,
+  CONFIG_FOLDER_NAME,
+  CONFIG_FILENAME_OLD,
+  CONFIG_FOLDER_NAME_OLD,
+} = require('@abtnode/constant');
+
+const _join = (prefix, file) => {
+  return path.join(expandTilde(prefix), file);
+};
+
+const joinConfigDir = (dir) => _join(dir, CONFIG_FOLDER_NAME);
+
+const joinConfigFile = (dir) => _join(dir, CONFIG_FILENAME);
+
+const joinKFile = (dir) => _join(dir, '.sock');
+
+const getDataDirectoryByConfigFile = (configFile) => {
+  if (!configFile) {
+    throw new Error('configFile can not be empty');
+  }
+
+  return path.dirname(configFile);
+};
+
+const getConfigDirFromCurrentDir = (currentDir) => {
+  const configDir = _join(currentDir, CONFIG_FOLDER_NAME);
+  const configDirOld = _join(currentDir, CONFIG_FOLDER_NAME_OLD);
+
+  if (fs.existsSync(configDir)) {
+    return configDir;
+  }
+
+  if (fs.existsSync(configDirOld)) {
+    return configDirOld;
+  }
+
+  return '';
+};
+
+const getConfigDirFromAncestors = (currentDir) => {
+  let dir = fs.statSync(currentDir).isDirectory() ? currentDir : path.dirname(currentDir);
+
+  do {
+    const configDir = getConfigDirFromCurrentDir(dir);
+    if (configDir) {
+      return configDir;
+    }
+
+    dir = path.dirname(dir);
+  } while (path.basename(dir) !== '');
+
+  return '';
+};
+
+const getConfigFileFromAncestors = (dir) => {
+  const configDir = getConfigDirFromAncestors(dir);
+  if (!configDir) {
+    return '';
+  }
+
+  if (configDir.endsWith(CONFIG_FOLDER_NAME_OLD)) {
+    return _join(configDir, CONFIG_FILENAME_OLD);
+  }
+
+  return _join(configDir, CONFIG_FILENAME);
+};
+
+/**
+ * get base configuration data directory
+ * @param {string} dir directory to check
+ */
+const getBaseConfigDataDirectory = (dir) => {
+  if (!dir || !fs.existsSync(dir)) {
+    throw new Error(`directory ${dir} does not exist`);
+  }
+
+  if (dir.includes(CONFIG_FOLDER_NAME) || dir.includes(CONFIG_FOLDER_NAME_OLD)) {
+    return dir;
+  }
+
+  return '';
+};
+
+/**
+ * validate the `dir` directory has valid data directory, if not, throw error
+ * @param {string} dir the directory to validate
+ */
+const verifyDataDirectory = (dir) => {
+  if (!dir) {
+    throw new Error('dir should not be empty');
+  }
+
+  if (!fs.existsSync(dir)) {
+    throw new Error(`directory ${dir} does not exist`);
+  }
+
+  const configFile = path.join(dir, CONFIG_FILENAME);
+  const configFileOld = path.join(dir, CONFIG_FILENAME_OLD);
+  if (!fs.existsSync(configFile) && !fs.existsSync(configFileOld)) {
+    throw new Error(`the config file does not exist in ${dir}`);
+  }
+};
+
+const getDaemonLogDir = (baseDir) => path.join(baseDir, 'logs', '_abtnode');
+
+module.exports = {
+  joinConfigDir,
+  joinConfigFile,
+  joinKFile,
+  getBaseConfigDataDirectory,
+  getConfigDirFromAncestors,
+  getConfigDirFromCurrentDir,
+  getConfigFileFromAncestors,
+  getDaemonLogDir,
+  getDataDirectoryByConfigFile,
+  verifyDataDirectory,
+};

package/lib/manager/deploy.js

@@ -0,0 +1,75 @@
+const chalk = require('chalk');
+const { minimatch } = require('minimatch');
+
+const { print, printInfo } = require('../util');
+
+const checkMatch = (file, match) => {
+  let m = match;
+  if (!m.includes('*')) {
+    return false;
+  }
+  if (!m.endsWith('*')) {
+    return minimatch(file, m);
+  }
+  if (!m.endsWith('**')) {
+    m = `${m}*`;
+  }
+
+  return minimatch(file, m);
+};
+
+const checkInclude = (list, f) =>
+  f === '.' ||
+  f === '' || // root folder maybe '.' and ''
+  list.some(
+    (x) =>
+      x.indexOf(f) === 0 || // f is 'website' && x is 'website/public'
+      f.indexOf(x) === 0 || // f is website/public/index.html && x is website/public
+      checkMatch(f, x) // f is hooks/pre-start.js && x is hooks/*
+  );
+
+/**
+ * Whether a file should be deployed
+ * @param {string} file a file will be deployed
+ * @param {object} opts
+ * @param {array<string>} opts.diffList
+ * @param {BundleType} opts.bundleType
+ * @param {array<string>} opts.staticList
+ * @return {boolean} Should this file be deployed
+ */
+const fileFilter = (file, opts = {}) => {
+  const { diffList, bundleType, staticList } = opts;
+  // only include diffList if has one
+  if (diffList) {
+    return checkInclude(diffList, file);
+  }
+  // only include staticList if bundleType is static
+  if (bundleType === 'static') {
+    if (!staticList) {
+      throw new Error('staticList should not be empty when bundleType is static');
+    }
+    return checkInclude(staticList, file);
+  }
+  // include all files
+  return true;
+};
+
+const printDeployFileInfo = (adds, changes, deletes) => {
+  const padLeft = '  - ';
+  printInfo(`Added Files: ${chalk.cyan(adds.length)}`);
+  adds.forEach((f) => print(padLeft, f));
+  if (typeof changes !== 'undefined') {
+    printInfo(`Changed Files: ${chalk.cyan(changes.length)}`);
+    changes.forEach((f) => print(padLeft, f));
+  }
+  if (typeof deletes !== 'undefined') {
+    printInfo(`Deleted Files: ${chalk.cyan(deletes.length)}`);
+    deletes.forEach((f) => print(padLeft, f));
+  }
+};
+
+module.exports = {
+  fileFilter,
+  printDeployFileInfo,
+  checkMatch,
+};

package/lib/manager/index.js

@@ -0,0 +1,23 @@
+const processManager = require('./process');
+const configManager = require('./config');
+const deployManager = require('./deploy');
+
+const getConfigFile = async (configPathArg = process.cwd()) => {
+  const runningConfigFile = await processManager.getRunningConfigFile();
+  if (runningConfigFile) {
+    return runningConfigFile;
+  }
+
+  return configManager.getConfigFileFromAncestors(configPathArg);
+};
+
+const getConfigDir = async (configPathArg = process.cwd()) => {
+  const runningConfigDir = await processManager.getRunningConfigDataDir();
+  if (runningConfigDir) {
+    return runningConfigDir;
+  }
+
+  return configManager.getConfigDirFromAncestors(configPathArg);
+};
+
+module.exports = { ...processManager, ...configManager, deployManager, getConfigFile, getConfigDir };