kubeview-mcp 1.9.0 → 1.9.1

package/CHANGELOG.md

@@ -7,6 +7,12 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [1.9.1] - 2026-06-13
+
+### Fixed
+- **(fix) Fix the launch issue for claude desktop**
+
+
 ## [1.9.0] - 2026-06-02
 
 ### Added

package/bin/kubeview-mcp.js

@@ -52,11 +52,11 @@ class KubeMCPCLI {
         const nodeModulesPath = path.join(this.projectRoot, 'node_modules');
         if (!fs.existsSync(nodeModulesPath)) {
           this.log('📦 Installing dependencies...', colors.blue);
-          execSync('npm install', { cwd: this.projectRoot, stdio: 'inherit' });
+          this.runCommandForMcpStartup('npm install');
         }
 
         // Build the project
-        execSync('npm run build', { cwd: this.projectRoot, stdio: 'inherit' });
+        this.runCommandForMcpStartup('npm run build');
         this.log('✅ Build completed successfully', colors.green);
       } catch (buildError) {
         this.error('❌ Build failed:');
@@ -66,6 +66,23 @@ class KubeMCPCLI {
     }
   }
 
+  runCommandForMcpStartup(command) {
+    try {
+      execSync(command, {
+        cwd: this.projectRoot,
+        stdio: ['ignore', 'pipe', 'pipe'],
+      });
+    } catch (error) {
+      if (error.stdout) {
+        process.stderr.write(error.stdout);
+      }
+      if (error.stderr) {
+        process.stderr.write(error.stderr);
+      }
+      throw error;
+    }
+  }
+
   // Display help information
   displayHelp() {
     this.log('Kube MCP - Kubernetes MCP Server', colors.cyan);

package/dist/src/version.d.ts

@@ -1,2 +1,2 @@
-export declare const VERSION = "1.9.0";
+export declare const VERSION = "1.9.1";
 //# sourceMappingURL=version.d.ts.map

package/dist/src/version.js

@@ -1,3 +1,3 @@
 // Auto-generated by scripts/build-version.js - DO NOT EDIT
-export const VERSION = '1.9.0';
+export const VERSION = '1.9.1';
 //# sourceMappingURL=version.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kubeview-mcp",
-  "version": "1.9.0",
+  "version": "1.9.1",
   "description": "Read-only MCP server enabling code-driven AI analysis of Kubernetes clusters",
   "homepage": "https://github.com/mikhae1/kubeview-mcp",
   "mcpName": "io.github.mikhae1/kubeview",
@@ -20,6 +20,9 @@
   "files": [
     "bin/",
     "dist/",
+    "scripts/build-version.js",
+    "src/",
+    "tsconfig.json",
     "*.md"
   ],
   "scripts": {

package/scripts/build-version.js

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+/**
+ * Generates src/version.ts from package.json version.
+ * Run before TypeScript compilation to bake version into the build.
+ */
+
+import { readFileSync, writeFileSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const rootDir = join(__dirname, '..');
+
+const packageJson = JSON.parse(readFileSync(join(rootDir, 'package.json'), 'utf8'));
+const versionTs = `// Auto-generated by scripts/build-version.js - DO NOT EDIT
+export const VERSION = '${packageJson.version}';\n`;
+
+writeFileSync(join(rootDir, 'src', 'version.ts'), versionTs);
+console.error(`Generated src/version.ts with version ${packageJson.version}`);

package/src/agent/bridge/MCPBridge.ts

@@ -0,0 +1,176 @@
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+import type { ListToolsResult, Tool } from '@modelcontextprotocol/sdk/types.js';
+import type { Logger } from 'winston';
+import { PIITokenizer } from '../security/PIITokenizer.js';
+
+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 class MCPBridge {
+  private clients: Map<string, Client> = new Map();
+  private toolRegistry: Map<string, ToolRegistration> = new Map();
+  private piiTokenizer?: PIITokenizer;
+  private toolDiscoveryCache: Map<string, Tool[]> = new Map();
+  private configByServer: Map<string, MCPServerConfig> = new Map();
+
+  constructor(
+    private readonly configs: MCPServerConfig[],
+    private readonly options: MCPBridgeOptions = {},
+  ) {
+    if (options.enablePII) {
+      this.piiTokenizer = new PIITokenizer();
+    }
+  }
+
+  public async initialize(): Promise<void> {
+    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);
+    }
+  }
+
+  private async initializeServer(config: MCPServerConfig): Promise<void> {
+    const envEntries = Object.entries({
+      ...process.env,
+      ...config.env,
+    }).filter((entry): entry is [string, string] => 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);
+  }
+
+  private cacheToolMetadata(serverName: string, toolsResponse: ListToolsResult): void {
+    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,
+      });
+    }
+  }
+
+  public getRegisteredTools(): ToolRegistration[] {
+    return Array.from(this.toolRegistry.values());
+  }
+
+  public getToolMetadata(qualifiedName: string): ToolRegistration | undefined {
+    return this.toolRegistry.get(qualifiedName);
+  }
+
+  public listServers(): string[] {
+    return Array.from(this.clients.keys());
+  }
+
+  public listToolsForServer(serverName: string): Tool[] {
+    return this.toolDiscoveryCache.get(serverName) ?? [];
+  }
+
+  public async callTool<T = any>(qualifiedName: string, args: any): Promise<T> {
+    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: Awaited<ReturnType<typeof client.callTool>>;
+    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 as T;
+  }
+
+  public async close(): Promise<void> {
+    for (const client of this.clients.values()) {
+      await client.close();
+    }
+    this.clients.clear();
+    this.toolRegistry.clear();
+    this.toolDiscoveryCache.clear();
+  }
+
+  private async withTimeout<T>(promise: Promise<T>, timeoutMs: number, label: string): Promise<T> {
+    return new Promise<T>((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);
+        });
+    });
+  }
+}

