@uipath/function-tool 1.205.0-preview.281 → 1.206.0-preview.282

package/dist/{index-sby22td6.js → index-nzr4mx5p.js}

@@ -1,5 +1,3 @@
-import"./packager-tool-1de529jm.js";
-
 // ../../node_modules/open/index.js
 import process7 from "node:process";
 import path from "node:path";
@@ -548,22 +546,6 @@ var open = (target, options) => {
     target
   });
 };
-var openApp = (name, options) => {
-  if (typeof name !== "string" && !Array.isArray(name)) {
-    throw new TypeError("Expected a valid `name`");
-  }
-  const { arguments: appArguments = [] } = options ?? {};
-  if (appArguments !== undefined && appArguments !== null && !Array.isArray(appArguments)) {
-    throw new TypeError("Expected `appArguments` as Array type");
-  }
-  return baseOpen({
-    ...options,
-    app: {
-      name,
-      arguments: appArguments
-    }
-  });
-};
 function detectArchBinary(binary) {
   if (typeof binary === "string" || Array.isArray(binary)) {
     return binary;
@@ -626,9 +608,7 @@ defineLazyProperty(apps, "safari", () => detectPlatformBinary({
 }));
 var open_default = open;
 export {
-  apps,
-  open_default as default,
-  openApp
+  open_default as default
 };
 
-//# debugId=42C9AEC59ECC644E64756E2164756E21
+//# debugId=6F288C058A3A412164756E2164756E21

package/dist/{index-jhfvqtwr.js → index-vbqxs3my.js}

@@ -1,48 +1,93 @@
 import {
-  getAuthEnv
-} from "./packager-tool-1shggyya.js";
-import"./packager-tool-qa9gftnj.js";
-import {
-  OutputFormatter,
+  getFileSystem,
+  catchError2,
   RESULTS,
-  UIPATH_HOME_DIR,
-  catchError,
-  getOutputFormat,
-  getOutputFormatExplicit,
   getOutputSink,
   logger,
-  processContext
-} from "./packager-tool-f7enb48c.js";
+  getOutputFormat,
+  getOutputFormatExplicit,
+  OutputFormatter,
+  UIPATH_HOME_DIR
+} from "./packager-tool-cmtxbmhx.js";
 import {
-  getFileSystem
-} from "./packager-tool-y4vgqz1w.js";
-import"./packager-tool-0gctz400.js";
-import"./packager-tool-yc4kw997.js";
-import"./packager-tool-1de529jm.js";
+  getAuthEnv2
+} from "./packager-tool-qjerhjyd.js";
 
 // ../uipath-python-bridge/src/cache.ts
 async function readCache(cacheFile) {
   const fs = getFileSystem();
-  const [existsError, exists] = await catchError(fs.exists(cacheFile));
+  const [existsError, exists] = await catchError2(fs.exists(cacheFile));
   if (existsError || !exists)
     return null;
-  const [readError, content] = await catchError(fs.readFile(cacheFile, "utf-8"));
+  const [readError, content] = await catchError2(fs.readFile(cacheFile, "utf-8"));
   if (readError) {
     logger.warn(`Failed to load cache: ${readError}`);
     return null;
   }
-  const [parseError, cache] = catchError(() => JSON.parse(content));
+  const [parseError, cache] = catchError2(() => JSON.parse(content));
   if (parseError) {
     logger.warn(`Failed to parse cache: ${parseError}`);
     return null;
   }
   return cache;
 }
