@uipath/solution-tool 1.201.0-preview.133 → 1.202.0-preview.134

package/dist/{packager-tool-9vehmnke.js → packager-tool-3hbsdwjm.js}

@@ -1,10 +1,10 @@
 import {
   toolsFactoryRepository
-} from "./packager-tool-vpr77gre.js";
+} from "./packager-tool-x3ehbhsn.js";
 import {
   unzipSync,
   zipSync
-} from "./packager-tool-129wn232.js";
+} from "./packager-tool-dfrk01gn.js";
 
 // ../packager/packager-core/dist/index.js
 class Path {
@@ -1067,6 +1067,7 @@ var ProjectTypes;
 ((ProjectTypes2) => {
   ProjectTypes2["Agent"] = "Agent";
   ProjectTypes2["Api"] = "Api";
+  ProjectTypes2["BusinessRules"] = "BusinessRules";
   ProjectTypes2["Connector"] = "Connector";
   ProjectTypes2["CaseManagement"] = "CaseManagement";
   ProjectTypes2["Flow"] = "Flow";
@@ -1419,7 +1420,8 @@ class ToolsFactoryRepository {
   getProjectToolFactory(projectType) {
     const factory = this.projectFactoryMap.get(projectType);
     if (!factory) {
-      throw new Error(`No tool factory found for project type '${projectType}'`);
+      const known = [...this.projectFactoryMap.keys()].join(", ");
+      throw new Error(`Cannot pack project type '${projectType}': no packager is installed for it. ` + `Project types that can be packed: ${known || "none"}.`);
     }
     return factory;
   }
@@ -1568,662 +1570,6 @@ class ConnectorToolFactory {
     return new ConnectorTool(fileSystem, logger);
   }
 }
-// ../packager/packager-tool-webapp/src/models/webapp-manifest.ts
-var WebAppVariantType;
-((WebAppVariantType2) => {
-  WebAppVariantType2["Coded"] = "Coded";
-  WebAppVariantType2["JS"] = "JS";
-})(WebAppVariantType ||= {});
-var WEBAPP_MANIFEST_FILE_NAME = "webAppManifest.json";
-// ../packager/packager-tool-webapp/src/constants.ts
-var PROJECT_JSON_FILE = "project.json";
-var DEFAULT_BUNDLE_PATH = "source/dist";
-var APP_FOLDER_NAME = ".app";
-var CONTENT_APP_FOLDER_NAME = "app";
-var TARGET_RUNTIME = "Coded";
-var TARGET_JS_RUNTIME = "JS";
-var DEFAULT_ENTRY_POINT_TYPE = "api";
-var ERROR_MESSAGES = {
-  MANIFEST_NOT_FOUND: (file) => `WebApp manifest not found: ${file}. This file is required for WebApp projects.`,
-  PROJECT_JSON_FOUND: "project.json found in WebApp project. The WebApp tool only supports Coded web apps without project.json.",
-  MANIFEST_LOAD_FAILED: (file) => `Failed to load or parse ${file}`,
-  BUNDLE_NOT_FOUND: (path) => `Compiled bundle not found at ${path}. Ensure the project is built before packing.`,
-  BUNDLE_NOT_DIRECTORY: (path) => `Bundle path ${path} exists but is not a directory.`,
-  APP_FOLDER_NOT_FOUND: (path) => `.app folder not found at ${path}. Ensure the project contains a .app folder.`,
-  APP_FOLDER_NOT_DIRECTORY: (path) => `.app path ${path} exists but is not a directory.`,
-  BUILD_NOT_SUPPORTED: "Build execution (isCompiled=false) is not yet supported. Please build the project manually and set isCompiled=true.",
-  VALIDATION_FAILED: (context) => `Validation failed: ${context}`,
-  PACKING_FAILED: (context) => `An error occurred while packing WebApp project: ${context}`,
-  PACKAGE_NAME_REQUIRED: "Package name is required",
-  PACKAGE_VERSION_REQUIRED: "Package version is required",
-  PROJECT_PATH_REQUIRED: "Project path is required",
-  OUTPUT_PATH_REQUIRED: "Output path is required"
-};
-
-// ../packager/packager-tool-webapp/src/utils/fs-helpers.ts
-async function copyDirectoryAsync(fileSystem, sourcePath, destinationPath) {
-  await fileSystem.mkdir(destinationPath);
-  const entries = await fileSystem.readdir(sourcePath);
-  for (const entry of entries) {
-    const sourceEntry = Path.join(sourcePath, entry);
-    const destEntry = Path.join(destinationPath, entry);
-    const stat = await fileSystem.stat(sourceEntry);
-    if (stat?.isDirectory()) {
-      await copyDirectoryAsync(fileSystem, sourceEntry, destEntry);
-    } else if (stat?.isFile()) {
-      const content = await fileSystem.readFile(sourceEntry);
-      if (content) {
-        await fileSystem.writeFile(destEntry, content);
-      }
-    }
-  }
-}
-
-// ../packager/packager-tool-webapp/src/utils/manifest-loader.ts
-async function loadWebAppManifest(fileSystem, projectPath) {
-  const manifestPath = Path.join(projectPath, WEBAPP_MANIFEST_FILE_NAME);
-  const exists = await fileSystem.exists(manifestPath);
-  if (!exists) {
-    return null;
-  }
-  const content = await fileSystem.readFile(manifestPath);
-  if (!content) {
-    return null;
-  }
-  try {
-    const text = new TextDecoder().decode(content);
-    const manifest = JSON.parse(text);
-    return manifest;
-  } catch (error) {
-    throw new Error(`Failed to parse ${WEBAPP_MANIFEST_FILE_NAME}: ${error instanceof Error ? error.message : String(error)}`);
-  }
-}
-async function ensureWebAppProjectId(fileSystem, projectPath) {
-  const manifest = await loadWebAppManifest(fileSystem, projectPath);
-  if (manifest && typeof manifest.projectId === "string" && manifest.projectId.length > 0) {
-    return manifest.projectId;
-  }
-  const id = crypto.randomUUID();
-  if (manifest) {
-    const updated = { ...manifest, projectId: id };
-    const manifestPath = Path.join(projectPath, WEBAPP_MANIFEST_FILE_NAME);
-    await fileSystem.writeFile(manifestPath, `${JSON.stringify(updated, null, 2)}
-`);
-  }
-  return id;
-}
-
-// ../packager/packager-tool-webapp/src/strategies/coded-app-strategy.ts
-class CodedAppStrategy {
-  fileSystem;
-  constructor(fileSystem) {
-    this.fileSystem = fileSystem;
-  }
-  async validateAsync(args) {
-    const { projectPath, manifest, logger } = args;
-    const typed = manifest;
-    let bundlePath = typed.config?.bundlePath;
-    if (typeof bundlePath !== "string" || bundlePath.length === 0) {
-      bundlePath = DEFAULT_BUNDLE_PATH;
-    }
-    const isCompiled = typed.config?.isCompiled ?? true;
-    if (isCompiled) {
-      const fullBundlePath = Path.join(projectPath, bundlePath);
-      const exists = await this.fileSystem.exists(fullBundlePath);
-      if (!exists) {
-        const message = ERROR_MESSAGES.BUNDLE_NOT_FOUND(fullBundlePath);
-        const warnable = logger;
-        if (warnable?.warn) {
-          warnable.warn(message);
-        } else {
-          logger?.info(`Warning: ${message}`);
-        }
-      }
-    }
-  }
-  async packageAsync(args) {
-    const { projectPath, manifest, outputPath, packageInfo, logger } = args;
-    logger?.info(`Packaging Coded variant: ${packageInfo.id}@${packageInfo.version}`);
-    let bundlePath = manifest.config?.bundlePath;
-    if (typeof bundlePath !== "string" || bundlePath.length === 0) {
-      bundlePath = DEFAULT_BUNDLE_PATH;
-    }
-    const isCompiled = manifest.config?.isCompiled ?? true;
-    const fullBundlePath = Path.join(projectPath, bundlePath);
-    if (isCompiled) {
-      logger?.progress("Validating compiled bundle...");
-      const bundleExists = await this.fileSystem.exists(fullBundlePath);
-      if (!bundleExists) {
-        throw new Error(ERROR_MESSAGES.BUNDLE_NOT_FOUND(fullBundlePath));
-      }
-      const bundleStat = await this.fileSystem.stat(fullBundlePath);
-      if (!bundleStat?.isDirectory()) {
-        throw new Error(ERROR_MESSAGES.BUNDLE_NOT_DIRECTORY(fullBundlePath));
-      }
-    } else {
-      logger?.info("Build mode (isCompiled=false) is not yet implemented in v1.");
-      throw new Error(ERROR_MESSAGES.BUILD_NOT_SUPPORTED);
-    }
-    const localBuildFolder = Path.join(outputPath, NugetConstants.OutputFolderName);
-    const contentFolder = Path.join(localBuildFolder, NugetConstants.ContentFolderName);
-    await this.fileSystem.mkdir(contentFolder);
-    try {
-      logger?.progress("Copying bundle to content folder...");
-      await copyDirectoryAsync(this.fileSystem, fullBundlePath, contentFolder);
-      logger?.progress("Preparing metadata files...");
-      await this.prepareMetadataFiles(localBuildFolder, contentFolder, packageInfo, manifest, projectPath);
-      logger?.progress("Creating NuGet package...");
-      const nupkgFileName = `${packageInfo.id}.${packageInfo.version}.nupkg`;
-      const nupkgPath = Path.join(outputPath, nupkgFileName);
-      const packager = new NugetPackager(this.fileSystem);
-      const result = await packager.packAsync(localBuildFolder, packageInfo, nupkgPath);
-      logger?.info(`Package created successfully: ${result.outputPath}`);
-      return result.outputPath;
-    } finally {
-      try {
-        await this.fileSystem.rm(localBuildFolder);
-      } catch (cleanupError) {
-        logger?.error(`Failed to cleanup build folder: ${cleanupError instanceof Error ? cleanupError.message : String(cleanupError)}`);
-      }
-    }
-  }
-  async prepareMetadataFiles(_localBuildFolder, contentFolder, _packageInfo, _manifest, projectPath) {
-    let mainFile = "index.html";
-    const indexHtmlPath = Path.join(contentFolder, "index.html");
-    const indexHtmlExists = await this.fileSystem.exists(indexHtmlPath);
-    if (!indexHtmlExists) {
-      const possibleEntries = ["index.html", "main.html", "app.html"];
-      for (const entry of possibleEntries) {
-        const entryPath = Path.join(contentFolder, entry);
-        if (await this.fileSystem.exists(entryPath)) {
-          mainFile = entry;
-          break;
-        }
-      }
-    }
-    const operatePath = Path.join(contentFolder, NugetConstants.OperateFileName);
-    const operateModel = {
-      projectId: await ensureWebAppProjectId(this.fileSystem, projectPath),
-      main: mainFile,
-      contentType: ProjectTypes.WebApp,
-      targetFramework: TargetFramework.Portable,
-      targetRuntime: TARGET_RUNTIME,
-      runtimeOptions: {
-        requiresUserInteraction: false,
-        isAttended: false
-      }
-    };
-    const operateJson = JSON.stringify(operateModel, null, 2);
-    await this.fileSystem.writeFile(operatePath, operateJson);
-    const manifestSourcePath = Path.join(projectPath, WEBAPP_MANIFEST_FILE_NAME);
-    const manifestDestPath = Path.join(contentFolder, WEBAPP_MANIFEST_FILE_NAME);
-    const manifestExists = await this.fileSystem.exists(manifestSourcePath);
-    if (manifestExists) {
-      const manifestContent = await this.fileSystem.readFile(manifestSourcePath, "utf-8");
-      if (manifestContent) {
-        await this.fileSystem.writeFile(manifestDestPath, manifestContent);
-      }
-    }
-    const uipathJsonSourcePath = Path.join(projectPath, "uipath.json");
-    const uipathJsonDestPath = Path.join(contentFolder, "uipath.json");
-    const uipathJsonExists = await this.fileSystem.exists(uipathJsonSourcePath);
-    if (uipathJsonExists) {
-      const uipathJsonContent = await this.fileSystem.readFile(uipathJsonSourcePath, "utf-8");
-      if (uipathJsonContent) {
-        await this.fileSystem.writeFile(uipathJsonDestPath, uipathJsonContent);
-      }
-    }
-    const actionSchemaSourcePath = Path.join(projectPath, "action-schema.json");
-    const actionSchemaDestPath = Path.join(contentFolder, "action-schema.json");
-    const actionSchemaExists = await this.fileSystem.exists(actionSchemaSourcePath);
-    if (actionSchemaExists) {
-      const actionSchemaContent = await this.fileSystem.readFile(actionSchemaSourcePath, "utf-8");
-      if (actionSchemaContent) {
-        await this.fileSystem.writeFile(actionSchemaDestPath, actionSchemaContent);
-      }
-    }
-    const bindingsPath = Path.join(contentFolder, "bindings.json");
-    const bindingsExists = await this.fileSystem.exists(bindingsPath);
-    if (!bindingsExists) {
-      const bindingsJson = JSON.stringify({
-        version: "1.0",
-        resources: []
-      }, null, 2);
-      await this.fileSystem.writeFile(bindingsPath, bindingsJson);
-    }
-    const bindingsV2Path = Path.join(contentFolder, "bindings_v2.json");
-    const bindingsCandidatePaths = [
-      Path.join(projectPath, "source", "bindings_v2.json"),
-      Path.join(projectPath, "source", "bindings.json"),
-      Path.join(projectPath, "bindings.json"),
-      Path.join(projectPath, "bindings_v2.json")
-    ];
-    let bindingsV2Json = null;
-    for (const candidate of bindingsCandidatePaths) {
-      if (await this.fileSystem.exists(candidate)) {
-        bindingsV2Json = await this.fileSystem.readFile(candidate, "utf-8");
-        if (bindingsV2Json)
-          break;
-      }
-    }
-    if (!bindingsV2Json && await this.fileSystem.exists(bindingsV2Path)) {
-      bindingsV2Json = await this.fileSystem.readFile(bindingsV2Path, "utf-8");
-    }
-    if (!bindingsV2Json) {
-      bindingsV2Json = JSON.stringify({
-        version: "2.0",
-        resources: []
-      }, null, 2);
-    }
-    await this.fileSystem.writeFile(bindingsV2Path, bindingsV2Json);
-    const entryPointsPath = Path.join(contentFolder, "entry-points.json");
-    const projectEntryPointsPath = Path.join(projectPath, "entry-points.json");
-    let entryPointsContent;
-    const projectEntryPointsExists = await this.fileSystem.exists(projectEntryPointsPath);
-    if (projectEntryPointsExists) {
-      const entryPointsData = await this.fileSystem.readFile(projectEntryPointsPath, "utf-8");
-      if (entryPointsData) {
-        entryPointsContent = entryPointsData;
-      } else {
-        entryPointsContent = this.createDefaultEntryPoints(mainFile);
-      }
-    } else {
-      entryPointsContent = this.createDefaultEntryPoints(mainFile);
-    }
-    await this.fileSystem.writeFile(entryPointsPath, entryPointsContent);
-    const packageDescriptorPath = Path.join(contentFolder, NugetConstants.PackageDescriptorFileName);
-    const packageDescriptor = {
-      $schema: "https://cloud.uipath.com/draft/2024-12/package-descriptor",
-      files: {
-        [NugetConstants.OperateFileName]: Path.join(NugetConstants.ContentFolderName, NugetConstants.OperateFileName),
-        "entry-points.json": Path.join(NugetConstants.ContentFolderName, "entry-points.json"),
-        "bindings.json": Path.join(NugetConstants.ContentFolderName, "bindings_v2.json")
-      }
-    };
-    const packageDescriptorJson = JSON.stringify(packageDescriptor, null, 2);
-    await this.fileSystem.writeFile(packageDescriptorPath, packageDescriptorJson);
-  }
-  createDefaultEntryPoints(mainFile) {
-    const uniqueId = this.generateUniqueId();
-    const entryPoints = {
-      $schema: "https://cloud.uipath.com/draft/2024-12/entry-point",
-      $id: "entry-points-doc-001",
-      entryPoints: [
-        {
-          filePath: mainFile,
-          uniqueId,
-          type: DEFAULT_ENTRY_POINT_TYPE,
-          input: {
-            amount: { type: "integer" },
-            id: { type: "string" }
-          },
-          output: {
-            status: { type: "string" }
-          }
-        }
-      ]
-    };
-    return JSON.stringify(entryPoints, null, 2);
-  }
-  generateUniqueId() {
-    const randomBytes = new Uint8Array(16);
-    if (typeof crypto !== "undefined" && crypto.getRandomValues) {
-      crypto.getRandomValues(randomBytes);
-    } else {
-      throw new Error("crypto.getRandomValues is not available");
-    }
-    randomBytes[6] = randomBytes[6] & 15 | 64;
-    randomBytes[8] = randomBytes[8] & 63 | 128;
-    const hex = Array.from(randomBytes).map((b) => b.toString(16).padStart(2, "0")).join("");
-    return [
-      hex.substring(0, 8),
-      hex.substring(8, 12),
-      hex.substring(12, 16),
-      hex.substring(16, 20),
-      hex.substring(20, 32)
-    ].join("-");
-  }
-}
-
-// ../packager/packager-tool-webapp/src/strategies/js-apps-strategy.ts
-class JsAppsStrategy {
-  fileSystem;
-  constructor(fileSystem) {
-    this.fileSystem = fileSystem;
-  }
-  async validateAsync(args) {
-    const { projectPath, logger } = args;
-    const appFolder = Path.join(projectPath, APP_FOLDER_NAME);
-    const exists = await this.fileSystem.exists(appFolder);
-    if (!exists) {
-      const message = ERROR_MESSAGES.APP_FOLDER_NOT_FOUND(appFolder);
-      if (logger?.warn) {
-        logger.warn(message);
-      } else {
-        logger?.info(`Warning: ${message}`);
-      }
-      return;
-    }
-    const stat = await this.fileSystem.stat(appFolder);
-    if (!stat?.isDirectory()) {
-      const message = ERROR_MESSAGES.APP_FOLDER_NOT_DIRECTORY(appFolder);
-      if (logger?.warn) {
-        logger.warn(message);
-      } else {
-        logger?.info(`Warning: ${message}`);
-      }
-    }
-  }
-  async packageAsync(args) {
-    const { projectPath, manifest, outputPath, packageInfo, logger } = args;
-    logger?.info(`Packaging JS variant: ${packageInfo.id}@${packageInfo.version}`);
-    const appFolder = Path.join(projectPath, APP_FOLDER_NAME);
-    logger?.progress("Validating .app folder...");
-    const appFolderExists = await this.fileSystem.exists(appFolder);
-    if (!appFolderExists) {
-      throw new Error(ERROR_MESSAGES.APP_FOLDER_NOT_FOUND(appFolder));
-    }
-    const appFolderStat = await this.fileSystem.stat(appFolder);
-    if (!appFolderStat?.isDirectory()) {
-      throw new Error(ERROR_MESSAGES.APP_FOLDER_NOT_DIRECTORY(appFolder));
-    }
-    const localBuildFolder = Path.join(outputPath, NugetConstants.OutputFolderName);
-    const contentFolder = Path.join(localBuildFolder, NugetConstants.ContentFolderName);
-    const contentAppFolder = Path.join(contentFolder, CONTENT_APP_FOLDER_NAME);
-    await this.fileSystem.mkdir(contentFolder);
-    try {
-      logger?.progress("Copying .app folder into content/app...");
-      await copyDirectoryAsync(this.fileSystem, appFolder, contentAppFolder);
-      logger?.progress("Preparing metadata files...");
-      await this.prepareMetadataFiles(contentFolder, contentAppFolder, packageInfo, manifest, projectPath);
-      logger?.progress("Creating NuGet package...");
-      const nupkgFileName = `${packageInfo.id}.${packageInfo.version}.nupkg`;
-      const nupkgPath = Path.join(outputPath, nupkgFileName);
-      const packager = new NugetPackager(this.fileSystem);
-      const result = await packager.packAsync(localBuildFolder, packageInfo, nupkgPath);
-      logger?.info(`Package created successfully: ${result.outputPath}`);
-      return result.outputPath;
-    } finally {
-      try {
-        await this.fileSystem.rm(localBuildFolder);
-      } catch (cleanupError) {
-        logger?.error(`Failed to cleanup build folder: ${cleanupError instanceof Error ? cleanupError.message : String(cleanupError)}`);
-      }
-    }
-  }
-  async prepareMetadataFiles(contentFolder, _contentAppFolder, _packageInfo, _manifest, projectPath) {
-    const mainFile = "index.html";
-    const mainRelativeToContent = `${CONTENT_APP_FOLDER_NAME}/${mainFile}`;
-    const operatePath = Path.join(contentFolder, NugetConstants.OperateFileName);
-    const operateModel = {
-      projectId: await ensureWebAppProjectId(this.fileSystem, projectPath),
-      main: mainRelativeToContent,
-      contentType: ProjectTypes.WebApp,
-      targetFramework: TargetFramework.Portable,
-      targetRuntime: TARGET_JS_RUNTIME,
-      runtimeOptions: {
-        requiresUserInteraction: false,
-        isAttended: false
-      }
-    };
-    const operateJson = JSON.stringify(operateModel, null, 2);
-    await this.fileSystem.writeFile(operatePath, operateJson);
-    const manifestSourcePath = Path.join(projectPath, WEBAPP_MANIFEST_FILE_NAME);
-    const manifestDestPath = Path.join(contentFolder, WEBAPP_MANIFEST_FILE_NAME);
-    const manifestExists = await this.fileSystem.exists(manifestSourcePath);
-    if (manifestExists) {
-      const manifestContent = await this.fileSystem.readFile(manifestSourcePath);
-      if (manifestContent) {
-        await this.fileSystem.writeFile(manifestDestPath, manifestContent);
-      }
-    }
-    const uipathJsonSourcePath = Path.join(projectPath, "uipath.json");
-    const uipathJsonDestPath = Path.join(contentFolder, "uipath.json");
-    const uipathJsonExists = await this.fileSystem.exists(uipathJsonSourcePath);
-    if (uipathJsonExists) {
-      const uipathJsonContent = await this.fileSystem.readFile(uipathJsonSourcePath);
-      if (uipathJsonContent) {
-        await this.fileSystem.writeFile(uipathJsonDestPath, uipathJsonContent);
-      }
-    }
-    const bindingsPath = Path.join(contentFolder, "bindings.json");
-    const bindingsExists = await this.fileSystem.exists(bindingsPath);
-    if (!bindingsExists) {
-      const bindingsJson = JSON.stringify({ version: "1.0", resources: [] }, null, 2);
-      await this.fileSystem.writeFile(bindingsPath, bindingsJson);
-    }
-    const bindingsV2Path = Path.join(contentFolder, "bindings_v2.json");
-    const bindingsV2Exists = await this.fileSystem.exists(bindingsV2Path);
-    if (!bindingsV2Exists) {
-      const bindingsV2Json = JSON.stringify({ version: "2.0", resources: [] }, null, 2);
-      await this.fileSystem.writeFile(bindingsV2Path, bindingsV2Json);
-    }
-    const entryPointsPath = Path.join(contentFolder, "entry-points.json");
-    const projectEntryPointsPath = Path.join(projectPath, "entry-points.json");
-    let entryPointsContent;
-    const projectEntryPointsExists = await this.fileSystem.exists(projectEntryPointsPath);
-    if (projectEntryPointsExists) {
-      const entryPointsData = await this.fileSystem.readFile(projectEntryPointsPath);
-      if (entryPointsData) {
-        entryPointsContent = new TextDecoder().decode(entryPointsData);
-      } else {
-        entryPointsContent = this.createDefaultEntryPoints(mainRelativeToContent);
-      }
-    } else {
-      entryPointsContent = this.createDefaultEntryPoints(mainRelativeToContent);
-    }
-    await this.fileSystem.writeFile(entryPointsPath, entryPointsContent);
-    const packageDescriptorPath = Path.join(contentFolder, NugetConstants.PackageDescriptorFileName);
-    const packageDescriptor = {
-      files: {
-        [NugetConstants.OperateFileName]: Path.join(NugetConstants.ContentFolderName, NugetConstants.OperateFileName),
-        "entry-points.json": Path.join(NugetConstants.ContentFolderName, "entry-points.json"),
-        "bindings.json": Path.join(NugetConstants.ContentFolderName, "bindings_v2.json")
-      }
-    };
-    const packageDescriptorJson = JSON.stringify(packageDescriptor, null, 2);
-    await this.fileSystem.writeFile(packageDescriptorPath, packageDescriptorJson);
-  }
-  createDefaultEntryPoints(mainFilePath) {
-    const uniqueId = this.generateUniqueId();
-    const entryPoints = {
-      $schema: "https://cloud.uipath.com/draft/2024-12/entry-point",
-      $id: "entry-points-doc-001",
-      entryPoints: [
-        {
-          filePath: mainFilePath,
-          uniqueId,
-          type: DEFAULT_ENTRY_POINT_TYPE,
-          input: {
-            amount: { type: "integer" },
-            id: { type: "string" }
-          },
-          output: {
-            status: { type: "string" }
-          }
-        }
-      ]
-    };
-    return JSON.stringify(entryPoints, null, 2);
-  }
-  generateUniqueId() {
-    const randomBytes = new Uint8Array(16);
-    if (typeof crypto !== "undefined" && crypto.getRandomValues) {
-      crypto.getRandomValues(randomBytes);
-    } else {
-      throw new Error("crypto.getRandomValues is not available");
-    }
-    randomBytes[6] = randomBytes[6] & 15 | 64;
-    randomBytes[8] = randomBytes[8] & 63 | 128;
-    const hex = Array.from(randomBytes).map((b) => b.toString(16).padStart(2, "0")).join("");
-    return [
-      hex.substring(0, 8),
-      hex.substring(8, 12),
-      hex.substring(12, 16),
-      hex.substring(16, 20),
-      hex.substring(20, 32)
-    ].join("-");
-  }
-}
-
-// ../packager/packager-tool-webapp/src/strategies/variant-strategy-factory.ts
-class VariantStrategyFactory {
-  static createStrategy(manifest, fileSystem) {
-    const variant = manifest.type;
-    switch (variant) {
-      case "Coded" /* Coded */:
-        return new CodedAppStrategy(fileSystem);
-      case "JS" /* JS */:
-        return new JsAppsStrategy(fileSystem);
-      default:
-        throw new Error(`Unknown WebApp variant: ${manifest.type}. Supported variants: ${Object.values(WebAppVariantType).join(", ")}`);
-    }
-  }
-}
-
-// ../packager/packager-tool-webapp/src/webapp-tool.ts
-class WebAppTool extends ProjectTool {
-  _temporaryStorage;
-  _tempBuildFolder = null;
-  constructor(fileSystem, logger) {
-    super(fileSystem, logger);
-    this._temporaryStorage = new TemporaryStorageService(fileSystem);
-  }
-  async restoreAsync(_options, _cancellationToken) {
-    this.logger.info("Restore operation is not required for WebApp projects");
-    return ToolResult.success();
-  }
-  async validateAsync(options, _cancellationToken) {
-    if (!options.projectPath) {
-      return this.handleError(new Error(ERROR_MESSAGES.PROJECT_PATH_REQUIRED), "Validation");
-    }
-    try {
-      this.logger.info("Validating WebApp project...");
-      let manifest;
-      let strategy;
-      try {
-        const prepared = await this.getManifestAndStrategy(options.projectPath);
-        manifest = prepared.manifest;
-        strategy = prepared.strategy;
-      } catch (error) {
-        return this.handleError(error, "Validation");
-      }
-      try {
-        if (strategy.validateAsync) {
-          await strategy.validateAsync({
-            fileSystem: this.fileSystem,
-            projectPath: options.projectPath,
-            manifest,
-            logger: this.createStrategyLogger()
-          });
-        }
-      } catch (error) {
-        return this.handleError(error, "Validation");
-      }
-      this.logger.info("WebApp project validation completed");
-      return ToolResult.success();
-    } catch (error) {
-      return this.handleError(error, "Validation");
-    }
-  }
-  async buildAsync(_options, _cancellationToken) {
-    this.logger.info("Build operation for WebApp is lightweight (metadata preparation only)");
-    return ToolResult.success();
-  }
-  async packAsync(options, _cancellationToken) {
-    if (!options.projectPath) {
-      return this.handleError(new Error(ERROR_MESSAGES.PROJECT_PATH_REQUIRED), "Packing");
-    }
-    if (!options.outputPath) {
-      return this.handleError(new Error(ERROR_MESSAGES.OUTPUT_PATH_REQUIRED), "Packing");
-    }
-    if (!options.package?.id) {
-      return this.handleError(new Error(ERROR_MESSAGES.PACKAGE_NAME_REQUIRED), "Packing");
-    }
-    if (!options.package?.version) {
-      return this.handleError(new Error(ERROR_MESSAGES.PACKAGE_VERSION_REQUIRED), "Packing");
-    }
-    try {
-      this.logger.info(`Packing WebApp project: ${options.package.id}@${options.package.version}`);
-      let manifest;
-      let strategy;
-      try {
-        const prepared = await this.getManifestAndStrategy(options.projectPath);
-        manifest = prepared.manifest;
-        strategy = prepared.strategy;
-      } catch (error) {
-        return this.handleError(error, `Packing WebApp project '${options.package.id}'`);
-      }
-      const nupkgPath = await strategy.packageAsync({
-        fileSystem: this.fileSystem,
-        projectPath: options.projectPath,
-        manifest,
-        outputPath: options.outputPath,
-        packageInfo: options.package,
-        logger: this.createStrategyLogger()
-      });
-      this.logger.info(`WebApp package created successfully: ${nupkgPath}`);
-      return new ToolResult(ToolErrorCodes.Success, "done", [nupkgPath]);
-    } catch (error) {
-      return this.handleError(error, `Packing WebApp project '${options.package.id}'`);
-    }
-  }
-  async dispose() {
-    this.logger.info("Disposing WebApp Tool");
-    try {
-      if (this._tempBuildFolder) {
-        await this.fileSystem.rm(this._tempBuildFolder);
-        this._tempBuildFolder = null;
-      }
-      await this._temporaryStorage.cleanup();
-    } catch {}
-  }
-  async getManifestAndStrategy(projectPath) {
-    const manifestPath = Path.join(projectPath, WEBAPP_MANIFEST_FILE_NAME);
-    const manifestExists = await this.fileSystem.exists(manifestPath);
-    if (!manifestExists) {
-      throw new Error(ERROR_MESSAGES.MANIFEST_NOT_FOUND(WEBAPP_MANIFEST_FILE_NAME));
-    }
-    const projectJsonPath = Path.join(projectPath, PROJECT_JSON_FILE);
-    if (await this.fileSystem.exists(projectJsonPath)) {
-      throw new Error(ERROR_MESSAGES.PROJECT_JSON_FOUND);
-    }
-    const manifest = await loadWebAppManifest(this.fileSystem, projectPath);
-    if (!manifest) {
-      throw new Error(ERROR_MESSAGES.MANIFEST_LOAD_FAILED(WEBAPP_MANIFEST_FILE_NAME));
-    }
-    const strategy = VariantStrategyFactory.createStrategy(manifest, this.fileSystem);
-    return { manifest, strategy };
-  }
-  handleError(error, context) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    this.logger.error(`${context}: ${errorMessage}`);
-    let userMessage;
-    if (context === "Validation") {
-      userMessage = ERROR_MESSAGES.VALIDATION_FAILED(errorMessage);
-    } else if (context.startsWith("Packing")) {
-      userMessage = ERROR_MESSAGES.PACKING_FAILED(errorMessage);
-    } else {
-      userMessage = errorMessage;
-    }
-    return ToolResult.error(ToolErrorCodes.InternalError, userMessage);
-  }
-  createStrategyLogger() {
-    return {
-      info: (msg) => this.logger.info(msg),
-      error: (msg) => this.logger.error(msg),
-      progress: (msg) => this.logger.progress(msg),
-      warn: (msg) => this.logger.warn(msg)
-    };
-  }
-}
-// ../packager/packager-tool-webapp/src/webapp-tool-factory.ts
-class WebAppToolFactory {
-  supportedTypes = [ProjectTypes.AppV2];
-  async createAsync(logger, fileSystem) {
-    return new WebAppTool(fileSystem, logger);
-  }
-}
 // ../../node_modules/@uipath/resource-builder-tool/dist/index.js
 function _define_property(obj, key, value) {
   if (key in obj)
@@ -2920,9 +2266,8 @@ class ResourceBuilderToolFactory {
 function registerPackagerFactories() {
   toolsFactoryRepository.registerSolutionToolFactory(new ResourceBuilderToolFactory);
   toolsFactoryRepository.registerProjectToolFactory(new ConnectorToolFactory);
-  toolsFactoryRepository.registerProjectToolFactory(new WebAppToolFactory);
 }
 
 export { Path, TemporaryStorageService, ZipService, I18nManager, translate, BuildConfiguration, LogLevel, LogMessage, TargetFramework, ToolErrorCodes, ToolResult, toolsFactoryRepository2 as toolsFactoryRepository, registerPackagerFactories };
 
-//# debugId=D265E2C64CC7BFA064756E2164756E21
+//# debugId=FCA9CE604FDEAF2C64756E2164756E21