bluelamp 3.0.8 → 4.0.0

package/lib/auth/TokenManager.js

@@ -0,0 +1,258 @@
+/**
+ * TokenManager - Portal統合CLIトークン管理クラス
+ * CommonJS版（bluelamp-vscode用）
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const crypto = require('crypto');
+const https = require('https');
+const http = require('http');
+const { URL } = require('url');
+
+class TokenManager {
+    static TOKEN_FILE_PATH = path.join(os.homedir(), '.bluelamp-vscode', 'portal-token.enc');
+    static PORTAL_API_URL_PROD = 'https://bluelamp-6clpzmy5pa-an.a.run.app/api/cli/verify';
+    static PORTAL_API_URL_LOCAL = 'https://bluelamp-6clpzmy5pa-an.a.run.app/api/cli/verify';
+    static ENCRYPTION_KEY = 'bluelamp-vscode-portal-token-key-2024';
+    static REQUEST_TIMEOUT = 10000; // 10秒
+
+    /**
+     * 開発環境かどうかを判定
+     */
+    static isLocalDev() {
+        return process.env.PORTAL_URL && process.env.PORTAL_URL.includes('localhost');
+    }
+
+    /**
+     * APIエンドポイントを取得
+     */
+    static getApiUrl(endpoint) {
+        // 環境変数から取得（デフォルトは本番）
+        const portalUrl = process.env.PORTAL_URL || 'https://bluelamp-6clpzmy5pa-an.a.run.app';
+        return portalUrl + endpoint;
+    }
+
+    /**
+     * Portal発行CLIトークンを暗号化して保存
+     */
+    static async saveToken(token, userInfo = {}) {
+        try {
+            // トークン形式検証
+            if (!this.validateTokenFormat(token)) {
+                throw new Error('Portal発行のcli_形式トークンのみサポートされています');
+            }
+
+            // 保存データ構造
+            const tokenData = {
+                token: token,
+                savedAt: Date.now(),
+                userInfo: userInfo,
+                version: '1.0',
+                source: 'portal'
+            };
+
+            // 暗号化
+            const encrypted = this.encrypt(JSON.stringify(tokenData));
+
+            // ディレクトリ作成
+            const tokenDir = path.dirname(this.TOKEN_FILE_PATH);
+            if (!fs.existsSync(tokenDir)) {
+                fs.mkdirSync(tokenDir, { recursive: true });
+            }
+
+            // ファイル保存
+            fs.writeFileSync(this.TOKEN_FILE_PATH, encrypted);
+            console.log('   ✅ トークン保存完了');
+
+            return true;
+
+        } catch (error) {
+            console.error('❌ トークン保存エラー:', error.message);
+            return false;
+        }
+    }
+
+    /**
+     * 保存されたPortal CLIトークンを読み込み
+     */
+    static async loadToken() {
+        try {
+            if (!fs.existsSync(this.TOKEN_FILE_PATH)) {
+                return null;
+            }
+
+            // ファイル読み込み
+            const encrypted = fs.readFileSync(this.TOKEN_FILE_PATH, 'utf8');
+
+            // 復号化
+            const decrypted = this.decrypt(encrypted);
+            const tokenData = JSON.parse(decrypted);
+
+            // データ構造確認
+            if (!tokenData.token || !tokenData.version) {
+                return null;
+            }
+
+            return tokenData;
+
+        } catch (error) {
+            console.error('❌ トークン読み込みエラー:', error.message);
+            return null;
+        }
+    }
+
+    /**
+     * Portal API でトークン検証
+     */
+    static async validateToken(token) {
+        try {
+            const response = await this.makeRequest({
+                method: 'POST',
+                url: this.getApiUrl('/api/cli/verify'),
+                headers: {
+                    'Content-Type': 'application/json',
+                    'X-CLI-Token': token
+                },
+                body: JSON.stringify({ token: token })
+            });
+
+            if (response.success && response.data) {
+                return {
+                    valid: true,
+                    userInfo: {
+                        id: response.data.userId,
+                        name: response.data.userName,
+                        email: response.data.userEmail,
+                        role: response.data.userRole
+                    }
+                };
+            } else {
+                return { valid: false, error: response.message };
+            }
+
+        } catch (error) {
+            return { valid: false, error: error.message };
+        }
+    }
+
+    /**
+     * 保存されたPortal CLIトークンを削除
+     */
+    static async deleteToken() {
+        try {
+            if (fs.existsSync(this.TOKEN_FILE_PATH)) {
+                fs.unlinkSync(this.TOKEN_FILE_PATH);
+                return true;
+            }
+            return true;
+        } catch (error) {
+            console.error('❌ トークン削除エラー:', error.message);
+            return false;
+        }
+    }
+
+    /**
+     * トークン形式検証
+     */
+    static validateTokenFormat(token) {
+        if (!token || typeof token !== 'string') {
+            return false;
+        }
+
+        // Portal発行形式: cli_xxxxx_[64文字の16進数]
+        const patterns = [
+            /^cli_[a-z0-9]+_[a-f0-9]{64}$/,  // 通常形式
+            /^cli_vscode_test_[a-f0-9]{64}$/ // テスト形式
+        ];
+
+        return patterns.some(pattern => pattern.test(token));
+    }
+
+    /**
+     * データ暗号化
+     */
+    static encrypt(text) {
+        const algorithm = 'aes-256-cbc';
+        const key = crypto.scryptSync(this.ENCRYPTION_KEY, 'salt', 32);
+        const iv = crypto.randomBytes(16);
+
+        const cipher = crypto.createCipheriv(algorithm, key, iv);
+        let encrypted = cipher.update(text, 'utf8', 'hex');
+        encrypted += cipher.final('hex');
+
+        return iv.toString('hex') + ':' + encrypted;
+    }
+
+    /**
+     * データ復号化
+     */
+    static decrypt(encryptedData) {
+        const algorithm = 'aes-256-cbc';
+        const key = crypto.scryptSync(this.ENCRYPTION_KEY, 'salt', 32);
+
+        const parts = encryptedData.split(':');
+        const iv = Buffer.from(parts[0], 'hex');
+        const encrypted = parts[1];
+
+        const decipher = crypto.createDecipheriv(algorithm, key, iv);
+        let decrypted = decipher.update(encrypted, 'hex', 'utf8');
+        decrypted += decipher.final('utf8');
+
+        return decrypted;
+    }
+
+    /**
+     * HTTP/HTTPS リクエスト実行
+     */
+    static async makeRequest(options) {
+        return new Promise((resolve, reject) => {
+            const url = new URL(options.url);
+            const requestOptions = {
+                hostname: url.hostname,
+                port: url.port || (url.protocol === 'https:' ? 443 : 80),
+                path: url.pathname + url.search,
+                method: options.method || 'GET',
+                headers: options.headers || {},
+                timeout: this.REQUEST_TIMEOUT
+            };
+
+            const client = url.protocol === 'https:' ? https : http;
+
+            const req = client.request(requestOptions, (res) => {
+                let data = '';
+
+                res.on('data', (chunk) => {
+                    data += chunk;
+                });
+
+                res.on('end', () => {
+                    try {
+                        const jsonData = JSON.parse(data);
+                        resolve(jsonData);
+                    } catch (error) {
+                        reject(new Error(`Invalid JSON response: ${data}`));
+                    }
+                });
+            });
+
+            req.on('error', (error) => {
+                reject(error);
+            });
+
+            req.on('timeout', () => {
+                req.destroy();
+                reject(new Error('Request timeout'));
+            });
+
+            if (options.body) {
+                req.write(options.body);
+            }
+
+            req.end();
+        });
+    }
+}
+
+module.exports = { TokenManager };