+// ../uipath-python-bridge/package.json
+var package_default = {
+  name: "@uipath/uipath-python-bridge",
+  author: "UiPath",
+  license: "SEE LICENSE IN LICENSE.txt",
+  version: "1.206.0-preview.282",
+  description: "Shared Python detection, caching, and CLI bridge for UiPath Python SDK tools.",
+  keywords: [
+    "uip",
+    "python",
+    "bridge"
+  ],
+  uipath: {
+    requires: {
+      uipath: ">=2.14.41"
+    }
+  },
+  type: "module",
+  main: "./dist/index.js",
+  exports: {
+    ".": "./dist/index.js"
+  },
+  files: [
+    "dist"
+  ],
+  repository: {
+    type: "git",
+    url: "https://github.com/UiPath/cli.git",
+    directory: "packages/uipath-python-bridge"
+  },
+  publishConfig: {
+    registry: "https://npm.pkg.github.com/@uipath"
+  },
+  scripts: {
+    build: "bun build ./src/index.ts --outdir dist --format esm --target node --external applicationinsights --sourcemap=linked",
+    typecheck: "tsc --noEmit",
+    test: "vitest run",
+    "test:coverage": "vitest run --coverage",
+    lint: "biome check .",
+    "lint:fix": "biome check --write ."
+  },
+  devDependencies: {
+    "@uipath/auth": "workspace:*",
+    "@uipath/common": "workspace:*",
+    "@uipath/filesystem": "workspace:*",
+    "@types/bun": "^1.3.11",
+    commander: "^14.0.3",
+    typescript: "^7.0.2"
+  }
+};
+
 // ../uipath-python-bridge/src/config.ts
 var DEFAULT_CONFIG = {
-  allowedPythonVersions: ["3.14", "3.13", "3.12", "3.11"],
+  allowedPythonVersions: ["3.14", "3.13", "3.12", "3.11", "3.15"],
   packageName: "uipath",
-  cacheFileName: ".uipath-python-cache.json"
+  cacheFileName: ".uipath-python-cache.json",
+  uipathVersionRequirement: package_default.uipath.requires.uipath
 };
 function getAllowedPythonVersions() {
   const envVersions = process.env.PYTHON_TOOL_PYTHON_VERSIONS;
@@ -57,6 +102,9 @@ function getPackageName() {
 function getCacheFileName() {
   return DEFAULT_CONFIG.cacheFileName;
 }
+function getUipathVersionRequirement() {
+  return DEFAULT_CONFIG.uipathVersionRequirement;
+}
 function matchesPattern(args, pattern) {
   if (typeof pattern === "string") {
     return args.includes(pattern);
@@ -136,6 +184,132 @@ async function supportsNewTypeOption(exePath, cwd, env = {}, signal) {
   });
 }
 
+// ../uipath-python-bridge/src/uipath-version.ts
+import { execFile as execFile2 } from "node:child_process";
+
+// ../uipath-python-bridge/src/package-version.ts
+var VERSION_RE = /^v?(\d+)\.(\d+)(?:\.(\d+))?/;
+function parseSimpleVersion(raw) {
+  const match = raw.trim().match(VERSION_RE);
+  if (!match)
+    return null;
+  return {
+    major: Number(match[1]),
+    minor: Number(match[2]),
+    patch: match[3] === undefined ? 0 : Number(match[3])
+  };
+}
+function compareSimpleVersion(a, b) {
+  return a.major - b.major || a.minor - b.minor || a.patch - b.patch;
+}
+var MINIMUM_RE = /^>=\s*(\d+)\.(\d+)\.(\d+)$/;
+function parseMinimumVersion(specifier) {
+  const match = specifier.trim().match(MINIMUM_RE);
+  if (!match)
+    return null;
+  return {
+    major: Number(match[1]),
+    minor: Number(match[2]),
+    patch: Number(match[3])
+  };
+}
+function formatSimpleVersion(version) {
+  return `${version.major}.${version.minor}.${version.patch}`;
+}
+
+// ../uipath-python-bridge/src/uipath-version.ts
+var VERSION_LINE = /uipath\s+version\s+(\S+)/i;
+async function probeUipathVersion(exePath, options = {}) {
+  return new Promise((resolve) => {
+    execFile2(exePath, ["--version"], {
+      cwd: options.cwd,
+      encoding: "utf-8",
+      windowsHide: true,
+      signal: options.signal
+    }, (error, stdout, stderr) => {
+      const out = typeof stdout === "string" ? stdout.trim() : "";
+      const err = typeof stderr === "string" ? stderr.trim() : "";
+      if (error) {
+        resolve({ error: describeProbeError(exePath, error, err) });
+        return;
+      }
+      const match = out.match(VERSION_LINE);
+      if (!match) {
+        resolve({
+          error: `Could not parse version from '${exePath} --version' output: ${out || "<empty>"}`
+        });
+        return;
+      }
+      resolve({ version: match[1] });
+    });
+  });
+}
+function describeProbeError(exePath, error, stderr) {
+  if (typeof error.code === "number") {
+    return `'${exePath} --version' exited with code ${error.code}${stderr ? `: ${stderr}` : ""}`;
+  }
+  return `Failed to run '${exePath} --version': ${error.message}`;
+}
+function resolveRequirement() {
+  const requirement = getUipathVersionRequirement();
+  const minimum = parseMinimumVersion(requirement);
+  if (!minimum) {
+    return {
+      requirement,
+      invalid: {
+        ok: false,
+        kind: "unverifiable",
+        requirement,
+        message: `Invalid uipath version requirement '${requirement}' declared by @uipath/uipath-python-bridge.`
+      }
+    };
+  }
+  return { requirement, minimum };
+}
+function judge(version, exePath, requirement, minimum) {
+  const parsed = parseSimpleVersion(version);
+  if (!parsed) {
+    return {
+      ok: false,
+      kind: "unverifiable",
+      requirement,
+      message: `Could not read uipath version '${version}' reported by ${exePath}.`
+    };
+  }
+  if (compareSimpleVersion(parsed, minimum) < 0) {
+    return {
+      ok: false,
+      kind: "unsupported",
+      version,
+      requirement,
+      message: `uipath ${version} found at ${exePath}; ${formatSimpleVersion(minimum)} or later is required.`
+    };
+  }
+  return { ok: true, version, requirement };
+}
+async function checkUipathVersion(exePath, options = {}) {
+  const resolved = resolveRequirement();
+  if ("invalid" in resolved)
+    return resolved.invalid;
+  const probe = await probeUipathVersion(exePath, options);
+  if ("error" in probe) {
+    return {
+      ok: false,
+      kind: "unverifiable",
+      requirement: resolved.requirement,
+      message: probe.error
+    };
+  }
+  return judge(probe.version, exePath, resolved.requirement, resolved.minimum);
+}
+function uipathVersionInstructions(check, toolName) {
+  const setupHint = `then re-run 'uip ${toolName} setup --force'`;
+  if (check.kind === "unverifiable") {
+    return `Make sure the uipath package is installed and runnable in that environment, ${setupHint}.`;
+  }
+  return `Upgrade uipath, ${setupHint}.`;
+}
+
 // ../uipath-python-bridge/src/execute.ts
 var ENV_FILE_NAME = ".env";
 function isHelpCommand(args) {
@@ -162,8 +336,8 @@ function envValueFromFile(content, name) {
     if (!line || line.startsWith("#")) {
       return false;
     }
-    const [key, ...valueParts2] = line.split("=");
-    return key.trim() === name && valueParts2.join("=").trim().length > 0;
+    const [key, ...valueParts] = line.split("=");
+    return key.trim() === name && valueParts.join("=").trim().length > 0;
   });
   if (!envLine) {
     return null;
@@ -180,7 +354,7 @@ async function getConfiguredEnvValue(fs, name) {
   if (!await fs.exists(envPath)) {
     return null;
   }
-  const [readError, content] = await catchError(fs.readFile(envPath, "utf-8"));
+  const [readError, content] = await catchError2(fs.readFile(envPath, "utf-8"));
   return !readError && typeof content === "string" ? envValueFromFile(content, name) : null;
 }
 var fail = (reason, message, instructions, extras = {}) => ({
@@ -235,13 +409,13 @@ async function runUipathPythonCommand(args, options = {}) {
     }
     requiredEnv[requirement.name] = value;
   }
-  const { authEnv, loginStatus } = await getAuthEnv();
+  const { authEnv, loginStatus } = await getAuthEnv2();
   if (!loginStatus) {
     logger.debug("Auth unavailable, continuing without credentials.");
   }
   if (options.commandPreflight) {
     const preflight = options.commandPreflight;
-    const [preflightError, preflightResult] = await catchError(Promise.resolve().then(() => preflight({
+    const [preflightError, preflightResult] = await catchError2(Promise.resolve().then(() => preflight({
       args: commandArgs,
       loginStatus,
       authEnv
@@ -255,6 +429,14 @@ async function runUipathPythonCommand(args, options = {}) {
   }
   const stdio = options.stdio ?? "inherit";
   const cwd = options.cwd ?? fs.env.cwd();
+  const versionCheck = await checkUipathVersion(cache.uipathExePath, {
+    cwd,
+    signal: options.signal
+  });
+  if (!versionCheck.ok) {
+    return fail(versionCheck.kind === "unsupported" ? "uipath_version_unsupported" : "uipath_version_unverifiable", versionCheck.message, uipathVersionInstructions(versionCheck, toolLabel));
+  }
+  logger.debug(`Using uipath ${versionCheck.version} at ${cache.uipathExePath} (source: ${cache.source ?? "unknown"}; requires uipath${versionCheck.requirement})`);
   if (options.pinNewType && processed.args[0] === "new" && !isHelpCommand(processed.args) && await supportsNewTypeOption(cache.uipathExePath, cwd, { ...authEnv, ...requiredEnv }, options.signal)) {
     commandArgs.push("--type", options.pinNewType);
   }
@@ -285,7 +467,7 @@ async function runUipathPythonCommand(args, options = {}) {
       getOutputSink().writeErr(chunk);
     });
   }
-  const [spawnError, exitCode] = await catchError(new Promise((resolve, reject) => {
+  const [spawnError, exitCode] = await catchError2(new Promise((resolve, reject) => {
     proc.on("close", (code) => resolve(code ?? 1));
     proc.on("error", reject);
   }));
@@ -303,6 +485,7 @@ async function runUipathPythonCommand(args, options = {}) {
   return {
     ok: true,
     pythonExePath: cache.uipathExePath,
+    uipathVersion: versionCheck.version,
     exitCode: 0,
     stdout: stdio === "pipe" ? stdout : undefined,
     stderr: stdio === "pipe" ? stderr : undefined
@@ -311,6 +494,8 @@ async function runUipathPythonCommand(args, options = {}) {
 var CLI_RESULT_BY_REASON = {
   python_not_configured: RESULTS.ConfigError,
   uipath_exe_missing: RESULTS.ConfigError,
+  uipath_version_unsupported: RESULTS.ConfigError,
+  uipath_version_unverifiable: RESULTS.ConfigError,
   command_disabled: RESULTS.ValidationError,
   new_type_not_allowed: RESULTS.ValidationError,
   required_env_missing: RESULTS.ConfigError,
@@ -328,31 +513,6 @@ function reportUipathPythonFailure(result) {
   }
   return result.exitCode;
 }
-function createExecuteCommand(config) {
-  const executeCommand = async (rawArgs, _options) => {
-    const runIndex = rawArgs.indexOf("exec");
-    const actualArgs = runIndex >= 0 ? rawArgs.slice(runIndex + 1) : [];
-    const result = await runUipathPythonCommand(actualArgs, {
-      commandPrefix: config.commandPrefix,
-      toolName: config.toolName,
-      pinNewType: config.pinNewType,
-      commandRules: config.commandRules,
-      commandPreflight: config.commandPreflight,
-      requiredEnvironmentVariables: config.requiredEnvironmentVariables,
-      outputFormatOption: config.outputFormatOption,
-      outputFormats: config.outputFormats,
-      stdio: "inherit"
-    });
-    processContext.exit(reportUipathPythonFailure(result));
-    return result;
-  };
-  const registerExecCommand = (program) => {
-    program.command("exec", { hidden: true }).description("Execute the uipath package with provided arguments").allowUnknownOption(true).allowExcessArguments(true).trackedAction(processContext, async (_options, cmd) => {
-      await executeCommand(["_", "_", "exec", ...cmd.args], {});
-    });
-  };
-  return { executeCommand, registerExecCommand };
-}
 // ../uipath-python-bridge/src/python-service.ts
 import { spawn as spawn2 } from "node:child_process";
 import { platform } from "node:os";
@@ -360,14 +520,13 @@ class PythonService {
   cacheFile;
   config;
   uipathExePath;
-  packageVersion;
   constructor(config) {
     const fs = getFileSystem();
     this.config = config;
     this.cacheFile = config.cacheFile || fs.path.join(fs.env.homedir(), UIPATH_HOME_DIR, getCacheFileName());
   }
   async setup(packageName, force = false) {
-    const [error, result] = await catchError(this._setupInternal(packageName, force));
+    const [error, result] = await catchError2(this._setupInternal(packageName, force));
     if (error) {
       return { success: false, error: error.message };
     }
@@ -420,26 +579,20 @@ To install the package, run:
   ${pythonPath} -m pip install ${packageName}`
       };
     }
-    const versionResult = await this.getUipathVersion(this.uipathExePath);
-    if ("error" in versionResult) {
-      return {
-        success: false,
+    const versionCheck = await checkUipathVersion(this.uipathExePath);
+    if (!versionCheck.ok) {
+      return this.rejectVersion(versionCheck, {
         pythonPath,
         pythonVersion: version,
-        packageInstalled: true,
-        uipathExePath: this.uipathExePath,
-        source,
-        error: versionResult.error
-      };
+        source
+      });
     }
-    this.packageVersion = versionResult.version;
     await this.saveCache({
       pythonPath,
       version,
       lastValidated: new Date().toISOString(),
       packageName,
       uipathExePath: this.uipathExePath,
-      packageVersion: this.packageVersion,
       source
     });
     return {
@@ -447,7 +600,7 @@ To install the package, run:
       pythonPath,
       pythonVersion: version,
       packageInstalled: true,
-      packageVersion: this.packageVersion,
+      packageVersion: versionCheck.version,
       uipathExePath: this.uipathExePath,
       source
     };
@@ -471,21 +624,13 @@ To install the package, run:
     this.uipathExePath = cached.uipathExePath;
     const source = cached.source ?? (virtualEnv ? "venv" : "path");
     logger.info(`Using cached uipath executable: ${this.uipathExePath}`);
-    this.packageVersion = cached.packageVersion;
-    if (!this.packageVersion) {
-      const versionResult = await this.getUipathVersion(this.uipathExePath);
-      if ("error" in versionResult) {
-        return {
-          success: false,
-          pythonPath,
-          pythonVersion: version,
-          packageInstalled: true,
-          uipathExePath: this.uipathExePath,
-          source,
-          error: versionResult.error
-        };
-      }
-      this.packageVersion = versionResult.version;
+    const versionCheck = await checkUipathVersion(this.uipathExePath);
+    if (!versionCheck.ok) {
+      return this.rejectVersion(versionCheck, {
+        pythonPath,
+        pythonVersion: version,
+        source
+      });
     }
     await this.saveCache({
       pythonPath,
@@ -493,7 +638,6 @@ To install the package, run:
       lastValidated: new Date().toISOString(),
       packageName,
       uipathExePath: this.uipathExePath,
-      packageVersion: this.packageVersion,
       source
     });
     return {
@@ -501,7 +645,7 @@ To install the package, run:
       pythonPath,
       pythonVersion: version,
       packageInstalled: true,
-      packageVersion: this.packageVersion,
+      packageVersion: versionCheck.version,
       uipathExePath: this.uipathExePath,
       source
     };
@@ -594,7 +738,7 @@ To install the package, run:
     const stderrChunks = [];
     versionProc.stdout.on("data", (chunk) => stdoutChunks.push(chunk));
     versionProc.stderr.on("data", (chunk) => stderrChunks.push(chunk));
-    const [versionError, exitCode] = await catchError(new Promise((resolve, reject) => {
+    const [versionError, exitCode] = await catchError2(new Promise((resolve, reject) => {
       versionProc.on("exit", (code) => resolve(code ?? 1));
       versionProc.on("error", (error) => reject(error));
     }));
@@ -677,7 +821,7 @@ sys.exit(3)
     const stderrChunks = [];
     proc.stdout.on("data", (chunk) => stdoutChunks.push(chunk));
     proc.stderr.on("data", (chunk) => stderrChunks.push(chunk));
-    const [error, exitCode] = await catchError(new Promise((resolve, reject) => {
+    const [error, exitCode] = await catchError2(new Promise((resolve, reject) => {
       proc.on("exit", (code) => resolve(code ?? 1));
       proc.on("error", (err) => reject(err));
     }));
@@ -708,7 +852,7 @@ sys.exit(3)
     });
     const stdoutChunks = [];
     proc.stdout.on("data", (chunk) => stdoutChunks.push(chunk));
-    const [error, exitCode] = await catchError(new Promise((resolve, reject) => {
+    const [error, exitCode] = await catchError2(new Promise((resolve, reject) => {
       proc.on("exit", (code) => resolve(code ?? 1));
       proc.on("error", (err) => reject(err));
     }));
@@ -721,37 +865,18 @@ sys.exit(3)
     const prefix = Buffer.concat(stdoutChunks).toString("utf-8").trim();
     return prefix || undefined;
   }
-  async getUipathVersion(exePath) {
-    const proc = spawn2(exePath, ["--version"], {
-      stdio: ["ignore", "pipe", "pipe"]
-    });
-    const stdoutChunks = [];
-    const stderrChunks = [];
-    proc.stdout.on("data", (chunk) => stdoutChunks.push(chunk));
-    proc.stderr.on("data", (chunk) => stderrChunks.push(chunk));
-    const [spawnError, exitCode] = await catchError(new Promise((resolve, reject) => {
-      proc.on("exit", (code) => resolve(code ?? 1));
-      proc.on("error", (err) => reject(err));
-    }));
-    if (spawnError) {
-      return {
-        error: `Failed to run '${exePath} --version': ${spawnError.message}`
-      };
-    }
-    const stdout = Buffer.concat(stdoutChunks).toString("utf-8").trim();
-    const stderr = Buffer.concat(stderrChunks).toString("utf-8").trim();
-    if (exitCode !== 0) {
-      return {
-        error: `'${exePath} --version' exited with code ${exitCode}${stderr ? `: ${stderr}` : ""}`
-      };
-    }
-    const match = stdout.match(/uipath\s+version\s+(\S+)/i);
-    if (!match) {
-      return {
-        error: `Could not parse version from '${exePath} --version' output: ${stdout || "<empty>"}`
-      };
-    }
-    return { version: match[1] };
+  rejectVersion(check, context) {
+    return {
+      success: false,
+      pythonPath: context.pythonPath,
+      pythonVersion: context.pythonVersion,
+      packageInstalled: true,
+      packageVersion: check.kind === "unsupported" ? check.version : undefined,
+      uipathExePath: this.uipathExePath,
+      source: context.source,
+      error: check.message,
+      instructions: uipathVersionInstructions(check, this.config.toolName ?? "codedagent")
+    };
   }
   getPathUipathCandidates(fs, isWindows) {
     const pathValue = process.env.PATH || (isWindows ? process.env.Path : undefined);
@@ -838,12 +963,12 @@ Please install one of the required Python versions:
   async saveCache(cache) {
     const fs = getFileSystem();
     const dir = fs.path.dirname(this.cacheFile);
-    const [mkdirError] = await catchError(fs.mkdir(dir));
+    const [mkdirError] = await catchError2(fs.mkdir(dir));
     if (mkdirError) {
       logger.warn(`Failed to create cache directory: ${mkdirError}`);
       return;
     }
-    const [writeError] = await catchError(fs.writeFile(this.cacheFile, JSON.stringify(cache, null, 2)));
+    const [writeError] = await catchError2(fs.writeFile(this.cacheFile, JSON.stringify(cache, null, 2)));
     if (writeError) {
       logger.warn(`Failed to save cache: ${writeError}`);
       return;
@@ -862,100 +987,13 @@ function isPathInside(target, root) {
   const normalizedRoot = normalize(root);
   return normalizedTarget === normalizedRoot || normalizedTarget.startsWith(`${normalizedRoot}/`);
 }
-// ../uipath-python-bridge/src/register.ts
-function createSetupCommand(config) {
-  return (program) => {
-    program.command("setup").description("Detect Python installation and verify package is installed").option("--force", "Force re-detection of Python even if cached", false).trackedAction(processContext, async (options) => {
-      const packageName = config.packageName || getPackageName();
-      const allowedVersions = getAllowedPythonVersions();
-      if (allowedVersions.length === 0) {
-        OutputFormatter.error({
-          Result: RESULTS.Failure,
-          Message: "Invalid configuration. Allowed Python list misconfigured.",
-          Instructions: "Check env variable PYTHON_TOOL_PYTHON_VERSIONS"
-        });
-        processContext.exit(1);
-        return;
-      }
-      logger.info(`
-Searching for Python installations: ${allowedVersions}`);
-      const service = new PythonService({
-        allowedVersions,
-        packageName,
-        toolName: config.toolName
-      });
-      const result = await service.setup(packageName, options.force);
-      if (!result.success) {
-        OutputFormatter.error({
-          Result: RESULTS.Failure,
-          Message: result.error || "Setup failed with no error.",
-          Instructions: result.instructions || `Install a supported Python version and the '${packageName}' tool, then re-run setup. For uv installs, run 'uv tool install ${packageName}' and ensure the uv tool directory is on PATH.`
-        });
-        processContext.exit(1);
-        return;
-      }
-      OutputFormatter.success({
-        Result: RESULTS.Success,
-        Code: config.successCode,
-        Data: {
-          PythonPath: result.pythonPath,
-          Package: packageName,
-          PackageInstalled: result.packageInstalled ? "Yes" : "No",
-          PackageVersion: result.packageVersion ?? "N/A",
-          UipathPath: result.uipathExePath,
-          Source: result.source
-        }
-      });
-      processContext.exit(0);
-    });
-  };
-}
-function createDefaultAction(executeCommand) {
-  return (program) => {
-    program.trackedAction(processContext, async () => {
-      const userArgs = program.args.length > 0 ? normalizeDefaultActionArgs(program.args) : [];
-      const extra = userArgs.length > 0 ? userArgs : ["--help"];
-      await executeCommand(["_", "_", "exec", ...extra], {});
-    });
-  };
-}
-function normalizeDefaultActionArgs(args) {
-  return args.length === 1 && args[0] === "-h" ? ["--help"] : args;
-}
-function createHelpCommand(executeCommand) {
-  return (program) => {
-    program.command("help").description("Display help for the python tool").trackedAction(processContext, async () => {
-      await executeCommand(["_", "_", "exec", "--help"], {});
-    });
-  };
-}
-function createCommandForwarder(executeCommand) {
-  return (program) => {
-    program.on("command:*", async (operands) => {
-      const unknownCommand = operands[0];
-      if (!program.commands.some((c) => c.name() === unknownCommand)) {
-        await executeCommand(["_", "_", "exec", ...operands], {});
-      }
-    });
-  };
-}
 export {
   PythonService,
-  createCommandForwarder,
-  createDefaultAction,
-  createExecuteCommand,
-  createHelpCommand,
-  createSetupCommand,
   getAllowedPythonVersions,
-  getCacheFileName,
   getPackageName,
-  hasTypeOption,
-  isPathInside,
-  processCommandArgs,
-  readCache,
+  getUipathVersionRequirement,
   reportUipathPythonFailure,
-  runUipathPythonCommand,
-  supportsNewTypeOption
+  runUipathPythonCommand
 };
 
-//# debugId=A5A08FE74545D89264756E2164756E21
+//# debugId=EB43C467CA61EDA464756E2164756E21