@uipath/common 1.199.0-preview.99 → 1.200.0-preview.109

package/dist/formatter.d.ts

@@ -164,6 +164,25 @@ export declare class FilterEvaluationError extends Error {
     readonly result: FailureResultType;
     constructor(filter: string, cause: unknown);
 }
+/**
+ * Thrown by `trackedAction` when `--output-filter` is combined with a command
+ * whose `--limit` resolved from its declared default instead of the command
+ * line. The filter runs client-side over only the records the command fetched,
+ * so an implicit limit would silently cap the data being filtered — the caller
+ * must state how much data the filter applies to.
+ *
+ * Uses a duck-type `__brand` rather than relying on `instanceof`, because each
+ * tool bundles its own copy of `@uipath/common` and class identity differs
+ * across bundle boundaries.
+ */
+export declare class FilterImplicitLimitError extends Error {
+    readonly __brand: "FilterImplicitLimitError";
+    readonly errorCode: CliErrorCode;
+    readonly instructions: string;
+    readonly retry: RetryHint;
+    readonly result: FailureResultType;
+    constructor(defaultLimit: string);
+}
 /**
  * OutputFormatter namespace for formatting and displaying output.
  */

package/dist/guid.js

@@ -0,0 +1,10 @@
+// src/guid.ts
+var GUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function isGuid(value) {
+  return GUID_REGEX.test(value);
+}
+export {
+  isGuid
+};
+
+//# debugId=F25023E1915C1B3664756E2164756E21

package/dist/host-global-options.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Global options the CLI host owns. It parses them out of argv before
+ * Commander runs (`stripGlobalOptions` in `packages/cli/src/utils/globalOptions.ts`)
+ * so tools never have to define them.
+ *
+ * The host cleans `context.args` only — `process.argv` keeps the raw tokens. A
+ * tool that re-reads `process.argv` therefore still sees these, and must strip
+ * them itself before forwarding. `function-tool`'s passthrough does exactly
+ * that: it reads raw argv on purpose, so unknown flags reach the downstream
+ * CLI verbatim, which means the host's own options would reach it too and be
+ * rejected as unknown options.
+ *
+ * Adding a global option to the host means adding it here as well;
+ * `globalOptions.spec.ts` fails if the two drift apart.
+ */
+/** Host options that consume a following value (`--flag v` / `--flag=v`). */
+export declare const HOST_GLOBAL_OPTIONS_WITH_VALUE: readonly ["--output", "--output-filter", "--log-level", "--log-file", "--profile"];
+/** Host options that take no value. */
+export declare const HOST_GLOBAL_FLAGS: readonly ["--json", "--interactive", "--no-interactive"];
+/**
+ * Drop every host-owned global option from `args`, returning the rest
+ * untouched. Handles both `--flag value` and `--flag=value`; unrelated flags
+ * are always preserved, since a passthrough tool must forward what it does not
+ * own.
+ */
+export declare function stripHostGlobalOptions(args: string[]): string[];

package/dist/index.browser.d.ts

@@ -26,7 +26,7 @@ export * from "./telemetry/command-attribution.js";
 export * from "./telemetry/command-terminal.js";
 export { ConsoleTelemetryProvider } from "./telemetry/console-telemetry-provider.js";
 export type { IContextStorage } from "./telemetry/context-storage.js";
-export { getConfiguredTelemetrySessionId, getTelemetrySessionId, resolveTelemetrySessionId, TELEMETRY_SESSION_ID_ENV, TELEMETRY_SESSION_ID_PROPERTY, } from "./telemetry/session-id.js";
+export { getConfiguredTelemetrySessionId, getTelemetrySessionId, getTelemetrySessionSource, TELEMETRY_SESSION_ID_ENV, TELEMETRY_SESSION_SOURCE_PROPERTY, } from "./telemetry/session-id.js";
 export * from "./telemetry/telemetry-events.js";
 export type { ITelemetryProvider } from "./telemetry/telemetry-provider.js";
 export type { ITelemetryService, TelemetryContext, TelemetryProperties, } from "./telemetry/telemetry-service.js";

package/dist/index.browser.js

@@ -21223,6 +21223,9 @@ async function extractErrorDetails(error, options) {
         if (!extractedMessage) {
           extractedMessage = body;
         }
+        if (extractedMessage && typeof parsedBody.detail === "string" && parsedBody.detail.length > 0 && !extractedMessage.includes(parsedBody.detail)) {
+          extractedMessage = `${extractedMessage}: ${parsedBody.detail}`;
+        }
       } else {
         extractedMessage = isHtmlDocument(body) ? HTML_RESPONSE_MESSAGE : body;
       }
