@uofx/cli 1.0.0

package/dist/infrastructure/execution/command-builder.js

@@ -0,0 +1,252 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommandBuilder = void 0;
+/**
+ * 命令建構器 - 支援安全的命令建構與執行
+ *
+ * 特性:
+ * - 自動區分安全參數與敏感參數
+ * - 生成兩個版本: 實際執行命令 & 安全記錄命令
+ * - Fluent API 設計
+ *
+ * 注意：此類別用於非 DI 場景（如環境檢查服務）。
+ * 對於 WSL 實例內的命令執行，請使用 IExecutionEnvironmentFactory。
+ *
+ * @example
+ * // 基本使用
+ * const result = await CommandBuilder
+ *   .create('wsl')
+ *   .arg('--list')
+ *   .arg('--verbose')
+ *   .exec(commandExecutor);
+ *
+ * @example
+ * // PowerShell 命令
+ * const result = await CommandBuilder
+ *   .create('powershell')
+ *   .arg('-NoProfile')
+ *   .arg('-Command')
+ *   .arg('Get-Process')
+ *   .exec(commandExecutor);
+ */
+class CommandBuilder {
+    constructor() {
+        this.executable = '';
+        this.commandArgs = [];
+        this.isSensitiveInput = false;
+        this._inheritStdio = false;
+    }
+    // ========== 工廠方法 (Factory Methods) ==========
+    /**
+     * 建立一般命令
+     * @param executable 可執行檔名稱或路徑
+     * @returns CommandBuilder 實例
+     * @example CommandBuilder.create('wsl').arg('--list').arg('--verbose')
+     */
+    static create(executable) {
+        const builder = new CommandBuilder();
+        builder.executable = executable;
+        return builder;
+    }
+    // ========== 命令輔助方法 (Command Helper Methods) ==========
+    /**
+     * PowerShell 命令 (Windows 專用)
+     * @param command PowerShell 命令字串
+     * @returns this (支援方法鏈)
+     * @example CommandBuilder.create('powershell').powershell('Get-Process')
+     */
+    powershell(command) {
+        this.executable = 'powershell';
+        this.arg('-NoProfile');
+        this.arg('-NoLogo');
+        this.arg('-Command');
+        this.arg(command);
+        return this;
+    }
+    /**
+     * WSL 管理命令 (不包裝實例)
+     * @param subcommand WSL 子命令
+     * @returns this (支援方法鏈)
+     * @example CommandBuilder.create('wsl.exe').wslCmd('--list').arg('--verbose')
+     */
+    wslCmd(subcommand) {
+        // 使用 wsl.exe 而非 wsl，因為當 WSL 未安裝時 wsl 只是 stub
+        this.executable = 'wsl.exe';
+        this.arg(subcommand);
+        return this;
+    }
+    // ========== 參數方法 (Argument Methods) ==========
+    /**
+     * 新增一般參數 (安全，會被記錄)
+     * @param flag 參數名稱或值
+     * @param value 參數值 (可選)
+     * @returns this (支援方法鏈)
+     * @example .arg('--wait')
+     * @example .arg('--namespace', 'mssql')
+     */
+    arg(flag, value) {
+        if (value !== undefined) {
+            this.commandArgs.push({ type: 'safe', flag, value });
+        }
+        else {
+            this.commandArgs.push({ type: 'safe', value: flag });
+        }
+        return this;
+    }
+    /**
+     * 新增敏感參數 (會被遮罩)
+     * @param flag 參數名稱
+     * @param value 參數值 (含敏感資料)
+     * @returns this (支援方法鏈)
+     * @example .sensitiveArg('--set', `sa_password='${password}'`)
+     * @example .sensitiveArg('-P', password)
+     */
+    sensitiveArg(flag, value) {
+        this.commandArgs.push({ type: 'sensitive', flag, value });
+        return this;
+    }
+    /**
+     * 新增條件參數
+     * @param condition 條件判斷
+     * @param flag 參數名稱
+     * @param value 參數值 (可選)
+     * @returns this (支援方法鏈)
+     * @example .argIf(enableDebug, '--debug')
+     */
+    argIf(condition, flag, value) {
+        if (condition) {
+            this.arg(flag, value);
+        }
+        return this;
+    }
+    /**
+     * 新增多個參數
+     * @param values 參數值陣列
+     * @returns this (支援方法鏈)
+     * @example .args('--wait', '--timeout', '300s')
+     */
+    args(...values) {
+        values.forEach(v => this.arg(v));
+        return this;
+    }
+    // ========== 標準輸入方法 (Stdin Methods) ==========
+    /**
+     * 透過 stdin 傳入一般資料
+     * @param input stdin 輸入內容
+     * @returns this (支援方法鏈)
+     * @example .stdin(jsonContent)
+     */
+    stdin(input) {
+        this.stdinInput = input;
+        this.isSensitiveInput = false;
+        return this;
+    }
+    /**
+     * 透過 stdin 傳入敏感資料 (如密碼、keys)
+     * @param input stdin 輸入內容 (含敏感資料)
+     * @returns this (支援方法鏈)
+     * @example .sensitiveStdin(password)
+     */
+    sensitiveStdin(input) {
+        this.stdinInput = input;
+        this.isSensitiveInput = true;
+        return this;
+    }
+    /**
+     * 設定直接繼承終端的 stdio
+     * 用於需要終端訪問的命令（如 WSL 安裝）
+     * @returns this (支援方法鏈)
+     */
+    inheritStdio() {
+        this._inheritStdio = true;
+        return this;
+    }
+    // ========== 建構方法 (Build Methods) ==========
+    /**
+     * 建構實際執行的命令字串
+     * @returns 完整命令字串 (含敏感資料)
+     */
+    buildActual() {
+        return this.buildCommand(false);
+    }
+    /**
+     * 建構用於記錄的安全命令字串 (敏感參數已遮罩)
+     * @returns 安全命令字串 (敏感資料已遮罩為 ***REDACTED***)
+     */
+    buildSafe() {
+        let cmd = this.buildCommand(true);
+        if (this.isSensitiveInput) {
+            cmd += ' < [STDIN: ***REDACTED***]';
+        }
+        return cmd;
+    }
+    /**
+     * 內部方法：建構命令字串
+     * @param maskSensitive 是否遮罩敏感參數
+     * @returns 命令字串
+     */
+    buildCommand(maskSensitive) {
+        const parts = [this.executable];
+        for (const arg of this.commandArgs) {
+            if (arg.type === 'sensitive' && maskSensitive) {
+                // 遮罩敏感參數
+                if (arg.flag) {
+                    parts.push(`${arg.flag} ***REDACTED***`);
+                }
+                else {
+                    parts.push('***REDACTED***');
+                }
+            }
+            else {
+                // 正常輸出
+                if (arg.flag && arg.value !== undefined) {
+                    parts.push(`${arg.flag} ${arg.value}`);
+                }
+                else if (arg.value !== undefined) {
+                    parts.push(arg.value);
+                }
+            }
+        }
+        return parts.join(' ');
+    }
+    /**
+     * 取得 CommandExecutor 的執行選項
+     * @returns 包含 command, options, safeCommand 的物件
+     */
+    getExecutionOptions() {
+        return {
+            command: this.buildActual(),
+            options: {
+                shell: true,
+                ...(this.stdinInput && { input: this.stdinInput }),
+                ...(this._inheritStdio && { inheritStdio: true }),
+            },
+            safeCommand: this.buildSafe(),
+        };
+    }
+    // ========== 執行方法 (Execute Methods) ==========
+    /**
+     * 執行命令 (同步)
+     * @param executor CommandExecutor 實例
+     * @param showOutput 是否顯示輸出
+     * @param suppressStderr 是否隱藏 stderr
+     * @returns 命令執行結果
+     */
+    execSync(executor, showOutput = false, suppressStderr = false) {
+        const { command, options, safeCommand } = this.getExecutionOptions();
+        return executor.execSync(command, options, showOutput, suppressStderr, safeCommand);
+    }
+    /**
+     * 執行命令 (異步)
+     * @param executor CommandExecutor 實例
+     * @param onStdout stdout 回調函式
+     * @param onStderr stderr 回調函式
+     * @returns Promise<命令執行結果>
+     */
+    async exec(executor, onStdout, onStderr) {
+        const { command, options, safeCommand } = this.getExecutionOptions();
+        return executor.exec(command, onStdout, onStderr, options, safeCommand);
+    }
+}
+exports.CommandBuilder = CommandBuilder;
+//# sourceMappingURL=command-builder.js.map

