kubeview-mcp 1.2.0 → 1.4.1

package/CHANGELOG.md

@@ -5,6 +5,56 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [Unreleased]
+
+## [1.4.0] - 2025-11-29
+
+### Added
+- **RunCode Tool Exposure**: Exposed `run_code` tool by default in standard mode alongside other tools.
+- **Code-Mode Prompt**: Added `code-mode` prompt for injecting the full TypeScript API documentation, tool overview, and examples into the context.
+
+### Changed
+- **Documentation**: Improved README.md to be more professional, valid, and concise.
+- **Name Change**: Changed name from `kubeview-mcp` to `kubeview` to align with the new MCP server name.
+- **Dependencies**: Updated deprecated dependencies.
+
+### Fixed
+- **Filter Logic**: `kube_list` now honors namespace/selector filters even when `resourceType` is omitted.
+- **Runtime Errors**: Fixed `ERR_MODULE_NOT_FOUND` for `typescript` package.
+- **Build Issues**: Resolved TypeScript compilation errors in `src/index.ts`.
+- **Logging**: Fixed "Required parameter name was null or undefined" error in `kube_log` and `kube_logs` tools.
+
+## [1.3.0] - 2025-11-27
+
+### Added
+- **Code-Mode Execution**: Added sandboxed TypeScript code execution runtime following Anthropic's code execution with MCP approach
+- **RunCodeTool**: Implemented `run_code` tool for executing TypeScript code in a sandboxed Node.js VM environment
+- **Code-Mode CLI**: Added `kubeview-mcp-code-mode` binary and `npm run code-mode` script for standalone code execution
+- **TypeScript Transpilation**: Integrated TypeScript compiler for runtime transpilation of agent code (ES2022 target)
+- **Global Type Definitions**: Added `/sys/global.d.ts` resource providing TypeScript type definitions for all available tools
+- **Tool Executor**: Implemented tool executor allowing sandboxed code to call MCP tools internally
+- **Helper Functions**: Added namespaced `tools.*` helpers for discovery (`tools.list()`, `tools.search()`, `tools.help()`, `tools.call()`) and execution
+- **Code-Mode Configuration**: Added `CodeModeConfig` with configurable sandbox limits (memory, timeout) and workspace settings
+- **Mode Support**: Added `MCP_MODE` environment variable with three modes:
+  - `code`: exposes only `run_code` tool
+  - `tools`: exposes only Kubernetes/Helm/Argo tools (no `run_code`)
+  - `all`: exposes both tools and `run_code` (default)
+  - Replaced `NODE_MODE=code` with `MCP_MODE=code|tools|all`
+
+### Changed
+- **Plugin Architecture**: Removed version property from various tools plugins and MCPServer for simplified plugin management
+- **Dependencies**: Added TypeScript as a runtime dependency (previously dev-only) for code-mode transpilation
+- **Tool Manifest**: Enhanced tool manifest system to support dynamic tool generation for agent code execution
+
+### Fixed
+- **Type Definitions**: Fixed TypeScript typing for generated global DTS resources and resource registration
+
+## [1.2.0] - 2025-08-19
+
+### Changed
+- **Changed variable naming**
+- **Diabled logging by default**
+
 ## [1.1.0] - 2025-08-09
 
 ### Added
@@ -80,4 +130,4 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Integration guides for Cursor IDE
 - API documentation for developers
 
-[1.0.0]: https://github.com/mikhae1/kubeview-mcp/releases/tag/v1.0.0
+[1.0.0]: https://github.com/mikhae1/kubeview-mcp/releases/tag/v1.0.0

package/README.md

