@uipath/function-tool 1.203.0-preview.205 → 1.204.0-preview.206

package/dist/index-pv66qwr4.js

@@ -0,0 +1,961 @@
+import {
+  getAuthEnv
+} from "./packager-tool-4r3qztwy.js";
+import {
+  OutputFormatter,
+  RESULTS,
+  UIPATH_HOME_DIR,
+  catchError,
+  getOutputFormat,
+  getOutputFormatExplicit,
+  getOutputSink,
+  logger,
+  processContext
+} from "./packager-tool-5s8z8be9.js";
+import"./packager-tool-0gctz400.js";
+import"./packager-tool-qa9gftnj.js";
+import {
+  getFileSystem
+} from "./packager-tool-g0hcxnae.js";
+import"./packager-tool-yc4kw997.js";
+import"./packager-tool-1de529jm.js";
+
+// ../uipath-python-bridge/src/cache.ts
+async function readCache(cacheFile) {
+  const fs = getFileSystem();
+  const [existsError, exists] = await catchError(fs.exists(cacheFile));
+  if (existsError || !exists)
+    return null;
+  const [readError, content] = await catchError(fs.readFile(cacheFile, "utf-8"));
+  if (readError) {
+    logger.warn(`Failed to load cache: ${readError}`);
+    return null;
+  }
+  const [parseError, cache] = catchError(() => JSON.parse(content));
+  if (parseError) {
+    logger.warn(`Failed to parse cache: ${parseError}`);
+    return null;
+  }
+  return cache;
+}
+// ../uipath-python-bridge/src/config.ts
+var DEFAULT_CONFIG = {
+  allowedPythonVersions: ["3.14", "3.13", "3.12", "3.11"],
+  packageName: "uipath",
+  cacheFileName: ".uipath-python-cache.json"
+};
+function getAllowedPythonVersions() {
+  const envVersions = process.env.PYTHON_TOOL_PYTHON_VERSIONS;
+  if (envVersions) {
+    return envVersions.split(",").map((v) => v.trim()).filter(Boolean);
+  }
+  return DEFAULT_CONFIG.allowedPythonVersions;
+}
+function getPackageName() {
+  return DEFAULT_CONFIG.packageName;
+}
+function getCacheFileName() {
+  return DEFAULT_CONFIG.cacheFileName;
+}
+function matchesPattern(args, pattern) {
+  if (typeof pattern === "string") {
+    return args.includes(pattern);
+  }
+  if (Array.isArray(pattern)) {
+    for (let i = 0;i <= args.length - pattern.length; i++) {
+      let match = true;
+      for (let j = 0;j < pattern.length; j++) {
+        if (args[i + j] !== pattern[j]) {
+          match = false;
+          break;
+        }
+      }
+      if (match) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+function processCommandArgs(args, rules) {
+  const hasForceFlag = args.includes("--force");
+  const argsWithoutForce = args.filter((arg) => arg !== "--force");
+  for (const rule of rules) {
+    if (matchesPattern(argsWithoutForce, rule.pattern)) {
+      switch (rule.action) {
+        case "filter":
+          if (hasForceFlag) {
+            return {
+              allowed: true,
+              args: [...argsWithoutForce]
+            };
+          }
+          return {
+            allowed: false,
+            args: [],
+            errorMessage: rule.filterMessage || "This command is not allowed"
+          };
+        case "append":
+          if (rule.appendArgs && rule.appendArgs.length > 0) {
+            return {
+              allowed: true,
+              args: [...argsWithoutForce, ...rule.appendArgs]
+            };
+          }
+          break;
+      }
+    }
+  }
+  return {
+    allowed: true,
+    args: [...argsWithoutForce]
+  };
+}
+// ../uipath-python-bridge/src/execute.ts
+import { spawn } from "node:child_process";
+
+// ../uipath-python-bridge/src/scaffold-type.ts
+import { execFile } from "node:child_process";
+var PROBE_TIMEOUT_MS = 15000;
+var TYPE_OPTION = /^--type(=|$)/;
+var TYPE_LISTED = /^[ \t]*--type(?![\w-])/m;
+function hasTypeOption(args) {
+  return args.some((arg) => TYPE_OPTION.test(arg));
+}
+async function supportsNewTypeOption(exePath, cwd, env = {}, signal) {
+  return new Promise((resolve) => {
+    execFile(exePath, ["new", "--help"], {
+      cwd,
+      env: { ...process.env, ...env },
+      timeout: PROBE_TIMEOUT_MS,
+      windowsHide: true,
+      signal
+    }, (error, stdout) => {
+      resolve(!error && TYPE_LISTED.test(typeof stdout === "string" ? stdout : ""));
+    });
+  });
+}
+
+// ../uipath-python-bridge/src/execute.ts
+var ENV_FILE_NAME = ".env";
+function isHelpCommand(args) {
+  return args.includes("--help") || args.includes("-h");
+}
+function hasOption(args, option) {
+  return args.some((arg) => arg === option || arg.startsWith(`${option}=`));
+}
+function applyOutputFormatOption(args, option, supportedFormats) {
+  if (!option || !getOutputFormatExplicit() || isHelpCommand(args) || hasOption(args, option)) {
+    return args;
+  }
+  const format = getOutputFormat();
+  if (supportedFormats && !supportedFormats.includes(format)) {
+    return args;
+  }
+  return [...args, option, format];
+}
+function matchesRequiredCommand(args, commands) {
+  return args[0] !== undefined && commands.includes(args[0]);
+}
+function envValueFromFile(content, name) {
+  const envLine = content.split(/\r?\n/).map((line) => line.trim()).find((line) => {
+    if (!line || line.startsWith("#")) {
+      return false;
+    }
+    const [key, ...valueParts2] = line.split("=");
+    return key.trim() === name && valueParts2.join("=").trim().length > 0;
+  });
+  if (!envLine) {
+    return null;
+  }
+  const [, ...valueParts] = envLine.split("=");
+  return valueParts.join("=").trim().replace(/^["']|["']$/g, "") || null;
+}
+async function getConfiguredEnvValue(fs, name) {
+  const processValue = process.env[name]?.trim();
+  if (processValue) {
+    return processValue;
+  }
+  const envPath = fs.path.join(fs.env.cwd(), ENV_FILE_NAME);
+  if (!await fs.exists(envPath)) {
+    return null;
+  }
+  const [readError, content] = await catchError(fs.readFile(envPath, "utf-8"));
+  return !readError && typeof content === "string" ? envValueFromFile(content, name) : null;
+}
+var fail = (reason, message, instructions, extras = {}) => ({
+  ok: false,
+  reason,
+  message,
+  instructions,
+  exitCode: extras.exitCode ?? 1,
+  stderr: extras.stderr
+});
+function childStdio(stdio) {
+  switch (stdio) {
+    case "pipe":
+      return ["ignore", "pipe", "pipe"];
+    case "stdout-to-stderr":
+      return ["inherit", "pipe", "inherit"];
+    default:
+      return "inherit";
+  }
+}
+async function runUipathPythonCommand(args, options = {}) {
+  const fs = getFileSystem();
+  const cacheFile = fs.path.join(fs.env.homedir(), UIPATH_HOME_DIR, getCacheFileName());
+  const toolLabel = options.toolName ?? options.commandPrefix ?? "codedagent";
+  const setupCommand = `uip ${toolLabel} setup`;
+  const setupHint = `Run '${setupCommand}' first to configure the environment. ` + `Activate the project's virtual environment and run ${setupCommand} --force.`;
+  const cache = await readCache(cacheFile);
+  if (!cache?.uipathExePath) {
+    return fail("python_not_configured", "Python not configured.", setupHint);
+  }
+  if (!await fs.exists(cache.uipathExePath)) {
+    return fail("uipath_exe_missing", "uipath executable not found. Please install it using 'pip install uipath' or 'uv add uipath'.", setupHint);
+  }
+  const processed = processCommandArgs(args, options.commandRules ?? []);
+  if (!processed.allowed) {
+    return fail("command_disabled", processed.errorMessage || "Command disabled.", "Use of --force flag is not recommended. Favor alternate command.", { exitCode: 3 });
+  }
+  if (options.pinNewType && processed.args[0] === "new" && !isHelpCommand(processed.args) && hasTypeOption(processed.args)) {
+    return fail("new_type_not_allowed", "--type is not a valid option.", "Remove --type and re-run.");
+  }
+  const processedArgs = applyOutputFormatOption(processed.args, options.outputFormatOption, options.outputFormats);
+  const commandArgs = options.commandPrefix ? [options.commandPrefix, ...processedArgs] : [...processedArgs];
+  const requiredEnv = {};
+  for (const requirement of options.requiredEnvironmentVariables ?? []) {
+    const applies = matchesRequiredCommand(processed.args, requirement.commands) && (!requirement.skipWhenHelp || !isHelpCommand(processed.args));
+    if (!applies) {
+      continue;
+    }
+    const value = await getConfiguredEnvValue(fs, requirement.name);
+    if (!value) {
+      return fail("required_env_missing", `${requirement.name} environment variable not found.`, requirement.instructions);
+    }
+    requiredEnv[requirement.name] = value;
+  }
+  const { authEnv, loginStatus } = await getAuthEnv();
+  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({
+      args: commandArgs,
+      loginStatus,
+      authEnv
+    })));
+    if (preflightError) {
+      return fail("preflight_error", preflightError.message, "Check your credentials and configuration, then retry.");
+    }
+    if (preflightResult && !preflightResult.allowed) {
+      return fail("preflight_rejected", preflightResult.message || "Command preflight check failed.", preflightResult.instructions || "Update the command configuration and try again.", { exitCode: preflightResult.exitCode ?? 1 });
+    }
+  }
+  const stdio = options.stdio ?? "inherit";
+  const cwd = options.cwd ?? fs.env.cwd();
+  if (options.pinNewType && processed.args[0] === "new" && !isHelpCommand(processed.args) && await supportsNewTypeOption(cache.uipathExePath, cwd, { ...authEnv, ...requiredEnv }, options.signal)) {
+    commandArgs.push("--type", options.pinNewType);
+  }
+  const proc = spawn(cache.uipathExePath, commandArgs, {
+    cwd,
+    env: {
+      ...process.env,
+      ...authEnv,
+      ...requiredEnv
+    },
+    stdio: childStdio(stdio),
+    signal: options.signal
+  });
+  let stdout = "";
+  let stderr = "";
+  if (stdio === "pipe") {
+    proc.stdout?.setEncoding("utf8");
+    proc.stderr?.setEncoding("utf8");
+    proc.stdout?.on("data", (chunk) => {
+      stdout += chunk;
+    });
+    proc.stderr?.on("data", (chunk) => {
+      stderr += chunk;
+    });
+  } else if (stdio === "stdout-to-stderr") {
+    proc.stdout?.setEncoding("utf8");
+    proc.stdout?.on("data", (chunk) => {
+      getOutputSink().writeErr(chunk);
+    });
+  }
+  const [spawnError, exitCode] = await catchError(new Promise((resolve, reject) => {
+    proc.on("close", (code) => resolve(code ?? 1));
+    proc.on("error", reject);
+  }));
+  if (spawnError) {
+    return fail("spawn_failed", spawnError.message, setupHint, {
+      stderr: stdio === "pipe" ? stderr : undefined
+    });
+  }
+  if (exitCode !== 0) {
+    return fail("command_failed", `Python 'uipath ${commandArgs.join(" ")}' exited with code ${exitCode}.`, stdio === "pipe" && stderr ? "See the captured stderr below for the Python tool's error output." : "Re-run with verbose flags or stream stdio inherit to diagnose.", {
+      exitCode,
+      stderr: stdio === "pipe" ? stderr : undefined
+    });
+  }
+  return {
+    ok: true,
+    pythonExePath: cache.uipathExePath,
+    exitCode: 0,
+    stdout: stdio === "pipe" ? stdout : undefined,
+    stderr: stdio === "pipe" ? stderr : undefined
+  };
+}
+var CLI_RESULT_BY_REASON = {
+  python_not_configured: RESULTS.ConfigError,
+  uipath_exe_missing: RESULTS.ConfigError,
+  command_disabled: RESULTS.ValidationError,
+  new_type_not_allowed: RESULTS.ValidationError,
+  required_env_missing: RESULTS.ConfigError,
+  preflight_error: RESULTS.Failure,
+  preflight_rejected: RESULTS.ConfigError,
+  spawn_failed: RESULTS.Failure
+};
+function reportUipathPythonFailure(result) {
+  if (!result.ok && result.reason !== "command_failed") {
+    OutputFormatter.error({
+      Result: CLI_RESULT_BY_REASON[result.reason],
+      Message: result.message,
+      Instructions: result.instructions
+    });
+  }
+  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";
+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));
+    if (error) {
+      return { success: false, error: error.message };
+    }
+    return result;
+  }
+  async _setupInternal(packageName, force) {
+    const virtualEnv = process.env.VIRTUAL_ENV || undefined;
+    const dormantVenv = await this.checkDormantVenv();
+    if (dormantVenv) {
+      return dormantVenv;
+    }
+    if (!force) {
+      const reused = await this.reuseCache(packageName, virtualEnv);
+      if (reused)
+        return reused;
+    }
+    logger.info("Checking Python...");
+    const detection = virtualEnv ? await this.detectVenvPython(virtualEnv) : await this.detectPython();
+    if (!detection.success || !detection.pythonPath || !detection.version) {
+      return {
+        success: false,
+        error: detection.error || "Failed to detect Python"
+      };
+    }
+    const pythonPath = detection.pythonPath;
+    const version = detection.version;
+    const source = detection.source ?? "path";
+    this.uipathExePath = detection.uipathExePath;
+    if (!this.uipathExePath) {
+      if (virtualEnv) {
+        return {
+          success: false,
+          pythonPath,
+          pythonVersion: version,
+          packageInstalled: false,
+          source,
+          error: `Package '${packageName}' is not installed in the active virtual environment: ${virtualEnv}`,
+          instructions: `Install it inside the active virtual environment (uv pip install ${packageName} or the framework package), then re-run uip ${this.config.toolName ?? "codedagent"} setup --force.`
+        };
+      }
+      return {
+        success: false,
+        pythonPath,
+        pythonVersion: version,
+        packageInstalled: false,
+        source,
+        error: `Package '${packageName}' is not installed.
+
+To install the package, run:
+  ${pythonPath} -m pip install ${packageName}`
+      };
+    }
+    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;
+    await this.saveCache({
+      pythonPath,
+      version,
+      lastValidated: new Date().toISOString(),
+      packageName,
+      uipathExePath: this.uipathExePath,
+      packageVersion: this.packageVersion,
+      source
+    });
+    return {
+      success: true,
+      pythonPath,
+      pythonVersion: version,
+      packageInstalled: true,
+      packageVersion: this.packageVersion,
+      uipathExePath: this.uipathExePath,
+      source
+    };
+  }
+  async reuseCache(packageName, virtualEnv) {
+    const fs = getFileSystem();
+    logger.debug("Checking cache...");
+    const cached = await this.loadCache();
+    if (!cached)
+      return null;
+    if (!cached.uipathExePath || !await fs.exists(cached.uipathExePath)) {
+      logger.warn("Cached Python path no longer exists, re-detecting...");
+      return null;
+    }
+    if (virtualEnv && !isPathInside(cached.uipathExePath, virtualEnv)) {
+      logger.warn(`Cached uipath executable ${cached.uipathExePath} is outside the active virtual environment ${virtualEnv}, re-detecting...`);
+      return null;
+    }
+    const pythonPath = cached.pythonPath;
+    const version = cached.version;
+    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;
+    }
+    await this.saveCache({
+      pythonPath,
+      version,
+      lastValidated: new Date().toISOString(),
+      packageName,
+      uipathExePath: this.uipathExePath,
+      packageVersion: this.packageVersion,
+      source
+    });
+    return {
+      success: true,
+      pythonPath,
+      pythonVersion: version,
+      packageInstalled: true,
+      packageVersion: this.packageVersion,
+      uipathExePath: this.uipathExePath,
+      source
+    };
+  }
+  async detectVenvPython(virtualEnv) {
+    const fs = getFileSystem();
+    const isWindows = platform() === "win32";
+    const command = isWindows ? fs.path.join(virtualEnv, "Scripts", "python.exe") : fs.path.join(virtualEnv, "bin", "python");
+    const checkedVersions = [];
+    const searchedCommands = [];
+    const version = await this.checkPythonVersion(command, [], checkedVersions, searchedCommands);
+    if (!version) {
+      return {
+        success: false,
+        error: this.buildNotFoundError(checkedVersions, searchedCommands)
+      };
+    }
+    const metadataPath = await this.findUipathExeFromMetadata(fs, command, []);
+    let uipathExePath = metadataPath;
+    if (!uipathExePath) {
+      const candidate = isWindows ? fs.path.join(virtualEnv, "Scripts", "uipath.exe") : fs.path.join(virtualEnv, "bin", "uipath");
+      logger.debug(`Checking for uipath executable at: ${candidate}`);
+      if (await fs.exists(candidate)) {
+        logger.info(`Found uipath executable at: ${candidate}`);
+        uipathExePath = candidate;
+      } else {
+        logger.error(`uipath executable not found in virtual environment. Checked: ${candidate}`);
+      }
+    }
+    return {
+      success: true,
+      pythonPath: command,
+      version,
+      uipathExePath,
+      source: "venv"
+    };
+  }
+  async checkDormantVenv() {
+    if (process.env.VIRTUAL_ENV) {
+      return null;
+    }
+    const fs = getFileSystem();
+    if (!await fs.exists(fs.path.join(fs.env.cwd(), ".venv"))) {
+      return null;
+    }
+    return {
+      success: false,
+      error: "Found .venv in current directory but no virtual environment is activated.",
+      instructions: process.platform === "win32" ? "Run '.venv\\Scripts\\activate' first, then re-run setup." : "Run 'source .venv/bin/activate' first, then re-run setup."
+    };
+  }
+  async detectPython() {
+    const pythonCommands = this.getDefaultPythonPaths();
+    const checkedVersions = [];
+    const searchedCommands = [];
+    for (const { command, args } of pythonCommands) {
+      const result = await this.checkPythonCommand(command, args, checkedVersions, searchedCommands);
+      if (result)
+        return result;
+    }
+    return {
+      success: false,
+      error: this.buildNotFoundError(checkedVersions, searchedCommands)
+    };
+  }
+  async checkPythonCommand(command, args, checkedVersions, searchedCommands) {
+    const fs = getFileSystem();
+    const version = await this.checkPythonVersion(command, args, checkedVersions, searchedCommands);
+    if (!version)
+      return null;
+    const commandStr = args.length > 0 ? `${command} ${args.join(" ")}` : command;
+    const uipathExePath = await this.findUipathExe(fs, command, args);
+    return {
+      success: true,
+      pythonPath: commandStr,
+      version,
+      uipathExePath,
+      source: "path"
+    };
+  }
+  async checkPythonVersion(command, args, checkedVersions, searchedCommands) {
+    const commandStr = args.length > 0 ? `${command} ${args.join(" ")}` : command;
+    searchedCommands.push(commandStr);
+    logger.debug(`Checking Python command: ${commandStr}`);
+    const versionArgs = [...args, "--version"];
+    const versionProc = spawn2(command, versionArgs, {
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    const stdoutChunks = [];
+    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) => {
+      versionProc.on("exit", (code) => resolve(code ?? 1));
+      versionProc.on("error", (error) => reject(error));
+    }));
+    if (versionError) {
+      logger.debug(`Failed to check ${commandStr}: ${versionError}`);
+      return null;
+    }
+    const output = Buffer.concat(stdoutChunks).toString("utf-8");
+    const stderr = Buffer.concat(stderrChunks).toString("utf-8");
+    logger.debug(`${output.trim()}`);
+    if (stderr.trim()) {
+      logger.debug(`stderr: ${stderr.trim()}`);
+    }
+    if (exitCode !== 0)
+      return null;
+    const version = output.trim().replace("Python ", "");
+    const majorMinor = version.match(/^(\d+\.\d+)/)?.[1];
+    if (majorMinor) {
+      checkedVersions.push(`${version} at ${commandStr}`);
+    }
+    if (!majorMinor || !this.config.allowedVersions.includes(majorMinor)) {
+      logger.info(`Python ${version} at ${commandStr} is not in allowed versions`);
+      return null;
+    }
+    logger.info(`Found valid Python: ${commandStr} - ${version}`);
+    return version;
+  }
+  async findUipathExe(fs, command, args) {
+    const metadataPath = await this.findUipathExeFromMetadata(fs, command, args);
+    if (metadataPath)
+      return metadataPath;
+    const isWindows = platform() === "win32";
+    const candidatePaths = [];
+    const virtualEnv = process.env.VIRTUAL_ENV;
+    if (virtualEnv) {
+      candidatePaths.push(isWindows ? fs.path.join(virtualEnv, "Scripts", "uipath.exe") : fs.path.join(virtualEnv, "bin", "uipath"));
+    }
+    const prefix = await this.getPythonPrefix(command, args);
+    if (prefix) {
+      candidatePaths.push(isWindows ? fs.path.join(prefix, "Scripts", "uipath.exe") : fs.path.join(prefix, "bin", "uipath"));
+    }
+    for (const candidate of candidatePaths) {
+      logger.debug(`Checking for uipath executable at: ${candidate}`);
+      if (await fs.exists(candidate)) {
+        logger.info(`Found uipath executable at: ${candidate}`);
+        return candidate;
+      }
+    }
+    const pathCandidates = this.getPathUipathCandidates(fs, isWindows);
+    for (const candidate of pathCandidates) {
+      logger.debug(`Checking for uipath executable on PATH at: ${candidate}`);
+      if (await fs.exists(candidate)) {
+        logger.info(`Found uipath executable at: ${candidate}`);
+        return candidate;
+      }
+    }
+    const checkedCandidates = [...candidatePaths, ...pathCandidates];
+    logger.error(`uipath executable not found. Checked: ${checkedCandidates.join(", ")}`);
+    return;
+  }
+  async findUipathExeFromMetadata(fs, command, args) {
+    const script = `
+from importlib.metadata import distribution, PackageNotFoundError
+import os
+import sys
+try:
+    d = distribution("uipath")
+except PackageNotFoundError:
+    sys.exit(2)
+for f in d.files or []:
+    if f.name.lower() in ("uipath", "uipath.exe"):
+        print(os.path.normpath(str(f.locate())))
+        sys.exit(0)
+sys.exit(3)
+`;
+    const proc = spawn2(command, [...args, "-c", script], {
+      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 [error, exitCode] = await catchError(new Promise((resolve, reject) => {
+      proc.on("exit", (code) => resolve(code ?? 1));
+      proc.on("error", (err) => reject(err));
+    }));
+    if (error) {
+      logger.debug(`Failed to locate uipath executable: ${error}`);
+      return;
+    }
+    if (exitCode !== 0) {
+      const stderr = Buffer.concat(stderrChunks).toString("utf-8").trim();
+      logger.debug(`uipath executable metadata lookup exited with code ${exitCode}${stderr ? `: ${stderr}` : ""}`);
+      return;
+    }
+    const resolved = Buffer.concat(stdoutChunks).toString("utf-8").trim();
+    if (!resolved) {
+      logger.debug("uipath executable metadata lookup returned empty path");
+      return;
+    }
+    if (!await fs.exists(resolved)) {
+      logger.debug(`uipath executable path from metadata does not exist: ${resolved}`);
+      return;
+    }
+    logger.info(`Found uipath executable at: ${resolved}`);
+    return resolved;
+  }
+  async getPythonPrefix(command, args) {
+    const proc = spawn2(command, [...args, "-c", "import sys; print(sys.prefix)"], {
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    const stdoutChunks = [];
+    proc.stdout.on("data", (chunk) => stdoutChunks.push(chunk));
+    const [error, exitCode] = await catchError(new Promise((resolve, reject) => {
+      proc.on("exit", (code) => resolve(code ?? 1));
+      proc.on("error", (err) => reject(err));
+    }));
+    if (error) {
+      logger.debug(`Failed to locate uipath executable: ${error}`);
+      return;
+    }
+    if (exitCode !== 0)
+      return;
+    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] };
+  }
+  getPathUipathCandidates(fs, isWindows) {
+    const pathValue = process.env.PATH || (isWindows ? process.env.Path : undefined);
+    if (!pathValue)
+      return [];
+    const delimiter = isWindows ? ";" : ":";
+    const pathEntries = pathValue.split(delimiter).map((entry) => entry.trim().replace(/^"|"$/g, "")).filter((entry) => entry.length > 0);
+    const executableNames = isWindows ? this.getWindowsExecutableNames() : ["uipath"];
+    return pathEntries.flatMap((entry) => executableNames.map((name) => fs.path.join(entry, name)));
+  }
+  getWindowsExecutableNames() {
+    const pathExt = process.env.PATHEXT || ".COM;.EXE;.BAT;.CMD";
+    const extensions = pathExt.split(";").map((extension) => extension.trim().toLowerCase()).filter((extension) => extension.length > 0).map((extension) => extension.startsWith(".") ? extension : `.${extension}`);
+    return [
+      "uipath",
+      ...extensions.map((extension) => `uipath${extension}`)
+    ];
+  }
+  buildNotFoundError(checkedVersions, searchedCommands) {
+    let msg = `No compatible Python installation found.
+
+`;
+    msg += `Required versions: ${this.config.allowedVersions.join(", ")}
+`;
+    if (checkedVersions.length > 0) {
+      msg += `
+Found Python installations (incompatible versions):
+`;
+      for (const ver of checkedVersions) {
+        msg += `  - ${ver}
+`;
+      }
+    } else {
+      msg += `
+No Python installations found in PATH or default locations.
+`;
+    }
+    msg += `
+Searched commands (${searchedCommands.length} commands):
+`;
+    const uniqueCommands = [...new Set(searchedCommands)].slice(0, 10);
+    for (const cmd of uniqueCommands) {
+      msg += `  - ${cmd}
+`;
+    }
+    if (searchedCommands.length > 10) {
+      msg += `  ... and ${searchedCommands.length - 10} more
+`;
+    }
+    msg += `
+Please install one of the required Python versions:
+`;
+    msg += `  - Download from: https://www.python.org/downloads/
+`;
+    msg += `  - Or use environment variable: PYTHON_TOOL_PYTHON_VERSIONS=<versions>
+`;
+    return msg;
+  }
+  getDefaultPythonPaths() {
+    const paths = [];
+    const isWindows = platform() === "win32";
+    if (isWindows) {
+      paths.push({ command: "python", args: [] });
+      paths.push({ command: "python3", args: [] });
+      for (const version of this.config.allowedVersions) {
+        paths.push({ command: `python${version}`, args: [] });
+      }
+      for (const version of this.config.allowedVersions) {
+        paths.push({ command: "py", args: [`-${version}`] });
+      }
+      paths.push({ command: "py", args: [] });
+    } else {
+      for (const version of this.config.allowedVersions) {
+        paths.push({ command: `python${version}`, args: [] });
+      }
+      paths.push({ command: "python3", args: [] });
+      paths.push({ command: "python", args: [] });
+    }
+    return paths;
+  }
+  async loadCache() {
+    return readCache(this.cacheFile);
+  }
+  async saveCache(cache) {
+    const fs = getFileSystem();
+    const dir = fs.path.dirname(this.cacheFile);
+    const [mkdirError] = await catchError(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)));
+    if (writeError) {
+      logger.warn(`Failed to save cache: ${writeError}`);
+      return;
+    }
+    logger.info(`Cache saved to ${this.cacheFile}`);
+  }
+}
+function isPathInside(target, root) {
+  const normalize = (value) => {
+    let normalized = value.replace(/\\/g, "/").replace(/\/+$/, "");
+    if (platform() === "win32")
+      normalized = normalized.toLowerCase();
+    return normalized;
+  };
+  const normalizedTarget = normalize(target);
+  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,
+  reportUipathPythonFailure,
+  runUipathPythonCommand,
+  supportsNewTypeOption
+};
+
+//# debugId=C0732B4F0D2C235064756E2164756E21