@uipath/rpa-tool 0.9.3 → 0.9.4

package/dist/packager-tool.js

@@ -1,10 +1,1037 @@
+// node_modules/@uipath/solutionpackager-tool-core/dist/index.js
+class Path {
+  static normalize(path) {
+    return path.replace(/\\/g, "/").replace(/\/+/g, "/");
+  }
+  static join(...segments) {
+    return Path.normalize(segments.filter((s) => s.length > 0).join("/"));
+  }
+  static dirname(path) {
+    const normalized = Path.normalize(path).replace(/\/$/, "");
+    if (normalized === "")
+      return ".";
+    const lastSlash = normalized.lastIndexOf("/");
+    if (lastSlash === -1)
+      return ".";
+    if (lastSlash === 0)
+      return "/";
+    return normalized.substring(0, lastSlash);
+  }
+  static basename(path) {
+    const normalized = Path.normalize(path).replace(/\/$/, "");
+    if (normalized === "")
+      return "";
+    const lastSlash = normalized.lastIndexOf("/");
+    return lastSlash >= 0 ? normalized.substring(lastSlash + 1) : normalized;
+  }
+  static extname(path) {
+    const base = Path.basename(path);
+    const lastDot = base.lastIndexOf(".");
+    if (lastDot === -1 || lastDot === 0 || lastDot === base.length - 1) {
+      return "";
+    }
+    return base.substring(lastDot);
+  }
+  static async walkDirectory(fs, rootPath, currentRelativePath = "") {
+    const entries = [];
+    const absolutePath = currentRelativePath ? Path.join(rootPath, currentRelativePath) : rootPath;
+    const items = await fs.readdir(absolutePath);
+    for (const item of items) {
+      const itemRelativePath = currentRelativePath ? Path.join(currentRelativePath, item) : item;
+      const itemAbsolutePath = Path.join(rootPath, itemRelativePath);
+      const stat = await fs.stat(itemAbsolutePath);
+      if (stat?.isDirectory()) {
+        const subEntries = await Path.walkDirectory(fs, rootPath, itemRelativePath);
+        entries.push(...subEntries);
+      } else if (stat?.isFile()) {
+        entries.push({
+          relativePath: Path.normalize(itemRelativePath),
+          absolutePath: Path.normalize(itemAbsolutePath)
+        });
+      }
+    }
+    return entries;
+  }
+}
+
+class TemporaryStorageService {
+  fileSystem;
+  _tempFolderPath = null;
+  constructor(fileSystem) {
+    this.fileSystem = fileSystem;
+  }
+  async getTempFolderPath() {
+    if (!this._tempFolderPath) {
+      const systemTempDir = await this.fileSystem.getTempDir();
+      const uniqueFolderName = this.generateUniqueFolderName();
+      this._tempFolderPath = Path.join(systemTempDir, uniqueFolderName);
+      await this.fileSystem.mkdir(this._tempFolderPath);
+    }
+    return this._tempFolderPath;
+  }
+  generateUniqueFolderName() {
+    const timestamp = Date.now();
+    const random = Math.random().toString(36).substring(2, 10);
+    return `tool-temp-${timestamp}-${random}`;
+  }
+  async getTempSubfolderPathAsync(subfolder) {
+    const tempFolderPath = await this.getTempFolderPath();
+    const inputPath = Path.join(tempFolderPath, subfolder);
+    await this.fileSystem.mkdir(inputPath);
+    return inputPath;
+  }
+  async cleanup() {
+    try {
+      if (!this._tempFolderPath) {
+        return;
+      }
+      try {
+        const stats = await this.fileSystem.stat(this._tempFolderPath);
+        if (!stats) {
+          return;
+        }
+      } catch {
+        return;
+      }
+      const pathToCleanup = this._tempFolderPath;
+      await this.fileSystem.rm(this._tempFolderPath);
+      this._tempFolderPath = null;
+    } catch {}
+  }
+}
+function isPluralForm(value) {
+  return typeof value === "object" && value !== null && "other" in value;
+}
+function selectPluralForm(forms, count) {
+  if (count === 0 && forms.zero !== undefined) {
+    return forms.zero;
+  }
+  if (count === 1 && forms.one !== undefined) {
+    return forms.one;
+  }
+  if (count === 2 && forms.two !== undefined) {
+    return forms.two;
+  }
+  if (forms.few !== undefined) {
+    const mod10 = count % 10;
+    const mod100 = count % 100;
+    if (mod10 >= 2 && mod10 <= 4 && (mod100 < 10 || mod100 >= 20)) {
+      return forms.few;
+    }
+  }
+  if (forms.many !== undefined) {
+    const mod10 = count % 10;
+    const mod100 = count % 100;
+    if (count === 0 || mod10 === 0 && mod100 !== 0 || mod10 >= 5 && mod10 <= 9 || mod100 >= 11 && mod100 <= 14) {
+      return forms.many;
+    }
+  }
+  return forms.other;
+}
+
+class I18nManager {
+  static translations = {};
+  static currentLocale = "en";
+  static fallbackLocale = "en";
+  static registerTranslations(locale, catalog) {
+    if (!I18nManager.translations[locale]) {
+      I18nManager.translations[locale] = {};
+    }
+    I18nManager.translations[locale] = I18nManager.deepMerge(I18nManager.translations[locale], catalog);
+  }
+  static setLocale(locale) {
+    const normalized = I18nManager.normalizeLocale(locale);
+    if (I18nManager.translations[normalized]) {
+      I18nManager.currentLocale = normalized;
+      return normalized;
+    }
+    const baseLocale = normalized.split("-")[0];
+    if (baseLocale !== normalized && I18nManager.translations[baseLocale]) {
+      I18nManager.currentLocale = baseLocale;
+      return baseLocale;
+    }
+    return I18nManager.currentLocale;
+  }
+  static getLocale() {
+    return I18nManager.currentLocale;
+  }
+  static setFallbackLocale(locale) {
+    I18nManager.fallbackLocale = I18nManager.normalizeLocale(locale);
+  }
+  static t(key, params, locale) {
+    const targetLocale = locale ? I18nManager.normalizeLocale(locale) : I18nManager.currentLocale;
+    let value = I18nManager.getTranslationValue(key, targetLocale);
+    if (value === undefined && targetLocale !== I18nManager.fallbackLocale) {
+      value = I18nManager.getTranslationValue(key, I18nManager.fallbackLocale);
+    }
+    if (value === undefined) {
+      return key;
+    }
+    if (isPluralForm(value) && params && "count" in params) {
+      const count = typeof params.count === "number" ? params.count : Number(params.count);
+      value = selectPluralForm(value, count);
+    } else if (isPluralForm(value)) {
+      value = value.other;
+    }
+    if (typeof value !== "string") {
+      return key;
+    }
+    return params ? I18nManager.interpolate(value, params) : value;
+  }
+  static has(key, locale) {
+    const targetLocale = locale ? I18nManager.normalizeLocale(locale) : I18nManager.currentLocale;
+    const value = I18nManager.getTranslationValue(key, targetLocale);
+    if (value !== undefined) {
+      return true;
+    }
+    if (targetLocale !== I18nManager.fallbackLocale) {
+      return I18nManager.getTranslationValue(key, I18nManager.fallbackLocale) !== undefined;
+    }
+    return false;
+  }
+  static getAvailableLocales() {
+    return Object.keys(I18nManager.translations);
+  }
+  static clearTranslations() {
+    I18nManager.translations = {};
+    I18nManager.currentLocale = "en";
+  }
+  static getTranslationValue(key, locale) {
+    const catalog = I18nManager.translations[locale];
+    if (!catalog) {
+      return;
+    }
+    const keys = key.split(".");
+    let value = catalog;
+    for (const k of keys) {
+      if (value && typeof value === "object" && k in value) {
+        value = value[k];
+      } else {
+        return;
+      }
+    }
+    return value;
+  }
+  static interpolate(template, params) {
+    return template.replace(/\{(\w+)\}/g, (_, key) => {
+      const value = params[key];
+      return value !== undefined ? String(value) : `{${key}}`;
+    });
+  }
+  static normalizeLocale(locale) {
+    const normalized = locale.toLowerCase().replace(/_/g, "-");
+    const specialLocales = ["es-mx", "pt-br", "zh-cn", "zh-tw"];
+    if (specialLocales.includes(normalized)) {
+      return normalized;
+    }
+    return normalized.split("-")[0];
+  }
+  static deepMerge(target, source) {
+    const result = { ...target };
+    for (const key of Object.keys(source)) {
+      const sourceValue = source[key];
+      const targetValue = result[key];
+      if (sourceValue && typeof sourceValue === "object" && !Array.isArray(sourceValue) && targetValue && typeof targetValue === "object" && !Array.isArray(targetValue)) {
+        result[key] = I18nManager.deepMerge(targetValue, sourceValue);
+      } else {
+        result[key] = sourceValue;
+      }
+    }
+    return result;
+  }
+}
+var de = {
+  toolCore: {
+    errors: {
+      internal: "Internal error: {message}",
+      fileNotFound: "File not found: {path}",
+      fileReadFailed: "Failed to read file: {path}",
+      fileWriteFailed: "Failed to write file: {path}",
+      directoryNotFound: "Directory not found: {path}",
+      invalidPath: "{path} is not a valid path",
+      operationCanceled: "Operation was canceled",
+      invalidParameter: "Invalid parameter: {parameter}"
+    },
+    progress: {
+      copying: "Copying files...",
+      building: "Building project...",
+      packaging: "Creating package...",
+      validating: "Validating...",
+      analyzing: "Analyzing...",
+      restoring: "Restoring dependencies..."
+    },
+    validation: {
+      requiredField: "{field} is required",
+      invalidValue: "Invalid value for {field}",
+      pathNotFound: "Path not found: {path}",
+      fileRequired: "File is required: {path}",
+      directoryRequired: "Directory is required: {path}"
+    },
+    warnings: {
+      factoryAlreadyRegistered: "A factory is already registered for project type '{type}'. Skipping duplicate registration."
+    },
+    info: {
+      operationComplete: "Operation completed successfully",
+      filesProcessed: {
+        zero: "No files processed",
+        one: "{count} file processed",
+        other: "{count} files processed"
+      }
+    }
+  }
+};
+var en = {
+  toolCore: {
+    errors: {
+      internal: "Internal error: {message}",
+      fileNotFound: "File not found: {path}",
+      fileReadFailed: "Failed to read file: {path}",
+      fileWriteFailed: "Failed to write file: {path}",
+      directoryNotFound: "Directory not found: {path}",
+      invalidPath: "{path} is not a valid path",
+      operationCanceled: "Operation was canceled",
+      invalidParameter: "Invalid parameter: {parameter}"
+    },
+    progress: {
+      copying: "Copying files...",
+      building: "Building project...",
+      packaging: "Creating package...",
+      validating: "Validating...",
+      analyzing: "Analyzing...",
+      restoring: "Restoring dependencies..."
+    },
+    validation: {
+      requiredField: "{field} is required",
+      invalidValue: "Invalid value for {field}",
+      pathNotFound: "Path not found: {path}",
+      fileRequired: "File is required: {path}",
+      directoryRequired: "Directory is required: {path}"
+    },
+    warnings: {
+      factoryAlreadyRegistered: "A factory is already registered for project type '{type}'. Skipping duplicate registration."
+    },
+    info: {
+      operationComplete: "Operation completed successfully",
+      filesProcessed: {
+        zero: "No files processed",
+        one: "{count} file processed",
+        other: "{count} files processed"
+      }
+    }
+  }
+};
+var es = {
+  toolCore: {
+    errors: {
+      internal: "Internal error: {message}",
+      fileNotFound: "File not found: {path}",
+      fileReadFailed: "Failed to read file: {path}",
+      fileWriteFailed: "Failed to write file: {path}",
+      directoryNotFound: "Directory not found: {path}",
+      invalidPath: "{path} is not a valid path",
+      operationCanceled: "Operation was canceled",
+      invalidParameter: "Invalid parameter: {parameter}"
+    },
+    progress: {
+      copying: "Copying files...",
+      building: "Building project...",
+      packaging: "Creating package...",
+      validating: "Validating...",
+      analyzing: "Analyzing...",
+      restoring: "Restoring dependencies..."
+    },
+    validation: {
+      requiredField: "{field} is required",
+      invalidValue: "Invalid value for {field}",
+      pathNotFound: "Path not found: {path}",
+      fileRequired: "File is required: {path}",
+      directoryRequired: "Directory is required: {path}"
+    },
+    warnings: {
+      factoryAlreadyRegistered: "A factory is already registered for project type '{type}'. Skipping duplicate registration."
+    },
+    info: {
+      operationComplete: "Operation completed successfully",
+      filesProcessed: {
+        zero: "No files processed",
+        one: "{count} file processed",
+        other: "{count} files processed"
+      }
+    }
+  }
+};
+var es_MX = {
+  toolCore: {
+    errors: {
+      internal: "Internal error: {message}",
+      fileNotFound: "File not found: {path}",
+      fileReadFailed: "Failed to read file: {path}",
+      fileWriteFailed: "Failed to write file: {path}",
+      directoryNotFound: "Directory not found: {path}",
+      invalidPath: "{path} is not a valid path",
+      operationCanceled: "Operation was canceled",
+      invalidParameter: "Invalid parameter: {parameter}"
+    },
+    progress: {
+      copying: "Copying files...",
+      building: "Building project...",
+      packaging: "Creating package...",
+      validating: "Validating...",
+      analyzing: "Analyzing...",
+      restoring: "Restoring dependencies..."
+    },
+    validation: {
+      requiredField: "{field} is required",
+      invalidValue: "Invalid value for {field}",
+      pathNotFound: "Path not found: {path}",
+      fileRequired: "File is required: {path}",
+      directoryRequired: "Directory is required: {path}"
+    },
+    warnings: {
+      factoryAlreadyRegistered: "A factory is already registered for project type '{type}'. Skipping duplicate registration."
+    },
+    info: {
+      operationComplete: "Operation completed successfully",
+      filesProcessed: {
+        zero: "No files processed",
+        one: "{count} file processed",
+        other: "{count} files processed"
+      }
+    }
+  }
+};
+var fr = {
+  toolCore: {
+    errors: {
+      internal: "Internal error: {message}",
+      fileNotFound: "File not found: {path}",
+      fileReadFailed: "Failed to read file: {path}",
+      fileWriteFailed: "Failed to write file: {path}",
+      directoryNotFound: "Directory not found: {path}",
+      invalidPath: "{path} is not a valid path",
+      operationCanceled: "Operation was canceled",
+      invalidParameter: "Invalid parameter: {parameter}"
+    },
+    progress: {
+      copying: "Copying files...",
+      building: "Building project...",
+      packaging: "Creating package...",
+      validating: "Validating...",
+      analyzing: "Analyzing...",
+      restoring: "Restoring dependencies..."
+    },
+    validation: {
+      requiredField: "{field} is required",
+      invalidValue: "Invalid value for {field}",
+      pathNotFound: "Path not found: {path}",
+      fileRequired: "File is required: {path}",
+      directoryRequired: "Directory is required: {path}"
+    },
+    warnings: {
+      factoryAlreadyRegistered: "A factory is already registered for project type '{type}'. Skipping duplicate registration."
+    },
+    info: {
+      operationComplete: "Operation completed successfully",
+      filesProcessed: {
+        zero: "No files processed",
+        one: "{count} file processed",
+        other: "{count} files processed"
+      }
+    }
+  }
+};
+var ja = {
+  toolCore: {
+    errors: {
+      internal: "Internal error: {message}",
+      fileNotFound: "File not found: {path}",
+      fileReadFailed: "Failed to read file: {path}",
+      fileWriteFailed: "Failed to write file: {path}",
+      directoryNotFound: "Directory not found: {path}",
+      invalidPath: "{path} is not a valid path",
+      operationCanceled: "Operation was canceled",
+      invalidParameter: "Invalid parameter: {parameter}"
+    },
+    progress: {
+      copying: "Copying files...",
+      building: "Building project...",
+      packaging: "Creating package...",
+      validating: "Validating...",
+      analyzing: "Analyzing...",
+      restoring: "Restoring dependencies..."
+    },
+    validation: {
+      requiredField: "{field} is required",
+      invalidValue: "Invalid value for {field}",
+      pathNotFound: "Path not found: {path}",
+      fileRequired: "File is required: {path}",
+      directoryRequired: "Directory is required: {path}"
+    },
+    warnings: {
+      factoryAlreadyRegistered: "A factory is already registered for project type '{type}'. Skipping duplicate registration."
+    },
+    info: {
+      operationComplete: "Operation completed successfully",
+      filesProcessed: {
+        zero: "No files processed",
+        one: "{count} file processed",
+        other: "{count} files processed"
+      }
+    }
+  }
+};
+var ko = {
+  toolCore: {
+    errors: {
+      internal: "Internal error: {message}",
+      fileNotFound: "File not found: {path}",
+      fileReadFailed: "Failed to read file: {path}",
+      fileWriteFailed: "Failed to write file: {path}",
+      directoryNotFound: "Directory not found: {path}",
+      invalidPath: "{path} is not a valid path",
+      operationCanceled: "Operation was canceled",
+      invalidParameter: "Invalid parameter: {parameter}"
+    },
+    progress: {
+      copying: "Copying files...",
+      building: "Building project...",
+      packaging: "Creating package...",
+      validating: "Validating...",
+      analyzing: "Analyzing...",
+      restoring: "Restoring dependencies..."
+    },
+    validation: {
+      requiredField: "{field} is required",
+      invalidValue: "Invalid value for {field}",
+      pathNotFound: "Path not found: {path}",
+      fileRequired: "File is required: {path}",
+      directoryRequired: "Directory is required: {path}"
+    },
+    warnings: {
+      factoryAlreadyRegistered: "A factory is already registered for project type '{type}'. Skipping duplicate registration."
+    },
+    info: {
+      operationComplete: "Operation completed successfully",
+      filesProcessed: {
+        zero: "No files processed",
+        one: "{count} file processed",
+        other: "{count} files processed"
+      }
+    }
+  }
+};
+var pt = {
+  toolCore: {
+    errors: {
+      internal: "Internal error: {message}",
+      fileNotFound: "File not found: {path}",
+      fileReadFailed: "Failed to read file: {path}",
+      fileWriteFailed: "Failed to write file: {path}",
+      directoryNotFound: "Directory not found: {path}",
+      invalidPath: "{path} is not a valid path",
+      operationCanceled: "Operation was canceled",
+      invalidParameter: "Invalid parameter: {parameter}"
+    },
+    progress: {
+      copying: "Copying files...",
+      building: "Building project...",
+      packaging: "Creating package...",
+      validating: "Validating...",
+      analyzing: "Analyzing...",
+      restoring: "Restoring dependencies..."
+    },
+    validation: {
+      requiredField: "{field} is required",
+      invalidValue: "Invalid value for {field}",
+      pathNotFound: "Path not found: {path}",
+      fileRequired: "File is required: {path}",
+      directoryRequired: "Directory is required: {path}"
+    },
+    warnings: {
+      factoryAlreadyRegistered: "A factory is already registered for project type '{type}'. Skipping duplicate registration."
+    },
+    info: {
+      operationComplete: "Operation completed successfully",
+      filesProcessed: {
+        zero: "No files processed",
+        one: "{count} file processed",
+        other: "{count} files processed"
+      }
+    }
+  }
+};
+var pt_BR = {
+  toolCore: {
+    errors: {
+      internal: "Internal error: {message}",
+      fileNotFound: "File not found: {path}",
+      fileReadFailed: "Failed to read file: {path}",
+      fileWriteFailed: "Failed to write file: {path}",
+      directoryNotFound: "Directory not found: {path}",
+      invalidPath: "{path} is not a valid path",
+      operationCanceled: "Operation was canceled",
+      invalidParameter: "Invalid parameter: {parameter}"
+    },
+    progress: {
+      copying: "Copying files...",
+      building: "Building project...",
+      packaging: "Creating package...",
+      validating: "Validating...",
+      analyzing: "Analyzing...",
+      restoring: "Restoring dependencies..."
+    },
+    validation: {
+      requiredField: "{field} is required",
+      invalidValue: "Invalid value for {field}",
+      pathNotFound: "Path not found: {path}",
+      fileRequired: "File is required: {path}",
+      directoryRequired: "Directory is required: {path}"
+    },
+    warnings: {
+      factoryAlreadyRegistered: "A factory is already registered for project type '{type}'. Skipping duplicate registration."
+    },
+    info: {
+      operationComplete: "Operation completed successfully",
+      filesProcessed: {
+        zero: "No files processed",
+        one: "{count} file processed",
+        other: "{count} files processed"
+      }
+    }
+  }
+};
+var ro = {
+  toolCore: {
+    errors: {
+      internal: "Internal error: {message}",
+      fileNotFound: "File not found: {path}",
+      fileReadFailed: "Failed to read file: {path}",
+      fileWriteFailed: "Failed to write file: {path}",
+      directoryNotFound: "Directory not found: {path}",
+      invalidPath: "{path} is not a valid path",
+      operationCanceled: "Operation was canceled",
+      invalidParameter: "Invalid parameter: {parameter}"
+    },
+    progress: {
+      copying: "Copying files...",
+      building: "Building project...",
+      packaging: "Creating package...",
+      validating: "Validating...",
+      analyzing: "Analyzing...",
+      restoring: "Restoring dependencies..."
+    },
+    validation: {
+      requiredField: "{field} is required",
+      invalidValue: "Invalid value for {field}",
+      pathNotFound: "Path not found: {path}",
+      fileRequired: "File is required: {path}",
+      directoryRequired: "Directory is required: {path}"
+    },
+    warnings: {
+      factoryAlreadyRegistered: "A factory is already registered for project type '{type}'. Skipping duplicate registration."
+    },
+    info: {
+      operationComplete: "Operation completed successfully",
+      filesProcessed: {
+        zero: "No files processed",
+        one: "{count} file processed",
+        other: "{count} files processed"
+      }
+    }
+  }
+};
+var ru = {
+  toolCore: {
+    errors: {
+      internal: "Internal error: {message}",
+      fileNotFound: "File not found: {path}",
+      fileReadFailed: "Failed to read file: {path}",
+      fileWriteFailed: "Failed to write file: {path}",
+      directoryNotFound: "Directory not found: {path}",
+      invalidPath: "{path} is not a valid path",
+      operationCanceled: "Operation was canceled",
+      invalidParameter: "Invalid parameter: {parameter}"
+    },
+    progress: {
+      copying: "Copying files...",
+      building: "Building project...",
+      packaging: "Creating package...",
+      validating: "Validating...",
+      analyzing: "Analyzing...",
+      restoring: "Restoring dependencies..."
+    },
+    validation: {
+      requiredField: "{field} is required",
+      invalidValue: "Invalid value for {field}",
+      pathNotFound: "Path not found: {path}",
+      fileRequired: "File is required: {path}",
+      directoryRequired: "Directory is required: {path}"
+    },
+    warnings: {
+      factoryAlreadyRegistered: "A factory is already registered for project type '{type}'. Skipping duplicate registration."
+    },
+    info: {
+      operationComplete: "Operation completed successfully",
+      filesProcessed: {
+        zero: "No files processed",
+        one: "{count} file processed",
+        other: "{count} files processed"
+      }
+    }
+  }
+};
+var tr = {
+  toolCore: {
+    errors: {
+      internal: "Internal error: {message}",
+      fileNotFound: "File not found: {path}",
+      fileReadFailed: "Failed to read file: {path}",
+      fileWriteFailed: "Failed to write file: {path}",
+      directoryNotFound: "Directory not found: {path}",
+      invalidPath: "{path} is not a valid path",
+      operationCanceled: "Operation was canceled",
+      invalidParameter: "Invalid parameter: {parameter}"
+    },
+    progress: {
+      copying: "Copying files...",
+      building: "Building project...",
+      packaging: "Creating package...",
+      validating: "Validating...",
+      analyzing: "Analyzing...",
+      restoring: "Restoring dependencies..."
+    },
+    validation: {
+      requiredField: "{field} is required",
+      invalidValue: "Invalid value for {field}",
+      pathNotFound: "Path not found: {path}",
+      fileRequired: "File is required: {path}",
+      directoryRequired: "Directory is required: {path}"
+    },
+    warnings: {
+      factoryAlreadyRegistered: "A factory is already registered for project type '{type}'. Skipping duplicate registration."
+    },
+    info: {
+      operationComplete: "Operation completed successfully",
+      filesProcessed: {
+        zero: "No files processed",
+        one: "{count} file processed",
+        other: "{count} files processed"
+      }
+    }
+  }
+};
+var zh_CN = {
+  toolCore: {
+    errors: {
+      internal: "Internal error: {message}",
+      fileNotFound: "File not found: {path}",
+      fileReadFailed: "Failed to read file: {path}",
+      fileWriteFailed: "Failed to write file: {path}",
+      directoryNotFound: "Directory not found: {path}",
+      invalidPath: "{path} is not a valid path",
+      operationCanceled: "Operation was canceled",
+      invalidParameter: "Invalid parameter: {parameter}"
+    },
+    progress: {
+      copying: "Copying files...",
+      building: "Building project...",
+      packaging: "Creating package...",
+      validating: "Validating...",
+      analyzing: "Analyzing...",
+      restoring: "Restoring dependencies..."
+    },
+    validation: {
+      requiredField: "{field} is required",
+      invalidValue: "Invalid value for {field}",
+      pathNotFound: "Path not found: {path}",
+      fileRequired: "File is required: {path}",
+      directoryRequired: "Directory is required: {path}"
+    },
+    warnings: {
+      factoryAlreadyRegistered: "A factory is already registered for project type '{type}'. Skipping duplicate registration."
+    },
+    info: {
+      operationComplete: "Operation completed successfully",
+      filesProcessed: {
+        zero: "No files processed",
+        one: "{count} file processed",
+        other: "{count} files processed"
+      }
+    }
+  }
+};
+var zh_TW = {
+  toolCore: {
+    errors: {
+      internal: "Internal error: {message}",
+      fileNotFound: "File not found: {path}",
+      fileReadFailed: "Failed to read file: {path}",
+      fileWriteFailed: "Failed to write file: {path}",
+      directoryNotFound: "Directory not found: {path}",
+      invalidPath: "{path} is not a valid path",
+      operationCanceled: "Operation was canceled",
+      invalidParameter: "Invalid parameter: {parameter}"
+    },
+    progress: {
+      copying: "Copying files...",
+      building: "Building project...",
+      packaging: "Creating package...",
+      validating: "Validating...",
+      analyzing: "Analyzing...",
+      restoring: "Restoring dependencies..."
+    },
+    validation: {
+      requiredField: "{field} is required",
+      invalidValue: "Invalid value for {field}",
+      pathNotFound: "Path not found: {path}",
+      fileRequired: "File is required: {path}",
+      directoryRequired: "Directory is required: {path}"
+    },
+    warnings: {
+      factoryAlreadyRegistered: "A factory is already registered for project type '{type}'. Skipping duplicate registration."
+    },
+    info: {
+      operationComplete: "Operation completed successfully",
+      filesProcessed: {
+        zero: "No files processed",
+        one: "{count} file processed",
+        other: "{count} files processed"
+      }
+    }
+  }
+};
+var zu = {
+  toolCore: {
+    errors: {
+      internal: "Internal error: {message}",
+      fileNotFound: "File not found: {path}",
+      fileReadFailed: "Failed to read file: {path}",
+      fileWriteFailed: "Failed to write file: {path}",
+      directoryNotFound: "Directory not found: {path}",
+      invalidPath: "{path} is not a valid path",
+      operationCanceled: "Operation was canceled",
+      invalidParameter: "Invalid parameter: {parameter}"
+    },
+    progress: {
+      copying: "Copying files...",
+      building: "Building project...",
+      packaging: "Creating package...",
+      validating: "Validating...",
+      analyzing: "Analyzing...",
+      restoring: "Restoring dependencies..."
+    },
+    validation: {
+      requiredField: "{field} is required",
+      invalidValue: "Invalid value for {field}",
+      pathNotFound: "Path not found: {path}",
+      fileRequired: "File is required: {path}",
+      directoryRequired: "Directory is required: {path}"
+    },
+    warnings: {
+      factoryAlreadyRegistered: "A factory is already registered for project type '{type}'. Skipping duplicate registration."
+    },
+    info: {
+      operationComplete: "Operation completed successfully",
+      filesProcessed: {
+        zero: "No files processed",
+        one: "{count} file processed",
+        other: "{count} files processed"
+      }
+    }
+  }
+};
+
+class TranslationService {
+  static instance;
+  currentLocale = "en";
+  constructor() {}
+  static getInstance() {
+    if (!TranslationService.instance) {
+      TranslationService.instance = new TranslationService;
+    }
+    return TranslationService.instance;
+  }
+  setLocale(locale) {
+    this.currentLocale = I18nManager.setLocale(locale);
+  }
+  getLocale() {
+    return this.currentLocale;
+  }
+  t(key, params) {
+    return I18nManager.t(key, params, this.currentLocale);
+  }
+  tLocale(key, locale, params) {
+    return I18nManager.t(key, params, locale);
+  }
+  has(key) {
+    return I18nManager.has(key, this.currentLocale);
+  }
+  getAvailableLocales() {
+    return I18nManager.getAvailableLocales();
+  }
+}
+var translate = TranslationService.getInstance();
+I18nManager.registerTranslations("en", en);
+I18nManager.registerTranslations("de", de);
+I18nManager.registerTranslations("es", es);
+I18nManager.registerTranslations("es-mx", es_MX);
+I18nManager.registerTranslations("fr", fr);
+I18nManager.registerTranslations("ja", ja);
+I18nManager.registerTranslations("ko", ko);
+I18nManager.registerTranslations("pt", pt);
+I18nManager.registerTranslations("pt-br", pt_BR);
+I18nManager.registerTranslations("ro", ro);
+I18nManager.registerTranslations("ru", ru);
+I18nManager.registerTranslations("tr", tr);
+I18nManager.registerTranslations("zh-cn", zh_CN);
+I18nManager.registerTranslations("zh-tw", zh_TW);
+I18nManager.registerTranslations("zu", zu);
+I18nManager.setLocale("en");
+var BuildConfiguration;
+((BuildConfiguration2) => {
+  BuildConfiguration2["Debug"] = "Debug";
+  BuildConfiguration2["Release"] = "Release";
+})(BuildConfiguration ||= {});
+var LogLevel;
+((LogLevel2) => {
+  LogLevel2["Debug"] = "Debug";
+  LogLevel2["Info"] = "Information";
+  LogLevel2["Warn"] = "Warning";
+  LogLevel2["Error"] = "Error";
+})(LogLevel ||= {});
+var ProjectTypes;
+((ProjectTypes2) => {
+  ProjectTypes2["Agent"] = "Agent";
+  ProjectTypes2["Api"] = "Api";
+  ProjectTypes2["Connector"] = "Connector";
+  ProjectTypes2["CaseManagement"] = "CaseManagement";
+  ProjectTypes2["Flow"] = "Flow";
+  ProjectTypes2["Function"] = "Function";
+  ProjectTypes2["ProcessOrchestration"] = "ProcessOrchestration";
+  ProjectTypes2["Process"] = "Process";
+  ProjectTypes2["Library"] = "Library";
+  ProjectTypes2["WebApp"] = "WebApp";
+  ProjectTypes2["Tests"] = "Tests";
+  ProjectTypes2["AppV2"] = "AppV2";
+})(ProjectTypes ||= {});
+var TargetFramework;
+((TargetFramework2) => {
+  TargetFramework2["Portable"] = "Portable";
+  TargetFramework2["Windows"] = "Windows";
+})(TargetFramework ||= {});
+var ToolErrorCodes;
+((ToolErrorCodes2) => {
+  ToolErrorCodes2["Success"] = "SUCCESS";
+  ToolErrorCodes2["InternalError"] = "INTERNAL_ERROR";
+  ToolErrorCodes2["Canceled"] = "CANCELED";
+})(ToolErrorCodes ||= {});
+
+class ToolResult {
+  errorCode;
+  message;
+  packages;
+  constructor(errorCode, message, packages = []) {
+    this.errorCode = errorCode;
+    this.message = message;
+    this.packages = packages;
+  }
+  get isSuccess() {
+    return this.errorCode === "SUCCESS";
+  }
+  static success() {
+    return new ToolResult("SUCCESS");
+  }
+  static error(errorCode, message) {
+    return new ToolResult(errorCode, message);
+  }
+}
+class ProjectTool {
+  fileSystem;
+  logger;
+  static ProjectFileName = "project.uiproj";
+  constructor(fileSystem, logger) {
+    this.fileSystem = fileSystem;
+    this.logger = logger;
+  }
+  async restoreAsync(_options, _cancellationToken) {
+    this.logger.info("Restore operation is a noop");
+    return ToolResult.success();
+  }
+  async validateAsync(_options, _cancellationToken) {
+    this.logger.info("Validate operation is a noop");
+    return ToolResult.success();
+  }
+  async buildAsync(_options, _cancellationToken) {
+    this.logger.info("Build operation is a noop");
+    return ToolResult.success();
+  }
+  async packAsync(_options, _cancellationToken) {
+    this.logger.info("Pack operation is a noop");
+    return ToolResult.success();
+  }
+  async getUiProjectAsync(projectPath) {
+    const filePath = Path.join(projectPath, ProjectTool.ProjectFileName);
+    if (!await this.fileSystem.exists(filePath)) {
+      return;
+    }
+    const raw = await this.fileSystem.readFile(filePath);
+    if (!raw) {
+      return;
+    }
+    const json = typeof raw === "string" ? raw : new TextDecoder("utf-8").decode(raw);
+    return JSON.parse(json);
+  }
+  async dispose() {}
+}
+class ToolsFactoryRepository {
+  projectFactoryMap = new Map;
+  solutionFactory = null;
+  registerProjectToolFactory(factory) {
+    for (const type of factory.supportedTypes) {
+      if (this.projectFactoryMap.has(type)) {
+        console.warn(`Tool factory already registered for project type '${type}', skipping.`);
+        continue;
+      }
+      this.projectFactoryMap.set(type, factory);
+    }
+  }
+  registerSolutionToolFactory(factory) {
+    this.solutionFactory = factory;
+  }
+  getSolutionToolFactory() {
+    if (!this.solutionFactory) {
+      throw new Error("No solution tool factory is registered");
+    }
+    return this.solutionFactory;
+  }
+  canHandleProject(projectType) {
+    return this.projectFactoryMap.has(projectType);
+  }
+  getProjectToolFactory(projectType) {
+    const factory = this.projectFactoryMap.get(projectType);
+    if (!factory) {
+      throw new Error(`No tool factory found for project type '${projectType}'`);
+    }
+    return factory;
+  }
+  reset() {
+    this.projectFactoryMap.clear();
+    this.solutionFactory = null;
+  }
+}
+var REGISTRY_KEY = Symbol.for("@uipath/solutionpackager-tool-core/toolsFactoryRepository");
+var _global = globalThis;
+if (!_global[REGISTRY_KEY]) {
+  _global[REGISTRY_KEY] = new ToolsFactoryRepository;
+}
+var toolsFactoryRepository = _global[REGISTRY_KEY];
+
 // 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 = {
