npm - @uipath/common - Versions diffs - 1.202.0 → 1.203.0-preview.160 - Mend

@uipath/common 1.202.0 → 1.203.0-preview.160

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (19) hide show

package/dist/THIRD-PARTY-NOTICES.md +32 -1
package/dist/catch-error.js +17 -1
package/dist/command-help.d.ts +1 -1
package/dist/entity-name-rules.js +17 -1
package/dist/formatter.d.ts +50 -1
package/dist/guid.js +17 -1
package/dist/index.browser.d.ts +1 -0
package/dist/index.browser.js +70 -16
package/dist/index.js +384 -36
package/dist/logger.d.ts +1 -1
package/dist/output-format-context.d.ts +1 -1
package/dist/output-formats.d.ts +34 -0
package/dist/registry.d.ts +5 -0
package/dist/telemetry/index.js +9 -6
package/dist/telemetry/telemetry-init.d.ts +1 -1
package/dist/timings.d.ts +19 -0
package/dist/zip.d.ts +14 -0
package/dist/zip.js +1380 -0
package/package.json +7 -2

package/dist/index.js CHANGED Viewed

@@ -7897,7 +7897,7 @@ var UUID_PATTERN = /\b[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{1
 var EMAIL_PATTERN = /\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}\b/g;
 var JWT_PATTERN = /\beyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+/g;
 var LONG_TOKEN_PATTERN = /\b[A-Za-z0-9_-]{40,}\b/g;
-var PADDED_BASE64_PATTERN = /[A-Za-z0-9+/]{16,}={1,2}(?![A-Za-z0-9+/=])/g;
+var PADDED_BASE64_PATTERN = /(?<![A-Za-z0-9+/])[A-Za-z0-9+/]{16,}={1,2}(?![A-Za-z0-9+/=])/g;
 var BASE64_WITH_PLUS_PATTERN = /[A-Za-z0-9+/]{40,}/g;
 var USER_HOME_PATTERN = /(?<![A-Za-z0-9._-])([/\\])(Users|home|Profiles)([/\\])([^/\\]+)/gi;
 var UNC_PATH_PATTERN = /(^|[\s"'<>|=,;([{])(\\\\[^\s"'<>|]+)/g;
@@ -7944,7 +7944,7 @@ var QUOTED_LITERAL_PATTERN = new RegExp([
   `(?<![A-Za-z0-9])"(?:[^\\
 ]|\\.){2,${QUOTED_LITERAL_MAX_SPAN}}?"(?![A-Za-z0-9])`
 ].join("|"), "g");
-var JSON_BODY_PATTERN = /[{[][^{}[\]]*[:,][^{}[\]]*[\]}]/g;
+var JSON_BODY_PATTERN = /[{[][^{}[\]:,]*[:,][^{}[\]]*[\]}]/g;
 var COLLAPSED_BODY = "{…}";
 var COLLAPSED_BODY_MARKER = "\x01body\x01";
 var MAX_BODY_NESTING = 8;
@@ -7959,10 +7959,13 @@ function collapseJsonBodies(text) {
   }
   return out.split(COLLAPSED_BODY_MARKER).join(COLLAPSED_BODY);
 }
-var TRAILING_PROSE_PUNCT = /[.,;:!?)\]}>'"]+$/;
+var TRAILING_PROSE_PUNCT = `.,;:!?)]}>'"`;
 function peelTrailingPunctuation(match) {
-  const trailing = match.match(TRAILING_PROSE_PUNCT)?.[0] ?? "";
-  return trailing ? [match.slice(0, -trailing.length), trailing] : [match, ""];
+  let end = match.length;
+  while (end > 0 && TRAILING_PROSE_PUNCT.includes(match[end - 1])) {
+    end -= 1;
+  }
+  return [match.slice(0, end), match.slice(end)];
 }
 function redactUrl(raw) {
   try {
@@ -8302,6 +8305,22 @@ function parseHttpStatusFromMessage(message) {
   const status = Number(match[1]);
   return Number.isInteger(status) && status >= 100 && status <= 599 ? status : undefined;
 }
+function findHttpStatusInGraph(error) {
+  for (const node of walkErrorGraph(error)) {
+    const response = node.response;
+    const explicit = typeof node.status === "number" ? node.status : response?.status;
+    if (typeof explicit === "number" && explicit >= 400 && explicit <= 599) {
+      return explicit;
+    }
+    if (typeof node.message === "string") {
+      const parsed = parseHttpStatusFromMessage(node.message);
+      if (parsed !== undefined && parsed >= 400) {
+        return parsed;
+      }
+    }
+  }
+  return;
+}
 function isHtmlDocument(body) {
   return /^\s*(<!doctype html|<html\b)/i.test(body);
 }
@@ -8415,7 +8434,8 @@ async function extractErrorDetails(error, options) {
   }
   let message;
   let result = "Failure";
-  const classification = classifyError(status, error);
+  const classificationStatus = status ?? findHttpStatusInGraph(error);
+  const classification = classifyError(classificationStatus, error);
   let retry = classification.retry;
   if (status === 401) {
     message = DEFAULT_401;
@@ -8491,8 +8511,8 @@ async function extractErrorDetails(error, options) {
     details = describeThrownValue(error);
   }
   const context = {};
-  if (status) {
-    context.httpStatus = status;
+  if (classificationStatus) {
+    context.httpStatus = classificationStatus;
   }
   if (parsedBody?.errorCode && typeof parsedBody.errorCode === "string") {
     context.errorCode = parsedBody.errorCode;
@@ -8953,6 +8973,18 @@ function getOutputFilter() {
   return filterSlot.get();
 }
+// src/output-formats.ts
+var OUTPUT_FORMATS = [
+  "table",
+  "json",
+  "yaml",
+  "plain",
+  "markdown"
+];
+function isOutputFormat(value) {
+  return OUTPUT_FORMATS.includes(value);
+}
 // src/telemetry/command-terminal.ts
 var recordedFailureSlot = singleton("CommandTelemetryFailure");
 var AUTH_ERROR_CODES = new Set([
@@ -9191,7 +9223,8 @@ function readRegistryValue(keyPath, valueName) {
   }
   const [error, output] = catchError(() => execFileSync2("reg", ["query", keyPath, "/v", valueName], {
     encoding: "utf-8",
-    stdio: ["pipe", "pipe", "pipe"]
+    stdio: ["pipe", "pipe", "pipe"],
+    windowsHide: true
   }));
   if (error) {
     return "";
@@ -9800,6 +9833,7 @@ class TelemetryService {
 }
 // src/timings.ts
 var TIMINGS_ENV_VAR = "UIP_TIMINGS";
+var TIMINGS_FILE_ENV_VAR = "UIP_TIMINGS_FILE";
 var TIMINGS_LINE_PREFIX = "[timing]";
 function createStorage2() {
   const [error, mod] = catchError(() => __require("node:async_hooks"));
@@ -9866,7 +9900,7 @@ async function runWithTimings(fallbackCommand, fn) {
         }
       }
       if (timingsEnabled()) {
-        emitTimingReport(state, fallbackCommand);
+        await emitTimingReport(state, fallbackCommand);
       }
     }
   });
@@ -9882,6 +9916,13 @@ function timingsEnabled() {
   const normalized = value.trim().toLowerCase();
   return normalized === "1" || normalized === "true";
 }
+function timingsFile() {
+  if (typeof process === "undefined") {
+    return;
+  }
+  const value = process.env?.[TIMINGS_FILE_ENV_VAR]?.trim();
+  return value === undefined || value === "" ? undefined : value;
+}
 function setTimingCommand(command) {
   if (!timingsEnabled()) {
     return;
@@ -9968,12 +10009,12 @@ function formatTimingReport(args) {
   parts.push(`flush=${total - startup - command}ms`);
   return parts.join(" ");
 }
-function emitTimingReport(state, fallbackCommand) {
+async function emitTimingReport(state, fallbackCommand) {
   if (state.suppressed) {
     return;
   }
   const now = performance.now();
-  logger.report(formatTimingReport({
+  const line = formatTimingReport({
     command: state.command ?? fallbackCommand,
     exitCode: state.exitCode ?? 0,
     totalMs: now - state.baseline,
@@ -9985,7 +10026,17 @@ function emitTimingReport(state, fallbackCommand) {
     },
     httpMs: state.httpMs,
     httpCalls: state.httpCalls
-  }));
+  });
+  const file = timingsFile();
+  if (file === undefined) {
+    logger.report(line);
+    return;
+  }
+  const [error] = await catchError(() => getFileSystem().appendFile(file, `${line}
+`));
+  if (error) {
+    logger.report(line);
+  }
 }
 // src/telemetry/tracked-fetch.ts
@@ -10662,18 +10713,56 @@ function isSyncFlushForced() {
 function isDrainableTelemetryProvider(provider) {
   return "drainPendingEnvelopes" in provider && typeof provider.drainPendingEnvelopes === "function";
 }
-function spawnTelemetrySidecar(entryPath) {
-  const child = spawn(process.execPath, [entryPath, TELEMETRY_DRAIN_ARGV], {
-    cwd: getFileSystem().env.tmpdir(),
-    detached: true,
+async function spawnTelemetrySidecar(entryPath) {
+  const cwd = getFileSystem().env.tmpdir();
+  const isWindows = process.platform === "win32";
+  const child = isWindows ? spawn(windowsShell(), windowsLauncherArgs(entryPath), {
+    cwd,
     stdio: "ignore",
-    windowsHide: true
+    windowsHide: true,
+    windowsVerbatimArguments: true
+  }) : spawn(process.execPath, [entryPath, TELEMETRY_DRAIN_ARGV], {
+    cwd,
+    detached: true,
+    stdio: "ignore"
   });
   child.on("error", (error) => {
     logger.debug(`[Telemetry] sidecar spawn failed (spool kept for a later run): ${error.message}`);
   });
+  if (isWindows) {
+    await waitForWindowsLauncher(child);
+  }
   child.unref();
 }
+var WINDOWS_LAUNCHER_TIMEOUT_MS = 3000;
+function waitForWindowsLauncher(child) {
+  return new Promise((resolve2) => {
+    const timer = setTimeout(resolve2, WINDOWS_LAUNCHER_TIMEOUT_MS);
+    timer.unref();
+    const settle = () => {
+      clearTimeout(timer);
+      resolve2();
+    };
+    child.on("exit", settle);
+    child.on("error", settle);
+  });
+}
+function windowsShell() {
+  return process.env.ComSpec ?? "cmd.exe";
+}
+function windowsLauncherArgs(entryPath) {
+  return [
+    "/d",
+    "/s",
+    "/c",
+    "start",
+    '""',
+    "/b",
+    `"${process.execPath}"`,
+    `"${entryPath}"`,
+    TELEMETRY_DRAIN_ARGV
+  ];
+}
 async function trySidecarHandoff(provider) {
   const entryPath = getTelemetrySidecarEntry();
   if (entryPath === undefined || isSyncFlushForced() || !isDrainableTelemetryProvider(provider)) {
@@ -10688,7 +10777,7 @@ async function trySidecarHandoff(provider) {
     if (spoolError) {
       logger.debug(`[Telemetry] spool write failed; dropping ${pending.envelopes.length} pending envelope(s): ${spoolError.message}`);
     } else {
-      const [spawnError] = catchError(() => spawnTelemetrySidecar(entryPath));
+      const [spawnError] = await catchError(spawnTelemetrySidecar(entryPath));
       if (spawnError) {
         logger.debug(`[Telemetry] sidecar spawn failed; spool will be sent by a future run: ${spawnError.message}`);
       }
@@ -10765,6 +10854,18 @@ function isCliErrorCode(value) {
 function isRetryHint(value) {
   return typeof value === "string" && RETRY_HINT_VALUES.has(value);
 }
+function carriedErrorCode(error) {
+  if (!error || typeof error !== "object")
+    return;
+  const code = error.errorCode;
+  return isCliErrorCode(code) ? code : undefined;
+}
+function carriedRetry(error) {
+  if (!error || typeof error !== "object")
+    return;
+  const retry = error.retry;
+  return isRetryHint(retry) ? retry : undefined;
+}
 var RESULTS = {
   Success: "Success",
   Failure: "Failure",
@@ -10880,28 +10981,32 @@ function isPlainRecord(value) {
   const prototype = Object.getPrototypeOf(value);
   return prototype === Object.prototype || prototype === null;
 }
-function extractPagedRows(value) {
+function splitPagedEnvelope(value) {
   if (Array.isArray(value) || !isPlainRecord(value))
     return null;
-  const entries = Object.values(value);
+  const entries = Object.entries(value);
   if (entries.length === 0)
     return null;
-  let rows = null;
-  let hasScalarSibling = false;
-  for (const entry of entries) {
+  let found = null;
+  const meta = Object.create(null);
+  for (const [key, entry] of entries) {
     if (Array.isArray(entry)) {
-      if (rows !== null)
+      if (found !== null)
         return null;
-      rows = entry;
+      found = { key, rows: entry };
     } else if (entry !== null && typeof entry === "object") {
       return null;
     } else {
-      hasScalarSibling = true;
+      meta[key] = entry;
     }
   }
-  if (rows === null || !hasScalarSibling)
+  if (found === null || Object.keys(meta).length === 0)
     return null;
-  return rows;
+  return { ...found, meta };
+}
+function extractPagedRows(value) {
+  const paged = splitPagedEnvelope(value);
+  return paged === null ? null : paged.rows;
 }
 function toLowerCamelCaseKey(key) {
   if (!key)
@@ -11005,6 +11110,9 @@ function printOutput(data, format = "json", logFn, asciiSafe = false, tableRowSt
       }
       break;
     }
+    case "markdown":
+      logFn(renderMarkdown(data));
+      break;
     default: {
       const hasData = "Data" in data && data.Data != null;
       const pagedRows = hasData ? extractPagedRows(data.Data) : null;
@@ -11029,6 +11137,10 @@ function logOutput(data, format = "json", tableRowStyle) {
   printOutput(data, format, (msg) => sink.writeOut(`${msg}
 `), needsAsciiSafeJson(sink), styleFn);
 }
+var PLUMBING_KEYS = new Set(["code", "log"]);
+function isPlumbingKey(key) {
+  return PLUMBING_KEYS.has(key.toLowerCase());
+}
 function cellToString(val) {
   return val != null && typeof val === "object" ? JSON.stringify(val) : String(val ?? "");
 }
@@ -11044,7 +11156,7 @@ function wrapText(text, width) {
 function printTable(data, logFn, externalLogValue, tableRowStyle) {
   if (data.length === 0)
     return;
-  const keys = Object.keys(data[0]).filter((key) => !["code", "log"].includes(key.toLowerCase()));
+  const keys = Object.keys(data[0]).filter((key) => !isPlumbingKey(key));
   const maxWidths = keys.map((key) => Math.max(key.length, ...data.map((item) => cellToString(item[key]).length)));
   const header = keys.map((key, i) => key.padEnd(maxWidths[i])).join(" | ");
   logFn(header);
@@ -11066,7 +11178,7 @@ function isNonEmptyPlainObject(value) {
 }
 var NESTED_INDENT = "  ";
 function printVerticalTable(data, logFn = console.log, externalLogValue) {
-  const keys = Object.keys(data).filter((key) => !["code", "log"].includes(key.toLowerCase()));
+  const keys = Object.keys(data).filter((key) => !isPlumbingKey(key));
   if (keys.length === 0)
     return;
   const isBlockValue = (value) => isPlainObjectArray(value) || isNonEmptyPlainObject(value);
@@ -11097,7 +11209,7 @@ function printVerticalTable(data, logFn = console.log, externalLogValue) {
 function printResizableTable(data, logFn = console.log, externalLogValue, availableWidth, tableRowStyle) {
   if (data.length === 0)
     return;
-  const keys = Object.keys(data[0]).filter((key) => !["code", "log"].includes(key.toLowerCase()));
+  const keys = Object.keys(data[0]).filter((key) => !isPlumbingKey(key));
   if (keys.length === 0)
     return;
   if (!process.stdout.isTTY) {
@@ -11171,6 +11283,220 @@ function printResizableTable(data, logFn = console.log, externalLogValue, availa
     logFn(`Log: ${externalLogValue}`);
   }
 }
+var MARKDOWN_MAX_CELL = 200;
+var MARKDOWN_MAX_DEPTH = 3;
+function markdownHeading(depth) {
+  return "#".repeat(Math.min(3 + depth, 6));
+}
+var BACKTICK_RUN = /`+/g;
+function fencedBlock(text) {
+  const first = text.trimStart()[0];
+  const language = first === "<" ? "xml" : first === "{" || first === "[" ? "json" : "";
+  const longestRun = Math.max(0, ...Array.from(text.matchAll(BACKTICK_RUN), (match) => match[0].length));
+  const fence = "`".repeat(Math.max(3, longestRun + 1));
+  return `${fence}${language}
+${text}
+${fence}`;
+}
+function collapseNewlineRuns(text) {
+  return text.split(/(\s+)/).map((part, index) => index % 2 === 1 && part.includes(`
+`) ? " " : part).join("");
+}
+function markdownCell(value) {
+  const text = value instanceof Date ? value.toISOString() : cellToString(value);
+  return collapseNewlineRuns(text).replace(/\|/g, "\\|");
+}
+function markdownLabel(key) {
+  return collapseNewlineRuns(key).replace(/[\\`*|]/g, "\\$&");
+}
+function withoutPlumbing(record) {
+  const kept = Object.create(null);
+  for (const [key, value] of Object.entries(record)) {
+    if (!isPlumbingKey(key))
+      kept[key] = value;
+  }
+  return kept;
+}
+function rowsWithoutPlumbing(rows) {
+  return rows.map((row) => isPlainRecord(row) ? withoutPlumbing(row) : row);
+}
+function markdownTable(rows) {
+  const columns = [];
+  const seen = new Set;
+  for (const row of rows) {
+    for (const key of Object.keys(row)) {
+      if (!seen.has(key)) {
+        seen.add(key);
+        columns.push(key);
+      }
+    }
+  }
+  if (columns.length === 0)
+    return null;
+  const cells = rows.map((row) => columns.map((key) => markdownCell(row[key])));
+  if (cells.some((row) => row.some((c) => c.length > MARKDOWN_MAX_CELL))) {
+    return null;
+  }
+  return [
+    `| ${columns.map(markdownLabel).join(" | ")} |`,
+    `| ${columns.map(() => "---").join(" | ")} |`,
+    ...cells.map((row) => `| ${row.join(" | ")} |`)
+  ].join(`
+`);
+}
+function extractMessageSequence(rows) {
+  const messages = [];
+  for (const row of rows) {
+    const message = extractSingleMessage(row);
+    if (message === null)
+      return null;
+    messages.push(message);
+  }
+  return messages.join(`
+`);
+}
+function markdownRows(rows, depth) {
+  if (rows.length === 0)
+    return "(none)";
+  if (!isPlainObjectArray(rows)) {
+    return rows.map((item) => `- ${markdownCell(item)}`).join(`
+`);
+  }
+  const prose = extractMessageSequence(rows);
+  if (prose !== null)
+    return prose;
+  const table = markdownTable(rows);
+  if (table !== null)
+    return table;
+  if (depth >= MARKDOWN_MAX_DEPTH) {
+    return fencedBlock(JSON.stringify(rows, null, 2));
+  }
+  return rows.map((row, index) => [
+    `${markdownHeading(depth)} ${index + 1}`,
+    markdownObject(row, depth + 1)
+  ].join(`
+`)).join(`
+`);
+}
+function markdownObject(obj, depth) {
+  const scalars = [];
+  const blocks = [];
+  for (const [key, value] of Object.entries(obj)) {
+    if (value === undefined)
+      continue;
+    const label = markdownLabel(key);
+    if (Array.isArray(value)) {
+      blocks.push(`${markdownHeading(depth)} ${label}
+${markdownRows(value, depth + 1)}`);
+    } else if (isNonEmptyPlainObject(value)) {
+      const nested = depth < MARKDOWN_MAX_DEPTH ? markdownObject(value, depth + 1) : fencedBlock(JSON.stringify(value, null, 2));
+      if (nested !== "") {
+        blocks.push(`${markdownHeading(depth)} ${label}
+${nested}`);
+      }
+    } else if (typeof value === "string" && value.includes(`
+`)) {
+      blocks.push(`**${label}:**
+${fencedBlock(value)}`);
+    } else {
+      scalars.push(`**${label}:** ${markdownCell(value)}`);
+    }
+  }
+  const sections = scalars.length > 0 ? [scalars.join(`
+`)] : [];
+  sections.push(...blocks);
+  return sections.join(`
+`);
+}
+function extractSingleMessage(payload) {
+  if (!isPlainRecord(payload))
+    return null;
+  const keys = Object.keys(payload);
+  if (keys.length !== 1 || keys[0].toLowerCase() !== "message")
+    return null;
+  const value = payload[keys[0]];
+  return typeof value === "string" ? value : null;
+}
+function markdownPayload(payload) {
+  const message = extractSingleMessage(payload);
+  if (message !== null)
+    return message;
+  if (Array.isArray(payload)) {
+    return markdownRows(rowsWithoutPlumbing(payload), 0);
+  }
+  const visible = withoutPlumbing(payload);
+  const paged = splitPagedEnvelope(visible);
+  if (paged !== null) {
+    const meta = markdownObject(paged.meta, 0);
+    const rows = `${markdownHeading(0)} ${markdownLabel(paged.key)}
+${markdownRows(rowsWithoutPlumbing(paged.rows), 1)}`;
+    return meta === "" ? rows : `${meta}
+${rows}`;
+  }
+  return markdownObject(visible, 0);
+}
+function isPaginationWorthShowing(value) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  const page = value;
+  return page.HasMore === true || typeof page.Offset === "number" && page.Offset > 0;
+}
+function markdownEnvelopeNotes(data) {
+  const envelope = data;
+  const notes = [];
+  const warning = envelope.Warning;
+  if (typeof warning === "string" && warning !== "") {
+    notes.push(`> **Warning:** ${warning}`);
+  }
+  const instructions = envelope.Instructions;
+  if (typeof instructions === "string" && instructions !== "") {
+    notes.push(`> ${instructions}`);
+  }
+  const pagination = envelope.Pagination;
+  if (isPaginationWorthShowing(pagination)) {
+    const body = markdownObject(pagination, 1);
+    if (body !== "") {
+      notes.push(`${markdownHeading(0)} Pagination
+${body}`);
+    }
+  }
+  const log = envelope.Log;
+  if (typeof log === "string" && log !== "") {
+    notes.push(`**Log:** ${log}`);
+  }
+  return notes;
+}
+function renderMarkdown(data) {
+  if (data.Result !== RESULTS.Success) {
+    const failure = data;
+    const sections = [`**Failed:** ${failure.Message}`];
+    if (failure.Data != null) {
+      sections.push(markdownPayload(failure.Data));
+    }
+    if (failure.Instructions) {
+      sections.push(`> ${failure.Instructions}`);
+    }
+    return sections.filter((section) => section !== "").join(`
+`);
+  }
+  if (!("Data" in data) || data.Data == null) {
+    return markdownObject(withoutPlumbing(data), 0);
+  }
+  return [markdownPayload(data.Data), ...markdownEnvelopeNotes(data)].filter((section) => section !== "").join(`
+`);
+}
 function toYaml(data) {
   const codec = getYamlCodec();
   if (!codec) {
@@ -11223,6 +11549,20 @@ class FilterImplicitLimitError extends Error {
     this.instructions = "Pass --limit <n> to choose how many records the filter applies to. " + "To filter over all records, pass the command's maximum accepted --limit (see the option's description in --help).";
   }
 }
+class ConfigurationError extends Error {
+  __brand = "ConfigurationError";
+  errorCode = "configuration_error";
+  retry = "RetryWillNotFix";
+  result = RESULTS.ConfigError;
+  constructor(message) {
+    super(message);
+    this.name = "ConfigurationError";
+  }
+}
+function isConfigurationError(error) {
+  return typeof error === "object" && error !== null && "__brand" in error && error.__brand === "ConfigurationError";
+}
 function applyFilter(data, filter) {
   const codec = requireJmespath();
   let result;
@@ -11949,18 +12289,17 @@ function extractCommandHelp(cmd, helper) {
   }
   return result;
 }
-var VALID_FORMATS = ["table", "json", "yaml", "plain"];
 function extractFormatFromArgs(args) {
   for (let i = 0;i < args.length; i++) {
     if (args[i] === "--output" && i + 1 < args.length) {
       const value = args[i + 1];
-      if (VALID_FORMATS.includes(value)) {
+      if (isOutputFormat(value)) {
         return value;
       }
     }
     if (args[i]?.startsWith("--output=")) {
       const value = args[i].substring("--output=".length);
-      if (VALID_FORMATS.includes(value)) {
+      if (isOutputFormat(value)) {
         return value;
       }
     }
@@ -13459,6 +13798,7 @@ export {
   CLI_ERROR_CODES,
   CONFIG_FILENAME,
   CommonTelemetryEvents,
+  ConfigurationError,
   ConsoleTelemetryProvider,
   DEFAULT_AUTH_TIMEOUT_MS,
   DEFAULT_BASE_URL,
@@ -13480,6 +13820,7 @@ export {
   MAX_SPOOL_FILES,
   MIN_INTERVAL_MS,
   NodeContextStorage,
+  OUTPUT_FORMATS,
   OutputFormatter,
   POLL_DEFAULTS,
   Pagination,
@@ -13498,6 +13839,7 @@ export {
   TELEMETRY_SESSION_SOURCE_PROPERTY,
   TELEMETRY_TRACEPARENT_ENV,
   TIMINGS_ENV_VAR,
+  TIMINGS_FILE_ENV_VAR,
   TIMINGS_LINE_PREFIX,
   TelemetryService,
   UIPATH_HOME_DIR,
@@ -13513,7 +13855,9 @@ export {
   buildOrchestratorUrl,
   buildSkillEventTelemetryAttribution,
   canPrompt,
+  carriedErrorCode,
   carriedInstructions,
+  carriedRetry,
   catchError,
   claimPendingSpoolFiles,
   classifiedFailure,
@@ -13543,6 +13887,7 @@ export {
   extractErrorMessage,
   extractErrorMessageSync,
   extractFormatFromArgs,
+  extractSingleMessage,
   findReservedNameError,
   formatErrorChain,
   formatTimingReport,
@@ -13581,9 +13926,11 @@ export {
   invocationElapsedMs,
   invocationStartedAt,
   isCliErrorCode,
+  isConfigurationError,
   isFailureStatus,
   isGuid,
   isHtmlDocument,
+  isOutputFormat,
   isPreviewBuild,
   isRetryHint,
   isSuccessStatus,
@@ -13673,6 +14020,7 @@ export {
   telemetryInit,
   telemetryShutdownWithoutFlush,
   timingsEnabled,
+  timingsFile,
   trackShipSucceeded,
   unsupportedSolutionProjectType,
   validateName,
@@ -13684,4 +14032,4 @@ export {
   writeTelemetrySpoolFile
 };
-//# debugId=E388413E446272F364756E2164756E21
+//# debugId=1C8485A93560E50864756E2164756E21

package/dist/logger.d.ts CHANGED Viewed

@@ -121,7 +121,7 @@ export declare function getLogFilePath(): string;
  * // CLI entry point
  * configureLogger({ sink: new TerminalSink() });
  *
- * // Browser entry point
+ * // Browser entry point (BrowserSink lives in packages/cli-browser)
  * configureLogger({ sink: new BrowserSink() });
  *
  * // MCP — errors still surface via writeErr

package/dist/output-format-context.d.ts CHANGED Viewed

@@ -5,7 +5,7 @@
  * OutputFormatter functions can apply them automatically without every
  * command having to thread these values through.
  */
-import type { OutputFormat } from "./formatter";
+import type { OutputFormat } from "./output-formats";
 /**
  * Set the process-wide output format.
  * Called once at CLI startup (from extractFormatFromArgs for early use via --output)