@uipath/solution-packager 1.197.0 → 1.198.0-preview.80

package/dist/index.js

@@ -402,8 +402,8 @@ import {
   Path as Path4,
   TargetFramework,
   TemporaryStorageService,
-  ToolErrorCodes as ToolErrorCodes4,
-  ToolResult as ToolResult4,
+  ToolErrorCodes as ToolErrorCodes5,
+  ToolResult as ToolResult5,
   toolsFactoryRepository,
   translate as translate3,
   ZipService
@@ -505,6 +505,16 @@ class OptionsBuilder {
       outputPath: await this.buildProjectOutputPath(solutionOptions.outputPath, project)
     };
   }
+  buildProjectCleanupOptions(solutionOptions, project) {
+    return {
+      projectPath: this.resolveProjectPath(solutionOptions, project),
+      excludeConfiguredSources: solutionOptions.excludeConfiguredSources ?? false,
+      nuGetSourcesConfigPath: solutionOptions.nuGetSourcesConfigPath,
+      logLevel: solutionOptions.logLevel,
+      dryRun: solutionOptions.cleanupOptions.dryRun,
+      skipImports: solutionOptions.cleanupOptions.skipImports
+    };
+  }
   resolveProjectPath(solutionOptions, project) {
     return Path.join(solutionOptions.inputPath, Path.dirname(project.ProjectRelativePath));
   }
