@uipath/packager-tool-webapp 1.0.5 → 1.197.0-preview.64

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

@@ -1,14 +1,13 @@
-// 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/models/webapp-manifest.ts
+var WebAppVariantType;
+((WebAppVariantType2) => {
+  WebAppVariantType2["Coded"] = "Coded";
+  WebAppVariantType2["JS"] = "JS";
+})(WebAppVariantType ||= {});
+var WEBAPP_MANIFEST_FILE_NAME = "webAppManifest.json";
 // src/webapp-tool.ts
 import {
-  Path as Path4,
+  Path as Path5,
   ProjectTool,
   TemporaryStorageService,
   ToolErrorCodes,
@@ -18,7 +17,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 +28,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}`,
@@ -35,19 +39,11 @@ var ERROR_MESSAGES = {
   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,
+  Path as Path3,
   ProjectTypes,
   TargetFramework
 } from "@uipath/solutionpackager-tool-core";
@@ -72,6 +68,41 @@ async function copyDirectoryAsync(fileSystem, sourcePath, destinationPath) {
   }
 }
 
+// src/utils/manifest-loader.ts
+import { Path as Path2 } from "@uipath/solutionpackager-tool-core";
+async function loadWebAppManifest(fileSystem, projectPath) {
+  const manifestPath = Path2.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 = Path2.join(projectPath, WEBAPP_MANIFEST_FILE_NAME);
+    await fileSystem.writeFile(manifestPath, `${JSON.stringify(updated, null, 2)}
+`);
+  }
+  return id;
+}
+
 // src/strategies/coded-app-strategy.ts
 class CodedAppStrategy {
   fileSystem;
@@ -87,7 +118,7 @@ class CodedAppStrategy {
     }
     const isCompiled = typed.config?.isCompiled ?? true;
     if (isCompiled) {
-      const fullBundlePath = Path2.join(projectPath, bundlePath);
+      const fullBundlePath = Path3.join(projectPath, bundlePath);
       const exists = await this.fileSystem.exists(fullBundlePath);
       if (!exists) {
         const message = ERROR_MESSAGES.BUNDLE_NOT_FOUND(fullBundlePath);
@@ -107,7 +138,7 @@ class CodedAppStrategy {
       bundlePath = DEFAULT_BUNDLE_PATH;
     }
     const isCompiled = manifest.config?.isCompiled ?? true;
-    const fullBundlePath = Path2.join(projectPath, bundlePath);
+    const fullBundlePath = Path3.join(projectPath, bundlePath);
     if (isCompiled) {
       logger?.progress("Validating compiled bundle...");
       const bundleExists = await this.fileSystem.exists(fullBundlePath);
@@ -122,8 +153,8 @@ class CodedAppStrategy {
       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);
+    const localBuildFolder = Path3.join(outputPath, NugetConstants.OutputFolderName);
+    const contentFolder = Path3.join(localBuildFolder, NugetConstants.ContentFolderName);
     await this.fileSystem.mkdir(contentFolder);
     try {
       logger?.progress("Copying bundle to content folder...");
@@ -132,7 +163,7 @@ class CodedAppStrategy {
       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 nupkgPath = Path3.join(outputPath, nupkgFileName);
       const packager = new NugetPackager(this.fileSystem);
       const result = await packager.packAsync(localBuildFolder, packageInfo, nupkgPath);
       logger?.info(`Package created successfully: ${result.outputPath}`);
@@ -145,23 +176,23 @@ class CodedAppStrategy {
       }
     }
   }
-  async prepareMetadataFiles(_localBuildFolder, contentFolder, packageInfo, _manifest, projectPath) {
+  async prepareMetadataFiles(_localBuildFolder, contentFolder, _packageInfo, _manifest, projectPath) {
     let mainFile = "index.html";
-    const indexHtmlPath = Path2.join(contentFolder, "index.html");
+    const indexHtmlPath = Path3.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);
+        const entryPath = Path3.join(contentFolder, entry);
         if (await this.fileSystem.exists(entryPath)) {
           mainFile = entry;
           break;
         }
       }
     }
-    const operatePath = Path2.join(contentFolder, NugetConstants.OperateFileName);
+    const operatePath = Path3.join(contentFolder, NugetConstants.OperateFileName);
     const operateModel = {
-      projectId: packageInfo.id,
+      projectId: await ensureWebAppProjectId(this.fileSystem, projectPath),
       main: mainFile,
       contentType: ProjectTypes.WebApp,
       targetFramework: TargetFramework.Portable,
@@ -173,25 +204,25 @@ class CodedAppStrategy {
     };
     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 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);
+      const manifestContent = await this.fileSystem.readFile(manifestSourcePath, "utf-8");
       if (manifestContent) {
         await this.fileSystem.writeFile(manifestDestPath, manifestContent);
       }
     }
-    const uipathJsonSourcePath = Path2.join(projectPath, "uipath.json");
-    const uipathJsonDestPath = Path2.join(contentFolder, "uipath.json");
+    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);
+      const uipathJsonContent = await this.fileSystem.readFile(uipathJsonSourcePath, "utf-8");
       if (uipathJsonContent) {
         await this.fileSystem.writeFile(uipathJsonDestPath, uipathJsonContent);
       }
     }
-    const bindingsPath = Path2.join(contentFolder, "bindings.json");
+    const bindingsPath = Path3.join(contentFolder, "bindings.json");
     const bindingsExists = await this.fileSystem.exists(bindingsPath);
     if (!bindingsExists) {
       const bindingsJson = JSON.stringify({
@@ -200,23 +231,38 @@ class CodedAppStrategy {
       }, 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({
+    const bindingsV2Path = Path3.join(contentFolder, "bindings_v2.json");
+    const bindingsCandidatePaths = [
+      Path3.join(projectPath, "source", "bindings.json"),
+      Path3.join(projectPath, "bindings.json"),
+      Path3.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 = Path2.join(contentFolder, "entry-points.json");
-    const projectEntryPointsPath = Path2.join(projectPath, "entry-points.json");
+    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);
+      const entryPointsData = await this.fileSystem.readFile(projectEntryPointsPath, "utf-8");
       if (entryPointsData) {
-        entryPointsContent = new TextDecoder().decode(entryPointsData);
+        entryPointsContent = entryPointsData;
       } else {
         entryPointsContent = this.createDefaultEntryPoints(mainFile);
       }
@@ -224,12 +270,13 @@ class CodedAppStrategy {
       entryPointsContent = this.createDefaultEntryPoints(mainFile);
     }
     await this.fileSystem.writeFile(entryPointsPath, entryPointsContent);
-    const packageDescriptorPath = Path2.join(contentFolder, NugetConstants.PackageDescriptorFileName);
+    const packageDescriptorPath = Path3.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"),
-        "bindings.json": Path2.join(NugetConstants.ContentFolderName, "bindings_v2.json")
+        [NugetConstants.OperateFileName]: Path3.join(NugetConstants.ContentFolderName, NugetConstants.OperateFileName),
+        "entry-points.json": Path3.join(NugetConstants.ContentFolderName, "entry-points.json"),
+        "bindings.json": Path3.join(NugetConstants.ContentFolderName, "bindings_v2.json")
       }
     };
     const packageDescriptorJson = JSON.stringify(packageDescriptor, null, 2);
@@ -277,6 +324,194 @@ class CodedAppStrategy {
   }
 }
 
+// src/strategies/js-apps-strategy.ts
+import {
+  NugetConstants as NugetConstants2,
+  NugetPackager as NugetPackager2,
+  Path as Path4,
+  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 = Path4.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 = Path4.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 = Path4.join(outputPath, NugetConstants2.OutputFolderName);
+    const contentFolder = Path4.join(localBuildFolder, NugetConstants2.ContentFolderName);
+    const contentAppFolder = Path4.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 = Path4.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 = Path4.join(contentFolder, NugetConstants2.OperateFileName);
+    const operateModel = {
+      projectId: await ensureWebAppProjectId(this.fileSystem, projectPath),
+      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 = Path4.join(projectPath, WEBAPP_MANIFEST_FILE_NAME);
+    const manifestDestPath = Path4.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 = Path4.join(projectPath, "uipath.json");
+    const uipathJsonDestPath = Path4.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 = Path4.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 = Path4.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 = Path4.join(contentFolder, "entry-points.json");
+    const projectEntryPointsPath = Path4.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 = Path4.join(contentFolder, NugetConstants2.PackageDescriptorFileName);
+    const packageDescriptor = {
+      files: {
+        [NugetConstants2.OperateFileName]: Path4.join(NugetConstants2.ContentFolderName, NugetConstants2.OperateFileName),
+        "entry-points.json": Path4.join(NugetConstants2.ContentFolderName, "entry-points.json"),
+        "bindings.json": Path4.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,34 +520,13 @@ 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(", ")}`);
     }
   }
 }
 
