@uipath/common 0.1.8 → 0.1.10

package/dist/index.js

@@ -11,6 +11,12 @@ function catchError(fnOrPromise) {
   }
   try {
     const result = fnOrPromise();
+    if (result instanceof Promise) {
+      return result.then((data) => [undefined, data]).catch((error) => [
+        error instanceof Error ? error : new Error(String(error)),
+        undefined
+      ]);
+    }
     return [undefined, result];
   } catch (error) {
     return [
@@ -4651,10 +4657,8 @@ import { dirname } from "node:path";
 
 // src/output-context.ts
 function createStorage() {
-  try {
-    const { AsyncLocalStorage } = __require("node:async_hooks");
-    return new AsyncLocalStorage;
-  } catch {
+  const [error, mod2] = catchError(() => __require("node:async_hooks"));
+  if (error) {
     return {
       getStore: () => {
         return;
@@ -4662,6 +4666,7 @@ function createStorage() {
       run: (_store, fn) => fn()
     };
   }
+  return new mod2.AsyncLocalStorage;
 }
 var outputStorage = createStorage();
 var globalSink;
@@ -4724,13 +4729,19 @@ class SimpleLogger {
   static isNode = typeof process !== "undefined" && !!process.versions?.node;
   static resolveLevel() {
     if (SimpleLogger.isNode) {
-      return SimpleLogger.parseLevel(process.env?.UIPCLI_LOG_LEVEL ?? "") ?? (process.env?.DEBUG ? 0 /* DEBUG */ : DEFAULT_LOG_LEVEL);
-    }
-    try {
-      if (typeof localStorage !== "undefined" && localStorage.getItem("debug")) {
+      const explicitLevel = SimpleLogger.parseLevel(process.env?.UIPCLI_LOG_LEVEL ?? "");
+      if (explicitLevel !== undefined)
+        return explicitLevel;
+      const debugVal = process.env?.DEBUG;
+      if (debugVal === "true" || debugVal === "1") {
         return 0 /* DEBUG */;
       }
-    } catch {}
+      return DEFAULT_LOG_LEVEL;
+    }
+    const [localStorageError, hasDebug] = catchError(() => typeof localStorage !== "undefined" && !!localStorage.getItem("debug"));
+    if (!localStorageError && hasDebug) {
+      return 0 /* DEBUG */;
+    }
     return DEFAULT_LOG_LEVEL;
   }
   static parseLevel(value) {
@@ -4761,10 +4772,8 @@ class SimpleLogger {
     const path = this.logFilePath || getGlobalLogFilePath();
     if (!path)
       return;
-    try {
-      const timestamp2 = new Date().toISOString();
-      appendFileSync(path, `${timestamp2} ${formatted}`);
-    } catch {}
+    const timestamp2 = new Date().toISOString();
+    catchError(() => appendFileSync(path, `${timestamp2} ${formatted}`));
   }
   debug(message, ...args) {
     if (this.level > 0 /* DEBUG */)
@@ -4824,13 +4833,11 @@ class SimpleLogger {
     setGlobalLogFilePath(path);
     if (!path)
       return;
-    try {
+    const [error] = catchError(() => {
       mkdirSync(dirname(path), { recursive: true });
       writeFileSync(path, "");
-      this.fileLoggingEnabled = true;
-    } catch {
-      this.fileLoggingEnabled = false;
-    }
+    });
+    this.fileLoggingEnabled = !error;
   }
   getLogFilePath() {
     return this.logFilePath || getGlobalLogFilePath();
@@ -4896,137 +4903,8 @@ function getOutputFilter() {
   return currentFilter;
 }
 
-// ../../node_modules/@uipath/telemetry/dist/node.js
-import { AsyncLocalStorage } from "async_hooks";
-function node_context_storage_define_property(obj, key, value) {
-  if (key in obj)
-    Object.defineProperty(obj, key, {
-      value,
-      enumerable: true,
-      configurable: true,
-      writable: true
-    });
-  else
-    obj[key] = value;
-  return obj;
-}
-
-class NodeContextStorage {
-  run(context, fn) {
-    return this.storage.run(context, fn);
-  }
-  getContext() {
-    return this.storage.getStore();
-  }
-  constructor() {
-    node_context_storage_define_property(this, "storage", new AsyncLocalStorage);
-  }
-}
-function telemetry_service_define_property(obj, key, value) {
-  if (key in obj)
-    Object.defineProperty(obj, key, {
-      value,
-      enumerable: true,
-      configurable: true,
-      writable: true
-    });
-  else
-    obj[key] = value;
-  return obj;
-}
-
-class TelemetryService {
-  setOperationId(operationId) {
-    this.operationId = operationId;
-  }
-  setProvider(provider) {
-    this.telemetryProvider = provider;
-  }
-  setDefaultProperties(properties) {
-    this.defaultProperties = properties;
-  }
-  trackEvent(name, properties) {
-    const context = this.getCurrentContext();
-    const enrichedProperties = this.enrichPropertiesWithContext(properties, context);
-    this.telemetryProvider.trackEvent(name, enrichedProperties);
-  }
-  trackException(error, properties) {
-    const context = this.getCurrentContext();
-    const enrichedProperties = this.enrichPropertiesWithContext(properties, context);
-    this.telemetryProvider.trackException(error, enrichedProperties);
-  }
-  async trackRequest(name, fn, properties) {
-    const context = {
-      operationId: this.operationId ?? this.generateId(),
-      id: this.generateId()
-    };
-    const startTime = performance.now();
-    try {
-      const result = await this.contextStorage.run(context, fn);
-      const durationMs = performance.now() - startTime;
-      const enrichedProperties = this.enrichPropertiesWithContext(properties, context);
-      await this.telemetryProvider.trackRequest(name, durationMs, true, enrichedProperties);
-      return result;
-    } catch (error) {
-      const durationMs = performance.now() - startTime;
-      const err = error instanceof Error ? error : new Error(String(error));
-      const enrichedProperties = this.enrichPropertiesWithContext({
-        ...properties,
-        errorMessage: err.message
-      }, context);
-      await this.telemetryProvider.trackRequest(name, durationMs, false, enrichedProperties);
-      throw error;
-    }
-  }
-  async trackDependencyOperation(name, type2, fn, properties) {
-    const parentContext = this.getCurrentContext();
-    if (!parentContext)
-      throw new Error("trackDependencyOperation must be called within a trackRequest block.");
-    const childContext = {
-      operationId: parentContext.operationId,
-      parentId: parentContext.id,
-      id: this.generateId()
-    };
-    const startTime = performance.now();
-    try {
-      const result = await this.contextStorage.run(childContext, fn);
-      const durationMs = performance.now() - startTime;
-      const enrichedProperties = this.enrichPropertiesWithContext(properties, childContext);
-      await this.telemetryProvider.trackDependency(name, type2, durationMs, true, enrichedProperties);
-      return result;
-    } catch (error) {
-      const durationMs = performance.now() - startTime;
-      const err = error instanceof Error ? error : new Error(String(error));
-      const enrichedProperties = this.enrichPropertiesWithContext({
-        ...properties,
-        errorMessage: err.message
-      }, childContext);
-      await this.telemetryProvider.trackDependency(name, type2, durationMs, false, enrichedProperties);
-      throw error;
-    }
-  }
-  getCurrentContext() {
-    return this.contextStorage.getContext();
-  }
-  enrichPropertiesWithContext(properties, context) {
-    return {
-      ...this.defaultProperties,
-      ...properties,
-      ...context
-    };
-  }
-  generateId() {
-    return crypto.randomUUID().replaceAll("-", "");
-  }
-  constructor(telemetryProvider, contextStorage) {
-    telemetry_service_define_property(this, "telemetryProvider", undefined);
-    telemetry_service_define_property(this, "contextStorage", undefined);
-    telemetry_service_define_property(this, "operationId", undefined);
-    telemetry_service_define_property(this, "defaultProperties", undefined);
-    this.telemetryProvider = telemetryProvider;
-    this.contextStorage = contextStorage;
-  }
-}
+// src/telemetry.ts
+import { NodeContextStorage, TelemetryService } from "@uipath/telemetry/node";
 
 // src/registry.ts
 import { execFileSync } from "node:child_process";
@@ -5034,16 +4912,15 @@ function readRegistryValue(keyPath, valueName) {
   if (process.platform !== "win32") {
     return "";
   }
-  try {
-    const output = execFileSync("reg", ["query", keyPath, "/v", valueName], {
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"]
-    });
-    const match = output.match(new RegExp(`${valueName}\\s+REG_SZ\\s+(.+)`));
-    return match?.[1]?.trim() ?? "";
-  } catch {
+  const [error, output] = catchError(() => execFileSync("reg", ["query", keyPath, "/v", valueName], {
+    encoding: "utf-8",
+    stdio: ["pipe", "pipe", "pipe"]
+  }));
+  if (error) {
     return "";
   }
+  const match = output.match(new RegExp(`${valueName}\\s+REG_SZ\\s+(.+)`));
+  return match?.[1]?.trim() ?? "";
 }
 
 // src/logger-telemetry-provider.ts
@@ -5059,7 +4936,7 @@ class LoggerTelemetryProvider {
     };
   }
   async trackEvent(eventName, properties) {
-    logger.info(formatMessage("Event", eventName, this.enrich(properties)));
+    logger.debug(formatMessage("Event", eventName, this.enrich(properties)));
   }
   async trackException(error, properties) {
     logger.error(formatMessage("Exception", error.message, this.enrich({
@@ -5068,7 +4945,7 @@ class LoggerTelemetryProvider {
     })));
   }
   async trackRequest(name, duration, success, properties) {
-    logger.info(formatMessage("Request", name, this.enrich({
+    logger.debug(formatMessage("Request", name, this.enrich({
       ...properties,
       duration: `${duration}ms`,
       success
@@ -5108,7 +4985,12 @@ function getGlobalTelemetryProperties() {
   return globalThis[GLOBAL_TELEMETRY_PROPS_KEY];
 }
 async function loadApplicationInsights() {
+  const savedDebug = process.env.DEBUG;
+  delete process.env.DEBUG;
   const [error, mod2] = await catchError(import("applicationinsights"));
+  if (savedDebug !== undefined) {
+    process.env.DEBUG = savedDebug;
+  }
   if (error) {
     logger.warn(`[Telemetry] applicationinsights package not available: ${error.message}. Telemetry will use logger fallback.`);
     return;
@@ -5157,13 +5039,11 @@ class NodeAppInsightsTelemetryProvider {
     if (!client)
       return;
     const merged = this.mergeProperties(properties);
-    logger.debug(`[AppInsights] trackEvent: ${eventName}`, merged ? JSON.stringify(merged) : "");
-    try {
-      client.trackEvent({
-        name: eventName,
-        properties: merged
-      });
-    } catch {
+    const [error] = catchError(() => client.trackEvent({
+      name: eventName,
+      properties: merged
+    }));
+    if (error) {
       logger.debug(`[AppInsights] trackEvent failed for: ${eventName}`);
     }
   }
@@ -5172,13 +5052,11 @@ class NodeAppInsightsTelemetryProvider {
     if (!client)
       return;
     const merged = this.mergeProperties(properties);
-    logger.debug(`[AppInsights] trackException: ${error.message}`, merged ?? "");
-    try {
-      client.trackException({
-        exception: error,
-        properties: merged
-      });
-    } catch {
+    const [trackError] = catchError(() => client.trackException({
+      exception: error,
+      properties: merged
+    }));
+    if (trackError) {
       logger.debug(`[AppInsights] trackException failed for: ${error.message}`);
     }
   }
@@ -5187,7 +5065,6 @@ class NodeAppInsightsTelemetryProvider {
     if (!client)
       return;
     const merged = this.mergeProperties(properties);
-    logger.debug(`[AppInsights] trackRequest: ${name} duration=${duration}ms success=${success}`, merged ?? "");
     client.trackRequest({
       name,
       url: name,
@@ -5202,14 +5079,12 @@ class NodeAppInsightsTelemetryProvider {
     if (!client)
       return;
     const merged = this.mergeProperties(properties);
-    logger.debug(`[AppInsights] trackDependency: ${name} type=${type2} duration=${duration}ms success=${success}`, merged ?? "");
     client.trackDependency({
       name,
       dependencyTypeName: type2,
       duration,
       resultCode: success ? "200" : "500",
       success,
-      data: name,
       properties: merged
     });
   }
@@ -5219,7 +5094,6 @@ class NodeAppInsightsTelemetryProvider {
       logger.warn(`[AppInsights] flush error (non-fatal): nil client`);
       return;
     }
-    logger.debug("[AppInsights] flush: sending buffered telemetry to cloud");
     const [error] = await catchError(new Promise((resolve, reject) => {
       client.flush({
         callback: (response) => {
@@ -5355,12 +5229,9 @@ async function telemetryInit(defaultProperties) {
   setGlobalTelemetryProperties({ sessionId, ...defaultProperties });
   telemetry.setDefaultProperties({ sessionId, ...defaultProperties });
   const isAppInsights = providerName === "NodeAppInsightsTelemetryProvider";
-  if (isAppInsights) {
-    logger.debug("[Telemetry] initialized successfully with AppInsights provider");
-  } else {
+  if (!isAppInsights) {
     logger.debug(`[Telemetry] initialized with fallback provider (${providerName}). applicationinsights package not available.`);
   }
-  logger.debug(`[Telemetry] sessionId=${sessionId}`);
 }
 var FLUSH_SHUTDOWN_TIMEOUT_MS = 5000;
 async function telemetryFlushAndShutdown() {
@@ -5371,13 +5242,7 @@ async function telemetryFlushAndShutdown() {
       timer = setTimeout(() => resolve("timeout"), FLUSH_SHUTDOWN_TIMEOUT_MS);
     });
     const result = await Promise.race([
-      provider.flush().then(() => {
-        logger.debug("[Telemetry] flush complete");
-        return provider.shutdown();
-      }).then(() => {
-        logger.debug("[Telemetry] shutdown complete");
-        return "done";
-      }),
+      provider.flush().then(() => provider.shutdown()).then(() => "done"),
       timeout
     ]);
     if (timer)
@@ -5425,7 +5290,7 @@ class FailureOutput {
     }
   }
 }
-function printOutput(data, format = "table", logFn = console.log) {
+function printOutput(data, format = "table", logFn) {
   if (!data) {
     logFn("Empty response object. No data to display.");
     return;
@@ -5444,8 +5309,6 @@ function printOutput(data, format = "table", logFn = console.log) {
           const values = Object.values(item).map((v) => v ?? "").join("\t");
           logFn(values);
         });
-      } else if ("Message" in data && !("Result" in data)) {
-        logFn(data.Message);
       } else {
         const values = Object.values(data).map((v) => v ?? "").join("\t");
         logFn(values);
@@ -5454,11 +5317,12 @@ function printOutput(data, format = "table", logFn = console.log) {
     }
     default: {
       if ("Data" in data && data.Data != null) {
-        const items = Array.isArray(data.Data) ? data.Data : [data.Data];
-        const logValue = "Log" in data ? data.Log : undefined;
-        printTable(items, logFn, logValue);
-      } else if ("Message" in data && !("Result" in data)) {
-        logFn(data.Message);
+        const logValue = data.Log;
+        if (Array.isArray(data.Data)) {
+          printResizableTable(data.Data, logFn, logValue);
+        } else {
+          printVerticalTable(data.Data, logFn, logValue);
+        }
       } else {
         printTable([{ ...data }], logFn);
       }
@@ -5471,11 +5335,22 @@ function logOutput(data, format = "table") {
   printOutput(data, format, (msg) => sink.writeOut(`${msg}
 `));
 }
-function printTable(data, logFn = console.log, externalLogValue) {
+function cellToString(val) {
+  return val != null && typeof val === "object" ? JSON.stringify(val) : String(val ?? "");
+}
+function wrapText(text, width) {
+  if (text.length <= width)
+    return [text];
+  const lines = [];
+  for (let pos = 0;pos < text.length; pos += width) {
+    lines.push(text.substring(pos, pos + width));
+  }
+  return lines;
+}
+function printTable(data, logFn, externalLogValue) {
   if (data.length === 0)
     return;
   const keys = Object.keys(data[0]).filter((key) => key !== "Code" && key !== "Log");
-  const cellToString = (val) => val != null && typeof val === "object" ? JSON.stringify(val) : String(val ?? "");
   const maxWidths = keys.map((key) => Math.max(key.length, ...data.map((item) => cellToString(item[key]).length)));
   const header = keys.map((key, i2) => key.padEnd(maxWidths[i2])).join(" | ");
   logFn(header);
@@ -5489,6 +5364,96 @@ function printTable(data, logFn = console.log, externalLogValue) {
     logFn(`Log: ${externalLogValue}`);
   }
 }
+function printVerticalTable(data, logFn = console.log, externalLogValue) {
+  const keys = Object.keys(data).filter((key) => key !== "Code" && key !== "Log");
+  if (keys.length === 0)
+    return;
+  const maxKeyWidth = Math.max(...keys.map((key) => key.length));
+  keys.forEach((key) => {
+    const keyCol = key.padEnd(maxKeyWidth);
+    logFn(`${keyCol} | ${cellToString(data[key])}`);
+  });
+  if (externalLogValue) {
+    logFn("");
+    logFn(`Log: ${externalLogValue}`);
+  }
+}
+function printResizableTable(data, logFn = console.log, externalLogValue) {
+  if (data.length === 0)
+    return;
+  const keys = Object.keys(data[0]).filter((key) => key !== "Code" && key !== "Log");
+  if (keys.length === 0)
+    return;
+  if (!process.stdout.isTTY) {
+    printTable(data, logFn, externalLogValue);
+    return;
+  }
+  const naturalWidths = keys.map((key) => Math.max(key.length, ...data.map((item) => cellToString(item[key]).length)));
+  const separatorTotal = (keys.length - 1) * 3;
+  const totalWidth = naturalWidths.reduce((a, b) => a + b, 0) + separatorTotal;
+  const termWidth = process.stdout.columns || 120;
+  if (totalWidth <= termWidth) {
+    printTable(data, logFn, externalLogValue);
+    return;
+  }
+  const overflow = totalWidth - termWidth;
+  const MIN_COL_WIDTH = 10;
+  const minWidths = keys.map((key) => Math.max(key.length, MIN_COL_WIDTH));
+  let bestCol = -1;
+  let bestCost = Infinity;
+  for (let i2 = 0;i2 < keys.length; i2++) {
+    const maxShrink = naturalWidths[i2] - minWidths[i2];
+    if (maxShrink < overflow)
+      continue;
+    const newWidth = naturalWidths[i2] - overflow;
+    let extraRows = 0;
+    for (const item of data) {
+      const cellLen = cellToString(item[keys[i2]]).length;
+      if (cellLen > newWidth) {
+        extraRows += Math.ceil(cellLen / newWidth) - 1;
+      }
+    }
+    if (extraRows < bestCost) {
+      bestCost = extraRows;
+      bestCol = i2;
+    }
+  }
+  const finalWidths = [...naturalWidths];
+  if (bestCol !== -1) {
+    finalWidths[bestCol] = naturalWidths[bestCol] - overflow;
+  } else {
+    let remaining = overflow;
+    const colsByShrinkPotential = keys.map((_, i2) => ({
+      index: i2,
+      potential: naturalWidths[i2] - minWidths[i2]
+    })).filter((c) => c.potential > 0).sort((a, b) => b.potential - a.potential);
+    for (const col of colsByShrinkPotential) {
+      if (remaining <= 0)
+        break;
+      const shrink = Math.min(remaining, col.potential);
+      finalWidths[col.index] -= shrink;
+      remaining -= shrink;
+    }
+  }
+  const header = keys.map((key, i2) => key.padEnd(finalWidths[i2])).join(" | ");
+  logFn(header);
+  logFn(keys.map((_, i2) => "-".repeat(finalWidths[i2])).join("-|-"));
+  data.forEach((item) => {
+    const cellLines = keys.map((key, i2) => wrapText(cellToString(item[key]), finalWidths[i2]));
+    const lineCount = Math.max(...cellLines.map((l) => l.length));
+    for (let line = 0;line < lineCount; line++) {
+      const row = keys.map((_, i2) => {
+        const val = line < cellLines[i2].length ? cellLines[i2][line] : "";
+        return val.padEnd(finalWidths[i2]);
+      }).join(" | ");
+      logFn(row);
+    }
+  });
+  if (externalLogValue) {
+    logFn("");
+    logFn(`Log: ${externalLogValue}`);
+  }
+}
 function toYaml(data) {
   return dump(data);
 }
@@ -5530,11 +5495,14 @@ var OutputFormatter;
   OutputFormatter.error = error;
   function log(data) {
     const format = getOutputFormat();
+    const sink = getOutputSink();
     if (format === "json") {
-      console.error(JSON.stringify(data));
+      sink.writeErr(`${JSON.stringify(data)}
+`);
     } else {
       for (const [key, value] of Object.entries(data)) {
-        console.error(`${key}: ${value}`);
+        sink.writeErr(`${key}: ${value}
+`);
       }
     }
   }
@@ -5635,6 +5603,95 @@ function registerHelpAll(command) {
     throw new CommanderError(0, "commander.helpDisplayed", "(outputHelp)");
   });
 }
+// src/console-guard.ts
+function format(first, ...rest) {
+  if (typeof first !== "string") {
+    if (first === undefined && rest.length === 0)
+      return "";
+    return [first, ...rest].map(String).join(" ");
+  }
+  let i2 = 0;
+  const result = first.replace(/%[sdifjoO%]/g, (spec) => {
+    if (spec === "%%")
+      return "%";
+    if (i2 >= rest.length)
+      return spec;
+    const arg = rest[i2++];
+    switch (spec) {
+      case "%s":
+        return String(arg);
+      case "%d":
+      case "%i":
+        return String(parseInt(String(arg), 10));
+      case "%f":
+        return String(parseFloat(String(arg)));
+      case "%j":
+      case "%o":
+      case "%O":
+        try {
+          return JSON.stringify(arg);
+        } catch {
+          return String(arg);
+        }
+      default:
+        return spec;
+    }
+  });
+  const extra = rest.slice(i2);
+  if (extra.length > 0) {
+    return result + " " + extra.map(String).join(" ");
+  }
+  return result;
+}
+function formatArgs(args) {
+  return `${format(...args)}
+`;
+}
+var guardInstalled = false;
+var savedOriginals;
+function installConsoleGuard() {
+  if (guardInstalled)
+    return;
+  const originals = {
+    log: console.log,
+    info: console.info,
+    warn: console.warn,
+    error: console.error,
+    debug: console.debug
+  };
+  savedOriginals = originals;
+  let reentrant = false;
+  function guardedWriter(original) {
+    return (...args) => {
+      if (reentrant) {
+        original.apply(console, args);
+        return;
+      }
+      reentrant = true;
+      try {
+        getOutputSink().writeErr(formatArgs(args));
+      } finally {
+        reentrant = false;
+      }
+    };
+  }
+  console.log = guardedWriter(originals.log);
+  console.info = guardedWriter(originals.info);
+  console.warn = guardedWriter(originals.warn);
+  console.error = guardedWriter(originals.error);
+  console.debug = guardedWriter(originals.debug);
+  guardInstalled = true;
+}
+function restoreConsole() {
+  if (!savedOriginals)
+    return;
+  console.log = savedOriginals.log;
+  console.info = savedOriginals.info;
+  console.warn = savedOriginals.warn;
+  console.error = savedOriginals.error;
+  console.debug = savedOriginals.debug;
+  guardInstalled = false;
+}
 // src/constants.ts
 var UIPATH_HOME_DIR = ".uipath";
 var AUTH_FILENAME = ".auth";
@@ -5645,6 +5702,108 @@ var DEFAULT_PAGE_SIZE = 50;
 var DEFAULT_AUTH_TIMEOUT_MS = 5 * 60 * 1000;
 var DEFAULT_FETCH_TIMEOUT_MS = 30000;
 var DEFAULT_REDIRECT_URI = "http://localhost:8104/oidc/login";
+// src/error-handler.ts
+var DEFAULT_401 = "Unauthorized (401). Run `uip login` to authenticate.";
+var DEFAULT_403 = "Forbidden (403). Ensure the account has the required permissions.";
+var DEFAULT_405 = "Method Not Allowed (405). The endpoint may not exist or the base URL may be incorrect.";
+async function extractErrorDetails(error, options) {
+  const err = error !== null && error !== undefined && typeof error === "object" ? error : {};
+  const response = err.response;
+  const status = err.status ?? response?.status;
+  let rawBody;
+  let extractedMessage;
+  let parsedBody;
+  if (response?.text) {
+    const [bodyError, body] = await catchError((async () => response.text())());
+    if (!bodyError && body) {
+      rawBody = body;
+      const [parseError, parsed] = catchError(() => JSON.parse(body));
+      if (!parseError && parsed && typeof parsed === "object") {
+        parsedBody = parsed;
+        if (parsedBody.errors && typeof parsedBody.errors === "object") {
+          for (const field of Object.values(parsedBody.errors)) {
+            if (Array.isArray(field) && field.length > 0) {
+              const first = field[0];
+              if (first && typeof first.message === "string") {
+                extractedMessage = first.message;
+                break;
+              }
+            }
+          }
+        }
+        if (!extractedMessage) {
+          extractedMessage = typeof parsedBody.message === "string" ? parsedBody.message : typeof parsedBody.errorMessage === "string" ? parsedBody.errorMessage : typeof parsedBody.title === "string" ? parsedBody.title : undefined;
+        }
+        if (!extractedMessage) {
+          extractedMessage = body;
+        }
+      } else {
+        extractedMessage = body;
+      }
+    }
+  }
+  const rawMessage = typeof err.message === "string" ? err.message : "Unknown error";
+  let message;
+  if (status === 401) {
+    message = DEFAULT_401;
+  } else if (status === 403) {
+    message = options?.forbiddenMessage ?? DEFAULT_403;
+  } else if (status === 405) {
+    message = DEFAULT_405;
+  } else if (extractedMessage) {
+    message = status ? `HTTP ${status}: ${extractedMessage}` : extractedMessage;
+  } else if (status) {
+    if (rawMessage === "Unknown error" && response) {
+      const statusText = response.statusText;
+      message = statusText ? `HTTP ${status} ${statusText}` : `HTTP ${status} - request failed`;
+    } else {
+      message = `HTTP ${status}: ${rawMessage}`;
+    }
+  } else {
+    message = rawMessage;
+  }
+  let details = rawMessage;
+  if (rawBody) {
+    if (parsedBody) {
+      const extra = {};
+      if (parsedBody.errorCode)
+        extra.errorCode = parsedBody.errorCode;
+      if (parsedBody.details)
+        extra.details = parsedBody.details;
+      if (parsedBody.errors != null)
+        extra.errors = parsedBody.errors;
+      if (parsedBody.data && typeof parsedBody.data === "object" && Object.keys(parsedBody.data).length > 0) {
+        extra.data = parsedBody.data;
+      }
+      details = Object.keys(extra).length > 0 ? JSON.stringify(extra) : rawBody;
+    } else {
+      details = rawBody;
+    }
+  } else if (typeof err.message === "string") {
+    details = err.message;
+  } else {
+    details = String(error);
+  }
+  return { message, details };
+}
+async function extractErrorMessage(error, options) {
+  const { message } = await extractErrorDetails(error, options);
+  return message;
+}
+function extractErrorMessageSync(error) {
+  if (error instanceof Error) {
+    return error.message;
+  }
+  if (typeof error === "object" && error !== null) {
+    if ("status" in error && error.status === 401) {
+      return DEFAULT_401;
+    }
+    if ("message" in error && typeof error.message === "string") {
+      return error.message;
+    }
+  }
+  return String(error);
+}
 // ../../node_modules/jsonpath-plus/dist/index-node-esm.js
 import vm from "vm";
 
@@ -7068,6 +7227,477 @@ class JsonPathError extends Error {
     this.name = "JsonPathError";
   }
 }
+// src/polling/abort-controller.ts
+var created = false;
+function createPollAbortController() {
+  const controller = new AbortController;
+  if (typeof process === "undefined" || typeof process.on !== "function") {
+    return controller;
+  }
+  if (created) {
+    logger.warn("[pollUntil] createPollAbortController called more than once — listeners may accumulate");
+  }
+  created = true;
+  const onSignal = () => {
+    cleanup();
+    controller.abort(new Error("Process interrupted (SIGINT/SIGTERM)"));
+  };
+  const cleanup = () => {
+    process.removeListener("SIGINT", onSignal);
+    process.removeListener("SIGTERM", onSignal);
+    process.removeListener("exit", cleanup);
+  };
+  process.on("SIGINT", onSignal);
+  process.on("SIGTERM", onSignal);
+  process.on("exit", cleanup);
+  controller.signal.addEventListener("abort", () => {
+    cleanup();
+  }, { once: true });
+  return controller;
+}
+// src/polling/format-utils.ts
+function msToDuration(ms) {
+  if (!Number.isFinite(ms) || ms < 0) {
+    return "00:00:00";
+  }
+  const totalSec = Math.floor(ms / 1000);
+  const h = Math.floor(totalSec / 3600);
+  const m = Math.floor(totalSec % 3600 / 60);
+  const s = totalSec % 60;
+  return [h, m, s].map((v) => String(v).padStart(2, "0")).join(":");
+}
+// src/polling/types.ts
+var PollOutcome = {
+  Completed: "completed",
+  Timeout: "timeout",
+  Interrupted: "interrupted",
+  Aborted: "aborted",
+  Failed: "failed"
+};
+var ErrorDecision = {
+  Abort: "abort"
+};
+var POLL_DEFAULTS = {
+  intervalMs: 5000,
+  timeoutMs: 1800000,
+  maxConsecutiveErrors: 3,
+  logIntervalMs: 30000,
+  logPrefix: "wait"
+};
+var BACKOFF_DEFAULTS = {
+  initialMs: 1000,
+  multiplier: 2,
+  maxMs: 30000,
+  jitter: 0.5
+};
+var MIN_INTERVAL_MS = 100;
+
+// src/polling/poll-until.ts
+function resolveIntervalFn(options) {
+  if (typeof options.intervalMs === "function") {
+    return options.intervalMs;
+  }
+  const staticInterval = options.intervalMs ?? POLL_DEFAULTS.intervalMs;
+  return () => staticInterval;
+}
+function resolveBackoffFn(options) {
+  if (!options.backoff)
+    return;
+  const config = options.backoff === true ? { ...BACKOFF_DEFAULTS } : {
+    initialMs: options.backoff.initialMs ?? BACKOFF_DEFAULTS.initialMs,
+    multiplier: options.backoff.multiplier ?? BACKOFF_DEFAULTS.multiplier,
+    maxMs: options.backoff.maxMs ?? BACKOFF_DEFAULTS.maxMs,
+    jitter: Math.min(1, Math.max(0, options.backoff.jitter ?? BACKOFF_DEFAULTS.jitter))
+  };
+  return (errorCount) => {
+    const exponent = Math.min(errorCount - 1, 30);
+    const raw = Math.min(config.initialMs * config.multiplier ** exponent, config.maxMs);
+    if (config.jitter > 0) {
+      const jitterAmount = raw * config.jitter;
+      return raw - jitterAmount * Math.random();
+    }
+    return raw;
+  };
+}
+function clampInterval(raw, label, prefix) {
+  if (!Number.isFinite(raw) || Number.isNaN(raw)) {
+    if (label) {
+      logger.warn(`[${prefix}] ${label} — intervalMs returned ${raw}, falling back to ${POLL_DEFAULTS.intervalMs}ms`);
+    }
+    return POLL_DEFAULTS.intervalMs;
+  }
+  if (raw < MIN_INTERVAL_MS) {
+    if (label) {
+      logger.warn(`[${prefix}] ${label} — intervalMs ${raw}ms clamped to minimum ${MIN_INTERVAL_MS}ms`);
+    }
+    return MIN_INTERVAL_MS;
+  }
+  return raw;
+}
+function abortError(signal) {
+  const reason = signal.reason;
+  if (reason instanceof Error && reason.name === "AbortError") {
+    return reason;
+  }
+  const msg = reason instanceof Error ? reason.message : typeof reason === "string" || typeof reason === "number" ? String(reason) : "Aborted";
+  const err = new Error(msg);
+  err.name = "AbortError";
+  return err;
+}
+function interruptibleSleep(ms, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted) {
+      reject(abortError(signal));
+      return;
+    }
+    let onAbort;
+    const cleanup = () => {
+      if (onAbort) {
+        signal?.removeEventListener("abort", onAbort);
+      }
+    };
+    const timer = setTimeout(() => {
+      cleanup();
+      resolve();
+    }, ms);
+    if (signal) {
+      onAbort = () => {
+        clearTimeout(timer);
+        cleanup();
+        reject(abortError(signal));
+      };
+      signal.addEventListener("abort", onAbort, { once: true });
+    }
+  });
+}
+function sanitizeMaxErrors(value) {
+  if (value === undefined)
+    return POLL_DEFAULTS.maxConsecutiveErrors;
+  if (!Number.isFinite(value) || value < 0)
+    return 0;
+  return Math.floor(value);
+}
+function resolveConfig(options) {
+  const timeoutMs = Math.max(0, options.timeoutMs ?? POLL_DEFAULTS.timeoutMs);
+  const startTime = Date.now();
+  return {
+    fn: options.fn,
+    until: options.until,
+    getStatus: options.getStatus,
+    signal: options.signal,
+    label: options.label,
+    beforePoll: options.beforePoll,
+    onPoll: options.onPoll,
+    onStatusChange: options.onStatusChange,
+    onError: options.onError,
+    onComplete: options.onComplete,
+    onTimeout: options.onTimeout,
+    onInterrupt: options.onInterrupt,
+    timeoutMs,
+    maxConsecutiveErrors: sanitizeMaxErrors(options.maxConsecutiveErrors),
+    logIntervalMs: options.logIntervalMs ?? POLL_DEFAULTS.logIntervalMs,
+    logPrefix: options.logPrefix ?? POLL_DEFAULTS.logPrefix,
+    getInterval: resolveIntervalFn(options),
+    getErrorInterval: resolveBackoffFn(options),
+    startTime,
+    deadline: timeoutMs > 0 ? startTime + timeoutMs : 0
+  };
+}
+function elapsed(cfg) {
+  return Date.now() - cfg.startTime;
+}
+function isPastDeadline(cfg) {
+  return cfg.deadline > 0 && Date.now() >= cfg.deadline;
+}
+function buildContext(cfg, state) {
+  return {
+    pollCount: state.pollCount,
+    elapsedMs: elapsed(cfg),
+    lastResult: state.lastResult,
+    lastStatus: state.lastStatus
+  };
+}
+function truncateMessage(msg, maxLen = 500) {
+  return msg.length > maxLen ? `${msg.slice(0, maxLen)}...` : msg;
+}
+async function handlePollError(error, errorSource, cfg, state) {
+  state.consecutiveErrors++;
+  if (cfg.onError) {
+    const [callbackErr, decision] = await catchError(Promise.resolve().then(() => cfg.onError(error, state.consecutiveErrors)));
+    if (callbackErr) {
+      if (cfg.label) {
+        logger.warn(`[${cfg.logPrefix}] ${cfg.label} — onError callback threw: ${callbackErr.message}`);
+      }
+    } else if (decision === ErrorDecision.Abort) {
+      return "abort";
+    }
+  }
+  if (cfg.label) {
+    const maxLabel = cfg.maxConsecutiveErrors === 0 ? "unlimited" : String(cfg.maxConsecutiveErrors);
+    logger.warn(`[${cfg.logPrefix}] ${cfg.label} — ${errorSource} error (${state.consecutiveErrors}/${maxLabel}): ${error.message}, retrying...`);
+  }
+  if (cfg.maxConsecutiveErrors > 0 && state.consecutiveErrors >= cfg.maxConsecutiveErrors) {
+    return "failed";
+  }
+  return;
+}
+function boundToDeadline(interval, deadline) {
+  if (deadline > 0) {
+    return Math.min(interval, Math.max(0, deadline - Date.now()));
+  }
+  return interval;
+}
+function computeSleepMs(cfg, ctx) {
+  const interval = clampInterval(cfg.getInterval(ctx), cfg.label, cfg.logPrefix);
+  return boundToDeadline(interval, cfg.deadline);
+}
+function computeErrorSleepMs(cfg, state, ctx) {
+  if (cfg.getErrorInterval) {
+    const interval = clampInterval(cfg.getErrorInterval(state.consecutiveErrors), cfg.label, cfg.logPrefix);
+    return boundToDeadline(interval, cfg.deadline);
+  }
+  return computeSleepMs(cfg, ctx);
+}
+async function doSleep(ms, cfg) {
+  if (ms > 0) {
+    const [err] = await catchError(interruptibleSleep(ms, cfg.signal));
+    if (err) {
+      if (isAbortError(err))
+        return;
+      throw err;
+    }
+  }
+}
+function isAbortError(err) {
+  if (!(err instanceof Error))
+    return false;
+  return err.name === "AbortError";
+}
+async function safeCallback(label, name, fn, prefix) {
+  const [err] = await catchError(Promise.resolve().then(() => fn()));
+  if (err && label) {
+    logger.warn(`[${prefix}] ${label} — ${name} callback threw: ${err.message}`);
+  }
+}
+async function processSuccessfulPoll(result, cfg, state) {
+  state.consecutiveErrors = 0;
+  if (cfg.onPoll) {
+    await safeCallback(cfg.label, "onPoll", () => cfg.onPoll?.(result, elapsed(cfg)), cfg.logPrefix);
+  }
+  if (cfg.getStatus) {
+    const getStatus = cfg.getStatus;
+    const [statusErr, newStatus] = catchError(() => getStatus(result));
+    if (statusErr) {
+      if (cfg.label) {
+        logger.warn(`[${cfg.logPrefix}] ${cfg.label} — getStatus threw: ${statusErr.message}`);
+      }
+    } else {
+      if (state.lastStatus !== undefined && newStatus !== state.lastStatus) {
+        const oldStatus = state.lastStatus ?? "";
+        await safeCallback(cfg.label, "onStatusChange", () => cfg.onStatusChange?.(newStatus, oldStatus, result), cfg.logPrefix);
+        if (cfg.label) {
+          logger.info(`[${cfg.logPrefix}] ${cfg.label} — status changed: ${state.lastStatus} → ${newStatus}`);
+        }
+      }
+      state.lastStatus = newStatus;
+    }
+  }
+  logProgress(cfg, state);
+  state.lastResult = result;
+  state.pollCount++;
+}
+function logProgress(cfg, state) {
+  if (!cfg.label || cfg.logIntervalMs <= 0)
+    return;
+  const now = elapsed(cfg);
+  if (now - state.lastLogAt >= cfg.logIntervalMs) {
+    const statusStr = state.lastStatus ? `status: ${state.lastStatus}, ` : "";
+    logger.info(`[${cfg.logPrefix}] ${cfg.label} — ${statusStr}elapsed: ${msToDuration(now)}`);
+    state.lastLogAt = now;
+  }
+}
+function buildResult(data, outcome, cfg) {
+  return { data, outcome, elapsedMs: elapsed(cfg) };
+}
+async function handleCompleted(result, cfg) {
+  await safeCallback(cfg.label, "onComplete", () => cfg.onComplete?.(result, elapsed(cfg)), cfg.logPrefix);
+  if (cfg.label) {
+    let statusStr = "";
+    if (cfg.getStatus) {
+      const getStatus = cfg.getStatus;
+      const [, status] = catchError(() => getStatus(result));
+      if (status != null)
+        statusStr = ` ${status}`;
+    }
+    logger.info(`[${cfg.logPrefix}] ${cfg.label} — reached terminal status:${statusStr} (took ${msToDuration(elapsed(cfg))})`);
+  }
+  return buildResult(result, PollOutcome.Completed, cfg);
+}
+async function handleTimeout(cfg, state) {
+  await safeCallback(cfg.label, "onTimeout", () => cfg.onTimeout?.(state.lastResult, elapsed(cfg)), cfg.logPrefix);
+  if (cfg.label) {
+    const statusStr = state.lastStatus ? ` Last status: ${state.lastStatus}` : "";
+    logger.info(`[${cfg.logPrefix}] ${cfg.label} — timed out after ${msToDuration(elapsed(cfg))}.${statusStr}`);
+  }
+  return buildResult(state.lastResult, PollOutcome.Timeout, cfg);
+}
+async function handleInterrupted(cfg, state) {
+  await safeCallback(cfg.label, "onInterrupt", () => cfg.onInterrupt?.(state.lastResult, elapsed(cfg)), cfg.logPrefix);
+  if (cfg.label) {
+    const statusStr = state.lastStatus ? ` Last status: ${state.lastStatus}` : "";
+    logger.info(`[${cfg.logPrefix}] ${cfg.label} — interrupted.${statusStr}`);
+  }
+  return buildResult(state.lastResult, PollOutcome.Interrupted, cfg);
+}
+function handleAborted(cfg, state, error) {
+  const result = buildResult(state.lastResult, PollOutcome.Aborted, cfg);
+  if (error) {
+    result.error = error;
+  }
+  return result;
+}
+function handleFailed(cfg, state, error) {
+  if (cfg.label) {
+    logger.warn(`[${cfg.logPrefix}] ${cfg.label} — polling failed after ${state.consecutiveErrors} consecutive errors. Last error: ${truncateMessage(error.message)}`);
+  }
+  const result = buildResult(state.lastResult, PollOutcome.Failed, cfg);
+  result.error = error;
+  return result;
+}
+function setupSignalGuard(cfg, state) {
+  const onAbort = () => {
+    state.interrupted = true;
+  };
+  if (cfg.signal) {
+    if (cfg.signal.aborted) {
+      state.interrupted = true;
+    } else {
+      cfg.signal.addEventListener("abort", onAbort, { once: true });
+    }
+  }
+  return {
+    cleanup: () => {
+      cfg.signal?.removeEventListener("abort", onAbort);
+    }
+  };
+}
+function logStart(options, cfg) {
+  if (!cfg.label)
+    return;
+  let intervalDesc;
+  if (typeof options.intervalMs === "function") {
+    intervalDesc = "dynamic";
+  } else {
+    const [intervalErr, intervalVal] = catchError(() => cfg.getInterval({ pollCount: 0, elapsedMs: 0 }));
+    intervalDesc = intervalErr ? "dynamic" : `${intervalVal}ms`;
+  }
+  const backoffDesc = options.backoff ? ", error backoff enabled" : "";
+  const timeoutDesc = cfg.timeoutMs === 0 ? "none" : `${cfg.timeoutMs}ms`;
+  logger.info(`[${cfg.logPrefix}] Waiting for ${cfg.label} — polling every ${intervalDesc}${backoffDesc}, timeout ${timeoutDesc}`);
+}
+function validateConfig(cfg) {
+  if (cfg.maxConsecutiveErrors === 0 && cfg.timeoutMs === 0 && !cfg.signal) {
+    logger.warn(`[${cfg.logPrefix}] Warning: no timeout, no error limit, and no abort signal — polling will continue indefinitely until terminal state.`);
+  }
+}
+async function pollUntil(options) {
+  const cfg = resolveConfig(options);
+  const state = {
+    pollCount: 0,
+    consecutiveErrors: 0,
+    lastResult: undefined,
+    lastStatus: undefined,
+    lastLogAt: 0,
+    interrupted: false
+  };
+  validateConfig(cfg);
+  const guard = setupSignalGuard(cfg, state);
+  logStart(options, cfg);
+  try {
+    return await runPollLoop(cfg, state);
+  } finally {
+    guard.cleanup();
+  }
+}
+async function runPollLoop(cfg, state) {
+  while (!state.interrupted && !cfg.signal?.aborted) {
+    if (isPastDeadline(cfg)) {
+      return handleTimeout(cfg, state);
+    }
+    const ctx = buildContext(cfg, state);
+    if (cfg.beforePoll) {
+      const [beforePollErr] = await catchError(Promise.resolve().then(() => cfg.beforePoll?.(ctx)));
+      if (beforePollErr) {
+        const outcome = await handleErrorAndSleep(beforePollErr, "beforePoll", cfg, state, ctx);
+        if (outcome)
+          return outcome;
+        continue;
+      }
+    }
+    const [pollErr, result] = await catchError(cfg.fn());
+    if (pollErr) {
+      const outcome = await handleErrorAndSleep(pollErr, "poll", cfg, state, ctx);
+      if (outcome)
+        return outcome;
+      continue;
+    }
+    await processSuccessfulPoll(result, cfg, state);
+    const [untilErr, isTerminal] = catchError(() => cfg.until(result));
+    if (untilErr) {
+      const outcome = await handleErrorAndSleep(untilErr, "until", cfg, state, ctx);
+      if (outcome)
+        return outcome;
+      continue;
+    }
+    if (isTerminal) {
+      return handleCompleted(result, cfg);
+    }
+    const sleepCtx = buildContext(cfg, state);
+    await doSleep(computeSleepMs(cfg, sleepCtx), cfg);
+  }
+  return handleInterrupted(cfg, state);
+}
+async function handleErrorAndSleep(error, source, cfg, state, ctx) {
+  const decision = await handlePollError(error, source, cfg, state);
+  if (decision === "abort") {
+    return handleAborted(cfg, state, error);
+  }
+  if (decision === "failed") {
+    return handleFailed(cfg, state, error);
+  }
+  if (isPastDeadline(cfg)) {
+    return handleTimeout(cfg, state);
+  }
+  await doSleep(computeErrorSleepMs(cfg, state, ctx), cfg);
+  return;
+}
+// src/polling/terminal-statuses.ts
+var TERMINAL_STATUSES = new Set([
+  "completed",
+  "successful",
+  "faulted",
+  "failed",
+  "cancelled",
+  "canceled",
+  "stopped",
+  "finished"
+]);
+var FAILURE_STATUSES = new Set([
+  "faulted",
+  "failed",
+  "cancelled",
+  "canceled",
+  "stopped"
+]);
+function isTerminalStatus(status) {
+  return TERMINAL_STATUSES.has(status.toLowerCase());
+}
+function isFailureStatus(status) {
+  return FAILURE_STATUSES.has(status.toLowerCase());
+}
+function isSuccessStatus(status) {
+  return isTerminalStatus(status) && !isFailureStatus(status);
+}
 // src/tool-provider.ts
 var toolProvider;
 function setToolProvider(provider) {
@@ -7081,11 +7711,18 @@ async function ensureToolAvailable(verb) {
 }
 // src/trackedAction.ts
 import { Command } from "commander";
+var POLL_SIGNAL_KEY = Symbol.for("@uipath/common/poll-signal");
 var processContext = {
   exit: (code) => {
     process.exitCode = code;
+  },
+  get pollSignal() {
+    return globalThis[POLL_SIGNAL_KEY];
   }
 };
+function setProcessContextPollSignal(signal) {
+  globalThis[POLL_SIGNAL_KEY] = signal;
+}
 function deriveCommandPath(cmd) {
   const parts = [];
   let current = cmd;
@@ -7143,6 +7780,7 @@ export {
   telemetryFlushAndShutdown,
   telemetry,
   setToolProvider,
+  setProcessContextPollSignal,
   setOutputFormat,
   setOutputFilter,
   setGlobalTelemetryProperties,
@@ -7150,11 +7788,18 @@ export {
   setGlobalLogFilePath,
   sessionId,
   runWithSink,
+  restoreConsole,
   registerHelpAll,
   readRegistryValue,
   processContext,
+  pollUntil,
+  msToDuration,
   logger,
+  isTerminalStatus,
   isTelemetryDisabled,
+  isSuccessStatus,
+  isFailureStatus,
+  installConsoleGuard,
   getOutputSink,
   getOutputFormat,
   getOutputFilter,
@@ -7162,22 +7807,30 @@ export {
   getGlobalLogFilePath,
   formatHelpAll,
   extractFormatFromArgs,
+  extractErrorMessageSync,
+  extractErrorMessage,
+  extractErrorDetails,
   extractCommandHelp,
   evaluateJsonPath,
   ensureToolAvailable,
   deriveCommandPath,
   createTelemetryProvider,
+  createPollAbortController,
   createAppInsightsProvider,
   configureLogger,
   collectCommands,
   catchError,
   UIPATH_HOME_DIR,
   SuccessOutput,
+  PollOutcome,
+  POLL_DEFAULTS,
   OutputFormatter,
+  MIN_INTERVAL_MS,
   LogLevel,
   LOCAL_CONFIG_FILENAME,
   JsonPathError,
   FailureOutput,
+  ErrorDecision,
   DEFAULT_REDIRECT_URI,
   DEFAULT_PAGE_SIZE,
   DEFAULT_LOG_LEVEL,
@@ -7186,5 +7839,6 @@ export {
   DEFAULT_AUTH_TIMEOUT_MS,
   CommonTelemetryEvents,
   CONFIG_FILENAME,
+  BACKOFF_DEFAULTS,
   AUTH_FILENAME
 };

package/package.json

@@ -1,10 +1,10 @@
 {
     "name": "@uipath/common",
-    "version": "0.1.8",
+    "version": "0.1.10",
     "description": "Common infrastructure needed by uipcli tools.",
     "repository": {
         "type": "git",
-        "url": "https://github.com/UiPath/uipcli.git",
+        "url": "https://github.com/UiPath/cli.git",
         "directory": "packages/common"
     },
     "publishConfig": {
@@ -24,23 +24,24 @@
         "vlad-uipath"
     ],
     "scripts": {
-        "build": "bun build ./src/index.ts --outdir dist --format esm --target node --external commander --external applicationinsights",
+        "build": "bun build ./src/index.ts --outdir dist --format esm --target node --external commander --external applicationinsights --external @uipath/telemetry",
         "lint": "biome check .",
         "test": "vitest run",
         "test:coverage": "vitest run --coverage"
     },
     "dependencies": {
         "@jmespath-community/jmespath": "^1.3.0",
-        "@uipath/telemetry": "0.0.5",
         "js-yaml": "^4.1.0",
         "jsonpath-plus": "^10.4.0"
     },
     "devDependencies": {
+        "@uipath/telemetry": "workspace:*",
         "@types/js-yaml": "^4.0.9",
         "@types/node": "^25.2.3",
         "typescript": "^5"
     },
     "peerDependencies": {
+        "@uipath/telemetry": "^0.0.6",
         "commander": "^14.0.3"
     }
 }