@uipath/packager-tool-flow 0.0.17 → 0.0.18

package/dist/flow-tool.d.ts

@@ -11,6 +11,15 @@ export declare class FlowTool extends ProjectTool {
     buildAsync(options: IProjectBuildOptions, _cancellationToken?: AbortSignal): Promise<ToolResult>;
     packAsync(options: IProjectPackOptions, cancellationToken?: AbortSignal): Promise<ToolResult>;
     dispose(): Promise<void>;
+    /**
+     * Read the .flow file from the content folder, convert to BPMN, and
+     * generate entry-points.json, bindings_v2.json, and the BPMN file.
+     *
+     * Artifacts are always regenerated from the .flow source to ensure
+     * the package reflects the current state of the workflow, regardless
+     * of any stale artifacts that may exist on disk.
+     */
+    private generateFlowPackagingArtifacts;
     /**
      * Copy project files into the correct nupkg structure.
      *

package/dist/index.js

@@ -7,6 +7,15 @@ import {
 } from "@uipath/solutionpackager-tool-core";
 
 // src/flow-tool.ts
+import { convertFlowToBpmn } from "@uipath/flow-converter";
+import {
+  generateBindingsJson,
+  generateEntryPointsJson,
+  generateOperateJson,
+  getBindingResources,
+  getEntryPoints,
+  ProjectType
+} from "@uipath/flow-schema";
 import {
   NugetConstants,
   NugetPackager,
@@ -112,6 +121,8 @@ class FlowTool extends ProjectTool {
       await this.copyProjectFiles(options.projectPath, contentFolder);
       this.logger.progress("Processing agents...");
       await processAgents(this.fileSystem, this.logger, options.projectPath, contentFolder);
+      this.logger.progress("Generating packaging artifacts from .flow...");
+      await this.generateFlowPackagingArtifacts(contentFolder, options.projectStorageId ?? "");
       this.logger.progress("Creating operate.json file...");
       await this.createOperateFile(options, contentFolder);
       this.logger.progress("Creating package-descriptor.json file...");
@@ -153,6 +164,59 @@ class FlowTool extends ProjectTool {
       await this._temporaryStorage.cleanup();
     } catch {}
   }
+  async generateFlowPackagingArtifacts(contentFolder, projectId) {
+    const entries = await this.fileSystem.readdir(contentFolder);
+    const flowFile = entries.find((e) => e.endsWith(".flow"));
+    if (!flowFile) {
+      this.logger.warn("No .flow file found in content folder — skipping artifact generation");
+      return;
+    }
+    const flowJsonBuffer = await this.fileSystem.readFile(Path3.join(contentFolder, flowFile));
+    if (!flowJsonBuffer) {
+      this.logger.warn(`Could not read ${flowFile} — skipping artifact generation`);
+      return;
+    }
+    const flowJson = typeof flowJsonBuffer === "string" ? flowJsonBuffer : new TextDecoder().decode(flowJsonBuffer);
+    let flowData;
+    try {
+      flowData = JSON.parse(flowJson);
+    } catch {
+      this.logger.warn(`Could not parse ${flowFile} as JSON — skipping artifact generation`);
+      return;
+    }
+    const bpmnFileName = flowFile.replace(/\.flow$/, ".bpmn");
+    const bpmnPath = Path3.join(contentFolder, bpmnFileName);
+    const { bpmn } = await convertFlowToBpmn(flowJson);
+    await this.fileSystem.writeFile(bpmnPath, bpmn);
+    const packagingNodes = (flowData.nodes ?? []).map((node) => ({
+      id: node.id,
+      type: node.type,
+      data: {
+        type: node.type,
+        typeVersion: node.typeVersion ?? "1.0.0",
+        display: node.display,
+        inputs: node.inputs,
+        outputs: node.outputs,
+        model: node.model
+      }
+    }));
+    const variables = flowData.variables ?? {};
+    const bindings = flowData.bindings ?? [];
+    const entryPointsPath = Path3.join(contentFolder, FlowConstants.EntryPointsFileName);
+    const entryPoints = getEntryPoints(bpmnFileName, packagingNodes, variables, ProjectType.Flow);
+    await this.fileSystem.writeFile(entryPointsPath, `${JSON.stringify(generateEntryPointsJson(entryPoints), null, 2)}
+`);
+    const bindingsPath = Path3.join(contentFolder, FlowConstants.BindingsV2FileName);
+    const bindingResources = getBindingResources(packagingNodes, bindings);
+    await this.fileSystem.writeFile(bindingsPath, `${JSON.stringify(generateBindingsJson(bindingResources), null, 2)}
+`);
+    const operatePath = Path3.join(contentFolder, NugetConstants.OperateFileName);
+    const startEventMatch = bpmn.match(/<bpmn:startEvent\s+id="([^"]+)"/);
+    const startEventId = startEventMatch?.[1] ?? "start";
+    const mainEntryPoint = `/${bpmnFileName}#${startEventId}`;
+    await this.fileSystem.writeFile(operatePath, `${JSON.stringify(generateOperateJson(projectId || flowData.id || "", mainEntryPoint), null, 2)}
+`);
+  }
   async copyProjectFiles(projectPath, contentFolder) {
     await this.fileSystem.mkdir(contentFolder);
     const entries = await this.fileSystem.readdir(projectPath);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@uipath/packager-tool-flow",
-    "version": "0.0.17",
+    "version": "0.0.18",
     "description": "UiPath Flow tool implementation",
     "type": "module",
     "exports": {
@@ -19,8 +19,8 @@
     },
     "types": "./dist/index.d.ts",
     "scripts": {
-        "build": "bun build ./src/index.ts --outdir dist --format esm --target browser --external @uipath/solutionpackager-tool-core --external @uipath/tool-agent && tsc --emitDeclarationOnly --outDir dist",
-        "dev": "bun build ./src/index.ts --outdir dist --format esm --target browser --external @uipath/solutionpackager-tool-core --external @uipath/tool-agent --watch",
+        "build": "bun build ./src/index.ts --outdir dist --format esm --target browser --external @uipath/solutionpackager-tool-core --external @uipath/tool-agent --external @uipath/flow-converter --external @uipath/flow-schema && tsc --emitDeclarationOnly --outDir dist",
+        "dev": "bun build ./src/index.ts --outdir dist --format esm --target browser --external @uipath/solutionpackager-tool-core --external @uipath/tool-agent --external @uipath/flow-converter --external @uipath/flow-schema --watch",
         "test": "vitest run",
         "test:browser": "vitest run --config=vitest.browser.config.ts",
         "test:coverage": "vitest run --coverage",
@@ -43,12 +43,14 @@
     "author": "",
     "license": "ISC",
     "peerDependencies": {
-        "@uipath/solutionpackager-tool-core": "0.0.31",
+        "@uipath/flow-converter": "^0.1.6",
+        "@uipath/flow-schema": "^0.2.141",
+        "@uipath/solutionpackager-tool-core": "0.0.33",
         "@uipath/tool-agent": "^1.0.1"
     },
     "devDependencies": {
         "@types/node": "^25.5.0",
-        "@uipath/solutionpackager-tool-core": "0.0.31",
+        "@uipath/solutionpackager-tool-core": "0.0.33",
         "@uipath/tool-agent": "^1.0.1",
         "@vitest/browser": "^4.0.14",
         "@vitest/browser-playwright": "^4.0.14",
@@ -56,5 +58,6 @@
         "playwright": "^1.57.0",
         "typescript": "^5.9.3",
         "vitest": "^4.0.14"
-    }
+    },
+    "gitHead": "3f1b4d8e9f910be81e4cab956537f21dbd5d63ac"
 }

package/src/flow-tool.ts

@@ -1,3 +1,15 @@
+import { convertFlowToBpmn } from "@uipath/flow-converter";
+import {
+    generateBindingsJson,
+    generateEntryPointsJson,
+    generateOperateJson,
+    getBindingResources,
+    getEntryPoints,
+    type PackagingBinding,
+    type PackagingNode,
+    type PackagingWorkflowVariables,
+    ProjectType,
+} from "@uipath/flow-schema";
 import type {
     EntryPointsFileModel,
     IProjectBuildOptions,
@@ -79,6 +91,14 @@ export class FlowTool extends ProjectTool {
                 contentFolder,
             );
 
+            this.logger.progress(
+                "Generating packaging artifacts from .flow...",
+            );
+            await this.generateFlowPackagingArtifacts(
+                contentFolder,
+                options.projectStorageId ?? "",
+            );
+
             this.logger.progress("Creating operate.json file...");
             await this.createOperateFile(options, contentFolder);
 
@@ -149,6 +169,134 @@ export class FlowTool extends ProjectTool {
         }
     }
 
+    /**
+     * Read the .flow file from the content folder, convert to BPMN, and
+     * generate entry-points.json, bindings_v2.json, and the BPMN file.
+     *
+     * Artifacts are always regenerated from the .flow source to ensure
+     * the package reflects the current state of the workflow, regardless
+     * of any stale artifacts that may exist on disk.
+     */
+    private async generateFlowPackagingArtifacts(
+        contentFolder: string,
+        projectId: string,
+    ): Promise<void> {
+        // Find the .flow file in content folder
+        const entries = await this.fileSystem.readdir(contentFolder);
+        const flowFile = entries.find((e: string) => e.endsWith(".flow"));
+        if (!flowFile) {
+            this.logger.warn(
+                "No .flow file found in content folder — skipping artifact generation",
+            );
+            return;
+        }
+
+        // Read the .flow JSON
+        const flowJsonBuffer = await this.fileSystem.readFile(
+            Path.join(contentFolder, flowFile),
+        );
+        if (!flowJsonBuffer) {
+            this.logger.warn(
+                `Could not read ${flowFile} — skipping artifact generation`,
+            );
+            return;
+        }
+        const flowJson =
+            typeof flowJsonBuffer === "string"
+                ? flowJsonBuffer
+                : new TextDecoder().decode(flowJsonBuffer);
+
+        let flowData: {
+            id?: string;
+            nodes?: Array<{
+                id: string;
+                type: string;
+                typeVersion?: string;
+                display?: Record<string, unknown>;
+                inputs?: Record<string, unknown>;
+                outputs?: Record<string, unknown>;
+                model?: Record<string, unknown>;
+            }>;
+            bindings?: PackagingBinding[];
+            variables?: PackagingWorkflowVariables;
+        };
+
+        try {
+            flowData = JSON.parse(flowJson);
+        } catch {
+            this.logger.warn(
+                `Could not parse ${flowFile} as JSON — skipping artifact generation`,
+            );
+            return;
+        }
+
+        // Convert .flow to BPMN (always regenerate from .flow source)
+        const bpmnFileName = flowFile.replace(/\.flow$/, ".bpmn");
+        const bpmnPath = Path.join(contentFolder, bpmnFileName);
+        const { bpmn } = await convertFlowToBpmn(flowJson);
+        await this.fileSystem.writeFile(bpmnPath, bpmn);
+
+        // Build PackagingNode[] from the .flow nodes
+        const packagingNodes: PackagingNode[] = (flowData.nodes ?? []).map(
+            (node) => ({
+                id: node.id,
+                type: node.type,
+                data: {
+                    type: node.type,
+                    typeVersion: node.typeVersion ?? "1.0.0",
+                    display: node.display,
+                    inputs: node.inputs,
+                    outputs: node.outputs,
+                    model: node.model,
+                },
+            }),
+        );
+
+        const variables =
+            (flowData.variables as PackagingWorkflowVariables) ?? {};
+        const bindings = (flowData.bindings ?? []) as PackagingBinding[];
+
+        // Generate entry-points.json (always regenerate from .flow source)
+        const entryPointsPath = Path.join(
+            contentFolder,
+            FlowConstants.EntryPointsFileName,
+        );
+        const entryPoints = getEntryPoints(
+            bpmnFileName,
+            packagingNodes,
+            variables,
+            ProjectType.Flow,
+        );
+        await this.fileSystem.writeFile(
+            entryPointsPath,
+            `${JSON.stringify(generateEntryPointsJson(entryPoints), null, 2)}\n`,
+        );
+
+        // Generate bindings_v2.json (always regenerate from .flow source)
+        const bindingsPath = Path.join(
+            contentFolder,
+            FlowConstants.BindingsV2FileName,
+        );
+        const bindingResources = getBindingResources(packagingNodes, bindings);
+        await this.fileSystem.writeFile(
+            bindingsPath,
+            `${JSON.stringify(generateBindingsJson(bindingResources), null, 2)}\n`,
+        );
+
+        // Generate operate.json (always regenerate from .flow source)
+        const operatePath = Path.join(
+            contentFolder,
+            NugetConstants.OperateFileName,
+        );
+        const startEventMatch = bpmn.match(/<bpmn:startEvent\s+id="([^"]+)"/);
+        const startEventId = startEventMatch?.[1] ?? "start";
+        const mainEntryPoint = `/${bpmnFileName}#${startEventId}`;
+        await this.fileSystem.writeFile(
+            operatePath,
+            `${JSON.stringify(generateOperateJson(projectId || flowData.id || "", mainEntryPoint), null, 2)}\n`,
+        );
+    }
+
     /**
      * Copy project files into the correct nupkg structure.
      *