@uipath/packager-tool-workflowcompiler 0.0.14

package/src/workflow-compiler-executor.ts

@@ -0,0 +1,386 @@
+import { spawn } from "node:child_process";
+import {
+    type IFileSystem,
+    type IToolLogger,
+    ToolErrorCodes,
+    ToolResult,
+    translate,
+} from "@uipath/solutionpackager-tool-core";
+import type {
+    IOutputLog,
+    IOutputMessage,
+    IOutputProgress,
+    IOutputResult,
+} from "./output-entry.js";
+import {
+    type IWorkflowCompilerPathResolver,
+    WorkflowCompilerPathResolver,
+} from "./workflow-compiler-path-resolver.js";
+
+function camelCaseKeys(obj: unknown): unknown {
+    if (Array.isArray(obj)) {
+        return obj.map(camelCaseKeys);
+    }
+    if (obj !== null && typeof obj === "object") {
+        const result: Record<string, unknown> = {};
+        for (const [key, value] of Object.entries(obj)) {
+            result[key.charAt(0).toLowerCase() + key.slice(1)] =
+                camelCaseKeys(value);
+        }
+        return result;
+    }
+    return obj;
+}
+
+/**
+ * Executor for running workflow compiler commands as child processes.
+ * Handles process spawning, output parsing, and logging.
+ */
+export class WorkflowCompilerExecutor {
+    private static readonly DOTNET_EXECUTABLE = "dotnet";
+    private readonly pathResolver: IWorkflowCompilerPathResolver;
+
+    constructor(
+        private readonly logger: IToolLogger,
+        fileSystem: IFileSystem,
+    ) {
+        this.pathResolver = WorkflowCompilerPathResolver.getInstance(
+            logger,
+            fileSystem,
+        );
+    }
+
+    /**
+     * Execute a workflow compiler command
+     * @param operation - Operation name (e.g., 'restore', 'build', 'pack', 'validate')
+     * @param args - Additional command arguments
+     * @param cancellationToken - Optional cancellation token
+     * @returns Promise resolving to ToolResult
+     */
+    async executeAsync(
+        operation: string,
+        args: string[],
+        cancellationToken?: AbortSignal,
+    ): Promise<ToolResult> {
+        const startTime = Date.now();
+        const compilerPath = await this.pathResolver.getCompilerPathAsync();
+        const isDll = compilerPath.endsWith(".dll");
+        const executable = isDll
+            ? WorkflowCompilerExecutor.DOTNET_EXECUTABLE
+            : compilerPath;
+        const commandArgs = isDll
+            ? [compilerPath, operation, ...args]
+            : [operation, ...args];
+
+        this.logCommandStart(operation, executable, commandArgs);
+
+        return new Promise((resolve) => {
+            let result: IOutputResult | null = null;
+            const fallbackErrors: string[] = [];
+
+            const childProcess = this.spawnProcess(executable, commandArgs);
+
+            // Track stream completion
+            let stdoutEnded = false;
+            let stderrEnded = false;
+            let processExited = false;
+
+            const checkComplete = () => {
+                if (stdoutEnded && stderrEnded && processExited) {
+                    const elapsed = Date.now() - startTime;
+
+                    if (result) {
+                        result.elapsed = elapsed;
+                        this.logger.info(
+                            translate.t(
+                                "toolWorkflowcompiler.lifecycle.completed",
+                                {
+                                    operation,
+                                    elapsed: elapsed.toString(),
+                                    errorCode: result.errorCode,
+                                },
+                            ),
+                        );
+                        resolve(
+                            new ToolResult(
+                                result.errorCode,
+                                result.message,
+                                result.outputPackages,
+                            ),
+                        );
+                    } else {
+                        const exitCode = childProcess.exitCode ?? -1;
+                        const errorMessage =
+                            fallbackErrors.join("\n") ||
+                            translate.t(
+                                "toolWorkflowcompiler.errors.processExited",
+                                {
+                                    exitCode: exitCode.toString(),
+                                },
+                            );
+                        this.logger.error(
+                            translate.t("toolWorkflowcompiler.errors.failed", {
+                                operation,
+                                errorMessage,
+                            }),
+                        );
+                        resolve(
+                            new ToolResult(
+                                ToolErrorCodes.InternalError,
+                                errorMessage,
+                                [],
+                            ),
+                        );
+                    }
+                }
+            };
+
+            const streamCompletion = {
+                markStdoutEnded: () => {
+                    stdoutEnded = true;
+                    checkComplete();
+                },
+                markStderrEnded: () => {
+                    stderrEnded = true;
+                    checkComplete();
+                },
+                markProcessExited: () => {
+                    processExited = true;
+                    checkComplete();
+                },
+            };
+
+            this.setupStdoutHandling(
+                childProcess,
+                streamCompletion,
+                (r) => (result = r),
+            );
+            this.setupStderrHandling(
+                childProcess,
+                streamCompletion,
+                fallbackErrors,
+            );
+            this.setupProcessEventHandlers(
+                childProcess,
+                streamCompletion,
+                resolve,
+            );
+            this.setupCancellationHandler(
+                childProcess,
+                cancellationToken,
+                resolve,
+            );
+        });
+    }
+
+    protected spawnProcess(command: string, args: string[]) {
+        return spawn(command, args, {
+            stdio: ["ignore", "pipe", "pipe"],
+            shell: false,
+            windowsHide: true,
+        });
+    }
+
+    private logCommandStart(
+        operation: string,
+        executable: string,
+        commandArgs: string[],
+    ): void {
+        const fullCommand = [executable, ...commandArgs];
+        this.logger.info(
+            translate.t("toolWorkflowcompiler.lifecycle.started", {
+                operation,
+            }),
+        );
+        this.logger.info(
+            translate.t("toolWorkflowcompiler.lifecycle.command", {
+                command: fullCommand.join(" "),
+            }),
+        );
+    }
+
+    private setupStdoutHandling(
+        childProcess: any,
+        streamCompletion: any,
+        onResult: (result: IOutputResult) => void,
+    ): void {
+        if (!childProcess.stdout) {
+            streamCompletion.markStdoutEnded();
+            return;
+        }
+
+        let buffer = "";
+        childProcess.stdout.on("data", (data: Buffer) => {
+            buffer += data.toString();
+            const lines = buffer.split("\n");
+            // Keep the last element — it's either a partial line or ""
+            buffer = lines.pop()!;
+            for (const line of lines) {
+                if (!line.trim()) continue;
+                this.processOutputLine(line, onResult);
+            }
+        });
+
+        childProcess.stdout.on("end", () => {
+            if (buffer.trim()) {
+                this.processOutputLine(buffer, onResult);
+            }
+            streamCompletion.markStdoutEnded();
+        });
+    }
+
+    private processOutputLine(
+        line: string,
+        onResult: (result: IOutputResult) => void,
+    ): void {
+        const entry = this.parseOutputEntry(line);
+        if (!entry) return;
+
+        if (entry.type === "Result") {
+            onResult(entry as IOutputResult);
+        } else if (entry.type === "Log") {
+            this.logMessage(entry as IOutputLog);
+        } else if (entry.type === "Progress") {
+            this.logProgress(entry as IOutputProgress);
+        }
+    }
+
+    private logMessage(log: IOutputLog): void {
+        switch (log.logLevel) {
+            case "Information":
+                this.logger.info(log.message);
+                break;
+            case "Warning":
+                this.logger.warn(log.message);
+                break;
+            case "Error":
+                this.logger.error(log.message);
+                break;
+        }
+    }
+
+    private logProgress(progress: IOutputProgress): void {
+        const percent = progress.percentage ? `${progress.percentage}%` : "";
+        const separator = percent && progress.message ? " - " : "";
+        this.logger.progress(`${percent}${separator}${progress.message ?? ""}`);
+    }
+
+    private setupStderrHandling(
+        childProcess: any,
+        streamCompletion: any,
+        fallbackErrors: string[],
+    ): void {
+        if (!childProcess.stderr) {
+            streamCompletion.markStderrEnded();
+            return;
+        }
+
+        let buffer = "";
+        childProcess.stderr.on("data", (data: Buffer) => {
+            buffer += data.toString();
+            const lines = buffer.split("\n");
+            buffer = lines.pop()!;
+            for (const line of lines) {
+                if (!line.trim()) continue;
+                this.processErrorLine(line, fallbackErrors);
+            }
+        });
+
+        childProcess.stderr.on("end", () => {
+            if (buffer.trim()) {
+                this.processErrorLine(buffer, fallbackErrors);
+            }
+            streamCompletion.markStderrEnded();
+        });
+    }
+
+    private processErrorLine(line: string, fallbackErrors: string[]): void {
+        const entry = this.parseOutputEntry(line);
+
+        if (entry && entry.type === "Log") {
+            this.logger.error((entry as IOutputLog).message);
+        } else {
+            fallbackErrors.push(line);
+            this.logger.error(line);
+        }
+    }
+
+    private setupProcessEventHandlers(
+        childProcess: any,
+        streamCompletion: any,
+        resolve: (value: ToolResult) => void,
+    ): void {
+        childProcess.on("exit", () => streamCompletion.markProcessExited());
+
+        childProcess.on("error", (error: Error) => {
+            this.logger.error(
+                translate.t("toolWorkflowcompiler.errors.processError", {
+                    message: error.message,
+                }),
+            );
+            resolve(
+                new ToolResult(
+                    ToolErrorCodes.InternalError,
+                    translate.t("toolWorkflowcompiler.errors.startFailed", {
+                        message: error.message,
+                    }),
+                    [],
+                ),
+            );
+        });
+    }
+
+    private setupCancellationHandler(
+        childProcess: any,
+        cancellationToken: AbortSignal | undefined,
+        resolve: (value: ToolResult) => void,
+    ): void {
+        if (!cancellationToken) return;
+
+        cancellationToken.addEventListener("abort", () => {
+            this.logger.warn(
+                translate.t("toolWorkflowcompiler.lifecycle.cancelled"),
+            );
+            childProcess.kill("SIGTERM");
+            resolve(
+                new ToolResult(
+                    ToolErrorCodes.Canceled,
+                    translate.t(
+                        "toolWorkflowcompiler.errors.operationCancelled",
+                    ),
+                    [],
+                ),
+            );
+        });
+    }
+
+    private parseOutputEntry(line: string): IOutputMessage | null {
+        try {
+            const parsed = JSON.parse(line);
+
+            // Convert PascalCase to camelCase
+            const camelCased = camelCaseKeys(parsed) as Record<string, any>;
+
+            // Convert numeric error codes to strings
+            if (camelCased.errorCode !== undefined) {
+                if (camelCased.errorCode === 0 || camelCased.success === true) {
+                    camelCased.errorCode = ToolErrorCodes.Success;
+                } else {
+                    camelCased.errorCode = String(camelCased.errorCode);
+                }
+            }
+
+            // Extract paths from OutputPackages array of objects
+            if (camelCased.outputPackages) {
+                camelCased.outputPackages = camelCased.outputPackages.map(
+                    (pkg: any) => pkg.path || pkg,
+                );
+            }
+
+            return camelCased as IOutputMessage;
+        } catch {
+            // Not JSON, return null
+            return null;
+        }
+    }
+}

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

