@sentry/cli 1.77.1 → 1.77.2

package/js/releases/options/uploadSourcemaps.js

@@ -11,6 +11,10 @@ module.exports = {
     param: '--dist',
     type: 'string',
   },
+  decompress: {
+    param: '--decompress',
+    type: 'boolean',
+  },
   rewrite: {
     param: '--rewrite',
     invertedParam: '--no-rewrite',
@@ -20,6 +24,10 @@ module.exports = {
     invertedParam: '--no-sourcemap-reference',
     type: 'boolean',
   },
+  dedupe: {
+    invertedParam: '--no-dedupe',
+    type: 'boolean',
+  },
   stripPrefix: {
     param: '--strip-prefix',
     type: 'array',
@@ -44,4 +52,8 @@ module.exports = {
     param: '--ext',
     type: 'array',
   },
+  useArtifactBundle: {
+    param: '--use-artifact-bundle',
+    type: 'boolean',
+  },
 };

package/package.json

@@ -1,43 +1,21 @@
 {
   "name": "@sentry/cli",
-  "version": "1.77.1",
+  "version": "1.77.2",
   "description": "A command line utility to work with Sentry. https://docs.sentry.io/hosted/learn/cli/",
+  "repository": "git://github.com/getsentry/sentry-cli.git",
   "homepage": "https://docs.sentry.io/hosted/learn/cli/",
+  "author": "Sentry",
   "license": "BSD-3-Clause",
-  "keywords": [
-    "sentry",
-    "sentry-cli",
-    "cli"
-  ],
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/getsentry/sentry-cli"
-  },
-  "bugs": {
-    "url": "https://github.com/getsentry/sentry-cli/issues"
-  },
   "engines": {
-    "node": ">= 8"
+    "node": ">= 10"
   },
   "main": "js/index.js",
+  "types": "js/index.d.ts",
   "bin": {
     "sentry-cli": "bin/sentry-cli"
   },
-  "scripts": {
-    "install": "node ./scripts/install.js",
-    "fix": "npm-run-all fix:eslint fix:prettier",
-    "fix:eslint": "eslint --fix bin/* scripts/**/*.js js/**/*.js",
-    "fix:prettier": "prettier --write bin/* scripts/**/*.js js/**/*.js",
-    "test": "npm-run-all test:jest test:eslint test:prettier test:vercel-nft",
-    "test:jest": "jest",
-    "test:watch": "jest --watch --notify",
-    "test:eslint": "eslint bin/* scripts/**/*.js js/**/*.js",
-    "test:prettier": "prettier --check  bin/* scripts/**/*.js js/**/*.js",
-    "test:vercel-nft": "node scripts/test-vercel-nft.js"
-  },
   "dependencies": {
     "https-proxy-agent": "^5.0.0",
-    "mkdirp": "^0.5.5",
     "node-fetch": "^2.6.7",
     "progress": "^2.0.3",
     "proxy-from-env": "^1.1.0",
@@ -45,26 +23,42 @@
   },
   "devDependencies": {
     "@vercel/nft": "^0.22.1",
-    "eslint": "^6.8.0",
-    "eslint-config-airbnb-base": "^14.1.0",
-    "eslint-config-prettier": "^6.10.1",
-    "eslint-plugin-import": "^2.20.2",
-    "jest": "^25.3.0",
+    "eslint": "^7.32.0",
+    "eslint-config-prettier": "^8.5.0",
+    "jest": "^27.5.1",
     "npm-run-all": "^4.1.5",
-    "prettier": "^1.19.1"
+    "prettier": "2.8.8"
+  },
+  "optionalDependencies": {
+    "@sentry/cli-darwin": "1.77.2",
+    "@sentry/cli-linux-arm": "1.77.2",
+    "@sentry/cli-linux-arm64": "1.77.2",
+    "@sentry/cli-linux-i686": "1.77.2",
+    "@sentry/cli-linux-x64": "1.77.2",
+    "@sentry/cli-win32-i686": "1.77.2",
+    "@sentry/cli-win32-x64": "1.77.2"
+  },
+  "scripts": {
+    "postinstall": "node ./scripts/install.js",
+    "fix": "npm-run-all fix:eslint fix:prettier",
+    "fix:eslint": "eslint --fix bin/* scripts/**/*.js js/**/*.js",
+    "fix:prettier": "prettier --write bin/* scripts/**/*.js js/**/*.js",
+    "test": "npm-run-all test:jest test:eslint test:prettier test:vercel-nft",
+    "test:jest": "jest",
+    "test:watch": "jest --watch --notify",
+    "test:eslint": "eslint bin/* scripts/**/*.js js/**/*.js",
+    "test:prettier": "prettier --check  bin/* scripts/**/*.js js/**/*.js",
+    "test:vercel-nft": "node scripts/test-vercel-nft.js"
   },
   "jest": {
-    "collectCoverage": false,
+    "collectCoverage": true,
     "testEnvironment": "node",
     "testPathIgnorePatterns": [
-      "src/utils"
+      "<rootDir>/src"
     ]
   },
   "volta": {
-    "node": "10.24.1",
+    "node": "20.10.0",
     "yarn": "1.22.19"
-  },
-  "publishConfig": {
-    "tag": "v1"
   }
 }

