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

package/src/workflow-compiler-tool.ts

@@ -1,519 +0,0 @@
-import { OrchestratorFeedComposer } from "@uipath/packager-orchestrator-client";
-import {
-    type FileSystemStats,
-    type IFileSystem,
-    type IProjectBuildOptions,
-    type IProjectCleanupOptions,
-    type IProjectOptions,
-    type IProjectPackOptions,
-    type IProjectRestoreOptions,
-    type IProjectValidateOptions,
-    type IToolLogger,
-    LogLevel,
-    type ProjectOperationContext,
-    ProjectTool,
-    type ToolResult,
-    toProjectCleanupInfo,
-    type WorkflowCompilerCleanupPayload,
-} from "@uipath/solutionpackager-tool-core";
-import { WorkflowCompilerExecutor } from "./workflow-compiler-executor.js";
-
-/**
- * Raw `remove-unused-dependencies` payload the WorkflowCompiler emits on
- * `details.removeUnusedDependencies` (PascalCase on the wire, camelCased by the
- * executor). Owned by this tool; mapped to the generic {@link ProjectCleanupInfo}
- * before it leaves `cleanupAsync` so nothing downstream depends on this shape.
- */
-type RawRemoveUnusedDependenciesResult = WorkflowCompilerCleanupPayload;
-
-const NO_CLEANUP_SOURCE_FILES_MESSAGE =
-    "no workflow xamls or coded source files";
-const CLEANUP_SOURCE_FILE_EXTENSIONS = [".xaml", ".cs", ".vb"];
-const CLEANUP_SOURCE_SCAN_SKIP_DIRS = new Set([
-    ".git",
-    ".local",
-    ".project",
-    "bin",
-    "dist",
-    "node_modules",
-    "obj",
-]);
-
-/**
- * The two NuGet-source channels the WorkflowCompiler accepts, kept apart on
- * purpose:
- * - `orchestratorFeedsJsonPath` — Orchestrator tenant feeds composed internally into a
- *   JSON file, passed on the hidden `--nuget-config-file` option. Never
- *   user-supplied.
- * - `userNugetConfigPath` — the user's own NuGet.config (XML), passed verbatim on
- *   `--nuget-config`.
- */
-interface FeedPaths {
-    orchestratorFeedsJsonPath?: string;
-    userNugetConfigPath?: string;
-}
-
-/**
- * Workflow compiler tool implementation.
- * Builds commands and delegates execution to WorkflowCompilerExecutor.
- */
-export class WorkflowCompilerTool extends ProjectTool {
-    private readonly executor: WorkflowCompilerExecutor;
-
-    constructor(
-        fileSystem: IFileSystem,
-        logger: IToolLogger,
-        private readonly context?: ProjectOperationContext,
-    ) {
-        super(fileSystem, logger);
-        this.executor = new WorkflowCompilerExecutor(logger, fileSystem);
-    }
-
-    private async withFeedPaths(
-        options: IProjectOptions,
-        run: (paths: FeedPaths) => Promise<ToolResult>,
-    ): Promise<ToolResult> {
-        // The user's own NuGet.config (XML) always rides the --nuget-config
-        // channel; it is never mixed into the internal feeds file.
-        const userNugetConfigPath = options.nuGetSourcesConfigPath;
-        const connection = this.context?.connection;
-        // A named folder must fail closed. Skipping composition here would let
-        // the build fall back to whatever other sources are configured, which is
-        // precisely what --feed-folder exists to prevent — so hand it to the
-        // composer even without a session and let it raise.
-        if (!connection && !options.feedFolder) {
-            return run({ userNugetConfigPath });
-        }
-        // Orchestrator tenant feeds are composed into a JSON file that only ever
-        // goes on the hidden --nuget-config-file option.
-        const composed = await new OrchestratorFeedComposer(
-            this.fileSystem,
-            this.logger,
-        ).composeAsync({ connection, feedFolder: options.feedFolder });
-        try {
-            return await run({
-                orchestratorFeedsJsonPath: composed.configPath,
-                userNugetConfigPath,
-            });
-        } finally {
-            await composed.dispose();
-        }
-    }
-
-    async restoreAsync(
-        options: IProjectRestoreOptions,
-        cancellationToken?: AbortSignal,
-    ): Promise<ToolResult> {
-        return this.withFeedPaths(options, (paths) => {
-            const args = [
-                `-p`,
-                options.projectPath,
-                `--log-level`,
-                String(options.logLevel ?? LogLevel.Info),
-                `--destination`,
-                options.outputPath ?? "",
-                `--format-logs`,
-                `true`,
-                `--exclude-configured-sources`,
-                `${options.excludeConfiguredSources}`,
-            ];
-
-            if (paths.orchestratorFeedsJsonPath) {
-                args.push(
-                    `--nuget-config-file`,
-                    paths.orchestratorFeedsJsonPath,
-                );
-            }
-            if (paths.userNugetConfigPath) {
-                args.push(`--nuget-config`, paths.userNugetConfigPath);
-            }
-
-            return this.executor.executeAsync(
-                "restore",
-                args,
-                cancellationToken,
-            );
-        });
-    }
-
-    async validateAsync(
-        options: IProjectValidateOptions,
-        cancellationToken?: AbortSignal,
-    ): Promise<ToolResult> {
-        return this.withFeedPaths(options, (paths) => {
-            const args = [
-                `-p`,
-                options.projectPath,
-                `--log-level`,
-                String(options.logLevel ?? LogLevel.Info),
-                `--format-logs`,
-                `true`,
-                `--skip-analyze`,
-                `${options.skipAnalyze}`,
-                `--skip-validate`,
-                `${options.skipValidate}`,
-                `--exclude-configured-sources`,
-                `${options.excludeConfiguredSources}`,
-            ];
-
-            if (options.detailedLogPath) {
-                args.push(`--detailed`, options.detailedLogPath);
-            }
-            if (options.defaultSeverity) {
-                args.push(`--default-severity`, options.defaultSeverity);
-            }
-            if (options.policyFilePath) {
-                args.push(`--policy-file`, options.policyFilePath);
-            }
-            if (options.policyFileType) {
-                args.push(`--policy-file-type`, `${options.policyFileType}`);
-            }
-            if (paths.orchestratorFeedsJsonPath) {
-                args.push(
-                    `--nuget-config-file`,
-                    paths.orchestratorFeedsJsonPath,
-                );
-            }
-            if (paths.userNugetConfigPath) {
-                args.push(`--nuget-config`, paths.userNugetConfigPath);
-            }
-
-            return this.executor.executeAsync(
-                "validate",
-                args,
-                cancellationToken,
-            );
-        });
-    }
-
-    async buildAsync(
-        options: IProjectBuildOptions,
-        cancellationToken?: AbortSignal,
-    ): Promise<ToolResult> {
-        return this.withFeedPaths(options, (paths) => {
-            const args = [
-                `-p`,
-                options.projectPath,
-                `-o`,
-                options.outputPath,
-                `--log-level`,
-                String(options.logLevel ?? LogLevel.Info),
-                `--format-logs`,
-                `true`,
-                `--skip-analyze`,
-                `${options.skipAnalyze}`,
-                `--skip-validate`,
-                `${options.skipValidate}`,
-                `--exclude-configured-sources`,
-                `${options.excludeConfiguredSources}`,
-            ];
-
-            if (options.detailedLogPath) {
-                args.push(`--detailed`, options.detailedLogPath);
-            }
-            if (options.policyFilePath) {
-                args.push(`--policy-file`, options.policyFilePath);
-            }
-            if (options.policyFileType) {
-                args.push(`--policy-file-type`, `${options.policyFileType}`);
-            }
-            if (options.outputType) {
-                const outputType = this.mapOutputType(options.outputType);
-                args.push(`--output-type`, outputType);
-            }
-            if (paths.orchestratorFeedsJsonPath) {
-                args.push(
-                    `--nuget-config-file`,
-                    paths.orchestratorFeedsJsonPath,
-                );
-            }
-            if (paths.userNugetConfigPath) {
-                args.push(`--nuget-config`, paths.userNugetConfigPath);
-            }
-
-            return this.executor.executeAsync("build", args, cancellationToken);
-        });
-    }
-
-    async packAsync(
-        options: IProjectPackOptions,
-        cancellationToken?: AbortSignal,
-    ): Promise<ToolResult> {
-        return this.withFeedPaths(options, async (paths) => {
-            const args: string[] = [
-                `-p`,
-                options.projectPath,
-                `-o`,
-                options.outputPath,
-                `--build-version`,
-                options.package.version,
-                `--log-level`,
-                String(options.logLevel ?? LogLevel.Info),
-                `--format-logs`,
-                `true`,
-                `--skip-analyze`,
-                `${options.skipAnalyze}`,
-                `--skip-validate`,
-                `${options.skipValidate}`,
-                `--no-optimize-deps`,
-                `${options.skipDependencyOptimization}`,
-                `--include-sources`,
-                `${options.includeSources}`,
-                `--split-packages`,
-                `${options.splitPackages}`,
-                `--exclude-configured-sources`,
-                `${options.excludeConfiguredSources}`,
-                `--pack-options`,
-                JSON.stringify(options.package),
-            ];
-
-            if (options.package.id) {
-                args.push(`--package-name`, options.package.id);
-            }
-            if (options.detailedLogPath) {
-                args.push(`--detailed`, options.detailedLogPath);
-            }
-            if (options.policyFilePath) {
-                args.push(`--policy-file`, options.policyFilePath);
-            }
-            if (options.policyFileType) {
-                args.push(`--policy-file-type`, options.policyFileType);
-            }
-            if (options.outputType) {
-                const outputType = this.mapOutputType(options.outputType);
-                args.push(`--output-type`, outputType);
-            }
-            if (paths.orchestratorFeedsJsonPath) {
-                args.push(
-                    `--nuget-config-file`,
-                    paths.orchestratorFeedsJsonPath,
-                );
-            }
-            if (paths.userNugetConfigPath) {
-                args.push(`--nuget-config`, paths.userNugetConfigPath);
-            }
-
-            const result = await this.executor.executeAsync(
-                "build",
-                args,
-                cancellationToken,
-            );
-            return this.recoverPackagePathsAsync(result, options.outputPath);
-        });
-    }
-
-    async cleanupAsync(
-        options: IProjectCleanupOptions,
-        cancellationToken?: AbortSignal,
-    ): Promise<ToolResult> {
-        return this.withFeedPaths(options, async (paths) => {
-            const args = [
-                `-p`,
-                options.projectPath,
-                `--log-level`,
-                String(options.logLevel ?? LogLevel.Info),
-                `--format-logs`,
-                `true`,
-                `--exclude-configured-sources`,
-                `${options.excludeConfiguredSources}`,
-            ];
-
-            // --dry-run and --skip-imports are boolean switches on the compiler CLI:
-            // present means true, absent means false. They take no value — passing
-            // one (`--dry-run false`) leaves a stray token and still enables the flag.
-            if (options.dryRun) {
-                args.push(`--dry-run`);
-            }
-            if (options.skipImports) {
-                args.push(`--skip-imports`);
-            }
-
-            if (paths.orchestratorFeedsJsonPath) {
-                args.push(
-                    `--nuget-config-file`,
-                    paths.orchestratorFeedsJsonPath,
-                );
-            }
-            if (paths.userNugetConfigPath) {
-                args.push(`--nuget-config`, paths.userNugetConfigPath);
-            }
-
-            const result = await this.executor.executeAsync(
-                "remove-unused-dependencies",
-                args,
-                cancellationToken,
-            );
-            if (
-                await this.shouldRetryCleanupNoSourceFalseNegativeAsync(
-                    result,
-                    options.projectPath,
-                )
-            ) {
-                this.logger.warn(
-                    "[WorkflowCompiler] remove-unused-dependencies reported no workflow/source files even though the project contains source files; retrying once.",
-                );
-                const retryResult = await this.executor.executeAsync(
-                    "remove-unused-dependencies",
-                    args,
-                    cancellationToken,
-                );
-                return this.toProjectCleanupResult(retryResult);
-            }
-            return this.toProjectCleanupResult(result);
-        });
-    }
-
-    private async shouldRetryCleanupNoSourceFalseNegativeAsync(
-        result: ToolResult,
-        projectPath: string,
-    ): Promise<boolean> {
-        if (result.isSuccess) {
-            return false;
-        }
-
-        const message = result.message?.toLowerCase();
-        if (!message?.includes(NO_CLEANUP_SOURCE_FILES_MESSAGE)) {
-            return false;
-        }
-
-        return await this.hasCleanupSourceFilesAsync(projectPath);
-    }
-
-    private async hasCleanupSourceFilesAsync(
-        projectPath: string,
-    ): Promise<boolean> {
-        let entries: string[];
-        try {
-            entries = await this.fileSystem.readdir(projectPath);
-        } catch {
-            return false;
-        }
-
-        for (const entry of entries) {
-            const lowerEntry = entry.toLowerCase();
-            const fullPath = this.fileSystem.path.join(projectPath, entry);
-            let stats: FileSystemStats | null;
-            try {
-                stats = await this.fileSystem.stat(fullPath);
-            } catch {
-                continue;
-            }
-            if (!stats) {
-                continue;
-            }
-
-            if (
-                stats.isFile() &&
-                CLEANUP_SOURCE_FILE_EXTENSIONS.some((extension) =>
-                    lowerEntry.endsWith(extension),
-                )
-            ) {
-                return true;
-            }
-
-            if (
-                stats.isDirectory() &&
-                !CLEANUP_SOURCE_SCAN_SKIP_DIRS.has(lowerEntry) &&
-                (await this.hasCleanupSourceFilesAsync(fullPath))
-            ) {
-                return true;
-            }
-        }
-
-        return false;
-    }
-
-    /**
-     * Convert the WorkflowCompiler's raw `remove-unused-dependencies` payload
-     * into the generic {@link ProjectCleanupInfo} the cleanup pipeline expects,
-     * exposed under the generic `details.projectCleanup` key. The
-     * workflow-specific bits (per-file removed namespaces) are preserved under
-     * `toolDetails` with this tool's own type; callers that only want the general
-     * result ignore it. Leaves the result untouched when the tool reported no
-     * cleanup payload (e.g. a failure, or an older compiler build).
-     */
-    private toProjectCleanupResult(result: ToolResult): ToolResult {
-        const raw = result.details?.removeUnusedDependencies as
-            | RawRemoveUnusedDependenciesResult
-            | undefined;
-        if (!raw) {
-            return result;
-        }
-
-        // Re-key the wire-named payload under the generic `projectCleanup` so
-        // nothing downstream sees this tool's domain naming.
-        const details = { ...result.details };
-        delete details.removeUnusedDependencies;
-        details.projectCleanup = toProjectCleanupInfo(raw);
-        result.details = details;
-        return result;
-    }
-
-    /**
-     * Maps output type for workflow compiler.
-     */
-    private mapOutputType(outputType: string): string {
-        return outputType === "WebApp" ? "Process" : outputType;
-    }
-
-    /**
-     * WORKAROUND (UV-15007): older WorkflowCompiler builds report the staging
-     * content folder in their pack result instead of the produced `.nupkg` path,
-     * so downstream consumers (package signing, solution compression) cannot rely
-     * on `packages`. When the result does not already carry `.nupkg` paths, recover
-     * them by scanning the output folder.
-     *
-     * Remove this fallback after UV-15007 lands and the bundled WorkflowCompiler
-     * surfaces the produced `.nupkg` path in its result
-     * (see scripts/Download-WorkflowCompiler.ps1).
-     */
-    private async recoverPackagePathsAsync(
-        result: ToolResult,
-        outputPath: string,
-    ): Promise<ToolResult> {
-        if (!result.isSuccess) {
-            return result;
-        }
-
-        const alreadyHasNupkgPaths =
-            result.packages.length > 0 &&
-            result.packages.every((p) => p.toLowerCase().endsWith(".nupkg"));
-        if (alreadyHasNupkgPaths) {
-            return result;
-        }
-
-        const recovered = await this.findNupkgFilesAsync(outputPath);
-        if (recovered.length > 0) {
-            this.logger.warn(
-                `[WorkflowCompiler] pack result did not include .nupkg paths; recovered ${recovered.length} package(s) by scanning the output folder (UV-15007 workaround).`,
-            );
-            result.packages = recovered;
-        }
-        return result;
-    }
-
-    /**
-     * Recursively collect `.nupkg` files under `dir` (cross-platform). Returns an
-     * empty list if the folder cannot be read.
-     */
-    private async findNupkgFilesAsync(dir: string): Promise<string[]> {
-        const results: string[] = [];
-        let entries: string[];
-        try {
-            entries = await this.fileSystem.readdir(dir);
-        } catch {
-            return results;
-        }
-
-        for (const entry of entries) {
-            const fullPath = this.fileSystem.path.join(dir, entry);
-            const stats = await this.fileSystem.stat(fullPath);
-            if (stats?.isDirectory()) {
-                results.push(...(await this.findNupkgFilesAsync(fullPath)));
-            } else if (entry.toLowerCase().endsWith(".nupkg")) {
-                results.push(fullPath);
-            }
-        }
-        return results;
-    }
-}