feat: add MCP providers for mcp-confluent bundling

Gulpfile.js

@@ -57,6 +57,15 @@ export function clean(done) {
 
 pack.description = "Create .vsix file for the extension. Make sure to pre-build assets.";
 export function pack(done) {
+  // install runtime dependencies (e.g., the bundled MCP server) in the output directory so they're
+  // included in the .vsix; the Rollup bundle itself doesn't need these (they're marked external)
+  const npmResult = spawnSync("npm", ["install", "--production"], {
+    stdio: "inherit",
+    cwd: DESTINATION,
+    shell: IS_WINDOWS,
+  });
+  if (npmResult.error) throw npmResult.error;
+
   var vsceCommandArgs = ["vsce", "package"];
   // Check if TARGET is set, if so, add it to the command
   if (process.env.TARGET) {
@@ -141,7 +150,13 @@ export function build(done) {
       }),
     ],
     onLog: handleBuildLog,
-    external: ["vscode", "electron"],
+    external: [
+      "vscode",
+      "electron",
+      // the MCP server is spawned as a separate stdio child process and must not be bundled into
+      // the extension; require.resolve finds it in node_modules at runtime
+      /^@confluentinc\/mcp-confluent/,
+    ],
     context: "globalThis",
   };
   /** @type {import("rollup").OutputOptions} */
