@uipath/packager-tool-workflowcompiler 0.0.14

package/dist/output-entry.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Message type from workflow compiler output
+ */
+export declare enum OutputMessageType {
+    Log = "Log",
+    Progress = "Progress",
+    Result = "Result"
+}
+/**
+ * Base output message from workflow compiler
+ */
+export interface IOutputMessage {
+    type: OutputMessageType;
+    toolId?: string;
+    inputId?: string;
+}
+/**
+ * Log message from workflow compiler output
+ */
+export interface IOutputLog extends IOutputMessage {
+    type: OutputMessageType.Log;
+    message: string;
+    logLevel: "Information" | "Warning" | "Error";
+}
+/**
+ * Progress update from workflow compiler output
+ */
+export interface IOutputProgress extends IOutputMessage {
+    type: OutputMessageType.Progress;
+    percentage?: number;
+    message?: string;
+}
+/**
+ * Result from workflow compiler execution
+ */
+export interface IOutputResult extends IOutputMessage {
+    type: OutputMessageType.Result;
+    errorCode: string;
+    message?: string;
+    outputPackages: string[];
+    elapsed?: number;
+}

package/dist/workflow-compiler-config.d.ts

@@ -0,0 +1,23 @@
+export declare const DEFAULT_WORKFLOW_COMPILER_VERSION = "26.0.0-alpha.22366";
+export declare const workflowCompilerConfig: {
+    workflowCompilerPath: string | undefined;
+    workflowCompilerVersion: string;
+};
+/**
+ * Configure the workflow compiler tool.
+ *
+ * @param options.compilerPath - Explicit path to the compiler executable (skips all resolution logic).
+ * @param options.version - NuGet package version to download. Defaults to {@link DEFAULT_WORKFLOW_COMPILER_VERSION}.
+ *
+ * @example
+ * ```ts
+ * import { setupWorkflowCompiler } from "@uipath/packager-tool-workflowcompiler";
+ *
+ * setupWorkflowCompiler({ compilerPath: "/path/to/UiPath.WorkflowCompiler.exe" });
+ * setupWorkflowCompiler({ version: "26.0.0-alpha.22366" });
+ * ```
+ */
+export declare function setupWorkflowCompiler(options: {
+    compilerPath?: string;
+    version?: string;
+}): void;

package/dist/workflow-compiler-executor.d.ts

@@ -0,0 +1,30 @@
+import { type IFileSystem, type IToolLogger, ToolResult } from "@uipath/solutionpackager-tool-core";
+/**
+ * Executor for running workflow compiler commands as child processes.
+ * Handles process spawning, output parsing, and logging.
+ */
+export declare class WorkflowCompilerExecutor {
+    private readonly logger;
+    private static readonly DOTNET_EXECUTABLE;
+    private readonly pathResolver;
+    constructor(logger: IToolLogger, fileSystem: IFileSystem);
+    /**
+     * 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
+     */
+    executeAsync(operation: string, args: string[], cancellationToken?: AbortSignal): Promise<ToolResult>;
+    protected spawnProcess(command: string, args: string[]): import("node:child_process").ChildProcessByStdio<null, import("node:stream").Readable, import("node:stream").Readable>;
+    private logCommandStart;
+    private setupStdoutHandling;
+    private processOutputLine;
+    private logMessage;
+    private logProgress;
+    private setupStderrHandling;
+    private processErrorLine;
+    private setupProcessEventHandlers;
+    private setupCancellationHandler;
+    private parseOutputEntry;
+}

package/dist/workflow-compiler-path-resolver.d.ts

@@ -0,0 +1,30 @@
+import type { IFileSystem, IToolLogger } from "@uipath/solutionpackager-tool-core";
+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 declare class WorkflowCompilerPathResolver implements IWorkflowCompilerPathResolver {
+    private readonly logger;
+    private readonly fileSystem;
+    private static instance;
+    private cachedPath;
+    private pendingResolution;
+    private readonly tempStorage;
+    constructor(logger: IToolLogger, fileSystem: IFileSystem);
+    static getInstance(logger: IToolLogger, fileSystem: IFileSystem): IWorkflowCompilerPathResolver;
+    getCompilerPathAsync(): Promise<string>;
+    private resolveCompilerPath;
+    private findInEnvLocation;
+    private restoreAndResolve;
+    private getPlatformInfo;
+    private getNuGetCompilerPath;
+}

