@uipath/solution-packager 0.0.34 → 1.197.0-preview.64

package/dist/node.js

@@ -8,6 +8,9 @@ var de_default = {
         pathRequired: "Solution directory path is required",
         fileNotFound: "Solution file not found: {path}",
         invalidSolution: "Invalid solution file: {path}",
+        projectMustBeObject: "Invalid solution file: {path}. Projects[{index}] must be an object.",
+        projectMissingProjectRelativePath: `Invalid solution file: {path}. Projects[{index}] is missing ProjectRelativePath.{pathHint} Use 'uip solution project add' to add projects, or set ProjectRelativePath to the project file path, for example "Foo/project.uiproj".`,
+        projectRelativePathPathHint: " Found Path, but .uipx uses ProjectRelativePath.",
         noSolutionFile: "No .uipx solution file found in directory: {path}",
         invalidStorageFile: "Invalid {fileName} file"
       }
@@ -30,6 +33,9 @@ var en = {
         pathRequired: "Solution directory path is required",
         fileNotFound: "Solution file not found: {path}",
         invalidSolution: "Invalid solution file: {path}",
+        projectMustBeObject: "Invalid solution file: {path}. Projects[{index}] must be an object.",
+        projectMissingProjectRelativePath: `Invalid solution file: {path}. Projects[{index}] is missing ProjectRelativePath.{pathHint} Use 'uip solution project add' to add projects, or set ProjectRelativePath to the project file path, for example "Foo/project.uiproj".`,
+        projectRelativePathPathHint: " Found Path, but .uipx uses ProjectRelativePath.",
         noSolutionFile: "No .uipx solution file found in directory: {path}",
         invalidStorageFile: "Invalid {fileName} file"
       }
@@ -51,6 +57,9 @@ var es_default = {
         pathRequired: "Solution directory path is required",
         fileNotFound: "Solution file not found: {path}",
         invalidSolution: "Invalid solution file: {path}",
+        projectMustBeObject: "Invalid solution file: {path}. Projects[{index}] must be an object.",
+        projectMissingProjectRelativePath: `Invalid solution file: {path}. Projects[{index}] is missing ProjectRelativePath.{pathHint} Use 'uip solution project add' to add projects, or set ProjectRelativePath to the project file path, for example "Foo/project.uiproj".`,
+        projectRelativePathPathHint: " Found Path, but .uipx uses ProjectRelativePath.",
         noSolutionFile: "No .uipx solution file found in directory: {path}",
         invalidStorageFile: "Invalid {fileName} file"
       }
@@ -72,6 +81,9 @@ var es_MX_default = {
         pathRequired: "Solution directory path is required",
         fileNotFound: "Solution file not found: {path}",
         invalidSolution: "Invalid solution file: {path}",
+        projectMustBeObject: "Invalid solution file: {path}. Projects[{index}] must be an object.",
+        projectMissingProjectRelativePath: `Invalid solution file: {path}. Projects[{index}] is missing ProjectRelativePath.{pathHint} Use 'uip solution project add' to add projects, or set ProjectRelativePath to the project file path, for example "Foo/project.uiproj".`,
+        projectRelativePathPathHint: " Found Path, but .uipx uses ProjectRelativePath.",
         noSolutionFile: "No .uipx solution file found in directory: {path}",
         invalidStorageFile: "Invalid {fileName} file"
       }
@@ -93,6 +105,9 @@ var fr_default = {
         pathRequired: "Solution directory path is required",
         fileNotFound: "Solution file not found: {path}",
         invalidSolution: "Invalid solution file: {path}",
+        projectMustBeObject: "Invalid solution file: {path}. Projects[{index}] must be an object.",
+        projectMissingProjectRelativePath: `Invalid solution file: {path}. Projects[{index}] is missing ProjectRelativePath.{pathHint} Use 'uip solution project add' to add projects, or set ProjectRelativePath to the project file path, for example "Foo/project.uiproj".`,
+        projectRelativePathPathHint: " Found Path, but .uipx uses ProjectRelativePath.",
         noSolutionFile: "No .uipx solution file found in directory: {path}",
         invalidStorageFile: "Invalid {fileName} file"
       }