package/scripts/build-in-docker.sh

@@ -1,7 +1,7 @@
 #!/bin/bash
 set -eux
 
-DOCKER_IMAGE="getsentry/rust-musl-cross:${DOCKER_TAG}"
+DOCKER_IMAGE="messense/rust-musl-cross:${DOCKER_TAG}"
 BUILD_DIR="/work"
 
 DOCKER_RUN_OPTS="
@@ -9,7 +9,6 @@ DOCKER_RUN_OPTS="
   -v $(pwd):${BUILD_DIR}:ro
   -v $(pwd)/target:${BUILD_DIR}/target
   -v $HOME/.cargo/registry:/root/.cargo/registry
-  -e ARMV7_UNKNOWN_LINUX_MUSLEABI_OPENSSL_NO_VENDOR=1
   ${DOCKER_IMAGE}
 "
 

package/scripts/bump-version.sh

@@ -21,4 +21,17 @@ cargo update -p sentry-cli
 
 # Do not tag and commit changes made by "npm version"
 export npm_config_git_tag_version=false
+
+# Bump main sentry cli npm package
 npm version "${TARGET}"
+
+# Bump the binary npm distributions
+for dir in $SCRIPT_DIR/../npm-binary-distributions/*; do
+    cd $dir
+    npm version "${TARGET}"
+    cd -
+done
+
+# Update the optional deps in the main cli npm package
+# Requires jq to be installed - should be installed ootb on github runners
+jq '.optionalDependencies |= map_values("'"${TARGET}"'")' $SCRIPT_DIR/../package.json > package.json.tmp && mv package.json.tmp $SCRIPT_DIR/../package.json

package/scripts/install.js

@@ -2,30 +2,348 @@
 
 'use strict';
 
-const http = require('http');
 const fs = require('fs');
+const os = require('os');
 const path = require('path');
-const { downloadBinary } = require('../js/install');
-
-if (process.env.SENTRYCLI_LOCAL_CDNURL) {
-  // For testing, mock the CDN by spawning a local server
-  const server = http.createServer((request, response) => {
-    const contents = fs.readFileSync(path.join(__dirname, '../js/__mocks__/sentry-cli'));
-    response.writeHead(200, {
-      'Content-Type': 'application/octet-stream',
-      'Content-Length': String(contents.byteLength),
+const crypto = require('crypto');
+const zlib = require('zlib');
+const stream = require('stream');
+const process = require('process');
+
+const fetch = require('node-fetch');
+const HttpsProxyAgent = require('https-proxy-agent');
+const ProgressBar = require('progress');
+const Proxy = require('proxy-from-env');
+const which = require('which');
+
+const helper = require('../js/helper');
+const pkgInfo = require('../package.json');
+const Logger = require('../js/logger');
+
+const logger = new Logger(getLogStream('stderr'));
+
+const CDN_URL =
+  process.env.SENTRYCLI_LOCAL_CDNURL ||
+  process.env.npm_config_sentrycli_cdnurl ||
+  process.env.SENTRYCLI_CDNURL ||
+  'https://downloads.sentry-cdn.com/sentry-cli';
+
+function getLogStream(defaultStream) {
+  const logStream = process.env.SENTRYCLI_LOG_STREAM || defaultStream;
+
+  if (logStream === 'stdout') {
+    return process.stdout;
+  }
+
+  if (logStream === 'stderr') {
+    return process.stderr;
+  }
+
+  throw new Error(
+    `Incorrect SENTRYCLI_LOG_STREAM env variable. Possible values: 'stdout' | 'stderr'`
+  );
+}
+
+function shouldRenderProgressBar() {
+  const silentFlag = process.argv.some((v) => v === '--silent');
+  const silentConfig = process.env.npm_config_loglevel === 'silent';
+  const silentEnv = process.env.SENTRYCLI_NO_PROGRESS_BAR;
+  const ciEnv = process.env.CI === 'true' || process.env.CI === '1';
+  const notTTY = !process.stdout.isTTY;
+  // If any of possible options is set, skip rendering of progress bar
+  return !(silentFlag || silentConfig || silentEnv || ciEnv || notTTY);
+}
+
+function getDownloadUrl(platform, arch) {
+  const releasesUrl = `${CDN_URL}/${pkgInfo.version}/sentry-cli`;
+  let archString = '';
+  switch (arch) {
+    case 'x64':
+      archString = 'x86_64';
+      break;
+    case 'x86':
+    case 'ia32':
+      archString = 'i686';
+      break;
+    case 'arm64':
+      archString = 'aarch64';
+      break;
+    case 'arm':
+      archString = 'armv7';
+      break;
+    default:
+      archString = arch;
+  }
+  switch (platform) {
+    case 'darwin':
+      return `${releasesUrl}-Darwin-universal`;
+    case 'win32':
+      // Windows arm machines can run x64 binaries
+      if (arch === 'arm64') {
+        archString = 'x86_64';
+      }
+      return `${releasesUrl}-Windows-${archString}.exe`;
+    case 'linux':
+    case 'freebsd':
+      return `${releasesUrl}-Linux-${archString}`;
+    default:
+      return null;
+  }
+}
+
+function createProgressBar(name, total) {
+  const incorrectTotal = typeof total !== 'number' || Number.isNaN(total);
+
+  if (incorrectTotal || !shouldRenderProgressBar()) {
+    return {
+      tick: () => {},
+    };
+  }
+
+  const logStream = getLogStream('stdout');
+
+  if (logStream.isTTY) {
+    return new ProgressBar(`fetching ${name} :bar :percent :etas`, {
+      complete: '█',
+      incomplete: '░',
+      width: 20,
+      total,
     });
-    response.end(contents);
-  });
+  }
+
+  let pct = null;
+  let current = 0;
+  return {
+    tick: (length) => {
+      current += length;
+      const next = Math.round((current / total) * 100);
+      if (next > pct) {
+        pct = next;
+        logStream.write(`fetching ${name} ${pct}%\n`);
+      }
+    },
+  };
+}
+
+function npmCache() {
+  const keys = ['npm_config_cache', 'npm_config_cache_folder', 'npm_config_yarn_offline_mirror'];
+
+  for (let key of [...keys, ...keys.map((k) => k.toUpperCase())]) {
+    if (process.env[key]) return process.env[key];
+  }
+
+  if (process.env.APPDATA) {
+    return path.join(process.env.APPDATA, 'npm-cache');
+  }
 
-  server.listen(8999);
-  process.on('exit', () => server.close());
+  return path.join(os.homedir(), '.npm');
 }
 
-downloadBinary()
-  .then(() => process.exit(0))
-  .catch(e => {
-    // eslint-disable-next-line no-console
-    console.error(e.toString());
-    process.exit(1);
+function getCachedPath(url) {
+  const digest = crypto.createHash('md5').update(url).digest('hex').slice(0, 6);
+
+  return path.join(
+    npmCache(),
+    'sentry-cli',
+    `${digest}-${path.basename(url).replace(/[^a-zA-Z0-9.]+/g, '-')}`
+  );
+}
+
+function getTempFile(cached) {
+  return `${cached}.${process.pid}-${Math.random().toString(16).slice(2)}.tmp`;
+}
+
+function validateChecksum(tempPath, name) {
+  let storedHash;
+  try {
+    const checksums = fs.readFileSync(path.join(__dirname, '../checksums.txt'), 'utf8');
+    const entries = checksums.split('\n');
+    for (let i = 0; i < entries.length; i++) {
+      const [key, value] = entries[i].split('=');
+      if (key === name) {
+        storedHash = value;
+        break;
+      }
+    }
+  } catch (e) {
+    logger.log(
+      'Checksums are generated when the package is published to npm. They are not available directly in the source repository. Skipping validation.'
+    );
+    return;
+  }
+
+  if (!storedHash) {
+    logger.log(`Checksum for ${name} not found, skipping validation.`);
+    return;
+  }
+
+  const currentHash = crypto.createHash('sha256').update(fs.readFileSync(tempPath)).digest('hex');
+
+  if (storedHash !== currentHash) {
+    fs.unlinkSync(tempPath);
+    throw new Error(
+      `Checksum validation for ${name} failed.\nExpected: ${storedHash}\nReceived: ${currentHash}`
+    );
+  } else {
+    logger.log('Checksum validation passed.');
+  }
+}
+
+async function downloadBinary() {
+  const arch = os.arch();
+  const platform = os.platform();
+  const outputPath = helper.getFallbackBinaryPath();
+
+  if (process.env.SENTRYCLI_USE_LOCAL === '1') {
+    try {
+      const binPaths = which.sync('sentry-cli', { all: true });
+      if (!binPaths.length) throw new Error('Binary not found');
+      const binPath = binPaths[binPaths.length - 1];
+      logger.log(`Using local binary: ${binPath}`);
+      fs.copyFileSync(binPath, outputPath);
+      return Promise.resolve();
+    } catch (e) {
+      throw new Error(
+        'Configured installation of local binary, but it was not found.' +
+          'Make sure that `sentry-cli` executable is available in your $PATH or disable SENTRYCLI_USE_LOCAL env variable.'
+      );
+    }
+  }
+
+  const downloadUrl = getDownloadUrl(platform, arch);
+  if (!downloadUrl) {
+    throw new Error(`Unsupported target ${platform}-${arch}`);
+  }
+
+  const cachedPath = getCachedPath(downloadUrl);
+  if (fs.existsSync(cachedPath)) {
+    logger.log(`Using cached binary: ${cachedPath}`);
+    fs.copyFileSync(cachedPath, outputPath);
+    return;
+  }
+
+  const proxyUrl = Proxy.getProxyForUrl(downloadUrl);
+  const agent = proxyUrl ? new HttpsProxyAgent(proxyUrl) : null;
+
+  logger.log(`Downloading from ${downloadUrl}`);
+
+  if (proxyUrl) {
+    logger.log(`Using proxy URL: ${proxyUrl}`);
+  }
+
+  let response;
+  try {
+    response = await fetch(downloadUrl, {
+      agent,
+      compress: false,
+      headers: {
+        'accept-encoding': 'gzip, deflate, br',
+      },
+      redirect: 'follow',
+    });
+  } catch (error) {
+    let errorMsg = `Unable to download sentry-cli binary from ${downloadUrl}.\nError message: ${error.message}`;
+    if (error.code) {
+      errorMsg += `\nError code: ${error.code}`;
+    }
+    throw new Error(errorMsg);
+  }
+
+  if (!response.ok) {
+    let errorMsg = `Unable to download sentry-cli binary from ${downloadUrl}.\nServer returned: ${response.status}`;
+    if (response.statusText) {
+      errorMsg += ` - ${response.statusText}`;
+    }
+    throw new Error(errorMsg);
+  }
+
+  const contentEncoding = response.headers.get('content-encoding');
+  let decompressor;
+  if (/\bgzip\b/.test(contentEncoding)) {
+    decompressor = zlib.createGunzip();
+  } else if (/\bdeflate\b/.test(contentEncoding)) {
+    decompressor = zlib.createInflate();
+  } else if (/\bbr\b/.test(contentEncoding)) {
+    decompressor = zlib.createBrotliDecompress();
+  } else {
+    decompressor = new stream.PassThrough();
+  }
+  const name = downloadUrl.match(/.*\/(.*?)$/)[1];
+  let downloadedBytes = 0;
+  const totalBytes = parseInt(response.headers.get('content-length'), 10);
+  const progressBar = createProgressBar(name, totalBytes);
+  const tempPath = getTempFile(cachedPath);
+  fs.mkdirSync(path.dirname(tempPath), { recursive: true });
+
+  await new Promise((resolve, reject) => {
+    response.body
+      .on('error', (e) => reject(e))
+      .on('data', (chunk) => {
+        downloadedBytes += chunk.length;
+        progressBar.tick(chunk.length);
+      })
+      .pipe(decompressor)
+      .pipe(fs.createWriteStream(tempPath, { mode: '0755' }))
+      .on('error', (e) => reject(e))
+      .on('close', () => {
+        if (downloadedBytes >= totalBytes) {
+          resolve();
+        } else {
+          reject(new Error('connection interrupted'));
+        }
+      });
   });
+
+  if (process.env.SENTRYCLI_SKIP_CHECKSUM_VALIDATION !== '1') {
+    validateChecksum(tempPath, name);
+  }
+
+  fs.copyFileSync(tempPath, cachedPath);
+  fs.copyFileSync(tempPath, outputPath);
+  fs.unlinkSync(tempPath);
+}
+
+async function checkVersion() {
+  const output = await helper.execute(['--version']);
+  const version = output.replace('sentry-cli ', '').trim();
+  const expected = pkgInfo.version;
+  if (version !== expected) {
+    throw new Error(`Unexpected sentry-cli version "${version}", expected "${expected}"`);
+  }
+}
+
+if (process.env.SENTRYCLI_SKIP_DOWNLOAD === '1') {
+  logger.log(`Skipping download because SENTRYCLI_SKIP_DOWNLOAD=1 detected.`);
+  process.exit(0);
+}
+
+const { packageName: distributionPackageName, subpath: distributionSubpath } =
+  helper.getDistributionForThisPlatform();
+
+if (distributionPackageName === undefined) {
+  helper.throwUnsupportedPlatformError();
+}
+
+try {
+  require.resolve(`${distributionPackageName}/${distributionSubpath}`);
+  // If the `resolve` call succeeds it means a binary was installed successfully via optional dependencies so we can skip the manual postinstall download.
+  process.exit(0);
+} catch (e) {
+  // Optional dependencies likely didn't get installed - proceed with fallback downloading manually
+  // Log message inspired by esbuild: https://github.com/evanw/esbuild/blob/914f6080c77cfe32a54888caa51ca6ea13873ce9/lib/npm/node-install.ts#L253
+  logger.log(
+    `Sentry CLI failed to locate the "${distributionPackageName}" package after installation!
+
+This can happen if you use an option to disable optional dependencies during installation, like "--no-optional", "--ignore-optional", or "--omit=optional". Sentry CLI uses the "optionalDependencies" package.json feature to install the correct binary for your platform and operating system. This post-install script will now try to work around this by manually downloading the Sentry CLI binary from the Sentry CDN. If this fails, you need to remove the "--no-optional", "--ignore-optional", and "--omit=optional" flags for Sentry CLI to work.`
+  );
+
+  downloadBinary()
+    .then(() => checkVersion())
+    .then(() => {
+      process.exit(0);
+    })
+    .catch((e) => {
+      console.error(e);
+      process.exit(1);
+    });
+}

package/scripts/test-vercel-nft.js

@@ -1,27 +1,16 @@
-const major = process.versions.node.split('.')[0];
-
-// @vercel/nft doe not support Node.js v8
-if (major < 10) {
-  process.exit(0);
-}
-
-// eslint-disable-next-line import/no-extraneous-dependencies
 const { nodeFileTrace } = require('@vercel/nft');
 
 const entryPoint = require.resolve('..');
 
 // Trace the module entrypoint
-nodeFileTrace([entryPoint]).then(result => {
-  // eslint-disable-next-line no-console
+nodeFileTrace([entryPoint]).then((result) => {
   console.log('@vercel/nft traced dependencies:', Array.from(result.fileList));
 
   // If either binary is picked up, fail the test
   if (result.fileList.has('sentry-cli') || result.fileList.has('sentry-cli.exe')) {
-    // eslint-disable-next-line no-console
     console.error('ERROR: The sentry-cli binary should not be found by @vercel/nft');
     process.exit(-1);
   } else {
-    // eslint-disable-next-line no-console
     console.log('The sentry-cli binary was not traced by @vercel/nft');
   }
 });