llm-chess-mcp 0.1.1 → 0.1.3

package/.env.example

@@ -0,0 +1,9 @@
+# Lichess opening explorer (optional; explorer tools disabled if unset)
+# Generate at https://lichess.org/account/oauth/token/create
+LICHESS_TOKEN=
+
+# The published package bundles only Maia3 5m (~20 MB). Leave at 5m.
+MAIA3_MODEL=5m
+
+# Stockfish flavor: lite-single (default, ~7MB) | lite | single | full
+STOCKFISH_FLAVOR=lite-single

package/README.md

@@ -1,20 +1,30 @@
 # llm-chess-mcp
 
-An MCP server for truly enjoying chess games with your LLM. It adds a feature that, rather than simply making the best move, allows it to think and judge on its own and make moves. the MCP server handles all the computation (Stockfish evaluation, Maia3 human-move prediction, Lichess opening statistics).
+An MCP chess runtime that lets LLMs play, analyze, and adapt their strength
+without outsourcing every decision to an engine.
+
+Rather than returning a single best move, it exposes objective strength
+(Stockfish), human move likelihood (Maia3), and real-game statistics (Lichess)
+so the LLM can choose how it wants to play. The LLM does the strategy and
+judgment; the MCP server handles all the computation.
 
 ## Engines
 
 | Engine | Role | Runtime |
 |---|---|---|
 | **Stockfish 18** (WASM) | Objective evaluation, best moves, multipv | In-process (npm `stockfish`) |
-| **Maia3** (ONNX) | Human-like move probabilities conditioned on Elo | In-process (`onnxruntime-node`) |
+| **Maia3 5M** (ONNX) | Human-like move probabilities conditioned on Elo | In-process (`onnxruntime-node`) |
 | **Lichess explorer** | Real human game statistics | HTTP (needs token) |
 
-Everything runs inside the Node process — no separate engine binaries or Python
-runtime needed at deploy time. Maia3 is exported to ONNX once at build time.
+Everything runs inside the Node process — no external engine process or Python
+runtime is required at deploy time. The published package bundles the Maia3 5M
+model; other export variants are not runtime options unless their ONNX files are
+provided separately.
 
 ## Install
 
+Requires Node.js 20 or newer.
+
 No install needed — run it directly with `npx`:
 
 ```bash
@@ -35,6 +45,7 @@ npm install -g llm-chess-mcp
 ```bash
 pnpm install
 pnpm build
+pnpm test
 ```
 
 ### Export Maia3 to ONNX (build-time only)
@@ -45,7 +56,7 @@ the reimplementation against the original, and exports `models/maia3-5m.onnx`.
 ```bash
 uv venv .venv-maia3 --python 3.13
 uv pip install --python .venv-maia3/bin/python -r scripts/requirements.txt
-uv pip install --python .venv-maia3/bin/python "maia3 @ git+https://github.com/CSSLab/maia3"
+uv pip install --python .venv-maia3/bin/python "maia3 @ git+https://github.com/CSSLab/maia3.git@1e13597c42d4858b7cfd7cfdae01e297263364b2"
 pnpm export:maia3            # -> models/maia3-5m.onnx
 ```
 
@@ -78,8 +89,7 @@ Add to `opencode.json` (project) or `~/.config/opencode/opencode.json` (global):
       "command": ["npx", "-y", "llm-chess-mcp"],
       "enabled": true,
       "environment": {
-        "LICHESS_TOKEN": "your-token",
-        "MAIA3_MODEL": "5m"
+        "LICHESS_TOKEN": "your-token"
       }
     }
   }
@@ -101,8 +111,7 @@ claude mcp add llm-chess-mcp -- npx -y llm-chess-mcp
       "command": "npx",
       "args": ["-y", "llm-chess-mcp"],
       "env": {
-        "LICHESS_TOKEN": "your-token",
-        "MAIA3_MODEL": "5m"
+        "LICHESS_TOKEN": "your-token"
       }
     }
   }
@@ -120,7 +129,6 @@ args = ["-y", "llm-chess-mcp"]
 
 [mcp_servers.llm-chess-mcp.env]
 LICHESS_TOKEN = "your-token"
-MAIA3_MODEL = "5m"
 ```
 
 Or via the CLI:
