@uipath/common 1.203.0-preview.212 → 1.204.0-preview.211

package/dist/local-permission-codes.d.ts

@@ -0,0 +1 @@
+export declare const LOCAL_PERMISSION_ERROR_CODES: ReadonlySet<string>;

package/dist/mime-types.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Extension-to-MIME lookup for upload paths. Pure leaf (no imports) so both
+ * barrels export it and any layer can import it (AGENTS.md Hard Rule 19).
+ */
+export declare const OCTET_STREAM = "application/octet-stream";
+export declare const MIME_TYPES_BY_EXTENSION: Readonly<Record<string, string>>;
+/** MIME type for a file name (pass a basename). Unknown or missing extension gives octet-stream. */
+export declare function mimeTypeForFileName(fileName: string): string;

package/dist/sdk-user-agent.js

@@ -40,10 +40,138 @@ function isTelemetryDisabled() {
   return value === "1" || value === "true";
 }
 
+// src/telemetry/telemetry-dimensions.ts
+var BaseDimensions = {
+  ApplicationName: "ApplicationName",
+  ProductVersion: "ProductVersion",
+  InstallationId: "InstallationId",
+  CloudUserId: "CloudUserId",
+  CloudTenantId: "CloudTenantId",
+  CloudOrganizationId: "CloudOrganizationId",
+  IsInternalUser: "IsInternalUser",
+  Environment: "Environment",
+  BaseUrl: "BaseUrl",
+  Region: "Region",
+  Agent: "Agent",
+  AgentVersion: "AgentVersion",
+  AgentModel: "AgentModel",
+  ToolName: "ToolName",
+  ToolVersion: "ToolVersion",
+  ExecutionContext: "ExecutionContext",
+  CiProvider: "CiProvider",
+  SessionIdSource: "SessionIdSource",
+  SessionId: "SessionId"
+};
+var CommandDimensions = {
+  IsCommand: "IsCommand",
+  IsReexec: "IsReexec",
+  CommandName: "CommandName",
+  ExitCode: "ExitCode",
+  TerminalOutcome: "TerminalOutcome",
+  ErrorClass: "ErrorClass",
+  TerminalSignal: "TerminalSignal",
+  ErrorMessage: "ErrorMessage",
+  SkillName: "SkillName",
+  ProductArea: "ProductArea",
+  Mode: "Mode"
+};
+var ShipDimensions = {
+  ShipKind: "ShipKind",
+  Target: "Target",
+  ProjectType: "ProjectType",
+  ProjectTypes: "ProjectTypes",
+  ArtifactCorrelationKey: "ArtifactCorrelationKey",
+  PackageName: "PackageName",
+  PackageVersion: "PackageVersion",
+  PackageVersionKey: "PackageVersionKey",
+  DeploymentKey: "DeploymentKey",
+  SolutionId: "SolutionId",
+  FolderKey: "FolderKey",
+  FeedId: "FeedId"
+};
+var ErrorDimensions = {
+  Result: "Result",
+  ErrorCode: "ErrorCode",
+  Retry: "Retry",
+  ErrorMessage: "ErrorMessage"
+};
+var AuthDimensions = {
+  AuthenticationMethod: "AuthenticationMethod",
+  Success: "Success",
+  Reason: "Reason"
+};
+var SkillsDimensions = {
+  SchemaVersion: "SchemaVersion",
+  AgentType: "AgentType",
+  SkillsVersion: "SkillsVersion",
+  UipSubcommand: "UipSubcommand",
+  FileExtension: "FileExtension",
+  SubagentModel: "SubagentModel",
+  SubagentType: "SubagentType",
+  PermissionMode: "PermissionMode",
+  EffortLevel: "EffortLevel",
+  SessionSource: "SessionSource",
+  Outcome: "Outcome",
+  DurationMs: "DurationMs",
+  Source: "Source"
+};
+var PackagerDimensions = {
+  ProjectId: "ProjectId",
+  ProjectType: "ProjectType",
+  SolutionId: "SolutionId"
+};
+var ScopeDimensions = {
+  FolderId: "FolderId"
+};
+var ID_DIMENSIONS = new Set([
+  BaseDimensions.CloudUserId,
+  BaseDimensions.CloudTenantId,
+  BaseDimensions.CloudOrganizationId,
+  BaseDimensions.InstallationId,
+  ShipDimensions.ArtifactCorrelationKey,
+  ShipDimensions.PackageVersionKey,
+  ShipDimensions.DeploymentKey,
+  ShipDimensions.SolutionId,
+  ShipDimensions.FolderKey,
+  ShipDimensions.FeedId,
+  PackagerDimensions.ProjectId
+]);
+var RESERVED_DIMENSION_NAMES = new Set([
+  ...Object.values(BaseDimensions),
+  ...Object.values(CommandDimensions),
+  ...Object.values(ShipDimensions),
+  ...Object.values(ErrorDimensions),
+  ...Object.values(AuthDimensions),
+  ...Object.values(SkillsDimensions),
+  ...Object.values(PackagerDimensions),
+  ...Object.values(ScopeDimensions)
+]);
+var CURATED_DIMENSIONS = new Set([
+  BaseDimensions.ApplicationName,
+  BaseDimensions.ProductVersion,
+  BaseDimensions.InstallationId,
+  BaseDimensions.CloudUserId,
+  BaseDimensions.CloudTenantId,
+  BaseDimensions.CloudOrganizationId,
+  BaseDimensions.IsInternalUser,
+  BaseDimensions.Environment,
+  BaseDimensions.BaseUrl,
+  BaseDimensions.Region,
+  BaseDimensions.Agent,
+  BaseDimensions.AgentVersion,
+  BaseDimensions.ToolVersion,
+  BaseDimensions.ExecutionContext,
+  BaseDimensions.CiProvider,
+  BaseDimensions.SessionIdSource,
+  BaseDimensions.SessionId,
+  ...Object.values(CommandDimensions),
+  ...Object.values(ShipDimensions)
+]);
+
 // src/sdk-user-agent.ts
 var USER_AGENT_HEADER = "User-Agent";
 var CODING_AGENT_HEADER = "x-coding-agent-info";
