@uipath/rpa-tool 1.202.1 → 1.203.0

package/dist/packager-tool.js

@@ -2058,7 +2058,7 @@ function addSdkUserAgentHeader(headers, userAgent) {
 }
 var package_default = {
   name: "@uipath/packager-orchestrator-client",
-  version: "1.202.0",
+  version: "1.203.0",
   description: "UiPath packager client for Orchestrator package-feed interaction (feed discovery + NuGet source composition)",
   type: "module",
   private: true,
@@ -13093,28 +13093,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)
@@ -13218,6 +13222,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;
@@ -13242,6 +13249,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 ?? "");
 }
@@ -13257,7 +13268,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);
@@ -13279,7 +13290,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);
@@ -13310,7 +13321,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) {
@@ -13384,6 +13395,216 @@ 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 markdownCell(value) {
+  const text = value instanceof Date ? value.toISOString() : cellToString(value);
+  return text.replace(/\s*\n\s*/g, " ").replace(/\|/g, "\\|");
+}
+function markdownLabel(key) {
+  return key.replace(/\s*\n\s*/g, " ").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) {
@@ -14300,6 +14521,7 @@ import { dirname as dirname2, join as join2 } from "node:path";
 
 // src/resolution/paths.ts
 var ROBOT_SUBDIR = "Robot";
+var HELM_DOTNET_MAJOR = 10;
 var HELM_EXE = process.platform === "win32" ? "UiPath.Studio.Helm.exe" : "UiPath.Studio.Helm";
 
 // src/resolution/runtime-arch.ts
@@ -14381,6 +14603,7 @@ import {
 import { homedir as homedir3 } from "node:os";
 import { join as join3 } from "node:path";
 var READY_MARKER = ".ready";
+var PAYLOAD_NOT_SHIPPED = new Set(["System.Activities.ViewModels.dll"]);
 var STALE_LOCK_MS = 5 * 60000;
 var STALE_STAGING_MS = 10 * 60000;
 function resolveHelmCacheRoot() {
@@ -14413,7 +14636,14 @@ function helmSlotIfReady(version, cacheRoot = resolveHelmCacheRoot()) {
 import { join as join4, posix, win32 } from "node:path";
 var ROBOT_WINDOWS_MARKER = "UiRobot.exe";
 var ROBOT_MACOS_MARKER = "UiRobot.dll";
-var MACOS_ASSISTANT_ROBOT_PATH = "/Applications/UiPath Assistant.app/Contents/Robot";
+var MACOS_ASSISTANT_APP = "UiPath Assistant.app";
+var MACOS_CONNECTED_ASSISTANT_SUBDIR = "UiPath Connected/Assistant";
+var MACOS_CONNECTED_CURRENT = "current";
+var MACOS_BUNDLE_ROBOT_SUBDIRS = [
+  "Contents/Resources/assistant/Robot",
+  "Contents/Robot"
+];
+var byVersionDesc = (a, b) => b.localeCompare(a, undefined, { numeric: true });
 var REGISTRY_HIVES = [
   "HKCU\\Software\\UiPath\\UiPath Studio",
   "HKLM\\Software\\UiPath\\UiPath Studio"
@@ -14438,6 +14668,32 @@ function resolveRobotComponentDir(installRoot, deps) {
   const nested = win32.join(installRoot, ROBOT_SUBDIR);
   return deps.fileExists(win32.join(nested, ROBOT_WINDOWS_MARKER)) ? nested : installRoot;
 }
+function* macosRobotDirCandidates(deps) {
+  const home = process.env.HOME;
+  const appRoots = [
+    "/Applications",
+    ...home ? [posix.join(home, "Applications")] : []
+  ];
+  for (const appRoot of appRoots) {
+    const connectedDir = posix.join(appRoot, MACOS_CONNECTED_ASSISTANT_SUBDIR);
+    let versions;
+    try {
+      versions = deps.readDir(connectedDir).filter((entry) => entry !== MACOS_CONNECTED_CURRENT).sort(byVersionDesc);
+    } catch {
+      versions = [];
+    }
+    const bundles = [
+      posix.join(connectedDir, MACOS_CONNECTED_CURRENT, MACOS_ASSISTANT_APP),
+      ...versions.map((version) => posix.join(connectedDir, version, MACOS_ASSISTANT_APP)),
+      posix.join(appRoot, MACOS_ASSISTANT_APP)
+    ];
+    for (const bundle of bundles) {
+      for (const subdir of MACOS_BUNDLE_ROBOT_SUBDIRS) {
+        yield posix.join(bundle, subdir);
+      }
+    }
+  }
+}
 function resolveRobotDir(cliPath, deps) {
   if (cliPath) {
     deps.log(`Using --robot-dir: ${cliPath}`);
@@ -14462,18 +14718,21 @@ function resolveRobotDir(cliPath, deps) {
     }
   }
   if (process.platform === "darwin") {
-    if (deps.fileExists(posix.join(MACOS_ASSISTANT_ROBOT_PATH, ROBOT_MACOS_MARKER))) {
-      deps.log(`Found robot at well-known path: ${MACOS_ASSISTANT_ROBOT_PATH}`);
-      return MACOS_ASSISTANT_ROBOT_PATH;
+    for (const candidate of macosRobotDirCandidates(deps)) {
+      if (deps.fileExists(posix.join(candidate, ROBOT_MACOS_MARKER))) {
+        deps.log(`Found robot at well-known path: ${candidate}`);
+        return candidate;
+      }
     }
   }
   deps.log("Robot dir not resolved — Robot must already be running");
   return null;
 }
 var DOTNET_ROLL_FORWARD_ENV = {
-  DOTNET_ROLL_FORWARD: "Major"
+  DOTNET_ROLL_FORWARD: "LatestMajor"
 };
-var MIN_BUNDLED_DOTNET_MAJOR = 8;
+var DOTNET_ROOT_ARCH_ENV = `DOTNET_ROOT_${process.arch === "ia32" ? "X86" : process.arch.toUpperCase()}`;
+var MIN_BUNDLED_DOTNET_MAJOR = HELM_DOTNET_MAJOR;
 var DOTNET_ROOT_ENV = "UIPATH_DOTNET_ROOT";
 var RUNTIMES_SUBDIR = "Runtimes";
 var dotnetExeName = () => process.platform === "win32" ? "dotnet.exe" : "dotnet";
@@ -14508,7 +14767,7 @@ function* rootsAtOrUnder(dir, deps) {
   } catch {
     return;
   }
-  for (const entry of entries.sort((a, b) => b.localeCompare(a, undefined, { numeric: true }))) {
+  for (const entry of entries.sort(byVersionDesc)) {
     yield layoutPath().join(dir, entry);
   }
 }
@@ -14518,6 +14777,8 @@ function* dotnetRootCandidates(robotDir, deps) {
     deps.log(`Using ${DOTNET_ROOT_ENV}: ${declaredRoot}`);
     yield* rootsAtOrUnder(declaredRoot, deps);
   }
+  if (!robotDir)
+    return;
   if (process.platform !== "win32") {
     yield layoutPath().join(robotDir, "dotnet");
     return;
@@ -14526,8 +14787,6 @@ function* dotnetRootCandidates(robotDir, deps) {
   yield* rootsAtOrUnder(win32.resolve(robotDir, "..", "..", RUNTIMES_SUBDIR), deps);
 }
 function resolveBundledDotnet(robotDir, deps) {
-  if (!robotDir)
-    return;
   for (const dotnetRoot of dotnetRootCandidates(robotDir, deps)) {
     const exePath = layoutPath().join(dotnetRoot, dotnetExeName());
     if (!deps.fileExists(exePath))
@@ -14542,6 +14801,7 @@ function resolveBundledDotnet(robotDir, deps) {
       exePath,
       env: {
         DOTNET_ROOT: dotnetRoot,
+        [DOTNET_ROOT_ARCH_ENV]: dotnetRoot,
         DOTNET_MULTILEVEL_LOOKUP: "0",
         ...DOTNET_ROLL_FORWARD_ENV
       }