@uipath/packager-tool-flow 0.0.17

package/README.md

@@ -0,0 +1,51 @@
+# @uipath/tool-flow
+
+A **Project Tool** for the UiPath Solution Packager, designed for handling **Flow** projects.
+
+## Overview
+
+This package implements a packaging tool for Flow projects using `@uipath/solutionpackager-tool-core`. It implements the lifecycle methods for building and packing Flow projects.
+
+## Features
+
+- **Build Operations**:
+  - Copies project files to a clean output directory
+  - Generates `operate.json` configuration
+  - Generates `package-descriptor.json`
+- **Pack Operations**:
+  - Creates `.nupkg` packages (NuGet)
+  - Handles versioning and metadata
+
+## Project Structure
+
+```
+src/
+├── flow-tool.ts           # Main tool logic implementation
+├── flow-tool-factory.ts   # Factory for creating tool instances
+└── index.ts               # Export entry point
+```
+
+## Usage
+
+This tool is designed to be loaded dynamically by `solutionpackager`.
+
+### Development
+
+**Install dependencies:**
+
+```bash
+npm install
+```
+
+**Build:**
+
+```bash
+npm run build
+```
+
+**Run Tests:**
+
+```bash
+npm test
+npm run test:browser
+```

package/dist/agents.d.ts

@@ -0,0 +1,2 @@
+import type { IFileSystem, IToolLogger } from "@uipath/solutionpackager-tool-core";
+export declare const processAgents: (fileSystem: IFileSystem, logger: IToolLogger, projectPath: string, contentFolder: string) => Promise<void>;

package/dist/bindings.d.ts

@@ -0,0 +1,17 @@
+import type { IFileSystem } from "@uipath/solutionpackager-tool-core";
+import type { AgentBuildResult } from "@uipath/tool-agent/build";
+export interface BindingsResource {
+    resource: string;
+    key: string;
+    [other: string]: unknown;
+}
+export interface Bindings {
+    version: string;
+    resources: BindingsResource[];
+}
+export declare const toBindingsResources: (result: AgentBuildResult) => BindingsResource[];
+/**
+ * Merge agent binding resources into the flow's bindings_v2.json.
+ * Deduplicates by (resource, key) tuple, keeping the first occurrence.
+ */
+export declare const mergeAgentBindings: (fileSystem: IFileSystem, contentFolder: string, agentBindingResources: BindingsResource[]) => Promise<void>;

package/dist/flow-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 Flow project tools
+ */
+export declare class FlowToolFactory implements IProjectToolFactory {
+    readonly supportedTypes: readonly ProjectType[];
+    createAsync(logger: IToolLogger, fileSystem: IFileSystem): Promise<ProjectTool>;
+}

package/dist/flow-tool.d.ts

@@ -0,0 +1,42 @@
+import type { IProjectBuildOptions, IProjectPackOptions, IProjectRestoreOptions, IProjectValidateOptions } from "@uipath/solutionpackager-tool-core";
+import { type IFileSystem, type IToolLogger, ProjectTool, ToolResult } from "@uipath/solutionpackager-tool-core";
+/**
+ * Flow project tool implementation
+ */
+export declare class FlowTool 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 project files into the correct nupkg structure.
+     *
+     * Flow projects have two layouts:
+     * 1. Structured: content/ subdirectory
+     * 2. Flat: .bpmn, .flow, and config files at the project root
+     *
+     * In the nupkg, all files go under content/. This avoids the double-nesting
+     * bug where content/content/ would be created.
+     */
+    private copyProjectFiles;
+    /**
+     * Recursively copy all files and subdirectories from source to destination.
+     */
+    private copyDirectoryContents;
+    /**
+     * 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 plus .bpmn and .flow files from content/.
+     */
+    private createPackageDescriptor;
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export { FlowTool } from "./flow-tool.js";
+export { FlowToolFactory } from "./flow-tool-factory.js";

package/dist/index.js