-var AGENT_PROPERTY = "agent";
+var AGENT_PROPERTY = BaseDimensions.Agent;
 var CODING_AGENT_PROPERTY = "CodingAgent";
 var sdkUserAgentHostToken = singleton("SdkUserAgentHostToken");
 function userAgentPatchKey(userAgent) {
@@ -157,4 +285,4 @@ export {
   setSdkUserAgentHostToken
 };
 
-//# debugId=6BBB85462D129AD364756E2164756E21
+//# debugId=159182CCF3CDBCFB64756E2164756E21

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

@@ -1,9 +1,25 @@
 export type TelemetryMode = "build" | "operate" | "troubleshoot";
 export interface TelemetryAttribution {
-    skill_name?: string;
-    product_area?: string;
-    mode?: TelemetryMode;
+    SkillName?: string;
+    ProductArea?: string;
+    Mode?: TelemetryMode;
 }
 export declare function normalizeSkillName(value: unknown): string | undefined;
 export declare function buildCommandTelemetryAttribution(commandPath: string, skillSource?: string): TelemetryAttribution;
 export declare function buildSkillEventTelemetryAttribution(skillSource: unknown, uipSubcommand?: unknown): TelemetryAttribution;
+declare const AGENT_SESSION_ENV: {
+    readonly AgentModel: "UIPATH_AGENT_MODEL";
+    readonly PermissionMode: "UIPATH_PERMISSION_MODE";
+    readonly EffortLevel: "UIPATH_EFFORT_LEVEL";
+    readonly SkillsVersion: "UIPATH_SKILLS_VERSION";
+};
+export type AgentSessionTelemetry = Partial<Record<keyof typeof AGENT_SESSION_ENV, string>>;
+/** Bound a free-ish agent-supplied value to a low-cardinality token: anything
+ * outside a safe charset becomes `_` (no quotes, backslashes, control chars or
+ * pipes survive), capped at 120 chars. Value-level PII redaction still runs
+ * downstream. */
+export declare function sanitizeTelemetryToken(value: string): string;
+/** Optional request dimensions from the agent-session env; a variable that is
+ * unset or empty contributes no key. */
+export declare function buildAgentSessionTelemetry(env: Record<string, string | undefined>): AgentSessionTelemetry;
+export {};

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

@@ -2,21 +2,42 @@
  * 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.
+ * percentile groups by, so the name has to be the command and nothing else.
+ * The shape is the UiPath business-telemetry convention's
+ * `[FeatureName].[PerformedAction]`: exactly two PascalCase segments, `Cli`
+ * plus the command path folded into one action token — `uip or assets list`
+ * is `Cli.OrAssetsList` (PRENG-7421).
  *
- * 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.
+ * The path's levels are not lost, they move to dimensions: `CommandName`
+ * carries the spaced path, and `ToolName` / `ProductArea` / `Mode` carry the
+ * groupings a dashboard actually pivots on. That is where the convention says
+ * structured detail belongs, and it is why the name can afford to be flat.
+ *
+ * Two places work out which command ran — `deriveCommandParts` 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. */
+/** The `[FeatureName]` half of every CLI telemetry name. */
+export declare const TELEMETRY_NAME_ROOT = "Cli";
+/**
+ * The binary's own name. Dropped from the parts rather than rendered, so a
+ * caller that includes argv[0] cannot produce `Cli.UipLogin`.
+ */
+export declare const CLI_COMMAND_ROOT = "uip";
+/**
+ * @deprecated Use {@link CLI_COMMAND_ROOT}. Kept so existing consumers can
+ * keep compiling while telemetry request names use {@link TELEMETRY_NAME_ROOT}.
+ * @alias
+ */
 export declare const TELEMETRY_COMMAND_ROOT = "uip";
+/** A run that named no command at all. */
+export declare const TELEMETRY_NAME_BARE_ACTION = "Invoke";
 /**
  * Build a command's telemetry name from the path parts a caller resolved.
  *
@@ -27,34 +48,59 @@ export declare const TELEMETRY_COMMAND_ROOT = "uip";
  *   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.
+ * - the binary name, so `Cli.UipTools` 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
+ * 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.
+ * Whitespace inside a part is a part that was never split — the caller handed
+ * over a joined string. It is split back into tokens 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`. So one argv token that holds
+ * a value contributes one token: `uip "no'pe\nsecond"` is `Cli.Unknown`, not
+ * `Cli.UnknownSecond` — one typo cannot invent a path level the user never
+ * typed. A token whose pieces all read as command names does still split, and
+ * that is the point of the rule: it is how a caller's joined `"help config"`
+ * gets back to two levels.
+ *
+ * That check is the second line of defence, not the first, and it could not be
+ * the first: a positional sits in command position and shape cannot tell one
+ * from a subcommand — `myasset` in `uip or assets get myasset` is lowercase,
+ * dash-free and short, exactly like `assets`. Only the Commander tree knows,
+ * so the tree is what bounds this column. `deriveCommandParts` walks up from
+ * the command object and passes command names only; `cli.core.ts` walks the
+ * tree down from argv, stops at the first token it cannot match, and keeps at
+ * most ONE unmatched token, in first position. `commandPartsFromArgs`
+ * (`parseError.ts`) has no tree at all, so it applies that same rule with an
+ * empty one and keeps exactly one token. So an argument never reaches here —
+ * `uip or assets get <guid>` is `Cli.OrAssetsGet`, and `uip or queues items
+ * add myqueue` stops at the last command the tree recognized. What a shape
+ * check is left to catch is that one first token, 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.
+ * and that is worth seeing rather than collapsing into one `Cli.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;
+/**
+ * The same parts as a person would type them: `uip or assets list`.
+ *
+ * The flat telemetry name cannot be turned back into this — `Cli.OrAssetsList`
+ * has lost where the levels were — so both renderings are built from the parts
+ * and neither is derived from the other. This one is what `CommandName`
+ * carries, what the attribution lookup is keyed on, and what a `--help` hint
+ * has to print to stay a command the user can actually run.
+ *
+ * It runs the parts through the SAME vetting as the name, and that is not
+ * cosmetic. The name collapses an unrecognized token to `Unknown`; a raw join
+ * would put that same token straight in a dimension, and the redactor behind
+ * it only fires on value SHAPES — a GUID would be caught, a queue name or a
+ * solution name would not. Vetting here is what keeps the two renderings
+ * telling the same truth.
+ */
+export declare function commandInvocationPath(parts: readonly string[]): string;

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

@@ -1,6 +1,6 @@
 import type { CliErrorCode, ErrorContext, FailureResultType, RetryHint } from "../formatter";
 import type { TelemetryProperties } from "./telemetry-service";
-export type CommandErrorClass = "auth" | "network_http" | "validation" | "missing_dependency" | "timeout" | "internal" | "unknown" | "user_cancelled";
+export type CommandErrorClass = "auth" | "local_permission" | "network_http" | "validation" | "missing_dependency" | "timeout" | "internal" | "unknown" | "user_cancelled";
 export type TerminalOutcome = "success" | "failure" | "cancelled" | "no_op";
 export interface RecordedCommandFailure {
     result?: FailureResultType;

package/dist/telemetry/environment-info.d.ts

@@ -17,7 +17,7 @@ export declare function normalizeEnvironment(baseUrl: string | undefined): Norma
 export declare function normalizeBaseUrl(baseUrl: string | undefined): string | undefined;
 /**
  * Build the normalized environment telemetry properties for a base URL.
- * `environment` is always present (falling back to `unknown`); `base_url` and
- * `region` are added only when they can be derived safely.
+ * `Environment` is always present (falling back to `unknown`); `BaseUrl` and
+ * `Region` are added only when they can be derived safely.
  */
 export declare function buildEnvironmentProperties(baseUrl: string | undefined): TelemetryProperties;

package/dist/telemetry/index.d.ts

@@ -6,6 +6,7 @@ export { buildEnvironmentProperties, type NormalizedEnvironment, normalizeBaseUr
 export { type CiProvider, detectExecutionContext, EXECUTION_CONTEXT_VALUES, type ExecutionContext, type ExecutionContextDetection, type ExecutionContextDetectionOptions, getExecutionContextTelemetryProperties, setExecutionContextAuthSignal, } from "./execution-context.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 * from "./telemetry-dimensions.js";
 export type { ITelemetryProvider, TelemetryCorrelation, TrackedDependencySpan, TrackedEvent, TrackedException, TrackedSpan, } from "./telemetry-provider.js";
 export type { ITelemetryService, TelemetryContext, TelemetryProperties, } from "./telemetry-service.js";
 export { TelemetryService } from "./telemetry-service.js";