@uipath/packager-tool-bpmn 0.0.7

package/dist/bpmn-tool-factory.d.ts

@@ -0,0 +1,8 @@
+import { type IFileSystem, type IProjectToolFactory, type IToolLogger, type ProjectTool, type ProjectType } from "@uipath/solutionpackager-tool-core";
+/**
+ * Factory for creating ProcessOrchestration (BPMN) project tools
+ */
+export declare class BpmnToolFactory implements IProjectToolFactory {
+    readonly supportedTypes: readonly ProjectType[];
+    createAsync(logger: IToolLogger, fileSystem: IFileSystem): Promise<ProjectTool>;
+}

package/dist/bpmn-tool.d.ts

@@ -0,0 +1,31 @@
+import type { IProjectBuildOptions, IProjectPackOptions, IProjectRestoreOptions, IProjectValidateOptions } from "@uipath/solutionpackager-tool-core";
+import { type IFileSystem, type IToolLogger, ProjectTool, ToolResult } from "@uipath/solutionpackager-tool-core";
+/**
+ * ProcessOrchestration (BPMN) project tool implementation
+ */
+export declare class BpmnTool extends ProjectTool {
+    private readonly _temporaryStorage;
+    constructor(fileSystem: IFileSystem, logger: IToolLogger);
+    restoreAsync(_options: IProjectRestoreOptions, _cancellationToken?: AbortSignal): Promise<ToolResult>;
+    validateAsync(_options: IProjectValidateOptions, _cancellationToken?: AbortSignal): Promise<ToolResult>;
+    buildAsync(options: IProjectBuildOptions, _cancellationToken?: AbortSignal): Promise<ToolResult>;
+    packAsync(options: IProjectPackOptions, cancellationToken?: AbortSignal): Promise<ToolResult>;
+    dispose(): Promise<void>;
+    /**
+     * Copy all files from source path to content folder
+     */
+    private copyFiles;
+    /**
+     * Create operate.json file if it doesn't already exist
+     */
+    private createOperateFile;
+    /**
+     * Create the operate.json file with project configuration
+     */
+    private createOperateJsonFile;
+    /**
+     * Create package-descriptor.json file.
+     * Lists standard packaging files and .bpmn files from content/.
+     */
+    private createPackageDescriptor;
+}

package/dist/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/index.js

@@ -0,0 +1,168 @@
+// src/index.ts
+import { toolsFactoryRepository } from "@uipath/solutionpackager-tool-core";
+
+// src/bpmn-tool-factory.ts
+import {
+  ProjectTypes as ProjectTypes2
+} from "@uipath/solutionpackager-tool-core";
+
+// src/bpmn-tool.ts
+import {
+  NugetConstants,
+  NugetPackager,
+  Path,
+  ProjectTool,
+  ProjectTypes,
+  TemporaryStorageService,
+  ToolErrorCodes,
+  ToolResult
+} from "@uipath/solutionpackager-tool-core";
+var BpmnConstants = {
+  EntryPointsFileName: "entry-points.json",
+  BindingsV2FileName: "bindings_v2.json"
+};
+
+class BpmnTool extends ProjectTool {
+  _temporaryStorage;
+  constructor(fileSystem, logger) {
+    super(fileSystem, logger);
+    this._temporaryStorage = new TemporaryStorageService(fileSystem);
+  }
+  async restoreAsync(_options, _cancellationToken) {
+    this.logger.info("Restore operation is not required for ProcessOrchestration projects");
+    return ToolResult.success();
+  }
+  async validateAsync(_options, _cancellationToken) {
+    this.logger.info("Validate operation is not required for ProcessOrchestration projects");
+    return ToolResult.success();
+  }
+  async buildAsync(options, _cancellationToken) {
+    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("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 ProcessOrchestration project files");
+    }
+  }
+  async packAsync(options, cancellationToken) {
+    const buildResult = await this.buildAsync(options, cancellationToken);
+    if (!buildResult.isSuccess) {
+      return buildResult;
+    }
+    const localBuildFolder = buildResult.packages[0];
+    try {
+      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 ProcessOrchestration project");
+    }
+  }
+  async dispose() {
+    this.logger.info("Disposing ProcessOrchestration Tool");
+    try {
+      await this._temporaryStorage.cleanup();
+    } catch {}
+  }
+  async copyFiles(sourcePath, destinationPath) {
+    await this.fileSystem.mkdir(destinationPath);
+    const files = await this.fileSystem.readdir(sourcePath);
+    for (const file of files) {
+      const sourceFile = Path.join(sourcePath, file);
+      const destinationFile = Path.join(destinationPath, file);
+      const stat = await this.fileSystem.stat(sourceFile);
+      if (stat?.isFile()) {
+        const content = await this.fileSystem.readFile(sourceFile);
+        if (content) {
+          await this.fileSystem.writeFile(destinationFile, content);
+        }
+      }
+    }
+  }
+  async createOperateFile(options, contentFolder) {
+    const operateJsonFilePath = Path.join(contentFolder, NugetConstants.OperateFileName);
+    const exists = await this.fileSystem.exists(operateJsonFilePath);
+    if (!exists) {
+      await this.createOperateJsonFile(contentFolder, options.projectStorageId ?? "", operateJsonFilePath);
+    }
+  }
+  async createOperateJsonFile(projectPath, projectId, filePath) {
+    const entryPointsFilePath = Path.join(projectPath, BpmnConstants.EntryPointsFileName);
+    let mainPath = "";
+    const entryPointsExists = await this.fileSystem.exists(entryPointsFilePath);
+    if (entryPointsExists) {
+      const entryPointsContent = await this.fileSystem.readFile(entryPointsFilePath);
+      if (entryPointsContent) {
+        try {
+          const entryPointsText = new TextDecoder().decode(entryPointsContent);
+          const entryPoints = JSON.parse(entryPointsText);
+          mainPath = entryPoints.entryPoints?.[0]?.filePath ?? "";
+        } catch {}
+      }
+    }
+    const operateFileModel = {
+      $schema: "https://cloud.uipath.com/draft/2024-12/operate",
+      contentType: ProjectTypes.ProcessOrchestration,
+      projectId,
+      main: mainPath,
+      targetFramework: "Portable",
+      runtimeOptions: {
+        isAttended: false,
+        requiresUserInteraction: false
+      }
+    };
+    const operateJsonString = JSON.stringify(operateFileModel, null, 2);
+    await this.fileSystem.writeFile(filePath, operateJsonString);
+  }
+  async createPackageDescriptor(localBuildFolder, contentFolder) {
+    const descriptorFiles = {};
+    descriptorFiles[NugetConstants.OperateFileName] = Path.join(NugetConstants.ContentFolderName, NugetConstants.OperateFileName);
+    descriptorFiles[BpmnConstants.EntryPointsFileName] = Path.join(NugetConstants.ContentFolderName, BpmnConstants.EntryPointsFileName);
+    descriptorFiles[NugetConstants.BindingsFileId] = Path.join(NugetConstants.ContentFolderName, BpmnConstants.BindingsV2FileName);
+    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);
+  }
+}
+
+// src/bpmn-tool-factory.ts
+class BpmnToolFactory {
+  supportedTypes = [
+    ProjectTypes2.ProcessOrchestration
+  ];
+  async createAsync(logger, fileSystem) {
+    return new BpmnTool(fileSystem, logger);
+  }
+}
+
+// src/index.ts
+toolsFactoryRepository.registerProjectToolFactory(new BpmnToolFactory);

