@uipath/packager-tool-workflowcompiler 1.197.0 → 1.198.0-preview.80

package/dist/index.d.ts

@@ -1,3 +1,4 @@
 import "./i18n/index.js";
 export { WorkflowCompilerToolFactory } from "./workflow-compiler-tool-factory.js";
 export { setupWorkflowCompiler } from "./workflow-compiler-config.js";
+export type { CleanedWorkflowDetail, WorkflowCleanupDetails, } from "./workflow-cleanup-details.js";

package/dist/index.js

@@ -850,17 +850,8 @@ function feedsEndpoint(orchestratorUrl) {
     end--;
   }
   const trimmed = orchestratorUrl.slice(0, end);
-  if (/\/orchestrator_$/i.test(trimmed)) {
-    return `${trimmed}${FEEDS_PATH}`;
-  }
-  return hasPathSegments(trimmed) ? `${trimmed}/orchestrator_${FEEDS_PATH}` : `${trimmed}${FEEDS_PATH}`;
-}
-function hasPathSegments(url) {
-  const [error, parsed] = catchError(() => new URL(url));
-  if (error) {
-    return true;
-  }
-  return parsed.pathname !== "/" && parsed.pathname !== "";
+  const base = /\/orchestrator_$/i.test(trimmed) ? trimmed : `${trimmed}/orchestrator_`;
+  return `${base}${FEEDS_PATH}`;
 }
 async function describeFailure(response) {
   const text = await response.text().catch(() => "");
@@ -957,7 +948,8 @@ function toTenantFeedSource(feed, accessToken) {
 // src/workflow-compiler-tool.ts
 import {
   LogLevel,
-  ProjectTool
+  ProjectTool,
+  toProjectCleanupInfo
 } from "@uipath/solutionpackager-tool-core";
 
 // src/workflow-compiler-executor.ts
@@ -1381,20 +1373,24 @@ class WorkflowCompilerTool extends ProjectTool {
     this.context = context;
     this.executor = new WorkflowCompilerExecutor(logger, fileSystem);
   }
-  async withNuGetConfig(options, run) {
+  async withFeedPaths(options, run) {
+    const userNugetConfigPath = options.nuGetSourcesConfigPath;
     const connection = this.context?.connection;
-    if (options.nuGetSourcesConfigPath || !connection) {
-      return run(options.nuGetSourcesConfigPath);
+    if (!connection) {
+      return run({ userNugetConfigPath });
     }
     const composed = await new OrchestratorFeedComposer(this.fileSystem, this.logger).composeAsync({ connection });
     try {
-      return await run(composed.configPath);
+      return await run({
+        orchestratorFeedsJsonPath: composed.configPath,
+        userNugetConfigPath
+      });
     } finally {
       await composed.dispose();
     }
   }
   async restoreAsync(options, cancellationToken) {
-    return this.withNuGetConfig(options, (nuGetConfigPath) => {
+    return this.withFeedPaths(options, (paths) => {
       const args = [
         `-p`,
         options.projectPath,
@@ -1407,14 +1403,17 @@ class WorkflowCompilerTool extends ProjectTool {
         `--exclude-configured-sources`,
         `${options.excludeConfiguredSources}`
       ];
-      if (nuGetConfigPath) {
-        args.push(`--nuget-config-file`, nuGetConfigPath);
+      if (paths.orchestratorFeedsJsonPath) {
+        args.push(`--nuget-config-file`, paths.orchestratorFeedsJsonPath);
+      }
+      if (paths.userNugetConfigPath) {
+        args.push(`--nuget-config`, paths.userNugetConfigPath);
       }
       return this.executor.executeAsync("restore", args, cancellationToken);
     });
   }
   async validateAsync(options, cancellationToken) {
-    return this.withNuGetConfig(options, (nuGetConfigPath) => {
+    return this.withFeedPaths(options, (paths) => {
       const args = [
         `-p`,
         options.projectPath,
@@ -1441,14 +1440,17 @@ class WorkflowCompilerTool extends ProjectTool {
       if (options.policyFileType) {
         args.push(`--policy-file-type`, `${options.policyFileType}`);
       }
-      if (nuGetConfigPath) {
-        args.push(`--nuget-config-file`, nuGetConfigPath);
+      if (paths.orchestratorFeedsJsonPath) {
+        args.push(`--nuget-config-file`, paths.orchestratorFeedsJsonPath);
+      }
+      if (paths.userNugetConfigPath) {
+        args.push(`--nuget-config`, paths.userNugetConfigPath);
       }
       return this.executor.executeAsync("validate", args, cancellationToken);
     });
   }
   async buildAsync(options, cancellationToken) {
-    return this.withNuGetConfig(options, (nuGetConfigPath) => {
+    return this.withFeedPaths(options, (paths) => {
       const args = [
         `-p`,
         options.projectPath,
@@ -1478,14 +1480,17 @@ class WorkflowCompilerTool extends ProjectTool {
         const outputType = this.mapOutputType(options.outputType);
         args.push(`--output-type`, outputType);
       }
-      if (nuGetConfigPath) {
-        args.push(`--nuget-config-file`, nuGetConfigPath);
+      if (paths.orchestratorFeedsJsonPath) {
+        args.push(`--nuget-config-file`, paths.orchestratorFeedsJsonPath);
+      }
+      if (paths.userNugetConfigPath) {
+        args.push(`--nuget-config`, paths.userNugetConfigPath);
       }
       return this.executor.executeAsync("build", args, cancellationToken);
     });
   }
   async packAsync(options, cancellationToken) {
-    return this.withNuGetConfig(options, async (nuGetConfigPath) => {
+    return this.withFeedPaths(options, async (paths) => {
       const args = [
         `-p`,
         options.projectPath,
@@ -1528,15 +1533,92 @@ class WorkflowCompilerTool extends ProjectTool {
         const outputType = this.mapOutputType(options.outputType);
         args.push(`--output-type`, outputType);
       }
-      if (nuGetConfigPath) {
-        args.push(`--nuget-config-file`, nuGetConfigPath);
+      if (paths.orchestratorFeedsJsonPath) {
+        args.push(`--nuget-config-file`, paths.orchestratorFeedsJsonPath);
       }
-      return this.executor.executeAsync("build", args, cancellationToken);
+      if (paths.userNugetConfigPath) {
+        args.push(`--nuget-config`, paths.userNugetConfigPath);
+      }
+      const result = await this.executor.executeAsync("build", args, cancellationToken);
+      return this.recoverPackagePathsAsync(result, options.outputPath);
     });
   }
+  async cleanupAsync(options, cancellationToken) {
+    return this.withFeedPaths(options, async (paths) => {
+      const args = [
+        `-p`,
+        options.projectPath,
+        `--log-level`,
+        String(options.logLevel ?? LogLevel.Info),
+        `--format-logs`,
+        `true`,
+        `--exclude-configured-sources`,
+        `${options.excludeConfiguredSources}`
+      ];
+      if (options.dryRun) {
+        args.push(`--dry-run`);
+      }
+      if (options.skipImports) {
+        args.push(`--skip-imports`);
+      }
+      if (paths.orchestratorFeedsJsonPath) {
+        args.push(`--nuget-config-file`, paths.orchestratorFeedsJsonPath);
+      }
+      if (paths.userNugetConfigPath) {
+        args.push(`--nuget-config`, paths.userNugetConfigPath);
+      }
+      const result = await this.executor.executeAsync("remove-unused-dependencies", args, cancellationToken);
+      return this.toProjectCleanupResult(result);
+    });
+  }
+  toProjectCleanupResult(result) {
+    const raw = result.details?.removeUnusedDependencies;
+    if (!raw) {
+      return result;
+    }
+    const details = { ...result.details };
+    delete details.removeUnusedDependencies;
+    details.projectCleanup = toProjectCleanupInfo(raw);
+    result.details = details;
+    return result;
+  }
   mapOutputType(outputType) {
     return outputType === "WebApp" ? "Process" : outputType;
   }
+  async recoverPackagePathsAsync(result, outputPath) {
+    if (!result.isSuccess) {
+      return result;
+    }
+    const alreadyHasNupkgPaths = result.packages.length > 0 && result.packages.every((p) => p.toLowerCase().endsWith(".nupkg"));
+    if (alreadyHasNupkgPaths) {
+      return result;
+    }
+    const recovered = await this.findNupkgFilesAsync(outputPath);
+    if (recovered.length > 0) {
+      this.logger.warn(`[WorkflowCompiler] pack result did not include .nupkg paths; recovered ${recovered.length} package(s) by scanning the output folder (UV-15007 workaround).`);
+      result.packages = recovered;
+    }
+    return result;
+  }
+  async findNupkgFilesAsync(dir) {
+    const results = [];
+    let entries;
+    try {
+      entries = await this.fileSystem.readdir(dir);
+    } catch {
+      return results;
+    }
+    for (const entry of entries) {
+      const fullPath = this.fileSystem.path.join(dir, entry);
+      const stats = await this.fileSystem.stat(fullPath);
+      if (stats?.isDirectory()) {
+        results.push(...await this.findNupkgFilesAsync(fullPath));
+      } else if (entry.toLowerCase().endsWith(".nupkg")) {
+        results.push(fullPath);
+      }
+    }
+    return results;
+  }
 }
 
 // src/workflow-compiler-tool-factory.ts
@@ -1574,4 +1656,4 @@ export {
   WorkflowCompilerToolFactory
 };
 
-//# debugId=3093E6E2D5D9AED664756E2164756E21
+//# debugId=34D4B1BF483A641664756E2164756E21

package/dist/workflow-cleanup-details.d.ts

@@ -0,0 +1 @@
+export type { CleanedWorkflowDetail, WorkflowCleanupDetails, } from "@uipath/solutionpackager-tool-core";

package/dist/workflow-compiler-tool.d.ts

@@ -1,4 +1,4 @@
-import { type IFileSystem, type IProjectBuildOptions, type IProjectPackOptions, type IProjectRestoreOptions, type IProjectValidateOptions, type IToolLogger, type ProjectOperationContext, ProjectTool, type ToolResult } from "@uipath/solutionpackager-tool-core";
+import { type IFileSystem, type IProjectBuildOptions, type IProjectCleanupOptions, type IProjectPackOptions, type IProjectRestoreOptions, type IProjectValidateOptions, type IToolLogger, type ProjectOperationContext, ProjectTool, type ToolResult } from "@uipath/solutionpackager-tool-core";
 /**
  * Workflow compiler tool implementation.
  * Builds commands and delegates execution to WorkflowCompilerExecutor.
@@ -7,13 +7,41 @@ export declare class WorkflowCompilerTool extends ProjectTool {
     private readonly context?;
     private readonly executor;
     constructor(fileSystem: IFileSystem, logger: IToolLogger, context?: ProjectOperationContext | undefined);
-    private withNuGetConfig;
+    private withFeedPaths;
     restoreAsync(options: IProjectRestoreOptions, cancellationToken?: AbortSignal): Promise<ToolResult>;
     validateAsync(options: IProjectValidateOptions, cancellationToken?: AbortSignal): Promise<ToolResult>;
     buildAsync(options: IProjectBuildOptions, cancellationToken?: AbortSignal): Promise<ToolResult>;
     packAsync(options: IProjectPackOptions, cancellationToken?: AbortSignal): Promise<ToolResult>;
+    cleanupAsync(options: IProjectCleanupOptions, cancellationToken?: AbortSignal): Promise<ToolResult>;
+    /**
+     * Convert the WorkflowCompiler's raw `remove-unused-dependencies` payload
+     * into the generic {@link ProjectCleanupInfo} the cleanup pipeline expects,
+     * exposed under the generic `details.projectCleanup` key. The
+     * workflow-specific bits (per-file removed namespaces) are preserved under
+     * `toolDetails` with this tool's own type; callers that only want the general
+     * result ignore it. Leaves the result untouched when the tool reported no
+     * cleanup payload (e.g. a failure, or an older compiler build).
+     */
+    private toProjectCleanupResult;
     /**
      * Maps output type for workflow compiler.
      */
     private mapOutputType;
+    /**
+     * WORKAROUND (UV-15007): older WorkflowCompiler builds report the staging
+     * content folder in their pack result instead of the produced `.nupkg` path,
+     * so downstream consumers (package signing, solution compression) cannot rely
+     * on `packages`. When the result does not already carry `.nupkg` paths, recover
+     * them by scanning the output folder.
+     *
+     * Remove this fallback after UV-15007 lands and the bundled WorkflowCompiler
+     * surfaces the produced `.nupkg` path in its result
+     * (see scripts/Download-WorkflowCompiler.ps1).
+     */
+    private recoverPackagePathsAsync;
+    /**
+     * Recursively collect `.nupkg` files under `dir` (cross-platform). Returns an
+     * empty list if the folder cannot be read.
+     */
+    private findNupkgFilesAsync;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uipath/packager-tool-workflowcompiler",
-  "version": "1.197.0",
+  "version": "1.198.0-preview.80",
   "description": "UiPath Workflow Compiler tool implementation",
   "type": "module",
   "exports": {
@@ -25,8 +25,8 @@
   "author": "",
   "license": "ISC",
   "peerDependencies": {
-    "@uipath/solutionpackager-tool-core": "1.197.0"
+    "@uipath/solutionpackager-tool-core": "1.198.0"
   },
   "dependencies": {},
-  "gitHead": "56f68b263cec4ea1f2a39d738bd99ecf52f88fea"
+  "gitHead": "9b2c3c0f21a256d2f38dd28bc97e72e6f7b10a9c"
 }

package/src/index.ts

@@ -16,3 +16,13 @@ export { WorkflowCompilerToolFactory } from "./workflow-compiler-tool-factory.js
 // ============================================================================
 
 export { setupWorkflowCompiler } from "./workflow-compiler-config.js";
+
+// ============================================================================
+// Tool-specific cleanup detail. Surfaced via `ProjectCleanupInfo.toolDetails`;
+// only consumers that want WorkflowCompiler specifics import these types.
+// ============================================================================
+
+export type {
+    CleanedWorkflowDetail,
+    WorkflowCleanupDetails,
+} from "./workflow-cleanup-details.js";

package/src/workflow-cleanup-details.ts

@@ -0,0 +1,4 @@
+export type {
+    CleanedWorkflowDetail,
+    WorkflowCleanupDetails,
+} from "@uipath/solutionpackager-tool-core";

package/src/workflow-compiler-executor.ts

@@ -1,4 +1,4 @@
-import { spawn } from "node:child_process";
+import { type ChildProcess, spawn } from "node:child_process";
 import {
     type IFileSystem,
     type IToolLogger,
@@ -17,6 +17,13 @@ import {
     WorkflowCompilerPathResolver,
 } from "./workflow-compiler-path-resolver.js";
 
+/** Signals when each child-process stream has finished. */
+interface StreamCompletion {
+    markStdoutEnded(): void;
+    markStderrEnded(): void;
+    markProcessExited(): void;
+}
+
 function camelCaseKeys(obj: unknown): unknown {
     if (Array.isArray(obj)) {
         return obj.map(camelCaseKeys);
@@ -195,8 +202,8 @@ export class WorkflowCompilerExecutor {
     }
 
     private setupStdoutHandling(
-        childProcess: any,
-        streamCompletion: any,
+        childProcess: ChildProcess,
+        streamCompletion: StreamCompletion,
         onResult: (result: IOutputResult) => void,
     ): void {
         if (!childProcess.stdout) {
@@ -261,8 +268,8 @@ export class WorkflowCompilerExecutor {
     }
 
     private setupStderrHandling(
-        childProcess: any,
-        streamCompletion: any,
+        childProcess: ChildProcess,
+        streamCompletion: StreamCompletion,
         fallbackErrors: string[],
     ): void {
         if (!childProcess.stderr) {
@@ -301,8 +308,8 @@ export class WorkflowCompilerExecutor {
     }
 
     private setupProcessEventHandlers(
-        childProcess: any,
-        streamCompletion: any,
+        childProcess: ChildProcess,
+        streamCompletion: StreamCompletion,
         resolve: (value: ToolResult) => void,
     ): void {
         childProcess.on("exit", () => streamCompletion.markProcessExited());
@@ -326,7 +333,7 @@ export class WorkflowCompilerExecutor {
     }
 
     private setupCancellationHandler(
-        childProcess: any,
+        childProcess: ChildProcess,
         cancellationToken: AbortSignal | undefined,
         resolve: (value: ToolResult) => void,
     ): void {
@@ -354,7 +361,7 @@ export class WorkflowCompilerExecutor {
             const parsed = JSON.parse(line);
 
             // Convert PascalCase to camelCase
-            const camelCased = camelCaseKeys(parsed) as Record<string, any>;
+            const camelCased = camelCaseKeys(parsed) as Record<string, unknown>;
 
             // Convert numeric error codes to strings
             if (camelCased.errorCode !== undefined) {
@@ -367,12 +374,12 @@ export class WorkflowCompilerExecutor {
 
             // Extract paths from OutputPackages array of objects
             if (camelCased.outputPackages) {
-                camelCased.outputPackages = camelCased.outputPackages.map(
-                    (pkg: any) => pkg.path || pkg,
-                );
+                camelCased.outputPackages = (
+                    camelCased.outputPackages as Array<{ path?: string }>
+                ).map((pkg) => pkg.path || pkg);
             }
 
-            return camelCased as IOutputMessage;
+            return camelCased as unknown as IOutputMessage;
         } catch {
             // Not JSON, return null
             return null;

package/src/workflow-compiler-tool.ts

@@ -2,6 +2,7 @@ import { OrchestratorFeedComposer } from "@uipath/packager-orchestrator-client";
 import {
     type IFileSystem,
     type IProjectBuildOptions,
+    type IProjectCleanupOptions,
     type IProjectOptions,
     type IProjectPackOptions,
     type IProjectRestoreOptions,
@@ -11,9 +12,33 @@ import {
     type ProjectOperationContext,
     ProjectTool,
     type ToolResult,
+    toProjectCleanupInfo,
+    type WorkflowCompilerCleanupPayload,
 } from "@uipath/solutionpackager-tool-core";
 import { WorkflowCompilerExecutor } from "./workflow-compiler-executor.js";
 
+/**
+ * Raw `remove-unused-dependencies` payload the WorkflowCompiler emits on
+ * `details.removeUnusedDependencies` (PascalCase on the wire, camelCased by the
+ * executor). Owned by this tool; mapped to the generic {@link ProjectCleanupInfo}
+ * before it leaves `cleanupAsync` so nothing downstream depends on this shape.
+ */
+type RawRemoveUnusedDependenciesResult = WorkflowCompilerCleanupPayload;
+
+/**
+ * The two NuGet-source channels the WorkflowCompiler accepts, kept apart on
+ * purpose:
+ * - `orchestratorFeedsJsonPath` — Orchestrator tenant feeds composed internally into a
+ *   JSON file, passed on the hidden `--nuget-config-file` option. Never
+ *   user-supplied.
+ * - `userNugetConfigPath` — the user's own NuGet.config (XML), passed verbatim on
+ *   `--nuget-config`.
+ */
+interface FeedPaths {
+    orchestratorFeedsJsonPath?: string;
+    userNugetConfigPath?: string;
+}
+
 /**
  * Workflow compiler tool implementation.
  * Builds commands and delegates execution to WorkflowCompilerExecutor.
@@ -30,20 +55,28 @@ export class WorkflowCompilerTool extends ProjectTool {
         this.executor = new WorkflowCompilerExecutor(logger, fileSystem);
     }
 
-    private async withNuGetConfig(
+    private async withFeedPaths(
         options: IProjectOptions,
-        run: (nuGetConfigPath?: string) => Promise<ToolResult>,
+        run: (paths: FeedPaths) => Promise<ToolResult>,
     ): Promise<ToolResult> {
+        // The user's own NuGet.config (XML) always rides the --nuget-config
+        // channel; it is never mixed into the internal feeds file.
+        const userNugetConfigPath = options.nuGetSourcesConfigPath;
         const connection = this.context?.connection;
-        if (options.nuGetSourcesConfigPath || !connection) {
-            return run(options.nuGetSourcesConfigPath);
+        if (!connection) {
+            return run({ userNugetConfigPath });
         }
+        // Orchestrator tenant feeds are composed into a JSON file that only ever
+        // goes on the hidden --nuget-config-file option.
         const composed = await new OrchestratorFeedComposer(
             this.fileSystem,
             this.logger,
         ).composeAsync({ connection });
         try {
-            return await run(composed.configPath);
+            return await run({
+                orchestratorFeedsJsonPath: composed.configPath,
+                userNugetConfigPath,
+            });
         } finally {
             await composed.dispose();
         }
@@ -53,7 +86,7 @@ export class WorkflowCompilerTool extends ProjectTool {
         options: IProjectRestoreOptions,
         cancellationToken?: AbortSignal,
     ): Promise<ToolResult> {
-        return this.withNuGetConfig(options, (nuGetConfigPath) => {
+        return this.withFeedPaths(options, (paths) => {
             const args = [
                 `-p`,
                 options.projectPath,
@@ -67,8 +100,14 @@ export class WorkflowCompilerTool extends ProjectTool {
                 `${options.excludeConfiguredSources}`,
             ];
 
-            if (nuGetConfigPath) {
-                args.push(`--nuget-config-file`, nuGetConfigPath);
+            if (paths.orchestratorFeedsJsonPath) {
+                args.push(
+                    `--nuget-config-file`,
+                    paths.orchestratorFeedsJsonPath,
+                );
+            }
+            if (paths.userNugetConfigPath) {
+                args.push(`--nuget-config`, paths.userNugetConfigPath);
             }
 
             return this.executor.executeAsync(
@@ -83,7 +122,7 @@ export class WorkflowCompilerTool extends ProjectTool {
         options: IProjectValidateOptions,
         cancellationToken?: AbortSignal,
     ): Promise<ToolResult> {
-        return this.withNuGetConfig(options, (nuGetConfigPath) => {
+        return this.withFeedPaths(options, (paths) => {
             const args = [
                 `-p`,
                 options.projectPath,
@@ -111,8 +150,14 @@ export class WorkflowCompilerTool extends ProjectTool {
             if (options.policyFileType) {
                 args.push(`--policy-file-type`, `${options.policyFileType}`);
             }
-            if (nuGetConfigPath) {
-                args.push(`--nuget-config-file`, nuGetConfigPath);
+            if (paths.orchestratorFeedsJsonPath) {
+                args.push(
+                    `--nuget-config-file`,
+                    paths.orchestratorFeedsJsonPath,
+                );
+            }
+            if (paths.userNugetConfigPath) {
+                args.push(`--nuget-config`, paths.userNugetConfigPath);
             }
 
             return this.executor.executeAsync(
@@ -127,7 +172,7 @@ export class WorkflowCompilerTool extends ProjectTool {
         options: IProjectBuildOptions,
         cancellationToken?: AbortSignal,
     ): Promise<ToolResult> {
-        return this.withNuGetConfig(options, (nuGetConfigPath) => {
+        return this.withFeedPaths(options, (paths) => {
             const args = [
                 `-p`,
                 options.projectPath,
@@ -158,8 +203,14 @@ export class WorkflowCompilerTool extends ProjectTool {
                 const outputType = this.mapOutputType(options.outputType);
                 args.push(`--output-type`, outputType);
             }
-            if (nuGetConfigPath) {
-                args.push(`--nuget-config-file`, nuGetConfigPath);
+            if (paths.orchestratorFeedsJsonPath) {
+                args.push(
+                    `--nuget-config-file`,
+                    paths.orchestratorFeedsJsonPath,
+                );
+            }
+            if (paths.userNugetConfigPath) {
+                args.push(`--nuget-config`, paths.userNugetConfigPath);
             }
 
             return this.executor.executeAsync("build", args, cancellationToken);
@@ -170,7 +221,7 @@ export class WorkflowCompilerTool extends ProjectTool {
         options: IProjectPackOptions,
         cancellationToken?: AbortSignal,
     ): Promise<ToolResult> {
-        return this.withNuGetConfig(options, async (nuGetConfigPath) => {
+        return this.withFeedPaths(options, async (paths) => {
             const args: string[] = [
                 `-p`,
                 options.projectPath,
@@ -214,18 +265,161 @@ export class WorkflowCompilerTool extends ProjectTool {
                 const outputType = this.mapOutputType(options.outputType);
                 args.push(`--output-type`, outputType);
             }
-            if (nuGetConfigPath) {
-                args.push(`--nuget-config-file`, nuGetConfigPath);
+            if (paths.orchestratorFeedsJsonPath) {
+                args.push(
+                    `--nuget-config-file`,
+                    paths.orchestratorFeedsJsonPath,
+                );
+            }
+            if (paths.userNugetConfigPath) {
+                args.push(`--nuget-config`, paths.userNugetConfigPath);
             }
 
-            return this.executor.executeAsync("build", args, cancellationToken);
+            const result = await this.executor.executeAsync(
+                "build",
+                args,
+                cancellationToken,
+            );
+            return this.recoverPackagePathsAsync(result, options.outputPath);
+        });
+    }
+
+    async cleanupAsync(
+        options: IProjectCleanupOptions,
+        cancellationToken?: AbortSignal,
+    ): Promise<ToolResult> {
+        return this.withFeedPaths(options, async (paths) => {
+            const args = [
+                `-p`,
+                options.projectPath,
+                `--log-level`,
+                String(options.logLevel ?? LogLevel.Info),
+                `--format-logs`,
+                `true`,
+                `--exclude-configured-sources`,
+                `${options.excludeConfiguredSources}`,
+            ];
+
+            // --dry-run and --skip-imports are boolean switches on the compiler CLI:
+            // present means true, absent means false. They take no value — passing
+            // one (`--dry-run false`) leaves a stray token and still enables the flag.
+            if (options.dryRun) {
+                args.push(`--dry-run`);
+            }
+            if (options.skipImports) {
+                args.push(`--skip-imports`);
+            }
+
+            if (paths.orchestratorFeedsJsonPath) {
+                args.push(
+                    `--nuget-config-file`,
+                    paths.orchestratorFeedsJsonPath,
+                );
+            }
+            if (paths.userNugetConfigPath) {
+                args.push(`--nuget-config`, paths.userNugetConfigPath);
+            }
+
+            const result = await this.executor.executeAsync(
+                "remove-unused-dependencies",
+                args,
+                cancellationToken,
+            );
+            return this.toProjectCleanupResult(result);
         });
     }
 
+    /**
+     * Convert the WorkflowCompiler's raw `remove-unused-dependencies` payload
+     * into the generic {@link ProjectCleanupInfo} the cleanup pipeline expects,
+     * exposed under the generic `details.projectCleanup` key. The
+     * workflow-specific bits (per-file removed namespaces) are preserved under
+     * `toolDetails` with this tool's own type; callers that only want the general
+     * result ignore it. Leaves the result untouched when the tool reported no
+     * cleanup payload (e.g. a failure, or an older compiler build).
+     */
+    private toProjectCleanupResult(result: ToolResult): ToolResult {
+        const raw = result.details?.removeUnusedDependencies as
+            | RawRemoveUnusedDependenciesResult
+            | undefined;
+        if (!raw) {
+            return result;
+        }
+
+        // Re-key the wire-named payload under the generic `projectCleanup` so
+        // nothing downstream sees this tool's domain naming.
+        const details = { ...result.details };
+        delete details.removeUnusedDependencies;
+        details.projectCleanup = toProjectCleanupInfo(raw);
+        result.details = details;
+        return result;
+    }
+
     /**
      * Maps output type for workflow compiler.
      */
     private mapOutputType(outputType: string): string {
         return outputType === "WebApp" ? "Process" : outputType;
     }
+
+    /**
+     * WORKAROUND (UV-15007): older WorkflowCompiler builds report the staging
+     * content folder in their pack result instead of the produced `.nupkg` path,
+     * so downstream consumers (package signing, solution compression) cannot rely
+     * on `packages`. When the result does not already carry `.nupkg` paths, recover
+     * them by scanning the output folder.
+     *
+     * Remove this fallback after UV-15007 lands and the bundled WorkflowCompiler
+     * surfaces the produced `.nupkg` path in its result
+     * (see scripts/Download-WorkflowCompiler.ps1).
+     */
+    private async recoverPackagePathsAsync(
+        result: ToolResult,
+        outputPath: string,
+    ): Promise<ToolResult> {
+        if (!result.isSuccess) {
+            return result;
+        }
+
+        const alreadyHasNupkgPaths =
+            result.packages.length > 0 &&
+            result.packages.every((p) => p.toLowerCase().endsWith(".nupkg"));
+        if (alreadyHasNupkgPaths) {
+            return result;
+        }
+
+        const recovered = await this.findNupkgFilesAsync(outputPath);
+        if (recovered.length > 0) {
+            this.logger.warn(
+                `[WorkflowCompiler] pack result did not include .nupkg paths; recovered ${recovered.length} package(s) by scanning the output folder (UV-15007 workaround).`,
+            );
+            result.packages = recovered;
+        }
+        return result;
+    }
+
+    /**
+     * Recursively collect `.nupkg` files under `dir` (cross-platform). Returns an
+     * empty list if the folder cannot be read.
+     */
+    private async findNupkgFilesAsync(dir: string): Promise<string[]> {
+        const results: string[] = [];
+        let entries: string[];
+        try {
+            entries = await this.fileSystem.readdir(dir);
+        } catch {
+            return results;
+        }
+
+        for (const entry of entries) {
+            const fullPath = this.fileSystem.path.join(dir, entry);
+            const stats = await this.fileSystem.stat(fullPath);
+            if (stats?.isDirectory()) {
+                results.push(...(await this.findNupkgFilesAsync(fullPath)));
+            } else if (entry.toLowerCase().endsWith(".nupkg")) {
+                results.push(fullPath);
+            }
+        }
+        return results;
+    }
 }