package/src/agent/codegen/CodegenManager.ts

@@ -0,0 +1,334 @@
+import { promises as fs } from 'fs';
+import path from 'path';
+import ts from 'typescript';
+import { ToolSchemaIntrospector } from './ToolSchemaIntrospector.js';
+import { SchemaToTypeScriptMapper } from './SchemaToTypeScriptMapper.js';
+import type { ToolSchemaSummary } from './types.js';
+
+export interface CodegenManagerOptions {
+  outputDir: string;
+  runtimeImportPath?: string;
+  manifestPath?: string;
+}
+
+const DEFAULT_OPTIONS: CodegenManagerOptions = {
+  outputDir: path.resolve(process.cwd(), 'generated/servers'),
+  runtimeImportPath: '../../runtime/callMCPTool.ts',
+  manifestPath: path.resolve(process.cwd(), 'generated/servers/manifest.json'),
+};
+
+export class CodegenManager {
+  private readonly mapper = new SchemaToTypeScriptMapper();
+  private readonly printer = ts.createPrinter({ newLine: ts.NewLineKind.LineFeed });
+  private readonly options: CodegenManagerOptions;
+
+  constructor(
+    private readonly introspector: ToolSchemaIntrospector,
+    options?: Partial<CodegenManagerOptions>,
+  ) {
+    this.options = { ...DEFAULT_OPTIONS, ...options };
+  }
+
+  public async generate(): Promise<void> {
+    const summaries = this.introspector.collectToolSchemas();
+    if (!summaries.length) {
+      return;
+    }
+
+    await fs.mkdir(this.options.outputDir, { recursive: true });
+    await this.ensureRuntimeHelpers();
+
+    const grouped = this.groupByServer(summaries);
+    for (const [server, tools] of grouped.entries()) {
+      const serverDir = path.join(this.options.outputDir, server);
+      await fs.rm(serverDir, { recursive: true, force: true });
+      await fs.mkdir(serverDir, { recursive: true });
+      await Promise.all(tools.map((tool) => this.writeToolFile(serverDir, server, tool)));
+      await this.writeServerIndex(serverDir, tools);
+    }
+
+    await this.writeRootIndex(Array.from(grouped.keys()));
+    await this.writeManifest(grouped);
+  }
+
+  private groupByServer(summaries: ToolSchemaSummary[]): Map<string, ToolSchemaSummary[]> {
+    const grouped = new Map<string, ToolSchemaSummary[]>();
+    for (const summary of summaries) {
+      if (!grouped.has(summary.server)) {
+        grouped.set(summary.server, []);
+      }
+      grouped.get(summary.server)!.push(summary);
+    }
+    return grouped;
+  }
+
+  private async writeToolFile(
+    baseDir: string,
+    _server: string,
+    tool: ToolSchemaSummary,
+  ): Promise<void> {
+    const statements: ts.Statement[] = [];
+    statements.push(this.createRuntimeImport());
+
+    const pascalName = this.toPascalCase(tool.toolName);
+    const inputTypeName = `${pascalName}Input`;
+    const resultTypeName = `${pascalName}Result`;
+
+    statements.push(this.mapper.createTypeAliasDeclaration(inputTypeName, tool.inputSchema));
+    statements.push(this.mapper.createTypeAliasDeclaration(resultTypeName, undefined));
+
+    statements.push(this.createToolFunction(tool, inputTypeName, resultTypeName));
+
+    const content = this.printStatements(statements);
+    const filePath = path.join(baseDir, `${tool.toolName}.ts`);
+    await fs.writeFile(filePath, content, 'utf-8');
+  }
+
+  private createRuntimeImport(): ts.ImportDeclaration {
+    const importPath = this.options.runtimeImportPath ?? DEFAULT_OPTIONS.runtimeImportPath!;
+    return ts.factory.createImportDeclaration(
+      undefined,
+      ts.factory.createImportClause(
+        false,
+        undefined,
+        ts.factory.createNamedImports([
+          ts.factory.createImportSpecifier(
+            false,
+            undefined,
+            ts.factory.createIdentifier('callMCPTool'),
+          ),
+        ]),
+      ),
+      ts.factory.createStringLiteral(importPath),
+      undefined,
+    );
+  }
+
+  private createToolFunction(
+    tool: ToolSchemaSummary,
+    inputTypeName: string,
+    resultTypeName: string,
+  ): ts.FunctionDeclaration {
+    const docComment = tool.description
+      ? ts.factory.createJSDocComment(tool.description)
+      : undefined;
+
+    const fn = ts.factory.createFunctionDeclaration(
+      [ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)],
+      undefined,
+      ts.factory.createIdentifier(this.toCamelCase(tool.toolName)),
+      undefined,
+      [
+        ts.factory.createParameterDeclaration(
+          undefined,
+          undefined,
+          ts.factory.createIdentifier('input'),
+          undefined,
+          ts.factory.createTypeReferenceNode(ts.factory.createIdentifier(inputTypeName)),
+          undefined,
+        ),
+      ],
+      ts.factory.createTypeReferenceNode(ts.factory.createIdentifier('Promise'), [
+        ts.factory.createTypeReferenceNode(ts.factory.createIdentifier(resultTypeName)),
+      ]),
+      ts.factory.createBlock(
+        [
+          ts.factory.createReturnStatement(
+            ts.factory.createCallExpression(
+              ts.factory.createIdentifier('callMCPTool'),
+              [ts.factory.createTypeReferenceNode(ts.factory.createIdentifier(resultTypeName))],
+              [
+                ts.factory.createStringLiteral(tool.qualifiedName),
+                ts.factory.createIdentifier('input'),
+              ],
+            ),
+          ),
+        ],
+        true,
+      ),
+    );
+
+    if (docComment) {
+      ts.addSyntheticLeadingComment(
+        fn,
+        ts.SyntaxKind.MultiLineCommentTrivia,
+        `*\n * ${tool.description}\n `,
+        true,
+      );
+    }
+
+    return fn;
+  }
+
+  private async writeServerIndex(serverDir: string, tools: ToolSchemaSummary[]): Promise<void> {
+    const statements = tools.map((tool) =>
+      ts.factory.createExportDeclaration(
+        undefined,
+        false,
+        ts.factory.createNamedExports([
+          ts.factory.createExportSpecifier(
+            false,
+            undefined,
+            ts.factory.createIdentifier(this.toCamelCase(tool.toolName)),
+          ),
+        ]),
+        ts.factory.createStringLiteral(`./${tool.toolName}.ts`),
+        undefined,
+      ),
+    );
+
+    const content = this.printStatements(statements);
+    await fs.writeFile(path.join(serverDir, 'index.ts'), content, 'utf-8');
+  }
+
+  private async writeRootIndex(servers: string[]): Promise<void> {
+    const statements = servers.map((server) =>
+      ts.factory.createExportDeclaration(
+        undefined,
+        false,
+        undefined,
+        ts.factory.createStringLiteral(`./${server}/index.ts`),
+        undefined,
+      ),
+    );
+    const content = this.printStatements(statements);
+    await fs.writeFile(path.join(this.options.outputDir, 'index.ts'), content, 'utf-8');
+  }
+
+  private async writeManifest(grouped: Map<string, ToolSchemaSummary[]>): Promise<void> {
+    const manifest = Array.from(grouped.entries()).map(([server, tools]) => ({
+      server,
+      tools: tools.map((tool) => ({
+        name: tool.toolName,
+        qualifiedName: tool.qualifiedName,
+        description: tool.description,
+        inputSchema: tool.inputSchema, // Include full schema for runtime introspection
+      })),
+    }));
+
+    if (!this.options.manifestPath) return;
+    await fs.writeFile(this.options.manifestPath, JSON.stringify(manifest, null, 2), 'utf-8');
+  }
+
+  private async ensureRuntimeHelpers(): Promise<void> {
+    const runtimeDir = path.resolve(this.options.outputDir, '../runtime');
+    await fs.mkdir(runtimeDir, { recursive: true });
+    const filePath = path.join(runtimeDir, 'callMCPTool.ts');
+    const content = `declare global {
+  // eslint-disable-next-line no-var
+  var __callMCPTool: ((qualifiedName: string, args: unknown) => Promise<unknown>) | undefined;
+}
+
+export async function callMCPTool<T = unknown>(qualifiedName: string, args: unknown): Promise<T> {
+  if (typeof globalThis.__callMCPTool !== 'function') {
+    throw new Error('callMCPTool bridge not initialized');
+  }
+  const fn = globalThis.__callMCPTool as (name: string, params: unknown) => Promise<T>;
+  return fn(qualifiedName, args);
+}
+`;
+    await fs.writeFile(filePath, content, 'utf-8');
+
+    const searchHelperPath = path.join(runtimeDir, 'toolSearch.ts');
+    const searchContent = `import manifest from '../servers/manifest.json';
+
+export interface ToolManifestEntry {
+  server: string;
+  name: string;
+  qualifiedName: string;
+  description?: string;
+}
+
+const tools: ToolManifestEntry[] = manifest.flatMap((serverEntry) =>
+  serverEntry.tools.map((tool) => ({
+    server: serverEntry.server,
+    ...tool,
+  })),
+);
+
+export function listServers(): string[] {
+  return manifest.map((entry) => entry.server);
+}
+
+export function listTools(server?: string): ToolManifestEntry[] {
+  if (!server) return tools;
+  return tools.filter((tool) => tool.server === server);
+}
+
+export function searchTools(query: string, limit = 10): ToolManifestEntry[] {
+  const normalized = query.toLowerCase();
+  return tools
+    .filter(
+      (tool) =>
+        tool.name.toLowerCase().includes(normalized) ||
+        (tool.description ?? '').toLowerCase().includes(normalized),
+    )
+    .slice(0, limit);
+}
+`;
+    await fs.writeFile(searchHelperPath, searchContent, 'utf-8');
+
+    const workspaceHelperPath = path.join(runtimeDir, 'workspaceFs.ts');
+    const workspaceContent = `declare global {
+  // eslint-disable-next-line no-var
+  var __workspaceFs:
+    | {
+        readFile(path: string): Promise<string>;
+        writeFile(path: string, data: string): Promise<void>;
+        listDir(path?: string): Promise<string[]>;
+        exists(path: string): Promise<boolean>;
+      }
+    | undefined;
+}
+
+function ensureWorkspaceFs() {
+  if (!globalThis.__workspaceFs) {
+    throw new Error('Workspace filesystem bridge not initialized');
+  }
+  return globalThis.__workspaceFs;
+}
+
+export async function readWorkspaceFile(path: string): Promise<string> {
+  return ensureWorkspaceFs().readFile(path);
+}
+
+export async function writeWorkspaceFile(path: string, data: string): Promise<void> {
+  return ensureWorkspaceFs().writeFile(path, data);
+}
+
+export async function listWorkspaceDir(path?: string): Promise<string[]> {
+  return ensureWorkspaceFs().listDir(path);
+}
+
+export async function workspacePathExists(path: string): Promise<boolean> {
+  return ensureWorkspaceFs().exists(path);
+}
+`;
+    await fs.writeFile(workspaceHelperPath, workspaceContent, 'utf-8');
+  }
+
+  private printStatements(statements: ts.Statement[]): string {
+    const sourceFile = ts.createSourceFile(
+      'temp.ts',
+      '',
+      ts.ScriptTarget.ES2020,
+      false,
+      ts.ScriptKind.TS,
+    );
+    return statements
+      .map((statement) => this.printer.printNode(ts.EmitHint.Unspecified, statement, sourceFile))
+      .join('\n\n');
+  }
+
+  private toPascalCase(value: string): string {
+    return value
+      .replace(/[_-]+/g, ' ')
+      .replace(/(?:^\w|[A-Z]|\b\w)/g, (word) => word.toUpperCase())
+      .replace(/\s+/g, '');
+  }
+
+  private toCamelCase(value: string): string {
+    const pascal = this.toPascalCase(value);
+    return pascal.charAt(0).toLowerCase() + pascal.slice(1);
+  }
+}