package/package.json

@@ -0,0 +1,58 @@
+{
+    "name": "@uipath/packager-tool-bpmn",
+    "version": "0.0.7",
+    "description": "UiPath ProcessOrchestration (BPMN) 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-bpmn"
+    },
+    "publishConfig": {
+        "registry": "https://registry.npmjs.org/"
+    },
+    "types": "./dist/index.d.ts",
+    "scripts": {
+        "build": "bun build ./src/index.ts --outdir dist --format esm --target browser --external @uipath/solutionpackager-tool-core && tsc --emitDeclarationOnly --outDir dist",
+        "dev": "bun build ./src/index.ts --outdir dist --format esm --target browser --external @uipath/solutionpackager-tool-core --watch",
+        "test": "vitest run",
+        "test:browser": "vitest run --config=vitest.browser.config.ts",
+        "test:coverage": "vitest run --coverage",
+        "test:browser:coverage": "vitest run --config=vitest.browser.config.ts --coverage",
+        "test:all": "bun run test && bun run test:browser",
+        "test:all:coverage": "bun run test:coverage && bun run test:browser:coverage",
+        "prepack": "bun run build",
+        "publish:dry": "bun publish --dry-run",
+        "publish:gh": "bun publish",
+        "version:patch": "bun version patch --no-git-tag-version",
+        "version:minor": "bun version minor --no-git-tag-version",
+        "version:major": "bun version major --no-git-tag-version",
+        "lint": "biome check ."
+    },
+    "files": [
+        "dist",
+        "!dist/**/*.map",
+        "src"
+    ],
+    "author": "",
+    "license": "ISC",
+    "peerDependencies": {
+        "@uipath/solutionpackager-tool-core": "0.0.31"
+    },
+    "devDependencies": {
+        "@types/node": "^25.5.0",
+        "@uipath/solutionpackager-tool-core": "0.0.31",
+        "@vitest/browser": "^4.0.14",
+        "@vitest/browser-playwright": "^4.0.14",
+        "@vitest/coverage-v8": "^4.0.14",
+        "playwright": "^1.57.0",
+        "typescript": "^5.9.3",
+        "vitest": "^4.0.14"
+    }
+}

package/src/bpmn-tool-factory.ts

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

package/src/bpmn-tool.ts