package/dist/infrastructure/execution/command-executor.service.js

@@ -0,0 +1,230 @@
+"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.CommandExecutorService = void 0;
+const tsyringe_1 = require("tsyringe");
+const child_process_1 = require("child_process");
+const defaults_1 = require("../../constants/defaults");
+const sensitive_decorator_1 = require("../../domain/decorators/sensitive.decorator");
+/**
+ * 命令執行器服務
+ *
+ * 使用 Node.js child_process 模組實作 ICommandExecutor 介面,
+ * 提供真實的命令執行功能。支援同步和非同步執行、串流輸出、timeout 機制。
+ */
+let CommandExecutorService = class CommandExecutorService {
+    /**
+     * 同步執行命令
+     * @param command - 要執行的命令字串
+     * @param options - 執行選項（如 cwd, env, timeout）
+     * @param showOutput - 是否在 stdout 顯示輸出（預設：true）
+     * @param suppressStderr - 是否隱藏 stderr 輸出（預設：false）
+     * @param _safeCommandForLogging - 用於日誌記錄的安全命令字串（隱藏敏感資料）
+     * @returns 命令執行結果，包含 stdout, stderr 和 exitCode
+     * @throws 當命令執行嚴重失敗且無法捕捉時拋出 Error
+     */
+    execSync(command, options, _showOutput = true, suppressStderr = false, _safeCommandForLogging) {
+        // 處理 shell 選項
+        let shell;
+        if (options?.shell === true) {
+            shell = process.platform === 'win32' ? 'cmd.exe' : '/bin/sh';
+        }
+        else if (typeof options?.shell === 'string') {
+            shell = options.shell;
+        }
+        const execOptions = {
+            // encoding: 'buffer' 会導致 ERR_UNKNOWN_ENCODING，設為 undefined 則會返回 Buffer
+            encoding: undefined,
+            cwd: options?.cwd,
+            env: options?.env,
+            timeout: options?.timeout,
+            shell,
+            maxBuffer: defaults_1.FILE_SIZE.MAX_COMMAND_BUFFER,
+            input: options?.input,
+            // 總是 pipe stderr 以便正確解碼 UTF-16LE
+            stdio: suppressStderr ? ['pipe', 'pipe', 'ignore'] : ['pipe', 'pipe', 'pipe'],
+        };
+        try {
+            const stdoutBuffer = (0, child_process_1.execSync)(command, execOptions);
+            const stdout = this.decodeBuffer(stdoutBuffer);
+            return {
+                stdout,
+                stderr: '',
+                exitCode: 0,
+            };
+        }
+        catch (error) {
+            if (error && typeof error === 'object' && 'status' in error) {
+                const execError = error;
+                const stdout = this.decodeBuffer(execError.stdout);
+                const stderr = this.decodeBuffer(execError.stderr);
+                return {
+                    stdout,
+                    stderr: stderr,
+                    exitCode: execError.status ?? 1,
+                };
+            }
+            throw new Error(`Command execution failed: ${String(error)}`);
+        }
+    }
+    /**
+     * 非同步執行命令
+     * @param command - 要執行的命令字串
+     * @param onStdout - 標準輸出回調函式
+     * @param onStderr - 標準錯誤回調函式
+     * @param options - 執行選項（如 cwd, env, timeout）
+     * @param _safeCommandForLogging - 用於日誌記錄的安全命令字串（隱藏敏感資料）
+     * @returns 解析為命令執行結果的 Promise
+     */
+    async exec(command, onStdout, onStderr, options, _safeCommandForLogging) {
+        return new Promise((resolve, reject) => {
+            const encoding = options?.encoding ?? 'utf8';
+            // 預設 shell 為 true 以支援命令字串
+            let shell = true;
+            if (options?.shell === false) {
+                shell = false;
+            }
+            else if (typeof options?.shell === 'string') {
+                shell = options.shell;
+            }
+            // 如果需要繼承 stdio（用於 WSL 安裝等需要終端訪問的命令）
+            if (options?.inheritStdio) {
+                const spawnOptions = {
+                    cwd: options?.cwd,
+                    env: options?.env,
+                    shell,
+                    stdio: 'inherit',
+                };
+                const childProcess = (0, child_process_1.spawn)(command, [], spawnOptions);
+                childProcess.on('close', (code) => {
+                    resolve({
+                        stdout: '',
+                        stderr: '',
+                        exitCode: code ?? 0,
+                    });
+                });
+                childProcess.on('error', (error) => {
+                    reject(new Error(`Failed to execute command: ${error.message}`));
+                });
+                return;
+            }
+            const spawnOptions = {
+                cwd: options?.cwd,
+                env: options?.env,
+                shell,
+                encoding,
+            };
+            const childProcess = (0, child_process_1.spawn)(command, [], spawnOptions);
+            if (options?.input && childProcess.stdin) {
+                childProcess.stdin.write(options.input);
+                childProcess.stdin.end();
+            }
+            // 累積輸出 Buffer
+            const stdoutChunks = [];
+            const stderrChunks = [];
+            // 監聽標準輸出
+            if (childProcess.stdout) {
+                childProcess.stdout.on('data', (data) => {
+                    stdoutChunks.push(data);
+                    if (onStdout) {
+                        onStdout(this.decodeBuffer(data));
+                    }
+                });
+            }
+            // 監聽標準錯誤輸出
+            if (childProcess.stderr) {
+                childProcess.stderr.on('data', (data) => {
+                    stderrChunks.push(data);
+                    if (onStderr) {
+                        onStderr(this.decodeBuffer(data));
+                    }
+                });
+            }
+            // 設定 timeout (如果有指定)
+            let timeoutId;
+            if (options?.timeout) {
+                timeoutId = setTimeout(() => {
+                    childProcess.kill('SIGTERM');
+                    reject(new Error(`Command timed out after ${options.timeout}ms`));
+                }, options.timeout);
+            }
+            // 監聽進程結束
+            childProcess.on('close', (code) => {
+                if (timeoutId) {
+                    clearTimeout(timeoutId);
+                }
+                const stdoutBuffer = Buffer.concat(stdoutChunks);
+                const stderrBuffer = Buffer.concat(stderrChunks);
+                resolve({
+                    stdout: this.decodeBuffer(stdoutBuffer),
+                    stderr: this.decodeBuffer(stderrBuffer),
+                    exitCode: code ?? 0,
+                });
+            });
+            childProcess.on('error', (error) => {
+                if (timeoutId) {
+                    clearTimeout(timeoutId);
+                }
+                reject(new Error(`Failed to execute command: ${error.message}`));
+            });
+        });
+    }
+    /**
+     * 解碼 Buffer
+     * 嘗試偵測 UTF-16 LE (常見於 Windows/WSL 輸出)，否則使用 UTF-8
+     */
+    decodeBuffer(buffer) {
+        if (!buffer)
+            return '';
+        if (typeof buffer === 'string')
+            return buffer;
+        if (buffer.length === 0)
+            return '';
+        // 1. 檢查 UTF-16LE BOM (FF FE)
+        if (buffer.length >= 2 && buffer[0] === 0xFF && buffer[1] === 0xFE) {
+            return buffer.toString('utf16le');
+        }
+        // 2. 檢查是否為 UTF-16LE (無 BOM)
+        // WSL 輸出通常沒有 BOM,但使用 UTF-16LE 編碼
+        const sample = buffer.subarray(0, Math.min(buffer.length, 200));
+        let nullCount = 0;
+        for (let i = 0; i < sample.length; i++) {
+            if (sample[i] === 0)
+                nullCount++;
+        }
+        // 如果 null bytes 超過 20%,很可能是 UTF-16LE
+        if (nullCount > sample.length * 0.2) {
+            return buffer.toString('utf16le');
+        }
+        // 3. 預設使用 UTF-8
+        return buffer.toString('utf8');
+    }
+};
+exports.CommandExecutorService = CommandExecutorService;
+__decorate([
+    __param(1, (0, sensitive_decorator_1.Sensitive)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Object, Boolean, Boolean, String]),
+    __metadata("design:returntype", Object)
+], CommandExecutorService.prototype, "execSync", null);
+__decorate([
+    __param(3, (0, sensitive_decorator_1.Sensitive)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [String, Function, Function, Object, String]),
+    __metadata("design:returntype", Promise)
+], CommandExecutorService.prototype, "exec", null);
+exports.CommandExecutorService = CommandExecutorService = __decorate([
+    (0, tsyringe_1.injectable)()
+], CommandExecutorService);
+//# sourceMappingURL=command-executor.service.js.map

