@uipath/packager-tool-functions 1.202.0-preview.141 → 1.202.0-preview.143

package/LICENSE.txt

@@ -0,0 +1,3 @@
+© 2026 UiPath
+Use of this product is subject (a) to the applicable licensing agreement available: https://www.uipath.com/legal/trust-and-security/legal-terms#content-1 and, (b) for paid products listed here https://licensing.uipath.com/: the licensing agreement agreed between you and UiPath.
+(UiPath means UiPath SRL with headquarters at 4 Vasile Alecsandri Str. and 11 Constantin Daniel Str., Building A, floors 5 and 6, District 1, Bucharest 010639, Romania and UiPath Inc. with principal place of business: One Vanderbilt Avenue, 60th Floor, New York, NY 10017)

package/dist/THIRD-PARTY-NOTICES.md

@@ -0,0 +1,8 @@
+# Third-party notices for @uipath/packager-tool-functions
+
+This package is distributed as a bundle: the dependencies below are
+compiled into its `dist/` output rather than installed alongside it.
+Their licences and copyright notices are reproduced here in full, as
+those licences require.
+
+No third-party code is bundled into this package.

package/package.json

@@ -1,13 +1,10 @@
 {
     "name": "@uipath/packager-tool-functions",
-    "version": "1.202.0-preview.141",
+    "version": "1.202.0-preview.143",
     "description": "UiPath Functions 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",
+    "license": "SEE LICENSE IN LICENSE.txt",
     "peerDependencies": {
         "@uipath/solutionpackager-tool-core": "1.202.0"
     },
-    "gitHead": "2c2b4b3b218f18c26db78eb8cd9ab8002d2b5290"
+    "gitHead": "23b5a7038ead7264439af18f8b807c7cc99a29d5"
 }

package/src/functions-tool-factory.ts

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

@@ -1,180 +0,0 @@
-import type {
-    IProjectBuildOptions,
-    IProjectPackOptions,
-    IProjectRestoreOptions,
-    IProjectValidateOptions,
-} from "@uipath/solutionpackager-tool-core";
-import {
-    ensureProjectId,
-    type IFileSystem,
-    type IToolLogger,
-    NugetConstants,
-    NugetPackager,
-    Path,
-    ProjectTool,
-    TemporaryStorageService,
-    ToolErrorCodes,
-    ToolResult,
-} from "@uipath/solutionpackager-tool-core";
-import { buildJsFunctionsPackage } from "./js/index.js";
-import { buildPyFunctionsPackage } from "./py/index.js";
-import {
-    type BuildPackageFn,
-    type Language,
-    LanguageLabels,
-    Languages,
-} from "./types.js";
-
-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 language = await this.detectLanguage(options.projectPath);
-        const tempFolder = await this._temporaryStorage.getTempFolderPath();
-        const localBuildFolder = Path.join(
-            tempFolder,
-            NugetConstants.OutputFolderName,
-        );
-
-        const build: BuildPackageFn =
-            language === Languages.Python
-                ? buildPyFunctionsPackage
-                : buildJsFunctionsPackage;
-        const languageLabel = LanguageLabels[language];
-
-        try {
-            this.logger.progress(
-                `Building ${languageLabel} Functions package...`,
-            );
-            const projectStorageId =
-                options.projectStorageId ??
-                (await ensureProjectId(options.projectPath, this.fileSystem));
-            await build(this.fileSystem, {
-                projectPath: options.projectPath,
-                outputPath: localBuildFolder,
-                projectStorageId,
-            });
-
-            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 ${languageLabel} 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
-        }
-    }
-
-    // Detects project language from uipath.json functions map extensions.
-    // Mirrors detectProjectKind() in @uipath/tool-agent (Agents repo):
-    //   primary:  uipath.json functions map extension (.ts/.js → javascript, .py → python)
-    //   fallback: pyproject.toml presence → python (same signal Agents uses)
-    protected async detectLanguage(projectPath: string): Promise<Language> {
-        const uipathJsonContent = await this.fileSystem.readFile(
-            Path.join(projectPath, "uipath.json"),
-            "utf-8",
-        );
-        if (uipathJsonContent) {
-            try {
-                const uipathJson = JSON.parse(uipathJsonContent as string) as {
-                    functions?: Record<string, string>;
-                };
-                const firstEntry = Object.values(uipathJson.functions ?? {})[0];
-                if (firstEntry) {
-                    const filePath = firstEntry.split(":")[0] ?? "";
-                    const ext = filePath.slice(filePath.lastIndexOf("."));
-                    if (ext === ".ts" || ext === ".js" || ext === ".mjs")
-                        return Languages.JavaScript;
-                    if (ext === ".py") return Languages.Python;
-                }
-            } catch {
-                // fall through to fallback
-            }
-        }
-        const pyprojectStat = await this.fileSystem.stat(
-            Path.join(projectPath, "pyproject.toml"),
-        );
-        if (pyprojectStat?.isFile()) return Languages.Python;
-        return Languages.JavaScript;
-    }
-}

