@uipath/packager-tool-case 1.202.0-preview.141 → 1.202.0-preview.143

package/LICENSE.txt

@@ -0,0 +1,3 @@
+© 2026 UiPath
+Use of this product is subject (a) to the applicable licensing agreement available: https://www.uipath.com/legal/trust-and-security/legal-terms#content-1 and, (b) for paid products listed here https://licensing.uipath.com/: the licensing agreement agreed between you and UiPath.
+(UiPath means UiPath SRL with headquarters at 4 Vasile Alecsandri Str. and 11 Constantin Daniel Str., Building A, floors 5 and 6, District 1, Bucharest 010639, Romania and UiPath Inc. with principal place of business: One Vanderbilt Avenue, 60th Floor, New York, NY 10017)

package/dist/THIRD-PARTY-NOTICES.md

@@ -0,0 +1,8 @@
+# Third-party notices for @uipath/packager-tool-case
+
+This package is distributed as a bundle: the dependencies below are
+compiled into its `dist/` output rather than installed alongside it.
+Their licences and copyright notices are reproduced here in full, as
+those licences require.
+
+No third-party code is bundled into this package.

package/package.json

@@ -1,15 +1,11 @@
 {
     "name": "@uipath/packager-tool-case",
-    "version": "1.202.0-preview.141",
+    "version": "1.202.0-preview.143",
     "description": "UiPath Case Management tool implementation",
     "type": "module",
     "exports": {
-        ".": {
-            "source": "./src/index.ts",
-            "default": "./dist/index.js"
-        },
+        ".": "./dist/index.js",
         "./node": {
-            "source": "./src/node.ts",
             "types": "./dist/node.d.ts",
             "default": "./dist/node.js"
         }
@@ -24,13 +20,12 @@
     },
     "types": "./dist/index.d.ts",
     "files": [
-        "dist",
-        "src"
+        "dist"
     ],
     "author": "",
-    "license": "ISC",
+    "license": "SEE LICENSE IN LICENSE.txt",
     "peerDependencies": {
         "@uipath/solutionpackager-tool-core": "1.202.0"
     },
-    "gitHead": "2c2b4b3b218f18c26db78eb8cd9ab8002d2b5290"
+    "gitHead": "23b5a7038ead7264439af18f8b807c7cc99a29d5"
 }

package/src/case-bpmn-compiler.ts

@@ -1,48 +0,0 @@
-/**
- * Registry for the `caseplan.json` -> BPMN compiler.
- *
- * The compiler lives in `@uipath/case-schema`, a 2.5 MB CommonJS bundle that
- * `require`s `child_process`, `tls` and `http2`. This package builds for the
- * browser (StudioWeb loads it as a micro-frontend), so it cannot import that
- * dependency directly. Instead it declares the interface and whoever runs on
- * Node registers the real thing — `@uipath/packager-tool-case/node` provides
- * that implementation, and the CLI tools that register the Case factory call
- * it alongside.
- *
- * Nothing registered means no compile: `CaseTool` then requires the project to
- * carry an already-compiled `.bpmn` and fails the build with an actionable
- * message if it does not. It never packs a case silently missing its BPMN.
- */
-
-/** Compiles the contents of `caseplan.json` into BPMN XML. */
-export type CaseBpmnCompiler = (casePlanJson: string) => Promise<string>;
-
-/**
- * Global singleton key, keyed with `Symbol.for()` so every copy of this module
- * resolves to the same slot. There are always several: `maestro-tool` and
- * `case-tool` each bundle their own copy of this package, and the Node entry
- * that registers the compiler is a separate build output from the browser one
- * that reads it. A module-local `let` would leave the registration in one copy
- * and the lookup in another — which is silently the old bug, a package packed
- * without its BPMN. Mirrors `toolsFactoryRepository` in
- * `@uipath/solutionpackager-tool-core`.
- */
-const COMPILER_KEY = Symbol.for("@uipath/packager-tool-case/caseBpmnCompiler");
-
-const _global = globalThis as Record<symbol, CaseBpmnCompiler | undefined>;
-
-/**
- * Register the compiler used by `CaseTool.buildAsync`. Last call wins. Pass
- * `undefined` to clear it — how a test reproduces a host that never
- * registered one.
- */
-export function registerCaseBpmnCompiler(
-    caseBpmnCompiler: CaseBpmnCompiler | undefined,
-): void {
-    _global[COMPILER_KEY] = caseBpmnCompiler;
-}
-
-/** The registered compiler, or `undefined` when none was registered. */
-export function getCaseBpmnCompiler(): CaseBpmnCompiler | undefined {
-    return _global[COMPILER_KEY];
-}

package/src/case-tool-factory.ts

