@uipath/packager-tool-workflowcompiler 1.199.0-preview.97 → 1.200.0-preview.109

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

@@ -28,7 +28,7 @@ export declare const en: {
                 readonly checkingNuGetCache: "[PathResolver] Checking NuGet cache: {path}";
                 readonly foundInNuGetCache: "[PathResolver] Found compiler in NuGet cache";
                 readonly notFoundStartingInstall: "[PathResolver] Compiler not found, starting dotnet restore...";
-                readonly restoringPackage: "[PathResolver] Restoring NuGet package \"{packageName}\" v{version} for platform \"{platform}\" via dotnet restore...";
+                readonly restoringPackage: '[PathResolver] Restoring NuGet package "{packageName}" v{version} for platform "{platform}" via dotnet restore...';
                 readonly runningDotnetRestore: "[PathResolver] Running dotnet restore...";
                 readonly restoreCompleted: "[PathResolver] dotnet restore completed";
                 readonly installCompleted: "[PathResolver] Compiler restored successfully";

package/dist/index.js

@@ -656,6 +656,30 @@ import {
   translate as translate6
 } from "@uipath/solutionpackager-tool-core";
 
+// src/workflow-compiler-config.ts
+var DEFAULT_WORKFLOW_COMPILER_VERSION = "26.0.198-alpha.24031";
+var DEFAULT_DOTNET_PATH = "dotnet";
+var workflowCompilerConfig = {
+  workflowCompilerPath: undefined,
+  workflowCompilerVersion: DEFAULT_WORKFLOW_COMPILER_VERSION,
+  dotnetPath: DEFAULT_DOTNET_PATH,
+  dotnetEnv: undefined
+};
+function setupWorkflowCompiler(options) {
+  if (options.compilerPath !== undefined) {
+    workflowCompilerConfig.workflowCompilerPath = options.compilerPath;
+  }
+  if (options.version !== undefined) {
+    workflowCompilerConfig.workflowCompilerVersion = options.version;
+  }
+  if (options.dotnetPath !== undefined) {
+    workflowCompilerConfig.dotnetPath = options.dotnetPath;
+  }
+  if (options.dotnetEnv !== undefined) {
+    workflowCompilerConfig.dotnetEnv = options.dotnetEnv;
+  }
+}
+
 // ../packager-orchestrator-client/dist/index.js
 import { I18nManager as I18nManager2 } from "@uipath/solutionpackager-tool-core";
 import {
@@ -765,7 +789,7 @@ function addSdkUserAgentHeader(headers, userAgent) {
 }
 var package_default = {
   name: "@uipath/packager-orchestrator-client",
-  version: "1.199.0",
+  version: "1.200.0",
   description: "UiPath packager client for Orchestrator package-feed interaction (feed discovery + NuGet source composition)",
   type: "module",
   private: true,
@@ -804,7 +828,7 @@ var package_default = {
     "@uipath/common": "workspace:*",
     "@uipath/solutionpackager-tool-core": "workspace:*",
     "@vitest/coverage-v8": "^4.1.6",
-    typescript: "^6.0.2",
+    typescript: "^7.0.2",
     vitest: "^4.1.6"
   }
 };
@@ -960,29 +984,6 @@ import {
   translate as translate5
 } from "@uipath/solutionpackager-tool-core";
 
-// src/workflow-compiler-config.ts
-var DEFAULT_WORKFLOW_COMPILER_VERSION = "26.0.198-alpha.24031";
-var workflowCompilerConfig = {
-  workflowCompilerPath: undefined,
-  workflowCompilerVersion: DEFAULT_WORKFLOW_COMPILER_VERSION,
-  dotnetPath: "dotnet",
-  dotnetEnv: undefined
-};
-function setupWorkflowCompiler(options) {
-  if (options.compilerPath !== undefined) {
-    workflowCompilerConfig.workflowCompilerPath = options.compilerPath;
-  }
-  if (options.version !== undefined) {
-    workflowCompilerConfig.workflowCompilerVersion = options.version;
-  }
-  if (options.dotnetPath !== undefined) {
-    workflowCompilerConfig.dotnetPath = options.dotnetPath;
-  }
-  if (options.dotnetEnv !== undefined) {
-    workflowCompilerConfig.dotnetEnv = options.dotnetEnv;
-  }
-}
-
 // src/workflow-compiler-path-resolver.ts
 import { execFileSync } from "node:child_process";
 import { homedir, platform } from "node:os";
@@ -991,7 +992,7 @@ import {
   TemporaryStorageService as TemporaryStorageService2,
   translate as translate3
 } from "@uipath/solutionpackager-tool-core";
-var NUGET_FEED_URL = "https://uipath.pkgs.visualstudio.com/Public.Feeds/_packaging/UiPath-Internal/nuget/v3/index.json";
+var NUGET_FEED_URL = "https://pkgs.uipath.com/internal/index.json";
 var WORKFLOW_COMPILER_DLL_NAME = "UiPath.WorkflowCompiler.dll";
 var PLATFORM_PACKAGE_IDS = {
   win32: "UiPath.WorkflowCompiler.Windows",
@@ -1371,6 +1372,18 @@ function getAdditionalResultDetails(result) {
 }
 
 // src/workflow-compiler-tool.ts
+var NO_CLEANUP_SOURCE_FILES_MESSAGE = "no workflow xamls or coded source files";
+var CLEANUP_SOURCE_FILE_EXTENSIONS = [".xaml", ".cs", ".vb"];
+var CLEANUP_SOURCE_SCAN_SKIP_DIRS = new Set([
+  ".git",
+  ".local",
+  ".project",
+  "bin",
+  "dist",
+  "node_modules",
+  "obj"
+]);
+
 class WorkflowCompilerTool extends ProjectTool {
   context;
   executor;
@@ -1574,9 +1587,52 @@ class WorkflowCompilerTool extends ProjectTool {
         args.push(`--nuget-config`, paths.userNugetConfigPath);
       }
       const result = await this.executor.executeAsync("remove-unused-dependencies", args, cancellationToken);
+      if (await this.shouldRetryCleanupNoSourceFalseNegativeAsync(result, options.projectPath)) {
+        this.logger.warn("[WorkflowCompiler] remove-unused-dependencies reported no workflow/source files even though the project contains source files; retrying once.");
+        const retryResult = await this.executor.executeAsync("remove-unused-dependencies", args, cancellationToken);
+        return this.toProjectCleanupResult(retryResult);
+      }
       return this.toProjectCleanupResult(result);
     });
   }
+  async shouldRetryCleanupNoSourceFalseNegativeAsync(result, projectPath) {
+    if (result.isSuccess) {
+      return false;
+    }
+    const message = result.message?.toLowerCase();
+    if (!message?.includes(NO_CLEANUP_SOURCE_FILES_MESSAGE)) {
+      return false;
+    }
+    return await this.hasCleanupSourceFilesAsync(projectPath);
+  }
+  async hasCleanupSourceFilesAsync(projectPath) {
+    let entries;
+    try {
+      entries = await this.fileSystem.readdir(projectPath);
+    } catch {
+      return false;
+    }
+    for (const entry of entries) {
+      const lowerEntry = entry.toLowerCase();
+      const fullPath = this.fileSystem.path.join(projectPath, entry);
+      let stats;
+      try {
+        stats = await this.fileSystem.stat(fullPath);
+      } catch {
+        continue;
+      }
+      if (!stats) {
+        continue;
+      }
+      if (stats.isFile() && CLEANUP_SOURCE_FILE_EXTENSIONS.some((extension) => lowerEntry.endsWith(extension))) {
+        return true;
+      }
+      if (stats.isDirectory() && !CLEANUP_SOURCE_SCAN_SKIP_DIRS.has(lowerEntry) && await this.hasCleanupSourceFilesAsync(fullPath)) {
+        return true;
+      }
+    }
+    return false;
+  }
   toProjectCleanupResult(result) {
     const raw = result.details?.removeUnusedDependencies;
     if (!raw) {
@@ -1637,11 +1693,14 @@ class WorkflowCompilerToolFactory {
     ProjectTypes.WebApp
   ];
   async createAsync(logger, fileSystem, context) {
-    if (!this.isDotnetAvailable()) {
+    if (!this.isPinnedByCaller() && !this.isDotnetAvailable()) {
       throw new Error(translate6.t("toolWorkflowcompiler.errors.dotnetNotAvailable"));
     }
     return new WorkflowCompilerTool(fileSystem, logger, context);
   }
+  isPinnedByCaller() {
+    return workflowCompilerConfig.workflowCompilerPath !== undefined && workflowCompilerConfig.dotnetPath !== DEFAULT_DOTNET_PATH;
+  }
   isDotnetAvailable() {
     if (WorkflowCompilerToolFactory.cachedDotnetAvailable !== undefined) {
       return WorkflowCompilerToolFactory.cachedDotnetAvailable;
@@ -1662,4 +1721,4 @@ export {
   WorkflowCompilerToolFactory
 };
 
-//# debugId=DF8E70BC8F5CC6D964756E2164756E21
+//# debugId=98DEE79ADEE701B964756E2164756E21

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

@@ -1,4 +1,6 @@
 export declare const DEFAULT_WORKFLOW_COMPILER_VERSION = "26.0.198-alpha.24031";
+/** The dotnet host used when no consumer pins one: whatever `dotnet` PATH resolves to. */
+export declare const DEFAULT_DOTNET_PATH = "dotnet";
 export declare const workflowCompilerConfig: {
     workflowCompilerPath: string | undefined;
     workflowCompilerVersion: string;

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

@@ -12,5 +12,17 @@ export declare class WorkflowCompilerToolFactory implements IProjectToolFactory
     private static cachedDotnetAvailable;
     readonly supportedTypes: readonly ProjectType[];
     createAsync(logger: IToolLogger, fileSystem: IFileSystem, context?: ProjectOperationContext): Promise<ProjectTool>;
+    /**
+     * True when the caller has supplied both the compiler and the dotnet host to
+     * run it with — i.e. it resolved its own .NET and neither the NuGet-restore
+     * fallback nor a machine-wide install is involved.
+     *
+     * The preflight below asks PATH for an SDK. A pinned host is typically a
+     * runtime-only bundle (Studio/Robot ship the runtime, never the SDK), which
+     * cannot answer `dotnet --version` at all — that is an SDK verb. Probing it
+     * can therefore only reject a configuration that works, so a caller that has
+     * pinned both is trusted and the tool is created unconditionally.
+     */
+    private isPinnedByCaller;
     private isDotnetAvailable;
 }

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

@@ -13,6 +13,8 @@ export declare class WorkflowCompilerTool extends ProjectTool {
     buildAsync(options: IProjectBuildOptions, cancellationToken?: AbortSignal): Promise<ToolResult>;
     packAsync(options: IProjectPackOptions, cancellationToken?: AbortSignal): Promise<ToolResult>;
     cleanupAsync(options: IProjectCleanupOptions, cancellationToken?: AbortSignal): Promise<ToolResult>;
+    private shouldRetryCleanupNoSourceFalseNegativeAsync;
+    private hasCleanupSourceFilesAsync;
     /**
      * Convert the WorkflowCompiler's raw `remove-unused-dependencies` payload
      * into the generic {@link ProjectCleanupInfo} the cleanup pipeline expects,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uipath/packager-tool-workflowcompiler",
-  "version": "1.199.0-preview.97",
+  "version": "1.200.0-preview.109",
   "description": "UiPath Workflow Compiler tool implementation",
   "type": "module",
   "exports": {
@@ -25,8 +25,8 @@
   "author": "",
   "license": "ISC",
   "peerDependencies": {
-    "@uipath/solutionpackager-tool-core": "1.199.0"
+    "@uipath/solutionpackager-tool-core": "1.200.0"
   },
   "dependencies": {},
-  "gitHead": "087ae21e842f27bde5eb0013892c9487bfe60568"
+  "gitHead": "fcc01cdae81bbd0c25d3d4fc287537a9d19d99f4"
 }

package/src/workflow-compiler-config.ts

@@ -1,12 +1,15 @@
 export const DEFAULT_WORKFLOW_COMPILER_VERSION = "26.0.198-alpha.24031";
 
+/** The dotnet host used when no consumer pins one: whatever `dotnet` PATH resolves to. */
+export const DEFAULT_DOTNET_PATH = "dotnet";
+
 export const workflowCompilerConfig = {
     workflowCompilerPath: undefined as string | undefined,
     workflowCompilerVersion: DEFAULT_WORKFLOW_COMPILER_VERSION as string,
     // The dotnet host used to launch `UiPath.WorkflowCompiler.dll`. Defaults to `dotnet` on PATH.
     // Consumers that ship a bundled runtime (e.g. rpa-tool resolving Robot/Studio's .NET) point this
     // at the bundled muxer so the compiler runs under that runtime instead of a machine-wide install.
-    dotnetPath: "dotnet" as string,
+    dotnetPath: DEFAULT_DOTNET_PATH as string,
     // Extra environment variables for the compiler process (e.g. DOTNET_ROOT / DOTNET_MULTILEVEL_LOOKUP).
     // Merged over the inherited process env. Undefined means inherit the parent env unchanged.
     dotnetEnv: undefined as Record<string, string> | undefined,

package/src/workflow-compiler-path-resolver.ts

@@ -11,8 +11,7 @@ import {
 } from "@uipath/solutionpackager-tool-core";
 import { workflowCompilerConfig } from "./workflow-compiler-config.js";
 
-const NUGET_FEED_URL =
-    "https://uipath.pkgs.visualstudio.com/Public.Feeds/_packaging/UiPath-Internal/nuget/v3/index.json";
+const NUGET_FEED_URL = "https://pkgs.uipath.com/internal/index.json";
 
 const WORKFLOW_COMPILER_DLL_NAME = "UiPath.WorkflowCompiler.dll";
 

package/src/workflow-compiler-tool-factory.ts

@@ -9,6 +9,10 @@ import {
     ProjectTypes,
     translate,
 } from "@uipath/solutionpackager-tool-core";
+import {
+    DEFAULT_DOTNET_PATH,
+    workflowCompilerConfig,
+} from "./workflow-compiler-config.js";
 import { WorkflowCompilerTool } from "./workflow-compiler-tool.js";
 
 /**
@@ -35,7 +39,7 @@ export class WorkflowCompilerToolFactory implements IProjectToolFactory {
         fileSystem: IFileSystem,
         context?: ProjectOperationContext,
     ): Promise<ProjectTool> {
-        if (!this.isDotnetAvailable()) {
+        if (!this.isPinnedByCaller() && !this.isDotnetAvailable()) {
             throw new Error(
                 translate.t("toolWorkflowcompiler.errors.dotnetNotAvailable"),
             );
@@ -43,6 +47,24 @@ export class WorkflowCompilerToolFactory implements IProjectToolFactory {
         return new WorkflowCompilerTool(fileSystem, logger, context);
     }
 
+    /**
+     * True when the caller has supplied both the compiler and the dotnet host to
+     * run it with — i.e. it resolved its own .NET and neither the NuGet-restore
+     * fallback nor a machine-wide install is involved.
+     *
+     * The preflight below asks PATH for an SDK. A pinned host is typically a
+     * runtime-only bundle (Studio/Robot ship the runtime, never the SDK), which
+     * cannot answer `dotnet --version` at all — that is an SDK verb. Probing it
+     * can therefore only reject a configuration that works, so a caller that has
+     * pinned both is trusted and the tool is created unconditionally.
+     */
+    private isPinnedByCaller(): boolean {
+        return (
+            workflowCompilerConfig.workflowCompilerPath !== undefined &&
+            workflowCompilerConfig.dotnetPath !== DEFAULT_DOTNET_PATH
+        );
+    }
+
     private isDotnetAvailable(): boolean {
         if (WorkflowCompilerToolFactory.cachedDotnetAvailable !== undefined) {
             return WorkflowCompilerToolFactory.cachedDotnetAvailable;

package/src/workflow-compiler-tool.ts

@@ -1,5 +1,6 @@
 import { OrchestratorFeedComposer } from "@uipath/packager-orchestrator-client";
 import {
+    type FileSystemStats,
     type IFileSystem,
     type IProjectBuildOptions,
     type IProjectCleanupOptions,
@@ -25,6 +26,19 @@ import { WorkflowCompilerExecutor } from "./workflow-compiler-executor.js";
  */
 type RawRemoveUnusedDependenciesResult = WorkflowCompilerCleanupPayload;
 
+const NO_CLEANUP_SOURCE_FILES_MESSAGE =
+    "no workflow xamls or coded source files";
+const CLEANUP_SOURCE_FILE_EXTENSIONS = [".xaml", ".cs", ".vb"];
+const CLEANUP_SOURCE_SCAN_SKIP_DIRS = new Set([
+    ".git",
+    ".local",
+    ".project",
+    "bin",
+    "dist",
+    "node_modules",
+    "obj",
+]);
+
 /**
  * The two NuGet-source channels the WorkflowCompiler accepts, kept apart on
  * purpose:
@@ -325,10 +339,86 @@ export class WorkflowCompilerTool extends ProjectTool {
                 args,
                 cancellationToken,
             );
+            if (
+                await this.shouldRetryCleanupNoSourceFalseNegativeAsync(
+                    result,
+                    options.projectPath,
+                )
+            ) {
+                this.logger.warn(
+                    "[WorkflowCompiler] remove-unused-dependencies reported no workflow/source files even though the project contains source files; retrying once.",
+                );
+                const retryResult = await this.executor.executeAsync(
+                    "remove-unused-dependencies",
+                    args,
+                    cancellationToken,
+                );
+                return this.toProjectCleanupResult(retryResult);
+            }
             return this.toProjectCleanupResult(result);
         });
     }
 
+    private async shouldRetryCleanupNoSourceFalseNegativeAsync(
+        result: ToolResult,
+        projectPath: string,
+    ): Promise<boolean> {
+        if (result.isSuccess) {
+            return false;
+        }
+
+        const message = result.message?.toLowerCase();
+        if (!message?.includes(NO_CLEANUP_SOURCE_FILES_MESSAGE)) {
+            return false;
+        }
+
+        return await this.hasCleanupSourceFilesAsync(projectPath);
+    }
+
+    private async hasCleanupSourceFilesAsync(
+        projectPath: string,
+    ): Promise<boolean> {
+        let entries: string[];
+        try {
+            entries = await this.fileSystem.readdir(projectPath);
+        } catch {
+            return false;
+        }
+
+        for (const entry of entries) {
+            const lowerEntry = entry.toLowerCase();
+            const fullPath = this.fileSystem.path.join(projectPath, entry);
+            let stats: FileSystemStats | null;
+            try {
+                stats = await this.fileSystem.stat(fullPath);
+            } catch {
+                continue;
+            }
+            if (!stats) {
+                continue;
+            }
+
+            if (
+                stats.isFile() &&
+                CLEANUP_SOURCE_FILE_EXTENSIONS.some((extension) =>
+                    lowerEntry.endsWith(extension),
+                )
+            ) {
+                return true;
+            }
+
+            if (
+                stats.isDirectory() &&
+                !CLEANUP_SOURCE_SCAN_SKIP_DIRS.has(lowerEntry) &&
+                (await this.hasCleanupSourceFilesAsync(fullPath))
+            ) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
     /**
      * Convert the WorkflowCompiler's raw `remove-unused-dependencies` payload
      * into the generic {@link ProjectCleanupInfo} the cleanup pipeline expects,