@uipath/packager-tool-functions 0.0.8 → 0.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@uipath/packager-tool-functions",
-    "version": "0.0.8",
+    "version": "0.1.0",
     "description": "UiPath Functions tool implementation",
     "type": "module",
     "exports": {
@@ -42,11 +42,12 @@
         "@uipath/solutionpackager-tool-core": "0.0.33"
     },
     "devDependencies": {
-        "@types/node": "^25.5.0",
+        "@uipath/coded-functions-js-packager": "^0.1.0",
+        "@types/node": "^25.5.2",
         "@uipath/solutionpackager-tool-core": "0.0.33",
-        "@vitest/coverage-v8": "^4.0.14",
-        "typescript": "^5.9.3",
-        "vitest": "^4.0.14"
+        "@vitest/coverage-v8": "^4.1.3",
+        "typescript": "^6.0.2",
+        "vitest": "^4.1.3"
     },
-    "gitHead": "3f1b4d8e9f910be81e4cab956537f21dbd5d63ac"
+    "gitHead": "d982977e86057fd9d0846c955595c64865aeecab"
 }

package/src/functions-tool-factory.ts

@@ -9,7 +9,7 @@ import {
 import { FunctionsTool } from "./functions-tool.js";
 
 /**
- * Factory for creating JS Functions project tools.
+ * Factory for creating Functions project tools.
  * Handles projects with projectType "Function".
  */
 export class FunctionsToolFactory implements IProjectToolFactory {

package/src/functions-tool.ts

@@ -1,10 +1,8 @@
 import type {
-    EntryPointsFileModel,
     IProjectBuildOptions,
     IProjectPackOptions,
     IProjectRestoreOptions,
     IProjectValidateOptions,
-    PackageDescriptorFileModel,
 } from "@uipath/solutionpackager-tool-core";
 import {
     type IFileSystem,
@@ -17,22 +15,14 @@ import {
     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";
+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;
@@ -62,25 +52,28 @@ export class FunctionsTool extends ProjectTool {
         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 contentFolder = Path.join(
-            localBuildFolder,
-            NugetConstants.ContentFolderName,
-        );
 
-        try {
-            this.logger.progress("Copying project files...");
-            await this.copyFiles(options.projectPath, contentFolder);
+        const build: BuildPackageFn =
+            language === Languages.Python
+                ? buildPyFunctionsPackage
+                : buildJsFunctionsPackage;
+        const languageLabel = LanguageLabels[language];
 
-            this.logger.progress("Creating operate.json...");
-            await this.createOperateFile(options, contentFolder);
-
-            this.logger.progress("Creating package-descriptor.json...");
-            await this.createPackageDescriptor(localBuildFolder);
+        try {
+            this.logger.progress(
+                `Building ${languageLabel} Functions package...`,
+            );
+            await build(this.fileSystem, {
+                projectPath: options.projectPath,
+                outputPath: localBuildFolder,
+                projectStorageId: options.projectStorageId ?? "",
+            });
 
             return new ToolResult(
                 ToolErrorCodes.Success,
@@ -93,7 +86,7 @@ export class FunctionsTool extends ProjectTool {
             this.logger.error(errorMessage);
             return ToolResult.error(
                 ToolErrorCodes.InternalError,
-                "Build failed for Functions project.",
+                `Build failed for ${languageLabel} Functions project.`,
             );
         }
     }
@@ -148,186 +141,36 @@ export class FunctionsTool extends ProjectTool {
         }
     }
 
-    private async detectRuntime(projectPath: string): Promise<string> {
-        const uipathJsonPath = Path.join(projectPath, "uipath.json");
-        const content = await this.fileSystem.readFile(uipathJsonPath);
-        if (content) {
+    // 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)
+    private 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(
-                    new TextDecoder().decode(content as Uint8Array),
-                );
-                const functions = uipathJson?.functions as
-                    | Record<string, string>
-                    | undefined;
-                const firstEntry = functions
-                    ? Object.values(functions)[0]
-                    : undefined;
+                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 filePath = firstEntry.split(":")[0] ?? "";
                     const ext = filePath.slice(filePath.lastIndexOf("."));
-                    const runtime = EXTENSION_TO_RUNTIME[ext];
-                    if (runtime) {
-                        return runtime;
-                    }
+                    if (ext === ".ts" || ext === ".js" || ext === ".mjs")
+                        return Languages.JavaScript;
+                    if (ext === ".py") return Languages.Python;
                 }
             } 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
-                }
+                // fall through to fallback
             }
         }
-
-        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,
+        const pyprojectStat = await this.fileSystem.stat(
+            Path.join(projectPath, "pyproject.toml"),
         );
-        packageDescriptor.files[key] = relativePath;
+        if (pyprojectStat?.isFile()) return Languages.Python;
+        return Languages.JavaScript;
     }
 }

package/src/index.ts

@@ -1,5 +1,5 @@
 // ============================================================================
-// Self-register JS Functions tool factory with the singleton repository
+// Self-register Functions tool factory with the singleton repository
 // ============================================================================
 
 import { toolsFactoryRepository } from "@uipath/solutionpackager-tool-core";

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

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

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

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

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

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

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