package/dist/infrastructure/execution/environments/wsl-execution.environment.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WslExecutionEnvironment = void 0;
+const execution_environment_interface_1 = require("../interfaces/execution-environment.interface");
+const wsl_command_builder_1 = require("../builders/wsl-command.builder");
+const paths_1 = require("../../../constants/paths");
+/**
+ * WSL 執行環境
+ *
+ * 提供在 WSL 實例內執行命令的能力
+ */
+class WslExecutionEnvironment {
+    constructor(identifier, commandExecutor) {
+        this.identifier = identifier;
+        this.commandExecutor = commandExecutor;
+        this.type = execution_environment_interface_1.EXECUTION_ENVIRONMENT_TYPES.WSL;
+    }
+    helm(subcommand) {
+        const builder = new wsl_command_builder_1.WslCommandBuilder(this.identifier, this.commandExecutor);
+        builder.setExecutable(paths_1.LINUX_PATHS.MICROK8S_HELM);
+        builder.arg(subcommand);
+        return builder;
+    }
+    kubectl(subcommand) {
+        const builder = new wsl_command_builder_1.WslCommandBuilder(this.identifier, this.commandExecutor);
+        builder.setExecutable(paths_1.LINUX_PATHS.KUBECTL_BIN);
+        builder.arg(subcommand);
+        return builder;
+    }
+    /**
+     * 執行 shell 命令
+     * @param command 可執行檔名稱（如 'mkdir', 'cat', 'chmod'）
+     * @returns 命令建構器，可用 .arg() 添加參數
+     * @example env.shell('mkdir').arg('-p').arg('/var/data')
+     * @example env.shell('cat').arg('/proc/uptime')
+     */
+    shell(command) {
+        const builder = new wsl_command_builder_1.WslCommandBuilder(this.identifier, this.commandExecutor);
+        builder.setExecutable(command);
+        return builder;
+    }
+    /**
+     * 執行 shell 腳本（支援重定向、管道等 shell 特性）
+     * @param script 完整的 shell 腳本字串
+     * @returns 命令建構器
+     * @example env.shellScript('cat > /tmp/file').stdin(content)
+     * @example env.shellScript('echo $HOME | grep user')
+     */
+    shellScript(script) {
+        const builder = new wsl_command_builder_1.WslCommandBuilder(this.identifier, this.commandExecutor);
+        builder.setExecutable('sh');
+        builder.arg('-c');
+        builder.arg(`"${script}"`);
+        return builder;
+    }
+    async isAvailable() {
+        try {
+            const builder = new wsl_command_builder_1.WslCommandBuilder(this.identifier, this.commandExecutor);
+            builder.setExecutable('echo');
+            builder.arg('ok');
+            const result = await builder.exec();
+            return result.exitCode === 0;
+        }
+        catch {
+            return false;
+        }
+    }
+}
+exports.WslExecutionEnvironment = WslExecutionEnvironment;
+//# sourceMappingURL=wsl-execution.environment.js.map