package/lib/mcp-server/fetch-prompt.js

@@ -0,0 +1,61 @@
+/**
+ * Portal APIからプロンプトを取得するモジュール
+ */
+
+import fetch from 'node-fetch';
+
+const PORTAL_URL = process.env.PORTAL_URL || 'https://bluelamp-6clpzmy5pa-an.a.run.app';
+
+/**
+ * キーワードに基づいてPortalからプロンプトを取得
+ */
+export async function fetchPromptFromPortal(keyword) {
+  try {
+    // Portal APIエンドポイント
+    const response = await fetch(`${PORTAL_URL}/api/prompts/by-keyword/${encodeURIComponent(keyword)}`, {
+      method: 'GET',
+      headers: {
+        'Content-Type': 'application/json',
+      }
+    });
+
+    if (!response.ok) {
+      console.error(`Portal API error: ${response.status}`);
+      return null;
+    }
+
+    const data = await response.json();
+
+    if (!data.prompt) {
+      console.error('No prompt found in response');
+      return null;
+    }
+
+    // Portalから取得したプロンプトデータを返す
+    return {
+      title: data.prompt.name || keyword,
+      content: data.prompt.text || '',
+      tags: data.prompt.tags || [],
+      level: 'expert'
+    };
+
+  } catch (error) {
+    console.error('Failed to fetch prompt from Portal:', error);
+    return null;
+  }
+}
+
+/**
+ * フォールバック用のデフォルトプロンプト
+ */
+export const DEFAULT_PROMPTS = {
+  'BL-要件定義': {
+    title: '要件定義エンジニア',
+    content: `あなたは要件定義のスペシャリストです。
+- ユーザーの要求を正確に理解し、技術要件に落とし込む
+- 機能要件と非機能要件を明確に分離
+- 実装可能性を考慮した要件定義`,
+    level: 'expert'
+  },
+  // ... 他の15個も同様
+};

