yamatovision 1.0.0

package/lib/mcp-server/index.cjs

@@ -0,0 +1,536 @@
+#!/usr/bin/env node
+
+/**
+ * BlueLamp VSCode MCP Server
+ * VSCode拡張機能専用のMCPサーバー実装
+ */
+
+const { Server } = require('@modelcontextprotocol/sdk/server/index.js');
+const { StdioServerTransport } = require('@modelcontextprotocol/sdk/server/stdio.js');
+const {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+} = require('@modelcontextprotocol/sdk/types.js');
+const { getPromptFromPortal, reportViolation, listAvailableMcps, getMcpInfo, callMcpTool, deployUserMcp, listUserCreatedMcps, deleteUserMcp } = require('./portal-api-client.cjs');
+const { logger } = require('../utils/logger');
+const { t, setLanguage } = require('../i18n');
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+
+// .envファイルを読み込み（.env.localを優先）
+const dotenvLocalPath = path.join(__dirname, '../../.env.local');
+const dotenvPath = path.join(__dirname, '../../.env');
+
+if (fs.existsSync(dotenvLocalPath)) {
+  require('dotenv').config({ path: dotenvLocalPath });
+  logger.debug('[MCP Server] Loaded .env.local');
+} else if (fs.existsSync(dotenvPath)) {
+  require('dotenv').config({ path: dotenvPath });
+  logger.debug('[MCP Server] Loaded .env');
+}
+
+// 環境変数から取得
+const KEYWORD = process.env.BLUELAMP_KEYWORD || 'BL-要件定義';
+const TOKEN = process.env.BLUELAMP_TOKEN;
+const PORTAL_URL = process.env.PORTAL_URL || 'https://musuhi-portal-235426778039.asia-northeast1.run.app';
+const LANGUAGE = process.env.BLUELAMP_LANGUAGE || 'ja';
+
+// 言語設定を適用
+setLanguage(LANGUAGE);
+
+// ログファイル設定（ユーザーホームディレクトリに保存）
+const LOG_DIR = path.join(os.homedir(), '.bluelamp-vscode', 'logs');
+const LOG_FILE = path.join(LOG_DIR, 'mcp.log');
+
+// ログディレクトリが存在しない場合は作成
+if (!fs.existsSync(LOG_DIR)) {
+  fs.mkdirSync(LOG_DIR, { recursive: true });
+}
+
+/**
+ * ファイルとコンソールにログを出力
+ * @param {string} message - ログメッセージ
+ */
+function log(message) {
+  const timestamp = new Date().toISOString();
+  const logMessage = `[${timestamp}] ${message}\n`;
+  fs.appendFileSync(LOG_FILE, logMessage);
+  logger.info(`[MCP Server] ${message}`);
+}
+
+log(`MCP Server started - Log file: ${LOG_FILE}`);
+log(`Environment variables:`);
+log(`  KEYWORD: ${KEYWORD}`);
+log(`  TOKEN: ${TOKEN ? TOKEN.substring(0, 20) + '...' : 'NOT SET'}`);
+log(`  PORTAL_URL: ${PORTAL_URL}`);
+log(`  LANGUAGE: ${LANGUAGE}`);
+log(`  .env file exists: ${fs.existsSync(dotenvPath)}`);
+
+/**
+ * BlueLamp VSCode MCPサーバークラス
+ * @class BlueLampVSCodeServer
+ */
+class BlueLampVSCodeServer {
+  constructor() {
+    this.server = new Server(
+      {
+        name: 'bluelamp',
+        version: '1.0.0',
+      },
+      {
+        capabilities: {
+          tools: {},
+        },
+      }
+    );
+
+    this.setupHandlers();
+  }
+
+  setupHandlers() {
+    // ツール一覧を返す
+    this.server.setRequestHandler(ListToolsRequestSchema, async () => {
+      log('[MCP Server] ListTools request received');
+      const toolSchema = {
+        type: 'object',
+        properties: {
+          keyword: {
+            type: 'string',
+            description: t('mcp.keywordDescription'),
+          },
+        },
+        required: ['keyword'],
+      };
+      const toolAnnotations = {
+        readOnlyHint: true,
+        idempotentHint: true,
+      };
+      return {
+        tools: [
+          {
+            name: 'load_knowledge',
+            description: t('mcp.toolDescriptionLoadKnowledge'),
+            annotations: toolAnnotations,
+            inputSchema: toolSchema,
+          },
+          {
+            name: 'inject_knowledge',
+            description: t('mcp.toolDescriptionInjectKnowledge'),
+            annotations: toolAnnotations,
+            inputSchema: toolSchema,
+          },
+          {
+            name: 'report_violation',
+            description: t('mcp.toolDescriptionReportViolation'),
+            annotations: {
+              readOnlyHint: false,
+              idempotentHint: false,
+            },
+            inputSchema: {
+              type: 'object',
+              properties: {
+                reason: {
+                  type: 'string',
+                  description: t('mcp.violationReasonDescription'),
+                },
+                severity: {
+                  type: 'string',
+                  enum: ['warning', 'serious', 'critical'],
+                  description: t('mcp.violationSeverityDescription'),
+                },
+                userMessage: {
+                  type: 'string',
+                  description: t('mcp.violationUserMessageDescription'),
+                },
+              },
+              required: ['reason', 'severity'],
+            },
+          },
+          {
+            name: 'list_available_mcps',
+            description: t('mcp.toolDescriptionListMcps'),
+            annotations: { readOnlyHint: true, idempotentHint: true },
+            inputSchema: {
+              type: 'object',
+              properties: {
+                category: {
+                  type: 'string',
+                  enum: ['productivity', 'development', 'communication', 'data', 'media', 'custom'],
+                  description: t('mcp.listMcpsCategoryDescription'),
+                },
+                search: {
+                  type: 'string',
+                  description: t('mcp.listMcpsSearchDescription'),
+                },
+              },
+              required: [],
+            },
+          },
+          {
+            name: 'get_mcp_info',
+            description: t('mcp.toolDescriptionGetMcpInfo'),
+            annotations: { readOnlyHint: true, idempotentHint: true },
+            inputSchema: {
+              type: 'object',
+              properties: {
+                mcp_id: {
+                  type: 'string',
+                  description: t('mcp.getMcpInfoIdDescription'),
+                },
+              },
+              required: ['mcp_id'],
+            },
+          },
+          {
+            name: 'call_tool',
+            description: t('mcp.toolDescriptionCallTool'),
+            annotations: { readOnlyHint: false, idempotentHint: false },
+            inputSchema: {
+              type: 'object',
+              properties: {
+                mcp_id: {
+                  type: 'string',
+                  description: t('mcp.callToolMcpIdDescription'),
+                },
+                tool_name: {
+                  type: 'string',
+                  description: t('mcp.callToolNameDescription'),
+                },
+                arguments: {
+                  type: 'object',
+                  description: t('mcp.callToolArgsDescription'),
+                },
+              },
+              required: ['mcp_id', 'tool_name'],
+            },
+          },
+          {
+            name: 'create_user_mcp',
+            description: t('mcp.toolDescriptionCreateUserMcp'),
+            annotations: { readOnlyHint: false, idempotentHint: false },
+            inputSchema: {
+              type: 'object',
+              properties: {
+                name: { type: 'string', description: t('mcp.createMcpNameDescription') },
+                description: { type: 'string', description: t('mcp.createMcpDescDescription') },
+                tools: { type: 'string', description: t('mcp.createMcpToolsDescription') },
+                code: { type: 'string', description: t('mcp.createMcpCodeDescription') },
+                category: { type: 'string', enum: ['productivity', 'development', 'communication', 'data', 'media', 'custom'], description: t('mcp.createMcpCategoryDescription') },
+                envVars: { type: 'string', description: t('mcp.createMcpEnvVarsDescription') },
+              },
+              required: ['name', 'description', 'code'],
+            },
+          },
+          {
+            name: 'list_user_mcps',
+            description: t('mcp.toolDescriptionListUserMcps'),
+            annotations: { readOnlyHint: true, idempotentHint: true },
+            inputSchema: { type: 'object', properties: {}, required: [] },
+          },
+          {
+            name: 'delete_user_mcp',
+            description: t('mcp.toolDescriptionDeleteUserMcp'),
+            annotations: { readOnlyHint: false, idempotentHint: false },
+            inputSchema: {
+              type: 'object',
+              properties: {
+                mcp_id: { type: 'string', description: t('mcp.deleteUserMcpIdDescription') },
+              },
+              required: ['mcp_id'],
+            },
+          },
+        ],
+      };
+    });
+
+    // ツール実行
+    this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+      const { name } = request.params;
+      if (name === 'load_knowledge' || name === 'inject_knowledge') {
+        const { keyword } = request.params.arguments;
+
+        log(`[MCP Server] load_knowledge called with keyword: ${keyword}`);
+        log(`[MCP Server] TOKEN: ${TOKEN ? TOKEN.substring(0, 20) + '...' : 'missing'}`);
+        log(`[MCP Server] PORTAL_URL: ${PORTAL_URL}`);
+        log(`[MCP Server] LANGUAGE: ${LANGUAGE}`);
+
+        try {
+          // Portal APIから認証付きで知識を取得（言語パラメータ付き）
+          const result = await getPromptFromPortal(keyword, TOKEN, LANGUAGE);
+
+          if (!result || !result.success) {
+            const errorMessage = result?.error || t('mcp.knowledgeNotFound', { keyword });
+            log(`[MCP Server] Knowledge loading failed: ${errorMessage}`);
+            return {
+              content: [
+                {
+                  type: 'text',
+                  text: `❌ ${t('mcp.portalApiFailed', { error: errorMessage })}`,
+                },
+              ],
+              isError: true,
+            };
+          }
+
+          // 言語指示（英語ユーザーの場合、周囲の日本語コンテキストに流されないよう明示）
+          const langInstruction = LANGUAGE !== 'ja'
+            ? `\n\n[Language Instruction] Communicate with the user in English. Respond in English regardless of surrounding context language.`
+            : '';
+
+          // 専門コンテキスト読み込み完了メッセージを返す
+          return {
+            content: [
+              {
+                type: 'text',
+                text: `✅ ${t('mcp.knowledgeLoadSuccess')}
+
+${result.knowledge}${langInstruction}
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+${t('mcp.knowledgeApplied')}`,
+              },
+            ],
+          };
+        } catch (error) {
+          log(`[MCP Server] Exception in load_knowledge: ${error.message}`);
+          return {
+            content: [
+              {
+                type: 'text',
+                text: `❌ ${t('mcp.knowledgeLoadError', { error: error.message })}`,
+              },
+            ],
+            isError: true,
+          };
+        }
+      }
+
+      if (name === 'report_violation') {
+        const { reason, severity, userMessage } = request.params.arguments;
+
+        log(`[MCP Server] report_violation called: severity=${severity}, reason=${reason}`);
+
+        try {
+          const result = await reportViolation(reason, severity, TOKEN, userMessage);
+
+          if (!result || !result.success) {
+            return {
+              content: [{ type: 'text', text: `❌ ${t('mcp.violationReportFailed', { error: result?.error || 'Unknown' })}` }],
+              isError: true,
+            };
+          }
+
+          return {
+            content: [{ type: 'text', text: `🔒 ${result.message}` }],
+          };
+        } catch (error) {
+          log(`[MCP Server] report_violation error: ${error.message}`);
+          return {
+            content: [{ type: 'text', text: `❌ ${t('mcp.violationReportError', { error: error.message })}` }],
+            isError: true,
+          };
+        }
+      }
+
+      if (name === 'list_available_mcps') {
+        const { category, search } = request.params.arguments || {};
+        log(`[MCP Server] list_available_mcps called: category=${category}, search=${search}`);
+        try {
+          const result = await listAvailableMcps({ category, search }, TOKEN, LANGUAGE);
+          if (!result || !result.success) {
+            return { content: [{ type: 'text', text: `❌ ${t('mcp.listMcpsFailed', { error: result?.error || 'Unknown' })}` }], isError: true };
+          }
+          const mcps = result.data || [];
+          let text = `📋 ${t('mcp.listMcpsTitle')}\n\n`;
+          if (mcps.length === 0) {
+            text += t('mcp.listMcpsEmpty');
+          } else {
+            mcps.forEach(mcp => {
+              const toolCount = mcp.tools?.length || 0;
+              text += `**${mcp.name}** (${mcp.mcpId})\n`;
+              text += `  ${mcp.description}\n`;
+              text += `  カテゴリ: ${mcp.category} | ツール数: ${toolCount} | アクセス: ${mcp.hasAccess ? '✅' : '❌'}\n\n`;
+            });
+          }
+          return { content: [{ type: 'text', text }] };
+        } catch (error) {
+          log(`[MCP Server] list_available_mcps error: ${error.message}`);
+          return { content: [{ type: 'text', text: `❌ ${error.message}` }], isError: true };
+        }
+      }
+
+      if (name === 'get_mcp_info') {
+        const { mcp_id } = request.params.arguments;
+        log(`[MCP Server] get_mcp_info called: mcpId=${mcp_id}`);
+        try {
+          const result = await getMcpInfo(mcp_id, TOKEN, LANGUAGE);
+          if (!result || !result.success) {
+            return { content: [{ type: 'text', text: `❌ ${t('mcp.getMcpInfoFailed', { error: result?.error || 'Unknown' })}` }], isError: true };
+          }
+          const mcp = result.data;
+          let text = `🔧 **${mcp.name}** (${mcp.mcpId})\n\n`;
+          text += `${mcp.description}\n\n`;
+          text += `カテゴリ: ${mcp.category}\n`;
+          text += `アクセス: ${mcp.hasAccess ? '利用可能' : '利用不可'}\n`;
+          text += `ステータス: ${mcp.status}\n\n`;
+          if (mcp.tools && mcp.tools.length > 0) {
+            text += `### ツール一覧 (${mcp.tools.length})\n\n`;
+            mcp.tools.forEach(tool => {
+              text += `- **${tool.name}**: ${tool.description}\n`;
+              if (tool.inputSchema?.properties) {
+                const params = Object.entries(tool.inputSchema.properties);
+                params.forEach(([key, val]) => {
+                  text += `  - \`${key}\` (${val.type || 'any'}): ${val.description || ''}\n`;
+                });
+              }
+            });
+          }
+          if (mcp.requiredCredentials && mcp.requiredCredentials.length > 0) {
+            text += `\n### 必要な認証情報\n`;
+            mcp.requiredCredentials.forEach(cred => {
+              text += `- **${cred.displayName}** (${cred.key}): ${cred.required ? '必須' : '任意'}\n`;
+            });
+          }
+          return { content: [{ type: 'text', text }] };
+        } catch (error) {
+          log(`[MCP Server] get_mcp_info error: ${error.message}`);
+          return { content: [{ type: 'text', text: `❌ ${error.message}` }], isError: true };
+        }
+      }
+
+      if (name === 'call_tool') {
+        const { mcp_id, tool_name, arguments: toolArgs } = request.params.arguments;
+        log(`[MCP Server] call_tool called: mcpId=${mcp_id}, tool=${tool_name}`);
+        try {
+          const result = await callMcpTool(mcp_id, tool_name, toolArgs || {}, TOKEN);
+          if (!result || !result.success) {
+            return { content: [{ type: 'text', text: `❌ ${t('mcp.callToolFailed', { error: result?.error || 'Unknown' })}` }], isError: true };
+          }
+          const data = result.data;
+          if (typeof data === 'string') {
+            return { content: [{ type: 'text', text: data }] };
+          }
+          return { content: [{ type: 'text', text: JSON.stringify(data, null, 2) }] };
+        } catch (error) {
+          log(`[MCP Server] call_tool error: ${error.message}`);
+          return { content: [{ type: 'text', text: `❌ ${error.message}` }], isError: true };
+        }
+      }
+
+      if (name === 'create_user_mcp') {
+        const args = request.params.arguments;
+        log(`[MCP Server] create_user_mcp called: name=${args.name}`);
+        try {
+          // tools/envVars がJSON文字列の場合パース
+          let tools = args.tools;
+          if (typeof tools === 'string') {
+            try { tools = JSON.parse(tools); } catch (e) { tools = []; }
+          }
+          let envVars = args.envVars;
+          if (typeof envVars === 'string') {
+            try { envVars = JSON.parse(envVars); } catch (e) { envVars = undefined; }
+          }
+
+          const deployData = {
+            code: args.code,
+            name: args.name,
+            description: args.description || '',
+            tools: tools || [],
+            category: args.category || 'custom',
+            envVars
+          };
+
+          const result = await deployUserMcp(deployData, TOKEN);
+          if (!result || !result.success) {
+            const errorMsg = result?.details
+              ? `${t('mcp.createMcpScanFailed')}\n${JSON.stringify(result.details, null, 2)}`
+              : t('mcp.createMcpFailed', { error: result?.error || 'Unknown' });
+            return { content: [{ type: 'text', text: `❌ ${errorMsg}` }], isError: true };
+          }
+
+          const data = result.data;
+          return {
+            content: [{ type: 'text', text: `✅ ${t('mcp.createMcpSuccess')}\n\n**MCP ID**: ${data.mcpId}\n**Endpoint**: ${data.endpoint}\n**有効化**: ${data.enabled ? '自動有効化済み' : '未有効化'}` }]
+          };
+        } catch (error) {
+          log(`[MCP Server] create_user_mcp error: ${error.message}`);
+          return { content: [{ type: 'text', text: `❌ ${error.message}` }], isError: true };
+        }
+      }
+
+      if (name === 'list_user_mcps') {
+        log(`[MCP Server] list_user_mcps called`);
+        try {
+          const result = await listUserCreatedMcps(TOKEN);
+          if (!result || !result.success) {
+            return { content: [{ type: 'text', text: `❌ ${result?.error || 'Unknown'}` }], isError: true };
+          }
+          const mcps = result.data?.mcps || [];
+          let text = `📋 ${t('mcp.listUserMcpsTitle')}\n\n`;
+          if (mcps.length === 0) {
+            text += t('mcp.listUserMcpsEmpty');
+          } else {
+            mcps.forEach(mcp => {
+              text += `**${mcp.name}** (${mcp.mcpId})\n`;
+              text += `  ${mcp.description || ''}\n`;
+              text += `  カテゴリ: ${mcp.category} | ツール数: ${mcp.toolCount || 0} | ステータス: ${mcp.status}\n`;
+              if (mcp.endpoint) text += `  エンドポイント: ${mcp.endpoint}\n`;
+              text += '\n';
+            });
+          }
+          return { content: [{ type: 'text', text }] };
+        } catch (error) {
+          log(`[MCP Server] list_user_mcps error: ${error.message}`);
+          return { content: [{ type: 'text', text: `❌ ${error.message}` }], isError: true };
+        }
+      }
+
+      if (name === 'delete_user_mcp') {
+        const { mcp_id } = request.params.arguments;
+        log(`[MCP Server] delete_user_mcp called: mcpId=${mcp_id}`);
+        try {
+          const result = await deleteUserMcp(mcp_id, TOKEN);
+          if (!result || !result.success) {
+            return { content: [{ type: 'text', text: `❌ ${t('mcp.deleteUserMcpFailed', { error: result?.error || 'Unknown' })}` }], isError: true };
+          }
+          return { content: [{ type: 'text', text: `✅ ${t('mcp.deleteUserMcpSuccess', { mcpId: mcp_id })}` }] };
+        } catch (error) {
+          log(`[MCP Server] delete_user_mcp error: ${error.message}`);
+          return { content: [{ type: 'text', text: `❌ ${error.message}` }], isError: true };
+        }
+      }
+
+      return {
+        content: [
+          {
+            type: 'text',
+            text: `Unknown tool: ${request.params.name}`,
+          },
+        ],
+        isError: true,
+      };
+    });
+  }
+
+  async run() {
+    const transport = new StdioServerTransport();
+    await this.server.connect(transport);
+    logger.info('BlueLamp VSCode MCP server started');
+
+    // 起動時に自動的に知識を読み込み（環境変数で指定されたキーワード）
+    if (KEYWORD && TOKEN) {
+      log(`[MCP Server] Auto-loading knowledge for keyword: ${KEYWORD} (lang: ${LANGUAGE})`);
+      const result = await getPromptFromPortal(KEYWORD, TOKEN, LANGUAGE);
+      if (result && result.success) {
+        log(`[MCP Server] Auto-load successful: ${result.title}`);
+      } else {
+        log(`[MCP Server] Auto-load failed for keyword: ${KEYWORD}`);
+      }
+    }
+  }
+}
+
+// サーバー起動
+const server = new BlueLampVSCodeServer();
+server.run().catch((err) => logger.error(err.message));