@@ -611,7 +621,7 @@ class PackageIdReader {
       const resource = resources.find((r) => {
         const projectKey = this.getProperty(r, "projectKey");
         const kind = this.getProperty(r, "kind");
-        return projectKey === project.Id && kind?.toLowerCase() === "process";
+        return projectKey === project.Id && typeof kind === "string" && kind.toLowerCase() === "process";
       });
       if (!resource) {
         return null;
@@ -652,9 +662,9 @@ class PackageIdReader {
         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;
+          const packageName = this.getProperty(spec, "packageName");
+          if (typeof packageName !== "string" || packageName.trim() === "") {
+            return null;
           }
           return packageName;
         }
@@ -674,6 +684,77 @@ class PackageIdReader {
   }
 }
 
+// src/services/solution-cleanup-service.ts
+import {
+  ToolErrorCodes,
+  ToolResult
+} from "@uipath/solutionpackager-tool-core";
+class SolutionCleanupService {
+  optionsBuilder;
+  projectExecutor;
+  telemetry;
+  constructor(optionsBuilder, projectExecutor, telemetry) {
+    this.optionsBuilder = optionsBuilder;
+    this.projectExecutor = projectExecutor;
+    this.telemetry = telemetry;
+  }
+  async cleanupAsync(parameters, solution, context, cancellationToken) {
+    return await this.telemetry.trackDependencyOperation("SolutionPackager.Solution.Cleanup" /* SolutionCleanup */, "cleanup", async () => {
+      const projectResults = await Promise.all(solution.Projects.map(async (project) => {
+        if (project.ProjectPath == null) {
+          return {
+            project,
+            result: ToolResult.error(ToolErrorCodes.InternalError, `Project '${project.Id}' has no ProjectPath; the solution loader must populate it before cleanup.`)
+          };
+        }
+        const result2 = await this.projectExecutor.cleanupAsync(this.optionsBuilder.buildProjectCleanupOptions(parameters, project), project, context, cancellationToken);
+        return { project, result: result2 };
+      }));
+      const failed = projectResults.find((r) => !r.result.isSuccess);
+      if (failed) {
+        return failed.result;
+      }
+      const result = ToolResult.success();
+      const details = {};
+      const changedFilesByProject = this.mergeChangedFiles(projectResults.map((r) => r.result));
+      if (Object.keys(changedFilesByProject).length > 0) {
+        details.changedFilesByProject = changedFilesByProject;
+      }
+      const cleanupByProject = this.collectProjectCleanups(projectResults);
+      if (Object.keys(cleanupByProject).length > 0) {
+        details.cleanupByProject = cleanupByProject;
+      }
+      if (Object.keys(details).length > 0) {
+        result.details = details;
+      }
+      return result;
+    }, { solutionId: solution.SolutionId });
+  }
+  mergeChangedFiles(results) {
+    const merged = {};
+    for (const result of results) {
+      const changed = result.details?.changedFilesByProject;
+      if (!changed) {
+        continue;
+      }
+      for (const [projectId, files] of Object.entries(changed)) {
+        merged[projectId] = files;
+      }
+    }
+    return merged;
+  }
+  collectProjectCleanups(results) {
+    const byProject = {};
+    for (const { project, result } of results) {
+      const info = result.details?.projectCleanup;
+      if (info) {
+        byProject[project.Id] = info;
+      }
+    }
+    return byProject;
+  }
+}
+
 // src/services/solution-loader.ts
 import { Path as Path3, translate as translate2 } from "@uipath/solutionpackager-tool-core";
 
@@ -802,8 +883,8 @@ import {
   signNupkgsAsync
 } from "@uipath/project-packager";
 import {
-  ToolErrorCodes,
-  ToolResult
+  ToolErrorCodes as ToolErrorCodes2,
+  ToolResult as ToolResult2
 } from "@uipath/solutionpackager-tool-core";
 
 // src/services/tool-result-helpers.ts
@@ -846,21 +927,21 @@ class SolutionPackService {
           ...projectResults
         ];
         if (hasFailedResults(restoreAndPackResults)) {
-          return ToolResult.error(ToolErrorCodes.InternalError, `Solution pack failed: ${getFailedResultsMessage(restoreAndPackResults)}`);
+          return ToolResult2.error(ToolErrorCodes2.InternalError, `Solution pack failed: ${getFailedResultsMessage(restoreAndPackResults)}`);
         }
         const buildResult = await solutionTool.buildAsync(solutionOptions, cancellationToken);
         if (!buildResult.isSuccess) {
-          return ToolResult.error(buildResult.errorCode, `Solution build failed: ${buildResult.message || "Unknown error"}`);
+          return ToolResult2.error(buildResult.errorCode, `Solution build failed: ${buildResult.message || "Unknown error"}`);
         }
         if (!solutionOptions.outputPath) {
-          return ToolResult.error(ToolErrorCodes.InternalError, "Solution output path is not defined");
+          return ToolResult2.error(ToolErrorCodes2.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, [
+        return new ToolResult2(ToolErrorCodes2.Success, undefined, [
           archivePath
         ]);
       }, { solutionId: solution.SolutionId });
@@ -880,12 +961,12 @@ class SolutionPackService {
       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);
+      return ToolResult2.error(ToolErrorCodes2.InternalError, errorMessage);
     }
   }
   async signProjectPackagesAsync(projectResults, signingInfo) {
     if (!signingInfo?.certificatePath) {
-      return ToolResult.success();
+      return ToolResult2.success();
     }
     const producedPaths = projectResults.flatMap((result) => result.packages);
     const resolved = await Promise.all(producedPaths.map(async (producedPath) => ({
@@ -894,7 +975,7 @@ class SolutionPackService {
     })));
     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(", ")}.`);
+      return ToolResult2.error(ToolErrorCodes2.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);
@@ -938,8 +1019,8 @@ class SolutionPackService {
 
 // src/services/solution-restore-service.ts
 import {
-  ToolErrorCodes as ToolErrorCodes2,
-  ToolResult as ToolResult2
+  ToolErrorCodes as ToolErrorCodes3,
+  ToolResult as ToolResult3
 } from "@uipath/solutionpackager-tool-core";
 class SolutionRestoreService {
   optionsBuilder;
@@ -965,9 +1046,9 @@ class SolutionRestoreService {
           })
         ]);
         if (hasFailedResults(restoreResults)) {
-          return ToolResult2.error(ToolErrorCodes2.InternalError, `Solution restore failed: ${getFailedResultsMessage(restoreResults)}`);
+          return ToolResult3.error(ToolErrorCodes3.InternalError, `Solution restore failed: ${getFailedResultsMessage(restoreResults)}`);
         }
-        return ToolResult2.success();
+        return ToolResult3.success();
       }, { solutionId: solution.SolutionId });
     } finally {
       const disposeResult = solutionTool.dispose();
@@ -991,8 +1072,8 @@ class SolutionValidateOptionsValidator extends PackagerParametersValidator2 {
 
 // src/services/solution-validate-service.ts
 import {
-  ToolErrorCodes as ToolErrorCodes3,
-  ToolResult as ToolResult3
+  ToolErrorCodes as ToolErrorCodes4,
+  ToolResult as ToolResult4
 } from "@uipath/solutionpackager-tool-core";
 class SolutionValidateService {
   optionsBuilder;
@@ -1007,12 +1088,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(ToolResult3.error(ToolErrorCodes3.InternalError, `Project '${project.Id}' has no ProjectPath; the solution loader must populate it before validation.`));
+          return Promise.resolve(ToolResult4.error(ToolErrorCodes4.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 ?? ToolResult3.success();
+      return failed ?? ToolResult4.success();
     }, { solutionId: solution.SolutionId });
   }
 }
@@ -1033,6 +1114,7 @@ class SolutionPackager {
   solutionPackService;
   solutionRestoreService;
   solutionValidateService;
+  solutionCleanupService;
   packOptionsValidator;
   validateOptionsValidator;
   governancePolicyService;
@@ -1056,6 +1138,7 @@ class SolutionPackager {
     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);
+    this.solutionCleanupService = new SolutionCleanupService(this.optionsBuilder, this.projectExecutor, this.telemetryService);
   }
   async setupAsync(input, operationId) {
     this.telemetryService.setOperationId(operationId);
@@ -1112,7 +1195,7 @@ class SolutionPackager {
       } catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);
         this.logger.error(`Processing error: ${errorMessage}`);
-        return ToolResult4.error(ToolErrorCodes4.InternalError, `Solution pack failed: ${errorMessage}`);
+        return ToolResult5.error(ToolErrorCodes5.InternalError, `Solution pack failed: ${errorMessage}`);
       } finally {
         await this.temporaryStorage.cleanup();
       }
@@ -1139,7 +1222,7 @@ class SolutionPackager {
       } catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);
         this.logger.error(`Processing error: ${errorMessage}`);
-        return ToolResult4.error(ToolErrorCodes4.InternalError, `Solution validate failed: ${errorMessage}`);
+        return ToolResult5.error(ToolErrorCodes5.InternalError, `Solution validate failed: ${errorMessage}`);
       } finally {
         await this.temporaryStorage.cleanup();
       }
@@ -1164,7 +1247,29 @@ class SolutionPackager {
       } 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}`);
