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

package/lib/commands/blocklet/deploy.js

@@ -0,0 +1,435 @@
+/* eslint-disable indent */
+require('dotenv-flow').config({ silent: true, node_env: 'development' });
+
+const fs = require('fs');
+const path = require('path');
+const expandTilde = require('expand-tilde');
+const tar = require('tar');
+const FormData = require('form-data');
+const chalk = require('chalk');
+const slugify = require('slugify');
+const { joinURL } = require('ufo');
+
+const { isValid: isValidDid, toAddress } = require('@arcblock/did');
+const Client = require('@abtnode/client');
+const hashFiles = require('@abtnode/util/lib/hash-files');
+const { default: axios } = require('axios');
+const isPathPrefixEqual = require('@abtnode/util/lib/is-path-prefix-equal');
+const getBlockletMeta = require('@blocklet/meta/lib/parse');
+const validateBlockletEntry = require('@blocklet/meta/lib/entry');
+const { hasMountPoint } = require('@blocklet/meta/lib/engine');
+const { BLOCKLET_BUNDLE_FOLDER } = require('@blocklet/constant');
+const hasReservedKey = require('@blocklet/meta/lib/has-reserved-key');
+const urlPathFriendly = require('@blocklet/meta/lib/url-path-friendly').default;
+const { ROLES } = require('@abtnode/constant');
+
+const {
+  print,
+  printError,
+  printInfo,
+  printSuccess,
+  printWarning,
+  formatGQLError,
+  getCLIBinaryName,
+} = require('../../util');
+const { wrapSpinner } = require('../../ui');
+const { getNode } = require('../../node');
+const { checkRunning, deployManager } = require('../../manager');
+const { version } = require('../../../package.json');
+const debug = require('../../debug')('blocklet:deploy');
+
+const { signWithAccessKey, validateAccessKey } = Client;
+const { fileFilter, printDeployFileInfo } = deployManager;
+
+const makeFormData = ({ tarFile: file, hasDiff, did, serverVersion, deleteSet, rootDid, mountPoint }) => {
+  let varFields = hasDiff
+    ? '$file: Upload!, $did: String, $diffVersion: String, $deleteSet: [String!]'
+    : '$file: Upload!';
+  let inputFields = hasDiff
+    ? 'file: $file, did: $did, diffVersion: $diffVersion, deleteSet: $deleteSet'
+    : 'file: $file';
+
+  varFields = `${varFields}, $rootDid: String, $mountPoint: String`;
+  inputFields = `${inputFields}, rootDid: $rootDid, mountPoint: $mountPoint`;
+
+  const variables = hasDiff
+    ? {
+        file: null,
+        did,
+        diffVersion: serverVersion,
+        deleteSet,
+      }
+    : {
+        file: null,
+      };
+
+  variables.rootDid = rootDid;
+  variables.mountPoint = mountPoint;
+
+  const apiName = 'installComponent';
+  const query = `
+    mutation (${varFields}) {
+      ${apiName}(input: { ${inputFields} } ) {
+        code
+        blocklet {
+          meta {
+            did
+            name
+            title
+            version
+            description
+          }
+          status
+          source
+        }
+      }
+    }
+  `;
+  const gql = {
+    query,
+    variables,
+  };
+  const map = {
+    file0: ['variables.file'],
+  };
+  const form = new FormData();
+  form.append('operations', JSON.stringify(gql));
+  form.append('map', JSON.stringify(map));
+  form.append('file0', fs.createReadStream(file));
+  return { form, apiName };
+};
+
+const deploy = async (dir, { endpoint, accessKey, accessSecret, appDid, appId, mountPoint: inputMountPoint }) => {
+  let bundleDir = dir;
+  if (fs.existsSync(path.join(dir, BLOCKLET_BUNDLE_FOLDER))) {
+    bundleDir = path.join(dir, BLOCKLET_BUNDLE_FOLDER);
+  }
+
+  const rootDid = appDid || appId;
+
+  const fullEndpoint = joinURL(endpoint, '/api/gql');
+  const client = new Client(fullEndpoint, `BlockletCLI/${version}`);
+  client.setAuthAccessKey({
+    accessKeyId: accessKey,
+    accessKeySecret: accessSecret,
+  });
+
+  // check mountPoint when deploy a component
+  const { blocklet: app } = await client.getBlocklet({
+    input: {
+      did: rootDid,
+      attachRuntimeInfo: false,
+    },
+  });
+
+  if (!app) {
+    printError(`App ${chalk.cyan(rootDid)} not found`);
+    process.exit(1);
+  }
+
+  if (new URL(endpoint).protocol === 'http:' && new URL(endpoint).hostname !== '127.0.0.1') {
+    printWarning(
+      `You are deploying to an insecure endpoint of ${chalk.cyan('http')} protocol, you should use ${chalk.cyan(
+        'https'
+      )} to achieve better security.`
+    );
+  }
+
+  // get local blocklet meta
+  let localMeta;
+  try {
+    localMeta = getBlockletMeta(bundleDir);
+  } catch (error) {
+    debug('get blocklet error', error);
+    throw new Error(`Get blocklet meta failed: ${error.message}`);
+  }
+
+  printInfo(
+    `Try to deploy ${chalk.cyan(`${localMeta.title}@${localMeta.version}`)} from`,
+    `${chalk.cyan(bundleDir)} to ${chalk.cyan(app.meta.title)} in server ${chalk.cyan(endpoint)}.`
+  );
+
+  if (hasReservedKey(localMeta.environments)) {
+    throw new Error('Blocklet key of environments can not start with `ABT_NODE_` or `BLOCKLET_`');
+  }
+
+  // mountPoint
+  let mountPoint;
+  if (hasMountPoint(localMeta)) {
+    if (inputMountPoint) {
+      mountPoint = inputMountPoint;
+      printInfo(`Use mountPoint from input: ${chalk.cyan(inputMountPoint)}`);
+    } else if (process.env.BLOCKLET_DEPLOY_MOUNT_POINT) {
+      printInfo(`Use mountPoint from env: ${chalk.cyan(process.env.BLOCKLET_DEPLOY_MOUNT_POINT)}`);
+      mountPoint = process.env.BLOCKLET_DEPLOY_MOUNT_POINT;
+    } else {
+      const { name, title } = localMeta;
+      mountPoint = `/${urlPathFriendly(title) || urlPathFriendly(name)}`.toLowerCase();
+      printInfo(`Use default mountPoint: ${chalk.cyan(mountPoint)}`);
+    }
+  } else {
+    mountPoint = `/${localMeta.did}`;
+    printInfo(`Use fake mountPoint: ${chalk.cyan(mountPoint)}`);
+  }
+
+  // ensure entry file/folder exist
+  try {
+    await validateBlockletEntry(bundleDir, localMeta);
+  } catch (err) {
+    throw new Error(err.message);
+  }
+
+  // get hashFiles
+  const { files } = await hashFiles(bundleDir);
+
+  // check node_modules
+  const fileNames = Object.keys(files);
+  for (let i = 0; i < fileNames.length; i++) {
+    if (fileNames[i].includes('node_modules')) {
+      printError(`${chalk.bold('node_modules')} cannot be in the list of uploaded files`);
+      process.exit();
+    }
+  }
+
+  let blockletDiff;
+  try {
+    blockletDiff = await client.getBlockletDiff({
+      input: {
+        did: localMeta.did,
+        hashFiles: Object.entries(files).map(([file, hash]) => ({ file, hash })),
+        rootDid: rootDid || '',
+      },
+    });
+  } catch (error) {
+    throw new Error(`Blocklet deploy failed when fetching diff: ${formatGQLError(error)}`);
+  }
+
+  const {
+    addSet = [],
+    changeSet = [],
+    deleteSet = [],
+    hasBlocklet: hasDiff,
+    version: serverVersion,
+  } = blockletDiff.blockletDiff || {};
+  const diffList = hasDiff ? [...addSet, ...changeSet] : null;
+
+  // if no diff and mountPoint not changed, stop deploy
+  if (hasDiff && localMeta.version === serverVersion && !addSet.length && !changeSet.length && !deleteSet.length) {
+    let needNotDeploy = true;
+    const child = app.children.find((x) => x.meta.did === localMeta.did);
+    needNotDeploy = isPathPrefixEqual(mountPoint, child.mountPoint);
+
+    if (needNotDeploy) {
+      print(`${localMeta.title}@${localMeta.version} already exists in ${app.meta.title}`);
+      return;
+    }
+  }
+  printInfo(`Name: ${chalk.cyan(localMeta.name)}`);
+  printInfo(`DID: ${chalk.cyan(localMeta.did)}`);
+  printInfo(`Version: ${chalk.cyan(localMeta.version)}`);
+
+  if (hasDiff) {
+    printDeployFileInfo(addSet, changeSet, deleteSet);
+  } else {
+    printDeployFileInfo(Object.keys(files));
+  }
+
+  // build tarFile
+  const tarFile = path.join(process.cwd(), `${slugify(localMeta.name)}-${localMeta.version}.tgz`);
+
+  await tar.c(
+    {
+      file: tarFile,
+      cwd: bundleDir,
+      filter: (f) =>
+        !diffList ||
+        fileFilter(f.replace(/^\.\//, ''), {
+          diffList,
+        }),
+    },
+    ['.']
+  );
+
+  // do upload
+  const { form } = makeFormData({
+    tarFile,
+    hasDiff,
+    did: localMeta.did,
+    serverVersion,
+    deleteSet,
+    mountPoint,
+    rootDid,
+  });
+  try {
+    const timestamp = Date.now();
+    const timer = setInterval(() => {
+      // travis will close task if no output has been received in the last 10m0s
+      if (process.env.CI && process.env.TRAVIS) {
+        print('Uploading...');
+      }
+    }, 1000 * 500);
+    const res = await wrapSpinner(`Uploading ${localMeta.name}...`, () =>
+      axios({
+        url: fullEndpoint,
+        method: 'POST',
+        data: form,
+        headers: {
+          ...form.getHeaders(),
+          'user-agent': `BlockletCLI/${version}`,
+          'x-access-key-id': accessKey,
+          'x-access-stamp': timestamp,
+          'x-access-signature': signWithAccessKey({
+            accessKeyId: accessKey,
+            accessKeySecret: accessSecret,
+            message: `${timestamp}-${accessKey}`,
+          }),
+        },
+        timeout: 1000 * 60 * 30, // 30min
+        // max file size is limited by server, so here is infinity
+        maxContentLength: Number.POSITIVE_INFINITY,
+        maxBodyLength: Number.POSITIVE_INFINITY,
+      })); // prettier-ignore
+    clearInterval(timer);
+    if (Array.isArray(res.data.errors) && res.data.errors.length) {
+      const error = new Error('GraphQL Response Error');
+      error.errors = res.data.errors;
+      throw error;
+    }
+    if (fs.existsSync(tarFile)) {
+      fs.unlinkSync(tarFile);
+    }
+    printSuccess(
+      `${chalk.cyan(localMeta.title)}@${chalk.cyan(localMeta.version)} was successfully deployed to ${chalk.cyan(
+        app.meta.title
+      )} in server ${chalk.cyan(endpoint)}.`
+    );
+  } catch (error) {
+    if (fs.existsSync(tarFile)) {
+      fs.unlinkSync(tarFile);
+    }
+    throw new Error(`Blocklet deploy failed when uploading: ${formatGQLError(error)}`);
+  }
+};
+
+const getNodeAsync = async ({ dir }) => {
+  const { node } = await getNode({ dir });
+  return new Promise((resolve) => {
+    node.onReady(() => resolve({ node }));
+  });
+};
+
+const deployToLocal = async (dir, opts) => {
+  const isRunning = await checkRunning();
+  if (!isRunning) {
+    const startCommand = chalk.cyan(`${getCLIBinaryName()} start`);
+    printError('Blocklet Server is not running, can not deploy anything!');
+    printInfo(`To start Blocklet Server, use ${startCommand}`);
+    process.exit(1);
+  }
+
+  const { node } = await getNodeAsync({ dir: process.cwd() });
+
+  const nodeInfo = await node.getNodeInfo();
+  const endpoint = `http://127.0.0.1:${nodeInfo.port}`;
+  const { accessKeyId, accessKeySecret } = await node.createAccessKey({
+    remark: 'Local CLI',
+    passport: ROLES.ADMIN,
+  });
+  try {
+    await deploy(dir, {
+      endpoint,
+      accessKey: accessKeyId,
+      accessSecret: accessKeySecret,
+      ...opts,
+    });
+    await node.deleteAccessKey({ accessKeyId });
+    process.exit(0);
+  } catch (err) {
+    printError(err.message);
+    await node.deleteAccessKey({ accessKeyId });
+    process.exit(1);
+  }
+};
+
+const deployToRemote = async (dir, opts) => {
+  try {
+    await deploy(dir, opts);
+    process.exit(0);
+  } catch (err) {
+    printError(err.message);
+    process.exit(1);
+  }
+};
+
+const checkAppID = (opts) => {
+  if (!opts.appDid && !opts.appId) {
+    printError('appId must exist. Please use --app-id to specify appId');
+    printInfo('If you want to deploy this blocklet as an application, please install from your Blocklet Server');
+    printInfo(`See ${chalk.cyan('https://developer.blocklet.io/docs/d6e08589-278a-448a-92e1-1e5f8bd4cc70')}`);
+    process.exit(1);
+  }
+
+  if (opts.appId) {
+    if (!isValidDid(opts.appId)) {
+      printError('Invalid appId');
+      process.exit(1);
+    } else {
+      opts.appId = toAddress(opts.appId);
+    }
+  }
+
+  if (opts.appDid) {
+    if (!isValidDid(opts.appDid)) {
+      printError('Invalid appDid');
+      process.exit(1);
+    } else {
+      opts.appDid = toAddress(opts.appDid);
+    }
+  }
+};
+
+exports.run = (dirRaw, { endpoint, accessKey, accessSecret, ...opts }) => {
+  const dirExpanded = expandTilde(dirRaw);
+  const dir = [dirExpanded, path.join(process.cwd(), dirExpanded)].filter((x) => fs.existsSync(x)).pop();
+
+  if (!dir) {
+    printError(`Can not deploy blocklet from a non-existent directory ${chalk.red(dirRaw)}`);
+    process.exit(1);
+  }
+
+  if (!opts.appDid && !opts.appId) {
+    opts.appDid = process.env.BLOCKLET_DEPLOY_APP_DID || process.env.BLOCKLET_DEPLOY_APP_ID;
+  }
+
+  if (endpoint || accessKey || accessSecret) {
+    if (!endpoint) {
+      printError('Can not deploy to remote Blocklet Server with empty endpoint!');
+      process.exit(1);
+    }
+    try {
+      const { protocol } = new URL(endpoint);
+      if (!/https?/.test(protocol)) {
+        printError('Invalid endpoint protocol:', protocol.replace(':', ''));
+        process.exit(1);
+      }
+    } catch (error) {
+      printError('Invalid endpoint:', endpoint);
+      process.exit(1);
+    }
+    if (!accessKey) {
+      printError('Can not deploy to remote Blocklet Server with empty access-key!');
+      process.exit(1);
+    }
+    if (!accessSecret) {
+      printError('Can not deploy to remote Blocklet Server with empty access-secret!');
+      process.exit(1);
+    }
+    validateAccessKey({ accessKeyId: accessKey, accessKeySecret: accessSecret });
+
+    checkAppID(opts);
+    deployToRemote(dir, { endpoint, accessKey, accessSecret, ...opts });
+  } else {
+    checkAppID(opts);
+    deployToLocal(dir, opts);
+  }
+};