@uipath/packager-tool-workflowcompiler 1.197.0-preview.63 → 1.197.0-preview.65

package/dist/index.js

@@ -653,9 +653,307 @@ I18nManager.registerTranslations("zu", zu_default);
 import { execSync } from "node:child_process";
 import {
   ProjectTypes,
-  translate as translate3
+  translate as translate6
 } from "@uipath/solutionpackager-tool-core";
 
+// ../packager-orchestrator-client/dist/index.js
+import { I18nManager as I18nManager2 } from "@uipath/solutionpackager-tool-core";
+import {
+  Path,
+  TemporaryStorageService,
+  translate as translate2
+} from "@uipath/solutionpackager-tool-core";
+import {
+  translate
+} from "@uipath/solutionpackager-tool-core";
+var en2 = {
+  packagerOrchestratorClient: {
+    feeds: {
+      errors: {
+        orchestratorUrlRequired: "Orchestrator URL is required.",
+        getAccessibleFeedsFailed: "GetAccessibleFeeds failed: {status} {statusText}{body}"
+      },
+      warnings: {
+        tenantFeedsUnavailable: "Could not retrieve Orchestrator tenant feeds. Packaging will continue, but it may fail if a project references a library published to a tenant feed."
+      }
+    }
+  }
+};
+I18nManager2.registerTranslations("en", en2);
+function isPromiseLike(value) {
+  return value !== null && typeof value === "object" && typeof value.then === "function";
+}
+function catchError(fnOrPromise) {
+  if (isPromiseLike(fnOrPromise)) {
+    return settlePromiseLike(fnOrPromise);
+  }
+  try {
+    const result = fnOrPromise();
+    if (isPromiseLike(result)) {
+      return settlePromiseLike(result);
+    }
+    return [undefined, result];
+  } catch (error) {
+    return [
+      error instanceof Error ? error : new Error(String(error)),
+      undefined
+    ];
+  }
+}
+function settlePromiseLike(thenable) {
+  return Promise.resolve(thenable).then((data) => [undefined, data]).catch((error) => [
+    error instanceof Error ? error : new Error(String(error)),
+    undefined
+  ]);
+}
+var PREFIX = "@uipath/common/";
+var _g = globalThis;
+function singleton(ctorOrName) {
+  const name = typeof ctorOrName === "string" ? ctorOrName : ctorOrName.name;
+  const key = Symbol.for(PREFIX + name);
+  return {
+    get(fallback) {
+      return _g[key] ?? fallback;
+    },
+    set(value) {
+      _g[key] = value;
+    },
+    clear() {
+      delete _g[key];
+    },
+    getOrInit(factory, guard) {
+      const existing = _g[key];
+      if (existing != null && typeof existing === "object") {
+        if (!guard || guard(existing)) {
+          return existing;
+        }
+      }
+      const instance = factory();
+      _g[key] = instance;
+      return instance;
+    }
+  };
+}
+var telemetryPropsSlot = singleton("TelemetryDefaultProps");
+var USER_AGENT_HEADER = "User-Agent";
+var sdkUserAgentHostToken = singleton("SdkUserAgentHostToken");
+function splitUserAgentTokens(value) {
+  return value?.trim().split(/\s+/).filter(Boolean) ?? [];
+}
+function appendUserAgentToken(value, userAgent) {
+  const tokens = splitUserAgentTokens(value);
+  const seen = new Set(tokens);
+  for (const token of splitUserAgentTokens(userAgent)) {
+    if (!seen.has(token)) {
+      tokens.push(token);
+      seen.add(token);
+    }
+  }
+  return tokens.join(" ");
+}
+function getEffectiveUserAgent(userAgent) {
+  return appendUserAgentToken(sdkUserAgentHostToken.get(), userAgent);
+}
+function getHeaderName(headers, headerName) {
+  return Object.keys(headers).find((key) => key.toLowerCase() === headerName.toLowerCase());
+}
+function addSdkUserAgentHeader(headers, userAgent) {
+  const result = { ...headers ?? {} };
+  const headerName = getHeaderName(result, USER_AGENT_HEADER);
+  result[headerName ?? USER_AGENT_HEADER] = appendUserAgentToken(headerName ? result[headerName] : undefined, getEffectiveUserAgent(userAgent));
+  return result;
+}
+var package_default = {
+  name: "@uipath/packager-orchestrator-client",
+  version: "1.198.0",
+  description: "UiPath packager client for Orchestrator package-feed interaction (feed discovery + NuGet source composition)",
+  type: "module",
+  private: true,
+  exports: {
+    ".": {
+      source: "./src/index.ts",
+      default: "./dist/index.js"
+    }
+  },
+  types: "./dist/index.d.ts",
+  scripts: {
+    build: "bun build ./src/index.ts --outdir dist --format esm --target node --external @uipath/solutionpackager-tool-core --sourcemap=linked && 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",
+    lint: "biome check ."
+  },
+  files: [
+    "dist",
+    "src"
+  ],
+  author: "",
+  license: "ISC",
+  repository: {
+    type: "git",
+    url: "https://github.com/UiPath/cli.git",
+    directory: "packages/packager/packager-orchestrator-client"
+  },
+  peerDependencies: {
+    "@uipath/solutionpackager-tool-core": "workspace:*"
+  },
+  devDependencies: {
+    "@types/node": "^25.5.2",
+    "@uipath/common": "workspace:*",
+    "@uipath/solutionpackager-tool-core": "workspace:*",
+    "@vitest/coverage-v8": "^4.1.6",
+    typescript: "^6.0.2",
+    vitest: "^4.1.6"
+  }
+};
+var FEEDS_PATH = "/api/PackageFeeds/GetFeeds?onlyPublishable=false";
+var HEADER_TENANT_ID = "X-UIPATH-TenantId";
+var FEEDS_TIMEOUT_MS = 30000;
+var SDK_USER_AGENT = `${package_default.name.replace(/^@uipath\//, "")}/${package_default.version}`;
+
+class OrchestratorFeedsService {
+  logger;
+  constructor(logger) {
+    this.logger = logger;
+  }
+  async getAccessibleFeedsAsync(connection) {
+    const { orchestratorUrl, accessToken, tenantId } = connection;
+    if (!orchestratorUrl) {
+      throw new Error(translate.t("packagerOrchestratorClient.feeds.errors.orchestratorUrlRequired"));
+    }
+    this.logger.info(`Fetching accessible feeds from ${orchestratorUrl}`);
+    const headers = {};
+    if (accessToken) {
+      headers.Authorization = `Bearer ${accessToken}`;
+    }
+    if (tenantId) {
+      headers[HEADER_TENANT_ID] = tenantId;
+    }
+    const response = await fetch(feedsEndpoint(orchestratorUrl), {
+      method: "GET",
+      headers: addSdkUserAgentHeader(headers, SDK_USER_AGENT),
+      signal: AbortSignal.timeout(FEEDS_TIMEOUT_MS)
+    });
+    if (!response.ok) {
+      throw new Error(translate.t("packagerOrchestratorClient.feeds.errors.getAccessibleFeedsFailed", await describeFailure(response)));
+    }
+    const text = await response.text();
+    const feeds = text === "" || text === "null" ? null : JSON.parse(text);
+    return Array.isArray(feeds) ? feeds : [];
+  }
+}
+function feedsEndpoint(orchestratorUrl) {
+  let end = orchestratorUrl.length;
+  while (end > 0 && orchestratorUrl.charAt(end - 1) === "/") {
+    end--;
+  }
+  const trimmed = orchestratorUrl.slice(0, end);
+  if (/\/orchestrator_$/i.test(trimmed)) {
+    return `${trimmed}${FEEDS_PATH}`;
+  }
+  return hasPathSegments(trimmed) ? `${trimmed}/orchestrator_${FEEDS_PATH}` : `${trimmed}${FEEDS_PATH}`;
+}
+function hasPathSegments(url) {
+  const [error, parsed] = catchError(() => new URL(url));
+  if (error) {
+    return true;
+  }
+  return parsed.pathname !== "/" && parsed.pathname !== "";
+}
+async function describeFailure(response) {
+  const text = await response.text().catch(() => "");
+  return {
+    status: response.status,
+    statusText: response.statusText,
+    body: text ? ` - ${text.slice(0, 500)}` : ""
+  };
+}
+var feedsByTenant = new Map;
+function tenantKey(connection) {
+  return JSON.stringify([
+    connection.orchestratorUrl,
+    connection.tenantId ?? ""
+  ]);
+}
+function getAccessibleFeedsOnce(connection, fetchFeeds) {
+  const key = tenantKey(connection);
+  const inFlight = feedsByTenant.get(key);
+  if (inFlight) {
+    return inFlight;
+  }
+  const request = fetchFeeds();
+  feedsByTenant.set(key, request);
+  request.catch(() => {
+    if (feedsByTenant.get(key) === request) {
+      feedsByTenant.delete(key);
+    }
+  });
+  return request;
+}
+var FEEDS_FILE_NAME = "nuget-feeds.json";
+var LIBRARIES_PURPOSE = "Libraries";
+var NO_FEEDS = { dispose: async () => {} };
+
+class OrchestratorFeedComposer {
+  fileSystem;
+  logger;
+  feedsService;
+  constructor(fileSystem, logger, feedsService) {
+    this.fileSystem = fileSystem;
+    this.logger = logger;
+    this.feedsService = feedsService ?? new OrchestratorFeedsService(logger);
+  }
+  async composeAsync({
+    connection
+  }) {
+    const feeds = await this.resolveTenantFeeds(connection);
+    if (feeds.length === 0) {
+      return NO_FEEDS;
+    }
+    const [error, composed] = await catchError(this.writeFeedsFile(feeds));
+    if (error || !composed) {
+      this.warnFeedsUnavailable();
+      return NO_FEEDS;
+    }
+    return composed;
+  }
+  async resolveTenantFeeds(connection) {
+    if (!connection?.accessToken || !connection.cloudUrl) {
+      return [];
+    }
+    const { accessToken, cloudUrl, tenantId } = connection;
+    const orchestratorConnection = {
+      orchestratorUrl: cloudUrl,
+      accessToken,
+      tenantId
+    };
+    const [error, feeds] = await catchError(getAccessibleFeedsOnce(orchestratorConnection, () => this.feedsService.getAccessibleFeedsAsync(orchestratorConnection)));
+    if (error || !feeds) {
+      this.warnFeedsUnavailable();
+      return [];
+    }
+    return feeds.map((feed) => toTenantFeedSource(feed, accessToken)).filter((feed) => feed !== undefined);
+  }
+  async writeFeedsFile(feeds) {
+    const storage = new TemporaryStorageService(this.fileSystem);
+    const directory = await storage.getTempFolderPath();
+    const configPath = Path.join(directory, FEEDS_FILE_NAME);
+    await this.fileSystem.writeFile(configPath, JSON.stringify(feeds));
+    return { configPath, dispose: () => storage.cleanup() };
+  }
+  warnFeedsUnavailable() {
+    this.logger.warn(translate2.t("packagerOrchestratorClient.feeds.warnings.tenantFeedsUnavailable"));
+  }
+}
+function toTenantFeedSource(feed, accessToken) {
+  if (feed.purpose !== LIBRARIES_PURPOSE || !feed.feedUrl) {
+    return;
+  }
+  return { Url: feed.feedUrl, AccessToken: accessToken };
+}
+
 // src/workflow-compiler-tool.ts
 import {
   LogLevel,
@@ -667,16 +965,16 @@ import { spawn } from "node:child_process";
 import {
   ToolErrorCodes,
   ToolResult,
-  translate as translate2
+  translate as translate5
 } from "@uipath/solutionpackager-tool-core";
 
 // src/workflow-compiler-path-resolver.ts
 import { execFileSync } from "node:child_process";
 import { homedir, platform } from "node:os";
 import {
-  Path,
-  TemporaryStorageService,
-  translate
+  Path as Path2,
+  TemporaryStorageService as TemporaryStorageService2,
+  translate as translate3
 } from "@uipath/solutionpackager-tool-core";
 
 // src/workflow-compiler-config.ts
@@ -724,7 +1022,7 @@ class WorkflowCompilerPathResolver {
   constructor(logger, fileSystem) {
     this.logger = logger;
     this.fileSystem = fileSystem;
-    this.tempStorage = new TemporaryStorageService(fileSystem);
+    this.tempStorage = new TemporaryStorageService2(fileSystem);
   }
   static getInstance(logger, fileSystem) {
     if (!WorkflowCompilerPathResolver.instance) {
@@ -734,7 +1032,7 @@ class WorkflowCompilerPathResolver {
   }
   async getCompilerPathAsync() {
     if (this.cachedPath) {
-      this.logger.info(translate.t("toolWorkflowcompiler.pathResolver.info.usingCached", { path: this.cachedPath }));
+      this.logger.info(translate3.t("toolWorkflowcompiler.pathResolver.info.usingCached", { path: this.cachedPath }));
       return this.cachedPath;
     }
     if (this.pendingResolution) {
@@ -742,7 +1040,7 @@ class WorkflowCompilerPathResolver {
     }
     this.pendingResolution = this.resolveCompilerPath();
     this.cachedPath = await this.pendingResolution;
-    this.logger.info(translate.t("toolWorkflowcompiler.pathResolver.info.resolved", {
+    this.logger.info(translate3.t("toolWorkflowcompiler.pathResolver.info.resolved", {
       path: this.cachedPath
     }));
     return this.cachedPath;
@@ -750,30 +1048,30 @@ class WorkflowCompilerPathResolver {
   async resolveCompilerPath() {
     this.logger.info("[PathResolver] resolveCompilerPath started");
     if (workflowCompilerConfig.workflowCompilerPath) {
-      this.logger.info(translate.t("toolWorkflowcompiler.pathResolver.info.usingExplicitPath", { path: workflowCompilerConfig.workflowCompilerPath }));
+      this.logger.info(translate3.t("toolWorkflowcompiler.pathResolver.info.usingExplicitPath", { path: workflowCompilerConfig.workflowCompilerPath }));
       return workflowCompilerConfig.workflowCompilerPath;
     }
-    this.logger.info(translate.t("toolWorkflowcompiler.pathResolver.info.resolving"));
+    this.logger.info(translate3.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 }));
+    this.logger.info(translate3.t("toolWorkflowcompiler.pathResolver.info.checkingNuGetCache", { path: compilerPath }));
     if (await this.fileSystem.exists(compilerPath)) {
-      this.logger.info(translate.t("toolWorkflowcompiler.pathResolver.info.foundInNuGetCache"));
+      this.logger.info(translate3.t("toolWorkflowcompiler.pathResolver.info.foundInNuGetCache"));
       return compilerPath;
     }
-    this.logger.info(translate.t("toolWorkflowcompiler.pathResolver.info.notFoundStartingInstall"));
+    this.logger.info(translate3.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 }));
+    this.logger.info(translate3.t("toolWorkflowcompiler.pathResolver.info.checkingEnvVar", { path: location }));
     if (location.endsWith(".dll") && await this.fileSystem.exists(location)) {
-      this.logger.info(translate.t("toolWorkflowcompiler.pathResolver.info.foundViaEnv"));
+      this.logger.info(translate3.t("toolWorkflowcompiler.pathResolver.info.foundViaEnv"));
       return location;
     }
     return null;
@@ -782,11 +1080,11 @@ class WorkflowCompilerPathResolver {
     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() }));
+      this.logger.info(translate3.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"));
+      await this.fileSystem.writeFile(Path2.join(tempDir, "restore.csproj"), csproj);
+      await this.fileSystem.writeFile(Path2.join(tempDir, "nuget.config"), EMPTY_NUGET_CONFIG);
+      this.logger.info(translate3.t("toolWorkflowcompiler.pathResolver.info.runningDotnetRestore"));
       try {
         execFileSync("dotnet", [
           "restore",
@@ -803,29 +1101,29 @@ class WorkflowCompilerPathResolver {
         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 }));
+        throw new Error(translate3.t("toolWorkflowcompiler.pathResolver.errors.dotnetRestoreFailed", { details }));
       }
-      this.logger.info(translate.t("toolWorkflowcompiler.pathResolver.info.restoreCompleted"));
+      this.logger.info(translate3.t("toolWorkflowcompiler.pathResolver.info.restoreCompleted"));
       if (!await this.fileSystem.exists(compilerPath)) {
-        throw new Error(translate.t("toolWorkflowcompiler.pathResolver.errors.compilerNotFoundAfterRestore"));
+        throw new Error(translate3.t("toolWorkflowcompiler.pathResolver.errors.compilerNotFoundAfterRestore"));
       }
-      this.logger.info(translate.t("toolWorkflowcompiler.pathResolver.info.installCompleted"));
+      this.logger.info(translate3.t("toolWorkflowcompiler.pathResolver.info.installCompleted"));
       return compilerPath;
     } finally {
-      this.logger.info(translate.t("toolWorkflowcompiler.pathResolver.info.cleaningUp"));
+      this.logger.info(translate3.t("toolWorkflowcompiler.pathResolver.info.cleaningUp"));
       await this.tempStorage.cleanup();
     }
   }
   getPackageId() {
     const packageId = PLATFORM_PACKAGE_IDS[platform()];
     if (!packageId) {
-      throw new Error(translate.t("toolWorkflowcompiler.pathResolver.errors.unsupportedPlatform", { platform: platform() }));
+      throw new Error(translate3.t("toolWorkflowcompiler.pathResolver.errors.unsupportedPlatform", { platform: platform() }));
     }
     return packageId;
   }
   getNuGetCompilerPath(version) {
-    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);
+    const cacheRoot = process.env.NUGET_PACKAGES ?? Path2.join(homedir(), ".nuget", "packages");
+    return Path2.join(cacheRoot, this.getPackageId().toLowerCase(), version.toLowerCase(), "WorkflowCompiler", WORKFLOW_COMPILER_DLL_NAME);
   }
 }
 
@@ -870,7 +1168,7 @@ class WorkflowCompilerExecutor {
           const elapsed = Date.now() - startTime;
           if (result) {
             result.elapsed = elapsed;
-            this.logger.info(translate2.t("toolWorkflowcompiler.lifecycle.completed", {
+            this.logger.info(translate5.t("toolWorkflowcompiler.lifecycle.completed", {
               operation,
               elapsed: elapsed.toString(),
               errorCode: result.errorCode
@@ -881,10 +1179,10 @@ class WorkflowCompilerExecutor {
           } else {
             const exitCode = childProcess.exitCode ?? -1;
             const errorMessage = fallbackErrors.join(`
-`) || translate2.t("toolWorkflowcompiler.errors.processExited", {
+`) || translate5.t("toolWorkflowcompiler.errors.processExited", {
               exitCode: exitCode.toString()
             });
-            this.logger.error(translate2.t("toolWorkflowcompiler.errors.failed", {
+            this.logger.error(translate5.t("toolWorkflowcompiler.errors.failed", {
               operation,
               errorMessage
             }));
@@ -921,10 +1219,10 @@ class WorkflowCompilerExecutor {
   }
   logCommandStart(operation, executable, commandArgs) {
     const fullCommand = [executable, ...commandArgs];
-    this.logger.info(translate2.t("toolWorkflowcompiler.lifecycle.started", {
+    this.logger.info(translate5.t("toolWorkflowcompiler.lifecycle.started", {
       operation
     }));
-    this.logger.info(translate2.t("toolWorkflowcompiler.lifecycle.command", {
+    this.logger.info(translate5.t("toolWorkflowcompiler.lifecycle.command", {
       command: fullCommand.join(" ")
     }));
   }
@@ -1018,10 +1316,10 @@ class WorkflowCompilerExecutor {
   setupProcessEventHandlers(childProcess, streamCompletion, resolve) {
     childProcess.on("exit", () => streamCompletion.markProcessExited());
     childProcess.on("error", (error) => {
-      this.logger.error(translate2.t("toolWorkflowcompiler.errors.processError", {
+      this.logger.error(translate5.t("toolWorkflowcompiler.errors.processError", {
         message: error.message
       }));
-      resolve(new ToolResult(ToolErrorCodes.InternalError, translate2.t("toolWorkflowcompiler.errors.startFailed", {
+      resolve(new ToolResult(ToolErrorCodes.InternalError, translate5.t("toolWorkflowcompiler.errors.startFailed", {
         message: error.message
       }), []));
     });
@@ -1030,9 +1328,9 @@ class WorkflowCompilerExecutor {
     if (!cancellationToken)
       return;
     cancellationToken.addEventListener("abort", () => {
-      this.logger.warn(translate2.t("toolWorkflowcompiler.lifecycle.cancelled"));
+      this.logger.warn(translate5.t("toolWorkflowcompiler.lifecycle.cancelled"));
       childProcess.kill("SIGTERM");
-      resolve(new ToolResult(ToolErrorCodes.Canceled, translate2.t("toolWorkflowcompiler.errors.operationCancelled"), []));
+      resolve(new ToolResult(ToolErrorCodes.Canceled, translate5.t("toolWorkflowcompiler.errors.operationCancelled"), []));
     });
   }
   parseOutputEntry(line) {
@@ -1076,143 +1374,165 @@ function getAdditionalResultDetails(result) {
 
 // src/workflow-compiler-tool.ts
 class WorkflowCompilerTool extends ProjectTool {
+  context;
   executor;
-  constructor(fileSystem, logger) {
+  constructor(fileSystem, logger, context) {
     super(fileSystem, logger);
+    this.context = context;
     this.executor = new WorkflowCompilerExecutor(logger, fileSystem);
   }
-  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);
+  async withNuGetConfig(options, run) {
+    const connection = this.context?.connection;
+    if (options.nuGetSourcesConfigPath || !connection) {
+      return run(options.nuGetSourcesConfigPath);
+    }
+    const composed = await new OrchestratorFeedComposer(this.fileSystem, this.logger).composeAsync({ connection });
+    try {
+      return await run(composed.configPath);
+    } finally {
+      await composed.dispose();
     }
-    return this.executor.executeAsync("restore", args, cancellationToken);
+  }
+  async restoreAsync(options, cancellationToken) {
+    return this.withNuGetConfig(options, (nuGetConfigPath) => {
+      const args = [
+        `-p`,
+        options.projectPath,
+        `--log-level`,
+        String(options.logLevel ?? LogLevel.Info),
+        `--destination`,
+        options.outputPath ?? "",
+        `--format-logs`,
+        `true`,
+        `--exclude-configured-sources`,
+        `${options.excludeConfiguredSources}`
+      ];
+      if (nuGetConfigPath) {
+        args.push(`--nuget-config-file`, nuGetConfigPath);
+      }
+      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}`,
-      `--skip-validate`,
-      `${options.skipValidate}`,
-      `--exclude-configured-sources`,
-      `${options.excludeConfiguredSources}`
-    ];
-    if (options.detailedLogPath) {
-      args.push(`--detailed`, options.detailedLogPath);
-    }
-    if (options.defaultSeverity) {
-      args.push(`--default-severity`, options.defaultSeverity);
-    }
-    if (options.policyFilePath) {
-      args.push(`--policy-file`, options.policyFilePath);
-    }
-    if (options.policyFileType) {
-      args.push(`--policy-file-type`, `${options.policyFileType}`);
-    }
-    if (options.nuGetSourcesConfigPath) {
-      args.push(`--nuget-config-file`, options.nuGetSourcesConfigPath);
-    }
-    return this.executor.executeAsync("validate", args, cancellationToken);
+    return this.withNuGetConfig(options, (nuGetConfigPath) => {
+      const args = [
+        `-p`,
+        options.projectPath,
+        `--log-level`,
+        String(options.logLevel ?? LogLevel.Info),
+        `--format-logs`,
+        `true`,
+        `--skip-analyze`,
+        `${options.skipAnalyze}`,
+        `--skip-validate`,
+        `${options.skipValidate}`,
+        `--exclude-configured-sources`,
+        `${options.excludeConfiguredSources}`
+      ];
+      if (options.detailedLogPath) {
+        args.push(`--detailed`, options.detailedLogPath);
+      }
+      if (options.defaultSeverity) {
+        args.push(`--default-severity`, options.defaultSeverity);
+      }
+      if (options.policyFilePath) {
+        args.push(`--policy-file`, options.policyFilePath);
+      }
+      if (options.policyFileType) {
+        args.push(`--policy-file-type`, `${options.policyFileType}`);
+      }
+      if (nuGetConfigPath) {
+        args.push(`--nuget-config-file`, nuGetConfigPath);
+      }
+      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);
+    return this.withNuGetConfig(options, (nuGetConfigPath) => {
+      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 (nuGetConfigPath) {
+        args.push(`--nuget-config-file`, nuGetConfigPath);
+      }
+      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);
+    return this.withNuGetConfig(options, async (nuGetConfigPath) => {
+      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 (nuGetConfigPath) {
+        args.push(`--nuget-config-file`, nuGetConfigPath);
+      }
+      return this.executor.executeAsync("build", args, cancellationToken);
+    });
   }
   mapOutputType(outputType) {
     return outputType === "WebApp" ? "Process" : outputType;
@@ -1228,11 +1548,11 @@ class WorkflowCompilerToolFactory {
     ProjectTypes.Tests,
     ProjectTypes.WebApp
   ];
-  async createAsync(logger, fileSystem) {
+  async createAsync(logger, fileSystem, context) {
     if (!this.isDotnetAvailable()) {
-      throw new Error(translate3.t("toolWorkflowcompiler.errors.dotnetNotAvailable"));
+      throw new Error(translate6.t("toolWorkflowcompiler.errors.dotnetNotAvailable"));
     }
-    return new WorkflowCompilerTool(fileSystem, logger);
+    return new WorkflowCompilerTool(fileSystem, logger, context);
   }
   isDotnetAvailable() {
     if (WorkflowCompilerToolFactory.cachedDotnetAvailable !== undefined) {
@@ -1254,4 +1574,4 @@ export {
   WorkflowCompilerToolFactory
 };
 
-//# debugId=50A7EA5FC29ACF3664756E2164756E21
+//# debugId=3093E6E2D5D9AED664756E2164756E21

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

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

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

@@ -1,11 +1,13 @@
-import { type IFileSystem, type IProjectBuildOptions, type IProjectPackOptions, type IProjectRestoreOptions, type IProjectValidateOptions, type IToolLogger, ProjectTool, type ToolResult } from "@uipath/solutionpackager-tool-core";
+import { type IFileSystem, type IProjectBuildOptions, type IProjectPackOptions, type IProjectRestoreOptions, type IProjectValidateOptions, type IToolLogger, type ProjectOperationContext, 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 context?;
     private readonly executor;
-    constructor(fileSystem: IFileSystem, logger: IToolLogger);
+    constructor(fileSystem: IFileSystem, logger: IToolLogger, context?: ProjectOperationContext | undefined);
+    private withNuGetConfig;
     restoreAsync(options: IProjectRestoreOptions, cancellationToken?: AbortSignal): Promise<ToolResult>;
     validateAsync(options: IProjectValidateOptions, cancellationToken?: AbortSignal): Promise<ToolResult>;
     buildAsync(options: IProjectBuildOptions, cancellationToken?: AbortSignal): Promise<ToolResult>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uipath/packager-tool-workflowcompiler",
-  "version": "1.197.0-preview.63",
+  "version": "1.197.0-preview.65",
   "description": "UiPath Workflow Compiler tool implementation",
   "type": "module",
   "exports": {
@@ -28,5 +28,5 @@
     "@uipath/solutionpackager-tool-core": "1.197.0"
   },
   "dependencies": {},
-  "gitHead": "f11c510734215113744bf42073c327ecd776c7c2"
+  "gitHead": "9388ccbe5e739c9578bfd9b5395980fb63e11d9c"
 }

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

@@ -3,6 +3,7 @@ import {
     type IFileSystem,
     type IProjectToolFactory,
     type IToolLogger,
+    type ProjectOperationContext,
     type ProjectTool,
     type ProjectType,
     ProjectTypes,
@@ -32,13 +33,14 @@ export class WorkflowCompilerToolFactory implements IProjectToolFactory {
     async createAsync(
         logger: IToolLogger,
         fileSystem: IFileSystem,
+        context?: ProjectOperationContext,
     ): Promise<ProjectTool> {
         if (!this.isDotnetAvailable()) {
             throw new Error(
                 translate.t("toolWorkflowcompiler.errors.dotnetNotAvailable"),
             );
         }
-        return new WorkflowCompilerTool(fileSystem, logger);
+        return new WorkflowCompilerTool(fileSystem, logger, context);
     }
 
     private isDotnetAvailable(): boolean {

package/src/workflow-compiler-tool.ts

@@ -1,11 +1,14 @@
+import { OrchestratorFeedComposer } from "@uipath/packager-orchestrator-client";
 import {
     type IFileSystem,
     type IProjectBuildOptions,
+    type IProjectOptions,
     type IProjectPackOptions,
     type IProjectRestoreOptions,
     type IProjectValidateOptions,
     type IToolLogger,
     LogLevel,
+    type ProjectOperationContext,
     ProjectTool,
     type ToolResult,
 } from "@uipath/solutionpackager-tool-core";
@@ -18,166 +21,205 @@ import { WorkflowCompilerExecutor } from "./workflow-compiler-executor.js";
 export class WorkflowCompilerTool extends ProjectTool {
     private readonly executor: WorkflowCompilerExecutor;
 
-    constructor(fileSystem: IFileSystem, logger: IToolLogger) {
+    constructor(
+        fileSystem: IFileSystem,
+        logger: IToolLogger,
+        private readonly context?: ProjectOperationContext,
+    ) {
         super(fileSystem, logger);
         this.executor = new WorkflowCompilerExecutor(logger, fileSystem);
     }
 
+    private async withNuGetConfig(
+        options: IProjectOptions,
+        run: (nuGetConfigPath?: string) => Promise<ToolResult>,
+    ): Promise<ToolResult> {
+        const connection = this.context?.connection;
+        if (options.nuGetSourcesConfigPath || !connection) {
+            return run(options.nuGetSourcesConfigPath);
+        }
+        const composed = await new OrchestratorFeedComposer(
+            this.fileSystem,
+            this.logger,
+        ).composeAsync({ connection });
+        try {
+            return await run(composed.configPath);
+        } finally {
+            await composed.dispose();
+        }
+    }
+
     async restoreAsync(
         options: IProjectRestoreOptions,
         cancellationToken?: AbortSignal,
     ): Promise<ToolResult> {
-        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.withNuGetConfig(options, (nuGetConfigPath) => {
+            const args = [
+                `-p`,
+                options.projectPath,
+                `--log-level`,
+                String(options.logLevel ?? LogLevel.Info),
+                `--destination`,
+                options.outputPath ?? "",
+                `--format-logs`,
+                `true`,
+                `--exclude-configured-sources`,
+                `${options.excludeConfiguredSources}`,
+            ];
+
+            if (nuGetConfigPath) {
+                args.push(`--nuget-config-file`, nuGetConfigPath);
+            }
 
-        return this.executor.executeAsync("restore", args, cancellationToken);
+            return this.executor.executeAsync(
+                "restore",
+                args,
+                cancellationToken,
+            );
+        });
     }
 
     async validateAsync(
         options: IProjectValidateOptions,
         cancellationToken?: AbortSignal,
     ): Promise<ToolResult> {
-        const args = [
-            `-p`,
-            options.projectPath,
-            `--log-level`,
-            String(options.logLevel ?? LogLevel.Info),
-            `--format-logs`,
-            `true`,
-            `--skip-analyze`,
-            `${options.skipAnalyze}`,
-            `--skip-validate`,
-            `${options.skipValidate}`,
-            `--exclude-configured-sources`,
-            `${options.excludeConfiguredSources}`,
-        ];
-
-        if (options.detailedLogPath) {
-            args.push(`--detailed`, options.detailedLogPath);
-        }
-        if (options.defaultSeverity) {
-            args.push(`--default-severity`, options.defaultSeverity);
-        }
-        if (options.policyFilePath) {
-            args.push(`--policy-file`, options.policyFilePath);
-        }
-        if (options.policyFileType) {
-            args.push(`--policy-file-type`, `${options.policyFileType}`);
-        }
-        if (options.nuGetSourcesConfigPath) {
-            args.push(`--nuget-config-file`, options.nuGetSourcesConfigPath);
-        }
+        return this.withNuGetConfig(options, (nuGetConfigPath) => {
+            const args = [
+                `-p`,
+                options.projectPath,
+                `--log-level`,
+                String(options.logLevel ?? LogLevel.Info),
+                `--format-logs`,
+                `true`,
+                `--skip-analyze`,
+                `${options.skipAnalyze}`,
+                `--skip-validate`,
+                `${options.skipValidate}`,
+                `--exclude-configured-sources`,
+                `${options.excludeConfiguredSources}`,
+            ];
+
+            if (options.detailedLogPath) {
+                args.push(`--detailed`, options.detailedLogPath);
+            }
+            if (options.defaultSeverity) {
+                args.push(`--default-severity`, options.defaultSeverity);
+            }
+            if (options.policyFilePath) {
+                args.push(`--policy-file`, options.policyFilePath);
+            }
+            if (options.policyFileType) {
+                args.push(`--policy-file-type`, `${options.policyFileType}`);
+            }
+            if (nuGetConfigPath) {
+                args.push(`--nuget-config-file`, nuGetConfigPath);
+            }
 
-        return this.executor.executeAsync("validate", args, cancellationToken);
+            return this.executor.executeAsync(
+                "validate",
+                args,
+                cancellationToken,
+            );
+        });
     }
 
     async buildAsync(
         options: IProjectBuildOptions,
         cancellationToken?: AbortSignal,
     ): Promise<ToolResult> {
-        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.withNuGetConfig(options, (nuGetConfigPath) => {
+            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 (nuGetConfigPath) {
+                args.push(`--nuget-config-file`, nuGetConfigPath);
+            }
 
-        return this.executor.executeAsync("build", args, cancellationToken);
+            return this.executor.executeAsync("build", args, cancellationToken);
+        });
     }
 
     async packAsync(
         options: IProjectPackOptions,
         cancellationToken?: AbortSignal,
     ): Promise<ToolResult> {
-        const args: string[] = [
-            `-p`,
-            options.projectPath,
-            `-o`,
-            options.outputPath,
-            `--build-version`,
-            options.package.version,
-            `--log-level`,
-            String(options.logLevel ?? LogLevel.Info),
-            `--format-logs`,
-            `true`,
-            `--skip-analyze`,
-            `${options.skipAnalyze}`,
-            `--skip-validate`,
-            `${options.skipValidate}`,
-            `--no-optimize-deps`,
-            `${options.skipDependencyOptimization}`,
-            `--include-sources`,
-            `${options.includeSources}`,
-            `--split-packages`,
-            `${options.splitPackages}`,
-            `--exclude-configured-sources`,
-            `${options.excludeConfiguredSources}`,
-            `--pack-options`,
-            JSON.stringify(options.package),
-        ];
-
-        if (options.package.id) {
-            args.push(`--package-name`, options.package.id);
-        }
-        if (options.detailedLogPath) {
-            args.push(`--detailed`, options.detailedLogPath);
-        }
-        if (options.policyFilePath) {
-            args.push(`--policy-file`, options.policyFilePath);
-        }
-        if (options.policyFileType) {
-            args.push(`--policy-file-type`, options.policyFileType);
-        }
-        if (options.outputType) {
-            const outputType = this.mapOutputType(options.outputType);
-            args.push(`--output-type`, outputType);
-        }
-        if (options.nuGetSourcesConfigPath) {
-            args.push(`--nuget-config-file`, options.nuGetSourcesConfigPath);
-        }
+        return this.withNuGetConfig(options, async (nuGetConfigPath) => {
+            const args: string[] = [
+                `-p`,
+                options.projectPath,
+                `-o`,
+                options.outputPath,
+                `--build-version`,
+                options.package.version,
+                `--log-level`,
+                String(options.logLevel ?? LogLevel.Info),
+                `--format-logs`,
+                `true`,
+                `--skip-analyze`,
+                `${options.skipAnalyze}`,
+                `--skip-validate`,
+                `${options.skipValidate}`,
+                `--no-optimize-deps`,
+                `${options.skipDependencyOptimization}`,
+                `--include-sources`,
+                `${options.includeSources}`,
+                `--split-packages`,
+                `${options.splitPackages}`,
+                `--exclude-configured-sources`,
+                `${options.excludeConfiguredSources}`,
+                `--pack-options`,
+                JSON.stringify(options.package),
+            ];
+
+            if (options.package.id) {
+                args.push(`--package-name`, options.package.id);
+            }
+            if (options.detailedLogPath) {
+                args.push(`--detailed`, options.detailedLogPath);
+            }
+            if (options.policyFilePath) {
+                args.push(`--policy-file`, options.policyFilePath);
+            }
+            if (options.policyFileType) {
+                args.push(`--policy-file-type`, options.policyFileType);
+            }
+            if (options.outputType) {
+                const outputType = this.mapOutputType(options.outputType);
+                args.push(`--output-type`, outputType);
+            }
+            if (nuGetConfigPath) {
+                args.push(`--nuget-config-file`, nuGetConfigPath);
+            }
 
-        return this.executor.executeAsync("build", args, cancellationToken);
+            return this.executor.executeAsync("build", args, cancellationToken);
+        });
     }
 
     /**