@uipath/packager-tool-workflowcompiler 1.199.0-preview.99 → 1.199.1-preview.119

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";
@@ -1156,6 +1157,7 @@ class WorkflowCompilerExecutor {
     return new Promise((resolve) => {
       let result = null;
       const fallbackErrors = [];
+      const analyzerFindings = [];
       const childProcess = this.spawnProcess(executable, commandArgs, workflowCompilerConfig.dotnetEnv);
       let stdoutEnded = false;
       let stderrEnded = false;
@@ -1171,7 +1173,7 @@ class WorkflowCompilerExecutor {
               errorCode: result.errorCode
             }));
             const toolResult = new ToolResult(result.errorCode, result.message, result.outputPackages);
-            toolResult.details = getAdditionalResultDetails(result);
+            toolResult.details = withAnalyzerFindings(getAdditionalResultDetails(result), analyzerFindings);
             resolve(toolResult);
           } else {
             const exitCode = childProcess.exitCode ?? -1;
@@ -1201,8 +1203,8 @@ class WorkflowCompilerExecutor {
           checkComplete();
         }
       };
-      this.setupStdoutHandling(childProcess, streamCompletion, (r) => result = r);
-      this.setupStderrHandling(childProcess, streamCompletion, fallbackErrors);
+      this.setupStdoutHandling(childProcess, streamCompletion, (r) => result = r, analyzerFindings);
+      this.setupStderrHandling(childProcess, streamCompletion, fallbackErrors, analyzerFindings);
       this.setupProcessEventHandlers(childProcess, streamCompletion, resolve);
       this.setupCancellationHandler(childProcess, cancellationToken, resolve);
     });
@@ -1224,7 +1226,7 @@ class WorkflowCompilerExecutor {
       command: fullCommand.join(" ")
     }));
   }
