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

package/dist/index.js

@@ -765,7 +765,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,
@@ -960,20 +960,13 @@ import {
   translate as translate5
 } from "@uipath/solutionpackager-tool-core";
 
-// src/workflow-compiler-path-resolver.ts
-import { execFileSync } from "node:child_process";
-import { homedir, platform } from "node:os";
-import {
-  Path as Path2,
-  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 DEFAULT_WORKFLOW_COMPILER_VERSION = "26.0.198-alpha.24031";
 var workflowCompilerConfig = {
   workflowCompilerPath: undefined,
-  workflowCompilerVersion: DEFAULT_WORKFLOW_COMPILER_VERSION
+  workflowCompilerVersion: DEFAULT_WORKFLOW_COMPILER_VERSION,
+  dotnetPath: "dotnet",
+  dotnetEnv: undefined
 };
 function setupWorkflowCompiler(options) {
   if (options.compilerPath !== undefined) {
@@ -982,9 +975,22 @@ 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;
+  }
 }
 
 // src/workflow-compiler-path-resolver.ts
+import { execFileSync } from "node:child_process";
+import { homedir, platform } from "node:os";
+import {
+  Path as Path2,
+  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 WORKFLOW_COMPILER_DLL_NAME = "UiPath.WorkflowCompiler.dll";
 var PLATFORM_PACKAGE_IDS = {
@@ -1136,7 +1142,6 @@ function camelCaseKeys(obj) {
 
 class WorkflowCompilerExecutor {
   logger;
-  static DOTNET_EXECUTABLE = "dotnet";
   pathResolver;
   constructor(logger, fileSystem) {
     this.logger = logger;
@@ -1145,13 +1150,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 +1207,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) {
@@ -1656,4 +1662,4 @@ export {
   WorkflowCompilerToolFactory
 };
 
-//# debugId=34D4B1BF483A641664756E2164756E21
+//# debugId=DF8E70BC8F5CC6D964756E2164756E21

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

@@ -1,23 +1,34 @@
-export declare const DEFAULT_WORKFLOW_COMPILER_VERSION = "26.0.196-cloud.23765";
+export declare const DEFAULT_WORKFLOW_COMPILER_VERSION = "26.0.198-alpha.24031";
 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uipath/packager-tool-workflowcompiler",
-  "version": "1.198.0-preview.90",
+  "version": "1.199.0-preview.91",
   "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": "7fa615fb10f91f98f796a038ea70569336611f42"
+  "gitHead": "f428cb1e61ba89ad18394b0c6106784055699f02"
 }

package/src/workflow-compiler-config.ts

@@ -1,8 +1,15 @@
-export const DEFAULT_WORKFLOW_COMPILER_VERSION = "26.0.196-cloud.23765";
+export const DEFAULT_WORKFLOW_COMPILER_VERSION = "26.0.198-alpha.24031";
 
 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,
+    // 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 +17,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 +45,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,
         });
     }