@uipath/packager-tool-connector 1.202.0-preview.140 → 1.202.0-preview.142

package/package.json

@@ -1,13 +1,10 @@
 {
     "name": "@uipath/packager-tool-connector",
-    "version": "1.202.0-preview.140",
+    "version": "1.202.0-preview.142",
     "description": "UiPath Connector tool implementation",
     "type": "module",
     "exports": {
-        ".": {
-            "source": "./src/index.ts",
-            "default": "./dist/index.js"
-        }
+        ".": "./dist/index.js"
     },
     "repository": {
         "type": "git",
@@ -19,13 +16,12 @@
     },
     "types": "./dist/index.d.ts",
     "files": [
-        "dist",
-        "src"
+        "dist"
     ],
     "author": "",
     "license": "ISC",
     "peerDependencies": {
         "@uipath/solutionpackager-tool-core": "1.202.0"
     },
-    "gitHead": "1861498d8a158a710a718c04614523ba59c93781"
+    "gitHead": "2f7204440851d62ecc9f2d2e202c863293821d90"
 }

package/src/connector-tool-factory.ts

@@ -1,23 +0,0 @@
-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

@@ -1,284 +0,0 @@
-import type {
-    IProjectBuildOptions,
-    IProjectPackOptions,
-    IProjectRestoreOptions,
-    IProjectValidateOptions,
-} from "@uipath/solutionpackager-tool-core";
-import {
-    ensureProjectId,
-    type IFileSystem,
-    type IToolLogger,
-    NugetConstants,
-    NugetPackager,
-    Path,
-    ProjectTool,
-    ProjectTypes,
-    TemporaryStorageService,
-    ToolErrorCodes,
-    ToolResult,
-    writeOrBackfillOperateProjectId,
-} 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);
-
-            this.logger.progress("Creating operate.json file...");
-            await this.createOperateFile(options, localBuildFolder);
-
-            this.logger.progress("Creating package-descriptor.json file...");
-            await this.createPackageDescriptor(localBuildFolder);
-
-            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
-        }
-    }
-
-    private async createOperateFile(
-        options: IProjectBuildOptions,
-        localBuildFolder: string,
-    ): Promise<void> {
-        const contentFolder = Path.join(
-            localBuildFolder,
-            NugetConstants.ContentFolderName,
-        );
-        const operateJsonFilePath = Path.join(
-            contentFolder,
-            NugetConstants.OperateFileName,
-        );
-
-        const projectId =
-            options.projectStorageId ??
-            (await this.resolveConnectorProjectId(options.projectPath));
-
-        await writeOrBackfillOperateProjectId(
-            operateJsonFilePath,
-            projectId,
-            this.fileSystem,
-            // Connector packages bundle content/app/ as the unit; no single
-            // entry file, so main is intentionally empty.
-            () =>
-                this.fileSystem.writeFile(
-                    operateJsonFilePath,
-                    JSON.stringify(
-                        {
-                            $schema:
-                                "https://cloud.uipath.com/draft/2024-12/operate",
-                            contentType: ProjectTypes.Connector,
-                            projectId,
-                            main: "",
-                            targetFramework: "Portable",
-                            runtimeOptions: {
-                                isAttended: false,
-                                requiresUserInteraction: false,
-                            },
-                        },
-                        null,
-                        2,
-                    ),
-                ),
-        );
-    }
-
-    /**
-     * Anchor the connector's projectId in a source-side project.json so
-     * repeated direct packs (no projectStorageId from a solution) reuse
-     * the same id. ensureProjectId only persists into files that already
-     * exist; connector projects typically have neither operate.json nor
-     * project.json, so we scaffold project.json on first pack. The file
-     * stays out of the nupkg because the build copies only the `app/`
-     * subfolder.
-     */
-    private async resolveConnectorProjectId(
-        projectPath: string,
-    ): Promise<string> {
-        const operatePath = Path.join(projectPath, "operate.json");
-        const projectFilePath = Path.join(projectPath, "project.json");
-        const hasAnchor =
-            (await this.fileSystem.exists(operatePath)) ||
-            (await this.fileSystem.exists(projectFilePath));
-        if (hasAnchor) {
-            return ensureProjectId(projectPath, this.fileSystem);
-        }
-
-        const id = crypto.randomUUID();
-        await this.fileSystem.writeFile(
-            projectFilePath,
-            `${JSON.stringify({ projectId: id }, null, 2)}\n`,
-        );
-        return id;
-    }
-
-    private async createPackageDescriptor(
-        localBuildFolder: string,
-    ): Promise<void> {
-        const packageDescriptorPath = Path.join(
-            localBuildFolder,
-            NugetConstants.ContentFolderName,
-            NugetConstants.PackageDescriptorFileName,
-        );
-
-        const exists = await this.fileSystem.exists(packageDescriptorPath);
-        if (exists) {
-            return;
-        }
-
-        const descriptor = {
-            $schema:
-                "https://cloud.uipath.com/draft/2024-12/package-descriptor",
-            files: {
-                [NugetConstants.OperateFileName]: Path.join(
-                    NugetConstants.ContentFolderName,
-                    NugetConstants.OperateFileName,
-                ),
-            },
-        };
-
-        await this.fileSystem.writeFile(
-            packageDescriptorPath,
-            JSON.stringify(descriptor, null, 2),
-        );
-    }
-
-    /**
-     * 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

@@ -1,3 +0,0 @@
-// Connector tool factory. Consumers register it explicitly via
-// `toolsFactoryRepository.registerProjectToolFactory(new ConnectorToolFactory())`.
-export { ConnectorToolFactory } from "./connector-tool-factory.js";