argsbarg 3.6.4 → 4.0.0

package/src/invoke.test.ts

@@ -0,0 +1,207 @@
+/*
+Domain-specific regression tests (split from index.test.ts).
+*/
+
+import { expect, test } from "bun:test";
+import { join } from "node:path";
+import { $ } from "bun";
+import { Cli, type CliContext, CliOptionKind } from "./index.ts";
+import { ParseKind, parse, postParseValidate } from "./parse.ts";
+import { testProgram, varargsReadFixture } from "./test-fixtures.ts";
+import type { CliLeaf } from "./types.ts";
+import { isCliRouter } from "./types.ts";
+import { cliValidateProgram } from "./validate.ts";
+
+test("ctx.invocation is cli via Cli.run", async () => {
+  const indexPath = join(import.meta.dir, "index.ts");
+  const { stdout } = await $`bun -e ${`
+import { Cli, CliProgram } from ${JSON.stringify(indexPath)};
+const program = { key: "t", description: "d", version: "0.0.0", handler: (ctx) => console.log(ctx.invocation) };
+await new Cli(program).run([]);
+  `}`.quiet();
+  expect(stdout.toString().trim()).toBe("cli");
+});
+
+test("ctx.invocation is mcp via Cli.invoke", async () => {
+  let seen = "";
+  const root = testProgram({
+    key: "app",
+    description: "",
+    handler: (ctx: CliContext) => {
+      seen = ctx.invocation;
+    },
+  });
+  cliValidateProgram(root);
+  const result = await new Cli(root).invoke([]);
+  expect(result.kind).toBe("ok");
+  expect(seen).toBe("mcp");
+});
+
+test("Cli.invoke rejects invalid Enum value", async () => {
+  const root = testProgram({
+    key: "app",
+    description: "",
+    handler: () => {},
+    options: [
+      {
+        name: "mode",
+        description: "Mode.",
+        kind: CliOptionKind.Enum,
+        choices: ["dev", "prod"],
+        required: true,
+      },
+    ],
+  });
+  cliValidateProgram(root);
+  const result = await new Cli(root).invoke(["--mode", "staging"]);
+  expect(result.kind).toBe("error");
+  expect(result.errorMsg).toContain("not one of");
+});
+
+test("Cli.invoke accepts valid Enum value", async () => {
+  const root = testProgram({
+    key: "app",
+    description: "",
+    handler: (ctx: CliContext) => {
+      console.log(ctx.stringOpt("mode"));
+    },
+    options: [
+      {
+        name: "mode",
+        description: "Mode.",
+        kind: CliOptionKind.Enum,
+        choices: ["dev", "prod"],
+        required: true,
+      },
+    ],
+  });
+  cliValidateProgram(root);
+  const result = await new Cli(root).invoke(["--mode", "dev"]);
+  expect(result.kind).toBe("ok");
+  expect(result.stdout.trim()).toBe("dev");
+});
+
+test("varargs trailing option after positionals via Cli.invoke", async () => {
+  const root = varargsReadFixture();
+  cliValidateProgram(root);
+  const pr = postParseValidate(root, parse(root, ["read", "file.txt", "--json"]));
+  expect(pr.kind).toBe(ParseKind.Ok);
+  expect(pr.args).toEqual(["file.txt"]);
+  expect(pr.opts.json).toBe("1");
+});
+
+test("varargs option before positionals", () => {
+  const root = varargsReadFixture();
+  cliValidateProgram(root);
+  const pr = postParseValidate(root, parse(root, ["read", "--json", "file.txt"]));
+  expect(pr.kind).toBe(ParseKind.Ok);
+  expect(pr.args).toEqual(["file.txt"]);
+  expect(pr.opts.json).toBe("1");
+});
+
+test("varargs multiple files then trailing option", () => {
+  const root = varargsReadFixture();
+  cliValidateProgram(root);
+  const pr = postParseValidate(root, parse(root, ["read", "a.txt", "b.txt", "--json"]));
+  expect(pr.kind).toBe(ParseKind.Ok);
+  expect(pr.args).toEqual(["a.txt", "b.txt"]);
+  expect(pr.opts.json).toBe("1");
+});
+
+test("varargs double dash forces positional", () => {
+  const root = varargsReadFixture();
+  cliValidateProgram(root);
+  const pr = postParseValidate(root, parse(root, ["read", "file.txt", "--", "--json"]));
+  expect(pr.kind).toBe(ParseKind.Ok);
+  expect(pr.args).toEqual(["file.txt", "--json"]);
+  expect(pr.opts.json).toBeUndefined();
+});
+
+test("varargs unknown flag errors", async () => {
+  const root = varargsReadFixture();
+  cliValidateProgram(root);
+  const result = await new Cli(root).invoke(["read", "--unknown"]);
+  expect(result.kind).toBe("error");
+  expect(result.stderr).toContain("--unknown");
+});
+
+test("varargs scoped help in tail", () => {
+  const root = varargsReadFixture();
+  cliValidateProgram(root);
+  const pr = parse(root, ["read", "file.txt", "--help"]);
+  expect(pr.kind).toBe(ParseKind.Help);
+  expect(pr.helpPath).toContain("read");
+  expect(pr.helpExplicit).toBe(true);
+});
+
+test("ctx.positional returns single slot value", async () => {
+  const root = testProgram({
+    key: "app",
+    description: "",
+    commands: [
+      {
+        key: "x",
+        description: "",
+        positionals: [{ name: "path", description: "", kind: CliOptionKind.String }],
+        handler: (ctx: CliContext) => {
+          captured = ctx.positional("path");
+        },
+      },
+    ],
+  });
+  let captured: string | string[] | undefined;
+  cliValidateProgram(root);
+  await new Cli(root).invoke(["x", "./file"]);
+  expect(captured).toBe("./file");
+});
+
+test("ctx.positional returns varargs array", async () => {
+  const root = varargsReadFixture();
+  let captured: string | string[] | undefined;
+  if (isCliRouter(root)) {
+    (root.commands[0] as CliLeaf).handler = (ctx) => {
+      captured = ctx.positional("files");
+    };
+  }
+  cliValidateProgram(root);
+  await new Cli(root).invoke(["read", "a.txt", "b.txt"]);
+  expect(captured).toEqual(["a.txt", "b.txt"]);
+});
+
+test("ctx.positional returns undefined for absent optional slot", async () => {
+  const root = testProgram({
+    key: "app",
+    description: "",
+    commands: [
+      {
+        key: "x",
+        description: "",
+        positionals: [
+          { name: "opt", description: "", kind: CliOptionKind.String, argMin: 0, argMax: 1 },
+        ],
+        handler: (ctx: CliContext) => {
+          captured = ctx.positional("opt");
+        },
+      },
+    ],
+  });
+  let captured: string | string[] | undefined;
+  cliValidateProgram(root);
+  await new Cli(root).invoke(["x"]);
+  expect(captured).toBeUndefined();
+});
+
+test("ctx.positional varargs matches ctx.args", async () => {
+  const root = varargsReadFixture();
+  let positional: string | string[] | undefined;
+  let args: string[] = [];
+  if (isCliRouter(root)) {
+    (root.commands[0] as CliLeaf).handler = (ctx) => {
+      positional = ctx.positional("files");
+      args = ctx.args;
+    };
+  }
+  cliValidateProgram(root);
+  await new Cli(root).invoke(["read", "a.txt", "b.txt"]);
+  expect(positional).toEqual(args);
+});