package/dist/infrastructure/execution/execution-environment.factory.js

@@ -0,0 +1,53 @@
+"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.ExecutionEnvironmentFactory = void 0;
+const tsyringe_1 = require("tsyringe");
+const tokens_1 = require("../../di/tokens");
+const wsl_execution_environment_1 = require("./environments/wsl-execution.environment");
+/**
+ * 執行環境工廠
+ *
+ * 提供建立執行環境的工廠方法
+ */
+let ExecutionEnvironmentFactory = class ExecutionEnvironmentFactory {
+    constructor(commandExecutor, hostCommandBuilder) {
+        this.commandExecutor = commandExecutor;
+        this.hostCommandBuilder = hostCommandBuilder;
+    }
+    /**
+     * 取得指定實例的執行環境
+     * @param instanceName 實例名稱
+     * @returns 執行環境實例
+     */
+    getForInstance(instanceName) {
+        // 目前只有 WSL 實作，未來可根據 Instance 元資料決定使用哪種執行環境
+        return new wsl_execution_environment_1.WslExecutionEnvironment(instanceName, this.commandExecutor);
+    }
+    /**
+     * 取得主機命令建構器
+     * @returns 主機命令建構器（根據平台返回對應實作，透過 DI 注入）
+     */
+    getHostEnvironment() {
+        return this.hostCommandBuilder;
+    }
+};
+exports.ExecutionEnvironmentFactory = ExecutionEnvironmentFactory;
+exports.ExecutionEnvironmentFactory = ExecutionEnvironmentFactory = __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.IHostCommandBuilder)),
+    __metadata("design:paramtypes", [Object, Object])
+], ExecutionEnvironmentFactory);
+//# sourceMappingURL=execution-environment.factory.js.map

