@uipath/solution-packager 1.196.0 → 1.197.0-preview.65

package/dist/index.js

@@ -402,8 +402,8 @@ import {
   Path as Path4,
   TargetFramework,
   TemporaryStorageService,
-  ToolErrorCodes as ToolErrorCodes3,
-  ToolResult as ToolResult3,
+  ToolErrorCodes as ToolErrorCodes4,
+  ToolResult as ToolResult4,
   toolsFactoryRepository,
   translate as translate3,
   ZipService
@@ -493,6 +493,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));
   }
@@ -785,10 +797,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;
@@ -796,13 +822,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);
@@ -817,8 +845,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) {
@@ -827,6 +855,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
@@ -845,18 +877,27 @@ 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 () => {
@@ -895,6 +936,48 @@ class SolutionPackService {
   }
 }
 
+// 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
 import {
   PackagerParametersValidator as PackagerParametersValidator2
@@ -908,8 +991,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;
@@ -924,12 +1007,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 });
   }
 }
@@ -948,6 +1031,7 @@ class SolutionPackager {
   projectExecutor;
   solutionLoader;
   solutionPackService;
+  solutionRestoreService;
   solutionValidateService;
   packOptionsValidator;
   validateOptionsValidator;
@@ -966,10 +1050,11 @@ 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 setupAsync(input, operationId) {
@@ -1027,7 +1112,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();
       }
@@ -1054,7 +1139,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();
       }
@@ -1155,3 +1265,5 @@ export {
   LogLevel,
   BuildConfiguration2 as BuildConfiguration
 };
+
+//# debugId=00A5AFB7E48A8EC764756E2164756E21

package/dist/node.js

@@ -422,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
@@ -513,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));
   }
@@ -805,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;
@@ -816,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);
@@ -837,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) {
@@ -847,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
@@ -865,18 +897,27 @@ 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 () => {
@@ -915,6 +956,48 @@ class SolutionPackService {
   }
 }
 
+// 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
 import {
   PackagerParametersValidator as PackagerParametersValidator2
@@ -928,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;
@@ -944,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 });
   }
 }
@@ -968,6 +1051,7 @@ class SolutionPackager {
   projectExecutor;
   solutionLoader;
   solutionPackService;
+  solutionRestoreService;
   solutionValidateService;
   packOptionsValidator;
   validateOptionsValidator;
@@ -986,10 +1070,11 @@ 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 setupAsync(input, operationId) {
@@ -1047,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();
       }
@@ -1074,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();
       }
@@ -1152,3 +1262,5 @@ export {
   SolutionPackager,
   SolutionPackOptions
 };
+
+//# debugId=374EFD55C7484FC664756E2164756E21

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

@@ -10,9 +10,17 @@ import { type ISolutionPackager } from "./services/solution-packager.js";
  *
  * @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/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-pack-service.d.ts

@@ -1,4 +1,4 @@
-import type { IProjectToolExecutor, ITelemetryService, IToolsFactory } from "@uipath/project-packager";
+import { type IPackageSignService, type IProjectToolExecutor, type ITelemetryService, type IToolsFactory } from "@uipath/project-packager";
 import { type IFileSystem, type IZipService, type ProjectOperationContext, ToolResult } from "@uipath/solutionpackager-tool-core";
 import type { LoadedUiPathSolution } from "../models/loaded-uipath-solution.js";
 import type { SolutionPackOptions } from "../models/solution-pack-options.js";