package/src/mcp/bundle.ts

@@ -14,8 +14,11 @@ import {
 } from "node:fs";
 import { tmpdir } from "node:os";
 import { basename, join, resolve } from "node:path";
+import { buildProgramUserConfig } from "../config/manifest.ts";
 import type { CliMcpBundleConfig, CliProgram } from "../types.ts";
+import { packClaudePlugin } from "./claude.ts";
 import { collectMcpTools, mcpServerId } from "./tools.ts";
+import { zipStore } from "./zip.ts";
 
 const MANIFEST_VERSION = "0.3";
 const DIST_DIR = "dist";
@@ -38,41 +41,9 @@ export function defaultMcpBundlePaths(program: CliProgram, cwd = process.cwd()):
   };
 }
 
-/** Collects unique env var names from MCP tool `requiresEnv` for manifest `user_config`. */
-function collectUserConfigEnvVars(program: CliProgram): string[] {
-  const names = new Set<string>();
-  for (const tool of collectMcpTools(program)) {
-    for (const env of tool.leaf.mcpTool?.requiresEnv ?? []) {
-      if (env.length > 0) {
-        names.add(env);
-      }
-    }
-  }
-  return [...names].sort();
-}
-
-/** Builds manifest `user_config` entries for required environment variables. */
+/** Builds MCPB/plugin user_config from schema entries with `env` set. */
 function buildUserConfig(program: CliProgram): Record<string, unknown> | undefined {
-  const envVars = collectUserConfigEnvVars(program);
-  if (envVars.length === 0) {
-    return undefined;
-  }
-  const out: Record<string, unknown> = {};
-  for (const name of envVars) {
-    const key =
-      name
-        .toLowerCase()
-        .replace(/[^a-z0-9]+/g, "_")
-        .replace(/^_|_$/g, "") || "env_var";
-    out[key] = {
-      type: "string",
-      title: name,
-      description: `Value for environment variable ${name}`,
-      sensitive: /key|token|secret|password/i.test(name),
-      required: true,
-    };
-  }
-  return out;
+  return buildProgramUserConfig(program);
 }
 
 /** Default author when `mcpServer.bundle.author` is unset. */