@@ -135,32 +143,100 @@ codex mcp add llm-chess-mcp --command npx --args -y llm-chess-mcp --env LICHESS_
 |---|---|
 | `create_game` | Create a game (optionally from a FEN), returns `game_id` |
 | `delete_game` | Delete a game and free its session |
-| `game_state` | Authoritative state: FEN, turn, check/mate/draw flags, history, last move, castling |
-| `game_state_ascii` | ASCII board diagram |
-| `game_play_move` | Play a move (SAN or UCI) — the only mutating tool |
+| `game_state` | Authoritative state: FEN, turn, revision, check/mate/draw flags, history, last move, castling (optional ASCII) |
+| `game_play_move` | Play a move (SAN or UCI) — the only mutating tool, with stale-position guard |
 | `game_legal_moves` | All legal moves with metadata |
 | `game_pgn` | Export the game as PGN |
 | `game_import_pgn` | Import a PGN into a new game |
-| `position_analyze` | Stockfish multipv lines (cp/mate + PV) |
+| `position_analyze` | Stockfish multipv lines (cp/mate/WDL + PV), `analysis_level` preset |
 | `human_move_distribution` | Maia3 human-move probabilities at a target Elo |
-| `move_evaluate` | Score a move + cpLoss + classification |
-| `move_candidates` | Unified candidates (SF eval + cpLoss + Maia3 prob + Lichess stats) |
-| `move_candidates_by_intent` | Candidates ranked for a strategic intent |
+| `move_evaluate` | Score one or more moves + cpLoss + classification |
+| `move_candidates` | **Primary tool**: unified candidates (objective + human + opening) |
+| `move_candidates_by_intent` | Convenience layer: candidates ranked for a strategic intent |
 | `opening_explorer` | Lichess human game statistics |
 
 ## Score conventions
 
 - Stockfish scores are **side-to-move perspective**: positive cp = side to move is
-  better; `mate N` = side to move mates in N.
-- `move_evaluate` reports the score **from the mover's perspective** (negated after
-  the move), plus `cpLoss` (centipawns lost vs the best move) and a classification:
+  better; `mate N` = side to move mates in N. `wdl` is `[win, draw, loss]` in
+  permille for the side to move.
+- `move_candidates` gives `moverCp` (the mover's perspective — higher is better
+  for the player choosing the move) and `whiteCp` (fixed white perspective) so
+  the sign never flips on you.
+- `move_evaluate` reports the score **from the mover's perspective**, plus `cpLoss`
+  (centipawns lost vs the best move) and a classification:
   `best / excellent / good / inaccuracy / mistake / blunder`.
 - `maia3Prob` is a **human-likelihood**, not move quality. A high-probability move
   can still be objectively bad.
 
+## Candidate structure
+
+`move_candidates` returns each candidate with three independent facets:
+
+```json
+{
+  "uci": "g1f3",
+  "san": "Nf3",
+  "objective": { "rank": 1, "moverCp": 55, "whiteCp": 55, "cpLoss": 0, "moverMate": null, "wdl": [153, 844, 3] },
+  "human": { "maia3Prob": 0.62, "selfElo": 1500, "opponentElo": 1500 },
+  "opening": { "status": "available", "games": 18421, "frequency": 0.31 }
+}
+```
+
+- `objective` — Stockfish: engine strength, never conflated with human-likeness.
+  `moverCp` is from the mover's perspective (higher = better for the chooser).
+- `human` — Maia3 conditional probability at a target Elo.
+- `opening` — Lichess empirical frequency (a different signal from Maia3).
+
+`opening.status` is `available`, `no_data` (API ok but no games in this
+position), `unavailable` (timeout/429/401), or `disabled` (no token).
+Stockfish + Maia3 results are always returned regardless.
+
+`move_candidates` also returns `moveSensitivity`, describing how sharply the
+evaluation changes across the top engine lines:
+
+```json
+{ "moveSensitivity": { "level": "high", "topMoveSpreadCp": 245 } }
+```
+
+`level` is `low` (<80cp spread), `medium` (80–200cp), or `high` (≥200cp). High
+sensitivity means choosing among plausible alternatives can materially change
+the evaluation — useful for deciding whether to ease off or play precisely.
+
+## Analysis levels
+
+Stockfish tools accept an `analysis_level` preset instead of raw UCI knobs:
+
+| Level | Depth | MultiPV |
+|---|---|---|
+| `fast` | 8 | 5 |
+| `normal` | 15 | 8 |
+| `deep` | 22 | 10 |
+
+Explicit `depth`/`multipv` overrides are still available for advanced use.
+
+## Stale-position guard
+
+Every state read returns a `revision`. `game_play_move` **requires**
+`expected_revision`; if the game has advanced since your last read, the move is
+rejected:
+
+```json
+{ "error": { "code": "STALE_POSITION", "message": "position changed: expected revision 2, current 3" } }
+```
+
+## Runtime limits
+
+- Up to 1,000 game sessions are retained; idle sessions expire after one hour.
+- `move_evaluate` accepts at most 10 moves per call.
+- Imported PGNs are limited to 1 MiB and 4,096 plies.
+- Stockfish accepts up to 32 active or queued analyses.
+
 ## Intents
 
