@uipath/solution-tool 1.203.0-preview.205 → 1.204.0-preview.206

package/dist/packager-tool-zns6n8zp.js

@@ -0,0 +1,837 @@
+import {
+  NugetConstants,
+  NugetPackager,
+  Path,
+  ProjectTool,
+  SolutionTool,
+  TemporaryStorageService,
+  ToolResult,
+  ensureProjectId,
+  toolsFactoryRepository,
+  writeOrBackfillOperateProjectId
+} from "./packager-tool-fv7xyzg2.js";
+
+// ../packager/packager-tool-connector/src/connector-tool.ts
+class ConnectorTool extends ProjectTool {
+  static AppFolderName = "app";
+  _temporaryStorage;
+  constructor(fileSystem, logger) {
+    super(fileSystem, logger);
+    this._temporaryStorage = new TemporaryStorageService(fileSystem);
+  }
+  async restoreAsync(_options, _cancellationToken) {
+    this.logger.info("Restore operation is not required for Connector projects");
+    return ToolResult.success();
+  }
+  async validateAsync(_options, _cancellationToken) {
+    this.logger.info("Validate operation is not required for Connector projects");
+    return ToolResult.success();
+  }
+  async buildAsync(options, _cancellationToken) {
+    const tempFolder = await this._temporaryStorage.getTempFolderPath();
+    const localBuildFolder = Path.join(tempFolder, NugetConstants.OutputFolderName);
+    const appProjectFolder = Path.join(options.projectPath, ConnectorTool.AppFolderName);
+    const destinationFolder = Path.join(localBuildFolder, NugetConstants.ContentFolderName, ConnectorTool.AppFolderName);
+    try {
+      this.logger.progress("Copying app folder...");
+      await this.copyDirectory(appProjectFolder, destinationFolder);
+      this.logger.progress("Creating operate.json file...");
+      await this.createOperateFile(options, localBuildFolder);
+      this.logger.progress("Creating package-descriptor.json file...");
+      await this.createPackageDescriptor(localBuildFolder);
+      return new ToolResult("SUCCESS" /* Success */, "done", [
+        localBuildFolder
+      ]);
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.toString() : String(error);
+      this.logger.error(errorMessage);
+      return ToolResult.error("INTERNAL_ERROR" /* InternalError */, "An error occurred while building Connector project");
+    }
+  }
+  async packAsync(options, cancellationToken) {
+    const buildResult = await this.buildAsync(options, cancellationToken);
+    if (!buildResult.isSuccess) {
+      return buildResult;
+    }
+    const localBuildFolder = buildResult.packages[0];
+    try {
+      this.logger.progress("Creating NuGet package...");
+      const nupkgFileName = `${options.package.id}.${options.package.version}.nupkg`;
+      const nupkgPath = Path.join(options.outputPath, nupkgFileName);
+      const packager = new NugetPackager(this.fileSystem);
+      const result = await packager.packAsync(localBuildFolder, options.package, nupkgPath);
+      this.logger.progress("Package created successfully");
+      return new ToolResult("SUCCESS" /* Success */, "done", [
+        result.outputPath
+      ]);
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.toString() : String(error);
+      this.logger.error(errorMessage);
+      return ToolResult.error("INTERNAL_ERROR" /* InternalError */, "An error occurred while packing Connector project");
+    }
+  }
+  async dispose() {
+    this.logger.info("Disposing Connector Tool");
+    try {
+      await this._temporaryStorage.cleanup();
+    } catch {}
+  }
+  async createOperateFile(options, localBuildFolder) {
+    const contentFolder = Path.join(localBuildFolder, NugetConstants.ContentFolderName);
+    const operateJsonFilePath = Path.join(contentFolder, NugetConstants.OperateFileName);
+    const projectId = options.projectStorageId ?? await this.resolveConnectorProjectId(options.projectPath);
+    await writeOrBackfillOperateProjectId(operateJsonFilePath, projectId, this.fileSystem, () => this.fileSystem.writeFile(operateJsonFilePath, JSON.stringify({
+      $schema: "https://cloud.uipath.com/draft/2024-12/operate",
+      contentType: "Connector" /* Connector */,
+      projectId,
+      main: "",
+      targetFramework: "Portable",
+      runtimeOptions: {
+        isAttended: false,
+        requiresUserInteraction: false
+      }
+    }, null, 2)));
+  }
+  async resolveConnectorProjectId(projectPath) {
+    const operatePath = Path.join(projectPath, "operate.json");
+    const projectFilePath = Path.join(projectPath, "project.json");
+    const hasAnchor = await this.fileSystem.exists(operatePath) || await this.fileSystem.exists(projectFilePath);
+    if (hasAnchor) {
+      return ensureProjectId(projectPath, this.fileSystem);
+    }
+    const id = crypto.randomUUID();
+    await this.fileSystem.writeFile(projectFilePath, `${JSON.stringify({ projectId: id }, null, 2)}
+`);
+    return id;
+  }
+  async createPackageDescriptor(localBuildFolder) {
+    const packageDescriptorPath = Path.join(localBuildFolder, NugetConstants.ContentFolderName, NugetConstants.PackageDescriptorFileName);
+    const exists = await this.fileSystem.exists(packageDescriptorPath);
+    if (exists) {
+      return;
+    }
+    const descriptor = {
+      $schema: "https://cloud.uipath.com/draft/2024-12/package-descriptor",
+      files: {
+        [NugetConstants.OperateFileName]: Path.join(NugetConstants.ContentFolderName, NugetConstants.OperateFileName)
+      }
+    };
+    await this.fileSystem.writeFile(packageDescriptorPath, JSON.stringify(descriptor, null, 2));
+  }
+  async copyDirectory(sourcePath, destinationPath) {
+    await this.fileSystem.mkdir(destinationPath);
+    const entries = await this.fileSystem.readdir(sourcePath);
+    for (const entry of entries) {
+      const sourceEntry = Path.join(sourcePath, entry);
+      const destinationEntry = Path.join(destinationPath, entry);
+      const stat = await this.fileSystem.stat(sourceEntry);
+      if (stat?.isDirectory()) {
+        await this.copyDirectory(sourceEntry, destinationEntry);
+      } else if (stat?.isFile()) {
+        const content = await this.fileSystem.readFile(sourceEntry);
+        if (content) {
+          await this.fileSystem.writeFile(destinationEntry, content);
+        }
+      }
+    }
+  }
+}
+
+// ../packager/packager-tool-connector/src/connector-tool-factory.ts
+class ConnectorToolFactory {
+  supportedTypes = ["Connector" /* Connector */];
+  async createAsync(logger, fileSystem) {
+    return new ConnectorTool(fileSystem, logger);
+  }
+}
+// ../../node_modules/@uipath/resource-builder-tool/dist/index.js
+function _define_property(obj, key, value) {
+  if (key in obj)
+    Object.defineProperty(obj, key, {
+      value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  else
+    obj[key] = value;
+  return obj;
+}
+var KNOWN_ARCHIVE_FILE_NAMES = {
+  packageInfoJsonFileName: "packageInfo.json",
+  metadataJsonFileName: "solutionMetadata.json"
+};
+var KNOWN_ARCHIVE_FOLDERS = {
+  files: "files",
+  resources: "resources"
+};
+var PACKAGE_DEFAULTS = {
+  currentVersion: "v1",
+  defaultPackageVersion: "1.0.0",
+  defaultAuthorName: "UiPath",
+  unifiedBuildPackageType: "unified",
+  currentDocVersion: "1.0.0",
+  rootFolderName: "solution_folder"
+};
+var JWT_CLAIMS = {
+  firstName: "first_name",
+  lastName: "last_name",
+  email: "email",
+  userId: "sub",
+  partition: "prt_id"
+};
+var RESILIENCE_DEFAULTS = {
+  maxRetryAttempts: 3,
+  retryIntervalMs: 1000,
+  maxRedirectRetries: 10
+};
+var MAX_DOWNLOAD_CONCURRENCY = 8;
+var RETRIABLE_STATUS_CODES = [
+  500,
+  502,
+  503,
+  504
+];
+var INVALID_FILE_NAME_CHARS = /[<>:"/\\|?*\x00-\x1f\s]/g;
+var MAX_SERVER_MESSAGE_LENGTH = 100;
+var MAX_BUILD_OUTPUT_SIZE_BYTES = 524288000;
+
+class OperationCancelledException extends Error {
+  constructor(message) {
+    super(message ?? "The operation was cancelled");
+    this.name = "OperationCancelledException";
+    if (Error.captureStackTrace)
+      Error.captureStackTrace(this, OperationCancelledException);
+  }
+}
+function mapHttpStatusCodeToReason(status) {
+  switch (status) {
+    case 404:
+      return "NotFound";
+    case 401:
+      return "Unauthorized";
+    case 403:
+      return "Forbidden";
+    case 400:
+      return "BadRequest";
+    case 408:
+    case 504:
+      return "Timeout";
+    default:
+      if (status >= 500)
+        return "ServerError";
+      return "Unknown";
+  }
+}
+function truncateMessage(message, maxLength) {
+  if (!message)
+    return message;
+  if (message.length <= maxLength)
+    return message;
+  return message.substring(0, maxLength) + "...";
+}
+function buildFailureMessage(failures) {
+  const lines = [
+    `Failed to download ${failures.length} file(s):`
+  ];
+  for (const failure of failures)
+    lines.push(`  - FileKey: ${failure.fileKey}, Service: ${failure.service}, Url: ${failure.externalUrl}, Reason: ${failure.reason}, Message: ${failure.errorMessage ?? ""}`);
+  return lines.join(`
+`);
+}
+function isArtefactResource(resource) {
+  return resource.projectKey != null && resource.projectKey.trim() !== "";
+}
+var JSON_INDENT = 2;
+function shouldExcludeValue(value) {
+  return value == null;
+}
+function serializeJson(obj) {
+  return JSON.stringify(obj, (_key, value) => shouldExcludeValue(value) ? undefined : value, JSON_INDENT);
+}
+function decodeJwtPayload(token) {
+  try {
+    const parts = token.split(".");
+    if (parts.length !== 3)
+      return null;
+    const payload = parts[1];
+    const base64 = payload.replace(/-/g, "+").replace(/_/g, "/");
+    const padded = base64 + "=".repeat((4 - base64.length % 4) % 4);
+    const decoded = atob(padded);
+    return JSON.parse(decoded);
+  } catch {
+    return null;
+  }
+}
+function extractDataFromAccessToken(accessToken) {
+  if (!accessToken)
+    return {};
+  const payload = decodeJwtPayload(accessToken);
+  if (!payload)
+    return {};
+  const getString = (key) => {
+    const value = payload[key];
+    return typeof value == "string" && value.trim() !== "" ? value : undefined;
+  };
+  return {
+    email: getString(JWT_CLAIMS.email),
+    firstName: getString(JWT_CLAIMS.firstName),
+    lastName: getString(JWT_CLAIMS.lastName),
+    userId: getString(JWT_CLAIMS.userId),
+    partitionId: getString(JWT_CLAIMS.partition)
+  };
+}
+function isRetriableStatusCode(status) {
+  return RETRIABLE_STATUS_CODES.includes(status);
+}
+function isRedirectStatusCode(status) {
+  return status === 302 || status === 303;
+}
+function isClientError(status) {
+  return status >= 400 && status < 500;
+}
+function delay(ms, cancellationToken) {
+  return new Promise((resolve, reject) => {
+    if (cancellationToken?.aborted)
+      return void reject(new OperationCancelledException);
+    const timeoutId = setTimeout(resolve, ms);
+    cancellationToken?.addEventListener("abort", () => {
+      clearTimeout(timeoutId);
+      reject(new OperationCancelledException);
+    }, {
+      once: true
+    });
+  });
+}
+function throwIfCancelled(cancellationToken) {
+  if (cancellationToken?.aborted)
+    throw new OperationCancelledException;
+}
+
+class Semaphore {
+  async acquire() {
+    if (this.permits > 0)
+      return void this.permits--;
+    return new Promise((resolve) => {
+      this.waitQueue.push(resolve);
+    });
+  }
+  release() {
+    const next = this.waitQueue.shift();
+    if (next)
+      next();
+    else
+      this.permits++;
+  }
+  constructor(permits) {
+    _define_property(this, "permits", undefined);
+    _define_property(this, "waitQueue", []);
+    this.permits = permits;
+  }
+}
+
+class ResourceBuilderTool extends SolutionTool {
+  async buildAsync(options, cancellationToken) {
+    this.logger.info("Build starting.");
+    this.inputPath = Path.dirname(options.solutionFilePath);
+    try {
+      throwIfCancelled(cancellationToken);
+      const accessToken = options.connection?.accessToken;
+      const tokenData = extractDataFromAccessToken(accessToken);
+      const existingResources = await this.readFromDirectory(KNOWN_ARCHIVE_FOLDERS.resources, cancellationToken);
+      this.logger.info(`Read ${existingResources.length} existing resources from ${KNOWN_ARCHIVE_FOLDERS.resources} directory.`);
+      if (existingResources && existingResources.length > 0) {
+        throwIfCancelled(cancellationToken);
+        const filteredResources = this.filterResources(existingResources, options);
+        await this.writeResources(filteredResources, options, cancellationToken);
+      } else
+        throw new Error("No resources found to build.");
+      await this.writePackageFiles(options, tokenData, cancellationToken);
+      const sizeLimitError = await this.enforceOutputSizeLimit(options.outputPath);
+      if (sizeLimitError)
+        return sizeLimitError;
+      this.logger.info("Build finished.");
+      return ToolResult.success();
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      this.logger.error(`Build failed: ${message}`);
+      return ToolResult.error("INTERNAL_ERROR" /* InternalError */, `Build failed: ${message}`);
+    }
+  }
+  async enforceOutputSizeLimit(outputPath) {
+    const filesDirectory = Path.join(outputPath, KNOWN_ARCHIVE_FOLDERS.files);
+    if (!await this.fileSystem.exists(filesDirectory))
+      return null;
+    const totalBytes = await this.getTotalDirectorySize(filesDirectory);
+    if (totalBytes <= MAX_BUILD_OUTPUT_SIZE_BYTES)
+      return null;
+    const maxMb = Math.floor(MAX_BUILD_OUTPUT_SIZE_BYTES / 1024 / 1024);
+    const currentMb = Math.floor(totalBytes / 1024 / 1024);
+    const message = `The built solution exceeds the maximum allowed size of ${maxMb} MB (current size: ${currentMb} MB). Solutions larger than this cannot be uploaded. Reduce the size by removing unused packages, splitting the solution into smaller solutions, or trimming large binary assets.`;
+    this.logger.error(`Built solution size ${currentMb} MB exceeds maximum allowed ${maxMb} MB.`);
+    return ToolResult.error("INTERNAL_ERROR" /* InternalError */, message);
+  }
+  async getTotalDirectorySize(dirPath) {
+    let total = 0;
+    const stack = [
+      dirPath
+    ];
+    let current = stack.pop();
+    while (current !== undefined) {
+      const entries = await this.fileSystem.readdir(current);
+      for (const entry of entries) {
+        const fullPath = Path.join(current, entry);
+        const stats = await this.fileSystem.stat(fullPath);
+        if (stats) {
+          if (stats.isDirectory())
+            stack.push(fullPath);
+          else if (stats.isFile())
+            total += stats.size;
+        }
+      }
+      current = stack.pop();
+    }
+    return total;
+  }
+  async restoreAsync(options, cancellationToken) {
+    this.logger.info("Restore starting.");
+    this.inputPath = Path.dirname(options.solutionFilePath);
+    try {
+      throwIfCancelled(cancellationToken);
+      const existingResources = await this.readFromDirectory(KNOWN_ARCHIVE_FOLDERS.resources, cancellationToken);
+      this.logger.info(`Read ${existingResources.length} existing resources from ${KNOWN_ARCHIVE_FOLDERS.resources} directory.`);
+      if (existingResources.length === 0) {
+        this.logger.error("Solution definition empty or not found.");
+        return ToolResult.error("INTERNAL_ERROR" /* InternalError */, "Solution definition empty or not found.");
+      }
+      const filteredResources = this.filterResources(existingResources, {
+        configuration: options.configuration,
+        projectsToBuild: options.projectsToBuild
+      });
+      const files = this.extractFilesFromResources(filteredResources);
+      const filesToDownload = files.filter((f) => f.url != null);
+      if (filesToDownload.length === 0) {
+        this.logger.info("No files to download.");
+        this.logger.info("Restore finished.");
+        return ToolResult.success();
+      }
+      const outputPath = options.outputPath ?? "";
+      const downloadTasks = [];
+      const semaphore = new Semaphore(MAX_DOWNLOAD_CONCURRENCY);
+      for (const file of filesToDownload) {
+        throwIfCancelled(cancellationToken);
+        this.logger.info(`Downloading file ${file.name} kind ${file.kind} from service url ${file.url}...`);
+        const resource = this.findResourceForFile(filteredResources, file);
+        if (!resource) {
+          this.logger.warn(`File with name '${file.name}', kind '${file.kind}', key '${file.key}' not referenced by any resource.`);
+          continue;
+        }
+        const filePath = Path.join(outputPath, KNOWN_ARCHIVE_FOLDERS.files, file.key, file.name);
+        if (await this.fileSystem.exists(filePath)) {
+          this.logger.info(`File ${file.name} already exists at ${filePath}, skipping download.`);
+          continue;
+        }
+        const dirPath = Path.dirname(filePath);
+        await this.fileSystem.mkdir(dirPath);
+        const serviceName = resource.apiVersion ?? "unknown";
+        downloadTasks.push(this.downloadFileWithSemaphore(semaphore, file, filePath, serviceName, options, cancellationToken));
+      }
+      if (downloadTasks.length === 0) {
+        this.logger.info("No files to download.");
+        this.logger.info("Restore finished.");
+        return ToolResult.success();
+      }
+      const results = await Promise.all(downloadTasks);
+      const failures = results.filter((r) => !r.isSuccess && r.failure != null).map((r) => r.failure);
+      if (failures.length > 0) {
+        for (const failure of failures)
+          this.logger.error(`Download failed for file ${failure.fileKey} from service ${failure.service} at ${failure.externalUrl}. Reason: ${failure.reason}. ${failure.errorMessage ?? ""}`);
+        const message = buildFailureMessage(failures);
+        this.logger.error(message);
+        return ToolResult.error("INTERNAL_ERROR" /* InternalError */, message);
+      }
+      this.logger.info("Restore finished.");
+      return ToolResult.success();
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      this.logger.error(`Restore failed: ${message}`);
+      return ToolResult.error("INTERNAL_ERROR" /* InternalError */, `Restore failed: ${message}`);
+    }
+  }
+  async validateAsync(options, cancellationToken) {
+    this.logger.info("Validate starting.");
+    if (options.solutionFilePath === undefined)
+      throw new Error("Solution file path is undefined.");
+    this.inputPath = Path.dirname(options.solutionFilePath);
+    try {
+      throwIfCancelled(cancellationToken);
+      const packageVersion = options.packageVersion;
+      if (packageVersion !== undefined && !this.isValidSemanticVersion(packageVersion)) {
+        this.logger.error(`Invalid package version ${packageVersion}`);
+        return ToolResult.error("VALIDATION_ERROR", `Invalid package version: ${packageVersion}`);
+      }
+      this.logger.info("Validate finished.");
+      return ToolResult.success();
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      this.logger.error(`Validation failed: ${message}`);
+      return ToolResult.error("INTERNAL_ERROR" /* InternalError */, `Validation failed: ${message}`);
+    }
+  }
+  async readFromDirectory(folderName, cancellationToken) {
+    const basePath = this.inputPath;
+    const folderPath = folderName ? Path.join(basePath, folderName) : basePath;
+    const resources = [];
+    if (!await this.fileSystem.exists(folderPath))
+      return resources;
+    throwIfCancelled(cancellationToken);
+    const allFiles = await this.readFilesRecursively(folderPath, cancellationToken);
+    const jsonFiles = allFiles.filter((f) => f.endsWith(".json"));
+    this.logger.info(`Found ${jsonFiles.length} resource JSON files in ${folderName ?? basePath} directory.`);
+    const failedFiles = [];
+    for (const fileRelativeToFolder of jsonFiles) {
+      throwIfCancelled(cancellationToken);
+      const normalizedFileRelative = fileRelativeToFolder.replace(/\\/g, "/");
+      const relativeToBasePath = folderName ? `${folderName}/${normalizedFileRelative}` : normalizedFileRelative;
+      try {
+        const fullFilePath = Path.join(basePath, relativeToBasePath);
+        const content = await this.fileSystem.readFile(fullFilePath);
+        if (!content) {
+          this.logger.warn(`Failed to read resource file: ${relativeToBasePath}`);
+          continue;
+        }
+        const jsonContent = new TextDecoder().decode(content);
+        const wrapper = JSON.parse(jsonContent);
+        if (wrapper?.resource) {
+          const rd = wrapper.resource;
+          const normalizedPath = fileRelativeToFolder.replace(/\\/g, "/");
+          const segments = normalizedPath.split("/").filter((s) => s.length > 0);
+          if (segments.length >= 2) {
+            const hasType = rd.type != null && rd.type.trim() !== "";
+            const folderSegmentCount = hasType ? segments.length - 3 : segments.length - 2;
+            if (folderSegmentCount < 1)
+              rd.folders = [
+                {
+                  fullyQualifiedName: PACKAGE_DEFAULTS.rootFolderName
+                }
+              ];
+            else {
+              const segmentsToUse = segments.slice(0, folderSegmentCount);
+              const folderFqn = segmentsToUse.join("/");
+              rd.folders = [
+                {
+                  fullyQualifiedName: folderFqn
+                }
+              ];
+            }
+          } else
+            rd.folders = [
+              {
+                fullyQualifiedName: PACKAGE_DEFAULTS.rootFolderName
+              }
+            ];
+          resources.push(rd);
+          this.logger.info(`Read resource: ${rd.name} kind: ${rd.kind} from ${relativeToBasePath}`);
+        }
+      } catch (ex) {
+        const message = ex instanceof Error ? ex.message : String(ex);
+        this.logger.error(`Failed to read resource file ${relativeToBasePath}: ${message}`);
+        failedFiles.push(relativeToBasePath);
+      }
+    }
+    if (failedFiles.length > 0)
+      throw new Error(`Failed to read resource files: ${failedFiles.join(", ")}`);
+    return resources;
+  }
+  async readFilesRecursively(basePath, cancellationToken) {
+    const results = [];
+    const processDirectory = async (currentPath, relativePath) => {
+      throwIfCancelled(cancellationToken);
+      const entries = await this.fileSystem.readdir(currentPath);
+      for (const entry of entries) {
+        const fullPath = Path.join(currentPath, entry);
+        const relPath = relativePath ? `${relativePath}/${entry}` : entry;
+        const stats = await this.fileSystem.stat(fullPath);
+        if (stats?.isDirectory())
+          await processDirectory(fullPath, relPath);
+        else if (stats?.isFile())
+          results.push(relPath);
+      }
+    };
+    await processDirectory(basePath, "");
+    return results;
+  }
+  filterResources(resources, options) {
+    const { projectsToBuild, configuration } = options;
+    if (!resources)
+      return [];
+    if (configuration !== "Debug" /* Debug */)
+      return resources;
+    if (!projectsToBuild || projectsToBuild.length === 0)
+      return resources;
+    const projectsToBuildSet = new Set(projectsToBuild);
+    return resources.filter((resource) => {
+      if (!isArtefactResource(resource))
+        return true;
+      const projectKey = resource.projectKey;
+      if (!projectKey || !projectsToBuildSet.has(projectKey)) {
+        this.logger.info(`Artefact resource skipped: ${resource.key}`);
+        return false;
+      }
+      return true;
+    });
+  }
+  async writeResources(resources, options, cancellationToken) {
+    for (const resource of resources) {
+      throwIfCancelled(cancellationToken);
+      const resourcePath = this.buildResourceRelativePath(resource);
+      const fullPath = Path.join(options.outputPath, resourcePath);
+      const dirPath = Path.dirname(fullPath);
+      await this.fileSystem.mkdir(dirPath);
+      const wrapper = {
+        docVersion: PACKAGE_DEFAULTS.currentDocVersion,
+        resource
+      };
+      await this.fileSystem.writeFile(fullPath, serializeJson(wrapper));
+      this.logger.info(`Writing resource file for resource ${resource.key}`);
+    }
+  }
+  buildResourceRelativePath(resource) {
+    const safeName = this.sanitizeFileName(resource.name);
+    const folderFqn = resource.folders[0]?.fullyQualifiedName ?? "";
+    const parts = [
+      KNOWN_ARCHIVE_FOLDERS.resources
+    ];
+    const folderSegments = folderFqn.split("/").filter((s) => s.length > 0);
+    if (folderSegments.length > 0)
+      parts.push(...folderSegments);
+    else
+      parts.push(PACKAGE_DEFAULTS.rootFolderName);
+    parts.push(resource.kind);
+    if (resource.type && resource.type.trim())
+      parts.push(resource.type);
+    parts.push(`${safeName}.json`);
+    return Path.join(...parts);
+  }
+  sanitizeFileName(name) {
+    return name.replace(INVALID_FILE_NAME_CHARS, "_");
+  }
+  isValidSemanticVersion(version) {
+    const semverRegex = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+([0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$/;
+    return semverRegex.test(version);
+  }
+  async writePackageFiles(options, tokenData, cancellationToken) {
+    throwIfCancelled(cancellationToken);
+    const packageName = options.package.id;
+    if (!packageName)
+      throw new Error("Package name not found");
+    const packageVersion = options.package.version ?? PACKAGE_DEFAULTS.defaultPackageVersion;
+    const uipxContentBuffer = await this.fileSystem.readFile(options.solutionFilePath);
+    if (!uipxContentBuffer)
+      throw new Error(`Failed to read solution file: ${options.solutionFilePath}`);
+    const uipxContent = new TextDecoder().decode(uipxContentBuffer);
+    const uipxData = JSON.parse(uipxContent);
+    if (!uipxData.SolutionId)
+      throw new Error(`SolutionId not found in solution file: ${options.solutionFilePath}`);
+    const solutionId = uipxData.SolutionId;
+    this.logger.info(`Extracted SolutionId from .uipx file: ${solutionId}`);
+    let authorName = options.package.author;
+    if (!authorName) {
+      const nameParts = [
+        tokenData.firstName,
+        tokenData.lastName
+      ].filter((s) => s != null && s.trim() !== "");
+      authorName = nameParts.length > 0 ? nameParts.join(" ").trim() : PACKAGE_DEFAULTS.defaultAuthorName;
+    }
+    const packageVersionKey = options.publishId ?? crypto.randomUUID();
+    const metadata = {
+      authorEmail: tokenData.email,
+      authorName,
+      description: options.package.description,
+      releaseNotes: options.package.releaseNotes,
+      packageName,
+      packageVersion,
+      projectKey: solutionId,
+      packageVersionKey,
+      origin: "Studio",
+      configuration: options.configuration
+    };
+    this.logger.info(`Creating solution package with name '${metadata.packageName}' and version '${metadata.packageVersion}'.`);
+    await this.writePackageInfo(options.outputPath);
+    throwIfCancelled(cancellationToken);
+    await this.writeMetadata(options.outputPath, metadata);
+  }
+  async writePackageInfo(outputPath) {
+    const packageInfo = {
+      version: PACKAGE_DEFAULTS.currentVersion,
+      type: PACKAGE_DEFAULTS.unifiedBuildPackageType
+    };
+    const packageInfoPath = Path.join(outputPath, KNOWN_ARCHIVE_FILE_NAMES.packageInfoJsonFileName);
+    await this.fileSystem.writeFile(packageInfoPath, serializeJson(packageInfo));
+  }
+  async writeMetadata(outputPath, metadata) {
+    const metadataResource = {
+      apiVersion: "solutions.uipath.com/v1",
+      kind: "Metadata",
+      spec: metadata
+    };
+    const metadataPath = Path.join(outputPath, KNOWN_ARCHIVE_FILE_NAMES.metadataJsonFileName);
+    await this.fileSystem.writeFile(metadataPath, serializeJson(metadataResource));
+  }
+  async downloadFile(file, filePath, serviceName, options, cancellationToken) {
+    const maxRetryAttempts = RESILIENCE_DEFAULTS.maxRetryAttempts;
+    const retryIntervalMs = RESILIENCE_DEFAULTS.retryIntervalMs;
+    const accessToken = options.connection?.accessToken;
+    const externalUrl = file.url;
+    if (!externalUrl)
+      throw new Error("File URL is required for download");
+    let currentUrl = externalUrl;
+    let redirectCount = 0;
+    const createFailure = (reason, errorMessage) => ({
+      isSuccess: false,
+      failure: {
+        fileKey: file.key,
+        service: serviceName,
+        externalUrl,
+        reason,
+        errorMessage: truncateMessage(errorMessage, MAX_SERVER_MESSAGE_LENGTH)
+      }
+    });
+    try {
+      while (redirectCount < RESILIENCE_DEFAULTS.maxRedirectRetries) {
+        const response = await this.fetchWithRetry(currentUrl, accessToken, maxRetryAttempts, retryIntervalMs, file.name, cancellationToken);
+        if (isRedirectStatusCode(response.status)) {
+          const location = response.headers.get("location");
+          if (!location)
+            return createFailure("TooManyRedirects", "Redirect response without location header");
+          currentUrl = location;
+          redirectCount++;
+          this.logger.info(`Following redirect for file ${file.name} to ${location}`);
+          continue;
+        }
+        if (isClientError(response.status)) {
+          const serverMessage = await this.readResponseTextSafe(response);
+          if (accessToken) {
+            this.logger.info(`Retrying download of file ${file.name} without access token`);
+            const retryResponse = await this.fetchWithRetry(currentUrl, undefined, maxRetryAttempts, retryIntervalMs, file.name, cancellationToken);
+            if (retryResponse.ok) {
+              const buffer2 = await retryResponse.arrayBuffer();
+              await this.fileSystem.writeFile(filePath, Buffer.from(buffer2));
+              this.logger.info(`File ${file.name} written to ${filePath}.`);
+              return {
+                isSuccess: true
+              };
+            }
+            const retryServerMessage = await this.readResponseTextSafe(retryResponse);
+            return createFailure(mapHttpStatusCodeToReason(retryResponse.status), retryServerMessage ?? `HTTP ${retryResponse.status}`);
+          }
+          return createFailure(mapHttpStatusCodeToReason(response.status), serverMessage ?? `HTTP ${response.status}`);
+        }
+        if (!response.ok) {
+          const serverMessage = await this.readResponseTextSafe(response);
+          return createFailure(mapHttpStatusCodeToReason(response.status), serverMessage ?? `HTTP ${response.status}: ${response.statusText}`);
+        }
+        const buffer = await response.arrayBuffer();
+        await this.fileSystem.writeFile(filePath, Buffer.from(buffer));
+        this.logger.info(`File ${file.name} written to ${filePath}.`);
+        return {
+          isSuccess: true
+        };
+      }
+      return createFailure("TooManyRedirects", "Too many redirects");
+    } catch (error) {
+      if (cancellationToken?.aborted)
+        return createFailure("Cancelled", "Operation was cancelled");
+      const message = error instanceof Error ? error.message : String(error);
+      if (message.toLowerCase().includes("timeout") || message.toLowerCase().includes("timed out"))
+        return createFailure("Timeout", message);
+      if (message.toLowerCase().includes("network") || message.toLowerCase().includes("econnrefused") || message.toLowerCase().includes("enotfound"))
+        return createFailure("ConnectionError", message);
+      return createFailure("Unknown", message);
+    }
+  }
+  async readResponseTextSafe(response) {
+    try {
+      const text = await response.text();
+      return truncateMessage(text, MAX_SERVER_MESSAGE_LENGTH);
+    } catch {
+      return;
+    }
+  }
+  extractFilesFromResources(resources) {
+    const files = [];
+    for (const resource of resources)
+      if (resource.files && resource.files.length !== 0)
+        for (const file of resource.files)
+          files.push({
+            name: file.name,
+            kind: file.kind,
+            key: file.key ?? resource.key ?? "",
+            url: file.url
+          });
+    return files;
+  }
+  findResourceForFile(resources, file) {
+    return resources.find((resource) => {
+      if (!resource.files || resource.files.length === 0)
+        return false;
+      return resource.files.some((rf) => rf.name === file.name && rf.kind === file.kind);
+    });
+  }
+  async downloadFileWithSemaphore(semaphore, file, filePath, serviceName, options, cancellationToken) {
+    await semaphore.acquire();
+    try {
+      return await this.downloadFile(file, filePath, serviceName, options, cancellationToken);
+    } finally {
+      semaphore.release();
+    }
+  }
+  async fetchWithRetry(url, accessToken, maxRetryAttempts, retryIntervalMs, fileName, cancellationToken) {
+    let lastError;
+    for (let attempt = 1;attempt <= maxRetryAttempts + 1; attempt++)
+      try {
+        const response = await fetch(url, {
+          signal: cancellationToken,
+          headers: accessToken ? {
+            Authorization: `Bearer ${accessToken}`
+          } : undefined,
+          redirect: "manual"
+        });
+        if (isRetriableStatusCode(response.status) && attempt <= maxRetryAttempts) {
+          const delayMs = retryIntervalMs * attempt;
+          this.logger.warn(`Retriable error (HTTP ${response.status}) downloading file ${fileName}, attempt ${attempt}/${maxRetryAttempts}. Retrying in ${delayMs}ms...`);
+          await delay(delayMs, cancellationToken);
+          continue;
+        }
+        return response;
+      } catch (error) {
+        lastError = error instanceof Error ? error : new Error(String(error));
+        if (attempt <= maxRetryAttempts) {
+          const delayMs = retryIntervalMs * attempt;
+          this.logger.warn(`Network error downloading file ${fileName}, attempt ${attempt}/${maxRetryAttempts}: ${lastError.message}. Retrying in ${delayMs}ms...`);
+          await delay(delayMs, cancellationToken);
+          continue;
+        }
+      }
+    throw lastError ?? new Error(`Failed to download file ${fileName} after ${maxRetryAttempts} retries`);
+  }
+  constructor(fileSystem, logger) {
+    super(fileSystem, logger), _define_property(this, "inputPath", "");
+  }
+}
+
+class ResourceBuilderToolFactory {
+  async createAsync(logger, fileSystem) {
+    return new ResourceBuilderTool(fileSystem, logger);
+  }
+}
+
+// src/packager-tool.ts
+function registerPackagerFactories() {
+  toolsFactoryRepository.registerSolutionToolFactory(new ResourceBuilderToolFactory);
+  toolsFactoryRepository.registerProjectToolFactory(new ConnectorToolFactory);
+}
+
+export { registerPackagerFactories };
+
+//# debugId=D9EA794DD6EA909B64756E2164756E21