@uipath/common 1.199.0 → 1.201.0-preview.115

package/dist/command-extensions.d.ts

@@ -0,0 +1,6 @@
+import { Command } from "commander";
+import "./command-examples";
+import "./preview";
+import "./trackedAction.js";
+/** Install Common's Commander augmentations on a caller-owned constructor. */
+export declare function installCommandExtensions(commandConstructor: typeof Command): void;

package/dist/formatter.d.ts

@@ -142,6 +142,9 @@ export declare function escapeNonAscii(jsonText: string): string;
  * successfully can still throw at evaluation time (e.g. type-coercion errors
  * when functions receive unexpected types). Callers that need a fully
  * closed-box guarantee must additionally wrap {@link applyFilter}.
+ *
+ * Requires `loadOutputCodecsAsync({ filter: true })` to have run — the CLI
+ * host awaits it immediately before calling this.
  */
 export declare function validateOutputFilter(filter: string): Error | null;
 /**
@@ -164,6 +167,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.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"]],
@@ -22915,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 = [
@@ -23278,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);
@@ -23333,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;
+  }
+  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;
   }
-  await provider(verb);
+  logger.debug(`No packager factory provider registered; loaded '${specifier}' directly.`);
+  return;
 }
 export {
   withCompleter,
   takeRecordedCommandFailureTelemetry,
   singleton,
+  setToolModuleProvider,
   setSdkUserAgentHostToken,
   setPackagerFactoryProvider,
   setOutputFormatExplicit,
@@ -23404,6 +23470,7 @@ export {
   extractErrorMessage,
   extractErrorDetails,
   extractCommandHelp,
+  ensureToolModule,
   ensurePackagerFactory,
   describeConnectivityError,
   createPollAbortController,
@@ -23443,4 +23510,4 @@ export {
   AUTH_FILENAME
 };
 
-//# debugId=04886234C3E93F8264756E2164756E21
+//# debugId=C2BB3B73AD55AF7D64756E2164756E21

package/dist/index.d.ts

@@ -2,6 +2,7 @@ export * from "./attachment-binding";
 export * from "./body-validators";
 export * from "./catch-error";
 export * from "./command-examples";
+export * from "./command-extensions";
 export * from "./command-help";
 export * from "./command-walker";
 export * from "./completer";
@@ -14,21 +15,26 @@ 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";
 export * from "./option-validators";
 export * from "./orchestrator-urls";
+export * from "./output-codecs";
 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 "./solution-project-types";
 export * from "./stdin";
 export { BrowserContextStorage } from "./telemetry/browser-context-storage.js";
 export * from "./telemetry/command-attribution.js";
@@ -37,8 +43,10 @@ export { ConsoleTelemetryProvider } from "./telemetry/console-telemetry-provider
 export * from "./telemetry/node.js";
 export { setGlobalTelemetryProperties } from "./telemetry/node-appinsights-telemetry-provider.js";
 export { redactError, redactProperties, redactProperty, redactValue, } from "./telemetry/pii-redactor.js";
+export { getProxyAuthHttpsAgent, setProxyAuthHttpsAgent, } from "./telemetry/proxy-http-agent.js";
 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";