@uofx/cli 1.0.0

package/dist/infrastructure/platforms/windows/parsers/wsl-version.parser.js

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WslVersionParser = void 0;
+/**
+ * WSL 版本解析器
+ *
+ * 負責解析 WSL 命令輸出的版本資訊
+ * 支援英文與中文（繁體/簡體）系統語言
+ *
+ * 設計原則：
+ * - 將 Regex 解析邏輯隔離，方便測試
+ * - 容錯編碼問題（Unicode BOM、不同編碼）
+ * - 支援多語系輸出
+ */
+class WslVersionParser {
+    /**
+     * 解析 WSL 版本號
+     * @param output wsl --version 的輸出
+     * @returns WSL 版本號，解析失敗返回 null
+     *
+     * @example
+     * // English: "WSL version: 2.0.9.0"
+     * // Chinese: "WSL 版本： 2.0.9.0"
+     * parseWslVersion(output) // "2.0.9.0"
+     */
+    static parseWslVersion(output) {
+        if (!output || typeof output !== 'string') {
+            return null;
+        }
+        // 清理輸出（移除 BOM、標準化空白）
+        const cleanOutput = this.cleanOutput(output);
+        // 支援多種格式：
+        // - English: "WSL version: 2.0.9.0" or "WSL version 2.0.9.0"
+        // - Chinese (Traditional): "WSL 版本： 2.0.9.0" or "WSL 版本: 2.0.9.0"
+        // - Chinese (Simplified): "WSL 版本： 2.0.9.0"
+        const patterns = [
+            /WSL\s+version[:\s]+([0-9.]+)/i,
+            /WSL\s*版本[：:\s]+([0-9.]+)/,
+        ];
+        for (const pattern of patterns) {
+            const match = cleanOutput.match(pattern);
+            if (match && match[1]) {
+                return match[1];
+            }
+        }
+        return null;
+    }
+    /**
+     * 解析 Kernel 版本號
+     * @param output wsl --version 的輸出
+     * @returns Kernel 版本號，解析失敗返回 null
+     *
+     * @example
+     * // English: "Kernel version: 5.15.133.1-1"
+     * // Chinese: "核心版本： 5.15.133.1-1"
+     * parseKernelVersion(output) // "5.15.133.1-1"
+     */
+    static parseKernelVersion(output) {
+        if (!output || typeof output !== 'string') {
+            return null;
+        }
+        const cleanOutput = this.cleanOutput(output);
+        // 支援多種格式：
+        // - English: "Kernel version: 5.15.133.1-1"
+        // - Chinese: "核心版本： 5.15.133.1-1"
+        const patterns = [
+            /Kernel\s+version[:\s]+([0-9.-]+)/i,
+            /核心版本[：:\s]+([0-9.-]+)/,
+        ];
+        for (const pattern of patterns) {
+            const match = cleanOutput.match(pattern);
+            if (match && match[1]) {
+                return match[1];
+            }
+        }
+        return null;
+    }
+    /**
+     * 解析預設 WSL 版本
+     * @param output wsl --status 的輸出
+     * @returns 預設版本號 (1 或 2)，解析失敗返回 null
+     *
+     * @example
+     * // English: "Default Version: 2"
+     * // Chinese: "預設版本: 2" or "默认版本: 2"
+     * parseDefaultVersion(output) // 2
+     */
+    static parseDefaultVersion(output) {
+        if (!output || typeof output !== 'string') {
+            return null;
+        }
+        const cleanOutput = this.cleanOutput(output);
+        // 支援多種格式：
+        // - English: "Default Version: 2"
+        // - Chinese (Traditional): "預設版本: 2"
+        // - Chinese (Simplified): "默认版本: 2"
+        const patterns = [
+            /Default\s+Version[:\s]+(\d+)/i,
+            /預設版本[：:\s]+(\d+)/,
+            /默认版本[：:\s]+(\d+)/,
+        ];
+        for (const pattern of patterns) {
+            const match = cleanOutput.match(pattern);
+            if (match && match[1]) {
+                const version = parseInt(match[1], 10);
+                if (!isNaN(version) && (version === 1 || version === 2)) {
+                    return version;
+                }
+            }
+        }
+        return null;
+    }
+    /**
+     * 清理命令輸出
+     * - 移除 Unicode BOM
+     * - 標準化換行符
+     * - 移除多餘空白
+     */
+    static cleanOutput(output) {
+        return output
+            // 移除 UTF-8 BOM
+            .replace(/^\uFEFF/, '')
+            // 移除 UTF-16 BOM
+            .replace(/^\uFFFE/, '')
+            // 標準化換行符
+            .replace(/\r\n/g, '\n')
+            .replace(/\r/g, '\n')
+            // 移除多餘空白但保留結構
+            .trim();
+    }
+}
+exports.WslVersionParser = WslVersionParser;
+//# sourceMappingURL=wsl-version.parser.js.map

