v0.7.0
The first Authenticode-signed release, and nvx is on npm. pnpm installs inside the Windows sandbox, nvx setup takes seconds, and the pre-install checks cover every package an npm install brings in.
Added
- fish and cmd.exe are supported shells.
nvx env --shell=fishprints a PATH setup, annvxfunction that evaluatesuseandauto, and a hook on every directory change that also runs once at load, as the zsh one does.nvx useprints fish syntax when it is run from fish.install.shwrites~/.config/fish/conf.d/nvx.fishfor fish, where it used to print a manualfish_add_pathcommand.nvx env --shell=cmdprints aset "PATH=..."line that cmd reads withFOR /f "tokens=*" %i IN ('nvx env --shell=cmd') DO %i. cmd.exe cannot evaluate a program's output, so there is no cmd integration and no AutoRun hook. The shims already run each project's pinned version there.
NVX_NODE_MIRRORfetches Node.js from a mirror. nodejs.org was hard-coded, so a network that reaches it only through an internal mirror could not install Node.js. The release index, the archives andSHASUMS256.txtall come from the mirror, as with nvm. An existingNVM_NODEJS_ORG_MIRRORorFNM_NODE_DIST_MIRRORis read too. The checksums come from the same place as the archives, so a mirror is trusted as nodejs.org is.
- A global policy can now be a baseline a project cannot weaken. Setting
"enforced": truein~/.nvx/policy.jsonmeans a project's own.nvx-policy.jsonmay make a setting stricter and may not make one looser. A file that tries is refused, by name: which setting, what the baseline says, and what the file asked for. Nothing runs under a policy nvx could not assemble.
Opt-in and read from the global file only, so every policy already written behaves exactly as it did. A project file that sets the key is told it was ignored rather than left to assume otherwise.
nvx policy explainprints each setting's effective value and where it came from: a built-in default, the global policy, one of the project files, or an approval recorded for this project. It also names a project file that is not in force, and says which of the two reasons applies, because "I set this and it is not applying" has more than one cause and they look identical from outside.
nvx policy check, a CI gate with a distinct exit code per failure class rather than the blanket 1 every command used before. A pipeline can now tell a blocked package from a vulnerability from a policy file it could not read. The codes are documented indocs/exit-codes.mdand pinned to the code by a test. It never prompts, and it makes no network request unless--onlineis passed, so it cannot hang a job or fail one because a third party is down.--format jsonprints the same verdict as data, including what was checked and what was skipped.
nvx audit exportwrites the local record as jsonl, json or csv, filtered by--since(a timestamp, or7d/2w/12h) and by--event. A line that cannot be parsed is reported and the command exits non-zero, having exported and counted everything that could be read:nvx auditskips a torn line silently because it is printing to a screen, and an export that quietly omits records is worse than none.docs/audit-log.mddocuments every event, its fields, and which parts of that are a contract and which may change.
nvx doctornow tells you when a straypackage.jsonhas merged your projects into one sandbox. nvx works out which project a sandbox belongs to by looking upward for the nearest manifest, so one sitting above a set of projects quietly joins them together: something installed in either can then read and write the other. Measured on 2026-09-01 — an install run in a home directory left a manifest behind, and every project underneath it, including nvx's own test fixtures, became a single scope. That was already written up under Known limitations, together with the admission that nothing warned you.
Doctor now names the file, says what it means for you, and counts it as a problem so the command exits non-zero. Only a home directory or the top of a drive is reported, because those are the ones that sweep in projects that have nothing to do with each other; a manifest one level up is an ordinary monorepo and is left alone.
- Fuzz targets for the egress proxy's two parsers. The SOCKS5 handshake and the HTTP CONNECT request are the only things nvx parses whose bytes come from the contained process rather than from a person, and the proxy that parses them runs in the parent, outside the containment, with real network access. A panic there takes down the supervisor of a running sandbox; a hang holds an install open. Until now they had unit tests for the shapes someone thought to write down and nothing for the rest.
Four targets: the two connection handlers driven over net.Pipe, plus validEgressHost and the proxy credential check. The two that matter assert liveness rather than correctness — a parser refusing malformed input is doing its job — while validEgressHost asserts that anything it accepts is free of control characters, since what it accepts is printed to a terminal and written to the audit log, and the credential check asserts that an accepted header decodes to exactly this session's token.
The fuzz configuration cannot reach the network: the allowlist is empty and prompt_unknown is false, so allowed() refuses before dialVetted is called, and the resolver is stubbed because both handlers resolve the host before consulting the allowlist. Measured 2026-09-11: 25 seconds per target, no panic, no hang, no unauthorized acceptance, and no crasher written.
Changed
- The release workflow Authenticode-signs
nvx.exe, with the Certum certificate netscli uses, before any checksum, attestation or SBOM is made over it. Signing runs in its own job, which holds the Certum credentials and receives onlynvx.exe, and has no write access to the release. The workflow can be run by hand to build, sign and verify without publishing anything.
- A failed contained
bun installoutside the system drive says why. Bun's package manager cannot run in the Windows sandbox in a project on a drive other than the one Windows is installed on, and printed onlyerror: An internal error occurred (EBADF). Measured with Bun 1.4.2,bun installworks on C: and fails on D: and H:. After a failedbun install,add,remove,update,patchorpmin such a project, nvx now adds two lines naming the cause and the two ways out. Those arenvx --no-sandbox bun ..., which runs Bun uncontained, or moving the project to the system drive. Bun's fix is in progress as oven-sh/bun#38365. nvx setupcovers every fixed drive. It used to grant only the drives holding Windows, your profile, nvx and the current directory, because each grant was slow on a large drive. Now that a grant is fast, one run covers them all and nobody has to run setup again from each drive.--all-drivesis still accepted and changes nothing.- nvx is on npm as
@fstubner/nvx, published through trusted publishing.npm install -g @fstubner/nvxinstalls the binary for your platform and runs no install script. Releases now publish to npm with the release workflow's GitHub identity rather than a stored npm token, so each version carries npm provenance and there is noNPM_TOKENsecret to leak or expire. - The shims run the version the project pins, with or without the shell integration. In a project whose
.nvmrcsaid 20.11, with 22 as the default,node --versionthrough the shim printed v22.23.3 and a warning. Only a shell with the integration loaded switched, so IDE tasks, git hooks, cron, CI and editors runningnpm runall got the default.node,npm,npx,pnpm,yarn,corepack,bunandbunxnow read.nvmrc,.node-version,.bun-versionandpackage.jsonthe waynvx autodoes and run the installed version that matches. A version this shell already has active fromnvx usestill wins. A pinned version that is not installed still runs the default, and the warning now names thenvx installcommand that fixes it. Contained runs pick the same version, with the policy'sruntime.versionsahead of the file. The search for a version file now stops at your home directory.
- An npm install that brings in new packages now runs npm twice. The first run only resolves versions, so that each package can be checked before the second run installs it. Measured 2026-10-01 on Windows, five runs each with a 5-dependency project and no lockfile,
nvx npm installtook 5283 to 5573 ms, and 9950 ms on the first run. Without the resolution step it took 3064 to 3219 ms.npm ciand annpm installwhose lockfile matchespackage.jsonskip it. Because dependencies are now checked,enforce_ignore_scriptsrefuses a dependency with install scripts, and a dependency inside the release-age window prompts, where before only the packages you named did. - The installers check the download's build attestation when
ghis present.install.shandinstall.ps1used to compare the download only with the.sha256file from the same release, which a replaced release could replace as well. When the GitHub CLI is installed, signed in and 2.49 or newer, they now also rungh attestation verifyagainstfstubner/nvxand stop without changing nvx if it fails. Without a usableghthey print one line saying the check was skipped and the command to run. The checksum check is unchanged. The install guide now shows how to verify a downloaded asset by hand.
- The README is a short front page, and the reference moved to the docs site. Containment, policy, known limitations and the FAQ are now docs pages, and the full
nvx helpreference is on the Commands page. The tests that held the README's command list tonvx helpnow read that page.
- nvx exits 77 when it refuses to run a command, instead of 1. A global install it will not contain, a package that failed pre-install verification, a sandbox it could not establish — all of these returned 1, which is also what npm returns when an install fails on its own terms. A script or an agent loop saw "exit 1" either way and could not tell nvx saying no (fix:
--no-sandboxornpx) from a registry timeout (fix: retry) without parsing English off stderr. The audit log already made this distinction (mode=refused, with a reason); this is the same distinction at the one layer a program reads. 77 isEX_NOPERMin sysexits.h. The command's own exit codes are passed through unchanged.
- The global-install refusal now says what to do if you are an agent. It leads with "nvx refused", states the consequence plainly — anything installed globally runs uncontained on every future invocation — and names
npxand a project-local install as the contained alternatives, and tells an agent not to pass--no-sandboxon its own but to inform the person it works for that the install would run uncontained, and let them decide.-qno longer hides any of that: it asks nvx not to narrate progress, and a refusal has no progress to narrate —nvx -q npm install -gused to print the one-line refusal and drop every actionable part of it. The old message offered only the escape hatch, which nudged an automated caller toward the least-contained option and left the person out of the loop.
- A test whose setup lost a handle now retries, and skips rather than failing if the host keeps refusing. The same Windows condition that refuses a process also refuses a file write: measured 2026-09-10, a test died at
write ...\windows-setup.json: The handle is invalidbefore a single assertion ran, and the identical commit re-run was clean. This is the third face of one host state, after cleanup (removeAllBestEffort) and reading the staged probe child (stageProbeChild).
Applied at the two measured call sites only, not to the 135 t.Fatal(err) setup sites across 52 Windows test files. A sweep that size would be unreviewable and would make every one of those sites quieter about real defects; machinery earns its place from a failure that happened. A persistent refusal skips with a message saying an assertion was not checked, so a run cannot report success for a probe that never executed.
- macOS: the
sandbox-execprovider's availability check now asks about the same path the launcher uses. It had the path written out a second time, so a test that puts nvx on a machine with nosandbox-exec-- the only way to check that nvx refuses rather than running uncontained -- could not reach the provider gate.
- The tests that need an AF_UNIX socket skip on a long temporary directory rather than failing. The socket path limit is 104 bytes and includes whatever
TMPDIRis; under an agent harness's scratch directory that produced a 151-byte path and turned six tests red for a reason unrelated to the code. The skip names the limit and the path.
- Removed the pre-AppContainer low-integrity token path (five functions and six constants on Windows, plus their no-op Linux twins). Nothing had called any of it since containment moved to AppContainer security capabilities. Code that compiles and looks like the security model, but is not the security model, is the wrong thing to leave in the file someone opens to find out how containment works. Also removed the two helpers that read permissions out of icacls' printed text, superseded by reading the access mask off the entry.
nvx reportand the Docker provider's environment. SECURITY.md now records thatdocker runtakes allowed environment values as-e KEY=VALUE, so they are visible in the process list to other processes running as you while the container starts. nvx keeps them out of its own output; the argument list is docker's. The native providers are unaffected.
Fixed
- On macOS, a contained install can no longer write other apps' temp and cache files. The sandbox let every contained process write
/private/tmp,/private/var/tmp, all of/devand all of/private/var/folders, which holds every app's per-user temp and cache directories. A package could plant files there for uncontained programs to read. It now writes only the project, its own temporary home, where its temp directory already was, and a named list of device files such as/dev/nulland/dev/tty.
--helpworks afterpolicy init,policy check,policy explainandaudit export. Each printed "Unknown option" and exited 1. They now print the command's help and exit 0, as the other commands do.
nvx policy check --format=jsonprints an emptyfindingslist when nothing failed. It printednull, which a script that loops over the list had to treat as a special case.
- The help text describes what
nvx setup,nvx grants listandnvx autodo.setupgrants read and list access, not stat access, on the root of every fixed volume and its Users folder.grants listshows egress hosts recorded by older versions, because approving a host at the prompt now lasts one run and is not stored.autolists.bun-versionand thevoltaentry inpackage.json, which it reads, and no longer names a separate Volta file.
- pnpm installs inside the Windows sandbox. pnpm 10 resolves the project directory with
fs.promises.realpath, which asks Windows for the path with its drive letter, and an AppContainer is refused that on every path. A firstpnpm installstopped withEPERM: operation not permitted, realpath. The preload nvx puts in every contained node process now retries a refused native realpath with Node's JavaScript one, which walks the path withlstatandreadlinkand reaches the same answer. Measured 2026-10-04 with pnpm 10.34.6 on Node 22.23.3: a first install now completes in projects onC:and onH:.
- A second
pnpm installin the sandbox works. pnpm keeps its package store in the home folder when the project is on the same drive, and records the store's path innode_modules/.modules.yaml. Every contained run had a new home, so the next install found a different store and stopped withERR_PNPM_ABORTED_REMOVE_MODULES_DIR_NO_TTY. Contained pnpm commands now share one home per project that is kept between runs, as a trusted tool's is. No other project and no other package manager uses it. Measured 2026-10-05 with pnpm 10.34.6 on Windows: two installs in a row now both finish in a project onC:. A project already installed by an earlier nvx still records the old path, so delete itsnode_modulesfolder once.
nvx setupno longer spends minutes on each large drive. On 2026-10-04nvx setup --all-drivesgranted D:\ in 1 second and E:\ in 3, then was still working on F:\ after 33 minutes. The grant is one entry on the drive root that nothing below the root inherits. Writing it made Windows re-check the permissions of every file on the volume, which changed nothing. Setup andnvx setup --undonow write the root's own permissions and leave the rest of the volume alone. On a test directory holding 20,000 files the old write took 2.67 to 3.01 seconds and the new one under 1 millisecond, and no file's permissions changed either way. The same write used to drop the directory's auto-inherited mark, and now keeps it as it was.- The typosquat check no longer refuses dependencies you did not choose. The pre-install checks run over the whole resolved tree, and the typosquat check asked api.npmjs.org for the weekly downloads of every package in it. On 2026-10-04
npm ciover a 415-package tree got HTTP 429 from that API, the lookups fell back to name similarity, and the legitimate transitive packageregexwas refused as a typosquat. A typosquat is a name someone typed wrongly, and a dependency's name was written by its author. The check now runs only on the packages named on the command line, or with none named, on the dependencies inpackage.json. The blocklist, release-age, install-script and advisory checks still cover the whole tree. Download lookups are also remembered for the rest of the run. - A command that turns install scripts off is no longer asked about them.
npm ci --ignore-scriptsin a project depending on chromedriver stopped at the install-script prompt, andnpm install esbuild --ignore-scriptsaborted non-interactively with exit 77, although npm ran none of those scripts. The install-script prompt and theenforce_ignore_scriptsrefusal are now skipped when--ignore-scriptsis on the command line (also--ignore-scripts=true), whennpm_config_ignore_scripts=trueis in the environment, or when the project.npmrcsetsignore-scripts=true. bun reads only the flag. A run inside the sandbox gets nonpm_config_*variables, so the environment does not count there.--ignore-scripts=falsedoes not count. The skip is recorded once per run ascheck_skipped. The typosquat, release-age, advisory and blocklist checks still run.
nvx usein cmd.exe no longer prints bash or PowerShell syntax. Run from a cmd window opened out of Git Bash it printedexport PATH='/c/...'lines and told you to add a line to~/.bashrc, because theMSYSTEMvariable Git Bash sets is inherited. In any other cmd window it printed PowerShell syntax. nvx now asks which process started it and finds cmd.exe. It says that cmd cannot be switched by a program, that the shims already follow the project's version file, thatnvx default <version>sets the version for new windows, and gives the one command that switches only that window. The same check makesnvx envandnvx doctoruse cmd syntax there. A PowerShell, bash, zsh or fish parent is recognised the same way.- On Windows, contained runs now work under a long
NVX_HOME. The sandbox reaches nvx through sockets that lived underNVX_HOME, and a socket path must stay under 108 bytes. Measured on 2026-10-01, a 132-characterNVX_HOMEneeded a 174-byte path and every run that used the egress proxy refused with exit 77. The longest that worked was 65 characters. Long values are common on Windows, with profiles redirected to OneDrive or corporate home folders. When the sockets do not fit underNVX_HOME, nvx now puts them in the sandbox's own folder in%LOCALAPPDATA%\Packages, which Windows already grants the sandbox. The same run then used a 90-byte path and completed. When that folder's path is too long as well, the refusal names the longestNVX_HOMEthat works.
- Packages from a private registry are now checked on that registry. The pre-install checks asked registry.npmjs.org about every package. A package served only by a private registry came back 404, and with nobody to answer the prompt the install was refused. nvx now reads the registry npm will use for each package from
.npmrcandnpm_config_*, scopes included. A contained install reads the project's.npmrconly, as its npm does. When the registry needs a token to read metadata, nvx sends the_authTokenfrom your.npmrcwith its own request. The token does not reach the sandbox or any log. A package from a registry other than registry.npmjs.org skips the typosquat and advisory checks, because both send the name to a public service. The run says so in one line and the audit log records it ascheck_skipped.
- Contained installs now work behind a corporate proxy. nvx's egress proxy dialled every allowed host itself, and the contained process got nvx's proxy in place of yours. On a machine that reaches the internet only through a proxy, a contained install could reach nothing. When
HTTPS_PROXYorHTTP_PROXYis set, an allowed connection now goes through that proxy as a CONNECT tunnel, withProxy-Authorizationfrom the URL's user and password.NO_PROXYhosts and loopback destinations are dialled directly. The allowlist still decides first, so a host it refuses is never sent to your proxy.
- On Windows, a program your own code leaves running in the background now outlives the command. Through nvx it was killed the moment the command exited. That hit
npm runscripts thatstarta program,spawnwithdetached: true, and tools that start a daemon and return. Measured on 2026-10-01, annpm runscript ofstart "" ping.exe -n 20 127.0.0.1left 1 ping running with plain npm and 0 through nvx. A node script spawning ping withdetached: truegave the same 1 and 0. Both now leave 1 through nvx.
When nvx ends a command itself, because the program that started nvx has gone, or when nvx is killed while the command runs, the command's whole process tree still ends with it. A command nobody is waiting on is still not left behind.
- The pre-install checks now run on every package an npm install brings in. They ran on the packages named on the command line, so
npm install tsxinstalled esbuild and ran its postinstall with no prompt, whilenpm install esbuildasked first. Its release age was never looked at either. Fornpm install,npm updateandnpm dedupe, nvx now runs npm's own resolver first with--package-lock-only --ignore-scripts, contained like the install, on a scratch copy ofpackage.jsonand the lockfile. Every package in the tree it writes gets the blocklist, typosquat, release-age, install-script and advisory checks, with the same prompts as a package you named, apart from those already installed at the same version. A failed resolution is asked about like a failed registry lookup, and refused when nobody is there to answer. Projects with npm workspaces or a dependency on a local folder are not resolved, and the run says so.
- A lockfile entry must now match the registry's record of its name and version. The checks read each entry's name and version and never its
resolvedURL orintegrityhash, which are what npm installs from. An entry named left-pad@1.3.0 that pointed at the is-number tarball was checked as left-pad and installed is-number. An entry's hash must now equal the registry's hash for that name and version, or its URL must be the registry's tarball when it has no hash. One that does not is refused. Entries from git, a local path, or a URL the dependency asked for are reported as not registry-checked.
- Without a lockfile, the checks read the version
package.jsondeclares. They read only the names, so esbuild pinned at 0.20.0 was checked as 0.28.2, the newest release. Afile:,link:orworkspace:dependency was looked up in the registry by name, so a localevil-pkgwas flagged for an unrelated registry package of that name. Each dependency is now checked at its declared version or range, and local and workspace dependencies are not looked up.
npm update,npm dedupe,npm rebuild,npm exec,npm create,npm init <initializer>,pnpm dlx,yarn dlxandbun xnow get the pre-install checks. They were contained and checked nothing.npm updateandnpm dedupeare resolved by npm as above. rebuild checks what the lockfile says is installed. The runners check the package they run, asnpxdoes, andcreate foocheckscreate-foo. pnpm, yarn and bun update, upgrade, dedupe and rebuild check the packages they name, or the project's declared dependencies.
blocked_packagesnow applies to packages that do not come from the registry.left-pad@github:user/repo,left-pad@https://...and a registry tarball URL for left-pad all install left-pad, and none was compared with the list. The name a spec installs under is now checked, from the command line, frompackage.jsonand from the lockfile.
- An unreadable lockfile no longer sends the checks to
package.json. Whenpackage-lock.jsoncould not be parsed, nvx checked the newest version of each name inpackage.jsoninstead, and refused versions nobody was installing. That is hownpm ciin a docs site was stopped over @astrojs/starlight 0.42.5 while its lockfile pinned 0.42.1. It is now asked about like a failed registry lookup, and refused when nobody is there to answer.
- On macOS a contained install can no longer read your credential files. The macOS sandbox allows filesystem reads so programs can load system libraries, and that included
~/.npmrc,~/.ssh,~/.awsand the other places registry tokens, keys and cloud credentials live. Windows and Linux already kept them out of reach. The macOS sandbox now refuses reads of the npm, yarn, pnpm and bun config files,~/.docker/config.json,~/.netrc,~/.git-credentials, and everything under~/.ssh,~/.aws,~/.gnupg,~/.config/gh,~/.kube,~/.config/gcloud,~/.azureand~/Library/Keychains. Other files outside the project stay readable on macOS. - A contained install can no longer write the project's
.git. The project directory was writable as a whole,.gitincluded, and git runs outside the sandbox. So a hook or a.git/configentry written by an install ran as you on the nextgit commitorgit status, at thestrictlevel too..gitis now read-only to contained runs on Linux, macOS and Windows, and so is the git directory a.gitfile names inside the project. Reads still work. A run that cannot protect.gitrefuses to start. Hook installers that run during an install (husky'sprepare, simple-git-hooks, lefthook) can no longer set themselves up inside the sandbox, so run them yourself afterwards. On Windows.gitstops inheriting permission changes from the project folder. - More package-manager commands that run dependency code are contained. nvx contains a package-manager command when it recognises the verb, and several verbs that run dependency install scripts ran uncontained with no pre-install checks.
bun pm trustandpnpm approve-buildsrun the scripts the install held back.npm uninstall,npm prune,pnpm remove,pnpm fetchandbun removere-install whatever the lockfile lists that is missing.npm link <package>andbun link <package>install as well, andnpm packof a git dependency runs its prepare script. These verbs and their aliases in npm, pnpm, yarn and bun are now contained.corepackis now wrapped too, andcorepack pnpm add xornode "$npm_execpath" install xis judged as the package-manager command it runs.npm link,pnpm self-updateandpnpm env usewrite outside the project, so a contained run of one is refused before it starts and names the--no-sandboxcommand to use instead. - Killing nvx on Linux now stops the contained process. The sandbox supervisor was started with no parent-death signal and no signal forwarding, so
killorkill -9on nvx left the contained process running, and the next nvx run deleted its home directory underneath it. The supervisor now dies with nvx, SIGINT, SIGTERM and SIGHUP reach the contained process so it can shut down, and the session record names the supervisor as well as nvx.
- A command run outside the sandbox now stops with nvx on Linux and macOS, and reports a signal as 128 plus its number.
killon nvx left the realnoderunning, and a runtime ended by SIGTERM exited 255 where a shell shows 143. nvx now passes SIGINT, SIGTERM and SIGHUP on to the runtime, and on Linux the kernel kills the runtime if nvx is killed outright. The same exit code mapping applies to contained commands.
nvx doctornow tests a real sandbox launch on Linux, and explains a refusal on Ubuntu 23.10 and later. It used to report a healthy sandbox without starting one. It now runs a contained process, and when the kernel refuses the namespaces it nameskernel.apparmor_restrict_unprivileged_userns, offers relaxing it or settingisolation.network.modetoopen, and says whetheropenstarts on that machine. macOS is unchanged.- On Linux, a contained process can no longer reach the host's UNIX sockets. Landlock below ABI v9 does not restrict connecting to a UNIX socket by path, so a contained process could open
/var/run/docker.sockor any other socket on the machine while its writes stayed blocked. The sandbox now sees only the directories it is granted, and every other path on the host is absent from it. nvx's own proxy and--connectsockets live in the sandbox's home and keep working. On kernels with Landlock ABI v9, sockets in the system and runtime directories are refused as well.
- The first
nvx installnow becomes the default version. With no default set,noderan an unrelated system node or failed with "Could not find real executable for node" and no hint. The first version installed for a runtime is now its default. Installing a version that is not the default says how to switch to it, withnvx use <version>for this shell andnvx default <version>for new shells.nvx doctoralso exits non-zero when no runtime is available behindnode,npmornpx, where it used to report that nvx was intercepting correctly.
- zsh switches version as soon as a terminal opens inside a project. The zsh hook only ran on a directory change, so the project's version applied after the first
cd. The integration now runs the hook once when it loads, which matches bash.
- A
.nvmrcwithlts/*orlts/<codename>no longer prints a false "shell integration is not active" warning. Everynode,npmandnpm runin such a project warned, even with the right version running. The aliases are now resolved against the installed versions, so a pin that is satisfied gives no warning.
nvx installandnvx usewith no version read the project's version file. They answered "Please specify a version" in a directory whose.nvmrcnamed one. They now read.nvmrc,.node-version,.bun-versionandpackage.jsonthe waynvx autodoes.nodeandstablenow mean the newest version, as in nvm, andnvx use ironaccepts an LTS codename for an installed version. When a.tool-versionsfile ordevEngines.runtimeis present, nvx says it does not read it.
nvx defaultno longer says to add thecurrentlink to PATH. Only the shim directory belongs on PATH, and a runtime directory ahead of it is whatnvx doctorreports as shadowing the shims.
nvx cleanupandnvx installremove what an interrupted install left. A killed install left a.tmp.<pid>staging directory, its download and a lock, and nothing removed them. Both commands now remove staging directories and downloads whose process is gone, and locks nvx can prove are abandoned. Anything whose process is still running, or whose owner cannot be read, stays.
- nvx refuses to install the glibc build on Alpine. On a musl system the install reported success and
nodethen failed withfork/exec ... no such file or directory. The install now stops and says the system uses musl and that nvx has no musl build. nvx does not download musl builds.
- Colour codes and the download bar stay out of pipes and logs. Output is plain when it is not a terminal, and
NO_COLORis honoured. A download that is not on a terminal prints a line per tenth of the file instead of a bar redrawn with carriage returns. The text of the messages is unchanged.
-y,--agent-modeandNVX_YESno longer approve pre-install checks silently. The typosquat, release-age, install-script, known-advisory and "could not check" prompts were answered with no output and no audit record, sonvx auditread "No audit records yet" after an install that had gone past all of them. Every one of these checks now writes acheck_approvedorcheck_refusedrecord, however it was answered and whateverNVX_TRACEsays. An approval nobody was asked about also prints one line to stderr that names it.
A refusal now names the narrowest fix first, as the exact policy line to add, and mentions -y and NVX_YES last. That covers typosquatting.trusted_packages, release_age.trusted_packages, install_scripts.trusted_packages, vulnerabilities.allowed_advisories and min_severity, and isolation.network.allow_hosts for a refused host. The enforce_ignore_scripts refusal used to say to run with --ignore-scripts, which does not get past it, and now says what does. The reply sent to an MCP client and SECURITY.md follow the same order.
A failed weekly-download lookup (a 429, a proxy block, no network) used to fall back to name similarity without saying so. The prompt now says the lookup failed and that the result is a name-similarity guess. A name on nvx's popular-package list is warned about instead of flagged. A name on no list is checked as before.
- Cleanup no longer removes a running session's files on Windows. A session whose owning process nvx could not open, such as an elevated one, was read as finished, and its home could be deleted while it ran. A trusted tool's AppContainer profile could also be deleted while the tool was running, once it had gone unused for the retention window. Each trusted-tool run now marks itself as live for as long as it runs.
- Two runs of one trusted tool no longer share stdio pipes on Windows. The pipe names came from the tool's home, which is the same for every run, so a second run joined the first one's pipes. Each run now draws its own names, and a name already in use is refused.
nvx setupchecks that the old loopback exemption is really gone. Any failure to remove it, a timeout included, was reported as nothing to remove. Setup now reads the exemption list and fails while the exemption is still registered.nvx setup --undoalso removes the grants setup recorded, which included the Users folder on other volumes, and no longer leaves an unused AppContainer profile behind.nvx doctornow says leftover sandbox permissions on a project admit sandboxes from nvx builds older than 0.5.0, which is who they admit.
nvx doctor --fixkeeps non-ASCII entries in your User PATH. It read the PATH throughreg query, whose output is in the console code page, soC:\Users\Jürgen\bincame back with a wrong byte in place of the ü, and the repair wrote that back. It now reads the value directly from the registry.
- An unreadable grants record is no longer replaced with an empty one. A record that existed and could not be read was treated as empty, and the next change saved over it, losing the list of permissions nvx had granted. The change now fails instead, and read-only commands warn.
- The egress proxy refuses a malformed CONNECT port.
443xwent on as port 0 and99999as 65535, and the raw request, port included, was printed to the terminal when the dial failed. It now answers 400 and logs only the parsed host and port. The proxy also checks its credential before it judges the host, so an unauthenticated caller can no longer put a warning on your terminal or a line in the audit log.
nvx audit export --format csvno longer emits spreadsheet formulas. A value starting with=,+,-or@became a live formula when the file was opened in a spreadsheet, and several fields can come from lines anything on the machine appended to the log. Such cells now start with a single quote.
- A project bin with a dot in its name gets a working shim. A
node_modules/.binentry namedfoo.barwas shimmed asfoo, which ran a command nothing provides. Only.cmd,.ps1and.exeare trimmed now.
bun@0.8and other older Bun lines resolve again. Only the first 100 Bun releases were read, and that page now ends at 1.0.25. The whole list is read.
- A refused
isolation.environment.allowentry is recorded in audit.log. A policy asking to pass a credential into the sandbox was a terminal warning and nothing else. It is now anenv_pass_refusedrecord, with names only.
- Smaller Windows fixes. The hangup watchdog no longer waits on an unrelated process that reused its parent's pid. A contained command's exit no longer waits up to 5 seconds per stuck stdio channel, one after another. A failure to stage the command now has its own reason in the audit log. The icacls command nvx suggests for a widened read/execute entry can be pasted as printed.
- A package installed under an npm alias is checked as itself.
npm install myalias@npm:left-padwas checked as a package calledmyalias, so a blocklist entry for left-pad did not stop it, and the typosquat, advisory and release-age checks asked about a package that does not exist. The same alias in package.json or package-lock.json was read the same way bynpm ciand bynvx policy check. The target package and its version are what gets checked now.
nvx NPM install xgets the same checks asnvx npm install x. The command name was accepted in any case and ran contained, and the pre-install checks only matched it in lowercase, so they were skipped.
nvx policy checkfails when package.json or package-lock.json does not parse. It warned and exited 0 having checked no dependency. It now reports aninternal_error(exit 1). Run from a subdirectory, it also reads the project root's files, as the package manager does, instead of finding none.
-yand--agent-modeno longer approve a persistent tool profile. The help says onlyNVX_TRUST_YESapproves trusting a tool, and this one prompt was answered by the ordinary-y.
- The prompt to trust a project policy says what the file loosens. It named the file only. It now lists each setting with its value before and after, for example
typosquatting.enabled: true -> false.
- A policy key in the wrong case is no longer reported as ignored.
{"Isolation": {"Enabled": false}}switched containment off, because JSON keys match in any case, while nvx warned the key was "being ignored". It now says which setting the key applies to and asks for lowercase.
nvx policy initin a project no longer overrides the global policy. It wrote every default into.nvx-policy.json, so under a stricter global policy the file loosened it, and under an enforced one every command in the project was refused. It also replaced the runtimes' own default hosts. The project file it writes now sets nothing until you add to it.
- An enforced global policy is not widened by hosts approved earlier. Hosts a project had approved at a prompt were added after the enforcement check, so they reached the network past the baseline. Under enforcement nvx now drops them and says so once.
allow_read_execrefuses an entry that would grant a whole drive or home. An entry using an unset variable collapsed to a filesystem root:%UNSET%\becameC:\and$UNSET/became/.~alone granted the whole home directory. These are now refused with a warning, as is a directory that holds the nvx home.
- A version range with a space after the operator is accepted.
">= 18", common in package.json engines, failed with "empty version". The error for a range that really cannot be read now names the text.
- The version-pin warning no longer reports npm's version as node's. With a
.nvmrcasking for 22, annpmcommand warned it was "running 10.9.2", which is npm's own version.
- The quickstart no longer promises read containment on macOS. It said installs run with "no access to your keys" on every platform. The macOS sandbox does not contain reads, so there it now says what holds.
nvx use --shell bash 20switches to 20. It tookbashas the version.
nvx grants listsays when the grant record cannot be read. It printed "(none)" for every kind of grant, which reads as nothing granted.
- The help names every
--filesystem-provider. It listed native and docker and left out sandbox-exec, the macOS one.
nvx importasks about only the versions it would download. Its prompt counted versions nvx already had.
nvx policy explainno longer cuts a character in half. A long value was shortened by bytes, which split a non-ASCII character and printed invalid text.
- The Docker check has a time limit.
docker inforan without one, so a daemon that accepted the connection and never answered held the command with no output. It now gives up after 15 seconds.
npm install --location=globalandbun add -gare refused up front. They are global installs likenpm install -g, and went into the sandbox instead of getting the same clear refusal.
- A cached command path must name the command. The cache of resolved command paths accepted an entry for
nodethat pointed at any program in a PATH directory. It now requires the file name to match. Its temporary file also has a unique name, so two nvx processes saving at once cannot rename each other's half-written file into place.
nvx audit --limit 5works like--limit=5. Export already took both spellings. An over-long last line with no newline after it is now counted as malformed rather than dropped without a word.
nvx use 99no longer offers to install a version that does not exist. It asked whether to download and install Node.js 99. It now checks the release index first and says no published release matches.
--helpafter any command prints that command's help.nvx install --helpprinted help andnvx list-remote --helpfailed with "Unknown option". Commands without a page of their own now print their entry fromnvx help.
nvx doctorprints its PATH fix in Git Bash syntax under Git Bash. On Windows it always printed the PowerShell form, which bash cannot run.
- A contained
spawnkeeps the stdin descriptor its caller passed in. In the Windows sandbox,spawn(cmd, args, {stdio: [fd, 'pipe', 'pipe']})closedfdonce the child started, so a file the caller opened and handed to the child as stdin could not be read again. The sandbox now closes only the descriptors it opened itself, and removes the temp folder behind an empty stdin when the child closes.
- Two installs that find the same abandoned lock no longer both proceed. nvx clears an install lock left by a process that has gone. On Linux and macOS two waiters could both read the dead owner, and the second removed the lock the first had just taken, so both extracted into one directory. Clearing a lock is now serialised.
- On macOS a SIGTERM sent while nvx starts the sandboxed command reaches that command. nvx installed its signal handler after starting the child, so a signal in between killed nvx and left the child running. The handler is now in place first.
- A slow disk no longer reads as a stalled download, and a stall can no longer crash nvx. The stall timer ran between reads too, so time spent writing the archive counted as the network going quiet. If it fired, a read that then returned data re-armed it, and a second firing crashed the process. The timer now runs only while nvx waits for data, and fires its signal once.
- A version name ending in a dot is refused. Windows drops trailing dots from a path component, so
v20.names thev20directory and...names the versions folder itself. On Windows, listinga\...returned the contents ofa. No real version ends in a dot.
- A socket path too long for Linux says so. A deep
NVX_HOMEmade the sandbox's egress and--connectsockets fail with a bare "bind: invalid argument". nvx now reports the path's length against the 107-byte limit and says to setNVX_HOMEto a shorter directory, as it already did on Windows.
- install.sh refuses a CPU it has no build for. On armv7l, i686, riscv64 or any other CPU it installed the x86_64 binary, which cannot run there. It now stops and names the architecture.
- install.sh says so when it has no way to check the download. With neither sha256sum nor shasum installed it reported a checksum mismatch. It now looks for one before downloading and says which to install.
- install.sh no longer writes lines fish cannot read. For a fish user it added POSIX lines to
~/.profile, which fish never reads, and reported the profile as updated. It now prints thefish_add_pathcommand to run.
- The one-line Windows install leaves your PowerShell session as it was. Run as
irm ... | iex, install.ps1 left$ErrorActionPreference = 'Stop', a TLS 1.2-only connection setting, and its own variables and functions in the window it was pasted into. It now runs in a scope of its own and puts the TLS setting back.
- Homebrew and Scoop releases are checked against their build provenance. Only the npm publish checked that a binary was built by
release.yml. The Homebrew and Scoop jobs trusted a.sha256file from the same release page as the binary, so a binary replaced there together with its checksum would have been published. All three now require the attestationrelease.ymlmade for the binary.
nvx grants reset --allworks after a grant has been recorded. It read the lock file kept beside each grant record as a record of its own, failed to parse it, exited 1 and said to remove permissions with icacls by hand, on every run after the first grant. It now skips lock and temp files, and both reset forms hold the record's lock while they read, withdraw and delete it, so a grant saved at the same moment is not deleted with it.
nvx doctorno longer calls a bypassed command healthy. It listed[FAIL] npm -> ... (bypasses nvx)and then said "nvx is intercepting commands correctly" and exited 0, because it only counted nvx's own runtime folders as shadowing. A system Node earlier on PATH, the usual Windows layout, now makes doctor exit non-zero.
- Every spelling of an install is contained and checked. Plain
yarnandyarn --frozen-lockfile(yarn's default command installs),npm x,npm clean-installandic,npm it,citandsit,npm rb, and npm'sisntalandudpatetypo aliases ran as your own code: no sandbox and no pre-install checks. They now run as the install or tool run they are.
exec()andexecFile()no longer hang inside the Windows sandbox. node's own versions call a spawn the sandbox's preload could not reach, so they took the path that blocks forever before the child exists. A containedexec('cmd /c echo hi', cb)never called back, and neither did a timer set before it, while the same call uncontained answered in 300ms. node-gyp finds Python this way, and many install scripts shell out the same way. Both are now rebuilt on the sandbox's working spawn, with the same callback, error, timeout, maxBuffer and promisified behaviour as node's. A streamed child'scloseevent also waits for its output again: it fired when the child exited, while nvx was still passing the output along, and a CI run saw 1 line of 200 arrive by then.
- A contained command started in your home directory can no longer write it. The working directory is writable inside the sandbox, and nothing checked which directory it was. From
~or/, where editors often start MCP servers, a contained process could write~/.nvx(its grants and policy, so the next run's trust) and~/.bashrc. Measured on Linux and on a macOS runner: from a project all three writes were refused, from the home directory all three landed. nvx now starts such a command in the sandbox's home and says why. The same rule applies on Windows to a directory above the profile or inside~/.nvx. The Linux and macOS enforcement scripts check it on every CI run.
- Windows: granting the sandbox access no longer opens your profile to other accounts. Every permission nvx wrote on a folder switched that folder's inheritance protection off. Windows ships
C:\Usersand each profile folder protected, so they do not take the drive root's "Authenticated Users: Modify". Onenvx setupgrant onC:\Users, or one traverse grant on a profile, lifted that, and every signed-in account on the machine could then read and change the whole profile. nvx now keeps a folder's protection as it found it, andnvx doctorreports a profile, or the folder above it, that has lost its protection, with theicacls ... /inheritance:rcommand to restore it when the folder's own entries keep you in.
- The one-line Windows install works.
irm https://nvx.run/install.ps1 | iexstopped every time with "Cannot bind argument to parameter 'Path' because it is an empty string": the script read its own directory, whichiexdoes not have. It had already edited PATH and the PowerShell profile by then. The installer now downloads and verifies nvx first and changes nothing if that fails, and CI runs the whole script throughInvoke-Expression. It also no longer offersnvx setupat the end with a warning that package managers "run without OS isolation" until you do. That was false: installs andnpxrun contained without it.
- The Linux sandbox runs the system's
ipandiptables, not the first ones on your PATH. It set a system-only PATH for the child, which does not change which binary starts: that is looked up in nvx's own PATH. They are now taken from/usr/sbin,/usr/bin,/sbinand/binonly, as Windows already does for its system tools.
- A contained process can no longer hold nvx's egress proxy open by sending nothing. The proxy waited indefinitely for a request's headers; it now allows 5 seconds for the handshake, the same bound the Linux loopback redirect uses, and none once the tunnel is open.
--connectworks innetwork.mode: loopbackon Linux. It was refused on the grounds that the mode denied the sandbox every IP socket, which stopped being true when loopback moved to the proxy filter on 2026-09-08. Measured 2026-09-25 in WSL: the previous binary refused the flag; this one carried a request to a service on the host's 127.0.0.1:7788 and got its reply.
- Bun accepts version ranges, and
^0means what npm means.nvx install bun@^1.1, and anyengines.bunrange, failed with "no Bun release matches" because Bun's resolver took only exact versions and prefixes; it now takes the same ranges Node does.^0and^0.0allowed only 0.0.0; they now mean<1.0.0and<0.1.0, as in npm.
network.mode: offlinemeans no network, allowlist included. The egress proxy checked the allowlist before the mode, so an offline run that reached it got every allowlisted host, and on Linux its socket was offered in offline mode with only seccomp in the way. The proxy now refuses everything in offline mode, and Linux no longer offers the socket there, as Windows already did not.
nvx import fnmfinds fnm's Node versions. fnm keeps them in anode-versionsdirectory under its base directory, and the import looked in the base directory itself, so on a standard fnm install it found nothing. It now readsnode-versionsunderFNM_DIR, the platform data directory,~/.fnm, and on macOS~/Library/Application Support/fnm.
nvx uninstallno longer removes the Node version your shell is using when Bun comes first on PATH. The guard read the first nvx runtime on PATH whatever it was, so with Bun ahead it compared Bun's version and let the active Node go. It now checks Node's own entry, as Bun's uninstall already checked Bun's.
- Smaller fixes.
nvx importexits 1 when every install it tried failed. A truncated download of the typosquat package list is no longer cached as the whole list, and the cache is written atomically. A failure to write the audit log is reported once instead of silently dropped.--connectrefuses to start when it cannot pick an in-sandbox port, instead of advertising port 0.
- A policy can no longer pass
GH_TOKENorSTRIPE_SECRET_KEYinto the sandbox.isolation.environment.allowrefused credential-looking names by their start only (GITHUB_,AWS_, ...), so names whose secret-ness is at the end got through:GH_TOKEN,SENTRY_AUTH_TOKEN,STRIPE_SECRET_KEY,PGPASSWORD. Names containing TOKEN, SECRET, PASSWORD, PASS, CREDENTIAL or APIKEY as a word, API_KEY / ACCESS_KEY / PRIVATE_KEY, or ending in TOKEN, SECRET or PASSWORD are now refused the same way.TOKENIZERS_PARALLELISM,MAX_TOKENSandAUTH_URLstill pass.
- A failed install no longer closes your PowerShell window or removes your nvx.
irm ... | iexended withexit, which closes the session it runs in, so the error vanished with the window; it now reports the error and leaves the window open.install.shdownloaded over the existing binary and deleted it when the checksum did not match, leaving no nvx; it now verifies the download beside it and replaces nvx only on a match.
npm cispends less time in nvx's package checks. Every lockfile entry is checked against the registry, and those requests went one at a time. They now run eight at once, ahead of the checks, which still ask their questions one at a time and in order. Measured 2026-09-24 on a 651-entry lockfile withnpm ci --dry-run: 34.5 s and 32.7 s before, 11.0 s to 13.1 s over four runs after.
- Old staged copies of commands are cleaned up on Windows. A contained command from outside nvx's own runtimes, such as a system Node or Bun, runs from a copy of its whole directory, and every update to it left the previous copy behind for good. The largest of four on the development machine was 31,814 files and 451 MB. Copies whose command has changed are now removed, one after each contained command and all of them by
nvx cleanup. A copy something is still running is left until it stops.
- Only a runtime's own files are copied for the Windows sandbox. The copy of a system Node or Bun was the command's whole folder, and every sandbox on the machine can read it, so anything kept beside the runtime went with it. nvx now copies the executables, the npm and npx wrappers and
node_modules, and refuses a command whose folder has nonode.exeorbun.exerather than copying it. node, npm and npx from one install now share one copy: they made three before, 1.6 GB each for the nvm install on the development machine. Existing copies are replaced on next use and the old ones pruned.
- The Linux sandbox's network filter covers x32 and io_uring. It matched system calls by their x86-64 numbers only, so the same call made through the x32 ABI or submitted through io_uring went past it. On a kernel with x32 enabled, a contained program in
network.mode: offlinecould open a TCP socket and connect to nvx's in-sandbox relay. It reached nothing beyond that, because the relay's own outbound connection was still refused. Calls from a foreign ABI are now refused, and io_uring reports itself unavailable, as it does on a kernel built without it.
nvx defaultworks when the home path contains&. On Windows it made its junction throughcmd /c mklink, and cmd.exe split the path at the&and ran the rest as a command. With a home likeC:\Users\A&B, the text after the&ran and the default was never set. nvx now writes the junction itself.
- The Windows installer no longer leaves a binary that failed its checksum. A download whose SHA-256 did not match stayed in
~/.nvx/binafter the installer reported the failure, and-InsecureSkipChecksum, meant for a release with no checksum file, installed it. The download now goes to a side file and replacesnvx.exeonly after it verifies, so a failed upgrade also leaves the previous binary working. A checksum that is present and wrong fails with or without the flag.
- A package can no longer put its own
gitahead of yours. nvx refuses to wrap anode_modules/.binentry whose name already resolves elsewhere on PATH, and the check stopped at the first match. Inside any npm script that first match is the project's ownnode_modules/.bin, so a file a contained install dropped there asgitwas taken for the project's copy and wrapped onto PATH ahead of the real one. The nextgittyped in that project ran it outside the sandbox. The check now looks past every directory inside the project. Measured 2026-09-23 on Windows: the same planted file is no longer wrapped,gitresolves to Git for Windows, and an ordinary project CLI is still wrapped.
- Contained commands on Linux can write to
/dev/null. It was granted read-only, so>/dev/nullin any shell script failed, and so did every Node spawn withstdio: 'ignore', which opens it for writing. Measured on Linux 6.18: both failed with EACCES inside the sandbox before, and both work now. The other devices stay read-only.
- The Linux sandbox forks the contained command from the thread it restricted. Landlock, no-new-privs and the private
/procmount each apply to one OS thread, and nothing kept nvx on that thread, so the command could start from another one with none of them in force. This was not reproduced through nvx itself. The same sequence in a standalone program on Linux 6.18 let 164 of 300 children create a file Landlock should have refused, and 0 of 300 once the thread was pinned, which nvx now does.
yarn installruns inside the Windows sandbox. yarn classic fetches fromregistry.yarnpkg.com, a front for the npm registry, and that name was not on the default allowlist, so every containedyarn installwas refused on its first fetch and gave up after four retries. It is allowed by default now, next toregistry.npmjs.org. Measured 2026-09-17 with yarn 1.22.19: a bare install of one dependency exits 0, and so does the second run.
- A tool on Node 18 can stat nvx's own directories from inside the Windows sandbox. The entry nvx writes on the directories above a contained command's home let it pass through them and read their attributes, but not the SYNCHRONIZE right that every CreateFile asks for. A runtime that opens a directory to stat it, which libuv did until 1.44, got EPERM on
~/.nvxand~/.nvx/sandbox_home; newer runtimes list the parent instead and never noticed. pnpm's standalone binary bundles Node 18.5 and died on that stat before doing anything. The entry carries SYNCHRONIZE now, and~/.nvxitself gets one, written without the propagation over everything beneath it that used to time out: 22.3 s for the propagating write against 1.07 ms without, measured back to back. A firstpnpm installin a fresh project exits 0. A second one still does not, for a reason no permission fixes; see Known limitations on the docs site.
- A project directory deleted and recreated no longer fails to launch on Windows. nvx remembered for seven days which directories already carried its sandbox permission, in
~/.nvx/grant-cache.json, and trusted that record without looking at the directory. A fresh clone into the same path, a CI workspace, or a new worktree has no such permission, so the grant was skipped, nothing was logged, and the contained process could not enter its own working directory:AppContainer launch failed ... The parameter is incorrect. Every package manager failed this way, npm included. Reproduced with the previous binary on 2026-09-17 by deleting and recreating a project directory between two runs.
The record is gone. Every check reads the directory's real permissions, which was measured at under a millisecond a path; warm launch times before and after the change were within run-to-run noise of each other. The old cache file is no longer read and can be deleted.
- Contained commands work again from inside AI agent shells on Windows. Every contained launch asked Windows for
CREATE_BREAKAWAY_FROM_JOB, and a process inside a job object that forbids breakaway — which is how Claude Code, Codex CLI and similar harnesses run every command — is refused with a bareAccess is deniedbefore anything is created. From an ordinary terminal the same command worked, which is why it read as a machine problem for weeks: memory, disk, ACLs and a security product were each ruled out on the way to measuring it directly (2026-09-20: plaincmd.exefrom such a shell — fine without the flag, denied with it). nvx now asks to break away only where the calling process's job permits it. A child that stays in that job is still reaped through nvx's own nested job.
- A command the sandbox refused to run is no longer logged as having run inside it. The run record's mode is decided before the sandbox is asked to start, and nothing corrected it when the start failed, so
nvx auditshowedsandboxed npm install exit=1for a command that never began — the same line a fully contained install failing on its own terms produces. Measured on 2026-09-20 against a host that could not launch an AppContainer at all. Those runs now readrefused, and carry the reason.
runSandbox's own refusals — an unknown filesystem provider, a provider that cannot enforce the requested network mode, an egress proxy that would not start — wrote nothing to the audit log at all. They now record a reason like every other refusal does.
- The test suite no longer writes nvx's shell integration into your real PowerShell profile.
nvx doctor --fixrepairs two things a throwawayNVX_HOMEdoes not contain: the persistent PATH, and the shell profile. The PATH write was given a test seam after it was caught prepending dead temp directories to real user PATHs. The profile write was not, and kept going.
Redirecting HOME does not reliably contain it. On Windows nvx asks PowerShell for $PROFILE, and where that lands depends on the machine: a CI runner's PowerShell follows the redirected home, while one whose Documents folder is redirected to OneDrive does not and answers with the real profile. A test cannot tell the two apart, so any test reaching doctor --fix could append the integration line outside its own temporary directory.
It is plainest in CI, where the runner starts clean: the Windows job's unit-test step logged Added the shell integration to C:\Users\runneradmin\Documents\PowerShell\Microsoft.PowerShell_profile.ps1, and every later PowerShell step in that job then printed The term 'nvx' is not recognized at startup, loading a line a test had planted.
The write is now replaceable in tests, the way the PATH repair already was, and the tests that run doctor --fix replace it. Nothing about the shipped behaviour of nvx doctor --fix changes.
The check that keeps it that way parses the test sources rather than matching them with a pattern. A review caught the pattern version passing in two cases, both then reproduced: a caller written the ordinary way for this suite, runDoctor(tempDir(t), true), never matched at all, because the expression could not cross a nested bracket; and the stub was looked for anywhere in the same file, so one careful test excused every other caller beside it. It now looks per function, fails when it finds no callers at all rather than passing by looking at nothing, and covers the remaining route — a test that runs the built binary, where an in-process substitute cannot reach.
Two reasons it went unnoticed on developer machines, both accidents rather than protection: under Git Bash MSYSTEM is set, so nvx picks bash and the PowerShell branch never runs, and a developer's profile usually already loads nvx, so the check short-circuits before writing.
- The Windows installer no longer changes your PowerShell execution policy without asking. It set the policy to RemoteSigned behind a progress line, with
-Forceand errors suppressed. That is the setting PowerShell uses to decide what code it will run, and an installer should not move it on your behalf; suppressing the error also meant a failed change read exactly like a successful one, leaving the shell integration dead with nothing saying why.
It now explains what the change does and why nvx wants it, asks, and reports what actually happened. Declining still installs nvx, and prints the one command to run later. A non-interactive run changes nothing.
It also asked the wrong question. The check read the CurrentUser scope, which is Undefined on any machine whose policy is set elsewhere — measured on a developer machine on 2026-09-11: CurrentUser Undefined, effective RemoteSigned, scripts running fine. It now reads the effective policy, so a machine that is already fine is left alone.
build-release.ps1stamped builds with a version from eight tags ago. Its-Versiondefault was the literal0.5.0, written once and never revisited, so any local build since has reported a version it was not. The default now comes fromversion.go, which a test already holds equal to the newest changelog entry, so the binary, the changelog and the build script cannot disagree. Published releases were never affected — those are built by the release workflow, which takes the version from the git tag.
- Windows: a contained launch could be refused because the machine briefly could not create a process.
prepareAppContainerFilesystemlabels the guest home by runningicacls, and when Windows momentarily runs out of handles that call fails atfork/execwithThe handle is invalid— the command never starts. nvx reported it as a launch failure, so the sandbox refused to run for a condition that clears by itself.
Measured on a hosted runner on 2026-09-09, in the same second that AppContainer launches were being refused and two probe children returned no output at all; the same commit re-run was clean. nvx already treated this exact error as transient when reading the staged probe child, and as fatal when creating a process — that asymmetry is what this closes.
Retried five times at 200ms, the shape already used elsewhere, and only when the error says the process was never created (fork/exec plus ERROR_INVALID_HANDLE). That is what makes re-running safe whatever the command would have done. A missing executable also fails at fork/exec and is still reported at once rather than after five waits, and the errno is matched rather than the English text, which differs on a localised Windows.
blocked_packagesunderstood only a trailing*. Every other policy list goes through one shared matcher that takes*and?anywhere; the blocklist had a matcher of its own that recognised a literal name or a trailing star and nothing else. So"*-malware"and"evil-?-pkg"parsed, validated, produced no warning, and blocked nothing. The asymmetry ran the wrong way -- the lists that widen access understood more syntax than the list that withdraws it. The blocklist now uses the shared matcher.
- Approving a registry-metadata failure also gave up the vulnerability scan, without saying so. When nvx cannot resolve a package's metadata it asks whether to proceed; approving skips the rest of the checks for that package, including the OSV advisory lookup, because advisories are queried by exact version and the version is what could not be resolved. The question named only "metadata checks", so a run could report nothing about a package it had never asked about. nvx cannot scan without a version; the prompt and the warning now say that is what approving costs.
- A zsh user is now treated as a zsh user. With no
--shellgiven, nvx on Linux and macOS chose bash unlessSHELLnamed fish. Someone on zsh, the macOS default, who rannvx use 20without the integration was told to add the line to~/.bashrc, andnvx doctor --fixwrote it there, where zsh never reads it. nvx now selects zsh whenSHELLends inzsh. The hint names~/.zshrcandnvx doctor --fixwrites to it.
nvx doctor --fixwrites the same fish file as the installer. For fish it wrote only thenvx env --shell=fish | sourceline. The installer'sconf.d/nvx.fishalso puts~/.nvx/binonPATHfirst, and without that fish cannot findnvxwhen the line runs. doctor now writes the installer's whole file. A file that already loads nvx, in either form, is left alone, so one an earlierdoctor --fixwrote keeps the line-only form until you delete it and runnvx doctor --fixagain.
- On Linux, the refusal for a long
NVX_HOMEnames the longest one that works. A socket path must be shorter than 108 bytes, and the refusal only said to use a shorterNVX_HOME, leaving you to guess how much shorter. It now saysSet NVX_HOME to a directory of at most N characters (it is M), as the Windows refusal does. N leaves room for the longest socket the run creates, so following it does not meet a second refusal. The loopback socket used to fail with a barebind: invalid argumentand now gets the same check. Where the sockets live on Linux has not changed.