@uofx/cli 1.0.0

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

@@ -0,0 +1,442 @@
+"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.WslInstanceLifecycleService = void 0;
+const tsyringe_1 = require("tsyringe");
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const tokens_1 = require("../../../../di/tokens");
+const command_builder_1 = require("../../../execution/command-builder");
+const index_1 = require("../../../../constants/index");
+const errors_1 = require("../../../errors");
+const input_validator_util_1 = require("../../../utils/input-validator.util");
+/**
+ * WSL 實例生命週期服務
+ *
+ * 負責 WSL 實例的建立、啟動、停止、刪除等生命週期操作
+ * 包含系統檢查功能：WSL 安裝檢查、Rootfs 存在性、磁碟空間
+ */
+let WslInstanceLifecycleService = class WslInstanceLifecycleService {
+    constructor(commandExecutor, namingService, inspectionService, wslConfigService, microK8sService, wslInfo, metadataPort, appLogger) {
+        this.commandExecutor = commandExecutor;
+        this.namingService = namingService;
+        this.inspectionService = inspectionService;
+        this.wslConfigService = wslConfigService;
+        this.microK8sService = microK8sService;
+        this.wslInfo = wslInfo;
+        this.metadataPort = metadataPort;
+        this.appLogger = appLogger;
+    }
+    /**
+     * 建立 WSL 實例 (高階方法)
+     */
+    async createInstance(displayName, installPath, chartVersion, rootfsPath, output) {
+        if (!this.namingService.validateInstanceName(displayName)) {
+            throw new errors_1.AppError(`Invalid instance name: ${displayName}`, {
+                exitCode: errors_1.EXIT_CODES.VALIDATION_ERROR,
+                solution: 'Only alphanumeric characters and hyphens are allowed'
+            });
+        }
+        const fullInstanceName = this.namingService.getFullInstanceName(displayName);
+        this.appLogger?.info('[WSL] Creating WSL instance', {
+            shortName: displayName,
+            fullName: fullInstanceName,
+            installPath,
+            chartVersion,
+            component: 'WslInstanceLifecycleService'
+        });
+        const actualRootfsPath = rootfsPath || this.namingService.getDefaultRootfsPath();
+        if (!await this.checkWslInstalled()) {
+            throw new errors_1.AppError('WSL is not installed', {
+                exitCode: errors_1.EXIT_CODES.ENVIRONMENT_ERROR,
+                solution: 'Please install WSL using: wsl --install'
+            });
+        }
+        if (!this.checkRootfsExists(actualRootfsPath)) {
+            throw new errors_1.AppError('Ubuntu rootfs not found', {
+                exitCode: errors_1.EXIT_CODES.ENVIRONMENT_ERROR,
+                solution: 'Please download the rootfs first using: uofx env download-rootfs',
+                context: { expectedLocation: actualRootfsPath }
+            });
+        }
+        if (!await this.checkDiskSpace(5)) {
+            throw new errors_1.AppError('Insufficient disk space', {
+                exitCode: errors_1.EXIT_CODES.ENVIRONMENT_ERROR,
+                solution: 'Please free up disk space (required: 5 GB) and try again'
+            });
+        }
+        if (await this.inspectionService.checkInstanceExists(fullInstanceName)) {
+            throw new errors_1.AppError(`Instance '${fullInstanceName}' already exists`, {
+                exitCode: errors_1.EXIT_CODES.SYSTEM_ERROR,
+                solution: `Delete it first by running: uofx env delete --name ${displayName}`,
+            });
+        }
+        if (!fs.existsSync(installPath)) {
+            fs.mkdirSync(installPath, { recursive: true });
+        }
+        output?.item('arrow', `Importing WSL instance (this may take a few minutes)...`).flush();
+        await this.importInstance(fullInstanceName, installPath, actualRootfsPath, output);
+        if (!await this.inspectionService.verifyInstance(fullInstanceName)) {
+            throw new errors_1.AppError(`Failed to verify instance '${fullInstanceName}'`, { exitCode: errors_1.EXIT_CODES.SYSTEM_ERROR });
+        }
+        output?.item('arrow', `Configuring systemd support...`).flush();
+        try {
+            output?.indent().item('arrow', `Creating default user 'ubuntu'`).outdent().flush();
+            await this.wslConfigService.createUser(fullInstanceName, 'ubuntu');
+            output?.indent().item('arrow', `Creating /etc/wsl.conf`).outdent().flush();
+            await this.wslConfigService.createWslConfig(fullInstanceName, 'ubuntu');
+            output?.indent().item('arrow', `Restarting WSL instance`).outdent().flush();
+            await this.wslConfigService.restartWslInstance(fullInstanceName);
+            output?.indent().success(`Systemd support enabled`).outdent().flush();
+            output?.indent().success(`Default user: ubuntu`).outdent().flush();
+            output?.indent().success(`WSL instance ready for use`).outdent().flush();
+        }
+        catch (error) {
+            output?.error(`Failed to configure systemd: ${error}`).flush();
+            output?.indent().item('arrow', `Instance created but systemd configuration failed`).outdent().flush();
+            output?.indent().item('arrow', `You may need to configure it manually`).outdent().flush();
+            throw error;
+        }
+        const metadata = {
+            name: fullInstanceName,
+            displayName: displayName,
+            createdAt: new Date().toISOString(),
+            version: '0.1.0',
+            chartVersion: chartVersion,
+            rootfsVersion: 'Ubuntu 22.04',
+        };
+        this.saveMetadata(metadata, installPath);
+        this.appLogger?.info('[WSL] WSL instance created successfully', {
+            fullName: fullInstanceName,
+            component: 'WslInstanceLifecycleService'
+        });
+    }
+    /**
+     * 刪除 WSL 實例
+     */
+    async deleteInstance(instanceName) {
+        (0, input_validator_util_1.requireValidInstanceName)(instanceName);
+        this.appLogger?.info('Deleting WSL instance', { instanceName });
+        const builder = command_builder_1.CommandBuilder.create('wsl')
+            .arg('--unregister')
+            .arg(instanceName);
+        await builder.exec(this.commandExecutor);
+    }
+    /**
+     * 匯入 WSL 實例
+     */
+    async importInstance(instanceName, installPath, rootfsPath, output) {
+        (0, input_validator_util_1.requireValidInstanceName)(instanceName);
+        if (!fs.existsSync(installPath)) {
+            fs.mkdirSync(installPath, { recursive: true });
+        }
+        const builder = command_builder_1.CommandBuilder.create('wsl')
+            .arg('--import')
+            .arg(instanceName)
+            .arg(installPath)
+            .arg(rootfsPath);
+        await builder.exec(this.commandExecutor, () => { }, (stderr) => {
+            if (stderr.trim()) {
+                output?.error(`${stderr.trim()}`).flush();
+            }
+        });
+    }
+    /**
+     * 啟動 WSL 實例和 MicroK8s
+     */
+    async startInstance(instanceName, output) {
+        (0, input_validator_util_1.requireValidInstanceName)(instanceName);
+        this.appLogger?.info('Starting WSL instance', { instanceName });
+        output?.item('arrow', `Starting WSL instance '${instanceName}'...`).flush();
+        output?.item('arrow', 'Initializing D-Bus session...').flush();
+        await this.initDBusSession(instanceName, output);
+        await new Promise((resolve) => setTimeout(resolve, index_1.TIMEOUTS.WSL_STARTUP_DELAY));
+        output?.item('arrow', 'Starting MicroK8s services...').flush();
+        try {
+            await this.microK8sService.start(instanceName);
+            await new Promise((resolve) => setTimeout(resolve, index_1.TIMEOUTS.WSL_FULL_STARTUP));
+            await this.microK8sService.restartContainerd(instanceName);
+        }
+        catch (error) {
+            // MicroK8s start 失敗不應阻止整個啟動流程
+            this.appLogger?.warn('MicroK8s start warning, continuing...', { error });
+        }
+        // output?.item('arrow', 'Waiting for MicroK8s to initialize...').flush();
+        // await new Promise((resolve) => setTimeout(resolve, TIMEOUTS.WSL_FULL_STARTUP));
+        output?.item('arrow', 'Waiting for MicroK8s to be ready...').flush();
+        try {
+            // await this.microK8sService.restartContainerd(instanceName);
+            const isReady = await this.microK8sService.waitForReady(instanceName);
+            if (!isReady) {
+                throw new errors_1.AppError('MicroK8s did not become ready within timeout', { exitCode: errors_1.EXIT_CODES.SYSTEM_ERROR, context: { instanceName } });
+            }
+            output?.success('MicroK8s is ready').flush();
+        }
+        catch (error) {
+            this.appLogger?.error(error instanceof Error ? error : new Error(String(error)), {
+                operation: 'startInstance',
+                instanceName,
+            });
+            throw new errors_1.AppError('Failed to wait for MicroK8s ready', {
+                exitCode: errors_1.EXIT_CODES.SYSTEM_ERROR,
+                cause: error instanceof Error ? error : new Error(String(error)),
+                context: { instanceName }
+            });
+        }
+    }
+    /**
+     * 停止 WSL 實例
+     */
+    async stopInstance(instanceName, force = false, output) {
+        (0, input_validator_util_1.requireValidInstanceName)(instanceName);
+        this.appLogger?.info('Stopping WSL instance', { instanceName, force });
+        output?.item('arrow', `Stopping instance '${instanceName}'...`).flush();
+        if (!force) {
+            output?.item('arrow', 'Stopping MicroK8s services...').flush();
+            try {
+                await this.microK8sService.stop(instanceName);
+                await this.microK8sService.waitForStop();
+            }
+            catch (error) {
+                this.appLogger?.warn('Failed to stop MicroK8s gracefully', { error });
+                output?.warning(`Failed to stop MicroK8s gracefully: ${error}`).flush();
+            }
+        }
+        else {
+            output?.item('arrow', 'Force stop requested, skipping MicroK8s graceful shutdown').flush();
+        }
+        output?.item('arrow', 'Shutting down WSL instance...').flush();
+        try {
+            const terminateBuilder = command_builder_1.CommandBuilder.create('wsl')
+                .arg('--terminate')
+                .arg(instanceName);
+            await terminateBuilder.exec(this.commandExecutor);
+            await new Promise((resolve) => setTimeout(resolve, index_1.TIMEOUTS.WSL_STARTUP_DELAY));
+            const status = await this.inspectionService.getInstanceStatus(instanceName);
+            if (status.running) {
+                await terminateBuilder.exec(this.commandExecutor);
+                await new Promise((resolve) => setTimeout(resolve, index_1.TIMEOUTS.WSL_STARTUP_DELAY));
+                const retryStatus = await this.inspectionService.getInstanceStatus(instanceName);
+                if (retryStatus.running) {
+                    throw new errors_1.AppError('WSL instance is still running after termination', { exitCode: errors_1.EXIT_CODES.SYSTEM_ERROR, context: { instanceName } });
+                }
+            }
+        }
+        catch (error) {
+            this.appLogger?.error(error instanceof Error ? error : new Error(String(error)), {
+                operation: 'stopInstance',
+                instanceName,
+            });
+            throw new errors_1.AppError('Failed to terminate WSL instance', {
+                exitCode: errors_1.EXIT_CODES.SYSTEM_ERROR,
+                cause: error instanceof Error ? error : new Error(String(error)),
+                context: { instanceName }
+            });
+        }
+    }
+    /**
+     * 初始化 D-Bus session (防止 WSL 自動停止)
+     */
+    async initDBusSession(fullInstanceName, output) {
+        (0, input_validator_util_1.requireValidInstanceName)(fullInstanceName);
+        try {
+            const builder = command_builder_1.CommandBuilder.create('wsl')
+                .arg('-d')
+                .arg(fullInstanceName)
+                .arg('--exec')
+                .arg('dbus-launch')
+                .arg('true');
+            await builder.exec(this.commandExecutor);
+        }
+        catch (error) {
+            this.appLogger?.warn('D-Bus initialization warning', { error });
+            output?.warning(`D-Bus initialization warning: ${error}`).flush();
+        }
+    }
+    /**
+     * 等待 Kubernetes Pods 就緒
+     */
+    async waitForPodsReady(instanceName, timeoutMs = index_1.TIMEOUTS.K8S_READY_TIMEOUT) {
+        return await this.microK8sService.waitForPodsReady(instanceName, timeoutMs);
+    }
+    /**
+     * 檢查 MicroK8s 是否正在執行
+     */
+    async isMicroK8sRunning(instanceName) {
+        return await this.microK8sService.isRunning(instanceName);
+    }
+    /**
+     * 等待 MicroK8s 停止
+     */
+    async waitForMicroK8sStop() {
+        return await this.microK8sService.waitForStop();
+    }
+    /**
+     * 儲存實例 metadata
+     */
+    saveMetadata(metadata, installPath) {
+        this.metadataPort.save(metadata, installPath);
+    }
+    /**
+     * 載入實例 metadata
+     */
+    loadMetadata(installPath) {
+        return this.metadataPort.load(installPath);
+    }
+    // ===========================================================================
+    // File Management Methods (原 WslFileManagerService)
+    // ===========================================================================
+    /**
+     * 移除實例儲存目錄
+     * @param instanceName 實例名稱（短名稱）
+     * @param output 輸出介面
+     */
+    async removeInstanceDirectory(instanceName, output) {
+        const installPath = this.namingService.getInstallPath(instanceName);
+        output?.item('arrow', `Removing data directory: ${installPath}`).flush();
+        try {
+            if (fs.existsSync(installPath)) {
+                fs.rmSync(installPath, { recursive: true, force: true });
+            }
+        }
+        catch (error) {
+            this.appLogger?.warn('Failed to remove directory', { installPath, error });
+            output?.warning(`Failed to remove directory: ${installPath}`).flush();
+            output?.warning(`Error: ${error}`).flush();
+            output?.warning(`Please manually delete the directory`).flush();
+        }
+    }
+    /**
+     * 取得目錄大小 (Bytes)
+     * @param dirPath 目錄路徑
+     * @returns 目錄大小 (Bytes)
+     */
+    async getDirectorySize(dirPath) {
+        try {
+            const builder = command_builder_1.CommandBuilder.create('powershell')
+                .arg('-NoProfile')
+                .arg('-Command')
+                .arg(`(Get-ChildItem -Path '${dirPath.replace(/'/g, "''")}' -Recurse -ErrorAction SilentlyContinue | Measure-Object -Property Length -Sum).Sum`);
+            const result = await builder.exec(this.commandExecutor);
+            if (result.exitCode !== 0)
+                return 0;
+            const size = parseInt(result.stdout.trim(), 10);
+            return isNaN(size) ? 0 : size;
+        }
+        catch {
+            return 0;
+        }
+    }
+    /**
+     * 格式化檔案大小為人類可讀格式
+     * @param bytes 位元組數
+     * @returns 格式化後的字串 (e.g., "1.5 GB")
+     */
+    formatSize(bytes) {
+        const gb = bytes / index_1.FILE_SIZE.GB;
+        if (gb >= 1) {
+            return `${gb.toFixed(1)} GB`;
+        }
+        const mb = bytes / index_1.FILE_SIZE.MB;
+        return `${mb.toFixed(1)} MB`;
+    }
+    // ===========================================================================
+    // System Check Methods (原 WslSystemCheckService)
+    // ===========================================================================
+    /**
+     * 檢查 WSL 是否已安裝
+     * @returns 是否已安裝
+     */
+    async checkWslInstalled() {
+        return await this.wslInfo.isWslInstalled();
+    }
+    /**
+     * 檢查 rootfs 檔案是否存在
+     * @param rootfsPath Rootfs 檔案路徑
+     * @returns 是否存在
+     */
+    checkRootfsExists(rootfsPath) {
+        return fs.existsSync(rootfsPath);
+    }
+    /**
+     * 檢查磁碟空間是否足夠
+     * @param requiredSpaceGB 所需空間 (GB)，預設 5 GB
+     * @returns 是否足夠
+     */
+    async checkDiskSpace(requiredSpaceGB = 5) {
+        const homeDir = os.homedir();
+        const driveLetter = homeDir.charAt(0);
+        try {
+            const builder = command_builder_1.CommandBuilder.create('powershell')
+                .powershell(`(Get-PSDrive ${driveLetter}).Free`);
+            const result = await builder.exec(this.commandExecutor);
+            const freeSpaceBytes = parseInt(result.stdout.trim(), 10);
+            if (isNaN(freeSpaceBytes)) {
+                return true;
+            }
+            const freeSpaceGB = freeSpaceBytes / index_1.FILE_SIZE.GB;
+            return freeSpaceGB >= requiredSpaceGB;
+        }
+        catch {
+            return true;
+        }
+    }
+};
+exports.WslInstanceLifecycleService = WslInstanceLifecycleService;
+exports.WslInstanceLifecycleService = WslInstanceLifecycleService = __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.Internal.IWslInstanceNaming)),
+    __param(2, (0, tsyringe_1.inject)(tokens_1.TOKENS.Internal.IWslInstanceInspection)),
+    __param(3, (0, tsyringe_1.inject)(tokens_1.TOKENS.Internal.IWslConfig)),
+    __param(4, (0, tsyringe_1.inject)(tokens_1.TOKENS.Internal.IMicroK8s)),
+    __param(5, (0, tsyringe_1.inject)(tokens_1.TOKENS.Internal.WslInfoService)),
+    __param(6, (0, tsyringe_1.inject)(tokens_1.TOKENS.IInstanceMetadataPort)),
+    __param(7, (0, tsyringe_1.inject)(tokens_1.TOKENS.ILoggerPort)),
+    __metadata("design:paramtypes", [Object, Object, Object, Object, Object, Object, Object, Object])
+], WslInstanceLifecycleService);
+//# sourceMappingURL=wsl-instance-lifecycle.service.js.map

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