-// 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;
@@ -411,12 +625,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);
     }
@@ -449,18 +663,21 @@ class WebAppTool extends ProjectTool {
     };
   }
 }
-
 // src/webapp-tool-factory.ts
+import {
+  ProjectTypes as ProjectTypes3
+} from "@uipath/solutionpackager-tool-core";
 class WebAppToolFactory {
-  supportedTypes = [ProjectTypes2.AppV2];
+  supportedTypes = [ProjectTypes3.AppV2];
   async createAsync(logger, fileSystem) {
     return new WebAppTool(fileSystem, logger);
   }
 }
-
-// src/index.ts
-toolsFactoryRepository.registerProjectToolFactory(new WebAppToolFactory);
 export {
+  WebAppVariantType,
   WebAppToolFactory,
-  WebAppTool
+  WebAppTool,
+  WEBAPP_MANIFEST_FILE_NAME
 };
+
+//# debugId=D42E6DA7B2DF063064756E2164756E21

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

@@ -34,6 +34,7 @@ export type WebAppManifest<T extends WebAppVariantType = WebAppVariantType> = {
     type: T;
     solutionResourceSubType: string;
     config?: ManifestConfigMap[T];
+    projectId?: string;
 };
 export declare const WEBAPP_MANIFEST_FILE_NAME = "webAppManifest.json";
 export {};

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/dist/utils/manifest-loader.d.ts

