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

package/lib/commands/blocklet/document.js

@@ -0,0 +1,39 @@
+const { toAddress } = require('@ocap/util');
+const { updateDidDocument } = require('@abtnode/core/lib/util/blocklet');
+
+const { getNode } = require('../../node');
+const debug = require('../../debug')('document');
+const { printSuccess, printError } = require('../../util');
+const { wrapSpinner } = require('../../ui');
+
+const update = async (appId) => {
+  try {
+    const { node } = await getNode();
+    const nodeInfo = await node.getNodeInfo();
+
+    const did = toAddress(appId);
+
+    const blocklet = await node.getBlocklet({ did });
+    if (!blocklet) {
+      printError(`Blocklet ${appId} not found`);
+      process.exit(1);
+    }
+
+    await wrapSpinner('Updating...', () => updateDidDocument({ blocklet, nodeInfo }), {
+      throwOnError: true,
+      printErrorFn: printError,
+    });
+
+    printSuccess(`Update did document for ${appId} successfully!`);
+    process.exit(0);
+  } catch (error) {
+    debug(error);
+    printError(`Failed to update did document for blocklet ${appId}, error: ${error.message}`);
+
+    process.exit(1);
+  }
+};
+
+module.exports = {
+  update,
+};

package/lib/commands/blocklet/exec.js

@@ -0,0 +1,106 @@
+const fs = require('fs');
+const path = require('path');
+const chalk = require('chalk');
+const runScript = require('@abtnode/util/lib/run-script');
+const getBlockletMeta = require('@blocklet/meta/lib/parse');
+const { getSafeEnv } = require('@abtnode/core/lib/util');
+const { isValid: isValidDid, toAddress } = require('@arcblock/did');
+const { getRuntimeEnvironments } = require('@abtnode/core/lib/util/blocklet');
+
+const { printError, printInfo, printSuccess, getCLIBinaryName } = require('../../util');
+const { getNode } = require('../../node');
+const { checkRunning } = require('../../manager');
+const ensureBlockletEnv = require('../../util/blocklet/env');
+
+const checkNodeRunning = async () => {
+  const isRunning = await checkRunning();
+  if (!isRunning) {
+    const startCommand = chalk.cyan(`${getCLIBinaryName()} server start`);
+    printError('Blocklet Server is not running, can not execute anything!');
+    printInfo(`To start Blocklet Server, use ${startCommand}`);
+    process.exit(1);
+  }
+};
+
+const run = async (script, { appId, timeout } = {}) => {
+  try {
+    await checkNodeRunning();
+    const { node } = await getNode();
+
+    const timeoutMs = (+timeout || 30 * 60) * 1000;
+    const appDir = process.cwd();
+    const meta = getBlockletMeta(appDir, { fix: false });
+
+    printInfo(
+      `Try to run script for ${appId ? 'component' : 'blocklet'} ${chalk.cyan(meta.name)} (timeout: ${timeoutMs}ms)`
+    );
+
+    const scriptPath = path.join(appDir, script);
+    if (fs.existsSync(scriptPath) === false) {
+      printError(`Script ${chalk.cyan(scriptPath)} does not exist`);
+      process.exit(1);
+    }
+
+    if (appId) {
+      if (isValidDid(appId) === false) {
+        printError(`appId is not valid: ${appId}`);
+        process.exit(1);
+      }
+
+      // eslint-disable-next-line
+      appId = toAddress(appId);
+    }
+
+    node.onReady(async () => {
+      const rootDid = appId || meta.did;
+      const componentId = appId ? meta.did : null;
+
+      let blocklet = await node.getBlocklet({ did: rootDid });
+      let component;
+
+      if (!blocklet) {
+        printError(`Blocklet ${appId || meta.name} not found, you should install the blocklet first.`);
+        process.exit(1);
+      }
+
+      if (componentId) {
+        component = blocklet.children.find((x) => x.meta.did === componentId);
+        if (!component) {
+          printError(
+            `Component ${meta.name} not found in ${blocklet.meta.name}, you should add the component to the blocklet first`
+          );
+          process.exit(1);
+        }
+      }
+
+      // ensure environments
+      await ensureBlockletEnv(node, blocklet, appDir);
+
+      blocklet = await node.getBlocklet({ did: rootDid });
+      const nodeEnvironments = await node.states.node.getEnvironments();
+      if (componentId) {
+        component = blocklet.children.find((x) => x.meta.did === componentId);
+        await runScript(`node ${scriptPath}`, component.env.processId, {
+          cwd: appDir,
+          env: getSafeEnv(getRuntimeEnvironments(component, nodeEnvironments, [blocklet])),
+          silent: false,
+          timeout: timeoutMs,
+        });
+      } else {
+        await runScript(`node ${scriptPath}`, blocklet.env.processId, {
+          cwd: appDir,
+          env: getSafeEnv(getRuntimeEnvironments(blocklet, nodeEnvironments)),
+          silent: false,
+          timeout: timeoutMs,
+        });
+      }
+      printSuccess('Done!');
+      process.exit(0);
+    });
+  } catch (err) {
+    printError(err.message);
+    process.exit(1);
+  }
+};
+
+exports.run = run;