package/lib/mcp-server/index.cjs

@@ -0,0 +1,164 @@
+#!/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 } = require('./portal-api-client.cjs');
+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 });
+  console.error('[MCP Server] Loaded .env.local');
+} else if (fs.existsSync(dotenvPath)) {
+  require('dotenv').config({ path: dotenvPath });
+  console.error('[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://bluelamp-6clpzmy5pa-an.a.run.app';
+
+// ログファイル設定（固定名にして見つけやすくする）
+const LOG_FILE = path.join(os.tmpdir(), 'bluelamp-vscode-mcp-latest.log');
+
+function log(message) {
+  const timestamp = new Date().toISOString();
+  const logMessage = `[${timestamp}] ${message}\n`;
+  fs.appendFileSync(LOG_FILE, logMessage);
+  console.error(`[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(`  .env file exists: ${fs.existsSync(dotenvPath)}`);
+
+class BlueLampVSCodeServer {
+  constructor() {
+    this.server = new Server(
+      {
+        name: 'bluelamp-vscode',
+        version: '1.0.0',
+      },
+      {
+        capabilities: {
+          tools: {},
+        },
+      }
+    );
+
+    this.setupHandlers();
+  }
+
+  setupHandlers() {
+    // ツール一覧を返す
+    this.server.setRequestHandler(ListToolsRequestSchema, async () => {
+      log('[MCP Server] ListTools request received');
+      return {
+        tools: [
+          {
+            name: 'inject_knowledge',
+            description: 'BlueLamp VSCode開発プロンプトの知識を注入',
+            inputSchema: {
+              type: 'object',
+              properties: {
+                keyword: {
+                  type: 'string',
+                  description: 'キーワード（@相談 など、そのまま指定してください。プレフィックスの追加は不要です）',
+                },
+              },
+              required: ['keyword'],
+            },
+          },
+        ],
+      };
+    });
+
+    // ツール実行
+    this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+      if (request.params.name === 'inject_knowledge') {
+        const { keyword } = request.params.arguments;
+
+        log(`[MCP Server] inject_knowledge called with keyword: ${keyword}`);
+        log(`[MCP Server] TOKEN: ${TOKEN ? TOKEN.substring(0, 20) + '...' : 'missing'}`);
+        log(`[MCP Server] PORTAL_URL: ${PORTAL_URL}`);
+
+        // Portal APIから認証付きで知識を取得
+        const result = await getPromptFromPortal(keyword, TOKEN);
+
+        if (!result || !result.success) {
+          return {
+            content: [
+              {
+                type: 'text',
+                text: `❌ Portal APIから知識を取得できませんでした: "${keyword}"`,
+              },
+            ],
+          };
+        }
+
+        // 知識注入メッセージを返す
+        return {
+          content: [
+            {
+              type: 'text',
+              text: `✅ BlueLamp VSCode 知識注入完了
+
+${result.knowledge}
+
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+専門知識が注入されました。このロールで支援を開始します。`,
+            },
+          ],
+        };
+      }
+
+      return {
+        content: [
+          {
+            type: 'text',
+            text: `Unknown tool: ${request.params.name}`,
+          },
+        ],
+      };
+    });
+  }
+
+  async run() {
+    const transport = new StdioServerTransport();
+    await this.server.connect(transport);
+    console.error('BlueLamp VSCode MCP server started');
+
+    // 起動時に自動的に知識を注入（環境変数で指定されたキーワード）
+    if (KEYWORD && TOKEN) {
+      log(`[MCP Server] Auto-injecting knowledge for keyword: ${KEYWORD}`);
+      const result = await getPromptFromPortal(KEYWORD, TOKEN);
+      if (result && result.success) {
+        log(`[MCP Server] Auto-injection successful: ${result.title}`);
+      } else {
+        log(`[MCP Server] Auto-injection failed for keyword: ${KEYWORD}`);
+      }
+    }
+  }
+}
+
+// サーバー起動
+const server = new BlueLampVSCodeServer();
+server.run().catch(console.error);

package/lib/mcp-server/portal-api-client.cjs

@@ -0,0 +1,210 @@
+/**
+ * Portal API Client for BlueLamp VSCode
+ * 認証付きでPortal APIからプロンプトを取得
+ */
+
+const fetch = (...args) => import('node-fetch').then(({default: fetch}) => fetch(...args));
+const https = require('https');
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+// 自己署名証明書を許可するHTTPSエージェント
+const httpsAgent = new https.Agent({
+  rejectUnauthorized: false
+});
+
+const PORTAL_URL = process.env.PORTAL_URL || 'https://bluelamp-6clpzmy5pa-an.a.run.app';
+
+// ログファイル（index.cjsと同じファイルに書き込む）
+const LOG_FILE = path.join(os.tmpdir(), 'bluelamp-vscode-mcp-latest.log');
+
+// 共通設定のキャッシュ（5分間有効）
+let globalConfigCache = null;
+let cacheExpiry = 0;
+
+function log(message) {
+  const timestamp = new Date().toISOString();
+  const logMessage = `[${timestamp}] ${message}\n`;
+  fs.appendFileSync(LOG_FILE, logMessage);
+  console.error(message);
+}
+
+/**
+ * 共通CLAUDE.MD設定を取得（オプショナル）
+ * エラーが発生してもnullを返して処理を継続
+ */
+async function getGlobalConfig(token) {
+  try {
+    // キャッシュが有効ならそれを返す
+    if (globalConfigCache && Date.now() < cacheExpiry) {
+      log('[portal-api-client] Using cached global config');
+      return globalConfigCache;
+    }
+
+    if (!token) {
+      return null;
+    }
+
+    // Portal APIから共通設定を取得
+    const url = `${PORTAL_URL}/api/cli/global-config`;
+    log(`[portal-api-client] Fetching global config from: ${url}`);
+
+    const response = await fetch(url, {
+      method: 'GET',
+      headers: {
+        'X-CLI-Token': token,
+        'Content-Type': 'application/json',
+        'User-Agent': 'BlueLamp-VSCode-MCP/1.0'
+      },
+      agent: httpsAgent
+    });
+
+    if (response.ok) {
+      const data = await response.json();
+      if (data.success && data.content) {
+        log('[portal-api-client] Global config fetched successfully');
+        globalConfigCache = data.content;
+        cacheExpiry = Date.now() + 300000; // 5分間キャッシュ
+        return data.content;
+      }
+    }
+
+    log('[portal-api-client] Global config not available (optional)');
+    return null;
+
+  } catch (error) {
+    // エラーが発生しても処理を継続（後方互換性）
+    log(`[portal-api-client] Global config fetch error (optional): ${error.message}`);
+    return null;
+  }
+}
+
+/**
+ * Portal APIから認証付きでプロンプトを取得
+ */
+async function getPromptFromPortal(keyword, token) {
+  try {
+    log(`[portal-api-client] getPromptFromPortal called with keyword: ${keyword}, token: ${token ? 'present' : 'missing'}`);
+
+    if (!token) {
+      log('[portal-api-client] No authentication token provided');
+      return null;
+    }
+
+    // キーワードをそのまま使用
+    const encodedKeyword = encodeURIComponent(keyword);
+    const url = `${PORTAL_URL}/api/cli/prompts/knowledge-injection/${encodedKeyword}`;
+    log(`[portal-api-client] Direct keyword search: ${url}`);
+    log(`[portal-api-client] Token (first 30 chars): ${token.substring(0, 30)}...`);
+
+    log(`[portal-api-client] About to call fetch...`);
+    const response = await fetch(url, {
+      method: 'GET',
+      headers: {
+        'X-CLI-Token': token,
+        'Content-Type': 'application/json',
+        'User-Agent': 'BlueLamp-VSCode-MCP/1.0'
+      },
+      agent: url.startsWith('https') ? httpsAgent : undefined
+    });
+    log(`[portal-api-client] Fetch completed`);
+
+    log(`[portal-api-client] Response status: ${response.status}`);
+    log(`[portal-api-client] Response headers: ${JSON.stringify(Object.fromEntries(response.headers.entries()))}`);
+
+    if (!response.ok) {
+      log(`[portal-api-client] Portal API error: ${response.status}`);
+      const errorText = await response.text();
+      log(`[portal-api-client] Error response: ${errorText}`);
+      return null;
+    }
+
+    const data = await response.json();
+    log(`[portal-api-client] Direct keyword search completed successfully`);
+
+    if (!data.success) {
+      log(`[portal-api-client] API returned success: false`);
+      return null;
+    }
+
+    // 直接プロンプトデータを取得（検索不要）
+    const prompt = data.data;
+
+    if (!prompt) {
+      log(`[portal-api-client] No prompt found for keyword: ${keyword}`);
+      return null;
+    }
+
+    log(`[portal-api-client] Found prompt: ${prompt.title}`);
+
+    // プロンプトの詳細情報が既に含まれているかチェック
+    if (prompt.content || prompt.text) {
+      // 詳細情報が含まれている場合はそのまま返す
+      return {
+        success: true,
+        knowledge: prompt.content || prompt.text,
+        title: prompt.title,
+        tags: prompt.tags || []
+      };
+    }
+
+    // 個別のプロンプト詳細を取得
+    try {
+      const detailUrl = `${PORTAL_URL}/api/cli/prompts/${prompt.id}`;
+      log(`[portal-api-client] Fetching prompt details from: ${detailUrl}`);
+
+      const detailResponse = await fetch(detailUrl, {
+        method: 'GET',
+        headers: {
+          'X-CLI-Token': token,
+          'Content-Type': 'application/json',
+          'User-Agent': 'BlueLamp-VSCode-MCP/1.0'
+        },
+        agent: httpsAgent
+      });
+
+      if (detailResponse.ok) {
+        const detailData = await detailResponse.json();
+        if (detailData.success && detailData.data?.prompt?.content) {
+          log(`[portal-api-client] Successfully fetched prompt content`);
+
+          // 共通設定を取得（オプショナル）
+          const globalConfig = await getGlobalConfig(token);
+          let finalContent = detailData.data.prompt.content;
+
+          // 共通設定があれば先頭に追加
+          if (globalConfig) {
+            log(`[portal-api-client] Adding global config to prompt content`);
+            finalContent = `${globalConfig}\n\n---\n\n${finalContent}`;
+          }
+
+          return {
+            success: true,
+            knowledge: finalContent,
+            title: prompt.title || prompt.name,
+            tags: prompt.tags
+          };
+        }
+      }
+    } catch (error) {
+      log(`[portal-api-client] Error fetching prompt details: ${error.message}`);
+    }
+
+    // フォールバック: リスト情報のみ返す
+    return {
+      success: true,
+      knowledge: prompt.description || `# ${prompt.title}\n\n詳細情報の取得に失敗しました。`,
+      title: prompt.title || prompt.name,
+      tags: prompt.tags
+    };
+
+  } catch (error) {
+    log(`[portal-api-client] FATAL ERROR in getPromptFromPortal: ${error.message}`);
+    log(`[portal-api-client] Error stack: ${error.stack}`);
+    console.error('Failed to get prompt from Portal:', error);
+    return null;
+  }
+}
+
+module.exports = { getPromptFromPortal, getGlobalConfig };