@uipath/packager-tool-functions 0.0.7

package/dist/functions-tool-factory.d.ts

@@ -0,0 +1,9 @@
+import { type IFileSystem, type IProjectToolFactory, type IToolLogger, type ProjectTool, type ProjectType } from "@uipath/solutionpackager-tool-core";
+/**
+ * Factory for creating JS Functions project tools.
+ * Handles projects with projectType "Function".
+ */
+export declare class FunctionsToolFactory implements IProjectToolFactory {
+    readonly supportedTypes: readonly ProjectType[];
+    createAsync(logger: IToolLogger, fileSystem: IFileSystem): Promise<ProjectTool>;
+}

package/dist/functions-tool.d.ts

@@ -0,0 +1,18 @@
+import type { IProjectBuildOptions, IProjectPackOptions, IProjectRestoreOptions, IProjectValidateOptions } from "@uipath/solutionpackager-tool-core";
+import { type IFileSystem, type IToolLogger, ProjectTool, ToolResult } from "@uipath/solutionpackager-tool-core";
+export declare class FunctionsTool 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>;
+    private detectRuntime;
+    private copyFiles;
+    private isExcluded;
+    private createOperateFile;
+    private createOperateJsonFile;
+    private createPackageDescriptor;
+    private addFileToDescriptor;
+}

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,193 @@
+// src/index.ts
+import { toolsFactoryRepository } from "@uipath/solutionpackager-tool-core";
+
+// src/functions-tool-factory.ts
+import {
+  ProjectTypes
+} from "@uipath/solutionpackager-tool-core";
+
+// src/functions-tool.ts
+import {
+  NugetConstants,
+  NugetPackager,
+  Path,
+  ProjectTool,
+  TemporaryStorageService,
+  ToolErrorCodes,
+  ToolResult
+} from "@uipath/solutionpackager-tool-core";
+var EXCLUDED_NAMES = new Set([".deno", ".env"]);
+var EXCLUDED_EXTENSIONS = [".nupkg"];
+var EXTENSION_TO_RUNTIME = {
+  ".ts": "javascript",
+  ".js": "javascript",
+  ".py": "python"
+};
+var DEFAULT_RUNTIME = "javascript";
+
+class FunctionsTool extends ProjectTool {
+  _temporaryStorage;
+  constructor(fileSystem, logger) {
+    super(fileSystem, logger);
+    this._temporaryStorage = new TemporaryStorageService(fileSystem);
+  }
+  async restoreAsync(_options, _cancellationToken) {
+    this.logger.info("Restore not required for Functions projects.");
+    return ToolResult.success();
+  }
+  async validateAsync(_options, _cancellationToken) {
+    this.logger.info("Validate not required for Functions projects.");
+    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("Copying project files...");
+      await this.copyFiles(options.projectPath, contentFolder);
+      this.logger.progress("Creating operate.json...");
+      await this.createOperateFile(options, contentFolder);
+      this.logger.progress("Creating package-descriptor.json...");
+      await this.createPackageDescriptor(localBuildFolder);
+      return new ToolResult(ToolErrorCodes.Success, "Build completed successfully.", [localBuildFolder]);
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.toString() : String(error);
+      this.logger.error(errorMessage);
+      return ToolResult.error(ToolErrorCodes.InternalError, "Build failed for Functions 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, "Pack completed successfully.", [result.outputPath]);
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.toString() : String(error);
+      this.logger.error(errorMessage);
+      return ToolResult.error(ToolErrorCodes.InternalError, "Pack failed for Functions project.");
+    }
+  }
+  async dispose() {
+    this.logger.info("Disposing Functions Tool");
+    try {
+      await this._temporaryStorage.cleanup();
+    } catch {}
+  }
+  async detectRuntime(projectPath) {
+    const uipathJsonPath = Path.join(projectPath, "uipath.json");
+    const content = await this.fileSystem.readFile(uipathJsonPath);
+    if (content) {
+      try {
+        const uipathJson = JSON.parse(new TextDecoder().decode(content));
+        const functions = uipathJson?.functions;
+        const firstEntry = functions ? Object.values(functions)[0] : undefined;
+        if (firstEntry) {
+          const filePath = firstEntry.split(":")[0];
+          const ext = filePath.slice(filePath.lastIndexOf("."));
+          const runtime = EXTENSION_TO_RUNTIME[ext];
+          if (runtime) {
+            return runtime;
+          }
+        }
+      } catch {}
+    }
+    return DEFAULT_RUNTIME;
+  }
+  async copyFiles(sourcePath, destinationPath) {
+    await this.fileSystem.mkdir(destinationPath);
+    const entries = await this.fileSystem.readdir(sourcePath);
+    for (const entry of entries) {
+      if (this.isExcluded(entry)) {
+        continue;
+      }
+      const sourceFile = Path.join(sourcePath, entry);
+      const destinationFile = Path.join(destinationPath, entry);
+      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);
+        }
+      } else if (stat?.isDirectory()) {
+        await this.copyFiles(sourceFile, destinationFile);
+      }
+    }
+  }
+  isExcluded(name) {
+    if (EXCLUDED_NAMES.has(name)) {
+      return true;
+    }
+    return EXCLUDED_EXTENSIONS.some((ext) => name.endsWith(ext));
+  }
+  async createOperateFile(options, contentFolder) {
+    const operateJsonFilePath = Path.join(contentFolder, NugetConstants.OperateFileName);
+    const exists = await this.fileSystem.exists(operateJsonFilePath);
+    if (!exists) {
+      const targetRuntime = await this.detectRuntime(options.projectPath);
+      await this.createOperateJsonFile(contentFolder, options.projectStorageId ?? "", operateJsonFilePath, targetRuntime);
+    }
+  }
+  async createOperateJsonFile(contentFolder, projectId, filePath, targetRuntime) {
+    const entryPointsFilePath = Path.join(contentFolder, 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: "function",
+      projectId,
+      main: mainPath,
+      targetRuntime
+    };
+    const operateJsonString = JSON.stringify(operateFileModel, null, 2);
+    await this.fileSystem.writeFile(filePath, operateJsonString);
+  }
+  async createPackageDescriptor(localBuildFolder) {
+    const packageDescriptor = {
+      files: {}
+    };
+    this.addFileToDescriptor(packageDescriptor, NugetConstants.OperateFileName, NugetConstants.OperateFileName);
+    this.addFileToDescriptor(packageDescriptor, NugetConstants.EntryPointsFileName, NugetConstants.EntryPointsFileName);
+    this.addFileToDescriptor(packageDescriptor, 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);
+  }
+  addFileToDescriptor(packageDescriptor, key, fileName) {
+    const relativePath = Path.join(NugetConstants.ContentFolderName, fileName);
+    packageDescriptor.files[key] = relativePath;
+  }
+}
+
+// src/functions-tool-factory.ts
+class FunctionsToolFactory {
+  supportedTypes = [ProjectTypes.Function];
+  async createAsync(logger, fileSystem) {
+    return new FunctionsTool(fileSystem, logger);
+  }
+}
+
+// src/index.ts
+toolsFactoryRepository.registerProjectToolFactory(new FunctionsToolFactory);

