@uipath/packager-tool-webapp 1.0.4

package/dist/constants.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Constants used throughout the WebApp tool implementation
+ */
+/**
+ * File names
+ */
+export declare const PROJECT_JSON_FILE = "project.json";
+/**
+ * Default bundle path if not specified in manifest
+ */
+export declare const DEFAULT_BUNDLE_PATH = "source/dist";
+/**
+ * Target runtime for operate.json
+ */
+export declare const TARGET_RUNTIME = "Coded";
+/**
+ * Default entry point type
+ */
+export declare const DEFAULT_ENTRY_POINT_TYPE = "api";
+/**
+ * Error messages
+ */
+export declare const ERROR_MESSAGES: {
+    readonly MANIFEST_NOT_FOUND: (file: string) => string;
+    readonly PROJECT_JSON_FOUND: "project.json found in WebApp project. The WebApp tool only supports Coded web apps without project.json.";
+    readonly MANIFEST_LOAD_FAILED: (file: string) => string;
+    readonly BUNDLE_NOT_FOUND: (path: string) => string;
+    readonly BUNDLE_NOT_DIRECTORY: (path: string) => string;
+    readonly BUILD_NOT_SUPPORTED: "Build execution (isCompiled=false) is not yet supported. Please build the project manually and set isCompiled=true.";
+    readonly VALIDATION_FAILED: (context: string) => string;
+    readonly PACKING_FAILED: (context: string) => string;
+    readonly PACKAGE_NAME_REQUIRED: "Package name is required";
+    readonly PACKAGE_VERSION_REQUIRED: "Package version is required";
+    readonly PROJECT_PATH_REQUIRED: "Project path is required";
+    readonly OUTPUT_PATH_REQUIRED: "Output path is required";
+};

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export { WebAppTool } from "./webapp-tool.js";
+export { WebAppToolFactory } from "./webapp-tool-factory.js";

package/dist/index.js

@@ -0,0 +1,466 @@
+// src/index.ts
+import { toolsFactoryRepository } from "@uipath/solutionpackager-tool-core";
+
+// src/webapp-tool-factory.ts
+import {
+  ProjectTypes as ProjectTypes2
+} from "@uipath/solutionpackager-tool-core";
+
+// src/webapp-tool.ts
+import {
+  Path as Path4,
+  ProjectTool,
+  TemporaryStorageService,
+  ToolErrorCodes,
+  ToolResult
+} from "@uipath/solutionpackager-tool-core";
+
+// src/constants.ts
+var PROJECT_JSON_FILE = "project.json";
+var DEFAULT_BUNDLE_PATH = "source/dist";
+var TARGET_RUNTIME = "Coded";
+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.`,
+  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"
+};
+
+// src/models/webapp-manifest.ts
+var WebAppVariantType;
+((WebAppVariantType2) => {
+  WebAppVariantType2["Coded"] = "Coded";
+  WebAppVariantType2["JS"] = "JS";
+})(WebAppVariantType ||= {});
+var WEBAPP_MANIFEST_FILE_NAME = "webAppManifest.json";
+
+// src/strategies/coded-app-strategy.ts
+import {
+  NugetConstants,
+  NugetPackager,
+  Path as Path2,
+  ProjectTypes,
+  TargetFramework
+} from "@uipath/solutionpackager-tool-core";
+
+// src/utils/fs-helpers.ts
+import { Path } from "@uipath/solutionpackager-tool-core";
+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);
+      }
+    }
+  }
+}
+
+// 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 = Path2.join(projectPath, bundlePath);
+      const exists = await this.fileSystem.exists(fullBundlePath);
+      if (!exists) {
+        const message = ERROR_MESSAGES.BUNDLE_NOT_FOUND(fullBundlePath);
+        if (logger?.warn) {
+          logger.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 = Path2.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 = Path2.join(outputPath, NugetConstants.OutputFolderName);
+    const contentFolder = Path2.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 = Path2.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 = Path2.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 = Path2.join(contentFolder, entry);
+        if (await this.fileSystem.exists(entryPath)) {
+          mainFile = entry;
+          break;
+        }
+      }
+    }
+    const operatePath = Path2.join(contentFolder, NugetConstants.OperateFileName);
+    const operateModel = {
+      projectId: packageInfo.id,
+      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 = Path2.join(projectPath, WEBAPP_MANIFEST_FILE_NAME);
+    const manifestDestPath = Path2.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 = Path2.join(projectPath, "uipath.json");
+    const uipathJsonDestPath = Path2.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 = Path2.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 = Path2.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 = Path2.join(contentFolder, "entry-points.json");
+    const projectEntryPointsPath = Path2.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(mainFile);
+      }
+    } else {
+      entryPointsContent = this.createDefaultEntryPoints(mainFile);
+    }
+    await this.fileSystem.writeFile(entryPointsPath, entryPointsContent);
+    const packageDescriptorPath = Path2.join(contentFolder, NugetConstants.PackageDescriptorFileName);
+    const packageDescriptor = {
+      files: {
+        [NugetConstants.OperateFileName]: Path2.join(NugetConstants.ContentFolderName, NugetConstants.OperateFileName),
+        "entry-points.json": Path2.join(NugetConstants.ContentFolderName, "entry-points.json"),
+        "bindings.json": Path2.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("-");
+  }
+}
+
+// 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 */:
+        throw new Error("JS variant is not yet implemented. Only Coded is supported in v1.");
+      default:
+        throw new Error(`Unknown WebApp variant: ${manifest.type}. Supported variants: ${Object.values(WebAppVariantType).join(", ")}`);
+    }
+  }
+}
+
+// src/utils/manifest-loader.ts
+import { Path as Path3 } from "@uipath/solutionpackager-tool-core";
+async function loadWebAppManifest(fileSystem, projectPath) {
+  const manifestPath = Path3.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)}`);
+  }
+}
+
+// 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 = Path4.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 = Path4.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)
+    };
+  }
+}
+
+// src/webapp-tool-factory.ts
+class WebAppToolFactory {
+  supportedTypes = [ProjectTypes2.AppV2];
+  async createAsync(logger, fileSystem) {
+    return new WebAppTool(fileSystem, logger);
+  }
+}
+
+// src/index.ts
+toolsFactoryRepository.registerProjectToolFactory(new WebAppToolFactory);
+export {
+  WebAppToolFactory,
+  WebAppTool
+};

