Oct 3, 2026·6 min read·10 visits
The Trigger.dev CLI v3 exposed plaintext environment variables and sensitive API keys in stdout during build deployments when debug logging was enabled. Upgrading to version v4.5.9 or later resolves the vulnerability by implementing a strict metadata-only allowlist log handler.
A sensitive information disclosure vulnerability exists in the Trigger.dev Command Line Interface (CLI) framework. When executing build processes inside CLI v3 packages, the framework's debug deployment logs print unredacted, resolved environment variables and secrets to standard output or log streams. This exposure occurs when the CLI is operated with a high logging verbosity level, enabling any individual or automated system with read access to build logs, CI/CD output consoles, or local development streams to capture plaintext sensitive parameters, such as database credentials, API keys, and private external integration tokens.
The Trigger.dev framework relies on background workers compiled at deployment runtime. The CLI utility manages compiling, bundling, and pushing these execution units to their respective orchestrators. Because background workers interface with numerous third-party systems, they require environment variables, database configuration profiles, and credentials. During compilation, the CLI v3 sub-package parses local files and remote configuration stores to establish compilation parameters.
A security advisory, identified as GHSA-FJ2X-MQQP-3V2W, details an information exposure vulnerability inside this build pipeline. The issue stems from verbose debugging logs produced by the build worker initialization routine. When developers execute deployment scripts with elevated debugging flags, the tool dumps configuration options directly to console output. This dumping behavior exposes highly sensitive variables and credentials.
The vulnerability resides in the @trigger.dev/cli package, specifically impacting CLI v3 packages located in packages/cli-v3. The primary attack surface exists anywhere console logs are recorded, including CI/CD output interfaces and logging platforms. Any actor or automated system with viewing permissions to these logs can capture plaintext secrets without additional authentication or authorization.
At the core of GHSA-FJ2X-MQQP-3V2W is a design pattern that directly serializes a broad configuration object without sanitization or selective parsing. The CLI’s compilation worker, initialized via the buildWorker function in packages/cli-v3/src/build/buildWorker.ts, consumes an object of type BuildWorkerOptions. This object serves as a comprehensive container for deployment targets, branches, path maps, and an envVars record storing key-value secret strings.
During development, logging statements were integrated at critical lifecycle points to assist with diagnostics and troubleshooting. A debug log entry was implemented using logger.debug("Starting buildWorker", { options }) to capture the worker's initial state. Because this logger accepts arbitrary objects and converts them to JSON, the entire configuration block, including the decrypted environment variables, was written to stdout.
This mechanism violates CWE-532: Insertion of Sensitive Information into Log File. The vulnerability becomes active whenever the log level is configured to capture debug statements, a common troubleshooting practice. The lack of an input-filtering or output-redaction layer allowed secrets to escape memory protections and enter persistent log streams.
The vulnerable implementation of buildWorker.ts highlights the risk of passing unvetted objects to logging interfaces. The original code path directly serialized the options parameter, writing it to the console. The following snippet illustrates this insecure logging pattern prior to remediation:
// Vulnerable implementation in packages/cli-v3/src/build/buildWorker.ts
export async function buildWorker(options: BuildWorkerOptions) {
logger.debug("Starting buildWorker", {
options, // Directly serializes the unredacted options block
});
const resolvedConfig = options.resolvedConfig;
// ... remaining compilation logic continues
}To address this, the maintainers separated logging concerns from the execution context. They created a dedicated file, packages/cli-v3/src/build/buildWorkerLogging.ts, and defined a strict schema for capturing parameters. The updated code maps and records only the counts of sensitive keys and safe configuration metadata.
// Patched implementation in packages/cli-v3/src/build/buildWorkerLogging.ts
import { logger } from "../utilities/logger.js";
type BuildWorkerLogOptions = {
target: string;
branch?: string;
envVars?: Record<string, string>;
rewritePaths?: boolean;
forcedExternals?: string[];
plain?: boolean;
};
export function logBuildWorkerStart(options: BuildWorkerLogOptions) {
logger.debug("Starting buildWorker", {
target: options.target,
hasBranch: options.branch !== undefined,
envVarCount: Object.keys(options.envVars ?? {}).length, // Captures only variable quantity
rewritePaths: options.rewritePaths ?? false,
forcedExternalsCount: options.forcedExternals?.length ?? 0,
plain: options.plain ?? false,
});
}This architectural change introduces an explicit structural allowlist. The main execution path in buildWorker.ts now calls logBuildWorkerStart(options) instead of writing raw configurations. This ensures that new configuration parameters added to the build sequence will not inadvertently leak secrets.
Exploiting this vulnerability does not require complex payloads or network exploitation techniques. It is a passive exposure scenario that relies on access to output buffers or log file stores. In typical enterprise setups, deployment commands are automated within CI/CD pipelines such as GitHub Actions, GitLab CI, or Jenkins.
To troubleshoot packaging or integration issues, administrators often enable verbosity flags such as trigger.dev deploy --log-level debug. When this occurs, the runner processes the CLI command, serializes the secrets, and outputs them to the runner's execution console. Any user or system with read-only access to the pipeline history can retrieve the plaintext credentials.
The risk is exacerbated when logging outputs are synchronized to third-party log aggregators, security information and event management (SIEM) engines, or public storage buckets. Because the logs contain structured JSON, automated scrapers can easily identify patterns such as STRIPE_API_KEY, DATABASE_URL, or OPENAI_API_KEY. Once harvested, these credentials can be used to pivot into deeper production architectures.
The security impact of GHSA-FJ2X-MQQP-3V2W is classified as severe information leakage. Because the CLI is used to compile backend workflows, the leaked secrets often represent highly critical credentials. This includes administrative database connection parameters, live payment processor integration keys, and cloud infrastructure service tokens.
Compromise of these secrets can result in full data exfiltration, service disruption, and financial loss. The vulnerability has an indirect but substantial impact on systems trust and regulatory compliance. Organizations subject to standards such as PCI-DSS or GDPR face immediate compliance failures if cryptographic keys or personal credentials are discovered in plain logs.
The CVSS score is established as 7.5 (High) under the assumption that the log outputs are stored in accessible build history consoles. The exploit maturity remains low since active external vectors are not required to trigger the leak. Security teams should treat any verbose log output generated before the patch as a potential breach and rotate all involved tokens immediately.
To resolve this security issue, organizations must immediately upgrade the @trigger.dev/cli package to version v4.5.9 or later. This release completely deprecates the raw serialization of build worker parameters in favor of the sanitized logging structure. Running standard dependency updates in the project's root folder will resolve the exposure.
# Upgrade commands for different package managers
npm install @trigger.dev/cli@latest --save-dev
pnpm add @trigger.dev/cli@latest -D
yarn add @trigger.dev/cli@latest --devIf immediate upgrading is not feasible, organizations should configure deployment agents to restrict log verbosity. Administrators must audit deployment configurations to verify that --log-level debug or verbose environments are disabled. Additionally, CI/CD platform features such as secret masking should be implemented to catch and redact sensitive strings.
Finally, security engineers must run retroactive log audits. Search historical log archives for the string "Starting buildWorker" and inspect the trailing JSON parameters. If plaintext database credentials or API tokens are discovered in the output history, those secrets must be rotated immediately.
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:N/A:N| Product | Affected Versions | Fixed Version |
|---|---|---|
@trigger.dev/cli Trigger.dev | < 4.5.9 | 4.5.9 |
| Attribute | Detail |
|---|---|
| CWE ID | CWE-532 |
| Attack Vector | Local / Log Access |
| CVSS | 7.5 (High) |
| Exploit Status | Proof of Concept (Unit Tests) |
| KEV Status | Not Listed |
The product writes sensitive information to log files, which can allow attackers to obtain credentials or other sensitive information.
CVE-2026-129297 is an origin validation vulnerability (CWE-345) in the Python library mail-parser prior to version 4.6.2. The MailParser.get_server_ipaddress() method fails to properly isolate MTA-recorded client IP addresses from sender-controlled text within email Received headers. Due to naive substring delimiter matching, appearance-based regular expression scanning, and fail-open header traversal, remote attackers can spoof their originating IP address to bypass email security controls, blocklists, and anti-spam attribution.
CVE-2026-129299 (GHSA-24mq-4vc6-2prf) is a parsing and serialization flaw in SpamScope mail-parser prior to version 4.6.2. The library uses reflective Python attribute resolution (getattr) over untrusted email header names and applies caller convenience transformations (such as underscore-to-hyphen folding and _json/_raw suffix stripping) directly to wire headers. An unauthenticated remote attacker can send crafted emails that trigger uncaught TypeError exceptions during JSON serialization or cause security-relevant headers and body content to be silently dropped without setting defect indicators.
CVE-2026-129236 is a command-line argument injection vulnerability (CWE-88) in Kubeshark, an eBPF-based network observability tool for Kubernetes. Located within the Model Context Protocol (MCP) server implementation in cmd/mcpRunner.go, the flaw occurs when handling the start_kubeshark tool request. When the MCP server runs with the --allow-destructive flag, the callStartKubeshark function appends the caller-supplied pod_regex parameter directly to the kubeshark tap argument slice without an end-of-options (--) delimiter. Because Kubeshark uses the Cobra and pflag libraries for command-line parsing, any pod_regex value prefixed with a hyphen is interpreted as a CLI flag rather than a positional regular expression. An attacker capable of influencing MCP tool arguments, such as through indirect prompt injection against a connected Large Language Model (LLM) agent, can inject the --set flag to override Helm chart values like tap.docker.registry. Because Kubeshark deploys its worker DaemonSet with privileged security contexts and host networking enabled, redirecting the container image registry allows arbitrary code execution as root across all Kubernetes cluster nodes.
Kubeshark versions 53.1.0 prior to 53.4.0 contain an arbitrary file write and path traversal vulnerability (CWE-22) alongside an argument injection vulnerability (CWE-88) in the Model Context Protocol (MCP) server implementation (cmd/mcpRunner.go). The download_file tool fails to validate caller-supplied path and dest arguments, allowing an attacker who influences an AI agent driving kubeshark mcp to write Kubeshark Hub API responses to arbitrary locations writable by the local user. Additionally, the start_kubeshark tool appends the pod_regex argument without flag delimiters, allowing argument injection into the kubeshark tap subcommand.
CVE-2026-129300 (GHSA-xhrq-2mqv-q8wx) is an unhandled exception vulnerability in SpamScope mail-parser, a Python library used to parse raw emails. When processing an email with a malformed Received header containing an out-of-range year or timezone offset, standard library datetime conversion routines raise OverflowError or OSError. Because the internal error handler only caught TypeError and ValueError, these exceptions escape the parser hierarchy, terminating email ingestion pipelines and causing a denial of service.
CVE-2026-129301 (GHSA-8cgq-x343-p74c) is an uncaught exception and MIME interpretation conflict vulnerability in the Python email parsing library mail-parser (versions >= 4.6.0 and < 4.6.3). The write_attachments() function iterates over parsed email attachments without per-attachment exception containment. When processing a specially crafted MIME part containing an RFC 2231-encoded null byte in the filename, a basename exceeding filesystem NAME_MAX limits, or a malformed base64 payload, the function raises an unhandled standard library exception (ValueError, OSError, or binascii.Error). This prematurely aborts the attachment extraction loop, preventing subsequent attachments from being written to disk for downstream security inspection while also triggering unhandled worker crashes in applications that only catch MailParserError.