@@ -1,25 +0,0 @@
-import {
-    type IFileSystem,
-    type IProjectToolFactory,
-    type IToolLogger,
-    type ProjectTool,
-    type ProjectType,
-    ProjectTypes,
-} from "@uipath/solutionpackager-tool-core";
-import { CaseTool } from "./case-tool.js";
-
-/**
- * Factory for creating Case Management project tools
- */
-export class CaseToolFactory implements IProjectToolFactory {
-    readonly supportedTypes: readonly ProjectType[] = [
-        ProjectTypes.CaseManagement,
-    ];
-
-    async createAsync(
-        logger: IToolLogger,
-        fileSystem: IFileSystem,
-    ): Promise<ProjectTool> {
-        return new CaseTool(fileSystem, logger);
-    }
-}

package/src/case-tool.ts

@@ -1,408 +0,0 @@
-import type {
-    IProjectBuildOptions,
-    IProjectPackOptions,
-    IProjectRestoreOptions,
-    IProjectValidateOptions,
-} from "@uipath/solutionpackager-tool-core";
-import {
-    ensureContentOperateFile,
-    type IFileSystem,
-    type IToolLogger,
-    NugetConstants,
-    NugetPackager,
-    Path,
-    ProjectTool,
-    ProjectTypes,
-    TemporaryStorageService,
-    ToolErrorCodes,
-    ToolResult,
-} from "@uipath/solutionpackager-tool-core";
-import { getCaseBpmnCompiler } from "./case-bpmn-compiler.js";
-
-/**
- * Case Management-specific file names
- */
-const CaseConstants = {
-    EntryPointsFileName: "entry-points.json",
-    BindingsV2FileName: "bindings_v2.json",
-    CasePlanFileName: "caseplan.json",
-    CompiledBpmnFileName: "caseplan.json.bpmn",
-} as const;
-
-/**
- * Case Management project tool implementation.
- *
- * The authored source is `caseplan.json`; the runtime reads the BPMN compiled
- * from it. `entry-points.json` points at `/content/caseplan.json.bpmn`, so the
- * build compiles that file into content/ — a package without it deploys and
- * activates fine and then faults every job it starts (UV-15809). All files are
- * placed in the content/ folder (no separate source folder like flow_files/).
- */
-export class CaseTool extends ProjectTool {
-    private readonly _temporaryStorage: TemporaryStorageService;
-
-    constructor(fileSystem: IFileSystem, logger: IToolLogger) {
-        super(fileSystem, logger);
-        this._temporaryStorage = new TemporaryStorageService(fileSystem);
-    }
-
-    override async restoreAsync(
-        _options: IProjectRestoreOptions,
-        _cancellationToken?: AbortSignal,
-    ): Promise<ToolResult> {
-        this.logger.info(
-            "Restore operation is not required for Case Management projects",
-        );
-        return ToolResult.success();
-    }
-
-    override async validateAsync(
-        _options: IProjectValidateOptions,
-        _cancellationToken?: AbortSignal,
-    ): Promise<ToolResult> {
-        this.logger.info(
-            "Validate operation is not required for Case Management projects",
-        );
-        return ToolResult.success();
-    }
-
-    override async buildAsync(
-        options: IProjectBuildOptions,
-        _cancellationToken?: AbortSignal,
-    ): Promise<ToolResult> {
-        const tempFolder = await this._temporaryStorage.getTempFolderPath();
-        const localBuildFolder = Path.join(
-            tempFolder,
-            NugetConstants.OutputFolderName,
-        );
-        const contentFolder = Path.join(
-            localBuildFolder,
-            NugetConstants.ContentFolderName,
-        );
-
-        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...");
-            await this.createPackageDescriptor(localBuildFolder, contentFolder);
-
-            return new ToolResult(ToolErrorCodes.Success, "done", [
-                localBuildFolder,
-            ]);
-        } catch (error) {
-            const errorMessage =
-                error instanceof Error ? error.toString() : String(error);
-            this.logger.error(errorMessage);
-            return ToolResult.error(
-                ToolErrorCodes.InternalError,
-                "An error occurred while building Case Management project files",
-            );
-        }
-    }
-
-    override async packAsync(
-        options: IProjectPackOptions,
-        cancellationToken?: AbortSignal,
-    ): Promise<ToolResult> {
-        // First, run the build step to prepare the bundle content
-        const buildResult = await this.buildAsync(options, cancellationToken);
-        if (!buildResult.isSuccess) {
-            return buildResult;
-        }
-
-        const localBuildFolder = buildResult.packages[0];
-
-        try {
-            // Create the NuGet package
-            this.logger.progress("Creating NuGet package...");
-
-            const nupkgFileName = `${options.package.id}.${options.package.version}.nupkg`;
-            const nupkgPath = Path.join(options.outputPath, nupkgFileName);
-
-            const packager = new NugetPackager(this.fileSystem);
-            const result = await packager.packAsync(
-                localBuildFolder,
-                options.package,
-                nupkgPath,
-            );
-
-            this.logger.progress("Package created successfully");
-            return new ToolResult(ToolErrorCodes.Success, "done", [
-                result.outputPath,
-            ]);
-        } catch (error) {
-            const errorMessage =
-                error instanceof Error ? error.toString() : String(error);
-            this.logger.error(errorMessage);
-            return ToolResult.error(
-                ToolErrorCodes.InternalError,
-                "An error occurred while packing Case Management project",
-            );
-        }
-    }
-
-    override async dispose(): Promise<void> {
-        this.logger.info("Disposing Case Management Tool");
-        try {
-            await this._temporaryStorage.cleanup();
-        } catch {
-            // Ignore errors during cleanup
-        }
-    }
-
-    /**
-     * Copy all files from source path to content/.
-     * Case Management projects keep all files in content/ (no separate folder).
-     */
-    private async copyFiles(
-        sourcePath: string,
-        contentFolder: string,
-    ): Promise<void> {
-        await this.fileSystem.mkdir(contentFolder);
-
-        const files = await this.fileSystem.readdir(sourcePath);
-
-        for (const file of files) {
-            const sourceFile = Path.join(sourcePath, file);
-
-            const stat = await this.fileSystem.stat(sourceFile);
-            if (stat?.isFile()) {
-                const content = await this.fileSystem.readFile(sourceFile);
-                if (content) {
-                    const destinationFile = Path.join(contentFolder, file);
-                    await this.fileSystem.writeFile(destinationFile, content);
-                }
-            }
-        }
-    }
-
-    /**
-     * Compile `caseplan.json` into `content/caseplan.json.bpmn`.
-     *
-     * Runs after copyFiles on purpose: a stale `caseplan.json.bpmn` left in the
-     * project directory by an earlier `uip maestro case pack` is copied in
-     * first and then overwritten here, so an edited case plan can never ship
-     * against an old BPMN. Nothing is written back into the project directory —
-     * packing a solution does not mutate the user's source tree.
-     *
-     * The compiler is injected (see `case-bpmn-compiler.ts`). With none
-     * registered — a browser host, where `@uipath/case-schema` cannot run — the
-     * project has to bring its own compiled `.bpmn`.
-     */
-    private async compileCasePlan(
-        projectPath: string,
-        contentFolder: string,
-    ): Promise<ToolResult> {
-        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,
-            );
-            // A compile alone does not prove the package is coherent: the
-            // entry point could name a different file. Check what was declared.
-            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.`,
-            );
-        }
-    }
-
-    /**
-     * Verify every `.bpmn` `entry-points.json` names is actually in content/.
-     *
-     * This is the defect UV-15809 reported, checked mechanically: the entry
-     * point resolved to a file the package did not contain, so it deployed and
-     * activated cleanly and then faulted every job. Checking the declaration
-     * rather than a fixed filename covers both project shapes — a CLI project
-     * (`caseplan.json` -> `caseplan.json.bpmn`) and a Studio Web one
-     * (`<name>.stage.json` shipped with its compiled `<name>.stage.json.bpmn`)
-     * — and a stray `.bpmn` left behind by `uip case debug` cannot stand in for
-     * the one that is missing.
-     *
-     * No `entry-points.json` means nothing declares an entry point, so there is
-     * nothing to resolve and nothing to fail on.
-     */
-    private async checkEntryPointBpmnPresent(
-        contentFolder: string,
-    ): Promise<ToolResult> {
-        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();
-        }
-
-        // Only the CLI shape can be produced by packing: the missing file is
-        // compiled from `caseplan.json`. A Studio Web project ships its own
-        // `<name>.stage.json.bpmn`, and telling that user to author a
-        // `caseplan.json` their project type does not use is wrong.
-        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}`,
-        );
-    }
-
-    /**
-     * The `.bpmn` file names `entry-points.json` refers to. Entries look like
-     * `/content/caseplan.json.bpmn#<triggerId>`; `uip case debug` writes them
-     * without the `content/` prefix, so both forms are accepted.
-     *
-     * No file at all means nothing is declared, so the caller has nothing to
-     * check. A file that is there but cannot be read as JSON returns `null`:
-     * treating that as "nothing declared" would wave through the very package
-     * this check exists to stop, since the entry point it names is unknown.
-     */
-    private async readEntryPointBpmnFiles(
-        contentFolder: string,
-    ): Promise<string[] | null> {
-        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)) as {
-                entryPoints?: { filePath?: string }[];
-            };
-            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;
-        }
-    }
-
-    /**
-     * Create operate.json file if it doesn't already exist
-     */
-    private async createOperateFile(
-        options: IProjectBuildOptions,
-        contentFolder: string,
-    ): Promise<void> {
-        await ensureContentOperateFile(this.fileSystem, {
-            contentFolder,
-            projectPath: options.projectPath,
-            projectStorageId: options.projectStorageId,
-            contentType: ProjectTypes.CaseManagement,
-        });
-    }
-
-    /**
-     * Create package-descriptor.json file.
-     * Lists standard packaging files and .bpmn files from content/.
-     */
-    private async createPackageDescriptor(
-        localBuildFolder: string,
-        contentFolder: string,
-    ): Promise<void> {
-        const descriptorFiles: Record<string, string> = {};
-
-        // Standard packaging files
-        descriptorFiles[NugetConstants.OperateFileName] = Path.join(
-            NugetConstants.ContentFolderName,
-            NugetConstants.OperateFileName,
-        );
-        descriptorFiles[CaseConstants.EntryPointsFileName] = Path.join(
-            NugetConstants.ContentFolderName,
-            CaseConstants.EntryPointsFileName,
-        );
-        descriptorFiles[NugetConstants.BindingsFileId] = Path.join(
-            NugetConstants.ContentFolderName,
-            CaseConstants.BindingsV2FileName,
-        );
-
-        // Add .bpmn files from content/
-        const contentFiles = await this.fileSystem.readdir(contentFolder);
-        for (const file of contentFiles) {
-            if (file.endsWith(".bpmn")) {
-                descriptorFiles[file] = Path.join(
-                    NugetConstants.ContentFolderName,
-                    file,
-                );
-            }
-        }
-
-        const packageDescriptorPath = Path.join(
-            localBuildFolder,
-            NugetConstants.ContentFolderName,
-            NugetConstants.PackageDescriptorFileName,
-        );
-        const packageDescriptorJson = JSON.stringify(
-            {
-                $schema:
-                    "https://cloud.uipath.com/draft/2024-12/package-descriptor",
-                files: descriptorFiles,
-            },
-            null,
-            2,
-        );
-        await this.fileSystem.writeFile(
-            packageDescriptorPath,
-            packageDescriptorJson,
-        );
-    }
-}