@@ -0,0 +1,263 @@
+// src/index.ts
+import { toolsFactoryRepository } from "@uipath/solutionpackager-tool-core";
+
+// src/flow-tool-factory.ts
+import {
+  ProjectTypes as ProjectTypes2
+} from "@uipath/solutionpackager-tool-core";
+
+// src/flow-tool.ts
+import {
+  NugetConstants,
+  NugetPackager,
+  Path as Path3,
+  ProjectTool,
+  ProjectTypes,
+  TemporaryStorageService,
+  ToolErrorCodes,
+  ToolResult
+} from "@uipath/solutionpackager-tool-core";
+
+// src/agents.ts
+import { Path as Path2 } from "@uipath/solutionpackager-tool-core";
+import { buildAgent } from "@uipath/tool-agent/build";
+
+// src/bindings.ts
+import { Path } from "@uipath/solutionpackager-tool-core";
+var BINDINGS_V2_FILE_NAME = "bindings_v2.json";
+var toBindingsResources = (result) => result.bindings.resources.map((r) => ({ ...r }));
+var mergeAgentBindings = async (fileSystem, contentFolder, agentBindingResources) => {
+  const bindingsPath = Path.join(contentFolder, BINDINGS_V2_FILE_NAME);
+  let existing = { version: "2.0", resources: [] };
+  const bindingsExists = await fileSystem.exists(bindingsPath);
+  if (bindingsExists) {
+    const content = await fileSystem.readFile(bindingsPath);
+    if (content) {
+      try {
+        const parsed = JSON.parse(new TextDecoder().decode(content));
+        if (Array.isArray(parsed?.resources)) {
+          existing = parsed;
+        }
+      } catch {}
+    }
+  }
+  const dedupKey = (b) => JSON.stringify([b.resource, b.key]);
+  const seen = new Set(existing.resources.map(dedupKey));
+  for (const binding of agentBindingResources) {
+    const key = dedupKey(binding);
+    if (!seen.has(key)) {
+      seen.add(key);
+      existing.resources.push(binding);
+    }
+  }
+  await fileSystem.writeFile(bindingsPath, JSON.stringify(existing, null, 2));
+};
+
+// src/agents.ts
+var processAgents = async (fileSystem, logger, projectPath, contentFolder) => {
+  const agentResults = [];
+  const entries = await fileSystem.readdir(projectPath);
+  for (const entry of entries) {
+    const sourceDir = Path2.join(projectPath, entry);
+    const stat = await fileSystem.stat(sourceDir);
+    if (!stat?.isDirectory()) {
+      continue;
+    }
+    const agentJsonPath = Path2.join(sourceDir, "agent.json");
+    if (!await fileSystem.exists(agentJsonPath)) {
+      continue;
+    }
+    const outputDir = Path2.join(contentFolder, entry);
+    logger.progress(`Processing agent: ${entry}...`);
+    const result = await buildAgent({
+      fileSystem,
+      projectPath: sourceDir,
+      outputPath: outputDir,
+      logger
+    });
+    agentResults.push(result);
+  }
+  const agentBindingResources = agentResults.flatMap(toBindingsResources);
+  if (agentBindingResources.length > 0) {
+    await mergeAgentBindings(fileSystem, contentFolder, agentBindingResources);
+  }
+};
+
+// src/flow-tool.ts
+var FlowConstants = {
+  EntryPointsFileName: "entry-points.json",
+  BindingsV2FileName: "bindings_v2.json"
+};
+
+class FlowTool 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 Flow projects");
+    return ToolResult.success();
+  }
+  async validateAsync(_options, _cancellationToken) {
+    this.logger.info("Validate operation is not required for Flow projects");
+    return ToolResult.success();
+  }
+  async buildAsync(options, _cancellationToken) {
+    const tempFolder = await this._temporaryStorage.getTempFolderPath();
+    const localBuildFolder = Path3.join(tempFolder, NugetConstants.OutputFolderName);
+    const contentFolder = Path3.join(localBuildFolder, NugetConstants.ContentFolderName);
+    try {
+      this.logger.progress("Copying files...");
+      await this.copyProjectFiles(options.projectPath, contentFolder);
+      this.logger.progress("Processing agents...");
+      await processAgents(this.fileSystem, this.logger, 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 Flow 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 = Path3.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 Flow project");
+    }
+  }
+  async dispose() {
+    this.logger.info("Disposing Flow Tool");
+    try {
+      await this._temporaryStorage.cleanup();
+    } catch {}
+  }
+  async copyProjectFiles(projectPath, contentFolder) {
+    await this.fileSystem.mkdir(contentFolder);
+    const entries = await this.fileSystem.readdir(projectPath);
+    for (const entry of entries) {
+      const sourceEntry = Path3.join(projectPath, entry);
+      const stat = await this.fileSystem.stat(sourceEntry);
+      if (stat?.isDirectory()) {
+        if (entry === NugetConstants.ContentFolderName) {
+          await this.copyDirectoryContents(sourceEntry, contentFolder);
+        }
+      } else if (stat?.isFile()) {
+        if (entry === "project.uiproj") {
+          continue;
+        }
+        const content = await this.fileSystem.readFile(sourceEntry);
+        if (content) {
+          await this.fileSystem.writeFile(Path3.join(contentFolder, entry), content);
+        }
+      }
+    }
+  }
+  async copyDirectoryContents(sourcePath, destinationPath) {
+    await this.fileSystem.mkdir(destinationPath);
+    const entries = await this.fileSystem.readdir(sourcePath);
+    for (const entry of entries) {
+      const sourceEntry = Path3.join(sourcePath, entry);
+      const destinationEntry = Path3.join(destinationPath, entry);
+      const stat = await this.fileSystem.stat(sourceEntry);
+      if (stat?.isDirectory()) {
+        await this.copyDirectoryContents(sourceEntry, destinationEntry);
+      } else if (stat?.isFile()) {
+        const content = await this.fileSystem.readFile(sourceEntry);
+        if (content) {
+          await this.fileSystem.writeFile(destinationEntry, content);
+        }
+      }
+    }
+  }
+  async createOperateFile(options, contentFolder) {
+    const operateJsonFilePath = Path3.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 = Path3.join(projectPath, FlowConstants.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.Flow,
+      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] = Path3.join(NugetConstants.ContentFolderName, NugetConstants.OperateFileName);
+    descriptorFiles[FlowConstants.EntryPointsFileName] = Path3.join(NugetConstants.ContentFolderName, FlowConstants.EntryPointsFileName);
+    descriptorFiles[NugetConstants.BindingsFileId] = Path3.join(NugetConstants.ContentFolderName, FlowConstants.BindingsV2FileName);
+    const contentEntries = await Path3.walkDirectory(this.fileSystem, contentFolder);
+    for (const entry of contentEntries) {
+      const ext = Path3.extname(entry.relativePath);
+      if (ext === ".bpmn" || ext === ".flow") {
+        descriptorFiles[entry.relativePath] = Path3.join(NugetConstants.ContentFolderName, entry.relativePath);
+      }
+    }
+    const packageDescriptorPath = Path3.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/flow-tool-factory.ts
+class FlowToolFactory {
+  supportedTypes = [ProjectTypes2.Flow];
+  async createAsync(logger, fileSystem) {
+    return new FlowTool(fileSystem, logger);
+  }
+}
+
+// src/index.ts
+toolsFactoryRepository.registerProjectToolFactory(new FlowToolFactory);
+export {
+  FlowToolFactory,
+  FlowTool
+};

package/package.json

@@ -0,0 +1,60 @@
+{
+    "name": "@uipath/packager-tool-flow",
+    "version": "0.0.17",
+    "description": "UiPath Flow 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-flow"
+    },
+    "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 --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",
+        "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",
+        "@uipath/tool-agent": "^1.0.1"
+    },
+    "devDependencies": {
+        "@types/node": "^25.5.0",
+        "@uipath/solutionpackager-tool-core": "0.0.31",
+        "@uipath/tool-agent": "^1.0.1",
+        "@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/agents.ts

@@ -0,0 +1,50 @@
+import type {
+    IFileSystem,
+    IToolLogger,
+} from "@uipath/solutionpackager-tool-core";
+import { Path } from "@uipath/solutionpackager-tool-core";
+import { type AgentBuildResult, buildAgent } from "@uipath/tool-agent/build";
+import { mergeAgentBindings, toBindingsResources } from "./bindings.js";
+
+export const processAgents = async (
+    fileSystem: IFileSystem,
+    logger: IToolLogger,
+    projectPath: string,
+    contentFolder: string,
+): Promise<void> => {
+    const agentResults: AgentBuildResult[] = [];
+
+    const entries = await fileSystem.readdir(projectPath);
+    for (const entry of entries) {
+        const sourceDir = Path.join(projectPath, entry);
+        const stat = await fileSystem.stat(sourceDir);
+        if (!stat?.isDirectory()) {
+            continue;
+        }
+
+        const agentJsonPath = Path.join(sourceDir, "agent.json");
+        if (!(await fileSystem.exists(agentJsonPath))) {
+            continue;
+        }
+
+        const outputDir = Path.join(contentFolder, entry);
+        logger.progress(`Processing agent: ${entry}...`);
+
+        const result = await buildAgent({
+            fileSystem,
+            projectPath: sourceDir,
+            outputPath: outputDir,
+            logger,
+        });
+        agentResults.push(result);
+    }
+
+    const agentBindingResources = agentResults.flatMap(toBindingsResources);
+    if (agentBindingResources.length > 0) {
+        await mergeAgentBindings(
+            fileSystem,
+            contentFolder,
+            agentBindingResources,
+        );
+    }
+};

package/src/bindings.ts

@@ -0,0 +1,64 @@
+import type { IFileSystem } from "@uipath/solutionpackager-tool-core";
+import { Path } from "@uipath/solutionpackager-tool-core";
+import type { AgentBuildResult } from "@uipath/tool-agent/build";
+
+export interface BindingsResource {
+    resource: string;
+    key: string;
+    [other: string]: unknown;
+}
+
+export interface Bindings {
+    version: string;
+    resources: BindingsResource[];
+}
+
+const BINDINGS_V2_FILE_NAME = "bindings_v2.json";
+
+export const toBindingsResources = (
+    result: AgentBuildResult,
+): BindingsResource[] => result.bindings.resources.map((r) => ({ ...r }));
+
+/**
+ * Merge agent binding resources into the flow's bindings_v2.json.
+ * Deduplicates by (resource, key) tuple, keeping the first occurrence.
+ */
+export const mergeAgentBindings = async (
+    fileSystem: IFileSystem,
+    contentFolder: string,
+    agentBindingResources: BindingsResource[],
+): Promise<void> => {
+    const bindingsPath = Path.join(contentFolder, BINDINGS_V2_FILE_NAME);
+
+    let existing: Bindings = { version: "2.0", resources: [] };
+
+    const bindingsExists = await fileSystem.exists(bindingsPath);
+    if (bindingsExists) {
+        const content = await fileSystem.readFile(bindingsPath);
+        if (content) {
+            try {
+                const parsed = JSON.parse(new TextDecoder().decode(content));
+                if (Array.isArray(parsed?.resources)) {
+                    existing = parsed;
+                }
+            } catch {
+                // Invalid JSON, start fresh
+            }
+        }
+    }
+
+    const dedupKey = (b: BindingsResource) =>
+        JSON.stringify([b.resource, b.key]);
+
+    const seen = new Set(existing.resources.map(dedupKey));
+
+    for (const binding of agentBindingResources) {
+        const key = dedupKey(binding);
+        if (!seen.has(key)) {
+            seen.add(key);
+            existing.resources.push(binding);
+        }
+    }
+
+    await fileSystem.writeFile(bindingsPath, JSON.stringify(existing, null, 2));
+};

package/src/flow-tool-factory.ts

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

package/src/flow-tool.ts

@@ -0,0 +1,359 @@
+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";
+import { processAgents } from "./agents.js";
+
+const FlowConstants = {
+    EntryPointsFileName: "entry-points.json",
+    BindingsV2FileName: "bindings_v2.json",
+} as const;
+
+/**
+ * Flow project tool implementation
+ */
+export class FlowTool 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 Flow projects");
+        return ToolResult.success();
+    }
+
+    override async validateAsync(
+        _options: IProjectValidateOptions,
+        _cancellationToken?: AbortSignal,
+    ): Promise<ToolResult> {
+        this.logger.info(
+            "Validate operation is not required for Flow 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.copyProjectFiles(options.projectPath, contentFolder);
+
+            this.logger.progress("Processing agents...");
+            await processAgents(
+                this.fileSystem,
+                this.logger,
+                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 Flow 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 Flow project",
+            );
+        }
+    }
+
+    override async dispose(): Promise<void> {
+        this.logger.info("Disposing Flow Tool");
+        try {
+            await this._temporaryStorage.cleanup();
+        } catch {
+            // Ignore errors during cleanup
+        }
+    }
+
+    /**
+     * Copy project files into the correct nupkg structure.
+     *
+     * Flow projects have two layouts:
+     * 1. Structured: content/ subdirectory
+     * 2. Flat: .bpmn, .flow, and config files at the project root
+     *
+     * In the nupkg, all files go under content/. This avoids the double-nesting
+     * bug where content/content/ would be created.
+     */
+    private async copyProjectFiles(
+        projectPath: string,
+        contentFolder: string,
+    ): Promise<void> {
+        await this.fileSystem.mkdir(contentFolder);
+
+        const entries = await this.fileSystem.readdir(projectPath);
+
+        for (const entry of entries) {
+            const sourceEntry = Path.join(projectPath, entry);
+            const stat = await this.fileSystem.stat(sourceEntry);
+
+            if (stat?.isDirectory()) {
+                if (entry === NugetConstants.ContentFolderName) {
+                    // Copy content/ subdir contents directly into contentFolder.
+                    await this.copyDirectoryContents(
+                        sourceEntry,
+                        contentFolder,
+                    );
+                }
+                // Other directories (agent projects, .local, .git, etc.)
+                // are not copied. Agent dirs are handled by processAgents
+                // which writes only the processed agent.json via buildAgent.
+            } else if (stat?.isFile()) {
+                // Skip the project.uiproj project metadata file
+                if (entry === "project.uiproj") {
+                    continue;
+                }
+
+                const content = await this.fileSystem.readFile(sourceEntry);
+                if (content) {
+                    await this.fileSystem.writeFile(
+                        Path.join(contentFolder, entry),
+                        content,
+                    );
+                }
+            }
+        }
+    }
+
+    /**
+     * Recursively copy all files and subdirectories from source to destination.
+     */
+    private async copyDirectoryContents(
+        sourcePath: string,
+        destinationPath: string,
+    ): Promise<void> {
+        await this.fileSystem.mkdir(destinationPath);
+
+        const entries = await this.fileSystem.readdir(sourcePath);
+
+        for (const entry of entries) {
+            const sourceEntry = Path.join(sourcePath, entry);
+            const destinationEntry = Path.join(destinationPath, entry);
+
+            const stat = await this.fileSystem.stat(sourceEntry);
+            if (stat?.isDirectory()) {
+                await this.copyDirectoryContents(sourceEntry, destinationEntry);
+            } else if (stat?.isFile()) {
+                const content = await this.fileSystem.readFile(sourceEntry);
+                if (content) {
+                    await this.fileSystem.writeFile(destinationEntry, 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> {
+        // Flow uses 'entry-points.json' (with dash), not 'entrypoints.json'
+        const entryPointsFilePath = Path.join(
+            projectPath,
+            FlowConstants.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.Flow,
+            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 plus .bpmn and .flow 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[FlowConstants.EntryPointsFileName] = Path.join(
+            NugetConstants.ContentFolderName,
+            FlowConstants.EntryPointsFileName,
+        );
+        descriptorFiles[NugetConstants.BindingsFileId] = Path.join(
+            NugetConstants.ContentFolderName,
+            FlowConstants.BindingsV2FileName,
+        );
+
+        // Discover .bpmn and .flow files from content/
+        const contentEntries = await Path.walkDirectory(
+            this.fileSystem,
+            contentFolder,
+        );
+        for (const entry of contentEntries) {
+            const ext = Path.extname(entry.relativePath);
+            if (ext === ".bpmn" || ext === ".flow") {
+                descriptorFiles[entry.relativePath] = Path.join(
+                    NugetConstants.ContentFolderName,
+                    entry.relativePath,
+                );
+            }
+        }
+
+        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,8 @@
+// Self-register Flow tool factory with the singleton repository
+import { toolsFactoryRepository } from "@uipath/solutionpackager-tool-core";
+import { FlowToolFactory } from "./flow-tool-factory.js";
+
+export { FlowTool } from "./flow-tool.js";
+export { FlowToolFactory } from "./flow-tool-factory.js";
+
+toolsFactoryRepository.registerProjectToolFactory(new FlowToolFactory());