argsbarg 1.4.0 → 1.4.1

package/src/index.test.ts

@@ -9,19 +9,23 @@ shell output regressions.
 
 import { completionBashScript, completionZshScript } from "./completion.ts";
 import { cliHelpRender } from "./help.ts";
-import { CliCommand, CliFallbackMode, CliOptionKind } from "./index.ts";
+import { CliCommand, CliFallbackMode, CliOptionKind, cliInvoke } from "./index.ts";
 import {
+  allMcpResources,
   collectMcpTools,
   mcpToolCallToArgv,
   mcpToolDescription,
   sanitizeToolSegment,
 } from "./mcp/tools.ts";
+import { applyShellEnv, loadEnvFile } from "./mcp/env.ts";
 import { buildToolCallSuccess } from "./mcp/result.ts";
 import { ParseKind, parse, postParseValidate } from "./parse.ts";
 import { cliSchemaJson } from "./schema.ts";
 import { cliValidateRoot } from "./validate.ts";
 import { expect, test } from "bun:test";
 import { $ } from "bun";
+import { mkdtempSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
 import { join } from "node:path";
 
 test("bundled short presence flags", () => {
@@ -718,11 +722,16 @@ const nestedMcpFixture: CliCommand = {
 };
 
 /** Sends NDJSON MCP requests to a subprocess and collects responses by id. */
-async function mcpRequest(requests: object[]): Promise<Map<string | number, object>> {
-  const proc = Bun.spawn(["bun", "run", "examples/nested.ts", "mcp"], {
+async function mcpRequest(
+  requests: object[],
+  opts?: { script?: string; env?: Record<string, string> },
+): Promise<Map<string | number, object>> {
+  const script = opts?.script ?? "examples/nested.ts";
+  const proc = Bun.spawn(["bun", "run", script, "mcp"], {
     stdin: "pipe",
     stdout: "pipe",
     stderr: "pipe",
+    env: opts?.env ? { ...process.env, ...opts.env } : process.env,
   });
 
   const input = requests.map((r) => JSON.stringify(r) + "\n").join("");
@@ -992,4 +1001,333 @@ test("minimal.ts mcp without opt-in fails", async () => {
   const { stderr, exitCode } = await $`bun run examples/minimal.ts mcp`.nothrow().quiet();
   expect(exitCode).toBe(1);
   expect(stderr.toString()).toContain("mcp");
+});
+
+test("ctx.invocation is cli via cliRun", async () => {
+  const indexPath = join(import.meta.dir, "index.ts");
+  const { stdout } = await $`bun -e ${`
+import { cliRun, CliCommand } from ${JSON.stringify(indexPath)};
+const cli = { key: "t", description: "d", handler: (ctx) => console.log(ctx.invocation) };
+await cliRun(cli, []);
+  `}`.quiet();
+  expect(stdout.toString().trim()).toBe("cli");
+});
+
+test("ctx.invocation is mcp via cliInvoke", async () => {
+  let seen = "";
+  const root: CliCommand = {
+    key: "app",
+    description: "",
+    handler: (ctx) => {
+      seen = ctx.invocation;
+    },
+  };
+  cliValidateRoot(root);
+  const result = await cliInvoke(root, []);
+  expect(result.kind).toBe("ok");
+  expect(seen).toBe("mcp");
+});
+
+const enumMcpFixture: CliCommand = {
+  key: "app",
+  description: "",
+  mcpServer: {},
+  commands: [
+    {
+      key: "run",
+      description: "Run with mode.",
+      options: [
+        {
+          name: "mode",
+          description: "Mode.",
+          kind: CliOptionKind.Enum,
+          choices: ["dev", "prod"],
+          required: true,
+        },
+      ],
+      handler: () => {},
+    },
+  ],
+};
+
+test("Enum option inputSchema includes enum array", () => {
+  const tools = collectMcpTools(enumMcpFixture);
+  const run = tools.find((t) => t.name === "run")!;
+  const schema = run.inputSchema as { properties: { mode: { enum?: string[] } } };
+  expect(schema.properties.mode.enum).toEqual(["dev", "prod"]);
+});
+
+test("cliInvoke rejects invalid Enum value", async () => {
+  const root: CliCommand = {
+    key: "app",
+    description: "",
+    handler: () => {},
+    options: [
+      {
+        name: "mode",
+        description: "Mode.",
+        kind: CliOptionKind.Enum,
+        choices: ["dev", "prod"],
+        required: true,
+      },
+    ],
+  };
+  cliValidateRoot(root);
+  const result = await cliInvoke(root, ["--mode", "staging"]);
+  expect(result.kind).toBe("error");
+  expect(result.errorMsg).toContain("not one of");
+});
+
+test("cliInvoke accepts valid Enum value", async () => {
+  const root: CliCommand = {
+    key: "app",
+    description: "",
+    handler: (ctx) => {
+      console.log(ctx.stringOpt("mode"));
+    },
+    options: [
+      {
+        name: "mode",
+        description: "Mode.",
+        kind: CliOptionKind.Enum,
+        choices: ["dev", "prod"],
+        required: true,
+      },
+    ],
+  };
+  cliValidateRoot(root);
+  const result = await cliInvoke(root, ["--mode", "dev"]);
+  expect(result.kind).toBe("ok");
+  expect(result.stdout.trim()).toBe("dev");
+});
+
+test("cliValidateRoot rejects Enum with no choices", () => {
+  const root: CliCommand = {
+    key: "app",
+    description: "",
+    handler: () => {},
+    options: [{ name: "mode", description: "", kind: CliOptionKind.Enum, choices: [] }],
+  };
+  expect(() => cliValidateRoot(root)).toThrow(/requires non-empty choices/);
+});
+
+test("cliValidateRoot rejects Enum with duplicate choices", () => {
+  const root: CliCommand = {
+    key: "app",
+    description: "",
+    handler: () => {},
+    options: [{ name: "mode", description: "", kind: CliOptionKind.Enum, choices: ["a", "a"] }],
+  };
+  expect(() => cliValidateRoot(root)).toThrow(/choices must be distinct/);
+});
+
+test("mcpTool.description override wins without requiresEnv suffix", () => {
+  const root: CliCommand = {
+    key: "app",
+    description: "",
+    mcpServer: {},
+    commands: [
+      {
+        key: "x",
+        description: "Leaf desc.",
+        mcpTool: { description: "custom", requiresEnv: ["TOKEN"] },
+        handler: () => {},
+      },
+    ],
+  };
+  const tools = collectMcpTools(root);
+  expect(tools[0]!.description).toBe("custom");
+});
+
+test("mcpTool.requiresEnv appended to auto description", () => {
+  const root: CliCommand = {
+    key: "app",
+    description: "",
+    mcpServer: {},
+    commands: [
+      {
+        key: "x",
+        description: "Leaf desc.",
+        mcpTool: { requiresEnv: ["TOKEN"] },
+        handler: () => {},
+      },
+    ],
+  };
+  const tools = collectMcpTools(root);
+  expect(tools[0]!.description).toContain("[requires env: TOKEN]");
+});
+
+test("cliValidateRoot rejects duplicate mcpResources URIs", () => {
+  const root: CliCommand = {
+    key: "app",
+    description: "",
+    mcpServer: {
+      resources: [
+        { uri: "a://1", name: "a", load: () => "a" },
+        { uri: "a://1", name: "b", load: () => "b" },
+      ],
+    },
+    commands: [{ key: "x", description: "", handler: () => {} }],
+  };
+  expect(() => cliValidateRoot(root)).toThrow(/URIs must be unique/);
+});
+
+test("cliValidateRoot rejects resource URI matching schemaResourceUri", () => {
+  const root: CliCommand = {
+    key: "app",
+    description: "",
+    mcpServer: {
+      schemaResourceUri: "custom://schema",
+      resources: [{ uri: "custom://schema", name: "dup", load: () => "" }],
+    },
+    commands: [{ key: "x", description: "", handler: () => {} }],
+  };
+  expect(() => cliValidateRoot(root)).toThrow(/conflicts with the built-in schema resource/);
+});
+
+test("allMcpResources includes custom resources", () => {
+  const root: CliCommand = {
+    key: "app",
+    description: "",
+    mcpServer: {
+      resources: [{ uri: "test://x", name: "x", load: () => "body" }],
+    },
+    commands: [{ key: "leaf", description: "", handler: () => {} }],
+  };
+  const resources = allMcpResources(root);
+  expect(resources.map((r) => r.uri)).toContain("argsbarg://schema");
+  expect(resources.map((r) => r.uri)).toContain("test://x");
+});
+
+test("applyShellEnv merges PATH and preserves host vars", () => {
+  const origPath = process.env.PATH ?? "";
+  const origHome = process.env.HOME;
+  process.env.PATH = "/host/bin";
+  process.env.HOME = "host-home";
+  applyShellEnv({ PATH: "/shell/bin:/host/bin", HOME: "shell-home", NEWVAR: "yes" });
+  expect(process.env.PATH?.startsWith("/shell/bin:")).toBe(true);
+  expect(process.env.PATH).toContain("/host/bin");
+  expect(process.env.HOME).toBe("host-home");
+  expect(process.env.NEWVAR).toBe("yes");
+  process.env.PATH = origPath;
+  if (origHome === undefined) {
+    delete process.env.HOME;
+  } else {
+    process.env.HOME = origHome;
+  }
+  delete process.env.NEWVAR;
+});
+
+test("loadEnvFile overwrites existing keys", () => {
+  const dir = mkdtempSync(join(tmpdir(), "argsbarg-env-"));
+  const file = join(dir, ".env");
+  writeFileSync(file, "FOO=fromfile\n", "utf8");
+  process.env.FOO = "original";
+  loadEnvFile(file);
+  expect(process.env.FOO).toBe("fromfile");
+  delete process.env.FOO;
+});
+
+test("Enum completions list choices in bash script", () => {
+  const root: CliCommand = {
+    key: "app",
+    description: "",
+    commands: [
+      {
+        key: "run",
+        description: "",
+        options: [
+          { name: "mode", description: "m", kind: CliOptionKind.Enum, choices: ["dev", "prod"] },
+        ],
+        handler: () => {},
+      },
+    ],
+  };
+  const bash = completionBashScript(root);
+  expect(bash).toContain("--mode) COMPREPLY=");
+  expect(bash).toContain("dev");
+  expect(bash).toContain("prod");
+});
+
+test("MCP resources/list includes custom resource", async () => {
+  const responses = await mcpRequest(
+    [{ jsonrpc: "2.0", id: 10, method: "resources/list", params: {} }],
+    { script: "examples/mcp-test.ts" },
+  );
+  const res = responses.get(10) as { result: { resources: { uri: string }[] } };
+  const uris = res.result.resources.map((r) => r.uri);
+  expect(uris).toContain("argsbarg://schema");
+  expect(uris).toContain("test://hello");
+});
+
+test("MCP resources/read returns custom resource body", async () => {
+  const responses = await mcpRequest(
+    [{ jsonrpc: "2.0", id: 11, method: "resources/read", params: { uri: "test://hello" } }],
+    { script: "examples/mcp-test.ts" },
+  );
+  const res = responses.get(11) as { result: { contents: { text: string }[] } };
+  expect(res.result.contents[0]!.text).toBe("hello resource");
+});
+
+test("MCP resources/read unknown URI returns error", async () => {
+  const responses = await mcpRequest(
+    [{ jsonrpc: "2.0", id: 12, method: "resources/read", params: { uri: "missing://nope" } }],
+    { script: "examples/mcp-test.ts" },
+  );
+  const res = responses.get(12) as { error: { code: number } };
+  expect(res.error.code).toBe(-32602);
+});
+
+test("MCP requiresEnv fails when env missing", async () => {
+  const responses = await mcpRequest(
+    [
+      {
+        jsonrpc: "2.0",
+        id: 13,
+        method: "tools/call",
+        params: { name: "echo_env", arguments: { name: "ARGS_TEST_SECRET" } },
+      },
+    ],
+    { script: "examples/mcp-test.ts", env: { ARGS_TEST_SECRET: "" } },
+  );
+  const res = responses.get(13) as { result: { isError: boolean; content: { text: string }[] } };
+  expect(res.result.isError).toBe(true);
+  expect(res.result.content[0]!.text).toContain("ARGS_TEST_SECRET");
+});
+
+test("MCP requiresEnv succeeds when env present", async () => {
+  const responses = await mcpRequest(
+    [
+      {
+        jsonrpc: "2.0",
+        id: 14,
+        method: "tools/call",
+        params: { name: "echo_env", arguments: { name: "ARGS_TEST_SECRET" } },
+      },
+    ],
+    { script: "examples/mcp-test.ts", env: { ARGS_TEST_SECRET: "sekrit" } },
+  );
+  const res = responses.get(14) as { result: { isError: boolean; content: { text: string }[] } };
+  expect(res.result.isError).toBe(false);
+  expect(res.result.content[0]!.text.trim()).toBe("sekrit");
+});
+
+test("MCP envFile loads vars for tool handlers", async () => {
+  const dir = mkdtempSync(join(tmpdir(), "argsbarg-mcp-"));
+  const envFile = join(dir, "mcp.env");
+  writeFileSync(envFile, "ARGS_FILE_TOKEN=file-value\n", "utf8");
+  const responses = await mcpRequest(
+    [
+      {
+        jsonrpc: "2.0",
+        id: 15,
+        method: "tools/call",
+        params: { name: "echo_env", arguments: { name: "ARGS_FILE_TOKEN" } },
+      },
+    ],
+    { script: "examples/mcp-test.ts", env: { ARGS_TEST_ENV_FILE: envFile, ARGS_TEST_SECRET: "present" } },
+  );
+  const res = responses.get(15) as { result: { isError: boolean; content: { text: string }[] } };
+  expect(res.result.isError).toBe(false);
+  expect(res.result.content[0]!.text.trim()).toBe("file-value");
 });

package/src/index.ts

@@ -7,8 +7,19 @@ It gives consumers one stable import path without forcing them to know the inter
 module layout.
 */
 
+export { cliInvoke } from "./invoke.ts";
+export type { CliInvokeKind, CliInvokeResult } from "./invoke.ts";
 export { CliContext } from "./context.ts";
 export { cliErrWithHelp, cliRun } from "./runtime";
 export { CliFallbackMode, CliOptionKind, CliSchemaValidationError } from "./types.ts";
-export type { CliCommand, CliHandler, CliMcpServerConfig, CliMcpToolConfig, CliOption, CliPositional } from "./types.ts";
+export type {
+  CliCommand,
+  CliHandler,
+  CliInvocation,
+  CliMcpResource,
+  CliMcpServerConfig,
+  CliMcpToolConfig,
+  CliOption,
+  CliPositional,
+} from "./types.ts";
 export { isInteractiveTty } from "./utils.ts";

package/src/invoke.ts

@@ -108,7 +108,7 @@ export async function cliInvoke(root: CliCommand, argv: string[]): Promise<CliIn
   }
 
   const handler = current.handler;
-  const ctx = new CliContext(root.key, pr.path, pr.args, pr.opts, root);
+  const ctx = new CliContext(root.key, pr.path, pr.args, pr.opts, root, "mcp");
 
   let stdout = "";
   let stderr = "";

package/src/mcp/env.ts

@@ -0,0 +1,99 @@
+/*
+This module bootstraps process.env for MCP servers from login shell and .env files.
+*/
+
+import { readFileSync } from "node:fs";
+import { spawnSync } from "node:child_process";
+
+/** Parses `env` stdout from a login shell into a key/value map. */
+export function captureShellEnv(shell: string): Record<string, string> {
+  const result = spawnSync(shell, ["-l", "-c", "env"], {
+    encoding: "utf8",
+    timeout: 5000,
+  });
+  if (result.error || result.status !== 0) {
+    return {};
+  }
+  const env: Record<string, string> = {};
+  for (const line of result.stdout.split("\n")) {
+    const eq = line.indexOf("=");
+    if (eq > 0) {
+      env[line.slice(0, eq)] = line.slice(eq + 1);
+    }
+  }
+  return env;
+}
+
+/** Merges captured shell env into process.env (PATH merged; host wins for other keys). */
+export function applyShellEnv(env: Record<string, string>): void {
+  for (const [key, val] of Object.entries(env)) {
+    if (key === "PATH") {
+      const existing = process.env.PATH ?? "";
+      const existingParts = new Set(existing.split(":"));
+      const shellOnly = val.split(":").filter((p) => p.length > 0 && !existingParts.has(p));
+      if (shellOnly.length > 0) {
+        process.env.PATH = [...shellOnly, existing].join(":");
+      }
+    } else if (process.env[key] === undefined) {
+      process.env[key] = val;
+    }
+  }
+}
+
+/** 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 {
+  const shellEnvCfg = config.shellEnv;
+  if (shellEnvCfg) {
+    const shell =
+      typeof shellEnvCfg === "string"
+        ? shellEnvCfg
+        : (process.env.SHELL ?? (process.platform === "darwin" ? "/bin/zsh" : "/bin/bash"));
+    const captured = captureShellEnv(shell);
+    if (Object.keys(captured).length === 0) {
+      process.stderr.write(`[argsbarg] shellEnv: failed to capture shell environment from ${shell}\n`);
+    } else {
+      applyShellEnv(captured);
+    }
+  }
+  if (config.envFile) {
+    loadEnvFile(config.envFile);
+  }
+}

package/src/mcp/server.ts

@@ -4,13 +4,12 @@ resources, and ping. Responses are newline-delimited JSON on stdout only.
 */
 
 import { cliInvoke } from "../invoke.ts";
-import { cliSchemaJson } from "../schema.ts";
 import { CliCommand } from "../types.ts";
 import { buildToolCallSuccess } from "./result.ts";
 import {
+  allMcpResources,
   collectMcpTools,
   mcpToolCallToArgv,
-  resolveMcpSchemaUri,
   resolveMcpServerInfo,
 } from "./tools.ts";
 
@@ -118,6 +117,18 @@ async function handleRequestLine(root: CliCommand, line: string): Promise<void>
         writeError(id, -32602, `Unknown tool: ${name}`);
         return;
       }
+      const missingEnv = (tool.leaf.mcpTool?.requiresEnv ?? []).filter((k) => !process.env[k]);
+      if (missingEnv.length > 0) {
+        writeResponse({
+          jsonrpc: "2.0",
+          id,
+          result: {
+            content: [{ type: "text", text: `Missing required env: ${missingEnv.join(", ")}` }],
+            isError: true,
+          },
+        });
+        return;
+      }
       const argvResult = mcpToolCallToArgv(root, tool, (rawArgs ?? {}) as Record<string, unknown>);
       if ("error" in argvResult) {
         writeResponse({
@@ -152,21 +163,13 @@ async function handleRequestLine(root: CliCommand, line: string): Promise<void>
     }
 
     if (method === "resources/list") {
-      const uri = resolveMcpSchemaUri(root);
-      writeResponse({
-        jsonrpc: "2.0",
-        id,
-        result: {
-          resources: [
-            {
-              uri,
-              name: "cli-schema",
-              description: "Full CLI command tree (same as --schema).",
-              mimeType: "application/json",
-            },
-          ],
-        },
-      });
+      const resources = allMcpResources(root).map((r) => ({
+        uri: r.uri,
+        name: r.name,
+        description: r.description,
+        mimeType: r.mimeType,
+      }));
+      writeResponse({ jsonrpc: "2.0", id, result: { resources } });
       return;
     }
 
@@ -176,20 +179,29 @@ async function handleRequestLine(root: CliCommand, line: string): Promise<void>
         writeError(id, -32602, "Invalid params: uri required");
         return;
       }
-      const expected = resolveMcpSchemaUri(root);
-      if (uri !== expected) {
+      const all = allMcpResources(root);
+      const found = all.find((r) => r.uri === uri);
+      if (!found) {
         writeError(id, -32602, `Unknown resource: ${uri}`);
         return;
       }
+      let text: string;
+      try {
+        text = found.load();
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        writeError(id, -32603, `Resource load failed: ${message}`);
+        return;
+      }
       writeResponse({
         jsonrpc: "2.0",
         id,
         result: {
           contents: [
             {
-              uri: expected,
-              mimeType: "application/json",
-              text: cliSchemaJson(root).trimEnd(),
+              uri: found.uri,
+              mimeType: found.mimeType,
+              text,
             },
           ],
         },

package/src/mcp/tools.ts

@@ -6,6 +6,7 @@ flat JSON tool arguments into argv for cliInvoke.
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
 import { collectOptionDefs } from "../parse.ts";
+import { cliSchemaJson } from "../schema.ts";
 import { CliCommand, CliOption, CliOptionKind, CliPositional } from "../types.ts";
 
 /** Default URI for the CLI schema MCP resource. */
@@ -54,6 +55,8 @@ function optionProperty(opt: CliOption): Record<string, unknown> {
       return { type: "string", ...base };
     case CliOptionKind.Number:
       return { type: "number", ...base };
+    case CliOptionKind.Enum:
+      return { type: "string", enum: opt.choices, ...base };
   }
 }
 
@@ -98,6 +101,48 @@ function buildInputSchema(root: CliCommand, path: string[], leaf: CliCommand): R
   return schema;
 }
 
+/** Resolves MCP tool description with optional override and requiresEnv suffix. */
+function resolveToolDescription(root: CliCommand, path: string[], leaf: CliCommand): string {
+  if (leaf.mcpTool?.description) {
+    return leaf.mcpTool.description;
+  }
+  let desc = mcpToolDescription(path, root.key, leaf.description);
+  const env = leaf.mcpTool?.requiresEnv;
+  if (env && env.length > 0) {
+    desc += ` [requires env: ${env.join(", ")}]`;
+  }
+  return desc;
+}
+
+/** One resolved MCP resource (built-in or user-defined). */
+export interface McpResourceEntry {
+  uri: string;
+  name: string;
+  description?: string;
+  mimeType: string;
+  load: () => string;
+}
+
+/** Returns built-in schema resource plus user mcpServer.resources. */
+export function allMcpResources(root: CliCommand): McpResourceEntry[] {
+  const schemaUri = resolveMcpSchemaUri(root);
+  const builtIn: McpResourceEntry = {
+    uri: schemaUri,
+    name: "cli-schema",
+    description: "Full CLI command tree (same as --schema).",
+    mimeType: "application/json",
+    load: () => cliSchemaJson(root),
+  };
+  const user = (root.mcpServer?.resources ?? []).map((r) => ({
+    uri: r.uri,
+    name: r.name,
+    description: r.description,
+    mimeType: r.mimeType ?? "text/plain",
+    load: r.load,
+  }));
+  return [builtIn, ...user];
+}
+
 /** Recursively collects MCP tool definitions from user leaf commands. */
 export function collectMcpTools(root: CliCommand): McpToolDef[] {
   const out: McpToolDef[] = [];
@@ -113,7 +158,7 @@ export function collectMcpTools(root: CliCommand): McpToolDef[] {
       }
       out.push({
         name: mcpToolName(root, path),
-        description: mcpToolDescription(path, root.key, cmd.description),
+        description: resolveToolDescription(root, path, cmd),
         path,
         leaf: cmd,
         inputSchema: buildInputSchema(root, path, cmd),

package/src/mcp.ts

@@ -3,6 +3,7 @@ This module starts the ArgsBarg MCP stdio server for opt-in program roots.
 */
 
 import { mcpServeStdioLoop } from "./mcp/server.ts";
+import { bootstrapMcpEnv } from "./mcp/env.ts";
 import { CliCommand } from "./types.ts";
 
 /**
@@ -11,6 +12,9 @@ import { CliCommand } from "./types.ts";
  */
 export async function cliMcpServeStdio(root: CliCommand): Promise<never> {
   try {
+    if (root.mcpServer) {
+      bootstrapMcpEnv(root.mcpServer);
+    }
     await mcpServeStdioLoop(root);
     process.exit(0);
   } catch (err) {