Skip to content

v0.14.0

Choose a tag to compare

@github-actions github-actions released this 13 Nov 02:49
· 152 commits to main since this release
29f6244

evnx v0.14.0

Read this first: what changes for scripts and CI. Each item has its own
entry below with the details and how to migrate.

  1. CI needs EVNX_KEY_BUNDLE for the cloud vault. Create it with
    evnx auth token create or evnx auth key-bundle; it is required once the
    server stops serving key material to tokens. Set it beside EVNX_TOKEN and
    EVNX_MASTER_PASSWORD.
  2. A vault id typed in upper case is stored in lower case. Versions pushed
    with an upper-case id open only with the same upper-case id, which only
    0.13.0 and earlier send: pull them with 0.13.0 and push again.
  3. migrate --to vercel prints the environment of the file it read
    (development, preview or production); it printed production for
    every file. If you ran it for a development or preview file, check Vercel
    production for development values.
  4. Vercel secrets are sensitive in development too, in convert --to vercel and migrate --to vercel.
  5. Backups no longer pile up: <file>.bak is replaced on each write, and
    old <file>.bak.<digits> copies are removed on the next write.
  6. convert output shapes changed: vercel and doppler print the
    shapes those tools read, terraform keeps the case of names (it lowercased
    them), and heroku is one heroku config:set call.
  7. More scan findings: names are checked in Dockerfiles, shell scripts
    and Python modules; notebooks are read cell by cell; ghs_ tokens in the
    new form are found; a secret under a public prefix (NEXT_PUBLIC_, VITE_,
    ...) is one severity level higher. A --severity high gate may start
    failing. validate has a new error, public_secret, and a new warning,
    partial_presence, for projects with several environment files.
  8. @evnx/cli has no postinstall: bin/evnx is a Node launcher.
  9. Each release carries a CycloneDX SBOM, evnx-<version>.cdx.json and its
    .sha256.