package/dist/models/webapp-manifest.d.ts

@@ -0,0 +1,39 @@
+export declare enum WebAppVariantType {
+    Coded = "Coded",
+    JS = "JS"
+}
+/** @public */
+export declare enum AppSubType {
+    /** Coded app subtype that is registered with Solutions */
+    Coded = "Coded",
+    /** CodedAction app subtype that is registered with Solutions */
+    CodedAction = "CodedAction"
+}
+/**
+ * Variant-specific configurations
+ */
+export interface CodedAppConfig {
+    /** If true: pack only; If false: build → pack (future) */
+    isCompiled?: boolean;
+    /** Compiled bundle folder location (default: dist/) */
+    bundlePath?: string;
+    /** Optional build command for future scenarios */
+    buildCommand?: string;
+    isActionApp?: boolean;
+}
+export interface JsConfig {
+    [key: string]: unknown;
+}
+/** Map each variant to its specific config type */
+type ManifestConfigMap = {
+    [WebAppVariantType.Coded]: CodedAppConfig;
+    [WebAppVariantType.JS]: JsConfig;
+};
+/** WebApp manifest type parameterized by variant */
+export type WebAppManifest<T extends WebAppVariantType = WebAppVariantType> = {
+    type: T;
+    solutionResourceSubType: string;
+    config?: ManifestConfigMap[T];
+};
+export declare const WEBAPP_MANIFEST_FILE_NAME = "webAppManifest.json";
+export {};

package/dist/strategies/coded-app-strategy.d.ts

@@ -0,0 +1,37 @@
+import type { IFileSystem } from "@uipath/solutionpackager-tool-core";
+import type { WebAppManifest } from "../models/webapp-manifest.js";
+import type { PackageArgs, VariantStrategy } from "./variant-strategy.js";
+/**
+ * Coded app strategy for Coded variant
+ * Supports isCompiled=true (v1) and isCompiled=false (future)
+ */
+export declare class CodedAppStrategy implements VariantStrategy {
+    private readonly fileSystem;
+    constructor(fileSystem: IFileSystem);
+    /**
+     * Variant-specific validation: warn if compiled bundle is expected but missing
+     */
+    validateAsync(args: {
+        fileSystem: IFileSystem;
+        projectPath: string;
+        manifest: WebAppManifest;
+        logger?: {
+            info: (message: string) => void;
+            error: (message: string) => void;
+            progress: (message: string) => void;
+        };
+    }): Promise<void>;
+    packageAsync(args: PackageArgs): Promise<string>;
+    /**
+     * Prepare metadata files (operate.json, package-descriptor.json, bindings.json, bindings_v2.json, entry-points.json)
+     */
+    private prepareMetadataFiles;
+    /**
+     * Create default entry-points.json structure
+     */
+    private createDefaultEntryPoints;
+    /**
+     * Generate a cryptographically secure unique ID (UUID v4-like format)
+     */
+    private generateUniqueId;
+}

