@uipath/packager-tool-webapp 1.204.0-preview.255 → 1.205.0-preview.256

package/dist/index.d.ts

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

package/dist/index.js

@@ -5,15 +5,93 @@ var WebAppVariantType;
   WebAppVariantType2["JS"] = "JS";
 })(WebAppVariantType ||= {});
 var WEBAPP_MANIFEST_FILE_NAME = "webAppManifest.json";
+// src/utils/manifest-loader.ts
+import { Path } from "@uipath/solutionpackager-tool-core";
+async function loadWebAppManifest(fileSystem, projectPath) {
+  const manifestPath = Path.join(projectPath, WEBAPP_MANIFEST_FILE_NAME);
+  const exists = await fileSystem.exists(manifestPath);
+  if (!exists) {
+    return null;
+  }
+  const content = await fileSystem.readFile(manifestPath);
+  if (!content) {
+    return null;
+  }
+  try {
+    const text = new TextDecoder().decode(content);
+    const manifest = 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 = Path.join(projectPath, WEBAPP_MANIFEST_FILE_NAME);
+    await fileSystem.writeFile(manifestPath, `${JSON.stringify(updated, null, 2)}
+`);
+  }
+  return id;
+}
 // src/webapp-tool.ts
 import {
-  Path as Path5,
+  Path as Path6,
   ProjectTool,
   TemporaryStorageService,
   ToolErrorCodes,
   ToolResult
 } from "@uipath/solutionpackager-tool-core";
 
+// src/utils/bundle-path.ts
+import { Path as Path2 } from "@uipath/solutionpackager-tool-core";
+function normalizeBundlePath(path) {
+  return path.replace(/\\/g, "/");
+}
+function isBundleRelativePath(path) {
+  const normalized = normalizeBundlePath(path);
+  const segments = normalized.split("/");
+  return !normalized.startsWith("/") && !/^[a-zA-Z]:/.test(normalized) && !segments.includes("..") && segments.some((segment) => segment !== "" && segment !== ".");
+}
+async function isCanonicalBundleChild(fileSystem, projectPath, bundlePath) {
+  const project = normalizeBundlePath(await fileSystem.realpath(projectPath)).replace(/\/+$/, "") || "/";
+  let bundle = project;
+  for (const segment of normalizeBundlePath(bundlePath).split("/")) {
+    if (!segment || segment === ".")
+      continue;
+    bundle = normalizeBundlePath(await fileSystem.realpath(Path2.join(bundle, segment))).replace(/\/+$/, "") || "/";
+  }
+  return bundle !== project && bundle.startsWith(project === "/" ? "/" : `${project}/`);
+}
+function isHtmlEntryPointPath(path) {
+  return typeof path === "string" && isBundleRelativePath(path) && /\.html?$/i.test(path);
+}
+async function resolveHtmlEntryPoint(fileSystem, folder, declaredPath) {
+  if (!isHtmlEntryPointPath(declaredPath))
+    return null;
+  const segments = normalizeBundlePath(declaredPath).split("/").filter((part) => part !== "" && part !== ".");
+  if (!(await fileSystem.stat(Path2.join(folder, ...segments)))?.isFile())
+    return null;
+  const actual = [];
+  for (const segment of segments) {
+    const entries = await fileSystem.readdir(Path2.join(folder, ...actual));
+    if (entries.includes(segment)) {
+      actual.push(segment);
+      continue;
+    }
+    const matches = entries.filter((entry) => entry.toLowerCase() === segment.toLowerCase());
+    if (matches.length !== 1)
+      return null;
+    actual.push(matches[0]);
+  }
+  return actual.join("/");
+}
+
 // src/constants.ts
 var PROJECT_JSON_FILE = "project.json";
 var DEFAULT_BUNDLE_PATH = "source/dist";
@@ -22,12 +100,23 @@ var CONTENT_APP_FOLDER_NAME = "app";
 var TARGET_RUNTIME = "Coded";
 var TARGET_JS_RUNTIME = "JS";
 var DEFAULT_ENTRY_POINT_TYPE = "api";
