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

package/lib/commands/blocklet/upload.js

@@ -0,0 +1,105 @@
+const path = require('path');
+const fs = require('fs');
+const chalk = require('chalk');
+const { BLOCKLET_STORE_URL } = require('@abtnode/constant');
+const debug = require('debug')(require('../../../package.json').name);
+const { upload } = require('@blocklet/store');
+const { joinURL } = require('ufo');
+const { printInfo, printSuccess, printError } = require('../../util');
+const { logTar, getContents } = require('../../util/blocklet/tar');
+const Config = require('../../util/blocklet/config');
+const { wrapSpinner } = require('../../ui');
+
+exports.run = async (originalMetaFile, { accessToken, profile }) => {
+  const config = new Config({
+    configFile: process.env.ABT_NODE_CONFIG_FILE,
+    section: profile === 'default' ? '' : profile,
+  });
+  const developerDoc = 'https://developer.blocklet.io/docs';
+  const storeUrl = config.get('store') || config.get('registry') || (profile === 'default' ? BLOCKLET_STORE_URL : '');
+  if (!storeUrl) {
+    printError('Can not find the store url to upload the blocklet!');
+    printInfo(`You can fix with: ${chalk.cyan('blocklet config set store [storeUrl]')}`);
+    printInfo(`To learn more: ${chalk.cyan(developerDoc)}`);
+  }
+
+  printInfo(`Upload using profile ${chalk.cyan(profile)} to store ${chalk.cyan(storeUrl)}`);
+
+  let metaFile = originalMetaFile;
+  if (!metaFile) {
+    metaFile = path.join(process.cwd(), '.blocklet', 'release', 'blocklet.json');
+  }
+
+  if (!fs.existsSync(metaFile)) {
+    printError(`Invalid meta file: '${metaFile}'`);
+    process.exit(1);
+  }
+
+  let realAccessToken = accessToken;
+  if (!realAccessToken) {
+    realAccessToken = config.get('accessToken');
+    debug('read access token from config');
+    if (!realAccessToken) {
+      // TODO: 添加 accessToken 不存在情况下自动去获取 accessToken 的逻辑
+      printError('accessToken is required to upload a blocklet');
+      process.exit(1);
+    }
+  }
+
+  try {
+    const response = await upload({
+      metaFile,
+      source: 'CLI',
+      accessToken: realAccessToken,
+      storeUrl,
+      config,
+      printInfo,
+      printSuccess,
+      printTar: async (meta, filePath) => {
+        const pkgContents = await getContents(meta, filePath);
+        logTar(pkgContents);
+      },
+      wrapSpinner,
+      debug,
+    });
+    if (response.status === 'published') {
+      printSuccess(
+        `Blocklet ${chalk.cyan(response.name)} ${chalk.cyan(
+          response.version
+        )} auto published successfully: ${chalk.cyan(joinURL(storeUrl, '/blocklets', response.did))} !`
+      );
+    } else {
+      printSuccess(
+        `Blocklet ${chalk.cyan(response.name)} ${chalk.cyan(response.version)} successfully uploaded to ${chalk.cyan(
+          storeUrl
+        )}!`
+      );
+      printInfo(
+        `${chalk.cyan('Tips:')}  You need to publish the blocklet at ${chalk.cyan(
+          joinURL(storeUrl, '/developer/blocklets')
+        )} to make it public accessible`
+      );
+    }
+  } catch (err) {
+    if (/\[NO-ACCESS\]/.test(err?.message || '')) {
+      printInfo(
+        `Blocklet store accessToken is used to authorize developers when uploading blocklets, you can generate your own accessToken from ${chalk.cyan(
+          storeUrl
+        )}`
+      );
+      printInfo('Please use the following two methods to specify');
+      printInfo(`Option 1: Set a access token locally: ${chalk.cyan('blocklet config set accessToken [accessToken]')}`);
+      printInfo(
+        `Option 2: By specifying the --access-token parameter: ${chalk.cyan(
+          'blocklet upload --access-token <access token>'
+        )}`
+      );
+    }
+    printError(err.message);
+    printInfo(`To learn more: ${chalk.cyan(developerDoc)}`);
+
+    process.exit(1);
+  }
+
+  process.exit(0);
+};

package/lib/commands/blocklet/version.js