package/dist/infrastructure/execution/index.js

@@ -0,0 +1,25 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./command-executor.service"), exports);
+__exportStar(require("./script-executor.service"), exports);
+__exportStar(require("./execution-environment.factory"), exports);
+__exportStar(require("./builders/base-command.builder"), exports);
+__exportStar(require("./builders/host-command.builder"), exports);
+__exportStar(require("./builders/windows-host-command.builder"), exports);
+__exportStar(require("./builders/wsl-command.builder"), exports);
+__exportStar(require("./environments/wsl-execution.environment"), exports);
+//# sourceMappingURL=index.js.map

package/dist/infrastructure/execution/interfaces/command-builder.interface.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=command-builder.interface.js.map

package/dist/infrastructure/execution/interfaces/command-executor.interface.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=command-executor.interface.js.map

package/dist/infrastructure/execution/interfaces/execution-environment-factory.interface.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=execution-environment-factory.interface.js.map

package/dist/infrastructure/execution/interfaces/execution-environment.interface.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EXECUTION_ENVIRONMENT_TYPES = void 0;
+// 重新匯出類型供外部使用
+var environments_1 = require("../../../constants/environments");
+Object.defineProperty(exports, "EXECUTION_ENVIRONMENT_TYPES", { enumerable: true, get: function () { return environments_1.EXECUTION_ENVIRONMENT_TYPES; } });
+//# sourceMappingURL=execution-environment.interface.js.map

package/dist/infrastructure/execution/interfaces/host-command-builder.interface.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=host-command-builder.interface.js.map

package/dist/infrastructure/execution/interfaces/index.js

@@ -0,0 +1,23 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./command-executor.interface"), exports);
+__exportStar(require("./script-executor.interface"), exports);
+__exportStar(require("./command-builder.interface"), exports);
+__exportStar(require("./execution-environment.interface"), exports);
+__exportStar(require("./host-command-builder.interface"), exports);
+__exportStar(require("./execution-environment-factory.interface"), exports);
+//# sourceMappingURL=index.js.map