@uipath/project-packager 1.1.4

package/dist/node.js

@@ -0,0 +1,915 @@
+import { I18nManager, LogLevel, LogMessage, NugetPackager, Path, ProjectTypes, TemporaryStorageService, ToolErrorCodes, ToolResult, ZipService, toolsFactoryRepository, translate } from "@uipath/solutionpackager-tool-core";
+import { ConsoleTelemetryProvider, NodeContextStorage, TelemetryService } from "@uipath/telemetry/node";
+import { execSync, spawn } from "node:child_process";
+import { NodeFileSystem } from "@uipath/filesystem";
+var de_namespaceObject = JSON.parse('{"solutionpackager":{"projectLoader":{"errors":{"pathRequired":"Project directory path is required","noProjectFile":"No {projectFile} or {manifestFile} found in directory: {path}","readFailed":"Failed to read project file: {path}","invalidProject":"Invalid project file: {path}. Missing ProjectType field."}},"validator":{"errors":{"destinationNotDefined":"Destination path is not defined","governanceRequired":"Governance file path is required when governance file type is not Default","governanceFileInfo":"Unable to get file information: {path}","governanceInvalidFile":"Governance file path is not a valid file: {path}"}},"packager":{"errors":{"failedToGetStreams":"Cannot get package streams from failed result. Error code: {errorCode}, message: {message}","failedToReadPackage":"Failed to read package file: {path}"}},"signing":{"errors":{"dotnetNotAvailable":"dotnet CLI is not available. Package signing requires dotnet CLI to be installed."},"info":{"dotnetNotAvailable":"dotnet CLI is not available. Cannot sign package."}}}}');
+const en = {
+    solutionpackager: {
+        projectLoader: {
+            errors: {
+                pathRequired: "Project directory path is required",
+                noProjectFile: "No {projectFile} or {manifestFile} found in directory: {path}",
+                readFailed: "Failed to read project file: {path}",
+                invalidProject: "Invalid project file: {path}. Missing ProjectType field."
+            }
+        },
+        validator: {
+            errors: {
+                destinationNotDefined: "Destination path is not defined",
+                governanceRequired: "Governance file path is required when governance file type is not Default",
+                governanceFileInfo: "Unable to get file information: {path}",
+                governanceInvalidFile: "Governance file path is not a valid file: {path}"
+            }
+        },
+        packager: {
+            errors: {
+                failedToGetStreams: "Cannot get package streams from failed result. Error code: {errorCode}, message: {message}",
+                failedToReadPackage: "Failed to read package file: {path}"
+            }
+        },
+        signing: {
+            errors: {
+                dotnetNotAvailable: "dotnet CLI is not available. Package signing requires dotnet CLI to be installed."
+            },
+            info: {
+                dotnetNotAvailable: "dotnet CLI is not available. Cannot sign package."
+            }
+        }
+    }
+};
+var es_namespaceObject = JSON.parse('{"solutionpackager":{"projectLoader":{"errors":{"pathRequired":"Project directory path is required","noProjectFile":"No {projectFile} or {manifestFile} found in directory: {path}","readFailed":"Failed to read project file: {path}","invalidProject":"Invalid project file: {path}. Missing ProjectType field."}},"validator":{"errors":{"destinationNotDefined":"Destination path is not defined","governanceRequired":"Governance file path is required when governance file type is not Default","governanceFileInfo":"Unable to get file information: {path}","governanceInvalidFile":"Governance file path is not a valid file: {path}"}},"packager":{"errors":{"failedToGetStreams":"Cannot get package streams from failed result. Error code: {errorCode}, message: {message}","failedToReadPackage":"Failed to read package file: {path}"}},"signing":{"errors":{"dotnetNotAvailable":"dotnet CLI is not available. Package signing requires dotnet CLI to be installed."},"info":{"dotnetNotAvailable":"dotnet CLI is not available. Cannot sign package."}}}}');
+var es_MX_namespaceObject = JSON.parse('{"solutionpackager":{"projectLoader":{"errors":{"pathRequired":"Project directory path is required","noProjectFile":"No {projectFile} or {manifestFile} found in directory: {path}","readFailed":"Failed to read project file: {path}","invalidProject":"Invalid project file: {path}. Missing ProjectType field."}},"validator":{"errors":{"destinationNotDefined":"Destination path is not defined","governanceRequired":"Governance file path is required when governance file type is not Default","governanceFileInfo":"Unable to get file information: {path}","governanceInvalidFile":"Governance file path is not a valid file: {path}"}},"packager":{"errors":{"failedToGetStreams":"Cannot get package streams from failed result. Error code: {errorCode}, message: {message}","failedToReadPackage":"Failed to read package file: {path}"}},"signing":{"errors":{"dotnetNotAvailable":"dotnet CLI is not available. Package signing requires dotnet CLI to be installed."},"info":{"dotnetNotAvailable":"dotnet CLI is not available. Cannot sign package."}}}}');
+var fr_namespaceObject = JSON.parse('{"solutionpackager":{"projectLoader":{"errors":{"pathRequired":"Project directory path is required","noProjectFile":"No {projectFile} or {manifestFile} found in directory: {path}","readFailed":"Failed to read project file: {path}","invalidProject":"Invalid project file: {path}. Missing ProjectType field."}},"validator":{"errors":{"destinationNotDefined":"Destination path is not defined","governanceRequired":"Governance file path is required when governance file type is not Default","governanceFileInfo":"Unable to get file information: {path}","governanceInvalidFile":"Governance file path is not a valid file: {path}"}},"packager":{"errors":{"failedToGetStreams":"Cannot get package streams from failed result. Error code: {errorCode}, message: {message}","failedToReadPackage":"Failed to read package file: {path}"}},"signing":{"errors":{"dotnetNotAvailable":"dotnet CLI is not available. Package signing requires dotnet CLI to be installed."},"info":{"dotnetNotAvailable":"dotnet CLI is not available. Cannot sign package."}}}}');
+var ja_namespaceObject = JSON.parse('{"solutionpackager":{"projectLoader":{"errors":{"pathRequired":"Project directory path is required","noProjectFile":"No {projectFile} or {manifestFile} found in directory: {path}","readFailed":"Failed to read project file: {path}","invalidProject":"Invalid project file: {path}. Missing ProjectType field."}},"validator":{"errors":{"destinationNotDefined":"Destination path is not defined","governanceRequired":"Governance file path is required when governance file type is not Default","governanceFileInfo":"Unable to get file information: {path}","governanceInvalidFile":"Governance file path is not a valid file: {path}"}},"packager":{"errors":{"failedToGetStreams":"Cannot get package streams from failed result. Error code: {errorCode}, message: {message}","failedToReadPackage":"Failed to read package file: {path}"}},"signing":{"errors":{"dotnetNotAvailable":"dotnet CLI is not available. Package signing requires dotnet CLI to be installed."},"info":{"dotnetNotAvailable":"dotnet CLI is not available. Cannot sign package."}}}}');
+var ko_namespaceObject = JSON.parse('{"solutionpackager":{"projectLoader":{"errors":{"pathRequired":"Project directory path is required","noProjectFile":"No {projectFile} or {manifestFile} found in directory: {path}","readFailed":"Failed to read project file: {path}","invalidProject":"Invalid project file: {path}. Missing ProjectType field."}},"validator":{"errors":{"destinationNotDefined":"Destination path is not defined","governanceRequired":"Governance file path is required when governance file type is not Default","governanceFileInfo":"Unable to get file information: {path}","governanceInvalidFile":"Governance file path is not a valid file: {path}"}},"packager":{"errors":{"failedToGetStreams":"Cannot get package streams from failed result. Error code: {errorCode}, message: {message}","failedToReadPackage":"Failed to read package file: {path}"}},"signing":{"errors":{"dotnetNotAvailable":"dotnet CLI is not available. Package signing requires dotnet CLI to be installed."},"info":{"dotnetNotAvailable":"dotnet CLI is not available. Cannot sign package."}}}}');
+var pt_namespaceObject = JSON.parse('{"solutionpackager":{"projectLoader":{"errors":{"pathRequired":"Project directory path is required","noProjectFile":"No {projectFile} or {manifestFile} found in directory: {path}","readFailed":"Failed to read project file: {path}","invalidProject":"Invalid project file: {path}. Missing ProjectType field."}},"validator":{"errors":{"destinationNotDefined":"Destination path is not defined","governanceRequired":"Governance file path is required when governance file type is not Default","governanceFileInfo":"Unable to get file information: {path}","governanceInvalidFile":"Governance file path is not a valid file: {path}"}},"packager":{"errors":{"failedToGetStreams":"Cannot get package streams from failed result. Error code: {errorCode}, message: {message}","failedToReadPackage":"Failed to read package file: {path}"}},"signing":{"errors":{"dotnetNotAvailable":"dotnet CLI is not available. Package signing requires dotnet CLI to be installed."},"info":{"dotnetNotAvailable":"dotnet CLI is not available. Cannot sign package."}}}}');
+var pt_BR_namespaceObject = JSON.parse('{"solutionpackager":{"projectLoader":{"errors":{"pathRequired":"Project directory path is required","noProjectFile":"No {projectFile} or {manifestFile} found in directory: {path}","readFailed":"Failed to read project file: {path}","invalidProject":"Invalid project file: {path}. Missing ProjectType field."}},"validator":{"errors":{"destinationNotDefined":"Destination path is not defined","governanceRequired":"Governance file path is required when governance file type is not Default","governanceFileInfo":"Unable to get file information: {path}","governanceInvalidFile":"Governance file path is not a valid file: {path}"}},"packager":{"errors":{"failedToGetStreams":"Cannot get package streams from failed result. Error code: {errorCode}, message: {message}","failedToReadPackage":"Failed to read package file: {path}"}},"signing":{"errors":{"dotnetNotAvailable":"dotnet CLI is not available. Package signing requires dotnet CLI to be installed."},"info":{"dotnetNotAvailable":"dotnet CLI is not available. Cannot sign package."}}}}');
+var ro_namespaceObject = JSON.parse('{"solutionpackager":{"projectLoader":{"errors":{"pathRequired":"Project directory path is required","noProjectFile":"No {projectFile} or {manifestFile} found in directory: {path}","readFailed":"Failed to read project file: {path}","invalidProject":"Invalid project file: {path}. Missing ProjectType field."}},"validator":{"errors":{"destinationNotDefined":"Destination path is not defined","governanceRequired":"Governance file path is required when governance file type is not Default","governanceFileInfo":"Unable to get file information: {path}","governanceInvalidFile":"Governance file path is not a valid file: {path}"}},"packager":{"errors":{"failedToGetStreams":"Cannot get package streams from failed result. Error code: {errorCode}, message: {message}","failedToReadPackage":"Failed to read package file: {path}"}},"signing":{"errors":{"dotnetNotAvailable":"dotnet CLI is not available. Package signing requires dotnet CLI to be installed."},"info":{"dotnetNotAvailable":"dotnet CLI is not available. Cannot sign package."}}}}');
+var ru_namespaceObject = JSON.parse('{"solutionpackager":{"projectLoader":{"errors":{"pathRequired":"Project directory path is required","noProjectFile":"No {projectFile} or {manifestFile} found in directory: {path}","readFailed":"Failed to read project file: {path}","invalidProject":"Invalid project file: {path}. Missing ProjectType field."}},"validator":{"errors":{"destinationNotDefined":"Destination path is not defined","governanceRequired":"Governance file path is required when governance file type is not Default","governanceFileInfo":"Unable to get file information: {path}","governanceInvalidFile":"Governance file path is not a valid file: {path}"}},"packager":{"errors":{"failedToGetStreams":"Cannot get package streams from failed result. Error code: {errorCode}, message: {message}","failedToReadPackage":"Failed to read package file: {path}"}},"signing":{"errors":{"dotnetNotAvailable":"dotnet CLI is not available. Package signing requires dotnet CLI to be installed."},"info":{"dotnetNotAvailable":"dotnet CLI is not available. Cannot sign package."}}}}');
+var tr_namespaceObject = JSON.parse('{"solutionpackager":{"projectLoader":{"errors":{"pathRequired":"Project directory path is required","noProjectFile":"No {projectFile} or {manifestFile} found in directory: {path}","readFailed":"Failed to read project file: {path}","invalidProject":"Invalid project file: {path}. Missing ProjectType field."}},"validator":{"errors":{"destinationNotDefined":"Destination path is not defined","governanceRequired":"Governance file path is required when governance file type is not Default","governanceFileInfo":"Unable to get file information: {path}","governanceInvalidFile":"Governance file path is not a valid file: {path}"}},"packager":{"errors":{"failedToGetStreams":"Cannot get package streams from failed result. Error code: {errorCode}, message: {message}","failedToReadPackage":"Failed to read package file: {path}"}},"signing":{"errors":{"dotnetNotAvailable":"dotnet CLI is not available. Package signing requires dotnet CLI to be installed."},"info":{"dotnetNotAvailable":"dotnet CLI is not available. Cannot sign package."}}}}');
+var zh_CN_namespaceObject = JSON.parse('{"solutionpackager":{"projectLoader":{"errors":{"pathRequired":"Project directory path is required","noProjectFile":"No {projectFile} or {manifestFile} found in directory: {path}","readFailed":"Failed to read project file: {path}","invalidProject":"Invalid project file: {path}. Missing ProjectType field."}},"validator":{"errors":{"destinationNotDefined":"Destination path is not defined","governanceRequired":"Governance file path is required when governance file type is not Default","governanceFileInfo":"Unable to get file information: {path}","governanceInvalidFile":"Governance file path is not a valid file: {path}"}},"packager":{"errors":{"failedToGetStreams":"Cannot get package streams from failed result. Error code: {errorCode}, message: {message}","failedToReadPackage":"Failed to read package file: {path}"}},"signing":{"errors":{"dotnetNotAvailable":"dotnet CLI is not available. Package signing requires dotnet CLI to be installed."},"info":{"dotnetNotAvailable":"dotnet CLI is not available. Cannot sign package."}}}}');
+var zh_TW_namespaceObject = JSON.parse('{"solutionpackager":{"projectLoader":{"errors":{"pathRequired":"Project directory path is required","noProjectFile":"No {projectFile} or {manifestFile} found in directory: {path}","readFailed":"Failed to read project file: {path}","invalidProject":"Invalid project file: {path}. Missing ProjectType field."}},"validator":{"errors":{"destinationNotDefined":"Destination path is not defined","governanceRequired":"Governance file path is required when governance file type is not Default","governanceFileInfo":"Unable to get file information: {path}","governanceInvalidFile":"Governance file path is not a valid file: {path}"}},"packager":{"errors":{"failedToGetStreams":"Cannot get package streams from failed result. Error code: {errorCode}, message: {message}","failedToReadPackage":"Failed to read package file: {path}"}},"signing":{"errors":{"dotnetNotAvailable":"dotnet CLI is not available. Package signing requires dotnet CLI to be installed."},"info":{"dotnetNotAvailable":"dotnet CLI is not available. Cannot sign package."}}}}');
+var zu_namespaceObject = JSON.parse('{"solutionpackager":{"projectLoader":{"errors":{"pathRequired":"Project directory path is required","noProjectFile":"No {projectFile} or {manifestFile} found in directory: {path}","readFailed":"Failed to read project file: {path}","invalidProject":"Invalid project file: {path}. Missing ProjectType field."}},"validator":{"errors":{"destinationNotDefined":"Destination path is not defined","governanceRequired":"Governance file path is required when governance file type is not Default","governanceFileInfo":"Unable to get file information: {path}","governanceInvalidFile":"Governance file path is not a valid file: {path}"}},"packager":{"errors":{"failedToGetStreams":"Cannot get package streams from failed result. Error code: {errorCode}, message: {message}","failedToReadPackage":"Failed to read package file: {path}"}},"signing":{"errors":{"dotnetNotAvailable":"dotnet CLI is not available. Package signing requires dotnet CLI to be installed."},"info":{"dotnetNotAvailable":"dotnet CLI is not available. Cannot sign package."}}}}');
+I18nManager.registerTranslations("en", en);
+I18nManager.registerTranslations("de", de_namespaceObject);
+I18nManager.registerTranslations("es", es_namespaceObject);
+I18nManager.registerTranslations("es-MX", es_MX_namespaceObject);
+I18nManager.registerTranslations("fr", fr_namespaceObject);
+I18nManager.registerTranslations("ja", ja_namespaceObject);
+I18nManager.registerTranslations("ko", ko_namespaceObject);
+I18nManager.registerTranslations("pt", pt_namespaceObject);
+I18nManager.registerTranslations("pt-BR", pt_BR_namespaceObject);
+I18nManager.registerTranslations("ro", ro_namespaceObject);
+I18nManager.registerTranslations("ru", ru_namespaceObject);
+I18nManager.registerTranslations("tr", tr_namespaceObject);
+I18nManager.registerTranslations("zh-CN", zh_CN_namespaceObject);
+I18nManager.registerTranslations("zh-TW", zh_TW_namespaceObject);
+I18nManager.registerTranslations("zu", zu_namespaceObject);
+function _define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+let globalLogHandler = (logMessage)=>{
+    const formattedMessage = logMessage.toFormattedString();
+    switch(logMessage.logLevel){
+        case LogLevel.Debug:
+            console.debug(formattedMessage);
+            break;
+        case LogLevel.Info:
+            console.info(formattedMessage);
+            break;
+        case LogLevel.Warn:
+            console.warn(formattedMessage);
+            break;
+        case LogLevel.Error:
+            console.error(formattedMessage);
+            break;
+    }
+};
+function setGlobalLogHandler(handler) {
+    globalLogHandler = handler;
+}
+class ToolLogger {
+    debug(message, options) {
+        const logMessage = new LogMessage(message, LogLevel.Debug, {
+            source: this.source,
+            sourceTarget: this.sourceTarget,
+            ...options
+        });
+        globalLogHandler(logMessage);
+    }
+    info(message, options) {
+        const logMessage = new LogMessage(message, LogLevel.Info, {
+            source: this.source,
+            sourceTarget: this.sourceTarget,
+            ...options
+        });
+        globalLogHandler(logMessage);
+    }
+    warn(message, options) {
+        const logMessage = new LogMessage(message, LogLevel.Warn, {
+            source: this.source,
+            sourceTarget: this.sourceTarget,
+            ...options
+        });
+        globalLogHandler(logMessage);
+    }
+    error(message, options) {
+        const logMessage = new LogMessage(message, LogLevel.Error, {
+            source: this.source,
+            sourceTarget: this.sourceTarget,
+            ...options
+        });
+        globalLogHandler(logMessage);
+    }
+    progress(message, options) {
+        const logMessage = new LogMessage(message, LogLevel.Info, {
+            source: this.source,
+            sourceTarget: this.sourceTarget,
+            ...options
+        });
+        globalLogHandler(logMessage);
+    }
+    log(message, logLevel, options) {
+        const logMessage = new LogMessage(message, logLevel, {
+            source: this.source,
+            sourceTarget: this.sourceTarget,
+            ...options
+        });
+        globalLogHandler(logMessage);
+    }
+    logMessage(message) {
+        globalLogHandler(message);
+    }
+    constructor(source, sourceTarget){
+        _define_property(this, "source", void 0);
+        _define_property(this, "sourceTarget", void 0);
+        this.source = source;
+        this.sourceTarget = sourceTarget;
+    }
+}
+class BaseNodePackagerFactory {
+    getOrCreateFileSystem(config) {
+        return config?.fileSystem ?? new NodeFileSystem();
+    }
+    getOrCreateTelemetryService(config) {
+        if (config?.telemetryService) return config.telemetryService;
+        const provider = new ConsoleTelemetryProvider();
+        const contextStorage = new NodeContextStorage();
+        return new TelemetryService(provider, contextStorage);
+    }
+    checkDotnetAvailability(logger) {
+        logger.info("Checking for dotnet CLI availability...");
+        try {
+            execSync("dotnet --version", {
+                stdio: [
+                    "ignore",
+                    "pipe",
+                    "ignore"
+                ]
+            });
+            logger.info("dotnet CLI is available.");
+        } catch  {
+            logger.error("dotnet CLI is not available. Workflow compiler functionality and package signing will not be available.");
+        }
+    }
+    configureLogHandler(config) {
+        if (config?.logHandler) setGlobalLogHandler(config.logHandler);
+    }
+    configureLanguage(config) {
+        const language = config?.language ?? "en";
+        translate.setLocale(language);
+    }
+}
+function packager_parameters_define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+var packager_parameters_RulesConfigFileType = /*#__PURE__*/ function(RulesConfigFileType) {
+    RulesConfigFileType["Default"] = "Default";
+    RulesConfigFileType["AutomationOps"] = "AutomationOps";
+    RulesConfigFileType["Studio"] = "Studio";
+    return RulesConfigFileType;
+}({});
+class PackagerParameters {
+    constructor(){
+        packager_parameters_define_property(this, "inputPath", void 0);
+        packager_parameters_define_property(this, "logLevel", LogLevel.Warn);
+        packager_parameters_define_property(this, "outputPath", void 0);
+        packager_parameters_define_property(this, "targetFramework", void 0);
+        packager_parameters_define_property(this, "excludeConfiguredSources", false);
+        packager_parameters_define_property(this, "nuGetSourcesConfigPath", void 0);
+        packager_parameters_define_property(this, "detailedLogPath", void 0);
+        packager_parameters_define_property(this, "connection", void 0);
+    }
+}
+class ProjectRestoreOptions extends PackagerParameters {
+}
+function project_validate_options_define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+class ProjectValidateOptions extends ProjectRestoreOptions {
+    constructor(...args){
+        super(...args), project_validate_options_define_property(this, "validateOptions", {
+            skipAnalyze: false,
+            governanceFileType: packager_parameters_RulesConfigFileType.Default
+        });
+    }
+}
+class ProjectBuildOptions extends ProjectValidateOptions {
+}
+function project_pack_options_define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+class ProjectPackOptions extends ProjectBuildOptions {
+    constructor(...args){
+        super(...args), project_pack_options_define_property(this, "destinationPath", void 0), project_pack_options_define_property(this, "package", void 0), project_pack_options_define_property(this, "signingInfo", void 0), project_pack_options_define_property(this, "packOptions", void 0);
+    }
+}
+function package_sign_service_define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+class NodePackageSignService {
+    async signPackageAsync(packagePath, certificatePath, certificatePassword, timestampServer) {
+        if (!this.checkAvailable()) {
+            this.logger.error(translate.t("solutionpackager.signing.info.dotnetNotAvailable"));
+            return ToolResult.error(ToolErrorCodes.InternalError, translate.t("solutionpackager.signing.errors.dotnetNotAvailable"));
+        }
+        const args = [
+            "nuget",
+            "sign",
+            packagePath,
+            "--certificate-path",
+            certificatePath,
+            "--overwrite"
+        ];
+        if (certificatePassword) args.push("--certificate-password", certificatePassword);
+        if (timestampServer) args.push("--timestamper", timestampServer);
+        return new Promise((resolve)=>{
+            const childProcess = spawn("dotnet", args, {
+                stdio: [
+                    "ignore",
+                    "pipe",
+                    "pipe"
+                ],
+                shell: false,
+                windowsHide: true
+            });
+            let stderr = "";
+            childProcess.stdout?.on("data", (data)=>{
+                this.logger.info(data.toString().trim());
+            });
+            childProcess.stderr?.on("data", (data)=>{
+                stderr += data.toString();
+            });
+            childProcess.on("error", (error)=>{
+                this.logger.error(`Failed to start dotnet process: ${error.message}`);
+                resolve(ToolResult.error(ToolErrorCodes.InternalError, `Failed to start dotnet process: ${error.message}`));
+            });
+            childProcess.on("exit", (code)=>{
+                if (0 === code) {
+                    this.logger.info(`Successfully signed package: ${packagePath}`);
+                    resolve(ToolResult.success());
+                } else {
+                    const errorMessage = stderr.trim() || `dotnet nuget sign exited with code ${code}`;
+                    this.logger.error(`Package signing failed: ${errorMessage}`);
+                    resolve(ToolResult.error(ToolErrorCodes.InternalError, `Package signing failed: ${errorMessage}`));
+                }
+            });
+        });
+    }
+    checkAvailable() {
+        try {
+            const output = execSync("dotnet nuget --version", {
+                stdio: [
+                    "ignore",
+                    "pipe",
+                    "ignore"
+                ],
+                encoding: "utf-8"
+            });
+            this.logger.info(`dotnet CLI found, version ${output.trim()}`);
+            return true;
+        } catch  {
+            return false;
+        }
+    }
+    constructor(logger){
+        package_sign_service_define_property(this, "logger", void 0);
+        this.logger = logger;
+    }
+}
+var telemetry_names_TelemetryNames = /*#__PURE__*/ function(TelemetryNames) {
+    TelemetryNames["ProjectToolPack"] = "ProjectPackager.Tool.Pack";
+    TelemetryNames["ProjectToolRestore"] = "ProjectPackager.Tool.Restore";
+    TelemetryNames["ProjectToolValidate"] = "ProjectPackager.Tool.Validate";
+    TelemetryNames["ProjectToolBuild"] = "ProjectPackager.Tool.Build";
+    TelemetryNames["ProjectPackagerPack"] = "ProjectPackager.Pack";
+    TelemetryNames["ProjectPackagerRestore"] = "ProjectPackager.Restore";
+    TelemetryNames["ProjectPackagerValidate"] = "ProjectPackager.Validate";
+    TelemetryNames["ProjectPackagerBuild"] = "ProjectPackager.Build";
+    TelemetryNames["ProjectPackagerProjectLoaded"] = "ProjectPackager.ProjectLoaded";
+    return TelemetryNames;
+}({});
+function pack_service_define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+class PackService {
+    sanitizePackageId(packageId) {
+        packageId = packageId.trim();
+        packageId = packageId.replace(this.spacesDotRegex, ".");
+        packageId = packageId.replace(this.dotDashRegex, "-");
+        packageId = packageId.replace(this.disallowedCharsRegex, "_");
+        if (packageId.length > this.MaxPackageIdLength) throw new Error(`Package id ${packageId} exceeds the characters limit of ${this.MaxPackageIdLength}`);
+        return packageId;
+    }
+    constructor(){
+        pack_service_define_property(this, "disallowedCharsRegex", /[^\w.-]/g);
+        pack_service_define_property(this, "spacesDotRegex", /[\s.]+/g);
+        pack_service_define_property(this, "dotDashRegex", /\.*[-:]\.*/g);
+        pack_service_define_property(this, "MaxPackageIdLength", 100);
+    }
+}
+function packager_parameters_validator_define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+class PackagerParametersValidator {
+    async validateAsync(_options, _cancellationToken) {
+        return ToolResult.success();
+    }
+    validateDestinationPath(destinationPath) {
+        if (!destinationPath) {
+            const error = translate.t("solutionpackager.validator.errors.destinationNotDefined");
+            this.logger.error(error);
+            return ToolResult.error(ToolErrorCodes.InternalError, error);
+        }
+        return ToolResult.success();
+    }
+    async validateGovernanceOptions(validateOptions) {
+        if (validateOptions.governanceFileType === packager_parameters_RulesConfigFileType.Default) {
+            if (validateOptions.governanceFilePath) this.logger.warn(`Governance file path '${validateOptions.governanceFilePath}' will be ignored when governance file type is Default`);
+            return ToolResult.success();
+        }
+        if (!validateOptions.governanceFilePath) {
+            const error = translate.t("solutionpackager.validator.errors.governanceRequired");
+            this.logger.error(error);
+            return ToolResult.error(ToolErrorCodes.InternalError, error);
+        }
+        try {
+            const stat = await this.fileSystem.stat(validateOptions.governanceFilePath);
+            if (!stat) {
+                const error = translate.t("solutionpackager.validator.errors.governanceFileInfo", {
+                    path: validateOptions.governanceFilePath
+                });
+                this.logger.error(error);
+                return ToolResult.error(ToolErrorCodes.InternalError, error);
+            }
+            if (stat.isDirectory()) {
+                const error = translate.t("solutionpackager.validator.errors.governanceInvalidFile", {
+                    path: validateOptions.governanceFilePath
+                });
+                this.logger.error(error);
+                return ToolResult.error(ToolErrorCodes.InternalError, error);
+            }
+        } catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            const errorLog = `Governance file not found or inaccessible: ${validateOptions.governanceFilePath}. Error: ${errorMessage}`;
+            this.logger.error(errorLog);
+            return ToolResult.error(ToolErrorCodes.InternalError, errorLog);
+        }
+        this.logger.info(`Using Studio governance file: ${validateOptions.governanceFilePath}`);
+        return ToolResult.success();
+    }
+    constructor(logger, fileSystem){
+        packager_parameters_validator_define_property(this, "logger", void 0);
+        packager_parameters_validator_define_property(this, "fileSystem", void 0);
+        this.logger = logger;
+        this.fileSystem = fileSystem;
+    }
+}
+class ProjectBuildOptionsValidator extends PackagerParametersValidator {
+    async validateAsync(options, _cancellationToken) {
+        return await this.validateGovernanceOptions(options.validateOptions);
+    }
+}
+function project_loader_define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+class ProjectLoader {
+    async loadProject(projectPath) {
+        if (!projectPath) throw new Error(translate.t("solutionpackager.projectLoader.errors.pathRequired"));
+        const projectFilePath = Path.join(projectPath, ProjectLoader.ProjectFileName);
+        const projectFileExists = await this.fileSystem.exists(projectFilePath);
+        if (projectFileExists) return await this.loadFromProjectFile(projectPath, projectFilePath);
+        const webAppManifestPath = Path.join(projectPath, ProjectLoader.WebAppManifestFileName);
+        const webAppManifestExists = await this.fileSystem.exists(webAppManifestPath);
+        if (webAppManifestExists) return this.loadFromWebAppManifest(projectPath, webAppManifestPath);
+        throw new Error(translate.t("solutionpackager.projectLoader.errors.noProjectFile", {
+            projectFile: ProjectLoader.ProjectFileName,
+            manifestFile: ProjectLoader.WebAppManifestFileName,
+            path: projectPath
+        }));
+    }
+    async loadFromProjectFile(projectPath, projectFilePath) {
+        const fileContent = await this.fileSystem.readFile(projectFilePath);
+        if (!fileContent) throw new Error(translate.t("solutionpackager.projectLoader.errors.readFailed", {
+            path: projectFilePath
+        }));
+        const json = "string" == typeof fileContent ? fileContent : new TextDecoder("utf-8").decode(fileContent);
+        const projectData = JSON.parse(json);
+        const projectType = projectData?.ProjectType || projectData?.type;
+        if (!projectData || !projectType) throw new Error(translate.t("solutionpackager.projectLoader.errors.invalidProject", {
+            path: projectFilePath
+        }));
+        return {
+            type: projectType,
+            name: projectData.Name || Path.basename(projectPath),
+            projectPath,
+            projectFilePath
+        };
+    }
+    loadFromWebAppManifest(projectPath, webAppManifestPath) {
+        const folderName = Path.basename(projectPath);
+        return {
+            type: ProjectTypes.AppV2,
+            name: folderName,
+            projectPath,
+            projectFilePath: webAppManifestPath
+        };
+    }
+    constructor(fileSystem){
+        project_loader_define_property(this, "fileSystem", void 0);
+        this.fileSystem = fileSystem;
+    }
+}
+project_loader_define_property(ProjectLoader, "ProjectFileName", "project.uiproj");
+project_loader_define_property(ProjectLoader, "WebAppManifestFileName", "webAppManifest.json");
+function project_pack_options_builder_define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+class ProjectPackOptionsBuilder {
+    async buildProjectPackOptions(parameters, project) {
+        if (!parameters.outputPath) throw new Error("Output path is required for Pack command");
+        await this.fileSystem.mkdir(parameters.outputPath);
+        const packageId = parameters.package.id && "" !== parameters.package.id.trim() ? parameters.package.id : project.name;
+        const packageInfo = {
+            ...parameters.package,
+            id: this.packService.sanitizePackageId(packageId)
+        };
+        return {
+            projectPath: project.projectPath,
+            excludeConfiguredSources: parameters.excludeConfiguredSources ?? false,
+            nuGetSourcesConfigPath: parameters.nuGetSourcesConfigPath,
+            logLevel: parameters.logLevel,
+            skipAnalyze: parameters.validateOptions.skipAnalyze,
+            skipValidate: false,
+            detailedLogPath: parameters.detailedLogPath,
+            policyFilePath: parameters.validateOptions.governanceFilePath,
+            policyFileType: parameters.validateOptions.governanceFileType,
+            outputPath: parameters.outputPath,
+            outputType: void 0,
+            projectType: project.type,
+            package: packageInfo,
+            skipDependencyOptimization: parameters.packOptions?.skipDependencyOptimization ?? false,
+            includeSources: parameters.packOptions?.includeSources ?? false,
+            splitPackages: parameters.packOptions?.splitPackages ?? false
+        };
+    }
+    constructor(packService, fileSystem){
+        project_pack_options_builder_define_property(this, "packService", void 0);
+        project_pack_options_builder_define_property(this, "fileSystem", void 0);
+        this.packService = packService;
+        this.fileSystem = fileSystem;
+    }
+}
+class ProjectPackOptionsValidator extends ProjectBuildOptionsValidator {
+    async validateAsync(options, cancellationToken) {
+        const destinationResult = this.validateDestinationPath(options.destinationPath);
+        if (!destinationResult.isSuccess) return destinationResult;
+        return await super.validateAsync(options, cancellationToken);
+    }
+}
+function project_tool_executor_define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+class ProjectToolExecutor {
+    async restoreAsync(options, project, context, cancellationToken) {
+        return await this.executeToolOperationAsync(project, context, (tool)=>this.telemetry.trackDependencyOperation(telemetry_names_TelemetryNames.ProjectToolRestore, project.Type, async ()=>tool.restoreAsync(options, cancellationToken), {
+                projectId: project.Id,
+                projectType: project.Type
+            }));
+    }
+    async validateAsync(options, project, context, cancellationToken) {
+        return await this.executeToolOperationAsync(project, context, (tool)=>this.telemetry.trackDependencyOperation(telemetry_names_TelemetryNames.ProjectToolValidate, project.Type, async ()=>tool.validateAsync(options, cancellationToken), {
+                projectId: project.Id,
+                projectType: project.Type
+            }));
+    }
+    async buildAsync(options, project, context, cancellationToken) {
+        return await this.executeToolOperationAsync(project, context, (tool)=>this.telemetry.trackDependencyOperation(telemetry_names_TelemetryNames.ProjectToolBuild, project.Type, async ()=>tool.buildAsync(options, cancellationToken), {
+                projectId: project.Id,
+                projectType: project.Type
+            }));
+    }
+    async packAsync(options, project, context, signingInfo, cancellationToken) {
+        return await this.executeToolOperationAsync(project, context, async (tool)=>{
+            const result = await this.telemetry.trackDependencyOperation(telemetry_names_TelemetryNames.ProjectToolPack, project.Type, async ()=>await tool.packAsync(options, cancellationToken), {
+                projectId: project.Id,
+                projectType: project.Type
+            });
+            if (result.isSuccess && signingInfo?.certificatePath && result.packages.length > 0) {
+                const signResult = await this.signPackagesAsync(result.packages, signingInfo);
+                if (!signResult.isSuccess) return signResult;
+            }
+            return result;
+        });
+    }
+    async executeToolOperationAsync(project, context, operation) {
+        try {
+            const tool = await this.toolsFactory.createProjectToolAsync(project, context);
+            try {
+                return await operation(tool);
+            } finally{
+                const disposeResult = tool.dispose();
+                if (disposeResult instanceof Promise) await disposeResult;
+            }
+        } catch (error) {
+            return ToolResult.error(ToolErrorCodes.InternalError, error instanceof Error ? error.message : String(error));
+        }
+    }
+    async signPackagesAsync(packages, signingInfo) {
+        if (!this.packageSignService) return ToolResult.error(ToolErrorCodes.InternalError, "Package signing is required but signing service is not available. Package signing requires dotnet CLI to be installed in Node.js environment.");
+        const certificatePath = signingInfo.certificatePath;
+        const signResults = await Promise.all(packages.map((packagePath)=>this.packageSignService?.signPackageAsync(packagePath, certificatePath, signingInfo.certificatePassword, signingInfo.timestampServer)));
+        const failedResult = signResults.find((result)=>result && !result.isSuccess);
+        if (failedResult) return failedResult;
+        return ToolResult.success();
+    }
+    constructor(toolsFactory, telemetry, packageSignService){
+        project_tool_executor_define_property(this, "toolsFactory", void 0);
+        project_tool_executor_define_property(this, "telemetry", void 0);
+        project_tool_executor_define_property(this, "packageSignService", void 0);
+        this.toolsFactory = toolsFactory;
+        this.telemetry = telemetry;
+        this.packageSignService = packageSignService;
+    }
+}
+class ProjectValidateOptionsValidator extends PackagerParametersValidator {
+    async validateAsync(options, _cancellationToken) {
+        return await this.validateGovernanceOptions(options.validateOptions);
+    }
+}
+function tools_factory_define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+class ToolsFactory {
+    async createSolutionToolAsync(solutionName) {
+        const logger = new ToolLogger("ResourceBuilder", solutionName);
+        const factory = this.repository.getSolutionToolFactory();
+        return await factory.createAsync(logger, this.fileSystem);
+    }
+    async createProjectToolAsync(project, context) {
+        const sourceTarget = getSourceTarget();
+        const logger = new ToolLogger(project.Type, sourceTarget);
+        if (!project.ProjectPath) throw new Error(`Project path not set for project: ${project.Id}`);
+        const factory = this.repository.getProjectToolFactory(project.Type);
+        return await factory.createAsync(logger, this.fileSystem, context);
+        function getSourceTarget() {
+            const segments = project.ProjectRelativePath.split(/[/\\]/);
+            if (segments.length > 1) return segments[0];
+            return project.Id;
+        }
+    }
+    constructor(repository, fileSystem){
+        tools_factory_define_property(this, "repository", void 0);
+        tools_factory_define_property(this, "fileSystem", void 0);
+        this.repository = repository;
+        this.fileSystem = fileSystem;
+    }
+}
+function project_packager_define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+class ProjectPackager {
+    async canPackProjectAsync(projectPath) {
+        const project = await this.projectLoader.loadProject(projectPath);
+        return this.repository.canHandleProject(project.type);
+    }
+    async setupAsync(input, operationId) {
+        this.telemetryService.setOperationId(operationId);
+        await this.temporaryStorage.cleanup();
+        if ("string" == typeof input) return input;
+        const inputPath = await this.temporaryStorage.getTempSubfolderPathAsync("input");
+        await this.zipService.extractAsync(input, inputPath);
+        const entries = await this.fileSystem.readdir(inputPath);
+        if (1 === entries.length) {
+            const innerPath = Path.join(inputPath, entries[0]);
+            const stat = await this.fileSystem.stat(innerPath);
+            if (stat?.isDirectory()) return innerPath;
+        }
+        return inputPath;
+    }
+    async restoreProjectAsync(options, cancellationToken) {
+        return await this.executeProjectOperationAsync(options, "Restore", telemetry_names_TelemetryNames.ProjectPackagerRestore, async (uiPathProject, loadedProject)=>{
+            const restoreOptions = {
+                projectPath: loadedProject.projectPath,
+                excludeConfiguredSources: options.excludeConfiguredSources ?? false,
+                nuGetSourcesConfigPath: options.nuGetSourcesConfigPath,
+                logLevel: options.logLevel,
+                outputPath: options.outputPath
+            };
+            return await this.projectExecutor.restoreAsync(restoreOptions, uiPathProject, void 0, cancellationToken);
+        }, cancellationToken);
+    }
+    async validateProjectAsync(options, cancellationToken) {
+        const validationResult = await this.validateOptionsValidator.validateAsync(options, cancellationToken);
+        if (!validationResult.isSuccess) return validationResult;
+        return await this.executeProjectOperationAsync(options, "Validate", telemetry_names_TelemetryNames.ProjectPackagerValidate, async (uiPathProject, loadedProject)=>{
+            const validateOptions = {
+                projectPath: loadedProject.projectPath,
+                excludeConfiguredSources: options.excludeConfiguredSources ?? false,
+                nuGetSourcesConfigPath: options.nuGetSourcesConfigPath,
+                logLevel: options.logLevel,
+                skipAnalyze: options.validateOptions.skipAnalyze,
+                defaultSeverity: options.validateOptions.defaultSeverity,
+                detailedLogPath: options.detailedLogPath,
+                policyFilePath: options.validateOptions.governanceFilePath,
+                policyFileType: options.validateOptions.governanceFileType
+            };
+            return await this.projectExecutor.validateAsync(validateOptions, uiPathProject, void 0, cancellationToken);
+        }, cancellationToken);
+    }
+    async buildProjectAsync(options, cancellationToken) {
+        const validationResult = await this.buildOptionsValidator.validateAsync(options, cancellationToken);
+        if (!validationResult.isSuccess) return validationResult;
+        return await this.executeProjectOperationAsync(options, "Build", telemetry_names_TelemetryNames.ProjectPackagerBuild, async (uiPathProject, loadedProject)=>{
+            if (!options.outputPath) options.outputPath = await this.temporaryStorage.getTempSubfolderPathAsync("output");
+            const buildOptions = {
+                projectPath: loadedProject.projectPath,
+                excludeConfiguredSources: options.excludeConfiguredSources ?? false,
+                nuGetSourcesConfigPath: options.nuGetSourcesConfigPath,
+                logLevel: options.logLevel,
+                skipAnalyze: options.validateOptions.skipAnalyze,
+                skipValidate: false,
+                detailedLogPath: options.detailedLogPath,
+                policyFilePath: options.validateOptions.governanceFilePath,
+                policyFileType: options.validateOptions.governanceFileType,
+                outputPath: options.outputPath,
+                outputType: void 0,
+                projectType: uiPathProject.Type
+            };
+            return await this.projectExecutor.buildAsync(buildOptions, uiPathProject, void 0, cancellationToken);
+        }, cancellationToken);
+    }
+    async packProjectAsync(options, cancellationToken) {
+        return await this.telemetryService.trackRequest(telemetry_names_TelemetryNames.ProjectPackagerPack, async ()=>{
+            try {
+                let result = await this.packOptionsValidator.validateAsync(options, cancellationToken);
+                if (!result.isSuccess) return result;
+                if (!options.outputPath) options.outputPath = await this.temporaryStorage.getTempSubfolderPathAsync("output");
+                const loadedProject = await this.projectLoader.loadProject(options.inputPath);
+                this.telemetryService.trackEvent(telemetry_names_TelemetryNames.ProjectPackagerProjectLoaded, {
+                    projectId: loadedProject.name
+                });
+                const projectPackOptions = await this.optionsBuilder.buildProjectPackOptions(options, loadedProject);
+                const uiPathProject = {
+                    Type: loadedProject.type,
+                    ProjectRelativePath: Path.basename(loadedProject.projectFilePath),
+                    ProjectPath: loadedProject.projectPath,
+                    Id: loadedProject.name
+                };
+                result = await this.projectExecutor.packAsync(projectPackOptions, uiPathProject, void 0, options.signingInfo, cancellationToken);
+                if (result.isSuccess && result.packages.length > 0) {
+                    const destinationPackages = await this.copyPackagesToDestination(result.packages, options.destinationPath, projectPackOptions.package);
+                    result = new ToolResult(ToolErrorCodes.Success, void 0, destinationPackages);
+                }
+                if (result.isSuccess) this.logger.info(`Project pack completed successfully. Packages: ${result.packages.join(", ")}`);
+                else this.logger.error(`Project pack failed with error code ${result.errorCode}: ${result.message}`);
+                return result;
+            } catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                this.logger.error(`Processing error: ${errorMessage}`);
+                return ToolResult.error(ToolErrorCodes.InternalError, `Project pack failed: ${errorMessage}`);
+            } finally{
+                await this.temporaryStorage.cleanup();
+            }
+        });
+    }
+    async getPackageStreamsAsync(result) {
+        if (!result.isSuccess) throw new Error(translate.t("solutionpackager.packager.errors.failedToGetStreams", {
+            errorCode: result.errorCode,
+            message: result.message ?? ""
+        }));
+        if (!result.packages || 0 === result.packages.length) return [];
+        const packageStreams = [];
+        for (const packagePath of result.packages){
+            const data = await this.fileSystem.readFile(packagePath);
+            if (!data) throw new Error(translate.t("solutionpackager.packager.errors.failedToReadPackage", {
+                path: packagePath
+            }));
+            const name = packagePath.split(/[\\/]/).pop() || packagePath;
+            packageStreams.push({
+                name,
+                data
+            });
+        }
+        return packageStreams;
+    }
+    async executeProjectOperationAsync(options, operationName, telemetryName, operation, _cancellationToken) {
+        return await this.telemetryService.trackRequest(telemetryName, async ()=>{
+            try {
+                const loadedProject = await this.projectLoader.loadProject(options.inputPath);
+                const uiPathProject = {
+                    Type: loadedProject.type,
+                    ProjectRelativePath: Path.basename(loadedProject.projectFilePath),
+                    ProjectPath: loadedProject.projectPath,
+                    Id: loadedProject.name
+                };
+                const operationResult = await operation(uiPathProject, loadedProject);
+                if (operationResult.isSuccess) this.logger.info(`Project ${operationName.toLowerCase()} completed successfully.`);
+                else this.logger.error(`Project ${operationName.toLowerCase()} failed with error code ${operationResult.errorCode}: ${operationResult.message}`);
+                return operationResult;
+            } catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                this.logger.error(`Processing error: ${errorMessage}`);
+                return ToolResult.error(ToolErrorCodes.InternalError, `Project ${operationName.toLowerCase()} failed: ${errorMessage}`);
+            } finally{
+                await this.temporaryStorage.cleanup();
+            }
+        });
+    }
+    async copyPackagesToDestination(packagePaths, destinationPath, packageInfo) {
+        await this.fileSystem.mkdir(destinationPath);
+        const destinationPackages = [];
+        for (const packagePath of packagePaths){
+            const stat = await this.fileSystem.stat(packagePath);
+            if (stat?.isDirectory()) {
+                const files = await this.fileSystem.readdir(packagePath);
+                const nupkgFiles = files.filter((f)=>f.endsWith(".nupkg"));
+                if (nupkgFiles.length > 0) for (const nupkgFile of nupkgFiles){
+                    const filePath = Path.join(packagePath, nupkgFile);
+                    const destPath = Path.join(destinationPath, nupkgFile);
+                    const data = await this.fileSystem.readFile(filePath);
+                    if (!data) throw new Error(translate.t("solutionpackager.packager.errors.failedToReadPackage", {
+                        path: filePath
+                    }));
+                    await this.fileSystem.writeFile(destPath, data);
+                    destinationPackages.push(destPath);
+                }
+                else {
+                    const nupkgFileName = `${packageInfo.id}.${packageInfo.version}.nupkg`;
+                    const destPath = Path.join(destinationPath, nupkgFileName);
+                    const packResult = await this.nugetPackager.packAsync(packagePath, packageInfo, destPath);
+                    destinationPackages.push(packResult.outputPath);
+                }
+            } else {
+                const fileName = packagePath.split(/[\\/]/).pop() || packagePath;
+                const destPath = Path.join(destinationPath, fileName);
+                const data = await this.fileSystem.readFile(packagePath);
+                if (!data) throw new Error(translate.t("solutionpackager.packager.errors.failedToReadPackage", {
+                    path: packagePath
+                }));
+                await this.fileSystem.writeFile(destPath, data);
+                destinationPackages.push(destPath);
+            }
+        }
+        return destinationPackages;
+    }
+    constructor(fileSystem, telemetryService, packageSignService){
+        project_packager_define_property(this, "fileSystem", void 0);
+        project_packager_define_property(this, "telemetryService", void 0);
+        project_packager_define_property(this, "packageSignService", void 0);
+        project_packager_define_property(this, "repository", void 0);
+        project_packager_define_property(this, "temporaryStorage", void 0);
+        project_packager_define_property(this, "zipService", void 0);
+        project_packager_define_property(this, "logger", void 0);
+        project_packager_define_property(this, "optionsBuilder", void 0);
+        project_packager_define_property(this, "toolsFactory", void 0);
+        project_packager_define_property(this, "projectExecutor", void 0);
+        project_packager_define_property(this, "projectLoader", void 0);
+        project_packager_define_property(this, "validateOptionsValidator", void 0);
+        project_packager_define_property(this, "buildOptionsValidator", void 0);
+        project_packager_define_property(this, "packOptionsValidator", void 0);
+        project_packager_define_property(this, "nugetPackager", void 0);
+        this.fileSystem = fileSystem;
+        this.telemetryService = telemetryService;
+        this.packageSignService = packageSignService;
+        this.repository = toolsFactoryRepository;
+        this.temporaryStorage = new TemporaryStorageService(this.fileSystem);
+        this.zipService = new ZipService(this.fileSystem);
+        this.nugetPackager = new NugetPackager(this.fileSystem);
+        this.logger = new ToolLogger("ProjectPackager", "PackProject");
+        this.validateOptionsValidator = new ProjectValidateOptionsValidator(this.logger, this.fileSystem);
+        this.buildOptionsValidator = new ProjectBuildOptionsValidator(this.logger, this.fileSystem);
+        this.packOptionsValidator = new ProjectPackOptionsValidator(this.logger, this.fileSystem);
+        const packService = new PackService();
+        this.optionsBuilder = new ProjectPackOptionsBuilder(packService, this.fileSystem);
+        this.toolsFactory = new ToolsFactory(this.repository, this.fileSystem);
+        this.projectExecutor = new ProjectToolExecutor(this.toolsFactory, this.telemetryService, this.packageSignService);
+        this.projectLoader = new ProjectLoader(this.fileSystem);
+    }
+}
+class NodeProjectPackagerFactory extends BaseNodePackagerFactory {
+    async createAsync(config) {
+        const logger = new ToolLogger("ProjectPackagerFactory", "Create");
+        this.configureLanguage(config);
+        this.configureLogHandler(config);
+        logger.info("Creating ProjectPackager instance...");
+        const fileSystem = this.getOrCreateFileSystem(config);
+        const telemetryService = this.getOrCreateTelemetryService(config);
+        const packageSignService = new NodePackageSignService(logger);
+        const projectPackager = new ProjectPackager(fileSystem, telemetryService, packageSignService);
+        this.checkDotnetAvailability(logger);
+        logger.info("ProjectPackager created successfully.");
+        return projectPackager;
+    }
+}
+async function createNodeProjectPackager(options) {
+    const factory = new NodeProjectPackagerFactory();
+    return factory.createAsync(options);
+}
+export { BaseNodePackagerFactory, ConsoleTelemetryProvider, NodeContextStorage, NodePackageSignService, PackService, PackagerParameters, PackagerParametersValidator, ProjectBuildOptions, ProjectBuildOptionsValidator, ProjectLoader, ProjectPackOptions, ProjectPackager, ProjectRestoreOptions, ProjectToolExecutor, ProjectValidateOptions, ProjectValidateOptionsValidator, TelemetryService, ToolLogger, ToolsFactory, createNodeProjectPackager, packager_parameters_RulesConfigFileType as RulesConfigFileType, setGlobalLogHandler, telemetry_names_TelemetryNames as TelemetryNames };
+
+//# sourceMappingURL=node.js.map