ci: Add a new option for cleaner CI/build output

Author: RulaKhaled

js/__tests__/helper.test.js

@@ -171,4 +171,179 @@ describe('SentryCli helper', () => {
       ]);
     });
   });
+
+  describe('silentLogs functionality', () => {
+    let consoleInfoSpy;
+    let consoleErrorSpy;
+
+    beforeEach(() => {
+      consoleInfoSpy = jest.spyOn(console, 'info').mockImplementation();
+      consoleErrorSpy = jest.spyOn(console, 'error').mockImplementation();
+    });
+
+    afterEach(() => {
+      consoleInfoSpy.mockRestore();
+      consoleErrorSpy.mockRestore();
+    });
+
+    test('determineSuccessMessage returns correct message for releases new', () => {
+      const args = ['releases', 'new', 'v1.0.0'];
+      const message = helper.determineSuccessMessage(args);
+      expect(message).toBe('✓ Release v1.0.0 created');
+    });
+
+    test('determineSuccessMessage returns correct message for sourcemaps upload', () => {
+      const args = ['sourcemaps', 'upload'];
+      const message = helper.determineSuccessMessage(args);
+      expect(message).toBe('✓ Source maps uploaded');
+    });
+
+    test('determineSuccessMessage returns null for version check', () => {
+      const args = ['--version'];
+      const message = helper.determineSuccessMessage(args);
+      expect(message).toBe(null);
+    });
+
+    test('determineSuccessMessage handles empty args', () => {
+      const message = helper.determineSuccessMessage([]);
+      expect(message).toBe(null);
+    });
+
+    test('determineSuccessMessage handles null args', () => {
+      const message = helper.determineSuccessMessage(null);
+      expect(message).toBe(null);
+    });
+
+    test('execute with silent=true takes precedence over silentLogs=true', async () => {
+      const result = await helper.execute(['--version'], false, true, true);
+
+      expect(result).toBe('');
+      expect(consoleInfoSpy).not.toHaveBeenCalled();
+    });
+  });
+
+  describe('command type coverage', () => {
+    test('determineSuccessMessage handles supported high-impact commands', () => {
+      const testCases = [
+        { args: ['releases', 'new', 'v1.0.0'], expected: '✓ Release v1.0.0 created' },
+        { args: ['releases', 'finalize', 'v1.0.0'], expected: '✓ Release v1.0.0 finalized' },
+        {
+          args: ['releases', 'files', 'v1.0.0', 'upload-sourcemaps'],
+          expected: '✓ Source maps uploaded to release v1.0.0',
+        },
+        { args: ['sourcemaps', 'upload'], expected: '✓ Source maps uploaded' },
+        { args: ['sourcemaps', 'inject'], expected: '✓ Source maps injected' },
+        { args: ['debug-files', 'upload'], expected: '✓ Debug files uploaded' },
+        { args: ['upload-proguard'], expected: '✓ ProGuard mappings uploaded' },
+        { args: ['upload-dif'], expected: '✓ Debug information files uploaded' },
+        { args: ['upload-dsym'], expected: '✓ dSYM files uploaded' },
+        { args: ['deploys', 'new'], expected: '✓ Deploy created' },
+        { args: ['mobile-app', 'upload'], expected: '✓ Mobile app uploaded' },
+        { args: ['send-event'], expected: '✓ Event sent' },
+        { args: ['send-envelope'], expected: '✓ Envelope sent' },
+        { args: ['send-metric'], expected: '✓ Metric sent' },
+      ];
+
+      testCases.forEach(({ args, expected }) => {
+        const message = helper.determineSuccessMessage(args);
+        expect(message).toBe(expected);
+      });
+    });
+
+    test('determineSuccessMessage returns null for info/list operations and utility commands', () => {
+      const testCases = [
+        ['--help'],
+        ['--version'],
+        ['info'],
+        ['login'],
+        ['organizations', 'list'],
+        ['projects', 'list'],
+        ['issues', 'list'],
+        ['events', 'list'],
+        ['files', 'list'],
+        ['deploys', 'list'],
+        ['monitors', 'list'],
+        ['releases', 'list'],
+        ['releases', 'delete', 'v1.0.0'],
+        ['unknown-command'],
+      ];
+
+      testCases.forEach((args) => {
+        const message = helper.determineSuccessMessage(args);
+        expect(message).toBe(null);
+      });
+    });
+  });
+
+  describe('Promise resolution scenarios', () => {
+    let consoleInfoSpy;
+
+    beforeEach(() => {
+      consoleInfoSpy = jest.spyOn(console, 'info').mockImplementation();
+    });
+
+    afterEach(() => {
+      consoleInfoSpy.mockRestore();
+    });
+
+    test('execute with live=true, silentLogs=true uses stdio piping and resolves with undefined', async () => {
+      const result = await helper.execute(['--version'], true, false, true);
+
+      expect(result).toBeUndefined();
+      expect(consoleInfoSpy).not.toHaveBeenCalled(); // --version doesn't have success message
+    });
+
+    test('execute with live=true, silentLogs=true shows success message for supported commands', async () => {
+      const result = await helper.execute(['sourcemaps', 'upload'], true, false, true);
+
+      expect(result).toBeUndefined();
+      expect(consoleInfoSpy).toHaveBeenCalledWith('✓ Source maps uploaded');
+    });
+
+    test('execute with live=false, silentLogs=true uses callback mode and resolves with empty string', async () => {
+      const result = await helper.execute(['--version'], false, false, true);
+
+      expect(result).toBe('');
+      expect(consoleInfoSpy).not.toHaveBeenCalled();
+    });
+
+    test('execute with live=false, silentLogs=true shows success message and returns empty string', async () => {
+      const result = await helper.execute(['sourcemaps', 'upload'], false, false, true);
+
+      expect(result).toBe('');
+      expect(consoleInfoSpy).toHaveBeenCalledWith('✓ Source maps uploaded');
+    });
+
+    test('execute with normal mode (live=false, silent=false, silentLogs=false) returns actual stdout', async () => {
+      const result = await helper.execute(['--version'], false, false, false);
+
+      expect(result.trim()).toBe('sentry-cli DEV');
+      expect(consoleInfoSpy).not.toHaveBeenCalled();
+    });
+
+    test('execute with silent=true suppresses output and messages', async () => {
+      // Test with live=true - uses stdio piping, resolves with undefined
+      const result1 = await helper.execute(['--version'], true, true, false);
+      expect(result1).toBeUndefined();
+
+      // Test with live=false - uses callback mode, resolves with empty string
+      const result2 = await helper.execute(['--version'], false, true, false);
+      expect(result2).toBe('');
+
+      // Test with silentLogs=true (should be ignored when silent=true)
+      const result3 = await helper.execute(['sourcemaps', 'upload'], false, true, true);
+      expect(result3).toBe('');
+
+      // No success messages should be shown when silent=true
+      expect(consoleInfoSpy).not.toHaveBeenCalled();
+    });
+
+    test('execute with live=true and normal mode uses stdio inherit and resolves with undefined', async () => {
+      const result = await helper.execute(['--version'], true, false, false);
+
+      // Should resolve with undefined (stdio inherit mode)
+      expect(result).toBeUndefined();
+      expect(consoleInfoSpy).not.toHaveBeenCalled();
+    });
+  });
 });