package/lib/commands/blocklet/init.js

@@ -0,0 +1,300 @@
+const chalk = require('chalk');
+const fs = require('fs-extra');
+const fuzzy = require('fuzzy');
+const inquirer = require('inquirer');
+const path = require('path');
+const open = require('open');
+const pickBy = require('lodash/pickBy');
+const {
+  BLOCKLET_GROUPS,
+  BLOCKLET_META_FILE,
+  BLOCKLET_DEFAULT_VERSION,
+  BlockletGroup,
+  BLOCKLET_LATEST_SPEC_VERSION,
+} = require('@blocklet/constant');
+const { select: getMetaFile, update: updateMetaFile, read: readMetaFile } = require('@blocklet/meta/lib/file');
+const { fixInterfaces, parsePerson } = require('@blocklet/meta/lib/fix');
+const { validateMeta } = require('@blocklet/meta/lib/validate');
+const { fixRepository } = require('@blocklet/meta/lib/fix');
+const { titleSchema } = require('@blocklet/meta/lib/schema');
+const { isValid } = require('@arcblock/did');
+
+const { createConnect } = require('@blocklet/store');
+const {
+  getNPMConfig,
+  print,
+  printError,
+  printInfo,
+  printSuccess,
+  getUserName,
+  fixFiles,
+  printWarning,
+} = require('../../util');
+const { wrapSpinner } = require('../../ui');
+
+const COMMON_KEYS = ['name', 'description', 'version', 'author', 'keywords', 'repository'];
+
+inquirer.registerPrompt('autocomplete', require('inquirer-autocomplete-prompt'));
+
+const pickCommonFieldsInBlockletAndPackage = (meta) =>
+  pickBy(meta, (value, key) => value !== undefined && COMMON_KEYS.includes(key));
+
+const doInit = ({ metaFilePath, blockletMeta }) => {
+  updateMetaFile(metaFilePath, blockletMeta);
+  printSuccess(`Meta file ${chalk.cyan(metaFilePath)} was created`);
+
+  if (!fs.existsSync('blocklet.md')) {
+    fs.writeFileSync('blocklet.md', `# ${blockletMeta.name}`);
+    printSuccess(`Doc file ${chalk.cyan('blocklet.md')} was created`);
+  }
+
+  if (!fs.existsSync('screenshots')) {
+    fs.mkdirSync('screenshots');
+    printSuccess(`Screenshots dir ${chalk.cyan('screenshots/')} was created`);
+  }
+
+  if (!fs.existsSync('logo.png')) {
+    fs.copyFileSync(path.join(__dirname, 'assets', 'logo.png'), 'logo.png');
+    printSuccess(`${chalk.cyan('logo.png')} was created`);
+  }
+
+  if (blockletMeta.group === BlockletGroup.dapp) {
+    if (!fs.existsSync('index.js')) {
+      fs.copyFileSync(path.join(__dirname, 'assets', 'index.js'), 'index.js');
+      printSuccess(`${chalk.cyan('index.js')} was created`);
+    }
+  }
+
+  if (blockletMeta.group === BlockletGroup.static) {
+    if (!fs.existsSync('index.html')) {
+      fs.copyFileSync(path.join(__dirname, 'assets', 'index.html'), 'index.html');
+      printSuccess(`${chalk.cyan('index.html')} was created`);
+    }
+  }
+
+  // avoid bundle bug
+  if (!fs.existsSync('.gitignore')) {
+    fs.copyFileSync(path.join(__dirname, 'assets', 'git-ignore'), '.gitignore');
+  }
+};
+
+const getPromptQuestions = (defaults) => {
+  const questions = [
+    {
+      type: 'text',
+      name: 'title',
+      message: 'blocklet title',
+      default: defaults.name,
+      transformer: (name) => name.trim(),
+      validate: async (input) => {
+        try {
+          if (!input || !input.trim()) {
+            return 'title can not be empty';
+          }
+          await titleSchema.validateAsync(input);
+        } catch (error) {
+          return error.message;
+        }
+
+        return true;
+      },
+    },
+    {
+      type: 'text',
+      name: 'description',
+      message: 'Please write concise description:',
+      default: defaults.description || '',
+      validate: (description) => (description.trim() ? true : 'Description can not be empty'),
+    },
+    {
+      type: 'autocomplete',
+      name: 'group',
+      message: 'What\'s the group of the blocklet?', // prettier-ignore
+      default: defaults.group,
+      source: (_, inp) => {
+        const input = inp || '';
+        return new Promise((resolve) => {
+          const result = fuzzy.filter(input, BLOCKLET_GROUPS);
+          resolve(result.map((item) => item.original));
+        });
+      },
+    },
+    {
+      type: 'text',
+      name: 'main',
+      message: 'What\'s the entry point of the blocklet?', // prettier-ignore
+      default: (answers) => (answers.group === BlockletGroup.dapp ? 'index.js' : defaults.main || '.'),
+      validate: (main) => (main.trim() ? true : 'The entry point can not be empty'),
+      when: (answers) => answers.group !== BlockletGroup.gateway,
+    },
+  ];
+
+  return questions;
+};
+
+function getNpmAuthor() {
+  const npmAuthor = getNPMConfig('init.author.name');
+  const npmEmail = getNPMConfig('init.author.email');
+  let author = '';
+  if (npmAuthor) {
+    author = npmEmail ? `${npmAuthor} <${npmEmail}>` : npmAuthor;
+  }
+
+  return author;
+}
+
+function ensureMainDirPathWhenStatic(answers) {
+  if (answers.group !== BlockletGroup.static || !answers.main) {
+    return;
+  }
+
+  answers.main = path.dirname(answers.main) || '.';
+}
+
+async function generateDidFromWallet(
+  connectUrl = 'https://store.blocklet.dev',
+  { verbose = true, monikers = '' } = {}
+) {
+  const infoList = await createConnect({
+    connectUrl,
+    verbose,
+    monikers,
+    connectAction: 'gen-key-pair',
+    openPage: open,
+    wrapSpinner,
+  });
+  return infoList.map((x) => x.address);
+}
+
+// Run the cli interactively
+async function run({ yes = false, force = false, monikers = '', connectUrl, did }) {
+  if (monikers) {
+    const blockletDidList = await generateDidFromWallet(connectUrl, { verbose: false, monikers });
+    print(blockletDidList.join(','));
+    process.exit(0);
+  }
+  const dir = process.cwd();
+  const metaFilePath = getMetaFile(dir, { throwOnError: false });
+
+  const defaultName = path.basename(dir);
+
+  // Do nothing if meta file found
+  if (metaFilePath) {
+    const metaData = readMetaFile(metaFilePath);
+    if (isValid(metaData.did)) {
+      printInfo(`Blocklet meta file found at: ${chalk.cyan(metaFilePath)}, skipping`);
+      process.exit(0);
+    } else {
+      printWarning('Blocklet did is invalid, generate a new blocklet did');
+      const [blockletDid] = await generateDidFromWallet(connectUrl, { monikers: defaultName });
+      updateMetaFile(metaFilePath, {
+        ...metaData,
+        did: blockletDid,
+      });
+      process.exit(0);
+    }
+  }
+
+  let packageJSON = {};
+  const packageJSONPath = path.join(dir, 'package.json');
+  if (fs.existsSync(packageJSONPath)) {
+    try {
+      packageJSON = JSON.parse(fs.readFileSync(packageJSONPath));
+    } catch (error) {
+      printError('Read package.json file failed.');
+      printInfo('Please check if package.json is a valid json file.');
+      process.exit(1);
+    }
+  }
+
+  const defaultMeta = Object.assign(
+    {
+      name: defaultName,
+      description: 'Blocklet Project',
+      group: BLOCKLET_GROUPS[0],
+      publicUrl: '/',
+      main: '.',
+      author: getNpmAuthor(),
+      specVersion: BLOCKLET_LATEST_SPEC_VERSION,
+    },
+    pickCommonFieldsInBlockletAndPackage(packageJSON)
+  );
+
+  let answers = {};
+  const questions = getPromptQuestions(defaultMeta);
+  if (yes || force) {
+    answers = questions.reduce((acc, item) => {
+      if (item.default) {
+        acc[item.name] = item.default;
+      }
+
+      return acc;
+    }, {});
+  } else {
+    print('This utility will walk you through create such files and folders(if not exists):');
+    print(`- ${BLOCKLET_META_FILE}`);
+    print('- blocklet.md');
+    print('- screenshots/');
+    print('\nIt only covers common items, if you want to check all items, please visit:');
+    print('https://github.com/ArcBlock/blocklets#keyinfo-blockletjson\n');
+    print('Press ^C to quit.');
+    answers = await inquirer.prompt(questions);
+  }
+
+  ensureMainDirPathWhenStatic(answers);
+  const meta = Object.assign(defaultMeta, answers);
+
+  fixFiles(meta, dir);
+  fixInterfaces(meta);
+  fixRepository(meta);
+
+  const author = getUserName(meta.author);
+  meta.author = parsePerson(author);
+  let blockletDid = did;
+  if (!blockletDid) {
+    [blockletDid] = await generateDidFromWallet(connectUrl, { monikers: meta.name });
+  }
+  meta.did = blockletDid;
+  meta.name = meta.did;
+  meta.version = BLOCKLET_DEFAULT_VERSION;
+
+  if (meta.group === BlockletGroup.gateway) {
+    delete meta.main;
+  } else if (meta.group === BlockletGroup.dapp) {
+    meta.scripts = {
+      dev: 'node index.js',
+    };
+  }
+
+  if (yes === false && force === false) {
+    const { isOK } = await inquirer.prompt([
+      {
+        type: 'confirm',
+        name: 'isOK',
+        message: 'Is this OK:',
+        default: true,
+      },
+    ]);
+
+    if (!isOK) {
+      print('User aborted!');
+      process.exit(0);
+    }
+  }
+
+  meta.logo = 'logo.png';
+
+  const blockletMeta = validateMeta(meta);
+
+  doInit({ metaFilePath: path.join(dir, BLOCKLET_META_FILE), blockletMeta });
+  process.exit(0);
+}
+
+exports.run = async (...args) => {
+  try {
+    await run(...args);
+  } catch (err) {
+    printError(`Failed to init blocklet: ${err.message}`);
+    process.exit(1);
+  }
+};

