@uipath/solution-packager 0.0.30

package/dist/index.js

@@ -0,0 +1,1038 @@
+// src/i18n/index.ts
+import { I18nManager } from "@uipath/solutionpackager-tool-core";
+// src/i18n/locales/de.json
+var de_default = {
+  solutionpackager: {
+    solutionLoader: {
+      errors: {
+        pathRequired: "Solution directory path is required",
+        fileNotFound: "Solution file not found: {path}",
+        invalidSolution: "Invalid solution file: {path}",
+        noSolutionFile: "No .uipx solution file found in directory: {path}",
+        invalidStorageFile: "Invalid {fileName} file"
+      }
+    },
+    optionsBuilder: {
+      errors: {
+        packageInfoRequired: "Package information is required for Pack command",
+        outputPathRequired: "Output path is required for Pack command",
+        invalidProjectIds: "The following project ids do not exist in the solution: {ids}"
+      }
+    }
+  }
+};
+
+// src/i18n/locales/en.ts
+var en = {
+  solutionpackager: {
+    solutionLoader: {
+      errors: {
+        pathRequired: "Solution directory path is required",
+        fileNotFound: "Solution file not found: {path}",
+        invalidSolution: "Invalid solution file: {path}",
+        noSolutionFile: "No .uipx solution file found in directory: {path}",
+        invalidStorageFile: "Invalid {fileName} file"
+      }
+    },
+    optionsBuilder: {
+      errors: {
+        packageInfoRequired: "Package information is required for Pack command",
+        outputPathRequired: "Output path is required for Pack command",
+        invalidProjectIds: "The following project ids do not exist in the solution: {ids}"
+      }
+    }
+  }
+};
+// src/i18n/locales/es.json
+var es_default = {
+  solutionpackager: {
+    solutionLoader: {
+      errors: {
+        pathRequired: "Solution directory path is required",
+        fileNotFound: "Solution file not found: {path}",
+        invalidSolution: "Invalid solution file: {path}",
+        noSolutionFile: "No .uipx solution file found in directory: {path}",
+        invalidStorageFile: "Invalid {fileName} file"
+      }
+    },
+    optionsBuilder: {
+      errors: {
+        packageInfoRequired: "Package information is required for Pack command",
+        outputPathRequired: "Output path is required for Pack command",
+        invalidProjectIds: "The following project ids do not exist in the solution: {ids}"
+      }
+    }
+  }
+};
+// src/i18n/locales/es-MX.json
+var es_MX_default = {
+  solutionpackager: {
+    solutionLoader: {
+      errors: {
+        pathRequired: "Solution directory path is required",
+        fileNotFound: "Solution file not found: {path}",
+        invalidSolution: "Invalid solution file: {path}",
+        noSolutionFile: "No .uipx solution file found in directory: {path}",
+        invalidStorageFile: "Invalid {fileName} file"
+      }
+    },
+    optionsBuilder: {
+      errors: {
+        packageInfoRequired: "Package information is required for Pack command",
+        outputPathRequired: "Output path is required for Pack command",
+        invalidProjectIds: "The following project ids do not exist in the solution: {ids}"
+      }
+    }
+  }
+};
+// src/i18n/locales/fr.json
+var fr_default = {
+  solutionpackager: {
+    solutionLoader: {
+      errors: {
+        pathRequired: "Solution directory path is required",
+        fileNotFound: "Solution file not found: {path}",
+        invalidSolution: "Invalid solution file: {path}",
+        noSolutionFile: "No .uipx solution file found in directory: {path}",
+        invalidStorageFile: "Invalid {fileName} file"
+      }
+    },
+    optionsBuilder: {
+      errors: {
+        packageInfoRequired: "Package information is required for Pack command",
+        outputPathRequired: "Output path is required for Pack command",
+        invalidProjectIds: "The following project ids do not exist in the solution: {ids}"
+      }
+    }
+  }
+};
+// src/i18n/locales/ja.json
+var ja_default = {
+  solutionpackager: {
+    solutionLoader: {
+      errors: {
+        pathRequired: "Solution directory path is required",
+        fileNotFound: "Solution file not found: {path}",
+        invalidSolution: "Invalid solution file: {path}",
+        noSolutionFile: "No .uipx solution file found in directory: {path}",
+        invalidStorageFile: "Invalid {fileName} file"
+      }
+    },
+    optionsBuilder: {
+      errors: {
+        packageInfoRequired: "Package information is required for Pack command",
+        outputPathRequired: "Output path is required for Pack command",
+        invalidProjectIds: "The following project ids do not exist in the solution: {ids}"
+      }
+    }
+  }
+};
+// src/i18n/locales/ko.json
+var ko_default = {
+  solutionpackager: {
+    solutionLoader: {
+      errors: {
+        pathRequired: "Solution directory path is required",
+        fileNotFound: "Solution file not found: {path}",
+        invalidSolution: "Invalid solution file: {path}",
+        noSolutionFile: "No .uipx solution file found in directory: {path}",
+        invalidStorageFile: "Invalid {fileName} file"
+      }
+    },
+    optionsBuilder: {
+      errors: {
+        packageInfoRequired: "Package information is required for Pack command",
+        outputPathRequired: "Output path is required for Pack command",
+        invalidProjectIds: "The following project ids do not exist in the solution: {ids}"
+      }
+    }
+  }
+};
+// src/i18n/locales/pt.json
+var pt_default = {
+  solutionpackager: {
+    solutionLoader: {
+      errors: {
+        pathRequired: "Solution directory path is required",
+        fileNotFound: "Solution file not found: {path}",
+        invalidSolution: "Invalid solution file: {path}",
+        noSolutionFile: "No .uipx solution file found in directory: {path}",
+        invalidStorageFile: "Invalid {fileName} file"
+      }
+    },
+    optionsBuilder: {
+      errors: {
+        packageInfoRequired: "Package information is required for Pack command",
+        outputPathRequired: "Output path is required for Pack command",
+        invalidProjectIds: "The following project ids do not exist in the solution: {ids}"
+      }
+    }
+  }
+};
+// src/i18n/locales/pt-BR.json
+var pt_BR_default = {
+  solutionpackager: {
+    solutionLoader: {
+      errors: {
+        pathRequired: "Solution directory path is required",
+        fileNotFound: "Solution file not found: {path}",
+        invalidSolution: "Invalid solution file: {path}",
+        noSolutionFile: "No .uipx solution file found in directory: {path}",
+        invalidStorageFile: "Invalid {fileName} file"
+      }
+    },
+    optionsBuilder: {
+      errors: {
+        packageInfoRequired: "Package information is required for Pack command",
+        outputPathRequired: "Output path is required for Pack command",
+        invalidProjectIds: "The following project ids do not exist in the solution: {ids}"
+      }
+    }
+  }
+};
+// src/i18n/locales/ro.json
+var ro_default = {
+  solutionpackager: {
+    solutionLoader: {
+      errors: {
+        pathRequired: "Solution directory path is required",
+        fileNotFound: "Solution file not found: {path}",
+        invalidSolution: "Invalid solution file: {path}",
+        noSolutionFile: "No .uipx solution file found in directory: {path}",
+        invalidStorageFile: "Invalid {fileName} file"
+      }
+    },
+    optionsBuilder: {
+      errors: {
+        packageInfoRequired: "Package information is required for Pack command",
+        outputPathRequired: "Output path is required for Pack command",
+        invalidProjectIds: "The following project ids do not exist in the solution: {ids}"
+      }
+    }
+  }
+};
+// src/i18n/locales/ru.json
+var ru_default = {
+  solutionpackager: {
+    solutionLoader: {
+      errors: {
+        pathRequired: "Solution directory path is required",
+        fileNotFound: "Solution file not found: {path}",
+        invalidSolution: "Invalid solution file: {path}",
+        noSolutionFile: "No .uipx solution file found in directory: {path}",
+        invalidStorageFile: "Invalid {fileName} file"
+      }
+    },
+    optionsBuilder: {
+      errors: {
+        packageInfoRequired: "Package information is required for Pack command",
+        outputPathRequired: "Output path is required for Pack command",
+        invalidProjectIds: "The following project ids do not exist in the solution: {ids}"
+      }
+    }
+  }
+};
+// src/i18n/locales/tr.json
+var tr_default = {
+  solutionpackager: {
+    solutionLoader: {
+      errors: {
+        pathRequired: "Solution directory path is required",
+        fileNotFound: "Solution file not found: {path}",
+        invalidSolution: "Invalid solution file: {path}",
+        noSolutionFile: "No .uipx solution file found in directory: {path}",
+        invalidStorageFile: "Invalid {fileName} file"
+      }
+    },
+    optionsBuilder: {
+      errors: {
+        packageInfoRequired: "Package information is required for Pack command",
+        outputPathRequired: "Output path is required for Pack command",
+        invalidProjectIds: "The following project ids do not exist in the solution: {ids}"
+      }
+    }
+  }
+};
+// src/i18n/locales/zh-CN.json
+var zh_CN_default = {
+  solutionpackager: {
+    solutionLoader: {
+      errors: {
+        pathRequired: "Solution directory path is required",
+        fileNotFound: "Solution file not found: {path}",
+        invalidSolution: "Invalid solution file: {path}",
+        noSolutionFile: "No .uipx solution file found in directory: {path}",
+        invalidStorageFile: "Invalid {fileName} file"
+      }
+    },
+    optionsBuilder: {
+      errors: {
+        packageInfoRequired: "Package information is required for Pack command",
+        outputPathRequired: "Output path is required for Pack command",
+        invalidProjectIds: "The following project ids do not exist in the solution: {ids}"
+      }
+    }
+  }
+};
+// src/i18n/locales/zh-TW.json
+var zh_TW_default = {
+  solutionpackager: {
+    solutionLoader: {
+      errors: {
+        pathRequired: "Solution directory path is required",
+        fileNotFound: "Solution file not found: {path}",
+        invalidSolution: "Invalid solution file: {path}",
+        noSolutionFile: "No .uipx solution file found in directory: {path}",
+        invalidStorageFile: "Invalid {fileName} file"
+      }
+    },
+    optionsBuilder: {
+      errors: {
+        packageInfoRequired: "Package information is required for Pack command",
+        outputPathRequired: "Output path is required for Pack command",
+        invalidProjectIds: "The following project ids do not exist in the solution: {ids}"
+      }
+    }
+  }
+};
+// src/i18n/locales/zu.json
+var zu_default = {
+  solutionpackager: {
+    solutionLoader: {
+      errors: {
+        pathRequired: "Solution directory path is required",
+        fileNotFound: "Solution file not found: {path}",
+        invalidSolution: "Invalid solution file: {path}",
+        noSolutionFile: "No .uipx solution file found in directory: {path}",
+        invalidStorageFile: "Invalid {fileName} file"
+      }
+    },
+    optionsBuilder: {
+      errors: {
+        packageInfoRequired: "Package information is required for Pack command",
+        outputPathRequired: "Output path is required for Pack command",
+        invalidProjectIds: "The following project ids do not exist in the solution: {ids}"
+      }
+    }
+  }
+};
+
+// src/i18n/index.ts
+I18nManager.registerTranslations("en", en);
+I18nManager.registerTranslations("de", de_default);
+I18nManager.registerTranslations("es", es_default);
+I18nManager.registerTranslations("es-MX", es_MX_default);
+I18nManager.registerTranslations("fr", fr_default);
+I18nManager.registerTranslations("ja", ja_default);
+I18nManager.registerTranslations("ko", ko_default);
+I18nManager.registerTranslations("pt", pt_default);
+I18nManager.registerTranslations("pt-BR", pt_BR_default);
+I18nManager.registerTranslations("ro", ro_default);
+I18nManager.registerTranslations("ru", ru_default);
+I18nManager.registerTranslations("tr", tr_default);
+I18nManager.registerTranslations("zh-CN", zh_CN_default);
+I18nManager.registerTranslations("zh-TW", zh_TW_default);
+I18nManager.registerTranslations("zu", zu_default);
+
+// src/index.ts
+import { RulesConfigFileType as RulesConfigFileType2 } from "@uipath/project-packager";
+import {
+  BuildConfiguration as BuildConfiguration3,
+  LogLevel
+} from "@uipath/solutionpackager-tool-core";
+
+// src/browser-solution-packager-factory.ts
+import { BrowserFileSystem } from "@uipath/filesystem/browser";
+import {
+  setGlobalLogHandler,
+  ToolLogger as ToolLogger2
+} from "@uipath/project-packager";
+import { translate as translate3 } from "@uipath/solutionpackager-tool-core";
+import {
+  BrowserContextStorage,
+  ConsoleTelemetryProvider,
+  TelemetryService
+} from "@uipath/telemetry";
+
+// src/services/solution-packager.ts
+import {
+  GovernancePolicyService,
+  PackService,
+  ProjectToolExecutor,
+  ToolLogger,
+  ToolsFactory
+} from "@uipath/project-packager";
+import {
+  Path as Path4,
+  TargetFramework,
+  TemporaryStorageService,
+  ToolErrorCodes as ToolErrorCodes2,
+  ToolResult as ToolResult2,
+  toolsFactoryRepository,
+  ZipService
+} from "@uipath/solutionpackager-tool-core";
+
+// src/services/options-builder.ts
+import {
+  BuildConfiguration,
+  Path,
+  translate
+} from "@uipath/solutionpackager-tool-core";
+
+class OptionsBuilder {
+  packageIdReader;
+  packService;
+  fileSystem;
+  constructor(packageIdReader, packService, fileSystem) {
+    this.packageIdReader = packageIdReader;
+    this.packService = packService;
+    this.fileSystem = fileSystem;
+  }
+  static FILES_DIRECTORY_NAME = "files";
+  async buildSolutionPackOptions(parameters, solution) {
+    if (!parameters.outputPath) {
+      throw new Error(translate.t("solutionpackager.optionsBuilder.errors.outputPathRequired"));
+    }
+    await this.createOutputFilesDirectoryAsync(parameters.outputPath);
+    const projectsToBuild = this.getProjectIdsToBuild(parameters, solution);
+    if (!parameters.package.id || parameters.package.id.trim() === "") {
+      parameters.package.id = solution.Name;
+    }
+    return {
+      solutionFilePath: solution.filePath,
+      outputPath: parameters.outputPath,
+      connection: parameters.connection,
+      configuration: parameters.configuration,
+      package: parameters.package,
+      publishId: parameters.publishInfo?.id,
+      projectsToBuild
+    };
+  }
+  async createOutputFilesDirectoryAsync(outputPath) {
+    const filesDir = Path.join(outputPath, OptionsBuilder.FILES_DIRECTORY_NAME);
+    await this.fileSystem.mkdir(filesDir);
+  }
+  async buildProjectPackOptions(solutionOptions, project) {
+    const solutionFolderPath = solutionOptions.inputPath;
+    const projectRelativePath = Path.dirname(project.ProjectRelativePath);
+    const projectPath = Path.join(solutionFolderPath, projectRelativePath);
+    const solutionName = solutionOptions.package.id || undefined;
+    const packageInfo = {
+      ...solutionOptions.package,
+      id: await this.packageIdReader.read(project, solutionOptions.inputPath, solutionName) || ""
+    };
+    if (!solutionOptions.outputPath) {
+      throw new Error(translate.t("solutionpackager.optionsBuilder.errors.outputPathRequired"));
+    }
+    const packageId = !packageInfo.id || packageInfo.id.trim() === "" ? Path.basename(projectPath) : packageInfo.id;
+    packageInfo.id = this.packService.sanitizePackageId(packageId);
+    return {
+      projectPath,
+      excludeConfiguredSources: solutionOptions.excludeConfiguredSources ?? false,
+      nuGetSourcesConfigPath: solutionOptions.nuGetSourcesConfigPath,
+      logLevel: solutionOptions.logLevel,
+      skipAnalyze: solutionOptions.validateOptions.skipAnalyze,
+      skipValidate: false,
+      projectStorageId: project.StorageId,
+      detailedLogPath: solutionOptions.detailedLogPath,
+      policyFilePath: solutionOptions.validateOptions.governanceFilePath,
+      policyFileType: solutionOptions.validateOptions.governanceFileType,
+      outputPath: await this.buildProjectOutputPath(solutionOptions.outputPath, project),
+      outputType: undefined,
+      projectType: project.Type,
+      package: packageInfo,
+      skipDependencyOptimization: solutionOptions.packOptions?.skipDependencyOptimization ?? false,
+      includeSources: solutionOptions.packOptions?.includeSources ?? false,
+      splitPackages: solutionOptions.packOptions?.splitPackages ?? false
+    };
+  }
+  async buildProjectOutputPath(solutionOutputPath, project) {
+    const filesDir = Path.join(solutionOutputPath, OptionsBuilder.FILES_DIRECTORY_NAME);
+    const projectOutputPath = Path.join(filesDir, project.Id);
+    await this.fileSystem.mkdir(projectOutputPath);
+    return projectOutputPath;
+  }
+  getProjectIdsToBuild(parameters, solution) {
+    const solutionProjectIds = solution.Projects.map((p) => p.Id);
+    if (parameters.projectsToBuild === null || parameters.projectsToBuild === undefined || parameters.projectsToBuild.length === 0) {
+      return parameters.configuration === BuildConfiguration.Release ? solutionProjectIds : [];
+    }
+    const invalidProjectIds = parameters.projectsToBuild.filter((id) => !solutionProjectIds.includes(id));
+    if (invalidProjectIds.length > 0) {
+      console.warn(translate.t("solutionpackager.optionsBuilder.errors.invalidProjectIds", {
+        ids: invalidProjectIds.join(",")
+      }));
+      return solutionProjectIds.filter((id) => parameters.projectsToBuild?.includes(id));
+    }
+    return parameters.projectsToBuild;
+  }
+}
+
+// src/services/package-id-reader.ts
+import { Path as Path2 } from "@uipath/solutionpackager-tool-core";
+var legacySolutionResourcesFileName = "resources.json";
+
+class PackageIdReader {
+  fileSystem;
+  packService;
+  projectTypesToFolderNameMapping = {
+    processorchestration: "processOrchestration",
+    casemanagement: "caseManagement",
+    agent: "agent",
+    api: "api",
+    webapp: "webApp",
+    process: "process"
+  };
+  static projectTypeMap = {
+    process: "Rpa",
+    library: "Lib",
+    tests: "Tests",
+    webapp: "App",
+    processorchestration: "Agentic",
+    casemanagement: "Case",
+    api: "Api",
+    agent: "Agent"
+  };
+  constructor(fileSystem, packService) {
+    this.fileSystem = fileSystem;
+    this.packService = packService;
+  }
+  async read(project, solutionPath, solutionName) {
+    try {
+      if (!solutionPath || solutionPath.trim() === "") {
+        return this.defaultToProjectFolder(project, solutionPath, solutionName);
+      }
+      return await this.readFromResourcesDirectory(project, solutionPath) || await this.readFromLegacyResourcesJson(project, solutionPath) || this.defaultToProjectFolder(project, solutionPath, solutionName);
+    } catch (ex) {
+      console.error("Error reading package ID:", ex);
+      return this.defaultToProjectFolder(project, solutionPath, solutionName);
+    }
+  }
+  defaultToProjectFolder(project, solutionPath, solutionName) {
+    const projectFolderName = Path2.dirname(project.ProjectRelativePath);
+    const id = this.packService.sanitizePackageId(projectFolderName);
+    return this.getPackageId(id, project, solutionPath, solutionName);
+  }
+  getPackageId(rootPackageId, project, solutionPath, solutionName) {
+    const packageId = this.composePackageId(rootPackageId, project, solutionPath, solutionName);
+    return this.packService.sanitizePackageId(packageId);
+  }
+  composePackageId(rootPackageId, project, solutionPath, solutionName) {
+    if (!solutionName && (!solutionPath || solutionPath.trim() === "")) {
+      return rootPackageId;
+    }
+    const resolvedSolutionName = solutionName || this.deriveSolutionName(solutionPath);
+    const parts = [resolvedSolutionName];
+    if (project.Type) {
+      parts.push(PackageIdReader.normalizeProjectType(project.Type));
+    }
+    parts.push(rootPackageId);
+    return parts.join(".");
+  }
+  static normalizeProjectType(projectType) {
+    const normalizedKey = projectType.toLowerCase();
+    return PackageIdReader.projectTypeMap[normalizedKey] || projectType;
+  }
+  deriveSolutionName(solutionPath) {
+    const ext = Path2.extname(solutionPath);
+    const base = Path2.basename(solutionPath);
+    return ext ? base.substring(0, base.length - ext.length) : base;
+  }
+  async readFromLegacyResourcesJson(project, solutionPath) {
+    const resourcesFilePath = Path2.join(solutionPath, legacySolutionResourcesFileName);
+    const exists = await this.fileSystem.exists(resourcesFilePath);
+    if (!exists) {
+      return null;
+    }
+    const data = await this.fileSystem.readFile(resourcesFilePath);
+    if (!data) {
+      return null;
+    }
+    const json = new TextDecoder().decode(data);
+    return this.getProjectIdFromJson(project, json);
+  }
+  getProjectIdFromJson(project, json) {
+    try {
+      const jsonObject = JSON.parse(json);
+      const resources = this.getProperty(jsonObject, "resources");
+      if (!Array.isArray(resources)) {
+        return null;
+      }
+      const resource = resources.find((r) => {
+        const projectKey = this.getProperty(r, "projectKey");
+        const kind = this.getProperty(r, "kind");
+        return projectKey === project.Id && kind?.toLowerCase() === "process";
+      });
+      if (!resource) {
+        return null;
+      }
+      const spec = this.getProperty(resource, "spec");
+      if (!spec) {
+        return null;
+      }
+      const packageName = this.getProperty(spec, "packageName");
+      if (!packageName || typeof packageName !== "string" || packageName.trim() === "") {
+        return null;
+      }
+      return packageName;
+    } catch (ex) {
+      console.error("Error parsing legacy resources JSON:", ex);
+      return null;
+    }
+  }
+  async readFromResourcesDirectory(project, solutionPath) {
+    const projectTypeLower = project.Type.toLowerCase();
+    const projectTypeFolder = this.projectTypesToFolderNameMapping[projectTypeLower] || Path2.dirname(project.ProjectRelativePath);
+    const processDirectory = Path2.join(solutionPath, "resources", "solution_folder", "process", projectTypeFolder);
+    const stats = await this.fileSystem.stat(processDirectory);
+    if (!stats?.isDirectory()) {
+      return null;
+    }
+    const files = await this.fileSystem.readdir(processDirectory);
+    const jsonFiles = files.filter((f) => f.endsWith(".json")).map((f) => Path2.join(processDirectory, f));
+    for (const jsonFile of jsonFiles) {
+      try {
+        const data = await this.fileSystem.readFile(jsonFile);
+        if (!data) {
+          continue;
+        }
+        const json = new TextDecoder().decode(data);
+        const jsonObject = JSON.parse(json);
+        const resource = this.getProperty(jsonObject, "resource");
+        const projectKey = this.getProperty(resource, "projectKey");
+        if (projectKey === project.Id) {
+          const spec = this.getProperty(resource, "spec");
+          let packageName = this.getProperty(spec, "packageName");
+          if (!packageName || typeof packageName !== "string" || packageName.trim() === "") {
+            packageName = null;
+          }
+          return packageName;
+        }
+      } catch (ex) {
+        console.error("Error reading resource file:", jsonFile, ex);
+      }
+    }
+    return null;
+  }
+  getProperty(obj, propertyName) {
+    if (!obj || typeof obj !== "object") {
+      return null;
+    }
+    const keys = Object.keys(obj);
+    const matchingKey = keys.find((key) => key.toLowerCase() === propertyName.toLowerCase());
+    return matchingKey ? obj[matchingKey] : null;
+  }
+}
+
+// src/services/solution-loader.ts
+import { Path as Path3, translate as translate2 } from "@uipath/solutionpackager-tool-core";
+
+class SolutionLoader {
+  fileSystem;
+  static SolutionStorageFileName = ".storage";
+  constructor(fileSystem) {
+    this.fileSystem = fileSystem;
+  }
+  async loadSolution(solutionPath) {
+    if (!solutionPath) {
+      throw new Error(translate2.t("solutionpackager.solutionLoader.errors.pathRequired"));
+    }
+    const solutionFilePath = await this.getSolutionFilePathAsync(solutionPath);
+    const fileContent = await this.fileSystem.readFile(solutionFilePath);
+    if (!fileContent) {
+      throw new Error(translate2.t("solutionpackager.solutionLoader.errors.fileNotFound", {
+        path: solutionFilePath
+      }));
+    }
+    const json = typeof fileContent === "string" ? fileContent : new TextDecoder("utf-8").decode(fileContent);
+    const solution = JSON.parse(json);
+    if (!solution?.Projects) {
+      throw new Error(translate2.t("solutionpackager.solutionLoader.errors.invalidSolution", {
+        path: solutionFilePath
+      }));
+    }
+    const loadedSolution = {
+      ...solution,
+      Name: GetSolutionName(),
+      filePath: solutionFilePath
+    };
+    for (const project of loadedSolution.Projects) {
+      const projectRelativeDir = Path3.dirname(project.ProjectRelativePath);
+      project.ProjectPath = Path3.join(solutionPath, projectRelativeDir);
+    }
+    await this.populateStorageIds(loadedSolution, solutionPath);
+    return loadedSolution;
+    function GetSolutionName() {
+      const uipxFileName = Path3.basename(solutionFilePath);
+      return uipxFileName.replace(/\.uipx$/i, "");
+    }
+  }
+  async getSolutionFilePathAsync(solutionPath) {
+    const files = await this.fileSystem.readdir(solutionPath);
+    const uipxFile = files.find((file) => file.endsWith(".uipx"));
+    if (!uipxFile) {
+      throw new Error(translate2.t("solutionpackager.solutionLoader.errors.noSolutionFile", {
+        path: solutionPath
+      }));
+    }
+    return Path3.join(solutionPath, uipxFile);
+  }
+  async populateStorageIds(solution, rootDirectory) {
+    const storageFile = Path3.join(rootDirectory, SolutionLoader.SolutionStorageFileName);
+    const exists = await this.fileSystem.exists(storageFile);
+    if (!exists) {
+      return;
+    }
+    const fileContent = await this.fileSystem.readFile(storageFile);
+    if (!fileContent) {
+      return;
+    }
+    const json = typeof fileContent === "string" ? fileContent : new TextDecoder("utf-8").decode(fileContent);
+    const storage = JSON.parse(json);
+    if (!storage?.Projects) {
+      throw new Error(translate2.t("solutionpackager.solutionLoader.errors.invalidStorageFile", {
+        fileName: SolutionLoader.SolutionStorageFileName
+      }));
+    }
+    for (const project of solution.Projects) {
+      const storageProject = storage.Projects.find((sp) => sp.ProjectRelativePath === project.ProjectRelativePath);
+      if (storageProject) {
+        project.StorageId = storageProject.ProjectId;
+      }
+    }
+  }
+}
+
+// src/services/solution-pack-options-validator.ts
+import {
+  PackagerParametersValidator
+} from "@uipath/project-packager";
+
+class SolutionPackOptionsValidator extends PackagerParametersValidator {
+  async validateAsync(options, _cancellationToken) {
+    const destinationResult = this.validateDestinationPath(options.destinationPath);
+    if (!destinationResult.isSuccess) {
+      return destinationResult;
+    }
+    return await this.validateGovernanceOptions(options.validateOptions);
+  }
+}
+
+// src/services/solution-pack-service.ts
+import {
+  ToolErrorCodes,
+  ToolResult
+} from "@uipath/solutionpackager-tool-core";
+class SolutionPackService {
+  optionsBuilder;
+  toolsFactory;
+  projectExecutor;
+  zipService;
+  fileSystem;
+  telemetry;
+  constructor(optionsBuilder, toolsFactory, projectExecutor, zipService, fileSystem, telemetry) {
+    this.optionsBuilder = optionsBuilder;
+    this.toolsFactory = toolsFactory;
+    this.projectExecutor = projectExecutor;
+    this.zipService = zipService;
+    this.fileSystem = fileSystem;
+    this.telemetry = telemetry;
+  }
+  async packAsync(parameters, solution, context, cancellationToken) {
+    const solutionOptions = await this.optionsBuilder.buildSolutionPackOptions(parameters, solution);
+    const solutionTool = await this.toolsFactory.createSolutionToolAsync(solution.SolutionId);
+    try {
+      return await this.telemetry.trackDependencyOperation("SolutionPackager.Solution.Pack" /* SolutionPack */, "pack", async () => {
+        const [restoreResult, ...projectResults] = await Promise.all([
+          solutionTool.restoreAsync(solutionOptions, cancellationToken),
+          ...this.packAllProjectsAsync(parameters, solution.Projects, context, cancellationToken)
+        ]);
+        const restoreAndPackResults = [
+          restoreResult,
+          ...projectResults
+        ];
+        if (this.hasFailedResults(restoreAndPackResults)) {
+          return ToolResult.error(ToolErrorCodes.InternalError, `Solution pack failed: ${this.getFailedResultsMessage(restoreAndPackResults)}`);
+        }
+        const buildResult = await solutionTool.buildAsync(solutionOptions, cancellationToken);
+        if (!buildResult.isSuccess) {
+          return ToolResult.error(buildResult.errorCode, `Solution build failed: ${buildResult.message || "Unknown error"}`);
+        }
+        if (!solutionOptions.outputPath) {
+          return ToolResult.error(ToolErrorCodes.InternalError, "Solution output path is not defined");
+        }
+        const archivePath = await this.compressSolutionAsync(parameters, solutionOptions.outputPath);
+        return new ToolResult(ToolErrorCodes.Success, undefined, [
+          archivePath
+        ]);
+      }, { solutionId: solution.SolutionId });
+    } finally {
+      const disposeResult = solutionTool.dispose();
+      if (disposeResult instanceof Promise) {
+        await disposeResult;
+      }
+    }
+  }
+  packAllProjectsAsync(parameters, projects, context, cancellationToken) {
+    return projects.map((project) => this.packSingleProjectAsync(parameters, project, context, cancellationToken));
+  }
+  async packSingleProjectAsync(parameters, project, context, cancellationToken) {
+    try {
+      const projectOptions = await this.optionsBuilder.buildProjectPackOptions(parameters, project);
+      return await this.projectExecutor.packAsync(projectOptions, project, context, parameters.signingInfo, cancellationToken);
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      return ToolResult.error(ToolErrorCodes.InternalError, errorMessage);
+    }
+  }
+  hasFailedResults(results) {
+    return results.some((result) => !result.isSuccess);
+  }
+  getFailedResultsMessage(results) {
+    const failedResults = results.filter((result) => !result.isSuccess);
+    return failedResults.map((r) => r.message || "Unknown error").join(", ");
+  }
+  async compressSolutionAsync(parameters, outputPath) {
+    return await this.telemetry.trackDependencyOperation("SolutionPackager.Solution.Compress" /* SolutionCompress */, "compress", async () => {
+      const packageName = parameters.package.id || "solution";
+      const version = parameters.package.version || "1.0.0";
+      const archiveFileName = `${packageName}_${version}.zip`;
+      const archivePath = `${parameters.destinationPath}/${archiveFileName}`;
+      const zipData = await this.zipService.compressAsync(outputPath);
+      await this.fileSystem.writeFile(archivePath, zipData);
+      return archivePath;
+    });
+  }
+}
+
+// src/services/solution-packager.ts
+class SolutionPackager {
+  fileSystem;
+  telemetryService;
+  packageSignService;
+  repository;
+  temporaryStorage;
+  zipService;
+  logger;
+  optionsBuilder;
+  toolsFactory;
+  projectExecutor;
+  solutionLoader;
+  solutionPackService;
+  optionsValidator;
+  governancePolicyService;
+  constructor(fileSystem, telemetryService, packageSignService) {
+    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.logger = new ToolLogger("SolutionPackager", "PackSolution");
+    this.optionsValidator = new SolutionPackOptionsValidator(this.logger, this.fileSystem);
+    const packService = new PackService;
+    const packageIdReader = new PackageIdReader(this.fileSystem, packService);
+    this.optionsBuilder = new OptionsBuilder(packageIdReader, packService, this.fileSystem);
+    this.toolsFactory = new ToolsFactory(this.repository, this.fileSystem);
+    this.projectExecutor = new ProjectToolExecutor(this.toolsFactory, this.telemetryService, this.packageSignService);
+    this.solutionLoader = new SolutionLoader(this.fileSystem);
+    this.governancePolicyService = new GovernancePolicyService(this.fileSystem, this.temporaryStorage);
+    this.solutionPackService = new SolutionPackService(this.optionsBuilder, this.toolsFactory, this.projectExecutor, this.zipService, this.fileSystem, this.telemetryService);
+  }
+  async canPackSolutionAsync(solutionPath) {
+    const solution = await this.solutionLoader.loadSolution(solutionPath);
+    for (const project of solution.Projects) {
+      if (!project.ProjectPath) {
+        return false;
+      }
+      const canHandle = this.repository.canHandleProject(project.Type);
+      if (!canHandle) {
+        return false;
+      }
+    }
+    return true;
+  }
+  async setupAsync(input, operationId) {
+    this.telemetryService.setOperationId(operationId);
+    await this.temporaryStorage.cleanup();
+    if (typeof input === "string") {
+      return input;
+    }
+    const inputPath = await this.temporaryStorage.getTempSubfolderPathAsync("input");
+    await this.zipService.extractAsync(input, inputPath);
+    const entries = await this.fileSystem.readdir(inputPath);
+    if (entries.length === 1) {
+      const innerPath = Path4.join(inputPath, entries[0]);
+      const stat = await this.fileSystem.stat(innerPath);
+      if (stat?.isDirectory()) {
+        return innerPath;
+      }
+    }
+    return inputPath;
+  }
+  async setupWithUrlAsync(downloadUrl, accessToken, operationId) {
+    const headers = {};
+    if (accessToken) {
+      headers.Authorization = `Bearer ${accessToken}`;
+    }
+    const response = await fetch(downloadUrl, { headers });
+    if (!response.ok) {
+      throw new Error(`Failed to download solution: ${response.status} ${response.statusText}`);
+    }
+    const arrayBuffer = await response.arrayBuffer();
+    const zipData = new Uint8Array(arrayBuffer);
+    return this.setupAsync(zipData, operationId);
+  }
+  async packSolutionAsync(options, cancellationToken) {
+    return await this.telemetryService.trackRequest("SolutionPackager.PackSolution" /* SolutionPackagerPackSolution */, async () => {
+      try {
+        await this.governancePolicyService.resolveGovernancePolicyAsync(options.validateOptions, options.connection, cancellationToken);
+        let result = await this.optionsValidator.validateAsync(options, cancellationToken);
+        if (!result.isSuccess) {
+          return result;
+        }
+        if (!options.outputPath) {
+          options.outputPath = await this.temporaryStorage.getTempSubfolderPathAsync("output");
+        }
+        const solution = await this.solutionLoader.loadSolution(options.inputPath);
+        const context = this.createOperationContext(options, solution);
+        result = await this.solutionPackService.packAsync(options, solution, context, cancellationToken);
+        if (result.isSuccess) {
+          this.logger.info(`Solution pack completed successfully. Packages: ${result.packages.join(", ")}`);
+        } else {
+          this.logger.error(`Solution 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 ToolResult2.error(ToolErrorCodes2.InternalError, `Solution pack failed: ${errorMessage}`);
+      } finally {
+        await this.temporaryStorage.cleanup();
+      }
+    });
+  }
+  createOperationContext(options, solution) {
+    return {
+      id: crypto.randomUUID(),
+      solution,
+      downloadUrl: options.downloadUrl,
+      configuration: options.configuration,
+      targetFramework: options.targetFramework ?? TargetFramework.Portable,
+      connection: options.connection,
+      logger: this.logger,
+      workflowCompilerVersion: options.workflowCompilerVersion
+    };
+  }
+  async getPackageStreamsAsync(result) {
+    if (!result.isSuccess) {
+      throw new Error(`Cannot get package streams from failed result. Error code: ${result.errorCode}, message: ${result.message}`);
+    }
+    if (!result.packages || result.packages.length === 0) {
+      return [];
+    }
+    const packageStreams = [];
+    for (const packagePath of result.packages) {
+      const data = await this.fileSystem.readFile(packagePath);
+      if (!data) {
+        throw new Error(`Failed to read package file: ${packagePath}`);
+      }
+      const name = packagePath.split(/[\\/]/).pop() || packagePath;
+      packageStreams.push({ name, data });
+    }
+    return packageStreams;
+  }
+}
+
+// src/browser-solution-packager-factory.ts
+var sharedFileSystem = null;
+var GLOBAL_FS_KEY = "__uipath_sharedFileSystem";
+
+class BrowserSolutionPackagerFactory {
+  async createAsync(config) {
+    const logger = new ToolLogger2("SolutionPackagerFactory", "Create");
+    this.configureLanguage(config);
+    this.configureLogHandler(config);
+    logger.info("Creating SolutionPackager instance...");
+    const fileSystem = await this.getOrCreateFileSystem(config);
+    const telemetryService = this.getOrCreateTelemetryService(config);
+    const solutionPackager = new SolutionPackager(fileSystem, telemetryService);
+    logger.info("SolutionPackager created successfully.");
+    return solutionPackager;
+  }
+  async getOrCreateFileSystem(config) {
+    if (config?.fileSystem) {
+      return config.fileSystem;
+    }
+    if (!sharedFileSystem) {
+      sharedFileSystem = globalThis[GLOBAL_FS_KEY] ?? null;
+    }
+    if (!sharedFileSystem) {
+      const fs = new BrowserFileSystem;
+      try {
+        await fs.init();
+      } catch (error) {
+        if (error instanceof Error && error.message.includes("Mount point is already in use")) {
+          fs.initialized = true;
+        } else {
+          throw error;
+        }
+      }
+      sharedFileSystem = fs;
+      globalThis[GLOBAL_FS_KEY] = fs;
+    }
+    return sharedFileSystem;
+  }
+  getOrCreateTelemetryService(config) {
+    if (config?.telemetryService) {
+      return config.telemetryService;
+    }
+    const provider = new ConsoleTelemetryProvider;
+    const contextStorage = new BrowserContextStorage;
+    return new TelemetryService(provider, contextStorage);
+  }
+  configureLogHandler(config) {
+    if (config?.logHandler) {
+      setGlobalLogHandler(config.logHandler);
+    }
+  }
+  configureLanguage(config) {
+    const language = config?.language ?? "en";
+    translate3.setLocale(language);
+  }
+}
+async function createBrowserSolutionPackager(options) {
+  const factory = new BrowserSolutionPackagerFactory;
+  return factory.createAsync(options);
+}
+// src/models/solution-pack-options.ts
+import {
+  PackagerParameters,
+  RulesConfigFileType
+} from "@uipath/project-packager";
+import {
+  BuildConfiguration as BuildConfiguration2
+} from "@uipath/solutionpackager-tool-core";
+
+class SolutionPackOptions extends PackagerParameters {
+  downloadUrl;
+  destinationPath;
+  projectsToBuild;
+  validateOptions = {
+    skipAnalyze: false,
+    governanceFileType: RulesConfigFileType.Default
+  };
+  package;
+  configuration = BuildConfiguration2.Release;
+  signingInfo;
+  packOptions;
+  publishInfo;
+}
+export {
+  createBrowserSolutionPackager,
+  SolutionPackager,
+  SolutionPackOptions,
+  RulesConfigFileType2 as RulesConfigFileType,
+  LogLevel,
+  BuildConfiguration3 as BuildConfiguration
+};