@uipath/common 1.0.4 → 1.195.0

package/dist/option-aliases.d.ts

@@ -0,0 +1,19 @@
+import { type Command, Option } from "commander";
+export interface OptionAliasResult<T> {
+    value: T | undefined;
+    usedDeprecated: boolean;
+    error?: {
+        message: string;
+        instructions: string;
+    };
+}
+export declare function resolveDeprecatedOptionAlias<T>({ preferredValue, deprecatedValue, preferredFlag, deprecatedFlag, }: {
+    preferredValue: T | undefined;
+    deprecatedValue: T | undefined;
+    preferredFlag: string;
+    deprecatedFlag: string;
+}): OptionAliasResult<T>;
+export declare function warnDeprecatedOptionAlias(deprecatedFlag: string, preferredFlag: string): void;
+export declare function createHiddenDeprecatedTenantOption(flags?: string): Option;
+export declare function addHiddenDeprecatedTenantOption<T extends Command>(command: T, flags?: string): T;
+export declare function warnDeprecatedTenantOption(tenant?: string): void;

package/dist/orchestrator-urls.d.ts

@@ -19,8 +19,7 @@
  *
  * The `path` argument on {@link buildOrchestratorUrl} is left as a string
  * **without** automatic encoding so callers can include OData filter syntax
- * and existing URL-encoded query strings; this matches the existing inline
- * pattern used in `solution-tool/src/services/apps-binding-sync.ts`.
+ * and existing URL-encoded query strings.
  *
  * For the Studio Web URL pattern (`/{org}/studio_/...`) — which has no
  * tenant segment by design — see `packages/maestro-sdk` instead. That

package/dist/polling/index.d.ts

@@ -1,5 +1,7 @@
 export { createPollAbortController } from "./abort-controller";
 export { msToDuration } from "./format-utils";
+export type { PollFailureMapped, PollFailureReason, } from "./poll-failure-mapping";
+export { mapPollFailure } from "./poll-failure-mapping";
 export { pollUntil } from "./poll-until";
 export { isFailureStatus, isSuccessStatus, isTerminalStatus, } from "./terminal-statuses";
 export type { BackoffConfig, OnErrorCallback, PollContext, PollUntilOptions, PollUntilResult, } from "./types";

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

@@ -0,0 +1,21 @@
+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";
+export interface PollFailureMapped {
+    reason: PollFailureReason;
+    /** `${label} polling {timed out | failed: <err> | was interrupted | was aborted}`. */
+    message: string;
+    /** `2` for Timeout, `1` otherwise. */
+    exitCode: number;
+}
+/**
+ * Maps a non-completed `pollUntil` result to `{ reason, message, exitCode }`.
+ * `label` prefixes the message (e.g. `"Deployment"` → `"Deployment polling timed out"`).
+ * Caller must check the outcome is non-completed before invoking.
+ */
+export declare function mapPollFailure(pollResult: {
+    outcome: PollOutcome;
+    error?: {
+        message?: string;
+    };
+}, label: string): PollFailureMapped;

package/dist/sdk-user-agent.d.ts

@@ -0,0 +1,12 @@
+export interface SdkUserAgentPackageInfo {
+    name: string;
+    version: string;
+}
+export type SdkHttpHeaders = Record<string, string>;
+export declare function getSdkUserAgentToken(pkg: SdkUserAgentPackageInfo): string;
+export declare function setSdkUserAgentHostToken(token: string | undefined): void;
+export declare function addSdkUserAgentHeader(headers: SdkHttpHeaders | undefined, userAgent: string): SdkHttpHeaders;
+export declare function withSdkUserAgentHeader(headers: unknown, userAgent: string): unknown;
+export declare function installSdkUserAgentHeader(BaseApiClass: {
+    prototype: unknown;
+}, userAgent: string): void;

package/dist/sdk-user-agent.js