@@ -114,6 +129,9 @@ var ja_default = {
         pathRequired: "Solution directory path is required",
         fileNotFound: "Solution file not found: {path}",
         invalidSolution: "Invalid solution file: {path}",
+        projectMustBeObject: "Invalid solution file: {path}. Projects[{index}] must be an object.",
+        projectMissingProjectRelativePath: `Invalid solution file: {path}. Projects[{index}] is missing ProjectRelativePath.{pathHint} Use 'uip solution project add' to add projects, or set ProjectRelativePath to the project file path, for example "Foo/project.uiproj".`,
+        projectRelativePathPathHint: " Found Path, but .uipx uses ProjectRelativePath.",
         noSolutionFile: "No .uipx solution file found in directory: {path}",
         invalidStorageFile: "Invalid {fileName} file"
       }
@@ -135,6 +153,9 @@ var ko_default = {
         pathRequired: "Solution directory path is required",
         fileNotFound: "Solution file not found: {path}",
         invalidSolution: "Invalid solution file: {path}",
+        projectMustBeObject: "Invalid solution file: {path}. Projects[{index}] must be an object.",
+        projectMissingProjectRelativePath: `Invalid solution file: {path}. Projects[{index}] is missing ProjectRelativePath.{pathHint} Use 'uip solution project add' to add projects, or set ProjectRelativePath to the project file path, for example "Foo/project.uiproj".`,
+        projectRelativePathPathHint: " Found Path, but .uipx uses ProjectRelativePath.",
         noSolutionFile: "No .uipx solution file found in directory: {path}",
         invalidStorageFile: "Invalid {fileName} file"
       }
@@ -156,6 +177,9 @@ var pt_default = {
         pathRequired: "Solution directory path is required",
         fileNotFound: "Solution file not found: {path}",
         invalidSolution: "Invalid solution file: {path}",
+        projectMustBeObject: "Invalid solution file: {path}. Projects[{index}] must be an object.",
+        projectMissingProjectRelativePath: `Invalid solution file: {path}. Projects[{index}] is missing ProjectRelativePath.{pathHint} Use 'uip solution project add' to add projects, or set ProjectRelativePath to the project file path, for example "Foo/project.uiproj".`,
+        projectRelativePathPathHint: " Found Path, but .uipx uses ProjectRelativePath.",
         noSolutionFile: "No .uipx solution file found in directory: {path}",
         invalidStorageFile: "Invalid {fileName} file"
       }
@@ -177,6 +201,9 @@ var pt_BR_default = {
         pathRequired: "Solution directory path is required",
         fileNotFound: "Solution file not found: {path}",
         invalidSolution: "Invalid solution file: {path}",
+        projectMustBeObject: "Invalid solution file: {path}. Projects[{index}] must be an object.",
+        projectMissingProjectRelativePath: `Invalid solution file: {path}. Projects[{index}] is missing ProjectRelativePath.{pathHint} Use 'uip solution project add' to add projects, or set ProjectRelativePath to the project file path, for example "Foo/project.uiproj".`,
+        projectRelativePathPathHint: " Found Path, but .uipx uses ProjectRelativePath.",
         noSolutionFile: "No .uipx solution file found in directory: {path}",
         invalidStorageFile: "Invalid {fileName} file"
       }
@@ -198,6 +225,9 @@ var ro_default = {
         pathRequired: "Solution directory path is required",
         fileNotFound: "Solution file not found: {path}",
         invalidSolution: "Invalid solution file: {path}",
+        projectMustBeObject: "Invalid solution file: {path}. Projects[{index}] must be an object.",
+        projectMissingProjectRelativePath: `Invalid solution file: {path}. Projects[{index}] is missing ProjectRelativePath.{pathHint} Use 'uip solution project add' to add projects, or set ProjectRelativePath to the project file path, for example "Foo/project.uiproj".`,
+        projectRelativePathPathHint: " Found Path, but .uipx uses ProjectRelativePath.",
         noSolutionFile: "No .uipx solution file found in directory: {path}",
         invalidStorageFile: "Invalid {fileName} file"
       }