Added

  • evnx auth resend-verification (N14-5). Sends the verification email again
    for the signed-in account. It asks the server who you are first, so an
    already-verified account is told so and nothing is sent (the server's resend
    endpoint answers 202 for everything, by design). Rate limited (3 per hour per
    address) it exits 15 and says how long to wait; not signed in exits 10; an
    API token is refused. The "email not verified" error and auth status now
    point at this command.

  • Each release carries a CycloneDX SBOM (SEC-2). A new sbom job in
    release.yml runs cargo-cyclonedx (0.5.10, installed with --locked) with
    all features on and attaches evnx-<version>.cdx.json and its .sha256 to the
    GitHub release next to the archives. The SBOM gets a build provenance
    attestation like the archives; gh attestation verify works on it. The
    README's verify section says so.

  • CI: EVNX_KEY_BUNDLE replaces fetching key material with an API token.
    Create it with evnx auth token create or evnx auth key-bundle; it is
    required once the server stops serving key material to tokens. CI now sets
    EVNX_TOKEN, EVNX_MASTER_PASSWORD and EVNX_KEY_BUNDLE (or
    EVNX_KEY_BUNDLE_FILE, first line of a file). The bundle (evnxkb1_…) is
    your sealed keypair and Argon2 salt, with no plaintext secret in it; the
    master password still opens it. token create prints it with the token
    (--no-key-bundle skips it; -q prints the token only). Without a bundle a
    token still asks an older server once; a server that refuses gets exit 11 and
    a message saying how to make one. A bundle made before a master-password
    change says to regenerate it. auth status under a token shows the token's
    own info instead of "refused" when the server will not describe the account,
    and the post-quantum key backfill at login is skipped under a token. The
    high-water warning now also names an admin deleting the latest version.

  • evnx platform diff|pull --to vercel: compare and pull a Vercel project's
    environment variables
    (N14-10, phase 1; push is below, --prune comes later).
    diff prints a plan (+ add, ~ update, = unchanged, ! remote only,
    ! type differs) for a local .env.<env> against a Vercel environment, with
    --format json; exit 0 with no differences, 1 with some. pull writes
    Vercel's Config values into the local file, keeping comments, order and
    formatting. A Secret is write-only on Vercel: one whose key has a local
    value keeps it, one the file lacks is written as KEY= and listed, and diff
    can say only that it exists. Local-only keys are kept. pull shows the plan
    and asks first (--yes without a terminal, exit 4 on a no, --dry-run), and
    keeps the old file as .bak. Values are never printed. The project comes
    from --project/--team, then VERCEL_PROJECT_ID/VERCEL_ORG_ID, then
    .vercel/project.json; the token from VERCEL_TOKEN or --token-file (there
    is no --token flag). --env-name production|preview|development (default
    development) also picks the file (.env.<env> if present, else .env).
    Exit codes follow cloud: 10 token refused, 11 forbidden, 13 unreachable, 15
    Vercel error or a rate limit that did not clear after three tries. A pull
    records .evnx/platform/vercel.json (each variable's id, targets, type and
    updatedAt; no values, no hashes) for the later push; add .evnx/platform/
    to .gitignore. Needs the net feature; a build without it lists platform
    in the missing-features table.

  • evnx platform push --to vercel: create and update Vercel variables from the
    local file
    (N14-10, phase 2). It prints the plan (+ create, ~ update,
    = unchanged, ! type differs, ! remote only; never a value) and asks first
    (--yes without a terminal, exit 4 on a no, --dry-run sends no request that
    carries a value). A new key is created in one bulk POST with
    upsert=false: Vercel's upsert replaces a variable's whole target list, so it
    is never used. A Config whose value differs is changed by id with PATCH;
    a Secret that exists on both sides cannot be compared, so it counts as an
    update (--only-new skips those). A variable shared with other environments
    leaves this environment first (PATCH its targets) and gets its own entry of
    the same type, so the others are untouched. The type of a new key is the
    classifier's; a public prefix (NEXT_PUBLIC_, VITE_, …) is always Config;
    --type config|secret overrides it for new keys only. An existing variable
    keeps its type. Keys only Vercel has are kept (--prune is a later phase). A
    key with an empty value is never pushed, so pull followed by push cannot
    blank a Secret. failed[] is read on every create: any entry is exit 1 naming
    the keys and Vercel's error code, and the rest stays applied. A 429 waits for
    the reset and gives up after three tries (exit 15). Before it writes, push
    compares each variable it will change with .evnx/platform/vercel.json; if
    Vercel changed it since the last pull or push, nothing is written and the
    exit code is 14 (no state file: a warning, and it goes ahead). A push that
    wrote anything refreshes the state file. --format json prints one document.
    Response bodies are never printed (create and delete answers echo ciphertext).

  • evnx platform push --prune, custom environments and --git-branch (N14-10,
    phase 3). --prune lists the variables only Vercel has in this environment as
    deletions and deletes them by id after the confirmation (--yes is required
    without a terminal, checked before anything is sent; --dry-run sends nothing).
    A remote-only variable shared with other environments is not deleted: this
    environment is taken out of its targets instead (shown as detach). A key
    that is in the local file with an empty value (KEY=) is never pruned, and the
    delete answer, which echoes ciphertext, is never printed. --env-name <slug>
    now accepts a custom environment: the slug is looked up with
    GET /v9/projects/<id>/custom-environments, its variables are the entries whose
    customEnvironmentIds include it, a new one is created with
    customEnvironmentIds and no target, and the local file is .env.<slug> else
    .env. --git-branch <branch> (only with --env-name preview, else exit 2)
    selects that branch's preview entries, falls back to a key's all-branches entry
    for reading (labelled in the plan, never changed or deleted by the run; a
    differing value creates a branch entry beside it), and creates with gitBranch
    set. diff and pull take the same two flags. The state file keeps a separate
    record for a branch run (preview@<branch>) and for a custom environment.

  • SSL_CERT_FILE and SSL_CERT_DIR add trusted root certificates, so evnx
    works behind TLS-inspecting corporate proxies (RM-68). The bundled roots stay;
    the extras are added to them. SSL_CERT_FILE is a PEM bundle; SSL_CERT_DIR
    is a directory (or a path-separator list of them) of *.pem, *.crt and
    hashed (a1b2c3d4.0) files. A missing path or a file with no certificate is an
    error naming the variable and the path (exit 13 for evnx cloud); an
    unreadable file inside the directory is a warning. An unknown-issuer failure
    now says: set SSL_CERT_FILE to your organisation's CA bundle (PEM). Applies to
    cloud, update --check, migrate --to github-actions and scan packs.

  • validate and spec check report a name some environment files have and
    others lack
    (N14-12). A partial_presence warning ("EXTRA is in .env,
    .env.production but not in .env.staging"), until now visible only through
    sync --check and diff. A warning, so the exit code is unchanged unless
    --fail-on warning; silence it with --ignore partial_presence or
    [validate] ignore. It needs two environment files (.env and each
    .env.<NAME>; the template and .bak copies do not count), so a project
    with one sees no new finding and --env -/--input-format json are never
    compared. With a contract, a file is expected to lack a name declared
    required = false or limited by environments, and a name missing_variable
    already reports for the checked file is not repeated. spec check prints the
    same finding as a warning on stderr and keeps its verdict.
    For CI: a project with several environment files that differ on purpose
    gets new warnings in validate (summary.warnings, and the evnx-action
    validate-findings count if it counts warnings); add the type to the ignore
    list to keep the old count.

  • evnx remove --check NAME…: is it gone everywhere? (N14-11). Read-only
    and made for CI after a removal merges: exit 0 when no named variable (or
    quoted glob) is in any environment file, the template or the [vars]
    contract; exit 1 listing each file (and line) where one still is; exit 2,
    no verdict, when it cannot read a file whole. It always looks everywhere, so
    it takes none of the scope flags (--template, --contract, --all,
    --env-name) nor --dry-run, --yes, --ignore-missing or --no-backup.
    --json prints schema_version, check, clean, names, checked and
    present (name, file, kind, and lines or table); no value appears.

  • evnx sync --prune: remove stale names from the template (N14-11).
    sync only ever added; a name that every environment had dropped stayed in
    .env.example until someone edited it by hand. --prune compares the
    template (--example, [defaults] example, else .env.example) with .env
    and every .env.<NAME>, lists the names none of them has, and removes them
    after asking. It uses remove's editor and writer, so comments, line
    endings and everything else in the template stay byte for byte.

    • A name declared in .evnx.toml [vars] is never pruned: it is listed as
      kept, with the evnx remove NAME --template --contract that drops both.
    • --dry-run previews and writes nothing; --yes (-y, only with
      --prune) skips the question; no terminal without --yes is exit 2;
      answering no is exit 4. Only the template is written, and no .bak is
      kept for it (it is committed, as with remove --template).
    • Refused, with nothing changed (exit 2): no environment file, every
      environment file empty, or one that has a line evnx cannot read (a name
      could hide behind it).
    • It is a mode of its own: clap refuses --prune with --check, --format,
      --env, --env-name, --direction, --force, --placeholder,
      --skip-without-env, --template-config and --naming-policy.
  • A precision and recall gate for scan, run by cargo test (RM-70).
    tests/scan_corpus/ is a labelled corpus of 60 files: 37 whose secrets must be
    found, each labelled with its rule id and line, and 23 look-alikes that must
    not be (documentation keys, near-miss tokens, hashes, UUIDs, lockfile
    digests, base64 images, notebook outputs, placeholders, public keys, config
    references). tests/scan_quality.rs runs the real evnx scan over it and
    prints precision and recall overall, per family (cloud, vcs, payment, chat,
    keys, jwt, ai, saas, database, generic) and per file format. A drop in recall
    anywhere fails the build; so does a precision drop of more than 0.02. The
    committed numbers are tests/scan_corpus/baseline.json; move them on purpose
    with EVNX_UPDATE_SCAN_BASELINE=1 cargo test --test scan_quality -- --nocapture.
    No secret-shaped value is committed: the files are templates filled at test
    time from parts, and a test fails if one holds a value that matches a rule.
    In CI the table is also written to the job summary.

  • init's schema.json says how scan sees each secret variable (RM-91).
    A new scan section in src/assets/schema.json has an entry for every
    variable the catalogue declares that scan would treat as a credential, or
    that sits behind a browser-exposed prefix: the id of the rule that reports its
    value (stripe-live-secret-key, github-token, ...), heuristic when only
    the generic name and entropy checks would, or public when a prefix from
    PUBLIC_PREFIXES (NEXT_PUBLIC_, VITE_, ...) puts it in the client bundle.
    Additive: the rest of the file is unchanged. schema::loader::scan_view(name)
    reads it. tests/schema_scan_view.rs holds the section, rules.toml and the
    prefix list in step, and checks each claim against the scanner itself, so a
    renamed or removed rule, a dropped variable or a new prefix breaks a test.
    It needs no target-format catalogue (RM-61): the rule ids come from the rule
    definitions.

  • tests/invariants.rs: evnx accepts what evnx generates (F14-8, OW-17).
    Chains commands and feeds each one's output to the next: every init
    component and blueprint must validate (placeholders are the only error),
    doctor (no error) and scan (no finding) and parse; convert of a .env
    holding quotes, $, #, spaces, =, unicode, an empty value, a multi-line
    value and the words YAML reads as something else must read back to the same
    keys and values in every format (JSON, YAML, TOML and base64 parsed by their
    own readers, the script formats run under sh against stand-ins for
    gcloud, az and heroku); every migrate --print-only script passes
    sh -n; and sync, add and remove leave files that parse, with diff
    of a file against itself clean. Found one bug, fixed below.

  • Known-answer tests for every primitive and for evnx's own envelope (SEC-1,
    tests/crypto_kat.rs). The official vectors run against the crate versions in
    Cargo.lock: BLAKE3 hash, keyed hash and derive_key (the BLAKE3 team's
    test_vectors.json, vendored unchanged), HKDF-SHA256 (RFC 5869), X25519
    (RFC 7748), Ed25519 (RFC 8032), ChaCha20-Poly1305 (RFC 8439),
    XChaCha20-Poly1305 (draft-arciszewski-xchacha), AES-256-GCM (McGrew and
    Viega, Test Case 16) and Argon2id (RFC 9106). Golden vectors generated once
    from evnx-crypto 0.2.1 pin evnx's wire format: master-key derivation, the
    vault key wrapped under the master key, the blob (nonce || AES-256-GCM
    bound by vault_aad) and its BLAKE3 hash, an encrypted private key and the
    three public keys derived from it, and a hybrid X25519 plus ML-KEM-768 wrapped
    vault key. Changing any of them is a breaking protocol change. The tests live
    here because evnx-crypto is a separate crate evnx consumes from crates.io.
    Adds four dev-dependencies (chacha20poly1305, x25519-dalek, hkdf,
    ed25519-dalek) that are already in the build graph.

  • Local fuzz targets for the .env parser, the scan engine and decryption
    (SEC-1, fuzz/). A cargo-fuzz project of its own, outside every build and
    without a CI job: env_parser (every ParserConfig), scan_engine (one
    in-memory file read as .env, text, JSON, YAML, TOML or a Jupyter notebook)
    and crypto_decrypt (evnx-crypto on arbitrary ciphertext, wrapped keys and
    encodings, which must always return an error). fuzz/README.md says how to
    run them; fuzz/seeds/ holds small starting inputs. The directory is excluded
    from the published crate.

