@uipath/common 1.201.0-preview.132 → 1.202.0-preview.134

package/dist/catch-error.d.ts

@@ -1,4 +1,18 @@
 type CatchErrorResult<T> = [undefined, T] | [Error, undefined];
+/**
+ * Describe a thrown value that is not an `Error`.
+ *
+ * `String(value)` on an object yields `"[object Object]"`, which is what a
+ * user ends up reading when a command reports `Instructions: error.message`
+ * — the real content is gone. Libraries that reject with a plain object
+ * (some SDK clients, validation results) hit exactly that. So: use the
+ * value's own `message` when it has one, otherwise serialize it, and only
+ * fall back to `String` when neither works.
+ *
+ * Exported for the error-handler extractors, which face the same raw
+ * `unknown` values when a caller hands them one directly.
+ */
+export declare function describeThrownValue(value: unknown): string;
 export declare function catchError<T>(fnOrPromise: Promise<T>): Promise<CatchErrorResult<T>>;
 export declare function catchError<T>(fnOrPromise: () => Promise<T>): Promise<CatchErrorResult<T>>;
 export declare function catchError<T>(fnOrPromise: () => T): CatchErrorResult<T>;

package/dist/catch-error.js

@@ -1,4 +1,258 @@
+// src/telemetry/pseudonymize.ts
+var SHA256_K = new Uint32Array([
+  1116352408,
+  1899447441,
+  3049323471,
+  3921009573,
+  961987163,
+  1508970993,
+  2453635748,
+  2870763221,
+  3624381080,
+  310598401,
+  607225278,
+  1426881987,
+  1925078388,
+  2162078206,
+  2614888103,
+  3248222580,
+  3835390401,
+  4022224774,
+  264347078,
+  604807628,
+  770255983,
+  1249150122,
+  1555081692,
+  1996064986,
+  2554220882,
+  2821834349,
+  2952996808,
+  3210313671,
+  3336571891,
+  3584528711,
+  113926993,
+  338241895,
+  666307205,
+  773529912,
+  1294757372,
+  1396182291,
+  1695183700,
+  1986661051,
+  2177026350,
+  2456956037,
+  2730485921,
+  2820302411,
+  3259730800,
+  3345764771,
+  3516065817,
+  3600352804,
+  4094571909,
+  275423344,
+  430227734,
+  506948616,
+  659060556,
+  883997877,
+  958139571,
+  1322822218,
+  1537002063,
+  1747873779,
+  1955562222,
+  2024104815,
+  2227730452,
+  2361852424,
+  2428436474,
+  2756734187,
+  3204031479,
+  3329325298
+]);
+var SHA256_INITIAL_STATE = new Uint32Array([
+  1779033703,
+  3144134277,
+  1013904242,
+  2773480762,
+  1359893119,
+  2600822924,
+  528734635,
+  1541459225
+]);
+
+// src/singleton.ts
+var PREFIX = "@uipath/common/";
+var _g = globalThis;
+function singleton(ctorOrName) {
+  const name = typeof ctorOrName === "string" ? ctorOrName : ctorOrName.name;
+  const key = Symbol.for(PREFIX + name);
+  return {
+    get(fallback) {
+      return _g[key] ?? fallback;
+    },
+    set(value) {
+      _g[key] = value;
+    },
+    clear() {
+      delete _g[key];
+    },
+    getOrInit(factory, guard) {
+      const existing = _g[key];
+      if (existing != null && typeof existing === "object") {
+        if (!guard || guard(existing)) {
+          return existing;
+        }
+      }
+      const instance = factory();
+      _g[key] = instance;
+      return instance;
+    }
+  };
+}
+
+// src/telemetry/supplied-values.ts
+var suppliedValuesSlot = singleton("TelemetrySuppliedArgumentValues");
+
+// src/telemetry/pii-redactor.ts
+var SENSITIVE_NAME_TOKENS = new Set([
+  "token",
+  "tokens",
+  "secret",
+  "secrets",
+  "password",
+  "passwords",
+  "pwd",
+  "credential",
+  "credentials",
+  "auth",
+  "authentication",
+  "authorization",
+  "authority",
+  "cert",
+  "certificate",
+  "certificates"
+]);
+var SENSITIVE_KEY_PREFIXES = new Set([
+  "api",
+  "access",
+  "client",
+  "private",
+  "public",
+  "signing",
+  "encryption",
+  "session",
+  "master",
+  "shared",
+  "root",
+  "ssh",
+  "rsa",
+  "aes",
+  "hmac",
+  "oauth"
+]);
+var SOURCE_FILE_EXTENSIONS = new Set([
+  "ts",
+  "tsx",
+  "js",
+  "jsx",
+  "mjs",
+  "cjs",
+  "cts",
+  "mts",
+  "py",
+  "cs",
+  "java",
+  "go",
+  "rs",
+  "rb",
+  "php",
+  "sh",
+  "ps1",
+  "json",
+  "jsonc",
+  "yaml",
+  "yml",
+  "xml",
+  "xaml",
+  "md",
+  "txt",
+  "log",
+  "css",
+  "html",
+  "htm",
+  "csproj",
+  "nuspec",
+  "sql"
+]);
+var QUOTED_LITERAL_MAX_SPAN = 200;
+var QUOTED_LITERAL_PATTERN = new RegExp([
+  `(?<![A-Za-z0-9])'(?:[^\\
+]|\\.){2,${QUOTED_LITERAL_MAX_SPAN}}?'(?![A-Za-z0-9])`,
+  `(?<![A-Za-z0-9])"(?:[^\\
+]|\\.){2,${QUOTED_LITERAL_MAX_SPAN}}?"(?![A-Za-z0-9])`
+].join("|"), "g");
+var MESSAGE_NAMES = new Set([
+  "message",
+  "errormessage",
+  "errmessage",
+  "error_message",
+  "msg",
+  "detail",
+  "details",
+  "reason",
+  "instructions",
+  "warning"
+]);
+function nameTokens(name) {
+  return name.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2").split(/[\s._-]+/).map((t) => t.toLowerCase()).filter(Boolean);
+}
+function isSensitiveName(name) {
+  const tokens = nameTokens(name);
+  for (let i = 0;i < tokens.length; i++) {
+    const token = tokens[i];
+    if (SENSITIVE_NAME_TOKENS.has(token)) {
+      return true;
+    }
+    if (token === "key" || token === "keys") {
+      const prev = tokens[i - 1];
+      if (prev && SENSITIVE_KEY_PREFIXES.has(prev)) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
 // src/catch-error.ts
+var MAX_SERIALIZED_LENGTH = 500;
+var TRUNCATION_SUFFIX = "…(truncated)";
+var REDACTED = "[REDACTED]";
+function cap(text) {
+  return text.length > MAX_SERIALIZED_LENGTH ? `${text.slice(0, MAX_SERIALIZED_LENGTH)}${TRUNCATION_SUFFIX}` : text;
+}
+function omitSensitive(key, value) {
+  return key.length > 0 && isSensitiveName(key) ? REDACTED : value;
+}
+function describeThrownValue(value) {
+  if (typeof value !== "object" || value === null) {
+    return String(value);
+  }
+  let message;
+  try {
+    message = value.message;
+  } catch {
+    message = undefined;
+  }
+  if (typeof message === "string" && message.length > 0) {
+    return cap(message);
+  }
+  try {
+    const json = JSON.stringify(value, omitSensitive);
+    if (json !== undefined) {
+      return cap(json);
+    }
+  } catch {}
+  return String(value);
+}
+function toError(error) {
+  return error instanceof Error ? error : new Error(describeThrownValue(error), { cause: error });
+}
 function isPromiseLike(value) {
   return value !== null && typeof value === "object" && typeof value.then === "function";
 }
@@ -13,20 +267,15 @@ function catchError(fnOrPromise) {
     }
     return [undefined, result];
   } catch (error) {
-    return [
-      error instanceof Error ? error : new Error(String(error)),
-      undefined
-    ];
+    return [toError(error), undefined];
   }
 }
 function settlePromiseLike(thenable) {
-  return Promise.resolve(thenable).then((data) => [undefined, data]).catch((error) => [
-    error instanceof Error ? error : new Error(String(error)),
-    undefined
-  ]);
+  return Promise.resolve(thenable).then((data) => [undefined, data]).catch((error) => [toError(error), undefined]);
 }
 export {
-  catchError
+  catchError,
+  describeThrownValue
 };
 
-//# debugId=246638ED7A60E04D64756E2164756E21
+//# debugId=523FB0079E2C37BE64756E2164756E21

package/dist/classified-failure.d.ts

@@ -0,0 +1,28 @@
+import { type FailureOutput } from "./formatter";
+/**
+ * Build the standard failure envelope for `error`, classified.
+ *
+ * `Message` says what the command was doing; `Instructions` carries the detail
+ * from {@link extractErrorDetails}, along with the `ErrorCode`, `Retry` and
+ * `Context` that agents branch on. Building the envelope from
+ * `extractErrorMessage` instead drops those three, so a transient 5xx reports
+ * as `unknown_error` / `RetryWillNotFix` and callers are told never to retry.
+ *
+ * Returns the envelope rather than emitting it, so each command still passes it
+ * to the `OutputFormatter` it imported. That keeps `vi.mock("@uipath/common")`
+ * able to intercept the call — a helper here that emitted directly would close
+ * over the real formatter and command specs could no longer assert on it.
+ *
+ * Pair it with the caller's own exit, which stays visible at the call site:
+ *
+ * ```ts
+ * OutputFormatter.error(await classifiedFailure("Error listing folders", err));
+ * processContext.exit(1);
+ * ```
+ */
+export declare function classifiedFailure(message: string, error: unknown): Promise<FailureOutput>;
+/**
+ * Collapse whitespace and cap length so a platform's raw response body can be
+ * quoted inside `Instructions` without dumping an arbitrarily long payload.
+ */
+export declare function summarizePlatformBody(body: string): string;

package/dist/entity-name-rules.d.ts

@@ -0,0 +1,18 @@
+import type { ValidationError } from "./body-validators";
+export type NameKind = "entity" | "field" | "choice set";
+/**
+ * The reserved-name half of the rules, split out so a caller that already checks
+ * name FORMAT does not report the same name twice. `solution pack` does exactly
+ * that: the authored document has its own format pattern, but the reserved lists
+ * are the server's and apply to every author.
+ *
+ * Field names are only reserved for CUSTOM fields — `Id`, `CreateTime`,
+ * `CreatedBy`, `UpdateTime` and `UpdatedBy` are the system fields' own names, so
+ * callers must not run this over them.
+ */
+export declare function findReservedNameError(name: string, kind: NameKind): ValidationError | null;
+/**
+ * Check an entity / field / choice-set name against the server's format,
+ * reserved-name, and reserved-keyword rules.
+ */
+export declare function validateName(name: string, kind: NameKind): ValidationError | null;

package/dist/entity-name-rules.js

@@ -0,0 +1,241 @@
+// src/entity-name-rules.ts
+var RESERVED_SQL_KEYWORDS_LOWER = new Set(["group", "order"]);
+var ENTITY_NAME_PATTERN = /^[a-zA-Z][a-zA-Z0-9_]{2,99}$/;
+var FIELD_NAME_PATTERN = /^[a-zA-Z][a-zA-Z0-9]{2,99}$/;
+var RESERVED_FIELD_NAMES_LOWER = new Set([
+  "id",
+  "createdby",
+  "createtime",
+  "updatedby",
+  "updatetime",
+  "recordowner",
+  "version"
+]);
+var RESERVED_KEYWORDS_LOWER = new Set([
+  "abstract",
+  "as",
+  "base",
+  "bool",
+  "break",
+  "byte",
+  "case",
+  "catch",
+  "char",
+  "checked",
+  "class",
+  "const",
+  "continue",
+  "decimal",
+  "default",
+  "delegate",
+  "do",
+  "double",
+  "else",
+  "enum",
+  "event",
+  "explicit",
+  "extern",
+  "false",
+  "finally",
+  "fixed",
+  "float",
+  "for",
+  "foreach",
+  "goto",
+  "if",
+  "implicit",
+  "in",
+  "int",
+  "interface",
+  "internal",
+  "is",
+  "lock",
+  "long",
+  "namespace",
+  "new",
+  "null",
+  "object",
+  "operator",
+  "out",
+  "override",
+  "params",
+  "private",
+  "protected",
+  "public",
+  "readonly",
+  "ref",
+  "return",
+  "sbyte",
+  "sealed",
+  "short",
+  "sizeof",
+  "stackalloc",
+  "static",
+  "string",
+  "struct",
+  "switch",
+  "this",
+  "throw",
+  "true",
+  "try",
+  "typeof",
+  "uint",
+  "ulong",
+  "unchecked",
+  "unsafe",
+  "ushort",
+  "using",
+  "virtual",
+  "void",
+  "volatile",
+  "while",
+  "addhandler",
+  "addressof",
+  "alias",
+  "and",
+  "andalso",
+  "boolean",
+  "byref",
+  "byval",
+  "call",
+  "cbool",
+  "cbyte",
+  "cchar",
+  "cdate",
+  "cdbl",
+  "cdec",
+  "cint",
+  "clng",
+  "cobj",
+  "csbyte",
+  "cshort",
+  "csng",
+  "cstr",
+  "ctype",
+  "cuint",
+  "culng",
+  "cushort",
+  "date",
+  "declare",
+  "dim",
+  "directcast",
+  "each",
+  "elseif",
+  "end",
+  "endif",
+  "erase",
+  "error",
+  "exit",
+  "friend",
+  "function",
+  "get",
+  "gettype",
+  "getxmlnamespace",
+  "global",
+  "gosub",
+  "goto",
+  "handles",
+  "implements",
+  "imports",
+  "inherits",
+  "integer",
+  "isnot",
+  "let",
+  "lib",
+  "like",
+  "loop",
+  "me",
+  "mod",
+  "module",
+  "mustinherit",
+  "mustoverride",
+  "mybase",
+  "myclass",
+  "narrowing",
+  "next",
+  "not",
+  "nothing",
+  "notinheritable",
+  "notoverridable",
+  "of",
+  "on",
+  "option",
+  "optional",
+  "or",
+  "orelse",
+  "overloads",
+  "overridable",
+  "overrides",
+  "paramarray",
+  "partial",
+  "property",
+  "raiseevent",
+  "redim",
+  "rem",
+  "removehandler",
+  "resume",
+  "select",
+  "set",
+  "shadows",
+  "shared",
+  "single",
+  "step",
+  "stop",
+  "structure",
+  "sub",
+  "synclock",
+  "then",
+  "to",
+  "trycast",
+  "uinteger",
+  "ushort",
+  "variant",
+  "wend",
+  "when",
+  "widening",
+  "with",
+  "withevents",
+  "writeonly",
+  "xor"
+]);
+function findReservedNameError(name, kind) {
+  if (kind === "field" && RESERVED_FIELD_NAMES_LOWER.has(name.toLowerCase())) {
+    return {
+      message: `Field name '${name}' is reserved`,
+      instructions: "The following field names are reserved by the platform (case-insensitive): Id, CreatedBy, CreateTime, UpdatedBy, UpdateTime, RecordOwner, Version. Pick a different name."
+    };
+  }
+  if (RESERVED_KEYWORDS_LOWER.has(name.toLowerCase())) {
+    return {
+      message: `${kind === "entity" ? "Entity" : kind === "field" ? "Field" : "Choice set"} name '${name}' is a reserved C# or VB keyword`,
+      instructions: "Reserved keywords are rejected with RESERVED_LANGUAGE_KEYWORDS. Pick a domain-specific rename, for example 'Case' -> 'WorkItem', 'Class' -> 'Category', 'New' -> 'IsNew'."
+    };
+  }
+  if (kind === "entity" && RESERVED_SQL_KEYWORDS_LOWER.has(name.toLowerCase())) {
+    return {
+      message: `Entity name '${name}' is a reserved SQL keyword`,
+      instructions: "The platform rejects 'Order' and 'Group' as entity names. Pick a domain-specific name such as 'PurchaseOrder' or 'TeamGroup'."
+    };
+  }
+  return null;
+}
+function validateName(name, kind) {
+  const reserved = findReservedNameError(name, kind);
+  if (reserved) {
+    return reserved;
+  }
+  const pattern = kind === "field" ? FIELD_NAME_PATTERN : ENTITY_NAME_PATTERN;
+  if (!pattern.test(name)) {
+    return {
+      message: `Invalid ${kind} name '${name}'`,
+      instructions: kind === "field" ? "Field names must start with a letter, contain only letters and digits (no underscores), and be 3-100 characters long." : "Names must start with a letter, contain only letters, digits, and underscores, and be 3-100 characters long."
+    };
+  }
+  return null;
+}
+export {
+  findReservedNameError,
+  validateName
+};
+
+//# debugId=DEFF72153B22EA2764756E2164756E21

package/dist/error-handler.d.ts

@@ -62,6 +62,19 @@ export interface LocalPermissionError {
     /** Actionable, user-facing remediation steps. */
     instructions: string;
 }
+/**
+ * Actionable instructions carried on an error object, when present. The
+ * repo-wide convention (`trackedAction` surfaces it the same way) is a string
+ * `instructions` field on the error — the CLI host's `InstallRefusedError`
+ * family, `FilterEvaluationError`, `LocalPermissionError`, and future shapes
+ * alike. Duck-typed on purpose, never `instanceof`: these errors cross bundle
+ * boundaries (a packager/executor pull inside `uip solution pack` / `run`
+ * throws from the host bundle into the tool's), where class identity does not
+ * survive. Lets an error funnel that only carries a message string keep the
+ * actionable next step (retry, the escape hatches, "remove the shadowing
+ * copy") attached to the failure instead of replacing it with a generic hint.
+ */
+export declare function carriedInstructions(error: unknown): string | undefined;
 export declare function formatErrorChain(error: unknown): string;
 /**
  * Classify an outbound connectivity failure by walking the error graph.

package/dist/exit-code.d.ts

@@ -0,0 +1,42 @@
+/**
+ * The one place that writes `process.exitCode`.
+ *
+ * A command signals its outcome by calling `context.exit(code)`; a failure
+ * envelope printed through `OutputFormatter.error()` sets the non-zero default
+ * on its own. Both land here, so anything that has to observe the outcome —
+ * telemetry, the exit-code bridge in the browser host, a timing report — reads
+ * one value written in one place instead of racing scattered assignments.
+ *
+ * Hosts that adopt a status from outside the process (the version-sync re-exec
+ * takes the child's) call {@link setExitCode} directly. Everything inside a
+ * command handler goes through `context.exit`.
+ *
+ * `bun scripts/lint-exit-code.ts` (part of `bun run lint`) keeps this the only
+ * writer: an assignment to `process.exitCode` in any other package file fails.
+ */
+/**
+ * Record `code` as the process exit code.
+ *
+ * Last write wins, which is what the scattered assignments did: an explicit
+ * `exit(code)` is the caller's final word. A caller that must not overwrite an
+ * earlier failure with success — the exit(0) at the end of a run — checks
+ * {@link getExitCode} first; the CLI host's `context.exit` does exactly that.
+ */
+export declare function setExitCode(code: number): void;
+/**
+ * The recorded exit code; `0` when nothing has set one.
+ *
+ * Node coerces a numeric string on assignment and rejects anything else, so a
+ * non-number here means unset — or a browser host writing to the `process`
+ * shim, which is not a code either way.
+ */
+export declare function getExitCode(): number;
+/**
+ * Clear the recorded exit code.
+ *
+ * For hosts that run more than one invocation in a process (the browser bundle,
+ * the MCP bridge): without this, a failing run's `1` leaks into the next run's
+ * success path. Not for command code — a command that wants to exit clean says
+ * so with `context.exit(0)`.
+ */
+export declare function resetExitCode(): void;