@uipath/packager-tool-workflowcompiler 1.198.0 → 1.199.0-preview.104

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.198.0",
+  version: "1.199.0",
   description: "UiPath packager client for Orchestrator package-feed interaction (feed discovery + NuGet source composition)",
   type: "module",
   private: true,
@@ -968,23 +992,6 @@ import {
   TemporaryStorageService as TemporaryStorageService2,
   translate as translate3
 } from "@uipath/solutionpackager-tool-core";
-
-// src/workflow-compiler-config.ts
-var DEFAULT_WORKFLOW_COMPILER_VERSION = "26.0.196-cloud.23765";
-var workflowCompilerConfig = {
-  workflowCompilerPath: undefined,
-  workflowCompilerVersion: DEFAULT_WORKFLOW_COMPILER_VERSION
-};
-function setupWorkflowCompiler(options) {
-  if (options.compilerPath !== undefined) {
-    workflowCompilerConfig.workflowCompilerPath = options.compilerPath;
-  }
-  if (options.version !== undefined) {
-    workflowCompilerConfig.workflowCompilerVersion = options.version;
-  }
-}
-
-// src/workflow-compiler-path-resolver.ts
 var NUGET_FEED_URL = "https://uipath.pkgs.visualstudio.com/Public.Feeds/_packaging/UiPath-Internal/nuget/v3/index.json";
 var WORKFLOW_COMPILER_DLL_NAME = "UiPath.WorkflowCompiler.dll";
 var PLATFORM_PACKAGE_IDS = {
@@ -1136,7 +1143,6 @@ function camelCaseKeys(obj) {
 
 class WorkflowCompilerExecutor {
   logger;
-  static DOTNET_EXECUTABLE = "dotnet";
   pathResolver;
   constructor(logger, fileSystem) {
     this.logger = logger;
@@ -1145,13 +1151,13 @@ class WorkflowCompilerExecutor {
   async executeAsync(operation, args, cancellationToken) {
     const startTime = Date.now();
     const compilerPath = await this.pathResolver.getCompilerPathAsync();
-    const executable = WorkflowCompilerExecutor.DOTNET_EXECUTABLE;
+    const executable = workflowCompilerConfig.dotnetPath;
     const commandArgs = [compilerPath, operation, ...args];
     this.logCommandStart(operation, executable, commandArgs);
     return new Promise((resolve) => {
       let result = null;
       const fallbackErrors = [];
-      const childProcess = this.spawnProcess(executable, commandArgs);
+      const childProcess = this.spawnProcess(executable, commandArgs, workflowCompilerConfig.dotnetEnv);
       let stdoutEnded = false;
       let stderrEnded = false;
       let processExited = false;
@@ -1202,11 +1208,12 @@ class WorkflowCompilerExecutor {
       this.setupCancellationHandler(childProcess, cancellationToken, resolve);
     });
   }
-  spawnProcess(command, args) {
+  spawnProcess(command, args, env) {
     return spawn(command, args, {
       stdio: ["ignore", "pipe", "pipe"],
       shell: false,
-      windowsHide: true
+      windowsHide: true,
+      env: env ? { ...process.env, ...env } : undefined
     });
   }
   logCommandStart(operation, executable, commandArgs) {
@@ -1631,11 +1638,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;
@@ -1656,4 +1666,4 @@ export {
   WorkflowCompilerToolFactory
 };
 
-//# debugId=34D4B1BF483A641664756E2164756E21
+//# debugId=D679068934126E3664756E2164756E21

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

@@ -1,23 +1,36 @@
-export declare const DEFAULT_WORKFLOW_COMPILER_VERSION = "26.0.196-cloud.23765";
+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;
+    dotnetPath: string;
+    dotnetEnv: Record<string, string> | undefined;
 };
 /**
  * Configure the workflow compiler tool.
  *
  * @param options.compilerPath - Explicit path to UiPath.WorkflowCompiler.dll (skips all resolution logic).
  * @param options.version - NuGet package version to download. Defaults to {@link DEFAULT_WORKFLOW_COMPILER_VERSION}.
+ * @param options.dotnetPath - dotnet host to launch the compiler with. Defaults to `dotnet` on PATH.
+ * @param options.dotnetEnv - Extra env vars for the compiler process (merged over the inherited env).
  *
  * @example
  * ```ts
  * import { setupWorkflowCompiler } from "@uipath/packager-tool-workflowcompiler";
  *
  * setupWorkflowCompiler({ compilerPath: "/path/to/UiPath.WorkflowCompiler.dll" });
- * setupWorkflowCompiler({ version: "26.0.196-cloud.23765" });
+ * setupWorkflowCompiler({ version: "26.0.198-alpha.24031" });
+ * setupWorkflowCompiler({
+ *     compilerPath: "/path/to/UiPath.WorkflowCompiler.dll",
+ *     dotnetPath: "/path/to/bundled/dotnet",
+ *     dotnetEnv: { DOTNET_ROOT: "/path/to/bundled", DOTNET_MULTILEVEL_LOOKUP: "0" },
+ * });
  * ```
  */
 export declare function setupWorkflowCompiler(options: {
     compilerPath?: string;
     version?: string;
+    dotnetPath?: string;
+    dotnetEnv?: Record<string, string>;
 }): void;

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

@@ -5,7 +5,6 @@ import { type IFileSystem, type IToolLogger, ToolResult } from "@uipath/solution
  */
 export declare class WorkflowCompilerExecutor {
     private readonly logger;
-    private static readonly DOTNET_EXECUTABLE;
     private readonly pathResolver;
     constructor(logger: IToolLogger, fileSystem: IFileSystem);
     /**
@@ -16,7 +15,7 @@ export declare class WorkflowCompilerExecutor {
      * @returns Promise resolving to ToolResult
      */
     executeAsync(operation: string, args: string[], cancellationToken?: AbortSignal): Promise<ToolResult>;
-    protected spawnProcess(command: string, args: string[]): import("node:child_process").ChildProcessByStdio<null, import("node:stream").Readable, import("node:stream").Readable>;
+    protected spawnProcess(command: string, args: string[], env?: Record<string, string>): import("node:child_process").ChildProcessByStdio<null, import("node:stream").Readable, import("node:stream").Readable>;
     private logCommandStart;
     private setupStdoutHandling;
     private processOutputLine;

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uipath/packager-tool-workflowcompiler",
-  "version": "1.198.0",
+  "version": "1.199.0-preview.104",
   "description": "UiPath Workflow Compiler tool implementation",
   "type": "module",
   "exports": {
@@ -25,8 +25,8 @@
   "author": "",
   "license": "ISC",
   "peerDependencies": {
-    "@uipath/solutionpackager-tool-core": "1.198.0"
+    "@uipath/solutionpackager-tool-core": "1.199.0"
   },
   "dependencies": {},
-  "gitHead": "1fadf03d7a8dd102742571dff569fdac11808afb"
+  "gitHead": "829a8ab8a25bce5b62c284bd1ddc674d2947f647"
 }

package/src/workflow-compiler-config.ts

@@ -1,8 +1,18 @@
-export const DEFAULT_WORKFLOW_COMPILER_VERSION = "26.0.196-cloud.23765";
+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: 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,
 };
 
 /**
@@ -10,18 +20,27 @@ export const workflowCompilerConfig = {
  *
  * @param options.compilerPath - Explicit path to UiPath.WorkflowCompiler.dll (skips all resolution logic).
  * @param options.version - NuGet package version to download. Defaults to {@link DEFAULT_WORKFLOW_COMPILER_VERSION}.
+ * @param options.dotnetPath - dotnet host to launch the compiler with. Defaults to `dotnet` on PATH.
+ * @param options.dotnetEnv - Extra env vars for the compiler process (merged over the inherited env).
  *
  * @example
  * ```ts
  * import { setupWorkflowCompiler } from "@uipath/packager-tool-workflowcompiler";
  *
  * setupWorkflowCompiler({ compilerPath: "/path/to/UiPath.WorkflowCompiler.dll" });
- * setupWorkflowCompiler({ version: "26.0.196-cloud.23765" });
+ * setupWorkflowCompiler({ version: "26.0.198-alpha.24031" });
+ * setupWorkflowCompiler({
+ *     compilerPath: "/path/to/UiPath.WorkflowCompiler.dll",
+ *     dotnetPath: "/path/to/bundled/dotnet",
+ *     dotnetEnv: { DOTNET_ROOT: "/path/to/bundled", DOTNET_MULTILEVEL_LOOKUP: "0" },
+ * });
  * ```
  */
 export function setupWorkflowCompiler(options: {
     compilerPath?: string;
     version?: string;
+    dotnetPath?: string;
+    dotnetEnv?: Record<string, string>;
 }): void {
     if (options.compilerPath !== undefined) {
         workflowCompilerConfig.workflowCompilerPath = options.compilerPath;
@@ -29,4 +48,10 @@ export function setupWorkflowCompiler(options: {
     if (options.version !== undefined) {
         workflowCompilerConfig.workflowCompilerVersion = options.version;
     }
+    if (options.dotnetPath !== undefined) {
+        workflowCompilerConfig.dotnetPath = options.dotnetPath;
+    }
+    if (options.dotnetEnv !== undefined) {
+        workflowCompilerConfig.dotnetEnv = options.dotnetEnv;
+    }
 }

package/src/workflow-compiler-executor.ts

@@ -12,6 +12,7 @@ import type {
     IOutputProgress,
     IOutputResult,
 } from "./output-entry.js";
+import { workflowCompilerConfig } from "./workflow-compiler-config.js";
 import {
     type IWorkflowCompilerPathResolver,
     WorkflowCompilerPathResolver,
@@ -44,7 +45,6 @@ function camelCaseKeys(obj: unknown): unknown {
  * Handles process spawning, output parsing, and logging.
  */
 export class WorkflowCompilerExecutor {
-    private static readonly DOTNET_EXECUTABLE = "dotnet";
     private readonly pathResolver: IWorkflowCompilerPathResolver;
 
     constructor(
@@ -71,7 +71,10 @@ export class WorkflowCompilerExecutor {
     ): Promise<ToolResult> {
         const startTime = Date.now();
         const compilerPath = await this.pathResolver.getCompilerPathAsync();
-        const executable = WorkflowCompilerExecutor.DOTNET_EXECUTABLE;
+        // The compiler ships as a managed .dll, so it always runs via a dotnet host. `dotnetPath`
+        // defaults to `dotnet` on PATH; consumers with a bundled runtime (rpa-tool) point it at that
+        // muxer so the compiler runs under the bundled .NET instead of requiring a machine-wide install.
+        const executable = workflowCompilerConfig.dotnetPath;
         const commandArgs = [compilerPath, operation, ...args];
 
         this.logCommandStart(operation, executable, commandArgs);
@@ -80,7 +83,11 @@ export class WorkflowCompilerExecutor {
             let result: IOutputResult | null = null;
             const fallbackErrors: string[] = [];
 
-            const childProcess = this.spawnProcess(executable, commandArgs);
+            const childProcess = this.spawnProcess(
+                executable,
+                commandArgs,
+                workflowCompilerConfig.dotnetEnv,
+            );
 
             // Track stream completion
             let stdoutEnded = false;
@@ -175,11 +182,18 @@ export class WorkflowCompilerExecutor {
         });
     }
 
-    protected spawnProcess(command: string, args: string[]) {
+    protected spawnProcess(
+        command: string,
+        args: string[],
+        env?: Record<string, string>,
+    ) {
         return spawn(command, args, {
             stdio: ["ignore", "pipe", "pipe"],
             shell: false,
             windowsHide: true,
+            // Undefined inherits the parent env; a provided env is merged over it (so DOTNET_ROOT
+            // et al. are added without dropping PATH and friends the child still needs).
+            env: env ? { ...process.env, ...env } : undefined,
         });
     }
 

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;