@@ -219,6 +249,9 @@ var ru_default = {
         pathRequired: "Solution directory path is required",
         fileNotFound: "Solution file not found: {path}",
         invalidSolution: "Invalid solution file: {path}",
+        projectMustBeObject: "Invalid solution file: {path}. Projects[{index}] must be an object.",
+        projectMissingProjectRelativePath: `Invalid solution file: {path}. Projects[{index}] is missing ProjectRelativePath.{pathHint} Use 'uip solution project add' to add projects, or set ProjectRelativePath to the project file path, for example "Foo/project.uiproj".`,
+        projectRelativePathPathHint: " Found Path, but .uipx uses ProjectRelativePath.",
         noSolutionFile: "No .uipx solution file found in directory: {path}",
         invalidStorageFile: "Invalid {fileName} file"
       }
@@ -240,6 +273,9 @@ var tr_default = {
         pathRequired: "Solution directory path is required",
         fileNotFound: "Solution file not found: {path}",
         invalidSolution: "Invalid solution file: {path}",
+        projectMustBeObject: "Invalid solution file: {path}. Projects[{index}] must be an object.",
+        projectMissingProjectRelativePath: `Invalid solution file: {path}. Projects[{index}] is missing ProjectRelativePath.{pathHint} Use 'uip solution project add' to add projects, or set ProjectRelativePath to the project file path, for example "Foo/project.uiproj".`,
+        projectRelativePathPathHint: " Found Path, but .uipx uses ProjectRelativePath.",
         noSolutionFile: "No .uipx solution file found in directory: {path}",
         invalidStorageFile: "Invalid {fileName} file"
       }
@@ -261,6 +297,9 @@ var zh_CN_default = {
         pathRequired: "Solution directory path is required",
         fileNotFound: "Solution file not found: {path}",
         invalidSolution: "Invalid solution file: {path}",
+        projectMustBeObject: "Invalid solution file: {path}. Projects[{index}] must be an object.",
+        projectMissingProjectRelativePath: `Invalid solution file: {path}. Projects[{index}] is missing ProjectRelativePath.{pathHint} Use 'uip solution project add' to add projects, or set ProjectRelativePath to the project file path, for example "Foo/project.uiproj".`,
+        projectRelativePathPathHint: " Found Path, but .uipx uses ProjectRelativePath.",
         noSolutionFile: "No .uipx solution file found in directory: {path}",
         invalidStorageFile: "Invalid {fileName} file"
       }
@@ -282,6 +321,9 @@ var zh_TW_default = {
         pathRequired: "Solution directory path is required",
         fileNotFound: "Solution file not found: {path}",
         invalidSolution: "Invalid solution file: {path}",
+        projectMustBeObject: "Invalid solution file: {path}. Projects[{index}] must be an object.",
+        projectMissingProjectRelativePath: `Invalid solution file: {path}. Projects[{index}] is missing ProjectRelativePath.{pathHint} Use 'uip solution project add' to add projects, or set ProjectRelativePath to the project file path, for example "Foo/project.uiproj".`,
+        projectRelativePathPathHint: " Found Path, but .uipx uses ProjectRelativePath.",
         noSolutionFile: "No .uipx solution file found in directory: {path}",
         invalidStorageFile: "Invalid {fileName} file"
       }
@@ -303,6 +345,9 @@ var zu_default = {
         pathRequired: "Solution directory path is required",
         fileNotFound: "Solution file not found: {path}",
         invalidSolution: "Invalid solution file: {path}",
+        projectMustBeObject: "Invalid solution file: {path}. Projects[{index}] must be an object.",
+        projectMissingProjectRelativePath: `Invalid solution file: {path}. Projects[{index}] is missing ProjectRelativePath.{pathHint} Use 'uip solution project add' to add projects, or set ProjectRelativePath to the project file path, for example "Foo/project.uiproj".`,
+        projectRelativePathPathHint: " Found Path, but .uipx uses ProjectRelativePath.",
         noSolutionFile: "No .uipx solution file found in directory: {path}",
         invalidStorageFile: "Invalid {fileName} file"
       }
