@uipath/rpa-tool 0.1.4 → 0.1.8

package/dist/packager-tool.js

@@ -0,0 +1,646 @@
+// node_modules/@uipath/tool-workflowcompiler/dist/index.js
+import { I18nManager, LogLevel, ProjectTool, ProjectTypes, TemporaryStorageService, ToolErrorCodes, ToolResult, toolsFactoryRepository, translate } from "@uipath/solutionpackager-tool-core";
+import { execFileSync, spawn } from "child_process";
+import { homedir, platform } from "os";
+import { join } from "path";
+var de_namespaceObject = JSON.parse('{"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}"}}}}');
+var 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}"
+      }
+    }
+  }
+};
+var es_namespaceObject = JSON.parse('{"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}"}}}}');
+var es_MX_namespaceObject = JSON.parse('{"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}"}}}}');
+var fr_namespaceObject = JSON.parse('{"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}"}}}}');
+var ja_namespaceObject = JSON.parse('{"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}"}}}}');
+var ko_namespaceObject = JSON.parse('{"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}"}}}}');
+var pt_namespaceObject = JSON.parse('{"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}"}}}}');
+var pt_BR_namespaceObject = JSON.parse('{"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}"}}}}');
+var ro_namespaceObject = JSON.parse('{"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}"}}}}');
+var ru_namespaceObject = JSON.parse('{"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}"}}}}');
+var tr_namespaceObject = JSON.parse('{"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}"}}}}');
+var zh_CN_namespaceObject = JSON.parse('{"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}"}}}}');
+var zh_TW_namespaceObject = JSON.parse('{"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}"}}}}');
+var zu_namespaceObject = JSON.parse('{"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}"}}}}');
+I18nManager.registerTranslations("en", en);
+I18nManager.registerTranslations("de", de_namespaceObject);
+I18nManager.registerTranslations("es", es_namespaceObject);
+I18nManager.registerTranslations("es-MX", es_MX_namespaceObject);
+I18nManager.registerTranslations("fr", fr_namespaceObject);
+I18nManager.registerTranslations("ja", ja_namespaceObject);
+I18nManager.registerTranslations("ko", ko_namespaceObject);
+I18nManager.registerTranslations("pt", pt_namespaceObject);
+I18nManager.registerTranslations("pt-BR", pt_BR_namespaceObject);
+I18nManager.registerTranslations("ro", ro_namespaceObject);
+I18nManager.registerTranslations("ru", ru_namespaceObject);
+I18nManager.registerTranslations("tr", tr_namespaceObject);
+I18nManager.registerTranslations("zh-CN", zh_CN_namespaceObject);
+I18nManager.registerTranslations("zh-TW", zh_TW_namespaceObject);
+I18nManager.registerTranslations("zu", zu_namespaceObject);
+var DEFAULT_WORKFLOW_COMPILER_VERSION = "26.0.0-alpha.22366";
+var workflowCompilerConfig = {
+  workflowCompilerPath: undefined,
+  workflowCompilerVersion: DEFAULT_WORKFLOW_COMPILER_VERSION
+};
+function _define_property(obj, key, value) {
+  if (key in obj)
+    Object.defineProperty(obj, key, {
+      value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  else
+    obj[key] = value;
+  return obj;
+}
+var NUGET_FEED_URL = "https://uipath.pkgs.visualstudio.com/Public.Feeds/_packaging/UiPath-Internal/nuget/v3/index.json";
+var PLATFORM_PACKAGES = {
+  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"
+  }
+};
+var RESTORE_CSPROJ_TEMPLATE = `<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>net8.0</TargetFramework>
+  </PropertyGroup>
+  <ItemGroup>
+    <PackageReference Include="{packageId}" Version="{version}" />
+  </ItemGroup>
+</Project>`;
+var EMPTY_NUGET_CONFIG = `<?xml version="1.0" encoding="utf-8"?>
+<configuration>
+</configuration>`;
+
+class WorkflowCompilerPathResolver {
+  static getInstance(logger, fileSystem) {
+    if (!WorkflowCompilerPathResolver.instance)
+      WorkflowCompilerPathResolver.instance = new WorkflowCompilerPathResolver(logger, fileSystem);
+    return WorkflowCompilerPathResolver.instance;
+  }
+  async getCompilerPathAsync() {
+    if (this.cachedPath) {
+      this.logger.info(translate.t("toolWorkflowcompiler.pathResolver.info.usingCached", {
+        path: this.cachedPath
+      }));
+      return this.cachedPath;
+    }
+    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;
+  }
+  async resolveCompilerPath() {
+    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);
+  }
+  async findInEnvLocation() {
+    const location = process.env.UIPATH_WORKFLOWCOMPILER_LOCATION;
+    if (!location)
+      return null;
+    this.logger.info(translate.t("toolWorkflowcompiler.pathResolver.info.checkingEnvVar", {
+      path: location
+    }));
+    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;
+  }
+  async restoreAndResolve(compilerPath, version) {
+    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(join(tempDir, "restore.csproj"), csproj);
+      await this.fileSystem.writeFile(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) {
+        const err = error;
+        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();
+    }
+  }
+  getPlatformInfo() {
+    const info = PLATFORM_PACKAGES[platform()];
+    if (!info)
+      throw new Error(translate.t("toolWorkflowcompiler.pathResolver.errors.unsupportedPlatform", {
+        platform: platform()
+      }));
+    return info;
+  }
+  getNuGetCompilerPath(version) {
+    const cacheRoot = process.env.NUGET_PACKAGES ?? join(homedir(), ".nuget", "packages");
+    const { packageId, compilerFileName } = this.getPlatformInfo();
+    return join(cacheRoot, packageId.toLowerCase(), version.toLowerCase(), "WorkflowCompiler", compilerFileName);
+  }
+  constructor(logger, fileSystem) {
+    _define_property(this, "logger", undefined);
+    _define_property(this, "fileSystem", undefined);
+    _define_property(this, "cachedPath", undefined);
+    _define_property(this, "pendingResolution", undefined);
+    _define_property(this, "tempStorage", undefined);
+    this.logger = logger;
+    this.fileSystem = fileSystem;
+    this.cachedPath = null;
+    this.pendingResolution = null;
+    this.tempStorage = new TemporaryStorageService(fileSystem);
+  }
+}
+_define_property(WorkflowCompilerPathResolver, "instance", null);
+function workflow_compiler_executor_define_property(obj, key, value) {
+  if (key in obj)
+    Object.defineProperty(obj, key, {
+      value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  else
+    obj[key] = value;
+  return obj;
+}
+function camelCaseKeys(obj) {
+  if (Array.isArray(obj))
+    return obj.map(camelCaseKeys);
+  if (obj !== null && typeof obj == "object") {
+    const result = {};
+    for (const [key, value] of Object.entries(obj))
+      result[key.charAt(0).toLowerCase() + key.slice(1)] = camelCaseKeys(value);
+    return result;
+  }
+  return obj;
+}
+
+class WorkflowCompilerExecutor {
+  async executeAsync(operation, args, cancellationToken) {
+    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 = null;
+      const fallbackErrors = [];
+      const childProcess = this.spawnProcess(executable, commandArgs);
+      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(`
+`) || 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);
+    });
+  }
+  spawnProcess(command, args) {
+    return spawn(command, args, {
+      stdio: [
+        "ignore",
+        "pipe",
+        "pipe"
+      ],
+      shell: false,
+      windowsHide: true
+    });
+  }
+  logCommandStart(operation, executable, commandArgs) {
+    const fullCommand = [
+      executable,
+      ...commandArgs
+    ];
+    this.logger.info(translate.t("toolWorkflowcompiler.lifecycle.started", {
+      operation
+    }));
+    this.logger.info(translate.t("toolWorkflowcompiler.lifecycle.command", {
+      command: fullCommand.join(" ")
+    }));
+  }
+  setupStdoutHandling(childProcess, streamCompletion, onResult) {
+    if (!childProcess.stdout)
+      return void streamCompletion.markStdoutEnded();
+    let buffer = "";
+    childProcess.stdout.on("data", (data) => {
+      buffer += data.toString();
+      const lines = buffer.split(`
+`);
+      buffer = lines.pop();
+      for (const line of lines)
+        if (line.trim())
+          this.processOutputLine(line, onResult);
+    });
+    childProcess.stdout.on("end", () => {
+      if (buffer.trim())
+        this.processOutputLine(buffer, onResult);
+      streamCompletion.markStdoutEnded();
+    });
+  }
+  processOutputLine(line, onResult) {
+    const entry = this.parseOutputEntry(line);
+    if (!entry)
+      return;
+    if (entry.type === "Result")
+      onResult(entry);
+    else if (entry.type === "Log")
+      this.logMessage(entry);
+    else if (entry.type === "Progress")
+      this.logProgress(entry);
+  }
+  logMessage(log) {
+    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;
+    }
+  }
+  logProgress(progress) {
+    const percent = progress.percentage ? `${progress.percentage}%` : "";
+    const separator = percent && progress.message ? " - " : "";
+    this.logger.progress(`${percent}${separator}${progress.message ?? ""}`);
+  }
+  setupStderrHandling(childProcess, streamCompletion, fallbackErrors) {
+    if (!childProcess.stderr)
+      return void streamCompletion.markStderrEnded();
+    let buffer = "";
+    childProcess.stderr.on("data", (data) => {
+      buffer += data.toString();
+      const lines = buffer.split(`
+`);
+      buffer = lines.pop();
+      for (const line of lines)
+        if (line.trim())
+          this.processErrorLine(line, fallbackErrors);
+    });
+    childProcess.stderr.on("end", () => {
+      if (buffer.trim())
+        this.processErrorLine(buffer, fallbackErrors);
+      streamCompletion.markStderrEnded();
+    });
+  }
+  processErrorLine(line, fallbackErrors) {
+    const entry = this.parseOutputEntry(line);
+    if (entry && entry.type === "Log")
+      this.logger.error(entry.message);
+    else {
+      fallbackErrors.push(line);
+      this.logger.error(line);
+    }
+  }
+  setupProcessEventHandlers(childProcess, streamCompletion, resolve) {
+    childProcess.on("exit", () => streamCompletion.markProcessExited());
+    childProcess.on("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
+      }), []));
+    });
+  }
+  setupCancellationHandler(childProcess, cancellationToken, resolve) {
+    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"), []));
+    });
+  }
+  parseOutputEntry(line) {
+    try {
+      const parsed = JSON.parse(line);
+      const camelCased = camelCaseKeys(parsed);
+      if (camelCased.errorCode !== undefined)
+        if (camelCased.errorCode === 0 || camelCased.success === true)
+          camelCased.errorCode = ToolErrorCodes.Success;
+        else
+          camelCased.errorCode = String(camelCased.errorCode);
+      if (camelCased.outputPackages)
+        camelCased.outputPackages = camelCased.outputPackages.map((pkg) => pkg.path || pkg);
+      return camelCased;
+    } catch {
+      return null;
+    }
+  }
+  constructor(logger, fileSystem) {
+    workflow_compiler_executor_define_property(this, "logger", undefined);
+    workflow_compiler_executor_define_property(this, "pathResolver", undefined);
+    this.logger = logger;
+    this.pathResolver = WorkflowCompilerPathResolver.getInstance(logger, fileSystem);
+  }
+}
+workflow_compiler_executor_define_property(WorkflowCompilerExecutor, "DOTNET_EXECUTABLE", "dotnet");
+function workflow_compiler_tool_define_property(obj, key, value) {
+  if (key in obj)
+    Object.defineProperty(obj, key, {
+      value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  else
+    obj[key] = value;
+  return obj;
+}
+
+class WorkflowCompilerTool extends ProjectTool {
+  async restoreAsync(options, cancellationToken) {
+    const args = [
+      "-p",
+      options.projectPath,
+      "--log-level",
+      String(options.logLevel ?? LogLevel.Info),
+      "--destination",
+      options.outputPath ?? "",
+      "--format-logs",
+      "true",
+      "--exclude-configured-sources",
+      `${options.excludeConfiguredSources}`
+    ];
+    if (options.nuGetSourcesConfigPath)
+      args.push("--nuget-config-file", options.nuGetSourcesConfigPath);
+    return this.executor.executeAsync("restore", args, cancellationToken);
+  }
+  async validateAsync(options, cancellationToken) {
+    const args = [
+      "-p",
+      options.projectPath,
+      "--log-level",
+      String(options.logLevel ?? LogLevel.Info),
+      "--format-logs",
+      "true",
+      "--skip-analyze",
+      `${options.skipAnalyze}`,
+      "--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 (options.nuGetSourcesConfigPath)
+      args.push("--nuget-config-file", options.nuGetSourcesConfigPath);
+    return this.executor.executeAsync("validate", args, cancellationToken);
+  }
+  async buildAsync(options, cancellationToken) {
+    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 (options.nuGetSourcesConfigPath)
+      args.push("--nuget-config-file", options.nuGetSourcesConfigPath);
+    return this.executor.executeAsync("build", args, cancellationToken);
+  }
+  async packAsync(options, cancellationToken) {
+    const args = [
+      "-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 (options.nuGetSourcesConfigPath)
+      args.push("--nuget-config-file", options.nuGetSourcesConfigPath);
+    return this.executor.executeAsync("build", args, cancellationToken);
+  }
+  mapOutputType(outputType) {
+    return outputType === "WebApp" ? "Process" : outputType;
+  }
+  constructor(fileSystem, logger) {
+    super(fileSystem, logger), workflow_compiler_tool_define_property(this, "executor", undefined);
+    this.executor = new WorkflowCompilerExecutor(logger, fileSystem);
+  }
+}
+function workflow_compiler_tool_factory_define_property(obj, key, value) {
+  if (key in obj)
+    Object.defineProperty(obj, key, {
+      value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  else
+    obj[key] = value;
+  return obj;
+}
+
+class WorkflowCompilerToolFactory {
+  async createAsync(logger, fileSystem) {
+    return new WorkflowCompilerTool(fileSystem, logger);
+  }
+  constructor() {
+    workflow_compiler_tool_factory_define_property(this, "supportedTypes", [
+      ProjectTypes.Process,
+      ProjectTypes.Library,
+      ProjectTypes.Tests,
+      ProjectTypes.WebApp
+    ]);
+  }
+}
+toolsFactoryRepository.registerProjectToolFactory(new WorkflowCompilerToolFactory);