+var en2 = {
   toolWorkflowcompiler: {
     lifecycle: {
       started: "[WorkflowCompiler] {operation} started",
@@ -57,7 +1084,7 @@ var tr_namespaceObject = JSON.parse('{"toolWorkflowcompiler":{"lifecycle":{"star
 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("en", en2);
 I18nManager.registerTranslations("de", de_namespaceObject);
 I18nManager.registerTranslations("es", es_namespaceObject);
 I18nManager.registerTranslations("es-MX", es_MX_namespaceObject);

package/dist/tool.js

@@ -61025,7 +61025,7 @@ var {
 // package.json
 var package_default = {
   name: "@uipath/rpa-tool",
-  version: "0.9.3",
+  version: "0.9.4",
   description: "Tool for creating and managing UiPath RPA projects",
   keywords: [
     "uipcli-tool",
@@ -61058,7 +61058,7 @@ var package_default = {
     registry: "https://npm.pkg.github.com"
   },
   scripts: {
-    build: "bunx tsc --noEmit && bun build ./src/packager-tool.ts --outdir dist --format esm --target node --external @uipath/solutionpackager-tool-core && bun build ./src/tool.ts --outdir dist --format esm --target node --external '*/packager-tool.js' --external applicationinsights && bun build ./src/index.ts --outdir dist --format esm --target node --external '*/tool.js' --external applicationinsights",
+    build: "bunx tsc --noEmit && bun build ./src/packager-tool.ts --outdir dist --format esm --target node && bun build ./src/tool.ts --outdir dist --format esm --target node --external '*/packager-tool.js' --external applicationinsights && bun build ./src/index.ts --outdir dist --format esm --target node --external '*/tool.js' --external applicationinsights",
     package: "bun run build && bun pm pack",
     "generate-docs": "bun run scripts/generate-docs.ts",
     "bump-uipath-alpha": "bun run scripts/bump-uipath-alpha.ts",
@@ -61894,7 +61894,7 @@ class WorkflowCompilerToolFactory {
 toolsFactoryRepository.registerProjectToolFactory(new WorkflowCompilerToolFactory);
 
 // src/resolution/helm-config.ts
-var DEFAULT_HELM_VERSION = "0.9.3";
+var DEFAULT_HELM_VERSION = "0.9.4";
 var helmConfig = {
   helmVersion: DEFAULT_HELM_VERSION
 };
@@ -64366,9 +64366,17 @@ function writeCache(path4, entry, deps) {
 
 // src/external-cli/forward.ts
 import { spawn as spawn5 } from "node:child_process";
-function spawnForward(exePath, args) {
+function mergeEnv(extra) {
+  if (!extra)
+    return;
+  return { ...process.env, ...extra };
+}
+function spawnForward(exePath, args, env) {
   return new Promise((resolve5, reject) => {
-    const child = spawn5(exePath, args, { stdio: "inherit" });
+    const child = spawn5(exePath, args, {
+      stdio: "inherit",
+      env: mergeEnv(env)
+    });
     child.on("error", (err2) => {
       reject(new Error(`Failed to spawn '${exePath}': ${err2.message}`));
     });
@@ -64377,10 +64385,11 @@ function spawnForward(exePath, args) {
     });
   });
 }
-function spawnCapture(exePath, args) {
+function spawnCapture(exePath, args, env) {
   return new Promise((resolve5, reject) => {
     const child = spawn5(exePath, args, {
-      stdio: ["inherit", "pipe", "pipe"]
+      stdio: ["inherit", "pipe", "pipe"],
+      env: mergeEnv(env)
     });
     const stdoutChunks = [];
     const stderrChunks = [];
@@ -64410,6 +64419,37 @@ var defaultDeps3 = {
   fileExists: existsSync9,
   readFile: (path4) => readFileSync4(path4, "utf-8")
 };
+function getCurrentPlatformKey() {
+  let osSegment;
+  switch (process.platform) {
+    case "win32":
+      osSegment = "win";
+      break;
+    case "darwin":
+      osSegment = "osx";
+      break;
+    case "linux":
+      osSegment = "linux";
+      break;
+    default:
+      osSegment = process.platform;
+  }
+  return `${osSegment}-${process.arch}`;
+}
+function resolveExecutableRelativePath(manifest, manifestPath, platformKey) {
+  const { executable, executables } = manifest.tool;
+  if (executables) {
+    const match = executables[platformKey];
+    if (!match) {
+      const supported = Object.keys(executables).sort().join(", ");
+      throw new Error(`No executable declared for platform '${platformKey}' in ${manifestPath}. ` + `Supported platforms: ${supported || "(none)"}.`);
+    }
+    return match;
+  }
+  if (executable)
+    return executable;
+  throw new Error(`Manifest ${manifestPath} declares neither 'tool.executable' nor 'tool.executables'.`);
+}
 function readCliManifest(packageRoot, deps = defaultDeps3) {
   const manifestPath = join14(packageRoot, MANIFEST_FILENAME);
   if (!deps.fileExists(manifestPath)) {
@@ -64424,7 +64464,9 @@ function readCliManifest(packageRoot, deps = defaultDeps3) {
   if (manifest.manifestVersion !== 1) {
     throw new Error(`Unsupported manifest version ${manifest.manifestVersion} in ${manifestPath}. Expected 1.`);
   }
-  const exePath = join14(packageRoot, manifest.tool.executable);
+  const platformKey = (deps.getPlatformKey ?? getCurrentPlatformKey)();
+  const relExe = resolveExecutableRelativePath(manifest, manifestPath, platformKey);
+  const exePath = join14(packageRoot, relExe);
   if (!deps.fileExists(exePath)) {
     throw new Error(`Executable not found at ${exePath} as declared in ${manifestPath}.`);
   }
@@ -64432,8 +64474,8 @@ function readCliManifest(packageRoot, deps = defaultDeps3) {
 }
 
 // src/external-cli/register-cli-commands.ts
-function registerExternalCliCommands(program3, projectDir, config2, deps, session, defaultFormat) {
-  const resolvedDeps = resolveDeps(projectDir, config2, deps, session);
+function registerExternalCliCommands(program3, projectDir, config2, deps, session, defaultFormat, runtime) {
+  const resolvedDeps = resolveDeps(projectDir, config2, deps, session, runtime);
   const group = program3.command(config2.commandName).description(config2.description);
   let exePath;
   let manifest;
@@ -64506,17 +64548,18 @@ function registerCommand(parent, exePath, projectDir, cmd, config2, deps, comman
       throw new Error(`Command '${currentPath.join(" ")}' does not support --format.`);
     }
     const run = async () => {
+      const env = deps.resolveEnv?.();
       if (supportsFormat) {
         const { format: _stripped, ...forwardOpts } = opts;
         const args = buildArgs(currentPath, positionalValues, forwardOpts, cmd, config2, effectiveProjectDir, "json");
-        const result = await deps.spawnCapture(exePath, args);
+        const result = await deps.spawnCapture(exePath, args, env);
         renderCapturedOutput(result);
         if (result.exitCode !== 0) {
           processContext.exit(result.exitCode);
         }
       } else {
         const args = buildArgs(currentPath, positionalValues, opts, cmd, config2, effectiveProjectDir);
-        const exitCode = await deps.spawnForward(exePath, args);
+        const exitCode = await deps.spawnForward(exePath, args, env);
         if (exitCode !== 0) {
           processContext.exit(exitCode);
         }
@@ -64644,7 +64687,7 @@ function renderCapturedOutput(captured) {
     OutputFormatter.error(new FailureOutput(envelope.Result || "Failure", envelope.Message ?? "Unknown error from external CLI", envelope.Instructions ?? "Check external CLI logs for details."));
   }
 }
-function resolveDeps(_projectDir, config2, partial2, session) {
+function resolveDeps(_projectDir, config2, partial2, session, runtime) {
   return {
     discover: partial2?.discover ?? ((dir) => {
       const packageRoot = discoverPackageRootCached({
@@ -64658,7 +64701,23 @@ function resolveDeps(_projectDir, config2, partial2, session) {
     spawnCapture: partial2?.spawnCapture ?? spawnCapture,
     openProject: partial2?.openProject ?? (session ? (dir, operation) => session.execute(async () => {
       await operation();
-    }, { projectDir: dir, backend: "helm" /* Helm */ }) : undefined)
+    }, { projectDir: dir, backend: "helm" /* Helm */ }) : undefined),
+    resolveEnv: partial2?.resolveEnv ?? buildBundledDotnetEnvResolver(runtime)
+  };
+}
+function buildBundledDotnetEnvResolver(runtime) {
+  const resolverDeps = runtime?.resolverDeps;
+  if (!resolverDeps)
+    return;
+  let cached3;
+  let resolved = false;
+  return () => {
+    if (!resolved) {
+      const robotDir = resolveRobotDir(runtime?.robotDir, resolverDeps);
+      cached3 = resolveBundledDotnet(robotDir, resolverDeps)?.env;
+      resolved = true;
+    }
+    return cached3;
   };
 }
 
@@ -67087,7 +67146,8 @@ var registerCommands = async (program3, options) => {
   registerAnalyzeCommand(program3);
   registerBuildCommand(program3);
   registerPackCommand(program3);
-  const session = createSession(resolved);
+  const resolverDeps = buildResolverDeps(resolved);
+  const session = createSession(resolved, resolverDeps);
   const format = extractArg(process.argv, "format");
   registerExternalCliCommands(program3, resolved.projectDir, {
     commandName: "uia",
@@ -67096,7 +67156,7 @@ var registerCommands = async (program3, options) => {
     minVersion: "26.4.1-preview",
     injectProjectDir: "project-dir",
     injectFormat: "format"
-  }, undefined, session, format);
+  }, undefined, session, format, { resolverDeps, robotDir: resolved.robotDir });
   const toolProvider = resolveToolProvider(resolved, session);
   await registerMcpCommands(program3, toolProvider);
   const parentOptionDefs = [
@@ -67125,13 +67185,16 @@ Run 'start-studio' to start a Studio instance — ` + "additional commands may b
     process.exit(1);
   });
 };
-function createSession(options) {
-  if (!options)
-    return;
-  const deps = options.verbose ? {
+function buildResolverDeps(options) {
+  return options.verbose ? {
     ...defaultResolverDeps,
     log: (msg) => console.debug(`[rpa-tool] ${msg}`)
   } : defaultResolverDeps;
+}
+function createSession(options, deps) {
+  if (!options)
+    return;
+  const resolverDeps = deps ?? buildResolverDeps(options);
   const timeoutMs = options.timeoutSeconds != null ? options.timeoutSeconds * 1000 : undefined;
   return new StudioSession({
     projectDir: options.projectDir,
@@ -67140,7 +67203,7 @@ function createSession(options) {
     useStudio: options.useStudio,
     hostStudioPid: options.hostStudioPid,
     timeoutMs
-  }, deps);
+  }, resolverDeps);
 }
 function resolveToolProvider(options, session) {
   const localTools = new LocalToolProvider;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uipath/rpa-tool",
-  "version": "0.9.3",
+  "version": "0.9.4",
   "description": "Tool for creating and managing UiPath RPA projects",
   "keywords": [
     "uipcli-tool",
@@ -33,7 +33,7 @@
     "registry": "https://npm.pkg.github.com"
   },
   "scripts": {
-    "build": "bunx tsc --noEmit && bun build ./src/packager-tool.ts --outdir dist --format esm --target node --external @uipath/solutionpackager-tool-core && bun build ./src/tool.ts --outdir dist --format esm --target node --external '*/packager-tool.js' --external applicationinsights && bun build ./src/index.ts --outdir dist --format esm --target node --external '*/tool.js' --external applicationinsights",
+    "build": "bunx tsc --noEmit && bun build ./src/packager-tool.ts --outdir dist --format esm --target node && bun build ./src/tool.ts --outdir dist --format esm --target node --external '*/packager-tool.js' --external applicationinsights && bun build ./src/index.ts --outdir dist --format esm --target node --external '*/tool.js' --external applicationinsights",
     "package": "bun run build && bun pm pack",
     "generate-docs": "bun run scripts/generate-docs.ts",
     "bump-uipath-alpha": "bun run scripts/bump-uipath-alpha.ts",