package/dist/infrastructure/platforms/windows/services/microk8s.service.js

@@ -0,0 +1,168 @@
+"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.MicroK8sService = void 0;
+const tsyringe_1 = require("tsyringe");
+const tokens_1 = require("../../../../di/tokens");
+const index_1 = require("../../../../constants/index");
+const input_validator_util_1 = require("../../../utils/input-validator.util");
+/**
+ * MicroK8s 服務
+ *
+ * 負責 MicroK8s 的狀態檢查、啟動、停止與等待操作
+ */
+let MicroK8sService = class MicroK8sService {
+    constructor(envFactory, logger) {
+        this.envFactory = envFactory;
+        this.logger = logger;
+    }
+    /**
+     * 檢查 MicroK8s 是否正在執行
+     */
+    async isRunning(instanceName) {
+        try {
+            (0, input_validator_util_1.requireValidInstanceName)(instanceName);
+            const env = this.envFactory.getForInstance(instanceName);
+            const builder = env.shell('systemctl')
+                .arg('is-active')
+                .arg('snap.microk8s.daemon-kubelite');
+            const result = await builder.exec();
+            return result.exitCode === 0 && result.stdout.trim() === 'active';
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * 啟動 MicroK8s
+     */
+    async start(instanceName) {
+        (0, input_validator_util_1.requireValidInstanceName)(instanceName);
+        this.logger.debug('[MicroK8s] Starting MicroK8s', { instanceName });
+        const env = this.envFactory.getForInstance(instanceName);
+        const builder = env.shell(index_1.LINUX_PATHS.MICROK8S_BIN)
+            .arg('start');
+        await builder.exec();
+    }
+    /**
+     * 停止 MicroK8s
+     */
+    async stop(instanceName) {
+        (0, input_validator_util_1.requireValidInstanceName)(instanceName);
+        this.logger.debug('[MicroK8s] Stopping MicroK8s', { instanceName });
+        const env = this.envFactory.getForInstance(instanceName);
+        const builder = env.shell(index_1.LINUX_PATHS.MICROK8S_BIN)
+            .arg('stop');
+        await builder.exec();
+    }
+    /**
+     * 等待 MicroK8s 停止
+     */
+    async waitForStop() {
+        await new Promise((resolve) => setTimeout(resolve, index_1.TIMEOUTS.MICROK8S_STARTUP));
+        return true;
+    }
+    /**
+     * 等待 MicroK8s 就緒
+     */
+    async waitForReady(instanceName) {
+        (0, input_validator_util_1.requireValidInstanceName)(instanceName);
+        this.logger.debug('[MicroK8s] Waiting for MicroK8s to be ready', { instanceName });
+        try {
+            const env = this.envFactory.getForInstance(instanceName);
+            const builder = env.shell(index_1.LINUX_PATHS.MICROK8S_BIN)
+                .arg('status')
+                .arg('--wait-ready');
+            const result = await builder.exec();
+            return result.exitCode === 0;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * 等待所有 Pods 就緒
+     */
+    async waitForPodsReady(instanceName, timeoutMs = index_1.TIMEOUTS.K8S_READY_TIMEOUT) {
+        (0, input_validator_util_1.requireValidInstanceName)(instanceName);
+        const startTime = Date.now();
+        let lastCheckTime = 0;
+        const env = this.envFactory.getForInstance(instanceName);
+        while (Date.now() - startTime < timeoutMs) {
+            const now = Date.now();
+            if (now - lastCheckTime < index_1.TIMEOUTS.K8S_READY_CHECK_INTERVAL) {
+                await new Promise((resolve) => setTimeout(resolve, 5000));
+                continue;
+            }
+            lastCheckTime = now;
+            try {
+                const builder = env.kubectl('get')
+                    .arg('pods')
+                    .arg('--all-namespaces')
+                    .arg('-o', 'json');
+                const { stdout, exitCode } = await builder.exec();
+                if (exitCode !== 0)
+                    continue;
+                const pods = JSON.parse(stdout);
+                if (!pods.items || pods.items.length === 0) {
+                    continue;
+                }
+                const allReady = pods.items.every((pod) => {
+                    if (pod.status.phase === 'Succeeded') {
+                        return true;
+                    }
+                    if (pod.status.phase === 'Failed') {
+                        return false;
+                    }
+                    const isRunning = pod.status.phase === 'Running';
+                    const readyCondition = pod.status.conditions?.find((c) => c.type === 'Ready');
+                    const isReady = readyCondition && readyCondition.status === 'True';
+                    return isRunning && isReady;
+                });
+                if (allReady) {
+                    this.logger.debug('[MicroK8s] All pods are ready', { instanceName });
+                    return true;
+                }
+            }
+            catch {
+                // Ignore and retry
+            }
+        }
+        this.logger.warn('[MicroK8s] Timeout waiting for pods to be ready', { instanceName, timeoutMs });
+        return false;
+    }
+    /**
+     * 重啟 containerd 服務
+     */
+    async restartContainerd(instanceName) {
+        (0, input_validator_util_1.requireValidInstanceName)(instanceName);
+        this.logger.debug('[MicroK8s] Restarting containerd', { instanceName });
+        const env = this.envFactory.getForInstance(instanceName);
+        // 停止
+        const restartBuilder = env.shell('sudo')
+            .arg('systemctl')
+            .arg('restart')
+            .arg('snap.microk8s.daemon-containerd');
+        await restartBuilder.exec();
+        await new Promise(resolve => setTimeout(resolve, 3000));
+    }
+};
+exports.MicroK8sService = MicroK8sService;
+exports.MicroK8sService = MicroK8sService = __decorate([
+    (0, tsyringe_1.injectable)(),
+    __param(0, (0, tsyringe_1.inject)(tokens_1.TOKENS.Internal.IExecutionEnvironmentFactory)),
+    __param(1, (0, tsyringe_1.inject)(tokens_1.TOKENS.ILoggerPort)),
+    __metadata("design:paramtypes", [Object, Object])
+], MicroK8sService);
+//# sourceMappingURL=microk8s.service.js.map

package/dist/infrastructure/platforms/windows/services/rootfs-manager.service.js

@@ -0,0 +1,336 @@
+"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.RootfsManagerService = void 0;
+const tsyringe_1 = require("tsyringe");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const crypto = __importStar(require("crypto"));
+const tokens_1 = require("../../../../di/tokens");
+const errors_1 = require("../../../errors");
+const index_1 = require("../../../../constants/index");
+/**
+ * Rootfs 管理相關常數
+ */
+const CACHE_DIR = path.join(os.homedir(), index_1.WINDOWS_PATHS.USER_CONFIG_DIR);
+const ROOTFS_FILENAME = 'ubuntu-22.04-root.tar.xz';
+const ROOTFS_URL = 'https://cloud-images.ubuntu.com/releases/jammy/release/ubuntu-22.04-server-cloudimg-amd64-root.tar.xz';
+const SHA256SUMS_URL = 'https://cloud-images.ubuntu.com/releases/jammy/release/SHA256SUMS';
+/**
+ * Ubuntu Rootfs 管理服務
+ */
+let RootfsManagerService = class RootfsManagerService {
+    /**
+     * 建立新的 RootfsManager 實例
+     * @param httpClient - 用於下載檔案的 HTTP 客戶端 (依賴注入)
+     * @param appLogger - 應用程式日誌記錄器
+     * @param cliProgress - CLI 進度條服務
+     */
+    constructor(httpClient, appLogger, cliProgress) {
+        this.appLogger = appLogger;
+        this.cliProgress = cliProgress;
+        this.httpClient = httpClient;
+        this.cacheDir = CACHE_DIR;
+        this.cachePath = path.join(this.cacheDir, ROOTFS_FILENAME);
+        this.rootfsUrl = ROOTFS_URL;
+        this.sha256SumsUrl = SHA256SUMS_URL;
+    }
+    /**
+     * 確保快取目錄存在
+     * 若不存在則建立目錄
+     */
+    ensureCacheDirectory() {
+        if (!fs.existsSync(this.cacheDir)) {
+            fs.mkdirSync(this.cacheDir, { recursive: true });
+        }
+    }
+    /**
+     * 檢查快取 rootfs 是否存在且有效
+     * @returns 快取檢查結果
+     */
+    checkCache() {
+        // 檢查檔案是否存在
+        if (!fs.existsSync(this.cachePath)) {
+            return {
+                exists: false,
+                path: this.cachePath,
+                valid: false,
+                reason: 'Cache file does not exist',
+            };
+        }
+        // 取得檔案狀態
+        const stats = fs.statSync(this.cachePath);
+        // 基本驗證 - 檔案應大於 100MB (rootfs 約 400MB)
+        if (stats.size < index_1.FILE_SIZE.MIN_ROOTFS_SIZE) {
+            return {
+                exists: true,
+                path: this.cachePath,
+                valid: false,
+                size: stats.size,
+                reason: 'Cache file is too small, may be corrupted',
+            };
+        }
+        return {
+            exists: true,
+            path: this.cachePath,
+            valid: true,
+            size: stats.size,
+        };
+    }
+    /**
+     * 計算檔案的 SHA256 雜湊值
+     * @param filePath - 檔案路徑
+     * @returns 解析為 hex 編碼 SHA256 雜湊值的 Promise
+     */
+    calculateSHA256(filePath) {
+        return new Promise((resolve, reject) => {
+            const hash = crypto.createHash('sha256');
+            const stream = fs.createReadStream(filePath);
+            stream.on('data', (data) => hash.update(data));
+            stream.on('end', () => resolve(hash.digest('hex')));
+            stream.on('error', (error) => reject(error));
+        });
+    }
+    /**
+     * 下載並解析 SHA256SUMS 檔案
+     * @returns 檔案名稱對應 SHA256 雜湊值的 Map
+     */
+    async downloadSHA256Sums() {
+        try {
+            this.appLogger?.debug('Downloading SHA256SUMS file', { url: this.sha256SumsUrl });
+            const responseText = await this.httpClient.fetchText(this.sha256SumsUrl);
+            const sums = new Map();
+            const lines = responseText.split('\n');
+            for (const line of lines) {
+                const trimmed = line.trim();
+                if (!trimmed)
+                    continue;
+                // 格式: <hash> *<filename> 或 <hash>  <filename>
+                const match = trimmed.match(/^([a-f0-9]{64})\s+\*?(.+)$/);
+                if (match) {
+                    const [, hash, filename] = match;
+                    sums.set(filename, hash);
+                }
+            }
+            return sums;
+        }
+        catch (error) {
+            this.appLogger?.error(error instanceof Error ? error : new Error(String(error)), {
+                operation: 'downloadSHA256Sums',
+                url: this.sha256SumsUrl,
+            });
+            throw new errors_1.AppError('Failed to download SHA256SUMS file', {
+                exitCode: errors_1.EXIT_CODES.NETWORK_ERROR,
+                solution: 'Check your internet connection and try again',
+                cause: error instanceof Error ? error : new Error(String(error)),
+                context: { operation: 'downloadSHA256Sums', resource: this.sha256SumsUrl }
+            });
+        }
+    }
+    /**
+     * 驗證快取檔案是否符合預期的 SHA256 雜湊值
+     * @param expectedHash - 預期的 SHA256 雜湊值
+     * @returns 若雜湊值相符則回傳 true，否則回傳 false
+     */
+    async verifyCachedFile(expectedHash) {
+        if (!fs.existsSync(this.cachePath)) {
+            return false;
+        }
+        const actualHash = await this.calculateSHA256(this.cachePath);
+        return actualHash.toLowerCase() === expectedHash.toLowerCase();
+    }
+    /**
+     * 取得 rootfs 檔案的預期 SHA256 雜湊值
+     * @returns 預期的 SHA256 雜湊值
+     */
+    async getExpectedHash() {
+        const sums = await this.downloadSHA256Sums();
+        const rootfsFilename = path.basename(this.rootfsUrl);
+        const hash = sums.get(rootfsFilename);
+        if (!hash) {
+            throw new Error(`SHA256 hash not found for ${rootfsFilename}`);
+        }
+        return hash;
+    }
+    /**
+     * 下載 rootfs 並顯示進度
+     * @param onProgress - 可選的進度回調函式
+     * @returns 下載結果
+     */
+    async downloadRootfs(onProgress) {
+        // 確保快取目錄存在
+        this.ensureCacheDirectory();
+        // 建立臨時檔案路徑
+        const tempPath = `${this.cachePath}.tmp`;
+        try {
+            this.appLogger?.debug('Starting rootfs download', {
+                url: this.rootfsUrl,
+                tempPath,
+            });
+            // 使用注入的 HTTP 客戶端下載
+            await this.httpClient.downloadFile(this.rootfsUrl, tempPath, onProgress);
+            // 驗證下載的檔案
+            const expectedHash = await this.getExpectedHash();
+            const actualHash = await this.calculateSHA256(tempPath);
+            const verified = actualHash.toLowerCase() === expectedHash.toLowerCase();
+            if (!verified) {
+                // 清理無效檔案
+                fs.unlinkSync(tempPath);
+                throw new Error('SHA256 verification failed - downloaded file may be corrupted');
+            }
+            // 移動臨時檔案到最終位置
+            if (fs.existsSync(this.cachePath)) {
+                fs.unlinkSync(this.cachePath);
+            }
+            fs.renameSync(tempPath, this.cachePath);
+            // 取得檔案大小
+            const stats = fs.statSync(this.cachePath);
+            this.appLogger?.debug('Rootfs download completed and verified', {
+                path: this.cachePath,
+                size: stats.size,
+            });
+            return {
+                success: true,
+                path: this.cachePath,
+                size: stats.size,
+                verified: true,
+            };
+        }
+        catch (error) {
+            // 發生錯誤時清理臨時檔案
+            if (fs.existsSync(tempPath)) {
+                fs.unlinkSync(tempPath);
+            }
+            this.appLogger?.error(error instanceof Error ? error : new Error(String(error)), {
+                operation: 'downloadRootfs',
+                url: this.rootfsUrl,
+            });
+            throw new errors_1.AppError('Failed to download Ubuntu rootfs', {
+                exitCode: errors_1.EXIT_CODES.NETWORK_ERROR,
+                solution: 'Check your internet connection and try again. The rootfs file will be downloaded from Ubuntu cloud images.',
+                cause: error instanceof Error ? error : new Error(String(error)),
+                context: { operation: 'downloadAndVerifyRootfs', resource: this.rootfsUrl }
+            });
+        }
+    }
+    /**
+     * 下載 rootfs 並顯示內建進度條
+     * @returns 下載結果
+     */
+    async downloadWithProgress() {
+        let progressBar;
+        try {
+            const result = await this.downloadRootfs((loaded, total) => {
+                if (!progressBar && this.cliProgress) {
+                    progressBar = this.cliProgress.createDownloadProgress('Downloading Ubuntu rootfs', total);
+                }
+                progressBar?.update(loaded);
+            });
+            progressBar?.stop();
+            return result;
+        }
+        catch (error) {
+            progressBar?.stop();
+            throw error;
+        }
+    }
+    /**
+     * 取得或下載 rootfs
+     * 僅在快取不存在或無效時下載
+     * @param progress - 進度通知回調
+     * @returns rootfs 檔案路徑
+     */
+    async getOrDownloadRootfs(output) {
+        // 檢查快取
+        const cacheCheck = this.checkCache();
+        if (cacheCheck.exists && cacheCheck.valid) {
+            // 驗證雜湊值
+            output?.info('Checking cached rootfs...').flush();
+            const expectedHash = await this.getExpectedHash();
+            const isValid = await this.verifyCachedFile(expectedHash);
+            if (isValid) {
+                output?.success('Using cached rootfs').flush();
+                return this.cachePath;
+            }
+            else {
+                output?.warning('! Cached rootfs checksum mismatch, re-downloading...').flush();
+            }
+        }
+        // 下載
+        output?.info('Downloading Ubuntu rootfs...').flush();
+        output?.item('arrow', `Source: ${this.rootfsUrl}`).flush();
+        output?.item('arrow', `Destination: ${this.cachePath}`).flush();
+        const result = await this.downloadWithProgress();
+        output?.success('SHA256 checksum verified').flush();
+        output?.success('Ubuntu rootfs cached successfully').flush();
+        return result.path;
+    }
+    /**
+     * 取得快取路徑
+     * @returns 快取 rootfs 檔案路徑
+     */
+    getCachePath() {
+        return this.cachePath;
+    }
+    /**
+     * 取得快取目錄
+     * @returns 快取目錄路徑
+     */
+    getCacheDirectory() {
+        return this.cacheDir;
+    }
+};
+exports.RootfsManagerService = RootfsManagerService;
+exports.RootfsManagerService = RootfsManagerService = __decorate([
+    (0, tsyringe_1.injectable)(),
+    __param(0, (0, tsyringe_1.inject)(tokens_1.TOKENS.Internal.IHttpClient)),
+    __param(1, (0, tsyringe_1.inject)(tokens_1.TOKENS.ILoggerPort)),
+    __param(2, (0, tsyringe_1.inject)(tokens_1.TOKENS.IProgress)),
+    __metadata("design:paramtypes", [Object, Object, Object])
+], RootfsManagerService);
+//# sourceMappingURL=rootfs-manager.service.js.map