package/dist/workflow-compiler-tool-factory.d.ts

@@ -0,0 +1,9 @@
+import { type IFileSystem, type IProjectToolFactory, type IToolLogger, type ProjectTool, type ProjectType } from "@uipath/solutionpackager-tool-core";
+/**
+ * Factory for creating a workflow compiler tool.
+ * Handles Process, Library, WebApp, and Tests project types.
+ */
+export declare class WorkflowCompilerToolFactory implements IProjectToolFactory {
+    readonly supportedTypes: readonly ProjectType[];
+    createAsync(logger: IToolLogger, fileSystem: IFileSystem): Promise<ProjectTool>;
+}

package/dist/workflow-compiler-tool.d.ts

@@ -0,0 +1,17 @@
+import { type IFileSystem, type IProjectBuildOptions, type IProjectPackOptions, type IProjectRestoreOptions, type IProjectValidateOptions, type IToolLogger, ProjectTool, type ToolResult } from "@uipath/solutionpackager-tool-core";
+/**
+ * Workflow compiler tool implementation.
+ * Builds commands and delegates execution to WorkflowCompilerExecutor.
+ */
+export declare class WorkflowCompilerTool extends ProjectTool {
+    private readonly executor;
+    constructor(fileSystem: IFileSystem, logger: IToolLogger);
+    restoreAsync(options: IProjectRestoreOptions, cancellationToken?: AbortSignal): Promise<ToolResult>;
+    validateAsync(options: IProjectValidateOptions, cancellationToken?: AbortSignal): Promise<ToolResult>;
+    buildAsync(options: IProjectBuildOptions, cancellationToken?: AbortSignal): Promise<ToolResult>;
+    packAsync(options: IProjectPackOptions, cancellationToken?: AbortSignal): Promise<ToolResult>;
+    /**
+     * Maps output type for workflow compiler.
+     */
+    private mapOutputType;
+}

package/package.json

@@ -0,0 +1,54 @@
+{
+    "name": "@uipath/packager-tool-workflowcompiler",
+    "version": "0.0.14",
+    "description": "UiPath Workflow Compiler tool implementation",
+    "type": "module",
+    "exports": {
+        ".": {
+            "source": "./src/index.ts",
+            "default": "./dist/index.js"
+        }
+    },
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/UiPath/cli.git",
+        "directory": "packages/packager/packager-tool-workflowcompiler"
+    },
+    "publishConfig": {
+        "registry": "https://registry.npmjs.org/"
+    },
+    "types": "./dist/index.d.ts",
+    "scripts": {
+        "build": "bun build ./src/index.ts --outdir dist --format esm --target node --external @uipath/solutionpackager-tool-core && tsc --emitDeclarationOnly --outDir dist",
+        "dev": "bun build ./src/index.ts --outdir dist --format esm --target node --external @uipath/solutionpackager-tool-core --watch",
+        "test": "vitest run",
+        "test:coverage": "vitest run --coverage",
+        "test:all": "bun run test",
+        "test:all:coverage": "bun run test:coverage",
+        "prepack": "bun run build",
+        "publish:dry": "bun publish --dry-run",
+        "publish:gh": "bun publish",
+        "version:patch": "bun version patch --no-git-tag-version",
+        "version:minor": "bun version minor --no-git-tag-version",
+        "version:major": "bun version major --no-git-tag-version",
+        "lint": "biome check ."
+    },
+    "files": [
+        "dist",
+        "!dist/**/*.map",
+        "src"
+    ],
+    "author": "",
+    "license": "ISC",
+    "peerDependencies": {
+        "@uipath/solutionpackager-tool-core": "0.0.31"
+    },
+    "devDependencies": {
+        "@types/node": "^25.5.0",
+        "@uipath/solutionpackager-tool-core": "0.0.31",
+        "@vitest/coverage-v8": "^4.0.14",
+        "typescript": "^5.9.3",
+        "vitest": "^4.0.14"
+    },
+    "dependencies": {}
+}

package/src/i18n/index.ts