@@ -19,7 +19,8 @@ export declare class SolutionPackService implements ISolutionPackService {
     private readonly zipService;
     private readonly fileSystem;
     private readonly telemetry;
-    constructor(optionsBuilder: IOptionsBuilder, toolsFactory: IToolsFactory, projectExecutor: IProjectToolExecutor, zipService: IZipService, fileSystem: IFileSystem, telemetry: ITelemetryService);
+    private readonly packageSignService?;
+    constructor(optionsBuilder: IOptionsBuilder, toolsFactory: IToolsFactory, projectExecutor: IProjectToolExecutor, zipService: IZipService, fileSystem: IFileSystem, telemetry: ITelemetryService, packageSignService?: IPackageSignService | undefined);
     packAsync(parameters: SolutionPackOptions, solution: LoadedUiPathSolution, context: ProjectOperationContext, cancellationToken?: AbortSignal): Promise<ToolResult>;
     /**
      * Pack all projects in parallel
@@ -39,17 +40,21 @@ export declare class SolutionPackService implements ISolutionPackService {
      */
     private packSingleProjectAsync;
     /**
-     * Check if any results in the array have failed
-     * @param results Array of tool results
-     * @returns True if any result has failed, false otherwise
+     * Sign the project .nupkg(s) produced for the solution, before zipping.
+     *
+     * Project tools write their package into the solution output tree; the
+     * workflow compiler reports a content *folder* rather than the .nupkg, so
+     * each produced path is resolved to the real .nupkg first. Unlike the
+     * single-project packager there's no copy/pack-from-content step here, so a
+     * path that resolves to nothing means the package is genuinely missing —
+     * fail loudly rather than zip an unsigned (or absent) package.
+     *
+     * A no-op when signing isn't requested (no signing info or no certificate).
+     * @param projectResults The per-project pack results, holding produced paths
+     * @param signingInfo Signing configuration, if signing was requested
+     * @returns Success, or the first signing/resolution failure
      */
-    private hasFailedResults;
-    /**
-     * Get a combined error message from all failed results
-     * @param results Array of tool results
-     * @returns Combined error message
-     */
-    private getFailedResultsMessage;
+    private signProjectPackagesAsync;
     /**
      * Compress the solution output folder into a zip archive
      * @param parameters Solution pack parameters

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

@@ -39,6 +39,15 @@ export interface ISolutionPackager {
      * @returns ToolResult indicating success if every project passed validation
      */
     validateSolutionAsync(options: SolutionPackOptions, cancellationToken?: AbortSignal): Promise<ToolResult>;
+    /**
+     * Restore dependencies for every project in a solution, without packing
+     * or building. Resolves NuGet dependencies (including authenticated feeds
+     * carried by `options.connection`) so a later pack can compile offline.
+     * @param options Solution pack options containing all parameters
+     * @param cancellationToken Optional cancellation token
+     * @returns ToolResult indicating success if every project restored
+     */
+    restoreSolutionAsync(options: SolutionPackOptions, cancellationToken?: AbortSignal): Promise<ToolResult>;
     /**
      * Convert a successful ToolResult to a list of package streams.
      * @param result The ToolResult to convert
@@ -60,6 +69,7 @@ export declare class SolutionPackager implements ISolutionPackager {
     private readonly projectExecutor;
     private readonly solutionLoader;
     private readonly solutionPackService;
+    private readonly solutionRestoreService;
     private readonly solutionValidateService;
     private readonly packOptionsValidator;
     private readonly validateOptionsValidator;
@@ -91,6 +101,11 @@ export declare class SolutionPackager implements ISolutionPackager {
      * Validate all projects in a solution using the provided options.
      */
     validateSolutionAsync(options: SolutionPackOptions, cancellationToken?: AbortSignal): Promise<ToolResult>;
+    /**
+     * Restore dependencies for every project in a solution, without packing
+     * or building.
+     */
+    restoreSolutionAsync(options: SolutionPackOptions, cancellationToken?: AbortSignal): Promise<ToolResult>;
     /**
      * Narrow the solution's project list to the subset the caller asked for.
      * An empty or absent `projectDesignIds` is a no-op (the whole solution is

package/dist/src/telemetry-names.d.ts

@@ -1,7 +1,9 @@
 export declare enum TelemetryNames {
     SolutionPackagerPackSolution = "SolutionPackager.PackSolution",
     SolutionPackagerValidateSolution = "SolutionPackager.ValidateSolution",
+    SolutionPackagerRestoreSolution = "SolutionPackager.RestoreSolution",
     SolutionPack = "SolutionPackager.Solution.Pack",
     SolutionValidate = "SolutionPackager.Solution.Validate",
+    SolutionRestore = "SolutionPackager.Solution.Restore",
     SolutionCompress = "SolutionPackager.Solution.Compress"
 }

package/dist/tests/solution-packager.e2e.test.d.ts

@@ -1,10 +1 @@
-import "@uipath/packager-tool-connector";
-import "@uipath/packager-tool-workflowcompiler";
-import "@uipath/packager-tool-apiworkflow";
-import "@uipath/packager-tool-bpmn";
-import "@uipath/packager-tool-case";
-import "@uipath/packager-tool-flow";
-import "@uipath/tool-agent";
-import "@uipath/packager-tool-functions";
-import "@uipath/packager-tool-webapp";
-import "@uipath/resource-builder-tool";
+export {};

package/package.json

@@ -1,61 +1,38 @@
 {
-    "name": "@uipath/solution-packager",
-    "license": "MIT",
-    "version": "1.196.0",
-    "description": "UiPath Solution Packager - core library for packing UiPath solutions",
-    "type": "module",
-    "main": "./dist/index.js",
-    "exports": {
-        ".": {
-            "types": "./dist/src/index.d.ts",
-            "default": "./dist/index.js"
-        },
-        "./node": {
-            "types": "./dist/src/node.d.ts",
-            "default": "./dist/node.js"
-        }
+  "name": "@uipath/solution-packager",
+  "license": "MIT",
+  "version": "1.197.0-preview.65",
+  "description": "UiPath Solution Packager - core library for packing UiPath solutions",
+  "type": "module",
+  "main": "./dist/index.js",
+  "exports": {
+    ".": {
+      "types": "./dist/src/index.d.ts",
+      "default": "./dist/index.js"
     },
-    "types": "./dist/src/index.d.ts",
-    "repository": {
-        "type": "git",
-        "url": "https://github.com/UiPath/cli.git",
-        "directory": "packages/packager/solution-packager"
-    },
-    "publishConfig": {
-        "registry": "https://registry.npmjs.org/"
-    },
-    "files": [
-        "dist",
-        "!dist/**/*.map"
-    ],
-    "dependencies": {
-        "@uipath/project-packager": "1.196.0",
-        "@uipath/solutionpackager-tool-core": "1.196.0"
-    },
-    "peerDependencies": {
-        "fflate": "^0.8.2"
-    },
-    "devDependencies": {
-        "@types/node": "^25.5.2",
-        "@uipath/common": "1.196.0",
-        "@uipath/filesystem": "1.196.0",
-        "@uipath/resource-builder-tool": "2025.11.0-alpha2928-3101",
-        "@uipath/tool-agent": "^1.2.6",
-        "@uipath/packager-tool-apiworkflow": "1.196.0",
-        "@uipath/packager-tool-bpmn": "1.196.0",
-        "@uipath/packager-tool-case": "1.196.0",
-        "@uipath/packager-tool-connector": "1.196.0",
-        "@uipath/packager-tool-flow": "1.196.0",
-        "@uipath/packager-tool-functions": "1.196.0",
-        "@uipath/packager-tool-webapp": "1.196.0",
-        "@uipath/packager-tool-workflowcompiler": "1.196.0",
-        "@vitest/browser": "^4.1.6",
-        "@vitest/browser-playwright": "^4.1.6",
-        "@vitest/coverage-v8": "^4.1.6",
-        "playwright": "^1.57.0",
-        "typescript": "^6.0.2",
-        "vite-tsconfig-paths": "^6.1.1",
-        "vitest": "^4.1.6"
-    },
-    "gitHead": "bed2b46f1ec33a47a7dcae2e6d4b7ab99bd06981"
+    "./node": {
+      "types": "./dist/src/node.d.ts",
+      "default": "./dist/node.js"
+    }
+  },
+  "types": "./dist/src/index.d.ts",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/UiPath/cli.git",
+    "directory": "packages/packager/solution-packager"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/"
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@uipath/project-packager": "1.197.0",
+    "@uipath/solutionpackager-tool-core": "1.197.0"
+  },
+  "peerDependencies": {
+    "fflate": "^0.8.2"
+  },
+  "gitHead": "9388ccbe5e739c9578bfd9b5395980fb63e11d9c"
 }