@@ -134,85 +105,6 @@ export function generateMcpManifest(
   return manifest;
 }
 
-/** CRC-32 table for ZIP local headers (store method). */
-function crc32(data: Buffer): number {
-  let crc = 0xffffffff;
-  for (let i = 0; i < data.length; i++) {
-    const byte = data[i];
-    if (byte === undefined) {
-      continue;
-    }
-    crc ^= byte;
-    for (let j = 0; j < 8; j++) {
-      crc = (crc >>> 1) ^ (crc & 1 ? 0xedb88320 : 0);
-    }
-  }
-  return (crc ^ 0xffffffff) >>> 0;
-}
-
-/** Writes a minimal ZIP (store, no compression) with one or more files. */
-function zipStore(files: { name: string; data: Buffer }[]): Buffer {
-  const parts: Buffer[] = [];
-  const central: Buffer[] = [];
-  let offset = 0;
-
-  for (const file of files) {
-    const nameBuf = Buffer.from(file.name, "utf8");
-    const crc = crc32(file.data);
-    const local = Buffer.alloc(30 + nameBuf.length);
-    local.writeUInt32LE(0x04034b50, 0);
-    local.writeUInt16LE(20, 4);
-    local.writeUInt16LE(0, 6);
-    local.writeUInt16LE(0, 8);
-    local.writeUInt16LE(0, 10);
-    local.writeUInt16LE(0, 12);
-    local.writeUInt32LE(crc, 14);
-    local.writeUInt32LE(file.data.length, 18);
-    local.writeUInt32LE(file.data.length, 22);
-    local.writeUInt32LE(nameBuf.length, 26);
-    local.writeUInt16LE(0, 28);
-    nameBuf.copy(local, 30);
-
-    const centralHdr = Buffer.alloc(46 + nameBuf.length);
-    centralHdr.writeUInt32LE(0x02014b50, 0);
-    centralHdr.writeUInt16LE(20, 4);
-    centralHdr.writeUInt16LE(20, 6);
-    centralHdr.writeUInt16LE(0, 8);
-    centralHdr.writeUInt16LE(0, 10);
-    centralHdr.writeUInt16LE(0, 12);
-    centralHdr.writeUInt16LE(0, 14);
-    centralHdr.writeUInt32LE(crc, 16);
-    centralHdr.writeUInt32LE(file.data.length, 20);
-    centralHdr.writeUInt32LE(file.data.length, 24);
-    centralHdr.writeUInt32LE(nameBuf.length, 28);
-    centralHdr.writeUInt16LE(0, 30);
-    centralHdr.writeUInt16LE(0, 32);
-    centralHdr.writeUInt16LE(0, 34);
-    centralHdr.writeUInt16LE(0, 36);
-    centralHdr.writeUInt32LE(0, 38);
-    centralHdr.writeUInt32LE(offset, 42);
-    nameBuf.copy(centralHdr, 46);
-
-    parts.push(local, file.data);
-    central.push(centralHdr);
-    offset += local.length + file.data.length;
-  }
-
-  const centralStart = offset;
-  const centralBuf = Buffer.concat(central);
-  const end = Buffer.alloc(22);
-  end.writeUInt32LE(0x06054b50, 0);
-  end.writeUInt16LE(0, 4);
-  end.writeUInt16LE(0, 6);
-  end.writeUInt16LE(files.length, 8);
-  end.writeUInt16LE(files.length, 10);
-  end.writeUInt32LE(centralBuf.length, 12);
-  end.writeUInt32LE(centralStart, 16);
-  end.writeUInt16LE(0, 20);
-
-  return Buffer.concat([...parts, centralBuf, end]);
-}
-
 export interface PackMcpBundleOpts {
   cwd?: string;
   binaryPath?: string;
@@ -268,8 +160,9 @@ export function packMcpBundle(program: CliProgram, opts: PackMcpBundleOpts = {})
   }
 }
 
