From 85ac88fe87631fec26c3daa1b2e8e54d0f13d508 Mon Sep 17 00:00:00 2001 From: morluto <76467478+morluto@users.noreply.github.com> Date: Thu, 19 Nov 2026 11:59:09 +0800 Subject: [PATCH] fix(cli): classify MCP launcher arguments once (#12152) Refs #12129 --- scripts/rea.mjs | 31 ++-- src/cliBuiltinArguments.ts | 134 +++++++++++++++++- src/main.ts | 9 +- src/main/mcpHttpArguments.ts | 52 ++----- src/server/http/serveStreamableHttp.test.ts | 21 ++- tests/boundary/cli/cliTimingArguments.test.ts | 54 ++++--- tests/boundary/cli/dispatcher.test.ts | 8 +- tests/boundary/mcp/mcpHttpOptions.test.ts | 57 +++++++- tests/support/cli/cliFixture.ts | 25 +--- 9 files changed, 258 insertions(+), 133 deletions(-) diff --git a/scripts/rea.mjs b/scripts/rea.mjs index 080f7c069e..884cb69c1a 100755 --- a/scripts/rea.mjs +++ b/scripts/rea.mjs @@ -37,21 +37,7 @@ const builtinArgumentRuntime = "dist/cli-runtime/cliBuiltinArguments.js"; const builtinArguments = (await compiledRuntimeExists([builtinArgumentRuntime])) ? await import("../dist/cli-runtime/cliBuiltinArguments.js") : undefined; -const isShellCompletion = - builtinArguments?.cliCompletionShell?.(process.env) !== undefined; -const doctorArguments = isShellCompletion - ? undefined - : builtinArguments?.productionMcpDoctorArguments(args); -const isMcpEntry = - !isShellCompletion && (args[0] === "--mcp" || args[0] === "mcp"); -const isMcpMode = isMcpEntry && args.length === 1; -const isMcpDoctorMode = doctorArguments !== undefined; -// Only flags may follow the entry: `mcp add --http` stays Incur's `mcp add`, -// while `mcp -h --http` reaches the HTTP entry's own help. -const isMcpHttpMode = - isMcpEntry && - (args[1]?.startsWith("-") ?? false) && - args.slice(1).includes("--http"); +const entry = builtinArguments?.classifyCliEntrypoint(args, process.env); /** How long an exiting command may wait for its remaining handles to close. */ const EXIT_DRAIN_GRACE_MS = 1_000; /** Exit status of a writer terminated by SIGPIPE (128 + 13). */ @@ -60,9 +46,9 @@ const SIGPIPE_EXIT_STATUS = 141; let stdoutClosed = false; const runtimeFiles = [ builtinArgumentRuntime, - ...(isMcpMode || isMcpHttpMode + ...(entry?.kind === "mcp-stdio" || entry?.kind === "mcp-http" ? ["dist/mcp/main.js"] - : isMcpDoctorMode + : entry?.kind === "mcp-doctor" ? ["dist/mcp/main.js", "dist/cli-runtime/mcpDoctor.js"] : [ "dist/cli-runtime/cli.js", @@ -76,18 +62,17 @@ if (!(await compiledRuntimeExists(runtimeFiles))) { `REA's compiled runtime is missing. Run \`npm ci && npm run build:cached\` in ${packageRoot} to install dependencies and build REA, then restart it. If this is an installed package, reinstall rea-agents.\n`, ); process.exitCode = 1; -} else if (isMcpMode) { +} else if (entry?.kind === "mcp-stdio") { const { runEntrypoint } = await import("../dist/mcp/main.js"); await runEntrypoint(); -} else if (isMcpHttpMode) { +} else if (entry?.kind === "mcp-http") { const { runMcpHttpEntrypoint } = await import("../dist/mcp/main.js"); - await runMcpHttpEntrypoint(args.slice(1)); -} else if (isMcpDoctorMode) { + await runMcpHttpEntrypoint(entry.command); +} else if (entry?.kind === "mcp-doctor") { guardClosedStdout(); // Doctor runs outside the command dispatcher, so the launcher measures its // timing global, which the global argument reader has taken out. - const { arguments: doctorCliArguments, timings: timingRequested } = - doctorArguments; + const { arguments: doctorCliArguments, timings: timingRequested } = entry; const started = performance.now(); try { const { runProductionMcpDoctorCli } = diff --git a/src/cliBuiltinArguments.ts b/src/cliBuiltinArguments.ts index 440f0793aa..94e2bc11bd 100644 --- a/src/cliBuiltinArguments.ts +++ b/src/cliBuiltinArguments.ts @@ -9,6 +9,12 @@ export const VALUED_OUTPUT_FLAGS: ReadonlySet = new Set([ "--token-offset", ]); +const spacedOutputValue = ( + flag: string, + next: string | undefined, +): string | undefined => + VALUED_OUTPUT_FLAGS.has(flag) && next ? next : undefined; + export const OUTPUT_SWITCHES: ReadonlySet = new Set([ "--json", "--full-output", @@ -80,10 +86,11 @@ const normalizeCliArguments = (arguments_: readonly string[]): string[] => { let rootUpdate = true; for (let index = 0; index < arguments_.length; index += 1) { const argument = arguments_[index]!; - if (VALUED_OUTPUT_FLAGS.has(argument) && arguments_[index + 1]) { + const outputValue = spacedOutputValue(argument, arguments_[index + 1]); + if (outputValue !== undefined) { // A nonempty spaced value is consumed before looking for more flags. // Its contents belong to that option, even when they look like a flag. - normalized.push(argument, arguments_[index + 1]!); + normalized.push(argument, outputValue); index += 1; continue; } @@ -134,7 +141,7 @@ export const parseCliGlobalArguments = ( flags.add(argument); continue; } - if (VALUED_OUTPUT_FLAGS.has(argument) && next) { + if (spacedOutputValue(argument, next) !== undefined) { outputValues.push({ flag: argument, index: index + 1 }); index += 1; continue; @@ -275,7 +282,7 @@ export const isProjectScopedAmpRegistration = ({ * the `mcp doctor` words and the timing global the launcher measures. Returns * undefined for any other command. */ -export const productionMcpDoctorArguments = ( +const productionMcpDoctorArguments = ( arguments_: readonly string[], ): | { readonly arguments: readonly string[]; readonly timings: boolean } @@ -336,3 +343,122 @@ export const CLI_COMPLETION_SHELLS = [ ] as const; export const cliCompletionShell = (environment: Readonly) => CLI_COMPLETION_SHELLS.find((shell) => shell === environment.COMPLETE); + +type McpHttpCommandProblem = + | { readonly kind: "help" } + | { readonly kind: "invalid"; readonly message: string }; + +export type McpHttpCommand = + | McpHttpCommandProblem + | { + readonly kind: "listen"; + readonly host: string | undefined; + readonly port: string | undefined; + readonly allowedHosts: readonly string[]; + }; + +const invalidMcpHttpCommand = (message: string): McpHttpCommandProblem => ({ + kind: "invalid", + message, +}); + +const MCP_HTTP_VALUED_FLAGS: ReadonlySet = new Set([ + "--host", + "--port", + "--allowed-hosts", +]); + +const MCP_HTTP_HELP_FLAGS: ReadonlySet = new Set(["--help", "-h"]); + +const readMcpHttpOption = (argument: string, next: string | undefined) => { + const separator = argument.indexOf("="); + return separator === -1 + ? { + flag: argument, + inline: false, + value: next?.startsWith("-") ? undefined : next, + } + : { + flag: argument.slice(0, separator), + inline: true, + value: argument.slice(separator + 1), + }; +}; + +/** Read the transport syntax once, retaining the first help or refusal while looking for the mode. */ +const readMcpHttpCommand = ( + arguments_: readonly string[], +): McpHttpCommand | undefined => { + let mode: "explicit" | "required" | undefined; + const values = new Map(); + const allowedHosts: string[] = []; + let problem: McpHttpCommandProblem | undefined; + for (let index = 0; index < arguments_.length; index += 1) { + const argument = arguments_[index]!; + if (MCP_HTTP_HELP_FLAGS.has(argument)) { + problem ??= { kind: "help" }; + continue; + } + if (argument === "--http") { + mode = "explicit"; + continue; + } + const next = arguments_[index + 1]; + const { flag, inline, value } = readMcpHttpOption(argument, next); + if (MCP_HTTP_VALUED_FLAGS.has(flag)) { + mode ??= "required"; + if (value === undefined) { + problem ??= invalidMcpHttpCommand(`Missing value for ${flag}`); + } else { + if (flag === "--allowed-hosts") allowedHosts.push(value); + else values.set(flag, value); + if (!inline) index += 1; + } + continue; + } + problem ??= invalidMcpHttpCommand( + `Unknown mcp --http argument: ${argument}`, + ); + // A subcommand or an option delimiter ends mode selection. Global + // output values belong to the one-shot CLI even if they spell --http. + if (!argument.startsWith("-") || argument === "--") break; + if (!inline && spacedOutputValue(flag, next) !== undefined) index += 1; + } + if (mode === undefined) return undefined; + if (problem !== undefined) return problem; + if (mode === "required") + return invalidMcpHttpCommand("--host and --port require --http"); + return { + kind: "listen", + host: values.get("--host"), + port: values.get("--port"), + allowedHosts, + }; +}; + +type CliEntrypoint = + | { readonly kind: "cli" | "mcp-stdio" } + | { readonly kind: "mcp-http"; readonly command: McpHttpCommand } + | { + readonly kind: "mcp-doctor"; + readonly arguments: readonly string[]; + readonly timings: boolean; + }; + +/** Select the process entry before loading its runtime, including completion requests. */ +export const classifyCliEntrypoint = ( + arguments_: readonly string[], + environment: Readonly, +): CliEntrypoint => { + if (cliCompletionShell(environment) !== undefined) return { kind: "cli" }; + const entry = arguments_[0]; + if (entry === "mcp" || entry === "--mcp") { + if (arguments_.length === 1) return { kind: "mcp-stdio" }; + const command = readMcpHttpCommand(arguments_.slice(1)); + if (command !== undefined) return { kind: "mcp-http", command }; + } + const doctor = productionMcpDoctorArguments(arguments_); + return doctor === undefined + ? { kind: "cli" } + : { kind: "mcp-doctor", ...doctor }; +}; diff --git a/src/main.ts b/src/main.ts index f00638e858..c209d430ed 100644 --- a/src/main.ts +++ b/src/main.ts @@ -10,6 +10,7 @@ import { import { serveStdio } from "@modelcontextprotocol/server/stdio"; import { parseConfig } from "./config/parseConfig.js"; +import type { McpHttpCommand } from "./cliBuiltinArguments.js"; import { projectAnalysisError } from "./domain/analysisErrorProjection.js"; import type { RuntimeDependencies } from "./main/types.js"; import { runDeferred } from "./main/deferredRuntime.js"; @@ -160,14 +161,14 @@ const processIo: EntrypointIo = { }, }; -/** Run `rea mcp --http`: parse its flags, resolve MCP_HOST/MCP_PORT, then serve over HTTP. */ +/** Validate the selected HTTP command, resolve MCP_HOST/MCP_PORT, then serve over HTTP. */ export const runMcpHttpEntrypoint = async ( - arguments_: readonly string[], + command: McpHttpCommand, io: EntrypointIo = processIo, ): Promise => { - const { parseMcpHttpArguments, renderMcpHttpHelp } = + const { validateMcpHttpCommand, renderMcpHttpHelp } = await import("./main/mcpHttpArguments.js"); - const parsed = parseMcpHttpArguments(arguments_); + const parsed = validateMcpHttpCommand(command); if (!parsed.ok) { if (parsed.help) { io.writeStdout(`${renderMcpHttpHelp()}\n`); diff --git a/src/main/mcpHttpArguments.ts b/src/main/mcpHttpArguments.ts index 8d6e612c87..9d83623427 100644 --- a/src/main/mcpHttpArguments.ts +++ b/src/main/mcpHttpArguments.ts @@ -1,4 +1,5 @@ import { formatCommandHelp } from "../cli/help.js"; +import type { McpHttpCommand } from "../cliBuiltinArguments.js"; import { z } from "zod"; import type { HttpHostname } from "../domain/httpHostname.js"; @@ -39,12 +40,6 @@ const MCP_HTTP_ALIAS = { help: "h" } as const; const MCP_HTTP_COMMAND = "rea mcp --http"; const MCP_HTTP_DESCRIPTION = "Serve the MCP server over streamable HTTP for one local client"; -const HELP_FLAGS: ReadonlySet = new Set(["--help", "-h"]); -const VALUED_FLAGS: ReadonlySet = new Set([ - "--host", - "--port", - "--allowed-hosts", -]); /** Render help for the dispatcher entry, which accepts no global options. */ export const renderMcpHttpHelp = (): string => @@ -72,49 +67,24 @@ const invalid = (message: string): McpHttpArguments => ({ message, }); -/** Split `--flag=value` into its flag and inline value. */ -const splitFlag = (argument: string): readonly [string, string | undefined] => { - const separator = argument.indexOf("="); - return separator === -1 - ? [argument, undefined] - : [argument.slice(0, separator), argument.slice(separator + 1)]; -}; - -/** Parse the dispatcher arguments after `mcp`; help wins only in flag position. */ -export const parseMcpHttpArguments = ( - arguments_: readonly string[], +/** Validate the transport options selected by the executable dispatcher. */ +export const validateMcpHttpCommand = ( + command: McpHttpCommand, ): McpHttpArguments => { - const values = new Map(); - const allowedHostValues: string[] = []; - let http = false; - for (let index = 0; index < arguments_.length; index += 1) { - const argument = arguments_[index] ?? ""; - if (HELP_FLAGS.has(argument)) return { ok: false, help: true }; - if (argument === "--http") { - http = true; - continue; - } - const [flag, inline] = splitFlag(argument); - if (!VALUED_FLAGS.has(flag)) - return invalid(`Unknown mcp --http argument: ${argument}`); - const value = inline ?? arguments_[index + 1]; - if (inline === undefined) index += 1; - if (value === undefined || (inline === undefined && value.startsWith("-"))) - return invalid(`Missing value for ${flag}`); - if (flag === "--allowed-hosts") allowedHostValues.push(value); - else values.set(flag, value); - } - if (!http) return invalid("--host and --port require --http"); - const host = values.get("--host")?.trim(); + if (command.kind === "help") return { ok: false, help: true }; + if (command.kind === "invalid") return invalid(command.message); + const host = command.host?.trim(); if (host !== undefined && host.length === 0) return invalid("--host must be a non-empty host name or IP address"); - const portText = values.get("--port"); + const portText = command.port; const port = portText === undefined ? undefined : mcpHttpPortSchema.safeParse(portText); if (port !== undefined && !port.success) return invalid(`Invalid --port: ${MCP_HTTP_PORT_CONSTRAINT}`); const allowedHostsText = - allowedHostValues.length === 0 ? undefined : allowedHostValues.join(","); + command.allowedHosts.length === 0 + ? undefined + : command.allowedHosts.join(","); const allowedHosts = allowedHostsText === undefined ? undefined diff --git a/src/server/http/serveStreamableHttp.test.ts b/src/server/http/serveStreamableHttp.test.ts index d7f7b9e42d..d400e7ebad 100644 --- a/src/server/http/serveStreamableHttp.test.ts +++ b/src/server/http/serveStreamableHttp.test.ts @@ -26,7 +26,8 @@ import { } from "./serveStreamableHttp.js"; import { StreamableHttpListenError } from "./streamableHttpListenError.js"; import { mcpAllowedHostsTextSchema } from "../../config/mcpHttpEndpoint.js"; -import { parseMcpHttpArguments } from "../../main/mcpHttpArguments.js"; +import { classifyCliEntrypoint } from "../../cliBuiltinArguments.js"; +import { validateMcpHttpCommand } from "../../main/mcpHttpArguments.js"; import { RequestTrackingMcpServer } from "../RequestTrackingMcpServer.js"; import { waitFor } from "../../../tests/support/testWait.js"; import { ProviderCleanupError } from "../../domain/providerCleanupError.js"; @@ -354,12 +355,18 @@ it.each([ }); it("serves every declared repeated host while refusing undeclared hosts and origins", async () => { - const parsed = parseMcpHttpArguments([ - "--http", - "--allowed-hosts", - "a.example", - "--allowed-hosts=b.example", - ]); + const entry = classifyCliEntrypoint( + [ + "mcp", + "--http", + "--allowed-hosts", + "a.example", + "--allowed-hosts=b.example", + ], + {}, + ); + if (entry.kind !== "mcp-http") throw new Error("Expected an MCP HTTP entry"); + const parsed = validateMcpHttpCommand(entry.command); if (!parsed.ok || parsed.allowedHosts === undefined) throw new Error("Expected valid repeated host lists"); const { served } = await start({ diff --git a/tests/boundary/cli/cliTimingArguments.test.ts b/tests/boundary/cli/cliTimingArguments.test.ts index 979f3786cc..e0453a6199 100644 --- a/tests/boundary/cli/cliTimingArguments.test.ts +++ b/tests/boundary/cli/cliTimingArguments.test.ts @@ -1,7 +1,7 @@ import { it, expect } from "vitest"; import { + classifyCliEntrypoint, parseCliGlobalArguments, - productionMcpDoctorArguments, } from "../../../src/cliBuiltinArguments.js"; // Observed with Incur 0.6.1 before removing the dependency. @@ -81,8 +81,12 @@ it.each([ "--timings=", ])("preserves output values and root alias with %s", (flag) => { expect( - productionMcpDoctorArguments(["mcp", "doctor", "--format", flag]), - ).toEqual({ arguments: ["--format", flag], timings: false }); + classifyCliEntrypoint(["mcp", "doctor", "--format", flag], {}), + ).toEqual({ + kind: "mcp-doctor", + arguments: ["--format", flag], + timings: false, + }); expect( parseCliGlobalArguments([flag, "--update", "--json"]).arguments, ).toEqual(["update", flag, "--json"]); @@ -99,25 +103,33 @@ it("retains the separator and its following timing-shaped data", () => { parseCliGlobalArguments(["--", "--update", "--timings=false"]).arguments, ).toEqual(["--", "--update", "--timings=false"]); expect( - productionMcpDoctorArguments([ - "mcp", - "doctor", - "--format", - "--", - "--timings=true", - ]), - ).toEqual({ arguments: ["--format", "--"], timings: true }); + classifyCliEntrypoint( + ["mcp", "doctor", "--format", "--", "--timings=true"], + {}, + ), + ).toEqual({ + kind: "mcp-doctor", + arguments: ["--format", "--"], + timings: true, + }); }); it("takes the doctor words and timing global out of the doctor's arguments", () => { expect( - productionMcpDoctorArguments([ - "--timings", - "mcp", - "--format=json", - "doctor", - "--no-timings", - "--verbose", - ]), - ).toEqual({ arguments: ["--format", "json", "--verbose"], timings: false }); - expect(productionMcpDoctorArguments(["mcp", "add"])).toBeUndefined(); + classifyCliEntrypoint( + [ + "--timings", + "mcp", + "--format=json", + "doctor", + "--no-timings", + "--verbose", + ], + {}, + ), + ).toEqual({ + kind: "mcp-doctor", + arguments: ["--format", "json", "--verbose"], + timings: false, + }); + expect(classifyCliEntrypoint(["mcp", "add"], {})).toEqual({ kind: "cli" }); }); diff --git a/tests/boundary/cli/dispatcher.test.ts b/tests/boundary/cli/dispatcher.test.ts index 2019bbc89b..ea073ad5ac 100644 --- a/tests/boundary/cli/dispatcher.test.ts +++ b/tests/boundary/cli/dispatcher.test.ts @@ -1,6 +1,5 @@ import { access, cp, symlink } from "node:fs/promises"; import { join, resolve } from "node:path"; -import { pathToFileURL } from "node:url"; import { describe, expect } from "vitest"; @@ -292,7 +291,7 @@ describe("executable dispatcher", () => { await Promise.all([ workspace.write( "dist/mcp/main.js", - 'export const runEntrypoint = () => process.stdout.write(JSON.stringify({ adapter: "mcp" })); export const runMcpHttpEntrypoint = (args) => process.stdout.write(JSON.stringify({ adapter: "mcp-http", args }));\n', + 'export const runEntrypoint = () => process.stdout.write(JSON.stringify({ adapter: "mcp" })); export const runMcpHttpEntrypoint = () => process.stdout.write(JSON.stringify({ adapter: "mcp-http" }));\n', ), workspace.write( "dist/cli-runtime/mcpDoctor.js", @@ -343,7 +342,6 @@ describe("executable dispatcher", () => { ]) await expect(invoke(args)).resolves.toEqual({ adapter: "mcp-http", - args: args.slice(1), }); await expect(invoke(["mcp", "doctor", "--http"])).resolves.toEqual({ adapter: "mcp-doctor", @@ -354,6 +352,10 @@ describe("executable dispatcher", () => { adapter: "cli", args: ["mcp", "add", "--http"], }); + await expect(invoke(["mcp", "--", "--http"])).resolves.toEqual({ + adapter: "cli", + args: ["mcp", "--", "--http"], + }); }, ); diff --git a/tests/boundary/mcp/mcpHttpOptions.test.ts b/tests/boundary/mcp/mcpHttpOptions.test.ts index 154e6eebbf..24b77d0d15 100644 --- a/tests/boundary/mcp/mcpHttpOptions.test.ts +++ b/tests/boundary/mcp/mcpHttpOptions.test.ts @@ -7,12 +7,22 @@ import { mcpAllowedHostsTextSchema, } from "../../../src/config/mcpHttpEndpoint.js"; import { projectAnalysisError } from "../../../src/domain/analysisErrorProjection.js"; +import { classifyCliEntrypoint } from "../../../src/cliBuiltinArguments.js"; import { runMcpHttpEntrypoint } from "../../../src/main.js"; import { - parseMcpHttpArguments, renderMcpHttpHelp, + validateMcpHttpCommand, } from "../../../src/main/mcpHttpArguments.js"; +const httpCommand = (args: readonly string[]) => { + const entry = classifyCliEntrypoint(["mcp", ...args], {}); + if (entry.kind !== "mcp-http") throw new Error("Expected an MCP HTTP entry"); + return entry.command; +}; + +const parseMcpHttpArguments = (args: readonly string[]) => + validateMcpHttpCommand(httpCommand(args)); + describe("rea mcp --http arguments", () => { it("accepts --http with optional host and port in either flag spelling", () => { expect(parseMcpHttpArguments(["--http"])).toEqual({ ok: true }); @@ -39,10 +49,6 @@ describe("rea mcp --http arguments", () => { ok: false, message: "Unknown mcp --http argument: add", }); - expect(parseMcpHttpArguments(["--port", "1"])).toMatchObject({ - ok: false, - message: "--host and --port require --http", - }); for (const port of ["70000", "08", "-1", "http"]) expect(parseMcpHttpArguments(["--http", `--port=${port}`])).toMatchObject( { ok: false, message: expect.stringContaining("Invalid --port") }, @@ -127,18 +133,55 @@ describe("rea mcp --http arguments", () => { }; }; const help = io(); - await runMcpHttpEntrypoint(["--http", "--help"], help); + await runMcpHttpEntrypoint(httpCommand(["--http", "--help"]), help); expect(help.stdout).toEqual([`${renderMcpHttpHelp()}\n`]); expect(help.stderr).toEqual([]); expect(help.exitCodes).toEqual([0]); const rejected = io(); - await runMcpHttpEntrypoint(["--http", "add"], rejected); + await runMcpHttpEntrypoint(httpCommand(["--http", "add"]), rejected); expect(rejected.stdout).toEqual([]); expect(rejected.stderr).toEqual(["Unknown mcp --http argument: add\n"]); expect(rejected.exitCodes).toEqual([1]); }); }); +processTest( + "keeps a flag-shaped output format with the doctor command without starting HTTP", + async ({ processes }) => { + const result = await processes.run(process.execPath, [ + fileURLToPath(new URL("../../../scripts/rea.mjs", import.meta.url)), + "mcp", + "--format", + "--http", + "doctor", + "--json", + ]); + expect(result.exitCode).toBe(1); + expect(result.stderr).toBe(""); + expect(JSON.parse(result.stdout)).toMatchObject({ + code: "VALIDATION_ERROR", + message: "Invalid output format: --http", + }); + }, +); + +processTest( + "reports an HTTP option without its mode through the compiled CLI", + async ({ processes }) => { + const result = await processes.run(process.execPath, [ + fileURLToPath(new URL("../../../scripts/rea.mjs", import.meta.url)), + "mcp", + "--port", + "8765", + ]); + expect(result).toMatchObject({ + exitCode: 1, + stdout: "", + stderr: "--host and --port require --http\n", + }); + }, +); + processTest( "rejects an invalid earlier host list before the compiled CLI opens a listener", async ({ processes }) => { diff --git a/tests/support/cli/cliFixture.ts b/tests/support/cli/cliFixture.ts index f34464b63c..39c29d1f99 100644 --- a/tests/support/cli/cliFixture.ts +++ b/tests/support/cli/cliFixture.ts @@ -1,8 +1,7 @@ import { resolve } from "node:path"; import { tmpdir } from "node:os"; import { - cliCompletionShell, - productionMcpDoctorArguments, + classifyCliEntrypoint, parseCliGlobalArguments, } from "../../../src/cliBuiltinArguments.js"; import { DEFAULT_INFO_LOGGING_COMMANDS } from "../../../src/contracts/cliCommandNames.js"; @@ -150,26 +149,6 @@ export const cliCompileCacheEnvironment = ( ...environment, }); -/** - * Mirror `scripts/rea.mjs` entry routing for invocations handled outside - * `runOneShotCli` (`rea mcp` / `rea --mcp`, `rea mcp ... --http`, and - * production `rea mcp doctor ...`). Subcommands such as `rea mcp add` and - * `rea mcp --help` still dispatch through `runOneShotCli`. - */ -const isDirectMcpLauncherEntry = ( - arguments_: readonly string[], - environment: NodeJS.ProcessEnv | undefined, -): boolean => { - if (cliCompletionShell(environment ?? {}) !== undefined) return false; - if (productionMcpDoctorArguments([...arguments_]) !== undefined) return true; - if (arguments_[0] !== "mcp" && arguments_[0] !== "--mcp") return false; - return ( - arguments_.length === 1 || - ((arguments_[1]?.startsWith("-") ?? false) && - arguments_.slice(1).includes("--http")) - ); -}; - /** * Whether the file's shared process reports this command exactly as a fresh * `rea` process would. Stdin and deadlines belong to a process; the launcher @@ -190,7 +169,7 @@ const sharedProcessCanServe = ({ terminal !== true && input === undefined && timeoutMs === undefined && - !isDirectMcpLauncherEntry(arguments_, environment) && + classifyCliEntrypoint(arguments_, environment ?? {}).kind === "cli" && (environment?.NODE_OPTIONS === undefined || environment.NODE_OPTIONS === environment[REGISTRATION_GUARD_NODE_OPTIONS_ENV]) &&