Changed

  • Repo files: CODEOWNERS, Dependabot grouping for cargo, a PR template
    (G5 to G7). .github/CODEOWNERS assigns the workflows, scripts, build script,
    manifests, .cargo/, Dockerfile, pyproject.toml and src/assets/ to the
    owner. The cargo entry in dependabot.yml groups minor and patch updates
    (open-pull-requests-limit stays 0, as documented there). The PR template asks
    what changed, how it was tested, and whether it touches workflows, scripts,
    build.rs or dependencies.

  • SECURITY.md states the support policy (RM-79). The latest minor gets fixes;
    the previous minor gets security fixes for 90 days after the next minor ships;
    older versions get none. It also states the minimum supported Rust version
    (1.87, the rust-version in Cargo.toml, checked by the CI MSRV job) and
    how it may change, and links to the security notices at evnx.dev/security.

  • scan reads files in parallel (RM-74). Files are scanned on all cores and
    reported in path order, so text, JSON, SARIF and GitHub output, the exit code
    and the notes on stderr are the same as before and the same at any thread
    count. RAYON_NUM_THREADS=N caps the threads (1 is the old behaviour).
    Measured on a 4,500-file, 51 MB tree on two cores: 9.4 s to 4.9 s with the
    built-in rules, 10.9 s to 6.2 s with the gitleaks pack. -v lines and
    evnx:allow warnings are now printed together after the scan rather than as
    each file is read.