@@ -0,0 +1,81 @@
+const semver = require('semver');
+const shell = require('shelljs');
+const chalk = require('chalk');
+const getBlockletMeta = require('@blocklet/meta/lib/parse');
+const { BLOCKLET_DEFAULT_VERSION, BLOCKLET_LATEST_SPEC_VERSION } = require('@blocklet/constant');
+const { select: getMetaFile, update: updateMetaFile } = require('@blocklet/meta/lib/file');
+
+const { printSuccess, printError, printInfo } = require('../../util');
+const debug = require('../../debug')('blocklet:version');
+
+// eslint-disable-next-line default-param-last
+exports.run = (newVersion = 'patch', { gitCommit = false, force = false }) => {
+  try {
+    const dir = process.cwd();
+    const file = getMetaFile(dir);
+    const meta = getBlockletMeta(dir, { ensureComponentStore: false });
+    const currentVersion = semver.clean(meta.version) || BLOCKLET_DEFAULT_VERSION;
+    const currentSpecVersion = meta.specVersion;
+
+    let nextVersion = null;
+    if (semver.valid(newVersion, { loose: true })) {
+      nextVersion = semver.clean(newVersion, { loose: true });
+    } else {
+      nextVersion = semver.inc(currentVersion, newVersion);
+    }
+
+    if (!nextVersion) {
+      printInfo('Failed to determine next version, abort!');
+      process.exit(1);
+    }
+
+    if (currentVersion === nextVersion) {
+      printInfo('Bumping to same version, skipping');
+      process.exit(0);
+    }
+
+    meta.version = nextVersion;
+    meta.specVersion = BLOCKLET_LATEST_SPEC_VERSION;
+    debug('bump blocklet version', { dir, newVersion, currentVersion, nextVersion });
+
+    if (semver.gt(currentSpecVersion, BLOCKLET_LATEST_SPEC_VERSION)) {
+      if (!force) {
+        // eslint-disable-next-line max-len
+        printError(
+          `The new specVersion of blocklet.yml (${chalk.cyan(
+            BLOCKLET_LATEST_SPEC_VERSION
+          )}) is smaller than the current specVersion (${chalk.cyan(currentSpecVersion)})\n`
+        );
+        printInfo(
+          `Please upgrade the version of the "blocklet" command by executing ${chalk.cyan('blocklet server upgrade')}`
+        );
+        process.exit(1);
+      }
+
+      // eslint-disable-next-line max-len
+      printInfo(
+        `The specVersion of blocklet.yml is about to be downgraded from ${chalk.cyan(
+          currentSpecVersion
+        )} to ${chalk.cyan(BLOCKLET_LATEST_SPEC_VERSION)}`
+      );
+    }
+
+    updateMetaFile(file, meta);
+    printSuccess(`Blocklet version bumped to ${nextVersion}`);
+
+    if (gitCommit) {
+      try {
+        shell.exec(`git add ${file.replace(dir, '')}`);
+        shell.exec(`git commit -nm "blocklet version ${nextVersion}`);
+      } catch (err) {
+        printError('Failed to commit to git', err.message);
+      }
+    }
+
+    process.exit(0);
+  } catch (error) {
+    debug('bump blocklet version failed', error);
+    printError('Bump blocklet version failed: ', error.message);
+    process.exit(1);
+  }
+};

package/lib/commands/server/cleanup.js

@@ -0,0 +1,32 @@
+const { printSuccess, printError } = require('../../util');
+const { getNode } = require('../../node');
+
+exports.run = async ({ target }) => {
+  const { node } = await getNode({ dir: process.cwd() });
+
+  node.onReady(async () => {
+    const info = await node.getNodeInfo();
+    await node.handleRouting(info);
+
+    if (target === 'cache') {
+      const removed = await node.clearCache({ pattern: null, teamDid: info.did });
+      printSuccess(`Cache for server cleared: ${removed.join(',')}`);
+      process.exit(0);
+    }
+
+    if (target === 'maintenance-status') {
+      await node.states.node.updateNodeInfo({
+        mode: info.previousMode || info.mode,
+        previousMode: '',
+        upgradeSessionId: '',
+        nextVersion: '',
+      });
+
+      printSuccess('Server maintenance status reset');
+      process.exit(0);
+    }
+
+    printError(`Unknown cleanup target: ${target}`);
+    process.exit(1);
+  });
+};

package/lib/commands/server/command.js

