@uipath/case-tool 1.201.0 → 1.202.0-preview.136

package/dist/{packager-tool-5arsyj36.js → packager-tool-yc4kw997.js}

@@ -5,7 +5,9 @@ var DEFAULT_BASE_URL = "https://cloud.uipath.com";
 var DEFAULT_AUTH_TIMEOUT_MS = 5 * 60 * 1000;
 var AUTH_TIMEOUT_ERROR_CODE = "EAUTHTIMEOUT";
 var AUTH_CANCELLED_ERROR_CODE = "EAUTHCANCELLED";
+var AUTH_RECLAIMED_ERROR_CODE = "EAUTHRECLAIMED";
+var DEFAULT_REDIRECT_URI = "http://localhost:8104/oidc/login";
 
-export { UIPATH_HOME_DIR, AUTH_FILENAME, DEFAULT_BASE_URL, DEFAULT_AUTH_TIMEOUT_MS, AUTH_TIMEOUT_ERROR_CODE, AUTH_CANCELLED_ERROR_CODE };
+export { UIPATH_HOME_DIR, AUTH_FILENAME, DEFAULT_BASE_URL, DEFAULT_AUTH_TIMEOUT_MS, AUTH_TIMEOUT_ERROR_CODE, AUTH_CANCELLED_ERROR_CODE, AUTH_RECLAIMED_ERROR_CODE, DEFAULT_REDIRECT_URI };
 
-//# debugId=E98AE5255EE78AC164756E2164756E21
+//# debugId=75C147C6FAA3208364756E2164756E21

package/dist/packager-tool.js

@@ -1,10 +1,13 @@
 import {
   toolsFactoryRepository
-} from "./packager-tool-wvqz81mx.js";
+} from "./packager-tool-gtzs471w.js";
 import {
   zipSync
 } from "./packager-tool-b098y4a2.js";