@@ -360,6 +405,7 @@ class SolutionPackOptions extends PackagerParameters {
 // src/node-solution-packager-factory.ts
 import {
   BaseNodePackagerFactory,
+  DotnetDiscoveryService,
   NodePackageSignService,
   ToolLogger as ToolLogger2
 } from "@uipath/project-packager/node";
@@ -376,8 +422,8 @@ import {
   Path as Path4,
   TargetFramework,
   TemporaryStorageService,
-  ToolErrorCodes as ToolErrorCodes3,
-  ToolResult as ToolResult3,
+  ToolErrorCodes as ToolErrorCodes4,
+  ToolResult as ToolResult4,
   toolsFactoryRepository,
   translate as translate3,
   ZipService
@@ -467,6 +513,18 @@ class OptionsBuilder {
       policyFileType: solutionOptions.validateOptions.governanceFileType
     };
   }
+  async buildProjectRestoreOptions(solutionOptions, project) {
+    if (!solutionOptions.outputPath) {
+      throw new Error(translate.t("solutionpackager.optionsBuilder.errors.outputPathRequired"));
+    }
+    return {
+      projectPath: this.resolveProjectPath(solutionOptions, project),
+      excludeConfiguredSources: solutionOptions.excludeConfiguredSources ?? false,
+      nuGetSourcesConfigPath: solutionOptions.nuGetSourcesConfigPath,
+      logLevel: solutionOptions.logLevel,
+      outputPath: await this.buildProjectOutputPath(solutionOptions.outputPath, project)
+    };
+  }
   resolveProjectPath(solutionOptions, project) {
     return Path.join(solutionOptions.inputPath, Path.dirname(project.ProjectRelativePath));
   }
@@ -641,7 +699,7 @@ import { Path as Path3, translate as translate2 } from "@uipath/solutionpackager
 
 class SolutionLoader {
   fileSystem;
-  static SolutionStorageFileName = ".storage";
+  static SolutionStorageFileName = "SolutionStorage.json";
   constructor(fileSystem) {
     this.fileSystem = fileSystem;
   }
@@ -657,12 +715,8 @@ class SolutionLoader {
       }));
     }
     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 parsed = JSON.parse(json);
+    const solution = validateSolutionFile(parsed, solutionFilePath);
     const loadedSolution = {
       ...solution,
       Name: GetSolutionName(),
@@ -714,6 +768,38 @@ class SolutionLoader {
     }
   }
 }
