@uipath/packager-tool-functions 0.0.8 → 0.1.0

package/README.md

@@ -0,0 +1,88 @@
+# @uipath/packager-tool-functions
+
+UiPath solution packager plugin for `ProjectType.Function`. Used by Studio Web to build and pack JS/TS and Python Functions projects.
+
+## Architecture
+
+```
+Studio Web publish (JS/TS)
+  → FunctionsTool.buildAsync()        ← this package
+    → buildJsFunctionsPackage()       ← src/js (thin wrapper)
+      → buildFunctionsPackage()       ← @uipath/coded-functions-js-packager
+
+Studio Web publish (Python)
+  → FunctionsTool.buildAsync()        ← this package
+    → buildPyFunctionsPackage()       ← src/py (local implementation)
+
+CLI: uip functions pack (JS/TS)
+  → uipath-functions pack             ← @uipath/uipath-functions CLI
+    → buildFunctionsPackage()         ← same shared library
+
+CLI: uip functions pack (Python)
+  → uipath pack                       ← Python CLI subprocess
+```
+
+## How it works
+
+`FunctionsTool` implements `ProjectTool` for `ProjectType.Function`. On `buildAsync`:
+
+1. Detects language from `uipath.json` functions map (`.ts`/`.js`/`.mjs` → javascript, `.py` → python); fallback: `pyproject.toml` presence → python.
+2. **JS/TS**: delegates to `buildFunctionsPackage(fs, options)` from `@uipath/coded-functions-js-packager` (externally-published library, shared with the `uipath-functions` CLI).
+3. **Python**: delegates to the local `buildPyFunctionsPackage(fs, options)` implementation in [`src/py/`](src/py/).
+
+### Language detection
+
+| Signal | Result |
+|---|---|
+| `uipath.json` functions map extension `.ts`/`.js`/`.mjs` | javascript |
+| `uipath.json` functions map extension `.py` | python |
+| `pyproject.toml` present | python (fallback) |
+| Neither | javascript (default) |
+
+## Python build pipeline
+
+`buildPyFunctionsPackage` produces a fully-formed nupkg content folder from the Python project sources. Pipeline:
+
+1. **Validate inputs** — requires `uipath.json` and `entry-points.json` at the project root. Throws a readable error if either is missing.
+2. **Copy source files** to `content/`, filtered by [`EXCLUDED_NAMES`](src/py/constants.ts) (`agent.json`, `project.uiproj`, `bindings.json`, `entry-points.json`, OS metadata) and [`EXCLUDED_DIRECTORIES`](src/py/constants.ts) (virtualenvs, caches, editor dirs, VCS dirs). `bindings.json` and `entry-points.json` are excluded because the packager re-emits canonical versions — see steps 3 and 5.
+3. **Normalize `content/entry-points.json`** — reads the source file and rewrites it with:
+   - Canonical `$schema` (`https://cloud.uipath.com/draft/2024-12/entry-point`) and `$id` (`entry-points.json`).
+   - Per-entry `uniqueId` — backfilled with `crypto.randomUUID()` when the source is missing it.
+   - Per-entry `type` — defaults to `"function"` when missing.
+   - All other fields (`filePath`, `input`, `output`, etc.) are passed through.
+4. **Write `content/operate.json`** — `$schema` = `operate`, `contentType` = `"function"`, `targetRuntime` = `"python"`, `main` = first entry-point's `filePath`, `projectId` = the platform-assigned storage id.
+5. **Write `content/bindings_v2.json`** — uses the source `bindings.json` if present and parseable; otherwise emits the default `{ $schema, version: "2.0", resources: [] }`.
+6. **Write `content/package-descriptor.json`** — registers `operate.json`, `entry-points.json`, and `bindings.json` (the latter pointing at `content/bindings_v2.json`).
+
+### Expected source-project shape
+
+The upstream tool (`uipath init` / Function Builder MFE) is responsible for producing a valid source layout before this packager runs. In particular:
+
+- `uipath.json.functions` — map of entrypoint key → `"<file>.py:<python-function>"` (the runtime uses this to resolve the function body).
+- `entry-points.json` — each entry's `filePath` must equal the functions-map key. The packager will fill in `uniqueId` and `type: "function"` if they're missing, but nothing can recover the real function-name mapping — that lives in `uipath.json.functions`.
+- The Python function must take exactly one parameter typed as a dataclass, Pydantic model, or annotated class; the UiPath runtime calls `func(input)` with a single argument and converts the input dict into that type.
+
+
+## Project structure
+
+```
+src/
+├── functions-tool.ts         # ProjectTool implementation (language detection, build/pack lifecycle)
+├── functions-tool-factory.ts # Factory for the tool loader
+├── js/                       # JS/TS build path (delegates to @uipath/coded-functions-js-packager)
+├── py/                       # Python build path
+│   ├── build-py-functions-package.ts
+│   ├── constants.ts          # All Python-packager constants (schemas, file names, exclusions)
+│   └── index.ts
+├── types.ts                  # BuildPackageOptions, Language enum, labels
+└── index.ts
+```
+
+## Development
+
+```bash
+bun install
+bun run build        # bun build → dist/ (ESM, browser target)
+bun run test         # vitest
+bun run lint         # biome check
+```

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