package/lib/commands/blocklet/meta.js

@@ -0,0 +1,22 @@
+const getBlockletMeta = require('@blocklet/meta/lib/parse');
+
+const { printError, printInfo } = require('../../util');
+const { pretty } = require('../../ui');
+const debug = require('../../debug')('blocklet:meta');
+
+exports.run = () => {
+  try {
+    const dir = process.cwd();
+
+    printInfo('Reading blocklet meta from', dir);
+
+    const meta = getBlockletMeta(dir, { ensureComponentStore: false });
+    printInfo('Blocklet meta', pretty(meta));
+
+    process.exit(0);
+  } catch (error) {
+    debug('read blocklet meta failed', error);
+    printError('Read blocklet meta failed:', error.message);
+    process.exit(1);
+  }
+};

package/lib/commands/blocklet/remove.js

@@ -0,0 +1,35 @@
+const chalk = require('chalk');
+const getBlockletMeta = require('@blocklet/meta/lib/parse');
+const { select: getMetaFile, update: updateMetaFile } = require('@blocklet/meta/lib/file');
+
+const { printSuccess, printError } = require('../../util');
+const { fixComponents } = require('../../util/blocklet/meta');
+const debug = require('../../debug')('blocklet:version');
+
+exports.run = (component) => {
+  try {
+    const dir = process.cwd();
+    const file = getMetaFile(dir);
+    const meta = getBlockletMeta(dir, { fix: false });
+
+    fixComponents(meta);
+
+    meta.components = meta.components || [];
+
+    if (!meta.components.find((x) => x.name === component)) {
+      printError(`Cannot find component with name ${chalk.cyan(component)}`);
+      process.exit(1);
+    }
+
+    meta.components = meta.components.filter((x) => x.name !== component);
+
+    updateMetaFile(file, meta, { fix: false });
+    printSuccess(`Component ${chalk.cyan(component)} was successfully removed`);
+
+    process.exit(0);
+  } catch (error) {
+    debug('Failed remove component', error);
+    printError('Failed remove component: ', error.message);
+    process.exit(1);
+  }
+};

