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

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

@@ -1,302 +0,0 @@
-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://pkgs.uipath.com/internal/index.json";
-
-const WORKFLOW_COMPILER_DLL_NAME = "UiPath.WorkflowCompiler.dll";
-
-const PLATFORM_PACKAGE_IDS: Record<string, string> = {
-    win32: "UiPath.WorkflowCompiler.Windows",
-    darwin: "UiPath.WorkflowCompiler.macOS",
-    linux: "UiPath.WorkflowCompiler.Linux",
-};
-
-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 DLL path. The executor always
- * launches `dotnet <dll>`, so the resolved path must point at a managed
- * assembly (UiPath.WorkflowCompiler.dll) on every platform.
- *
- * Resolution chain:
- * 1. In-memory cache (subsequent calls)
- * 2. Explicit config path (`workflowCompilerConfig.workflowCompilerPath`)
- * 3. `UIPATH_WORKFLOWCOMPILER_LOCATION` env var — full path to .dll (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;
-        }
-
-        // In-process coalescing only: dedupes concurrent callers within this
-        // Node process. Parallel `uip` invocations each run their own restore;
-        // NuGet's own per-package lock handles cross-process coordination of
-        // the cache.
-        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 UiPath.WorkflowCompiler.dll. The executor
-        // always launches via `dotnet <dll>`; .exe apphost paths are not
-        // accepted because they cannot be loaded as managed assemblies.
-        if (
-            location.endsWith(".dll") &&
-            (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.getPackageId();
-        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 getPackageId(): string {
-        const packageId = PLATFORM_PACKAGE_IDS[platform()];
-        if (!packageId) {
-            throw new Error(
-                translate.t(
-                    "toolWorkflowcompiler.pathResolver.errors.unsupportedPlatform",
-                    { platform: platform() },
-                ),
-            );
-        }
-        return packageId;
-    }
-
-    private getNuGetCompilerPath(version: string): string {
-        const cacheRoot =
-            process.env.NUGET_PACKAGES ??
-            Path.join(homedir(), ".nuget", "packages");
-        return Path.join(
-            cacheRoot,
-            this.getPackageId().toLowerCase(),
-            version.toLowerCase(),
-            "WorkflowCompiler",
-            WORKFLOW_COMPILER_DLL_NAME,
-        );
-    }
-}

package/src/workflow-compiler-tool-factory.ts

@@ -1,82 +0,0 @@
-import { execSync } from "node:child_process";
-import {
-    type IFileSystem,
-    type IProjectToolFactory,
-    type IToolLogger,
-    type ProjectOperationContext,
-    type ProjectTool,
-    type ProjectType,
-    ProjectTypes,
-    translate,
-} from "@uipath/solutionpackager-tool-core";
-import {
-    DEFAULT_DOTNET_PATH,
-    workflowCompilerConfig,
-} from "./workflow-compiler-config.js";
-import { WorkflowCompilerTool } from "./workflow-compiler-tool.js";
-
-/**
- * Factory for creating a workflow compiler tool.
- * Handles Process, Library, WebApp, and Tests project types.
- */
-export class WorkflowCompilerToolFactory implements IProjectToolFactory {
-    /**
-     * Process-lifetime cache of a successful `dotnet --version` lookup.
-     * Negative results are not cached so a one-off failure does not pin
-     * the factory across the rest of the process.
-     */
-    private static cachedDotnetAvailable: boolean | undefined;
-
-    readonly supportedTypes: readonly ProjectType[] = [
-        ProjectTypes.Process,
-        ProjectTypes.Library,
-        ProjectTypes.Tests,
-        ProjectTypes.WebApp,
-    ];
-
-    async createAsync(
-        logger: IToolLogger,
-        fileSystem: IFileSystem,
-        context?: ProjectOperationContext,
-    ): Promise<ProjectTool> {
-        if (!this.isPinnedByCaller() && !this.isDotnetAvailable()) {
-            throw new Error(
-                translate.t("toolWorkflowcompiler.errors.dotnetNotAvailable"),
-            );
-        }
-        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;
-        }
-        try {
-            execSync("dotnet --version", {
-                stdio: ["ignore", "pipe", "ignore"],
-            });
-            WorkflowCompilerToolFactory.cachedDotnetAvailable = true;
-            return true;
-        } catch {
-            return false;
-        }
-    }
-}