@@ -4,3 +4,8 @@ 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>;
+/**
+ * Resolve a stable projectId for a webapp, persisting it to
+ * webAppManifest.json so re-packs are stable.
+ */
+export declare function ensureWebAppProjectId(fileSystem: IFileSystem, projectPath: string): Promise<string>;

package/package.json

@@ -1,59 +1,31 @@
 {
-    "name": "@uipath/packager-tool-webapp",
-    "version": "1.0.5",
-    "description": "UiPath WebApp tool implementation",
-    "type": "module",
-    "exports": {
-        ".": {
-            "source": "./src/index.ts",
-            "default": "./dist/index.js"
-        }
-    },
-    "repository": {
-        "type": "git",
-        "url": "https://github.com/UiPath/cli.git",
-        "directory": "packages/packager/packager-tool-webapp"
-    },
-    "publishConfig": {
-        "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",
-        "src"
-    ],
-    "author": "",
-    "license": "ISC",
-    "peerDependencies": {
-        "@uipath/solutionpackager-tool-core": "0.0.33"
-    },
-    "devDependencies": {
-        "@types/node": "^25.5.0",
-        "@uipath/solutionpackager-tool-core": "0.0.33",
-        "@vitest/browser": "^4.0.14",
-        "@vitest/browser-playwright": "^4.0.14",
-        "@vitest/coverage-v8": "^4.0.14",
-        "playwright": "^1.57.0",
-        "typescript": "^5.9.3",
-        "vitest": "^4.0.14"
-    },
-    "gitHead": "3f1b4d8e9f910be81e4cab956537f21dbd5d63ac"
+  "name": "@uipath/packager-tool-webapp",
+  "version": "1.197.0-preview.64",
+  "description": "UiPath WebApp tool implementation",
+  "type": "module",
+  "exports": {
+    ".": {
+      "source": "./src/index.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/UiPath/cli.git",
+    "directory": "packages/packager/packager-tool-webapp"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/"
+  },
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "src"
+  ],
+  "author": "",
+  "license": "ISC",
+  "peerDependencies": {
+    "@uipath/solutionpackager-tool-core": "1.197.0"
+  },
+  "gitHead": "3977b977945bf519336258da69fd271433eaaef4"
 }

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,7 +1,9 @@
-import { toolsFactoryRepository } from "@uipath/solutionpackager-tool-core";
-import { WebAppToolFactory } from "./webapp-tool-factory.js";
-
+// WebApp tool factory. Consumers register it explicitly via
+// `toolsFactoryRepository.registerProjectToolFactory(new WebAppToolFactory())`.
+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";
-
-toolsFactoryRepository.registerProjectToolFactory(new WebAppToolFactory());