js/helper.js

@@ -282,11 +282,17 @@ function getPath() {
  * @param {string[]} args Command line arguments passed to `sentry-cli`.
  * @param {boolean} live We inherit stdio to display `sentry-cli` output directly.
  * @param {boolean} silent Disable stdout for silents build (CI/Webpack Stats, ...)
+ * @param {boolean} silentLogs Show only errors and success messages, hide verbose logs
  * @param {string} [configFile] Relative or absolute path to the configuration file.
  * @param {Object} [config] More configuration to pass to the CLI
  * @returns {Promise.<string>} A promise that resolves to the standard output.
  */
-async function execute(args, live, silent, configFile, config = {}) {
+async function execute(args, live, silent, silentLogs, configFile, config = {}) {
+  // Ensure silent takes precedence over silentLogs
+  if (silent) {
+    silentLogs = false;
+  }
+
   const env = { ...process.env };
   if (configFile) {
     env.SENTRY_PROPERTIES = configFile;
@@ -323,21 +329,58 @@ async function execute(args, live, silent, configFile, config = {}) {
   }
   return new Promise((resolve, reject) => {
     if (live === true) {
-      const output = silent ? 'ignore' : 'inherit';
+      let stdoutMode, stderrMode;
+
+      if (silent) {
+        // Complete silence
+        stdoutMode = 'ignore';
+        stderrMode = 'ignore';
+      } else if (silentLogs) {
+        // Capture stdout to filter it, but show stderr for errors
+        stdoutMode = 'pipe';
+        stderrMode = 'inherit';
+      } else {
+        // Show everything
+        stdoutMode = 'inherit';
+        stderrMode = 'inherit';
+      }
+
       const pid = childProcess.spawn(getPath(), args, {
         env,
         // stdin, stdout, stderr
-        stdio: ['ignore', output, output],
-      });
-      pid.on('exit', () => {
-        resolve();
+        stdio: ['ignore', stdoutMode, stderrMode],
       });
+
+      if (silentLogs) {
+        pid.on('exit', (code) => {
+          if (code === 0) {
+            const successMessage = determineSuccessMessage(args);
+            if (successMessage) {
+              console.info(successMessage);
+            }
+          }
+          // Note: errors are already shown via stderr inherit
+          resolve();
+        });
+      } else {
+        pid.on('exit', () => {
+          resolve();
+        });
+      }
     } else {
       childProcess.execFile(getPath(), args, { env }, (err, stdout) => {
         if (err) {
           reject(err);
         } else {
-          resolve(stdout);
+          if (silentLogs) {
+            const successMessage = determineSuccessMessage(args);
+            if (successMessage) {
+              console.info(successMessage);
+            }
+            resolve('');
+          } else {
+            resolve(silent ? '' : stdout);
+          }
         }
       });
     }
@@ -348,6 +391,84 @@ function getProjectFlagsFromOptions({ projects = [] } = {}) {
   return projects.reduce((flags, project) => flags.concat('-p', project), []);
 }
 
+/**
+ * Determines an appropriate success message based on the command.
+ *
+ * @param {string[]} args Command line arguments passed to sentry-cli
+ * @returns {string|null} Success message to display or null if no message needed
+ */
+function determineSuccessMessage(args) {
+  if (!args || args.length === 0) {
+    return null;
+  }
+
+  const command = args[0];
+
+  // Only show success messages for high-impact operations customers care about
+  switch (command) {
+    case 'releases':
+      if (args[1] === 'new' && args[2]) {
+        return `✓ Release ${args[2]} created`;
+      } else if (args[1] === 'finalize' && args[2]) {
+        return `✓ Release ${args[2]} finalized`;
+      } else if (args[1] === 'files' && args[3] === 'upload-sourcemaps' && args[2]) {
+        return `✓ Source maps uploaded to release ${args[2]}`;
+      }
+      break;
+
+    case 'sourcemaps':
+      if (args[1] === 'upload') {
+        return `✓ Source maps uploaded`;
+      } else if (args[1] === 'inject') {
+        return `✓ Source maps injected`;
+      }
+      break;
+
+    case 'debug-files':
+      if (args[1] === 'upload') {
+        return `✓ Debug files uploaded`;
+      }
+      break;
+
+    case 'upload-proguard':
+      return `✓ ProGuard mappings uploaded`;
+
+    case 'upload-dif':
+      return `✓ Debug information files uploaded`;
+
+    case 'upload-dsym':
+      return `✓ dSYM files uploaded`;
+
+    case 'deploys':
+      if (args[1] === 'new') {
+        return `✓ Deploy created`;
+      }
+      break;
+
+    case 'mobile-app':
+      if (args[1] === 'upload') {
+        return `✓ Mobile app uploaded`;
+      }
+      break;
+
+    case 'send-event':
+      return `✓ Event sent`;
+
+    case 'send-envelope':
+      return `✓ Envelope sent`;
+
+    case 'send-metric':
+      return `✓ Metric sent`;
+
+    // Don't show success messages for info/list operations - they show their own output
+    // Don't show for --version, --help - the output is the success
+    default:
+      return null;
+  }
+
+  return null;
+}
+
 module.exports = {
   execute,
   getPath,
@@ -358,4 +479,5 @@ module.exports = {
   getDistributionForThisPlatform,
   throwUnsupportedPlatformError,
   getFallbackBinaryPath,
+  determineSuccessMessage,
 };

js/index.js

@@ -34,7 +34,11 @@ class SentryCli {
     if (typeof configFile === 'string') {
       this.configFile = configFile;
     }
-    this.options = options || { silent: false };
+    this.options = {
+      silent: false,
+      silentLogs: false,
+      ...options,
+    };
     this.releases = new Releases({ ...this.options, configFile });
   }
 
@@ -61,7 +65,14 @@ class SentryCli {
    * @returns {Promise.<string>} A promise that resolves to the standard output.
    */
   execute(args, live) {
-    return helper.execute(args, live, this.options.silent, this.configFile, this.options);
+    return helper.execute(
+      args,
+      live,
+      this.options.silent,
+      this.options.silentLogs,
+      this.configFile,
+      this.options
+    );
   }
 }