@uipath/packager-tool-webapp 1.196.0 → 1.197.0-preview.65

package/dist/index.js

@@ -1,11 +1,10 @@
-// src/index.ts
-import { toolsFactoryRepository } from "@uipath/solutionpackager-tool-core";
-
-// src/webapp-tool-factory.ts
-import {
-  ProjectTypes as ProjectTypes3
-} 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 Path5,
@@ -40,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";
@@ -77,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;
@@ -92,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);
@@ -112,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);
@@ -127,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...");
@@ -137,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}`);
@@ -150,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,
@@ -178,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({
@@ -205,11 +231,11 @@ class CodedAppStrategy {
       }, null, 2);
       await this.fileSystem.writeFile(bindingsPath, bindingsJson);
     }
-    const bindingsV2Path = Path2.join(contentFolder, "bindings_v2.json");
+    const bindingsV2Path = Path3.join(contentFolder, "bindings_v2.json");
     const bindingsCandidatePaths = [
-      Path2.join(projectPath, "source", "bindings.json"),
-      Path2.join(projectPath, "bindings.json"),
-      Path2.join(projectPath, "bindings_v2.json")
+      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) {
@@ -229,14 +255,14 @@ class CodedAppStrategy {
       }, null, 2);
     }
     await this.fileSystem.writeFile(bindingsV2Path, bindingsV2Json);
-    const entryPointsPath = Path2.join(contentFolder, "entry-points.json");
-    const projectEntryPointsPath = Path2.join(projectPath, "entry-points.json");
+    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);
       }
@@ -244,13 +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);
@@ -302,7 +328,7 @@ class CodedAppStrategy {
 import {
   NugetConstants as NugetConstants2,
   NugetPackager as NugetPackager2,
-  Path as Path3,
+  Path as Path4,
   ProjectTypes as ProjectTypes2,
   TargetFramework as TargetFramework2
 } from "@uipath/solutionpackager-tool-core";
@@ -313,7 +339,7 @@ class JsAppsStrategy {
   }
   async validateAsync(args) {
     const { projectPath, logger } = args;
-    const appFolder = Path3.join(projectPath, APP_FOLDER_NAME);
+    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);
@@ -337,7 +363,7 @@ class JsAppsStrategy {
   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);
+    const appFolder = Path4.join(projectPath, APP_FOLDER_NAME);
     logger?.progress("Validating .app folder...");
     const appFolderExists = await this.fileSystem.exists(appFolder);
     if (!appFolderExists) {
@@ -347,9 +373,9 @@ class JsAppsStrategy {
     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);
+    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...");
@@ -358,7 +384,7 @@ class JsAppsStrategy {
       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 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}`);
@@ -371,12 +397,12 @@ class JsAppsStrategy {
       }
     }
   }
-  async prepareMetadataFiles(contentFolder, contentAppFolder, packageInfo, _manifest, projectPath) {
+  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 operatePath = Path4.join(contentFolder, NugetConstants2.OperateFileName);
     const operateModel = {
-      projectId: packageInfo.id,
+      projectId: await ensureWebAppProjectId(this.fileSystem, projectPath),
       main: mainRelativeToContent,
       contentType: ProjectTypes2.WebApp,
       targetFramework: TargetFramework2.Portable,
@@ -388,8 +414,8 @@ class JsAppsStrategy {
     };
     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 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);
@@ -397,8 +423,8 @@ class JsAppsStrategy {
         await this.fileSystem.writeFile(manifestDestPath, manifestContent);
       }
     }
-    const uipathJsonSourcePath = Path3.join(projectPath, "uipath.json");
-    const uipathJsonDestPath = Path3.join(contentFolder, "uipath.json");
+    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);
@@ -406,20 +432,20 @@ class JsAppsStrategy {
         await this.fileSystem.writeFile(uipathJsonDestPath, uipathJsonContent);
       }
     }
-    const bindingsPath = Path3.join(contentFolder, "bindings.json");
+    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 = Path3.join(contentFolder, "bindings_v2.json");
+    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 = Path3.join(contentFolder, "entry-points.json");
-    const projectEntryPointsPath = Path3.join(projectPath, "entry-points.json");
+    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) {
@@ -433,12 +459,12 @@ class JsAppsStrategy {
       entryPointsContent = this.createDefaultEntryPoints(mainRelativeToContent);
     }
     await this.fileSystem.writeFile(entryPointsPath, entryPointsContent);
-    const packageDescriptorPath = Path3.join(contentFolder, NugetConstants2.PackageDescriptorFileName);
+    const packageDescriptorPath = Path4.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")
+        [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);
@@ -501,27 +527,6 @@ class VariantStrategyFactory {
   }
 }
 
-// src/utils/manifest-loader.ts
-import { Path as Path4 } from "@uipath/solutionpackager-tool-core";
-async function loadWebAppManifest(fileSystem, projectPath) {
-  const manifestPath = Path4.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;
@@ -658,20 +663,21 @@ class WebAppTool extends ProjectTool {
     };
   }
 }
-
 // src/webapp-tool-factory.ts
+import {
+  ProjectTypes as ProjectTypes3
+} from "@uipath/solutionpackager-tool-core";
 class WebAppToolFactory {
   supportedTypes = [ProjectTypes3.AppV2];
   async createAsync(logger, fileSystem) {
     return new WebAppTool(fileSystem, logger);
   }
 }
-
-// src/index.ts
-toolsFactoryRepository.registerProjectToolFactory(new WebAppToolFactory);
 export {
   WebAppVariantType,
   WebAppToolFactory,
   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/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,42 +1,31 @@
 {
-    "name": "@uipath/packager-tool-webapp",
-    "version": "1.196.0",
-    "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",
-        "!dist/**/*.map",
-        "src"
-    ],
-    "author": "",
-    "license": "ISC",
-    "peerDependencies": {
-        "@uipath/solutionpackager-tool-core": "1.196.0"
-    },
-    "devDependencies": {
-        "@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": "^6.0.2",
-        "vitest": "^4.1.6"
-    },
-    "gitHead": "bed2b46f1ec33a47a7dcae2e6d4b7ab99bd06981"
+  "name": "@uipath/packager-tool-webapp",
+  "version": "1.197.0-preview.65",
+  "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": "9388ccbe5e739c9578bfd9b5395980fb63e11d9c"
 }

package/src/index.ts

@@ -1,6 +1,5 @@
-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,
@@ -8,5 +7,3 @@ export {
 } 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,
@@ -330,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);
             }

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

@@ -20,6 +20,7 @@ import {
 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";
 
 /**
@@ -156,8 +157,8 @@ export class JsAppsStrategy implements VariantStrategy {
      */
     private async prepareMetadataFiles(
         contentFolder: string,
-        contentAppFolder: string,
-        packageInfo: {
+        _contentAppFolder: string,
+        _packageInfo: {
             id: string;
             version: string;
             author?: string;
@@ -177,7 +178,10 @@ export class JsAppsStrategy implements VariantStrategy {
             NugetConstants.OperateFileName,
         );
         const operateModel: OperateFileModel & { targetRuntime: string } = {
-            projectId: packageInfo.id,
+            projectId: await ensureWebAppProjectId(
+                this.fileSystem,
+                projectPath,
+            ),
             main: mainRelativeToContent,
             contentType: ProjectTypes.WebApp,
             targetFramework: TargetFramework.Portable,

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;
+}