@@ -0,0 +1,131 @@
+#!/usr/bin/env node
+/* eslint-disable global-require */
+
+const chalk = require('chalk');
+const { Command } = require('commander');
+const last = require('lodash/last');
+
+const { NODE_MODES, WEB_WALLET_URL } = require('@abtnode/constant');
+const debug = require('debug')('@blocklet/cli:abtnode');
+
+const { version } = require('../../../package.json');
+const start = require('./start');
+const stop = require('./stop');
+const init = require('./init');
+const info = require('./info');
+const cleanup = require('./cleanup');
+const logs = require('./logs');
+const status = require('./status');
+const upgrade = require('./upgrade');
+const rescue = require('./rescue');
+const { printVersionTip } = require('../../util');
+
+module.exports = (parentCommand = '') => {
+  const program = new Command(parentCommand);
+
+  program.version(version);
+  program.description('Manage Blocklet Server');
+  program.option('-c --config [node-config]', 'Blocklet Server configuration file');
+  program.option('-y --yes', 'Automatic yes to prompts', false);
+
+  const parseOptions =
+    (handler) =>
+    async (...args) => {
+      printVersionTip();
+
+      const commonOptions = program.opts();
+      const options = last(args);
+      const allOptions = { ...commonOptions, ...options };
+      debug('parse options', allOptions);
+      await handler(...args.slice(0, args.length - 1), allOptions);
+    };
+
+  const modes = Object.values(NODE_MODES)
+    .map((d) => `"${d}"`)
+    .join(', ');
+
+  const forceIntranet = process.env.ABT_NODE_FORCE_INTRANET === '1';
+
+  program
+    .command('start')
+    .option('-u --update-db', 'Should we update Blocklet Server database with latest settings from config file')
+    .option('--update-blocklet-env', 'Should we update blocklet environments', false)
+    .option('-k --keep-alive', 'Should I keep running without exiting after starting success', false)
+    .option(
+      '-a --auto-init',
+      'If the configuration data directory does not exists, initialize it automatically.',
+      false
+    )
+    .option('-m --force-mode <forceMode>', `Update blocklet server mode to specified, allowed options can be ${modes}`)
+    .option('--force-intranet', 'Force blocklet server to run in intranet, ignore any external IP.', forceIntranet)
+    .description('Start Blocklet Server')
+    .action(parseOptions(start.run));
+
+  program
+    .command('init')
+    .option('-f --force', 'Initialize a Blocklet Server instance without having it ask any questions', false)
+    .option(
+      '-i --interactive',
+      'Should we run in interactive mode (default: false), if `--force` is enabled, the `--interactive` argument will be invalid',
+      false
+    )
+    .option(
+      '--mode <mode>',
+      `Initial server mode, allowed mode can be ${NODE_MODES.PRODUCTION}, ${NODE_MODES.DEBUG}`,
+      NODE_MODES.PRODUCTION
+    )
+    .option('--https', 'Enable default https support for dashboard and blocklets')
+    .option('--no-https', 'Disable default https support for dashboard and blocklets')
+    .option('--sk <custom-sk>', 'Customize the blocklet server secret key', '')
+    .option(
+      '--web-wallet-url <url>',
+      'Customize the web wallet url',
+      process.env.ABT_NODE_WEB_WALLET_URL || WEB_WALLET_URL
+    )
+    .option('--http-port <httpPort>', 'Http port of the service gateway', 80)
+    .option('--https-port <httpsPort>', 'Https port of the service gateway', 443)
+    .option('--owner-nft-holder <ownerNftHolderDid>', 'The did that holds the ownership NFT', '')
+    .option('--owner-nft-issuer <ownerNftIssuerDid>', 'The did that issued the ownership NFT', '')
+    .option('--trusted-passport-issuer <passportIssuerDid>', 'The passport issuer did that is trusted by this node', '')
+    .option('--disable-passport-issuance', 'Disable passport issuance by this node', false)
+    .description('Init Blocklet Server config')
+    .action(parseOptions(init.run));
+
+  program.command('status').description('Show Blocklet Server and blocklet status').action(parseOptions(status.run));
+  program.command('logs').description('Show Blocklet Server and blocklet log files').action(parseOptions(logs.run));
+
+  program
+    .command('stop')
+    .option('-f --force', 'Force stop all Blocklet Server related processes', false)
+    .description('Stop Blocklet Server and blocklets')
+    .action(parseOptions(stop.run));
+
+  program
+    .command('rescue')
+    .option('--stopped-after <datetime>', 'Only start blocklets that are stopped after the specified time')
+    .option('-f --force', 'Force start all blocklets, even if they are already running', false)
+    .description('Start all blocklets in current running server')
+    .action(parseOptions(rescue.run));
+
+  program
+    .command('info')
+    .option('-C --clipboard', 'Automatically copy environment information to clipboard', false)
+    .description('Get environment information for debugging and issue reporting')
+    .action(parseOptions(info.run));
+
+  program
+    .command('cleanup')
+    .option('--target <target>', 'Which target to cleanup, available options: cache, maintenance-status')
+    .description('Do some server level cleanup work')
+    .action(parseOptions(cleanup.run));
+
+  program.command('upgrade').description('Self-Upgrade Blocklet Server').action(parseOptions(upgrade.run));
+
+  program.on('--help', () => {
+    /* eslint-disable no-console */
+    console.log('');
+    console.log(`None of the above command seems help? Consider command line utility ${chalk.cyan('blocklet')}.`);
+  });
+
+  return program;
+};