-/** Runs `mcp bundle`: writes `dist/<key>.mcpb` and prints the path on stdout. */
+/** Runs `mcp bundle`: writes `.mcpb` and Claude Code plugin zip; prints both paths. */
 export function runMcpBundle(program: CliProgram): void {
-  const outPath = packMcpBundle(program);
-  process.stdout.write(`${outPath}\n`);
+  const mcpbPath = packMcpBundle(program);
+  const pluginPath = packClaudePlugin(program);
+  process.stdout.write(`${mcpbPath}\n${pluginPath}\n`);
 }

package/src/mcp/claude.test.ts

@@ -0,0 +1,73 @@
+import { describe, expect, test } from "bun:test";
+import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import type { CliProgram } from "../types.ts";
+import {
+  defaultClaudePluginPaths,
+  generatePluginManifest,
+  generatePluginMcpJson,
+  packClaudePlugin,
+  pluginName,
+} from "./claude.ts";
+
+const configFixture: CliProgram = {
+  key: "myapp",
+  version: "1.0.0",
+  description: "Demo.",
+  mcpServer: { enabled: true },
+  appConfig: {
+    entries: {
+      apiToken: {
+        description: "Token from settings.",
+        env: "API_TOKEN",
+        sensitive: true,
+      },
+    },
+  },
+  commands: [{ key: "run", description: "Run.", handler: () => {} }],
+};
+
+describe("claude plugin", () => {
+  test("pluginName is kebab-case", () => {
+    expect(pluginName({ ...configFixture, key: "MyApp" })).toBe("my-app");
+  });
+
+  test("generatePluginManifest includes userConfig from program.appConfig", () => {
+    const manifest = generatePluginManifest(configFixture, "myapp");
+    expect(manifest.name).toBe("myapp");
+    const userConfig = manifest.userConfig as Record<string, Record<string, unknown>>;
+    expect(userConfig.api_token?.description).toBe("Token from settings.");
+    expect(userConfig.api_token?.sensitive).toBe(true);
+  });
+
+  test("generatePluginMcpJson uses CLAUDE_PLUGIN_ROOT and env mapping", () => {
+    const json = generatePluginMcpJson(configFixture, "myapp");
+    const entry = json.myapp as { command: string; args: string[]; env: Record<string, string> };
+    expect(entry.command).toBe("${CLAUDE_PLUGIN_ROOT}/bin/myapp");
+    expect(entry.args).toEqual(["mcp"]);
+    expect(entry.env.API_TOKEN).toBe("${user_config.api_token}");
+  });
+
+  test("defaultClaudePluginPaths", () => {
+    const cwd = "/tmp/work";
+    const paths = defaultClaudePluginPaths(configFixture, cwd);
+    expect(paths.pluginZipPath).toBe(join(cwd, "dist", "claude-plugin", "myapp.zip"));
+  });
+
+  test("packClaudePlugin writes zip with expected entries", () => {
+    const work = mkdtempSync(join(tmpdir(), "claude-plugin-test-"));
+    try {
+      const dist = join(work, "dist");
+      mkdirSync(dist, { recursive: true });
+      const binaryPath = join(dist, "myapp");
+      writeFileSync(binaryPath, "#!/bin/sh\n", { mode: 0o755 });
+      const paths = defaultClaudePluginPaths(configFixture, work);
+      packClaudePlugin(configFixture, { cwd: work, binaryPath });
+      const zipPath = paths.pluginZipPath;
+      expect(readFileSync(zipPath).length).toBeGreaterThan(0);
+    } finally {
+      rmSync(work, { recursive: true, force: true });
+    }
+  });
+});

package/src/mcp/claude.ts

