Derive stdio MCP display name from the package, not the runner

The stdio add form fell back to the bare command (npx, uvx, ...) for both
the display name and namespace, so every npm-launched server landed as
"npx". Derive a name from the package/module being run instead: skip the
runner and its flags/subcommands, drop the npm scope, version, path, and the
usual MCP affixes (mcp-server-, server-, -mcp), then title-case. So
"npx -y @modelcontextprotocol/server-github" becomes "Github MCP" and
"uvx mcp-server-time" becomes "Time MCP", falling back to the raw command
when nothing meaningful can be extracted.

Author: RhysSullivan

packages/plugins/mcp/src/react/AddMcpSource.tsx

@@ -20,6 +20,7 @@ import { Input } from "@executor-js/react/components/input";
 import { Spinner } from "@executor-js/react/components/spinner";
 import { TagInput } from "@executor-js/react/components/tag-input";
 import {
+  integrationDisplayNameFromStdio,
   integrationDisplayNameFromUrl,
   slugifyNamespace,
   IntegrationIdentityFields,
@@ -57,6 +58,19 @@ function findPreset(id: string | undefined): McpPreset | undefined {
   return mcpPresets.find((p) => p.id === id);
 }
 
+// Splits the raw args field into tokens, honoring double-quoted groups so an
+// argument with spaces stays intact.
+function parseStdioArgs(raw: string): string[] {
+  if (!raw.trim()) return [];
+  const args: string[] = [];
+  const regex = /[^\s"]+|"([^"]*)"/g;
+  let match;
+  while ((match = regex.exec(raw)) !== null) {
+    args.push(match[1] ?? match[0]);
+  }
+  return args;
+}
+
 // ---------------------------------------------------------------------------
 // State machine (remote flow)
 // ---------------------------------------------------------------------------
@@ -174,7 +188,10 @@ export default function AddMcpSource(props: {
   );
   const [stdioEnvVars, setStdioEnvVars] = useState<string[]>([]);
   const stdioIdentity = useIntegrationIdentity({
-    fallbackName: isStdioPreset ? preset.name : stdioCommand,
+    fallbackName: isStdioPreset
+      ? preset.name
+      : (integrationDisplayNameFromStdio(stdioCommand, parseStdioArgs(stdioArgs), "MCP") ??
+        stdioCommand),
   });
   const [stdioAdding, setStdioAdding] = useState(false);
   const [stdioError, setStdioError] = useState<string | null>(null);
@@ -333,17 +350,6 @@ export default function AddMcpSource(props: {
 
   // ---- Stdio actions ----
 
-  const parseStdioArgs = (raw: string): string[] => {
-    if (!raw.trim()) return [];
-    const args: string[] = [];
-    const regex = /[^\s"]+|"([^"]*)"/g;
-    let match;
-    while ((match = regex.exec(raw)) !== null) {
-      args.push(match[1] ?? match[0]);
-    }
-    return args;
-  };
-
   const handleAddStdio = useCallback(async () => {
     const cmd = stdioCommand.trim();
     if (!cmd) return;

packages/react/src/plugins/integration-identity.test.ts

@@ -2,8 +2,11 @@ import { describe, expect, it } from "@effect/vitest";
 
 import {
   domainLabelFromUrl,
+  humanizeStdioToken,
+  integrationDisplayNameFromStdio,
   integrationDisplayNameFromUrl,
   pascalCaseDomainLabel,
+  stdioPackageToken,
 } from "./integration-identity";
 
 describe("integration identity URL display names", () => {
@@ -22,3 +25,43 @@ describe("integration identity URL display names", () => {
     );
   });
 });
+
+describe("integration identity stdio display names", () => {
+  it("picks the package spec past the runner and its flags", () => {
+    expect(stdioPackageToken("npx", ["-y", "@modelcontextprotocol/server-github"])).toBe(
+      "@modelcontextprotocol/server-github",
+    );
+    expect(stdioPackageToken("pnpm", ["dlx", "mcp-server-time"])).toBe("mcp-server-time");
+    expect(stdioPackageToken("uvx", ["mcp-server-time"])).toBe("mcp-server-time");
+  });
+
+  it("uses the command itself only when it is not a generic runner", () => {
+    expect(stdioPackageToken("npx", [])).toBeNull();
+    expect(stdioPackageToken("my-mcp-server", [])).toBe("my-mcp-server");
+  });
+
+  it("strips npm scope, MCP affixes, versions, and paths when humanizing", () => {
+    expect(humanizeStdioToken("@modelcontextprotocol/server-github")).toBe("Github");
+    expect(humanizeStdioToken("mcp-server-sequential-thinking")).toBe("Sequential Thinking");
+    expect(humanizeStdioToken("@scope/notion-mcp@1.2.3")).toBe("Notion");
+    expect(humanizeStdioToken("./build/index.js")).toBe("Index");
+  });
+
+  it("derives a humanized name with the kind suffix, ignoring trailing path args", () => {
+    expect(
+      integrationDisplayNameFromStdio("npx", ["-y", "@modelcontextprotocol/server-github"], "MCP"),
+    ).toBe("Github MCP");
+    expect(
+      integrationDisplayNameFromStdio(
+        "npx",
+        ["-y", "@modelcontextprotocol/server-filesystem", "/Users/me/work"],
+        "MCP",
+      ),
+    ).toBe("Filesystem MCP");
+    expect(integrationDisplayNameFromStdio("uvx", ["mcp-server-time"], "MCP")).toBe("Time MCP");
+  });
+
+  it("returns null for a bare runner so callers can fall back to the command", () => {
+    expect(integrationDisplayNameFromStdio("npx", [], "MCP")).toBeNull();
+  });
+});

packages/react/src/plugins/integration-identity.tsx

@@ -46,6 +46,96 @@ export function integrationDisplayNameFromUrl(url: string, sourceKind: string):
   return displayLabel ? `${displayLabel} ${sourceKind}` : null;
 }
 
+// Package runners whose own name is never the integration name: the meaningful
+// token is the package or module they execute, not the runner itself.
+const STDIO_RUNNERS = new Set([
+  "npx",
+  "bunx",
+  "pnpm",
+  "yarn",
+  "npm",
+  "uvx",
+  "uv",
+  "pipx",
+  "bun",
+  "deno",
+  "node",
+  "python",
+  "python3",
+]);
+
+// Subcommands that sit between a runner and its package: `pnpm dlx <pkg>`,
+// `npm exec <pkg>`, `uv run <pkg>`, `deno run <spec>`.
+const STDIO_RUNNER_SUBCOMMANDS = new Set(["dlx", "exec", "run", "x", "--"]);
+
+/**
+ * Picks the package/module spec from a stdio launch command: the first
+ * positional argument that isn't a runner flag or subcommand, falling back to
+ * the command itself when it isn't a generic runner (a server invoked
+ * directly). Returns `null` when only a bare runner is present.
+ */
+export function stdioPackageToken(command: string, args: readonly string[]): string | null {
+  for (const raw of args) {
+    const arg = raw.trim();
+    if (!arg || arg.startsWith("-")) continue; // skip flags like -y, --yes
+    if (STDIO_RUNNER_SUBCOMMANDS.has(arg)) continue; // skip dlx / exec / run
+    return arg;
+  }
+  const cmd = command.trim();
+  if (!cmd || STDIO_RUNNERS.has(cmd.toLowerCase())) return null;
+  return cmd;
+}
+
+/**
+ * Reduces a package/module spec to human words: drops an npm scope, a version
+ * or tag suffix, a path and file extension, and the noise affixes MCP packages
+ * conventionally carry (`mcp-server-`, `server-`, `-mcp`), then title-cases.
+ * Returns `null` when nothing alphanumeric survives.
+ */
+export function humanizeStdioToken(token: string): string | null {
+  let name = token.trim();
+  if (name.startsWith("@")) {
+    // Scoped npm package: @modelcontextprotocol/server-github → server-github.
+    name = name.split("/").pop() ?? name;
+  } else if (/[\\/]/.test(name)) {
+    // A filesystem path (node ./build/index.js) → its base filename.
+    name = name.split(/[\\/]/).pop() ?? name;
+    name = name.replace(/\.[a-z0-9]+$/i, ""); // strip extension
+  }
+  name = name.replace(/@[^@/]*$/, "") || name; // drop a trailing @version / @tag
+  name = name
+    .replace(/^mcp[-_]server[-_]/i, "")
+    .replace(/^mcp[-_]/i, "")
+    .replace(/^server[-_]/i, "")
+    .replace(/[-_]mcp[-_]server$/i, "")
+    .replace(/[-_]mcp$/i, "")
+    .replace(/[-_]server$/i, "");
+  const words = name
+    .split(/[^a-z0-9]+/i)
+    .map((word) => word.trim())
+    .filter(Boolean);
+  if (words.length === 0) return null;
+  return words.map((word) => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase()).join(" ");
+}
+
+/**
+ * Derives a display-name candidate from a stdio launch command by extracting
+ * the package/module being run and humanizing it, e.g.
+ * `npx -y @modelcontextprotocol/server-github` → `"Github MCP"`,
+ * `uvx mcp-server-time` → `"Time MCP"`, `node ./build/index.js` → `"Index MCP"`.
+ * Returns `null` when nothing meaningful can be extracted, so callers can fall
+ * back to the raw command.
+ */
+export function integrationDisplayNameFromStdio(
+  command: string,
+  args: readonly string[],
+  sourceKind: string,
+): string | null {
+  const token = stdioPackageToken(command, args);
+  const label = token ? humanizeStdioToken(token) : null;
+  return label ? `${label} ${sourceKind}` : null;
+}
+
 // ---------------------------------------------------------------------------
 // Hook — owns the name + namespace state with namespace auto-derivation
 // ---------------------------------------------------------------------------