-`move_candidates_by_intent` ranks candidates for a chosen intent:
+`move_candidates_by_intent` ranks candidates for a chosen intent. It is a
+convenience layer over `move_candidates`; the fixed thresholds below are
+heuristic defaults, not the source of truth:
 
 | Intent | Meaning |
 |---|---|
@@ -168,16 +244,40 @@ codex mcp add llm-chess-mcp --command npx --args -y llm-chess-mcp --env LICHESS_
 | `strong` | Engine-strong but human-plausible |
 | `natural` | Most human-typical at the target Elo |
 | `balanced` | Blend of strength and human-likeness |
-| `ease_off` | Slightly weaker (−30..−80cp) but human |
-| `give_chance` | Clearly weaker (−80..−150cp), gives the opponent chances |
+| `ease_off` | Human-plausible moves that modestly reduce advantage without changing the expected result |
+| `give_chance` | Human-plausible inaccuracies that meaningfully improve the opponent's chances |
+
+This tool ranks candidates but does not choose a move. Use the returned signals
+and conversation context to make the final decision — do not map user skill
+mechanically to an intent.
 
 ## Example flow
 
+The normal play loop is three calls:
+
 1. `create_game` → `game_id`
-2. `position_analyze` to see the objective best lines
-3. `human_move_distribution` to see what a human of a given Elo would play
-4. `move_candidates_by_intent` with the intent that fits the situation
-5. `game_play_move` to commit the chosen move
+2. `move_candidates` → pick a move
+3. `game_play_move` (with `expected_revision`) → commit it
+
+Go deeper only when you need to:
+
+- `position_analyze` — objective best lines
+- `human_move_distribution` — what a human of a given Elo would play
+- `opening_explorer` — real-game statistics
+- `move_evaluate` — score a specific move (or compare several)
+
+## Maia3 ONNX verification
+
+The exported ONNX model is regression-tested against the upstream Maia3
+implementation across fixed positions and Elo pairs:
+
+```bash
+.venv-maia3/bin/python scripts/verify_maia3.py --model 5m
+```
+
+It checks top-1/top-k move agreement and max probability error to detect
+export/runtime regressions. The bundled `maia3-5m.onnx` passes with 100% top-1
+and top-5 agreement and max probability error < 1e-4.
 
 ## License & attribution
 
