install: keep the project's .env out of the install's git children and HTTP client

docs/guides/install/custom-registry.mdx

@@ -22,6 +22,8 @@ registry = "https://registry.npmjs.org"
 
 Your `bunfig.toml` can reference environment variables. `bun install` automatically loads environment variables from `.env.production.local`, `.env.local`, `.env.production`, and `.env`, regardless of `NODE_ENV`. It does not read `.env.development` or `.env.test`. See [Environment variables](/runtime/environment-variables).
 
+`bun install` does not take proxy settings (`HTTP_PROXY`, `HTTPS_PROXY`, `ALL_PROXY`, `NO_PROXY`) or `NODE_TLS_REJECT_UNAUTHORIZED` from these files. The `git` that it runs for a git dependency sees none of their variables, such as `GIT_SSH_COMMAND` or `SSH_AUTH_SOCK`. Set those in the environment that runs `bun install`.
+
 ```toml bunfig.toml icon="settings"
 [install]
 registry = { url = "https://registry.npmjs.org", token = "$npm_token" }

docs/guides/install/registry-scope.mdx

@@ -30,6 +30,8 @@ To configure a registry for a particular npm scope:
 
 Your `bunfig.toml` can reference environment variables. `bun install` automatically loads environment variables from `.env.production.local`, `.env.local`, `.env.production`, and `.env`, regardless of `NODE_ENV`. It does not read `.env.development` or `.env.test`. See [Environment variables](/runtime/environment-variables).
 
+`bun install` does not take proxy settings (`HTTP_PROXY`, `HTTPS_PROXY`, `ALL_PROXY`, `NO_PROXY`) or `NODE_TLS_REJECT_UNAUTHORIZED` from these files. The `git` that it runs for a git dependency sees none of their variables, such as `GIT_SSH_COMMAND` or `SSH_AUTH_SOCK`. Set those in the environment that runs `bun install`.
+
 ```toml bunfig.toml icon="settings"
 [install.scopes]
 "@myorg3" = { token = "$npm_token", url = "https://registry.myorg.com/" }

src/install/PackageManager.rs

