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

package/lib/commands/blocklet/bundle/zip/resolve.js

@@ -0,0 +1,93 @@
+/* eslint-disable no-use-before-define */
+/* eslint-disable func-names */
+const { version: nodeVersion } = require('process');
+
+const findUp = require('find-up');
+const pathExists = require('path-exists');
+const resolve = require('resolve');
+const { lt: ltVersion } = require('semver');
+
+// Find the path to a module's `package.json`
+// We need to use `resolve` instead of `require.resolve()` because:
+//  - it is async
+//  - it preserves symlinks:
+//     - this is important because if a file does a `require('./symlink')`, we
+//       need to bundle the symlink and its target, not only the target
+//     - `path.resolve()` cannot be used for relative|absolute file paths
+//       because it does not resolve ommitted file extension,
+//       e.g. `require('./file')` instead of `require('./file.js')`
+//     - the CLI flag `--preserve-symlinks` can be used with Node.js, but it
+//       cannot be set runtime
+// However it does not give helpful error messages.
+//   https://github.com/browserify/resolve/issues/223
+// So, on errors, we fallback to `require.resolve()`
+const resolvePackage = async function (moduleName, basedir) {
+  try {
+    return await resolvePathPreserveSymlinks(`${moduleName}/package.json`, basedir);
+  } catch (error) {
+    if (ltVersion(nodeVersion, REQUEST_RESOLVE_MIN_VERSION)) {
+      throw error;
+    }
+
+    try {
+      return resolvePathFollowSymlinks(`${moduleName}/package.json`, basedir);
+    } catch (err) {
+      const packagePath = resolvePackageFallback(moduleName, basedir);
+      if (packagePath === undefined) {
+        throw err;
+      }
+      return packagePath;
+    }
+  }
+};
+
+// TODO: remove after dropping support for Node <8.9.0
+// `require.resolve()` option `paths` was introduced in Node 8.9.0
+const REQUEST_RESOLVE_MIN_VERSION = '8.9.0';
+
+// We need to use `new Promise()` due to a bug with `utils.promisify()` on
+// `resolve`:
+//   https://github.com/browserify/resolve/issues/151#issuecomment-368210310
+const resolvePathPreserveSymlinks = function (path, basedir) {
+  return new Promise((success, reject) => {
+    resolve(path, { basedir, preserveSymlinks: true }, (error, resolvedLocation) => {
+      if (error) {
+        return reject(error);
+      }
+
+      return success(resolvedLocation);
+    });
+  });
+};
+
+const resolvePathFollowSymlinks = function (path, basedir) {
+  return require.resolve(path, { paths: [basedir] });
+};
+
+// `require.resolve()` on a module's specific file (like `package.json`)
+// can be forbidden by the package author by using an `exports` field in
+// their `package.json`. We need this fallback.
+// It looks for the first directory up from a package's `main` file that:
+//   - is named like the package
+//   - has a `package.json`
+// Theoritically, this might not the root `package.json`, but this is very
+// unlikely, and we don't have any better alternative.
+const resolvePackageFallback = function (moduleName, basedir) {
+  const mainFilePath = resolvePathFollowSymlinks(moduleName, basedir);
+  return findUp(isPackageDir.bind(null, moduleName), { cwd: mainFilePath, type: 'directory' });
+};
+
+const isPackageDir = async function (moduleName, dir) {
+  // Need to use `endsWith()` to take into account `@scope/package`.
+  // Backslashes need to be converted for Windows.
+  if (!dir.replace(BACKSLASH_REGEXP, '/').endsWith(moduleName) || !(await pathExists(`${dir}/package.json`))) {
+    return;
+  }
+
+  // eslint-disable-next-line consistent-return
+  return dir;
+};
+
+const BACKSLASH_REGEXP = /\\/g;
+
+module.exports = { resolvePackage, resolvePathPreserveSymlinks };

package/lib/commands/blocklet/cleanup.js