@@ -21277,6 +21280,8 @@ async function extractErrorDetails(error, options) {
       const extra = {};
       if (parsedBody.errorCode)
         extra.errorCode = parsedBody.errorCode;
+      if (parsedBody.detail)
+        extra.detail = parsedBody.detail;
       if (parsedBody.details)
         extra.details = parsedBody.details;
       if (parsedBody.errors != null)
@@ -22254,9 +22259,15 @@ var FAILURE_STATUSES = new Set([
   "stopped"
 ]);
 function isTerminalStatus(status) {
+  if (typeof status !== "string") {
+    return false;
+  }
   return TERMINAL_STATUSES.has(status.toLowerCase());
 }
 function isFailureStatus(status) {
+  if (typeof status !== "string") {
+    return false;
+  }
   return FAILURE_STATUSES.has(status.toLowerCase());
 }
 function isSuccessStatus(status) {
@@ -22479,7 +22490,7 @@ var COMMAND_ATTRIBUTION = commandAttribution([
   ["agents", "build", ["uip.codedagent", "uip.agent"]],
   ["agenthub", "build", ["uip.agenthub"]],
   ["coded-apps", "build", ["uip.codedapp"]],
-  ["functions", "build", ["uip.functions"]],
+  ["functions", "build", ["uip.function", "uip.functions"]],
   ["solution", "build", ["uip.solution"]],
   ["maestro", "build", ["uip.maestro", "uip.case", "uip.flow"]],
   ["llm-observability", "troubleshoot", ["uip.traces"]],
@@ -22842,8 +22853,18 @@ function getInboundTraceContext() {
 
 // src/telemetry/session-id.ts
 var TELEMETRY_SESSION_ID_ENV = "UIPATH_SESSION_ID";
-var TELEMETRY_SESSION_ID_PROPERTY = "session_id";
-var telemetrySessionIdSlot = singleton("TelemetrySessionId");
+var SESSION_ID_MAX_LENGTH = 64;
+var RANDOM_SESSION_ID_LENGTH = 32;
+var TELEMETRY_SESSION_SOURCE_PROPERTY = "session_id_source";
+var CONTROL_CHARACTERS = /\p{Cc}/gu;
+var INHERITED_SESSION_SOURCES = [
+  { envVar: "CLAUDE_CODE_SESSION_ID", source: "claude-code" },
+  { envVar: "CODEX_THREAD_ID", source: "codex" },
+  { envVar: "ANTIGRAVITY_TRAJECTORY_ID", source: "antigravity" },
+  { envVar: "TERM_SESSION_ID", source: "terminal" },
+  { envVar: "WT_SESSION", source: "terminal" }
+];
+var telemetrySessionSlot = singleton("TelemetrySession");
 var telemetryOperationIdSlot = singleton("TelemetryOperationId");
 function getProcessEnv2() {
   return globalThis.process?.env;
@@ -22852,27 +22873,45 @@ function normalizeSessionId(value) {
   if (typeof value !== "string" && typeof value !== "number" && typeof value !== "boolean") {
     return;
   }
-  const trimmed = String(value).trim();
-  return trimmed || undefined;
+  const cleaned = String(value).replace(CONTROL_CHARACTERS, "").trim().slice(0, SESSION_ID_MAX_LENGTH);
+  return cleaned || undefined;
 }
 function getConfiguredTelemetrySessionId() {
   return normalizeSessionId(getProcessEnv2()?.[TELEMETRY_SESSION_ID_ENV]);
 }
-function getTelemetrySessionId() {
-  const envSessionId = getConfiguredTelemetrySessionId();
-  if (envSessionId) {
-    return envSessionId;
+function getInheritedSession(env2) {
+  for (const candidate of INHERITED_SESSION_SOURCES) {
+    const handle = normalizeSessionId(env2[candidate.envVar]);
+    if (handle) {
+      return { id: handle, source: candidate.source };
+    }
+  }
+  return;
+}
+function generateRandomSession() {
+  const bytes = new Uint8Array(RANDOM_SESSION_ID_LENGTH / 2);
+  crypto.getRandomValues(bytes);
+  let hex = "";
+  for (const byte of bytes) {
+    hex += byte.toString(16).padStart(2, "0");
   }
-  const existing = telemetrySessionIdSlot.get();
+  return { id: hex, source: "random" };
+}
+function resolveTelemetrySession() {
+  const existing = telemetrySessionSlot.get();
   if (existing) {
     return existing;
   }
-  const generated = crypto.randomUUID();
-  telemetrySessionIdSlot.set(generated);
-  return generated;
+  const declaredHandle = getConfiguredTelemetrySessionId();
+  const resolved = declaredHandle ? { id: declaredHandle, source: "declared" } : getInheritedSession(getProcessEnv2() ?? {}) ?? generateRandomSession();
+  telemetrySessionSlot.set(resolved);
+  return resolved;
+}
+function getTelemetrySessionId() {
+  return resolveTelemetrySession().id;
 }
-function resolveTelemetrySessionId(existingSessionId) {
-  return getConfiguredTelemetrySessionId() ?? normalizeSessionId(existingSessionId);
+function getTelemetrySessionSource() {
+  return resolveTelemetrySession().source;
 }
 function getTelemetryOperationId() {
   const existing = telemetryOperationIdSlot.get();
@@ -22887,7 +22926,7 @@ function getTelemetryOperationId() {
 // src/telemetry/telemetry-events.ts
 var CommonTelemetryEvents = {
   Error: "uip.error",
-  ShipSucceeded: "ship_succeeded"
+  ShipSucceeded: "uip.ship.succeeded"
 };
 // src/telemetry/detect-agent.ts
 var KNOWN_AGENTS = [
@@ -23250,14 +23289,11 @@ class TelemetryService {
   }
   async trackDependencyOperation(name, type, fn, properties) {
     const parentContext = this.getCurrentContext();
-    if (!parentContext) {
-      throw new Error("trackDependencyOperation must be called within a trackRequest block.");
-    }
-    const childContext = {
+    const childContext = parentContext !== undefined ? {
       operationId: parentContext.operationId,
       parentId: parentContext.id,
       id: this.generateId()
-    };
+    } : this.createRequestContext();
     const startTime = performance.now();
     try {
       const result = await this.contextStorage.run(childContext, fn);
@@ -23278,24 +23314,18 @@ class TelemetryService {
   }
   enrichPropertiesWithContext(properties, context) {
     const globalProperties = getGlobalTelemetryProperties();
-    const existingSessionId = properties?.[TELEMETRY_SESSION_ID_PROPERTY] ?? this.defaultProperties?.[TELEMETRY_SESSION_ID_PROPERTY] ?? globalProperties?.[TELEMETRY_SESSION_ID_PROPERTY];
-    const sessionId = resolveTelemetrySessionId(existingSessionId);
     const enriched = {
       ...getExecutionContextTelemetryProperties(),
       ...globalProperties,
       ...this.defaultProperties,
       ...redactProperties(properties ?? {}),
+      [TELEMETRY_SESSION_SOURCE_PROPERTY]: getTelemetrySessionSource(),
       ...context ? {
         [TELEMETRY_OPERATION_ID_PROPERTY]: context.operationId,
         ...context.parentId !== undefined ? { [TELEMETRY_PARENT_ID_PROPERTY]: context.parentId } : {},
         [TELEMETRY_SPAN_ID_PROPERTY]: context.id
       } : {}
     };
-    if (sessionId === undefined) {
-      delete enriched[TELEMETRY_SESSION_ID_PROPERTY];
-    } else {
-      enriched[TELEMETRY_SESSION_ID_PROPERTY] = sessionId;
-    }
     return enriched;
   }
   generateId() {
@@ -23311,22 +23341,80 @@ class TelemetryService {
     return hex;
   }
 }
+// src/packager-tool-import.ts
+var REGISTER_EXPORT = "registerPackagerFactories";
+async function importPackagerTool(specifier) {
+  const [importError, mod] = await catchError(import(specifier));
+  if (importError)
+    return importError;
+  const register = mod?.[REGISTER_EXPORT];
+  if (typeof register !== "function") {
+    logger.debug(`'${specifier}' has no '${REGISTER_EXPORT}' export — treating it as a ` + "legacy entry point that registered its factories at import.");
+    return;
+  }
+  const [registerError] = catchError(() => {
+    register();
+  });
+  return registerError;
+}
+
+// src/tool-module-import.ts
+async function importToolModule(specifier) {
+  return await import(specifier);
+}
+
 // src/tool-provider.ts
 var factorySlot = singleton("PackagerFactoryProvider");
 function setPackagerFactoryProvider(provider) {
   factorySlot.set(provider);
 }
-async function ensurePackagerFactory(verb) {
+var moduleSlot = singleton("ToolModuleProvider");
+function setToolModuleProvider(provider) {
+  moduleSlot.set(provider);
+}
+async function ensureToolModule(verb, packageName, moduleName) {
+  if (!/^[a-z0-9-]+$/.test(moduleName)) {
+    throw new Error(`Invalid tool module name '${moduleName}'.`);
+  }
+  const provider = moduleSlot.get();
+  if (provider) {
+    return provider(verb, moduleName);
+  }
+  const specifier = `${packageName}/${moduleName}`;
+  const [importError, mod] = await catchError(importToolModule(specifier));
+  if (importError) {
+    logger.debug(`No tool-module provider registered; import of '${specifier}' failed: ${importError.message}`);
+    throw new Error(`This command needs '${packageName}'. Install it.`, {
+      cause: importError
+    });
+  }
+  return mod;
+}
+async function ensurePackagerFactory(verb, packageName) {
   const provider = factorySlot.get();
-  if (!provider) {
-    throw new Error(`Packager factory for '${verb}' is required but no factory provider is registered. ` + `Run 'uip tools install ${verb}' manually.`);
+  if (provider) {
+    await provider(verb);
+    return;
   }
-  await provider(verb);
+  const importError = packageName ? await loadPackagerTool(`${packageName}/packager-tool`) : undefined;
+  if (packageName && !importError)
+    return;
+  throw new Error(packageName ? `Packing this project type needs '${packageName}'. Install it.` : `Packing this project type needs the packager factory for '${verb}', and no package provides it.`, { cause: importError });
+}
+async function loadPackagerTool(specifier) {
+  const error = await importPackagerTool(specifier);
+  if (error) {
+    logger.debug(`No packager factory provider registered; import of '${specifier}' failed: ${error.message}`);
+    return error;
+  }
+  logger.debug(`No packager factory provider registered; loaded '${specifier}' directly.`);
+  return;
 }
 export {
   withCompleter,
   takeRecordedCommandFailureTelemetry,
   singleton,
+  setToolModuleProvider,
   setSdkUserAgentHostToken,
   setPackagerFactoryProvider,
   setOutputFormatExplicit,
@@ -23337,7 +23425,6 @@ export {
   setGlobalLogFilePath,
   runWithSink,
   restoreConsole,
-  resolveTelemetrySessionId,
   resolveEnvReference,
   resetLoggerInstance,
   registerPackageMetadataOptions,
@@ -23363,6 +23450,7 @@ export {
   installSdkCodingAgentHeader,
   installConsoleGuard,
   hashContent,
+  getTelemetrySessionSource,
   getTelemetrySessionId,
   getSdkUserAgentToken,
   getRecordedCommandFailureTelemetry,
@@ -23382,6 +23470,7 @@ export {
   extractErrorMessage,
   extractErrorDetails,
   extractCommandHelp,
+  ensureToolModule,
   ensurePackagerFactory,
   describeConnectivityError,
   createPollAbortController,
@@ -23399,7 +23488,7 @@ export {
   addSdkCodingAgentHeader,
   UIPATH_HOME_DIR,
   TelemetryService,
-  TELEMETRY_SESSION_ID_PROPERTY,
+  TELEMETRY_SESSION_SOURCE_PROPERTY,
   TELEMETRY_SESSION_ID_ENV,
   ScreenLogger,
   PollOutcome,
@@ -23421,4 +23510,4 @@ export {
   AUTH_FILENAME
 };
 
-//# debugId=5714488353CEE82464756E2164756E21
+//# debugId=C2BB3B73AD55AF7D64756E2164756E21

package/dist/index.d.ts

@@ -14,6 +14,7 @@ export * from "./error-handler";
 export * from "./error-instructions";
 export * from "./formatter";
 export * from "./guid";
+export * from "./host-global-options";
 export * from "./interactivity-context";
 export * from "./logger";
 export * from "./option-aliases";
@@ -23,12 +24,14 @@ export * from "./output-context";
 export * from "./output-format-context";
 export * from "./output-sink";
 export * from "./package-metadata-options";
+export { type PackagerToolModule, REGISTER_EXPORT, } from "./packager-tool-import";
 export * from "./polling";
 export * from "./preview";
 export * from "./registry";
 export * from "./screen-logger";
 export * from "./sdk-user-agent";
 export * from "./singleton";
+export * from "./solution-project-artifacts";
 export * from "./stdin";
 export { BrowserContextStorage } from "./telemetry/browser-context-storage.js";
 export * from "./telemetry/command-attribution.js";
@@ -40,5 +43,6 @@ export { redactError, redactProperties, redactProperty, redactValue, } from "./t
 export { type ShipSucceededTelemetryPayload, trackShipSucceeded, } from "./telemetry/ship-succeeded.js";
 export * from "./telemetry/telemetry-events.js";
 export * from "./telemetry/telemetry-init.js";
+export * from "./telemetry/telemetry-spool.js";
 export * from "./tool-provider";
 export * from "./trackedAction.js";