@@ -320,7 +320,10 @@ pub struct PackageManager {
     // Set once in `init()`/`init_with_runtime()` to the process-singleton
     // `DotEnv.Loader` (leaked allocation; outlives the manager). `BackRef`
     // encapsulates the liveness invariant so `env()` is a safe accessor.
+    // Holds the project's `.env*` files too: git, proxy and TLS settings come from `tooling_env()`.
     pub env: Option<bun_ptr::BackRef<dot_env::Loader, bun_ptr::Mut>>,
+    /// The process environment with no `.env*` file merged in. `None` for the runtime's auto-install.
+    pub(crate) process_env: Option<dot_env::Loader>,
     pub progress: Progress,
     pub(crate) downloads_node: Option<*mut ProgressNode>, // BORROW_FIELD — points into self.progress
     pub scripts_node: Option<NonNull<ProgressNode>>, // points to a caller stack-local Progress node; only valid while that caller frame is live
@@ -886,14 +889,51 @@ impl PackageManager {
         Ok(unsafe { &mut *ptr })
     }
 
+    /// The environment of the git children and of the proxy / TLS settings.
+    pub(crate) fn tooling_env(&self) -> &dot_env::Loader {
+        self.process_env.as_ref().unwrap_or_else(|| self.env())
+    }
+
     pub fn http_proxy(&self, url: &URL<'_>) -> Option<URL<'static>> {
-        // `env_mut()` yields an unbounded `&'a Loader` (process-lifetime
-        // singleton), so the returned `URL<'_>` borrows for `'static`.
-        self.env_mut().get_http_proxy_for(url)
+        // SAFETY: the manager and the loader behind `env` are leaked
+        // process-lifetime singletons, and `process_env` is never written
+        // after `init()`.
+        let env: &'static dot_env::Loader =
+            unsafe { bun_ptr::detach_lifetime_ref(self.tooling_env()) };
+        env.get_http_proxy_for(url)
     }
 
     pub fn tls_reject_unauthorized(&self) -> bool {
-        self.env().get_tls_reject_unauthorized()
+        self.tooling_env().get_tls_reject_unauthorized()
+    }
+
+    /// After a failed request or git command: names, once, the settings that only `.env*` has.
+    pub fn note_dotenv_only_vars(&self, kind: ProcessOnlyEnv) {
+        static NOTED: [AtomicBool; 2] = [AtomicBool::new(false), AtomicBool::new(false)];
+        let Some(process_env) = &self.process_env else {
+            return;
+        };
+        if NOTED[kind as usize].swap(true, Ordering::SeqCst) {
+            return;
+        }
+        let mut names: Vec<u8> = Vec::new();
+        for key in self.env().map.map.keys() {
+            if kind.reads(key) && process_env.get(key).is_none() {
+                if !names.is_empty() {
+                    names.extend_from_slice(b", ");
+                }
+                names.extend_from_slice(key);
+            }
+        }
+        if names.is_empty() {
+            return;
+        }
+        bun_core::note!(
+            "bun {} reads <b>{}<r> from the environment only, not from .env files.",
+            <&'static str>::from(self.subcommand),
+            bstr::BStr::new(&names),
+        );
+        Output::flush();
     }
 
     pub(crate) fn fail_root_resolution(
@@ -1326,6 +1366,33 @@ fn http_thread_on_init_error(err: http::InitError, opts: &http::http_thread::Ini
 // allocate / get singleton
 // ──────────────────────────────────────────────────────────────────────────
 
+/// The settings that `PackageManager::process_env` serves.
+#[derive(Clone, Copy)]
+pub enum ProcessOnlyEnv {
+    Network,
+    Git,
+}
+
+impl ProcessOnlyEnv {
+    fn reads(self, key: &[u8]) -> bool {
+        match self {
+            Self::Network => [
+                b"http_proxy" as &[u8],
+                b"HTTP_PROXY",
+                b"https_proxy",
+                b"HTTPS_PROXY",
+                b"all_proxy",
+                b"ALL_PROXY",
+                b"no_proxy",
+                b"NO_PROXY",
+                b"NODE_TLS_REJECT_UNAUTHORIZED",
+            ]
+            .contains(&key),
+            Self::Git => key.starts_with(b"GIT_") || key.starts_with(b"SSH_"),
+        }
+    }
+}
+
 fn allocate_package_manager() {
     // Uninitialized memory, abort-on-OOM. The init() functions below write the full struct via
     // `core::ptr::write` (no Drop on the uninit bytes).
@@ -1893,6 +1960,8 @@ pub fn init(
     };
 
     env.load_process()?;
+    let mut process_env = dot_env::Loader::init();
+    process_env.load_process()?;
     // Copy the listing's basenames out under `entries_mutex`; `.data` must
     // only be probed while the lock is held.
     let env_probe_keys = {
@@ -2051,6 +2120,7 @@ pub fn init(
         // reads. `BackRef` stores a raw pointer —
         // ending the reborrow here does not alias the later uses.
         wr!(env, Some(bun_ptr::BackRef::new_mut(&mut *env)));
+        wr!(process_env, Some(process_env));
         wr!(
             thread_pool,
             ThreadPool::init(thread_pool::Config {
@@ -2314,7 +2384,7 @@ pub fn init(
             }
 
             // If any HTTP proxy is set, use a diferent limit
-            if env.has_http_proxy() {
+            if mgr_ref.tooling_env().has_http_proxy() {
                 break 'brk DEFAULT_MAX_SIMULTANEOUS_REQUESTS_FOR_BUN_INSTALL_FOR_PROXIES;
             }
 
@@ -2511,6 +2581,7 @@ fn init_with_runtime_once(
         // reads. `BackRef` stores a raw pointer —
         // ending the reborrow here does not alias the later uses.
         wr!(env, Some(bun_ptr::BackRef::new_mut(&mut *env)));
+        wr!(process_env, None);
         wr!(
             thread_pool,
             ThreadPool::init(thread_pool::Config {

src/install/PackageManager/install_with_manager.rs

@@ -57,7 +57,7 @@ pub fn install_with_manager(
 
     // Start resolving DNS for the default registry immediately.
     // Unless you're behind a proxy.
-    if !manager.env().has_http_proxy()
+    if !manager.tooling_env().has_http_proxy()
         && manager.options.offline != crate::package_manager_real::options::OfflineMode::Offline
     {
         // And don't try to resolve DNS if it's an IP address.

src/install/PackageManager/runTasks.rs

@@ -19,7 +19,8 @@ use bun_install::{
 };
 // Import the *module* under the `Task` name so `Task::Id` resolves as a path.
 use super::{
-    Command, PackageInstaller, PackageManager, ProgressStrings, Subcommand, TaskCallbackList,
+    Command, PackageInstaller, PackageManager, ProcessOnlyEnv, ProgressStrings, Subcommand,
+    TaskCallbackList,
 };
 use super::{directories, enqueue};
 use crate::dependency::Behavior;
@@ -1977,6 +1978,7 @@ fn throttle_after_network_error(manager: &PackageManager, has_network_error: &mu
     if core::mem::replace(has_network_error, true) {
         return;
     }
+    manager.note_dotenv_only_vars(ProcessOnlyEnv::Network);
     let min = manager.options.min_simultaneous_requests;
     let max = AsyncHTTP::max_simultaneous_requests().load(Ordering::Relaxed);
     if max > min {

src/install/git_runner.rs

@@ -24,6 +24,7 @@ use bun_sys::windows::libuv as uv;
 use bun_threading::thread_pool as ThreadPool;
 
 use crate::install::{ExtractData, ExtractDataJson};
+use crate::package_manager_real::ProcessOnlyEnv;
 use crate::package_manager_task::{self as Task, Tag};
 use crate::repository::{GitEnv, Repository, RepositoryExt as _, is_safe_resolved_tag};
 use crate::{Error, PackageManager};
@@ -593,7 +594,7 @@ impl GitSubprocess {
     /// Spawns `git <args>` with stdout and stderr captured. On `Ok` the child
     /// may already have exited and freed `this`.
     fn spawn(this: ThisPtr<Self>, args: &[&[u8]]) -> Result<(), Error> {
-        let env = GitEnv::get(this.manager().env_mut());
+        let env = GitEnv::get(this.manager().tooling_env());
         let Some(git) = &env.git else {
             this.log_error(format_args!(
                 "\"git\" is not installed (needed for \"{}\")",
@@ -776,8 +777,11 @@ impl GitSubprocess {
                 && strings::contains(stderr, b"not")
                 && strings::contains(stderr, b"found"))
                 || strings::contains(stderr, b"does not exist"));
-        if !ok && !not_found {
-            this.report_failure(status, stderr);
+        if !ok {
+            if !not_found {
+                this.report_failure(status, stderr);
+            }
+            this.manager().note_dotenv_only_vars(ProcessOnlyEnv::Git);
         }
         let name = BStr::new(&this.name);
         match step {

src/install/lib.rs

@@ -314,8 +314,8 @@ pub use tarball_stream::TarballStream;
 // `package_manager_real` so `crate::PackageManager` and
 // `package_manager_real::PackageManager` are the SAME type.
 pub use package_manager_real::{
-    AsyncNetworkTaskQueue, CommandLineArguments, PackageManager, PatchTaskQueue, RootPackageId,
-    Subcommand,
+    AsyncNetworkTaskQueue, CommandLineArguments, PackageManager, PatchTaskQueue, ProcessOnlyEnv,
+    RootPackageId, Subcommand,
 };
 
 // ──────────────────────────────────────────────────────────────────────────

src/install/repository.rs

@@ -136,6 +136,7 @@ impl SloppyGlobalGitConfig {
 pub use bun_install_types::resolver_hooks::Repository;
 
 /// The environment every `git` the install spawns runs with (see `GitEnv::get`).
+/// Built from `PackageManager::tooling_env`: the `.env*` files that `bun install` loads must not reach git.
 pub(crate) struct GitEnv {
     /// `KEY=VALUE\0` array for spawn.
     pub(crate) envp: bun_dotenv::NullDelimitedEnvMap,
@@ -147,21 +148,21 @@ pub(crate) struct GitEnv {
 static GIT_ENV: bun_core::RacyCell<Option<GitEnv>> = bun_core::RacyCell::new(None);
 
 impl GitEnv {
-    pub(crate) fn get(loader: &mut bun_dotenv::Loader) -> &'static GitEnv {
+    pub(crate) fn get(tooling_env: &bun_dotenv::Loader) -> &'static GitEnv {
         let slot = GIT_ENV.get();
         // SAFETY: only the install thread reaches this. The slot is written
         // once, before any reference into it exists, and never reassigned.
         unsafe {
             if (*slot).is_none() {
-                *slot = Some(Self::init(loader));
+                *slot = Some(Self::init(tooling_env));
             }
             (*slot).as_ref().unwrap()
         }
     }
 
-    fn init(loader: &mut bun_dotenv::Loader) -> GitEnv {
+    fn init(tooling_env: &bun_dotenv::Loader) -> GitEnv {
         // No prompts by default: the install's own output would hide them.
-        let mut map = bun_core::handle_oom(loader.map.clone_with_allocator());
+        let mut map = bun_core::handle_oom(tooling_env.map.clone_with_allocator());
 
         if map.get(b"GIT_ASKPASS").is_none() {
             let config = SloppyGlobalGitConfig::get();

src/runtime/cli/audit_command.rs

@@ -12,7 +12,9 @@ use bun_install::lockfile::reachable;
 use bun_install::package_manager_real::command_line_arguments::AuditLevel;
 use bun_install::package_manager_real::{ROOT_PACKAGE_JSON_PATH, install_with_manager};
 use bun_install::resolution::Tag as ResolutionTag;
-use bun_install::{CommandLineArguments, LogLevel, PackageManager, PackageNameHash, Subcommand};
+use bun_install::{
+    CommandLineArguments, LogLevel, PackageManager, PackageNameHash, ProcessOnlyEnv, Subcommand,
+};
 use bun_libdeflate_sys::libdeflate;
 use bun_parsers::json as bun_json;
 use bun_url::URL;
@@ -754,6 +756,7 @@ fn send_audit_request(
         http_proxy,
         http::FetchRedirect::Follow,
     );
+    req.client.flags.reject_unauthorized = pm.tls_reject_unauthorized();
     let reason = match req.send_sync(&mut response_buf) {
         Ok(res) if res.status_code() >= 400 => SkipReason::Status(res.status_code()),
         Ok(_) => {
@@ -764,7 +767,10 @@ fn send_audit_request(
             }
             SkipReason::NotJson
         }
-        Err(err) => SkipReason::Send(err.name()),
+        Err(err) => {
+            pm.note_dotenv_only_vars(ProcessOnlyEnv::Network);
+            SkipReason::Send(err.name())
+        }
     };
 
     if !registry.is_default {

src/runtime/cli/pm_diff_command.rs

@@ -15,7 +15,7 @@ use bun_install::dependency;
 use bun_install::lockfile::LoadResult;
 use bun_install::lockfile::package::PackageColumns as _;
 use bun_install::npm::{self, PackageManifest};
-use bun_install::{PackageManager, resolution};
+use bun_install::{PackageManager, ProcessOnlyEnv, resolution};
 use bun_libarchive::lib::{ArchiveIterator, IteratorResult as ArchiveIterResult};
 use bun_semver as Semver;
 use bun_sys::{Fd, FdExt as _, dir_iterator as DirIterator};
@@ -903,6 +903,7 @@ fn registry_get(
         Err(err) => {
             Status::clear();
             Output::err(err, "GET {} failed", (BStr::new(&display_url),));
+            pm.note_dotenv_only_vars(ProcessOnlyEnv::Network);
             Global::exit(1);
         }
     };

src/runtime/cli/pm_view_command.rs

@@ -6,9 +6,9 @@ use bun_core::fmt as bun_fmt;
 use bun_core::strings;
 use bun_core::{Global, Output, prettyln};
 use bun_http as http;
-use bun_install::PackageManager;
 use bun_install::dependency;
 use bun_install::npm::{self, PackageManifest};
+use bun_install::{PackageManager, ProcessOnlyEnv};
 use bun_js_parser as ast;
 use bun_js_printer as JSPrinter;
 use bun_parsers::json as JSON;
@@ -136,6 +136,7 @@ pub(crate) fn view(
         Ok(r) => r,
         Err(err) => {
             Output::err(err, "view request failed to send", ());
+            manager.note_dotenv_only_vars(ProcessOnlyEnv::Network);
             Global::crash();
         }
     };

test/cli/install/bun-audit.test.ts

@@ -10,6 +10,7 @@ import {
   normalizeBunSnapshot,
   runBunInstall,
   tempDir,
+  tls,
 } from "harness";
 import { join } from "node:path";
 import { resolveBulkAdvisoryFixture } from "./registry/fixtures/audit/audit-fixtures";
@@ -247,10 +248,11 @@ async function reinstall(dir: string, pkgJson: object) {
   await runBunInstall(installEnv(dir), dir);
 }
 
-async function run(dir: string, args: string[], root: string = dir) {
+// An `undefined` value in `extraEnv` removes that variable from the environment.
+async function run(dir: string, args: string[], root: string = dir, extraEnv: Record<string, string | undefined> = {}) {
   await using proc = Bun.spawn({
     cmd: [bunExe(), ...args],
-    env: installEnv(root),
+    env: { ...installEnv(root), ...extraEnv },
     cwd: dir,
     stdout: "pipe",
     stderr: "pipe",
@@ -1231,6 +1233,37 @@ describe("`bun audit` report", () => {
     expect(await lock(dir)).toBe(lockBefore);
   });
 
+  // `bun install`, `bun info` and `bun pm diff` read this variable for their requests in the same way.
+  test.concurrent(
+    "NODE_TLS_REJECT_UNAUTHORIZED=0 applies from the environment and not from the project's .env",
+    async () => {
+      // `tls` is self-signed, so a client that checks certificates rejects it.
+      await using server = Bun.serve({ port: 0, tls, fetch: () => Response.json({}) });
+      using dir = tempDir("audit-self-signed-", {
+        "package.json": JSON.stringify({ name: "foo", dependencies: { leaf: "1.0.0" } }),
+        "bun.lock": JSON.stringify({
+          lockfileVersion: 1,
+          configVersion: 1,
+          workspaces: { "": { name: "foo", dependencies: { leaf: "1.0.0" } } },
+          packages: { leaf: ["leaf@1.0.0", "", {}, ""] },
+        }),
+        ".env": "NODE_TLS_REJECT_UNAUTHORIZED=0\n",
+      });
+      await writeBunfig(String(dir), `https://localhost:${server.port}/`);
+
+      const fromDotenv = await run(String(dir), ["audit"], String(dir), { NODE_TLS_REJECT_UNAUTHORIZED: undefined });
+      expect(fromDotenv.stderr).toContain("DEPTH_ZERO_SELF_SIGNED_CERT");
+      expect(fromDotenv.stderr).toContain(
+        "note: bun audit reads NODE_TLS_REJECT_UNAUTHORIZED from the environment only, not from .env files.",
+      );
+      expect(fromDotenv.exitCode).toBe(1);
+
+      const fromRealEnv = await run(String(dir), ["audit"], String(dir), { NODE_TLS_REJECT_UNAUTHORIZED: "0" });
+      expect(normalizeBunSnapshot(fromRealEnv.stdout)).toBe(AUDIT_HEADER + noVulnerabilities(1));
+      expect(fromRealEnv.exitCode).toBe(0);
+    },
+  );
+
   test.concurrent("a scoped registry that refuses the connection is skipped", async () => {
     await using scoped = startRegistry({});
     await using server = startRegistry({});