@@ -0,0 +1,311 @@
+import { execFileSync } from "node:child_process";
+import { homedir, platform } from "node:os";
+import type {
+    IFileSystem,
+    IToolLogger,
+} from "@uipath/solutionpackager-tool-core";
+import {
+    Path,
+    TemporaryStorageService,
+    translate,
+} 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 PLATFORM_PACKAGES: Record<
+    string,
+    { packageId: string; compilerFileName: string }
+> = {
+    win32: {
+        packageId: "UiPath.WorkflowCompiler.Windows",
+        compilerFileName: "UiPath.WorkflowCompiler.exe",
+    },
+    darwin: {
+        packageId: "UiPath.WorkflowCompiler.macOS",
+        compilerFileName: "UiPath.WorkflowCompiler.dll",
+    },
+    linux: {
+        packageId: "UiPath.WorkflowCompiler.Linux",
+        compilerFileName: "UiPath.WorkflowCompiler.dll",
+    },
+};
+
+const RESTORE_CSPROJ_TEMPLATE = `<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net8.0</TargetFramework>
+  </PropertyGroup>
+  <ItemGroup>
+    <PackageReference Include="{packageId}" Version="{version}" />
+  </ItemGroup>
+</Project>`;
+
+const EMPTY_NUGET_CONFIG = `<?xml version="1.0" encoding="utf-8"?>
+<configuration>
+</configuration>`;
+
+export interface IWorkflowCompilerPathResolver {
+    getCompilerPathAsync(): Promise<string>;
+}
+
+/**
+ * Resolves and caches the workflow compiler executable path.
+ *
+ * Resolution chain:
+ * 1. In-memory cache (subsequent calls)
+ * 2. Explicit config path (`workflowCompilerConfig.workflowCompilerPath`)
+ * 3. `UIPATH_WORKFLOWCOMPILER_LOCATION` env var — full file path (pipelines / offline)
+ * 4. NuGet global packages cache
+ * 5. `dotnet restore` to populate NuGet cache, then (4) again
+ */
+export class WorkflowCompilerPathResolver
+    implements IWorkflowCompilerPathResolver
+{
+    private static instance: IWorkflowCompilerPathResolver | null = null;
+    private cachedPath: string | null = null;
+    private pendingResolution: Promise<string> | null = null;
+
+    private readonly tempStorage: TemporaryStorageService;
+
+    constructor(
+        private readonly logger: IToolLogger,
+        private readonly fileSystem: IFileSystem,
+    ) {
+        this.tempStorage = new TemporaryStorageService(fileSystem);
+    }
+
+    static getInstance(
+        logger: IToolLogger,
+        fileSystem: IFileSystem,
+    ): IWorkflowCompilerPathResolver {
+        if (!WorkflowCompilerPathResolver.instance) {
+            WorkflowCompilerPathResolver.instance =
+                new WorkflowCompilerPathResolver(logger, fileSystem);
+        }
+        return WorkflowCompilerPathResolver.instance;
+    }
+
+    async getCompilerPathAsync(): Promise<string> {
+        if (this.cachedPath) {
+            this.logger.info(
+                translate.t(
+                    "toolWorkflowcompiler.pathResolver.info.usingCached",
+                    { path: this.cachedPath },
+                ),
+            );
+            return this.cachedPath;
+        }
+
+        // Coalesce concurrent callers into a single resolution to avoid
+        // parallel dotnet restore processes.
+        if (this.pendingResolution) {
+            return this.pendingResolution;
+        }
+
+        this.pendingResolution = this.resolveCompilerPath();
+        this.cachedPath = await this.pendingResolution;
+        this.logger.info(
+            translate.t("toolWorkflowcompiler.pathResolver.info.resolved", {
+                path: this.cachedPath,
+            }),
+        );
+        return this.cachedPath;
+    }
+
+    private async resolveCompilerPath(): Promise<string> {
+        this.logger.info("[PathResolver] resolveCompilerPath started");
+
+        if (workflowCompilerConfig.workflowCompilerPath) {
+            this.logger.info(
+                translate.t(
+                    "toolWorkflowcompiler.pathResolver.info.usingExplicitPath",
+                    { path: workflowCompilerConfig.workflowCompilerPath },
+                ),
+            );
+            return workflowCompilerConfig.workflowCompilerPath;
+        }
+
+        this.logger.info(
+            translate.t("toolWorkflowcompiler.pathResolver.info.resolving"),
+        );
+
+        const envPath = await this.findInEnvLocation();
+        if (envPath) return envPath;
+
+        const version = workflowCompilerConfig.workflowCompilerVersion;
+        const compilerPath = this.getNuGetCompilerPath(version);
+
+        this.logger.info(
+            translate.t(
+                "toolWorkflowcompiler.pathResolver.info.checkingNuGetCache",
+                { path: compilerPath },
+            ),
+        );
+        if (await this.fileSystem.exists(compilerPath)) {
+            this.logger.info(
+                translate.t(
+                    "toolWorkflowcompiler.pathResolver.info.foundInNuGetCache",
+                ),
+            );
+            return compilerPath;
+        }
+
+        this.logger.info(
+            translate.t(
+                "toolWorkflowcompiler.pathResolver.info.notFoundStartingInstall",
+            ),
+        );
+        return this.restoreAndResolve(compilerPath, version);
+    }
+
+    private async findInEnvLocation(): Promise<string | null> {
+        const location = process.env.UIPATH_WORKFLOWCOMPILER_LOCATION;
+        if (!location) return null;
+
+        this.logger.info(
+            translate.t(
+                "toolWorkflowcompiler.pathResolver.info.checkingEnvVar",
+                { path: location },
+            ),
+        );
+
+        // Env var must point to a full file path (.dll or .exe)
+        if (
+            (location.endsWith(".dll") || location.endsWith(".exe")) &&
+            (await this.fileSystem.exists(location))
+        ) {
+            this.logger.info(
+                translate.t(
+                    "toolWorkflowcompiler.pathResolver.info.foundViaEnv",
+                ),
+            );
+            return location;
+        }
+
+        return null;
+    }
+
+    private async restoreAndResolve(
+        compilerPath: string,
+        version: string,
+    ): Promise<string> {
+        const { packageId } = this.getPlatformInfo();
+        const tempDir = await this.tempStorage.getTempFolderPath();
+
+        try {
+            this.logger.info(
+                translate.t(
+                    "toolWorkflowcompiler.pathResolver.info.restoringPackage",
+                    { packageName: packageId, version, platform: platform() },
+                ),
+            );
+
+            const csproj = RESTORE_CSPROJ_TEMPLATE.replace(
+                "{packageId}",
+                packageId,
+            ).replace("{version}", version);
+            await this.fileSystem.writeFile(
+                Path.join(tempDir, "restore.csproj"),
+                csproj,
+            );
+            await this.fileSystem.writeFile(
+                Path.join(tempDir, "nuget.config"),
+                EMPTY_NUGET_CONFIG,
+            );
+
+            this.logger.info(
+                translate.t(
+                    "toolWorkflowcompiler.pathResolver.info.runningDotnetRestore",
+                ),
+            );
+            try {
+                execFileSync(
+                    "dotnet",
+                    [
+                        "restore",
+                        "--source",
+                        NUGET_FEED_URL,
+                        "--source",
+                        "https://api.nuget.org/v3/index.json",
+                    ],
+                    {
+                        cwd: tempDir,
+                        stdio: "pipe",
+                    },
+                );
+            } catch (error: unknown) {
+                const err = error as Record<string, unknown>;
+                const stderr = err?.stderr ? String(err.stderr).trim() : "";
+                const stdout = err?.stdout ? String(err.stdout).trim() : "";
+                const details =
+                    stderr ||
+                    stdout ||
+                    (error instanceof Error ? error.message : String(error));
+                throw new Error(
+                    translate.t(
+                        "toolWorkflowcompiler.pathResolver.errors.dotnetRestoreFailed",
+                        { details },
+                    ),
+                );
+            }
+            this.logger.info(
+                translate.t(
+                    "toolWorkflowcompiler.pathResolver.info.restoreCompleted",
+                ),
+            );
+
+            if (!(await this.fileSystem.exists(compilerPath))) {
+                throw new Error(
+                    translate.t(
+                        "toolWorkflowcompiler.pathResolver.errors.compilerNotFoundAfterRestore",
+                    ),
+                );
+            }
+
+            this.logger.info(
+                translate.t(
+                    "toolWorkflowcompiler.pathResolver.info.installCompleted",
+                ),
+            );
+            return compilerPath;
+        } finally {
+            this.logger.info(
+                translate.t(
+                    "toolWorkflowcompiler.pathResolver.info.cleaningUp",
+                ),
+            );
+            await this.tempStorage.cleanup();
+        }
+    }
+
+    private getPlatformInfo(): {
+        packageId: string;
+        compilerFileName: string;
+    } {
+        const info = PLATFORM_PACKAGES[platform()];
+        if (!info) {
+            throw new Error(
+                translate.t(
+                    "toolWorkflowcompiler.pathResolver.errors.unsupportedPlatform",
+                    { platform: platform() },
+                ),
+            );
+        }
+        return info;
+    }
+
+    private getNuGetCompilerPath(version: string): string {
+        const cacheRoot =
+            process.env.NUGET_PACKAGES ??
+            Path.join(homedir(), ".nuget", "packages");
+        const { packageId, compilerFileName } = this.getPlatformInfo();
+        return Path.join(
+            cacheRoot,
+            packageId.toLowerCase(),
+            version.toLowerCase(),
+            "WorkflowCompiler",
+            compilerFileName,
+        );
+    }
+}