@@ -0,0 +1,93 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WslInstanceNamingService = void 0;
+const tsyringe_1 = require("tsyringe");
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const index_1 = require("../../../../constants/index");
+const paths_1 = require("../../../../constants/paths");
+const instance_name_value_object_1 = require("../../../../domain/value-objects/instance-name.value-object");
+/**
+ * WSL 實例命名服務
+ *
+ * 負責實例名稱的驗證、轉換和路徑管理
+ */
+let WslInstanceNamingService = class WslInstanceNamingService {
+    /**
+     * 驗證實例名稱格式是否合法
+     * @param name 實例名稱
+     * @returns 是否合法 (委託給 Domain VO 驗證)
+     */
+    validateInstanceName(name) {
+        return instance_name_value_object_1.InstanceName.isValid(name);
+    }
+    /**
+     * 產生完整實例名稱 (加上 uofx- 前綴)
+     * @param name 顯示名稱
+     * @returns 完整實例名稱
+     */
+    getFullInstanceName(name) {
+        return `${index_1.INSTANCE_DEFAULTS.PREFIX}${name}`;
+    }
+    /**
+     * 取得標準安裝路徑
+     * @param instanceName 實例名稱
+     * @returns 安裝路徑 (~/.uofx/instances/{instanceName})
+     */
+    getInstallPath(instanceName) {
+        const homeDir = os.homedir();
+        return path.join(homeDir, paths_1.WINDOWS_PATHS.USER_CONFIG_DIR, 'instances', instanceName);
+    }
+    /**
+     * 取得預設 rootfs 路徑
+     * @returns 預設 rootfs 檔案路徑
+     */
+    getDefaultRootfsPath() {
+        const homeDir = os.homedir();
+        return path.join(homeDir, paths_1.WINDOWS_PATHS.USER_CONFIG_DIR, paths_1.WINDOWS_PATHS.DEFAULT_ROOTFS);
+    }
+};
+exports.WslInstanceNamingService = WslInstanceNamingService;
+exports.WslInstanceNamingService = WslInstanceNamingService = __decorate([
+    (0, tsyringe_1.injectable)()
+], WslInstanceNamingService);
+//# sourceMappingURL=wsl-instance-naming.service.js.map