@uipath/codedagent-tool 0.1.12

package/README.md

@@ -0,0 +1,103 @@
+# Python Tool
+
+A command-line tool over [uipath-python](https://github.com/UiPath/uipath-python)
+
+## Features
+
+- Automatic Python version detection
+- Python path caching for improved performance
+- Package installation verification
+- Interactive command execution support
+
+## Commands
+
+### setup
+
+Detects Python installation and verifies required package is installed.
+
+```bash
+uipath ca setup [options]
+```
+
+Options:
+- `--force` - Force re-detection of Python even if cached
+
+### exec
+
+Executes the configured Python package with provided arguments.
+
+```bash
+uipath ca exec [args...]
+```
+
+Options:
+- `--interactive` - enable interactive mode
+
+All arguments are passed directly to the Python package.
+
+## Configuration
+
+### Static Configuration
+
+The following settings are configured in the code and can be overridden via environment variables:
+
+#### Python Versions
+
+Default: `3.11`, `3.12`, `3.13`
+
+Override with `PYTHON_TOOL_PYTHON_VERSIONS` environment variable:
+
+```bash
+# Windows
+set PYTHON_TOOL_PYTHON_VERSIONS=3.13,3.12,3.11
+
+# Linux/macOS
+export PYTHON_TOOL_PYTHON_VERSIONS=3.13,3.12,3.11
+```
+
+### Cache File
+
+The tool uses a cache file (`.codedagent-tool-cache.json`) to store:
+- Detected Python path
+- Python version
+- Package name
+- Last validation timestamp
+
+If the cached Python path no longer exists, will ask user to configure.
+
+```
+uip codedagent init
+❌ Invalid config. Python (C:\Users\georgescu.vlad\AppData\Local\Programs\Python\Python311\python.exe) no longer exists.
+Run 'uip codedagent setup' to reconfigure.
+```
+
+## Examples
+
+```bash
+# Setup with default package (uipath-python)
+uip codedagent setup
+
+# Force re-detection
+uipath codedagent setup --force
+
+# Setup with custom package via environment variable
+export CLOUD_TOOL_PACKAGE_NAME=my-package
+uipath codedagent setup
+
+# Run package with arguments
+uipath ca run --help
+uipath ca run command --option value
+
+# Interactive command
+uipath ca run interactive-shell
+
+# Override Python versions via environment variable
+export PYTHON_TOOL_PYTHON_VERSIONS=3.10,3.11
+uipath ca setup
+
+# Full configuration example
+export PYTHON_TOOL_PYTHON_VERSIONS=3.10,3.11,3.12
+export CLOUD_TOOL_PACKAGE_NAME=uipath-python
+uipath ca setup
+uipath ca run --version
+```

package/dist/index.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env bun
+// @bun
+
+// src/index.ts
+import { Command } from "commander";
+import { metadata, registerCommands } from "./tool.js";
+var program = new Command;
+program.name(metadata.name).version(metadata.version).description(metadata.description);
+await registerCommands(program);
+program.parse(process.argv);

package/dist/tool.js

@@ -0,0 +1,778 @@
+// package.json
+var package_default = {
+  name: "@uipath/codedagent-tool",
+  version: "0.1.12",
+  description: "Build, run, deploy, and manage AI Agents.",
+  keywords: [
+    "cli-tool",
+    "codedagents",
+    "wrapper"
+  ],
+  type: "module",
+  main: "./dist/tool.js",
+  exports: {
+    ".": "./dist/tool.js"
+  },
+  private: false,
+  maintainers: [
+    "aoltean16",
+    "mihaigirleanu",
+    "vlad-uipath"
+  ],
+  bin: {
+    "codedagent-tool": "./dist/index.js"
+  },
+  files: [
+    "dist"
+  ],
+  repository: {
+    type: "git",
+    url: "https://github.com/UiPath/cli.git",
+    directory: "packages/codedagent-tool"
+  },
+  publishConfig: {
+    registry: "https://npm.pkg.github.com/@uipath"
+  },
+  scripts: {
+    build: "bun ../../tools/build-tool.ts",
+    package: "bun run build && bun pm pack",
+    test: "vitest run",
+    "test:coverage": "vitest run --coverage",
+    lint: "biome check .",
+    "lint:fix": "biome check --write ."
+  },
+  peerDependencies: {
+    commander: "^14.0.3",
+    "@uipath/common": "^0.1.13",
+    "@uipath/auth": "^0.1.9",
+    "@uipath/filesystem": "^0.1.6"
+  },
+  devDependencies: {
+    "@types/bun": "^1.3.9",
+    typescript: "^5"
+  }
+};
+
+// src/commands/command.ts
+import { spawn } from "node:child_process";
+import { getLoginStatusAsync } from "@uipath/auth";
+import {
+  catchError,
+  logger,
+  OutputFormatter,
+  processContext,
+  UIPATH_HOME_DIR
+} from "@uipath/common";
+import { getFileSystem } from "@uipath/filesystem";
+
+// src/config.ts
+var COMMAND_RULES = [
+  {
+    pattern: ["auth"],
+    action: "filter",
+    filterMessage: `The 'auth' command is disabled in the python tool and is not recommended for use.
+To proceed anyway, use the --force flag.`
+  },
+  {
+    pattern: ["pack"],
+    action: "filter",
+    filterMessage: `The 'pack' command is disabled in the python tool and is not recommended for use.
+To proceed anyway, use the --force flag.`
+  },
+  {
+    pattern: ["publish"],
+    action: "filter",
+    filterMessage: `The 'publish' command is disabled in the python tool and is not recommended for use.
+To proceed anyway, use the --force flag.`
+  },
+  {
+    pattern: ["dev"],
+    action: "append",
+    appendArgs: ["--interactive"]
+  }
+];
+var DEFAULT_CONFIG = {
+  allowedPythonVersions: ["3.13", "3.12", "3.11"],
+  packageName: "uipath",
+  cacheFileName: ".codedagent-tool-cache.json"
+};
+function getAllowedPythonVersions() {
+  const envVersions = process.env.PYTHON_TOOL_PYTHON_VERSIONS;
+  if (envVersions) {
+    return envVersions.split(",").map((v) => v.trim());
+  }
+  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 (pattern.length === 0) {
+    return false;
+  }
+  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) {
+  const hasForceFlag = args.includes("--force");
+  const argsWithoutForce = args.filter((arg) => arg !== "--force");
+  for (const rule of COMMAND_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]
+  };
+}
+
+// src/commands/command.ts
+var executeCommand = async (rawArgs, _options) => {
+  const runIndex = rawArgs.indexOf("exec");
+  const actualArgs = runIndex >= 0 ? rawArgs.slice(runIndex + 1) : [];
+  const fs = getFileSystem();
+  const cacheFile = fs.path.join(fs.env.homedir(), UIPATH_HOME_DIR, getCacheFileName());
+  if (!await fs.exists(cacheFile)) {
+    OutputFormatter.error({
+      Result: "ConfigError",
+      Message: "Python not configured.",
+      Instructions: "Run 'uip codedagent setup' first to configure environment."
+    });
+    processContext.exit(1);
+    return;
+  }
+  const [readError, content] = await catchError(fs.readFile(cacheFile, "utf-8"));
+  if (readError || !content) {
+    OutputFormatter.error({
+      Result: "ConfigError",
+      Message: "Invalid configuration file.",
+      Instructions: "Run 'uip codedagent setup' first to configure environment."
+    });
+    processContext.exit(1);
+    return;
+  }
+  const [parseError, cache] = catchError(() => JSON.parse(content));
+  if (parseError) {
+    OutputFormatter.error({
+      Result: "ConfigError",
+      Message: "Invalid configuration file.",
+      Instructions: "Run 'uip codedagent setup' first to configure environment."
+    });
+    processContext.exit(1);
+    return;
+  }
+  if (!cache.uipathExePath || !await fs.exists(cache.uipathExePath)) {
+    OutputFormatter.error({
+      Result: "ConfigError",
+      Message: "uipath executable not found.",
+      Instructions: "Run 'uip codedagent setup' first to configure environment."
+    });
+    processContext.exit(1);
+    return;
+  }
+  const processed = processCommandArgs(actualArgs);
+  if (!processed.allowed) {
+    OutputFormatter.error({
+      Result: "ValidationError",
+      Message: processed.errorMessage || "Command disabled.",
+      Instructions: "Use of --force flag is not recommended. Favor alternate command."
+    });
+    processContext.exit(1);
+    return;
+  }
+  const commandArgs = processed.args.filter((arg) => arg !== "--interactive");
+  const authEnv = {};
+  const [authError, status] = await catchError(getLoginStatusAsync());
+  if (authError) {
+    logger.debug(`Auth unavailable — continuing without credentials: ${authError.message}`);
+  } else 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;
+  }
+  const proc = spawn(cache.uipathExePath, commandArgs, {
+    cwd: process.cwd(),
+    env: {
+      ...process.env,
+      ...authEnv
+    },
+    stdio: "inherit"
+  });
+  const [spawnError] = await catchError(new Promise((_resolve, reject) => {
+    proc.on("exit", (code) => {
+      process.exit(code || 0);
+    });
+    proc.on("error", reject);
+  }));
+  if (spawnError) {
+    OutputFormatter.error({
+      Result: "Failure",
+      Message: spawnError.message,
+      Instructions: spawnError.message
+    });
+    processContext.exit(1);
+  }
+};
+var registerExecCommand = (program) => {
+  program.command("exec", { hidden: true }).description("Execute the ca package with provided arguments").allowUnknownOption(true).allowExcessArguments(true).trackedAction(processContext, async (command) => {
+    const rawArgs = command.parent?.rawArgs || process.argv;
+    await executeCommand(rawArgs, {});
+  });
+};
+
+// src/commands/help.ts
+import { processContext as processContext2 } from "@uipath/common";
+var registerDefaultAction = (program) => {
+  program.trackedAction(processContext2, async () => {
+    const argv = process.argv;
+    const cloudIndex = argv.indexOf("codedagent");
+    if (cloudIndex >= 0) {
+      const afterCloud = argv.slice(cloudIndex + 1);
+      if (afterCloud.length > 0) {
+        const rawArgs = [
+          ...argv.slice(0, cloudIndex + 1),
+          "exec",
+          ...afterCloud
+        ];
+        await executeCommand(rawArgs, {});
+      } else {
+        const rawArgs = [
+          ...argv.slice(0, cloudIndex + 1),
+          "exec",
+          "--help"
+        ];
+        await executeCommand(rawArgs, {});
+      }
+    }
+  });
+};
+var registerHelpCommand = (program) => {
+  program.command("help").description("Display help for the python tool").trackedAction(processContext2, async () => {
+    const argv = process.argv;
+    const cloudIndex = argv.indexOf("codedagent");
+    if (cloudIndex >= 0) {
+      const rawArgs = [
+        ...argv.slice(0, cloudIndex + 1),
+        "exec",
+        "--help"
+      ];
+      await executeCommand(rawArgs, {});
+    }
+  });
+};
+
+// src/commands/setup.ts
+import {
+  catchError as catchError3,
+  logger as logger3,
+  OutputFormatter as OutputFormatter2,
+  processContext as processContext3
+} from "@uipath/common";
+import { getFileSystem as getFileSystem3 } from "@uipath/filesystem";
+
+// src/services/PythonService.ts
+import { spawn as spawn2 } from "node:child_process";
+import { existsSync } from "node:fs";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { platform } from "node:os";
+import { dirname, join } from "node:path";
+import {
+  catchError as catchError2,
+  getOutputSink,
+  logger as logger2,
+  UIPATH_HOME_DIR as UIPATH_HOME_DIR2
+} from "@uipath/common";
+import { getFileSystem as getFileSystem2 } from "@uipath/filesystem";
+class PythonService {
+  cacheFile;
+  config;
+  uipathExePath;
+  constructor(config) {
+    const fs = getFileSystem2();
+    this.config = config;
+    this.cacheFile = config.cacheFile || join(fs.env.homedir(), UIPATH_HOME_DIR2, getCacheFileName());
+  }
+  async setup(packageName, force = false) {
+    const [error, result] = await catchError2(this._setupInner(packageName, force));
+    if (error) {
+      return {
+        success: false,
+        error: error.message
+      };
+    }
+    return result;
+  }
+  async _setupInner(packageName, force) {
+    let pythonPath;
+    let version;
+    if (!force) {
+      logger2.debug("Checking cache...");
+      const cached = await this.loadCache();
+      if (cached && existsSync(cached.pythonPath)) {
+        pythonPath = cached.pythonPath;
+        version = cached.version;
+        this.uipathExePath = cached.uipathExePath;
+        logger2.info(`Using cached Python: ${pythonPath} (${version})`);
+        if (!this.uipathExePath || !existsSync(this.uipathExePath)) {
+          return {
+            success: false,
+            pythonPath,
+            pythonVersion: version,
+            packageInstalled: false,
+            error: `Package '${packageName}' is not installed or executable not found.
+
+To install the package, run:
+  ${pythonPath} -m pip install ${packageName}`
+          };
+        }
+        logger2.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) {
+        logger2.warn("Cached Python path no longer exists, re-detecting...");
+      }
+    }
+    logger2.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 run(options) {
+    const { args, interactive = false } = options;
+    const uipathExePath = options.uipathExePath || this.uipathExePath;
+    if (!uipathExePath || !existsSync(uipathExePath)) {
+      return {
+        success: false,
+        exitCode: 1,
+        error: "uipath executable not found. Please run setup first."
+      };
+    }
+    logger2.info(`Executing: ${uipathExePath} ${args.join(" ")}`);
+    const proc = spawn2(uipathExePath, args, {
+      cwd: process.cwd(),
+      env: process.env,
+      stdio: interactive ? "inherit" : "pipe"
+    });
+    if (!interactive) {
+      const stdoutChunks = [];
+      const stderrChunks = [];
+      const sink = getOutputSink();
+      proc.stdout?.on("data", (chunk) => {
+        stdoutChunks.push(chunk);
+        sink.writeOut(chunk.toString());
+      });
+      proc.stderr?.on("data", (chunk) => {
+        stderrChunks.push(chunk);
+        sink.writeErr(chunk.toString());
+      });
+    }
+    const [error, exitCode] = await catchError2(new Promise((resolve, reject) => {
+      proc.on("exit", (code) => resolve(code || 0));
+      proc.on("error", (error2) => reject(error2));
+    }));
+    if (error) {
+      return {
+        success: false,
+        exitCode: 1,
+        error: error.message
+      };
+    }
+    return {
+      success: exitCode === 0,
+      exitCode
+    };
+  }
+  async detectPython() {
+    const pythonCommands = this.getDefaultPythonPaths();
+    const checkedVersions = [];
+    const searchedCommands = [];
+    for (const { command, args } of pythonCommands) {
+      const commandStr = args.length > 0 ? `${command} ${args.join(" ")}` : command;
+      const [outerError, detectionResult] = await catchError2((async () => {
+        searchedCommands.push(commandStr);
+        logger2.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 exitCode = await new Promise((resolve, reject) => {
+          versionProc.on("exit", (code) => resolve(code || 0));
+          versionProc.on("error", (error) => reject(error));
+        });
+        const output = Buffer.concat([
+          ...stdoutChunks,
+          ...stderrChunks
+        ]).toString("utf-8");
+        logger2.debug(`${output.trim()}`);
+        if (exitCode === 0) {
+          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)) {
+            logger2.info(`Found valid Python: ${commandStr} - ${version}`);
+            const pythonPath = commandStr;
+            let uipathExePath;
+            const [locateError] = await catchError2((async () => {
+              const isWindows = platform() === "win32";
+              const candidatePaths = [];
+              const virtualEnv = process.env.VIRTUAL_ENV;
+              if (virtualEnv) {
+                const venvUipathPath = isWindows ? join(virtualEnv, "Scripts", "uipath.exe") : join(virtualEnv, "bin", "uipath");
+                candidatePaths.push(venvUipathPath);
+              }
+              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 prefixExitCode = await new Promise((resolve, reject) => {
+                prefixProc.on("exit", (code) => resolve(code || 0));
+                prefixProc.on("error", (error) => reject(error));
+              });
+              if (prefixExitCode === 0) {
+                const prefix = Buffer.concat(prefixChunks).toString("utf-8").trim();
+                const prefixUipathPath = isWindows ? join(prefix, "Scripts", "uipath.exe") : join(prefix, "bin", "uipath");
+                candidatePaths.push(prefixUipathPath);
+              }
+              for (const candidate of candidatePaths) {
+                logger2.debug(`Checking for uipath executable at: ${candidate}`);
+                if (existsSync(candidate)) {
+                  uipathExePath = candidate;
+                  logger2.info(`Found uipath executable at: ${uipathExePath}`);
+                  break;
+                }
+              }
+              if (!uipathExePath) {
+                logger2.error(`uipath executable not found. Checked: ${candidatePaths.join(", ")}`);
+              }
+            })());
+            if (locateError) {
+              logger2.debug(`Failed to locate uipath executable: ${locateError}`);
+            }
+            return {
+              success: true,
+              pythonPath,
+              version,
+              uipathExePath
+            };
+          } else {
+            logger2.info(`Python ${version} at ${commandStr} is not in allowed versions`);
+          }
+        }
+        return;
+      })());
+      if (outerError) {
+        logger2.debug(`Failed to check ${commandStr}: ${outerError}`);
+        continue;
+      }
+      if (detectionResult) {
+        return detectionResult;
+      }
+    }
+    let errorMessage = `No compatible Python installation found.
+
+`;
+    errorMessage += `Required versions: ${this.config.allowedVersions.join(", ")}
+`;
+    if (checkedVersions.length > 0) {
+      errorMessage += `
+Found Python installations (incompatible versions):
+`;
+      for (const ver of checkedVersions) {
+        errorMessage += `  - ${ver}
+`;
+      }
+    } else {
+      errorMessage += `
+No Python installations found in PATH or default locations.
+`;
+    }
+    errorMessage += `
+Searched commands (${searchedCommands.length} commands):
+`;
+    const uniqueCommands = [...new Set(searchedCommands)].slice(0, 10);
+    for (const cmd of uniqueCommands) {
+      errorMessage += `  - ${cmd}
+`;
+    }
+    if (searchedCommands.length > 10) {
+      errorMessage += `  ... and ${searchedCommands.length - 10} more
+`;
+    }
+    errorMessage += `
+Please install one of the required Python versions:
+`;
+    errorMessage += `  - Download from: https://www.python.org/downloads/
+`;
+    errorMessage += `  - Or use environment variable: PYTHON_TOOL_PYTHON_VERSIONS=<versions>
+`;
+    return {
+      success: false,
+      error: errorMessage
+    };
+  }
+  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() {
+    if (!existsSync(this.cacheFile)) {
+      return null;
+    }
+    const [error, content] = await catchError2(readFile(this.cacheFile, "utf-8"));
+    if (error) {
+      logger2.warn(`Failed to load cache: ${error}`);
+      return null;
+    }
+    const [parseError, parsed] = catchError2(() => JSON.parse(content));
+    if (parseError) {
+      logger2.warn(`Failed to load cache: ${parseError}`);
+      return null;
+    }
+    return parsed;
+  }
+  async saveCache(cache) {
+    const [error] = await catchError2((async () => {
+      const dir = dirname(this.cacheFile);
+      await mkdir(dir, { recursive: true });
+      await writeFile(this.cacheFile, JSON.stringify(cache, null, 2), "utf-8");
+      logger2.info(`Cache saved to ${this.cacheFile}`);
+    })());
+    if (error) {
+      logger2.warn(`Failed to save cache: ${error}`);
+    }
+  }
+  async getCachedPython() {
+    const cache = await this.loadCache();
+    if (cache && existsSync(cache.pythonPath)) {
+      return cache.pythonPath;
+    }
+    return null;
+  }
+}
+
+// src/commands/setup.ts
+var registerSetupCommand = (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(processContext3, async (options) => {
+    const packageName = getPackageName();
+    const allowedVersions = getAllowedPythonVersions();
+    if (allowedVersions.length === 0) {
+      OutputFormatter2.error({
+        Result: "Failure",
+        Message: "Invalid configuration. Allowed python list missconfigured.",
+        Instructions: "Check env variable PYTHON_TOOL_PYTHON_VERSIONS"
+      });
+      processContext3.exit(1);
+      return;
+    }
+    const fs = getFileSystem3();
+    const venvPath = fs.path.join(fs.env.cwd(), ".venv");
+    if (await fs.exists(venvPath) && !process.env.VIRTUAL_ENV) {
+      OutputFormatter2.error({
+        Result: "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."
+      });
+      processContext3.exit(1);
+      return;
+    }
+    logger3.info(`
+Searching for python instalations: ${allowedVersions}`);
+    const service = new PythonService({
+      allowedVersions,
+      packageName
+    });
+    const [error, result] = await catchError3(service.setup(packageName, options.force));
+    if (error) {
+      OutputFormatter2.error({
+        Result: "Failure",
+        Message: error.message,
+        Instructions: error.message
+      });
+      processContext3.exit(1);
+      return;
+    }
+    if (!result.success) {
+      OutputFormatter2.error({
+        Result: "Failure",
+        Message: result.error || "Setup failed with no error.",
+        Instructions: result.instructions || ""
+      });
+      processContext3.exit(1);
+      return;
+    }
+    OutputFormatter2.success({
+      Result: "Success",
+      Code: "CodedAgentsSetup",
+      Data: {
+        PythonPath: result.pythonPath,
+        Package: packageName,
+        PackageInstalled: result.packageInstalled ? "Yes" : "No",
+        PackageVersion: result.packageVersion ?? "N/A"
+      }
+    });
+  });
+};
+
+// src/tool.ts
+var metadata = {
+  name: "codedagent-tool",
+  version: package_default.version,
+  description: "Build, run, deploy, and manage AI Agents.",
+  commandPrefix: "codedagent"
+};
+var registerCommands = async (program) => {
+  program.allowUnknownOption(true);
+  program.allowExcessArguments(true);
+  program.helpOption(false);
+  registerDefaultAction(program);
+  registerSetupCommand(program);
+  registerExecCommand(program);
+  registerHelpCommand(program);
+  program.on("command:*", async (operands) => {
+    const unknownCommand = operands[0];
+    const knownCommands = ["setup", "exec", "help"];
+    if (!knownCommands.includes(unknownCommand)) {
+      const argv = process.argv;
+      const cloudIndex = argv.indexOf("codedagent");
+      if (cloudIndex >= 0) {
+        const afterCloud = argv.slice(cloudIndex + 1);
+        const rawArgs = [
+          ...argv.slice(0, cloudIndex + 1),
+          "exec",
+          ...afterCloud
+        ];
+        await executeCommand(rawArgs, { format: "table" });
+      }
+    }
+  });
+  program.showHelpAfterError(false);
+};
+export {
+  registerCommands,
+  metadata
+};