package/src/index.ts

@@ -1,10 +0,0 @@
-// ============================================================================
-// Functions tool factory. Consumers register it explicitly via
-// `toolsFactoryRepository.registerProjectToolFactory(new FunctionsToolFactory())`.
-// ============================================================================
-
-// Base tool + language detection, subclassable by Node-only hosts that add
-// manifest generation before packing (function-tool's packager entry).
-export { FunctionsTool } from "./functions-tool.js";
-export { FunctionsToolFactory } from "./functions-tool-factory.js";
-export { type Language, Languages } from "./types.js";

package/src/js/build-js-functions-package.ts

@@ -1,14 +0,0 @@
-import { buildFunctionsPackage } from "@uipath/coded-functions-js-packager";
-import type { IFileSystem } from "@uipath/solutionpackager-tool-core";
-import type { BuildPackageOptions } from "../types.js";
-
-export async function buildJsFunctionsPackage(
-    fileSystem: IFileSystem,
-    options: BuildPackageOptions,
-): Promise<void> {
-    await buildFunctionsPackage(fileSystem, {
-        projectPath: options.projectPath,
-        outputPath: options.outputPath,
-        projectStorageId: options.projectStorageId,
-    });
-}

package/src/js/index.ts

@@ -1 +0,0 @@
-export { buildJsFunctionsPackage } from "./build-js-functions-package.js";

package/src/py/build-py-functions-package.ts