@@ -0,0 +1,45 @@
+/**
+ * i18n module for tool-workflowcompiler package.
+ * Registers tool-workflowcompiler-specific translations.
+ */
+
+import { I18nManager } from "@uipath/solutionpackager-tool-core";
+import de from "./locales/de.json" with { type: "json" };
+import { en } from "./locales/en.js";
+import es from "./locales/es.json" with { type: "json" };
+import esMX from "./locales/es-MX.json" with { type: "json" };
+import fr from "./locales/fr.json" with { type: "json" };
+import ja from "./locales/ja.json" with { type: "json" };
+import ko from "./locales/ko.json" with { type: "json" };
+import pt from "./locales/pt.json" with { type: "json" };
+import ptBR from "./locales/pt-BR.json" with { type: "json" };
+import ro from "./locales/ro.json" with { type: "json" };
+import ru from "./locales/ru.json" with { type: "json" };
+import tr from "./locales/tr.json" with { type: "json" };
+import zhCN from "./locales/zh-CN.json" with { type: "json" };
+import zhTW from "./locales/zh-TW.json" with { type: "json" };
+import zu from "./locales/zu.json" with { type: "json" };
+
+/**
+ * Register tool-workflowcompiler translations at module initialization.
+ * This extends the core translations with package-specific keys.
+ */
+I18nManager.registerTranslations("en", en);
+I18nManager.registerTranslations("de", de);
+I18nManager.registerTranslations("es", es);
+I18nManager.registerTranslations("es-MX", esMX);
+I18nManager.registerTranslations("fr", fr);
+I18nManager.registerTranslations("ja", ja);
+I18nManager.registerTranslations("ko", ko);
+I18nManager.registerTranslations("pt", pt);
+I18nManager.registerTranslations("pt-BR", ptBR);
+I18nManager.registerTranslations("ro", ro);
+I18nManager.registerTranslations("ru", ru);
+I18nManager.registerTranslations("tr", tr);
+I18nManager.registerTranslations("zh-CN", zhCN);
+I18nManager.registerTranslations("zh-TW", zhTW);
+I18nManager.registerTranslations("zu", zu);
+
+export type { TranslationKeys } from "./locales/en.js";
+// Export the translations for type inference
+export { en };

package/src/i18n/locales/de.json

@@ -0,0 +1,40 @@
+{
+    "toolWorkflowcompiler": {
+        "lifecycle": {
+            "started": "[WorkflowCompiler] {operation} started",
+            "command": "[WorkflowCompiler] Command: {command}",
+            "completed": "[WorkflowCompiler] {operation} completed in {elapsed}ms with code: {errorCode}",
+            "cancelled": "[WorkflowCompiler] Operation cancelled"
+        },
+        "errors": {
+            "processExited": "Process exited with code {exitCode}",
+            "failed": "[WorkflowCompiler] {operation} failed: {errorMessage}",
+            "processError": "[WorkflowCompiler] Process error: {message}",
+            "startFailed": "Failed to start workflow compiler: {message}",
+            "operationCancelled": "Operation cancelled"
+        },
+        "pathResolver": {
+            "info": {
+                "usingCached": "[PathResolver] Using cached compiler path: {path}",
+                "usingExplicitPath": "[PathResolver] Using explicit compiler path: {path}",
+                "resolving": "[PathResolver] Resolving workflow compiler path...",
+                "checkingEnvVar": "[PathResolver] Checking environment variable location: {path}",
+                "foundViaEnv": "[PathResolver] Found compiler via UIPATH_WORKFLOWCOMPILER_LOCATION",
+                "checkingNuGetCache": "[PathResolver] Checking NuGet cache: {path}",
+                "foundInNuGetCache": "[PathResolver] Found compiler in NuGet cache",
+                "notFoundStartingInstall": "[PathResolver] Compiler not found, starting dotnet restore...",
+                "restoringPackage": "[PathResolver] Restoring NuGet package \"{packageName}\" v{version} for platform \"{platform}\" via dotnet restore...",
+                "runningDotnetRestore": "[PathResolver] Running dotnet restore...",
+                "restoreCompleted": "[PathResolver] dotnet restore completed",
+                "installCompleted": "[PathResolver] Compiler restored successfully",
+                "cleaningUp": "[PathResolver] Cleaning up temp directory",
+                "resolved": "[PathResolver] Compiler resolved at: {path}"
+            },
+            "errors": {
+                "unsupportedPlatform": "Unsupported platform: {platform}",
+                "compilerNotFoundAfterRestore": "Compiler not found in NuGet cache after dotnet restore.",
+                "dotnetRestoreFailed": "dotnet restore failed: {details}"
+            }
+        }
+    }
+}