Fixed

  • convert output shapes checked against each tool's documented input
    (RM-65, I-092, I-093, I-097).
    vercel prints the array of
    {key, value, type, target} that Vercel's create-environment-variables API
    takes, with type sensitive for a secret-looking name or value (the same
    classifier as platform). doppler prints the flat JSON object
    doppler secrets upload reads, not {value, computed} per name. terraform
    keeps the case of each name (it lowercased them) and lets --transform
    change it; A_B and a_b no longer collide. It still writes .tfvars
    values; the new --terraform-declarations writes a .tf of variable blocks
    instead, with sensitive = true and no default for a secret-looking
    variable, so no secret lands in a file people commit. heroku sets
    every variable in one shell-quoted heroku config:set A=… B=… call, so the
    app restarts once. doppler and vercel are no longer marked experimental;
    railway still is, because Railway documents no schema for its JSON import.

  • scan -v says names are checked in Dockerfiles, Containerfiles, shell
    scripts and Python modules.
    They print read as text: value patterns, and names in assignments; other text files keep value patterns only, names not checked. The JSON read_as stays text.

  • scan: false positives found by the RM-70 corpus (SCAN-FP).

    • A PEM or OpenSSH private key is one private-key finding; its base64 body
      lines are no longer also high-entropy-string.
    • The body of a PUBLIC KEY, RSA PUBLIC KEY or CERTIFICATE block, and
      the blob of an ssh-rsa or ssh-ed25519 public key line, are not
      reported: public material is not a secret.
    • CACHE_KEY, ETAG_KEY and IDEMPOTENCY_KEY holding a 32, 40 or 64 digit
      hex digest are identifiers, not credentials. Any other word in the name
      (CACHE_API_KEY, API_KEY, HASH_KEY) or any other value keeps the check.
    • A Stripe publishable key (pk_live_, pk_test_) is public by design and
      is not reported by name or by entropy. A secret key under NEXT_PUBLIC_
      is still reported.
    • YAML, JSON and TOML references are not values: a whole-value template
      ({{ .Values.apiToken }}, ${{ secrets.TOKEN }}), anything under a
      Kubernetes secretKeyRef or secretRef, and a lowercase secret name in a
      secrets: list (- db_password).
    • Names ending in _PASS (RABBITMQ_DEFAULT_PASS, DB_PASS) are password
      names, for scan and for masking. BYPASS_CACHE and COMPASS are not.
  • scan: names are checked in Dockerfiles, shell scripts and Python
    modules
    (SCAN-NAMES). A file read as text was judged by value alone, so
    ENV DB_PASSWORD=<random> (also ARG, the ENV KEY value form and
    continuation lines), export DB_PASSWORD="<random>" or DB_PASSWORD=<random>
    in a .sh, .bash, .zsh or #!-script, and DB_PASSWORD = "<random>" in
    a .py file scanned clean. Those assignments now get the name check, the
    placeholder, empty-value and reference filters a .env line gets, and are
    reported as sensitive-config-key on the right line. Never flagged: ARG X
    with no value, $VAR, ${VAR}, $(cmd), backticks, os.environ[...],
    os.getenv(...), settings.X, f-strings, empty strings and placeholders.
    Commented-out assignments are left to the value rules.

  • scan: the github-token rule matches stateless GitHub App installation
    tokens
    (SCAN-GHS). Since GitHub finished its rollout on 2026-10-02, ghs_
    tokens, the Actions GITHUB_TOKEN among them, are ghs_<appid>_<JWT> (about
    520 characters) and the classic 36 to 40 character shape missed them. The
    rule now has a second branch for that form and keeps the classic one. It is
    reported once, as github-token, not also as jwt or high-entropy-string;
    a trailing ., , or ) is not part of the match.

  • scan no longer flags the Neon sample URL init --with neon writes
    (F14-8). postgresql://user:password@ep-example-123456.<region>.aws.neon.tech/...
    was reported as a live connection-string credential, so a new project did not
    scan clean. A host with an example label is now a placeholder host, as
    localhost and example.com already were; user:password is still required,
    so a real host with those credentials, or a real password on an example host,
    stays a finding.

  • Monorepos: paths in .evnx.toml are read from the folder that holds it, and
    doctor notices nested .env files
    (F14-10, I-333, I-331).

    • A relative path in .evnx.toml means "from the folder holding this file",
      wherever evnx runs below it. That was already so for [defaults] example
      and [cloud] file; [scan] exclude patterns with a / now are too, so
      apps/web/fixtures/** excludes that folder from a scan run in apps/web.
      Patterns as written still match (a union), and a pattern with no /
      matches anywhere as before. Flags are relative to where you run.
    • doctor lists env files in subfolders (apps/web/.env, up to five, then
      "and N more") as info with evnx doctor apps/web as the hint; it checks
      only the folder you gave. node_modules, target, .git and other
      dependency, build and hidden folders are skipped, as init skips them.
      init already named a nested .env and touches none.
  • scan reads Jupyter notebooks cell by cell (F14-6, OW-4). A notebook is
    JSON, so a key in a cell or an output sat behind string escapes and was
    missed. Each cell's source (code and markdown) and each output's text,
    data["text/plain"] and traceback are now read unescaped, and a finding is
    located by cell: nb.ipynb:2 (cells[3].outputs[0].text), the line being
    within that cell or output. Image output is not read. A notebook that does not
    parse is scanned as text, as before. The baseline fingerprint of a notebook
    finding now includes its cell path.

  • platform pull: no more "already up to date" for a file that does not exist.
    When Vercel has nothing for the environment and the local file is absent, pull
    says nothing to pull; <file> not created (exit 0). An existing file with
    nothing to change still reads "is already up to date".

  • platform push: the plan says when it splits a shared entry. A row now reads
    ~ KEY secret update (split: Preview, Production keep their own entry; …), the
    summary counts N split (shared entry left), and --format json has
    summary.split and, per entry, split and keeps_shared_entry.

  • platform: the state file keeps one record per environment (PLAT-STATE).
    .evnx/platform/vercel.json held a single environment's record, so pulling
    production after development made a development push warn "no state" instead
    of stopping (exit 14) on a change made on Vercel. It now holds a record per
    project, team and environment, and a push checks only its own. The old
    single-record file is still read, and upgraded by the next pull or push.

  • Backups no longer pile up. Every command that keeps the replaced file as
    <file>.bak (platform pull, cloud pull, restore, diff --apply,
    validate --fix, remove) now keeps exactly one: <file>.bak is replaced on
    each write instead of becoming .bak.2, .bak.3, … Old numbered copies of
    that same file (<file>.bak.<digits>, nothing else: .bak.old and
    notes.bak.txt are never touched) are removed on the next write, with one line
    saying how many. .gitignore gets a single *.bak line, once, under the same
    --gitignore/--no-gitignore/--yes rules, instead of a question per copy;
    nothing is staged or committed. Because the backup is replaced, a second edit
    in a row leaves a copy of the first edit's result, not of the original.

  • platform diff: a Secret present on both sides is no longer a difference
    (F1). Vercel never returns a Secret's value, so such a variable made diff exit
    1 forever and the command was useless as a CI gate. It now prints as
    = secret present (write-only, not compared) and counts as unchanged for the
    exit code. diff --strict restores the old reading (an update, exit 1). In
    --format json the entry is "action": "unchanged" with "compare": "write_only", the summary gains present, and the document gains strict; no
    existing field was removed.

  • platform: a 403 that says invalidToken exits 10, not 11 (F2). The
    message is "the token is invalid or expired; create one at
    vercel.com/account/tokens" instead of a hint about the project and team. A 403
    without that flag stays 11.

  • platform diff with no .env.<env> and no .env compares against an empty
    local side
    (F3): every Vercel variable is "remote only", and a note says so,
    instead of exit 2. A --file that does not exist is still an error.

  • platform pull and push offer to add .evnx/platform/ to .gitignore
    (F4), the same yes/no question the env files get, on a terminal without
    --yes. --gitignore adds it without asking; otherwise the text hint stays.

  • evnx spec init wrote [vars.spring.datasource.url] for a variable with dots in its name.
    TOML reads that as nested tables, so evnx validate then reported Missing required variable: spring and unknown keys. Names that are not TOML bare keys (anything but A-Za-z0-9_-) are
    now quoted, as [vars."spring.datasource.url"], wherever evnx writes or prints a
    [vars.NAME] table (spec init, add, remove --contract messages and the validate
    hints). Bare names such as my-var and 9LIVES stay unquoted. A .evnx.toml already written
    with the unquoted form must be edited by hand: quote the name.

  • evnx migrate --to vercel printed production for a development file. With
    --env-name development (or preview) it read .env.development but every printed
    vercel env add said production, and the dry-run said Environment : production; every
    earlier version did this. The environment now follows the file that was read
    (.env.development/.env.dev is development, .env.preview is preview, anything else,
    including plain .env, is production). If you ran it for a development or preview
    file, check Vercel production for development values.

  • evnx add --help said a declined confirmation exits 0; it exits 4, as
    0.13.0 made it (the help text was not updated). It now lists 0, 2 and 4.

  • Vercel secrets are now sensitive in development too (convert --to vercel,
    migrate --to vercel). 0.13.0 kept them out of development because Vercel rejected a
    Sensitive variable there; Vercel reversed that rule on 2026-08-24 ("Secrets are allowed in
    Development", docs,
    changelog).
    convert --to vercel now gives a secret-looking variable all three targets (production,
    preview, development) and no longer prints the "not set for development" warning;
    migrate --to vercel adds --sensitive for development as for the other environments.
    The two commands agree again. --sensitive is the legacy spelling of the Secret type and
    still works.

  • A scan rule's names now beats a built-in rule in YAML and JSON too. A key such as
    app: secret_key: sk_live_… reported the built-in Stripe rule instead of the
    project's rule, because the text pass (no key) found Stripe and its remediation URL
    outranked the named rule; .env was already right. names stay case-sensitive regexes
    in every format, as in .env: write (?i) or both spellings to cover SECRET_KEY and secret_key.

  • Two remove (or sync --prune) runs on the same file can no longer undo
    each other
    (E-7). A run now takes an advisory lock file beside each file it
    writes (.evnx-<name>.lock, created exclusively, holding its process id)
    before it checks the file is unchanged and writes. The second run stops at
    once with exit 2, "another evnx (process N) is changing .env", and changes
    nothing; a lock left by a crashed run is taken over (the process is gone, or
    the lock is over ten minutes old). No locking crate is a dependency and
    File::lock needs Rust 1.89, so a lock file it is.

  • remove and remove --check say when two environment files differ only in
    case (.env.Staging, .env.staging): they are separate files except on a
    case-insensitive filesystem, and are never merged (G-2).

  • A secret under a browser-exposed prefix is worse, and says why (F14-5).
    VITE_, NEXT_PUBLIC_, REACT_APP_, EXPO_PUBLIC_ and the other prefixes
    scan already knew are inlined into the client bundle. scan now raises such a
    finding's severity one level (low stays low: a Maps browser key or a Sentry
    DSN is meant to ship), and validate has a new error, public_secret, for a
    secret-shaped value (a provider key, a private key, a password in a URL) under
    one of them; --ignore public_secret skips it. The prefix list is one list,
    shared with platform ... --to vercel (it gains STORYBOOK_, and matches in any
    case).

  • vault share takes --user as well as --with, and vault role and
    vault revoke take --with as well as --user (F14-7, OW-16): the member's
    email under whichever name you learned first. The aliases were already in the
    parser; this adds the test that holds them, so neither flag can be dropped by
    accident.

  • convert --to json and --to vercel warn, on stderr, when --exclude is used
    without --include (F14-9, OW-19). --exclude is a denylist, so a variable you
    did not think of is copied into a file that usually ends up in an app build or a
    web bundle (ANDROID_KEYSTORE_PASSWORD does not match *_SECRET*). The output is
    unchanged and the exit code stays 0; the warning says to list what may go there
    with --include.

  • cloud push reads the vault's current version after the password prompt and
    the Argon2id unlock, not before (CLOUD-409). The version it sends as
    base_version is now read just before encrypting, so the window in which a
    teammate's push makes yours answer 409 no longer includes a person typing a
    password. A wrong password also stops before any version request.

  • The cloud master password is read by utils::secret_source, as backup and
    restore read theirs (CLOUD-PW, the cloud half of B-WP3). --password-stdin,
    EVNX_MASTER_PASSWORD and the prompt behave as before, and the notice on
    stderr is unchanged. New: EVNX_MASTER_PASSWORD_FILE names a file whose first
    line is the password (nothing else is trimmed), read before the variable and
    announced without the value; a missing or empty file is an error. Changing a
    password (rotate-master-password) and login still always ask. Tests cover
    each source in order.

  • cloud warns when a vault's "latest" goes backwards (RM-89, a client-only
    slice of P6). The CLI remembers the highest version of each vault it has seen
    (pushed, fetched, or reported as latest) in high-water.json in the config
    directory: a vault id and a number, no name, key, value or hash. When the
    server later reports a lower latest (a version removed, a rollback, a restored
    backup), push, pull, run, diff and export print a warning on stderr
    naming both numbers and evnx cloud history. It is a hint and never stops
    the command; it is per machine, and vault delete forgets the vault.

  • A vault id typed in upper case is stored in lower case (C10).
    --vault 0B8A… was kept verbatim and bound into the encrypted version's AAD,
    while the server's id, which a pull by name uses, is lower case, so a version
    pushed by an upper-case id could not be pulled by name. The id is now
    lower-cased as soon as it is read, and an id is matched in any case against
    vault list. Pushes already made with an upper-case id: they were sealed
    with that spelling, so they open only with the same upper-case id, which only
    0.13.0 and earlier still send (evnx cloud pull --vault <the same upper-case id>). Pull them once with 0.13.0 and push again with this version; versions
    pushed from now on open by id or by name.

  • migrate keeps values off the command line where the tool allows it, and
    says so where it does not
    (K8). For aws-secrets-manager the printed
    commands now write the JSON to a private (umask 077) temp file through a
    quoted heredoc and pass --secret-string file://"$f", then remove the file,
    as the Azure commands already did: the values no longer show in ps or shell
    history, and the stored secret is exactly the JSON. heroku, doppler,
    infisical and railway take values only as arguments, so a one-line warning
    on stderr under the commands says they can show in ps and shell history and
    should be run on a trusted machine (-q does not hide it; > run.sh does not
    capture it).

  • Paid-user output gaps (F14-11, review F6, F7, F10, F11).
    cloud history names you as you (me@example.com) instead of you. A push
    by an API token is still recorded under its owner, so token versus person
    needs the server and is not done here. vault create prints one Next: line
    that stays true when cloud link is run after it, instead of a --vault hint
    that link then contradicted. A push into a production vault from the default
    .env shows its production warning once: the question when it asks, the !
    line only with --yes. auth status and cloud status print
    client evnx <version>.

  • @evnx/cli works where install scripts do not run (R6). pnpm 10+ and bun
    skip postinstall, so the placeholder bin/evnx (exit 1) was never replaced
    by install.js and evnx was broken there. bin/evnx is now a Node launcher
    that resolves @evnx/evnx-<platform>-<arch>/package.json, runs the binary next
    to it with the terminal attached, and forwards the exit code and any signal; a
    missing platform package gets a clear error naming --omit=optional.
    install.js and postinstall are gone. The global-install warning that
    another evnx comes first on PATH (RM-42) lived in install.js and goes
    with it; evnx update --list still lists every copy.

Installation

Linux / macOS (shell script)

curl -sSL https://raw.githubusercontent.com/urwithajit9/evnx/main/scripts/install.sh | bash

Homebrew (macOS and Linux)

brew install urwithajit9/evnx/evnx

Scoop (Windows, user-local)

scoop bucket add evnx https://github.com/urwithajit9/scoop-evnx
scoop install evnx

Winget (Windows, system-wide)

winget install urwithajit9.evnx

npm / Node.js

npm install -g @evnx/cli

Python (pipx)

pipx install evnx

Cargo

cargo install evnx --all-features

cargo install compiles from source with default = [], so plain
cargo install evnx gives you a binary without the auth,
vault and cloud commands. Every other channel above ships them
already — the binaries are built with --all-features.

Checksums

SHA256 checksums are provided for each binary. Verify after download:

sha256sum -c evnx-*.tar.gz.sha256

Provenance

Every archive has a signed build provenance attestation, which ties it
to the workflow run and commit that built it. Verify one with the
GitHub CLI (signed in with gh auth login):

gh attestation verify evnx-x86_64-unknown-linux-musl.tar.gz -R urwithajit9/evnx

SBOM

evnx-0.14.0.cdx.json is a CycloneDX software bill of materials for
this release: every crate in Cargo.lock, with all features on. It
carries a checksum (.sha256) and the same kind of signed attestation:

gh attestation verify evnx-0.14.0.cdx.json -R urwithajit9/evnx

What's Changed

  • ci: stop creating CLI-version releases on evnx-action by @urwithajit9 in #277
  • fix: v0.14.0 bug fixes (add help, Vercel environments, scan names in YAML, dotted spec keys) by @urwithajit9 in #278
  • feat(net): trust SSL_CERT_FILE and SSL_CERT_DIR roots (RM-68) by @urwithajit9 in #279
  • feat: sync --prune, remove --check, partial-presence warning, remove lock by @urwithajit9 in #280
  • feat(platform): evnx platform diff and pull --to vercel (sync phase 1) by @urwithajit9 in #281
  • feat(platform): push --to vercel, diff --strict, and P1 live-run fixes (N14-10 P2) by @urwithajit9 in #282
  • feat(platform): --prune, custom environments, --git-branch; one backup per file by @urwithajit9 in #283
  • fix: v0.14.0 small fixes — public-prefix secrets, cloud password and version checks, vault id case, migrate argv, npm launcher by @urwithajit9 in #284
  • feat(scan): notebooks, monorepo paths, parallel scan, precision/recall gate, schema scan view by @urwithajit9 in #285
  • fix(scan): stateless GitHub tokens, names in Dockerfile/shell/Python, corpus false positives by @urwithajit9 in #286
  • test: invariants, crypto known-answer vectors, fuzz targets (F14-8, SEC-1) by @urwithajit9 in #287
  • ci: pin apt jobs to ubuntu-24.04; build evnx.exe with a static C runtime by @urwithajit9 in #288
  • feat(cloud): CI key bundle (EVNX_KEY_BUNDLE), so API tokens no longer fetch key material by @urwithajit9 in #289
  • fix: verified convert outputs, release SBOM, security policy, resend-verification by @urwithajit9 in #290
  • chore(release): v0.14.0 by @urwithajit9 in #292

Full Changelog: v0.13.0...v0.14.0

npm / Node.js

npm install -g @evnx/cli          # global install
npx @evnx/cli --version           # zero-install usage
npm install --save-dev @evnx/cli  # project dev dependency