+var HTML_ENTRY_POINT_CANDIDATES = [
+  "index.html",
+  "main.html",
+  "app.html"
+];
 var ERROR_MESSAGES = {
   MANIFEST_NOT_FOUND: (file) => `WebApp manifest not found: ${file}. This file is required for WebApp projects.`,
   PROJECT_JSON_FOUND: "project.json found in WebApp project. The WebApp tool only supports Coded web apps without project.json.",
   MANIFEST_LOAD_FAILED: (file) => `Failed to load or parse ${file}`,
   BUNDLE_NOT_FOUND: (path) => `Compiled bundle not found at ${path}. Ensure the project is built before packing.`,
   BUNDLE_NOT_DIRECTORY: (path) => `Bundle path ${path} exists but is not a directory.`,
+  BUNDLE_OUTSIDE_PROJECT: (path) => `Bundle path ${path} resolves to the project root or outside the project. Use a child build output folder inside the project.`,
+  BUNDLE_NO_ENTRY_POINT: (path) => `Bundle at ${path} has no HTML entry point (${HTML_ENTRY_POINT_CANDIDATES.join(", ")}). Build the app before packing, or point config.bundlePath in webAppManifest.json at its build output.`,
+  MAIN_FILE_INVALID_TYPE: "Invalid webAppManifest.json: config.mainFile must be a string naming an HTML file, or be omitted.",
+  MAIN_FILE_NOT_IN_BUNDLE: (path, mainFile) => `${WEBAPP_MANIFEST_FILE_NAME} asks for "${mainFile}" as the app's main file, but the bundle at ${path} does not hold it. Name an HTML file inside the bundle in config.mainFile, or remove it to use the first of ${HTML_ENTRY_POINT_CANDIDATES.join(", ")} the bundle holds.`,
+  MAIN_FILE_LOST: (path, mainFile) => `Bundle at ${path} held "${mainFile}" when the pack started, but the copy taken for the package has not. Something changed the folder mid-pack — usually a build or watch process. Stop it and pack again.`,
+  BUNDLE_ENTRY_POINT_LOST: (path) => `Bundle at ${path} had an HTML entry point (${HTML_ENTRY_POINT_CANDIDATES.join(", ")}) when the pack started, but the copy taken for the package has none. Something changed the folder mid-pack — usually a build or watch process. Stop it and pack again.`,
   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.",
@@ -43,19 +132,19 @@ var ERROR_MESSAGES = {
 import {
   NugetConstants,
   NugetPackager,
-  Path as Path3,
+  Path as Path4,
   ProjectTypes,
   TargetFramework
 } from "@uipath/solutionpackager-tool-core";
 
 // src/utils/fs-helpers.ts
-import { Path } from "@uipath/solutionpackager-tool-core";
+import { Path as Path3 } from "@uipath/solutionpackager-tool-core";
 async function copyDirectoryAsync(fileSystem, sourcePath, destinationPath) {
   await fileSystem.mkdir(destinationPath);
   const entries = await fileSystem.readdir(sourcePath);
   for (const entry of entries) {
-    const sourceEntry = Path.join(sourcePath, entry);
-    const destEntry = Path.join(destinationPath, entry);
+    const sourceEntry = Path3.join(sourcePath, entry);
+    const destEntry = Path3.join(destinationPath, entry);
     const stat = await fileSystem.stat(sourceEntry);
     if (stat?.isDirectory()) {
       await copyDirectoryAsync(fileSystem, sourceEntry, destEntry);
@@ -68,41 +157,6 @@ 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;
@@ -118,10 +172,9 @@ class CodedAppStrategy {
     }
     const isCompiled = typed.config?.isCompiled ?? true;
     if (isCompiled) {
-      const fullBundlePath = Path3.join(projectPath, bundlePath);
-      const exists = await this.fileSystem.exists(fullBundlePath);
-      if (!exists) {
-        const message = ERROR_MESSAGES.BUNDLE_NOT_FOUND(fullBundlePath);
+      const fullBundlePath = Path4.join(projectPath, bundlePath);
+      const message = await this.describeBundleProblemAsync(fullBundlePath, typed.config?.mainFile);
+      if (message) {
         const warnable = logger;
         if (warnable?.warn) {
           warnable.warn(message);
@@ -139,7 +192,11 @@ class CodedAppStrategy {
       bundlePath = DEFAULT_BUNDLE_PATH;
     }
     const isCompiled = manifest.config?.isCompiled ?? true;
-    const fullBundlePath = Path3.join(projectPath, bundlePath);
+    const declaredMainFile = manifest.config?.mainFile;
+    const fullBundlePath = Path4.join(projectPath, bundlePath);
+    if (isBundleRelativePath(bundlePath) && !await isCanonicalBundleChild(this.fileSystem, projectPath, bundlePath)) {
+      throw new Error(ERROR_MESSAGES.BUNDLE_OUTSIDE_PROJECT(bundlePath));
+    }
     if (isCompiled) {
       logger?.progress("Validating compiled bundle...");
       const bundleExists = await this.fileSystem.exists(fullBundlePath);
@@ -150,21 +207,25 @@ class CodedAppStrategy {
       if (!bundleStat?.isDirectory()) {
         throw new Error(ERROR_MESSAGES.BUNDLE_NOT_DIRECTORY(fullBundlePath));
       }
+      const problem = await this.describeBundleEntryProblemAsync(fullBundlePath, declaredMainFile);
+      if (problem) {
+        throw new Error(problem);
+      }
     } else {
       logger?.info("Build mode (isCompiled=false) is not yet implemented in v1.");
       throw new Error(ERROR_MESSAGES.BUILD_NOT_SUPPORTED);
     }
-    const localBuildFolder = Path3.join(outputPath, NugetConstants.OutputFolderName);
-    const contentFolder = Path3.join(localBuildFolder, NugetConstants.ContentFolderName);
-    await this.fileSystem.mkdir(contentFolder);
+    const localBuildFolder = Path4.join(outputPath, `${NugetConstants.OutputFolderName}-${crypto.randomUUID()}`);
+    const contentFolder = Path4.join(localBuildFolder, NugetConstants.ContentFolderName);
     try {
+      await this.fileSystem.mkdir(contentFolder);
       logger?.progress("Copying bundle to content folder...");
       await copyDirectoryAsync(this.fileSystem, fullBundlePath, contentFolder);
       logger?.progress("Preparing metadata files...");
-      await this.prepareMetadataFiles(localBuildFolder, contentFolder, packageInfo, manifest, projectPath);
+      await this.prepareMetadataFiles(localBuildFolder, contentFolder, packageInfo, manifest, projectPath, fullBundlePath);
       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 NugetPackager(this.fileSystem);
       const result = await packager.packAsync(localBuildFolder, packageInfo, nupkgPath);
       logger?.info(`Package created successfully: ${result.outputPath}`);
@@ -177,21 +238,13 @@ class CodedAppStrategy {
       }
     }
   }
-  async prepareMetadataFiles(_localBuildFolder, contentFolder, _packageInfo, _manifest, projectPath) {
-    let mainFile = "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 = Path3.join(contentFolder, entry);
-        if (await this.fileSystem.exists(entryPath)) {
-          mainFile = entry;
-          break;
-        }
-      }
+  async prepareMetadataFiles(_localBuildFolder, contentFolder, _packageInfo, manifest, projectPath, sourceBundlePath) {
+    const declaredMainFile = manifest.config?.mainFile;
+    const mainFile = await this.resolveMainFileAsync(contentFolder, declaredMainFile);
+    if (!mainFile) {
+      throw new Error(declaredMainFile ? ERROR_MESSAGES.MAIN_FILE_LOST(sourceBundlePath, declaredMainFile) : ERROR_MESSAGES.BUNDLE_ENTRY_POINT_LOST(sourceBundlePath));
     }
-    const operatePath = Path3.join(contentFolder, NugetConstants.OperateFileName);
+    const operatePath = Path4.join(contentFolder, NugetConstants.OperateFileName);
     const operateModel = {
       projectId: await ensureWebAppProjectId(this.fileSystem, projectPath),
       main: mainFile,
@@ -205,17 +258,13 @@ class CodedAppStrategy {
     };
     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, "utf-8");
-      if (manifestContent) {
-        await this.fileSystem.writeFile(manifestDestPath, manifestContent);
-      }
-    }
-    const uipathJsonSourcePath = Path3.join(projectPath, "uipath.json");
-    const uipathJsonDestPath = Path3.join(contentFolder, "uipath.json");
+    await this.fileSystem.writeFile(Path4.join(contentFolder, WEBAPP_MANIFEST_FILE_NAME), JSON.stringify({
+      ...manifest,
+      config: { ...manifest.config, mainFile },
+      projectId: operateModel.projectId
+    }, null, 2));
+    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, "utf-8");
@@ -223,8 +272,8 @@ class CodedAppStrategy {
         await this.fileSystem.writeFile(uipathJsonDestPath, uipathJsonContent);
       }
     }
-    const actionSchemaSourcePath = Path3.join(projectPath, "action-schema.json");
-    const actionSchemaDestPath = Path3.join(contentFolder, "action-schema.json");
+    const actionSchemaSourcePath = Path4.join(projectPath, "action-schema.json");
+    const actionSchemaDestPath = Path4.join(contentFolder, "action-schema.json");
     const actionSchemaExists = await this.fileSystem.exists(actionSchemaSourcePath);
     if (actionSchemaExists) {
       const actionSchemaContent = await this.fileSystem.readFile(actionSchemaSourcePath, "utf-8");
@@ -232,7 +281,7 @@ class CodedAppStrategy {
         await this.fileSystem.writeFile(actionSchemaDestPath, actionSchemaContent);
       }
     }
-    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({
@@ -241,12 +290,12 @@ class CodedAppStrategy {
       }, 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 bindingsCandidatePaths = [
-      Path3.join(projectPath, "source", "bindings_v2.json"),
-      Path3.join(projectPath, "source", "bindings.json"),
-      Path3.join(projectPath, "bindings.json"),
-      Path3.join(projectPath, "bindings_v2.json")
+      Path4.join(projectPath, "source", "bindings_v2.json"),
+      Path4.join(projectPath, "source", "bindings.json"),
+      Path4.join(projectPath, "bindings.json"),
+      Path4.join(projectPath, "bindings_v2.json")
     ];
     let bindingsV2Json = null;
     for (const candidate of bindingsCandidatePaths) {
@@ -266,14 +315,14 @@ class CodedAppStrategy {
       }, 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) {
       const entryPointsData = await this.fileSystem.readFile(projectEntryPointsPath, "utf-8");
       if (entryPointsData) {
-        entryPointsContent = entryPointsData;
+        entryPointsContent = this.alignEntryPoint(entryPointsData, mainFile);
       } else {
         entryPointsContent = this.createDefaultEntryPoints(mainFile);
       }
@@ -281,18 +330,68 @@ class CodedAppStrategy {
       entryPointsContent = this.createDefaultEntryPoints(mainFile);
     }
     await this.fileSystem.writeFile(entryPointsPath, entryPointsContent);
-    const packageDescriptorPath = Path3.join(contentFolder, NugetConstants.PackageDescriptorFileName);
+    const packageDescriptorPath = Path4.join(contentFolder, NugetConstants.PackageDescriptorFileName);
     const packageDescriptor = {
       $schema: "https://cloud.uipath.com/draft/2024-12/package-descriptor",
       files: {
-        [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")
+        [NugetConstants.OperateFileName]: Path4.join(NugetConstants.ContentFolderName, NugetConstants.OperateFileName),
+        "entry-points.json": Path4.join(NugetConstants.ContentFolderName, "entry-points.json"),
+        "bindings.json": Path4.join(NugetConstants.ContentFolderName, "bindings_v2.json")
       }
     };
     const packageDescriptorJson = JSON.stringify(packageDescriptor, null, 2);
     await this.fileSystem.writeFile(packageDescriptorPath, packageDescriptorJson);
   }
+  async describeBundleProblemAsync(fullBundlePath, declaredMainFile) {
+    const bundleStat = await this.fileSystem.stat(fullBundlePath);
+    if (!bundleStat) {
+      return ERROR_MESSAGES.BUNDLE_NOT_FOUND(fullBundlePath);
+    }
+    if (!bundleStat.isDirectory()) {
+      return ERROR_MESSAGES.BUNDLE_NOT_DIRECTORY(fullBundlePath);
+    }
+    return this.describeBundleEntryProblemAsync(fullBundlePath, declaredMainFile);
+  }
+  async describeBundleEntryProblemAsync(fullBundlePath, declaredMainFile) {
+    if (declaredMainFile !== undefined && typeof declaredMainFile !== "string") {
+      return ERROR_MESSAGES.MAIN_FILE_INVALID_TYPE;
+    }
+    if (await this.resolveMainFileAsync(fullBundlePath, declaredMainFile)) {
+      return null;
+    }
+    return declaredMainFile !== undefined ? ERROR_MESSAGES.MAIN_FILE_NOT_IN_BUNDLE(fullBundlePath, declaredMainFile) : ERROR_MESSAGES.BUNDLE_NO_ENTRY_POINT(fullBundlePath);
+  }
+  async resolveMainFileAsync(folder, declaredMainFile) {
+    if (declaredMainFile === undefined) {
+      return this.findEntryPointAsync(folder);
+    }
+    return resolveHtmlEntryPoint(this.fileSystem, folder, declaredMainFile);
+  }
+  async findEntryPointAsync(folder) {
+    for (const candidate of HTML_ENTRY_POINT_CANDIDATES) {
+      const resolved = await resolveHtmlEntryPoint(this.fileSystem, folder, candidate);
+      if (resolved !== null)
+        return resolved;
+    }
+    return null;
+  }
+  alignEntryPoint(content, mainFile) {
+    const document = JSON.parse(content);
+    if (typeof document !== "object" || document === null || !("entryPoints" in document) || !Array.isArray(document.entryPoints)) {
+      throw new Error("Invalid entry-points.json: expected an entryPoints array.");
+    }
+    const primary = document.entryPoints[0];
+    if (typeof primary !== "object" || primary === null || Array.isArray(primary)) {
+      throw new Error("Invalid entry-points.json: expected a primary entry object.");
+    }
+    return JSON.stringify({
+      ...document,
+      entryPoints: [
+        { ...primary, filePath: mainFile },
+        ...document.entryPoints.slice(1)
+      ]
+    }, null, 2);
+  }
   createDefaultEntryPoints(mainFile) {
     const uniqueId = this.generateUniqueId();
     const entryPoints = {
@@ -339,7 +438,7 @@ class CodedAppStrategy {
 import {
   NugetConstants as NugetConstants2,
   NugetPackager as NugetPackager2,
-  Path as Path4,
+  Path as Path5,
   ProjectTypes as ProjectTypes2,
   TargetFramework as TargetFramework2
 } from "@uipath/solutionpackager-tool-core";
@@ -350,7 +449,7 @@ class JsAppsStrategy {
   }
   async validateAsync(args) {
     const { projectPath, logger } = args;
-    const appFolder = Path4.join(projectPath, APP_FOLDER_NAME);
+    const appFolder = Path5.join(projectPath, APP_FOLDER_NAME);
     const exists = await this.fileSystem.exists(appFolder);
     if (!exists) {
       const message = ERROR_MESSAGES.APP_FOLDER_NOT_FOUND(appFolder);
@@ -374,7 +473,7 @@ class JsAppsStrategy {
   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);
+    const appFolder = Path5.join(projectPath, APP_FOLDER_NAME);
     logger?.progress("Validating .app folder...");
     const appFolderExists = await this.fileSystem.exists(appFolder);
     if (!appFolderExists) {
@@ -384,9 +483,9 @@ class JsAppsStrategy {
     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);
+    const localBuildFolder = Path5.join(outputPath, NugetConstants2.OutputFolderName);
+    const contentFolder = Path5.join(localBuildFolder, NugetConstants2.ContentFolderName);
+    const contentAppFolder = Path5.join(contentFolder, CONTENT_APP_FOLDER_NAME);
     await this.fileSystem.mkdir(contentFolder);
     try {
       logger?.progress("Copying .app folder into content/app...");
@@ -395,7 +494,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 = Path4.join(outputPath, nupkgFileName);
+      const nupkgPath = Path5.join(outputPath, nupkgFileName);
       const packager = new NugetPackager2(this.fileSystem);
       const result = await packager.packAsync(localBuildFolder, packageInfo, nupkgPath);
       logger?.info(`Package created successfully: ${result.outputPath}`);
@@ -411,7 +510,7 @@ class JsAppsStrategy {
   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 operatePath = Path5.join(contentFolder, NugetConstants2.OperateFileName);
     const operateModel = {
       projectId: await ensureWebAppProjectId(this.fileSystem, projectPath),
       main: mainRelativeToContent,
@@ -425,8 +524,8 @@ class JsAppsStrategy {
     };
     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 manifestSourcePath = Path5.join(projectPath, WEBAPP_MANIFEST_FILE_NAME);
+    const manifestDestPath = Path5.join(contentFolder, WEBAPP_MANIFEST_FILE_NAME);
     const manifestExists = await this.fileSystem.exists(manifestSourcePath);
     if (manifestExists) {
       const manifestContent = await this.fileSystem.readFile(manifestSourcePath);
@@ -434,8 +533,8 @@ class JsAppsStrategy {
         await this.fileSystem.writeFile(manifestDestPath, manifestContent);
       }
     }
-    const uipathJsonSourcePath = Path4.join(projectPath, "uipath.json");
-    const uipathJsonDestPath = Path4.join(contentFolder, "uipath.json");
+    const uipathJsonSourcePath = Path5.join(projectPath, "uipath.json");
+    const uipathJsonDestPath = Path5.join(contentFolder, "uipath.json");
     const uipathJsonExists = await this.fileSystem.exists(uipathJsonSourcePath);
     if (uipathJsonExists) {
       const uipathJsonContent = await this.fileSystem.readFile(uipathJsonSourcePath);
@@ -443,20 +542,20 @@ class JsAppsStrategy {
         await this.fileSystem.writeFile(uipathJsonDestPath, uipathJsonContent);
       }
     }
-    const bindingsPath = Path4.join(contentFolder, "bindings.json");
+    const bindingsPath = Path5.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 bindingsV2Path = Path5.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");
+    const entryPointsPath = Path5.join(contentFolder, "entry-points.json");
+    const projectEntryPointsPath = Path5.join(projectPath, "entry-points.json");
     let entryPointsContent;
     const projectEntryPointsExists = await this.fileSystem.exists(projectEntryPointsPath);
     if (projectEntryPointsExists) {
@@ -470,12 +569,12 @@ class JsAppsStrategy {
       entryPointsContent = this.createDefaultEntryPoints(mainRelativeToContent);
     }
     await this.fileSystem.writeFile(entryPointsPath, entryPointsContent);
-    const packageDescriptorPath = Path4.join(contentFolder, NugetConstants2.PackageDescriptorFileName);
+    const packageDescriptorPath = Path5.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")
+        [NugetConstants2.OperateFileName]: Path5.join(NugetConstants2.ContentFolderName, NugetConstants2.OperateFileName),
+        "entry-points.json": Path5.join(NugetConstants2.ContentFolderName, "entry-points.json"),
+        "bindings.json": Path5.join(NugetConstants2.ContentFolderName, "bindings_v2.json")
       }
     };
     const packageDescriptorJson = JSON.stringify(packageDescriptor, null, 2);
@@ -605,7 +704,7 @@ class WebAppTool extends ProjectTool {
       let manifest;
       let strategy;
       try {
-        const prepared = await this.getManifestAndStrategy(options.projectPath);
+        const prepared = await this.getManifestAndStrategy(options.projectPath, options.codedBundle);
         manifest = prepared.manifest;
         strategy = prepared.strategy;
       } catch (error) {
@@ -635,20 +734,33 @@ class WebAppTool extends ProjectTool {
       await this._temporaryStorage.cleanup();
     } catch {}
   }
-  async getManifestAndStrategy(projectPath) {
-    const manifestPath = Path5.join(projectPath, WEBAPP_MANIFEST_FILE_NAME);
+  async getManifestAndStrategy(projectPath, codedBundle) {
+    const manifestPath = Path6.join(projectPath, WEBAPP_MANIFEST_FILE_NAME);
     const manifestExists = await this.fileSystem.exists(manifestPath);
-    if (!manifestExists) {
+    if (!manifestExists && !codedBundle) {
       throw new Error(ERROR_MESSAGES.MANIFEST_NOT_FOUND(WEBAPP_MANIFEST_FILE_NAME));
     }
-    const projectJsonPath = Path5.join(projectPath, PROJECT_JSON_FILE);
+    const projectJsonPath = Path6.join(projectPath, PROJECT_JSON_FILE);
     if (await this.fileSystem.exists(projectJsonPath)) {
       throw new Error(ERROR_MESSAGES.PROJECT_JSON_FOUND);
     }
-    const manifest = await loadWebAppManifest(this.fileSystem, projectPath);
+    let manifest = manifestExists ? await loadWebAppManifest(this.fileSystem, projectPath) : {
+      type: "Coded" /* Coded */,
+      solutionResourceSubType: "Coded" /* Coded */,
+      config: { isCompiled: true }
+    };
     if (!manifest) {
       throw new Error(ERROR_MESSAGES.MANIFEST_LOAD_FAILED(WEBAPP_MANIFEST_FILE_NAME));
     }
+    if (codedBundle) {
+      if (manifest.type !== "Coded" /* Coded */) {
+        throw new Error("A coded bundle requires a Coded webAppManifest.json.");
+      }
+      manifest = {
+        ...manifest,
+        config: { ...manifest.config, ...codedBundle }
+      };
+    }
     const strategy = VariantStrategyFactory.createStrategy(manifest, this.fileSystem);
     return { manifest, strategy };
   }
@@ -688,7 +800,8 @@ export {
   WEBAPP_MANIFEST_FILE_NAME,
   WebAppTool,
   WebAppToolFactory,
-  WebAppVariantType
+  WebAppVariantType,
+  ensureWebAppProjectId
 };
 
-//# debugId=117BAA70A6FBCC6564756E2164756E21
+//# debugId=AFDD418216D2D37664756E2164756E21

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

@@ -17,6 +17,14 @@ export interface CodedAppConfig {
     isCompiled?: boolean;
     /** Compiled bundle folder location (default: dist/) */
     bundlePath?: string;
+    /**
+     * The file inside the bundle that `operate.json` names as `main`. Omit it
+     * to let pack take the first of the default HTML candidates
+     * (index.html, main.html, app.html) the bundle holds. Set, it may be any HTML file in the bundle, and pack
+     * refuses the project when the bundle does not hold it — a `main` the
+     * package does not carry produces an app that cannot boot.
+     */
+    mainFile?: string;
     /** Optional build command for future scenarios */
     buildCommand?: string;
     isActionApp?: boolean;

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

@@ -26,6 +26,41 @@ export declare class CodedAppStrategy implements VariantStrategy {
      * Prepare metadata files (operate.json, package-descriptor.json, bindings.json, bindings_v2.json, entry-points.json)
      */
     private prepareMetadataFiles;
+    /**
+     * Why this bundle folder cannot be packed, or `null` when it can. Shared
+     * by `validateAsync` and the pack-time guard so the two never disagree
+     * about what counts as a usable bundle.
+     */
+    private describeBundleProblemAsync;
+    /**
+     * Why this bundle's entry point cannot be used, or `null` when it can. A
+     * `config.mainFile` the bundle does not hold is refused by name: falling
+     * back to `index.html` there would pack an app that boots a file the user
+     * did not ask for.
+     */
+    private describeBundleEntryProblemAsync;
+    /**
+     * The file `operate.json` names as `main`, or `null` when the folder does
+     * not hold it. A declared `config.mainFile` wins and may be any HTML file in
+     * the bundle, not only one of the three defaults; without one, the first
+     * default candidate present is used.
+     */
+    private resolveMainFileAsync;
+    /**
+     * The first HTML entry point present in a folder, or `null` when it holds
+     * none. One list, shared by the pack-time guard and the `operate.json`
+     * `main` lookup, so the file pack insists on is the file it then names.
+     *
+     * `stat().isFile()`, not `exists()`: `exists()` is true for a directory
+     * too, so a folder named `index.html` would satisfy the guard and then be
+     * named as `operate.json`'s `main`, which cannot boot.
+     */
+    private findEntryPointAsync;
+    /**
+     * Keep authored schemas and entry metadata; only the primary entry follows
+     * the HTML file selected for operate.json. The project file stays untouched.
+     */
+    private alignEntryPoint;
     /**
      * Create default entry-points.json structure
      */