package/src/index.ts

@@ -1,17 +0,0 @@
-// Case Management tool factory.
-//
-// Self-registers on import so micro-frontend consumers (whose MFEs UiPath does
-// not control) that load this package via a side-effect import get the factory
-// registered automatically — StudioWeb does not reference this package, so it
-// relies on self-registration. Also exported for consumers that register
-// explicitly; re-registering the same factory class is an idempotent no-op.
-import { toolsFactoryRepository } from "@uipath/solutionpackager-tool-core";
-import { CaseToolFactory } from "./case-tool-factory.js";
-
-toolsFactoryRepository.registerProjectToolFactory(new CaseToolFactory());
-
-export {
-    type CaseBpmnCompiler,
-    registerCaseBpmnCompiler,
-} from "./case-bpmn-compiler.js";
-export { CaseToolFactory };

package/src/node.ts

@@ -1,35 +0,0 @@
-// Node-only entry point: wires the real `caseplan.json` -> BPMN compiler into
-// the Case packager. Kept out of `index.ts` because `@uipath/case-schema`
-// requires Node built-ins and would break the browser build — see
-// `case-bpmn-compiler.ts`.
-
-import {
-    type CaseBpmnCompiler,
-    registerCaseBpmnCompiler,
-} from "./case-bpmn-compiler.js";
-
-/**
- * `@uipath/case-schema` ships as a single 2.5 MB CommonJS bundle with no
- * `exports` map, so nothing in it can be tree-shaken — importing one function
- * costs the whole file. Behind `await import` it becomes its own lazy chunk,
- * parsed only when a Case project is actually built, instead of loading with
- * every `uip maestro -h`. `case-tool` keeps the same shape for its own
- * `uip maestro case pack` path (`services/case-schema-loader.ts`).
- */
-const compileCasePlan: CaseBpmnCompiler = async (casePlanJson) => {
-    const { serializeCaseDiskJsonToBpmnAndRulesJson } = await import(
-        "@uipath/case-schema"
-    );
-    const { bpmnXml } =
-        await serializeCaseDiskJsonToBpmnAndRulesJson(casePlanJson);
-    return bpmnXml;
-};
-
-/**
- * Register the Node `caseplan.json` -> BPMN compiler. Call it wherever the
- * Case project tool factory is registered on Node — without it a Case project
- * can only be packed from an already-compiled `.bpmn`.
- */
-export function registerNodeCaseBpmnCompiler(): void {
-    registerCaseBpmnCompiler(compileCasePlan);
-}