@uipath/rpa-tool 1.199.0 → 1.199.1

package/dist/index.js

@@ -2272,6 +2272,7 @@ import { execFile as execFile4, execFileSync } from "node:child_process";
 import { promisify as promisify5 } from "node:util";
 import { execFile as execFile5 } from "node:child_process";
 import process7 from "node:process";
+import { spawn } from "node:child_process";
 import { execFileSync as execFileSync2 } from "node:child_process";
 import { AsyncLocalStorage } from "node:async_hooks";
 var __create2 = Object.create;
@@ -8136,7 +8137,7 @@ function requireOmap() {
   function resolveYamlOmap(data) {
     if (data === null)
       return true;
-    const objectKeys = [];
+    const objectKeys = {};
     const object = data;
     for (let index = 0, length = object.length;index < length; index += 1) {
       const pair = object[index];
@@ -8154,10 +8155,9 @@ function requireOmap() {
       }
       if (!pairHasKey)
         return false;
-      if (objectKeys.indexOf(pairKey) === -1)
-        objectKeys.push(pairKey);
-      else
+      if (_hasOwnProperty.call(objectKeys, pairKey))
         return false;
+      Object.defineProperty(objectKeys, pairKey, { value: true });
     }
     return true;
   }
@@ -10784,7 +10784,7 @@ function buildCommandTerminalTelemetryProperties(input) {
 }
 var CommonTelemetryEvents = {
   Error: "uip.error",
-  ShipSucceeded: "ship_succeeded"
+  ShipSucceeded: "uip.ship.succeeded"
 };
 function readRegistryValue(keyPath, valueName) {
   if (process.platform !== "win32") {
@@ -11007,8 +11007,18 @@ function getInboundTraceContext() {
   return parseInboundTraceparent(getProcessEnv()?.[TELEMETRY_TRACEPARENT_ENV]);
 }
 var TELEMETRY_SESSION_ID_ENV = "UIPATH_SESSION_ID";
-var TELEMETRY_SESSION_ID_PROPERTY = "session_id";
-var telemetrySessionIdSlot = singleton("TelemetrySessionId");
+var SESSION_ID_MAX_LENGTH = 64;
+var RANDOM_SESSION_ID_LENGTH = 32;
+var TELEMETRY_SESSION_SOURCE_PROPERTY = "session_id_source";
+var CONTROL_CHARACTERS = /\p{Cc}/gu;
+var INHERITED_SESSION_SOURCES = [
+  { envVar: "CLAUDE_CODE_SESSION_ID", source: "claude-code" },
+  { envVar: "CODEX_THREAD_ID", source: "codex" },
+  { envVar: "ANTIGRAVITY_TRAJECTORY_ID", source: "antigravity" },
+  { envVar: "TERM_SESSION_ID", source: "terminal" },
+  { envVar: "WT_SESSION", source: "terminal" }
+];
+var telemetrySessionSlot = singleton("TelemetrySession");
 var telemetryOperationIdSlot = singleton("TelemetryOperationId");
 function getProcessEnv2() {
   return globalThis.process?.env;
@@ -11017,27 +11027,45 @@ function normalizeSessionId(value) {
   if (typeof value !== "string" && typeof value !== "number" && typeof value !== "boolean") {
     return;
   }
-  const trimmed = String(value).trim();
-  return trimmed || undefined;
+  const cleaned = String(value).replace(CONTROL_CHARACTERS, "").trim().slice(0, SESSION_ID_MAX_LENGTH);
+  return cleaned || undefined;
 }
 function getConfiguredTelemetrySessionId() {
   return normalizeSessionId(getProcessEnv2()?.[TELEMETRY_SESSION_ID_ENV]);
 }
-function getTelemetrySessionId() {
-  const envSessionId = getConfiguredTelemetrySessionId();
-  if (envSessionId) {
-    return envSessionId;
+function getInheritedSession(env) {
+  for (const candidate of INHERITED_SESSION_SOURCES) {
+    const handle = normalizeSessionId(env[candidate.envVar]);
+    if (handle) {
+      return { id: handle, source: candidate.source };
+    }
   }
-  const existing = telemetrySessionIdSlot.get();
+  return;
+}
+function generateRandomSession() {
+  const bytes = new Uint8Array(RANDOM_SESSION_ID_LENGTH / 2);
+  crypto.getRandomValues(bytes);
+  let hex = "";
+  for (const byte of bytes) {
+    hex += byte.toString(16).padStart(2, "0");
+  }
+  return { id: hex, source: "random" };
+}
+function resolveTelemetrySession() {
+  const existing = telemetrySessionSlot.get();
   if (existing) {
     return existing;
   }
-  const generated = crypto.randomUUID();
-  telemetrySessionIdSlot.set(generated);
-  return generated;
+  const declaredHandle = getConfiguredTelemetrySessionId();
+  const resolved = declaredHandle ? { id: declaredHandle, source: "declared" } : getInheritedSession(getProcessEnv2() ?? {}) ?? generateRandomSession();
+  telemetrySessionSlot.set(resolved);
+  return resolved;
+}
+function getTelemetrySessionId() {
+  return resolveTelemetrySession().id;
 }
-function resolveTelemetrySessionId(existingSessionId) {
-  return getConfiguredTelemetrySessionId() ?? normalizeSessionId(existingSessionId);
+function getTelemetrySessionSource() {
+  return resolveTelemetrySession().source;
 }
 function getTelemetryOperationId() {
   const existing = telemetryOperationIdSlot.get();
@@ -11285,14 +11313,11 @@ class TelemetryService {
   }
   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 = {
+    const childContext = parentContext !== undefined ? {
       operationId: parentContext.operationId,
       parentId: parentContext.id,
       id: this.generateId()
-    };
+    } : this.createRequestContext();
     const startTime = performance.now();
     try {
       const result = await this.contextStorage.run(childContext, fn);
@@ -11313,24 +11338,18 @@ class TelemetryService {
   }
   enrichPropertiesWithContext(properties, context) {
     const globalProperties = getGlobalTelemetryProperties();
-    const existingSessionId = properties?.[TELEMETRY_SESSION_ID_PROPERTY] ?? this.defaultProperties?.[TELEMETRY_SESSION_ID_PROPERTY] ?? globalProperties?.[TELEMETRY_SESSION_ID_PROPERTY];
-    const sessionId = resolveTelemetrySessionId(existingSessionId);
     const enriched = {
       ...getExecutionContextTelemetryProperties(),
       ...globalProperties,
       ...this.defaultProperties,
       ...redactProperties(properties ?? {}),
+      [TELEMETRY_SESSION_SOURCE_PROPERTY]: getTelemetrySessionSource(),
       ...context ? {
         [TELEMETRY_OPERATION_ID_PROPERTY]: context.operationId,
         ...context.parentId !== undefined ? { [TELEMETRY_PARENT_ID_PROPERTY]: context.parentId } : {},
         [TELEMETRY_SPAN_ID_PROPERTY]: context.id
       } : {}
     };
-    if (sessionId === undefined) {
-      delete enriched[TELEMETRY_SESSION_ID_PROPERTY];
-    } else {
-      enriched[TELEMETRY_SESSION_ID_PROPERTY] = sessionId;
-    }
     return enriched;
   }
   generateId() {
@@ -11412,6 +11431,9 @@ function normalizeFlushCallbackError(response) {
   }
   return extractAppInsightsDumpMessage(text) ?? text;
 }
+function channelInternals(client) {
+  return client.channel;
+}
 function setDefaultAppInsightsEnv(name, value) {
   if (process.env[name] === undefined) {
     process.env[name] = value;
@@ -11501,16 +11523,6 @@ class NodeAppInsightsTelemetryProvider {
     }
     return { operationId, parentId, spanId };
   }
-  promoteSessionTag(merged, tags) {
-    const client = this.client;
-    if (!client || !merged)
-      return;
-    const sessionId = merged[TELEMETRY_SESSION_ID_PROPERTY];
-    delete merged[TELEMETRY_SESSION_ID_PROPERTY];
-    if (sessionId) {
-      tags[client.context.keys.sessionId] = sessionId;
-    }
-  }
   leafTagOverrides(properties) {
     const client = this.client;
     if (!client)
@@ -11523,7 +11535,6 @@ class NodeAppInsightsTelemetryProvider {
     if (spanId) {
       tags[keys.operationParentId] = spanId;
     }
-    this.promoteSessionTag(properties, tags);
     return tags;
   }
   operationCorrelation(properties) {
@@ -11538,7 +11549,6 @@ class NodeAppInsightsTelemetryProvider {
     if (parentId) {
       tagOverrides[keys.operationParentId] = parentId;
     }
-    this.promoteSessionTag(properties, tagOverrides);
     return { tagOverrides, id: spanId };
   }
   async trackEvent(eventName, properties) {
@@ -11631,6 +11641,32 @@ class NodeAppInsightsTelemetryProvider {
       logger.warn(`[AppInsights] flush error (non-fatal): ${error.message}`);
     }
   }
+  drainPendingEnvelopes() {
+    const client = this.client;
+    if (!client)
+      return;
+    const endpointUrl = client.config?.endpointUrl;
+    if (!endpointUrl)
+      return;
+    const [error, envelopes] = catchError(() => {
+      const channel = channelInternals(client);
+      if (!channel || !Array.isArray(channel._buffer)) {
+        throw new Error("unexpected channel shape");
+      }
+      if (channel._timeoutHandle) {
+        clearTimeout(channel._timeoutHandle);
+        channel._timeoutHandle = undefined;
+      }
+      const buffered = channel._buffer;
+      channel._buffer = [];
+      return buffered;
+    });
+    if (error) {
+      logger.debug("[AppInsights] failed to drain the channel buffer");
+      return;
+    }
+    return { endpointUrl, envelopes };
+  }
   async shutdown() {
     const client = this.client;
     if (client) {
@@ -11638,6 +11674,19 @@ class NodeAppInsightsTelemetryProvider {
       if (statsbeatError) {
         logger.debug("[AppInsights] failed to shut down Statsbeat");
       }
+      const [channelError] = catchError(() => {
+        const channel = channelInternals(client);
+        if (!channel)
+          return;
+        if (channel._timeoutHandle) {
+          clearTimeout(channel._timeoutHandle);
+          channel._timeoutHandle = undefined;
+        }
+        channel._buffer = [];
+      });
+      if (channelError) {
+        logger.debug("[AppInsights] failed to clear the channel buffer");
+      }
     }
     const appInsights = this.appInsightsModule;
     if (appInsights) {
@@ -11676,6 +11725,29 @@ function isTelemetryDisabled() {
   const value = process.env.UIPATH_TELEMETRY_DISABLED;
   return value === "1" || value === "true";
 }
+var TELEMETRY_DRAIN_ARGV = "__uip-drain-telemetry";
+var sidecarEntrySlot = singleton("TelemetrySidecarEntry");
+function getTelemetrySidecarEntry() {
+  return sidecarEntrySlot.get();
+}
+var PENDING_SUFFIX = ".json";
+var WRITE_TEMP_SUFFIX = ".tmp";
+var MAX_SPOOL_AGE_MS = 72 * 60 * 60 * 1000;
+function getTelemetrySpoolDir() {
+  const fs7 = getFileSystem();
+  return fs7.path.join(fs7.env.homedir(), ".uipath", "telemetry", "pending");
+}
+async function writeTelemetrySpoolFile(payload) {
+  const fs7 = getFileSystem();
+  const dir = getTelemetrySpoolDir();
+  await fs7.mkdir(dir);
+  const name = `${Date.now()}-${process.pid}`;
+  const finalPath = fs7.path.join(dir, `${name}${PENDING_SUFFIX}`);
+  const tempPath = fs7.path.join(dir, `${name}${WRITE_TEMP_SUFFIX}`);
+  await fs7.writeFile(tempPath, JSON.stringify(payload));
+  await fs7.rename(tempPath, finalPath);
+  return finalPath;
+}
 var telemetryInstanceSlot = singleton("TelemetryService");
 var DEFAULT_AI_CONNECTION_STRING = atob("SW5zdHJ1bWVudGF0aW9uS2V5PTliZDM3NDgyLTgxMGUtNDQyYS1hYWE2LWQzOGVmNjVjNjY3NDtJbmdlc3Rpb25FbmRwb2ludD1odHRwczovL3dlc3RldXJvcGUtNS5pbi5hcHBsaWNhdGlvbmluc2lnaHRzLmF6dXJlLmNvbS87TGl2ZUVuZHBvaW50PWh0dHBzOi8vd2VzdGV1cm9wZS5saXZlZGlhZ25vc3RpY3MubW9uaXRvci5henVyZS5jb20vO0FwcGxpY2F0aW9uSWQ9MzU2OTdlZjEtOGJkMC00ZjE5LWEyN2MtZDg3Y2NhYzY2ZDJj");
 function getConnectionString() {
@@ -11768,6 +11840,56 @@ async function runWithTimeout(operation, timeoutMs) {
       clearTimeout(timer);
   }
 }
+async function runProviderShutdown(provider) {
+  const [shutdownError, shutdownResult] = await catchError(runWithTimeout(provider.shutdown(), FLUSH_SHUTDOWN_TIMEOUT_MS));
+  if (shutdownError) {
+    logger.warn(`[Telemetry] shutdown failed (non-fatal): ${shutdownError.message}`);
+  } else if (shutdownResult === "timeout") {
+    logger.warn(`[Telemetry] shutdown timed out after ${FLUSH_SHUTDOWN_TIMEOUT_MS}ms`);
+  }
+}
+function isSyncFlushForced() {
+  const value = process.env.UIPATH_TELEMETRY_SYNC_FLUSH;
+  return value === "1" || value === "true";
+}
+function isDrainableTelemetryProvider(provider) {
+  return "drainPendingEnvelopes" in provider && typeof provider.drainPendingEnvelopes === "function";
+}
+function spawnTelemetrySidecar(entryPath) {
+  const child = spawn(process.execPath, [entryPath, TELEMETRY_DRAIN_ARGV], {
+    cwd: getFileSystem().env.tmpdir(),
+    detached: true,
+    stdio: "ignore",
+    windowsHide: true
+  });
+  child.on("error", (error) => {
+    logger.debug(`[Telemetry] sidecar spawn failed (spool kept for a later run): ${error.message}`);
+  });
+  child.unref();
+}
+async function trySidecarHandoff(provider) {
+  const entryPath = getTelemetrySidecarEntry();
+  if (entryPath === undefined || isSyncFlushForced() || !isDrainableTelemetryProvider(provider)) {
+    return false;
+  }
+  const pending = provider.drainPendingEnvelopes();
+  if (!pending) {
+    return false;
+  }
+  if (pending.envelopes.length > 0) {
+    const [spoolError] = await catchError(writeTelemetrySpoolFile(pending));
+    if (spoolError) {
+      logger.debug(`[Telemetry] spool write failed; dropping ${pending.envelopes.length} pending envelope(s): ${spoolError.message}`);
+    } else {
+      const [spawnError] = catchError(() => spawnTelemetrySidecar(entryPath));
+      if (spawnError) {
+        logger.debug(`[Telemetry] sidecar spawn failed; spool will be sent by a future run: ${spawnError.message}`);
+      }
+    }
+  }
+  await runProviderShutdown(provider);
+  return true;
+}
 async function telemetryFlushAndShutdown() {
   if (!isFlushableTelemetryProvider(telemetryProviderInstance)) {
     return;
@@ -11775,18 +11897,16 @@ async function telemetryFlushAndShutdown() {
   if (!telemetryFlushShutdownPromise) {
     const provider = telemetryProviderInstance;
     telemetryFlushShutdownPromise = (async () => {
+      if (await trySidecarHandoff(provider)) {
+        return;
+      }
       const [flushError, flushResult] = await catchError(runWithTimeout(provider.flush(), FLUSH_SHUTDOWN_TIMEOUT_MS));
       if (flushError) {
         logger.warn(`[Telemetry] flush failed (non-fatal): ${flushError.message}`);
       } else if (flushResult === "timeout") {
         logger.warn(`[Telemetry] flush timed out after ${FLUSH_SHUTDOWN_TIMEOUT_MS}ms`);
       }
-      const [shutdownError, shutdownResult] = await catchError(runWithTimeout(provider.shutdown(), FLUSH_SHUTDOWN_TIMEOUT_MS));
-      if (shutdownError) {
-        logger.warn(`[Telemetry] shutdown failed (non-fatal): ${shutdownError.message}`);
-      } else if (shutdownResult === "timeout") {
-        logger.warn(`[Telemetry] shutdown timed out after ${FLUSH_SHUTDOWN_TIMEOUT_MS}ms`);
-      }
+      await runProviderShutdown(provider);
     })();
   }
   await telemetryFlushShutdownPromise;
@@ -12140,6 +12260,19 @@ class FilterEvaluationError extends Error {
     this.instructions = `The --output-filter expression '${filter}' failed at evaluation time. ` + "Note that --output-filter operates on the 'Data' field of the envelope, not the full object. " + "For example, on a list result use 'length(@)' instead of 'Data | length(@)'.";
   }
 }
+
+class FilterImplicitLimitError extends Error {
+  __brand = "FilterImplicitLimitError";
+  errorCode = "invalid_argument";
+  instructions;
+  retry = "RetryWillNotFix";
+  result = RESULTS.ValidationError;
+  constructor(defaultLimit) {
+    super(`--output-filter requires an explicit --limit: this command defaults to --limit ${defaultLimit}, ` + `so the filter would silently apply to only the first ${defaultLimit} records.`);
+    this.name = "FilterImplicitLimitError";
+    this.instructions = "Pass --limit <n> to choose how many records the filter applies to. " + "To filter over all records, pass the command's maximum accepted --limit (see the option's description in --help).";
+  }
+}
 function applyFilter(data, filter) {
   let result;
   try {
@@ -12530,6 +12663,16 @@ function commandHelpHint(commandPath) {
 function isPromptCancellation(error) {
   return error instanceof Error && error.name === "ExitPromptError";
 }
+function implicitLimitViolation(cmd) {
+  if (getOutputFilter() === undefined) {
+    return;
+  }
+  const hasLimit = cmd.options.some((o) => o.attributeName() === "limit");
+  if (!hasLimit || cmd.getOptionValueSource("limit") !== "default") {
+    return;
+  }
+  return new FilterImplicitLimitError(String(cmd.opts().limit));
+}
 function exitCodeFromProcess(fallback) {
   return typeof process.exitCode === "number" ? process.exitCode : fallback;
 }
@@ -12543,7 +12686,13 @@ Command2.prototype.trackedAction = function(context, fn, properties) {
     let errorMessage;
     let fallbackExitCode = EXIT_CODES.Success;
     clearRecordedCommandFailureTelemetry();
-    const [error] = await catchError(telemetry.runWithContext(requestContext, () => fn(...args)));
+    const [error] = await catchError(telemetry.runWithContext(requestContext, () => {
+      const violation = implicitLimitViolation(command);
+      if (violation) {
+        return Promise.reject(violation);
+      }
+      return fn(...args);
+    }));
     if (error) {
       errorMessage = error instanceof Error ? error.message : String(error);
       logger.debug(`[trackedAction] ${telemetryName} failed: ${errorMessage}`);
@@ -12599,6 +12748,20 @@ Command2.prototype.trackedAction = function(context, fn, properties) {
 var guardInstalledSlot = singleton("ConsoleGuardInstalled");
 var savedOriginalsSlot = singleton("ConsoleGuardOriginals");
 var DEFAULT_AUTH_TIMEOUT_MS = 5 * 60 * 1000;
+var HOST_GLOBAL_OPTIONS_WITH_VALUE = [
+  "--output",
+  "--output-filter",
+  "--log-level",
+  "--log-file",
+  "--profile"
+];
+var HOST_GLOBAL_FLAGS = [
+  "--json",
+  "--interactive",
+  "--no-interactive"
+];
+var VALUE_OPTIONS = new Set(HOST_GLOBAL_OPTIONS_WITH_VALUE);
+var BOOLEAN_FLAGS = new Set(HOST_GLOBAL_FLAGS);
 var modeSlot = singleton("InteractivityMode");
 var interactiveFlagSlot = singleton("InteractiveFlag");
 var PollOutcome = {
@@ -12650,8 +12813,9 @@ var ScreenLogger;
   ScreenLogger2.progress = progress;
 })(ScreenLogger ||= {});
 var sdkUserAgentHostToken = singleton("SdkUserAgentHostToken");
-var shippedKeysSlot = singleton("ShipSucceededDedupeKeys");
 var factorySlot = singleton("PackagerFactoryProvider");
+var moduleSlot = singleton("ToolModuleProvider");
+var shippedKeysSlot = singleton("ShipSucceededDedupeKeys");
 
 // src/argv.ts
 function extractArg(argv, name, defaultValue) {