@@ -192,6 +292,7 @@ It bundles and depends on third-party components:
 | [onnxruntime-node](https://github.com/microsoft/onnxruntime) | MIT | Microsoft |
 | [chess.js](https://github.com/jhlywa/chess.js) | BSD-2-Clause | Jeff Hlywa |
 
-The Maia3 model weights (`models/maia3-5m.onnx`) are derived from the
-`UofTCSSLab/Maia3-5M` checkpoint. The ONNX export is a build-time step
-(`scripts/export_maia3.py`); the runtime does not execute any Maia3 Python code.
+The bundled Maia3 model (`models/maia3-5m.onnx`) is derived from
+[`UofTCSSLab/Maia3-5M` at `b6559de2398d7140b985f28fd2c19fb5e47ddabe`](https://huggingface.co/UofTCSSLab/Maia3-5M/tree/b6559de2398d7140b985f28fd2c19fb5e47ddabe).
+The ONNX export is a build-time step (`scripts/export_maia3.py`); the runtime
+does not execute any Maia3 Python code.

package/dist/engines/stockfish.js

@@ -1,7 +1,34 @@
 import { createRequire } from "node:module";
 const require = createRequire(import.meta.url);
-function flavor() {
-    return process.env.STOCKFISH_FLAVOR || "lite-single";
+export const STOCKFISH_FLAVORS = [
+    "full",
+    "lite",
+    "single",
+    "lite-single",
+    "single-lite",
+    "asm",
+];
+const DEFAULT_FLAVOR = "lite-single";
+const FLAVORS = new Set(STOCKFISH_FLAVORS);
+const DEFAULT_TIMEOUTS = {
+    init: 15000,
+    handshake: 15000,
+    analyze: 30000,
+    stopGrace: 2000,
+};
+const DEFAULT_MAX_QUEUE = 32;
+export function resolveStockfishFlavor(value) {
+    const normalized = (value || DEFAULT_FLAVOR).toLowerCase();
+    if (!FLAVORS.has(normalized)) {
+        throw new Error(`invalid STOCKFISH_FLAVOR: ${JSON.stringify(value)}; expected one of ${STOCKFISH_FLAVORS.join(", ")}`);
+    }
+    return normalized;
+}
+function loadStockfish() {
+    return require("stockfish");
+}
+function asError(error) {
+    return error instanceof Error ? error : new Error(String(error));
 }
 function parseScore(token) {
     if (token.startsWith("cp"))
@@ -10,57 +37,183 @@ function parseScore(token) {
         return { cp: null, mate: Number(token.slice(4)) };
     return { cp: null, mate: null };
 }
+function parseWdl(line) {
+    const m = line.match(/ wdl (\d+) (\d+) (\d+)/);
+    if (!m)
+        return null;
+    return [Number(m[1]), Number(m[2]), Number(m[3])];
+}
 export class Stockfish {
-    engine = null;
-    ready = null;
+    session = null;
     queue = Promise.resolve();
+    queued = 0;
+    quitGeneration = 0;
+    terminated = new WeakSet();
+    initEngine;
+    configuredFlavor;
+    maxQueue;
+    timeouts;
+    constructor(options = {}) {
+        this.initEngine = options.init;
+        this.configuredFlavor = options.flavor;
+        this.maxQueue = options.maxQueue ?? DEFAULT_MAX_QUEUE;
+        this.timeouts = { ...DEFAULT_TIMEOUTS, ...options.timeouts };
+        if (!Number.isInteger(this.maxQueue) || this.maxQueue < 1) {
+            throw new Error("stockfish maxQueue must be a positive integer");
+        }
+        for (const [name, timeout] of Object.entries(this.timeouts)) {
+            if (!Number.isFinite(timeout) || timeout < 1) {
+                throw new Error(`stockfish ${name} timeout must be positive`);
+            }
+        }
+    }
     init() {
-        if (this.ready)
-            return this.ready;
-        this.ready = new Promise((resolve, reject) => {
-            const init = require("stockfish");
-            const engine = init(flavor(), (err) => {
-                if (err)
-                    return reject(err);
-                this.handshake().then(resolve, reject);
-            });
-            this.engine = engine;
-            engine.listener = () => { };
+        if (this.session)
+            return this.session.ready;
+        let resolve;
+        let reject;
+        const ready = new Promise((res, rej) => {
+            resolve = res;
+            reject = rej;
         });
-        return this.ready;
+        const session = {
+            engine: null,
+            ready,
+            initSettled: false,
+            initTimer: null,
+            resolve,
+            reject,
+            aborts: new Set(),
+        };
+        this.session = session;
+        session.initTimer = setTimeout(() => this.failSession(session, new Error("stockfish init timeout")), this.timeouts.init);
+        let callbackCalled = false;
+        try {
+            const selectedFlavor = resolveStockfishFlavor(this.configuredFlavor ?? process.env.STOCKFISH_FLAVOR);
+            const engine = (this.initEngine ?? loadStockfish())(selectedFlavor, (error, initializedEngine) => {
+                callbackCalled = true;
+                if (this.session !== session) {
+                    this.terminate(initializedEngine);
+                    return;
+                }
+                if (session.initSettled) {
+                    if (initializedEngine !== session.engine)
+                        this.terminate(initializedEngine);
+                    return;
+                }
+                if (session.engine && session.engine !== initializedEngine) {
+                    this.terminate(session.engine);
+                }
+                session.engine = initializedEngine;
+                if (error) {
+                    this.failSession(session, asError(error));
+                    return;
+                }
+                initializedEngine.listener = () => { };
+                if (session.initTimer)
+                    clearTimeout(session.initTimer);
+                session.initTimer = null;
+                this.handshake(session).then(() => {
+                    if (this.session !== session || session.initSettled)
+                        return;
+                    session.initSettled = true;
+                    session.resolve();
+                }, (handshakeError) => this.failSession(session, asError(handshakeError)));
+            });
+            if (!callbackCalled && this.session === session && !session.initSettled) {
+                session.engine = engine;
+                engine.listener = () => { };
+            }
+        }
+        catch (error) {
+            this.failSession(session, asError(error));
+        }
+        return ready;
     }
-    handshake() {
+    handshake(session) {
         return new Promise((resolve, reject) => {
-            const engine = this.engine;
+            const engine = session.engine;
+            if (!engine) {
+                reject(new Error("stockfish initialized without an engine"));
+                return;
+            }
             let stage = 0;
-            const timer = setTimeout(() => reject(new Error("stockfish handshake timeout")), 15000);
-            engine.listener = (line) => {
+            let settled = false;
+            const finish = (error) => {
+                if (settled)
+                    return;
+                settled = true;
+                clearTimeout(timer);
+                session.aborts.delete(abort);
+                if (engine.listener === listener)
+                    engine.listener = null;
+                if (error)
+                    reject(error);
+                else
+                    resolve();
+            };
+            const abort = (error) => finish(error);
+            const listener = (line) => {
                 if (stage === 0 && line === "uciok") {
                     stage = 1;
-                    engine.sendCommand("isready");
+                    try {
+                        engine.sendCommand("isready");
+                    }
+                    catch (error) {
+                        finish(asError(error));
+                    }
                 }
                 else if (stage === 1 && line === "readyok") {
-                    clearTimeout(timer);
-                    engine.listener = null;
-                    resolve();
+                    finish();
                 }
             };
-            engine.sendCommand("uci");
+            const timer = setTimeout(() => finish(new Error("stockfish handshake timeout")), this.timeouts.handshake);
+            session.aborts.add(abort);
+            engine.listener = listener;
+            try {
+                engine.sendCommand("uci");
+            }
+            catch (error) {
+                finish(asError(error));
+            }
         });
     }
     enqueue(fn) {
-        const run = this.queue.then(fn, fn);
-        this.queue = run.catch(() => { });
-        return run;
+        if (this.queued >= this.maxQueue) {
+            return Promise.reject(new Error("stockfish queue full"));
+        }
+        this.queued++;
+        const run = this.queue.then(fn);
+        this.queue = run.then(() => { }, () => { });
+        return run.finally(() => {
+            this.queued--;
+        });
     }
-    async analyze(fen, depth, multipv) {
-        await this.init();
-        return this.enqueue(() => this.doAnalyze(fen, depth, multipv));
+    analyze(fen, depth, multipv) {
+        const quitGeneration = this.quitGeneration;
+        return this.enqueue(async () => {
+            if (quitGeneration !== this.quitGeneration) {
+                throw new Error("stockfish request cancelled");
+            }
+            await this.init();
+            if (quitGeneration !== this.quitGeneration) {
+                throw new Error("stockfish request cancelled");
+            }
+            const session = this.session;
+            if (!session)
+                throw new Error("stockfish unavailable after initialization");
+            return this.doAnalyze(session, fen, depth, multipv);
+        });
     }
-    doAnalyze(fen, depth, multipv) {
+    doAnalyze(session, fen, depth, multipv) {
         return new Promise((resolve, reject) => {
-            const engine = this.engine;
+            const engine = session.engine;
+            if (!engine) {
+                reject(new Error("stockfish engine unavailable"));
+                return;
+            }
             const byPv = new Map();
+            let settled = false;
             let stopTimer = null;
             let failTimer = null;
             const cleanup = () => {
@@ -70,8 +223,28 @@ export class Stockfish {
                     clearTimeout(failTimer);
                 stopTimer = null;
                 failTimer = null;
+                session.aborts.delete(abort);
+                if (engine.listener === listener)
+                    engine.listener = null;
             };
-            engine.listener = (line) => {
+            const succeed = () => {
+                if (settled)
+                    return;
+                settled = true;
+                cleanup();
+                resolve([...byPv.values()].sort((a, b) => a.multipv - b.multipv));
+            };
+            const fail = (error, reset) => {
+                if (settled)
+                    return;
+                settled = true;
+                cleanup();
+                if (reset)
+                    this.invalidateSession(session, error);
+                reject(error);
+            };
+            const abort = (error) => fail(error, false);
+            const listener = (line) => {
                 if (line.startsWith("info") && line.includes(" multipv ")) {
                     const m = line.match(/multipv (\d+)/);
                     const s = line.match(/ score (cp -?\d+|mate -?\d+)/);
@@ -84,42 +257,82 @@ export class Stockfish {
                         multipv: n,
                         scoreCp: score.cp,
                         scoreMate: score.mate,
+                        wdl: parseWdl(line),
                         pv: pv ? pv[1].split(" ") : [],
                     });
                 }
                 else if (line.startsWith("bestmove")) {
-                    cleanup();
-                    engine.listener = null;
-                    resolve([...byPv.values()].sort((a, b) => a.multipv - b.multipv));
+                    succeed();
                 }
             };
-            engine.sendCommand("position fen " + fen);
-            engine.sendCommand(`setoption name MultiPV value ${multipv}`);
-            engine.sendCommand(`go depth ${depth}`);
+            session.aborts.add(abort);
+            engine.listener = listener;
             stopTimer = setTimeout(() => {
-                engine.sendCommand("stop");
-                failTimer = setTimeout(() => {
-                    if (engine.listener) {
-                        engine.listener = null;
-                        this.reset();
-                        reject(new Error("stockfish analyze timeout"));
-                    }
-                }, 2000);
-            }, 30000);
-        });
-    }
-    reset() {
-        if (this.engine) {
+                failTimer = setTimeout(() => fail(new Error("stockfish analyze timeout"), true), this.timeouts.stopGrace);
+                try {
+                    engine.sendCommand("stop");
+                }
+                catch (error) {
+                    fail(asError(error), true);
+                }
+            }, this.timeouts.analyze);
             try {
-                this.engine.terminate();
+                engine.sendCommand("position fen " + fen);
+                engine.sendCommand(`setoption name MultiPV value ${multipv}`);
+                engine.sendCommand("setoption name UCI_ShowWDL value true");
+                engine.sendCommand(`go depth ${depth}`);
+            }
+            catch (error) {
+                fail(asError(error), true);
+                return;
             }
-            catch { }
+        });
+    }
+    failSession(session, error) {
+        if (session.initSettled)
+            return;
+        session.initSettled = true;
+        if (session.initTimer)
+            clearTimeout(session.initTimer);
+        session.initTimer = null;
+        this.invalidateSession(session, error);
+        session.reject(error);
+    }
+    invalidateSession(session, error) {
+        if (this.session !== session)
+            return;
+        this.session = null;
+        if (session.initTimer)
+            clearTimeout(session.initTimer);
+        session.initTimer = null;
+        if (!session.initSettled) {
+            session.initSettled = true;
+            session.reject(error);
+        }
+        const aborts = [...session.aborts];
+        session.aborts.clear();
+        if (session.engine) {
+            session.engine.listener = null;
+            this.terminate(session.engine);
+        }
+        for (const abort of aborts)
+            abort(error);
+    }
+    terminate(engine) {
+        if (this.terminated.has(engine))
+            return;
+        this.terminated.add(engine);
+        engine.listener = null;
+        try {
+            engine.terminate();
         }
-        this.engine = null;
-        this.ready = null;
+        catch { }
     }
     async quit() {
-        this.reset();
+        this.quitGeneration++;
+        const session = this.session;
+        if (session)
+            this.invalidateSession(session, new Error("stockfish quit"));
     }
 }
 export const stockfish = new Stockfish();

package/dist/env.js

@@ -1,5 +1,6 @@
 import { readFileSync } from "node:fs";
 import { resolve } from "node:path";
+const ALLOWED_KEYS = new Set(["LICHESS_TOKEN", "MAIA3_MODEL", "STOCKFISH_FLAVOR"]);
 export function loadEnv(path = ".env") {
     let text;
     try {
@@ -17,7 +18,7 @@ export function loadEnv(path = ".env") {
             continue;
         const key = trimmed.slice(0, eq).trim();
         const value = trimmed.slice(eq + 1).trim();
-        if (key && process.env[key] === undefined) {
+        if (ALLOWED_KEYS.has(key) && process.env[key] === undefined) {
             process.env[key] = value.replace(/^["']|["']$/g, "");
         }
     }