@uipath/common 1.202.0 → 1.202.1-preview.167

package/dist/formatter.d.ts

@@ -24,6 +24,23 @@ export type RetryHint = (typeof RETRY_HINTS)[number];
 export declare function isCliErrorCode(value: unknown): value is CliErrorCode;
 /** Narrow an arbitrary value to a {@link RetryHint}. See {@link isCliErrorCode}. */
 export declare function isRetryHint(value: unknown): value is RetryHint;
+/**
+ * The `ErrorCode` an error carries, when it classified itself.
+ *
+ * Companion to `carriedInstructions` (error-handler): a thrower that knows its
+ * failure mode can say so, and the renderer uses it instead of defaulting to
+ * `unknown_error`. Duck-typed and validated for the same reason — the error may
+ * have crossed a bundle boundary, and an unrecognised string must not reach the
+ * envelope as a code no consumer can branch on.
+ *
+ * Lives here, beside {@link isCliErrorCode}, rather than next to
+ * `carriedInstructions`: error-handler reaches formatter type-only on purpose,
+ * and a runtime edge from there pulls this module's telemetry imports into the
+ * browser bundle, which cannot require node builtins.
+ */
+export declare function carriedErrorCode(error: unknown): CliErrorCode | undefined;
+/** The `Retry` hint an error carries. See {@link carriedErrorCode}. */
+export declare function carriedRetry(error: unknown): RetryHint | undefined;
 /** Canonical string constants for {@link ResultType} values. */
 export declare const RESULTS: {
     readonly Success: "Success";

package/dist/index.js

@@ -10662,18 +10662,56 @@ function isSyncFlushForced() {
 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,
+async function spawnTelemetrySidecar(entryPath) {
+  const cwd = getFileSystem().env.tmpdir();
+  const isWindows = process.platform === "win32";
+  const child = isWindows ? spawn(windowsShell(), windowsLauncherArgs(entryPath), {
+    cwd,
     stdio: "ignore",
-    windowsHide: true
+    windowsHide: true,
+    windowsVerbatimArguments: true
+  }) : spawn(process.execPath, [entryPath, TELEMETRY_DRAIN_ARGV], {
+    cwd,
+    detached: true,
+    stdio: "ignore"
   });
   child.on("error", (error) => {
     logger.debug(`[Telemetry] sidecar spawn failed (spool kept for a later run): ${error.message}`);
   });
+  if (isWindows) {
+    await waitForWindowsLauncher(child);
+  }
   child.unref();
 }
+var WINDOWS_LAUNCHER_TIMEOUT_MS = 3000;
+function waitForWindowsLauncher(child) {
+  return new Promise((resolve2) => {
+    const timer = setTimeout(resolve2, WINDOWS_LAUNCHER_TIMEOUT_MS);
+    timer.unref();
+    const settle = () => {
+      clearTimeout(timer);
+      resolve2();
+    };
+    child.on("exit", settle);
+    child.on("error", settle);
+  });
+}
+function windowsShell() {
+  return process.env.ComSpec ?? "cmd.exe";
+}
+function windowsLauncherArgs(entryPath) {
+  return [
+    "/d",
+    "/s",
+    "/c",
+    "start",
+    '""',
+    "/b",
+    `"${process.execPath}"`,
+    `"${entryPath}"`,
+    TELEMETRY_DRAIN_ARGV
+  ];
+}
 async function trySidecarHandoff(provider) {
   const entryPath = getTelemetrySidecarEntry();
   if (entryPath === undefined || isSyncFlushForced() || !isDrainableTelemetryProvider(provider)) {
@@ -10688,7 +10726,7 @@ async function trySidecarHandoff(provider) {
     if (spoolError) {
       logger.debug(`[Telemetry] spool write failed; dropping ${pending.envelopes.length} pending envelope(s): ${spoolError.message}`);
     } else {
-      const [spawnError] = catchError(() => spawnTelemetrySidecar(entryPath));
+      const [spawnError] = await catchError(spawnTelemetrySidecar(entryPath));
       if (spawnError) {
         logger.debug(`[Telemetry] sidecar spawn failed; spool will be sent by a future run: ${spawnError.message}`);
       }
@@ -10765,6 +10803,18 @@ function isCliErrorCode(value) {
 function isRetryHint(value) {
   return typeof value === "string" && RETRY_HINT_VALUES.has(value);
 }
+function carriedErrorCode(error) {
+  if (!error || typeof error !== "object")
+    return;
+  const code = error.errorCode;
+  return isCliErrorCode(code) ? code : undefined;
+}
+function carriedRetry(error) {
+  if (!error || typeof error !== "object")
+    return;
+  const retry = error.retry;
+  return isRetryHint(retry) ? retry : undefined;
+}
 var RESULTS = {
   Success: "Success",
   Failure: "Failure",
@@ -13513,7 +13563,9 @@ export {
   buildOrchestratorUrl,
   buildSkillEventTelemetryAttribution,
   canPrompt,
+  carriedErrorCode,
   carriedInstructions,
+  carriedRetry,
   catchError,
   claimPendingSpoolFiles,
   classifiedFailure,
@@ -13684,4 +13736,4 @@ export {
   writeTelemetrySpoolFile
 };
 
-//# debugId=E388413E446272F364756E2164756E21
+//# debugId=58E4DC863EA8483464756E2164756E21

package/dist/telemetry/telemetry-init.d.ts

@@ -71,7 +71,7 @@ export declare function telemetryInit(options?: TelemetryInitOptions): Promise<v
  * Deliver all buffered telemetry before the process exits.
  * Must be awaited on every exit path.
  *
- * Normally hands the buffered envelopes to a detached sidecar process (see
+ * Normally hands the buffered envelopes to a background sidecar process (see
  * {@link trySidecarHandoff}) so the exit is instant. Falls back to the
  * in-process flush — one ingestion round-trip, capped at
  * FLUSH_SHUTDOWN_TIMEOUT_MS — when the sidecar handoff isn't available or

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@uipath/common",
     "license": "SEE LICENSE IN LICENSE.txt",
-    "version": "1.202.0",
+    "version": "1.202.1-preview.167",
     "description": "Common infrastructure needed by uip tools.",
     "repository": {
         "type": "git",
@@ -75,5 +75,5 @@
         "mihaigirleanu",
         "vlad-uipath"
     ],
-    "gitHead": "23b5a7038ead7264439af18f8b807c7cc99a29d5"
+    "gitHead": "04e307035c95c9da5b9a2e04c6794f64f14fd9da"
 }