package/lib/commands/blocklet/test.js

@@ -0,0 +1,201 @@
+require('dotenv-flow').config({ silent: true, node_env: 'test' });
+
+const chalk = require('chalk');
+const { fromSecretKey } = require('@ocap/wallet');
+const { types } = require('@ocap/mcrypto');
+const { replaceSlotToIp } = require('@blocklet/meta/lib/util');
+const { BlockletStatus, BlockletEvents } = require('@blocklet/constant');
+const getIP = require('@abtnode/util/lib/get-ip');
+const sleep = require('@abtnode/util/lib/sleep');
+
+const { print, printError, printInfo, printSuccess, getDevUrl, printWarning } = require('../../util');
+const { getNode } = require('../../node');
+const { getOption, waitForAnyEvents, checkNodeRunning, getAccessibleUrl } = require('./dev');
+
+const ACTIONS = {
+  INIT: 'init',
+  START: 'start',
+  REMOVE: 'remove',
+  RESET: 'reset',
+};
+
+const getUtil = ({ node, socket, publishEvent, appName, appSk, ownerSk }) => {
+  const app = fromSecretKey(appSk, { role: types.RoleType.ROLE_APPLICATION });
+
+  printInfo(`Test blocklet did: ${chalk.cyan(app.address)}`);
+
+  // init app container
+  const initApp = async () => {
+    const owner = fromSecretKey(ownerSk, { role: types.RoleType.ROLE_ACCOUNT });
+    printInfo(`Test owner did: ${chalk.cyan(owner.address)}`);
+
+    const exist = await node.getBlocklet({ did: app.address, attachConfig: false });
+    if (exist) {
+      printWarning(`Test blocklet already exist: ${chalk.cyan(app.address)}`);
+      return;
+    }
+
+    try {
+      const blocklet = await node.installBlocklet({
+        appSk,
+        title: appName,
+        description: `Test blocklet ${appName}`,
+        skSource: 'blocklet:cli:test:init',
+      });
+      await publishEvent(BlockletEvents.installed, { blocklet });
+      await waitForAnyEvents({ blocklet, socket, events: [BlockletEvents.installed] }); // wait for db updating
+      printInfo(`Test blocklet created: ${app.address}`);
+
+      await node.setBlockletInitialized({ did: app.address, owner: { did: owner.address, pk: owner.publicKey } });
+      await node.addUser({
+        teamDid: app.address,
+        force: true,
+        user: {
+          did: owner.address,
+          pk: owner.publicKey,
+          role: 'owner',
+          fullName: 'TestOwner',
+          email: 'blocklet@arcblock.io',
+          approved: true,
+        },
+      });
+      await node.issuePassportToUser({ teamDid: app.address, userDid: owner.address, role: 'owner', notify: false });
+      await node.issuePassportToUser({ teamDid: app.address, userDid: owner.address, role: 'admin', notify: false });
+      await node.issuePassportToUser({ teamDid: app.address, userDid: owner.address, role: 'member', notify: false });
+      printInfo(`Test blocklet initialized: ${app.address}`);
+    } catch (err) {
+      printError(`Test blocklet init failed: ${err.message}`);
+      console.error(err);
+      // eslint-disable-next-line no-use-before-define
+      await removeApp();
+      process.exit(1);
+    }
+  };
+
+  const removeApp = async () => {
+    try {
+      const deleted = await node.deleteBlocklet({
+        did: app.address,
+        keepData: false,
+        keepLogsDir: false,
+        keepConfigs: false,
+      });
+      await publishEvent(BlockletEvents.removed, { blocklet: deleted, context: { keepRouting: false } });
+      print(`Test blocklet was removed: ${app.address}`);
+    } catch (err) {
+      console.error(err);
+    }
+    await sleep(200);
+  };
+
+  const startApp = async () => {
+    try {
+      const blocklet = await node.ensureBlockletIntegrity(app.address);
+
+      await node.startBlocklet({
+        did: app.address,
+        throwOnError: true,
+        checkHealthImmediately: true,
+        atomic: true,
+        componentDids: null,
+      });
+
+      blocklet.status = BlockletStatus.running;
+      await publishEvent(BlockletEvents.statusChange, blocklet);
+
+      await sleep(1000);
+      printSuccess(`Test blocklet successfully started: ${app.address}`);
+
+      // print info
+      const info = await node.getNodeInfo();
+      const port = Number(info.routing.httpsPort) !== 443 ? `:${info.routing.httpsPort}` : '';
+      const url = await getDevUrl({
+        getUrl: async () => {
+          const ips = await getIP();
+
+          const urls = blocklet.site.domainAliases.map(
+            (x) => `https://${replaceSlotToIp(x.value, ips.internal)}${port}`
+          );
+
+          return getAccessibleUrl(urls);
+        },
+      });
+
+      if (url) {
+        print('');
+        printInfo('You can access with the following URL\n');
+        print(`- ${chalk.cyan(url)}`);
+      }
+    } catch (err) {
+      console.error(err);
+      printError(err.message);
+    }
+  };
+
+  const resetApp = async () => {
+    try {
+      await node.getBlocklet({ did: app.address });
+      await node.resetBlocklet({ did: app.address });
+      print(`\nTest blocklet has been reset: ${app.address}\n`);
+    } catch (err) {
+      console.error(err);
+      printError(err.message);
+    }
+  };
+
+  return {
+    initApp,
+    startApp,
+    resetApp,
+    removeApp,
+  };
+};
+
+const run = async (action, { appName, appSk, ownerSk }) => {
+  try {
+    await checkNodeRunning();
+
+    const { node, publishEvent, getWsClient } = await getNode({ dir: process.cwd() });
+    const socket = await getWsClient();
+    const util = getUtil({ node, publishEvent, socket, appName, appSk, ownerSk });
+
+    node.onReady(async () => {
+      if (action === ACTIONS.INIT) {
+        await util.initApp();
+        process.exit(0);
+      }
+
+      if (action === ACTIONS.REMOVE) {
+        await util.removeApp();
+        process.exit(0);
+      }
+
+      if (action === ACTIONS.START) {
+        await util.startApp();
+        process.exit(0);
+      }
+
+      if (action === ACTIONS.RESET) {
+        await util.resetApp();
+        process.exit(0);
+      }
+    });
+  } catch (err) {
+    printError(err.message);
+    process.exit(1);
+  }
+};
+
+const getOptions = (command) => ({
+  appSk: getOption(command, 'appSk'),
+  appName: getOption(command, 'appName'),
+  ownerSk: getOption(command, 'ownerSk'),
+});
+
+module.exports = {
+  run: (command) => run(null, getOptions(command)),
+  init: (command) => run('init', getOptions(command)),
+  start: (command) => run('start', getOptions(command)),
+  remove: (command) => run('remove', getOptions(command)),
+  reset: (command) => run('reset', getOptions(command)),
+};