@uofx/cli 1.0.0

package/dist/infrastructure/platforms/windows/services/wsl-updater.service.js

@@ -0,0 +1,273 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WslUpdaterService = void 0;
+const tsyringe_1 = require("tsyringe");
+const tokens_1 = require("../../../../di/tokens");
+const errors_1 = require("../../../errors");
+const command_builder_1 = require("../../../execution/command-builder");
+const error_formatter_util_1 = require("../../../utils/error-formatter.util");
+/**
+ * WSL 更新服務
+ *
+ * 負責 WSL 的安裝與更新操作，包含：
+ * - WSL 安裝狀態檢查
+ * - WSL 2 預設版本設定
+ * - WSL 更新執行
+ * - 使用者互動提示
+ */
+let WslUpdaterService = class WslUpdaterService {
+    constructor(commandExecutor, appLogger, userInteraction) {
+        this.commandExecutor = commandExecutor;
+        this.appLogger = appLogger;
+        this.userInteraction = userInteraction;
+    }
+    /**
+     * 格式化 WSL 設定提示訊息
+     * @param requirement - 更新需求資訊
+     * @returns 格式化後的提示訊息
+     */
+    formatWslSetupPrompt(requirement) {
+        const lines = [];
+        lines.push('⚠ WSL 2 setup required');
+        lines.push('');
+        lines.push('Kubernetes requires WSL 2 with up-to-date software version.');
+        lines.push('');
+        lines.push('Current status:');
+        if (requirement.needsUpdate && requirement.currentVersion) {
+            lines.push(`  • WSL version: ${requirement.currentVersion} (update available)`);
+        }
+        else if (requirement.currentVersion) {
+            lines.push(`  • WSL version: ${requirement.currentVersion} ✓`);
+        }
+        else {
+            lines.push('  • WSL version: Unknown (update recommended)');
+        }
+        if (requirement.needsDefaultVersion && requirement.currentDefaultVersion !== undefined) {
+            lines.push(`  • Default WSL version: WSL ${requirement.currentDefaultVersion}`);
+        }
+        else if (requirement.currentDefaultVersion !== undefined) {
+            lines.push(`  • Default WSL version: WSL ${requirement.currentDefaultVersion} ✓`);
+        }
+        else {
+            lines.push('  • Default WSL version: Unknown');
+        }
+        lines.push('');
+        lines.push('The following steps will be performed:');
+        requirement.steps.forEach((step, index) => {
+            lines.push(`  ${index + 1}. ${step}`);
+        });
+        if (requirement.needsDefaultVersion) {
+            lines.push('');
+            lines.push('WSL 2 uses a real Linux kernel and provides full system call');
+            lines.push('compatibility required by Kubernetes.');
+        }
+        return lines.join('\n');
+    }
+    /**
+     * 提示使用者是否進行 WSL 設定
+     * @param requirement - 更新需求資訊
+     * @param progress - 進度通知回調
+     * @returns 若使用者同意則回傳 true
+     */
+    async promptWslSetup(requirement, output) {
+        output?.info(this.formatWslSetupPrompt(requirement)).flush();
+        const questionText = requirement.needsUpdate && requirement.needsDefaultVersion
+            ? 'Do you want to proceed with WSL 2 setup?'
+            : requirement.needsUpdate
+                ? 'Do you want to proceed with WSL update?'
+                : 'Do you want to proceed with WSL 2 setup?';
+        if (!this.userInteraction)
+            return false;
+        return this.userInteraction.confirm(questionText, true);
+    }
+    /**
+     * 提示使用者安裝 WSL
+     * @param output - 輸出介面
+     */
+    async promptWslInstall(output) {
+        output?.info('WSL is not installed on this system.').flush();
+        output?.info('This process will install WSL and automatically enable required Windows features.').flush();
+        if (!this.userInteraction)
+            return false;
+        return this.userInteraction.confirm('Do you want to install WSL now?', true);
+    }
+    /**
+     * 檢查當前程序是否具有管理員權限
+     */
+    async checkAdmin() {
+        try {
+            const builder = command_builder_1.CommandBuilder.create('powershell')
+                .powershell("([Security.Principal.WindowsPrincipal] [Security.Principal.WindowsIdentity]::GetCurrent()).IsInRole([Security.Principal.WindowsBuiltInRole] 'Administrator')");
+            const result = await builder.exec(this.commandExecutor);
+            return result.stdout.trim() === 'True';
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * 安裝或更新 WSL
+     * 統一使用 wsl --update 命令，適用於所有 Windows 版本
+     * 如果以管理員身分執行，則在當前控制台中執行
+     * 否則，提示用戶以管理員身份重新執行
+     *
+     * @param action 'install' 或 'update'（統一執行 --update）
+     * @param output - 輸出介面
+     * @returns 物件指示是否需要重新啟動
+     */
+    async installWsl(action = 'install', output) {
+        const isAdmin = await this.checkAdmin();
+        const actionDescription = action === 'install' ? 'installation' : 'update';
+        this.appLogger?.info(`Starting WSL ${actionDescription}`, { isAdmin, action });
+        if (isAdmin) {
+            output?.info(`Running WSL ${actionDescription} in the current console...`).flush();
+            try {
+                // 統一使用 --update，適用於所有 Windows 版本
+                const builder = command_builder_1.CommandBuilder.create('wsl')
+                    .wslCmd('--update');
+                const result = await builder.exec(this.commandExecutor);
+                const cmdOutput = result.stdout + result.stderr;
+                if (result.exitCode !== 0) {
+                    // 即使命令 "失敗"，也可能已經成功但需要重新啟動
+                    // Windows 經常在需要重新啟動時返回非零退出碼
+                    if (/restart|reboot|重新啟動/i.test(cmdOutput)) {
+                        output?.success(`WSL ${actionDescription} completed (restart required).`).flush();
+                        return { needsRestart: true };
+                    }
+                    throw new Error('Command failed');
+                }
+                // 根據輸出檢查是否需要重新啟動
+                const needsRestart = /restart|reboot|重新啟動/i.test(cmdOutput);
+                if (needsRestart) {
+                    output?.success(`WSL ${actionDescription} completed.`).flush();
+                    output?.warning('A system restart is required.').flush();
+                }
+                else {
+                    output?.success(`WSL ${actionDescription} completed.`).flush();
+                }
+                return { needsRestart };
+            }
+            catch (error) {
+                // 檢查錯誤訊息中是否包含重啟提示
+                const errorMessage = (0, error_formatter_util_1.formatErrorMessage)(error);
+                if (/restart|reboot|重新啟動/i.test(errorMessage)) {
+                    output?.success(`WSL ${actionDescription} completed (restart required).`).flush();
+                    return { needsRestart: true };
+                }
+                this.appLogger?.error(error instanceof Error ? error : new Error(String(error)), {
+                    operation: 'installWsl',
+                    action,
+                    isAdmin: true
+                });
+                throw new errors_1.AppError(`Failed to execute WSL ${actionDescription}`, {
+                    exitCode: errors_1.EXIT_CODES.SYSTEM_ERROR,
+                    solution: 'Try running the command as administrator or check Windows Event Viewer for details',
+                });
+            }
+        }
+        else {
+            // 沒有管理員權限,需要用戶重新以管理員身份開啟終端
+            output?.error('Administrator privileges required.').flush();
+            output?.info(`WSL ${actionDescription} requires administrator privileges.`).flush();
+            output?.info('Please reopen this terminal as Administrator and run the setup command again.').flush();
+            output?.info('How to run as Administrator:').flush();
+            output?.info('  1. Right-click your terminal (Command Prompt, PowerShell, or Windows Terminal)').flush();
+            output?.info('  2. Select "Run as administrator"').flush();
+            output?.info(`  3. Run: uofx env setup`).flush();
+            // 拋出簡單錯誤以便記錄,但不顯示冗長的錯誤詳情
+            this.appLogger?.error(new Error(`Administrator privileges required for WSL ${actionDescription}`), {
+                operation: 'installWsl',
+                action,
+                isAdmin: false
+            });
+            throw new errors_1.AppError(`Failed to launch WSL ${actionDescription}`, {
+                exitCode: errors_1.EXIT_CODES.SYSTEM_ERROR,
+                solution: 'Run the command as administrator or check your Windows permissions',
+            });
+        }
+    }
+    /**
+     * 設定 WSL 預設版本為 2 (wsl --set-default-version 2)
+     * @param progress - 進度通知回調
+     * @throws AppSystemError 若設定失敗
+     */
+    async setDefaultVersion(output) {
+        try {
+            output?.info('Setting WSL 2 as default version...').flush();
+            this.appLogger?.debug('Running wsl --set-default-version 2');
+            const builder = command_builder_1.CommandBuilder.create('wsl')
+                .arg('--set-default-version')
+                .arg('2');
+            const result = await builder.exec(this.commandExecutor, (data) => output?.info(`${data.trim()}`).flush(), (data) => output?.info(`${data.trim()}`).flush());
+            if (result.exitCode !== 0) {
+                throw new Error(result.stderr || 'Command failed');
+            }
+            output?.success('WSL 2 set as default version').flush();
+        }
+        catch (error) {
+            this.appLogger?.error(error instanceof Error ? error : new Error(String(error)), {
+                operation: 'setDefaultVersion',
+            });
+            throw new errors_1.AppError('Failed to set WSL default version', {
+                exitCode: errors_1.EXIT_CODES.SYSTEM_ERROR,
+                solution: 'Try running: wsl --set-default-version 2',
+            });
+        }
+    }
+    /**
+     * 格式化設定取消錯誤訊息
+     * @param requirement - 更新需求資訊
+     * @returns 格式化後的錯誤訊息
+     */
+    formatSetupCancelledError(requirement) {
+        const lines = [];
+        lines.push('✗ Setup cancelled: WSL 2 is required for Kubernetes');
+        lines.push('');
+        lines.push('To continue setup manually, please run:');
+        if (requirement.needsUpdate) {
+            lines.push('  wsl --update');
+        }
+        if (requirement.needsDefaultVersion) {
+            lines.push('  wsl --set-default-version 2');
+        }
+        lines.push('');
+        lines.push("Then run 'uofx setup' again");
+        lines.push('');
+        lines.push('For more information: https://docs.microsoft.com/en-us/windows/wsl/');
+        return lines.join('\n');
+    }
+    /**
+     * 處理設定取消事件，顯示錯誤訊息並拋出異常
+     * @param requirement - 更新需求資訊
+     * @param progress - 進度通知回調
+     * @throws AppBusinessError 總是拋出 SETUP_CANCELLED 錯誤
+     */
+    handleSetupCancelled(requirement, output) {
+        output?.info(this.formatSetupCancelledError(requirement)).flush();
+        throw new errors_1.AppError('Setup cancelled: WSL 2 is required for Kubernetes', {
+            exitCode: errors_1.EXIT_CODES.BUSINESS_ERROR,
+            solution: 'Install WSL 2 to continue. Run: uofx setup',
+        });
+    }
+};
+exports.WslUpdaterService = WslUpdaterService;
+exports.WslUpdaterService = WslUpdaterService = __decorate([
+    (0, tsyringe_1.injectable)(),
+    __param(0, (0, tsyringe_1.inject)(tokens_1.TOKENS.Internal.ICommandExecutor)),
+    __param(1, (0, tsyringe_1.inject)(tokens_1.TOKENS.ILoggerPort)),
+    __param(2, (0, tsyringe_1.inject)(tokens_1.TOKENS.IUserInteractionPort)),
+    __metadata("design:paramtypes", [Object, Object, Object])
+], WslUpdaterService);
+//# sourceMappingURL=wsl-updater.service.js.map

package/dist/infrastructure/platforms/windows/services/wslconfig-parser.service.js

@@ -0,0 +1,222 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WslConfigParserService = void 0;
+const tsyringe_1 = require("tsyringe");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const tokens_1 = require("../../../../di/tokens");
+const command_builder_1 = require("../../../execution/command-builder");
+/**
+ * WSL 配置檔案解析服務
+ *
+ * 負責讀取和解析 .wslconfig 設定檔以及查詢 WSL 記憶體使用狀態
+ */
+let WslConfigParserService = class WslConfigParserService {
+    constructor(hardwareInfo, wslInfo, commandExecutor) {
+        this.hardwareInfo = hardwareInfo;
+        this.wslInfo = wslInfo;
+        this.commandExecutor = commandExecutor;
+    }
+    /**
+     * 解析記憶體值字串
+     * @param value 記憶體值 (如 "16GB", "16384MB")
+     * @returns 記憶體大小 (GB)
+     */
+    parseMemoryValue(value) {
+        if (typeof value === 'number') {
+            return value;
+        }
+        const trimmed = value.trim().toUpperCase();
+        if (trimmed.endsWith('GB')) {
+            return parseInt(trimmed.replace('GB', ''), 10);
+        }
+        if (trimmed.endsWith('MB')) {
+            return Math.round(parseInt(trimmed.replace('MB', ''), 10) / 1024);
+        }
+        return parseInt(trimmed, 10);
+    }
+    /**
+     * 取得 WSL2 預設記憶體限制
+     * - WSL 2.0+: 總記憶體的 50%（無上限）
+     * - WSL < 2.0 或無法取得版本: min(50%, 8GB)
+     * @returns 預設記憶體限制 (GB)
+     */
+    async getWsl2DefaultMemory() {
+        const totalMemoryGB = await this.hardwareInfo.getTotalMemoryGB();
+        const halfMemory = Math.floor(totalMemoryGB / 2);
+        // 取得 WSL 版本
+        const versionInfo = await this.wslInfo.getWslVersionInfo();
+        // WSL 2.0+ 沒有 8GB 上限
+        if (versionInfo.wslVersion && this.isWsl2OrLater(versionInfo.wslVersion)) {
+            return halfMemory;
+        }
+        // 舊版或無法取得版本：使用保守值 min(50%, 8GB)
+        return Math.min(halfMemory, 8);
+    }
+    /**
+     * 檢查 WSL 版本是否為 2.0 或更新
+     * @param version WSL 版本字串 (如 "2.0.9.0")
+     * @returns 是否為 2.0+
+     */
+    isWsl2OrLater(version) {
+        const parts = version.split('.').map(Number);
+        return parts[0] >= 2;
+    }
+    /**
+     * 讀取 .wslconfig 設定
+     * @returns WSL 配置記憶體資訊
+     */
+    async readWslConfig() {
+        const wslConfigPath = path.join(os.homedir(), '.wslconfig');
+        if (!fs.existsSync(wslConfigPath)) {
+            return {
+                exists: false,
+                memoryGB: await this.getWsl2DefaultMemory(),
+                configured: false
+            };
+        }
+        try {
+            const content = fs.readFileSync(wslConfigPath, 'utf-8');
+            const lines = content.split('\n');
+            let inWsl2Section = false;
+            let memoryValue;
+            for (const line of lines) {
+                const trimmed = line.trim();
+                if (trimmed === '[wsl2]') {
+                    inWsl2Section = true;
+                    continue;
+                }
+                if (trimmed.startsWith('[') && trimmed.endsWith(']')) {
+                    inWsl2Section = false;
+                    continue;
+                }
+                if (inWsl2Section && trimmed.startsWith('memory')) {
+                    const match = trimmed.match(/memory\s*=\s*(.+)/i);
+                    if (match) {
+                        memoryValue = match[1].trim();
+                        break;
+                    }
+                }
+            }
+            if (memoryValue) {
+                const memoryGB = this.parseMemoryValue(memoryValue);
+                return {
+                    exists: true,
+                    memoryGB,
+                    configured: true,
+                    rawValue: memoryValue
+                };
+            }
+            return {
+                exists: true,
+                memoryGB: await this.getWsl2DefaultMemory(),
+                configured: false
+            };
+        }
+        catch {
+            return {
+                exists: true,
+                memoryGB: await this.getWsl2DefaultMemory(),
+                configured: false
+            };
+        }
+    }
+    /**
+     * 取得 WSL2 目前使用的記憶體 (GB)
+     * 透過查詢 vmmem 程序取得
+     * @returns WSL 目前使用的記憶體 (GB)
+     */
+    async getWslCurrentMemoryUsageGB() {
+        try {
+            const builder = command_builder_1.CommandBuilder.create('powershell')
+                .arg('-NoProfile')
+                .arg('-Command')
+                .arg('(Get-Process vmmemWSL -ErrorAction SilentlyContinue).WorkingSet64');
+            const result = await builder.exec(this.commandExecutor);
+            const bytes = parseInt(result.stdout.trim(), 10);
+            if (isNaN(bytes))
+                return 0;
+            return Math.round(bytes / (1024 * 1024 * 1024) * 100) / 100;
+        }
+        catch {
+            return 0; // 如果查詢失敗，回傳 0（WSL 可能未運行）
+        }
+    }
+    /**
+     * 取得記憶體可用性資訊
+     * 綜合計算系統剩餘記憶體、WSL 限制、WSL 使用量
+     * @returns 記憶體可用性資訊
+     */
+    async getMemoryAvailability() {
+        const systemAvailableGB = await this.hardwareInfo.getAvailableMemoryGB();
+        const wslConfig = await this.readWslConfig();
+        const wslLimitGB = wslConfig.memoryGB;
+        const wslCurrentUsageGB = await this.getWslCurrentMemoryUsageGB();
+        const wslAvailableGB = Math.max(0, wslLimitGB - wslCurrentUsageGB);
+        // 取系統剩餘和 WSL 可用的較小值
+        const availableForUofxGB = Math.min(systemAvailableGB, wslAvailableGB);
+        return {
+            systemAvailableGB,
+            wslLimitGB,
+            wslCurrentUsageGB,
+            wslAvailableGB,
+            availableForUofxGB,
+            wslLimitSource: wslConfig.configured ? 'wslconfig' : 'default'
+        };
+    }
+};
+exports.WslConfigParserService = WslConfigParserService;
+exports.WslConfigParserService = WslConfigParserService = __decorate([
+    (0, tsyringe_1.injectable)(),
+    __param(0, (0, tsyringe_1.inject)(tokens_1.TOKENS.Internal.IHardwareInfo)),
+    __param(1, (0, tsyringe_1.inject)(tokens_1.TOKENS.Internal.WslInfoService)),
+    __param(2, (0, tsyringe_1.inject)(tokens_1.TOKENS.Internal.ICommandExecutor)),
+    __metadata("design:paramtypes", [Object, Object, Object])
+], WslConfigParserService);
+//# sourceMappingURL=wslconfig-parser.service.js.map

package/dist/infrastructure/platforms/windows/wsl-base-image.adapter.js

@@ -0,0 +1,41 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WslBaseImageAdapter = void 0;
+const tsyringe_1 = require("tsyringe");
+const tokens_1 = require("../../../di/tokens");
+/**
+ * WSL Base Image Adapter
+ *
+ * implements IBaseImagePort for Windows/WSL platform
+ * 管理 Ubuntu rootfs 下載與快取
+ */
+let WslBaseImageAdapter = class WslBaseImageAdapter {
+    constructor(rootfsManager) {
+        this.rootfsManager = rootfsManager;
+    }
+    checkCache() {
+        return this.rootfsManager.checkCache();
+    }
+    async getOrDownload(output) {
+        return await this.rootfsManager.getOrDownloadRootfs(output);
+    }
+};
+exports.WslBaseImageAdapter = WslBaseImageAdapter;
+exports.WslBaseImageAdapter = WslBaseImageAdapter = __decorate([
+    (0, tsyringe_1.injectable)(),
+    __param(0, (0, tsyringe_1.inject)(tokens_1.TOKENS.Internal.RootfsManagerService)),
+    __metadata("design:paramtypes", [Object])
+], WslBaseImageAdapter);
+//# sourceMappingURL=wsl-base-image.adapter.js.map

package/dist/infrastructure/platforms/windows/wsl-instance-manager.adapter.js

@@ -0,0 +1,150 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WslInstanceManagerAdapter = void 0;
+const tsyringe_1 = require("tsyringe");
+const tokens_1 = require("../../../di/tokens");
+const instance_status_entity_1 = require("../../../domain/entities/instance-status.entity");
+/**
+ * WSL Instance Manager Adapter
+ *
+ * implements IInstanceManagerPort for Windows/WSL platform
+ * 橋接 Infrastructure 層的 WSL Services 與 Domain 層的 Port
+ */
+let WslInstanceManagerAdapter = class WslInstanceManagerAdapter {
+    constructor(naming, lifecycle, inspection, wslConfig, scriptExecutor, envFactory) {
+        this.naming = naming;
+        this.lifecycle = lifecycle;
+        this.inspection = inspection;
+        this.wslConfig = wslConfig;
+        this.scriptExecutor = scriptExecutor;
+        this.envFactory = envFactory;
+    }
+    async create(name, config, output) {
+        await this.lifecycle.createInstance(name.toString(), // 短名稱 "dev"
+        config.installPath, // 安裝路徑
+        config.chartVersion, // Chart 版本
+        config.rootfsPath, output);
+    }
+    async delete(name, output) {
+        // 先 unregister WSL（釋放 VHDX 檔案鎖定）
+        await this.lifecycle.deleteInstance(name.fullName);
+        // 再刪除資料夾
+        await this.lifecycle.removeInstanceDirectory(name.toString(), output);
+    }
+    async start(name, output) {
+        await this.lifecycle.startInstance(name.fullName, output);
+    }
+    async stop(name, force, output) {
+        await this.lifecycle.stopInstance(name.fullName, force, output);
+    }
+    async exists(name) {
+        return await this.inspection.checkInstanceExists(name.fullName);
+    }
+    async getStatus(name) {
+        const infraStatus = await this.inspection.getInstanceStatus(name.fullName);
+        if (infraStatus.running) {
+            return instance_status_entity_1.InstanceStatus.createRunning(name.toString(), infraStatus.uptime);
+        }
+        else {
+            return instance_status_entity_1.InstanceStatus.createStopped(name.toString());
+        }
+    }
+    async list() {
+        return await this.inspection.scanAllInstances();
+    }
+    async listUofx() {
+        const result = await this.inspection.scanUofxInstances();
+        return result.instances;
+    }
+    async verify(name) {
+        return await this.inspection.verifyInstance(name.fullName);
+    }
+    async initialize(name, params, environmentVersion, output) {
+        await this.scriptExecutor.runSystemInitialization(name.fullName, params, environmentVersion, output);
+    }
+    async listRunningInstances() {
+        return await this.inspection.listRunningInstances();
+    }
+    async waitForPodsReady(name, timeoutMs) {
+        return await this.lifecycle.waitForPodsReady(name.fullName, timeoutMs);
+    }
+    async initDBusSession(name, output) {
+        await this.lifecycle.initDBusSession(name.fullName, output);
+    }
+    async isMicroK8sRunning(name) {
+        return await this.lifecycle.isMicroK8sRunning(name.fullName);
+    }
+    async getInstanceDetails(name) {
+        const exists = await this.inspection.checkInstanceExists(name.fullName);
+        if (!exists) {
+            return null;
+        }
+        const status = await this.inspection.getInstanceStatus(name.fullName);
+        const installPath = this.naming.getInstallPath(name.toString());
+        const metadata = this.lifecycle.loadMetadata(installPath);
+        const diskUsage = await this.lifecycle.getDirectorySize(installPath);
+        return {
+            name: name.fullName,
+            isRunning: status.running,
+            chartVersion: metadata?.chartVersion || null,
+            installedAt: metadata?.createdAt || null,
+            diskUsage,
+            diskUsageFormatted: this.lifecycle.formatSize(diskUsage),
+        };
+    }
+    async getInstanceIP(name) {
+        try {
+            const env = this.envFactory.getForInstance(name.fullName);
+            const builder = env.shell('hostname')
+                .arg('-I');
+            const result = await builder.exec();
+            if (!result || result.exitCode !== 0 || !result.stdout) {
+                return null;
+            }
+            // 解析第一個 IP 位址
+            const ipAddr = result.stdout.trim().split(' ')[0];
+            // 驗證 IP 格式
+            const ipPattern = /^\d+\.\d+\.\d+\.\d+$/;
+            return ipPattern.test(ipAddr) ? ipAddr : null;
+        }
+        catch {
+            return null;
+        }
+    }
+    async requireExists(name) {
+        const exists = await this.exists(name);
+        if (!exists) {
+            throw new Error(`Instance "${name.toString()}" not found`);
+        }
+    }
+    async requireNotExists(name) {
+        const exists = await this.exists(name);
+        if (exists) {
+            throw new Error(`Instance "${name.toString()}" already exists`);
+        }
+    }
+};
+exports.WslInstanceManagerAdapter = WslInstanceManagerAdapter;
+exports.WslInstanceManagerAdapter = WslInstanceManagerAdapter = __decorate([
+    (0, tsyringe_1.injectable)(),
+    __param(0, (0, tsyringe_1.inject)(tokens_1.TOKENS.Internal.IWslInstanceNaming)),
+    __param(1, (0, tsyringe_1.inject)(tokens_1.TOKENS.Internal.IWslInstanceLifecycle)),
+    __param(2, (0, tsyringe_1.inject)(tokens_1.TOKENS.Internal.IWslInstanceInspection)),
+    __param(3, (0, tsyringe_1.inject)(tokens_1.TOKENS.Internal.WslConfigService)),
+    __param(4, (0, tsyringe_1.inject)(tokens_1.TOKENS.Internal.ScriptExecutorService)),
+    __param(5, (0, tsyringe_1.inject)(tokens_1.TOKENS.Internal.IExecutionEnvironmentFactory)),
+    __metadata("design:paramtypes", [Object, Object, Object, Object, Object, Object])
+], WslInstanceManagerAdapter);
+//# sourceMappingURL=wsl-instance-manager.adapter.js.map