package/src/i18n/locales/en.ts

@@ -0,0 +1,60 @@
+/**
+ * English translations for tool-workflowcompiler package.
+ * These translations are registered alongside core translations via I18nManager.
+ */
+
+export const en = {
+    toolWorkflowcompiler: {
+        lifecycle: {
+            started: "[WorkflowCompiler] {operation} started",
+            command: "[WorkflowCompiler] Command: {command}",
+            completed:
+                "[WorkflowCompiler] {operation} completed in {elapsed}ms with code: {errorCode}",
+            cancelled: "[WorkflowCompiler] Operation cancelled",
+        },
+        errors: {
+            processExited: "Process exited with code {exitCode}",
+            failed: "[WorkflowCompiler] {operation} failed: {errorMessage}",
+            processError: "[WorkflowCompiler] Process error: {message}",
+            startFailed: "Failed to start workflow compiler: {message}",
+            operationCancelled: "Operation cancelled",
+        },
+        pathResolver: {
+            info: {
+                usingCached:
+                    "[PathResolver] Using cached compiler path: {path}",
+                usingExplicitPath:
+                    "[PathResolver] Using explicit compiler path: {path}",
+                resolving: "[PathResolver] Resolving workflow compiler path...",
+                checkingEnvVar:
+                    "[PathResolver] Checking environment variable location: {path}",
+                foundViaEnv:
+                    "[PathResolver] Found compiler via UIPATH_WORKFLOWCOMPILER_LOCATION",
+                checkingNuGetCache:
+                    "[PathResolver] Checking NuGet cache: {path}",
+                foundInNuGetCache:
+                    "[PathResolver] Found compiler in NuGet cache",
+                notFoundStartingInstall:
+                    "[PathResolver] Compiler not found, starting dotnet restore...",
+                restoringPackage:
+                    '[PathResolver] Restoring NuGet package "{packageName}" v{version} for platform "{platform}" via dotnet restore...',
+                runningDotnetRestore:
+                    "[PathResolver] Running dotnet restore...",
+                restoreCompleted: "[PathResolver] dotnet restore completed",
+                installCompleted:
+                    "[PathResolver] Compiler restored successfully",
+                cleaningUp: "[PathResolver] Cleaning up temp directory",
+                resolved: "[PathResolver] Compiler resolved at: {path}",
+            },
+            errors: {
+                unsupportedPlatform: "Unsupported platform: {platform}",
+                compilerNotFoundAfterRestore:
+                    "Compiler not found in NuGet cache after dotnet restore.",
+                dotnetRestoreFailed: "dotnet restore failed: {details}",
+            },
+        },
+    },
+} as const;
+
+/** @public */
+export type TranslationKeys = typeof en;

package/src/i18n/locales/es-MX.json

@@ -0,0 +1,40 @@
+{
+    "toolWorkflowcompiler": {
+        "lifecycle": {
+            "started": "[WorkflowCompiler] {operation} started",
+            "command": "[WorkflowCompiler] Command: {command}",
+            "completed": "[WorkflowCompiler] {operation} completed in {elapsed}ms with code: {errorCode}",
+            "cancelled": "[WorkflowCompiler] Operation cancelled"
+        },
+        "errors": {
+            "processExited": "Process exited with code {exitCode}",
+            "failed": "[WorkflowCompiler] {operation} failed: {errorMessage}",
+            "processError": "[WorkflowCompiler] Process error: {message}",
+            "startFailed": "Failed to start workflow compiler: {message}",
+            "operationCancelled": "Operation cancelled"
+        },
+        "pathResolver": {
+            "info": {
+                "usingCached": "[PathResolver] Using cached compiler path: {path}",
+                "usingExplicitPath": "[PathResolver] Using explicit compiler path: {path}",
+                "resolving": "[PathResolver] Resolving workflow compiler path...",
+                "checkingEnvVar": "[PathResolver] Checking environment variable location: {path}",
+                "foundViaEnv": "[PathResolver] Found compiler via UIPATH_WORKFLOWCOMPILER_LOCATION",
+                "checkingNuGetCache": "[PathResolver] Checking NuGet cache: {path}",
+                "foundInNuGetCache": "[PathResolver] Found compiler in NuGet cache",
+                "notFoundStartingInstall": "[PathResolver] Compiler not found, starting dotnet restore...",
+                "restoringPackage": "[PathResolver] Restoring NuGet package \"{packageName}\" v{version} for platform \"{platform}\" via dotnet restore...",
+                "runningDotnetRestore": "[PathResolver] Running dotnet restore...",
+                "restoreCompleted": "[PathResolver] dotnet restore completed",
+                "installCompleted": "[PathResolver] Compiler restored successfully",
+                "cleaningUp": "[PathResolver] Cleaning up temp directory",
+                "resolved": "[PathResolver] Compiler resolved at: {path}"
+            },
+            "errors": {
+                "unsupportedPlatform": "Unsupported platform: {platform}",
+                "compilerNotFoundAfterRestore": "Compiler not found in NuGet cache after dotnet restore.",
+                "dotnetRestoreFailed": "dotnet restore failed: {details}"
+            }
+        }
+    }
+}