@@ -0,0 +1,52 @@
+const { BLOCKLET_CONFIGURABLE_KEY } = require('@blocklet/constant');
+const { isValid: isValidDid, toAddress } = require('@arcblock/did');
+const { printSuccess, printError } = require('../../util');
+const { getNode } = require('../../node');
+
+exports.run = async ({ target, appDid }) => {
+  if (!appDid) {
+    printError('Please provide `--app-did` when cleanup cache or backup');
+    process.exit(1);
+  }
+  if (isValidDid(appDid) === false) {
+    printError(`appDid is not valid: ${appDid}`);
+    process.exit(1);
+  }
+
+  // eslint-disable-next-line
+  appDid = toAddress(appDid);
+
+  const { node } = await getNode({ dir: process.cwd() });
+  node.onReady(async () => {
+    const blocklet = await node.getBlocklet({ did: appDid });
+    if (!blocklet) {
+      printError(`Blocklet ${appDid} not found`);
+      process.exit(1);
+    }
+
+    if (target === 'cache') {
+      const removed = await node.clearCache({ pattern: null, teamDid: appDid });
+      printSuccess(`Cache for app ${appDid} cleared: ${removed.join(',')}`);
+      process.exit(0);
+    }
+
+    if (target === 'backup') {
+      await node.configBlocklet({
+        did: appDid,
+        configs: [
+          {
+            key: BLOCKLET_CONFIGURABLE_KEY.BLOCKLET_APP_BACKUP_ENDPOINT,
+            value: '',
+          },
+        ],
+      });
+      await node.updateAutoBackup({ did: appDid, autoBackup: { enabled: false } });
+
+      printSuccess(`Blocklet ${appDid} auto-backup disabled`);
+      process.exit(0);
+    }
+
+    printError(`Unknown cleanup target: ${target}`);
+    process.exit(1);
+  });
+};

package/lib/commands/blocklet/config.js