package/dist/strategies/variant-strategy-factory.d.ts

@@ -0,0 +1,16 @@
+import type { IFileSystem } from "@uipath/solutionpackager-tool-core";
+import type { WebAppManifest } from "../models/webapp-manifest.js";
+import type { VariantStrategy } from "./variant-strategy.js";
+/**
+ * Factory for creating variant-specific packaging strategies
+ */
+export declare class VariantStrategyFactory {
+    /**
+     * Create a strategy instance based on manifest type
+     * @param manifest - WebApp manifest
+     * @param fileSystem - File system instance
+     * @returns Strategy instance
+     * @throws Error if variant is not supported
+     */
+    static createStrategy(manifest: WebAppManifest, fileSystem: IFileSystem): VariantStrategy;
+}

package/dist/strategies/variant-strategy.d.ts

@@ -0,0 +1,57 @@
+import type { IFileSystem, NugetPackageInfo } from "@uipath/solutionpackager-tool-core";
+import type { WebAppManifest } from "../models/webapp-manifest.js";
+/**
+ * Arguments for packaging operation
+ */
+export interface PackageArgs {
+    /**
+     * File system instance
+     */
+    fileSystem: IFileSystem;
+    /**
+     * Project root path
+     */
+    projectPath: string;
+    /**
+     * Parsed webApp manifest
+     */
+    manifest: WebAppManifest;
+    /**
+     * Output directory path
+     */
+    outputPath: string;
+    /**
+     * NuGet package information
+     */
+    packageInfo: NugetPackageInfo;
+    /**
+     * Logger instance (optional, for strategy-specific logging)
+     */
+    logger?: {
+        info: (message: string) => void;
+        error: (message: string) => void;
+        progress: (message: string) => void;
+        warn?: (message: string) => void;
+    };
+}
+/**
+ * Strategy interface for different WebApp variant packaging
+ */
+export interface VariantStrategy {
+    /**
+     * Package the WebApp according to variant-specific logic
+     * @param args - Packaging arguments
+     * @returns Path to the created .nupkg file
+     */
+    packageAsync(args: PackageArgs): Promise<string>;
+    /**
+     * Optional variant-specific validation step invoked during tool validation.
+     * Implementations may warn or throw on invalid configuration.
+     */
+    validateAsync?(args: {
+        fileSystem: PackageArgs["fileSystem"];
+        projectPath: string;
+        manifest: PackageArgs["manifest"];
+        logger?: PackageArgs["logger"];
+    }): Promise<void>;
+}

package/dist/utils/fs-helpers.d.ts

@@ -0,0 +1,9 @@
+import type { IFileSystem } from "@uipath/solutionpackager-tool-core";
+/**
+ * Copy directory recursively from source to destination
+ */
+export declare function copyDirectoryAsync(fileSystem: IFileSystem, sourcePath: string, destinationPath: string): Promise<void>;
+/**
+ * Find .nupkg file in a directory
+ */
+export declare function findNupkgInFolder(fileSystem: IFileSystem, directoryPath: string): Promise<string | null>;

package/dist/utils/manifest-loader.d.ts

@@ -0,0 +1,6 @@
+import type { IFileSystem } from "@uipath/solutionpackager-tool-core";
+import type { WebAppManifest } from "../models/webapp-manifest.js";
+/**
+ * Load and parse webAppManifest.json from project path
+ */
+export declare function loadWebAppManifest(fileSystem: IFileSystem, projectPath: string): Promise<WebAppManifest | null>;

package/dist/webapp-tool-factory.d.ts

@@ -0,0 +1,8 @@
+import { type IFileSystem, type IProjectToolFactory, type IToolLogger, type ProjectTool, type ProjectType } from "@uipath/solutionpackager-tool-core";
+/**
+ * Factory for creating WebApp project tools
+ */
+export declare class WebAppToolFactory implements IProjectToolFactory {
+    readonly supportedTypes: readonly ProjectType[];
+    createAsync(logger: IToolLogger, fileSystem: IFileSystem): Promise<ProjectTool>;
+}