@uipath/packager-tool-connector 0.0.17

package/README.md

@@ -0,0 +1,44 @@
+# UiPath Connector Tool
+
+A specialized Project Tool for building and packaging **UiPath Connector** projects.
+
+## Overview
+
+The Connector Tool handles the specific requirements of Connector projects, including asset management and manifest validation. It is built on top of the `@uipath/solutionpackager-tool-core` framework.
+
+## Capabilities
+
+- **Project Identification**: Automatically detects Connector projects based on project structure.
+- **Build Process**:
+  - Validates connector assets
+  - Copies resource files recursively
+  - Flattens directory structures where required
+- **Packaging**:
+  - Generates standard NuGet packages (`.nupkg`) suitable for UiPath Orchestrator or Marketplace.
+
+## Architecture
+
+This package exports a `ConnectorToolFactory` which is registered with the main Solution Packager at runtime.
+
+### Key Classes
+
+- **`ConnectorTool`**: Implements `buildAsync` and `packAsync`.
+- **`ConnectorToolFactory`**: Checked against `ProjectTypes.Connector`.
+
+## Development
+
+**Build:**
+
+```bash
+npm run build
+```
+
+**Test:**
+
+```bash
+# Node.js environment
+npm run test
+
+# Browser environment (via Vitest/Playwright)
+npm run test:browser
+```

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

package/dist/connector-tool.d.ts

@@ -0,0 +1,22 @@
+import type { IProjectBuildOptions, IProjectPackOptions, IProjectRestoreOptions, IProjectValidateOptions } from "@uipath/solutionpackager-tool-core";
+import { type IFileSystem, type IToolLogger, ProjectTool, ToolResult } from "@uipath/solutionpackager-tool-core";
+/**
+ * Connector project tool implementation
+ *
+ * Handles build and pack operations for Connector projects.
+ * Build copies the 'app' folder to the output content folder.
+ */
+export declare class ConnectorTool extends ProjectTool {
+    private static readonly AppFolderName;
+    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>;
+    /**
+     * Recursively copy a directory and its contents
+     */
+    private copyDirectory;
+}

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,108 @@
+// src/index.ts
+import { toolsFactoryRepository } from "@uipath/solutionpackager-tool-core";
+
+// src/connector-tool-factory.ts
+import {
+  ProjectTypes
+} from "@uipath/solutionpackager-tool-core";
+
+// src/connector-tool.ts
+import {
+  NugetConstants,
+  NugetPackager,
+  Path,
+  ProjectTool,
+  TemporaryStorageService,
+  ToolErrorCodes,
+  ToolResult
+} from "@uipath/solutionpackager-tool-core";
+
+class ConnectorTool extends ProjectTool {
+  static AppFolderName = "app";
+  _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 Connector projects");
+    return ToolResult.success();
+  }
+  async validateAsync(_options, _cancellationToken) {
+    this.logger.info("Validate operation is not required for Connector projects");
+    return ToolResult.success();
+  }
+  async buildAsync(options, _cancellationToken) {
+    const tempFolder = await this._temporaryStorage.getTempFolderPath();
+    const localBuildFolder = Path.join(tempFolder, NugetConstants.OutputFolderName);
+    const appProjectFolder = Path.join(options.projectPath, ConnectorTool.AppFolderName);
+    const destinationFolder = Path.join(localBuildFolder, NugetConstants.ContentFolderName, ConnectorTool.AppFolderName);
+    try {
+      this.logger.progress("Copying app folder...");
+      await this.copyDirectory(appProjectFolder, destinationFolder);
+      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 Connector project");
+    }
+  }
+  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 Connector project");
+    }
+  }
+  async dispose() {
+    this.logger.info("Disposing Connector Tool");
+    try {
+      await this._temporaryStorage.cleanup();
+    } catch {}
+  }
+  async copyDirectory(sourcePath, destinationPath) {
+    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.copyDirectory(sourceEntry, destinationEntry);
+      } else if (stat?.isFile()) {
+        const content = await this.fileSystem.readFile(sourceEntry);
+        if (content) {
+          await this.fileSystem.writeFile(destinationEntry, content);
+        }
+      }
+    }
+  }
+}
+
+// src/connector-tool-factory.ts
+class ConnectorToolFactory {
+  supportedTypes = [ProjectTypes.Connector];
+  async createAsync(logger, fileSystem) {
+    return new ConnectorTool(fileSystem, logger);
+  }
+}
+
+// src/index.ts
+toolsFactoryRepository.registerProjectToolFactory(new ConnectorToolFactory);

package/package.json

@@ -0,0 +1,58 @@
+{
+    "name": "@uipath/packager-tool-connector",
+    "version": "0.0.17",
+    "description": "UiPath Connector 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-connector"
+    },
+    "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/connector-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 { ConnectorTool } from "./connector-tool.js";
+
+/**
+ * Factory for creating Connector project tools
+ */
+export class ConnectorToolFactory implements IProjectToolFactory {
+    readonly supportedTypes: readonly ProjectType[] = [ProjectTypes.Connector];
+
+    async createAsync(
+        logger: IToolLogger,
+        fileSystem: IFileSystem,
+    ): Promise<ProjectTool> {
+        return new ConnectorTool(fileSystem, logger);
+    }
+}

package/src/connector-tool.ts

@@ -0,0 +1,169 @@
+import type {
+    IProjectBuildOptions,
+    IProjectPackOptions,
+    IProjectRestoreOptions,
+    IProjectValidateOptions,
+} from "@uipath/solutionpackager-tool-core";
+import {
+    type IFileSystem,
+    type IToolLogger,
+    NugetConstants,
+    NugetPackager,
+    Path,
+    ProjectTool,
+    TemporaryStorageService,
+    ToolErrorCodes,
+    ToolResult,
+} from "@uipath/solutionpackager-tool-core";
+
+/**
+ * Connector project tool implementation
+ *
+ * Handles build and pack operations for Connector projects.
+ * Build copies the 'app' folder to the output content folder.
+ */
+export class ConnectorTool extends ProjectTool {
+    private static readonly AppFolderName = "app";
+    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 Connector projects",
+        );
+        return ToolResult.success();
+    }
+
+    override async validateAsync(
+        _options: IProjectValidateOptions,
+        _cancellationToken?: AbortSignal,
+    ): Promise<ToolResult> {
+        this.logger.info(
+            "Validate operation is not required for Connector 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 appProjectFolder = Path.join(
+            options.projectPath,
+            ConnectorTool.AppFolderName,
+        );
+        const destinationFolder = Path.join(
+            localBuildFolder,
+            NugetConstants.ContentFolderName,
+            ConnectorTool.AppFolderName,
+        );
+
+        try {
+            this.logger.progress("Copying app folder...");
+            await this.copyDirectory(appProjectFolder, destinationFolder);
+
+            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 Connector project",
+            );
+        }
+    }
+
+    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 Connector project",
+            );
+        }
+    }
+
+    override async dispose(): Promise<void> {
+        this.logger.info("Disposing Connector Tool");
+        try {
+            await this._temporaryStorage.cleanup();
+        } catch {
+            // Ignore errors during cleanup
+        }
+    }
+
+    /**
+     * Recursively copy a directory and its contents
+     */
+    private async copyDirectory(
+        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()) {
+                // Recursively copy subdirectories
+                await this.copyDirectory(sourceEntry, destinationEntry);
+            } else if (stat?.isFile()) {
+                // Copy file
+                const content = await this.fileSystem.readFile(sourceEntry);
+                if (content) {
+                    await this.fileSystem.writeFile(destinationEntry, content);
+                }
+            }
+        }
+    }
+}

package/src/index.ts

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