@@ -0,0 +1,143 @@
+// 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/sdk-user-agent.ts
+var USER_AGENT_HEADER = "User-Agent";
+var sdkUserAgentHostToken = singleton("SdkUserAgentHostToken");
+function userAgentPatchKey(userAgent) {
+  return Symbol.for(`@uipath/common/sdk-user-agent/${userAgent}`);
+}
+function splitUserAgentTokens(value) {
+  return value?.trim().split(/\s+/).filter(Boolean) ?? [];
+}
+function appendUserAgentToken(value, userAgent) {
+  const tokens = splitUserAgentTokens(value);
+  const seen = new Set(tokens);
+  for (const token of splitUserAgentTokens(userAgent)) {
+    if (!seen.has(token)) {
+      tokens.push(token);
+      seen.add(token);
+    }
+  }
+  return tokens.join(" ");
+}
+function getEffectiveUserAgent(userAgent) {
+  return appendUserAgentToken(sdkUserAgentHostToken.get(), userAgent);
+}
+function isHeadersLike(headers) {
+  return typeof headers === "object" && headers !== null && "get" in headers && typeof headers.get === "function" && "set" in headers && typeof headers.set === "function";
+}
+function getSdkUserAgentToken(pkg) {
+  const packageName = pkg.name.replace(/^@uipath\//, "");
+  return getEffectiveUserAgent(`${packageName}/${pkg.version}`);
+}
+function setSdkUserAgentHostToken(token) {
+  if (token === undefined) {
+    sdkUserAgentHostToken.clear();
+    return;
+  }
+  sdkUserAgentHostToken.set(token);
+}
+function addSdkUserAgentHeader(headers, userAgent) {
+  const result = { ...headers ?? {} };
+  const effectiveUserAgent = getEffectiveUserAgent(userAgent);
+  const headerName = Object.keys(result).find((key) => key.toLowerCase() === USER_AGENT_HEADER.toLowerCase());
+  if (headerName) {
+    result[headerName] = appendUserAgentToken(result[headerName], effectiveUserAgent);
+  } else {
+    result[USER_AGENT_HEADER] = effectiveUserAgent;
+  }
+  return result;
+}
+function withSdkUserAgentHeader(headers, userAgent) {
+  const effectiveUserAgent = getEffectiveUserAgent(userAgent);
+  if (isHeadersLike(headers)) {
+    headers.set(USER_AGENT_HEADER, appendUserAgentToken(headers.get(USER_AGENT_HEADER), effectiveUserAgent));
+    return headers;
+  }
+  if (Array.isArray(headers)) {
+    const result = headers.map((entry) => {
+      const [key, value] = entry;
+      return [key, value];
+    });
+    const headerIndex = result.findIndex(([key]) => key.toLowerCase() === USER_AGENT_HEADER.toLowerCase());
+    if (headerIndex >= 0) {
+      const [key, value] = result[headerIndex];
+      result[headerIndex] = [
+        key,
+        appendUserAgentToken(value, effectiveUserAgent)
+      ];
+    } else {
+      result.push([USER_AGENT_HEADER, effectiveUserAgent]);
+    }
+    return result;
+  }
+  return addSdkUserAgentHeader(typeof headers === "object" && headers !== null ? { ...headers } : {}, effectiveUserAgent);
+}
+function withUserAgentInitOverride(initOverrides, userAgent) {
+  return async (requestContext) => {
+    const initWithUserAgent = {
+      ...requestContext.init,
+      headers: withSdkUserAgentHeader(requestContext.init.headers, userAgent)
+    };
+    const override = typeof initOverrides === "function" ? await initOverrides({
+      ...requestContext,
+      init: initWithUserAgent
+    }) : initOverrides;
+    return {
+      ...override ?? {},
+      headers: withSdkUserAgentHeader(override?.headers ?? initWithUserAgent.headers, userAgent)
+    };
+  };
+}
+function installSdkUserAgentHeader(BaseApiClass, userAgent) {
+  const prototype = BaseApiClass.prototype;
+  const patchKey = userAgentPatchKey(userAgent);
+  if (prototype[patchKey]) {
+    return;
+  }
+  if (typeof prototype.request !== "function") {
+    throw new Error("Generated BaseAPI request function not found.");
+  }
+  const originalRequest = prototype.request;
+  prototype.request = function requestWithUserAgent(context, initOverrides) {
+    return originalRequest.call(this, context, withUserAgentInitOverride(initOverrides, userAgent));
+  };
+  Object.defineProperty(prototype, patchKey, {
+    value: true
+  });
+}
+export {
+  withSdkUserAgentHeader,
+  setSdkUserAgentHostToken,
+  installSdkUserAgentHeader,
+  getSdkUserAgentToken,
+  addSdkUserAgentHeader
+};

package/package.json

@@ -1,51 +1,45 @@
 {
-    "name": "@uipath/common",
-    "version": "1.0.4",
-    "description": "Common infrastructure needed by uip tools.",
-    "repository": {
-        "type": "git",
-        "url": "https://github.com/UiPath/cli.git",
-        "directory": "packages/common"
+  "name": "@uipath/common",
+  "license": "MIT",
+  "version": "1.195.0",
+  "description": "Common infrastructure needed by uip tools.",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/UiPath/cli.git",
+    "directory": "packages/common"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/"
+  },
+  "type": "module",
+  "main": "./dist/index.js",
+  "exports": {
+    ".": {
+      "browser": {
+        "types": "./dist/index.browser.d.ts",
+        "default": "./dist/index.browser.js"
+      },
+      "default": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      }
     },
-    "publishConfig": {
-        "registry": "https://registry.npmjs.org/"
+    "./sdk-user-agent": {
+      "types": "./dist/sdk-user-agent.d.ts",
+      "default": "./dist/sdk-user-agent.js"
     },
-    "type": "module",
-    "main": "./dist/index.js",
-    "exports": {
-        ".": {
-            "types": "./dist/index.d.ts",
-            "default": "./dist/index.js"
-        },
-        "./telemetry": {
-            "types": "./dist/telemetry/index.d.ts",
-            "default": "./dist/telemetry/index.js"
-        }
-    },
-    "files": [
-        "dist"
-    ],
-    "maintainers": [
-        "aoltean16",
-        "mihaigirleanu",
-        "vlad-uipath"
-    ],
-    "scripts": {
-        "build": "bun build ./src/index.ts --outdir dist --format esm --target node --external applicationinsights && bun build ./src/telemetry/index.ts --outfile dist/telemetry/index.js --format esm --target browser && tsc -p tsconfig.build.json --noCheck",
-        "typecheck": "tsc --noEmit",
-        "lint": "biome check .",
-        "test": "vitest run",
-        "test:coverage": "vitest run --coverage"
-    },
-    "devDependencies": {
-        "@jmespath-community/jmespath": "^1.3.0",
-        "@types/js-yaml": "^4.0.9",
-        "@types/node": "^25.5.2",
-        "@uipath/filesystem": "1.0.4",
-        "commander": "^14.0.3",
-        "js-yaml": "^4.1.0",
-        "jsonpath-plus": "^10.4.0",
-        "typescript": "^6.0.2"
-    },
-    "gitHead": "e496ee5b65951c8047259ab50d7d6a284eea58a9"
+    "./telemetry": {
+      "types": "./dist/telemetry/index.d.ts",
+      "default": "./dist/telemetry/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "maintainers": [
+    "aoltean16",
+    "mihaigirleanu",
+    "vlad-uipath"
+  ],
+  "gitHead": "65fabb84552758b2710d8ca68470e70a9b1d19bc"
 }