-import"./packager-tool-wckvcay0.js";
+import {
+  __require,
+  __toESM
+} from "./packager-tool-1yh8g550.js";
 
 // ../packager/packager-core/dist/index.js
 class Path {
@@ -925,6 +928,7 @@ var ProjectTypes;
 ((ProjectTypes2) => {
   ProjectTypes2["Agent"] = "Agent";
   ProjectTypes2["Api"] = "Api";
+  ProjectTypes2["BusinessRules"] = "BusinessRules";
   ProjectTypes2["Connector"] = "Connector";
   ProjectTypes2["CaseManagement"] = "CaseManagement";
   ProjectTypes2["Flow"] = "Flow";
@@ -1293,7 +1297,8 @@ class ToolsFactoryRepository {
   getProjectToolFactory(projectType) {
     const factory = this.projectFactoryMap.get(projectType);
     if (!factory) {
-      throw new Error(`No tool factory found for project type '${projectType}'`);
+      const known = [...this.projectFactoryMap.keys()].join(", ");
+      throw new Error(`Cannot pack project type '${projectType}': no packager is installed for it. ` + `Project types that can be packed: ${known || "none"}.`);
     }
     return factory;
   }
@@ -1309,10 +1314,22 @@ if (!_global[REGISTRY_KEY]) {
 }
 var toolsFactoryRepository2 = _global[REGISTRY_KEY];
 
+// ../packager/packager-tool-case/src/case-bpmn-compiler.ts
+var COMPILER_KEY = Symbol.for("@uipath/packager-tool-case/caseBpmnCompiler");
+var _global2 = globalThis;
+function registerCaseBpmnCompiler(caseBpmnCompiler) {
+  _global2[COMPILER_KEY] = caseBpmnCompiler;
+}
+function getCaseBpmnCompiler() {
+  return _global2[COMPILER_KEY];
+}
+
 // ../packager/packager-tool-case/src/case-tool.ts
 var CaseConstants = {
   EntryPointsFileName: "entry-points.json",
-  BindingsV2FileName: "bindings_v2.json"
+  BindingsV2FileName: "bindings_v2.json",
+  CasePlanFileName: "caseplan.json",
+  CompiledBpmnFileName: "caseplan.json.bpmn"
 };
 
 class CaseTool extends ProjectTool {
@@ -1336,6 +1353,11 @@ class CaseTool extends ProjectTool {
     try {
       this.logger.progress("Copying files...");
       await this.copyFiles(options.projectPath, contentFolder);
+      this.logger.progress("Compiling case plan to BPMN...");
+      const compileResult = await this.compileCasePlan(options.projectPath, contentFolder);
+      if (!compileResult.isSuccess) {
+        return compileResult;
+      }
       this.logger.progress("Creating operate.json file...");
       await this.createOperateFile(options, contentFolder);
       this.logger.progress("Creating package-descriptor.json file...");
@@ -1392,6 +1414,59 @@ class CaseTool extends ProjectTool {
       }
     }
   }
+  async compileCasePlan(projectPath, contentFolder) {
+    const compile = getCaseBpmnCompiler();
+    const casePlanPath = Path.join(projectPath, CaseConstants.CasePlanFileName);
+    if (!compile || !await this.fileSystem.exists(casePlanPath)) {
+      return this.checkEntryPointBpmnPresent(contentFolder);
+    }
+    const casePlan = await this.fileSystem.readFile(casePlanPath);
+    if (!casePlan || casePlan.length === 0) {
+      return ToolResult.error(ToolErrorCodes.InternalError, `'${CaseConstants.CasePlanFileName}' in ${projectPath} is empty, so there is nothing to compile into '${CaseConstants.CompiledBpmnFileName}'. Author the case plan, or re-scaffold the project with 'uip maestro case init'.`);
+    }
+    try {
+      const bpmnXml = await compile(new TextDecoder().decode(casePlan));
+      await this.fileSystem.writeFile(Path.join(contentFolder, CaseConstants.CompiledBpmnFileName), bpmnXml);
+      return await this.checkEntryPointBpmnPresent(contentFolder);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      this.logger.error(message);
+      return ToolResult.error(ToolErrorCodes.InternalError, `Failed to compile '${CaseConstants.CasePlanFileName}' into '${CaseConstants.CompiledBpmnFileName}': ${message}. Run 'uip maestro case validate ${projectPath}' to find the problem in the case plan, then pack again.`);
+    }
+  }
+  async checkEntryPointBpmnPresent(contentFolder) {
+    const referenced = await this.readEntryPointBpmnFiles(contentFolder);
+    if (referenced === null) {
+      return ToolResult.error(ToolErrorCodes.InternalError, `'${CaseConstants.EntryPointsFileName}' could not be read as JSON, so pack cannot check that the BPMN it declares is in the package. Fix or re-scaffold '${CaseConstants.EntryPointsFileName}', then pack again.`);
+    }
+    if (referenced.length === 0) {
+      return ToolResult.success();
+    }
+    const contentFiles = await this.fileSystem.readdir(contentFolder);
+    const missing = referenced.filter((file) => !contentFiles.includes(file));
+    if (missing.length === 0) {
+      return ToolResult.success();
+    }
+    const fix = missing.includes(CaseConstants.CompiledBpmnFileName) ? `Author '${CaseConstants.CasePlanFileName}' so pack can compile it (see 'uip maestro case init'), then pack again.` : `Add the missing file to the project, or point '${CaseConstants.EntryPointsFileName}' at the BPMN the project does ship, then pack again.`;
+    return ToolResult.error(ToolErrorCodes.InternalError, `'${CaseConstants.EntryPointsFileName}' points at ${missing.map((f) => `'content/${f}'`).join(", ")}, which the package does not contain, so it would deploy and activate and then fault every job. ${fix}`);
+  }
+  async readEntryPointBpmnFiles(contentFolder) {
+    const entryPointsPath = Path.join(contentFolder, CaseConstants.EntryPointsFileName);
+    if (!await this.fileSystem.exists(entryPointsPath)) {
+      return [];
+    }
+    const raw = await this.fileSystem.readFile(entryPointsPath);
+    if (!raw || raw.length === 0) {
+      return null;
+    }
+    try {
+      const parsed = JSON.parse(new TextDecoder().decode(raw));
+      const names = (parsed.entryPoints ?? []).map((entry) => entry.filePath ?? "").map((filePath) => filePath.split("#")[0]).map((filePath) => filePath.split("/").pop() ?? "").filter((name) => name.endsWith(".bpmn"));
+      return [...new Set(names)];
+    } catch {
+      return null;
+    }
+  }
   async createOperateFile(options, contentFolder) {
     await ensureContentOperateFile(this.fileSystem, {
       contentFolder,
@@ -1433,12 +1508,23 @@ class CaseToolFactory {
 // ../packager/packager-tool-case/src/index.ts
 toolsFactoryRepository2.registerProjectToolFactory(new CaseToolFactory);
 
+// ../packager/packager-tool-case/src/node.ts
+var compileCasePlan = async (casePlanJson) => {
+  const { serializeCaseDiskJsonToBpmnAndRulesJson } = await import("./index-k4xz16db.js").then((m)=>__toESM(m.default,1));
+  const { bpmnXml } = await serializeCaseDiskJsonToBpmnAndRulesJson(casePlanJson);
+  return bpmnXml;
+};
+function registerNodeCaseBpmnCompiler() {
+  registerCaseBpmnCompiler(compileCasePlan);
+}
+
 // src/packager-tool.ts
 function registerPackagerFactories() {
   toolsFactoryRepository.registerProjectToolFactory(new CaseToolFactory);
+  registerNodeCaseBpmnCompiler();
 }
 export {
   registerPackagerFactories
 };
 
-//# debugId=CF4C19C422087D7F64756E2164756E21
+//# debugId=C7B6A0E748A5EE3464756E2164756E21

package/dist/project-artifacts-vhanbtw5.js

@@ -0,0 +1,14 @@
+import {
+  __require
+} from "./packager-tool-1yh8g550.js";
+
+// src/services/project-artifacts.ts
+async function ensureProjectArtifacts(args) {
+  const { addProjectArtifactsToSolutionAsync } = await import("./index-7s201ka0.js");
+  return addProjectArtifactsToSolutionAsync(args);
+}
+export {
+  ensureProjectArtifacts
+};
+
+//# debugId=81BC3D47DBA842B764756E2164756E21