@@ -0,0 +1,108 @@
+const chalk = require('chalk');
+const $get = require('lodash/get');
+const { fromSecretKey } = require('@ocap/wallet');
+const { isValid } = require('@arcblock/did');
+
+const Config = require('../../util/blocklet/config');
+const { print, printSuccess, printError } = require('../../util');
+
+const getConfig = (profile) => {
+  return new Config({ configFile: process.env.ABT_NODE_CONFIG_FILE, section: profile === 'default' ? '' : profile });
+};
+
+const getProfile = (command) => $get(command, 'parent._optionValues.profile') || $get(command, '_optionValues.profile');
+
+const whiteList = ['store', 'accessToken', 'registry', 'developerDid', 'name', 'email'];
+
+function validate(key, value) {
+  const validatorMap = {
+    store: (v) => {
+      // 校验是否为合法的url地址（必须是 http 或 https 协议）,例如：https://store.blocklet.dev/
+      if (/^((https?):\/\/)[\w-]+(\.[\w-]+)+([\w.,@?^=%&:/~+#-]*[\w@?^=%&/~+#-])?$/.test(v)) {
+        return true;
+      }
+      print('Invalid store url:', v);
+      return false;
+    },
+    // TODO: remove this in the future
+    registry(...args) {
+      return validatorMap.store(...args);
+    },
+    accessToken: (v) => {
+      try {
+        fromSecretKey(v);
+      } catch {
+        print('Invalid access token:', v);
+        return false;
+      }
+      return true;
+    },
+    developerDid: (v) => {
+      try {
+        return isValid(v);
+      } catch {
+        return false;
+      }
+    },
+  };
+  const fn = validatorMap[key] || (() => true);
+  return fn(value);
+}
+
+function set(key, value, options, command) {
+  if (whiteList.includes(key)) {
+    if (validate(key, value)) {
+      getConfig(getProfile(command)).set(key, value);
+      printSuccess(`Config ${key} successfully`);
+      process.exit(0);
+    } else {
+      printError(`Unexpected config value ${value} for ${key}`);
+      process.exit(1);
+    }
+  } else {
+    printError(`Support config keys are: ${whiteList.join(', ')}`);
+    process.exit(1);
+  }
+}
+
+function get(key, options, command) {
+  print(Config.stringify(getConfig(getProfile(command)).get(key)));
+  process.exit(0);
+}
+
+function list(options, command) {
+  const profile = getProfile(command);
+  const config = getConfig(profile).get();
+  if (config) {
+    print(Config.stringify(config));
+  } else {
+    print(`No config found for profile ${chalk.cyan(profile)}`);
+  }
+  process.exit(0);
+}
+
+function unset(key, options, command) {
+  getConfig(getProfile(command)).unset(key);
+  print(`Delete config ${key} successfully`);
+  process.exit(0);
+}
+
+module.exports = {
+  set,
+  get,
+  list,
+  del: unset,
+  delete: unset,
+
+  run: (command, options) => {
+    const [key, value] = options.args;
+
+    if (typeof key === 'undefined') {
+      list(key, command);
+    } else if (typeof value !== 'undefined') {
+      set(key, value, command);
+    } else {
+      get(key, command);
+    }
+  },
+};

package/lib/commands/blocklet/connect.js

@@ -0,0 +1,87 @@
+/* eslint-disable global-require */
+const chalk = require('chalk');
+const { createConnect } = require('@blocklet/store');
+const { getStoreUrl } = require('@abtnode/core/lib/util/store');
+const isUndefined = require('lodash/isUndefined');
+const open = require('open');
+const validUrl = require('valid-url');
+const inquirer = require('inquirer');
+const { printError, printInfo, printSuccess, getCLIBinaryName } = require('../../util');
+const Config = require('../../util/blocklet/config');
+const { wrapSpinner } = require('../../ui');
+
+/**
+ *
+ * @description 确认是否要覆盖之前填写的store url,回车或输入y直接覆盖,输入其他字符就不覆盖
+ * @see https://www.npmjs.com/package/inquirer
+ * @see https://github.com/SBoudrias/Inquirer.js/blob/0053e3f5694a4f75c4901512ab87e8906d1d7896/packages/inquirer/examples/pizza.js
+ * @default false
+ * @return {boolean}
+ */
+async function confirmOverwriteStoreUrl() {
+  const { isRewriteStore } = await inquirer.prompt([
+    {
+      name: 'isRewriteStore',
+      type: 'confirm',
+      default: false,
+      message: 'The store url has been set, do you need to overwrite it?',
+    },
+  ]);
+
+  return isRewriteStore;
+}
+
+const run = async (store, { profile }) => {
+  // 校验是否为合法的url地址（必须是 http 或 https 协议）,例如：https://store.blocklet.dev/
+  if (!validUrl.isWebUri(store)) {
+    printError('Invalid store url:', store);
+    process.exit(1);
+  }
+
+  try {
+    const storeUrl = await getStoreUrl(store);
+
+    // 读取配置
+    const config = new Config({
+      configFile: process.env.ABT_NODE_CONFIG_FILE,
+      section: profile === 'default' ? '' : profile,
+    });
+
+    const oldStoreUrl = config.get('store');
+    // 配置过store url,前后两次配置不一样,且选择不覆盖配置时,退出程序
+    if (!isUndefined(oldStoreUrl) && oldStoreUrl !== storeUrl && !(await confirmOverwriteStoreUrl())) {
+      process.exit(0);
+    }
+
+    const fetchData = await createConnect({
+      connectUrl: storeUrl,
+      connectAction: 'connect-cli',
+      enableEncrypt: true,
+      wrapSpinner,
+      openPage: open,
+      prettyUrl: (url) => chalk.cyan(url),
+    });
+    const { secretKey, developerDid, name, email } = fetchData;
+    config.set('store', storeUrl);
+    config.set('accessToken', secretKey);
+    config.set('developerDid', developerDid);
+    config.set('name', name);
+    config.set('email', email);
+
+    printSuccess(`Successfully connected, and now you are ready to upload blocklets to ${storeUrl}`);
+    printInfo(
+      `${chalk.cyan('Tips:')} Use the following command to view the configuration: ${chalk.cyan(
+        `${getCLIBinaryName()} config list ${profile === 'default' ? '' : `--profile ${profile}`}`
+      )}`
+    );
+  } catch (err) {
+    console.error(err);
+    printInfo(
+      `You can use the command ${chalk.cyan(`${getCLIBinaryName()} connect`)} to try to reconnect to the blocklet store`
+    );
+    process.exit(1);
+  }
+  process.exit(0);
+};
+
+exports.run = run;

package/lib/commands/blocklet/create.js

@@ -0,0 +1,38 @@
+const childProcess = require('child_process');
+const chalk = require('chalk');
+
+const { printInfo, print, printWarning } = require('../../util');
+
+exports.run = (name, options = {}) => {
+  // eslint-disable-next-line no-param-reassign
+  name = name ? name.trim() : '';
+  let createCommand;
+  // must use latest version, otherwise npx will use cache version
+  if (name) {
+    createCommand = `npx create-blocklet@latest ${name}`;
+  } else {
+    createCommand = 'npx create-blocklet@latest';
+  }
+  if (options.did) {
+    createCommand += ` --did=${options.did}`;
+  }
+
+  try {
+    childProcess.execSync(createCommand, { stdio: 'inherit' });
+    process.exit(0);
+  } catch (error) {
+    console.error(error);
+
+    print('');
+    printWarning(`This is a problem related to ${chalk.cyan('npx')}.`);
+    print(`  You can directly try to execute ${chalk.cyan(createCommand)} to create blocklet. \n`);
+
+    printInfo(
+      `You can also execute ${chalk.cyan('npm install -g create-blocklet')} and execute ${chalk.cyan(
+        createCommand.replace('npx ', '').replace('@latest', '')
+      )}`
+    );
+
+    process.exit(error.status);
+  }
+};