@uipath/common 1.201.0 → 1.202.0-preview.136

package/dist/logger.d.ts

@@ -52,10 +52,25 @@ declare class SimpleLogger {
     /** Check if file logging is active (local or cross-bundle via globalThis). */
     private isFileLoggingActive;
     private writeToFile;
+    /**
+     * Route one already-formatted line: into the log file when `--log-file`
+     * configured one, to stderr through the sink otherwise. Every level goes
+     * through here, so the two destinations can never drift apart.
+     */
+    private write;
     debug(message: string, ...args: unknown[]): void;
     info(message: string, ...args: unknown[]): void;
     warn(message: string, ...args: unknown[]): void;
     error(message: string, ...args: unknown[]): void;
+    /**
+     * Write a line regardless of the level threshold.
+     *
+     * For output that has its own switch and so must not be silenced by
+     * `--log-level` — currently only the `UIP_TIMINGS` report. Routing matches
+     * the other levels: the log file when one is configured, stderr otherwise.
+     * No level tag is prepended; the caller owns the whole line.
+     */
+    report(message: string): void;
     /**
      * Get the current log level.
      */

package/dist/package-metadata-options.js

@@ -26,8 +26,8 @@ function mapPackageMetadataOptions(opts) {
   return fields;
 }
 export {
-  registerPackageMetadataOptions,
-  mapPackageMetadataOptions
+  mapPackageMetadataOptions,
+  registerPackageMetadataOptions
 };
 
-//# debugId=D76F2616EBFEF0E864756E2164756E21
+//# debugId=C8F478FA4BBCD51264756E2164756E21

package/dist/polling/poll-failure-mapping.d.ts

@@ -1,3 +1,4 @@
+import type { CliErrorCode, RetryHint } from "../formatter";
 import { PollOutcome } from "./types";
 /** Canonical taxonomy for poll-loop failures; library callers branch on this without parsing the message. */
 export type PollFailureReason = "poll_timeout" | "poll_failed" | "poll_aborted";
@@ -7,9 +8,22 @@ export interface PollFailureMapped {
     message: string;
     /** `2` for Timeout, `1` otherwise. */
     exitCode: number;
+    /**
+     * Classification for `OutputFormatter.error`, set only where the outcome
+     * settles it. A timeout is `timeout` / `RetryLater`: the operation was
+     * still running when we stopped watching, so the instructions say to check
+     * again — and the hint has to agree, or an agent reads
+     * `RetryWillNotFix` next to "may still be in progress". The other outcomes
+     * carry an underlying error the formatter can classify better than we can
+     * from the outcome alone, so they are left unset.
+     */
+    errorCode?: CliErrorCode;
+    /** See {@link PollFailureMapped.errorCode}. */
+    retry?: RetryHint;
 }
 /**
- * Maps a non-completed `pollUntil` result to `{ reason, message, exitCode }`.
+ * Maps a non-completed `pollUntil` result to `{ reason, message, exitCode }`,
+ * plus `errorCode` / `retry` for the outcomes that classify themselves.
  * `label` prefixes the message (e.g. `"Deployment"` → `"Deployment polling timed out"`).
  * Caller must check the outcome is non-completed before invoking.
  */

package/dist/sdk-user-agent.js

@@ -149,12 +149,12 @@ function installSdkCodingAgentHeader(BaseApiClass) {
   installRequestHeaderForwarding(BaseApiClass, codingAgentPatchKey(), (headers) => addSdkCodingAgentHeader(headers));
 }
 export {
-  setSdkUserAgentHostToken,
-  installSdkUserAgentHeader,
-  installSdkCodingAgentHeader,
-  getSdkUserAgentToken,
+  addSdkCodingAgentHeader,
   addSdkUserAgentHeader,
-  addSdkCodingAgentHeader
+  getSdkUserAgentToken,
+  installSdkCodingAgentHeader,
+  installSdkUserAgentHeader,
+  setSdkUserAgentHostToken
 };
 
-//# debugId=9DC7523199926B8364756E2164756E21
+//# debugId=6BBB85462D129AD364756E2164756E21

package/dist/telemetry/command-name.d.ts

@@ -0,0 +1,60 @@
+/**
+ * How a command's telemetry name is formed.
+ *
+ * `requests.name` is the column every command count, failure rate and duration
+ * percentile groups by, so the name has to be a command path and nothing else:
+ * lowercase tokens under a `uip.` root, one per level.
+ *
+ * Two places work out which command ran — `deriveCommandPath` walks up from the
+ * command object, and `cli.core.ts` walks the tree down from argv for the runs
+ * that never reach a handler. That difference is real; the parse-error path is
+ * handed the second one's answer rather than guessing a third. How the parts
+ * become a name was never each caller's business either, and having it written
+ * three times is what let argv text into the column: `uip.config --help` and
+ * `uip.help config` both shipped as request names.
+ *
+ * So the parts are each caller's business and the name is this module's.
+ */
+/** Every CLI telemetry name sits under this root. */
+export declare const TELEMETRY_COMMAND_ROOT = "uip";
+/**
+ * Build a command's telemetry name from the path parts a caller resolved.
+ *
+ * Parts are taken as candidates, not as truth. A part is dropped when it is not
+ * a command token:
+ *
+ * - an option (`--help`, `-o`), which names no command and put argv text in the
+ *   column. Its VALUE is the caller's business: skipping that needs the option
+ *   grammar, which the argv walk in `cli.core.ts` has and this does not, so a
+ *   second guess here would only contradict it;
+ * - a repeated root, so `uip.uip.tools` cannot happen.
+ *
+ * What survives is still not trusted to be a command, so shape is checked: a
+ * token has to look like a command name and not like an identifier, and
+ * anything else becomes `<unknown>` — which keeps the row, a failed run the user
+ * cared about, without the column carrying a key.
+ *
+ * Whitespace inside a part is a part that was never split — the name is
+ * dot-separated, so a space in it is a sign the caller handed over a joined
+ * string. It is split back into levels only when EVERY piece is a command name;
+ * one piece that is not means the part was never a joined path, and it collapses
+ * whole onto a single `<unknown>`. A single argv token therefore stays a single
+ * level: `uip "nope\nsecond"` is `uip.<unknown>`, not `uip.<unknown>.second` —
+ * one typo cannot invent a path level the user never typed.
+ *
+ * That check is the second line of defence, not the first. What a caller hands
+ * over is what bounds this column: `deriveCommandPath` walks the Commander tree
+ * and passes command names only, and `cli.core.ts`'s walk pushes at most ONE
+ * unrecognized token, in first position, then stops. So an argument never
+ * reaches here — `uip or assets get <guid>` is `uip.or.assets.get` and `uip or
+ * queues items add myqueue` stops at the last command it recognized. What a
+ * shape check is left to catch is the first token of a run that named no
+ * command at all, where the user typed something the CLI does not have.
+ *
+ * A token shaped like a command name IS kept there, deliberately: `uip deploy`
+ * or `uip login-sso` is a person or an agent guessing at syntax we do not have,
+ * and that is worth seeing rather than collapsing into one `<unknown>` row. The
+ * cost is that this column's values are not a closed set — one row per distinct
+ * guess — bounded by the shapes below rather than by a list.
+ */
+export declare function commandTelemetryName(parts: readonly string[]): string;

package/dist/telemetry/console-telemetry-provider.d.ts

@@ -1,12 +1,11 @@
-import type { ITelemetryProvider } from "./telemetry-provider.js";
-import type { TelemetryProperties } from "./telemetry-service.js";
+import type { ITelemetryProvider, TrackedDependencySpan, TrackedEvent, TrackedException, TrackedSpan } from "./telemetry-provider.js";
 /**
  * A simple telemetry provider that logs events to the console.
  * Useful for development and testing. Browser-safe (no Node API dependencies).
  */
 export declare class ConsoleTelemetryProvider implements ITelemetryProvider {
-    trackEvent(eventName: string, _properties?: TelemetryProperties): Promise<void>;
-    trackException(error: Error, _properties?: TelemetryProperties): Promise<void>;
-    trackRequest(name: string, duration: number, success: boolean, _properties?: TelemetryProperties): Promise<void>;
-    trackDependency(name: string, type: string, duration: number, success: boolean, _properties?: TelemetryProperties): Promise<void>;
+    trackEvent({ name }: TrackedEvent): Promise<void>;
+    trackException({ error }: TrackedException): Promise<void>;
+    trackRequest({ name, durationMs, success, }: TrackedSpan): Promise<void>;
+    trackDependency({ name, type, durationMs, success, }: TrackedDependencySpan): Promise<void>;
 }

package/dist/telemetry/debug-telemetry-provider.d.ts

@@ -1,12 +1,11 @@
-import type { ITelemetryProvider } from "./telemetry-provider.js";
-import type { TelemetryProperties } from "./telemetry-service.js";
+import type { ITelemetryProvider, TrackedDependencySpan, TrackedEvent, TrackedException, TrackedSpan } from "./telemetry-provider.js";
 /**
  * A simple telemetry provider that logs events via the shared logger.
  * Useful for development and testing.
  */
 export declare class DebugTelemetryProvider implements ITelemetryProvider {
-    trackEvent(eventName: string, _properties?: TelemetryProperties): Promise<void>;
-    trackException(error: Error, _properties?: TelemetryProperties): Promise<void>;
-    trackRequest(name: string, duration: number, success: boolean, _properties?: TelemetryProperties): Promise<void>;
-    trackDependency(name: string, type: string, duration: number, success: boolean, _properties?: TelemetryProperties): Promise<void>;
+    trackEvent({ name }: TrackedEvent): Promise<void>;
+    trackException({ error }: TrackedException): Promise<void>;
+    trackRequest({ name, durationMs, success, }: TrackedSpan): Promise<void>;
+    trackDependency({ name, type, durationMs, success, }: TrackedDependencySpan): Promise<void>;
 }

package/dist/telemetry/index.d.ts

@@ -4,8 +4,8 @@ export { ConsoleTelemetryProvider } from "./console-telemetry-provider.js";
 export type { IContextStorage } from "./context-storage.js";
 export { buildEnvironmentProperties, type NormalizedEnvironment, normalizeBaseUrl, normalizeEnvironment, } from "./environment-info.js";
 export { type CiProvider, detectExecutionContext, EXECUTION_CONTEXT_VALUES, type ExecutionContext, type ExecutionContextDetection, type ExecutionContextDetectionOptions, getExecutionContextTelemetryProperties, setExecutionContextAuthSignal, } from "./execution-context.js";
-export { redactError, redactProperties, redactProperty, redactValue, } from "./pii-redactor.js";
+export { redactError, redactProperties, redactProperty, } from "./pii-redactor.js";
 export { getConfiguredTelemetrySessionId, getTelemetrySessionId, getTelemetrySessionSource, TELEMETRY_SESSION_ID_ENV, TELEMETRY_SESSION_SOURCE_PROPERTY, } from "./session-id.js";
-export type { ITelemetryProvider } from "./telemetry-provider.js";
+export type { ITelemetryProvider, TelemetryCorrelation, TrackedDependencySpan, TrackedEvent, TrackedException, TrackedSpan, } from "./telemetry-provider.js";
 export type { ITelemetryService, TelemetryContext, TelemetryProperties, } from "./telemetry-service.js";
-export { TELEMETRY_OPERATION_ID_PROPERTY, TELEMETRY_PARENT_ID_PROPERTY, TELEMETRY_SPAN_ID_PROPERTY, TelemetryService, } from "./telemetry-service.js";
+export { TelemetryService } from "./telemetry-service.js";