@uipath/packager-tool-webapp 1.0.4 → 1.196.0

package/dist/constants.d.ts

@@ -9,10 +9,22 @@ export declare const PROJECT_JSON_FILE = "project.json";
  * Default bundle path if not specified in manifest
  */
 export declare const DEFAULT_BUNDLE_PATH = "source/dist";
+/**
+ * Pre-built app folder for the JS variant (source)
+ */
+export declare const APP_FOLDER_NAME = ".app";
+/**
+ * Destination folder inside the NuGet content folder for the JS variant
+ */
+export declare const CONTENT_APP_FOLDER_NAME = "app";
 /**
  * Target runtime for operate.json
  */
 export declare const TARGET_RUNTIME = "Coded";
+/**
+ * Target runtime for operate.json
+ */
+export declare const TARGET_JS_RUNTIME = "JS";
 /**
  * Default entry point type
  */
@@ -26,6 +38,8 @@ export declare const ERROR_MESSAGES: {
     readonly MANIFEST_LOAD_FAILED: (file: string) => string;
     readonly BUNDLE_NOT_FOUND: (path: string) => string;
     readonly BUNDLE_NOT_DIRECTORY: (path: string) => string;
+    readonly APP_FOLDER_NOT_FOUND: (path: string) => string;
+    readonly APP_FOLDER_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;

package/dist/index.d.ts

@@ -1,2 +1,4 @@
+export type { WebAppManifest } from "./models/webapp-manifest.js";
+export { WEBAPP_MANIFEST_FILE_NAME, WebAppVariantType, } from "./models/webapp-manifest.js";
 export { WebAppTool } from "./webapp-tool.js";
 export { WebAppToolFactory } from "./webapp-tool-factory.js";

package/dist/index.js

@@ -3,12 +3,12 @@ import { toolsFactoryRepository } from "@uipath/solutionpackager-tool-core";
 
 // src/webapp-tool-factory.ts
 import {
-  ProjectTypes as ProjectTypes2
+  ProjectTypes as ProjectTypes3
 } from "@uipath/solutionpackager-tool-core";
 
 // src/webapp-tool.ts
 import {
-  Path as Path4,
+  Path as Path5,
   ProjectTool,
   TemporaryStorageService,
   ToolErrorCodes,
@@ -18,7 +18,10 @@ import {
 // 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.`,
@@ -26,6 +29,8 @@ var ERROR_MESSAGES = {
   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}`,
@@ -201,14 +206,29 @@ class CodedAppStrategy {
       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({
+    const bindingsCandidatePaths = [
+      Path2.join(projectPath, "source", "bindings.json"),
+      Path2.join(projectPath, "bindings.json"),
+      Path2.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);
     }
+    await this.fileSystem.writeFile(bindingsV2Path, bindingsV2Json);
     const entryPointsPath = Path2.join(contentFolder, "entry-points.json");
     const projectEntryPointsPath = Path2.join(projectPath, "entry-points.json");
     let entryPointsContent;
@@ -226,6 +246,7 @@ class CodedAppStrategy {
     await this.fileSystem.writeFile(entryPointsPath, entryPointsContent);
     const packageDescriptorPath = Path2.join(contentFolder, NugetConstants.PackageDescriptorFileName);
     const packageDescriptor = {
+      $schema: "https://cloud.uipath.com/draft/2024-12/package-descriptor",
       files: {
         [NugetConstants.OperateFileName]: Path2.join(NugetConstants.ContentFolderName, NugetConstants.OperateFileName),
         "entry-points.json": Path2.join(NugetConstants.ContentFolderName, "entry-points.json"),
@@ -277,6 +298,194 @@ class CodedAppStrategy {
   }
 }
 
+// src/strategies/js-apps-strategy.ts
+import {
+  NugetConstants as NugetConstants2,
+  NugetPackager as NugetPackager2,
+  Path as Path3,
+  ProjectTypes as ProjectTypes2,
+  TargetFramework as TargetFramework2
+} from "@uipath/solutionpackager-tool-core";
+class JsAppsStrategy {
+  fileSystem;
+  constructor(fileSystem) {
+    this.fileSystem = fileSystem;
+  }
+  async validateAsync(args) {
+    const { projectPath, logger } = args;
+    const appFolder = Path3.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 = Path3.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 = Path3.join(outputPath, NugetConstants2.OutputFolderName);
+    const contentFolder = Path3.join(localBuildFolder, NugetConstants2.ContentFolderName);
+    const contentAppFolder = Path3.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 = Path3.join(outputPath, nupkgFileName);
+      const packager = new NugetPackager2(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 = Path3.join(contentFolder, NugetConstants2.OperateFileName);
+    const operateModel = {
+      projectId: packageInfo.id,
+      main: mainRelativeToContent,
+      contentType: ProjectTypes2.WebApp,
+      targetFramework: TargetFramework2.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 = Path3.join(projectPath, WEBAPP_MANIFEST_FILE_NAME);
+    const manifestDestPath = Path3.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 = Path3.join(projectPath, "uipath.json");
+    const uipathJsonDestPath = Path3.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 = Path3.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 = Path3.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 = Path3.join(contentFolder, "entry-points.json");
+    const projectEntryPointsPath = Path3.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 = Path3.join(contentFolder, NugetConstants2.PackageDescriptorFileName);
+    const packageDescriptor = {
+      files: {
+        [NugetConstants2.OperateFileName]: Path3.join(NugetConstants2.ContentFolderName, NugetConstants2.OperateFileName),
+        "entry-points.json": Path3.join(NugetConstants2.ContentFolderName, "entry-points.json"),
+        "bindings.json": Path3.join(NugetConstants2.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("-");
+  }
+}
+
 // src/strategies/variant-strategy-factory.ts
 class VariantStrategyFactory {
   static createStrategy(manifest, fileSystem) {
@@ -285,7 +494,7 @@ class VariantStrategyFactory {
       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.");
+        return new JsAppsStrategy(fileSystem);
       default:
         throw new Error(`Unknown WebApp variant: ${manifest.type}. Supported variants: ${Object.values(WebAppVariantType).join(", ")}`);
     }
@@ -293,9 +502,9 @@ class VariantStrategyFactory {
 }
 
 // src/utils/manifest-loader.ts
-import { Path as Path3 } from "@uipath/solutionpackager-tool-core";
+import { Path as Path4 } from "@uipath/solutionpackager-tool-core";
 async function loadWebAppManifest(fileSystem, projectPath) {
-  const manifestPath = Path3.join(projectPath, WEBAPP_MANIFEST_FILE_NAME);
+  const manifestPath = Path4.join(projectPath, WEBAPP_MANIFEST_FILE_NAME);
   const exists = await fileSystem.exists(manifestPath);
   if (!exists) {
     return null;
@@ -411,12 +620,12 @@ class WebAppTool extends ProjectTool {
     } catch {}
   }
   async getManifestAndStrategy(projectPath) {
-    const manifestPath = Path4.join(projectPath, WEBAPP_MANIFEST_FILE_NAME);
+    const manifestPath = Path5.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);
+    const projectJsonPath = Path5.join(projectPath, PROJECT_JSON_FILE);
     if (await this.fileSystem.exists(projectJsonPath)) {
       throw new Error(ERROR_MESSAGES.PROJECT_JSON_FOUND);
     }
@@ -452,7 +661,7 @@ class WebAppTool extends ProjectTool {
 
 // src/webapp-tool-factory.ts
 class WebAppToolFactory {
-  supportedTypes = [ProjectTypes2.AppV2];
+  supportedTypes = [ProjectTypes3.AppV2];
   async createAsync(logger, fileSystem) {
     return new WebAppTool(fileSystem, logger);
   }
@@ -461,6 +670,8 @@ class WebAppToolFactory {
 // src/index.ts
 toolsFactoryRepository.registerProjectToolFactory(new WebAppToolFactory);
 export {
+  WebAppVariantType,
   WebAppToolFactory,
-  WebAppTool
+  WebAppTool,
+  WEBAPP_MANIFEST_FILE_NAME
 };

package/dist/strategies/js-apps-strategy.d.ts

@@ -0,0 +1,40 @@
+import type { IFileSystem } from "@uipath/solutionpackager-tool-core";
+import type { WebAppManifest } from "../models/webapp-manifest.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 declare class JsAppsStrategy implements VariantStrategy {
+    private readonly fileSystem;
+    constructor(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.
+     */
+    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>;
+    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/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@uipath/packager-tool-webapp",
-    "version": "1.0.4",
+    "version": "1.196.0",
     "description": "UiPath WebApp tool implementation",
     "type": "module",
     "exports": {
@@ -18,23 +18,6 @@
         "registry": "https://registry.npmjs.org/"
     },
     "types": "./dist/index.d.ts",
-    "scripts": {
-        "build": "bun build ./src/index.ts --outdir dist --format esm --target browser --external @uipath/solutionpackager-tool-core && tsc --emitDeclarationOnly --outDir dist",
-        "dev": "bun build ./src/index.ts --outdir dist --format esm --target browser --external @uipath/solutionpackager-tool-core --watch",
-        "test": "vitest run",
-        "test:browser": "vitest run --config=vitest.browser.config.ts",
-        "test:coverage": "vitest run --coverage",
-        "test:browser:coverage": "vitest run --config=vitest.browser.config.ts --coverage",
-        "test:all": "bun run test && bun run test:browser",
-        "test:all:coverage": "bun run test:coverage && bun run test:browser:coverage",
-        "prepack": "bun run build",
-        "publish:dry": "bun publish --dry-run",
-        "publish:gh": "bun publish",
-        "version:patch": "bun version patch --no-git-tag-version",
-        "version:minor": "bun version minor --no-git-tag-version",
-        "version:major": "bun version major --no-git-tag-version",
-        "lint": "biome check ."
-    },
     "files": [
         "dist",
         "!dist/**/*.map",
@@ -43,16 +26,17 @@
     "author": "",
     "license": "ISC",
     "peerDependencies": {
-        "@uipath/solutionpackager-tool-core": "0.0.31"
+        "@uipath/solutionpackager-tool-core": "1.196.0"
     },
     "devDependencies": {
-        "@types/node": "^25.5.0",
-        "@uipath/solutionpackager-tool-core": "0.0.31",
-        "@vitest/browser": "^4.0.14",
-        "@vitest/browser-playwright": "^4.0.14",
-        "@vitest/coverage-v8": "^4.0.14",
+        "@types/node": "^25.5.2",
+        "@uipath/solutionpackager-tool-core": "1.196.0",
+        "@vitest/browser": "^4.1.6",
+        "@vitest/browser-playwright": "^4.1.6",
+        "@vitest/coverage-v8": "^4.1.6",
         "playwright": "^1.57.0",
-        "typescript": "^5.9.3",
-        "vitest": "^4.0.14"
-    }
+        "typescript": "^6.0.2",
+        "vitest": "^4.1.6"
+    },
+    "gitHead": "bed2b46f1ec33a47a7dcae2e6d4b7ab99bd06981"
 }

package/src/constants.ts

@@ -12,11 +12,26 @@ export const PROJECT_JSON_FILE = "project.json";
  */
 export const DEFAULT_BUNDLE_PATH = "source/dist";
 
+/**
+ * Pre-built app folder for the JS variant (source)
+ */
+export const APP_FOLDER_NAME = ".app";
+
+/**
+ * Destination folder inside the NuGet content folder for the JS variant
+ */
+export const CONTENT_APP_FOLDER_NAME = "app";
+
 /**
  * Target runtime for operate.json
  */
 export const TARGET_RUNTIME = "Coded";
 
+/**
+ * Target runtime for operate.json
+ */
+export const TARGET_JS_RUNTIME = "JS";
+
 /**
  * Default entry point type
  */
@@ -41,6 +56,12 @@ export const ERROR_MESSAGES = {
     BUNDLE_NOT_DIRECTORY: (path: string): string =>
         `Bundle path ${path} exists but is not a directory.`,
 
+    APP_FOLDER_NOT_FOUND: (path: string): string =>
+        `.app folder not found at ${path}. Ensure the project contains a .app folder.`,
+
+    APP_FOLDER_NOT_DIRECTORY: (path: string): string =>
+        `.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.",
 

package/src/index.ts

@@ -1,6 +1,11 @@
 import { toolsFactoryRepository } from "@uipath/solutionpackager-tool-core";
 import { WebAppToolFactory } from "./webapp-tool-factory.js";
 
+export type { WebAppManifest } from "./models/webapp-manifest.js";
+export {
+    WEBAPP_MANIFEST_FILE_NAME,
+    WebAppVariantType,
+} from "./models/webapp-manifest.js";
 export { WebAppTool } from "./webapp-tool.js";
 export { WebAppToolFactory } from "./webapp-tool-factory.js";
 

package/src/strategies/coded-app-strategy.ts

@@ -279,10 +279,32 @@ export class CodedAppStrategy implements VariantStrategy {
 
         // Create or copy bindings_v2.json (version 2.0)
         const bindingsV2Path = Path.join(contentFolder, "bindings_v2.json");
-        const bindingsV2Exists = await this.fileSystem.exists(bindingsV2Path);
+        const bindingsCandidatePaths = [
+            Path.join(projectPath, "source", "bindings.json"),
+            Path.join(projectPath, "bindings.json"),
+            Path.join(projectPath, "bindings_v2.json"),
+        ];
+
+        let bindingsV2Json: string | null = 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 (!bindingsV2Exists) {
-            const bindingsV2Json = JSON.stringify(
+        if (!bindingsV2Json) {
+            bindingsV2Json = JSON.stringify(
                 {
                     version: "2.0",
                     resources: [],
@@ -290,8 +312,8 @@ export class CodedAppStrategy implements VariantStrategy {
                 null,
                 2,
             );
-            await this.fileSystem.writeFile(bindingsV2Path, bindingsV2Json);
         }
+        await this.fileSystem.writeFile(bindingsV2Path, bindingsV2Json);
 
         // Create or copy entry-points.json
         const entryPointsPath = Path.join(contentFolder, "entry-points.json");
@@ -326,6 +348,8 @@ export class CodedAppStrategy implements VariantStrategy {
             NugetConstants.PackageDescriptorFileName,
         );
         const packageDescriptor: PackageDescriptorFileModel = {
+            $schema:
+                "https://cloud.uipath.com/draft/2024-12/package-descriptor",
             files: {
                 [NugetConstants.OperateFileName]: Path.join(
                     NugetConstants.ContentFolderName,

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

@@ -0,0 +1,374 @@
+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 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: packageInfo.id,
+            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

@@ -2,6 +2,7 @@ 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";
 
 /**
@@ -26,9 +27,7 @@ export class VariantStrategyFactory {
                 return new CodedAppStrategy(fileSystem);
 
             case WebAppVariantType.JS:
-                throw new Error(
-                    "JS variant is not yet implemented. Only Coded is supported in v1.",
-                );
+                return new JsAppsStrategy(fileSystem);
 
             default:
                 throw new Error(