@@ -1,287 +0,0 @@
-import type {
-    EntryPointsFileModel,
-    IFileSystem,
-    PackageDescriptorFileModel,
-} from "@uipath/solutionpackager-tool-core";
-import { NugetConstants, Path } from "@uipath/solutionpackager-tool-core";
-import type { BuildPackageOptions } from "../types.js";
-import {
-    BINDINGS_SOURCE_FILE_NAME,
-    BINDINGS_VERSION,
-    CONTENT_TYPE,
-    ENTRY_POINT_TYPE,
-    EXCLUDED_DIRECTORIES,
-    EXCLUDED_NAMES,
-    SCHEMAS,
-    TARGET_RUNTIME,
-    UIPATH_JSON_FILE_NAME,
-} from "./constants.js";
-
-export async function buildPyFunctionsPackage(
-    fileSystem: IFileSystem,
-    options: BuildPackageOptions,
-): Promise<void> {
-    const contentFolder = Path.join(
-        options.outputPath,
-        NugetConstants.ContentFolderName,
-    );
-
-    await validateProjectFiles(fileSystem, options.projectPath);
-    await copyFiles(fileSystem, options.projectPath, contentFolder);
-    await writeEntryPointsFile(fileSystem, options.projectPath, contentFolder);
-    await createOperateFile(
-        fileSystem,
-        contentFolder,
-        options.projectStorageId,
-    );
-    await createBindingsFile(fileSystem, options.projectPath, contentFolder);
-    await createPackageDescriptor(fileSystem, options.outputPath);
-}
-
-async function validateProjectFiles(
-    fileSystem: IFileSystem,
-    projectPath: string,
-): Promise<void> {
-    const uipathJsonPath = Path.join(projectPath, UIPATH_JSON_FILE_NAME);
-    const entryPointsPath = Path.join(
-        projectPath,
-        NugetConstants.EntryPointsFileName,
-    );
-
-    if (!(await fileSystem.exists(uipathJsonPath))) {
-        throw new Error("uipath.json is missing from the project.");
-    }
-
-    if (!(await fileSystem.exists(entryPointsPath))) {
-        throw new Error("entry-points.json is missing from the project.");
-    }
-}
-
-async function copyFiles(
-    fileSystem: IFileSystem,
-    sourcePath: string,
-    destinationPath: string,
-): Promise<void> {
-    await fileSystem.mkdir(destinationPath);
-
-    const entries = await fileSystem.readdir(sourcePath);
-
-    for (const entry of entries) {
-        const sourceFile = Path.join(sourcePath, entry);
-        const destinationFile = Path.join(destinationPath, entry);
-
-        const stat = await fileSystem.stat(sourceFile);
-        if (stat?.isFile()) {
-            if (EXCLUDED_NAMES.has(entry)) {
-                continue;
-            }
-            const content = await fileSystem.readFile(sourceFile);
-            if (content) {
-                await fileSystem.writeFile(destinationFile, content);
-            }
-        } else if (stat?.isDirectory()) {
-            if (EXCLUDED_DIRECTORIES.has(entry)) {
-                continue;
-            }
-            await copyFiles(fileSystem, sourceFile, destinationFile);
-        }
-    }
-}
-
-async function createOperateFile(
-    fileSystem: IFileSystem,
-    contentFolder: string,
-    projectStorageId: string,
-): Promise<void> {
-    const operateJsonFilePath = Path.join(
-        contentFolder,
-        NugetConstants.OperateFileName,
-    );
-
-    const exists = await fileSystem.exists(operateJsonFilePath);
-    if (exists) {
-        return;
-    }
-
-    const entryPointsFilePath = Path.join(
-        contentFolder,
-        NugetConstants.EntryPointsFileName,
-    );
-    let mainPath = "";
-
-    const entryPointsExists = await fileSystem.exists(entryPointsFilePath);
-    if (entryPointsExists) {
-        const entryPointsContent =
-            await 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 parse errors, use empty mainPath
-            }
-        }
-    }
-
-    const operateFileModel = {
-        $schema: SCHEMAS.Operate,
-        contentType: CONTENT_TYPE,
-        projectId: projectStorageId,
-        main: mainPath,
-        targetFramework: "Portable",
-        targetRuntime: TARGET_RUNTIME,
-        runtimeOptions: {
-            isAttended: false,
-            requiresUserInteraction: false,
-            isConversational: false,
-        },
-    };
-
-    const operateJsonString = JSON.stringify(operateFileModel, null, 2);
-    await fileSystem.writeFile(operateJsonFilePath, operateJsonString);
-}
-
-async function writeEntryPointsFile(
-    fileSystem: IFileSystem,
-    projectPath: string,
-    contentFolder: string,
-): Promise<void> {
-    const sourcePath = Path.join(
-        projectPath,
-        NugetConstants.EntryPointsFileName,
-    );
-    const destinationPath = Path.join(
-        contentFolder,
-        NugetConstants.EntryPointsFileName,
-    );
-
-    const raw = await fileSystem.readFile(sourcePath);
-    if (!raw) {
-        throw new Error("entry-points.json is missing from the project.");
-    }
-
-    let parsed: Record<string, unknown>;
-    try {
-        parsed = JSON.parse(new TextDecoder().decode(raw));
-    } catch {
-        throw new Error("entry-points.json is not valid JSON.");
-    }
-
-    const sourceEntries = Array.isArray(parsed.entryPoints)
-        ? (parsed.entryPoints as Record<string, unknown>[])
-        : [];
-
-    const normalizedEntries = sourceEntries.map((entry) => ({
-        ...entry,
-        uniqueId:
-            typeof entry.uniqueId === "string" && entry.uniqueId.length > 0
-                ? entry.uniqueId
-                : crypto.randomUUID(),
-        type:
-            typeof entry.type === "string" && entry.type.length > 0
-                ? entry.type
-                : ENTRY_POINT_TYPE,
-    }));
-
-    const normalized = {
-        $schema: SCHEMAS.EntryPoint,
-        $id: NugetConstants.EntryPointsFileName,
-        entryPoints: normalizedEntries,
-    };
-
-    await fileSystem.writeFile(
-        destinationPath,
-        JSON.stringify(normalized, null, 2),
-    );
-}
-
-async function createBindingsFile(
-    fileSystem: IFileSystem,
-    projectPath: string,
-    contentFolder: string,
-): Promise<void> {
-    const bindingsOutputPath = Path.join(
-        contentFolder,
-        NugetConstants.BindingsV2FileName,
-    );
-
-    const sourcePath = Path.join(projectPath, BINDINGS_SOURCE_FILE_NAME);
-    let bindings: unknown = null;
-
-    if (await fileSystem.exists(sourcePath)) {
-        const raw = await fileSystem.readFile(sourcePath);
-        if (raw) {
-            try {
-                bindings = JSON.parse(new TextDecoder().decode(raw));
-            } catch {
-                bindings = null;
-            }
-        }
-    }
-
-    if (bindings === null) {
-        bindings = {
-            $schema: SCHEMAS.Bindings,
-            version: BINDINGS_VERSION,
-            resources: [],
-        };
-    }
-
-    await fileSystem.writeFile(
-        bindingsOutputPath,
-        JSON.stringify(bindings, null, 2),
-    );
-}
-
-async function createPackageDescriptor(
-    fileSystem: IFileSystem,
-    localBuildFolder: string,
-): Promise<void> {
-    const packageDescriptor: PackageDescriptorFileModel = {
-        files: {},
-    };
-
-    addFileToDescriptor(
-        packageDescriptor,
-        NugetConstants.OperateFileName,
-        NugetConstants.OperateFileName,
-    );
-    addFileToDescriptor(
-        packageDescriptor,
-        NugetConstants.EntryPointsFileName,
-        NugetConstants.EntryPointsFileName,
-    );
-    addFileToDescriptor(
-        packageDescriptor,
-        NugetConstants.BindingsFileId,
-        NugetConstants.BindingsV2FileName,
-    );
-
-    const packageDescriptorPath = Path.join(
-        localBuildFolder,
-        NugetConstants.ContentFolderName,
-        NugetConstants.PackageDescriptorFileName,
-    );
-    const packageDescriptorJson = JSON.stringify(
-        {
-            $schema: SCHEMAS.PackageDescriptor,
-            ...packageDescriptor,
-        },
-        null,
-        2,
-    );
-    await fileSystem.writeFile(packageDescriptorPath, packageDescriptorJson);
-}
-
-function addFileToDescriptor(
-    packageDescriptor: PackageDescriptorFileModel,
-    key: string,
-    fileName: string,
-): void {
-    const relativePath = Path.join(NugetConstants.ContentFolderName, fileName);
-    packageDescriptor.files[key] = relativePath;
-}

