@uipath/packager-tool-apiworkflow 0.0.17

package/README.md

@@ -0,0 +1,53 @@
+# @uipath/tool-apiworkflow
+
+A reference implementation of a **Project Tool** for the UiPath Solution Packager, designed for handling **API Workflow** projects.
+
+## Overview
+
+This package demonstrates how to build a fully functional packaging tool using `@uipath/solutionpackager-tool-core`. It implements the lifecycle method for building and packing API projects.
+
+## Features
+
+- **Reference Implementation**: strict adherence to `@uipath/solutionpackager-tool-core` contracts.
+- **Build Operations**:
+  - Validates project structure
+  - Copies project files to a clean output directory
+  - Generates `operating.json` configuration
+  - Generates `package-descriptor.json`
+- **Pack Operations**:
+  - Creates `.nupkg` packages (Nuget)
+  - Handles versioning and metadata
+
+## Project Structure
+
+```
+src/
+├── api-workflows-tool.ts      # Main tool logic implementation
+├── api-workflow-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/api-workflow-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 API Workflow project tools
+ */
+export declare class ApiWorkflowToolFactory implements IProjectToolFactory {
+    readonly supportedTypes: readonly ProjectType[];
+    createAsync(logger: IToolLogger, fileSystem: IFileSystem): Promise<ProjectTool>;
+}

package/dist/api-workflows-tool.d.ts

@@ -0,0 +1,34 @@
+import type { IProjectBuildOptions, IProjectPackOptions, IProjectRestoreOptions, IProjectValidateOptions } from "@uipath/solutionpackager-tool-core";
+import { type IFileSystem, type IToolLogger, ProjectTool, ToolResult } from "@uipath/solutionpackager-tool-core";
+/**
+ * API Workflow project tool implementation
+ */
+export declare class ApiWorkflowsTool 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 destination path
+     */
+    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
+     */
+    private createPackageDescriptor;
+    /**
+     * Add file to package descriptor if it exists
+     */
+    private addFileIfExists;
+}

package/dist/i18n/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * i18n module for tool-apiworkflow package.
+ * Registers tool-apiworkflow-specific translations.
+ */
+import { en } from "./locales/en.js";
+export type { TranslationKeys } from "./locales/en.js";
+export { en };

package/dist/i18n/locales/en.d.ts

@@ -0,0 +1,29 @@
+/**
+ * English translations for tool-apiworkflow package.
+ * These translations are registered alongside core translations via I18nManager.
+ */
+export declare const en: {
+    readonly toolApiworkflow: {
+        readonly info: {
+            readonly restoreNotRequired: "Restore operation is not required for API projects";
+            readonly validateNotRequired: "Validate operation is not required for API projects";
+            readonly disposing: "Disposing API Workflows Tool";
+        };
+        readonly progress: {
+            readonly copyingFiles: "Copying files...";
+            readonly creatingOperateFile: "Creating operate.json file...";
+            readonly creatingPackageDescriptor: "Creating package-descriptor.json file...";
+            readonly creatingNugetPackage: "Creating NuGet package...";
+            readonly packageCreatedSuccessfully: "Package created successfully";
+        };
+        readonly success: {
+            readonly done: "done";
+        };
+        readonly errors: {
+            readonly buildFailed: "An error occurred while building API project files";
+            readonly packFailed: "An error occurred while packing API project";
+        };
+    };
+};
+/** @public */
+export type TranslationKeys = typeof en;

package/dist/index.d.ts

@@ -0,0 +1 @@
+import "./i18n/index.js";

package/dist/index.js

@@ -0,0 +1,540 @@
+// src/i18n/index.ts
+import { I18nManager } from "@uipath/solutionpackager-tool-core";
+// src/i18n/locales/de.json
+var de_default = {
+  toolApiworkflow: {
+    info: {
+      restoreNotRequired: "Restore operation is not required for API projects",
+      validateNotRequired: "Validate operation is not required for API projects",
+      disposing: "Disposing API Workflows Tool"
+    },
+    progress: {
+      copyingFiles: "Copying files...",
+      creatingOperateFile: "Creating operate.json file...",
+      creatingPackageDescriptor: "Creating package-descriptor.json file...",
+      creatingNugetPackage: "Creating NuGet package...",
+      packageCreatedSuccessfully: "Package created successfully"
+    },
+    success: {
+      done: "done"
+    },
+    errors: {
+      buildFailed: "An error occurred while building API project files",
+      packFailed: "An error occurred while packing API project"
+    }
+  }
+};
+
+// src/i18n/locales/en.ts
+var en = {
+  toolApiworkflow: {
+    info: {
+      restoreNotRequired: "Restore operation is not required for API projects",
+      validateNotRequired: "Validate operation is not required for API projects",
+      disposing: "Disposing API Workflows Tool"
+    },
+    progress: {
+      copyingFiles: "Copying files...",
+      creatingOperateFile: "Creating operate.json file...",
+      creatingPackageDescriptor: "Creating package-descriptor.json file...",
+      creatingNugetPackage: "Creating NuGet package...",
+      packageCreatedSuccessfully: "Package created successfully"
+    },
+    success: {
+      done: "done"
+    },
+    errors: {
+      buildFailed: "An error occurred while building API project files",
+      packFailed: "An error occurred while packing API project"
+    }
+  }
+};
+// src/i18n/locales/es.json
+var es_default = {
+  toolApiworkflow: {
+    info: {
+      restoreNotRequired: "Restore operation is not required for API projects",
+      validateNotRequired: "Validate operation is not required for API projects",
+      disposing: "Disposing API Workflows Tool"
+    },
+    progress: {
+      copyingFiles: "Copying files...",
+      creatingOperateFile: "Creating operate.json file...",
+      creatingPackageDescriptor: "Creating package-descriptor.json file...",
+      creatingNugetPackage: "Creating NuGet package...",
+      packageCreatedSuccessfully: "Package created successfully"
+    },
+    success: {
+      done: "done"
+    },
+    errors: {
+      buildFailed: "An error occurred while building API project files",
+      packFailed: "An error occurred while packing API project"
+    }
+  }
+};
+// src/i18n/locales/es-MX.json
+var es_MX_default = {
+  toolApiworkflow: {
+    info: {
+      restoreNotRequired: "Restore operation is not required for API projects",
+      validateNotRequired: "Validate operation is not required for API projects",
+      disposing: "Disposing API Workflows Tool"
+    },
+    progress: {
+      copyingFiles: "Copying files...",
+      creatingOperateFile: "Creating operate.json file...",
+      creatingPackageDescriptor: "Creating package-descriptor.json file...",
+      creatingNugetPackage: "Creating NuGet package...",
+      packageCreatedSuccessfully: "Package created successfully"
+    },
+    success: {
+      done: "done"
+    },
+    errors: {
+      buildFailed: "An error occurred while building API project files",
+      packFailed: "An error occurred while packing API project"
+    }
+  }
+};
+// src/i18n/locales/fr.json
+var fr_default = {
+  toolApiworkflow: {
+    info: {
+      restoreNotRequired: "Restore operation is not required for API projects",
+      validateNotRequired: "Validate operation is not required for API projects",
+      disposing: "Disposing API Workflows Tool"
+    },
+    progress: {
+      copyingFiles: "Copying files...",
+      creatingOperateFile: "Creating operate.json file...",
+      creatingPackageDescriptor: "Creating package-descriptor.json file...",
+      creatingNugetPackage: "Creating NuGet package...",
+      packageCreatedSuccessfully: "Package created successfully"
+    },
+    success: {
+      done: "done"
+    },
+    errors: {
+      buildFailed: "An error occurred while building API project files",
+      packFailed: "An error occurred while packing API project"
+    }
+  }
+};
+// src/i18n/locales/ja.json
+var ja_default = {
+  toolApiworkflow: {
+    info: {
+      restoreNotRequired: "Restore operation is not required for API projects",
+      validateNotRequired: "Validate operation is not required for API projects",
+      disposing: "Disposing API Workflows Tool"
+    },
+    progress: {
+      copyingFiles: "Copying files...",
+      creatingOperateFile: "Creating operate.json file...",
+      creatingPackageDescriptor: "Creating package-descriptor.json file...",
+      creatingNugetPackage: "Creating NuGet package...",
+      packageCreatedSuccessfully: "Package created successfully"
+    },
+    success: {
+      done: "done"
+    },
+    errors: {
+      buildFailed: "An error occurred while building API project files",
+      packFailed: "An error occurred while packing API project"
+    }
+  }
+};
+// src/i18n/locales/ko.json
+var ko_default = {
+  toolApiworkflow: {
+    info: {
+      restoreNotRequired: "Restore operation is not required for API projects",
+      validateNotRequired: "Validate operation is not required for API projects",
+      disposing: "Disposing API Workflows Tool"
+    },
+    progress: {
+      copyingFiles: "Copying files...",
+      creatingOperateFile: "Creating operate.json file...",
+      creatingPackageDescriptor: "Creating package-descriptor.json file...",
+      creatingNugetPackage: "Creating NuGet package...",
+      packageCreatedSuccessfully: "Package created successfully"
+    },
+    success: {
+      done: "done"
+    },
+    errors: {
+      buildFailed: "An error occurred while building API project files",
+      packFailed: "An error occurred while packing API project"
+    }
+  }
+};
+// src/i18n/locales/pt.json
+var pt_default = {
+  toolApiworkflow: {
+    info: {
+      restoreNotRequired: "Restore operation is not required for API projects",
+      validateNotRequired: "Validate operation is not required for API projects",
+      disposing: "Disposing API Workflows Tool"
+    },
+    progress: {
+      copyingFiles: "Copying files...",
+      creatingOperateFile: "Creating operate.json file...",
+      creatingPackageDescriptor: "Creating package-descriptor.json file...",
+      creatingNugetPackage: "Creating NuGet package...",
+      packageCreatedSuccessfully: "Package created successfully"
+    },
+    success: {
+      done: "done"
+    },
+    errors: {
+      buildFailed: "An error occurred while building API project files",
+      packFailed: "An error occurred while packing API project"
+    }
+  }
+};
+// src/i18n/locales/pt-BR.json
+var pt_BR_default = {
+  toolApiworkflow: {
+    info: {
+      restoreNotRequired: "Restore operation is not required for API projects",
+      validateNotRequired: "Validate operation is not required for API projects",
+      disposing: "Disposing API Workflows Tool"
+    },
+    progress: {
+      copyingFiles: "Copying files...",
+      creatingOperateFile: "Creating operate.json file...",
+      creatingPackageDescriptor: "Creating package-descriptor.json file...",
+      creatingNugetPackage: "Creating NuGet package...",
+      packageCreatedSuccessfully: "Package created successfully"
+    },
+    success: {
+      done: "done"
+    },
+    errors: {
+      buildFailed: "An error occurred while building API project files",
+      packFailed: "An error occurred while packing API project"
+    }
+  }
+};
+// src/i18n/locales/ro.json
+var ro_default = {
+  toolApiworkflow: {
+    info: {
+      restoreNotRequired: "Restore operation is not required for API projects",
+      validateNotRequired: "Validate operation is not required for API projects",
+      disposing: "Disposing API Workflows Tool"
+    },
+    progress: {
+      copyingFiles: "Copying files...",
+      creatingOperateFile: "Creating operate.json file...",
+      creatingPackageDescriptor: "Creating package-descriptor.json file...",
+      creatingNugetPackage: "Creating NuGet package...",
+      packageCreatedSuccessfully: "Package created successfully"
+    },
+    success: {
+      done: "done"
+    },
+    errors: {
+      buildFailed: "An error occurred while building API project files",
+      packFailed: "An error occurred while packing API project"
+    }
+  }
+};
+// src/i18n/locales/ru.json
+var ru_default = {
+  toolApiworkflow: {
+    info: {
+      restoreNotRequired: "Restore operation is not required for API projects",
+      validateNotRequired: "Validate operation is not required for API projects",
+      disposing: "Disposing API Workflows Tool"
+    },
+    progress: {
+      copyingFiles: "Copying files...",
+      creatingOperateFile: "Creating operate.json file...",
+      creatingPackageDescriptor: "Creating package-descriptor.json file...",
+      creatingNugetPackage: "Creating NuGet package...",
+      packageCreatedSuccessfully: "Package created successfully"
+    },
+    success: {
+      done: "done"
+    },
+    errors: {
+      buildFailed: "An error occurred while building API project files",
+      packFailed: "An error occurred while packing API project"
+    }
+  }
+};
+// src/i18n/locales/tr.json
+var tr_default = {
+  toolApiworkflow: {
+    info: {
+      restoreNotRequired: "Restore operation is not required for API projects",
+      validateNotRequired: "Validate operation is not required for API projects",
+      disposing: "Disposing API Workflows Tool"
+    },
+    progress: {
+      copyingFiles: "Copying files...",
+      creatingOperateFile: "Creating operate.json file...",
+      creatingPackageDescriptor: "Creating package-descriptor.json file...",
+      creatingNugetPackage: "Creating NuGet package...",
+      packageCreatedSuccessfully: "Package created successfully"
+    },
+    success: {
+      done: "done"
+    },
+    errors: {
+      buildFailed: "An error occurred while building API project files",
+      packFailed: "An error occurred while packing API project"
+    }
+  }
+};
+// src/i18n/locales/zh-CN.json
+var zh_CN_default = {
+  toolApiworkflow: {
+    info: {
+      restoreNotRequired: "Restore operation is not required for API projects",
+      validateNotRequired: "Validate operation is not required for API projects",
+      disposing: "Disposing API Workflows Tool"
+    },
+    progress: {
+      copyingFiles: "Copying files...",
+      creatingOperateFile: "Creating operate.json file...",
+      creatingPackageDescriptor: "Creating package-descriptor.json file...",
+      creatingNugetPackage: "Creating NuGet package...",
+      packageCreatedSuccessfully: "Package created successfully"
+    },
+    success: {
+      done: "done"
+    },
+    errors: {
+      buildFailed: "An error occurred while building API project files",
+      packFailed: "An error occurred while packing API project"
+    }
+  }
+};
+// src/i18n/locales/zh-TW.json
+var zh_TW_default = {
+  toolApiworkflow: {
+    info: {
+      restoreNotRequired: "Restore operation is not required for API projects",
+      validateNotRequired: "Validate operation is not required for API projects",
+      disposing: "Disposing API Workflows Tool"
+    },
+    progress: {
+      copyingFiles: "Copying files...",
+      creatingOperateFile: "Creating operate.json file...",
+      creatingPackageDescriptor: "Creating package-descriptor.json file...",
+      creatingNugetPackage: "Creating NuGet package...",
+      packageCreatedSuccessfully: "Package created successfully"
+    },
+    success: {
+      done: "done"
+    },
+    errors: {
+      buildFailed: "An error occurred while building API project files",
+      packFailed: "An error occurred while packing API project"
+    }
+  }
+};
+// src/i18n/locales/zu.json
+var zu_default = {
+  toolApiworkflow: {
+    info: {
+      restoreNotRequired: "Restore operation is not required for API projects",
+      validateNotRequired: "Validate operation is not required for API projects",
+      disposing: "Disposing API Workflows Tool"
+    },
+    progress: {
+      copyingFiles: "Copying files...",
+      creatingOperateFile: "Creating operate.json file...",
+      creatingPackageDescriptor: "Creating package-descriptor.json file...",
+      creatingNugetPackage: "Creating NuGet package...",
+      packageCreatedSuccessfully: "Package created successfully"
+    },
+    success: {
+      done: "done"
+    },
+    errors: {
+      buildFailed: "An error occurred while building API project files",
+      packFailed: "An error occurred while packing API project"
+    }
+  }
+};
+
+// src/i18n/index.ts
+I18nManager.registerTranslations("en", en);
+I18nManager.registerTranslations("de", de_default);
+I18nManager.registerTranslations("es", es_default);
+I18nManager.registerTranslations("es-MX", es_MX_default);
+I18nManager.registerTranslations("fr", fr_default);
+I18nManager.registerTranslations("ja", ja_default);
+I18nManager.registerTranslations("ko", ko_default);
+I18nManager.registerTranslations("pt", pt_default);
+I18nManager.registerTranslations("pt-BR", pt_BR_default);
+I18nManager.registerTranslations("ro", ro_default);
+I18nManager.registerTranslations("ru", ru_default);
+I18nManager.registerTranslations("tr", tr_default);
+I18nManager.registerTranslations("zh-CN", zh_CN_default);
+I18nManager.registerTranslations("zh-TW", zh_TW_default);
+I18nManager.registerTranslations("zu", zu_default);
+
+// src/index.ts
+import { toolsFactoryRepository } from "@uipath/solutionpackager-tool-core";
+
+// src/api-workflow-tool-factory.ts
+import {
+  ProjectTypes as ProjectTypes2
+} from "@uipath/solutionpackager-tool-core";
+
+// src/api-workflows-tool.ts
+import {
+  NugetConstants,
+  NugetPackager,
+  Path,
+  ProjectTool,
+  ProjectTypes,
+  TemporaryStorageService,
+  ToolErrorCodes,
+  ToolResult,
+  translate
+} from "@uipath/solutionpackager-tool-core";
+
+class ApiWorkflowsTool extends ProjectTool {
+  _temporaryStorage;
+  constructor(fileSystem, logger) {
+    super(fileSystem, logger);
+    this._temporaryStorage = new TemporaryStorageService(fileSystem);
+  }
+  async restoreAsync(_options, _cancellationToken) {
+    this.logger.info(translate.t("toolApiworkflow.info.restoreNotRequired"));
+    return ToolResult.success();
+  }
+  async validateAsync(_options, _cancellationToken) {
+    this.logger.info(translate.t("toolApiworkflow.info.validateNotRequired"));
+    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(translate.t("toolApiworkflow.progress.copyingFiles"));
+      await this.copyFiles(options.projectPath, contentFolder);
+      this.logger.progress(translate.t("toolApiworkflow.progress.creatingOperateFile"));
+      await this.createOperateFile(options, contentFolder);
+      this.logger.progress(translate.t("toolApiworkflow.progress.creatingPackageDescriptor"));
+      await this.createPackageDescriptor(localBuildFolder);
+      return new ToolResult(ToolErrorCodes.Success, translate.t("toolApiworkflow.success.done"), [localBuildFolder]);
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.toString() : String(error);
+      this.logger.error(errorMessage);
+      return ToolResult.error(ToolErrorCodes.InternalError, translate.t("toolApiworkflow.errors.buildFailed"));
+    }
+  }
+  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(translate.t("toolApiworkflow.progress.creatingNugetPackage"));
+      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(translate.t("toolApiworkflow.progress.packageCreatedSuccessfully"));
+      return new ToolResult(ToolErrorCodes.Success, translate.t("toolApiworkflow.success.done"), [result.outputPath]);
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.toString() : String(error);
+      this.logger.error(errorMessage);
+      return ToolResult.error(ToolErrorCodes.InternalError, translate.t("toolApiworkflow.errors.packFailed"));
+    }
+  }
+  async dispose() {
+    this.logger.info(translate.t("toolApiworkflow.info.disposing"));
+    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, NugetConstants.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.Api,
+      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) {
+    const packageDescriptor = {
+      files: {}
+    };
+    this.addFileIfExists(packageDescriptor, localBuildFolder, NugetConstants.OperateFileName, NugetConstants.OperateFileName);
+    this.addFileIfExists(packageDescriptor, localBuildFolder, NugetConstants.EntryPointsFileName, NugetConstants.EntryPointsFileName);
+    this.addFileIfExists(packageDescriptor, localBuildFolder, NugetConstants.BindingsFileId, NugetConstants.BindingsV2FileName);
+    const packageDescriptorPath = Path.join(localBuildFolder, NugetConstants.ContentFolderName, NugetConstants.PackageDescriptorFileName);
+    const packageDescriptorJson = JSON.stringify({
+      $schema: "https://cloud.uipath.com/draft/2024-12/package-descriptor",
+      ...packageDescriptor
+    }, null, 2);
+    await this.fileSystem.writeFile(packageDescriptorPath, packageDescriptorJson);
+  }
+  addFileIfExists(packageDescriptor, _rootFolder, key, fileName) {
+    const relativePath = Path.join(NugetConstants.ContentFolderName, fileName);
+    packageDescriptor.files[key] = relativePath;
+  }
+}
+
+// src/api-workflow-tool-factory.ts
+class ApiWorkflowToolFactory {
+  supportedTypes = [ProjectTypes2.Api];
+  async createAsync(logger, fileSystem) {
+    return new ApiWorkflowsTool(fileSystem, logger);
+  }
+}
+
+// src/index.ts
+toolsFactoryRepository.registerProjectToolFactory(new ApiWorkflowToolFactory);