package/lib/commands/server/info.js

@@ -0,0 +1,92 @@
+const envinfo = require('envinfo');
+const xbytes = require('xbytes');
+const shell = require('shelljs');
+const chalk = require('chalk');
+const clipboardy = require('clipboardy');
+const ip = require('@abtnode/core/lib/util/ip');
+const info = require('@abtnode/core/lib/util/sysinfo');
+
+const { canUseFileSystemIsolateApi } = require('@abtnode/util/lib/security');
+const { print, printError, printInfo, getCLIBinaryName } = require('../../util');
+const { readNodeConfigWithValidate, getNode } = require('../../node');
+const getDockerStatusLog = require('../../util/docker-status-log');
+
+exports.run = ({ clipboard }) => {
+  // Clipboard is not accessible when on a linux tty
+  const copyToClipboard = process.platform === 'linux' && !process.env.DISPLAY ? false : clipboard;
+
+  const printEnvInfo = (err) => {
+    if (err) {
+      console.error(err);
+    }
+
+    return envinfo
+      .run({
+        System: ['OS', 'CPU', 'Shell'],
+        Binaries: ['Node', 'npm', 'Yarn', 'pm2', 'pnpm', 'bun'],
+        Browsers: ['Chrome', 'Edge', 'Firefox', 'Safari'],
+        Servers: ['Apache', 'Nginx'],
+        Virtualization: ['Docker', 'Parallels', 'VirtualBox', 'VMware Fusion'],
+        npmPackages: ['@abtnode/*', '@arcblock/*'],
+        npmGlobalPackages: ['@abtnode/*', '@arcblock/*', 'pm2', 'npm', 'yarn'],
+      })
+      .then((output) => {
+        print(output);
+
+        if (copyToClipboard) {
+          clipboardy.writeSync(output);
+        }
+
+        process.exit(0);
+      })
+      .catch((e) => {
+        printError(`Failed to fetch env info: ${e.message}`);
+        process.exit(1);
+      });
+  };
+
+  return readNodeConfigWithValidate(process.cwd())
+    .then(async ({ config, configFile }) => {
+      printInfo('Server binary from:', chalk.cyan(shell.which(getCLIBinaryName())?.stdout));
+      printInfo('Server config from:', chalk.cyan(configFile));
+      printInfo('Server router provider:', chalk.cyan(config.node.routing.provider));
+      printInfo('Server http port:', chalk.cyan(config.node.routing.httpPort));
+      printInfo('Server https port:', chalk.cyan(config.node.routing.httpsPort));
+
+      let result = await info.getSysInfo();
+      printInfo('Server host cpu:', chalk.cyan(result.cpu.physicalCores), '/', chalk.cyan(result.cpu.cpus.length));
+      printInfo(
+        'Server host memory:',
+        chalk.cyan(xbytes(result.mem.used, { iec: true })),
+        '/',
+        chalk.cyan(xbytes(result.mem.total, { iec: true }))
+      );
+
+      result = await ip.get();
+      printInfo('Server host IP:', chalk.cyan(JSON.stringify(result)));
+      const correct = await ip.isDnsIpMappingCorrect(config.node.did);
+
+      /**
+       * @type {{node: import('@abtnode/client')}}
+       */
+      const { node } = await getNode({ dir: process.cwd() });
+
+      const nodeInfo = await node.getNodeInfo();
+      const { enableFileSystemIsolation } = nodeInfo;
+      const canUseFileSystemIsolation = canUseFileSystemIsolateApi();
+
+      printInfo(
+        'Server file system isolation status:',
+        enableFileSystemIsolation
+          ? `${canUseFileSystemIsolation ? chalk.green('on(available)') : chalk.yellow('on(unavailable, version must be >= 21.6.0)')}`
+          : chalk.red('off')
+      );
+      // 判断是否是mac
+
+      getDockerStatusLog(printInfo, nodeInfo);
+      printInfo('Server domain status:', correct ? chalk.green('correct') : chalk.red('mismatch'));
+
+      return printEnvInfo();
+    })
+    .catch(printEnvInfo);
+};