package/package.json

@@ -0,0 +1,53 @@
+{
+    "name": "@uipath/codedagent-tool",
+    "version": "0.1.12",
+    "description": "Build, run, deploy, and manage AI Agents.",
+    "keywords": [
+        "cli-tool",
+        "codedagents",
+        "wrapper"
+    ],
+    "type": "module",
+    "main": "./dist/tool.js",
+    "exports": {
+        ".": "./dist/tool.js"
+    },
+    "private": false,
+    "maintainers": [
+        "aoltean16",
+        "mihaigirleanu",
+        "vlad-uipath"
+    ],
+    "bin": {
+        "codedagent-tool": "./dist/index.js"
+    },
+    "files": [
+        "dist"
+    ],
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/UiPath/cli.git",
+        "directory": "packages/codedagent-tool"
+    },
+    "publishConfig": {
+        "registry": "https://registry.npmjs.org/"
+    },
+    "scripts": {
+        "build": "bun ../../tools/build-tool.ts",
+        "package": "bun run build && bun pm pack",
+        "test": "vitest run",
+        "test:coverage": "vitest run --coverage",
+        "lint": "biome check .",
+        "lint:fix": "biome check --write ."
+    },
+    "peerDependencies": {
+        "commander": "^14.0.3",
+        "@uipath/common": "^0.1.13",
+        "@uipath/auth": "^0.1.9",
+        "@uipath/filesystem": "^0.1.6"
+    },
+    "devDependencies": {
+        "@types/bun": "^1.3.9",
+        "typescript": "^5"
+    }
+}