@@ -0,0 +1,299 @@
+import type {
+    EntryPointsFileModel,
+    IProjectBuildOptions,
+    IProjectPackOptions,
+    IProjectRestoreOptions,
+    IProjectValidateOptions,
+} from "@uipath/solutionpackager-tool-core";
+import {
+    type IFileSystem,
+    type IToolLogger,
+    NugetConstants,
+    NugetPackager,
+    Path,
+    ProjectTool,
+    ProjectTypes,
+    TemporaryStorageService,
+    ToolErrorCodes,
+    ToolResult,
+} from "@uipath/solutionpackager-tool-core";
+
+/**
+ * BPMN-specific file names (same conventions as Flow)
+ * ProcessOrchestration projects use 'entry-points.json' (with dash) and 'bindings_v2.json' (with underscore)
+ */
+const BpmnConstants = {
+    EntryPointsFileName: "entry-points.json",
+    BindingsV2FileName: "bindings_v2.json",
+} as const;
+
+/**
+ * ProcessOrchestration (BPMN) project tool implementation
+ */
+export class BpmnTool 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 ProcessOrchestration projects",
+        );
+        return ToolResult.success();
+    }
+
+    override async validateAsync(
+        _options: IProjectValidateOptions,
+        _cancellationToken?: AbortSignal,
+    ): Promise<ToolResult> {
+        this.logger.info(
+            "Validate operation is not required for ProcessOrchestration 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("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 ProcessOrchestration 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 ProcessOrchestration project",
+            );
+        }
+    }
+
+    override async dispose(): Promise<void> {
+        this.logger.info("Disposing ProcessOrchestration Tool");
+        try {
+            await this._temporaryStorage.cleanup();
+        } catch {
+            // Ignore errors during cleanup
+        }
+    }
+
+    /**
+     * Copy all files from source path to content folder
+     */
+    private async copyFiles(
+        sourcePath: string,
+        destinationPath: string,
+    ): Promise<void> {
+        await this.fileSystem.mkdir(destinationPath);
+
+        const files = await this.fileSystem.readdir(sourcePath);
+
+        for (const file of files) {
+            const sourceFile = Path.join(sourcePath, file);
+            const destinationFile = Path.join(destinationPath, file);
+
+            const stat = await this.fileSystem.stat(sourceFile);
+            if (stat?.isFile()) {
+                const content = await this.fileSystem.readFile(sourceFile);
+                if (content) {
+                    await this.fileSystem.writeFile(destinationFile, content);
+                }
+            }
+        }
+    }
+
+    /**
+     * Create operate.json file if it doesn't already exist
+     */
+    private async createOperateFile(
+        options: IProjectBuildOptions,
+        contentFolder: string,
+    ): Promise<void> {
+        const operateJsonFilePath = Path.join(
+            contentFolder,
+            NugetConstants.OperateFileName,
+        );
+
+        const exists = await this.fileSystem.exists(operateJsonFilePath);
+        if (!exists) {
+            await this.createOperateJsonFile(
+                contentFolder,
+                options.projectStorageId ?? "",
+                operateJsonFilePath,
+            );
+        }
+    }
+
+    /**
+     * Create the operate.json file with project configuration
+     */
+    private async createOperateJsonFile(
+        projectPath: string,
+        projectId: string,
+        filePath: string,
+    ): Promise<void> {
+        const entryPointsFilePath = Path.join(
+            projectPath,
+            BpmnConstants.EntryPointsFileName,
+        );
+        let mainPath = "";
+
+        const entryPointsExists =
+            await this.fileSystem.exists(entryPointsFilePath);
+        if (entryPointsExists) {
+            const entryPointsContent =
+                await this.fileSystem.readFile(entryPointsFilePath);
+            if (entryPointsContent) {
+                try {
+                    const entryPointsText = new TextDecoder().decode(
+                        entryPointsContent,
+                    );
+                    const entryPoints: EntryPointsFileModel =
+                        JSON.parse(entryPointsText);
+                    mainPath = entryPoints.entryPoints?.[0]?.filePath ?? "";
+                } catch {
+                    // Ignore parsing errors, use empty mainPath
+                }
+            }
+        }
+
+        const operateFileModel = {
+            $schema: "https://cloud.uipath.com/draft/2024-12/operate",
+            contentType: ProjectTypes.ProcessOrchestration,
+            projectId: projectId,
+            main: mainPath,
+            targetFramework: "Portable",
+            runtimeOptions: {
+                isAttended: false,
+                requiresUserInteraction: false,
+            },
+        };
+
+        const operateJsonString = JSON.stringify(operateFileModel, null, 2);
+        await this.fileSystem.writeFile(filePath, operateJsonString);
+    }
+
+    /**
+     * 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[BpmnConstants.EntryPointsFileName] = Path.join(
+            NugetConstants.ContentFolderName,
+            BpmnConstants.EntryPointsFileName,
+        );
+        descriptorFiles[NugetConstants.BindingsFileId] = Path.join(
+            NugetConstants.ContentFolderName,
+            BpmnConstants.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

@@ -0,0 +1,5 @@
+// Self-register BPMN (ProcessOrchestration) tool factory with the singleton repository
+import { toolsFactoryRepository } from "@uipath/solutionpackager-tool-core";
+import { BpmnToolFactory } from "./bpmn-tool-factory.js";
+
+toolsFactoryRepository.registerProjectToolFactory(new BpmnToolFactory());