std-env

Use std-env to identify the current execution environment (e.g., Node.js, Bun, Deno, or Workerd) following the WinterCG Runtime Keys proposal.

Strict vs. Compatibility Checks:

• Use runtime === 'node' for a strict check to ensure you are specifically in Node.js.
• Use isNode if you want to include Bun or Deno when they are running in Node.js compatibility mode.

Available named boolean exports include isNode, isBun, isDeno, isNetlify, isEdgeLight, isWorkerd, and isFastly.

import { runtime, runtimeInfo } from "std-env";

console.log(runtime); // "" | "node" | "deno" | "bun" | "workerd" ...
console.log(runtimeInfo); // { name: "node" }

Identify if the code is running in a Continuous Integration (CI) environment and which provider is being used (e.g., GitHub Actions) by inspecting environment variables.

Use detectProvider() if you need to re-run the detection logic manually.

import { isCI, provider, providerInfo } from "std-env";

console.log({ isCI, provider, providerInfo });
// { isCI: true, provider: "github_actions", providerInfo: { name: "github_actions", ci: true } }

Determine if the environment is being operated by an AI coding agent.

Manual Override: You can explicitly specify the agent name by setting the AI_AGENT environment variable.

Supported Agents: cursor, claude, devin, replit, gemini, codex, auggie, opencode, kiro, goose, pi, junie.

Use detectAgent() to re-run detection.

import { isAgent, agent, agentInfo } from "std-env";

console.log({ isAgent, agent, agentInfo });
// { isAgent: true, agent: "claude", agentInfo: { name: "claude" } }

Access environment variables and process-like objects in a runtime-agnostic way.

| Export    | Description                                          |
| --------- | ---------------------------------------------------- |
| `env`     | Universal `process.env` (works across all runtimes)   |
| `process` | Universal `process` shim (works across all runtimes) |
| `nodeENV` | Current `NODE_ENV` value (undefined if unset)        |

Access boolean flags and platform metadata to conditionally execute code based on the environment, OS, or mode (development/production).

import { env, isDevelopment, isProduction } from "std-env";

Use detectProvider() to identify the current CI/CD or deployment environment. It returns a ProviderInfo object containing the provider's name and metadata. Alternatively, you can import the provider constant for a quick string representation of the detected provider name.

Supported providers include a wide range of services such as github_actions, gitlab, vercel, netlify, cloudflare_pages, deno-deploy, and many others. If no provider is detected, the name will be an empty string.

import { detectProvider, provider } from "std-env";

// Method 1: Get full info object
const info = detectProvider();
console.log(info.name); // e.g., "github_actions"

// Method 2: Get just the name
console.log(provider); // e.g., "github_actions"

The process constant provides a runtime-agnostic reference to the process global. If globalThis.process is available, it returns that object. If not, it returns a minimal shim containing only the env object. This is useful for maintaining compatibility with code that expects a process-like interface.

import { process } from 'std-env';

// Accessing env through the shimmed process object
const debugMode = process.env?.DEBUG === 'true';

For simple conditional logic, use the exported boolean flags to check if the code is running in a specific environment.

Important Note on Node.js Compatibility: When running in Bun or Deno using Node.js compatibility modes, the isNode flag will be true. If you require a strict check specifically for the Node.js runtime, compare the runtime constant against the string "node" instead.

import { isNode, isBun, isDeno, isFastly, isNetlify, isEdgeLight, isWorkerd, runtime } from "std-env";

if (isBun) {
  // Bun-specific logic
}

// Strict Node.js check (avoids false positives from Bun/Deno compatibility modes)
if (runtime === "node") {
  // Only runs in actual Node.js
}

if (isNode) {
  // Runs in Node.js OR Node-compatible runtimes (like Bun/Deno)
}

The nodeENV constant provides the current value of the NODE_ENV environment variable. If NODE_ENV is not set in the environment, this value will be undefined. This is a convenient way to check for environments like development, production, or test without manual lookup.

import { nodeENV } from 'std-env';

if (nodeENV === 'production') {
  // perform production-only logic
}

Identify the JavaScript runtime executing your code.

Runtime Checks:

• isNode, isBun, isDeno
• isEdgeLight, isFastly, isNetlify, isWorkerd

Runtime Metadata:

• runtime: Returns the current RuntimeName.
• runtimeInfo: Returns detailed RuntimeInfo.
• detectRuntime: (via runtime logic) to identify the environment.