@uipath/uipath-python-bridge 1.202.0-preview.159 → 1.203.0-preview.160

package/dist/index.js

@@ -7935,7 +7935,7 @@ var UUID_PATTERN = /\b[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{1
 var EMAIL_PATTERN = /\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}\b/g;
 var JWT_PATTERN = /\beyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+/g;
 var LONG_TOKEN_PATTERN = /\b[A-Za-z0-9_-]{40,}\b/g;
-var PADDED_BASE64_PATTERN = /[A-Za-z0-9+/]{16,}={1,2}(?![A-Za-z0-9+/=])/g;
+var PADDED_BASE64_PATTERN = /(?<![A-Za-z0-9+/])[A-Za-z0-9+/]{16,}={1,2}(?![A-Za-z0-9+/=])/g;
 var BASE64_WITH_PLUS_PATTERN = /[A-Za-z0-9+/]{40,}/g;
 var USER_HOME_PATTERN = /(?<![A-Za-z0-9._-])([/\\])(Users|home|Profiles)([/\\])([^/\\]+)/gi;
 var UNC_PATH_PATTERN = /(^|[\s"'<>|=,;([{])(\\\\[^\s"'<>|]+)/g;
@@ -7982,7 +7982,7 @@ var QUOTED_LITERAL_PATTERN = new RegExp([
   `(?<![A-Za-z0-9])"(?:[^\\
 ]|\\.){2,${QUOTED_LITERAL_MAX_SPAN}}?"(?![A-Za-z0-9])`
 ].join("|"), "g");
-var JSON_BODY_PATTERN = /[{[][^{}[\]]*[:,][^{}[\]]*[\]}]/g;
+var JSON_BODY_PATTERN = /[{[][^{}[\]:,]*[:,][^{}[\]]*[\]}]/g;
 var COLLAPSED_BODY = "{…}";
 var COLLAPSED_BODY_MARKER = "\x01body\x01";
 var MAX_BODY_NESTING = 8;
@@ -7997,10 +7997,13 @@ function collapseJsonBodies(text) {
   }
   return out.split(COLLAPSED_BODY_MARKER).join(COLLAPSED_BODY);
 }
-var TRAILING_PROSE_PUNCT = /[.,;:!?)\]}>'"]+$/;
+var TRAILING_PROSE_PUNCT = `.,;:!?)]}>'"`;
 function peelTrailingPunctuation(match) {
-  const trailing = match.match(TRAILING_PROSE_PUNCT)?.[0] ?? "";
-  return trailing ? [match.slice(0, -trailing.length), trailing] : [match, ""];
+  let end = match.length;
+  while (end > 0 && TRAILING_PROSE_PUNCT.includes(match[end - 1])) {
+    end -= 1;
+  }
+  return [match.slice(0, end), match.slice(end)];
 }
 function redactUrl(raw) {
   try {
@@ -8711,7 +8714,8 @@ function readRegistryValue(keyPath, valueName) {
   }
   const [error, output] = catchError(() => execFileSync2("reg", ["query", keyPath, "/v", valueName], {
     encoding: "utf-8",
-    stdio: ["pipe", "pipe", "pipe"]
+    stdio: ["pipe", "pipe", "pipe"],
+    windowsHide: true
   }));
   if (error) {
     return "";
@@ -9207,6 +9211,7 @@ class TelemetryService {
   }
 }
 // ../common/src/timings.ts
+init_src();
 var TIMINGS_ENV_VAR = "UIP_TIMINGS";
 function createStorage2() {
   const [error, mod] = catchError(() => __require("node:async_hooks"));
@@ -9394,28 +9399,32 @@ function isPlainRecord(value) {
   const prototype = Object.getPrototypeOf(value);
   return prototype === Object.prototype || prototype === null;
 }
-function extractPagedRows(value) {
+function splitPagedEnvelope(value) {
   if (Array.isArray(value) || !isPlainRecord(value))
     return null;
-  const entries = Object.values(value);
+  const entries = Object.entries(value);
   if (entries.length === 0)
     return null;
-  let rows = null;
-  let hasScalarSibling = false;
-  for (const entry of entries) {
+  let found = null;
+  const meta = Object.create(null);
+  for (const [key, entry] of entries) {
     if (Array.isArray(entry)) {
-      if (rows !== null)
+      if (found !== null)
         return null;
-      rows = entry;
+      found = { key, rows: entry };
     } else if (entry !== null && typeof entry === "object") {
       return null;
     } else {
-      hasScalarSibling = true;
+      meta[key] = entry;
     }
   }
-  if (rows === null || !hasScalarSibling)
+  if (found === null || Object.keys(meta).length === 0)
     return null;
-  return rows;
+  return { ...found, meta };
+}
+function extractPagedRows(value) {
+  const paged = splitPagedEnvelope(value);
+  return paged === null ? null : paged.rows;
 }
 function toLowerCamelCaseKey(key) {
   if (!key)
@@ -9519,6 +9528,9 @@ function printOutput(data, format = "json", logFn, asciiSafe = false, tableRowSt
       }
       break;
     }
+    case "markdown":
+      logFn(renderMarkdown(data));
+      break;
     default: {
       const hasData = "Data" in data && data.Data != null;
       const pagedRows = hasData ? extractPagedRows(data.Data) : null;
@@ -9543,6 +9555,10 @@ function logOutput(data, format = "json", tableRowStyle) {
   printOutput(data, format, (msg) => sink.writeOut(`${msg}
 `), needsAsciiSafeJson(sink), styleFn);
 }
+var PLUMBING_KEYS = new Set(["code", "log"]);
+function isPlumbingKey(key) {
+  return PLUMBING_KEYS.has(key.toLowerCase());
+}
 function cellToString(val) {
   return val != null && typeof val === "object" ? JSON.stringify(val) : String(val ?? "");
 }
@@ -9558,7 +9574,7 @@ function wrapText(text, width) {
 function printTable(data, logFn, externalLogValue, tableRowStyle) {
   if (data.length === 0)
     return;
-  const keys = Object.keys(data[0]).filter((key) => !["code", "log"].includes(key.toLowerCase()));
+  const keys = Object.keys(data[0]).filter((key) => !isPlumbingKey(key));
   const maxWidths = keys.map((key) => Math.max(key.length, ...data.map((item) => cellToString(item[key]).length)));
   const header = keys.map((key, i) => key.padEnd(maxWidths[i])).join(" | ");
   logFn(header);
@@ -9580,7 +9596,7 @@ function isNonEmptyPlainObject(value) {
 }
 var NESTED_INDENT = "  ";
 function printVerticalTable(data, logFn = console.log, externalLogValue) {
-  const keys = Object.keys(data).filter((key) => !["code", "log"].includes(key.toLowerCase()));
+  const keys = Object.keys(data).filter((key) => !isPlumbingKey(key));
   if (keys.length === 0)
     return;
   const isBlockValue = (value) => isPlainObjectArray(value) || isNonEmptyPlainObject(value);
@@ -9611,7 +9627,7 @@ function printVerticalTable(data, logFn = console.log, externalLogValue) {
 function printResizableTable(data, logFn = console.log, externalLogValue, availableWidth, tableRowStyle) {
   if (data.length === 0)
     return;
-  const keys = Object.keys(data[0]).filter((key) => !["code", "log"].includes(key.toLowerCase()));
+  const keys = Object.keys(data[0]).filter((key) => !isPlumbingKey(key));
   if (keys.length === 0)
     return;
   if (!process.stdout.isTTY) {
@@ -9685,6 +9701,220 @@ function printResizableTable(data, logFn = console.log, externalLogValue, availa
     logFn(`Log: ${externalLogValue}`);
   }
 }
+var MARKDOWN_MAX_CELL = 200;
+var MARKDOWN_MAX_DEPTH = 3;
+function markdownHeading(depth) {
+  return "#".repeat(Math.min(3 + depth, 6));
+}
+var BACKTICK_RUN = /`+/g;
+function fencedBlock(text) {
+  const first = text.trimStart()[0];
+  const language = first === "<" ? "xml" : first === "{" || first === "[" ? "json" : "";
+  const longestRun = Math.max(0, ...Array.from(text.matchAll(BACKTICK_RUN), (match) => match[0].length));
+  const fence = "`".repeat(Math.max(3, longestRun + 1));
+  return `${fence}${language}
+${text}
+${fence}`;
+}
+function collapseNewlineRuns(text) {
+  return text.split(/(\s+)/).map((part, index) => index % 2 === 1 && part.includes(`
+`) ? " " : part).join("");
+}
+function markdownCell(value) {
+  const text = value instanceof Date ? value.toISOString() : cellToString(value);
+  return collapseNewlineRuns(text).replace(/\|/g, "\\|");
+}
+function markdownLabel(key) {
+  return collapseNewlineRuns(key).replace(/[\\`*|]/g, "\\$&");
+}
+function withoutPlumbing(record) {
+  const kept = Object.create(null);
+  for (const [key, value] of Object.entries(record)) {
+    if (!isPlumbingKey(key))
+      kept[key] = value;
+  }
+  return kept;
+}
+function rowsWithoutPlumbing(rows) {
+  return rows.map((row) => isPlainRecord(row) ? withoutPlumbing(row) : row);
+}
+function markdownTable(rows) {
+  const columns = [];
+  const seen = new Set;
+  for (const row of rows) {
+    for (const key of Object.keys(row)) {
+      if (!seen.has(key)) {
+        seen.add(key);
+        columns.push(key);
+      }
+    }
+  }
+  if (columns.length === 0)
+    return null;
+  const cells = rows.map((row) => columns.map((key) => markdownCell(row[key])));
+  if (cells.some((row) => row.some((c) => c.length > MARKDOWN_MAX_CELL))) {
+    return null;
+  }
+  return [
+    `| ${columns.map(markdownLabel).join(" | ")} |`,
+    `| ${columns.map(() => "---").join(" | ")} |`,
+    ...cells.map((row) => `| ${row.join(" | ")} |`)
+  ].join(`
+`);
+}
+function extractMessageSequence(rows) {
+  const messages = [];
+  for (const row of rows) {
+    const message = extractSingleMessage(row);
+    if (message === null)
+      return null;
+    messages.push(message);
+  }
+  return messages.join(`
+
+`);
+}
+function markdownRows(rows, depth) {
+  if (rows.length === 0)
+    return "(none)";
+  if (!isPlainObjectArray(rows)) {
+    return rows.map((item) => `- ${markdownCell(item)}`).join(`
+`);
+  }
+  const prose = extractMessageSequence(rows);
+  if (prose !== null)
+    return prose;
+  const table = markdownTable(rows);
+  if (table !== null)
+    return table;
+  if (depth >= MARKDOWN_MAX_DEPTH) {
+    return fencedBlock(JSON.stringify(rows, null, 2));
+  }
+  return rows.map((row, index) => [
+    `${markdownHeading(depth)} ${index + 1}`,
+    markdownObject(row, depth + 1)
+  ].join(`
+
+`)).join(`
+
+`);
+}
+function markdownObject(obj, depth) {
+  const scalars = [];
+  const blocks = [];
+  for (const [key, value] of Object.entries(obj)) {
+    if (value === undefined)
+      continue;
+    const label = markdownLabel(key);
+    if (Array.isArray(value)) {
+      blocks.push(`${markdownHeading(depth)} ${label}
+
+${markdownRows(value, depth + 1)}`);
+    } else if (isNonEmptyPlainObject(value)) {
+      const nested = depth < MARKDOWN_MAX_DEPTH ? markdownObject(value, depth + 1) : fencedBlock(JSON.stringify(value, null, 2));
+      if (nested !== "") {
+        blocks.push(`${markdownHeading(depth)} ${label}
+
+${nested}`);
+      }
+    } else if (typeof value === "string" && value.includes(`
+`)) {
+      blocks.push(`**${label}:**
+
+${fencedBlock(value)}`);
+    } else {
+      scalars.push(`**${label}:** ${markdownCell(value)}`);
+    }
+  }
+  const sections = scalars.length > 0 ? [scalars.join(`
+`)] : [];
+  sections.push(...blocks);
+  return sections.join(`
+
+`);
+}
+function extractSingleMessage(payload) {
+  if (!isPlainRecord(payload))
+    return null;
+  const keys = Object.keys(payload);
+  if (keys.length !== 1 || keys[0].toLowerCase() !== "message")
+    return null;
+  const value = payload[keys[0]];
+  return typeof value === "string" ? value : null;
+}
+function markdownPayload(payload) {
+  const message = extractSingleMessage(payload);
+  if (message !== null)
+    return message;
+  if (Array.isArray(payload)) {
+    return markdownRows(rowsWithoutPlumbing(payload), 0);
+  }
+  const visible = withoutPlumbing(payload);
+  const paged = splitPagedEnvelope(visible);
+  if (paged !== null) {
+    const meta = markdownObject(paged.meta, 0);
+    const rows = `${markdownHeading(0)} ${markdownLabel(paged.key)}
+
+${markdownRows(rowsWithoutPlumbing(paged.rows), 1)}`;
+    return meta === "" ? rows : `${meta}
+
+${rows}`;
+  }
+  return markdownObject(visible, 0);
+}
+function isPaginationWorthShowing(value) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  const page = value;
+  return page.HasMore === true || typeof page.Offset === "number" && page.Offset > 0;
+}
+function markdownEnvelopeNotes(data) {
+  const envelope = data;
+  const notes = [];
+  const warning = envelope.Warning;
+  if (typeof warning === "string" && warning !== "") {
+    notes.push(`> **Warning:** ${warning}`);
+  }
+  const instructions = envelope.Instructions;
+  if (typeof instructions === "string" && instructions !== "") {
+    notes.push(`> ${instructions}`);
+  }
+  const pagination = envelope.Pagination;
+  if (isPaginationWorthShowing(pagination)) {
+    const body = markdownObject(pagination, 1);
+    if (body !== "") {
+      notes.push(`${markdownHeading(0)} Pagination
+
+${body}`);
+    }
+  }
+  const log = envelope.Log;
+  if (typeof log === "string" && log !== "") {
+    notes.push(`**Log:** ${log}`);
+  }
+  return notes;
+}
+function renderMarkdown(data) {
+  if (data.Result !== RESULTS.Success) {
+    const failure = data;
+    const sections = [`**Failed:** ${failure.Message}`];
+    if (failure.Data != null) {
+      sections.push(markdownPayload(failure.Data));
+    }
+    if (failure.Instructions) {
+      sections.push(`> ${failure.Instructions}`);
+    }
+    return sections.filter((section) => section !== "").join(`
+
+`);
+  }
+  if (!("Data" in data) || data.Data == null) {
+    return markdownObject(withoutPlumbing(data), 0);
+  }
+  return [markdownPayload(data.Data), ...markdownEnvelopeNotes(data)].filter((section) => section !== "").join(`
+
+`);
+}
 function toYaml(data) {
   const codec = getYamlCodec();
   if (!codec) {
@@ -11466,16 +11696,7 @@ var resolveEnvFilePathAsync = async (envFilePath = DEFAULT_ENV_FILENAME, opts) =
     errorMessage: location.source === "absolute" ? `Environment file not found: ${envFilePath}` : `Unable to locate environment file: ${envFilePath}. Run 'uip login' to authenticate.`
   };
 };
-var loadEnvFileAsync = async ({ envPath }) => {
-  const fs7 = getFileSystem();
-  const absolutePath = fs7.path.isAbsolute(envPath) ? envPath : fs7.path.join(fs7.env.cwd(), envPath);
-  if (!await fs7.exists(absolutePath)) {
-    throw new Error(`Environment file not found: ${envPath}`);
-  }
-  const content = await fs7.readFile(absolutePath, "utf-8");
-  if (content === null) {
-    throw new Error(`Environment file not found: ${envPath}`);
-  }
+var parseEnvContent = (content) => {
   const env = {};
   for (const line of content.split(`
 `)) {
@@ -11496,6 +11717,18 @@ var loadEnvFileAsync = async ({ envPath }) => {
   }
   return env;
 };
+var loadEnvFileAsync = async ({ envPath }) => {
+  const fs7 = getFileSystem();
+  const absolutePath = fs7.path.isAbsolute(envPath) ? envPath : fs7.path.join(fs7.env.cwd(), envPath);
+  if (!await fs7.exists(absolutePath)) {
+    throw new Error(`Environment file not found: ${envPath}`);
+  }
+  const content = await fs7.readFile(absolutePath, "utf-8");
+  if (content === null) {
+    throw new Error(`Environment file not found: ${envPath}`);
+  }
+  return parseEnvContent(content);
+};
 var saveEnvFileAsync = async ({
   envPath,
   data,
@@ -12034,6 +12267,8 @@ var getAuthEnv = async (options = {}) => {
   }
   return { authEnv, loginStatus: status };
 };
+// ../auth/src/authProfileDetails.ts
+init_src();
 // ../auth/src/index.ts
 init_constants();
 
@@ -12111,7 +12346,8 @@ var fail = (reason, message, instructions, extras = {}) => ({
 async function runUipathPythonCommand(args, options = {}) {
   const fs7 = getFileSystem();
   const cacheFile = fs7.path.join(fs7.env.homedir(), UIPATH_HOME_DIR, getCacheFileName());
-  const setupHint = `Run 'uip ${options.commandPrefix ?? "codedagent"} setup' first to configure the environment. ` + "If you are using a virtual environment, activate it first.";
+  const setupCommand = `uip ${options.commandPrefix ?? "codedagent"} 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);
@@ -12261,67 +12497,42 @@ class PythonService {
     return result;
   }
   async _setupInternal(packageName, force) {
-    const fs7 = getFileSystem();
-    let pythonPath;
-    let version;
+    const virtualEnv = process.env.VIRTUAL_ENV || undefined;
     if (!force) {
-      logger.debug("Checking cache...");
-      const cached = await this.loadCache();
-      if (cached?.uipathExePath && await fs7.exists(cached.uipathExePath)) {
-        pythonPath = cached.pythonPath;
-        version = cached.version;
-        this.uipathExePath = cached.uipathExePath;
-        logger.info(`Using cached uipath executable: ${this.uipathExePath}`);
-        this.packageVersion = cached.packageVersion;
-        if (!this.packageVersion) {
-          const versionResult2 = await this.getUipathVersion(this.uipathExePath);
-          if ("error" in versionResult2) {
-            return {
-              success: false,
-              pythonPath,
-              pythonVersion: version,
-              packageInstalled: true,
-              error: versionResult2.error
-            };
-          }
-          this.packageVersion = versionResult2.version;
-        }
-        await this.saveCache({
-          pythonPath,
-          version,
-          lastValidated: new Date().toISOString(),
-          packageName,
-          uipathExePath: this.uipathExePath,
-          packageVersion: this.packageVersion
-        });
-        return {
-          success: true,
-          pythonPath,
-          pythonVersion: version,
-          packageInstalled: true,
-          packageVersion: this.packageVersion
-        };
-      } else if (cached) {
-        logger.warn("Cached Python path no longer exists, re-detecting...");
-      }
+      const reused = await this.reuseCache(packageName, virtualEnv);
+      if (reused)
+        return reused;
     }
     logger.info("Checking Python...");
-    const detection = await this.detectPython();
+    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"
       };
     }
-    pythonPath = detection.pythonPath;
-    version = detection.version;
+    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 codedagent setup --force.`
+        };
+      }
       return {
         success: false,
         pythonPath,
         pythonVersion: version,
         packageInstalled: false,
+        source,
         error: `Package '${packageName}' is not installed.
 
 To install the package, run:
@@ -12335,6 +12546,8 @@ To install the package, run:
         pythonPath,
         pythonVersion: version,
         packageInstalled: true,
+        uipathExePath: this.uipathExePath,
+        source,
         error: versionResult.error
       };
     }
@@ -12345,14 +12558,104 @@ To install the package, run:
       lastValidated: new Date().toISOString(),
       packageName,
       uipathExePath: this.uipathExePath,
-      packageVersion: this.packageVersion
+      packageVersion: this.packageVersion,
+      source
     });
     return {
       success: true,
       pythonPath,
       pythonVersion: version,
       packageInstalled: true,
-      packageVersion: this.packageVersion
+      packageVersion: this.packageVersion,
+      uipathExePath: this.uipathExePath,
+      source
+    };
+  }
+  async reuseCache(packageName, virtualEnv) {
+    const fs7 = getFileSystem();
+    logger.debug("Checking cache...");
+    const cached = await this.loadCache();
+    if (!cached)
+      return null;
+    if (!cached.uipathExePath || !await fs7.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 fs7 = getFileSystem();
+    const isWindows = platform2() === "win32";
+    const command = isWindows ? fs7.path.join(virtualEnv, "Scripts", "python.exe") : fs7.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(fs7, command, []);
+    let uipathExePath = metadataPath;
+    if (!uipathExePath) {
+      const candidate = isWindows ? fs7.path.join(virtualEnv, "Scripts", "uipath.exe") : fs7.path.join(virtualEnv, "bin", "uipath");
+      logger.debug(`Checking for uipath executable at: ${candidate}`);
+      if (await fs7.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 detectPython() {
@@ -12371,6 +12674,20 @@ To install the package, run:
   }
   async checkPythonCommand(command, args, checkedVersions, searchedCommands) {
     const fs7 = 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(fs7, 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}`);
@@ -12408,13 +12725,7 @@ To install the package, run:
       return null;
     }
     logger.info(`Found valid Python: ${commandStr} - ${version}`);
-    const uipathExePath = await this.findUipathExe(fs7, command, args);
-    return {
-      success: true,
-      pythonPath: commandStr,
-      version,
-      uipathExePath
-    };
+    return version;
   }
   async findUipathExe(fs7, command, args) {
     const metadataPath = await this.findUipathExeFromMetadata(fs7, command, args);
@@ -12452,6 +12763,7 @@ To install the package, run:
   async findUipathExeFromMetadata(fs7, command, args) {
     const script = `
 from importlib.metadata import distribution, PackageNotFoundError
+import os
 import sys
 try:
     d = distribution("uipath")
@@ -12459,7 +12771,7 @@ except PackageNotFoundError:
     sys.exit(2)
 for f in d.files or []:
     if f.name.lower() in ("uipath", "uipath.exe"):
-        print(str(f.locate()))
+        print(os.path.normpath(str(f.locate())))
         sys.exit(0)
 sys.exit(3)
 `;
@@ -12644,6 +12956,17 @@ Please install one of the required Python versions:
     logger.info(`Cache saved to ${this.cacheFile}`);
   }
 }
+function isPathInside(target, root) {
+  const normalize = (value) => {
+    let normalized = value.replace(/\\/g, "/").replace(/\/+$/, "");
+    if (platform2() === "win32")
+      normalized = normalized.toLowerCase();
+    return normalized;
+  };
+  const normalizedTarget = normalize(target);
+  const normalizedRoot = normalize(root);
+  return normalizedTarget === normalizedRoot || normalizedTarget.startsWith(`${normalizedRoot}/`);
+}
 // src/register.ts
 init_src();
 function createSetupCommand(config) {
@@ -12694,7 +13017,9 @@ Searching for Python installations: ${allowedVersions}`);
           PythonPath: result.pythonPath,
           Package: packageName,
           PackageInstalled: result.packageInstalled ? "Yes" : "No",
-          PackageVersion: result.packageVersion ?? "N/A"
+          PackageVersion: result.packageVersion ?? "N/A",
+          UipathPath: result.uipathExePath,
+          Source: result.source
         }
       });
       processContext.exit(0);
@@ -12740,9 +13065,10 @@ export {
   getAllowedPythonVersions,
   getCacheFileName,
   getPackageName,
+  isPathInside,
   processCommandArgs,
   readCache,
   runUipathPythonCommand
 };
 
-//# debugId=905F4C0FDB5AC82464756E2164756E21
+//# debugId=219233FAB6B0AA4C64756E2164756E21

package/package.json

@@ -1,7 +1,8 @@
 {
     "name": "@uipath/uipath-python-bridge",
+    "author": "UiPath",
     "license": "SEE LICENSE IN LICENSE.txt",
-    "version": "1.202.0-preview.159",
+    "version": "1.203.0-preview.160",
     "description": "Shared Python detection, caching, and CLI bridge for UiPath Python SDK tools.",
     "keywords": [
         "uip",
@@ -24,5 +25,5 @@
     "publishConfig": {
         "registry": "https://registry.npmjs.org/"
     },
-    "gitHead": "a3f23209784c6cec7155e735fa051b48ca49e8d7"
+    "gitHead": "3a42062ba731afca4595ba9aa8a80afc9667528d"
 }