package/src/i18n/locales/es.json

@@ -0,0 +1,40 @@
+{
+    "toolWorkflowcompiler": {
+        "lifecycle": {
+            "started": "[WorkflowCompiler] {operation} started",
+            "command": "[WorkflowCompiler] Command: {command}",
+            "completed": "[WorkflowCompiler] {operation} completed in {elapsed}ms with code: {errorCode}",
+            "cancelled": "[WorkflowCompiler] Operation cancelled"
+        },
+        "errors": {
+            "processExited": "Process exited with code {exitCode}",
+            "failed": "[WorkflowCompiler] {operation} failed: {errorMessage}",
+            "processError": "[WorkflowCompiler] Process error: {message}",
+            "startFailed": "Failed to start workflow compiler: {message}",
+            "operationCancelled": "Operation cancelled"
+        },
+        "pathResolver": {
+            "info": {
+                "usingCached": "[PathResolver] Using cached compiler path: {path}",
+                "usingExplicitPath": "[PathResolver] Using explicit compiler path: {path}",
+                "resolving": "[PathResolver] Resolving workflow compiler path...",
+                "checkingEnvVar": "[PathResolver] Checking environment variable location: {path}",
+                "foundViaEnv": "[PathResolver] Found compiler via UIPATH_WORKFLOWCOMPILER_LOCATION",
+                "checkingNuGetCache": "[PathResolver] Checking NuGet cache: {path}",
+                "foundInNuGetCache": "[PathResolver] Found compiler in NuGet cache",
+                "notFoundStartingInstall": "[PathResolver] Compiler not found, starting dotnet restore...",
+                "restoringPackage": "[PathResolver] Restoring NuGet package \"{packageName}\" v{version} for platform \"{platform}\" via dotnet restore...",
+                "runningDotnetRestore": "[PathResolver] Running dotnet restore...",
+                "restoreCompleted": "[PathResolver] dotnet restore completed",
+                "installCompleted": "[PathResolver] Compiler restored successfully",
+                "cleaningUp": "[PathResolver] Cleaning up temp directory",
+                "resolved": "[PathResolver] Compiler resolved at: {path}"
+            },
+            "errors": {
+                "unsupportedPlatform": "Unsupported platform: {platform}",
+                "compilerNotFoundAfterRestore": "Compiler not found in NuGet cache after dotnet restore.",
+                "dotnetRestoreFailed": "dotnet restore failed: {details}"
+            }
+        }
+    }
+}

package/src/i18n/locales/fr.json

