@uipath/packager-tool-webapp 1.202.0-preview.140 → 1.202.0-preview.142

package/src/strategies/js-apps-strategy.ts

@@ -1,378 +0,0 @@
-import type {
-    IFileSystem,
-    OperateFileModel,
-    PackageDescriptorFileModel,
-} from "@uipath/solutionpackager-tool-core";
-import {
-    NugetConstants,
-    NugetPackager,
-    Path,
-    ProjectTypes,
-    TargetFramework,
-} from "@uipath/solutionpackager-tool-core";
-import {
-    APP_FOLDER_NAME,
-    CONTENT_APP_FOLDER_NAME,
-    DEFAULT_ENTRY_POINT_TYPE,
-    ERROR_MESSAGES,
-    TARGET_JS_RUNTIME,
-} from "../constants.js";
-import type { WebAppManifest } from "../models/webapp-manifest.js";
-import { WEBAPP_MANIFEST_FILE_NAME } from "../models/webapp-manifest.js";
-import { copyDirectoryAsync } from "../utils/fs-helpers.js";
-import { ensureWebAppProjectId } from "../utils/manifest-loader.js";
-import type { PackageArgs, VariantStrategy } from "./variant-strategy.js";
-
-/**
- * JS apps strategy for the JS variant.
- * Packages a pre-built `.app` folder whose contents are placed under `content/app`
- * in the resulting .nupkg.
- */
-export class JsAppsStrategy implements VariantStrategy {
-    constructor(private readonly fileSystem: IFileSystem) {}
-
-    /**
-     * Variant-specific validation: warn if the `.app` folder is missing or not a directory.
-     * Bundle path from the manifest is intentionally ignored for this variant.
-     */
-    async validateAsync(args: {
-        fileSystem: IFileSystem;
-        projectPath: string;
-        manifest: WebAppManifest;
-        logger?: {
-            info: (message: string) => void;
-            error: (message: string) => void;
-            progress: (message: string) => void;
-            warn?: (message: string) => void;
-        };
-    }): Promise<void> {
-        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: PackageArgs): Promise<string> {
-        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));
-        }
-
-        // Bundle directory structure: <output>/bundle/content/app
-        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 {
-            // Copy contents of .app into content/app
-            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)
-                    }`,
-                );
-            }
-        }
-    }
-
-    /**
-     * Prepare metadata files (operate.json, package-descriptor.json, bindings.json, bindings_v2.json, entry-points.json)
-     */
-    private async prepareMetadataFiles(
-        contentFolder: string,
-        _contentAppFolder: string,
-        _packageInfo: {
-            id: string;
-            version: string;
-            author?: string;
-            description?: string;
-        },
-        _manifest: WebAppManifest,
-        projectPath: string,
-    ): Promise<void> {
-        const mainFile = "index.html";
-
-        // Path referenced from within the package content folder
-        const mainRelativeToContent = `${CONTENT_APP_FOLDER_NAME}/${mainFile}`;
-
-        // operate.json in content folder
-        const operatePath = Path.join(
-            contentFolder,
-            NugetConstants.OperateFileName,
-        );
-        const operateModel: OperateFileModel & { targetRuntime: string } = {
-            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);
-
-        // Copy webAppManifest.json from project root into content (as-is)
-        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,
-                );
-            }
-        }
-
-        // Copy uipath.json from project root into content (if it exists)
-        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,
-                );
-            }
-        }
-
-        // Create or copy bindings.json (version 1.0)
-        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);
-        }
-
-        // Create or copy bindings_v2.json (version 2.0)
-        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);
-        }
-
-        // Create or copy entry-points.json
-        const entryPointsPath = Path.join(contentFolder, "entry-points.json");
-        const projectEntryPointsPath = Path.join(
-            projectPath,
-            "entry-points.json",
-        );
-
-        let entryPointsContent: string;
-        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);
-
-        // Create package-descriptor.json in content folder
-        const packageDescriptorPath = Path.join(
-            contentFolder,
-            NugetConstants.PackageDescriptorFileName,
-        );
-        const packageDescriptor: PackageDescriptorFileModel = {
-            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,
-        );
-    }
-
-    /**
-     * Create default entry-points.json structure
-     */
-    private createDefaultEntryPoints(mainFilePath: string): string {
-        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: uniqueId,
-                    type: DEFAULT_ENTRY_POINT_TYPE,
-                    input: {
-                        amount: { type: "integer" },
-                        id: { type: "string" },
-                    },
-                    output: {
-                        status: { type: "string" },
-                    },
-                },
-            ],
-        };
-
-        return JSON.stringify(entryPoints, null, 2);
-    }
-
-    /**
-     * Generate a cryptographically secure unique ID (UUID v4-like format)
-     */
-    private generateUniqueId(): string {
-        const randomBytes = new Uint8Array(16);
-
-        if (typeof crypto !== "undefined" && crypto.getRandomValues) {
-            crypto.getRandomValues(randomBytes);
-        } else {
-            throw new Error("crypto.getRandomValues is not available");
-        }
-
-        // Set version (4) and variant bits according to UUID v4 spec
-        randomBytes[6] = (randomBytes[6] & 0x0f) | 0x40;
-        randomBytes[8] = (randomBytes[8] & 0x3f) | 0x80;
-
-        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("-");
-    }
-}

package/src/strategies/variant-strategy-factory.ts

@@ -1,38 +0,0 @@
-import type { IFileSystem } from "@uipath/solutionpackager-tool-core";
-import type { WebAppManifest } from "../models/webapp-manifest.js";
-import { WebAppVariantType } from "../models/webapp-manifest.js";
-import { CodedAppStrategy } from "./coded-app-strategy.js";
-import { JsAppsStrategy } from "./js-apps-strategy.js";
-import type { VariantStrategy } from "./variant-strategy.js";
-
-/**
- * Factory for creating variant-specific packaging strategies
- */
-export 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 {
-        const variant = manifest.type;
-
-        switch (variant) {
-            case WebAppVariantType.Coded:
-                return new CodedAppStrategy(fileSystem);
-
-            case WebAppVariantType.JS:
-                return new JsAppsStrategy(fileSystem);
-
-            default:
-                throw new Error(
-                    `Unknown WebApp variant: ${manifest.type}. Supported variants: ${Object.values(WebAppVariantType).join(", ")}`,
-                );
-        }
-    }
-}

package/src/strategies/variant-strategy.ts

@@ -1,67 +0,0 @@
-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/src/utils/fs-helpers.ts

@@ -1,58 +0,0 @@
-import type { IFileSystem } from "@uipath/solutionpackager-tool-core";
-import { Path } from "@uipath/solutionpackager-tool-core";
-
-/**
- * Copy directory recursively from source to destination
- */
-export async function copyDirectoryAsync(
-    fileSystem: IFileSystem,
-    sourcePath: string,
-    destinationPath: string,
-): Promise<void> {
-    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);
-            }
-        }
-    }
-}
-
-/**
- * Find .nupkg file in a directory
- */
-export async function findNupkgInFolder(
-    fileSystem: IFileSystem,
-    directoryPath: string,
-): Promise<string | null> {
-    const entries = await fileSystem.readdir(directoryPath);
-
-    for (const entry of entries) {
-        const entryPath = Path.join(directoryPath, entry);
-        const stat = await fileSystem.stat(entryPath);
-
-        if (stat?.isFile() && entry.endsWith(".nupkg")) {
-            return entryPath;
-        }
-
-        if (stat?.isDirectory()) {
-            const found = await findNupkgInFolder(fileSystem, entryPath);
-            if (found) {
-                return found;
-            }
-        }
-    }
-
-    return null;
-}

package/src/utils/manifest-loader.ts

@@ -1,63 +0,0 @@
-import type { IFileSystem } from "@uipath/solutionpackager-tool-core";
-import { Path } from "@uipath/solutionpackager-tool-core";
-import type { WebAppManifest } from "../models/webapp-manifest.js";
-import { WEBAPP_MANIFEST_FILE_NAME } from "../models/webapp-manifest.js";
-
-/**
- * Load and parse webAppManifest.json from project path
- */
-export async function loadWebAppManifest(
-    fileSystem: IFileSystem,
-    projectPath: string,
-): Promise<WebAppManifest | null> {
-    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: WebAppManifest = JSON.parse(text);
-        return manifest;
-    } catch (error) {
-        throw new Error(
-            `Failed to parse ${WEBAPP_MANIFEST_FILE_NAME}: ${error instanceof Error ? error.message : String(error)}`,
-        );
-    }
-}
-
-/**
- * Resolve a stable projectId for a webapp, persisting it to
- * webAppManifest.json so re-packs are stable.
- */
-export async function ensureWebAppProjectId(
-    fileSystem: IFileSystem,
-    projectPath: string,
-): Promise<string> {
-    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: WebAppManifest = { ...manifest, projectId: id };
-        const manifestPath = Path.join(projectPath, WEBAPP_MANIFEST_FILE_NAME);
-        await fileSystem.writeFile(
-            manifestPath,
-            `${JSON.stringify(updated, null, 2)}\n`,
-        );
-    }
-    return id;
-}

package/src/webapp-tool-factory.ts

@@ -1,23 +0,0 @@
-import {
-    type IFileSystem,
-    type IProjectToolFactory,
-    type IToolLogger,
-    type ProjectTool,
-    type ProjectType,
-    ProjectTypes,
-} from "@uipath/solutionpackager-tool-core";
-import { WebAppTool } from "./webapp-tool.js";
-
-/**
- * Factory for creating WebApp project tools
- */
-export class WebAppToolFactory implements IProjectToolFactory {
-    readonly supportedTypes: readonly ProjectType[] = [ProjectTypes.AppV2];
-
-    async createAsync(
-        logger: IToolLogger,
-        fileSystem: IFileSystem,
-    ): Promise<ProjectTool> {
-        return new WebAppTool(fileSystem, logger);
-    }
-}