@@ -1,6 +1,6 @@
 import { type IFileSystem, type IProjectToolFactory, type IToolLogger, type ProjectTool, type ProjectType } from "@uipath/solutionpackager-tool-core";
 /**
- * Factory for creating JS Functions project tools.
+ * Factory for creating Functions project tools.
  * Handles projects with projectType "Function".
  */
 export declare class FunctionsToolFactory implements IProjectToolFactory {

package/dist/functions-tool.d.ts

@@ -8,11 +8,5 @@ export declare class FunctionsTool extends ProjectTool {
     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;
+    private detectLanguage;
 }

package/dist/index.js

@@ -8,23 +8,334 @@ import {
 
 // src/functions-tool.ts
 import {
-  NugetConstants,
+  NugetConstants as NugetConstants2,
   NugetPackager,
-  Path,
+  Path as Path2,
   ProjectTool,
   TemporaryStorageService,
   ToolErrorCodes,
   ToolResult
 } from "@uipath/solutionpackager-tool-core";
-var EXCLUDED_NAMES = new Set([".deno", ".env"]);
+
+// ../../../node_modules/@uipath/coded-functions-js-packager/dist/index.js
+var EXCLUDED_NAMES = new Set([
+  "node_modules",
+  ".git",
+  ".env",
+  ".deno",
+  "dist",
+  ".uip-dbg",
+  ".uipath"
+]);
 var EXCLUDED_EXTENSIONS = [".nupkg"];
-var EXTENSION_TO_RUNTIME = {
-  ".ts": "javascript",
-  ".js": "javascript",
-  ".py": "python"
+var LOCK_FILES = new Set(["bun.lock", "package-lock.json", "deno.lock", "yarn.lock"]);
+async function buildFunctionsPackage(fs, options) {
+  const { projectPath, outputPath, projectStorageId } = options;
+  const contentPath = fs.path.join(outputPath, "content");
+  await fs.mkdir(outputPath);
+  await fs.mkdir(contentPath);
+  const uipathJsonRaw = await fs.readFile(fs.path.join(projectPath, "uipath.json"), "utf-8");
+  if (!uipathJsonRaw) {
+    throw new Error("uipath.json not found. Run 'uipath-functions init' first.");
+  }
+  const uipathJson = JSON.parse(uipathJsonRaw);
+  const entryPointsRaw = await fs.readFile(fs.path.join(projectPath, "entry-points.json"), "utf-8");
+  if (!entryPointsRaw) {
+    throw new Error("entry-points.json not found. Run 'uipath-functions pack' to generate it.");
+  }
+  const entryPoints = JSON.parse(entryPointsRaw);
+  const bindingsRaw = await fs.readFile(fs.path.join(projectPath, "bindings.json"), "utf-8");
+  const bindings = bindingsRaw ? JSON.parse(bindingsRaw) : {
+    $schema: "https://cloud.uipath.com/draft/2024-12/bindings",
+    version: "2.0",
+    resources: []
+  };
+  const packageJsonRaw = await fs.readFile(fs.path.join(projectPath, "package.json"), "utf-8");
+  const packageDependencies = packageJsonRaw ? JSON.parse(packageJsonRaw).dependencies ?? {} : {};
+  const targetRuntime = detectRuntime(uipathJson.functions);
+  const includeLockFile = options.excludeLockFile ? false : uipathJson.packOptions?.includeLockFile ?? true;
+  await copyProjectFiles(fs, projectPath, contentPath, includeLockFile, uipathJson.packOptions);
+  const mainPath = entryPoints.entryPoints[0]?.filePath ?? "";
+  const operateJson = {
+    $schema: "https://cloud.uipath.com/draft/2024-12/operate",
+    projectId: projectStorageId,
+    main: mainPath,
+    contentType: "function",
+    targetFramework: "Portable",
+    targetRuntime,
+    runtimeOptions: {
+      requiresUserInteraction: false,
+      isAttended: false
+    },
+    dependencies: packageDependencies
+  };
+  await fs.writeFile(fs.path.join(contentPath, "operate.json"), JSON.stringify(operateJson, null, 2));
+  await fs.writeFile(fs.path.join(contentPath, "entry-points.json"), JSON.stringify(entryPoints, null, 2));
+  await fs.writeFile(fs.path.join(contentPath, "bindings_v2.json"), JSON.stringify(bindings, null, 2));
+  const packageDescriptor = {
+    $schema: "https://cloud.uipath.com/draft/2024-12/package-descriptor",
+    files: {
+      "operate.json": "content/operate.json",
+      "entry-points.json": "content/entry-points.json",
+      "bindings.json": "content/bindings_v2.json"
+    }
+  };
+  for (const ep of entryPoints.entryPoints) {
+    const fnEntry = uipathJson.functions?.[ep.filePath];
+    const filePath = fnEntry ? fnEntry.split(":")[0] ?? ep.filePath : ep.filePath;
+    packageDescriptor.files[ep.filePath] = `content/${filePath}`;
+  }
+  await fs.writeFile(fs.path.join(contentPath, "package-descriptor.json"), JSON.stringify(packageDescriptor, null, 2));
+}
+function detectRuntime(functions) {
+  if (!functions)
+    return "javascript";
+  const first = Object.values(functions)[0];
+  if (!first)
+    return "javascript";
+  const filePath = first.split(":")[0] ?? "";
+  const ext = filePath.slice(filePath.lastIndexOf("."));
+  if (ext === ".py")
+    return "python";
+  return "javascript";
+}
+async function copyProjectFiles(fs, sourcePath, destPath, includeLockFile, packOptions) {
+  const extraExcludedDirs = new Set(packOptions?.directoriesExcluded ?? []);
+  const extraExcludedFiles = new Set(packOptions?.filesExcluded ?? []);
+  async function walk(src, dest) {
+    await fs.mkdir(dest);
+    const entries = await fs.readdir(src);
+    for (const name of entries) {
+      if (EXCLUDED_NAMES.has(name))
+        continue;
+      if (extraExcludedDirs.has(name))
+        continue;
+      if (extraExcludedFiles.has(name))
+        continue;
+      if (EXCLUDED_EXTENSIONS.some((ext) => name.endsWith(ext)))
+        continue;
+      if (!includeLockFile && LOCK_FILES.has(name))
+        continue;
+      const srcEntry = fs.path.join(src, name);
+      const destEntry = fs.path.join(dest, name);
+      const stat = await fs.stat(srcEntry);
+      if (stat?.isDirectory()) {
+        await walk(srcEntry, destEntry);
+      } else if (stat?.isFile()) {
+        const content = await fs.readFile(srcEntry);
+        if (content)
+          await fs.writeFile(destEntry, content);
+      }
+    }
+  }
+  await walk(sourcePath, destPath);
+}
+
+// src/js/build-js-functions-package.ts
+async function buildJsFunctionsPackage(fileSystem, options) {
+  await buildFunctionsPackage(fileSystem, {
+    projectPath: options.projectPath,
+    outputPath: options.outputPath,
+    projectStorageId: options.projectStorageId
+  });
+}
+// src/py/build-py-functions-package.ts
+import { NugetConstants, Path } from "@uipath/solutionpackager-tool-core";
+
+// src/py/constants.ts
+var EXCLUDED_NAMES2 = new Set([
+  "agent.json",
+  "project.uiproj",
+  "bindings.json",
+  "entry-points.json",
+  ".DS_Store",
+  "Thumbs.db"
+]);
+var EXCLUDED_DIRECTORIES = new Set([
+  "evaluations",
+  "evals",
+  ".function-builder",
+  "node_modules",
+  "__pycache__",
+  ".pytest_cache",
+  ".venv",
+  "venv",
+  "env",
+  ".git",
+  ".vscode",
+  ".idea",
+  ".local"
+]);
+var CONTENT_TYPE = "function";
+var TARGET_RUNTIME = "python";
+var UIPATH_JSON_FILE_NAME = "uipath.json";
+var BINDINGS_SOURCE_FILE_NAME = "bindings.json";
+var BINDINGS_VERSION = "2.0";
+var ENTRY_POINT_TYPE = "function";
+var SCHEMA_BASE_URL = "https://cloud.uipath.com/draft/2024-12";
+var SCHEMAS = {
+  Bindings: `${SCHEMA_BASE_URL}/bindings`,
+  EntryPoint: `${SCHEMA_BASE_URL}/entry-point`,
+  Operate: `${SCHEMA_BASE_URL}/operate`,
+  PackageDescriptor: `${SCHEMA_BASE_URL}/package-descriptor`
 };
-var DEFAULT_RUNTIME = "javascript";
 
+// src/py/build-py-functions-package.ts
+async function buildPyFunctionsPackage(fileSystem, options) {
+  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, projectPath) {
+  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, sourcePath, destinationPath) {
+  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_NAMES2.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, contentFolder, projectStorageId) {
+  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 = JSON.parse(entryPointsText);
+        mainPath = entryPoints.entryPoints?.[0]?.filePath ?? "";
+      } catch {}
+    }
+  }
+  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, projectPath, contentFolder) {
+  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;
+  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 : [];
+  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, projectPath, contentFolder) {
+  const bindingsOutputPath = Path.join(contentFolder, NugetConstants.BindingsV2FileName);
+  const sourcePath = Path.join(projectPath, BINDINGS_SOURCE_FILE_NAME);
+  let bindings = 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, localBuildFolder) {
+  const packageDescriptor = {
+    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, key, fileName) {
+  const relativePath = Path.join(NugetConstants.ContentFolderName, fileName);
+  packageDescriptor.files[key] = relativePath;
+}
+// src/types.ts
+var Languages = {
+  JavaScript: "javascript",
+  Python: "python"
+};
+var LanguageLabels = {
+  [Languages.JavaScript]: "JS/TS",
+  [Languages.Python]: "Python"
+};
+
+// src/functions-tool.ts
 class FunctionsTool extends ProjectTool {
   _temporaryStorage;
   constructor(fileSystem, logger) {
@@ -40,21 +351,23 @@ class FunctionsTool extends ProjectTool {
     return ToolResult.success();
   }
   async buildAsync(options, _cancellationToken) {
+    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);
+    const localBuildFolder = Path2.join(tempFolder, NugetConstants2.OutputFolderName);
+    const build = language === Languages.Python ? buildPyFunctionsPackage : buildJsFunctionsPackage;
+    const languageLabel = LanguageLabels[language];
     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);
+      this.logger.progress(`Building ${languageLabel} Functions package...`);
+      await build(this.fileSystem, {
+        projectPath: options.projectPath,
+        outputPath: localBuildFolder,
+        projectStorageId: options.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 Functions project.");
+      return ToolResult.error(ToolErrorCodes.InternalError, `Build failed for ${languageLabel} Functions project.`);
     }
   }
   async packAsync(options, cancellationToken) {
@@ -66,7 +379,7 @@ class FunctionsTool extends ProjectTool {
     try {
       this.logger.progress("Creating NuGet package...");
       const nupkgFileName = `${options.package.id}.${options.package.version}.nupkg`;
-      const nupkgPath = Path.join(options.outputPath, nupkgFileName);
+      const nupkgPath = Path2.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.");
@@ -83,101 +396,26 @@ class FunctionsTool extends ProjectTool {
       await this._temporaryStorage.cleanup();
     } catch {}
   }
-  async detectRuntime(projectPath) {
-    const uipathJsonPath = Path.join(projectPath, "uipath.json");
-    const content = await this.fileSystem.readFile(uipathJsonPath);
-    if (content) {
+  async detectLanguage(projectPath) {
+    const uipathJsonContent = await this.fileSystem.readFile(Path2.join(projectPath, "uipath.json"), "utf-8");
+    if (uipathJsonContent) {
       try {
-        const uipathJson = JSON.parse(new TextDecoder().decode(content));
-        const functions = uipathJson?.functions;
-        const firstEntry = functions ? Object.values(functions)[0] : undefined;
+        const uipathJson = JSON.parse(uipathJsonContent);
+        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 {}
     }
-    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;
+    const pyprojectStat = await this.fileSystem.stat(Path2.join(projectPath, "pyproject.toml"));
+    if (pyprojectStat?.isFile())
+      return Languages.Python;
+    return Languages.JavaScript;
   }
 }
 

package/dist/js/build-js-functions-package.d.ts

@@ -0,0 +1,3 @@
+import type { IFileSystem } from "@uipath/solutionpackager-tool-core";
+import type { BuildPackageOptions } from "../types.js";
+export declare function buildJsFunctionsPackage(fileSystem: IFileSystem, options: BuildPackageOptions): Promise<void>;

package/dist/js/index.d.ts

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

package/dist/py/build-py-functions-package.d.ts

@@ -0,0 +1,3 @@
+import type { IFileSystem } from "@uipath/solutionpackager-tool-core";
+import type { BuildPackageOptions } from "../types.js";
+export declare function buildPyFunctionsPackage(fileSystem: IFileSystem, options: BuildPackageOptions): Promise<void>;

package/dist/py/constants.d.ts

@@ -0,0 +1,14 @@
+export declare const EXCLUDED_NAMES: Set<string>;
+export declare const EXCLUDED_DIRECTORIES: Set<string>;
+export declare const CONTENT_TYPE = "function";
+export declare const TARGET_RUNTIME = "python";
+export declare const UIPATH_JSON_FILE_NAME = "uipath.json";
+export declare const BINDINGS_SOURCE_FILE_NAME = "bindings.json";
+export declare const BINDINGS_VERSION = "2.0";
+export declare const ENTRY_POINT_TYPE = "function";
+export declare const SCHEMAS: {
+    readonly Bindings: "https://cloud.uipath.com/draft/2024-12/bindings";
+    readonly EntryPoint: "https://cloud.uipath.com/draft/2024-12/entry-point";
+    readonly Operate: "https://cloud.uipath.com/draft/2024-12/operate";
+    readonly PackageDescriptor: "https://cloud.uipath.com/draft/2024-12/package-descriptor";
+};

package/dist/py/index.d.ts

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

package/dist/types.d.ts

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