@@ -4,248 +4,148 @@
 [![Node.js Version](https://img.shields.io/badge/node-%3E%3D18.0.0-brightgreen)](https://nodejs.org/)
 [![TypeScript](https://img.shields.io/badge/TypeScript-5.8+-blue)](https://www.typescriptlang.org/)
 
-KubeView MCP is a read-only Model Context Protocol (MCP) server that exposes AI-friendly tools for safe Kubernetes, Helm, Argo Workflows, and Argo CD introspection. It pairs with Cursor IDE, Claude Code/Desktop, and other MCP clients to let you inspect, diagnose, and debug clusters via natural language and without any change operations.
+**KubeView** is a read-only Model Context Protocol (MCP) server that enables AI agents (like Cursor, Claude Desktop) to inspect, diagnose, and debug Kubernetes clusters safely. It provides a comprehensive set of tools for Kubernetes, Helm, Argo Workflows, and Argo CD.
 
 ---
 
 ## ✨ Features
 
-- **Kubernetes tools (read-only)**: list, get/describe, metrics, single-pod logs, multi-pod streaming logs with event merge, exec (read-only), port-forward, and in-cluster network diagnostics
-- **Cluster overview**: one-shot, LLM-optimized diagnostics across nodes, workloads, storage, events, and security posture
-- **Helm integration**: list releases; fetch values, manifest, notes, hooks, history, status, and parsed resources
-- **Argo Workflows**: list/get workflows and fetch workflow logs
-- **Argo CD**: list/get app details, resources, history, logs, and status via a single multi-operation tool
-- **Sensitive data masking**: global redaction for secrets/tokens in ConfigMaps, Secrets, and Helm values
-- **Zero write access**: designed to be safe in production from day one
+- **🛡️ Read-Only & Safe**: Designed for production safety with zero write access and sensitive data masking.
+- **☸️ Kubernetes Integration**: List/get resources, fetch metrics, stream logs, execute commands, and diagnose network issues.
+- **📦 Helm Support**: Inspect releases, values, manifests, and history.
+- **🐙 Argo Ecosystem**: Manage Argo Workflows and Argo CD applications.
+- **🧠 Code Mode**: Sandboxed TypeScript environment for complex reasoning and multi-step workflows.
 
 ---
 
 ## 🚀 Quick Start
 
-### Zero-install via npx
+### Prerequisites
+
+- Node.js ≥ 18
+- Access to a Kubernetes cluster
+- Optional CLIs on current $PATH if you want to use those plugins: `helm`, `argo`, `argocd`
+
+### Installation
+
+Run directly with `npx`:
 
 ```bash
-npx -y https://github.com/mikhae1/kubeview-mcp
+npx -y kubeview-mcp
 ```
 
-Add to your MCP client config (for Cursor, `~/.cursor/mcp.json`):
+### Configuration for MCP Clients
+
+Add to your `mcpServers` configuration (e.g., in Cursor or Claude Desktop):
 
 ```json
 {
   "mcpServers": {
-    "kubeview-mcp": {
+    "kubeview": {
       "command": "npx",
-      "args": ["-y", "https://github.com/mikhae1/kubeview-mcp"],
-      "env": {
-        "KUBECONFIG": "$HOME/.kube/config"
-      }
+      "args": ["-y", "kubeview-mcp"]
     }
   }
 }
 ```
 
-### Prerequisites
-
-- Node.js ≥ 18
-- Access to a Kubernetes cluster (kubeconfig)
-- Optional CLIs on PATH when using those plugins: `helm`, `argo`, `argocd`
-
-### Local install
-
-```bash
-git clone https://github.com/mikhae1/kubeview-mcp.git
-cd kubeview-mcp
-npm install
-
-# Generate local MCP config entries for Cursor and/or Claude Desktop
-npm run setup
-```
-
-### Run
+### Environment Variables
 
-```bash
-# Build and start
-npm run build
-npm start
+Configure the server using environment variables:
 
-# Or use the bundled binary wrapper
-kubeview-mcp serve
-```
+| Variable | Description | Default |
+|----------|-------------|---------|
+| `KUBECONFIG` | Path to kubeconfig file | `~/.kube/config` |
+| `MCP_MODE` | Server mode: `all`, `code`, or `tools` | `all` |
+| `MCP_LOG_LEVEL` | Log level (`error`, `warn`, `info`, `debug`) | `info` |
+| `MCP_HIDE_SENSITIVE` | Enable global sensitive data masking | `false` |
 
 ---
 
-## 📟 Tool Index (CLI)
-
-Invoke tools with the helper:
-
-```bash
-npm run command -- <tool_name> [--param=value ...]
-```
+## 🛠️ Tools Overview
 
 ### Kubernetes
-
-- **kube_list**: List resources or, when no `resourceType` is provided, return a cluster diagnostics overview
-  - Params: `resourceType`, `namespace`, `labelSelector`, `fieldSelector`
-  - Supported `resourceType` for listing: `pod`, `service`, `deployment`, `node`, `namespace`, `persistentvolume`, `persistentvolumeclaim`, `secret`, `configmap`, `role`, `clusterrole`, `rolebinding`, `clusterrolebinding`
-- **kube_get**: Describe a single resource or list a type using plural, kind, shortname, or fully-qualified `group/version/resource`
-  - Params: `resourceType` (required), `name`, `namespace`, `includeEvents`, `includeDiagnostics`, `eventsLimit`, `restartThreshold`, `skipSanitize` (for ConfigMaps)
-- **kube_metrics**: Node and pod CPU/memory metrics, optional Prometheus enrichment and diagnostics
-  - Params: `scope` (`all|nodes|pods`), `namespace`, `podName`, `includeSummary`, `diagnostics`, `prometheusQueries[]`, `fetchPodSpecs`, thresholds (`topN`, `cpuSaturationThreshold`, `memorySaturationThreshold`, `podRestartThreshold`, `podLimitPressureThreshold`)
-- **kube_logs**: Pod/container logs (like `kubectl logs`)
-  - Params: `podName` (required), `namespace`, `container`, `tailLines`, `since`, `previous`, `timestamps`
-- **kube_log**: Multi-pod & multi-container log tail with dynamic discovery and merged Events
-  - Selectors: `namespace`, `labelSelector`, `ownerKind` (`Deployment|DaemonSet|Job`), `ownerName`
-  - Filters: `podRegex`, `containerRegex`, `messageRegex`, `excludeRegex`, `jsonPaths` (e.g., `[{"path":"level","equals":"error"}]`)
-  - Time/tail: `tailLines`, `since` (e.g., `15m`), `sinceTime` (RFC3339), `timestamps`, `previous`
-  - Session bounds: `durationSeconds` (default 30), `maxLines`
-  - Events: `includeEvents` (default true), `eventType` (`Normal|Warning|All`)
-  - Output: `structure` (`object|text`). In object mode each line has `type: 'log'|'event'`. In text mode events are prefixed with `[event]`.
-- **kube_exec**: Execute a command in a container via Kubernetes API only; returns stdout/stderr
-  - Params: `podName` (required), `namespace`, `container`, `args[]` | `argv` | `command`, `stdin`, `tty`, `timeoutSeconds`, `shell`
-- **kube_port**: Temporary port-forward to a pod or service (auto-terminates)
-  - Params: `namespace`, `podName` | `serviceName`, `remotePort` (required), `localPort`, `address`, `timeoutSeconds`, `readinessTimeoutSeconds`
-- **kube_net**: In-pod network diagnostics (DNS resolution, internet egress, pod/service connectivity)
-  - Params: `sourcePod` (required), `namespace`, `container`, `targetPod`, `targetPodNamespace`, `targetService`, `targetServiceNamespace`, `targetPort`, `externalHost`, `externalPort`, `dnsNames[]`, toggles: `runDnsTest`, `runInternetTest`, `runPodConnectivityTest`, `runServiceConnectivityTest`, `timeoutSeconds`
+- **`kube_list`**: List resources or get cluster diagnostics.
+- **`kube_get`**: Describe specific resources (supports all K8s types).
+- **`kube_metrics`**: Fetch CPU/memory metrics for nodes and pods.
+- **`kube_logs`**: Fetch or stream container logs.
+- **`kube_exec`**: Execute commands in containers (read-only recommended).
+- **`kube_port`**: Port-forward to pods/services.
+- **`kube_net`**: Run in-cluster network diagnostics.
 
 ### Helm
+- **`helm_list`**: List Helm releases.
+- **`helm_get`**: Fetch release values, manifests, and history.
 
-- **helm_list**: List Helm releases
-  - Params: `namespace`, `allNamespaces`, `outputFormat`, `selector`, `maxReleases`, `deployed`, `failed`, `pending`, `superseded`, `uninstalled`, `uninstalling`
-- **helm_get**: Get release data
-  - Params: `what` (`values|manifest|notes|hooks|resources|status|history`), `releaseName` (required), `namespace`, `revision`, `outputFormat`, `allValues`, `resourceType`, `showResources`
+### Argo
+- **`argo_list` / `argo_get`**: Manage Argo Workflows.
+- **`argocd_app`**: Inspect Argo CD applications and resources.
 
-### Argo Workflows
+### Utilities
+- **`run_code`**: Execute sandboxed TypeScript code for complex tasks.
 
-- **argo_list**: List workflows with rich filters
-  - Params: `namespace`, `allNamespaces`, `outputFormat`, `selector`, status flags (`running|succeeded|failed|pending|completed|status`), `since`, `chunked`, `maxWorkflows`
-- **argo_get**: Get workflow details
-  - Params: `workflowName` (required), `namespace`, `outputFormat`, `showParameters`, `showArtifacts`, `showEvents`, `nodeFieldSelector`
-- **argo_logs**: Get workflow logs
-  - Params: `workflowName` (required), `namespace`, `container`, `follow`, `previous`, `since`, `sinceTime`, `tail`, `timestamps`, `grep`, `noColor`
+> **Note**: For detailed parameter usage, the AI agent can query the tool definitions directly.
 
-### Argo CD
+---
 
-- **argocd_app**: Multi-operation tool for Argo CD apps
-  - Params: `operation` (`list|get|resources|logs|history|status`) plus operation-specific flags (`appName`, `outputFormat`, `selector`, `project`, `cluster`, `namespace`, `repo`, `health`, `sync`, `server`, `grpcWeb`, `plaintext`, `insecure`, `refresh`, `hardRefresh`, `group`, `kind`, `name`, `container`, `follow`, `previous`, `since`, `sinceTime`, `tail`, `timestamps`)
+## 🧠 Code Mode
 
----
+Inspired by [Code execution with MCP](https://www.anthropic.com/engineering/code-execution-with-mcp), KubeView ships with a code-mode runtime that allows agents to explore the API, search tools, and execute complex workflows in a sandboxed environment.
 
-## ⚙️ Configuration
+### What it provides
 
-Provide env vars via your MCP client config or shell.
+- **MCP Bridge Layer**: Seamlessly connects to all registered MCP server tools.
+- **Dynamic TypeScript Definitions**: Automatically converts tool schemas into a strongly-typed `global.d.ts` resource, enabling agents to use valid TypeScript patterns and enjoy type safety without hallucinating parameters.
+- **Tool Search Utilities**: Runtime helpers like `tools.search()` and `tools.list()` allow agents to progressively discover capabilities without needing to load the entire schema context upfront.
+- **Sandboxed Execution**: A locked-down Node.js environment (via `vm`) with controlled access to the `console` and the `tools` global object, ensuring safe execution of agent-generated code.
 
-- **KUBECONFIG**: Path to kubeconfig (default: `$HOME/.kube/config`)
-- **MCP_LOG_LEVEL**: `error|warn|info|debug`
-- **MCP_LOG_ENABLE**: `true|1` to enable server file logging (default: disabled)
-- **MCP_LOG_FILE**: Path to server log file (default when enabled: `kubeview-mcp.log`)
-- **MCP_TIMEOUT**: Global per-tool timeout in ms (applies to all tools)
-- CLI timeouts: **MCP_HELM_TIMEOUT**, **MCP_ARGO_TIMEOUT**, **MCP_ARGOCD_TIMEOUT** (ms)
-- CLI executable overrides: **MCP_HELM_PATH**, **MCP_ARGO_PATH**, **MCP_ARGOCD_PATH**
-- Plugin toggles: **MCP_DISABLE_KUBERNETES_PLUGIN**, **MCP_DISABLE_HELM_PLUGIN**, **MCP_DISABLE_ARGO_PLUGIN**, **MCP_DISABLE_ARGOCD_PLUGIN** (`true|1` to disable)
-- Kubernetes options: **MCP_KUBE_CONTEXT**, **MCP_K8S_SKIP_TLS_VERIFY** (`true|1`)
+### Usage
 
-Example (Cursor `mcp.json`):
+For complex tasks requiring logic, loops, or data processing, use **Code Mode**:
 
 ```json
-{
-  "mcpServers": {
-    "kubeview-mcp": {
-      "command": "npx",
-      "args": ["-y", "https://github.com/mikhae1/kubeview-mcp"],
-      "env": {
-        "KUBECONFIG": "$HOME/.kube/config",
-        "MCP_LOG_LEVEL": "info",
-        "MCP_HELM_TIMEOUT": "45000",
-        "MCP_DISABLE_ARGO_PLUGIN": "1"
-      }
-    }
-  }
-}
+"env": { "MCP_MODE": "code" }
 ```
 
----
-
-## 🔒 Sensitive Data Masking
-
-Global masking prevents accidental disclosure of secrets (enabled when any of the flags below are set):
+### 💡 Pro Tip: Code Mode Prompt
 
-- Enable: `MCP_HIDE_SENSITIVE` or `MCP_HIDE_SENSITIVE_DATA` or `MCP_MASK_SENSITIVE_DATA` → `true|1|yes|on`
-- Mask text override: `MCP_SENSITIVE_MASK` (default: `*** FILTERED ***`)
+The server includes a built-in prompt named **`code-mode`** that injects the full TypeScript API documentation, tool overview, and examples into the context.
 
-Effects:
-
-- ConfigMaps: values redacted by key/value heuristics; forcing `skipSanitize=true` on `kube_get` will still be overridden by global masking
-- Secrets: list/describe returns only key names; values are masked
-- Helm: `helm_get` with `what=values` applies masking on returned text
+**In Cursor IDE**:
+Simply type `/kubeview/code-mode` in the prompt (or select it from the `/` prompt menu). This gives the AI the exact context it needs to write correct `run_code` scripts immediately.
 
 ---
 
-## 💡 Examples
-
-```bash
-# Cluster diagnostics overview (no resourceType)
-npm run command -- kube_list
-
-# Pods in a namespace
-npm run command -- kube_list --resourceType=pod --namespace=default
-
-# Describe a deployment with events and diagnostics
-npm run command -- kube_get --resourceType=deployment --name=web --namespace=prod
-
-# Metrics summary with diagnostics
-npm run command -- kube_metrics --includeSummary=true --diagnostics=true
+## 💻 Local Development
 
-# Logs from a pod (last 200 lines)
-npm run command -- kube_logs --podName=nginx-123 --namespace=default --tailLines=200
+1. **Clone & Install**:
+   ```bash
+   git clone https://github.com/mikhae1/kubeview-mcp.git
+   cd kubeview-mcp
+   npm install
+   ```
 
-# Stream logs across pods by owner with events (10 minutes back)
-npm run command -- kube_log --namespace=prod --ownerKind=Deployment --ownerName=api --since=10m --includeEvents=true --durationSeconds=20
+2. **Build & Run**:
+   ```bash
+   npm run build
+   npm start
+   ```
 
-# Filter by labels and container name, text output
-npm run command -- kube_log --namespace=default --labelSelector='app=db,tier=api' --containerRegex='^(main|sidecar)$' --structure=text --durationSeconds=15
+3. **Test**:
+   ```bash
+   npm test
+   ```
 
-# Only errors from JSON logs
-npm run command -- kube_log --namespace=prod --labelSelector='app=my-api' --jsonPaths='[{"path":"level","equals":"error"}]' --messageRegex='timeout|exception' --since=30m --durationSeconds=20
+### CLI Usage
 
-# Only events (text mode)
-npm run command -- kube_log --namespace=default --includeEvents=true --structure=text --messageRegex='^\\[event\\]' --durationSeconds=10
+You can test tools directly via the CLI:
 
-# Port-forward service 80 -> local 8080 for 90s
-npm run command -- kube_port --serviceName=my-svc --namespace=default --remotePort=80 --localPort=8080 --timeoutSeconds=90
-
-# Network diagnostics from a pod
-npm run command -- kube_net --sourcePod=api-0 --namespace=prod --targetService=db --runServiceConnectivityTest=true
-
-# Helm release values (masked)
-npm run command -- helm_get --what=values --releaseName=my-release --namespace=default --allValues=true
-
-# Argo CD app resources
-npm run command -- argocd_app --operation=resources --appName=my-app --outputFormat=json
+```bash
+npm run command -- kube_list --namespace=default
 ```
 
 ---
 
-## 🤝 Contributing
-
-1. Fork the repo
-2. Create a feature branch: `git checkout -b feat/my-awesome-feature`
-3. Commit: `git commit -m "feat: add my awesome feature"`
-4. Push: `git push origin feat/my-awesome-feature`
-5. Open a Pull Request
-
-Tip: run `npm run lint` and `npm run test` locally before submitting.
-
----
-
 ## 📄 License
 
-MIT – see `LICENSE`.
-
----
-
-## 🙏 Acknowledgments
-
-- Model Context Protocol SDK
-- Kubernetes JavaScript Client
-- Winston
-- TypeScript
+MIT © [kubeview-mcp team](https://github.com/mikhae1/kubeview-mcp)

package/TODO.md

@@ -1,2 +1,2 @@
 - kube_logs (multiple log streams + events, selectors support)
--
+- add support for k8s context selector

package/bin/kubeview-mcp-code-mode.js

@@ -0,0 +1,60 @@
+#!/usr/bin/env node
+
+import { fileURLToPath } from 'url';
+import path from 'path';
+import fs from 'fs';
+import { spawn, execSync } from 'child_process';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const projectRoot = path.resolve(__dirname, '..');
+
+function ensureBuild() {
+  const distDir = path.join(projectRoot, 'dist');
+  const cliPath = path.join(distDir, 'src', 'cli', 'code-mode.js');
+  if (fs.existsSync(cliPath)) {
+    return cliPath;
+  }
+
+  console.error('[kubeview-mcp] Building project for code-mode CLI...');
+  try {
+    execSync('npm run build', { cwd: projectRoot, stdio: 'inherit' });
+  } catch (error) {
+    console.error('Failed to build project for code-mode CLI.');
+    console.error(error);
+    process.exit(1);
+  }
+
+  if (!fs.existsSync(cliPath)) {
+    console.error('code-mode CLI not found after build. Expected at:', cliPath);
+    process.exit(1);
+  }
+
+  return cliPath;
+}
+
+function runCodeMode() {
+  const cliPath = ensureBuild();
+  // Pass all arguments to the CLI
+  const args = process.argv.slice(2);
+
+  const child = spawn('node', [cliPath, ...args], {
+    cwd: projectRoot,
+    stdio: 'inherit',
+    env: {
+      ...process.env,
+      KUBE_MCP_FORCE_VM_SANDBOX: '1',
+    },
+  });
+
+  child.on('close', (code) => {
+    process.exit(code ?? 0);
+  });
+
+  child.on('error', (error) => {
+    console.error('Failed to start code-mode CLI:', error);
+    process.exit(1);
+  });
+}
+
+runCodeMode();

package/bin/kubeview-mcp.js

@@ -154,7 +154,10 @@ class KubeMCPCLI {
 
     try {
       // Determine the correct index path after build
-      const finalIndexPath = fs.existsSync(indexPathFlat) ? indexPathFlat : indexPathNested;
+      // Prefer the nested path because the TypeScript build outputs to dist/src by default.
+      // Older builds may leave a flat dist/index.js behind, which can point to stale artifacts
+      // (e.g., missing version.cjs). Prioritizing the nested path avoids those mismatches.
+      const finalIndexPath = fs.existsSync(indexPathNested) ? indexPathNested : indexPathFlat;
 
       // Debug: Check if the file actually exists
       if (!fs.existsSync(finalIndexPath)) {

package/bin/setup.js

@@ -343,11 +343,12 @@ class SetupManager {
     console.log('Add the following to your mcp.json (e.g. ~/.cursor/mcp.json):\n');
     console.log(`{
   "mcpServers": {
-    "kubeview-mcp": {
+    "kubeview": {
       "command": "npx",
-      "args": ["https://github.com/mikhae1/kubeview-mcp"],
+      "args": ["-y", "kubeview-mcp"],
       "env": {
-        "KUBECONFIG": "$HOME/.kube/config"
+        "KUBECONFIG": "$HOME/.kube/config",
+        "MCP_MODE": "all"
       }
     }
   }

package/dist/src/agent/bridge/MCPBridge.d.ts

@@ -0,0 +1,41 @@
+import type { Tool } from '@modelcontextprotocol/sdk/types.js';
+import type { Logger } from 'winston';
+export interface MCPServerConfig {
+    name: string;
+    command: string;
+    args?: string[];
+    env?: Record<string, string>;
+    timeoutMs?: number;
+}
+export interface ToolRegistration {
+    qualifiedName: string;
+    server: string;
+    toolName: string;
+    tool: Tool;
+}
+export interface MCPBridgeOptions {
+    enablePII?: boolean;
+    logger?: Logger;
+    defaultTimeoutMs?: number;
+}
+export declare class MCPBridge {
+    private readonly configs;
+    private readonly options;
+    private clients;
+    private toolRegistry;
+    private piiTokenizer?;
+    private toolDiscoveryCache;
+    private configByServer;
+    constructor(configs: MCPServerConfig[], options?: MCPBridgeOptions);
+    initialize(): Promise<void>;
+    private initializeServer;
+    private cacheToolMetadata;
+    getRegisteredTools(): ToolRegistration[];
+    getToolMetadata(qualifiedName: string): ToolRegistration | undefined;
+    listServers(): string[];
+    listToolsForServer(serverName: string): Tool[];
+    callTool<T = any>(qualifiedName: string, args: any): Promise<T>;
+    close(): Promise<void>;
+    private withTimeout;
+}
+//# sourceMappingURL=MCPBridge.d.ts.map

package/dist/src/agent/bridge/MCPBridge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MCPBridge.d.ts","sourceRoot":"","sources":["../../../../src/agent/bridge/MCPBridge.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAmB,IAAI,EAAE,MAAM,oCAAoC,CAAC;AAChF,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,SAAS,CAAC;AAGtC,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC7B,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,gBAAgB;IAC/B,aAAa,EAAE,MAAM,CAAC;IACtB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,IAAI,CAAC;CACZ;AAED,MAAM,WAAW,gBAAgB;IAC/B,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED,qBAAa,SAAS;IAQlB,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,OAAO;IAR1B,OAAO,CAAC,OAAO,CAAkC;IACjD,OAAO,CAAC,YAAY,CAA4C;IAChE,OAAO,CAAC,YAAY,CAAC,CAAe;IACpC,OAAO,CAAC,kBAAkB,CAAkC;IAC5D,OAAO,CAAC,cAAc,CAA2C;gBAG9C,OAAO,EAAE,eAAe,EAAE,EAC1B,OAAO,GAAE,gBAAqB;IAOpC,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;YAU1B,gBAAgB;IAmC9B,OAAO,CAAC,iBAAiB;IAclB,kBAAkB,IAAI,gBAAgB,EAAE;IAIxC,eAAe,CAAC,aAAa,EAAE,MAAM,GAAG,gBAAgB,GAAG,SAAS;IAIpE,WAAW,IAAI,MAAM,EAAE;IAIvB,kBAAkB,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI,EAAE;IAIxC,QAAQ,CAAC,CAAC,GAAG,GAAG,EAAE,aAAa,EAAE,MAAM,EAAE,IAAI,EAAE,GAAG,GAAG,OAAO,CAAC,CAAC,CAAC;IA+B/D,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;YASrB,WAAW;CAiB1B"}

package/dist/src/agent/bridge/MCPBridge.js

@@ -0,0 +1,127 @@
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+import { PIITokenizer } from '../security/PIITokenizer.js';
+export class MCPBridge {
+    configs;
+    options;
+    clients = new Map();
+    toolRegistry = new Map();
+    piiTokenizer;
+    toolDiscoveryCache = new Map();
+    configByServer = new Map();
+    constructor(configs, options = {}) {
+        this.configs = configs;
+        this.options = options;
+        if (options.enablePII) {
+            this.piiTokenizer = new PIITokenizer();
+        }
+    }
+    async initialize() {
+        for (const config of this.configs) {
+            if (this.configByServer.has(config.name)) {
+                throw new Error(`Duplicate MCP server name: ${config.name}`);
+            }
+            this.configByServer.set(config.name, config);
+            await this.initializeServer(config);
+        }
+    }
+    async initializeServer(config) {
+        const envEntries = Object.entries({
+            ...process.env,
+            ...config.env,
+        }).filter((entry) => typeof entry[1] === 'string');
+        const mergedEnv = Object.fromEntries(envEntries);
+        const transport = new StdioClientTransport({
+            command: config.command,
+            args: config.args ?? [],
+            env: mergedEnv,
+        });
+        const client = new Client({
+            name: 'kube-mcp-code-mode-client',
+            version: '1.0.0',
+        }, {
+            capabilities: {},
+        });
+        if (this.options.logger) {
+            this.options.logger.info(`Connecting to MCP server '${config.name}'`);
+        }
+        await client.connect(transport);
+        this.clients.set(config.name, client);
+        const toolsResponse = await client.listTools();
+        this.cacheToolMetadata(config.name, toolsResponse);
+    }
+    cacheToolMetadata(serverName, toolsResponse) {
+        this.toolDiscoveryCache.set(serverName, toolsResponse.tools);
+        for (const tool of toolsResponse.tools) {
+            const qualifiedName = `${serverName}__${tool.name}`;
+            this.toolRegistry.set(qualifiedName, {
+                qualifiedName,
+                server: serverName,
+                toolName: tool.name,
+                tool,
+            });
+        }
+    }
+    getRegisteredTools() {
+        return Array.from(this.toolRegistry.values());
+    }
+    getToolMetadata(qualifiedName) {
+        return this.toolRegistry.get(qualifiedName);
+    }
+    listServers() {
+        return Array.from(this.clients.keys());
+    }
+    listToolsForServer(serverName) {
+        return this.toolDiscoveryCache.get(serverName) ?? [];
+    }
+    async callTool(qualifiedName, args) {
+        const registration = this.toolRegistry.get(qualifiedName);
+        if (!registration) {
+            throw new Error(`Tool ${qualifiedName} not found`);
+        }
+        const client = this.clients.get(registration.server);
+        if (!client) {
+            throw new Error(`Server ${registration.server} not connected`);
+        }
+        const sanitizedArgs = this.piiTokenizer ? this.piiTokenizer.tokenize(args) : args;
+        const timeoutMs = this.configByServer.get(registration.server)?.timeoutMs ?? this.options.defaultTimeoutMs;
+        const callPromise = client.callTool({
+            name: registration.toolName,
+            arguments: sanitizedArgs,
+        });
+        let result;
+        if (timeoutMs && timeoutMs > 0) {
+            result = await this.withTimeout(callPromise, timeoutMs, qualifiedName);
+        }
+        else {
+            result = await callPromise;
+        }
+        const detokenized = this.piiTokenizer ? this.piiTokenizer.detokenize(result) : result;
+        return detokenized;
+    }
+    async close() {
+        for (const client of this.clients.values()) {
+            await client.close();
+        }
+        this.clients.clear();
+        this.toolRegistry.clear();
+        this.toolDiscoveryCache.clear();
+    }
+    async withTimeout(promise, timeoutMs, label) {
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                reject(new Error(`${label} timed out after ${timeoutMs}ms`));
+            }, timeoutMs);
+            promise
+                .then((value) => {
+                clearTimeout(timer);
+                resolve(value);
+            })
+                .catch((err) => {
+                clearTimeout(timer);
+                reject(err);
+            });
+        });
+    }
+}
+//# sourceMappingURL=MCPBridge.js.map