package/src/py/constants.ts

@@ -1,40 +0,0 @@
-export const EXCLUDED_NAMES = new Set([
-    "agent.json",
-    "project.uiproj",
-    "bindings.json",
-    "entry-points.json",
-    ".DS_Store",
-    "Thumbs.db",
-]);
-
-export const EXCLUDED_DIRECTORIES = new Set([
-    "evaluations",
-    "evals",
-    ".function-builder",
-    "node_modules",
-    "__pycache__",
-    ".pytest_cache",
-    ".venv",
-    "venv",
-    "env",
-    ".git",
-    ".vscode",
-    ".idea",
-    ".local",
-]);
-
-export const CONTENT_TYPE = "function";
-export const TARGET_RUNTIME = "python";
-export const UIPATH_JSON_FILE_NAME = "uipath.json";
-export const BINDINGS_SOURCE_FILE_NAME = "bindings.json";
-export const BINDINGS_VERSION = "2.0";
-export const ENTRY_POINT_TYPE = "function";
-
-const SCHEMA_BASE_URL = "https://cloud.uipath.com/draft/2024-12";
-
-export const SCHEMAS = {
-    Bindings: `${SCHEMA_BASE_URL}/bindings`,
-    EntryPoint: `${SCHEMA_BASE_URL}/entry-point`,
-    Operate: `${SCHEMA_BASE_URL}/operate`,
-    PackageDescriptor: `${SCHEMA_BASE_URL}/package-descriptor`,
-} as const;

package/src/py/index.ts

@@ -1 +0,0 @@
-export { buildPyFunctionsPackage } from "./build-py-functions-package.js";

package/src/types.ts

@@ -1,24 +0,0 @@
-import type { IFileSystem } from "@uipath/solutionpackager-tool-core";
-
-export const Languages = {
-    JavaScript: "javascript",
-    Python: "python",
-} as const;
-
-export type Language = (typeof Languages)[keyof typeof Languages];
-
-export const LanguageLabels: Record<Language, string> = {
-    [Languages.JavaScript]: "JS/TS",
-    [Languages.Python]: "Python",
-};
-
-export interface BuildPackageOptions {
-    projectPath: string;
-    outputPath: string;
-    projectStorageId: string;
-}
-
-export type BuildPackageFn = (
-    fileSystem: IFileSystem,
-    options: BuildPackageOptions,
-) => Promise<void>;