@uipath/uipath-python-bridge 0.9.0

package/dist/index.js

@@ -0,0 +1,565 @@
+// src/cache.ts
+import { catchError, logger } from "@uipath/common";
+import { getFileSystem } from "@uipath/filesystem";
+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;
+}
+// src/config.ts
+var DEFAULT_CONFIG = {
+  allowedPythonVersions: ["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: [...args]
+  };
+}
+// src/execute.ts
+import { spawn } from "node:child_process";
+import { getLoginStatusAsync } from "@uipath/auth";
+import {
+  catchError as catchError2,
+  logger as logger2,
+  OutputFormatter,
+  processContext,
+  RESULTS,
+  UIPATH_HOME_DIR
+} from "@uipath/common";
+import { getFileSystem as getFileSystem2 } from "@uipath/filesystem";
+async function buildAuthEnv() {
+  const authEnv = {};
+  const [authError, status] = await catchError2(getLoginStatusAsync());
+  if (authError) {
+    logger2.debug(`Auth unavailable — continuing without credentials: ${authError.message}`);
+    return authEnv;
+  }
+  if (status.loginStatus === "Logged in" && status.accessToken) {
+    authEnv.UIPATH_ACCESS_TOKEN = status.accessToken;
+    if (status.baseUrl) {
+      const org = status.organizationName || status.organizationId;
+      const tenant = status.tenantName || status.tenantId;
+      if (org && tenant) {
+        authEnv.UIPATH_URL = `${status.baseUrl.replace(/\/+$/, "")}/${org}/${tenant}`;
+      }
+    }
+    if (status.organizationId)
+      authEnv.UIPATH_ORGANIZATION_ID = status.organizationId;
+    if (status.organizationName)
+      authEnv.UIPATH_ORGANIZATION_NAME = status.organizationName;
+    if (status.tenantId)
+      authEnv.UIPATH_TENANT_ID = status.tenantId;
+    if (status.tenantName)
+      authEnv.UIPATH_TENANT_NAME = status.tenantName;
+  }
+  return authEnv;
+}
+function createExecuteCommand(config) {
+  const { commandPrefix, telemetryEvent, commandRules } = config;
+  const executeCommand = async (rawArgs, _options) => {
+    const runIndex = rawArgs.indexOf("exec");
+    const actualArgs = runIndex >= 0 ? rawArgs.slice(runIndex + 1) : [];
+    const fs = getFileSystem2();
+    const cacheFile = fs.path.join(fs.env.homedir(), UIPATH_HOME_DIR, getCacheFileName());
+    const setupHint = commandPrefix ? `Run 'uip ${commandPrefix} setup' first to configure environment.` : "Run setup first to configure environment.";
+    const cache = await readCache(cacheFile);
+    if (!cache || !cache.uipathExePath) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: "Python not configured.",
+        Instructions: setupHint
+      });
+      processContext.exit(1);
+      return;
+    }
+    if (!await fs.exists(cache.uipathExePath)) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: "uipath executable not found.",
+        Instructions: setupHint
+      });
+      processContext.exit(1);
+      return;
+    }
+    const processed = processCommandArgs(actualArgs, commandRules);
+    if (!processed.allowed) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: processed.errorMessage || "Command disabled.",
+        Instructions: "Use of --force flag is not recommended. Favor alternate command."
+      });
+      processContext.exit(1);
+      return;
+    }
+    const commandArgs = commandPrefix ? [commandPrefix, ...processed.args] : [...processed.args];
+    const authEnv = await buildAuthEnv();
+    const proc = spawn(cache.uipathExePath, commandArgs, {
+      cwd: fs.env.cwd(),
+      env: {
+        ...process.env,
+        ...authEnv
+      },
+      stdio: "inherit"
+    });
+    const [spawnError] = await catchError2(new Promise((resolve, reject) => {
+      proc.on("exit", (code) => {
+        processContext.exit(code ?? 1);
+        resolve();
+      });
+      proc.on("error", reject);
+    }));
+    if (spawnError) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: spawnError.message,
+        Instructions: setupHint
+      });
+      processContext.exit(1);
+    }
+  };
+  const registerExecCommand = (program) => {
+    program.command("exec", { hidden: true }).description("Execute the uipath package with provided arguments").allowUnknownOption(true).allowExcessArguments(true).trackedAction(processContext, telemetryEvent, async (_options, cmd) => {
+      await executeCommand(["_", "_", "exec", ...cmd.args], {});
+    });
+  };
+  return { executeCommand, registerExecCommand };
+}
+// src/python-service.ts
+import { spawn as spawn2 } from "node:child_process";
+import { platform } from "node:os";
+import { catchError as catchError3, logger as logger3, UIPATH_HOME_DIR as UIPATH_HOME_DIR2 } from "@uipath/common";
+import { getFileSystem as getFileSystem3 } from "@uipath/filesystem";
+class PythonService {
+  cacheFile;
+  config;
+  uipathExePath;
+  constructor(config) {
+    const fs = getFileSystem3();
+    this.config = config;
+    this.cacheFile = config.cacheFile || fs.path.join(fs.env.homedir(), UIPATH_HOME_DIR2, getCacheFileName());
+  }
+  async setup(packageName, force = false) {
+    const [error, result] = await catchError3(this._setupInternal(packageName, force));
+    if (error) {
+      return { success: false, error: error.message };
+    }
+    return result;
+  }
+  async _setupInternal(packageName, force) {
+    const fs = getFileSystem3();
+    let pythonPath;
+    let version;
+    if (!force) {
+      logger3.debug("Checking cache...");
+      const cached = await this.loadCache();
+      if (cached && cached.uipathExePath && await fs.exists(cached.uipathExePath)) {
+        pythonPath = cached.pythonPath;
+        version = cached.version;
+        this.uipathExePath = cached.uipathExePath;
+        logger3.info(`Using cached uipath executable: ${this.uipathExePath}`);
+        await this.saveCache({
+          pythonPath,
+          version,
+          lastValidated: new Date().toISOString(),
+          packageName,
+          uipathExePath: this.uipathExePath
+        });
+        return {
+          success: true,
+          pythonPath,
+          pythonVersion: version,
+          packageInstalled: true
+        };
+      } else if (cached) {
+        logger3.warn("Cached Python path no longer exists, re-detecting...");
+      }
+    }
+    logger3.info("Checking Python...");
+    const detection = await this.detectPython();
+    if (!detection.success || !detection.pythonPath || !detection.version) {
+      return {
+        success: false,
+        error: detection.error || "Failed to detect Python"
+      };
+    }
+    pythonPath = detection.pythonPath;
+    version = detection.version;
+    this.uipathExePath = detection.uipathExePath;
+    if (!this.uipathExePath) {
+      return {
+        success: false,
+        pythonPath,
+        pythonVersion: version,
+        packageInstalled: false,
+        error: `Package '${packageName}' is not installed.
+
+To install the package, run:
+  ${pythonPath} -m pip install ${packageName}`
+      };
+    }
+    await this.saveCache({
+      pythonPath,
+      version,
+      lastValidated: new Date().toISOString(),
+      packageName,
+      uipathExePath: this.uipathExePath
+    });
+    return {
+      success: true,
+      pythonPath,
+      pythonVersion: version,
+      packageInstalled: true
+    };
+  }
+  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 = getFileSystem3();
+    const commandStr = args.length > 0 ? `${command} ${args.join(" ")}` : command;
+    searchedCommands.push(commandStr);
+    logger3.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 catchError3(new Promise((resolve, reject) => {
+      versionProc.on("exit", (code) => resolve(code ?? 1));
+      versionProc.on("error", (error) => reject(error));
+    }));
+    if (versionError) {
+      logger3.debug(`Failed to check ${commandStr}: ${versionError}`);
+      return null;
+    }
+    const output = Buffer.concat(stdoutChunks).toString("utf-8");
+    const stderr = Buffer.concat(stderrChunks).toString("utf-8");
+    logger3.debug(`${output.trim()}`);
+    if (stderr.trim()) {
+      logger3.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)) {
+      logger3.info(`Python ${version} at ${commandStr} is not in allowed versions`);
+      return null;
+    }
+    logger3.info(`Found valid Python: ${commandStr} - ${version}`);
+    const uipathExePath = await this.findUipathExe(fs, command, args);
+    return {
+      success: true,
+      pythonPath: commandStr,
+      version,
+      uipathExePath
+    };
+  }
+  async findUipathExe(fs, command, args) {
+    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 prefixArgs = [...args, "-c", "import sys; print(sys.prefix)"];
+    const prefixProc = spawn2(command, prefixArgs, {
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    const prefixChunks = [];
+    prefixProc.stdout.on("data", (chunk) => prefixChunks.push(chunk));
+    const [prefixError, prefixExitCode] = await catchError3(new Promise((resolve, reject) => {
+      prefixProc.on("exit", (code) => resolve(code ?? 1));
+      prefixProc.on("error", (error) => reject(error));
+    }));
+    if (prefixError) {
+      logger3.debug(`Failed to locate uipath executable: ${prefixError}`);
+    } else if (prefixExitCode === 0) {
+      const prefix = Buffer.concat(prefixChunks).toString("utf-8").trim();
+      candidatePaths.push(isWindows ? fs.path.join(prefix, "Scripts", "uipath.exe") : fs.path.join(prefix, "bin", "uipath"));
+    }
+    for (const candidate of candidatePaths) {
+      logger3.debug(`Checking for uipath executable at: ${candidate}`);
+      if (await fs.exists(candidate)) {
+        logger3.info(`Found uipath executable at: ${candidate}`);
+        return candidate;
+      }
+    }
+    logger3.error(`uipath executable not found. Checked: ${candidatePaths.join(", ")}`);
+    return;
+  }
+  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 = getFileSystem3();
+    const dir = fs.path.dirname(this.cacheFile);
+    const [mkdirError] = await catchError3(fs.mkdir(dir, { recursive: true }));
+    if (mkdirError) {
+      logger3.warn(`Failed to create cache directory: ${mkdirError}`);
+      return;
+    }
+    const [writeError] = await catchError3(fs.writeFile(this.cacheFile, JSON.stringify(cache, null, 2)));
+    if (writeError) {
+      logger3.warn(`Failed to save cache: ${writeError}`);
+      return;
+    }
+    logger3.info(`Cache saved to ${this.cacheFile}`);
+  }
+}
+// src/register.ts
+import {
+  logger as logger4,
+  OutputFormatter as OutputFormatter2,
+  processContext as processContext2,
+  RESULTS as RESULTS2
+} from "@uipath/common";
+import { getFileSystem as getFileSystem4 } from "@uipath/filesystem";
+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(processContext2, config.telemetryEvent, async (options) => {
+      const packageName = config.packageName || getPackageName();
+      const allowedVersions = getAllowedPythonVersions();
+      if (allowedVersions.length === 0) {
+        OutputFormatter2.error({
+          Result: RESULTS2.Failure,
+          Message: "Invalid configuration. Allowed Python list misconfigured.",
+          Instructions: "Check env variable PYTHON_TOOL_PYTHON_VERSIONS"
+        });
+        processContext2.exit(1);
+        return;
+      }
+      const fs = getFileSystem4();
+      const venvPath = fs.path.join(fs.env.cwd(), ".venv");
+      if (await fs.exists(venvPath) && !process.env.VIRTUAL_ENV) {
+        OutputFormatter2.error({
+          Result: RESULTS2.Failure,
+          Message: "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."
+        });
+        processContext2.exit(1);
+        return;
+      }
+      logger4.info(`
+Searching for Python installations: ${allowedVersions}`);
+      const service = new PythonService({
+        allowedVersions,
+        packageName
+      });
+      const result = await service.setup(packageName, options.force);
+      if (!result.success) {
+        OutputFormatter2.error({
+          Result: RESULTS2.Failure,
+          Message: result.error || "Setup failed with no error.",
+          Instructions: result.instructions || ""
+        });
+        processContext2.exit(1);
+        return;
+      }
+      OutputFormatter2.success({
+        Result: RESULTS2.Success,
+        Code: config.successCode,
+        Data: {
+          PythonPath: result.pythonPath,
+          Package: packageName,
+          PackageInstalled: result.packageInstalled ? "Yes" : "No",
+          PackageVersion: result.packageVersion ?? "N/A"
+        }
+      });
+    });
+  };
+}
+function createDefaultAction(config, executeCommand) {
+  return (program) => {
+    program.trackedAction(processContext2, config.defaultTelemetryEvent, async () => {
+      const userArgs = program.args.length > 0 ? program.args : [];
+      const extra = userArgs.length > 0 ? userArgs : ["--help"];
+      await executeCommand(["_", "_", "exec", ...extra], {});
+    });
+  };
+}
+function createHelpCommand(config, executeCommand) {
+  return (program) => {
+    program.command("help").description("Display help for the python tool").trackedAction(processContext2, config.helpTelemetryEvent, 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 {
+  readCache,
+  processCommandArgs,
+  getPackageName,
+  getCacheFileName,
+  getAllowedPythonVersions,
+  createSetupCommand,
+  createHelpCommand,
+  createExecuteCommand,
+  createDefaultAction,
+  createCommandForwarder,
+  PythonService
+};

package/package.json

@@ -0,0 +1,42 @@
+{
+    "name": "@uipath/uipath-python-bridge",
+    "version": "0.9.0",
+    "description": "Shared Python detection, caching, and CLI bridge for UiPath Python SDK tools.",
+    "keywords": [
+        "uip",
+        "python",
+        "bridge"
+    ],
+    "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://registry.npmjs.org/"
+    },
+    "scripts": {
+        "build": "bun build ./src/index.ts --outdir dist --format esm --target node --external commander --external @uipath/common --external @uipath/auth --external @uipath/filesystem",
+        "test": "vitest run",
+        "test:coverage": "vitest run --coverage",
+        "lint": "biome check .",
+        "lint:fix": "biome check --write ."
+    },
+    "devDependencies": {
+        "@uipath/auth": "0.9.0",
+        "@uipath/common": "0.9.0",
+        "@uipath/filesystem": "0.9.0",
+        "@types/bun": "^1.3.9",
+        "commander": "^14.0.3",
+        "typescript": "^5"
+    },
+    "gitHead": "3f1b4d8e9f910be81e4cab956537f21dbd5d63ac"
+}