@@ -0,0 +1,168 @@
+/*
+Packs a Claude Code plugin zip from a compiled CLI binary.
+Internal module — not exported from index.ts.
+*/
+
+import {
+  cpSync,
+  type Dirent,
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  readdirSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { basename, join, relative, resolve } from "node:path";
+import { buildPluginMcpEnvMapping, buildProgramUserConfig } from "../config/manifest.ts";
+import { generateSkillBundle } from "../skill/generate.ts";
+import { applySkillBundleHints } from "../skill/hint.ts";
+import type { CliMcpBundleConfig, CliProgram } from "../types.ts";
+import { defaultMcpBundlePaths, type PackMcpBundleOpts } from "./bundle.ts";
+import { mcpServerId, sanitizeToolSegment } from "./tools.ts";
+import { zipStore } from "./zip.ts";
+
+const DIST_DIR = "dist";
+const CLAUDE_PLUGIN_DIR = "claude-plugin";
+
+/** Kebab-case plugin name for plugin.json (Claude Code requires kebab-case). */
+export function pluginName(program: CliProgram): string {
+  return program.key
+    .replace(/([a-z0-9])([A-Z])/g, "$1-$2")
+    .replace(/[^a-zA-Z0-9]+/g, "-")
+    .replace(/^-+|-+$/g, "")
+    .toLowerCase();
+}
+
+function defaultAuthor(bundle?: CliMcpBundleConfig): {
+  name: string;
+  email?: string;
+  url?: string;
+} {
+  return bundle?.author ?? { name: "Unknown" };
+}
+
+/** Default plugin zip output under cwd. */
+export function defaultClaudePluginPaths(program: CliProgram, cwd = process.cwd()) {
+  const binaryName = program.key;
+  const dist = join(cwd, DIST_DIR);
+  const name = pluginName(program);
+  return {
+    pluginZipPath: join(dist, CLAUDE_PLUGIN_DIR, `${name}.zip`),
+    binaryPath: join(dist, binaryName),
+    binaryName,
+  };
+}
+
+/** Generates `.claude-plugin/plugin.json` object. */
+export function generatePluginManifest(
+  program: CliProgram,
+  _binaryName: string,
+): Record<string, unknown> {
+  const bundle = program.mcpServer?.bundle;
+  const manifest: Record<string, unknown> = {
+    name: pluginName(program),
+    version: program.version,
+    description: program.description,
+    author: defaultAuthor(bundle),
+  };
+  const userConfig = buildProgramUserConfig(program);
+  if (userConfig) {
+    manifest.userConfig = userConfig;
+  }
+  return manifest;
+}
+
+/** Generates plugin `.mcp.json` stdio server config. */
+export function generatePluginMcpJson(
+  program: CliProgram,
+  binaryName: string,
+): Record<string, unknown> {
+  const mcp: Record<string, unknown> = {
+    command: `\${CLAUDE_PLUGIN_ROOT}/bin/${binaryName}`,
+    args: ["mcp"],
+  };
+  const env = buildPluginMcpEnvMapping(program);
+  if (env) {
+    mcp.env = env;
+  }
+  return {
+    [mcpServerId(program)]: mcp,
+  };
+}
+
+function collectZipEntries(rootDir: string, dir = rootDir): { name: string; data: Buffer }[] {
+  const entries: { name: string; data: Buffer }[] = [];
+  for (const ent of readdirSync(dir, { withFileTypes: true }) as Dirent[]) {
+    const full = join(dir, ent.name);
+    if (ent.isDirectory()) {
+      entries.push(...collectZipEntries(rootDir, full));
+      continue;
+    }
+    if (!ent.isFile()) {
+      continue;
+    }
+    const rel = relative(rootDir, full).split("\\").join("/");
+    entries.push({ name: rel, data: readFileSync(full) });
+  }
+  return entries;
+}
+
+function writePluginTree(
+  pluginRoot: string,
+  program: CliProgram,
+  binaryPath: string,
+  binaryName: string,
+): void {
+  const skillDirName = sanitizeToolSegment(program.key);
+  const bundle = generateSkillBundle(program, "claude");
+  const hinted = applySkillBundleHints(program, bundle.skillMd, bundle.referenceMd);
+
+  mkdirSync(join(pluginRoot, ".claude-plugin"), { recursive: true });
+  mkdirSync(join(pluginRoot, "bin"), { recursive: true });
+  mkdirSync(join(pluginRoot, "skills", skillDirName), { recursive: true });
+
+  writeFileSync(
+    join(pluginRoot, ".claude-plugin", "plugin.json"),
+    `${JSON.stringify(generatePluginManifest(program, binaryName), null, 2)}\n`,
+  );
+  writeFileSync(
+    join(pluginRoot, ".mcp.json"),
+    `${JSON.stringify(generatePluginMcpJson(program, binaryName), null, 2)}\n`,
+  );
+  cpSync(binaryPath, join(pluginRoot, "bin", binaryName), { mode: 0o755 });
+  writeFileSync(join(pluginRoot, "skills", skillDirName, "SKILL.md"), hinted.skillMd);
+  writeFileSync(join(pluginRoot, "skills", skillDirName, "reference.md"), hinted.referenceMd);
+}
+
+/**
+ * Writes `dist/claude-plugin/<name>.zip` with manifests, binary, and skill bundle.
+ * Requires the compiled binary to exist.
+ */
+export function packClaudePlugin(program: CliProgram, opts: PackMcpBundleOpts = {}): string {
+  const cwd = opts.cwd ?? process.cwd();
+  const defaults = defaultClaudePluginPaths(program, cwd);
+  const mcpDefaults = defaultMcpBundlePaths(program, cwd);
+  const binaryPath = resolve(cwd, opts.binaryPath ?? mcpDefaults.binaryPath);
+  const pluginZipPath = resolve(cwd, defaults.pluginZipPath);
+  const binaryName = basename(binaryPath);
+
+  if (!existsSync(binaryPath)) {
+    throw new Error(
+      `Binary not found: ${binaryPath}. Build with compile first (expected dist/${program.key}).`,
+    );
+  }
+
+  const staging = mkdtempSync(join(tmpdir(), "claude-plugin-"));
+  try {
+    writePluginTree(staging, program, binaryPath, binaryName);
+    const zip = zipStore(collectZipEntries(staging));
+    mkdirSync(join(pluginZipPath, ".."), { recursive: true });
+    writeFileSync(pluginZipPath, zip);
+    return pluginZipPath;
+  } finally {
+    rmSync(staging, { recursive: true, force: true });
+  }
+}

package/src/mcp/env.ts

@@ -1,9 +1,8 @@
 /*
-This module bootstraps process.env for MCP servers from login shell and .env files.
+This module bootstraps process.env for MCP servers from login shell.
 */
 
 import { spawnSync } from "node:child_process";
-import { readFileSync } from "node:fs";
 
 /** Parses `env` stdout from a login shell into a key/value map. */
 export function captureShellEnv(shell: string): Record<string, string> {
@@ -40,38 +39,8 @@ export function applyShellEnv(env: Record<string, string>): void {
   }
 }
 
-/** Loads a .env file into process.env (always overwrites). Warns on stderr if missing. */
-export function loadEnvFile(envFile: string): void {
-  const resolved = envFile.startsWith("~") ? envFile.replace("~", process.env.HOME ?? "") : envFile;
-  let text: string;
-  try {
-    text = readFileSync(resolved, "utf8");
-  } catch {
-    process.stderr.write(`[argsbarg] envFile not found: ${envFile}\n`);
-    return;
-  }
-  for (const line of text.split("\n")) {
-    const trimmed = line.trim();
-    if (!trimmed || trimmed.startsWith("#")) {
-      continue;
-    }
-    const eq = trimmed.indexOf("=");
-    if (eq < 1) {
-      continue;
-    }
-    const key = trimmed.slice(0, eq).trim();
-    let val = trimmed.slice(eq + 1).trim();
-    if ((val.startsWith('"') && val.endsWith('"')) || (val.startsWith("'") && val.endsWith("'"))) {
-      val = val.slice(1, -1);
-    }
-    if (key) {
-      process.env[key] = val;
-    }
-  }
-}
-
-/** Applies mcpServer shellEnv and envFile bootstrap in order. */
-export function bootstrapMcpEnv(config: { shellEnv?: boolean | string; envFile?: string }): void {
+/** Applies mcpServer shellEnv bootstrap. */
+export function bootstrapMcpEnv(config: { shellEnv?: boolean | string }): void {
   const shellEnvCfg = config.shellEnv;
   if (shellEnvCfg) {
     const shell =
@@ -87,7 +56,4 @@ export function bootstrapMcpEnv(config: { shellEnv?: boolean | string; envFile?:
       applyShellEnv(captured);
     }
   }
-  if (config.envFile) {
-    loadEnvFile(config.envFile);
-  }
 }