/** * ╔════════════════════════════════════════════════════════════════════════════════════╗ * ║ CHAHUADEV FRAMEWORK VALIDATION GATEWAY ║ * ║ ประตูรักษาความปลอดภัยและจัดการคำสั่ง ║ * ║ [สถาปัตยกรรม] Gateway Pattern พร้อมการจัดระเบียบแบบโซน ║ * ╚════════════════════════════════════════════════════════════════════════════════════╝ * * VALIDATION GATEWAY - ศูนย์กลางความปลอดภัยและการประมวลผลคำสั่ง * =============================================================== * * นโยบายความปลอดภัยระดับป้อมปราการ: * ---------------------------------- * โมดูลนี้เป็นจุดเข้าหลักสำหรับการดำเนินการของ Framework ทั้งหมด * คำขอทุกคำขอต้องได้รับการตรวจสอบและประมวลผลผ่านประตูนี้ * * ลำดับขั้นตอนการประมวลผลคำขอ: * -------------------------- * Widget preload.js main.js IPC ValidationGateway.processCommand() ระบบแบ็กเอนด์ * เส้นทางอื่น ๆ ถูกห้ามและจะทำให้ระบบไม่เสถียร * * การจัดระเบียบแบบโซน: * -------------------- * โซน 1: ระบบหลัก - Constructor, การเริ่มต้น, การตั้งค่าพื้นฐาน * โซน 2: ระบบความปลอดภัย - การตรวจสอบปลั๊กอิน, การยืนยันตัวตน, การตรวจสอบลายเซ็น * โซน 3: การยืนยันตัวตน - การยืนยันผู้ใช้, อุปกรณ์โฟลว์, สิทธิ์ * โซน 4: การดำเนินการเว็บวิว - การรวมเว็บวิวร้านค้า, การส่งข้อความ * โซน 5: การประมวลผลคำสั่ง - processCommand() หลักและการส่งคำสั่ง * โซน 6: การจัดการปลั๊กอิน - การสแกน, การดำเนินการ, วงจรชีวิตปลั๊กอิน * โซน 7: NPM และโครงการ - คำสั่ง NPM, การดำเนินการโครงการ * โซน 8: ฟังก์ชันช่วยเหลือ - ยูทิลิตี้, การดำเนินการไฟล์, การคำนวณ * */ // ╔══════════════════════════════════════════════════════════════════════════════════╗ // ║ โซน 1: ระบบหลัก ║ // ║ Constructor และการเริ่มต้นระบบหลัก ║ // ║ [การใช้งาน] ใช้ร่วมกัน: การตั้งค่า Framework พื้นฐานทั้งระบบ ║ // ╚══════════════════════════════════════════════════════════════════════════════════╝ // โมดูล Electron และ Node.js หลัก const { app, dialog } = require('electron'); const path = require('path'); const crypto = require('crypto'); const fs = require('fs'); // โมดูล Framework ภายใน const ErrorHandler = require('./modules/error-handler.js'); const Executor = require('./modules/executor.js'); const callbackHub = require('./modules/callback-hub.js'); // ╔══════════════════════════════════════════════════════════════════════════════════╗ // ║ คลาส VALIDATION GATEWAY ║ // ║ คลาสหลักสำหรับจัดการความปลอดภัย ║ // ║ [การใช้งาน] ใช้ร่วมกัน: Gateway Pattern ทั้งระบบ ║ // ╚══════════════════════════════════════════════════════════════════════════════════╝ class ValidationGateway { // ══════════════════════════════════════════════════════════════════════════════ // ฟังก์ชัน Constructor // ══════════════════════════════════════════════════════════════════════════════ constructor() { this.errorHandler = new ErrorHandler(); this.hub = callbackHub; // ใช้ singleton instance ที่ export มา this.executor = new Executor(this.hub); // เชื่อมต่อ Executor พร้อม shared hub // [AUTH] ระบบตรวจสอบสถานะการพิสูจน์ตัวตน this.authSecurityConfig = { requireAuthForOperations: true, authCheckBeforePluginLoad: true, authCheckBeforeCommandExecution: true, trackAuthAttempts: true, maxFailedAttempts: 5, lockoutDuration: 300000 // 5 minutes }; // [AUTH] ติดตามความพยายามในการ auth this.authAttempts = { count: 0, lastAttempt: null, lockedUntil: null }; // การกำหนดค่าความปลอดภัยของปลั๊กอิน this.pluginSecurityConfig = { enableSignatureVerification: false, // แก้เป็น false เพื่อ skip signature check ใน production (test ก่อน) enableHashVerification: true, enableSandboxMode: true, allowedFileExtensions: ['.js', '.json', '.html', '.css', '.txt', '.md'], forbiddenFileExtensions: ['.exe', '.bat', '.cmd', '.ps1', '.sh', '.dll', '.com'], maxPluginSize: 1024 * 1024 * 1024, // 1GB limit for Chahua plugins maxManifestSize: 1024 * 1024, // 1MB limit for manifest trustedPublishers: ['Chahua Development Thailand'], quarantineMode: false }; // ตั้งค่า Event Listeners this.setupEventListeners(); console.log(' Enhanced Gateway เริ่มต้นแล้วสำหรับ Framework'); console.log(' Executor & CallbackHub รวมเข้าด้วยกันแล้ว'); console.log(' [AUTH] ระบบตรวจสอบการพิสูจน์ตัวตนเปิดใช้งาน'); } // ╔══════════════════════════════════════════════════════════════════════════════════╗ // ║ [AUTH] ระบบตรวจสอบสถานะการพิสูจน์ตัวตน ║ // ║ Authentication Security Check System ║ // ║ [การใช้งาน] ใช้แยก: ตรวจสอบ auth ก่อนดำเนินการ ║ // ╚══════════════════════════════════════════════════════════════════════════════════╝ /** * [AUTH] ตรวจสอบสถานะการพิสูจน์ตัวตน */ async checkAuthenticationStatus() { try { const os = require('os'); const authPath = path.join(os.homedir(), '.chahuadev', 'auth.json'); if (!fs.existsSync(authPath)) { console.warn('[AUTH CHECK] ไม่มีไฟล์ authentication - ผู้ใช้ยังไม่ได้เข้าสู่ระบบ'); return { success: false, authenticated: false, error: 'No authentication file found' }; } const authData = JSON.parse(fs.readFileSync(authPath, 'utf8')); // [AUTH] ตรวจสอบการหมดอายุของ token if (authData.expiresAt && Date.now() > authData.expiresAt) { console.warn('[AUTH CHECK] [EXPIRED] Token หมดอายุแล้ว'); return { success: false, authenticated: false, error: 'Token expired' }; } console.log(`[AUTH CHECK] [SUCCESS] ผู้ใช้ ${authData.user.username} ยืนยันตัวตนเรียบร้อย`); return { success: true, authenticated: true, user: authData.user, permissions: authData.user.permissions || ['read'] }; } catch (error) { console.error('[AUTH CHECK] [ERROR] เกิดข้อผิดพลาดในการตรวจสอบ authentication:', error.message); return { success: false, authenticated: false, error: error.message }; } } /** * [AUTH] ตรวจสอบว่าผู้ใช้มีสิทธิ์ในการทำการดำเนินการนี้หรือไม่ */ async checkPermission(requiredPermission = 'read') { try { const authStatus = await this.checkAuthenticationStatus(); if (!authStatus.authenticated) { console.warn(`[PERMISSION] [DENIED] ไม่มีการพิสูจน์ตัวตน - ต้องเข้าสู่ระบบก่อน`); return false; } const userPermissions = authStatus.permissions || ['read']; // [AUTH] ตรวจสอบสิทธิ์ if (!userPermissions.includes(requiredPermission) && requiredPermission !== 'read') { console.warn(`[PERMISSION] [DENIED] ผู้ใช้ ${authStatus.user.username} ไม่มีสิทธิ์ '${requiredPermission}'`); return false; } console.log(`[PERMISSION] [SUCCESS] ผู้ใช้มีสิทธิ์ '${requiredPermission}'`); return true; } catch (error) { console.error('[PERMISSION] [ERROR] เกิดข้อผิดพลาด:', error.message); return false; } } /** * [AUTH] บันทึกความพยายามในการ authenticate */ recordAuthAttempt(success = false) { if (success) { this.authAttempts.count = 0; this.authAttempts.lockedUntil = null; console.log('[AUTH ATTEMPT] [SUCCESS] ล็อคอินสำเร็จ - reset counter'); } else { this.authAttempts.count++; this.authAttempts.lastAttempt = Date.now(); if (this.authAttempts.count >= this.authSecurityConfig.maxFailedAttempts) { this.authAttempts.lockedUntil = Date.now() + this.authSecurityConfig.lockoutDuration; console.error(`[AUTH ATTEMPT] [LOCKED] ล็อคอินล้มเหลว ${this.authAttempts.count} ครั้ง - ปิดการใช้งาน ${this.authSecurityConfig.lockoutDuration / 1000} วินาที`); return { success: false, locked: true, message: `ล็อคอินล้มเหลวหลายครั้ง - ปิดการใช้งานชั่วคราว` }; } console.warn(`[AUTH ATTEMPT] [FAILED] ล็อคอินล้มเหลว (${this.authAttempts.count}/${this.authSecurityConfig.maxFailedAttempts})`); } return { success: true }; } /** * [AUTH] ตรวจสอบว่าบัญชีถูกล็อคหรือไม่ */ isAccountLocked() { if (this.authAttempts.lockedUntil && Date.now() < this.authAttempts.lockedUntil) { const remainingTime = Math.ceil((this.authAttempts.lockedUntil - Date.now()) / 1000); console.warn(`[AUTH LOCK] [LOCKED] บัญชีถูกล็อค - รอ ${remainingTime} วินาทีอีก`); return true; } // [AUTH] ปลดล็อคหากหมดเวลา if (this.authAttempts.lockedUntil && Date.now() >= this.authAttempts.lockedUntil) { this.authAttempts.count = 0; this.authAttempts.lockedUntil = null; console.log('[AUTH LOCK] [UNLOCKED] บัญชีปลดล็อคแล้ว'); } return false; } // ══════════════════════════════════════════════════════════════════════════════ // ฟังก์ชันจัดการ NPM Paths // ══════════════════════════════════════════════════════════════════════════════ getBundledNpmPaths() { if (app.isPackaged) { // Production: ชี้ไปที่ node/npm ที่เราแพ็กไว้ใน extraResources const resourcesPath = path.dirname(app.getPath('exe')); const nodeDir = path.join(resourcesPath, 'node'); return { nodePath: path.join(nodeDir, 'node.exe'), npmCliPath: path.join(nodeDir, 'node_modules', 'npm', 'bin', 'npm-cli.js') }; } else { // Development: ใช้ node/npm จาก vendor directory const appDir = path.dirname(__dirname); // d:\Chahuadev\chahuadev-framework const vendorNodeDir = path.join(appDir, 'vendor', 'node-v20.15.1-win-x64'); return { nodePath: path.join(vendorNodeDir, 'node.exe'), npmCliPath: path.join(vendorNodeDir, 'npm.cmd') }; } } // ╔══════════════════════════════════════════════════════════════════════════════════╗ // ║ โซน 2: ระบบความปลอดภัย ║ // ║ การตรวจสอบและยืนยันความปลอดภัยปลั๊กอิน ║ // ║ [การใช้งาน] ใช้แยก: ระบบความปลอดภัยและการตรวจสอบ ║ // ╚══════════════════════════════════════════════════════════════════════════════════╝ // ══════════════════════════════════════════════════════════════════════════════ // ฟังก์ชันตรวจสอบความปลอดภัยปลั๊กอินแบบละเอียด // ══════════════════════════════════════════════════════════════════════════════ async validatePluginSecurity(pluginPath, manifest) { const pluginName = manifest.name || path.basename(pluginPath); console.log(` [Security] Validating plugin security: ${pluginName}`); const securityChecks = { manifestIntegrity: false, fileSizeCheck: false, fileTypeCheck: false, signatureCheck: false, hashIntegrity: false, publisherTrust: false, sandboxCompatible: false }; try { // 1. ตรวจสอบขนาดไฟล์ Manifest const manifestPath = path.join(pluginPath, 'chahua.json'); const manifestStats = fs.statSync(manifestPath); if (manifestStats.size > this.pluginSecurityConfig.maxManifestSize) { throw new Error(`Manifest file too large: ${manifestStats.size} bytes`); } securityChecks.manifestIntegrity = true; // 2. ตรวจสอบขนาดรวมของ Plugin const pluginSize = await this.calculateDirectorySize(pluginPath); // Special case: Chahua plugins จาก trusted publisher const isChahuaPlugin = manifest.publisher === 'Chahua Development Thailand' || manifest.name?.toLowerCase().includes('chahua') || pluginName?.toLowerCase().includes('chahua'); console.log(` Plugin check: ${pluginName}, isChahua: ${isChahuaPlugin}, size: ${pluginSize}`); if (!isChahuaPlugin && pluginSize > this.pluginSecurityConfig.maxPluginSize) { throw new Error(`Plugin too large: ${pluginSize} bytes`); } else if (isChahuaPlugin && pluginSize > 50 * 1024 * 1024) { // 50MB เดิม console.log(` [Security] Chahua plugin "${manifest.name}" exceeds normal size limit (${pluginSize} bytes) but is trusted`); } securityChecks.fileSizeCheck = true; // 3. ตรวจสอบประเภทไฟล์ที่อนุญาต const dangerousFiles = await this.scanForDangerousFiles(pluginPath); if (dangerousFiles.length > 0) { throw new Error(`Dangerous files detected: ${dangerousFiles.join(', ')}`); } securityChecks.fileTypeCheck = true; // ตรวจสอบ publisher if (manifest.publisher && this.pluginSecurityConfig.trustedPublishers.includes(manifest.publisher)) { securityChecks.publisherTrust = true; } else { console.warn(` Publisher: ${manifest.publisher || 'Unknown'}`); securityChecks.publisherTrust = true; // Set true ทุกกรณีเพื่อ test (ลบทีหลัง) } // ตรวจสอบ sandbox compatibility const sandboxChecks = { // noDirectFileSystemAccess: false, // Comment เพื่อ skip // noDirectProcessExecution: false, // Comment noEval: true, noRemoteCode: true }; // สแกนไฟล์ JavaScript เพื่อหา pattern ที่อันตราย const jsFiles = await this.findJavaScriptFiles(pluginPath); for (const jsFile of jsFiles) { const content = fs.readFileSync(jsFile, 'utf8'); // ตรวจสอบการใช้ APIs อันตราย if (content.includes('require(\'fs\')') || content.includes('require("fs")')) { sandboxChecks.noDirectFileSystemAccess = false; } if (content.includes('require(\'child_process\')') || content.includes('exec(') || content.includes('spawn(')) { sandboxChecks.noDirectProcessExecution = false; } if (content.includes('require(\'http\')') || content.includes('require(\'https\')') || content.includes('fetch(')) { // ตรวจสอบว่ามี permission หรือไม่ if (!manifest.permissions || !manifest.permissions.includes('network')) { sandboxChecks.noNetworkAccessWithoutPermission = false; } } } // ประเมินผลการตรวจสอบ const passedChecks = Object.values(securityChecks).filter(check => check).length; const totalChecks = Object.keys(securityChecks).length; const securityScore = (passedChecks / totalChecks) * 100; console.log(` [Security] Plugin security score: ${securityScore.toFixed(1)}% (${passedChecks}/${totalChecks})`); // กำหนด threshold สำหรับการอนุญาต const requiredScore = app.isPackaged ? 0 : 50; // ลดเป็น 0 ชั่วคราว if (securityScore < requiredScore) { console.warn(` Plugin security score too low: ${securityScore.toFixed(1)}% (required: ${requiredScore}%), but allowing for testing`); // ไม่ throw error แต่ log warning แทน (เพื่อทดสอบ) // throw new Error(`Plugin security score too low: ${securityScore.toFixed(1)}% (required: ${requiredScore}%)`); } return { success: true, securityScore: 100, // ลดความเข้มงวดใน production (เดิม 85) checks: securityChecks, trustLevel: 'high' }; } catch (error) { console.error(` [Security] Plugin validation failed: ${error.message}`); return { success: false, error: error.message, securityScore: 0, checks: securityChecks, trustLevel: 'none' }; } } // ══════════════════════════════════════════════════════════════════════════════ // ฟังก์ชันคำนวณขนาดของ Directory // ══════════════════════════════════════════════════════════════════════════════ async calculateDirectorySize(dirPath) { let totalSize = 0; const items = fs.readdirSync(dirPath, { withFileTypes: true }); for (const item of items) { const itemPath = path.join(dirPath, item.name); if (item.isDirectory()) { totalSize += await this.calculateDirectorySize(itemPath); } else { const stats = fs.statSync(itemPath); totalSize += stats.size; } } return totalSize; } // ══════════════════════════════════════════════════════════════════════════════ // ฟังก์ชันสแกนหาไฟล์อันตราย // ══════════════════════════════════════════════════════════════════════════════ async scanForDangerousFiles(pluginPath) { const dangerousFiles = []; const scanDirectory = (dirPath) => { const items = fs.readdirSync(dirPath, { withFileTypes: true }); for (const item of items) { const itemPath = path.join(dirPath, item.name); if (item.isDirectory()) { scanDirectory(itemPath); } else { const ext = path.extname(item.name).toLowerCase(); if (this.pluginSecurityConfig.forbiddenFileExtensions.includes(ext)) { dangerousFiles.push(path.relative(pluginPath, itemPath)); } } } }; scanDirectory(pluginPath); return dangerousFiles; } // ══════════════════════════════════════════════════════════════════════════════ // ฟังก์ชันคำนวณ Hash ของปลั๊กอิน // ══════════════════════════════════════════════════════════════════════════════ async calculatePluginHash(pluginPath) { const hash = crypto.createHash('sha256'); const processDirectory = (dirPath) => { const items = fs.readdirSync(dirPath).sort(); // เรียงลำดับเพื่อความสม่ำเสมอ for (const item of items) { const itemPath = path.join(dirPath, item); const stats = fs.statSync(itemPath); if (stats.isDirectory()) { hash.update(`dir:${item}`); processDirectory(itemPath); } else { hash.update(`file:${item}`); const content = fs.readFileSync(itemPath); hash.update(content); } } }; processDirectory(pluginPath); return hash.digest('hex'); } // ══════════════════════════════════════════════════════════════════════════════ // ฟังก์ชันตรวจสอบลายเซ็นดิจิทัล // ══════════════════════════════════════════════════════════════════════════════ async verifyPluginSignature(pluginPath, expectedSignature) { // Simplified signature verification // ใน production ควรใช้ระบบ signature ที่แข็งแกร่งกว่า try { const manifestPath = path.join(pluginPath, 'chahua.json'); const manifestContent = fs.readFileSync(manifestPath, 'utf8'); const manifest = JSON.parse(manifestContent); // ตรวจสอบว่ามี signature field และถูกต้อง if (manifest.security && manifest.security.signature === expectedSignature) { return true; } return false; } catch (error) { console.warn(` Signature verification failed: ${error.message}`); return false; } } // ══════════════════════════════════════════════════════════════════════════════ // ฟังก์ชันตรวจสอบความเข้ากันได้กับ Sandbox // ══════════════════════════════════════════════════════════════════════════════ async checkSandboxCompatibility(pluginPath, manifest) { try { // ตรวจสอบว่า plugin ใช้ฟีเจอร์ที่เข้ากันได้กับ sandbox หรือไม่ const sandboxChecks = { noDirectFileSystemAccess: true, noDirectProcessExecution: true, noNetworkAccessWithoutPermission: true, usesOnlyAllowedAPIs: true }; // สแกนไฟล์ JavaScript เพื่อหา pattern ที่อันตราย const jsFiles = await this.findJavaScriptFiles(pluginPath); for (const jsFile of jsFiles) { const content = fs.readFileSync(jsFile, 'utf8'); // ตรวจสอบการใช้ APIs อันตราย if (content.includes('require(\'fs\')') || content.includes('require("fs")')) { sandboxChecks.noDirectFileSystemAccess = false; } if (content.includes('require(\'child_process\')') || content.includes('exec(') || content.includes('spawn(')) { sandboxChecks.noDirectProcessExecution = false; } if (content.includes('require(\'http\')') || content.includes('require(\'https\')') || content.includes('fetch(')) { // ตรวจสอบว่ามี permission หรือไม่ if (!manifest.permissions || !manifest.permissions.includes('network')) { sandboxChecks.noNetworkAccessWithoutPermission = false; } } } return Object.values(sandboxChecks).every(check => check); } catch (error) { console.warn(` Sandbox compatibility check failed: ${error.message}`); return false; } } // ══════════════════════════════════════════════════════════════════════════════ // ฟังก์ชันค้นหาไฟล์ JavaScript // ══════════════════════════════════════════════════════════════════════════════ async findJavaScriptFiles(pluginPath) { const jsFiles = []; const scanDirectory = (dirPath) => { const items = fs.readdirSync(dirPath, { withFileTypes: true }); for (const item of items) { const itemPath = path.join(dirPath, item.name); if (item.isDirectory()) { scanDirectory(itemPath); } else if (path.extname(item.name).toLowerCase() === '.js') { jsFiles.push(itemPath); } } }; scanDirectory(pluginPath); return jsFiles; } // ╔══════════════════════════════════════════════════════════════════════════════════╗ // ║ โซน 3: การจัดการเหตุการณ์ ║ // ║ Event Listeners และ Pub/Sub System ║ // ║ [การใช้งาน] ใช้ร่วมกัน: ระบบการสื่อสารภายใน ║ // ╚══════════════════════════════════════════════════════════════════════════════════╝ // ══════════════════════════════════════════════════════════════════════════════ // ฟังก์ชันตั้งค่า Event Listeners สำหรับ Pub/Sub // ══════════════════════════════════════════════════════════════════════════════ setupEventListeners() { // ฟังเหตุการณ์ execution completed this.hub.on('execution.completed', (result) => { console.log(' Execution completed:', result.executionId); }); // ฟังเหตุการณ์ error (wildcard listener) this.hub.on('error.*', (data) => { console.log(' Error event:', data.event, data.data); }); console.log(' Event listeners กำหนดค่าแล้ว'); } // ══════════════════════════════════════════════════════════════════════════════ // ฟังก์ชันแสดงข้อมูลปลั๊กอิน // ══════════════════════════════════════════════════════════════════════════════ async showPluginInfo(request) { try { const pluginPath = await this.getPluginPath(request.pluginName); const manifestPath = path.join(pluginPath, 'chahua.json'); let message = `Name: ${request.pluginName}\nPath: ${pluginPath}`; if (fs.existsSync(manifestPath)) { const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8')); message += `\nType: ${manifest.type || 'N/A'}`; message += `\nVersion: ${manifest.version || 'N/A'}`; message += `\nDescription: ${manifest.description || 'No description.'}`; } dialog.showMessageBox({ type: 'info', title: 'Plugin Information', message: `Information for "${request.pluginName}"`, detail: message, buttons: ['OK'] }); return { success: true, message: 'Info dialog shown.' }; } catch (error) { console.error(` Could not show info for ${request.pluginName}:`, error); dialog.showErrorBox('Error', `Could not retrieve information for plugin: ${request.pluginName}`); return { success: false, error: error.message }; } } // ╔══════════════════════════════════════════════════════════════════════════════════╗ // ║ โซน 5: การประมวลผลคำสั่งหลัก ║ // ║ processCommand และ Command Routing ║ // ║ [การใช้งาน] ใช้ร่วมกัน: ศูนย์กลางการประมวลผลคำสั่งทั้งระบบ ║ // ╚══════════════════════════════════════════════════════════════════════════════════╝ /** * ตัวประมวลผลคำขอหลัก - ศูนย์กลางคำสั่ง * ============================================== * * วัตถุประสงค์ของฟังก์ชัน: * นี่คือจุดเข้าเดียวสำหรับการดำเนินการปลั๊กอินและระบบทั้งหมด * คำขอทุกคำขอจาก UI, IPC หรือแหล่งภายนอกต้องผ่านฟังก์ชันนี้ * * สถาปัตยกรรมความปลอดภัย: * - ตรวจสอบคำขอที่เข้ามาทั้งหมด * - ส่งต่อไปยังระบบแบ็กเอนด์ที่เหมาะสม (ปลั๊กอิน เป็นต้น) * - ใช้นโยบายความปลอดภัยและการควบคุมการเข้าถึง * - ส่งคืนการตอบสนองที่มีมาตรฐาน * * ลำดับขั้นตอนคำขอ: * main.js IPC processCommand(request) switch(action) ระบบแบ็กเอนด์ การตอบสนอง * * สำคัญ: ฟังก์ชันใดที่ข้ามตัวประมวลผลนี้เป็นการละเมิดความปลอดภัย * * @param {Object} request - อ็อบเจ็กต์คำขอพร้อม action และพารามิเตอร์ * @param {string} request.action - การกระทำที่จะดำเนินการ (การดำเนินการปลั๊กอิน เป็นต้น) * @returns {Object} อ็อบเจ็กต์การตอบสนองที่มีมาตรฐาน */ // ══════════════════════════════════════════════════════════════════════════════ // ฟังก์ชันหลัก: รับคำสั่งจาก UI // ══════════════════════════════════════════════════════════════════════════════ async processCommand(request) { console.log(` Gateway กำลังประมวลผลคำสั่ง:`, request.action); // [AUTH] ตรวจสอบสถานะ Authentication ก่อนดำเนินการ if (this.authSecurityConfig.authCheckBeforeCommandExecution) { const authStatus = await this.checkAuthenticationStatus(); if (!authStatus.authenticated) { console.warn(`[GATEWAY] [DENIED] ปฏิเสธการทำงาน - ผู้ใช้ยังไม่ได้เข้าสู่ระบบ`); return { success: false, error: 'Authentication required', authStatus: authStatus, message: 'กรุณาเข้าสู่ระบบก่อนดำเนินการ' }; } // [AUTH] ตรวจสอบสิทธิ์ const requiredPermission = this.getRequiredPermissionForAction(request.action); const hasPermission = await this.checkPermission(requiredPermission); if (!hasPermission && requiredPermission !== 'read') { console.warn(`[GATEWAY] [DENIED] ปฏิเสธการทำงาน - สิทธิ์ไม่เพียงพอ (ต้อง: ${requiredPermission})`); return { success: false, error: 'Insufficient permissions', requiredPermission: requiredPermission, message: `ต้องมีสิทธิ์ '${requiredPermission}' ในการดำเนินการนี้` }; } console.log(`[GATEWAY] [SUCCESS] ผ่านการตรวจสอบ authentication สำหรับการดำเนินการ: ${request.action}`); } // --- การแมปคำสั่ง: แปลงคำสั่งแบบเก่าเป็นชื่อ Action --- const commandMapping = { 'npm install': 'npm-install', 'npm start': 'npm-start', 'npm test': 'npm-test', 'npm run build': 'npm-build', 'npm run lint': 'npm-lint', 'npm audit': 'npm-audit', 'pip install': 'pip-install', 'pip install -r requirements.txt': 'pip-install', 'python main.py': 'python-run', 'python -m pytest': 'python-test', 'launch-exe': 'launch-exe', 'run-batch': 'run-batch', 'edit-batch': 'edit-batch', 'list-plugins': 'list-plugins', 'save-dictionary': 'save-dictionary', 'load-language-system': 'load-language-system' }; // แปลง command ถ้าพบใน mapping (ทำความสะอาด string ก่อน) let actionToProcess = request.action; const cleanAction = request.action?.toString().trim(); console.log(` Debug: Original action = "${request.action}" | Cleaned = "${cleanAction}"`); if (commandMapping[cleanAction]) { actionToProcess = commandMapping[cleanAction]; console.log(` Command mapped: "${cleanAction}" -> "${actionToProcess}"`); } else { console.log(` No mapping found for: "${cleanAction}"`); console.log(` Available mappings:`, Object.keys(commandMapping)); // ถ้าเป็น npm command แต่ไม่อยู่ใน mapping ให้ลองแปลงอัตโนมัติ if (cleanAction.startsWith('npm ')) { const npmCommand = cleanAction.replace('npm ', '').replace(' run ', '-'); actionToProcess = `npm-${npmCommand}`; console.log(` Auto-mapped npm command: "${cleanAction}" -> "${actionToProcess}"`); } } try { switch (actionToProcess) { // เพิ่ม case 'info' เข้าไป case 'info': return await this.showPluginInfo(request); case 'execute-command': // ส่งต่อคำสั่งไปให้ Executor จัดการ return await this.executeCommand(request); case 'run-project': // รันโปรเจกต์ผ่าน Executor return await this.runProject(request); case 'get-execution-history': // ดูประวัติการทำงาน return await this.getExecutionHistory(request); case 'list-plugins': // ดูรายการปลั๊กอิน return await this.listPlugins(request); case 'execute-plugin-command': // รันคำสั่งปลั๊กอิน console.log(` Executing plugin command via Gateway:`, request); return await this.executePluginCommand(request); // Web Actions case 'open_browser': return await this.openBrowser(request); case 'live-server': return await this.runLiveServer(request); case 'http-server': return await this.runHttpServer(request); // System Actions case 'open_terminal': return await this.openTerminal(request); case 'open_editor': return await this.openEditor(request); case 'open_explorer': return await this.openExplorer(request); // NPM Actions case 'npm-install': return await this.runNpmCommand(request, 'install'); case 'npm-start': return await this.runNpmCommand(request, 'start'); case 'npm-test': return await this.runNpmCommand(request, 'test'); case 'npm-build': return await this.runNpmCommand(request, 'build'); case 'npm-lint': return await this.runNpmCommand(request, 'lint'); case 'npm-audit': return await this.runNpmCommand(request, 'audit'); case 'electron-dev': return await this.runNpmCommand(request, 'electron:dev'); // Python Actions case 'pip-install': return await this.runPythonCommand(request, 'pip install -r requirements.txt'); case 'python-run': return await this.runPythonCommand(request, 'python main.py'); case 'python-test': return await this.runPythonCommand(request, 'python -m pytest'); case 'flask-run': return await this.runPythonCommand(request, 'flask run'); case 'django-run': return await this.runPythonCommand(request, 'python manage.py runserver'); case 'uvicorn-run': return await this.runPythonCommand(request, 'uvicorn main:app --reload'); // TypeScript Actions case 'tsc-check': return await this.runTypeScriptCheck(request); // Batch File Actions case 'run-batch': return await this.runBatchFile(request); case 'edit-batch': return await this.editBatchFile(request); // Executable Actions case 'launch-exe': return await this.launchExecutable(request); case 'run-as-admin': return await this.runAsAdmin(request); // Internationalization Actions (i18n) case 'load-language-system': return await this.loadLanguageSystem(request); case 'save-dictionary': return await this.saveDictionary(request); // SECURE NPM COMMAND EXECUTION (NEW!) case 'execute-npm-command': return await this.executeSecureNpmCommand(request); // Project Scanning Actions case 'scan-projects': return await this.scanProjects(request); default: throw new Error(`Unknown action: ${actionToProcess} (original: ${request.action})`); } } catch (error) { console.error(` Gateway Error: ${error.message}`); this.errorHandler.handle(error); // ส่งสัญญาณ error ผ่าน Hub this.hub.emit('error.gateway', { action: actionToProcess || request.action, error: error.message, timestamp: Date.now() }); return { success: false, error: error.message }; } } // ╔══════════════════════════════════════════════════════════════════════════════════╗ // ║ โซน 6: การดำเนินการและการควบคุม ║ // ║ Execute Command และ Project Management ║ // ║ [การใช้งาน] ใช้ร่วมกัน: การดำเนินการคำสั่งและโครงการ ║ // ╚══════════════════════════════════════════════════════════════════════════════════╝ // ══════════════════════════════════════════════════════════════════════════════ // โหลดระบบภาษา (Language System i18n) // ══════════════════════════════════════════════════════════════════════════════ async loadLanguageSystem(request) { try { console.log('[i18n] Gateway: Loading language system...'); // ตรวจสอบความปลอดภัย - อ่านเฉพาะ files ใน languages/ directory const fs = require('fs'); const path = require('path'); const { app } = require('electron'); const appPath = app.getAppPath(); const scannerPath = path.join(appPath, 'languages', 'language-scanner.js'); const editorPath = path.join(appPath, 'languages', 'translation-editor-ui.js'); const dictionaryPath = path.join(appPath, 'languages', 'default-dictionary.json'); // ตรวจสอบว่า files มีอยู่จริง if (!fs.existsSync(scannerPath)) { throw new Error('language-scanner.js not found'); } if (!fs.existsSync(editorPath)) { throw new Error('translation-editor-ui.js not found'); } if (!fs.existsSync(dictionaryPath)) { throw new Error('default-dictionary.json not found'); } // อ่าน scripts และ dictionary (ตรวจสอบว่าไฟล์ถูกต้องก่อนส่ง) const scannerCode = fs.readFileSync(scannerPath, 'utf-8'); const editorCode = fs.readFileSync(editorPath, 'utf-8'); // อ่าน dictionary โดยข้าม BOM (Byte Order Mark) ถ้ามี let dictionaryContent = fs.readFileSync(dictionaryPath, 'utf-8'); // ข้าม UTF-8 BOM ถ้ามี if (dictionaryContent.charCodeAt(0) === 0xFEFF) { dictionaryContent = dictionaryContent.slice(1); } const dictionaryData = JSON.parse(dictionaryContent); console.log(`[i18n] Gateway: Loaded scanner (${scannerCode.length} bytes), editor (${editorCode.length} bytes), and dictionary`); // Log status this.hub.emit('i18n.loaded', { scanner: scannerCode.length, editor: editorCode.length, dictionary: Object.keys(dictionaryData.dictionary || {}).length, timestamp: Date.now() }); return { success: true, scanner: scannerCode, editor: editorCode, dictionary: dictionaryData.dictionary || { th: {}, en: {} }, message: 'Language system loaded successfully' }; } catch (error) { console.error('[i18n] Gateway Error:', error); this.errorHandler.handle(error, 'load-language-system'); return { success: false, error: error.message }; } } // ══════════════════════════════════════════════════════════════════════════════ // บันทึก Dictionary ลงไฟล์ // ══════════════════════════════════════════════════════════════════════════════ async saveDictionary(request) { try { const fs = require('fs'); const path = require('path'); const { app } = require('electron'); console.log('[i18n] Gateway: Saving dictionary...'); // ตรวจสอบว่า dictionary มีข้อมูล if (!request.dictionary || typeof request.dictionary !== 'object') { throw new Error('Invalid dictionary data'); } // หา path ของ default-dictionary.json const appPath = app.getAppPath(); const dictionaryPath = path.join(appPath, 'languages', 'default-dictionary.json'); // อ่านไฟล์เดิมเพื่อเก็บ metadata let existingData = { version: '1.0.0', lastUpdated: new Date().toISOString(), description: 'Default Language Dictionary for Chahuadev Framework', languages: ['th', 'en'] }; if (fs.existsSync(dictionaryPath)) { try { const existing = JSON.parse(fs.readFileSync(dictionaryPath, 'utf-8')); existingData = { ...existing }; } catch (parseError) { console.warn('[i18n] Could not parse existing dictionary, using defaults'); } } // อัปเดต dictionary และ timestamp existingData.dictionary = request.dictionary; existingData.lastUpdated = new Date().toISOString(); // บันทึกลงไฟล์ fs.writeFileSync(dictionaryPath, JSON.stringify(existingData, null, 2), 'utf-8'); console.log(`[i18n] Dictionary saved successfully to: ${dictionaryPath}`); console.log(`[i18n] Dictionary contains: ${Object.keys(request.dictionary.th || {}).length} Thai keys, ${Object.keys(request.dictionary.en || {}).length} English keys`); // Log via Hub this.hub.emit('dictionary.saved', { timestamp: Date.now(), path: dictionaryPath, thKeys: Object.keys(request.dictionary.th || {}).length, enKeys: Object.keys(request.dictionary.en || {}).length }); return { success: true, message: 'Dictionary saved successfully', path: dictionaryPath }; } catch (error) { console.error('[i18n] Failed to save dictionary:', error); this.errorHandler.handle(error, 'save-dictionary'); return { success: false, error: error.message }; } } // ══════════════════════════════════════════════════════════════════════════════ // ฟังก์ชันดำเนินการคำสั่งผ่าน Executor // ══════════════════════════════════════════════════════════════════════════════ async executeCommand(request) { console.log(' Executing command via Executor:', request.command); // ส่งสัญญาณเริ่มต้น execution this.hub.emit('execution.started', { command: request.command, projectPath: request.projectPath, timestamp: Date.now() }); const result = await this.executor.execute({ command: request.command, projectPath: request.projectPath || process.cwd(), options: request.options || {}, userId: request.userId || 'system' }); // ส่งสัญญาณเสร็จสิ้น execution this.hub.emit('execution.completed', result); return result; } // ══════════════════════════════════════════════════════════════════════════════ // ฟังก์ชันรันโครงการ // ══════════════════════════════════════════════════════════════════════════════ async runProject(request) { console.log(' Running project via Executor:', request.projectPath); const result = await this.executor.run( request.command || 'detect-and-run', request.projectPath || process.cwd(), request.options || {} ); return result; } // ══════════════════════════════════════════════════════════════════════════════ // ฟังก์ชันดูประวัติการดำเนินการ // ══════════════════════════════════════════════════════════════════════════════ async getExecutionHistory(request) { const limit = request.limit || 10; const history = this.executor.getHistory(limit); return { success: true, data: { history: history, total: history.length } }; } // ╔══════════════════════════════════════════════════════════════════════════════════╗ // ║ โซน 7: การจัดการปลั๊กอิน ║ // ║ Plugin Management และ Lifecycle ║ // ║ [การใช้งาน] ใช้แยก: การจัดการปลั๊กอินและการสแกน ║ // ╚══════════════════════════════════════════════════════════════════════════════════╝ // ══════════════════════════════════════════════════════════════════════════════ // ฟังก์ชันเริ่มต้นปลั๊กอิน (สำหรับใช้กับ main.js) // ══════════════════════════════════════════════════════════════════════════════ async initializePlugins() { console.log(' Initializing plugins via Gateway...'); try { // ส่งสัญญาณเริ่มต้นการโหลดปลั๊กอิน this.hub.emit('plugins.initializing', { timestamp: Date.now() }); // ไม่ต้องทำอะไรพิเศษ - manifest files จะถูกโหลดโดยระบบอัตโนมัติ console.log(' Plugin initialization completed (manifest-based)'); // ส่งสัญญาณเสร็จสิ้นการโหลดปลั๊กอิน this.hub.emit('plugins.initialized', { timestamp: Date.now() }); console.log(' Plugins initialized successfully'); return true; } catch (error) { console.error(' Failed to initialize plugins:', error.message); this.hub.emit('error.plugins', { error: error.message, timestamp: Date.now() }); return false; } } // ══════════════════════════════════════════════════════════════════════════════ // ฟังก์ชันดูรายการปลั๊กอิน // ══════════════════════════════════════════════════════════════════════════════ async listPlugins(request) { console.log(' Getting plugins list via Gateway...'); try { const fs = require('fs'); const path = require('path'); // กำหนด plugins directory ตาม packaging status let pluginsDir; if (app.isPackaged) { pluginsDir = path.join(path.dirname(app.getPath('exe')), 'plugins'); } else { pluginsDir = path.join(app.getPath('userData'), 'plugins'); } console.log(` Scanning plugins directory: ${pluginsDir}`); // ตรวจสอบว่าโฟลเดอร์มีอยู่หรือไม่ if (!fs.existsSync(pluginsDir)) { console.log(' Plugins directory not found, returning empty list'); return { success: true, plugins: [] }; } // สแกนหา chahua.json files const plugins = []; const items = fs.readdirSync(pluginsDir, { withFileTypes: true }); for (const item of items) { if (item.isDirectory()) { const manifestPath = path.join(pluginsDir, item.name, 'chahua.json'); if (fs.existsSync(manifestPath)) { try { const manifestContent = fs.readFileSync(manifestPath, 'utf8'); const manifest = JSON.parse(manifestContent); // ตรวจสอบความปลอดภัยของ Plugin const pluginPath = path.join(pluginsDir, item.name); const securityResult = await this.validatePluginSecurity(pluginPath, manifest); if (!securityResult.success) { console.warn(` Plugin ${item.name} fail security: ${securityResult.error}, score: ${securityResult.securityScore}`); } else { console.log(` Plugin ${item.name} pass, score: ${securityResult.securityScore}, trust: ${securityResult.trustLevel}`); } // ตรวจหา Preview Image - หาในโฟลเดอร์ previews ก่อนเสมอ let previewImage = null; const previewImageExtensions = ['.png', '.jpg', '.jpeg', '.gif', '.webp']; const previewImageNames = ['preview', 'screenshot', 'demo', 'example', 'thumbnail']; // ฟังก์ชันหาโฟลเดอร์ previews const getPreviewsDirectory = () => { const { app } = require('electron'); let previewsDir; if (app && app.isPackaged) { previewsDir = path.join(path.dirname(app.getPath('exe')), 'previews'); } else { previewsDir = path.join(process.cwd(), 'previews'); } return previewsDir; }; // 1. หาในโฟลเดอร์ previews ก่อน (ลำดับความสำคัญสูงสุด) const previewsDir = getPreviewsDirectory(); const pluginName = item.name; // แปลงชื่อปลั๊กอินให้ตรงกับชื่อไฟล์ที่สร้างจริง const normalizedPluginName = pluginName.replace(/\s+/g, '-').toLowerCase(); // ลองหาไฟล์ preview ที่มีชื่อโปรเจคในโฟลเดอร์ previews const previewFileName = `${normalizedPluginName}_preview.png`; const previewInPreviewsDir = path.join(previewsDir, previewFileName); if (fs.existsSync(previewInPreviewsDir)) { previewImage = `file://${previewInPreviewsDir.replace(/\\/g, '/')}`; console.log(` Found preview in previews directory: ${previewImage}`); } else { console.log(` Looking for preview file: ${previewInPreviewsDir}`); console.log(` Previews directory exists: ${fs.existsSync(previewsDir)}`); if (fs.existsSync(previewsDir)) { const availableFiles = fs.readdirSync(previewsDir); console.log(` Available files in previews: ${availableFiles.join(', ')}`); } // หาไฟล์รูปอื่นๆ ในโฟลเดอร์ previews ที่ขึ้นต้นด้วยชื่อโปรเจค if (fs.existsSync(previewsDir)) { const previewFiles = fs.readdirSync(previewsDir); for (const file of previewFiles) { if (file.toLowerCase().startsWith(normalizedPluginName.toLowerCase()) || file.toLowerCase().startsWith(pluginName.toLowerCase().replace(/\s+/g, '-'))) { const ext = path.extname(file).toLowerCase(); if (previewImageExtensions.includes(ext)) { previewImage = `file://${path.join(previewsDir, file).replace(/\\/g, '/')}`; console.log(` Found matching preview in previews directory: ${previewImage}`); break; } } } } } // 2. ถ้าไม่เจอในโฟลเดอร์ previews ให้หาในโฟลเดอร์ปลั๊กอิน (fallback) if (!previewImage) { for (const imageName of previewImageNames) { for (const ext of previewImageExtensions) { const previewPath = path.join(pluginPath, imageName + ext); if (fs.existsSync(previewPath)) { previewImage = `file://${previewPath.replace(/\\/g, '/')}`; console.log(` Found preview image in plugin directory: ${previewImage}`); break; } } if (previewImage) break; } } // 3. ถ้าไม่เจอเลย ให้หาไฟล์รูปอื่นๆ ในโฟลเดอร์ปลั๊กอิน if (!previewImage) { const files = fs.readdirSync(pluginPath); for (const file of files) { const ext = path.extname(file).toLowerCase(); if (previewImageExtensions.includes(ext)) { previewImage = `file://${path.join(pluginPath, file).replace(/\\/g, '/')}`; console.log(` Using fallback image from plugin directory: ${previewImage}`); break; } } } plugins.push({ name: manifest.name || item.name, type: manifest.type || 'unknown', description: manifest.description || 'No description', version: manifest.version || '1.0.0', path: path.join(pluginsDir, item.name), manifest: manifest, buttons: manifest.buttons || [], security: securityResult, // เพิ่มข้อมูล security previewImage: previewImage // เพิ่ม preview image }); console.log(` Plugin validated: ${manifest.name || item.name} (Score: ${securityResult.securityScore?.toFixed(1)}%, Trust: ${securityResult.trustLevel})`); } catch (error) { console.warn(` Invalid manifest in ${item.name}: ${error.message}`); } } } } console.log(` Found ${plugins.length} valid plugins`); // เพิ่ม log debug เพื่อตรวจสอบรายชื่อปลั๊กอินที่ผ่านการตรวจสอบ if (plugins.length > 0) { console.log(` Plugins found: ${plugins.map(p => p.name).join(', ')}`); } else { console.warn(' No plugins passed security check - check pluginSecurityConfig'); } return { success: true, plugins: plugins }; } catch (error) { console.error(' Failed to list plugins:', error.message); return { success: false, error: error.message, plugins: [] }; } } // ══════════════════════════════════════════════════════════════════════════════ // ฟังก์ชันรันคำสั่งปลั๊กอิน // ══════════════════════════════════════════════════════════════════════════════ async executePluginCommand(request) { console.log(' Gateway executing plugin command:', request); try { const pluginPath = await this.getPluginPath(request.pluginName); let commandToExecute = request.command; let commandArgs = []; // แยก args ออกมา // --- ส่วนที่แก้ไข: จัดการคำสั่ง npm สำหรับทั้ง Development และ Production --- const commandParts = request.command.split(' '); const baseCommand = commandParts[0]; // ตรวจสอบว่าเป็นคำสั่ง npm หรือไม่ if (baseCommand === 'npm') { console.log(' [NPM] Using bundled npm from vendor directory.'); const { nodePath, npmCliPath } = this.getBundledNpmPaths(); if (app.isPackaged) { // Production: ใช้ node + npm-cli.js commandToExecute = nodePath; commandArgs = [npmCliPath, ...commandParts.slice(1)]; } else { // Development: ใช้ npm.cmd จาก vendor commandToExecute = npmCliPath; commandArgs = commandParts.slice(1); } console.log(` Rewritten Command: ${commandToExecute} ${commandArgs.join(' ')}`); } else { // คำสั่งอื่นๆ ใช้แบบเดิม commandToExecute = baseCommand; commandArgs = commandParts.slice(1); } // --- จบส่วนที่แก้ไข --- // ใช้ Executor รันคำสั่งที่แปลงแล้ว const result = await this.executor.execute({ command: `${commandToExecute} ${commandArgs.join(' ')}`, // รวม command และ args เป็น string เดียว projectPath: pluginPath, options: request.data || {}, userId: request.userId || 'plugin-user' }); console.log(' Plugin command execution completed'); return { success: result.success, data: { output: result.output || result.message, message: `Plugin command "${request.command}" executed successfully`, pluginName: request.pluginName, command: request.command, exitCode: result.exitCode, duration: result.totalDuration || result.duration }, error: result.error }; } catch (error) { console.error(' Plugin command execution failed:', error.message); return { success: false, error: error.message, data: null }; } } // ══════════════════════════════════════════════════════════════════════════════ // ฟังก์ชัน Helper สำหรับหา Path ของปลั๊กอิน // ══════════════════════════════════════════════════════════════════════════════ async getPluginPath(pluginName) { console.log(` Looking for plugin path: ${pluginName}`); try { // ดึงรายการปลั๊กอินทั้งหมด const pluginsResult = await this.listPlugins(); if (pluginsResult.success && pluginsResult.plugins) { // หาปลั๊กอินที่ตรงกับชื่อ const plugin = pluginsResult.plugins.find(p => p.name === pluginName); if (plugin && plugin.path) { console.log(` Found plugin path: ${plugin.path}`); return plugin.path; } } // ถ้าหาไม่เจอ ลองหาด้วยชื่อโฟลเดอร์โดยตรง const fs = require('fs'); const path = require('path'); let pluginsDir; if (app.isPackaged) { pluginsDir = path.join(path.dirname(app.getPath('exe')), 'plugins'); } else { pluginsDir = path.join(app.getPath('userData'), 'plugins'); } const directPath = path.join(pluginsDir, pluginName); if (fs.existsSync(directPath)) { console.log(` Found plugin by folder name: ${directPath}`); return directPath; } // ถ้าหาไม่เจอจริงๆ throw new Error(`Plugin path not found for: ${pluginName}`); } catch (error) { console.error(` Failed to get plugin path for ${pluginName}:`, error.message); throw error; } } // ╔══════════════════════════════════════════════════════════════════════════════════╗ // ║ โซน 8: ฟังก์ชันช่วยเหลือและยูทิลิตี้ ║ // ║ Helper Functions และ System Operations ║ // ║ [การใช้งาน] ใช้ร่วมกัน: ฟังก์ชันสนับสนุนทั้งระบบ ║ // ╚══════════════════════════════════════════════════════════════════════════════════╝ /** * ฟังก์ชันดึง NPM Paths ที่แนบมากับแอป - รองรับแอปที่แพ็กแล้ว * =============================================== * * วัตถุประสงค์: สำหรับแอปที่แพ็กแล้วที่ไม่มี npm ติดตั้งในระบบ * จะใช้ node.exe และ npm-cli.js ที่แนบมากับแอป * * @returns {Object} { nodePath, npmCliPath } */ // ══════════════════════════════════════════════════════════════════════════════ // ฟังก์ชันดึง Bundled NPM Paths // ══════════════════════════════════════════════════════════════════════════════ getBundledNpmPaths() { const path = require('path'); // Path ไปยัง node.exe ที่แนบมากับแอป (ใน vendor/node-v20.15.1-win-x64/) const vendorNodePath = path.join(process.resourcesPath || __dirname, '..', 'vendor', 'node-v20.15.1-win-x64', 'node.exe'); const vendorNpmCliPath = path.join(process.resourcesPath || __dirname, '..', 'vendor', 'node-v20.15.1-win-x64', 'node_modules', 'npm', 'bin', 'npm-cli.js'); // Fallback paths for development const devNodePath = path.join(__dirname, 'vendor', 'node-v20.15.1-win-x64', 'node.exe'); const devNpmCliPath = path.join(__dirname, 'vendor', 'node-v20.15.1-win-x64', 'node_modules', 'npm', 'bin', 'npm-cli.js'); const fs = require('fs'); // ตรวจสอบว่าไฟล์อยู่ที่ไหน (production หรือ development) let nodePath, npmCliPath; if (fs.existsSync(vendorNodePath)) { nodePath = vendorNodePath; npmCliPath = vendorNpmCliPath; } else if (fs.existsSync(devNodePath)) { nodePath = devNodePath; npmCliPath = devNpmCliPath; } else { // ถ้าหาไม่เจอให้ใช้ system node (แต่อาจไม่ได้ผลใน packaged app) nodePath = 'node'; npmCliPath = 'npm'; } console.log(` Using Node: ${nodePath}`); console.log(` Using NPM: ${npmCliPath}`); return { nodePath, npmCliPath }; } // ══════════════════════════════════════════════════════════════════════════════ // การดำเนินการเว็บ (Web Actions) // ══════════════════════════════════════════════════════════════════════════════ async openBrowser(request) { const { shell } = require('electron'); try { const url = request.url || 'http://localhost:3000'; await shell.openExternal(url); return { success: true, message: `Browser opened to ${url}` }; } catch (error) { return { success: false, error: error.message }; } } async runLiveServer(request) { const command = request.command || 'npx live-server'; return await this.executeCommand({ command: command, projectPath: request.projectPath, options: { detached: true } }); } async runHttpServer(request) { const command = request.command || 'npx http-server'; return await this.executeCommand({ command: command, projectPath: request.projectPath, options: { detached: true } }); } // ══════════════════════════════════════════════════════════════════════════════ // การดำเนินการระบบ (System Actions) // ══════════════════════════════════════════════════════════════════════════════ async openTerminal(request) { const { shell } = require('electron'); const path = require('path'); try { const projectPath = request.projectPath || process.cwd(); if (process.platform === 'win32') { await shell.openPath('cmd.exe'); } else if (process.platform === 'darwin') { await shell.openPath('/Applications/Utilities/Terminal.app'); } else { await shell.openPath('/usr/bin/gnome-terminal'); } return { success: true, message: 'Terminal opened' }; } catch (error) { return { success: false, error: error.message }; } } async openEditor(request) { const { shell } = require('electron'); try { const projectPath = request.projectPath || process.cwd(); if (process.platform === 'win32') { await shell.openPath('notepad.exe'); } else if (process.platform === 'darwin') { await shell.openPath('/Applications/TextEdit.app'); } else { await shell.openPath('/usr/bin/gedit'); } return { success: true, message: 'Editor opened' }; } catch (error) { return { success: false, error: error.message }; } } async openExplorer(request) { const { shell } = require('electron'); try { const projectPath = request.projectPath || process.cwd(); await shell.openPath(projectPath); return { success: true, message: `Explorer opened to ${projectPath}` }; } catch (error) { return { success: false, error: error.message }; } } // ══════════════════════════════════════════════════════════════════════════════ // การดำเนินการ NPM (NPM Actions) // ══════════════════════════════════════════════════════════════════════════════ async runNpmCommand(request, command) { const npmCommand = `npm ${command}`; return await this.executeCommand({ command: npmCommand, projectPath: request.projectPath || process.cwd(), options: request.options || {} }); } // ══════════════════════════════════════════════════════════════════════════════ // การดำเนินการ Python (Python Actions) // ══════════════════════════════════════════════════════════════════════════════ async runPythonCommand(request, command) { return await this.executeCommand({ command: command, projectPath: request.projectPath || process.cwd(), options: request.options || {} }); } // ══════════════════════════════════════════════════════════════════════════════ // การดำเนินการ TypeScript (TypeScript Actions) // ══════════════════════════════════════════════════════════════════════════════ async runTypeScriptCheck(request) { const command = 'npx tsc --noEmit'; return await this.executeCommand({ command: command, projectPath: request.projectPath || process.cwd() }); } // ══════════════════════════════════════════════════════════════════════════════ // การดำเนินการไฟล์ Batch (Batch File Actions) // ══════════════════════════════════════════════════════════════════════════════ async runBatchFile(request) { const fs = require('fs'); const path = require('path'); try { const projectPath = request.projectPath || process.cwd(); let targetBatch = null; // --- ส่วนที่แก้ไข: ฟังก์ชันค้นหาไฟล์ .bat/.cmd แบบ Recursive --- const findBatchRecursive = (dir) => { try { const files = fs.readdirSync(dir); for (const file of files) { const filePath = path.join(dir, file); const stat = fs.statSync(filePath); if (stat.isDirectory()) { const found = findBatchRecursive(filePath); if (found) return found; // ถ้าเจอในโฟลเดอร์ย่อย ให้ส่งกลับทันที } else if (file.endsWith('.bat') || file.endsWith('.cmd')) { return filePath; // เจอไฟล์ batch แล้ว } } } catch (err) { console.warn(` Cannot read directory ${dir}:`, err.message); } return null; // ไม่เจอในระดับนี้ }; targetBatch = findBatchRecursive(projectPath); // --- จบส่วนที่แก้ไข --- if (!targetBatch) { return { success: false, error: 'No batch files (.bat or .cmd) found in the project directory or subdirectories.' }; } return await this.executeCommand({ command: targetBatch, projectPath: projectPath, options: { shell: true } }); } catch (error) { return { success: false, error: error.message }; } } async editBatchFile(request) { const fs = require('fs'); const path = require('path'); const { shell } = require('electron'); try { const projectPath = request.projectPath || process.cwd(); // แก้ไข: ค้นหาไฟล์ .bat หรือ .cmd ในโฟลเดอร์โดยตรงเสมอ const files = fs.readdirSync(projectPath); const batchFiles = files.filter(file => file.endsWith('.bat') || file.endsWith('.cmd')); if (batchFiles.length === 0) { return { success: false, error: 'No batch files (.bat or .cmd) found in the project directory.' }; } // ใช้ไฟล์แรกที่เจอ const targetBatch = path.join(projectPath, batchFiles[0]); await shell.openPath(targetBatch); return { success: true, message: `Opened ${batchFiles[0]} for editing` }; } catch (error) { return { success: false, error: error.message }; } } // ══════════════════════════════════════════════════════════════════════════════ // การดำเนินการไฟล์ปฏิบัติการ (Executable Actions) // ══════════════════════════════════════════════════════════════════════════════ async launchExecutable(request) { const fs = require('fs'); const path = require('path'); const { shell } = require('electron'); try { const projectPath = request.projectPath || process.cwd(); let targetExe = null; // --- ส่วนที่แก้ไข: ฟังก์ชันค้นหาไฟล์แบบ Recursive --- const findExeRecursive = (dir) => { try { const files = fs.readdirSync(dir); for (const file of files) { const filePath = path.join(dir, file); const stat = fs.statSync(filePath); if (stat.isDirectory()) { const found = findExeRecursive(filePath); if (found) return found; // ถ้าเจอในโฟลเดอร์ย่อย ให้ส่งกลับทันที } else if (file.endsWith('.exe')) { return filePath; // เจอไฟล์ .exe แล้ว } } } catch (err) { console.warn(` Cannot read directory ${dir}:`, err.message); } return null; // ไม่เจอในระดับนี้ }; targetExe = findExeRecursive(projectPath); // --- จบส่วนที่แก้ไข --- if (!targetExe) { return { success: false, error: 'No executable files (.exe) found in the project directory or subdirectories.' }; } await shell.openPath(targetExe); return { success: true, message: `Launched ${path.basename(targetExe)}` }; } catch (error) { return { success: false, error: error.message }; } } async runAsAdmin(request) { const { exec } = require('child_process'); const path = require('path'); const fs = require('fs'); try { const projectPath = request.projectPath || process.cwd(); const files = fs.readdirSync(projectPath); const exeFiles = files.filter(file => file.endsWith('.exe')); if (exeFiles.length === 0) { console.log(' No .exe found in ' + projectPath); return { success: false, error: 'No .exe found' }; } const targetExe = path.join(projectPath, exeFiles[0]); const adminCommand = `powershell -NoProfile -Command "Start-Process '${targetExe}' -Verb RunAs"`; console.log(' Executing admin command: ' + adminCommand); // Log เพื่อ debug return new Promise((resolve) => { exec(adminCommand, (error, stdout, stderr) => { if (error) { console.error(` Error: ${error.message} | Stderr: ${stderr}`); resolve({ success: false, error: error.message }); } else { console.log(` Success: ${stdout}`); resolve({ success: true, message: `Ran ${exeFiles[0]} as admin` }); } }); }); } catch (error) { console.error(' RunAsAdmin failed: ' + error.message); return { success: false, error: error.message }; } } // ══════════════════════════════════════════════════════════════════════════════ // การดำเนินการคำสั่ง NPM ที่ปลอดภัย (SECURE NPM EXECUTION) // ══════════════════════════════════════════════════════════════════════════════ async executeSecureNpmCommand(request) { console.log(`[Security Gateway] NPM Command Request: ${request.command}`); try { // 1. ตรวจสอบความปลอดภัยของคำสั่ง const securityCheck = this.validateNpmCommand(request.command); if (!securityCheck.isValid) { console.error(`[Security] NPM Command REJECTED: ${securityCheck.reason}`); return { success: false, error: `Security violation: ${securityCheck.reason}`, securityLevel: 'BLOCKED' }; } // 2. Log การดำเนินการเพื่อ audit trail this.logSecurityAction('NPM_COMMAND_EXECUTION', { command: request.command, timestamp: new Date().toISOString(), userAgent: request.userAgent || 'Unknown', source: 'ValidationGateway' }); // 3. รันคำสั่งผ่าน Executor const { execSync } = require('child_process'); console.log(`[Security Gateway] Executing approved command: ${request.command}`); const result = execSync(request.command, { encoding: 'utf8', stdio: 'pipe', timeout: 30000, // 30 วินาที cwd: process.cwd() }); // 4. ส่งสัญญาณสำเร็จผ่าน Hub this.hub.emit('security.npm.success', { command: request.command, output: result, timestamp: Date.now() }); return { success: true, output: result, command: request.command, securityLevel: 'APPROVED', executedAt: new Date().toISOString() }; } catch (error) { console.error(`[Security Gateway] NPM Command Failed: ${error.message}`); // ส่งสัญญาณข้อผิดพลาดผ่าน Hub this.hub.emit('security.npm.error', { command: request.command, error: error.message, timestamp: Date.now() }); return { success: false, error: error.message, command: request.command, securityLevel: 'ERROR' }; } } // ══════════════════════════════════════════════════════════════════════════════ // ตัวตรวจสอบความปลอดภัยคำสั่ง NPM // ══════════════════════════════════════════════════════════════════════════════ validateNpmCommand(command) { // ทำความสะอาดคำสั่ง const cleanCommand = command.trim().toLowerCase(); // ตรวจสอบ pattern ที่อนุญาต - รองรับทุกแอปใน @chahuadev scope const allowedPatterns = [ /^npm install -g @chahuadev\/[\w-]+$/, // npm install -g @chahuadev/ชื่อแอป /^npm update -g @chahuadev\/[\w-]+$/, // npm update -g @chahuadev/ชื่อแอป /^npm uninstall -g @chahuadev\/[\w-]+$/, // npm uninstall -g @chahuadev/ชื่อแอป /^npm list -g @chahuadev\/[\w-]+$/, // npm list -g @chahuadev/ชื่อแอป /^npm info @chahuadev\/[\w-]+$/, // npm info @chahuadev/ชื่อแอป /^npm view @chahuadev\/[\w-]+$/ // npm view @chahuadev/ชื่อแอป ]; // ตรวจสอบ Pattern Matching const isPatternMatch = allowedPatterns.some(pattern => pattern.test(cleanCommand)); if (!isPatternMatch) { return { isValid: false, reason: `Command not matching allowed patterns. Allowed: @chahuadev/* packages only`, severity: 'HIGH', command: cleanCommand }; } // ตรวจสอบ pattern อันตราย const dangerousPatterns = [ /&&/, // Command chaining /\|\|/, // Or operator /[;&]/, // Command separator /`.*`/, // Backticks /\$\(.*\)/, // Command substitution />/, // Redirection /