+        return ToolResult5.error(ToolErrorCodes5.InternalError, `Solution restore failed: ${errorMessage}`);
+      } finally {
+        await this.temporaryStorage.cleanup();
+      }
+    });
+  }
+  async cleanupSolutionAsync(options, cancellationToken) {
+    return await this.telemetryService.trackRequest("SolutionPackager.CleanupSolution" /* SolutionPackagerCleanupSolution */, async () => {
+      try {
+        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.solutionCleanupService.cleanupAsync(options, solution, context, cancellationToken);
+        if (result.isSuccess) {
+          this.logger.info("Solution cleanup completed successfully.");
+        } else {
+          this.logger.error(`Solution cleanup 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 ToolResult5.error(ToolErrorCodes5.InternalError, `Solution cleanup failed: ${errorMessage}`);
       } finally {
         await this.temporaryStorage.cleanup();
       }
@@ -1189,11 +1294,13 @@ class SolutionPackager {
       id: crypto.randomUUID(),
       projects: solution.Projects,
       downloadUrl: options.downloadUrl,
+      solutionId: solution.SolutionId,
       configuration: options.configuration,
       targetFramework: options.targetFramework ?? TargetFramework.Portable,
       connection: options.connection,
       logger: this.logger,
-      workflowCompilerVersion: options.workflowCompilerVersion
+      workflowCompilerVersion: options.workflowCompilerVersion,
+      lockKey: options.lockKey
     };
   }
   async getPackageStreamsAsync(result) {
@@ -1256,6 +1363,11 @@ class SolutionPackOptions extends PackagerParameters {
   signingInfo;
   packOptions;
   publishInfo;
+  cleanupOptions = {
+    dryRun: false,
+    skipImports: false
+  };
+  lockKey;
 }
 export {
   createBrowserSolutionPackager,
@@ -1266,4 +1378,4 @@ export {
   BuildConfiguration2 as BuildConfiguration
 };
 
-//# debugId=00A5AFB7E48A8EC764756E2164756E21
+//# debugId=AED86F1027DF443564756E2164756E21

package/dist/node.js

@@ -401,6 +401,11 @@ class SolutionPackOptions extends PackagerParameters {
   signingInfo;
   packOptions;
   publishInfo;
+  cleanupOptions = {
+    dryRun: false,
+    skipImports: false
+  };
+  lockKey;
 }
 // src/node-solution-packager-factory.ts
 import {
@@ -422,8 +427,8 @@ import {
   Path as Path4,
   TargetFramework,
   TemporaryStorageService,
-  ToolErrorCodes as ToolErrorCodes4,
-  ToolResult as ToolResult4,
+  ToolErrorCodes as ToolErrorCodes5,
+  ToolResult as ToolResult5,
   toolsFactoryRepository,
   translate as translate3,
   ZipService
@@ -525,6 +530,16 @@ class OptionsBuilder {
       outputPath: await this.buildProjectOutputPath(solutionOptions.outputPath, project)
     };
   }
+  buildProjectCleanupOptions(solutionOptions, project) {
+    return {
+      projectPath: this.resolveProjectPath(solutionOptions, project),
+      excludeConfiguredSources: solutionOptions.excludeConfiguredSources ?? false,
+      nuGetSourcesConfigPath: solutionOptions.nuGetSourcesConfigPath,
+      logLevel: solutionOptions.logLevel,
+      dryRun: solutionOptions.cleanupOptions.dryRun,
+      skipImports: solutionOptions.cleanupOptions.skipImports
+    };
+  }
   resolveProjectPath(solutionOptions, project) {
     return Path.join(solutionOptions.inputPath, Path.dirname(project.ProjectRelativePath));
   }
@@ -631,7 +646,7 @@ class PackageIdReader {
       const resource = resources.find((r) => {
         const projectKey = this.getProperty(r, "projectKey");
         const kind = this.getProperty(r, "kind");
-        return projectKey === project.Id && kind?.toLowerCase() === "process";
+        return projectKey === project.Id && typeof kind === "string" && kind.toLowerCase() === "process";
       });
       if (!resource) {
         return null;
@@ -672,9 +687,9 @@ class PackageIdReader {
         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;
+          const packageName = this.getProperty(spec, "packageName");
+          if (typeof packageName !== "string" || packageName.trim() === "") {
+            return null;
           }
           return packageName;
         }
@@ -694,6 +709,77 @@ class PackageIdReader {
   }
 }
 
+// src/services/solution-cleanup-service.ts
+import {
+  ToolErrorCodes,
+  ToolResult
+} from "@uipath/solutionpackager-tool-core";
+class SolutionCleanupService {
+  optionsBuilder;
+  projectExecutor;
+  telemetry;
+  constructor(optionsBuilder, projectExecutor, telemetry) {
+    this.optionsBuilder = optionsBuilder;
+    this.projectExecutor = projectExecutor;
+    this.telemetry = telemetry;
+  }
+  async cleanupAsync(parameters, solution, context, cancellationToken) {
+    return await this.telemetry.trackDependencyOperation("SolutionPackager.Solution.Cleanup" /* SolutionCleanup */, "cleanup", async () => {
+      const projectResults = await Promise.all(solution.Projects.map(async (project) => {
+        if (project.ProjectPath == null) {
+          return {
+            project,
+            result: ToolResult.error(ToolErrorCodes.InternalError, `Project '${project.Id}' has no ProjectPath; the solution loader must populate it before cleanup.`)
+          };
+        }
+        const result2 = await this.projectExecutor.cleanupAsync(this.optionsBuilder.buildProjectCleanupOptions(parameters, project), project, context, cancellationToken);
+        return { project, result: result2 };
+      }));
+      const failed = projectResults.find((r) => !r.result.isSuccess);
+      if (failed) {
+        return failed.result;
+      }
+      const result = ToolResult.success();
+      const details = {};
+      const changedFilesByProject = this.mergeChangedFiles(projectResults.map((r) => r.result));
+      if (Object.keys(changedFilesByProject).length > 0) {
+        details.changedFilesByProject = changedFilesByProject;
+      }
+      const cleanupByProject = this.collectProjectCleanups(projectResults);
+      if (Object.keys(cleanupByProject).length > 0) {
+        details.cleanupByProject = cleanupByProject;
+      }
+      if (Object.keys(details).length > 0) {
+        result.details = details;
+      }
+      return result;
+    }, { solutionId: solution.SolutionId });
+  }
+  mergeChangedFiles(results) {
+    const merged = {};
+    for (const result of results) {
+      const changed = result.details?.changedFilesByProject;
+      if (!changed) {
+        continue;
+      }
+      for (const [projectId, files] of Object.entries(changed)) {
+        merged[projectId] = files;
+      }
+    }
+    return merged;
+  }
+  collectProjectCleanups(results) {
+    const byProject = {};
+    for (const { project, result } of results) {
+      const info = result.details?.projectCleanup;
+      if (info) {
+        byProject[project.Id] = info;
+      }
+    }
+    return byProject;
+  }
+}
+
 // src/services/solution-loader.ts
 import { Path as Path3, translate as translate2 } from "@uipath/solutionpackager-tool-core";
 
@@ -822,8 +908,8 @@ import {
   signNupkgsAsync
 } from "@uipath/project-packager";
 import {
-  ToolErrorCodes,
-  ToolResult
+  ToolErrorCodes as ToolErrorCodes2,
+  ToolResult as ToolResult2
 } from "@uipath/solutionpackager-tool-core";
 
 // src/services/tool-result-helpers.ts
@@ -866,21 +952,21 @@ class SolutionPackService {
           ...projectResults
         ];
         if (hasFailedResults(restoreAndPackResults)) {
-          return ToolResult.error(ToolErrorCodes.InternalError, `Solution pack failed: ${getFailedResultsMessage(restoreAndPackResults)}`);
+          return ToolResult2.error(ToolErrorCodes2.InternalError, `Solution pack failed: ${getFailedResultsMessage(restoreAndPackResults)}`);
         }
         const buildResult = await solutionTool.buildAsync(solutionOptions, cancellationToken);
         if (!buildResult.isSuccess) {
-          return ToolResult.error(buildResult.errorCode, `Solution build failed: ${buildResult.message || "Unknown error"}`);
+          return ToolResult2.error(buildResult.errorCode, `Solution build failed: ${buildResult.message || "Unknown error"}`);
         }
         if (!solutionOptions.outputPath) {
-          return ToolResult.error(ToolErrorCodes.InternalError, "Solution output path is not defined");
+          return ToolResult2.error(ToolErrorCodes2.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, [
+        return new ToolResult2(ToolErrorCodes2.Success, undefined, [
           archivePath
         ]);
       }, { solutionId: solution.SolutionId });
@@ -900,12 +986,12 @@ class SolutionPackService {
       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);
+      return ToolResult2.error(ToolErrorCodes2.InternalError, errorMessage);
     }
   }
   async signProjectPackagesAsync(projectResults, signingInfo) {
     if (!signingInfo?.certificatePath) {
-      return ToolResult.success();
+      return ToolResult2.success();
     }
     const producedPaths = projectResults.flatMap((result) => result.packages);
     const resolved = await Promise.all(producedPaths.map(async (producedPath) => ({
@@ -914,7 +1000,7 @@ class SolutionPackService {
     })));
     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(", ")}.`);
+      return ToolResult2.error(ToolErrorCodes2.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);
@@ -958,8 +1044,8 @@ class SolutionPackService {
 
 // src/services/solution-restore-service.ts
 import {
-  ToolErrorCodes as ToolErrorCodes2,
-  ToolResult as ToolResult2
+  ToolErrorCodes as ToolErrorCodes3,
+  ToolResult as ToolResult3
 } from "@uipath/solutionpackager-tool-core";
 class SolutionRestoreService {
   optionsBuilder;
@@ -985,9 +1071,9 @@ class SolutionRestoreService {
           })
         ]);
         if (hasFailedResults(restoreResults)) {
-          return ToolResult2.error(ToolErrorCodes2.InternalError, `Solution restore failed: ${getFailedResultsMessage(restoreResults)}`);
+          return ToolResult3.error(ToolErrorCodes3.InternalError, `Solution restore failed: ${getFailedResultsMessage(restoreResults)}`);
         }
-        return ToolResult2.success();
+        return ToolResult3.success();
       }, { solutionId: solution.SolutionId });
     } finally {
       const disposeResult = solutionTool.dispose();
@@ -1011,8 +1097,8 @@ class SolutionValidateOptionsValidator extends PackagerParametersValidator2 {
 
 // src/services/solution-validate-service.ts
 import {
-  ToolErrorCodes as ToolErrorCodes3,
-  ToolResult as ToolResult3
+  ToolErrorCodes as ToolErrorCodes4,
+  ToolResult as ToolResult4
 } from "@uipath/solutionpackager-tool-core";
 class SolutionValidateService {
   optionsBuilder;
@@ -1027,12 +1113,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(ToolResult3.error(ToolErrorCodes3.InternalError, `Project '${project.Id}' has no ProjectPath; the solution loader must populate it before validation.`));
+          return Promise.resolve(ToolResult4.error(ToolErrorCodes4.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 ?? ToolResult3.success();
+      return failed ?? ToolResult4.success();
     }, { solutionId: solution.SolutionId });
   }
 }
@@ -1053,6 +1139,7 @@ class SolutionPackager {
   solutionPackService;
   solutionRestoreService;
   solutionValidateService;
+  solutionCleanupService;
   packOptionsValidator;
   validateOptionsValidator;
   governancePolicyService;
@@ -1076,6 +1163,7 @@ class SolutionPackager {
     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);
+    this.solutionCleanupService = new SolutionCleanupService(this.optionsBuilder, this.projectExecutor, this.telemetryService);
   }
   async setupAsync(input, operationId) {
     this.telemetryService.setOperationId(operationId);
@@ -1132,7 +1220,7 @@ class SolutionPackager {
       } catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);
         this.logger.error(`Processing error: ${errorMessage}`);
-        return ToolResult4.error(ToolErrorCodes4.InternalError, `Solution pack failed: ${errorMessage}`);
+        return ToolResult5.error(ToolErrorCodes5.InternalError, `Solution pack failed: ${errorMessage}`);
       } finally {
         await this.temporaryStorage.cleanup();
       }
@@ -1159,7 +1247,7 @@ class SolutionPackager {
       } catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);
         this.logger.error(`Processing error: ${errorMessage}`);