@@ -446,10 +461,15 @@ function pkgjson() {
           pkg.version += process.env.CI ? "" : `+${Math.random().toString(16).slice(2, 8)}`;
           // no package.type: the bundle is CommonJS module
           delete pkg.type;
-          // no dev only manifests: scripts, dependencies
+          // no dev-only manifests
           delete pkg.scripts;
-          delete pkg.dependencies;
           delete pkg.devDependencies;
+          // preserve only runtime dependencies that must ship outside the Rollup bundle
+          // (spawned as separate child processes, not imported into the extension host)
+          const runtimeDeps = ["@confluentinc/mcp-confluent"];
+          pkg.dependencies = Object.fromEntries(
+            Object.entries(pkg.dependencies || {}).filter(([k]) => runtimeDeps.includes(k)),
+          );
           // the target folder is flat so the entry point is known to be in the root
           pkg.main = "extension.js";
           return JSON.stringify(pkg, null, 2);

package.json

@@ -20,7 +20,7 @@
   },
   "icon": "resources/confluent_logo-mark-meadow.png",
   "engines": {
-    "vscode": "^1.96.2"
+    "vscode": "^1.101.0"
   },
   "categories": [
     "Programming Languages",
@@ -51,6 +51,16 @@
   ],
   "main": "./out/extension.js",
   "contributes": {
+    "mcpServerDefinitionProviders": [
+      {
+        "id": "confluent-mcp-direct",
+        "label": "Confluent MCP Server (Direct)"
+      },
+      {
+        "id": "confluent-mcp-local",
+        "label": "Confluent MCP Server (Local)"
+      }
+    ],
     "authentication": [
       {
         "id": "confluent-cloud-auth-provider",
@@ -2671,7 +2681,7 @@
     "@types/sanitize-html": "^2.13.0",
     "@types/sinon": "^17.0.3",
     "@types/tail": "^2.2.3",
-    "@types/vscode": "^1.96.0",
+    "@types/vscode": "^1.101.0",
     "@types/ws": "^8.5.13",
     "@types/yauzl": "^2.10.3",
     "@types/yazl": "^3.3.0",
@@ -2704,6 +2714,7 @@
     "yazl": "^2.5.1"
   },
   "dependencies": {
+    "@confluentinc/mcp-confluent": "^1.2.1",
     "@segment/analytics-node": "^2.1.2",
     "@sentry/node": "^9.3.0",
     "@sentry/profiling-node": "^9.3.0",

src/extension.ts

@@ -83,6 +83,7 @@ import { setFlinkWorkspaceListener } from "./flinkSql/flinkWorkspace";
 import { IconNames } from "./icons";
 import { constructResourceLoaderSingletons } from "./loaders";
 import { cleanupOldLogFiles, EXTENSION_OUTPUT_CHANNEL, Logger } from "./logging";
+import { registerMcpServerProviders } from "./mcp/serverProvider";
 import { FlinkStatementResultsPanelProvider } from "./panelProviders/flinkStatementResults";
 import { getSidecar, getSidecarManager } from "./sidecar";
 import { createLocalConnection, getLocalConnection } from "./sidecar/connections/local";
@@ -346,6 +347,8 @@ async function _activateExtension(
   chatParticipant.iconPath = new vscode.ThemeIcon(IconNames.CONFLUENT_LOGO);
   context.subscriptions.push(chatParticipant, feedbackListener, ...registerChatTools());
 
+  context.subscriptions.push(registerMcpServerProviders());
+
   // track the status bar for CCloud notices (fetched from the Statuspage Status API)
   enableCCloudStatusPolling();
   context.subscriptions.push(getCCloudStatusBarItem());

src/mcp/baseMcpServerProvider.ts

@@ -0,0 +1,157 @@
+import type {
+  CancellationToken,
+  McpServerDefinitionProvider,
+  McpStdioServerDefinition as McpStdioServerDefinitionType,
+} from "vscode";
+import { EventEmitter, McpStdioServerDefinition } from "vscode";
+import { Logger } from "../logging";
+import { DisposableCollection } from "../utils/disposables";
+
+const logger = new Logger("mcp.baseMcpServerProvider");
+
+/**
+ * Env var key used to stash the connection ID inside the {@link McpStdioServerDefinition} so that
+ * {@linkcode BaseMcpServerProvider.resolveMcpServerDefinition} can match by ID rather than label.
+ * The MCP server ignores unrecognized env vars, so this is safe to include.
+ */
+const CONNECTION_ID_ENV_KEY = "__CONFLUENT_CONNECTION_ID";
+
+/** A label + env var map pair that the base class converts into an {@link McpStdioServerDefinition}. */
+export interface McpConnectionEnvMap {
+  /** Stable identifier used to match definitions during resolve (e.g., a connection ID). */
+  id: string;
+  /** Human-readable label shown in the VS Code tool picker. */
+  label: string;
+  env: Record<string, string>;
+}
+
+/**
+ * Abstract base for connection-type-specific MCP server providers. Subclasses supply connection
+ * data via {@linkcode loadConnectionEnvMaps}; this class handles building
+ * {@link McpStdioServerDefinition} instances, version tracking, and the change-event plumbing.
+ */
+export abstract class BaseMcpServerProvider
+  extends DisposableCollection
+  implements McpServerDefinitionProvider<McpStdioServerDefinitionType>
+{
+  protected readonly changeEmitter = new EventEmitter<void>();
+  readonly onDidChangeMcpServerDefinitions = this.changeEmitter.event;
+
+  constructor() {
+    super();
+    this.disposables.push(this.changeEmitter);
+  }
+
+  /**
+   * Return one {@link McpStdioServerDefinition} per connection that has usable credentials.
+   * Called eagerly by VS Code - must not prompt for user interaction.
+   */
+  async provideMcpServerDefinitions(
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    _token: CancellationToken,
+  ): Promise<McpStdioServerDefinitionType[]> {
+    const envMaps = await this.loadConnectionEnvMaps();
+    const version = getMcpServerVersion();
+    const definitions: McpStdioServerDefinitionType[] = [];
+
+    for (const { id, label, env } of envMaps) {
+      if (Object.keys(env).length === 0) continue;
+      const def = buildServerDefinition(id, label, env, version);
+      if (!def) continue;
+      definitions.push(def);
+      logger.info(`MCP server definition created: "${label}" (${id})`);
+    }
+
+    logger.info(`Providing ${definitions.length} MCP server definition(s)`);
+    return definitions;
+  }
+
+  /**
+   * Called just before VS Code starts a server. Re-reads connection data in case it changed since
+   * {@linkcode provideMcpServerDefinitions} was last called.
+   */
+  async resolveMcpServerDefinition(
+    server: McpStdioServerDefinitionType,
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    _token: CancellationToken,
+  ): Promise<McpStdioServerDefinitionType | undefined> {
+    const envMaps = await this.loadConnectionEnvMaps();
+    const version = getMcpServerVersion();
+
+    const serverId = server.env[CONNECTION_ID_ENV_KEY];
+    for (const { id, label, env } of envMaps) {
+      if (id === serverId && Object.keys(env).length > 0) {
+        logger.info(`Resolved MCP server definition for "${label}" (${id})`);
+        return buildServerDefinition(id, label, env, version);
+      }
+    }
+
+    logger.warn(`Could not resolve MCP server definition for "${server.label}"`);
+    return undefined;
+  }
+
+  /**
+   * Load the connection-specific label + env var mappings. Each entry produces one
+   * {@link McpStdioServerDefinition}. Empty env maps are filtered out by the base class.
+   */
+  protected abstract loadConnectionEnvMaps(): Promise<McpConnectionEnvMap[]>;
+}
+
+/**
+ * Resolve the absolute filesystem path to the bundled MCP server entry point.
+ *
+ * We use `require.resolve` instead of building a path from `extensionUri` or `extensionPath`
+ * because this project's launch.json sets `extensionDevelopmentPath` to `${workspaceFolder}/out`,
+ * which means `extensionPath` points to the compiled output directory rather than the project root
+ * where `node_modules` lives. `require.resolve` walks up the directory tree to find `node_modules`
+ * using Node's standard module resolution, so it works from both the `out/` bundle (dev) and a
+ * packaged extension (production).
+ *
+ * Note: `import.meta.resolve` would be the preferred ESM approach, but the esbuild bundler strips
+ * `import.meta.resolve` in the bundled output, making it `undefined` at runtime.
+ */
+function getMcpServerEntryPath(): string | undefined {
+  try {
+    return require.resolve("@confluentinc/mcp-confluent/dist/index.js");
+  } catch {
+    logger.warn("@confluentinc/mcp-confluent not found; MCP tools will be unavailable");
+    return undefined;
+  }
+}
+
+/** Read the bundled MCP server version from its package.json. */
+function getMcpServerVersion(): string {
+  try {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    return require("@confluentinc/mcp-confluent/package.json").version;
+  } catch {
+    return "unknown";
+  }
+}
+
+/**
+ * Build a single {@link McpStdioServerDefinition} from a label, env map, and version.
+ *
+ * Uses `"node"` (system Node.js) instead of `process.execPath` (Electron's Node) because the MCP
+ * server depends on `@confluentinc/kafka-javascript`, which has native addons compiled against the
+ * system Node ABI. Electron ships a different Node version with an incompatible
+ * `NODE_MODULE_VERSION`, so loading those native modules from `process.execPath` fails with
+ * `ERR_DLOPEN_FAILED`.
+ */
+function buildServerDefinition(
+  id: string,
+  label: string,
+  env: Record<string, string>,
+  version: string,
+): McpStdioServerDefinitionType | undefined {
+  const serverScript = getMcpServerEntryPath();
+  if (!serverScript) return undefined;
+
+  return new McpStdioServerDefinition(
+    label,
+    "node",
+    [serverScript],
+    { ...env, [CONNECTION_ID_ENV_KEY]: id },
+    version,
+  );
+}