@uipath/packager-tool-workflowcompiler 1.202.0-preview.141 → 1.202.0-preview.142

package/src/workflow-compiler-executor.ts

@@ -1,530 +0,0 @@
-import { type ChildProcess, 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 { workflowCompilerConfig } from "./workflow-compiler-config.js";
-import {
-    type IWorkflowCompilerPathResolver,
-    WorkflowCompilerPathResolver,
-} from "./workflow-compiler-path-resolver.js";
-
-/** Signals when each child-process stream has finished. */
-interface StreamCompletion {
-    markStdoutEnded(): void;
-    markStderrEnded(): void;
-    markProcessExited(): void;
-}
-
-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 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();
-        // 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);
-
-        return new Promise((resolve) => {
-            let result: IOutputResult | null = null;
-            const fallbackErrors: string[] = [];
-            const analyzerFindings: Record<string, unknown>[] = [];
-
-            const childProcess = this.spawnProcess(
-                executable,
-                commandArgs,
-                workflowCompilerConfig.dotnetEnv,
-            );
-
-            // 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,
-                                },
-                            ),
-                        );
-                        const toolResult = new ToolResult(
-                            result.errorCode,
-                            result.message,
-                            result.outputPackages,
-                        );
-                        toolResult.details = withAnalyzerFindings(
-                            getAdditionalResultDetails(result),
-                            analyzerFindings,
-                        );
-                        resolve(toolResult);
-                    } 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),
-                analyzerFindings,
-            );
-            this.setupStderrHandling(
-                childProcess,
-                streamCompletion,
-                fallbackErrors,
-                analyzerFindings,
-            );
-            this.setupProcessEventHandlers(
-                childProcess,
-                streamCompletion,
-                resolve,
-            );
-            this.setupCancellationHandler(
-                childProcess,
-                cancellationToken,
-                resolve,
-            );
-        });
-    }
-
-    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,
-        });
-    }
-
-    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: ChildProcess,
-        streamCompletion: StreamCompletion,
-        onResult: (result: IOutputResult) => void,
-        analyzerFindings: Record<string, unknown>[],
-    ): 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, analyzerFindings);
-            }
-        });
-
-        childProcess.stdout.on("end", () => {
-            if (buffer.trim()) {
-                this.processOutputLine(buffer, onResult, analyzerFindings);
-            }
-            streamCompletion.markStdoutEnded();
-        });
-    }
-
-    private processOutputLine(
-        line: string,
-        onResult: (result: IOutputResult) => void,
-        analyzerFindings: Record<string, unknown>[],
-    ): void {
-        const entry = this.parseOutputEntry(line);
-        if (!entry) return;
-
-        if (entry.type === "Result") {
-            onResult(entry as IOutputResult);
-        } else if (entry.type === "Log") {
-            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);
-        }
-    }
-
-    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: ChildProcess,
-        streamCompletion: StreamCompletion,
-        fallbackErrors: string[],
-        analyzerFindings: Record<string, unknown>[],
-    ): 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, analyzerFindings);
-            }
-        });
-
-        childProcess.stderr.on("end", () => {
-            if (buffer.trim()) {
-                this.processErrorLine(buffer, fallbackErrors, analyzerFindings);
-            }
-            streamCompletion.markStderrEnded();
-        });
-    }
-
-    private processErrorLine(
-        line: string,
-        fallbackErrors: string[],
-        analyzerFindings: Record<string, unknown>[],
-    ): void {
-        const entry = this.parseOutputEntry(line);
-
-        if (entry && entry.type === "Log") {
-            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);
-        }
-    }
-
-    private setupProcessEventHandlers(
-        childProcess: ChildProcess,
-        streamCompletion: StreamCompletion,
-        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: ChildProcess,
-        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, unknown>;
-
-            // 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 as Array<{ path?: string }>
-                ).map((pkg) => pkg.path || pkg);
-            }
-
-            return camelCased as unknown as IOutputMessage;
-        } catch {
-            // Not JSON, return null
-            return null;
-        }
-    }
-}
-
-/**
- * Allow-list-driven copy of any *extra* fields the WorkflowCompiler emits on
- * its result envelope (e.g. analyzer `findings`) into `ToolResult.details`,
- * so downstream callers can read structured data without the executor having
- * to know what each consumer needs.
- *
- * Known envelope fields (already exposed as first-class on `ToolResult` or
- * intentionally internal) are excluded; anything else is copied through.
- * Adding the new field to `KNOWN_ENVELOPE_KEYS` is what keeps it out of
- * `details` — leaving it absent surfaces it, which is the safer default.
- */
-const KNOWN_ENVELOPE_KEYS = new Set<keyof IOutputResult>([
-    "elapsed",
-    "errorCode",
-    "inputId",
-    "message",
-    "outputPackages",
-    "toolId",
-    "type",
-]);
-
-function getAdditionalResultDetails(
-    result: IOutputResult,
-): Record<string, unknown> | undefined {
-    const details: Record<string, unknown> = {};
-    for (const key of Object.keys(result)) {
-        if (!KNOWN_ENVELOPE_KEYS.has(key as keyof IOutputResult)) {
-            details[key] = (result as Record<string, unknown>)[key];
-        }
-    }
-
-    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;
-    }
-}