-        return ToolResult4.error(ToolErrorCodes4.InternalError, `Solution validate failed: ${errorMessage}`);
+        return ToolResult5.error(ToolErrorCodes5.InternalError, `Solution validate failed: ${errorMessage}`);
       } finally {
         await this.temporaryStorage.cleanup();
       }
@@ -1184,7 +1272,29 @@ class SolutionPackager {
       } 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}`);
+        return ToolResult5.error(ToolErrorCodes5.InternalError, `Solution restore failed: ${errorMessage}`);
+      } finally {
+        await this.temporaryStorage.cleanup();
+      }
+    });
+  }
+  async cleanupSolutionAsync(options, cancellationToken) {
+    return await this.telemetryService.trackRequest("SolutionPackager.CleanupSolution" /* SolutionPackagerCleanupSolution */, async () => {
+      try {
+        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.solutionCleanupService.cleanupAsync(options, solution, context, cancellationToken);
+        if (result.isSuccess) {
+          this.logger.info("Solution cleanup completed successfully.");
+        } else {
+          this.logger.error(`Solution cleanup 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 ToolResult5.error(ToolErrorCodes5.InternalError, `Solution cleanup failed: ${errorMessage}`);
       } finally {
         await this.temporaryStorage.cleanup();
       }
@@ -1209,11 +1319,13 @@ class SolutionPackager {
       id: crypto.randomUUID(),
       projects: solution.Projects,
       downloadUrl: options.downloadUrl,
+      solutionId: solution.SolutionId,
       configuration: options.configuration,
       targetFramework: options.targetFramework ?? TargetFramework.Portable,
       connection: options.connection,
       logger: this.logger,
-      workflowCompilerVersion: options.workflowCompilerVersion
+      workflowCompilerVersion: options.workflowCompilerVersion,
+      lockKey: options.lockKey
     };
   }
   async getPackageStreamsAsync(result) {
@@ -1263,4 +1375,4 @@ export {
   SolutionPackOptions
 };
 
-//# debugId=374EFD55C7484FC664756E2164756E21
+//# debugId=6638B6BAF951D31364756E2164756E21

package/dist/src/models/solution-pack-options.d.ts

@@ -39,4 +39,24 @@ export declare class SolutionPackOptions extends PackagerParameters {
      * Publish information
      */
     publishInfo?: PublishInfo;
+    /**
+     * Cleanup options. Defaults to removing unused items and cleaning up
+     * now-unused references to them in the project's files.
+     */
+    cleanupOptions: CleanupOptions;
+    /**
+     * Lock key of the current editing session. Forwarded to the remote agent for
+     * Cleanup so its save-back overwrite is accepted while the solution is locked
+     * by that session. Set by the caller that holds the lock.
+     */
+    lockKey?: string;
+}
+/**
+ * Options controlling the cleanup operation.
+ */
+export interface CleanupOptions {
+    /** Detect unused items without modifying the project. */
+    dryRun: boolean;
+    /** Do not clean up now-unused references to removed items in the project's files. */
+    skipImports: boolean;
 }

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 IProjectRestoreOptions, type IProjectValidateOptions, type ISolutionPackOptions } from "@uipath/solutionpackager-tool-core";
+import { type IFileSystem, type IProjectCleanupOptions, 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";
@@ -23,6 +23,10 @@ export interface IOptionsBuilder {
      * Build project restore options from solution parameters, for a specific project
      */
     buildProjectRestoreOptions(options: SolutionPackOptions, project: UiPathProject): Promise<IProjectRestoreOptions>;
+    /**
+     * Build project cleanup options from solution parameters, for a specific project
+     */
+    buildProjectCleanupOptions(options: SolutionPackOptions, project: UiPathProject): IProjectCleanupOptions;
 }
 export declare class OptionsBuilder implements IOptionsBuilder {
     private readonly packageIdReader;
@@ -38,6 +42,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>;
+    buildProjectCleanupOptions(solutionOptions: SolutionPackOptions, project: UiPathProject): IProjectCleanupOptions;
     private resolveProjectPath;
     /**
      * Build the output path for a project

package/dist/src/services/solution-cleanup-service.d.ts

@@ -0,0 +1,20 @@
+import type { IProjectToolExecutor, ITelemetryService } from "@uipath/project-packager";
+import { 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";
+import type { IOptionsBuilder } from "./options-builder.js";
+export interface ISolutionCleanupService {
+    /**
+     * Clean up every project in the solution by removing unused items.
+     */
+    cleanupAsync(parameters: SolutionPackOptions, solution: LoadedUiPathSolution, context: ProjectOperationContext, cancellationToken?: AbortSignal): Promise<ToolResult>;
+}
+export declare class SolutionCleanupService implements ISolutionCleanupService {
+    private readonly optionsBuilder;
+    private readonly projectExecutor;
+    private readonly telemetry;
+    constructor(optionsBuilder: IOptionsBuilder, projectExecutor: IProjectToolExecutor, telemetry: ITelemetryService);
+    cleanupAsync(parameters: SolutionPackOptions, solution: LoadedUiPathSolution, context: ProjectOperationContext, cancellationToken?: AbortSignal): Promise<ToolResult>;
+    private mergeChangedFiles;
+    private collectProjectCleanups;
+}

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

@@ -48,6 +48,15 @@ export interface ISolutionPackager {
      * @returns ToolResult indicating success if every project restored
      */
     restoreSolutionAsync(options: SolutionPackOptions, cancellationToken?: AbortSignal): Promise<ToolResult>;
+    /**
+     * Clean up every project in a solution by removing unused items. Modifies the
+     * project sources in place. When run via the remote agent against a cloud
+     * solution, the agent also saves the modified solution back to StudioWeb.
+     * @param options Solution pack options containing all parameters
+     * @param cancellationToken Optional cancellation token
+     * @returns ToolResult; `details.changedFilesByProject` lists the changed files per project
+     */
+    cleanupSolutionAsync(options: SolutionPackOptions, cancellationToken?: AbortSignal): Promise<ToolResult>;
     /**
      * Convert a successful ToolResult to a list of package streams.
      * @param result The ToolResult to convert
@@ -71,6 +80,7 @@ export declare class SolutionPackager implements ISolutionPackager {
     private readonly solutionPackService;
     private readonly solutionRestoreService;
     private readonly solutionValidateService;
+    private readonly solutionCleanupService;
     private readonly packOptionsValidator;
     private readonly validateOptionsValidator;
     private readonly governancePolicyService;
@@ -106,6 +116,10 @@ export declare class SolutionPackager implements ISolutionPackager {
      * or building.
      */
     restoreSolutionAsync(options: SolutionPackOptions, cancellationToken?: AbortSignal): Promise<ToolResult>;
+    /**
+     * Clean up every project in a solution by removing unused items.
+     */
+    cleanupSolutionAsync(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

@@ -2,8 +2,10 @@ export declare enum TelemetryNames {
     SolutionPackagerPackSolution = "SolutionPackager.PackSolution",
     SolutionPackagerValidateSolution = "SolutionPackager.ValidateSolution",
     SolutionPackagerRestoreSolution = "SolutionPackager.RestoreSolution",
+    SolutionPackagerCleanupSolution = "SolutionPackager.CleanupSolution",
     SolutionPack = "SolutionPackager.Solution.Pack",
     SolutionValidate = "SolutionPackager.Solution.Validate",
     SolutionRestore = "SolutionPackager.Solution.Restore",
+    SolutionCleanup = "SolutionPackager.Solution.Cleanup",
     SolutionCompress = "SolutionPackager.Solution.Compress"
 }

package/dist/tests/package-id-reader.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/tests/solution-cleanup-service.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@uipath/solution-packager",
   "license": "MIT",
-  "version": "1.197.0",
+  "version": "1.198.0-preview.80",
   "description": "UiPath Solution Packager - core library for packing UiPath solutions",
   "type": "module",
   "main": "./dist/index.js",
@@ -28,11 +28,11 @@
     "dist"
   ],
   "dependencies": {
-    "@uipath/project-packager": "1.197.0",
-    "@uipath/solutionpackager-tool-core": "1.197.0"
+    "@uipath/project-packager": "1.198.0",
+    "@uipath/solutionpackager-tool-core": "1.198.0"
   },
   "peerDependencies": {
     "fflate": "^0.8.2"
   },
-  "gitHead": "56f68b263cec4ea1f2a39d738bd99ecf52f88fea"
+  "gitHead": "9b2c3c0f21a256d2f38dd28bc97e72e6f7b10a9c"
 }