package/src/models/webapp-manifest.ts

@@ -40,6 +40,7 @@ export type WebAppManifest<T extends WebAppVariantType = WebAppVariantType> = {
     type: T;
     solutionResourceSubType: string;
     config?: ManifestConfigMap[T];
+    projectId?: string;
 };
 
 export const WEBAPP_MANIFEST_FILE_NAME = "webAppManifest.json";

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

@@ -22,6 +22,7 @@ import {
     type WebAppVariantType,
 } 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";
 
 /**
@@ -179,7 +180,7 @@ export class CodedAppStrategy implements VariantStrategy {
     private async prepareMetadataFiles(
         _localBuildFolder: string,
         contentFolder: string,
-        packageInfo: {
+        _packageInfo: {
             id: string;
             version: string;
             author?: string;
@@ -210,7 +211,10 @@ export class CodedAppStrategy implements VariantStrategy {
             NugetConstants.OperateFileName,
         );
         const operateModel: OperateFileModel & { targetRuntime: string } = {
-            projectId: packageInfo.id,
+            projectId: await ensureWebAppProjectId(
+                this.fileSystem,
+                projectPath,
+            ),
             main: mainFile,
             contentType: ProjectTypes.WebApp,
             targetFramework: TargetFramework.Portable,
@@ -235,8 +239,10 @@ export class CodedAppStrategy implements VariantStrategy {
         );
         const manifestExists = await this.fileSystem.exists(manifestSourcePath);
         if (manifestExists) {
-            const manifestContent =
-                await this.fileSystem.readFile(manifestSourcePath);
+            const manifestContent = await this.fileSystem.readFile(
+                manifestSourcePath,
+                "utf-8",
+            );
             if (manifestContent) {
                 await this.fileSystem.writeFile(
                     manifestDestPath,
@@ -251,8 +257,10 @@ export class CodedAppStrategy implements VariantStrategy {
         const uipathJsonExists =
             await this.fileSystem.exists(uipathJsonSourcePath);
         if (uipathJsonExists) {
-            const uipathJsonContent =
-                await this.fileSystem.readFile(uipathJsonSourcePath);
+            const uipathJsonContent = await this.fileSystem.readFile(
+                uipathJsonSourcePath,
+                "utf-8",
+            );
             if (uipathJsonContent) {
                 await this.fileSystem.writeFile(
                     uipathJsonDestPath,
@@ -279,10 +287,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 +320,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");
@@ -308,9 +338,10 @@ export class CodedAppStrategy implements VariantStrategy {
         if (projectEntryPointsExists) {
             const entryPointsData = await this.fileSystem.readFile(
                 projectEntryPointsPath,
+                "utf-8",
             );
             if (entryPointsData) {
-                entryPointsContent = new TextDecoder().decode(entryPointsData);
+                entryPointsContent = entryPointsData;
             } else {
                 entryPointsContent = this.createDefaultEntryPoints(mainFile);
             }
@@ -326,6 +357,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,378 @@
+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

@@ -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(

package/src/utils/manifest-loader.ts

@@ -32,3 +32,32 @@ export async function loadWebAppManifest(
         );
     }
 }
+
+/**
+ * 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;
+}