@sentry/cli 1.76.0 → 1.77.0

package/scripts/install.js

@@ -11,18 +11,24 @@ const zlib = require('zlib');
 const stream = require('stream');
 const process = require('process');
 
-const HttpsProxyAgent = require('https-proxy-agent');
 const fetch = require('node-fetch');
+const HttpsProxyAgent = require('https-proxy-agent');
 const ProgressBar = require('progress');
 const Proxy = require('proxy-from-env');
-// NOTE: Can be dropped in favor of `fs.mkdirSync(path, { recursive: true })` once we stop supporting Node 8.x
-const mkdirp = require('mkdirp');
 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;
 
@@ -39,22 +45,14 @@ function getLogStream(defaultStream) {
   );
 }
 
-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 shouldRenderProgressBar() {
-  const silentFlag = process.argv.some(v => v === '--silent');
+  const silentFlag = process.argv.some((v) => v === '--silent');
   const silentConfig = process.env.npm_config_loglevel === 'silent';
-  // Leave `SENTRY_NO_PROGRESS_BAR` for backwards compatibility
-  const silentEnv = process.env.SENTRYCLI_NO_PROGRESS_BAR || process.env.SENTRY_NO_PROGRESS_BAR;
-  const ciEnv = process.env.CI === 'true';
+  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);
+  return !(silentFlag || silentConfig || silentEnv || ciEnv || notTTY);
 }
 
 function getDownloadUrl(platform, arch) {
@@ -113,7 +111,7 @@ function createProgressBar(name, total) {
   let pct = null;
   let current = 0;
   return {
-    tick: length => {
+    tick: (length) => {
       current += length;
       const next = Math.round((current / total) * 100);
       if (next > pct) {
@@ -125,21 +123,21 @@ function createProgressBar(name, total) {
 }
 
 function npmCache() {
-  const env = process.env;
-  return (
-    env.npm_config_cache ||
-    env.npm_config_cache_folder ||
-    env.npm_config_yarn_offline_mirror ||
-    (env.APPDATA ? path.join(env.APPDATA, 'npm-cache') : path.join(os.homedir(), '.npm'))
-  );
+  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');
+  }
+
+  return path.join(os.homedir(), '.npm');
 }
 
 function getCachedPath(url) {
-  const digest = crypto
-    .createHash('md5')
-    .update(url)
-    .digest('hex')
-    .slice(0, 6);
+  const digest = crypto.createHash('md5').update(url).digest('hex').slice(0, 6);
 
   return path.join(
     npmCache(),
@@ -149,9 +147,7 @@ function getCachedPath(url) {
 }
 
 function getTempFile(cached) {
-  return `${cached}.${process.pid}-${Math.random()
-    .toString(16)
-    .slice(2)}.tmp`;
+  return `${cached}.${process.pid}-${Math.random().toString(16).slice(2)}.tmp`;
 }
 
 function validateChecksum(tempPath, name) {
@@ -178,10 +174,7 @@ function validateChecksum(tempPath, name) {
     return;
   }
 
-  const currentHash = crypto
-    .createHash('sha256')
-    .update(fs.readFileSync(tempPath))
-    .digest('hex');
+  const currentHash = crypto.createHash('sha256').update(fs.readFileSync(tempPath)).digest('hex');
 
   if (storedHash !== currentHash) {
     fs.unlinkSync(tempPath);
@@ -193,14 +186,16 @@ function validateChecksum(tempPath, name) {
   }
 }
 
-function downloadBinary() {
+async function downloadBinary() {
   const arch = os.arch();
   const platform = os.platform();
   const outputPath = helper.getPath();
 
   if (process.env.SENTRYCLI_USE_LOCAL === '1') {
     try {
-      const binPath = which.sync('sentry-cli');
+      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();
@@ -214,14 +209,14 @@ function downloadBinary() {
 
   const downloadUrl = getDownloadUrl(platform, arch);
   if (!downloadUrl) {
-    return Promise.reject(new Error(`Unsupported target ${platform}-${arch}`));
+    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 Promise.resolve();
+    return;
   }
 
   const proxyUrl = Proxy.getProxyForUrl(downloadUrl);
@@ -233,74 +228,85 @@ function downloadBinary() {
     logger.log(`Using proxy URL: ${proxyUrl}`);
   }
 
-  return fetch(downloadUrl, {
-    agent,
-    compress: false,
-    headers: {
-      'accept-encoding': 'gzip, deflate, br',
-    },
-    redirect: 'follow',
-  })
-    .then(response => {
-      if (!response.ok) {
-        throw new Error(
-          `Unable to download sentry-cli binary from ${downloadUrl}.\nServer returned ${response.status}: ${response.statusText}.`
-        );
-      }
+  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);
+  }
 
-      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];
-      const total = parseInt(response.headers.get('content-length'), 10);
-      const progressBar = createProgressBar(name, total);
-      const tempPath = getTempFile(cachedPath);
-      mkdirp.sync(path.dirname(tempPath));
-
-      return new Promise((resolve, reject) => {
-        response.body
-          .on('error', e => reject(e))
-          .on('data', chunk => progressBar.tick(chunk.length))
-          .pipe(decompressor)
-          .pipe(fs.createWriteStream(tempPath, { mode: '0755' }))
-          .on('error', e => reject(e))
-          .on('close', () => resolve());
-      }).then(() => {
-        if (process.env.SENTRYCLI_SKIP_CHECKSUM_VALIDATION !== '1') {
-          validateChecksum(tempPath, name);
+  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'));
         }
-        fs.copyFileSync(tempPath, cachedPath);
-        fs.copyFileSync(tempPath, outputPath);
-        fs.unlinkSync(tempPath);
       });
-    })
-    .catch(error => {
-      if (error instanceof fetch.FetchError) {
-        throw new Error(
-          `Unable to download sentry-cli binary from ${downloadUrl}.\nError code: ${error.code}`
-        );
-      } else {
-        throw error;
-      }
-    });
+  });
+
+  if (process.env.SENTRYCLI_SKIP_CHECKSUM_VALIDATION !== '1') {
+    validateChecksum(tempPath, name);
+  }
+
+  fs.copyFileSync(tempPath, cachedPath);
+  fs.copyFileSync(tempPath, outputPath);
+  fs.unlinkSync(tempPath);
 }
 
-function checkVersion() {
-  return helper.execute(['--version']).then(output => {
-    const version = output.replace('sentry-cli ', '').trim();
-    const expected = process.env.SENTRYCLI_LOCAL_CDNURL ? 'DEV' : pkgInfo.version;
-    if (version !== expected) {
-      throw new Error(`Unexpected sentry-cli version "${version}", expected "${expected}"`);
-    }
-  });
+async function checkVersion() {
+  const output = await helper.execute(['--version']);
+  const version = output.replace('sentry-cli ', '').trim();
+  const expected = process.env.SENTRYCLI_LOCAL_CDNURL ? 'DEV' : pkgInfo.version;
+  if (version !== expected) {
+    throw new Error(`Unexpected sentry-cli version "${version}", expected "${expected}"`);
+  }
 }
 
 if (process.env.SENTRYCLI_LOCAL_CDNURL) {
@@ -323,11 +329,14 @@ if (process.env.SENTRYCLI_SKIP_DOWNLOAD === '1') {
   process.exit(0);
 }
 
-downloadBinary()
-  .then(() => checkVersion())
-  .then(() => process.exit(0))
-  .catch(e => {
+(async () => {
+  try {
+    await downloadBinary();
+    await checkVersion();
+    process.exit(0);
+  } catch (e) {
     // eslint-disable-next-line no-console
     console.error(e.toString());
     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');
   }
 });

package/scripts/wheels

@@ -0,0 +1,174 @@
+#!/usr/bin/env python3
+import argparse
+import base64
+import hashlib
+import os.path
+import shutil
+import tempfile
+import zipfile
+from typing import NamedTuple
+
+
+class Wheel(NamedTuple):
+    src: str
+    plat: str
+    exe: str = 'sentry-cli'
+
+
+WHEELS = (
+    Wheel(
+        src='sentry-cli-Darwin-arm64',
+        plat='macosx_11_0_arm64',
+    ),
+    Wheel(
+        src='sentry-cli-Darwin-universal',
+        plat='macosx_11_0_universal2',
+    ),
+    Wheel(
+        src='sentry-cli-Darwin-x86_64',
+        plat='macosx_10_15_x86_64',
+    ),
+    Wheel(
+        src='sentry-cli-Linux-aarch64',
+        plat='manylinux_2_17_aarch64.manylinux2014_aarch64.musllinux_1_2_aarch64',
+    ),
+    Wheel(
+        src='sentry-cli-Linux-armv7',
+        plat='manylinux_2_17_armv7l.manylinux2014_armv7l.musllinux_1_2_armv7l',
+    ),
+    Wheel(
+        src='sentry-cli-Linux-i686',
+        plat='manylinux_2_17_i686.manylinux2014_i686.musllinux_1_2_i686',
+    ),
+    Wheel(
+        src='sentry-cli-Linux-x86_64',
+        plat='manylinux_2_17_x86_64.manylinux2014_x86_64.musllinux_1_2_x86_64',
+    ),
+    Wheel(
+        src='sentry-cli-Windows-i686.exe',
+        plat='win32',
+        exe='sentry-cli.exe',
+    ),
+    Wheel(
+        src='sentry-cli-Windows-x86_64.exe',
+        plat='win_amd64',
+        exe='sentry-cli.exe',
+    ),
+)
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--binaries', required=True)
+    parser.add_argument('--base', required=True)
+    parser.add_argument('--dest', required=True)
+    args = parser.parse_args()
+
+    expected = {wheel.src for wheel in WHEELS}
+    received = set(os.listdir(args.binaries))
+    if expected < received:
+        raise SystemExit(
+            f'Unexpected binaries:\n\n'
+            f'- extra: {", ".join(sorted(received - expected))}\n'
+            f'- missing: {", ".join(sorted(expected - received))}'
+        )
+
+    sdist_path = wheel_path = None
+    for fname in os.listdir(args.base):
+        if fname.endswith('.tar.gz'):
+            sdist_path = os.path.join(args.base, fname)
+        elif fname.endswith('.whl'):
+            wheel_path = os.path.join(args.base, fname)
+        else:
+            raise SystemExit(f'unexpected file in `--base`: {fname}')
+
+    if sdist_path is None or wheel_path is None:
+        raise SystemExit('expected wheel and sdist in `--base`')
+
+    os.makedirs(args.dest, exist_ok=True)
+    shutil.copy(sdist_path, args.dest)
+
+    for wheel in WHEELS:
+        binary_src = os.path.join(args.binaries, wheel.src)
+        binary_size = os.stat(binary_src).st_size
+        with open(binary_src, 'rb') as bf:
+            digest = hashlib.sha256(bf.read()).digest()
+            digest_b64 = base64.urlsafe_b64encode(digest).rstrip(b'=').decode()
+
+        basename = os.path.basename(wheel_path)
+        wheelname, _ = os.path.splitext(basename)
+        name, version, py, abi, plat = wheelname.split('-')
+
+        with tempfile.TemporaryDirectory() as tmp:
+            with zipfile.ZipFile(wheel_path) as zipf:
+                zipf.extractall(tmp)
+
+            distinfo = os.path.join(tmp, f'{name}-{version}.dist-info')
+            scripts = os.path.join(tmp, f'{name}-{version}.data', 'scripts')
+
+            # replace the script binary with our copy
+            os.remove(os.path.join(scripts, 'sentry-cli'))
+            shutil.copy(binary_src, os.path.join(scripts, wheel.exe))
+
+            # rewrite RECORD to include the new file
+            record_fname = os.path.join(distinfo, 'RECORD')
+            with open(record_fname) as f:
+                record_lines = list(f)
+
+            record = f'{name}-{version}.data/scripts/sentry-cli,'
+            for i, line in enumerate(record_lines):
+                if line.startswith(record):
+                    record_lines[i] = (
+                        f'{name}-{version}.data/scripts/{wheel.exe},'
+                        f'sha256={digest_b64},'
+                        f'{binary_size}\n'
+                    )
+                    break
+            else:
+                raise SystemExit(f'could not find {record!r} in RECORD')
+
+            with open(record_fname, 'w') as f:
+                f.writelines(record_lines)
+
+            # rewrite WHEEL to have the new tags
+            wheel_fname = os.path.join(distinfo, 'WHEEL')
+            with open(wheel_fname) as f:
+                wheel_lines = list(f)
+
+            for i, line in enumerate(wheel_lines):
+                if line.startswith('Tag: '):
+                    wheel_lines[i:i + 1] = [
+                        f'Tag: {py}-{abi}-{plat}\n'
+                        for plat in wheel.plat.split('.')
+                    ]
+                    break
+            else:
+                raise SystemExit("could not find 'Tag: ' in WHEEL")
+
+            with open(wheel_fname, 'w') as f:
+                f.writelines(wheel_lines)
+
+            # write out the final zip
+            new_basename = f'{name}-{version}-{py}-{abi}-{wheel.plat}.whl'
+            tmp_new_wheel = os.path.join(tmp, new_basename)
+            fnames = sorted(
+                os.path.join(root, fname)
+                for root, _, fnames in os.walk(tmp)
+                for fname in fnames
+            )
+            with zipfile.ZipFile(tmp_new_wheel, 'w') as zipf:
+                for fname in fnames:
+                    zinfo = zipfile.ZipInfo(os.path.relpath(fname, tmp))
+                    if '/scripts/' in zinfo.filename:
+                        zinfo.external_attr = 0o100755 << 16
+                    with open(fname, 'rb') as fb:
+                        zipf.writestr(zinfo, fb.read())
+
+            # move into dest
+            shutil.move(tmp_new_wheel, args.dest)
+
+    return 0
+
+
+if __name__ == '__main__':
+    raise SystemExit(main())