@@ -0,0 +1,40 @@
+{
+    "toolWorkflowcompiler": {
+        "lifecycle": {
+            "started": "[WorkflowCompiler] {operation} started",
+            "command": "[WorkflowCompiler] Command: {command}",
+            "completed": "[WorkflowCompiler] {operation} completed in {elapsed}ms with code: {errorCode}",
+            "cancelled": "[WorkflowCompiler] Operation cancelled"
+        },
+        "errors": {
+            "processExited": "Process exited with code {exitCode}",
+            "failed": "[WorkflowCompiler] {operation} failed: {errorMessage}",
+            "processError": "[WorkflowCompiler] Process error: {message}",
+            "startFailed": "Failed to start workflow compiler: {message}",
+            "operationCancelled": "Operation cancelled"
+        },
+        "pathResolver": {
+            "info": {
+                "usingCached": "[PathResolver] Using cached compiler path: {path}",
+                "usingExplicitPath": "[PathResolver] Using explicit compiler path: {path}",
+                "resolving": "[PathResolver] Resolving workflow compiler path...",
+                "checkingEnvVar": "[PathResolver] Checking environment variable location: {path}",
+                "foundViaEnv": "[PathResolver] Found compiler via UIPATH_WORKFLOWCOMPILER_LOCATION",
+                "checkingNuGetCache": "[PathResolver] Checking NuGet cache: {path}",
+                "foundInNuGetCache": "[PathResolver] Found compiler in NuGet cache",
+                "notFoundStartingInstall": "[PathResolver] Compiler not found, starting dotnet restore...",
+                "restoringPackage": "[PathResolver] Restoring NuGet package \"{packageName}\" v{version} for platform \"{platform}\" via dotnet restore...",
+                "runningDotnetRestore": "[PathResolver] Running dotnet restore...",
+                "restoreCompleted": "[PathResolver] dotnet restore completed",
+                "installCompleted": "[PathResolver] Compiler restored successfully",
+                "cleaningUp": "[PathResolver] Cleaning up temp directory",
+                "resolved": "[PathResolver] Compiler resolved at: {path}"
+            },
+            "errors": {
+                "unsupportedPlatform": "Unsupported platform: {platform}",
+                "compilerNotFoundAfterRestore": "Compiler not found in NuGet cache after dotnet restore.",
+                "dotnetRestoreFailed": "dotnet restore failed: {details}"
+            }
+        }
+    }
+}

package/src/i18n/locales/ja.json

@@ -0,0 +1,40 @@
+{
+    "toolWorkflowcompiler": {
+        "lifecycle": {
+            "started": "[WorkflowCompiler] {operation} started",
+            "command": "[WorkflowCompiler] Command: {command}",
+            "completed": "[WorkflowCompiler] {operation} completed in {elapsed}ms with code: {errorCode}",
+            "cancelled": "[WorkflowCompiler] Operation cancelled"
+        },
+        "errors": {
+            "processExited": "Process exited with code {exitCode}",
+            "failed": "[WorkflowCompiler] {operation} failed: {errorMessage}",
+            "processError": "[WorkflowCompiler] Process error: {message}",
+            "startFailed": "Failed to start workflow compiler: {message}",
+            "operationCancelled": "Operation cancelled"
+        },
+        "pathResolver": {
+            "info": {
+                "usingCached": "[PathResolver] Using cached compiler path: {path}",
+                "usingExplicitPath": "[PathResolver] Using explicit compiler path: {path}",
+                "resolving": "[PathResolver] Resolving workflow compiler path...",
+                "checkingEnvVar": "[PathResolver] Checking environment variable location: {path}",
+                "foundViaEnv": "[PathResolver] Found compiler via UIPATH_WORKFLOWCOMPILER_LOCATION",
+                "checkingNuGetCache": "[PathResolver] Checking NuGet cache: {path}",
+                "foundInNuGetCache": "[PathResolver] Found compiler in NuGet cache",
+                "notFoundStartingInstall": "[PathResolver] Compiler not found, starting dotnet restore...",
+                "restoringPackage": "[PathResolver] Restoring NuGet package \"{packageName}\" v{version} for platform \"{platform}\" via dotnet restore...",
+                "runningDotnetRestore": "[PathResolver] Running dotnet restore...",
+                "restoreCompleted": "[PathResolver] dotnet restore completed",
+                "installCompleted": "[PathResolver] Compiler restored successfully",
+                "cleaningUp": "[PathResolver] Cleaning up temp directory",
+                "resolved": "[PathResolver] Compiler resolved at: {path}"
+            },
+            "errors": {
+                "unsupportedPlatform": "Unsupported platform: {platform}",
+                "compilerNotFoundAfterRestore": "Compiler not found in NuGet cache after dotnet restore.",
+                "dotnetRestoreFailed": "dotnet restore failed: {details}"
+            }
+        }
+    }
+}

package/src/i18n/locales/ko.json

