@uipath/integrationservice-tool 1.203.0-preview.212 → 1.204.0-preview.211

package/dist/{tool-rpm313p8.js → tool-2h04aqp4.js}

@@ -2101,7 +2101,7 @@ var package_default = {
   name: "@uipath/integrationservice-tool",
   author: "UiPath",
   license: "SEE LICENSE IN LICENSE.txt",
-  version: "1.203.0-preview.212",
+  version: "1.204.0-preview.211",
   description: "Manage Integration Service connectors, connections, and triggers.",
   private: false,
   repository: {
@@ -2913,9 +2913,60 @@ function settlePromiseLike(thenable) {
   return Promise.resolve(thenable).then((data) => [undefined, data]).catch((error) => [toError(error), undefined]);
 }
 
+// ../common/src/error-graph.ts
+function* walkErrorGraph(error) {
+  const queue = [error];
+  const seen = new Set;
+  for (let steps = 0;queue.length > 0 && steps < 32; steps++) {
+    const current = queue.shift();
+    if (current === null || typeof current !== "object")
+      continue;
+    if (seen.has(current))
+      continue;
+    seen.add(current);
+    const cur = current;
+    yield cur;
+    if (cur.cause !== undefined)
+      queue.push(cur.cause);
+    if (Array.isArray(cur.errors))
+      queue.push(...cur.errors);
+  }
+  return;
+}
+function parseHttpStatusFromMessage(message) {
+  const match = /^HTTP\s+(\d{3})(?::|\s|-|$)/i.exec(message.trim());
+  if (!match)
+    return;
+  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;
+}
+
+// ../common/src/local-permission-codes.ts
+var LOCAL_PERMISSION_ERROR_CODES = new Set([
+  "EACCES",
+  "EPERM",
+  "EROFS"
+]);
+
 // ../common/src/error-handler.ts
-var DEFAULT_401 = "Unauthorized (401). Run `uip login` to authenticate.";
-var DEFAULT_403 = "Forbidden (403). Ensure the account has the required permissions.";
+var DEFAULT_401 = "Unauthorized (401). The session is missing or expired, or its token carries no scope for this API. Run `uip login status --detailed` to see the session and its scopes.";
+var DEFAULT_403 = "Forbidden (403). The account lacks permission for this operation, or the token carries no scope for this API. Run `uip login status --detailed` to see the token's scopes.";
 var DEFAULT_405 = "Method Not Allowed (405). The endpoint may not exist or the base URL may be incorrect.";
 var DEFAULT_413 = "Payload too large (413). The upload exceeded the server or CDN size limit. Reduce the package size — for example, exclude unused dependencies or remove large files from the project — and try again.";
 var HTML_RESPONSE_MESSAGE = "Received HTML instead of the expected JSON response.";
@@ -2942,14 +2993,14 @@ var TLS_ERROR_CODES = new Set([
 ]);
 var TLS_INSTRUCTIONS = "The server's TLS certificate could not be verified. Most often a " + "corporate proxy/firewall re-signs HTTPS with a root CA that Node does " + "not trust — set NODE_EXTRA_CA_CERTS to that CA's PEM file (and HTTPS_PROXY " + "if you connect through a proxy). If the certificate is instead expired or " + "its hostname does not match, fix the endpoint URL or the system clock. " + "Then retry.";
 var NETWORK_INSTRUCTIONS = "Could not reach the UiPath service. Check your network connection and " + "VPN, confirm any HTTP_PROXY/HTTPS_PROXY/NO_PROXY settings are correct, " + "then retry.";
-var LOCAL_PERMISSION_ERROR_CODES = new Set(["EACCES", "EPERM", "EROFS"]);
-var LOCAL_PERMISSION_MESSAGE_PATTERN = /\b(EACCES|EPERM|EROFS)\b/;
+var LOCAL_PERMISSION_MESSAGE_PATTERN = new RegExp(`\\b(${[...LOCAL_PERMISSION_ERROR_CODES].join("|")})\\b`);
 function localPermissionInstructions(code, path2) {
   const target = path2 !== undefined ? `'${path2}'` : "a local file or resource";
   if (code === "EROFS") {
     return `The filesystem containing ${target} is read-only (EROFS), so the ` + "CLI could not write to it. This is a local environment problem, " + "not a UiPath service error — retrying will not help. Use a " + "writable location, or give this environment write access to the " + "path.";
   }
-  const remedy = process.platform === "win32" ? "Re-run from an elevated terminal, close any program holding " + "the file open, or grant your user access to the path." : "Grant this user (or the sandbox the command runs in) access " + "to the path, or run the command outside the sandbox.";
+  const onWindows = typeof process !== "undefined" && process.platform === "win32";
+  const remedy = onWindows ? "Re-run from an elevated terminal, close any program holding " + "the file open, or grant your user access to the path." : "Grant this user (or the sandbox the command runs in) access " + "to the path, or run the command outside the sandbox.";
   return `The operating system denied access to ${target} (${code}). This is ` + "a local permission problem, not a UiPath service error — retrying " + `without a permission change will not help. ${remedy}`;
 }
 function describeConnectivityError(error) {
@@ -3003,48 +3054,6 @@ function localPermissionPath(path2, message) {
     return path2;
   return message ? /'([^']+)'/.exec(message)?.[1] : undefined;
 }
-function* walkErrorGraph(error) {
-  const queue = [error];
-  const seen = new Set;
-  for (let steps = 0;queue.length > 0 && steps < 32; steps++) {
-    const current = queue.shift();
-    if (current === null || typeof current !== "object")
-      continue;
-    if (seen.has(current))
-      continue;
-    seen.add(current);
-    const cur = current;
-    yield cur;
-    if (cur.cause !== undefined)
-      queue.push(cur.cause);
-    if (Array.isArray(cur.errors))
-      queue.push(...cur.errors);
-  }
-  return;
-}
-function parseHttpStatusFromMessage(message) {
-  const match = /^HTTP\s+(\d{3})(?::|\s|-|$)/i.exec(message.trim());
-  if (!match)
-    return;
-  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);
 }
@@ -3566,12 +3575,162 @@ function getOutputFilter() {
   return filterSlot.get();
 }
 
+// ../common/src/telemetry/telemetry-dimensions.ts
+var BaseDimensions = {
+  ApplicationName: "ApplicationName",
+  ProductVersion: "ProductVersion",
+  InstallationId: "InstallationId",
+  CloudUserId: "CloudUserId",
+  CloudTenantId: "CloudTenantId",
+  CloudOrganizationId: "CloudOrganizationId",
+  IsInternalUser: "IsInternalUser",
+  Environment: "Environment",
+  BaseUrl: "BaseUrl",
+  Region: "Region",
+  Agent: "Agent",
+  AgentVersion: "AgentVersion",
+  AgentModel: "AgentModel",
+  ToolName: "ToolName",
+  ToolVersion: "ToolVersion",
+  ExecutionContext: "ExecutionContext",
+  CiProvider: "CiProvider",
+  SessionIdSource: "SessionIdSource",
+  SessionId: "SessionId"
+};
+var CommandDimensions = {
+  IsCommand: "IsCommand",
+  IsReexec: "IsReexec",
+  CommandName: "CommandName",
+  ExitCode: "ExitCode",
+  TerminalOutcome: "TerminalOutcome",
+  ErrorClass: "ErrorClass",
+  TerminalSignal: "TerminalSignal",
+  ErrorMessage: "ErrorMessage",
+  SkillName: "SkillName",
+  ProductArea: "ProductArea",
+  Mode: "Mode"
+};
+var ShipDimensions = {
+  ShipKind: "ShipKind",
+  Target: "Target",
+  ProjectType: "ProjectType",
+  ProjectTypes: "ProjectTypes",
+  ArtifactCorrelationKey: "ArtifactCorrelationKey",
+  PackageName: "PackageName",
+  PackageVersion: "PackageVersion",
+  PackageVersionKey: "PackageVersionKey",
+  DeploymentKey: "DeploymentKey",
+  SolutionId: "SolutionId",
+  FolderKey: "FolderKey",
+  FeedId: "FeedId"
+};
+var ErrorDimensions = {
+  Result: "Result",
+  ErrorCode: "ErrorCode",
+  Retry: "Retry",
+  ErrorMessage: "ErrorMessage"
+};
+var AuthDimensions = {
+  AuthenticationMethod: "AuthenticationMethod",
+  Success: "Success",
+  Reason: "Reason"
+};
+var SkillsDimensions = {
+  SchemaVersion: "SchemaVersion",
+  AgentType: "AgentType",
+  SkillsVersion: "SkillsVersion",
+  UipSubcommand: "UipSubcommand",
+  FileExtension: "FileExtension",
+  SubagentModel: "SubagentModel",
+  SubagentType: "SubagentType",
+  PermissionMode: "PermissionMode",
+  EffortLevel: "EffortLevel",
+  SessionSource: "SessionSource",
+  Outcome: "Outcome",
+  DurationMs: "DurationMs",
+  Source: "Source"
+};
+var PackagerDimensions = {
+  ProjectId: "ProjectId",
+  ProjectType: "ProjectType",
+  SolutionId: "SolutionId"
+};
+var ScopeDimensions = {
+  FolderId: "FolderId"
+};
+var ID_DIMENSIONS = new Set([
+  BaseDimensions.CloudUserId,
+  BaseDimensions.CloudTenantId,
+  BaseDimensions.CloudOrganizationId,
+  BaseDimensions.InstallationId,
+  ShipDimensions.ArtifactCorrelationKey,
+  ShipDimensions.PackageVersionKey,
+  ShipDimensions.DeploymentKey,
+  ShipDimensions.SolutionId,
+  ShipDimensions.FolderKey,
+  ShipDimensions.FeedId,
+  PackagerDimensions.ProjectId
+]);
+var NON_IDENTIFIER_PLACEHOLDER_PATTERN = /^(?:\[[A-Z_]+\]|<[^>]+>)$/;
+var RESERVED_DIMENSION_NAMES = new Set([
+  ...Object.values(BaseDimensions),
+  ...Object.values(CommandDimensions),
+  ...Object.values(ShipDimensions),
+  ...Object.values(ErrorDimensions),
+  ...Object.values(AuthDimensions),
+  ...Object.values(SkillsDimensions),
+  ...Object.values(PackagerDimensions),
+  ...Object.values(ScopeDimensions)
+]);
+var CURATED_DIMENSIONS = new Set([
+  BaseDimensions.ApplicationName,
+  BaseDimensions.ProductVersion,
+  BaseDimensions.InstallationId,
+  BaseDimensions.CloudUserId,
+  BaseDimensions.CloudTenantId,
+  BaseDimensions.CloudOrganizationId,
+  BaseDimensions.IsInternalUser,
+  BaseDimensions.Environment,
+  BaseDimensions.BaseUrl,
+  BaseDimensions.Region,
+  BaseDimensions.Agent,
+  BaseDimensions.AgentVersion,
+  BaseDimensions.ToolVersion,
+  BaseDimensions.ExecutionContext,
+  BaseDimensions.CiProvider,
+  BaseDimensions.SessionIdSource,
+  BaseDimensions.SessionId,
+  ...Object.values(CommandDimensions),
+  ...Object.values(ShipDimensions)
+]);
+function lowercaseIdDimensionValues(properties) {
+  let changed = false;
+  const result = {
+    ...properties
+  };
+  for (const key of Object.keys(result)) {
+    const value = result[key];
+    if (!ID_DIMENSIONS.has(key) || typeof value !== "string" || NON_IDENTIFIER_PLACEHOLDER_PATTERN.test(value)) {
+      continue;
+    }
+    const lowered = value.toLowerCase();
+    if (lowered !== value) {
+      result[key] = lowered;
+      changed = true;
+    }
+  }
+  return changed ? result : properties;
+}
+
 // ../common/src/telemetry/command-terminal.ts
 var recordedFailureSlot = singleton("CommandTelemetryFailure");
 var AUTH_ERROR_CODES = new Set([
   "authentication_required",
   "permission_denied"
 ]);