+function validateSolutionFile(parsed, solutionFilePath) {
+  if (!isRecord(parsed)) {
+    throw new Error(translate2.t("solutionpackager.solutionLoader.errors.invalidSolution", {
+      path: solutionFilePath
+    }));
+  }
+  if (!Array.isArray(parsed.Projects)) {
+    throw new Error(translate2.t("solutionpackager.solutionLoader.errors.invalidSolution", {
+      path: solutionFilePath
+    }));
+  }
+  for (const [index, project] of parsed.Projects.entries()) {
+    if (!isRecord(project)) {
+      throw new Error(translate2.t("solutionpackager.solutionLoader.errors.projectMustBeObject", {
+        path: solutionFilePath,
+        index
+      }));
+    }
+    if (typeof project.ProjectRelativePath !== "string" || !project.ProjectRelativePath.trim()) {
+      const pathHint = typeof project.Path === "string" ? translate2.t("solutionpackager.solutionLoader.errors.projectRelativePathPathHint") : "";
+      throw new Error(translate2.t("solutionpackager.solutionLoader.errors.projectMissingProjectRelativePath", {
+        path: solutionFilePath,
+        index,
+        pathHint
+      }));
+    }
+  }
+  return parsed;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
 
 // src/services/solution-pack-options-validator.ts
 import {
@@ -731,10 +817,24 @@ class SolutionPackOptionsValidator extends PackagerParametersValidator {
 }
 
 // src/services/solution-pack-service.ts
+import {
+  resolveProducedNupkgsAsync,
+  signNupkgsAsync
+} from "@uipath/project-packager";
 import {
   ToolErrorCodes,
   ToolResult
 } from "@uipath/solutionpackager-tool-core";
+
+// src/services/tool-result-helpers.ts
+function hasFailedResults(results) {
+  return results.some((result) => !result.isSuccess);
+}
+function getFailedResultsMessage(results) {
+  return results.filter((result) => !result.isSuccess).map((r) => r.message || "Unknown error").join(", ");
+}
+
+// src/services/solution-pack-service.ts
 class SolutionPackService {
   optionsBuilder;
   toolsFactory;
@@ -742,13 +842,15 @@ class SolutionPackService {
   zipService;
   fileSystem;
   telemetry;
-  constructor(optionsBuilder, toolsFactory, projectExecutor, zipService, fileSystem, telemetry) {
+  packageSignService;
+  constructor(optionsBuilder, toolsFactory, projectExecutor, zipService, fileSystem, telemetry, packageSignService) {
     this.optionsBuilder = optionsBuilder;
     this.toolsFactory = toolsFactory;
     this.projectExecutor = projectExecutor;
     this.zipService = zipService;
     this.fileSystem = fileSystem;
     this.telemetry = telemetry;
+    this.packageSignService = packageSignService;
   }
   async packAsync(parameters, solution, context, cancellationToken) {
     const solutionOptions = await this.optionsBuilder.buildSolutionPackOptions(parameters, solution);
@@ -763,8 +865,8 @@ class SolutionPackService {
           restoreResult,
           ...projectResults
         ];
-        if (this.hasFailedResults(restoreAndPackResults)) {
-          return ToolResult.error(ToolErrorCodes.InternalError, `Solution pack failed: ${this.getFailedResultsMessage(restoreAndPackResults)}`);
+        if (hasFailedResults(restoreAndPackResults)) {
+          return ToolResult.error(ToolErrorCodes.InternalError, `Solution pack failed: ${getFailedResultsMessage(restoreAndPackResults)}`);
         }
         const buildResult = await solutionTool.buildAsync(solutionOptions, cancellationToken);
         if (!buildResult.isSuccess) {
@@ -773,6 +875,10 @@ class SolutionPackService {
         if (!solutionOptions.outputPath) {
           return ToolResult.error(ToolErrorCodes.InternalError, "Solution output path is not defined");
         }
+        const signResult = await this.signProjectPackagesAsync(projectResults, parameters.signingInfo);
+        if (!signResult.isSuccess) {
+          return signResult;
+        }
         const archivePath = await this.compressSolutionAsync(parameters, solutionOptions.outputPath);
         return new ToolResult(ToolErrorCodes.Success, undefined, [
           archivePath
@@ -791,23 +897,33 @@ class SolutionPackService {
   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);
+      return await this.projectExecutor.packAsync(projectOptions, project, context, 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 signProjectPackagesAsync(projectResults, signingInfo) {
+    if (!signingInfo?.certificatePath) {
+      return ToolResult.success();
+    }
+    const producedPaths = projectResults.flatMap((result) => result.packages);
+    const resolved = await Promise.all(producedPaths.map(async (producedPath) => ({
+      producedPath,
+      nupkgs: await resolveProducedNupkgsAsync(this.fileSystem, producedPath)
+    })));
+    const unresolved = resolved.filter((entry) => entry.nupkgs.length === 0).map((entry) => entry.producedPath);
+    if (unresolved.length > 0) {
+      return ToolResult.error(ToolErrorCodes.InternalError, `Package signing was required but no .nupkg was found to sign for: ${unresolved.join(", ")}.`);
+    }
+    const nupkgsToSign = resolved.flatMap((entry) => entry.nupkgs);
+    return signNupkgsAsync(this.packageSignService, nupkgsToSign, signingInfo);
   }
   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";
+      await this.writePackageMetadataAsync(parameters, outputPath);
       const archiveFileName = `${packageName}_${version}.zip`;
       const archivePath = `${parameters.destinationPath}/${archiveFileName}`;
       const zipData = await this.zipService.compressAsync(outputPath);
@@ -815,6 +931,71 @@ class SolutionPackService {
       return archivePath;
     });
   }
+  async writePackageMetadataAsync(parameters, outputPath) {
+    const pkg = parameters.package;
+    const metadata = {
+      name: pkg.id || "solution",
+      version: pkg.version || "1.0.0"
+    };
+    const optional = {
+      releaseNotes: pkg.releaseNotes,
+      projectUrl: pkg.projectUrl,
+      repositoryType: pkg.repositoryType,
+      repositoryUrl: pkg.repositoryUrl,
+      repositoryBranch: pkg.repositoryBranch,
+      repositoryCommit: pkg.repositoryCommit
+    };
+    for (const [key, value] of Object.entries(optional)) {
+      if (value !== undefined && value !== "") {
+        metadata[key] = value;
+      }
+    }
+    const metadataPath = `${outputPath}/package.metadata.json`;
+    await this.fileSystem.writeFile(metadataPath, `${JSON.stringify(metadata, null, 2)}
+`);
+  }
+}
+
+// src/services/solution-restore-service.ts
+import {
+  ToolErrorCodes as ToolErrorCodes2,
+  ToolResult as ToolResult2
+} from "@uipath/solutionpackager-tool-core";
+class SolutionRestoreService {
+  optionsBuilder;
+  toolsFactory;
+  projectExecutor;
+  telemetry;
+  constructor(optionsBuilder, toolsFactory, projectExecutor, telemetry) {
+    this.optionsBuilder = optionsBuilder;
+    this.toolsFactory = toolsFactory;
+    this.projectExecutor = projectExecutor;
+    this.telemetry = telemetry;
+  }
+  async restoreAsync(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.Restore" /* SolutionRestore */, "restore", async () => {
+        const restoreResults = await Promise.all([
+          solutionTool.restoreAsync(solutionOptions, cancellationToken),
+          ...solution.Projects.map(async (project) => {
+            const projectRestoreOptions = await this.optionsBuilder.buildProjectRestoreOptions(parameters, project);
+            return this.projectExecutor.restoreAsync(projectRestoreOptions, project, context, cancellationToken);
+          })
+        ]);
+        if (hasFailedResults(restoreResults)) {
+          return ToolResult2.error(ToolErrorCodes2.InternalError, `Solution restore failed: ${getFailedResultsMessage(restoreResults)}`);
+        }
+        return ToolResult2.success();
+      }, { solutionId: solution.SolutionId });
+    } finally {
+      const disposeResult = solutionTool.dispose();
+      if (disposeResult instanceof Promise) {
+        await disposeResult;
+      }
+    }
+  }
 }
 
 // src/services/solution-validate-options-validator.ts
@@ -830,8 +1011,8 @@ class SolutionValidateOptionsValidator extends PackagerParametersValidator2 {
 
 // src/services/solution-validate-service.ts
 import {
-  ToolErrorCodes as ToolErrorCodes2,
-  ToolResult as ToolResult2
+  ToolErrorCodes as ToolErrorCodes3,
+  ToolResult as ToolResult3
 } from "@uipath/solutionpackager-tool-core";
 class SolutionValidateService {
   optionsBuilder;
@@ -846,12 +1027,12 @@ class SolutionValidateService {
     return await this.telemetry.trackDependencyOperation("SolutionPackager.Solution.Validate" /* SolutionValidate */, "validate", async () => {
       const projectResults = await Promise.all(solution.Projects.map((project) => {
         if (project.ProjectPath == null) {
-          return Promise.resolve(ToolResult2.error(ToolErrorCodes2.InternalError, `Project '${project.Id}' has no ProjectPath; the solution loader must populate it before validation.`));
+          return Promise.resolve(ToolResult3.error(ToolErrorCodes3.InternalError, `Project '${project.Id}' has no ProjectPath; the solution loader must populate it before validation.`));
         }
         return this.projectExecutor.validateAsync(this.optionsBuilder.buildProjectValidateOptions(parameters, project), project, context, cancellationToken);
       }));
       const failed = projectResults.find((r) => !r.isSuccess);
-      return failed ?? ToolResult2.success();
+      return failed ?? ToolResult3.success();
     }, { solutionId: solution.SolutionId });
   }
 }
@@ -870,6 +1051,7 @@ class SolutionPackager {
   projectExecutor;
   solutionLoader;
   solutionPackService;
+  solutionRestoreService;
   solutionValidateService;
   packOptionsValidator;
   validateOptionsValidator;
@@ -888,25 +1070,13 @@ class SolutionPackager {
     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.projectExecutor = new ProjectToolExecutor(this.toolsFactory, this.telemetryService);
     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);
+    this.solutionPackService = new SolutionPackService(this.optionsBuilder, this.toolsFactory, this.projectExecutor, this.zipService, this.fileSystem, this.telemetryService, this.packageSignService);
+    this.solutionRestoreService = new SolutionRestoreService(this.optionsBuilder, this.toolsFactory, this.projectExecutor, this.telemetryService);
     this.solutionValidateService = new SolutionValidateService(this.optionsBuilder, this.projectExecutor, 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();
@@ -962,7 +1132,7 @@ class SolutionPackager {
       } catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);
         this.logger.error(`Processing error: ${errorMessage}`);
-        return ToolResult3.error(ToolErrorCodes3.InternalError, `Solution pack failed: ${errorMessage}`);
+        return ToolResult4.error(ToolErrorCodes4.InternalError, `Solution pack failed: ${errorMessage}`);
       } finally {
         await this.temporaryStorage.cleanup();
       }
@@ -989,7 +1159,32 @@ class SolutionPackager {
       } catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);
         this.logger.error(`Processing error: ${errorMessage}`);
-        return ToolResult3.error(ToolErrorCodes3.InternalError, `Solution validate failed: ${errorMessage}`);
+        return ToolResult4.error(ToolErrorCodes4.InternalError, `Solution validate failed: ${errorMessage}`);
+      } finally {
+        await this.temporaryStorage.cleanup();
+      }
+    });
+  }
+  async restoreSolutionAsync(options, cancellationToken) {
+    return await this.telemetryService.trackRequest("SolutionPackager.RestoreSolution" /* SolutionPackagerRestoreSolution */, async () => {
+      try {
+        if (!options.outputPath) {
+          options.outputPath = await this.temporaryStorage.getTempSubfolderPathAsync("restore");
+        }
+        const loadedSolution = await this.solutionLoader.loadSolution(options.inputPath);
+        const solution = this.filterSolutionProjects(loadedSolution, options.projectDesignIds);
+        const context = this.createOperationContext(options, solution);
+        const result = await this.solutionRestoreService.restoreAsync(options, solution, context, cancellationToken);
+        if (result.isSuccess) {
+          this.logger.info("Solution restore completed successfully.");
+        } else {
+          this.logger.error(`Solution restore 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 ToolResult4.error(ToolErrorCodes4.InternalError, `Solution restore failed: ${errorMessage}`);
       } finally {
         await this.temporaryStorage.cleanup();
       }
@@ -1050,7 +1245,8 @@ class NodeSolutionPackagerFactory extends BaseNodePackagerFactory {
     logger.info("Creating SolutionPackager instance...");
     const fileSystem = this.getOrCreateFileSystem(config);
     const telemetryService = this.getOrCreateTelemetryService(config);
-    const packageSignService = new NodePackageSignService(logger);
+    this.dotnetDiscovery = new DotnetDiscoveryService;
+    const packageSignService = new NodePackageSignService(this.dotnetDiscovery, logger);
     const solutionPackager = new SolutionPackager(fileSystem, telemetryService, packageSignService);
     this.checkDotnetAvailability(logger);
     logger.info("SolutionPackager created successfully.");
@@ -1066,3 +1262,5 @@ export {
   SolutionPackager,
   SolutionPackOptions
 };
+
+//# debugId=374EFD55C7484FC664756E2164756E21

package/dist/src/browser-solution-packager-factory.d.ts

@@ -4,16 +4,23 @@ import { type ISolutionPackager } from "./services/solution-packager.js";
  * Creates a SolutionPackager instance configured for browser usage.
  *
  * This is a convenience function that creates a BrowserSolutionPackagerFactory and calls createAsync.
- * For more control, use the BrowserSolutionPackagerFactory class directly.
  *
  * @param options - Configuration options for the SolutionPackager
  * @returns Promise<ISolutionPackager> - A fully configured SolutionPackager instance ready for use in the browser.
  *
  * @example
  * ```typescript
- * // Import tools (triggers self-registration)
- * import '@uipath/packager-tool-connector';
- * import '@uipath/packager-tool-flow';
+ * // Register the tools you need explicitly
+ * import { ResourceBuilderToolFactory } from '@uipath/resource-builder-tool';
+ * import { ConnectorToolFactory } from '@uipath/packager-tool-connector';
+ * import { FlowToolFactory } from '@uipath/packager-tool-flow';
+ * import { toolsFactoryRepository } from '@uipath/solutionpackager-tool-core';
+ *
+ * // ResourceBuilder is essential to solution packing — register it (consumer
+ * // controls the @uipath/resource-builder-tool version).
+ * toolsFactoryRepository.registerSolutionToolFactory(new ResourceBuilderToolFactory());
+ * toolsFactoryRepository.registerProjectToolFactory(new ConnectorToolFactory());
+ * toolsFactoryRepository.registerProjectToolFactory(new FlowToolFactory());
  *
  * // Create SolutionPackager
  * const packager = await createBrowserSolutionPackager({

package/dist/src/i18n/locales/en.d.ts

@@ -9,6 +9,9 @@ export declare const en: {
                 readonly pathRequired: "Solution directory path is required";
                 readonly fileNotFound: "Solution file not found: {path}";
                 readonly invalidSolution: "Invalid solution file: {path}";
+                readonly projectMustBeObject: "Invalid solution file: {path}. Projects[{index}] must be an object.";
+                readonly projectMissingProjectRelativePath: "Invalid solution file: {path}. Projects[{index}] is missing ProjectRelativePath.{pathHint} Use 'uip solution project add' to add projects, or set ProjectRelativePath to the project file path, for example \"Foo/project.uiproj\".";
+                readonly projectRelativePathPathHint: " Found Path, but .uipx uses ProjectRelativePath.";
                 readonly noSolutionFile: "No .uipx solution file found in directory: {path}";
                 readonly invalidStorageFile: "Invalid {fileName} file";
             };

package/dist/src/node-solution-packager-factory.d.ts

@@ -4,7 +4,6 @@ import { type ISolutionPackager } from "./services/solution-packager.js";
  * Creates a SolutionPackager instance configured for Node.js usage.
  *
  * This is a convenience function that creates a NodeSolutionPackagerFactory and calls createAsync.
- * For more control, use the NodeSolutionPackagerFactory class directly.
  *
  * @param options - Configuration options for the SolutionPackager
  * @returns Promise<ISolutionPackager> - A fully configured SolutionPackager instance ready for use in Node.js.

package/dist/src/services/options-builder.d.ts

@@ -1,5 +1,5 @@
 import type { IPackService, UiPathProject } from "@uipath/project-packager";
-import { type IFileSystem, type IProjectPackOptions, type IProjectValidateOptions, type ISolutionPackOptions } from "@uipath/solutionpackager-tool-core";
+import { type IFileSystem, type IProjectPackOptions, type IProjectRestoreOptions, type IProjectValidateOptions, type ISolutionPackOptions } from "@uipath/solutionpackager-tool-core";
 import type { LoadedUiPathSolution } from "../models/loaded-uipath-solution.js";
 import type { SolutionPackOptions } from "../models/solution-pack-options.js";
 import type { IPackageIdReader } from "./package-id-reader.js";
@@ -19,6 +19,10 @@ export interface IOptionsBuilder {
      * Build project validate options from solution parameters, for a specific project
      */
     buildProjectValidateOptions(options: SolutionPackOptions, project: UiPathProject): IProjectValidateOptions;
+    /**
+     * Build project restore options from solution parameters, for a specific project
+     */
+    buildProjectRestoreOptions(options: SolutionPackOptions, project: UiPathProject): Promise<IProjectRestoreOptions>;
 }
 export declare class OptionsBuilder implements IOptionsBuilder {
     private readonly packageIdReader;
@@ -33,6 +37,7 @@ export declare class OptionsBuilder implements IOptionsBuilder {
      */
     buildProjectPackOptions(solutionOptions: SolutionPackOptions, project: UiPathProject): Promise<IProjectPackOptions>;
     buildProjectValidateOptions(solutionOptions: SolutionPackOptions, project: UiPathProject): IProjectValidateOptions;
+    buildProjectRestoreOptions(solutionOptions: SolutionPackOptions, project: UiPathProject): Promise<IProjectRestoreOptions>;
     private resolveProjectPath;
     /**
      * Build the output path for a project

package/dist/src/services/solution-loader.d.ts

@@ -11,7 +11,7 @@ export interface ISolutionLoader {
 }
 export declare class SolutionLoader implements ISolutionLoader {
     private readonly fileSystem;
-    static readonly SolutionStorageFileName = ".storage";
+    static readonly SolutionStorageFileName = "SolutionStorage.json";
     constructor(fileSystem: IFileSystem);
     loadSolution(solutionPath: string): Promise<LoadedUiPathSolution>;
     private getSolutionFilePathAsync;