package/package.json

@@ -0,0 +1,51 @@
+{
+    "name": "@uipath/packager-tool-functions",
+    "version": "0.0.7",
+    "description": "UiPath Functions 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-functions"
+    },
+    "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:coverage": "vitest run --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/coverage-v8": "^4.0.14",
+        "typescript": "^5.9.3",
+        "vitest": "^4.0.14"
+    }
+}

package/src/functions-tool-factory.ts

@@ -0,0 +1,24 @@
+import {
+    type IFileSystem,
+    type IProjectToolFactory,
+    type IToolLogger,
+    type ProjectTool,
+    type ProjectType,
+    ProjectTypes,
+} from "@uipath/solutionpackager-tool-core";
+import { FunctionsTool } from "./functions-tool.js";
+
+/**
+ * Factory for creating JS Functions project tools.
+ * Handles projects with projectType "Function".
+ */
+export class FunctionsToolFactory implements IProjectToolFactory {
+    readonly supportedTypes: readonly ProjectType[] = [ProjectTypes.Function];
+
+    async createAsync(
+        logger: IToolLogger,
+        fileSystem: IFileSystem,
+    ): Promise<ProjectTool> {
+        return new FunctionsTool(fileSystem, logger);
+    }
+}

package/src/functions-tool.ts

@@ -0,0 +1,333 @@
+import type {
+    EntryPointsFileModel,
+    IProjectBuildOptions,
+    IProjectPackOptions,
+    IProjectRestoreOptions,
+    IProjectValidateOptions,
+    PackageDescriptorFileModel,
+} from "@uipath/solutionpackager-tool-core";
+import {
+    type IFileSystem,
+    type IToolLogger,
+    NugetConstants,
+    NugetPackager,
+    Path,
+    ProjectTool,
+    TemporaryStorageService,
+    ToolErrorCodes,
+    ToolResult,
+} from "@uipath/solutionpackager-tool-core";
+
+/** File and directory names excluded from packaging. */
+const EXCLUDED_NAMES = new Set([".deno", ".env"]);
+
+/** File extensions excluded from packaging. */
+const EXCLUDED_EXTENSIONS = [".nupkg"];
+
+/** Maps a function entry-point file extension to a target runtime. */
+const EXTENSION_TO_RUNTIME: Record<string, string> = {
+    ".ts": "javascript",
+    ".js": "javascript",
+    ".py": "python",
+};
+
+/** Fallback runtime when uipath.json cannot be read or has no functions. */
+const DEFAULT_RUNTIME = "javascript";
+
+export class FunctionsTool 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 not required for Functions projects.");
+        return ToolResult.success();
+    }
+
+    override async validateAsync(
+        _options: IProjectValidateOptions,
+        _cancellationToken?: AbortSignal,
+    ): Promise<ToolResult> {
+        this.logger.info("Validate not required for Functions 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 project files...");
+            await this.copyFiles(options.projectPath, contentFolder);
+
+            this.logger.progress("Creating operate.json...");
+            await this.createOperateFile(options, contentFolder);
+
+            this.logger.progress("Creating package-descriptor.json...");
+            await this.createPackageDescriptor(localBuildFolder);
+
+            return new ToolResult(
+                ToolErrorCodes.Success,
+                "Build completed successfully.",
+                [localBuildFolder],
+            );
+        } catch (error) {
+            const errorMessage =
+                error instanceof Error ? error.toString() : String(error);
+            this.logger.error(errorMessage);
+            return ToolResult.error(
+                ToolErrorCodes.InternalError,
+                "Build failed for Functions project.",
+            );
+        }
+    }
+
+    override async packAsync(
+        options: IProjectPackOptions,
+        cancellationToken?: AbortSignal,
+    ): Promise<ToolResult> {
+        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,
+                "Pack completed successfully.",
+                [result.outputPath],
+            );
+        } catch (error) {
+            const errorMessage =
+                error instanceof Error ? error.toString() : String(error);
+            this.logger.error(errorMessage);
+            return ToolResult.error(
+                ToolErrorCodes.InternalError,
+                "Pack failed for Functions project.",
+            );
+        }
+    }
+
+    override async dispose(): Promise<void> {
+        this.logger.info("Disposing Functions Tool");
+        try {
+            await this._temporaryStorage.cleanup();
+        } catch {
+            // Ignore errors during cleanup
+        }
+    }
+
+    private async detectRuntime(projectPath: string): Promise<string> {
+        const uipathJsonPath = Path.join(projectPath, "uipath.json");
+        const content = await this.fileSystem.readFile(uipathJsonPath);
+        if (content) {
+            try {
+                const uipathJson = JSON.parse(
+                    new TextDecoder().decode(content as Uint8Array),
+                );
+                const functions = uipathJson?.functions as
+                    | Record<string, string>
+                    | undefined;
+                const firstEntry = functions
+                    ? Object.values(functions)[0]
+                    : undefined;
+                if (firstEntry) {
+                    const filePath = firstEntry.split(":")[0];
+                    const ext = filePath.slice(filePath.lastIndexOf("."));
+                    const runtime = EXTENSION_TO_RUNTIME[ext];
+                    if (runtime) {
+                        return runtime;
+                    }
+                }
+            } catch {
+                // Ignore parse errors, fall through to default
+            }
+        }
+        return DEFAULT_RUNTIME;
+    }
+
+    private async copyFiles(
+        sourcePath: string,
+        destinationPath: string,
+    ): Promise<void> {
+        await this.fileSystem.mkdir(destinationPath);
+
+        const entries = await this.fileSystem.readdir(sourcePath);
+
+        for (const entry of entries) {
+            if (this.isExcluded(entry)) {
+                continue;
+            }
+
+            const sourceFile = Path.join(sourcePath, entry);
+            const destinationFile = Path.join(destinationPath, entry);
+
+            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);
+                }
+            } else if (stat?.isDirectory()) {
+                await this.copyFiles(sourceFile, destinationFile);
+            }
+        }
+    }
+
+    private isExcluded(name: string): boolean {
+        if (EXCLUDED_NAMES.has(name)) {
+            return true;
+        }
+        return EXCLUDED_EXTENSIONS.some((ext) => name.endsWith(ext));
+    }
+
+    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) {
+            const targetRuntime = await this.detectRuntime(options.projectPath);
+            await this.createOperateJsonFile(
+                contentFolder,
+                options.projectStorageId ?? "",
+                operateJsonFilePath,
+                targetRuntime,
+            );
+        }
+    }
+
+    private async createOperateJsonFile(
+        contentFolder: string,
+        projectId: string,
+        filePath: string,
+        targetRuntime: string,
+    ): Promise<void> {
+        const entryPointsFilePath = Path.join(
+            contentFolder,
+            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: 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: "function",
+            projectId: projectId,
+            main: mainPath,
+            targetRuntime,
+        };
+
+        const operateJsonString = JSON.stringify(operateFileModel, null, 2);
+        await this.fileSystem.writeFile(filePath, operateJsonString);
+    }
+
+    private async createPackageDescriptor(
+        localBuildFolder: string,
+    ): Promise<void> {
+        const packageDescriptor: PackageDescriptorFileModel = {
+            files: {},
+        };
+
+        this.addFileToDescriptor(
+            packageDescriptor,
+            NugetConstants.OperateFileName,
+            NugetConstants.OperateFileName,
+        );
+        this.addFileToDescriptor(
+            packageDescriptor,
+            NugetConstants.EntryPointsFileName,
+            NugetConstants.EntryPointsFileName,
+        );
+        this.addFileToDescriptor(
+            packageDescriptor,
+            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,
+        );
+    }
+
+    private addFileToDescriptor(
+        packageDescriptor: PackageDescriptorFileModel,
+        key: string,
+        fileName: string,
+    ): void {
+        const relativePath = Path.join(
+            NugetConstants.ContentFolderName,
+            fileName,
+        );
+        packageDescriptor.files[key] = relativePath;
+    }
+}

package/src/index.ts

@@ -0,0 +1,8 @@
+// ============================================================================
+// Self-register JS Functions tool factory with the singleton repository
+// ============================================================================
+
+import { toolsFactoryRepository } from "@uipath/solutionpackager-tool-core";
+import { FunctionsToolFactory } from "./functions-tool-factory.js";
+
+toolsFactoryRepository.registerProjectToolFactory(new FunctionsToolFactory());