@@ -0,0 +1,40 @@
+{
+    "toolWorkflowcompiler": {
+        "lifecycle": {
+            "started": "[WorkflowCompiler] {operation} started",
+            "command": "[WorkflowCompiler] Command: {command}",
+            "completed": "[WorkflowCompiler] {operation} completed in {elapsed}ms with code: {errorCode}",
+            "cancelled": "[WorkflowCompiler] Operation cancelled"
+        },
+        "errors": {
+            "processExited": "Process exited with code {exitCode}",
+            "failed": "[WorkflowCompiler] {operation} failed: {errorMessage}",
+            "processError": "[WorkflowCompiler] Process error: {message}",
+            "startFailed": "Failed to start workflow compiler: {message}",
+            "operationCancelled": "Operation cancelled"
+        },
+        "pathResolver": {
+            "info": {
+                "usingCached": "[PathResolver] Using cached compiler path: {path}",
+                "usingExplicitPath": "[PathResolver] Using explicit compiler path: {path}",
+                "resolving": "[PathResolver] Resolving workflow compiler path...",
+                "checkingEnvVar": "[PathResolver] Checking environment variable location: {path}",
+                "foundViaEnv": "[PathResolver] Found compiler via UIPATH_WORKFLOWCOMPILER_LOCATION",
+                "checkingNuGetCache": "[PathResolver] Checking NuGet cache: {path}",
+                "foundInNuGetCache": "[PathResolver] Found compiler in NuGet cache",
+                "notFoundStartingInstall": "[PathResolver] Compiler not found, starting dotnet restore...",
+                "restoringPackage": "[PathResolver] Restoring NuGet package \"{packageName}\" v{version} for platform \"{platform}\" via dotnet restore...",
+                "runningDotnetRestore": "[PathResolver] Running dotnet restore...",
+                "restoreCompleted": "[PathResolver] dotnet restore completed",
+                "installCompleted": "[PathResolver] Compiler restored successfully",
+                "cleaningUp": "[PathResolver] Cleaning up temp directory",
+                "resolved": "[PathResolver] Compiler resolved at: {path}"
+            },
+            "errors": {
+                "unsupportedPlatform": "Unsupported platform: {platform}",
+                "compilerNotFoundAfterRestore": "Compiler not found in NuGet cache after dotnet restore.",
+                "dotnetRestoreFailed": "dotnet restore failed: {details}"
+            }
+        }
+    }
+}

package/src/i18n/locales/pt-BR.json

@@ -0,0 +1,40 @@
+{
+    "toolWorkflowcompiler": {
+        "lifecycle": {
+            "started": "[WorkflowCompiler] {operation} started",
+            "command": "[WorkflowCompiler] Command: {command}",
+            "completed": "[WorkflowCompiler] {operation} completed in {elapsed}ms with code: {errorCode}",
+            "cancelled": "[WorkflowCompiler] Operation cancelled"
+        },
+        "errors": {
+            "processExited": "Process exited with code {exitCode}",
+            "failed": "[WorkflowCompiler] {operation} failed: {errorMessage}",
+            "processError": "[WorkflowCompiler] Process error: {message}",
+            "startFailed": "Failed to start workflow compiler: {message}",
+            "operationCancelled": "Operation cancelled"
+        },
+        "pathResolver": {
+            "info": {
+                "usingCached": "[PathResolver] Using cached compiler path: {path}",
+                "usingExplicitPath": "[PathResolver] Using explicit compiler path: {path}",
+                "resolving": "[PathResolver] Resolving workflow compiler path...",
+                "checkingEnvVar": "[PathResolver] Checking environment variable location: {path}",
+                "foundViaEnv": "[PathResolver] Found compiler via UIPATH_WORKFLOWCOMPILER_LOCATION",
+                "checkingNuGetCache": "[PathResolver] Checking NuGet cache: {path}",
+                "foundInNuGetCache": "[PathResolver] Found compiler in NuGet cache",
+                "notFoundStartingInstall": "[PathResolver] Compiler not found, starting dotnet restore...",
+                "restoringPackage": "[PathResolver] Restoring NuGet package \"{packageName}\" v{version} for platform \"{platform}\" via dotnet restore...",
+                "runningDotnetRestore": "[PathResolver] Running dotnet restore...",
+                "restoreCompleted": "[PathResolver] dotnet restore completed",
+                "installCompleted": "[PathResolver] Compiler restored successfully",
+                "cleaningUp": "[PathResolver] Cleaning up temp directory",
+                "resolved": "[PathResolver] Compiler resolved at: {path}"
+            },
+            "errors": {
+                "unsupportedPlatform": "Unsupported platform: {platform}",
+                "compilerNotFoundAfterRestore": "Compiler not found in NuGet cache after dotnet restore.",
+                "dotnetRestoreFailed": "dotnet restore failed: {details}"
+            }
+        }
+    }
+}