-  setupStdoutHandling(childProcess, streamCompletion, onResult) {
+  setupStdoutHandling(childProcess, streamCompletion, onResult, analyzerFindings) {
     if (!childProcess.stdout) {
       streamCompletion.markStdoutEnded();
       return;
@@ -1238,24 +1240,29 @@ class WorkflowCompilerExecutor {
       for (const line of lines) {
         if (!line.trim())
           continue;
-        this.processOutputLine(line, onResult);
+        this.processOutputLine(line, onResult, analyzerFindings);
       }
     });
     childProcess.stdout.on("end", () => {
       if (buffer.trim()) {
-        this.processOutputLine(buffer, onResult);
+        this.processOutputLine(buffer, onResult, analyzerFindings);
       }
       streamCompletion.markStdoutEnded();
     });
   }
-  processOutputLine(line, onResult) {
+  processOutputLine(line, onResult, analyzerFindings) {
     const entry = this.parseOutputEntry(line);
     if (!entry)
       return;
     if (entry.type === "Result") {
       onResult(entry);
     } else if (entry.type === "Log") {
-      this.logMessage(entry);
+      const log = entry;
+      const finding = toAnalyzerFinding(log);
+      if (finding) {
+        analyzerFindings.push(finding);
+      }
+      this.logMessage(log);
     } else if (entry.type === "Progress") {
       this.logProgress(entry);
     }
@@ -1278,7 +1285,7 @@ class WorkflowCompilerExecutor {
     const separator = percent && progress.message ? " - " : "";
     this.logger.progress(`${percent}${separator}${progress.message ?? ""}`);
   }
-  setupStderrHandling(childProcess, streamCompletion, fallbackErrors) {
+  setupStderrHandling(childProcess, streamCompletion, fallbackErrors, analyzerFindings) {
     if (!childProcess.stderr) {
       streamCompletion.markStderrEnded();
       return;
@@ -1292,20 +1299,25 @@ class WorkflowCompilerExecutor {
       for (const line of lines) {
         if (!line.trim())
           continue;
-        this.processErrorLine(line, fallbackErrors);
+        this.processErrorLine(line, fallbackErrors, analyzerFindings);
       }
     });
     childProcess.stderr.on("end", () => {
       if (buffer.trim()) {
-        this.processErrorLine(buffer, fallbackErrors);
+        this.processErrorLine(buffer, fallbackErrors, analyzerFindings);
       }
       streamCompletion.markStderrEnded();
     });
   }
-  processErrorLine(line, fallbackErrors) {
+  processErrorLine(line, fallbackErrors, analyzerFindings) {
     const entry = this.parseOutputEntry(line);
     if (entry && entry.type === "Log") {
-      this.logger.error(entry.message);
+      const log = entry;
+      const finding = toAnalyzerFinding(log);
+      if (finding) {
+        analyzerFindings.push(finding);
+      }
+      this.logger.error(log.message);
     } else {
       fallbackErrors.push(line);
       this.logger.error(line);
@@ -1369,6 +1381,54 @@ function getAdditionalResultDetails(result) {
   }
   return Object.keys(details).length > 0 ? details : undefined;
 }
+var ANALYZER_LOG_SOURCE = "Analyzer";
+function withAnalyzerFindings(details, findings) {
+  const fromEnvelope = details?.findings;
+  if (findings.length === 0 || Array.isArray(fromEnvelope) && fromEnvelope.length > 0) {
+    return details;
+  }
+  return { ...details, findings };
+}
+function toAnalyzerFinding(log) {
+  if (log.source !== ANALYZER_LOG_SOURCE) {
+    return;
+  }
+  const message = parseAnalyzerMessage(log.data) ?? {};
+  const activityId = message.ActivityId;
+  const item = message.Item;
+  return {
+    ...message,
+    ErrorCode: message.ErrorCode ?? log.code,
+    Description: message.Description ?? log.message,
+    FilePath: message.FilePath ?? log.filePath,
+    ErrorSeverity: message.ErrorSeverity ?? toErrorSeverity(log.logLevel),
+    ActivityIdRef: activityId?.IdRef ?? log.id,
+    AnalyzerItemName: item?.Name,
+    AnalyzerItemType: item?.Type
+  };
+}
+function toErrorSeverity(logLevel) {
+  switch (logLevel) {
+    case "Debug":
+    case "Trace":
+      return "Verbose";
+    case "Information":
+      return "Info";
+    default:
+      return logLevel;
+  }
+}
+function parseAnalyzerMessage(data) {
+  if (!data) {
+    return;
+  }
+  try {
+    const parsed = JSON.parse(data);
+    return typeof parsed === "object" && parsed !== null && !Array.isArray(parsed) ? parsed : undefined;
+  } catch {
+    return;
+  }
+}
 
 // src/workflow-compiler-tool.ts
 class WorkflowCompilerTool extends ProjectTool {
@@ -1637,11 +1697,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 +1725,4 @@ export {
   WorkflowCompilerToolFactory
 };
 
-//# debugId=DF8E70BC8F5CC6D964756E2164756E21
+//# debugId=9E5F0B597C7A3E6E64756E2164756E21

package/dist/output-entry.d.ts

@@ -15,12 +15,18 @@ export interface IOutputMessage {
     inputId?: string;
 }
 /**
- * Log message from workflow compiler output
+ * Log message from workflow compiler output. Analyzer findings are reported only here.
  */
 export interface IOutputLog extends IOutputMessage {
     type: OutputMessageType.Log;
     message: string;
-    logLevel: "Information" | "Warning" | "Error";
+    logLevel: "Trace" | "Debug" | "Information" | "Warning" | "Error" | "None";
+    source?: string;
+    code?: string;
+    filePath?: string;
+    id?: string;
+    /** Serialized `AnalyzerMessage`. */
+    data?: string;
 }
 /**
  * Progress update from workflow compiler output

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.99",
+  "version": "1.199.1-preview.119",
   "description": "UiPath Workflow Compiler tool implementation",
   "type": "module",
   "exports": {
@@ -28,5 +28,5 @@
     "@uipath/solutionpackager-tool-core": "1.199.0"
   },
   "dependencies": {},
-  "gitHead": "6ba217cddceb86e3fa39ed82e49c5062878a85c6"
+  "gitHead": "9237653cf731fb275714c8ee5aab5dc057424b42"
 }

package/src/output-entry.ts

@@ -17,12 +17,18 @@ export interface IOutputMessage {
 }
 
 /**
- * Log message from workflow compiler output
+ * Log message from workflow compiler output. Analyzer findings are reported only here.
  */
 export interface IOutputLog extends IOutputMessage {
     type: OutputMessageType.Log;
     message: string;
-    logLevel: "Information" | "Warning" | "Error";
+    logLevel: "Trace" | "Debug" | "Information" | "Warning" | "Error" | "None";
+    source?: string;
+    code?: string;
+    filePath?: string;
+    id?: string;
+    /** Serialized `AnalyzerMessage`. */
+    data?: string;
 }
 
 /**

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-executor.ts

@@ -82,6 +82,7 @@ export class WorkflowCompilerExecutor {
         return new Promise((resolve) => {
             let result: IOutputResult | null = null;
             const fallbackErrors: string[] = [];
+            const analyzerFindings: Record<string, unknown>[] = [];
 
             const childProcess = this.spawnProcess(
                 executable,
@@ -115,7 +116,10 @@ export class WorkflowCompilerExecutor {
                             result.message,
                             result.outputPackages,
                         );
-                        toolResult.details = getAdditionalResultDetails(result);
+                        toolResult.details = withAnalyzerFindings(
+                            getAdditionalResultDetails(result),
+                            analyzerFindings,
+                        );
                         resolve(toolResult);
                     } else {
                         const exitCode = childProcess.exitCode ?? -1;
@@ -163,11 +167,13 @@ export class WorkflowCompilerExecutor {
                 childProcess,
                 streamCompletion,
                 (r) => (result = r),
+                analyzerFindings,
             );
             this.setupStderrHandling(
                 childProcess,
                 streamCompletion,
                 fallbackErrors,
+                analyzerFindings,
             );
             this.setupProcessEventHandlers(
                 childProcess,
@@ -219,6 +225,7 @@ export class WorkflowCompilerExecutor {
         childProcess: ChildProcess,
         streamCompletion: StreamCompletion,
         onResult: (result: IOutputResult) => void,
+        analyzerFindings: Record<string, unknown>[],
     ): void {
         if (!childProcess.stdout) {
             streamCompletion.markStdoutEnded();
@@ -233,13 +240,13 @@ export class WorkflowCompilerExecutor {
             buffer = lines.pop()!;
             for (const line of lines) {
                 if (!line.trim()) continue;
-                this.processOutputLine(line, onResult);
+                this.processOutputLine(line, onResult, analyzerFindings);
             }
         });
 
         childProcess.stdout.on("end", () => {
             if (buffer.trim()) {
-                this.processOutputLine(buffer, onResult);
+                this.processOutputLine(buffer, onResult, analyzerFindings);
             }
             streamCompletion.markStdoutEnded();
         });
@@ -248,6 +255,7 @@ export class WorkflowCompilerExecutor {
     private processOutputLine(
         line: string,
         onResult: (result: IOutputResult) => void,
+        analyzerFindings: Record<string, unknown>[],
     ): void {
         const entry = this.parseOutputEntry(line);
         if (!entry) return;
@@ -255,7 +263,12 @@ export class WorkflowCompilerExecutor {
         if (entry.type === "Result") {
             onResult(entry as IOutputResult);
         } else if (entry.type === "Log") {
-            this.logMessage(entry as IOutputLog);
+            const log = entry as IOutputLog;
+            const finding = toAnalyzerFinding(log);
+            if (finding) {
+                analyzerFindings.push(finding);
+            }
+            this.logMessage(log);
         } else if (entry.type === "Progress") {
             this.logProgress(entry as IOutputProgress);
         }
@@ -285,6 +298,7 @@ export class WorkflowCompilerExecutor {
         childProcess: ChildProcess,
         streamCompletion: StreamCompletion,
         fallbackErrors: string[],
+        analyzerFindings: Record<string, unknown>[],
     ): void {
         if (!childProcess.stderr) {
             streamCompletion.markStderrEnded();
@@ -298,23 +312,32 @@ export class WorkflowCompilerExecutor {
             buffer = lines.pop()!;
             for (const line of lines) {
                 if (!line.trim()) continue;
-                this.processErrorLine(line, fallbackErrors);
+                this.processErrorLine(line, fallbackErrors, analyzerFindings);
             }
         });
 
         childProcess.stderr.on("end", () => {
             if (buffer.trim()) {
-                this.processErrorLine(buffer, fallbackErrors);
+                this.processErrorLine(buffer, fallbackErrors, analyzerFindings);
             }
             streamCompletion.markStderrEnded();
         });
     }
 
-    private processErrorLine(line: string, fallbackErrors: string[]): void {
+    private processErrorLine(
+        line: string,
+        fallbackErrors: string[],
+        analyzerFindings: Record<string, unknown>[],
+    ): void {
         const entry = this.parseOutputEntry(line);
 
         if (entry && entry.type === "Log") {
-            this.logger.error((entry as IOutputLog).message);
+            const log = entry as IOutputLog;
+            const finding = toAnalyzerFinding(log);
+            if (finding) {
+                analyzerFindings.push(finding);
+            }
+            this.logger.error(log.message);
         } else {
             fallbackErrors.push(line);
             this.logger.error(line);
@@ -434,3 +457,74 @@ function getAdditionalResultDetails(
 
     return Object.keys(details).length > 0 ? details : undefined;
 }
+
+const ANALYZER_LOG_SOURCE = "Analyzer";
+
+/** Only a *populated* envelope array wins — `CommandResult` defaults its lists to `[]`. */
+function withAnalyzerFindings(
+    details: Record<string, unknown> | undefined,
+    findings: Record<string, unknown>[],
+): Record<string, unknown> | undefined {
+    const fromEnvelope = details?.findings;
+    if (
+        findings.length === 0 ||
+        (Array.isArray(fromEnvelope) && fromEnvelope.length > 0)
+    ) {
+        return details;
+    }
+    return { ...details, findings };
+}
+
+/** Flattened because consumers match flat keys only; the payload omits null members. */
+function toAnalyzerFinding(
+    log: IOutputLog,
+): Record<string, unknown> | undefined {
+    if (log.source !== ANALYZER_LOG_SOURCE) {
+        return undefined;
+    }
+
+    const message = parseAnalyzerMessage(log.data) ?? {};
+    const activityId = message.ActivityId as { IdRef?: string } | undefined;
+    const item = message.Item as { Name?: string; Type?: string } | undefined;
+    return {
+        ...message,
+        ErrorCode: message.ErrorCode ?? log.code,
+        Description: message.Description ?? log.message,
+        FilePath: message.FilePath ?? log.filePath,
+        ErrorSeverity: message.ErrorSeverity ?? toErrorSeverity(log.logLevel),
+        ActivityIdRef: activityId?.IdRef ?? log.id,
+        AnalyzerItemName: item?.Name,
+        AnalyzerItemType: item?.Type,
+    };
+}
+
+/** Undo the compiler's `TraceLevel` → `LogLevel` mapping, so a consumer's lookup still matches. */
+function toErrorSeverity(logLevel: IOutputLog["logLevel"]): string {
+    switch (logLevel) {
+        case "Debug":
+        case "Trace":
+            return "Verbose";
+        case "Information":
+            return "Info";
+        default:
+            return logLevel;
+    }
+}
+
+function parseAnalyzerMessage(
+    data: string | undefined,
+): Record<string, unknown> | undefined {
+    if (!data) {
+        return undefined;
+    }
+    try {
+        const parsed: unknown = JSON.parse(data);
+        return typeof parsed === "object" &&
+            parsed !== null &&
+            !Array.isArray(parsed)
+            ? (parsed as Record<string, unknown>)
+            : undefined;
+    } catch {
+        return 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;