@modelcontextprotocol/inspector 1.0.1 → 2.0.0-rc.1

package/clients/launcher/build/index.js

@@ -0,0 +1,90 @@
+#!/usr/bin/env node
+import { dirname, join } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { Command } from "commander";
+import { parseLauncherArgv } from "./parse-launcher-argv.js";
+const launcherDir = dirname(fileURLToPath(import.meta.url));
+function clientEntry(client) {
+    return pathToFileURL(join(launcherDir, "..", "..", client, "build", "index.js")).href;
+}
+/**
+ * Whether to append the error stack on a top-level failure. Gated on `MCP_DEBUG`
+ * or `DEBUG` being *meaningfully* set — `"0"` / `"false"` / empty read as off, so
+ * a stray `DEBUG=0` doesn't turn stacks on (and `DEBUG` stays useful for the
+ * `debug` package's namespace filter, which is any non-empty value).
+ */
+function wantsDebugStack() {
+    const on = (v) => {
+        const s = v?.trim().toLowerCase();
+        return !!s && s !== "0" && s !== "false";
+    };
+    return on(process.env.MCP_DEBUG) || on(process.env.DEBUG);
+}
+const program = new Command();
+program
+    .name("mcp-inspector")
+    .description("MCP Inspector – run web UI, CLI, or TUI")
+    .option("--web", "Run web UI (default)")
+    .option("--cli", "Run CLI")
+    .option("--tui", "Run TUI");
+let parsedArgv;
+try {
+    parsedArgv = parseLauncherArgv(process.argv);
+}
+catch (err) {
+    const message = err instanceof Error ? err.message : "Invalid launcher arguments.";
+    console.error(`Error: ${message}`);
+    process.exit(1);
+}
+const { mode, forwardedArgv, hasPrefixModeFlag } = parsedArgv;
+const helpOnly = process.argv.includes("-h") || process.argv.includes("--help");
+if (helpOnly && !hasPrefixModeFlag) {
+    program.outputHelp();
+    console.log("\nMode flags (--web, --cli, --tui) must appear before app options. All following arguments are forwarded unchanged.");
+    process.exit(0);
+}
+async function run() {
+    if (mode === "web") {
+        const { runWeb } = await import(clientEntry("web"));
+        await runWeb(forwardedArgv);
+    }
+    else if (mode === "cli") {
+        // Route a CLI failure through the CLI's own error sink so `mcp-inspector
+        // --cli` (a module import here, so the CLI bin's own `.catch(handleError)`
+        // never fires) still honors the EXIT_CODES map and emits the JSON
+        // `{"error":…}` envelope its README documents — instead of the generic
+        // exit-1 catch-all below.
+        const { runCli, handleError } = await import(clientEntry("cli"));
+        try {
+            // On success, let `run()` resolve and the event loop drain (rather than a
+            // `process.exit(0)`) — the CLI closes its own transports, and an eager exit
+            // risks truncating a large stdout payload on a pipe (async on macOS).
+            await runCli(forwardedArgv);
+        }
+        catch (err) {
+            // A stale `cli/build` (built before handleError was exported) would make
+            // this `undefined`; fall through to the generic sink with the real message
+            // rather than throwing "handleError is not a function" over it.
+            if (typeof handleError !== "function")
+                throw err;
+            // write-then-exit like the direct bin; the envelope is a few hundred bytes,
+            // well inside the pipe buffer, so the truncation risk noted above (which is
+            // about a large stdout payload) doesn't apply to this stderr line.
+            handleError(err); // writes the envelope + process.exit(code); never returns
+        }
+    }
+    else {
+        const { runTui } = await import(clientEntry("tui"));
+        await runTui(forwardedArgv);
+    }
+}
+run().catch((err) => {
+    // Print the message, not the Error stack — a startup config error (a bad flag,
+    // the OAuth callback loopback guard) should read as actionable, not internal.
+    // The stack is still available under DEBUG / MCP_DEBUG for real faults.
+    console.error("Error running MCP Inspector:", err instanceof Error ? err.message : err);
+    if (wantsDebugStack() && err instanceof Error) {
+        console.error(err.stack);
+    }
+    process.exit(1);
+});

package/clients/launcher/build/parse-launcher-argv.js

@@ -0,0 +1,29 @@
+export const LAUNCHER_MODE_FLAGS = new Set(["--web", "--cli", "--tui"]);
+/**
+ * Launcher mode flags are read only from a contiguous prefix of user args
+ * (argv[2…]). Everything after the first non-mode token is forwarded
+ * unchanged so values like `--cli` can appear in app/server config.
+ */
+export function parseLauncherArgv(argv) {
+    const executable = argv.slice(0, 2);
+    const userArgs = argv.slice(2);
+    const prefixFlags = [];
+    let index = 0;
+    while (index < userArgs.length && LAUNCHER_MODE_FLAGS.has(userArgs[index])) {
+        prefixFlags.push(userArgs[index]);
+        index++;
+    }
+    if (prefixFlags.length > 1) {
+        throw new Error("Specify at most one of --web, --cli, or --tui.");
+    }
+    const mode = prefixFlags[0] === "--tui"
+        ? "tui"
+        : prefixFlags[0] === "--cli"
+            ? "cli"
+            : "web";
+    return {
+        mode,
+        forwardedArgv: [...executable, ...userArgs.slice(index)],
+        hasPrefixModeFlag: prefixFlags.length > 0,
+    };
+}

package/clients/tui/build/chunk-MCKGQKYU.js

@@ -0,0 +1,15 @@
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+
+export {
+  __require,
+  __commonJS
+};