fix(5955): ensure getEnvironment() function to return the correct environment values

development/build/constants.js

@@ -25,6 +25,18 @@ const ENVIRONMENT = {
   TESTING: 'testing',
 };
 
+/**
+ * Task prefixes for each build target.
+ * Used to create task names like 'scripts:core:dev:standardEntryPoints'.
+ */
+const TASK_PREFIXES = {
+  [BUILD_TARGETS.DEV]: 'scripts:core:dev',
+  [BUILD_TARGETS.DIST]: 'scripts:core:dist',
+  [BUILD_TARGETS.PROD]: 'scripts:core:prod',
+  [BUILD_TARGETS.TEST]: 'scripts:core:test',
+  [BUILD_TARGETS.TEST_DEV]: 'scripts:core:test-live',
+};
+
 const TASKS = {
   ...BUILD_TARGETS,
   CLEAN: 'clean',
@@ -87,6 +99,7 @@ const MANIFEST_RELEASE_CANDIDATE_KEY =
 module.exports = {
   BUILD_TARGETS,
   ENVIRONMENT,
+  TASK_PREFIXES,
   TASKS,
   MANIFEST_DEV_KEY,
   MANIFEST_RELEASE_CANDIDATE_KEY,

development/build/manifest.js

@@ -16,7 +16,11 @@ const {
   MANIFEST_RELEASE_CANDIDATE_KEY,
 } = require('./constants');
 const { createTask, composeSeries } = require('./task');
-const { getEnvironment, getBuildName } = require('./utils');
+const {
+  getEnvironment,
+  getBuildName,
+  getBuildTargetFromTask,
+} = require('./utils');
 const { fromIniFile } = require('./config');
 
 module.exports = createManifestTasks;
@@ -55,7 +59,8 @@ function createManifestTasks({
   shouldIncludeOcapKernel = false,
   shouldIncludeSnow,
 }) {
-  const environment = getEnvironment({ buildTarget: entryTask });
+  const buildTarget = getBuildTargetFromTask(entryTask);
+  const environment = getEnvironment({ buildTarget });
 
   // merge base manifest with per-platform manifests
   const prepPlatforms = async () => {

development/build/scripts.js

@@ -31,7 +31,7 @@ const bifyModuleGroups = require('bify-module-groups');
 const { streamFlatMap } = require('../stream-flat-map');
 const { isManifestV3 } = require('../../shared/modules/mv3.utils');
 const { setEnvironmentVariables } = require('./set-environment-variables');
-const { BUILD_TARGETS } = require('./constants');
+const { BUILD_TARGETS, TASK_PREFIXES } = require('./constants');
 const { getConfig, getActiveFeatures } = require('./config');
 const {
   isDevBuild,
@@ -155,27 +155,27 @@ function createScriptTasks({
     // dev tasks (live reload)
     dev: createTasksForScriptBundles({
       buildTarget: BUILD_TARGETS.DEV,
-      taskPrefix: 'scripts:core:dev',
+      taskPrefix: TASK_PREFIXES[BUILD_TARGETS.DEV],
     }),
     // production-like distributable build
     dist: createTasksForScriptBundles({
       buildTarget: BUILD_TARGETS.DIST,
-      taskPrefix: 'scripts:core:dist',
+      taskPrefix: TASK_PREFIXES[BUILD_TARGETS.DIST],
     }),
     // production
     prod: createTasksForScriptBundles({
       buildTarget: BUILD_TARGETS.PROD,
-      taskPrefix: 'scripts:core:prod',
+      taskPrefix: TASK_PREFIXES[BUILD_TARGETS.PROD],
     }),
     // built for CI tests
     test: createTasksForScriptBundles({
       buildTarget: BUILD_TARGETS.TEST,
-      taskPrefix: 'scripts:core:test',
+      taskPrefix: TASK_PREFIXES[BUILD_TARGETS.TEST],
     }),
     // built for CI test debugging
     testDev: createTasksForScriptBundles({
       buildTarget: BUILD_TARGETS.TEST_DEV,
-      taskPrefix: 'scripts:core:test-live',
+      taskPrefix: TASK_PREFIXES[BUILD_TARGETS.TEST_DEV],
     }),
   };
 

development/build/utils.js

@@ -3,7 +3,7 @@ const { readFileSync, writeFileSync } = require('fs');
 const semver = require('semver');
 const { capitalize } = require('lodash');
 const { loadBuildTypesConfig } = require('../lib/build-type');
-const { BUILD_TARGETS, ENVIRONMENT } = require('./constants');
+const { BUILD_TARGETS, ENVIRONMENT, TASK_PREFIXES } = require('./constants');
 
 /**
  * Returns whether the current build is a development build or not.
@@ -29,6 +29,43 @@ function isTestBuild(buildTarget) {
   );
 }
 
+/**
+ * Extract the actual build target from a task name.
+ *
+ * Task names follow patterns like:
+ * - 'scripts:core:dev:standardEntryPoints' -> 'dev'
+ * - 'scripts:core:test:contentscript' -> 'test'
+ * - 'scripts:core:test-live:sentry' -> 'testDev'
+ * - 'test' -> 'test' (already a build target)
+ *
+ * @param {string} taskName - The task name or build target.
+ * @returns {BUILD_TARGETS | string} The extracted build target.
+ */
+function getBuildTargetFromTask(taskName) {
+  // If it's already a valid build target, return it
+  const validTargets = Object.values(BUILD_TARGETS);
+  if (validTargets.includes(taskName)) {
+    return taskName;
+  }
+
+  // Create reverse mapping from prefix to build target
+  // Sort by prefix length descending to ensure longer prefixes match first
+  // (e.g., 'scripts:core:test-live' before 'scripts:core:test')
+  const prefixEntries = Object.entries(TASK_PREFIXES).sort(
+    ([, prefixA], [, prefixB]) => prefixB.length - prefixA.length,
+  );
+
+  for (const [buildTarget, prefix] of prefixEntries) {
+    if (taskName.startsWith(prefix)) {
+      return buildTarget;
+    }
+  }
+
+  // If no match found, return the original task name
+  // (getEnvironment will handle it appropriately)
+  return taskName;
+}
+
 /**
  * Map the current version to a format that is compatible with each browser.
  *
@@ -114,12 +151,24 @@ Good luck on your endeavors.`,
 /**
  * Get the environment of the current build.
  *
+ * This is a pure function that determines the build environment based on the
+ * build target and optional git context. When git context is not provided,
+ * it falls back to reading from process.env for backwards compatibility.
+ *
  * @param {object} options - Build options.
  * @param {BUILD_TARGETS} options.buildTarget - The target of the current build.
+ * @param {{ branch?: string, eventName?: string }} [options.git] - Optional git context for pure function usage.
  * @returns {ENVIRONMENT} The current build environment.
  */
-function getEnvironment({ buildTarget }) {
-  const branch = process.env.GITHUB_HEAD_REF || process.env.GITHUB_REF_NAME;
+function getEnvironment({ buildTarget, git }) {
+  // Use provided git context or fall back to process.env for backwards compatibility
+  const branch =
+    git?.branch ||
+    process.env.GITHUB_HEAD_REF ||
+    process.env.GITHUB_REF_NAME ||
+    '';
+  const eventName = git?.eventName || process.env.GITHUB_EVENT_NAME || '';
+
   // get environment slug
   if (buildTarget === BUILD_TARGETS.PROD) {
     return ENVIRONMENT.PRODUCTION;
@@ -131,7 +180,7 @@ function getEnvironment({ buildTarget }) {
     return ENVIRONMENT.RELEASE_CANDIDATE;
   } else if (branch === 'main') {
     return ENVIRONMENT.STAGING;
-  } else if (process.env.GITHUB_EVENT_NAME === 'pull_request') {
+  } else if (eventName === 'pull_request') {
     return ENVIRONMENT.PULL_REQUEST;
   }
   return ENVIRONMENT.OTHER;
@@ -299,6 +348,7 @@ function makeSelfInjecting(filePath) {
 module.exports = {
   getBrowserVersionMap,
   getBuildName,
+  getBuildTargetFromTask,
   getEnvironment,
   isDevBuild,
   isTestBuild,

development/build/utils.test.ts

@@ -0,0 +1,157 @@
+import { getEnvironment, getBuildTargetFromTask } from './utils';
+import { TASKS } from './constants';
+
+describe('getBuildTargetFromTask', () => {
+  it('passes through valid build targets', () => {
+    expect(getBuildTargetFromTask('dev')).toBe('dev');
+    expect(getBuildTargetFromTask('test')).toBe('test');
+    expect(getBuildTargetFromTask('prod')).toBe('prod');
+    expect(getBuildTargetFromTask('dist')).toBe('dist');
+    expect(getBuildTargetFromTask('testDev')).toBe('testDev');
+  });
+
+  it('extracts build target from task names', () => {
+    expect(
+      getBuildTargetFromTask(TASKS.SCRIPTS_CORE_DEV_STANDARD_ENTRY_POINTS),
+    ).toBe('dev');
+    expect(
+      getBuildTargetFromTask(TASKS.SCRIPTS_CORE_TEST_STANDARD_ENTRY_POINTS),
+    ).toBe('test');
+    expect(
+      getBuildTargetFromTask(TASKS.SCRIPTS_CORE_PROD_STANDARD_ENTRY_POINTS),
+    ).toBe('prod');
+    expect(
+      getBuildTargetFromTask(TASKS.SCRIPTS_CORE_DIST_STANDARD_ENTRY_POINTS),
+    ).toBe('dist');
+    expect(
+      getBuildTargetFromTask(
+        TASKS.SCRIPTS_CORE_TEST_LIVE_STANDARD_ENTRY_POINTS,
+      ),
+    ).toBe('testDev');
+  });
+
+  it('returns unknown patterns unchanged', () => {
+    expect(getBuildTargetFromTask('unknown:task')).toBe('unknown:task');
+    expect(getBuildTargetFromTask(TASKS.MANIFEST_DEV)).toBe(TASKS.MANIFEST_DEV);
+  });
+});
+
+describe('getEnvironment', () => {
+  const { env } = process;
+
+  beforeEach(() => {
+    process.env = { ...env };
+    // Clear GitHub env vars that CI sets
+    delete process.env.GITHUB_HEAD_REF;
+    delete process.env.GITHUB_REF_NAME;
+    delete process.env.GITHUB_EVENT_NAME;
+  });
+
+  afterAll(() => {
+    process.env = env;
+  });
+
+  describe('with explicit git context (pure function usage)', () => {
+    it('returns correct environment for build targets', () => {
+      const git = { branch: '', eventName: '' };
+      expect(getEnvironment({ buildTarget: 'prod' as never, git })).toBe(
+        'production',
+      );
+      expect(getEnvironment({ buildTarget: 'dev' as never, git })).toBe(
+        'development',
+      );
+      expect(getEnvironment({ buildTarget: 'test' as never, git })).toBe(
+        'testing',
+      );
+      expect(getEnvironment({ buildTarget: 'testDev' as never, git })).toBe(
+        'development',
+      );
+      expect(getEnvironment({ buildTarget: 'dist' as never, git })).toBe(
+        'other',
+      );
+    });
+
+    it('returns RELEASE_CANDIDATE for dist on release branch', () => {
+      const git = { branch: 'release/13.12.0', eventName: '' };
+      expect(getEnvironment({ buildTarget: 'dist' as never, git })).toBe(
+        'release-candidate',
+      );
+    });
+
+    it('returns STAGING for dist on main branch', () => {
+      const git = { branch: 'main', eventName: '' };
+      expect(getEnvironment({ buildTarget: 'dist' as never, git })).toBe(
+        'staging',
+      );
+    });
+
+    it('returns PULL_REQUEST for dist on pull_request event', () => {
+      const git = { branch: '', eventName: 'pull_request' };
+      expect(getEnvironment({ buildTarget: 'dist' as never, git })).toBe(
+        'pull-request',
+      );
+    });
+
+    it('returns TESTING for test even with pull_request event', () => {
+      const git = { branch: '', eventName: 'pull_request' };
+      expect(getEnvironment({ buildTarget: 'test' as never, git })).toBe(
+        'testing',
+      );
+    });
+
+    it('prioritizes release branch over pull_request event', () => {
+      const git = { branch: 'release/14.0.0', eventName: 'pull_request' };
+      expect(getEnvironment({ buildTarget: 'dist' as never, git })).toBe(
+        'release-candidate',
+      );
+    });
+  });
+
+  describe('with process.env fallback (backwards compatibility)', () => {
+    it('returns correct environment for build targets', () => {
+      expect(getEnvironment({ buildTarget: 'prod' as never })).toBe(
+        'production',
+      );
+      expect(getEnvironment({ buildTarget: 'dev' as never })).toBe(
+        'development',
+      );
+      expect(getEnvironment({ buildTarget: 'test' as never })).toBe('testing');
+      expect(getEnvironment({ buildTarget: 'testDev' as never })).toBe(
+        'development',
+      );
+      expect(getEnvironment({ buildTarget: 'dist' as never })).toBe('other');
+    });
+
+    it('returns RELEASE_CANDIDATE for dist on release branch', () => {
+      process.env.GITHUB_REF_NAME = 'release/13.12.0';
+      expect(getEnvironment({ buildTarget: 'dist' as never })).toBe(
+        'release-candidate',
+      );
+    });
+
+    it('returns STAGING for dist on main branch', () => {
+      process.env.GITHUB_REF_NAME = 'main';
+      expect(getEnvironment({ buildTarget: 'dist' as never })).toBe('staging');
+    });
+
+    it('returns PULL_REQUEST for dist on pull_request event', () => {
+      process.env.GITHUB_EVENT_NAME = 'pull_request';
+      expect(getEnvironment({ buildTarget: 'dist' as never })).toBe(
+        'pull-request',
+      );
+    });
+
+    it('returns TESTING for test even with pull_request event', () => {
+      process.env.GITHUB_EVENT_NAME = 'pull_request';
+      expect(getEnvironment({ buildTarget: 'test' as never })).toBe('testing');
+    });
+
+    it('prefers GITHUB_HEAD_REF over GITHUB_REF_NAME', () => {
+      process.env.GITHUB_HEAD_REF = 'release/15.0.0';
+      process.env.GITHUB_REF_NAME = 'main';
+      expect(getEnvironment({ buildTarget: 'dist' as never })).toBe(
+        'release-candidate',
+      );
+    });
+  });
+});

development/webpack/README.md

@@ -65,6 +65,35 @@ Run `yarn webpack --help` for the list of options.
 
 Note: multiple array options cannot be set this way, due to this bug in yargs: https://github.com/yargs/yargs/issues/821
 
+## CLI Arguments
+
+### `--metamaskEnvironment`
+
+Explicitly sets the build environment for Sentry reporting and feature flags. If not specified, it is auto-detected from git context.
+
+| Value               | When Used                                    |
+| ------------------- | -------------------------------------------- |
+| `production`        | Must be explicitly set (never auto-detected) |
+| `development`       | `--env development`                          |
+| `testing`           | `--test` flag                                |
+| `staging`           | `main` branch                                |
+| `release-candidate` | `release/*` branch                           |
+| `pull-request`      | `pull_request` GitHub event                  |
+| `other`             | Local builds or any other context (default)  |
+
+**Examples:**
+
+```bash
+# Local development (auto-detects as 'other')
+yarn webpack --env production
+
+# Explicit production (for actual releases only)
+yarn webpack --env production --metamaskEnvironment production
+
+# Check what environment will be used
+yarn webpack --env production --dry-run
+```
+
 You can also combine environment variables with `--config` and CLI options:
 
 ```bash

development/webpack/test/cli.test.ts

@@ -29,6 +29,7 @@ describe('./utils/cli.ts', () => {
     snow: false,
     dryRun: false,
     stats: false,
+    metamaskEnvironment: undefined,
   };
 
   it('should return defaults', () => {