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

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 {
@@ -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";
@@ -1637,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;
@@ -1662,4 +1666,4 @@ export {
   WorkflowCompilerToolFactory
 };
 
-//# debugId=DF8E70BC8F5CC6D964756E2164756E21
+//# debugId=D679068934126E3664756E2164756E21

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

@@ -1,6 +1,6 @@
 {
   "name": "@uipath/packager-tool-workflowcompiler",
-  "version": "1.199.0-preview.97",
+  "version": "1.199.0",
   "description": "UiPath Workflow Compiler tool implementation",
   "type": "module",
   "exports": {
@@ -28,5 +28,5 @@
     "@uipath/solutionpackager-tool-core": "1.199.0"
   },
   "dependencies": {},
-  "gitHead": "087ae21e842f27bde5eb0013892c9487bfe60568"
+  "gitHead": "723e6801b77b5926ba75e75b6a756cc38b1b7adc"
 }

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-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;