+var LOCAL_PERMISSION_CLI_ERROR_CODES = new Set([
+  "local_permission_denied"
+]);
 var VALIDATION_ERROR_CODES = new Set(["invalid_argument"]);
 var NETWORK_HTTP_ERROR_CODES = new Set([
   "network_error",
@@ -3712,6 +3871,9 @@ function classifyFromErrorCode(errorCode) {
   if (AUTH_ERROR_CODES.has(errorCode)) {
     return "auth";
   }
+  if (LOCAL_PERMISSION_CLI_ERROR_CODES.has(errorCode)) {
+    return "local_permission";
+  }
   if (VALIDATION_ERROR_CODES.has(errorCode)) {
     return "validation";
   }
@@ -3723,6 +3885,15 @@ function classifyFromErrorCode(errorCode) {
   }
   return;
 }
+function hasLocalPermissionCode(error) {
+  for (const node of walkErrorGraph(error)) {
+    const code = node.code;
+    if (typeof code === "string" && LOCAL_PERMISSION_ERROR_CODES.has(code)) {
+      return true;
+    }
+  }
+  return false;
+}
 function classifyFromError(error) {
   const code = findCodeInCauseChain(error);
   if (code) {
@@ -3739,6 +3910,9 @@ function classifyFromError(error) {
       return "missing_dependency";
     }
   }
+  if (hasLocalPermissionCode(error)) {
+    return "local_permission";
+  }
   const message = stringField(error, "message");
   if (message?.includes("fetch failed") === true) {
     return "network_http";
@@ -3754,7 +3928,7 @@ function classifyError2(input) {
   if (recorded?.errorClass) {
     return recorded.errorClass;
   }
-  const status = recorded?.context?.httpStatus;
+  const status = recorded?.context?.httpStatus ?? findHttpStatusInGraph(input.error);
   if (status !== undefined) {
     return classifyHttpStatus(status);
   }
@@ -3777,17 +3951,18 @@ function buildCommandTerminalTelemetryProperties(input) {
   const errorClass = outcome === "success" || outcome === "no_op" ? undefined : outcome === "cancelled" ? "user_cancelled" : classifyError2(input);
   const terminalSignal = terminalSignalFor(input, outcome);
   return {
-    exit_code: input.exitCode,
-    terminal_outcome: outcome,
-    ...errorClass ? { error_class: errorClass } : {},
-    ...terminalSignal ? { terminal_signal: terminalSignal } : {}
+    [CommandDimensions.ExitCode]: input.exitCode,
+    [CommandDimensions.TerminalOutcome]: outcome,
+    ...errorClass ? { [CommandDimensions.ErrorClass]: errorClass } : {},
+    ...terminalSignal ? { [CommandDimensions.TerminalSignal]: terminalSignal } : {}
   };
 }
 
 // ../common/src/telemetry/telemetry-events.ts
 var CommonTelemetryEvents = {
-  Error: "uip.error",
-  ShipSucceeded: "uip.ship.succeeded"
+  Start: "Application.Start",
+  Error: "Application.Error",
+  ShipSucceeded: "Cli.ShipSucceeded"
 };
 
 // ../common/src/registry.ts
@@ -3995,8 +4170,8 @@ function detectExecutionContext(options = {}) {
 function getExecutionContextTelemetryProperties() {
   const detected = detectExecutionContext();
   return {
-    execution_context: detected.executionContext,
-    ...detected.ciProvider ? { ci_provider: detected.ciProvider } : {}
+    [BaseDimensions.ExecutionContext]: detected.executionContext,
+    ...detected.ciProvider ? { [BaseDimensions.CiProvider]: detected.ciProvider } : {}
   };
 }
 // ../common/src/telemetry/node-context-storage.ts
@@ -4039,7 +4214,7 @@ function getInboundTraceContext() {
 var TELEMETRY_SESSION_ID_ENV = "UIPATH_SESSION_ID";
 var SESSION_ID_MAX_LENGTH = 64;
 var RANDOM_SESSION_ID_LENGTH = 32;
-var TELEMETRY_SESSION_SOURCE_PROPERTY = "session_id_source";
+var TELEMETRY_SESSION_SOURCE_PROPERTY = "SessionIdSource";
 var CONTROL_CHARACTERS = /\p{Cc}/gu;
 var INHERITED_SESSION_SOURCES = [
   { envVar: "CLAUDE_CODE_SESSION_ID", source: "claude-code" },
@@ -4091,6 +4266,9 @@ function resolveTelemetrySession() {
   telemetrySessionSlot.set(resolved);
   return resolved;
 }
+function getTelemetrySessionId() {
+  return resolveTelemetrySession().id;
+}
 function getTelemetrySessionSource() {
   return resolveTelemetrySession().source;
 }
@@ -4171,7 +4349,10 @@ class TelemetryService {
     } catch (error) {
       const durationMs = clock.elapsedMs();
       const err = error instanceof Error ? error : new Error(String(error));
-      await this.telemetryProvider.trackRequest(this.spanFor(name, durationMs, false, { ...properties, errorMessage: err.message }, context));
+      await this.telemetryProvider.trackRequest(this.spanFor(name, durationMs, false, {
+        ...properties,
+        [CommandDimensions.ErrorMessage]: err.message
+      }, context));
       throw error;
     }
   }
@@ -4242,7 +4423,10 @@ class TelemetryService {
       const durationMs = clock.elapsedMs();
       const err = error instanceof Error ? error : new Error(String(error));
       await this.telemetryProvider.trackDependency({
-        ...this.spanFor(name, durationMs, false, { ...properties, errorMessage: err.message }, childContext),
+        ...this.spanFor(name, durationMs, false, {
+          ...properties,
+          [CommandDimensions.ErrorMessage]: err.message
+        }, childContext),
         type
       });
       throw error;
@@ -4277,9 +4461,10 @@ class TelemetryService {
       ...globalProperties,
       ...this.defaultProperties,
       ...redactProperties(properties ?? {}),
-      [TELEMETRY_SESSION_SOURCE_PROPERTY]: getTelemetrySessionSource()
+      [TELEMETRY_SESSION_SOURCE_PROPERTY]: getTelemetrySessionSource(),
+      [BaseDimensions.SessionId]: this.telemetryProvider.getSessionId?.() ?? getTelemetrySessionId()
     };
-    return enriched;
+    return lowercaseIdDimensionValues(enriched);
   }
   generateId() {
     const bytes = new Uint8Array(8);
@@ -5040,7 +5225,165 @@ 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).";
   }
 }
-function applyFilter(data, filter) {
+function countRecords(data) {
+  if (Array.isArray(data))
+    return data.length;
+  return data == null ? 0 : 1;
+}
+function availableFields(data) {
+  const records = Array.isArray(data) ? data : [data];
+  const keys = new Set;
+  for (const record of records) {
+    if (record && typeof record === "object" && !Array.isArray(record)) {
+      for (const key of Object.keys(record))
+        keys.add(key);
+    }
+  }
+  return [...keys];
+}
+function decodeQuotedIdentifier(whole, inner) {
+  const [error, decoded] = catchError(() => JSON.parse(whole));
+  if (!error && typeof decoded === "string")
+    return decoded;
+  return inner.replace(/\\(.)/g, "$1");
+}
+function referencedFields(filter) {
+  const top = new Set;
+  const nested = new Set;
+  const withoutValueLiterals = filter.replace(/'(?:\\.|[^'\\])*'/g, " ").replace(/`(?:\\.|[^`\\])*`/g, " ");
+  const isPathTail = (text, index) => text[index - 1] === "." && /[A-Za-z0-9_"]/.test(text[index - 2] ?? "");
+  const quoted = [];
+  const withoutLiterals = withoutValueLiterals.replace(/"((?:\\.|[^"\\])*)"/g, (whole, name, index) => {
+    const isAlias = /^\s*:/.test(withoutValueLiterals.slice(index + whole.length));
+    if (!isAlias) {
+      quoted.push({
+        name: decodeQuotedIdentifier(whole, name),
+        index,
+        tail: isPathTail(withoutValueLiterals, index)
+      });
+    }
+    return `"${" ".repeat(whole.length - 2)}"`;
+  });
+  const descent = /[A-Za-z0-9_"]\s*[.[]/.exec(withoutLiterals);
+  const rootEnd = descent ? descent.index + 1 : Number.POSITIVE_INFINITY;
+  const place = (name, index, tail) => {
+    if (tail || index >= rootEnd)
+      nested.add(name);
+    else
+      top.add(name);
+  };
+  for (const entry of quoted)
+    place(entry.name, entry.index, entry.tail);
+  const identifiers = withoutLiterals.matchAll(/([A-Za-z_][A-Za-z0-9_]*)(\s*[:(])?/g);
+  const reserved = new Set(["true", "false", "null", "and", "or", "not"]);
+  for (const match of identifiers) {
+    const [, name, trailing] = match;
+    if (trailing || reserved.has(name))
+      continue;
+    place(name, match.index, isPathTail(withoutLiterals, match.index));
+  }
+  return {
+    top: [...top],
+    nested: [...nested].filter((name) => !top.has(name)),
+    hasPredicate: /\[\s*\?/.test(withoutValueLiterals)
+  };
+}
+function appearsBelowTopLevel(data, name) {
+  let budget = 2000;
+  const visit = (value, depth) => {
+    if (budget-- <= 0 || depth > 4)
+      return false;
+    if (value === null || typeof value !== "object")
+      return false;
+    if (Array.isArray(value))
+      return value.some((entry) => visit(entry, depth));
+    const record = value;
+    if (depth > 0 && Object.hasOwn(record, name))
+      return true;
+    return Object.values(record).some((entry) => visit(entry, depth + 1));
+  };
+  return visit(data, 0);
+}
+function alwaysNullKeys(records) {
+  const objects = records.filter((r) => r != null && typeof r === "object" && !Array.isArray(r));
+  if (objects.length === 0 || objects.length !== records.length)
+    return [];
+  const keys = [...new Set(objects.flatMap((o) => Object.keys(o)))];
+  if (keys.length === 0)
+    return [];
+  const nullKeys = keys.filter((key) => objects.every((record) => record[key] === null));
+  return nullKeys.length === keys.length ? nullKeys : [];
+}
+function carriesOnlyNulls(value) {
+  if (value === null)
+    return true;
+  if (Array.isArray(value)) {
+    return value.length > 0 && value.every(carriesOnlyNulls);
+  }
+  if (typeof value === "object" && value !== undefined) {
+    const values = Object.values(value);
+    return values.length > 0 && values.every(carriesOnlyNulls);
+  }
+  return false;
+}
+function nameList(names, cap2 = 12) {
+  const shown = names.slice(0, cap2).map((n) => `\`${n}\``);
+  const rest = names.length - shown.length;
+  return shown.join(", ") + (rest > 0 ? `, and ${rest} more` : "");
+}
+function buildFilterWarning(filter, data, outcome) {
+  const present = availableFields(data);
+  const refs = referencedFields(filter);
+  const unknown = refs.top.filter((name) => !present.includes(name) && !appearsBelowTopLevel(data, name));
+  const unchecked = refs.nested.filter((name) => !present.includes(name));
+  const count = countRecords(data);
+  const scope = `${count} record(s)`;
+  const isNotAField = (names) => `${nameList(names)} ${names.length === 1 ? "is not a field" : "are not fields"} on the ${scope} it read`;
+  const soundness = unchecked.length > 0 ? `${nameList(unchecked)} ${unchecked.length === 1 ? "reads" : "read"} below the top level, so ${unchecked.length === 1 ? "it was" : "they were"} not checked against the record keys` : refs.top.length > 0 ? "every field it names exists" : "";
+  const withSoundness = (base) => soundness ? `${base}, and ${soundness}` : base;
+  let detail;
+  let lede;
+  if (outcome.kind === "null-elements") {
+    lede = "returned only null values";
+    const projected = `all ${outcome.count} of the elements it projected are null`;
+    if (unknown.length > 0) {
+      detail = `${projected}, because ${isNotAField(unknown)}`;
+    } else if (unchecked.length > 0) {
+      detail = withSoundness(projected);
+    } else {
+      detail = `${projected}, and every field it names exists — a multi-select list ` + `(\`[A, B]\`) reads each entry against \`Data\` itself, so on a list ` + `result use \`[].[A, B]\` or \`[].{a: A, b: B}\` to read the records`;
+    }
+  } else if (outcome.kind === "null-rows") {
+    lede = "returned only null values";
+    const projected = `every value it projected is null on all ${outcome.count} row(s)`;
+    detail = unknown.length > 0 ? `${projected}, because ${isNotAField(unknown)}` : withSoundness(projected);
+  } else if (outcome.kind === "null-values") {
+    lede = "returned only null values";
+    const projected = `every key it projected (${nameList(outcome.keys)}) is null`;
+    const sameSet = unknown.length === outcome.keys.length && outcome.keys.every((k) => unknown.includes(k));
+    if (sameSet) {
+      detail = `${isNotAField(outcome.keys)}, so every key it projected is null`;
+    } else if (unknown.length > 0) {
+      detail = `${projected}, because ${isNotAField(unknown)}`;
+    } else {
+      detail = withSoundness(`${projected} on all ${scope}`);
+    }
+  } else {
+    lede = "returned nothing";
+    if (unknown.length > 0) {
+      detail = isNotAField(unknown);
+    } else {
+      const selection = refs.hasPredicate ? "no record matched" : "the expression resolved to no value";
+      detail = withSoundness(`${selection} — it read ${scope}`);
+    }
+  }
+  const fields = present.length > 0 ? ` Available fields: ${nameList(present)}.` : "";
+  return `--output-filter ${JSON.stringify(filter)} ${lede}: ${detail}.${fields}`;
+}
+function appendWarning(existing, note) {
+  return existing ? `${existing} ${note}` : note;
+}
+function applyFilter(data, filter, onWarning) {
   const codec = requireJmespath();
   let result;
   try {
@@ -5048,9 +5391,34 @@ function applyFilter(data, filter) {
   } catch (err) {
     throw new FilterEvaluationError(filter, err);
   }
-  if (result == null)
+  const inputCount = countRecords(data);
+  const warn = (outcome) => {
+    if (inputCount === 0)
+      return;
+    const note = buildFilterWarning(filter, data, outcome);
+    getOutputSink().writeErr(`[WARN] ${note}
+`);
+    onWarning?.(note);
+  };
+  const warnIfAllNull = (records) => {
+    const keys = alwaysNullKeys(records);
+    if (keys.length > 0)
+      warn({ kind: "null-values", keys });
+  };
+  if (result == null) {
+    warn({ kind: "empty" });
     return [];
+  }
   if (Array.isArray(result)) {
+    if (result.length === 0) {
+      warn({ kind: "empty" });
+    } else if (result.every((entry) => entry === null)) {
+      warn({ kind: "null-elements", count: result.length });
+    } else if (result.every((entry) => Array.isArray(entry)) && carriesOnlyNulls(result)) {
+      warn({ kind: "null-rows", count: result.length });
+    } else {
+      warnIfAllNull(result);
+    }
     if (result.length > 0 && typeof result[0] !== "object") {
       const fieldMatch = filter.match(/\.(\w+)$/);
       const key = fieldMatch ? fieldMatch[1] : "Value";
@@ -5058,10 +5426,30 @@ function applyFilter(data, filter) {
     }
     return result;
   }
-  if (typeof result === "object")
+  if (typeof result === "object") {
+    warnIfAllNull([result]);
     return result;
+  }
   return { Value: result };
 }
+function filterFailureData(envelope) {
+  const filter = getOutputFilter();
+  const data = envelope.Data;
+  if (!filter || data == null)
+    return;
+  let note;
+  const [filterError, filtered] = catchError(() => applyFilter(data, filter, (n) => {
+    note = n;
+  }));
+  if (filterError) {
+    envelope.Warning = appendWarning(envelope.Warning, `--output-filter was not applied, so Data is shown in full: ${filterError.message}`);
+    return;
+  }
+  envelope.Data = filtered;
+  if (note) {
+    envelope.Warning = appendWarning(envelope.Warning, note);
+  }
+}
 function defaultErrorCodeForResult(result) {
   switch (result) {
     case RESULTS.AuthenticationError:
@@ -5105,7 +5493,7 @@ function defaultErrorCodeForHttpStatus(status) {
     return "server_error";
   return;
 }
-var LOCAL_PERMISSION_TEXT_PATTERN = /(?:\b|\()(?:EACCES|EPERM|EROFS)(?::\s|\))/;
+var LOCAL_PERMISSION_TEXT_PATTERN = new RegExp(`(?:\\b|\\()(?:${[...LOCAL_PERMISSION_ERROR_CODES].join("|")})(?::\\s|\\))`);
 function defaultErrorCodeForFailure(data) {
   if (data.Result === RESULTS.Failure) {
     const status = data.Context?.httpStatus ?? parseHttpStatusFromMessage2(data.Message);
@@ -5144,8 +5532,14 @@ var OutputFormatter;
     }
     const filter = getOutputFilter();
     if (filter) {
-      const filtered = applyFilter(data.Data, filter);
+      let note;
+      const filtered = applyFilter(data.Data, filter, (n) => {
+        note = n;
+      });
       data.Data = normalize ? normalizeDataKeys(filtered, verbatim, subtrees && { refs: subtrees.refs, mode: "skip" }) : filtered;
+      if (note) {
+        data.Warning = appendWarning(data.Warning, note);
+      }
     }
     logOutput(normalizeOutputKeys(data), getOutputFormat(), options?.tableRowStyle);
   }
@@ -5173,12 +5567,13 @@ var OutputFormatter;
     delete envelope.TelemetryErrorClass;
     delete envelope.TelemetryTerminalOutcome;
     delete envelope.TelemetryTerminalSignal;
+    filterFailureData(envelope);
     if (!suppressTelemetry) {
       telemetry.trackEvent(CommonTelemetryEvents.Error, {
-        result: data.Result,
-        errorCode: data.ErrorCode,
-        retry: data.Retry,
-        message: data.Message
+        [ErrorDimensions.Result]: data.Result,
+        [ErrorDimensions.ErrorCode]: data.ErrorCode,
+        [ErrorDimensions.Retry]: data.Retry,
+        [ErrorDimensions.ErrorMessage]: data.Message
       });
     }
     logOutput(normalizeOutputKeys(envelope), getOutputFormat());
@@ -5221,13 +5616,20 @@ var OutputFormatter;
   OutputFormatter.log = log;
   function formatToString(data) {
     const filter = getOutputFilter();
+    const envelope = data;
     if ("Data" in data && data.Data != null) {
       data.Data = normalizeDataKeys(data.Data);
       if (filter) {
-        data.Data = normalizeDataKeys(applyFilter(data.Data, filter));
+        let note;
+        data.Data = normalizeDataKeys(applyFilter(data.Data, filter, (n) => {
+          note = n;
+        }));
+        if (note) {
+          envelope.Warning = appendWarning(envelope.Warning, note);
+        }
       }
     }
-    const output = normalizeOutputKeys(data);
+    const output = normalizeOutputKeys(envelope);
     const lines = [];
     const sink = getOutputSink();
     printOutput(output, getOutputFormat(), (msg) => {
@@ -5277,7 +5679,7 @@ var LEGACY_SKILL_NAMESPACE = "uipath:";
 var MAX_SKILL_NAME_LENGTH = 80;
 var SKILL_NAME_PATTERN = /^[a-z0-9][a-z0-9-]*[a-z0-9]$/;
 function productMode(productArea, mode) {
-  return { product_area: productArea, mode };
+  return { ProductArea: productArea, Mode: mode };
 }
 function attributionRecord(groups) {
   const record = {};
@@ -5335,6 +5737,7 @@ var COMMAND_ATTRIBUTION = commandAttribution([
   ["rpa", "build", ["uip.rpa-legacy"]],
   ["conversational", "operate", ["uip.conversational"]],
   ["agents", "build", ["uip.codedagent", "uip.agent"]],
+  ["coding-agents", "build", ["uip.coder"]],
   ["agenthub", "build", ["uip.agenthub"]],
   ["coded-apps", "build", ["uip.codedapp"]],
   ["functions", "build", ["uip.function", "uip.functions"]],
@@ -5420,32 +5823,64 @@ function normalizeSkillName(value) {
 function buildCommandTelemetryAttribution(commandPath, skillSource) {
   const skillName = normalizeSkillName(skillSource);
   return {
-    ...skillName ? { skill_name: skillName } : {},
+    ...skillName ? { SkillName: skillName } : {},
     ...getCommandProductModeAttribution(commandPath)
   };
 }
+var AGENT_SESSION_ENV = {
+  [BaseDimensions.AgentModel]: "UIPATH_AGENT_MODEL",
+  [SkillsDimensions.PermissionMode]: "UIPATH_PERMISSION_MODE",
+  [SkillsDimensions.EffortLevel]: "UIPATH_EFFORT_LEVEL",
+  [SkillsDimensions.SkillsVersion]: "UIPATH_SKILLS_VERSION"
+};
+var MAX_TELEMETRY_TOKEN_LENGTH = 120;
+function sanitizeTelemetryToken(value) {
+  return value.replace(/[^A-Za-z0-9:._/ -]/g, "_").slice(0, MAX_TELEMETRY_TOKEN_LENGTH);
+}
+function buildAgentSessionTelemetry(env) {
+  const dimensions = {};
+  for (const [key, variable] of Object.entries(AGENT_SESSION_ENV)) {
+    const value = env[variable]?.trim();
+    if (value) {
+      dimensions[key] = sanitizeTelemetryToken(value);
+    }
+  }
+  return dimensions;
+}
 
 // ../common/src/telemetry/command-name.ts
-var TELEMETRY_COMMAND_ROOT = "uip";
+var TELEMETRY_NAME_ROOT = "Cli";
+var CLI_COMMAND_ROOT = "uip";
+var TELEMETRY_NAME_BARE_ACTION = "Invoke";
 function commandTelemetryName(parts) {
+  const action = vetCommandTokens(parts).map(pascalizeToken).join("");
+  return `${TELEMETRY_NAME_ROOT}.${action || TELEMETRY_NAME_BARE_ACTION}`;
+}
+function commandInvocationPath(parts) {
+  return [CLI_COMMAND_ROOT, ...vetCommandTokens(parts)].join(" ");
+}
+function vetCommandTokens(parts) {
   const tokens = [];
   for (const part of parts) {
-    const pieces = String(part ?? "").split(/\s+/).filter((token) => token && !token.startsWith("-") && token !== TELEMETRY_COMMAND_ROOT);
+    const pieces = String(part ?? "").split(/\s+/).filter((token) => token && !token.startsWith("-") && token !== CLI_COMMAND_ROOT);
     if (pieces.every(isCommandToken)) {
       tokens.push(...pieces);
       continue;
     }
     tokens.push(UNKNOWN_TOKEN);
   }
-  return [TELEMETRY_COMMAND_ROOT, ...tokens].join(".");
+  return tokens;
+}
+function pascalizeToken(token) {
+  return token.split("-").filter(Boolean).map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join("");
 }
-var COMMAND_TOKEN_PATTERN = /^[a-z0-9][a-z0-9-]*$/;
+var COMMAND_TOKEN_PATTERN = /^[a-z][a-z0-9-]*$/;
 var MAX_COMMAND_TOKEN_LENGTH = 32;
 var GUID_TOKEN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
 function isCommandToken(token) {
-  return token.length <= MAX_COMMAND_TOKEN_LENGTH && COMMAND_TOKEN_PATTERN.test(token) && !GUID_TOKEN.test(token) && !/^\d+$/.test(token);
+  return token.length <= MAX_COMMAND_TOKEN_LENGTH && COMMAND_TOKEN_PATTERN.test(token) && !GUID_TOKEN.test(token);
 }
-var UNKNOWN_TOKEN = "<unknown>";
+var UNKNOWN_TOKEN = "unknown";
 
 // ../common/src/telemetry/invocation-request.ts
 var requestContextSlot = singleton("TelemetryInvocationRequestContext");
@@ -5550,7 +5985,7 @@ function withheldArgumentValues(cmd) {
   });
   return values;
 }
-function deriveCommandPath(cmd) {
+function deriveCommandParts(cmd) {
   const parts = [];
   let current = cmd;
   while (current) {
@@ -5563,14 +5998,13 @@ function deriveCommandPath(cmd) {
   if (parts.length > 1) {
     parts.shift();
   }
-  return commandTelemetryName(parts);
+  return parts;
 }
 function isErrorContext(value) {
   return value !== null && typeof value === "object";
 }
 function commandHelpHint(commandPath) {
-  const command = commandPath.replace(/\./g, " ");
-  return `An unexpected error occurred. Run '${command} --help' to verify command syntax, or run with --log-level debug for details.`;
+  return `An unexpected error occurred. Run '${commandPath} --help' to verify command syntax, or run with --log-level debug for details.`;
 }
 function isPromptCancellation(error) {
   return error instanceof Error && error.name === "ExitPromptError";
@@ -5595,7 +6029,9 @@ Command.prototype.trackedAction = function(context, fn, properties) {
       yaml: getOutputFormat() === "yaml",
       filter: getOutputFilter() !== undefined
     });
-    const telemetryName = deriveCommandPath(command);
+    const commandParts = deriveCommandParts(command);
+    const telemetryName = commandTelemetryName(commandParts);
+    const commandPath = commandInvocationPath(commandParts);
     const props = typeof properties === "function" ? properties(...args) : properties;
     markCommandStart();
     const supplied = recordSuppliedArgumentValues(withheldArgumentValues(command));
@@ -5630,7 +6066,7 @@ Command.prototype.trackedAction = function(context, fn, properties) {
           Result: finalResult,
           ...customErrorCode ? { ErrorCode: customErrorCode } : {},
           Message: errorMessage,
-          Instructions: customInstructions ?? commandHelpHint(telemetryName),
+          Instructions: customInstructions ?? commandHelpHint(commandPath),
           ...customRetry ? { Retry: customRetry } : {},
           ...customContext ? { Context: customContext } : {}
         });
@@ -5647,8 +6083,8 @@ Command.prototype.trackedAction = function(context, fn, properties) {
         recordedFailure,
         pollSignal: context.pollSignal
       });
-      if (terminalTelemetry.error_class === "internal" && error) {
-        telemetry.trackException(error instanceof Error ? error : new Error(String(error)), { command_name: telemetryName }, getInvocationRequestContext());
+      if (terminalTelemetry[CommandDimensions.ErrorClass] === "internal" && error) {
+        telemetry.trackException(error instanceof Error ? error : new Error(String(error)), { [CommandDimensions.CommandName]: commandPath }, getInvocationRequestContext());
       }
       const commandParams = extractCommandParams(command);
       if (props) {
@@ -5659,10 +6095,12 @@ Command.prototype.trackedAction = function(context, fn, properties) {
       const baseProperties = redactProperties({
         ...commandParams,
         ...props,
-        ...buildCommandTelemetryAttribution(telemetryName, process.env.UIPATH_SKILL),
-        command: "true",
+        ...buildCommandTelemetryAttribution(commandPath, process.env.UIPATH_SKILL),
+        ...buildAgentSessionTelemetry(process.env),
+        [CommandDimensions.CommandName]: commandPath,
+        [CommandDimensions.IsCommand]: "true",
         ...terminalTelemetry,
-        ...errorMessage ? { errorMessage } : {}
+        ...errorMessage ? { [CommandDimensions.ErrorMessage]: errorMessage } : {}
       });
       emitInvocationRequest(telemetryName, success, baseProperties);
     } finally {
@@ -5907,6 +6345,43 @@ var BOOLEAN_FLAGS = new Set(HOST_GLOBAL_FLAGS);
 // ../common/src/interactivity-context.ts
 var modeSlot = singleton("InteractivityMode");
 var interactiveFlagSlot = singleton("InteractiveFlag");
+function getInteractivityMode() {
+  return modeSlot.get("auto") ?? "auto";
+}
+// ../common/src/mime-types.ts
+var MIME_TYPES_BY_EXTENSION = Object.freeze({
+  pdf: "application/pdf",
+  png: "image/png",
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  gif: "image/gif",
+  webp: "image/webp",
+  bmp: "image/bmp",
+  tif: "image/tiff",
+  tiff: "image/tiff",
+  svg: "image/svg+xml",
+  txt: "text/plain",
+  log: "text/plain",
+  md: "text/markdown",
+  csv: "text/csv",
+  tsv: "text/tab-separated-values",
+  json: "application/json",
+  xml: "application/xml",
+  html: "text/html",
+  htm: "text/html",
+  yaml: "application/yaml",
+  yml: "application/yaml",
+  doc: "application/msword",
+  docx: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+  xls: "application/vnd.ms-excel",
+  xlsx: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+  ppt: "application/vnd.ms-powerpoint",
+  pptx: "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+  zip: "application/zip",
+  mp3: "audio/mpeg",
+  wav: "audio/wav",
+  mp4: "video/mp4"
+});
 // ../common/src/option-aliases.ts
 function resolveDeprecatedOptionAlias({
   preferredValue,
@@ -6415,6 +6890,7 @@ var ScreenLogger;
 })(ScreenLogger ||= {});
 // ../common/src/sdk-user-agent.ts
 var USER_AGENT_HEADER = "User-Agent";
+var AGENT_PROPERTY = BaseDimensions.Agent;
 var sdkUserAgentHostToken = singleton("SdkUserAgentHostToken");
 function userAgentPatchKey(userAgent) {
   return Symbol.for(`@uipath/common/sdk-user-agent/${userAgent}`);
@@ -7022,7 +7498,7 @@ var package_default2 = {
   name: "@uipath/integrationservice-sdk",
   author: "UiPath",
   license: "SEE LICENSE IN LICENSE.txt",
-  version: "1.203.0-preview.212",
+  version: "1.204.0-preview.211",
   repository: {
     type: "git",
     url: "https://github.com/UiPath/cli.git",
@@ -13073,6 +13549,11 @@ var pickName = (claims) => {
   const username = asString(claims?.preferred_username);
   return asString(claims?.name) ?? (looksLikeEmail(username) ? undefined : username);
 };
+var pickScopes = (claims) => {
+  const raw = claims?.scope;
+  const scopes = Array.isArray(raw) ? raw.filter((entry) => asString(entry) !== undefined) : typeof raw === "string" ? raw.split(/\s+/).filter(Boolean) : [];
+  return scopes.length > 0 ? scopes : undefined;
+};
 var resolveSessionIdentity = (accessToken, authFlow) => {
   const claims = accessToken ? decodeClaims(accessToken) : undefined;
   const email = pickEmail(claims);
@@ -13098,6 +13579,7 @@ var resolveSessionIdentity = (accessToken, authFlow) => {
     identity.clientId = clientId;
   return identity;
 };
+var readTokenScopes = (accessToken) => accessToken ? pickScopes(decodeClaims(accessToken)) : undefined;
 
 // ../auth/src/envAuth.ts
 var ENV_AUTH_ENABLE_VAR = "UIPATH_CLI_ENABLE_ENV_AUTH";
@@ -13170,6 +13652,7 @@ var readAuthFromEnv = () => {
   const expiration = getTokenExpiration(accessToken);
   const loginStatus = expiration && expiration <= new Date ? "Expired" : "Logged in";
   const identity = resolveSessionIdentity(accessToken);
+  const scopes = readTokenScopes(accessToken);
   return {
     loginStatus,
     accessToken,
@@ -13180,7 +13663,8 @@ var readAuthFromEnv = () => {
     tenantId,
     expiration,
     source: "env-vars" /* EnvironmentVariables */,
-    ...identity ? { identity } : {}
+    ...identity ? { identity } : {},
+    ...scopes ? { scopes } : {}
   };
 };
 
@@ -13818,10 +14302,15 @@ async function buildFileStatus(tokens, credentials, globalHint) {
 }
 function identityFields(accessToken, credentials) {
   const identity = resolveSessionIdentity(accessToken, parseAuthFlow(credentials[AUTH_FLOW_ENV_VAR]));
-  return identity ? { identity } : {};
+  const scopes = readTokenScopes(accessToken);
+  return {
+    ...identity ? { identity } : {},
+    ...scopes ? { scopes } : {}
+  };
 }
 function buildRobotStatus(robotCreds) {
   const identity = resolveSessionIdentity(robotCreds.accessToken);
+  const scopes = readTokenScopes(robotCreds.accessToken);
   return {
     loginStatus: "Logged in",
     accessToken: robotCreds.accessToken,
@@ -13833,7 +14322,8 @@ function buildRobotStatus(robotCreds) {
     issuer: robotCreds.issuer,
     expiration: getTokenExpiration(robotCreds.accessToken),
     source: "robot" /* Robot */,
-    ...identity ? { identity } : {}
+    ...identity ? { identity } : {},
+    ...scopes ? { scopes } : {}
   };
 }
 var isFileNotFoundError = (error) => {
@@ -14100,7 +14590,8 @@ var getAuthContext = async (options = {}) => {
     organizationId: status.organizationId,
     organizationName: status.organizationName,
     tenantId: status.tenantId,
-    tenantName
+    tenantName,
+    identity: status.identity
   };
 };
 // ../auth/src/tenantSelection.ts
@@ -14998,6 +15489,577 @@ function filterByTriggerMode(activities, isTrigger) {
   return activities.filter((a) => a.isTrigger === isTrigger);
 }
 
+// src/services/activity-metadata/text.ts
+function asText(v, fallback = "") {
+  if (typeof v === "string") {
+    return v;
+  }
+  if (v === undefined || v === null) {
+    return fallback;
+  }
+  if (typeof v === "number" || typeof v === "boolean") {
+    return String(v);
+  }
+  return JSON.stringify(v) ?? fallback;
+}
+
+// src/services/activity-metadata/annotate.ts
+var asBag = (v) => v && typeof v === "object" ? v : {};
+var TS_TYPE = {
+  string: "string",
+  integer: "number",
+  number: "number",
+  double: "number",
+  float: "number",
+  boolean: "boolean",
+  object: "Record<string, unknown>",
+  array: "unknown[]",
+  date: "string",
+  datetime: "string"
+};
+function firstLine(description) {
+  const text = asText(description);
+  return text ? text.split(`
+`)[0] : undefined;
+}
+function tsType(raw) {
+  return TS_TYPE[asText(raw).toLowerCase()] ?? "unknown";
+}
+var emptyNode = () => ({ children: new Map, isArray: false });
+function insert(root, leaf) {
+  const parts = leaf.path.split(".");
+  let node2 = root;
+  parts.forEach((rawPart, i) => {
+    const isArray = rawPart.endsWith("[*]");
+    const key = isArray ? rawPart.slice(0, -3) : rawPart;
+    if (!node2.children.has(key)) {
+      node2.children.set(key, emptyNode());
+    }
+    const child = node2.children.get(key);
+    if (isArray) {
+      child.isArray = true;
+    }
+    if (i === parts.length - 1) {
+      child.leaf = leaf;
+    }
+    node2 = child;
+  });
+}
+function render(node2, indent = "  ") {
+  const lines = [];
+  for (const [key, child] of node2.children) {
+    const opt = child.leaf?.optional ?? true ? "?" : "";
+    const comment = child.leaf?.comment ? `   // ${child.leaf.comment}` : "";
+    let type;
+    if (child.children.size > 0) {
+      const inner = render(child, `${indent}  `);
+      type = `{
+${inner}${indent}}`;
+    } else {
+      type = child.leaf ? child.leaf.type : "unknown";
+    }
+    if (child.isArray) {
+      type = `Array<${type}>`;
+    }
+    lines.push(`${indent}${key}${opt}: ${type};${comment}`);
+  }
+  return lines.length ? `${lines.join(`
+`)}
+` : "";
+}
+function block(name, leaves) {
+  if (leaves.length === 0) {
+    return;
+  }
+  const root = emptyNode();
+  for (const l of leaves) {
+    insert(root, l);
+  }
+  return `type ${name} = {
+${render(root)}};`;
+}
+function firstMethod(sr) {
+  const methods = asBag(asBag(sr.metadata).method);
+  const verb = Object.keys(methods)[0] ?? "GET";
+  return { verb, def: asBag(methods[verb]) };
+}
+function paramLeaves(def, kind) {
+  return (def.parameters ?? []).map(asBag).filter((p) => asText(p.type).toLowerCase() === kind).map((p) => ({
+    path: asText(p.name),
+    type: tsType(p.dataType ?? p.type),
+    optional: p.required !== true,
+    comment: firstLine(p.description)
+  }));
+}
+function fieldLeaves(sr, verb, side) {
+  const out = [];
+  const walk = (obj, prefix) => {
+    for (const [key, value] of Object.entries(asBag(obj))) {
+      const v = asBag(value);
+      if (v.method && v.type) {
+        const m = asBag(v.method)[verb];
+        if (m && asBag(m)[side] === true) {
+          out.push({
+            path: prefix + key,
+            type: tsType(v.type),
+            optional: !(asBag(m).required === true || v.required === true),
+            comment: firstLine(v.description)
+          });
+        }
+      } else if (value && typeof value === "object") {
+        walk(value, `${prefix + key}.`);
+      }
+    }
+  };
+  walk(sr.fields, "");
+  return out;
+}
+function pascal(raw) {
+  const cleaned = raw.replace(/[^A-Za-z0-9]+(.)?/g, (_, c) => c ? c.toUpperCase() : "");
+  return cleaned.charAt(0).toUpperCase() + cleaned.slice(1) || "Action";
+}
+function buildTypeHeader(sr) {
+  const name = pascal(asText(sr.name, "Action"));
+  const { verb, def } = firstMethod(sr);
+  const isList = asText(def.operation).toLowerCase() === "list";
+  const body = block(`${name}RequestBody`, fieldLeaves(sr, verb, "request"));
+  const query = block(`${name}RequestQuery`, paramLeaves(def, "query"));
+  const path2 = block(`${name}RequestPath`, paramLeaves(def, "path"));
+  let response = block(`${name}Response`, fieldLeaves(sr, verb, "response"));
+  if (isList && response) {
+    response = response.replace(`type ${name}Response = {`, `type ${name}ResponseRecord = {`).concat(`
+
+type ${name}Response = Array<${name}ResponseRecord>;`);
+  }
+  const bodyType = body ? `${name}RequestBody` : "unknown";
+  const queryType = query ? `${name}RequestQuery` : "Record<string, string>";
+  const responseType = response ? `${name}Response` : "unknown";
+  const context = [
+    "type Context = {",
+    "  request: {",
+    `    body?: ${bodyType};`,
+    `    query?: ${queryType};`,
+    "    headers?: Record<string, string>;",
+    "  };",
+    "  connectionConfiguration?: Record<string, string>;",
+    "  connectorKey: string;",
+    "  connectionId: string;",
+    "};"
+  ].join(`
+`);
+  const signature = [
+    "// execute(context: Context): Promise<{",
+    `//   status: number; headers?: { name: string; value: string }[]; body: ${responseType};`,
+    "// }>",
+    "// Docs only — generated from the activity metadata; re-run on change."
+  ].join(`
+`);
+  const parts = [body, query, path2, response, context, signature].filter((b) => b !== undefined);
+  return `/*
+${parts.join(`
+
+`)}
+*/
+`;
+}
+function injectTypeHeader(source, header) {
+  const leading = /^\s*\/\*[\s\S]*?\*\/\s*\n/;
+  return leading.test(source) ? source.replace(leading, header) : `${header}
+${source}`;
+}
+
+// src/services/activity-metadata/generate.ts
+var VERB_SLOTS = ["GET", "GETBYID", "POST", "PUT", "PATCH", "DELETE"];
+var VERB_OP = {
+  GET: "List",
+  GETBYID: "Retrieve",
+  POST: "Create",
+  PUT: "Replace",
+  PATCH: "Update",
+  DELETE: "Delete"
+};
+var OPERATIONS = [
+  "Unknown",
+  "List",
+  "Retrieve",
+  "Replace",
+  "Update",
+  "Create",
+  "Delete",
+  "Upload",
+  "Download"
+];
+function humanize(s) {
+  const last = s.replace(/\[\*\]$/, "").split(".").pop() ?? s;
+  return last.replaceAll("_", " ").replaceAll(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/^./, (c) => c.toUpperCase());
+}
+function fieldName(e) {
+  return e.isArray ? `${e.name}[*]` : e.name;
+}
+function referenceFor(l) {
+  return {
+    scriptRef: l.scriptRef,
+    lookupValue: l.value,
+    lookupNames: l.display
+  };
+}
+function fieldEntry(verb, e, dir) {
+  const m = { name: verb };
+  if (dir === "request") {
+    m.request = true;
+    if (e.required) {
+      m.required = true;
+    }
+    if (e.returned) {
+      m.response = true;
+    }
+  } else {
+    m.response = true;
+  }
+  const f = {
+    name: fieldName(e),
+    type: e.type,
+    displayName: e.displayName ?? humanize(e.name)
+  };
+  if (e.description) {
+    f.description = e.description;
+  }
+  f.method = { [verb]: m };
+  if (e.primaryKey) {
+    f.primaryKey = true;
+  }
+  if (e.enum) {
+    f.enum = e.enum;
+  }
+  if (e.defaultValue !== undefined) {
+    f.defaultValue = e.defaultValue;
+  }
+  if (e.lookup) {
+    f.reference = referenceFor(e.lookup);
+  }
+  if (dir === "request" && e.design) {
+    f.design = e.design;
+  }
+  return f;
+}
+function generateActivityMetadata(min) {
+  const a = min.activity;
+  const verb = String(a.httpMethod).toUpperCase();
+  const inputs = min.inputs ?? [];
+  const outputs = min.outputs ?? [];
+  const urlIns = inputs.filter((i) => i.in === "path" || i.in === "query");
+  const bodyIns = inputs.filter((i) => i.in === "body");
+  const parameters = urlIns.map((i) => {
+    const p = {
+      name: i.name,
+      description: i.description,
+      type: i.in,
+      dataType: i.type,
+      displayName: i.displayName ?? humanize(i.name)
+    };
+    if (i.required) {
+      p.required = true;
+    }
+    if (i.defaultValue !== undefined) {
+      p.defaultValue = i.defaultValue;
+    }
+    if (i.enum) {
+      p.enhancedEnum = i.enum;
+    }
+    if (i.lookup) {
+      p.reference = referenceFor(i.lookup);
+    }
+    if (i.design) {
+      p.design = i.design;
+    }
+    return p;
+  });
+  const fields = {};
+  for (const i of bodyIns) {
+    fields[fieldName(i)] = fieldEntry(verb, i, "request");
+  }
+  for (const i of urlIns.filter((x) => x.returned)) {
+    fields[fieldName(i)] = fieldEntry(verb, {
+      ...i,
+      required: false,
+      lookup: undefined,
+      design: undefined,
+      returned: false
+    }, "response");
+  }
+  for (const o of outputs) {
+    const key = fieldName(o);
+    const existing = fields[key];
+    if (existing) {
+      const method = existing.method;
+      method[verb].response = true;
+      if (o.primaryKey) {
+        existing.primaryKey = true;
+      }
+    } else {
+      fields[key] = fieldEntry(verb, o, "response");
+    }
+  }
+  const primaryKey = Object.values(fields).filter((f) => f.primaryKey).map((f) => f.name);
+  const operation = a.operation ?? VERB_OP[verb];
+  const methodObj = {
+    operation,
+    method: verb === "GETBYID" ? "GET" : verb,
+    path: a.vendorPath,
+    scriptRef: a.scriptRef
+  };
+  if (a.description) {
+    methodObj.description = a.description;
+  }
+  if (parameters.length) {
+    methodObj.parameters = parameters;
+  }
+  return {
+    name: a.name,
+    displayName: a.displayName ?? humanize(a.name),
+    description: a.description,
+    type: "standard",
+    elementKey: a.elementKey,
+    path: a.vendorPath,
+    metadata: {
+      ...primaryKey.length ? { primaryKey } : {},
+      method: { [verb]: methodObj }
+    },
+    fields
+  };
+}
+
+// src/services/activity-metadata/validate.ts
+var BANNED_REFERENCE_KEYS = [
+  "path",
+  "objectName",
+  "childPath",
+  "hydration",
+  "dependsOn"
+];
+var asBag2 = (v) => v && typeof v === "object" ? v : {};
+var isBareName = (v) => !/[\\/.]/.test(asText(v));
+function checkReference(where, r, errs) {
+  const scriptRef = r.scriptRef;
+  if (!scriptRef) {
+    errs.push(`${where}: reference.scriptRef is required (this structure is scriptRef-only)`);
+  } else if (!isBareName(scriptRef)) {
+    errs.push(`${where}: scriptRef "${asText(scriptRef)}" must be a bare base name (no path, no extension)`);
+  }
+  if (!r.lookupValue) {
+    errs.push(`${where}: reference.lookupValue is required`);
+  }
+  if (!Array.isArray(r.lookupNames) || r.lookupNames.length === 0) {
+    errs.push(`${where}: reference.lookupNames must be a non-empty array`);
+  }
+  for (const banned of BANNED_REFERENCE_KEYS) {
+    if (r[banned] !== undefined) {
+      errs.push(`${where}: reference must not carry "${banned}" (obsolete / not used in this structure)`);
+    }
+  }
+}
+function checkDesign(where, d, required, errs) {
+  if (!d) {
+    errs.push(`${where}: every input must carry a design block (authored in the min-file)`);
+    return;
+  }
+  const design = asBag2(d);
+  const position = asText(design.position);
+  if (!["primary", "secondary"].includes(position)) {
+    errs.push(`${where}: design.position must be primary|secondary (got "${position}")`);
+  } else if (required && position !== "primary") {
+    errs.push(`${where}: required input must have design.position "primary"`);
+  } else if (!required && position !== "secondary") {
+    errs.push(`${where}: optional input must have design.position "secondary"`);
+  }
+  if (design.component === "FolderPicker" && design.enableUserOverride) {
+    errs.push(`${where}: FolderPicker lookups must not set enableUserOverride`);
+  }
+}
+function checkSource(min, errs) {
+  for (const i of [...min.inputs ?? [], ...min.outputs ?? []]) {
+    const delimiter = asBag2(i.design).delimiter;
+    if (i.isArray && delimiter != null) {
+      errs.push(`input ${i.name}: isArray and design.delimiter are mutually exclusive (a true array is never joined)`);
+    }
+  }
+  for (const i of min.inputs ?? []) {
+    if (i.primaryKey && !i.returned) {
+      errs.push(`input ${i.name}: primaryKey requires returned:true (primaryKey is a response-side fact)`);
+    }
+  }
+}
+function verbSlot(sr, errs) {
+  const methods = asBag2(asBag2(sr.metadata).method);
+  const verbSlots = Object.keys(methods);
+  if (verbSlots.length !== 1) {
+    errs.push(`metadata.method must have exactly ONE verb slot (got ${verbSlots.length}) — an activity is always single-verb`);
+  }
+  const verb = verbSlots[0];
+  return { verb, m: asBag2(methods[verb]) };
+}
+function checkRequiredKeys(sr, verb, m, errs) {
+  for (const k of ["name", "displayName", "description", "metadata"]) {
+    if (!sr[k]) {
+      errs.push(`missing top-level "${k}"`);
+    }
+  }
+  for (const k of ["operation", "method", "path", "scriptRef"]) {
+    if (!m[k]) {
+      errs.push(`method ${verb}: missing "${k}"`);
+    }
+  }
+  if (m.scriptRef && !isBareName(m.scriptRef)) {
+    errs.push(`method ${verb}: scriptRef "${asText(m.scriptRef)}" must be a bare base name (no path, no extension)`);
+  }
+}
+function checkParameter(raw, errs) {
+  const p = asBag2(raw);
+  const label = `parameter ${asText(p.name, "?")}`;
+  for (const k of [
+    "name",
+    "description",
+    "type",
+    "dataType",
+    "displayName"
+  ]) {
+    if (!p[k]) {
+      errs.push(`${label}: missing "${k}"`);
+    }
+  }
+  const type = asText(p.type);
+  if (type && !["path", "query"].includes(type)) {
+    errs.push(`${label}: type must be path|query (got "${type}") — body inputs are fields`);
+  }
+  if (p.enum) {
+    errs.push(`${label}: parameters use enhancedEnum, never the deprecated enum`);
+  }
+  if (p.reference) {
+    checkReference(label, asBag2(p.reference), errs);
+  }
+  checkDesign(label, p.design, Boolean(p.required), errs);
+}
+function checkField(verb, k, rawField, errs) {
+  const f = asBag2(rawField);
+  for (const key of ["name", "type", "displayName", "method"]) {
+    if (!f[key]) {
+      errs.push(`field ${k}: missing "${key}"`);
+    }
+  }
+  const fm = asBag2(asBag2(f.method)[verb]);
+  if (Object.keys(fm).length === 0) {
+    errs.push(`field ${k}: no method entry for verb ${verb}`);
+    return;
+  }
+  if (f.primaryKey && !fm.response) {
+    errs.push(`field ${k}: primaryKey on a field that is not returned`);
+  }
+  if (k.endsWith("[*]") && asBag2(f.design).delimiter != null) {
+    errs.push(`field ${k}: a true-array field must not carry a delimiter`);
+  }
+  if (f.reference) {
+    checkReference(`field ${k}`, asBag2(f.reference), errs);
+  }
+  if (fm.request) {
+    checkDesign(`field ${k}`, f.design, Boolean(fm.required), errs);
+  } else if (f.design) {
+    errs.push(`field ${k}: response-only fields must not carry design`);
+  }
+}
+function checkListOutputs(sr, verb, m, errs) {
+  if (m.operation !== "List") {
+    return;
+  }
+  const outs = Object.entries(asBag2(sr.fields)).filter(([, f]) => asBag2(asBag2(asBag2(f).method)[verb]).response);
+  if (outs.length === 0) {
+    errs.push("List operation must declare the returned element's fields as outputs");
+  } else if (outs.length === 1 && /^[^.]+\[\*\]$/.test(outs[0][0])) {
+    errs.push(`List operation output "${outs[0][0]}" is a records-array wrapper — declare the element's fields (id, name, …) flat instead; the action returns the bare array`);
+  }
+}
+function checkClosedSets(verb, m, errs) {
+  if (verb && !VERB_SLOTS.includes(verb)) {
+    errs.push(`httpMethod "${verb}" not in ${VERB_SLOTS.join("|")} (the single-record slot is GETBYID, no underscores)`);
+  }
+  const operation = asText(m.operation);
+  if (operation && !OPERATIONS.includes(operation)) {
+    errs.push(`operation "${operation}" not in ${OPERATIONS.join("|")}`);
+  }
+}
+function collectActivityMetadataErrors(min, sr) {
+  const errs = [];
+  checkSource(min, errs);
+  const { verb, m } = verbSlot(sr, errs);
+  checkRequiredKeys(sr, verb, m, errs);
+  for (const raw of m.parameters ?? []) {
+    checkParameter(raw, errs);
+  }
+  for (const [k, rawField] of Object.entries(asBag2(sr.fields))) {
+    checkField(verb, k, rawField, errs);
+  }
+  checkListOutputs(sr, verb, m, errs);
+  checkClosedSets(verb, m, errs);
+  return errs;
+}
+function validateActivityMetadata(min, sr) {
+  const errs = collectActivityMetadataErrors(min, sr);
+  if (errs.length) {
+    throw new Error(`activity metadata invalid:
+  - ${errs.join(`
+  - `)}`);
+  }
+}
+
+// src/services/activity-metadata/index.ts
+async function readJson(path2, what) {
+  const fs2 = getFileSystem();
+  const raw = await fs2.readFile(path2, "utf-8");
+  if (raw === null || raw === undefined) {
+    throw new Error(`${what} not found: ${path2}`);
+  }
+  try {
+    return JSON.parse(raw);
+  } catch (err) {
+    throw new Error(`${what} is not valid JSON (${path2}): ${err instanceof Error ? err.message : String(err)}`);
+  }
+}
+async function generateActivityMetadataFile(minFile, outFile) {
+  const out = outFile ?? (minFile.endsWith(".min.json") ? minFile.replace(/\.min\.json$/, ".json") : null);
+  if (!out) {
+    throw new Error(`cannot derive an output path: ${minFile} does not end in .min.json — pass --out`);
+  }
+  const min = await readJson(minFile, "minimal-metadata file");
+  if (!min.activity) {
+    throw new Error(`${minFile} has no "activity" block`);
+  }
+  const sr = generateActivityMetadata(min);
+  validateActivityMetadata(min, sr);
+  const fs2 = getFileSystem();
+  await fs2.writeFile(out, `${JSON.stringify(sr, null, 2)}
+`);
+  const primaryKey = sr.metadata?.primaryKey;
+  return {
+    Out: out,
+    Name: asText(sr.name),
+    Fields: Object.keys(sr.fields ?? {}).length,
+    ...Array.isArray(primaryKey) ? { PrimaryKey: primaryKey } : {}
+  };
+}
+async function stampTypeHeader(metadataFile, scriptFile) {
+  const sr = await readJson(metadataFile, "activity metadata");
+  const fs2 = getFileSystem();
+  const source = await fs2.readFile(scriptFile, "utf-8");
+  if (source === null || source === undefined) {
+    throw new Error(`action script not found: ${scriptFile}`);
+  }
+  const header = buildTypeHeader(sr);
+  await fs2.writeFile(scriptFile, injectTypeHeader(source, header));
+  return {
+    Script: scriptFile,
+    Types: (header.match(/^type /gm) ?? []).length
+  };
+}
+
 // src/store/cache.ts
 var fs2 = getFileSystem();
 var HOUR = 60 * 60 * 1000;
@@ -15050,7 +16112,7 @@ async function buildPath(parts, tenantName) {
 function sanitizeObjectNameForFile(objectName) {
   return objectName.replace(/[<>:"/\\|?*]/g, "_");
 }
-async function readJson(filePath, ttlMs, schema) {
+async function readJson2(filePath, ttlMs, schema) {
   if (filePath === null)
     return null;
   const [err, raw] = await catchError(fs2.readFile(filePath, "utf-8"));
@@ -15088,7 +16150,7 @@ function resolveCacheKey(id) {
   return id || "_static";
 }
 async function readConnectors(tenantName) {
-  return readJson(await buildPath(["connectors.json"], tenantName), TTL.connectors, CONNECTORS_CACHE_SCHEMA);
+  return readJson2(await buildPath(["connectors.json"], tenantName), TTL.connectors, CONNECTORS_CACHE_SCHEMA);
 }
 async function writeConnectors(connectors, tenantName) {
   const compact = connectors.map((c) => ({
@@ -15111,7 +16173,7 @@ function connectionsFile(folderKey, allFolders) {
   return folderKey ? `connections.folder.${folderKey}.json` : "connections.json";
 }
 async function readConnections(connectorKey, folderKey, tenantName, allFolders) {
-  return readJson(await buildPath([connectorKey, connectionsFile(folderKey, allFolders)], tenantName), TTL.connections);
+  return readJson2(await buildPath([connectorKey, connectionsFile(folderKey, allFolders)], tenantName), TTL.connections);
 }
 async function writeConnections(connectorKey, connections, folderKey, tenantName, allFolders, detailsComplete = false) {
   const compact = connections.map((c) => ({
@@ -15133,7 +16195,7 @@ async function writeConnections(connectorKey, connections, folderKey, tenantName
   await writeJson(await buildPath([connectorKey, connectionsFile(folderKey, allFolders)], tenantName), compact);
 }
 async function readActivities(connectorKey, tenantName) {
-  return readJson(await buildPath([connectorKey, "activities.json"], tenantName), TTL.activities);
+  return readJson2(await buildPath([connectorKey, "activities.json"], tenantName), TTL.activities);
 }
 async function writeActivities(connectorKey, activities, tenantName) {
   const compact = activities.map((a) => ({
@@ -15149,7 +16211,7 @@ async function writeActivities(connectorKey, activities, tenantName) {
   await writeJson(await buildPath([connectorKey, "activities.json"], tenantName), compact);
 }
 async function readResourcesList(connectorKey, connectionId, tenantName) {
-  return readJson(await buildPath([connectorKey, connectionId, "resources.json"], tenantName), TTL.resources);
+  return readJson2(await buildPath([connectorKey, connectionId, "resources.json"], tenantName), TTL.resources);
 }
 async function writeResourcesList(connectorKey, connectionId, resources, tenantName) {
   const compact = resources.map((r) => ({
@@ -15169,7 +16231,7 @@ function schemaFileName(objectName, activityVersion) {
   return `${sanitizeObjectNameForFile(objectName)}${versionSegment}.schema.json`;
 }
 async function readSchema(connectorKey, connectionId, objectName, tenantName, activityVersion) {
-  return readJson(await buildPath([
+  return readJson2(await buildPath([
     connectorKey,
     resolveCacheKey(connectionId),
     schemaFileName(objectName, activityVersion)
@@ -15183,13 +16245,13 @@ async function writeSchema(connectorKey, connectionId, objectName, schema, tenan
   ], tenantName), schema);
 }
 async function readTriggerObjects(connectorKey, connectionId, operation, tenantName) {
-  return readJson(await buildPath([connectorKey, connectionId, "triggers", operation, "objects.json"], tenantName), TTL.triggerObjects);
+  return readJson2(await buildPath([connectorKey, connectionId, "triggers", operation, "objects.json"], tenantName), TTL.triggerObjects);
 }
 async function writeTriggerObjects(connectorKey, connectionId, operation, objects, tenantName) {
   await writeJson(await buildPath([connectorKey, connectionId, "triggers", operation, "objects.json"], tenantName), objects);
 }
 async function readTypecachePackages(projectType, tenantName) {
-  return readJson(await buildPath(["typecache", projectType, "connectors.json"], tenantName), TTL.typecache);
+  return readJson2(await buildPath(["typecache", projectType, "connectors.json"], tenantName), TTL.typecache);
 }
 async function writeTypecachePackages(projectType, connectors, tenantName) {
   const compact = connectors.map((c) => ({
@@ -15200,7 +16262,7 @@ async function writeTypecachePackages(projectType, connectors, tenantName) {
   await writeJson(await buildPath(["typecache", projectType, "connectors.json"], tenantName), compact);
 }
 async function readTypecacheActivities(projectType, connectorKey, tenantName) {
-  return readJson(await buildPath(["typecache", projectType, connectorKey, "activities.json"], tenantName), TTL.typecache);
+  return readJson2(await buildPath(["typecache", projectType, connectorKey, "activities.json"], tenantName), TTL.typecache);
 }
 async function writeTypecacheActivities(projectType, connectorKey, activities, tenantName) {
   const compact = activities.map((a) => ({
@@ -15214,7 +16276,7 @@ async function writeTypecacheActivities(projectType, connectorKey, activities, t
   await writeJson(await buildPath(["typecache", projectType, connectorKey, "activities.json"], tenantName), compact);
 }
 async function readTriggerMetadata(connectorKey, connectionId, operation, objectName, tenantName) {
-  return readJson(await buildPath([
+  return readJson2(await buildPath([
     connectorKey,
     connectionId,
     "triggers",
@@ -15271,6 +16333,31 @@ var ACTIVITIES_LIST_EXAMPLES = [
     }
   }
 ];
+var METADATA_GENERATE_EXAMPLES = [
+  {
+    Description: "Generate activity metadata from a minimal-metadata file",
+    Command: "uip is activities metadata generate ./AddUsersToUsergroup.min.json",
+    Output: {
+      Code: "ActivityMetadataGenerated",
+      Data: {
+        Out: "./AddUsersToUsergroup.json",
+        Name: "AddUsersToUsergroup",
+        Fields: 12,
+        PrimaryKey: ["usergroup.id"]
+      }
+    }
+  }
+];
+var SCRIPT_UPDATE_EXAMPLES = [
+  {
+    Description: "Update an action script's type header in place from its activity metadata",
+    Command: "uip is activities script update ./AddUsersToUsergroup.js --metadata ./AddUsersToUsergroup.json",
+    Output: {
+      Code: "ScriptUpdated",
+      Data: { Script: "./AddUsersToUsergroup.js", Types: 4 }
+    }
+  }
+];
 var registerActivitiesCommand = (program2) => {
   const activities = program2.command("activities").description("Manage UiPath Integration Service activities");
   activities.command("list").description("List activities for a connector").argument("<connector-key>", "Connector key (e.g., uipath-zoho-desk)").addOption(createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>")).option("--refresh", "Force re-fetch from API, ignoring cache").option("--triggers", "List trigger activities only").examples(ACTIVITIES_LIST_EXAMPLES).trackedAction(processContext, async (connectorKey, options) => {
@@ -15316,6 +16403,44 @@ var registerActivitiesCommand = (program2) => {
       emptyInstructions: !data || data.length === 0 ? `No activities found for connector '${connectorKey}'. Check that the connector key is correct.` : isTriggerMode ? `No trigger activities found for connector '${connectorKey}'. This connector has no trigger activities.` : `No non-trigger activities found for connector '${connectorKey}'. All activities are triggers — use --triggers to list them.`
     });
   });
+  const metadata = activities.command("metadata").description("Generate activity metadata from a minimal-metadata file");
+  metadata.command("generate").description("Generate activity metadata from a minimal-metadata file").argument("<min-file>", "Path to the <name>.min.json file").option("--out <file>", "Output path (default: the input with .min.json → .json)").examples(METADATA_GENERATE_EXAMPLES).trackedAction(processContext, async (minFile, options) => {
+    const [error, result] = await catchError(generateActivityMetadataFile(minFile, options.out));
+    if (error) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        ErrorCode: "invalid_metadata",
+        Message: `Could not generate activity metadata: ${error.message}`,
+        Instructions: "Fix the minimal-metadata file and regenerate — never hand-edit the generated metadata."
+      });
+      processContext.exit(1);
+      return;
+    }
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: "ActivityMetadataGenerated",
+      Data: result
+    });
+  });
+  const script = activities.command("script").description("Manage activity action scripts");
+  script.command("update").description("Update an action script's type header in place from its activity metadata").argument("<script-file>", "Path to the action script (.js) to update").requiredOption("--metadata <file>", "Path to the activity metadata JSON the type header is derived from").examples(SCRIPT_UPDATE_EXAMPLES).trackedAction(processContext, async (scriptFile, options) => {
+    const [error, result] = await catchError(stampTypeHeader(options.metadata, scriptFile));
+    if (error) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        ErrorCode: "invalid_metadata",
+        Message: `Could not update the script's type header: ${error.message}`,
+        Instructions: "Check both paths exist and the metadata file is valid JSON."
+      });
+      processContext.exit(1);
+      return;
+    }
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: "ScriptUpdated",
+      Data: result
+    });
+  });
 };
 
 // src/helpers/connections.ts
@@ -15409,7 +16534,8 @@ var POLL_EXIT_CODES = {
   [PollOutcome.Interrupted]: 1,
   [PollOutcome.Aborted]: 1
 };
-function handleAuthPollFailure(outcome, error, noun, retryCommand) {
+function handleAuthPollFailure(outcome, error, noun, retryCommand, authUrl) {
+  const target = authUrl ? authUrl : "the authentication URL";
   const messages = {
     [PollOutcome.Timeout]: `${noun} timed out after 5 minutes`,
     [PollOutcome.Failed]: `${noun} polling failed: ${error?.message ?? "too many consecutive errors"}`,
@@ -15419,19 +16545,20 @@ function handleAuthPollFailure(outcome, error, noun, retryCommand) {
   OutputFormatter.error({
     Result: RESULTS.Failure,
     Message: messages[outcome] ?? `${noun} polling failed`,
-    Instructions: `Open the authentication URL while it is valid, then retry. For headless scripts, run '${retryCommand} --no-browser --no-wait' to return the pending authorization details without polling.`
+    Instructions: `Open ${target} while it is valid, then retry. For scripts, run '${retryCommand} --no-wait' to return the pending authorization details without polling.`
   });
   processContext.exit(POLL_EXIT_CODES[outcome] ?? 1);
 }
 function normalizeSessionStatus(session) {
   return (session.status ?? "pending").toLowerCase();
 }
+var PENDING_AUTHORIZATION_INSTRUCTIONS = "Open AuthUrl to authorize the connection, then run 'uip is connections list' or 'uip is connections ping <connection-id>' to verify the connection.";
 function writePendingAuthorization(connectorKey, connectionId, response) {
   const data = {
     Status: "AuthorizationPending",
     SessionId: response.sessionId,
     AuthUrl: response.authUrl,
-    Instructions: "Open AuthUrl to authorize the connection, then run 'uip is connections list' or 'uip is connections ping <connection-id>' to verify the connection."
+    Instructions: PENDING_AUTHORIZATION_INSTRUCTIONS
   };
   if (connectorKey)
     data.Connector = connectorKey;
@@ -15579,7 +16706,7 @@ var CONNECTIONS_LIST_EXAMPLES = [
 ];
 var CONNECTIONS_CREATE_EXAMPLES = [
   {
-    Description: "Create a new OAuth connection",
+    Description: "Create a new OAuth connection from an interactive terminal: the browser opens and the command waits for the consent",
     Command: "uip is connections create uipath-zoho-desk",
     Output: {
       Code: "ConnectionCreated",
@@ -15593,6 +16720,21 @@ var CONNECTIONS_CREATE_EXAMPLES = [
         FolderKey: "f0f0f0f0-0000-0000-0000-000000000001"
       }
     }
+  },
+  {
+    Description: "The same command with nobody at the terminal (an agent, a CI job, a piped run) or with --no-wait: no browser is opened and the authorization is handed back to finish elsewhere",
+    Command: "uip is connections create uipath-zoho-desk",
+    Output: {
+      Code: "ConnectionAuthorizationPending",
+      Data: {
+        Status: "AuthorizationPending",
+        SessionId: "b2c3d4e5-0000-0000-0000-000000000020",
+        AuthUrl: "https://cloud.uipath.com/connections_/authorize/b2c3d4e5-0000-0000-0000-000000000020",
+        Instructions: PENDING_AUTHORIZATION_INSTRUCTIONS,
+        Connector: "uipath-zoho-desk",
+        ExpiresAt: 1774000000
+      }
+    }
   }
 ];
 var CONNECTIONS_PING_EXAMPLES = [
@@ -15638,7 +16780,7 @@ var CONNECTIONS_DELETE_EXAMPLES = [
 ];
 var CONNECTIONS_EDIT_EXAMPLES = [
   {
-    Description: "Re-authenticate an existing connection",
+    Description: "Re-authenticate an existing connection from an interactive terminal: the browser opens and the command waits for the consent",
     Command: "uip is connections edit a1b2c3d4-0000-0000-0000-000000000001",
     Output: {
       Code: "ConnectionEdited",
@@ -15647,6 +16789,21 @@ var CONNECTIONS_EDIT_EXAMPLES = [
         State: "Enabled"
       }
     }
+  },
+  {
+    Description: "The same command with nobody at the terminal (an agent, a CI job, a piped run) or with --no-wait: no browser is opened and the re-authorization is handed back to finish elsewhere",
+    Command: "uip is connections edit a1b2c3d4-0000-0000-0000-000000000001",
+    Output: {
+      Code: "ConnectionAuthorizationPending",
+      Data: {
+        Status: "AuthorizationPending",
+        SessionId: "b2c3d4e5-0000-0000-0000-000000000021",
+        AuthUrl: "https://cloud.uipath.com/connections_/authorize/b2c3d4e5-0000-0000-0000-000000000021",
+        Instructions: PENDING_AUTHORIZATION_INSTRUCTIONS,
+        ConnectionId: "a1b2c3d4-0000-0000-0000-000000000001",
+        ExpiresAt: 1774000000
+      }
+    }
   }
 ];
 var CONNECTIONS_EXPORT_EXAMPLES = [
@@ -15898,7 +17055,7 @@ var registerConnectionsCommand = (program2) => {
       Data: result
     });
   });
-  connections.command("create").description("Create a new connection (OAuth flow)").argument("<connector-key>", "Connector key").addOption(createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>")).option("--no-browser", "Don't auto-open browser").option("--no-wait", "Return pending authorization details without polling").examples(CONNECTIONS_CREATE_EXAMPLES).trackedAction(processContext, async (connectorKey, options) => {
+  connections.command("create").description("Create a new connection (OAuth flow)").argument("<connector-key>", "Connector key").addOption(createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>")).option("--no-browser", "Don't auto-open browser").option("--no-wait", "Return pending authorization details without opening a browser or polling").examples(CONNECTIONS_CREATE_EXAMPLES).trackedAction(processContext, async (connectorKey, options) => {
     logger.info(`Creating connection for: ${connectorKey}`);
     const [configError, config] = await catchError(createConnectionsConfig({ tenant: options.tenant }));
     if (configError) {
@@ -15930,18 +17087,16 @@ var registerConnectionsCommand = (program2) => {
     }
     logger.info(`Session: ${createResponse.sessionId}`);
     logger.info(`Auth URL: ${createResponse.authUrl}`);
-    if (options.browser !== false) {
-      const [openError] = await catchError(openBrowser(createResponse.authUrl));
-      if (openError) {
-        logger.info(`Open manually: ${createResponse.authUrl}`);
-      }
-    } else {
-      logger.info(`Open in browser: ${createResponse.authUrl}`);
-    }
-    if (options.wait === false) {
+    if (options.wait === false || !canFinishBrowserFlow()) {
       writePendingAuthorization(connectorKey, undefined, createResponse);
       return;
     }
+    const opened = options.browser !== false && await tryOpenAuthUrl(createResponse.authUrl);
+    if (!opened && createResponse.authUrl) {
+      OutputFormatter.log({
+        Message: `Open this URL to authorize: ${createResponse.authUrl}`
+      });
+    }
     const pollResult = await pollUntil({
       fn: () => sessionsApi.apiV1SessionsSessionIdGet({
         sessionId: createResponse.sessionId
@@ -15996,7 +17151,7 @@ var registerConnectionsCommand = (program2) => {
       processContext.exit(1);
       return;
     }
-    handleAuthPollFailure(pollResult.outcome, pollResult.error, "Authentication", `uip is connections create ${connectorKey}`);
+    handleAuthPollFailure(pollResult.outcome, pollResult.error, "Authentication", `uip is connections create ${connectorKey}`, createResponse.authUrl);
   });
   connections.command("ping").description("Check if a connection is active").argument("<connection-id>", "Connection ID").addOption(createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>")).option("--force-refresh", "Force a live connection status refresh").examples(CONNECTIONS_PING_EXAMPLES).trackedAction(processContext, async (connectionId, options) => {
     logger.info(`Pinging: ${connectionId}`);
@@ -16235,7 +17390,7 @@ var registerConnectionsCommand = (program2) => {
       }
     });
   });
-  connections.command("edit").description("Re-authenticate a connection (OAuth flow)").argument("<connection-id>", "Connection ID").addOption(createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>")).option("--no-browser", "Don't auto-open browser").option("--no-wait", "Return pending authorization details without polling").examples(CONNECTIONS_EDIT_EXAMPLES).trackedAction(processContext, async (connectionId, options) => {
+  connections.command("edit").description("Re-authenticate a connection (OAuth flow)").argument("<connection-id>", "Connection ID").addOption(createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>")).option("--no-browser", "Don't auto-open browser").option("--no-wait", "Return pending authorization details without opening a browser or polling").examples(CONNECTIONS_EDIT_EXAMPLES).trackedAction(processContext, async (connectionId, options) => {
     logger.info(`Re-authenticating: ${connectionId}`);
     const [configError, config] = await catchError(createConnectionsConfig({ tenant: options.tenant }));
     if (configError) {
@@ -16263,18 +17418,16 @@ var registerConnectionsCommand = (program2) => {
       return;
     }
     logger.info(`Auth URL: ${editResponse.authUrl}`);
-    if (options.browser !== false) {
-      const [openError] = await catchError(openBrowser(editResponse.authUrl));
-      if (openError) {
-        logger.info(`Open manually: ${editResponse.authUrl}`);
-      }
-    } else {
-      logger.info(`Open in browser: ${editResponse.authUrl}`);
-    }
-    if (options.wait === false) {
+    if (options.wait === false || !canFinishBrowserFlow()) {
       writePendingAuthorization(undefined, connectionId, editResponse);
       return;
     }
+    const opened = options.browser !== false && await tryOpenAuthUrl(editResponse.authUrl);
+    if (!opened && editResponse.authUrl) {
+      OutputFormatter.log({
+        Message: `Open this URL to authorize: ${editResponse.authUrl}`
+      });
+    }
     const pollResult = await pollUntil({
       fn: () => sessionsApi.apiV1SessionsSessionIdGet({
         sessionId: editResponse.sessionId
@@ -16309,7 +17462,7 @@ var registerConnectionsCommand = (program2) => {
       processContext.exit(1);
       return;
     }
-    handleAuthPollFailure(pollResult.outcome, pollResult.error, "Re-authentication", `uip is connections edit ${connectionId}`);
+    handleAuthPollFailure(pollResult.outcome, pollResult.error, "Re-authentication", `uip is connections edit ${connectionId}`, editResponse.authUrl);
   });
   connections.command("base-url").description("Get the API base URL for a connection").argument("<connection-id>", "Connection ID").addOption(createHiddenDeprecatedTenantOption("-t, --tenant <tenant-name>")).examples(CONNECTIONS_BASE_URL_EXAMPLES).trackedAction(processContext, async (connectionId, options) => {
     logger.info(`Fetching base URL for: ${connectionId}`);
@@ -16334,8 +17487,19 @@ var registerConnectionsCommand = (program2) => {
     });
   });
 };
-async function openBrowser(url) {
-  await getFileSystem().utils.open(url);
+function canFinishBrowserFlow() {
+  const mode = getInteractivityMode();
+  if (mode !== "auto") {
+    return mode === "always";
+  }
+  return getOutputSink().capabilities.isInteractive;
+}
+async function tryOpenAuthUrl(url) {
+  if (!url) {
+    return false;
+  }
+  const [openError] = await catchError(getFileSystem().utils.open(url));
+  return !openError;
 }
 
 // src/helpers/connectors.ts
@@ -18335,7 +19499,7 @@ function isRec(value) {
 function pascalCase2(s) {
   return s.split(/[_\-/\s]+/).filter(Boolean).map((p) => p.charAt(0).toUpperCase() + p.slice(1)).join("");
 }
-function humanize(s) {
+function humanize2(s) {
   return s.split(/[_\-/\s]+/).filter(Boolean).map((p) => p.charAt(0).toUpperCase() + p.slice(1)).join(" ");
 }
 function singularizeWord(word) {
@@ -18366,7 +19530,7 @@ function applyDefaultCuration(sr, resourceName, options = {}) {
   if (verbs.length === 0)
     return;
   const multiVerb = verbs.length > 1;
-  const baseDisplay = options.displayName ?? (typeof sr.displayName === "string" && sr.displayName ? sr.displayName : humanize(resourceName));
+  const baseDisplay = options.displayName ?? (typeof sr.displayName === "string" && sr.displayName ? sr.displayName : humanize2(resourceName));
   for (const verb of verbs) {
     const cfg = methodMap[verb];
     if (!isRec(cfg) || isRec(cfg.curated))
@@ -18482,11 +19646,11 @@ function buildSrParamFromElement(elemParam) {
     }
   }
   if ("name" in srParam && !("displayName" in srParam)) {
-    srParam.displayName = humanize2(String(srParam.name));
+    srParam.displayName = humanize3(String(srParam.name));
   }
   return srParam;
 }
-function humanize2(name) {
+function humanize3(name) {
   if (!name) {
     return name;
   }
@@ -18553,7 +19717,7 @@ function syncMethodParams(srMethodParams, elemResourceParams, options = {}) {
         }
       }
       if (!("displayName" in merged) && "name" in merged) {
-        merged.displayName = humanize2(String(merged.name));
+        merged.displayName = humanize3(String(merged.name));
       }
       out.push(merged);
       usedIds.add(identity);
@@ -18782,19 +19946,19 @@ async function resolveSrNameByInternalPath(connectorRoot, internalPath) {
     return null;
   return matches.find((n) => normalizeInternalPath(`/${n}`) === target) ?? matches[0];
 }
-function getSrField(sr, fieldName) {
-  return sr.fields?.[fieldName] ?? null;
+function getSrField(sr, fieldName2) {
+  return sr.fields?.[fieldName2] ?? null;
 }
-function upsertSrField(sr, fieldName, field, overwrite = false) {
+function upsertSrField(sr, fieldName2, field, overwrite = false) {
   if (!sr.fields) {
     sr.fields = {};
   }
-  const existing = sr.fields[fieldName];
+  const existing = sr.fields[fieldName2];
   if (existing === undefined || overwrite) {
-    sr.fields[fieldName] = field;
+    sr.fields[fieldName2] = field;
     return sr;
   }
-  sr.fields[fieldName] = mergeField(existing, field);
+  sr.fields[fieldName2] = mergeField(existing, field);
   return sr;
 }
 function mergeField(existing, incoming) {
@@ -18814,12 +19978,12 @@ function mergeField(existing, incoming) {
 function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function removeSrField(sr, fieldName) {
+function removeSrField(sr, fieldName2) {
   const fields = sr.fields ?? {};
-  if (!(fieldName in fields)) {
-    throw new Error(`Field '${fieldName}' not found in standard resource.`);
+  if (!(fieldName2 in fields)) {
+    throw new Error(`Field '${fieldName2}' not found in standard resource.`);
   }
-  delete fields[fieldName];
+  delete fields[fieldName2];
   return sr;
 }
 function getSrMetadataKey(sr, key) {
@@ -19843,13 +21007,13 @@ async function listFields(connectorRoot, resource) {
   const fields = Object.values(sr.sr.fields ?? {});
   return { ok: true, data: { resource, fields } };
 }
-async function getField(connectorRoot, resource, fieldName) {
+async function getField(connectorRoot, resource, fieldName2) {
   const sr = await loadSr(connectorRoot, resource);
   if (!sr.ok)
     return sr;
-  const field = getSrField(sr.sr, fieldName);
+  const field = getSrField(sr.sr, fieldName2);
   if (field === null) {
-    return fieldNotFound(resource, fieldName);
+    return fieldNotFound(resource, fieldName2);
   }
   return { ok: true, data: { resource, field } };
 }
@@ -19892,17 +21056,17 @@ async function upsertField(connectorRoot, resource, field, overwrite = false) {
     }
   };
 }
-async function removeField(connectorRoot, resource, fieldName) {
+async function removeField(connectorRoot, resource, fieldName2) {
   const loaded = await loadSr(connectorRoot, resource);
   if (!loaded.ok)
     return loaded;
   const sr = loaded.sr;
-  if (getSrField(sr, fieldName) === null) {
-    return fieldNotFound(resource, fieldName);
+  if (getSrField(sr, fieldName2) === null) {
+    return fieldNotFound(resource, fieldName2);
   }
-  removeSrField(sr, fieldName);
+  removeSrField(sr, fieldName2);
   await writeStandardResource(loaded.root, resource, sr);
-  return { ok: true, data: { resource, fieldName } };
+  return { ok: true, data: { resource, fieldName: fieldName2 } };
 }
 async function loadSr(connectorRoot, resource) {
   const found = await findElementDir(connectorRoot);
@@ -19923,12 +21087,12 @@ async function loadSr(connectorRoot, resource) {
     };
   }
 }
-function fieldNotFound(resource, fieldName) {
+function fieldNotFound(resource, fieldName2) {
   return {
     ok: false,
     error: {
       code: "fieldNotFound",
-      message: `Field '${fieldName}' was not found in resource '${resource}'.`,
+      message: `Field '${fieldName2}' was not found in resource '${resource}'.`,
       fixHint: "Use listFields to see the available field names."
     }
   };
@@ -27517,21 +28681,21 @@ async function patchStandardResources(cp, root, value, op) {
   }
   const srData = await readStandardResource(root, srName);
   if (cp.section === Section.FIELDS && cp.fieldName !== null) {
-    const fieldName = cp.fieldName;
+    const fieldName2 = cp.fieldName;
     if (op === "remove") {
-      removeSrField(srData, fieldName);
+      removeSrField(srData, fieldName2);
       await writeStandardResource(root, srName, srData);
-      return ok(`Removed field '${fieldName}' from ${srName}.`);
+      return ok(`Removed field '${fieldName2}' from ${srName}.`);
     }
-    const validationErr = validateFieldValue(value, fieldName, warnings);
+    const validationErr = validateFieldValue(value, fieldName2, warnings);
     if (validationErr !== null) {
       return validationErr;
     }
     const obj = value;
-    obj.name = fieldName;
-    upsertSrField(srData, fieldName, obj, true);
+    obj.name = fieldName2;
+    upsertSrField(srData, fieldName2, obj, true);
     await writeStandardResource(root, srName, srData);
-    return ok(`Upserted field '${fieldName}' in ${srName}.`, warnings);
+    return ok(`Upserted field '${fieldName2}' in ${srName}.`, warnings);
   }
   if (cp.section === Section.METADATA) {
     return patchSrMetadata(cp, root, srName, srData, value, op, warnings);
@@ -31125,4 +32289,4 @@ var registerCommands = async (program2) => {
 
 export { Command, metadata, registerCommands };
 
-//# debugId=B8E3196CFAFB331A64756E2164756E21
+//# debugId=0E02A525AF08DC4F64756E2164756E21