@uipath/case-tool 1.201.0 → 1.202.0-preview.136

package/dist/packager-tool-j9rfdrdm.js

@@ -0,0 +1,1125 @@
+import {
+  DEBUG_MODE_MAP,
+  SIMULATION_MODE_MAP
+} from "./packager-tool-9scn4b15.js";
+import {
+  resolveJsonInput
+} from "./packager-tool-3ze5vt52.js";
+import {
+  getAuthContext
+} from "./packager-tool-dqs5qy9s.js";
+import {
+  DEFAULT_PAGE_SIZE,
+  EXIT_CODES,
+  InvalidArgumentError,
+  OutputFormatter,
+  Pagination,
+  RESULTS,
+  catchError,
+  extractErrorMessage,
+  isGuid,
+  logger,
+  parseBoundedInt,
+  parseLimit,
+  parseOffset,
+  processContext
+} from "./packager-tool-5ax2ywcg.js";
+
+// ../maestro-sdk/src/query-string.ts
+function buildQueryString(params) {
+  const entries = [];
+  for (const [key, value] of Object.entries(params)) {
+    if (value === undefined)
+      continue;
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        entries.push([key, item]);
+      }
+      continue;
+    }
+    entries.push([key, String(value)]);
+  }
+  if (entries.length === 0)
+    return "";
+  return `?${new URLSearchParams(entries).toString()}`;
+}
+
+// ../maestro-sdk/src/shared-commands/debug-instances.ts
+var VALID_DEBUG_MODES = Object.keys(DEBUG_MODE_MAP);
+var VALID_SIMULATION_MODES = Object.keys(SIMULATION_MODE_MAP);
+
+// ../maestro-sdk/src/client.ts
+function parseBackendErrorBody(body) {
+  if (!body)
+    return {};
+  const [parseErr, parsed] = catchError(() => JSON.parse(body));
+  if (parseErr || !parsed || typeof parsed !== "object")
+    return {};
+  const result = {};
+  if (typeof parsed.message === "string")
+    result.message = parsed.message;
+  if (typeof parsed.errorCode === "number" || typeof parsed.errorCode === "string") {
+    result.errorCode = String(parsed.errorCode);
+  }
+  if (typeof parsed.traceId === "string")
+    result.traceId = parsed.traceId;
+  if (typeof parsed.requestId === "string") {
+    result.requestId = parsed.requestId;
+  }
+  return result;
+}
+
+class PimsApiError extends Error {
+  method;
+  endpoint;
+  url;
+  httpStatus;
+  statusText;
+  body;
+  parsedErrorMessage;
+  parsedErrorCode;
+  parsedTraceId;
+  parsedRequestId;
+  constructor(details) {
+    const parsed = parseBackendErrorBody(details.body);
+    const messageSuffix = parsed.message ? ` - ${parsed.message}` : "";
+    super(`PIMS API request failed: ${details.httpStatus} ${details.statusText} on ${details.method} ${details.endpoint}${messageSuffix}`);
+    this.name = "PimsApiError";
+    this.method = details.method;
+    this.endpoint = details.endpoint;
+    this.url = details.url;
+    this.httpStatus = details.httpStatus;
+    this.statusText = details.statusText;
+    this.body = details.body;
+    this.parsedErrorMessage = parsed.message;
+    this.parsedErrorCode = parsed.errorCode;
+    this.parsedTraceId = parsed.traceId;
+    this.parsedRequestId = parsed.requestId;
+  }
+}
+function buildPimsUrl(config, path) {
+  return `${config.baseUrl}/${config.organizationId}/${config.tenantId}/pims_/api/v1${path}`;
+}
+function buildHeaders(config, options) {
+  const headers = {
+    Authorization: `Bearer ${config.authToken}`,
+    "Content-Type": "application/json",
+    Accept: "application/json"
+  };
+  if (options?.folderKey) {
+    headers["x-uipath-folderkey"] = options.folderKey;
+  }
+  return headers;
+}
+async function pimsGet(config, path, options) {
+  const url = buildPimsUrl(config, path);
+  const headers = buildHeaders(config, options);
+  const response = await fetch(url, {
+    method: "GET",
+    headers
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new PimsApiError({
+      method: "GET",
+      endpoint: path,
+      url,
+      httpStatus: response.status,
+      statusText: response.statusText,
+      body: errorText
+    });
+  }
+  const contentType = response.headers.get("content-type") || "";
+  if (contentType.includes("application/xml") || contentType.includes("text/xml")) {
+    return await response.text();
+  }
+  const text = await response.text();
+  if (!text)
+    return {};
+  const [parseErr, parsed] = catchError(() => JSON.parse(text));
+  if (parseErr)
+    throw new Error(`Failed to parse API response body: ${parseErr.message}`);
+  return parsed;
+}
+async function pimsRequest(config, method, path, body, options) {
+  const url = buildPimsUrl(config, path);
+  const headers = buildHeaders(config, options);
+  const response = await fetch(url, {
+    method,
+    headers,
+    body: body ? JSON.stringify(body) : undefined
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new PimsApiError({
+      method,
+      endpoint: path,
+      url,
+      httpStatus: response.status,
+      statusText: response.statusText,
+      body: errorText
+    });
+  }
+  const text = await response.text();
+  if (!text)
+    return {};
+  const [parseErr, parsed] = catchError(() => JSON.parse(text));
+  if (parseErr) {
+    throw new Error(`Failed to parse API response body: ${parseErr.message}`);
+  }
+  return parsed;
+}
+async function pimsPost(config, path, body, options) {
+  return pimsRequest(config, "POST", path, body, options);
+}
+async function pimsPut(config, path, body, options) {
+  return pimsRequest(config, "PUT", path, body, options);
+}
+async function pimsPatch(config, path, body, options) {
+  return pimsRequest(config, "PATCH", path, body, options);
+}
+
+// ../maestro-sdk/src/client-factory.ts
+async function createPimsConfig() {
+  const ctx = await getAuthContext({
+    ensureTokenValidityMinutes: 10,
+    requireOrganizationId: true,
+    requireTenantId: true
+  });
+  return {
+    baseUrl: ctx.baseUrl,
+    organizationId: ctx.organizationId,
+    tenantId: ctx.tenantId,
+    authToken: ctx.accessToken
+  };
+}
+
+// ../maestro-sdk/src/with-pims-call.ts
+var NETWORK_ERROR_CODES = new Set([
+  "ECONNREFUSED",
+  "ECONNRESET",
+  "ENOTFOUND",
+  "EAI_AGAIN",
+  "ETIMEDOUT",
+  "EPIPE",
+  "EHOSTUNREACH",
+  "ENETUNREACH",
+  "EAI_FAIL"
+]);
+function capitalise(value) {
+  if (value.length === 0) {
+    return value;
+  }
+  return value.charAt(0).toUpperCase() + value.slice(1);
+}
+function isNetworkError(error) {
+  if (error === null || typeof error !== "object") {
+    return false;
+  }
+  const err = error;
+  const code = typeof err.code === "string" ? err.code : undefined;
+  if (code && NETWORK_ERROR_CODES.has(code)) {
+    return true;
+  }
+  const cause = err.cause;
+  if (cause && typeof cause === "object") {
+    const causeCode = typeof cause.code === "string" ? cause.code : undefined;
+    if (causeCode && NETWORK_ERROR_CODES.has(causeCode)) {
+      return true;
+    }
+  }
+  return false;
+}
+function pimsFailureContext(error) {
+  return {
+    httpStatus: error.httpStatus,
+    endpoint: error.endpoint,
+    method: error.method,
+    ...error.parsedErrorCode ? { errorCode: error.parsedErrorCode } : {},
+    ...error.parsedRequestId ? { requestId: error.parsedRequestId } : {},
+    ...error.parsedTraceId ? { traceId: error.parsedTraceId } : {}
+  };
+}
+function pimsFailureInstructions(error) {
+  const lines = [
+    `Status: ${error.httpStatus} ${error.statusText}`,
+    `Resource: ${error.method} ${error.endpoint}`
+  ];
+  if (error.parsedErrorMessage) {
+    lines.push(`Message: ${error.parsedErrorMessage}`);
+  } else if (error.body.trim()) {
+    lines.push(`Body: ${compactPimsErrorBody(error.body)}`);
+  }
+  if (error.parsedErrorCode) {
+    lines.push(`Error code: ${error.parsedErrorCode}`);
+  }
+  if (error.parsedTraceId) {
+    lines.push(`Trace ID: ${error.parsedTraceId}`);
+  } else if (error.parsedRequestId) {
+    lines.push(`Request ID: ${error.parsedRequestId}`);
+  }
+  lines.push("Remediation: verify the folder scope and identifiers, then retry. If the error persists, contact UiPath support with the status, resource, and trace/request ID.");
+  return lines.join(`
+`);
+}
+function compactPimsErrorBody(body) {
+  const text = body.split(/\s+/).filter(Boolean).join(" ");
+  return text.length <= 700 ? text : `${text.slice(0, 699)}...`;
+}
+function resolvePimsEnvelope(error, errorMessage, hint) {
+  const status = error.httpStatus;
+  if (status === 404) {
+    const message = hint?.resource && hint.id ? `${capitalise(hint.resource)} not found: ${hint.id}` : hint?.resource ? `${capitalise(hint.resource)} not found` : errorMessage;
+    return { result: RESULTS.Failure, code: "NotFound", message };
+  }
+  if (status === 401) {
+    return {
+      result: RESULTS.AuthenticationError,
+      code: "Unauthorized",
+      message: errorMessage
+    };
+  }
+  if (status === 403) {
+    return {
+      result: RESULTS.AuthenticationError,
+      code: "Forbidden",
+      message: errorMessage
+    };
+  }
+  if (status >= 500 && status < 600) {
+    return {
+      result: RESULTS.Failure,
+      code: `ServerError_${status}`,
+      message: errorMessage
+    };
+  }
+  return {
+    result: RESULTS.Failure,
+    code: `Http_${status}`,
+    message: errorMessage
+  };
+}
+async function withPimsCall(fn, errorMessage, hint) {
+  const [configError, config] = await catchError(createPimsConfig());
+  if (configError) {
+    logger.warn(`${errorMessage}: ${configError.message}`);
+    OutputFormatter.error({
+      Result: RESULTS.Failure,
+      Code: "ConfigError",
+      Message: errorMessage,
+      Instructions: configError.message
+    });
+    processContext.exit(1);
+    return;
+  }
+  const [error, result] = await catchError(fn(config));
+  if (error) {
+    if (isNetworkError(error)) {
+      const msg2 = await extractErrorMessage(error);
+      logger.warn(`${errorMessage}: ${msg2}`);
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Code: "NetworkError",
+        Message: errorMessage,
+        Instructions: msg2
+      });
+      processContext.exit(1);
+      return;
+    }
+    if (error instanceof PimsApiError) {
+      const envelope = resolvePimsEnvelope(error, errorMessage, hint);
+      logger.warn(`${envelope.message}: ${error.message}`);
+      OutputFormatter.error({
+        Result: envelope.result,
+        Code: envelope.code,
+        Message: envelope.message,
+        Instructions: pimsFailureInstructions(error),
+        Context: pimsFailureContext(error)
+      });
+      processContext.exit(1);
+      return;
+    }
+    const msg = await extractErrorMessage(error);
+    logger.warn(`${errorMessage}: ${msg}`);
+    OutputFormatter.error({
+      Result: RESULTS.Failure,
+      Code: "UnknownError",
+      Message: errorMessage,
+      Instructions: msg
+    });
+    processContext.exit(1);
+    return;
+  }
+  return result;
+}
+
+// ../maestro-sdk/src/shared-commands/incidents.ts
+var registerSharedIncidentCommands = (program, config) => {
+  const { toolLabel } = config;
+  const incident = program.command("incident").description(`Manage ${toolLabel} incidents`);
+  incident.command("summary").description(`Get ${toolLabel} incident summaries across processes`).option("--folder-key <key>", "Folder key").option("-l, --limit <number>", "Number of items to return (1-10000)", parseLimit).option("--offset <number>", "Number of items to skip (0-1000000)", parseOffset, 0).option("--process-key <process-key>", "Filter by process key").option("--status <status>", "Filter by incident status").option("--severity <severity>", "Filter by incident severity").trackedAction(processContext, async (options) => {
+    const query = buildQueryString({
+      processKey: options.processKey,
+      incidentStatus: options.status,
+      incidentSeverity: options.severity,
+      $top: options.limit,
+      $skip: options.offset !== 0 ? options.offset : undefined
+    });
+    const reqOptions = { folderKey: options.folderKey };
+    const result = await withPimsCall((config2) => pimsGet(config2, `/incidents/summary${query}`, reqOptions), "Error listing incidents");
+    if (!result)
+      return;
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: "IncidentSummary",
+      Data: result
+    });
+  });
+  incident.command("get").description(`Get a single ${toolLabel} incident by ID`).argument("<incident-id>", "Incident ID").requiredOption("-f, --folder-key <key>", "Folder key").trackedAction(processContext, async (incidentId, options) => {
+    const reqOptions = { folderKey: options.folderKey };
+    const result = await withPimsCall((config2) => pimsGet(config2, `/incidents/${encodeURIComponent(incidentId)}`, reqOptions), "Error getting incident", { resource: "incident", id: incidentId });
+    if (!result)
+      return;
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: "IncidentGet",
+      Data: result
+    });
+  });
+};
+
+// ../maestro-sdk/src/instance-status.ts
+var INSTANCE_STATUSES = [
+  "Canceling",
+  "Cancelled",
+  "Completed",
+  "Faulted",
+  "Paused",
+  "Pausing",
+  "Pending",
+  "Resuming",
+  "Retrying",
+  "Running",
+  "Upgrading"
+];
+var STATUS_ALIASES = new Map([
+  ["successful", "Completed"],
+  ["success", "Completed"],
+  ["canceled", "Cancelled"]
+]);
+var CANONICAL_BY_LOWER = new Map(INSTANCE_STATUSES.map((status) => [status.toLowerCase(), status]));
+function resolveInstanceStatus(raw) {
+  const normalized = raw.trim().toLowerCase();
+  return CANONICAL_BY_LOWER.get(normalized) ?? STATUS_ALIASES.get(normalized);
+}
+var INSTANCE_STATUS_LIST = INSTANCE_STATUSES.join(", ");
+function resolveInstanceStatuses(raw) {
+  const statuses = [];
+  const invalid = [];
+  for (const value of raw) {
+    const resolved = resolveInstanceStatus(value);
+    if (resolved === undefined) {
+      invalid.push(value);
+      continue;
+    }
+    if (!statuses.includes(resolved)) {
+      statuses.push(resolved);
+    }
+  }
+  return { statuses, invalid };
+}
+
+// ../maestro-sdk/src/shared-commands/instances.ts
+var collectStatus = (raw, prev) => [...prev, raw];
+var MAX_INSTANCE_PAGE_SIZE = 500;
+var parseInstanceLimit = (raw) => parseBoundedInt(raw, "--limit", { min: 1, max: MAX_INSTANCE_PAGE_SIZE });
+function extractProcessInstances(result) {
+  if (Array.isArray(result)) {
+    return result;
+  }
+  return result.instances ?? result.value ?? result.items ?? [];
+}
+function extractInstanceCursor(result) {
+  if (Array.isArray(result)) {
+    return { hasMore: false };
+  }
+  const nextPage = result.nextPage ?? undefined;
+  return {
+    nextPage,
+    hasMore: result.hasMoreResults ?? nextPage !== undefined
+  };
+}
+var failListFilter = (message, instructions) => {
+  OutputFormatter.error({
+    Result: RESULTS.ValidationError,
+    Message: message,
+    Instructions: instructions
+  });
+  processContext.exit(EXIT_CODES.ValidationError);
+  return null;
+};
+function resolveListFilters(options) {
+  if (options.offset !== undefined && Number(options.offset) !== 0) {
+    return failListFilter("--offset is not supported when listing process instances", "The instances API pages by cursor, not by offset. Drop --offset, " + "then pass the Pagination.NextPage value from the previous " + "response to --next-page.");
+  }
+  if (options.processKey !== undefined && !isGuid(options.processKey)) {
+    return failListFilter(`--process-key expects a process key (GUID), got '${options.processKey}'`, "Pass the instance's processKey. For the dotted package " + "identifier that `uip or processes list` prints as ProcessKey, " + "use --package-id instead.");
+  }
+  const { statuses, invalid } = resolveInstanceStatuses(options.status ?? []);
+  if (invalid.length > 0) {
+    return failListFilter(`Invalid --status value${invalid.length > 1 ? "s" : ""}: ${invalid.join(", ")}`, `Valid values: ${INSTANCE_STATUS_LIST}.`);
+  }
+  return { statuses: statuses.length > 0 ? statuses : undefined };
+}
+var registerSharedInstanceCommands = (program, config) => {
+  const {
+    toolLabel,
+    assetType,
+    processType,
+    includeElementExecutions = true,
+    folderKeyRequired = true,
+    listFolderKeyRequired = folderKeyRequired
+  } = config;
+  const withFolderKey = (cmd, required = folderKeyRequired) => required ? cmd.requiredOption("-f, --folder-key <key>", "Folder key (GUID)") : cmd.option("-f, --folder-key <key>", "Folder key (GUID)");
+  const instances = program.command("instance").description(`Manage ${toolLabel} process instances`);
+  const listCmd = instances.command("list").description(`List ${toolLabel} process instances. Filters are applied by the ` + "server: --status narrows by run status, --process-key by " + "process key (GUID), --package-id by package identifier, and " + "--from-date/--to-date by start time. Results page by cursor " + "— read Pagination.NextPage and pass it back via --next-page.");
+  withFolderKey(listCmd, listFolderKeyRequired).option("-l, --limit <number>", `Number of items to return (1-${MAX_INSTANCE_PAGE_SIZE})`, parseInstanceLimit, DEFAULT_PAGE_SIZE).option("--offset <number>", "Not supported by the instances API — use --next-page instead").option("--next-page <cursor>", "Cursor from a previous response's Pagination.NextPage").option("--process-key <process-key>", "Filter by process key (GUID). For the dotted package " + "identifier use --package-id.").option("--package-id <id>", "Filter by package ID").option("--error-code <code>", "Filter by error code").option("--status <status>", "Filter by instance status (repeatable; OR-semantics). " + `Values: ${INSTANCE_STATUS_LIST}.`, collectStatus, []).option("--from-date <iso-8601>", "Only include instances started at or after this ISO-8601 " + "timestamp (e.g. 2026-01-01T00:00:00Z).").option("--to-date <iso-8601>", "Only include instances started at or before this ISO-8601 " + "timestamp (e.g. 2026-02-01T00:00:00Z).").trackedAction(processContext, async (options) => {
+    const filters = resolveListFilters(options);
+    if (!filters)
+      return;
+    const query = buildQueryString({
+      processKey: options.processKey,
+      packageId: options.packageId,
+      errorCode: options.errorCode,
+      statuses: filters.statuses?.join(","),
+      startedTimeUtcStart: options.fromDate,
+      startedTimeUtcEnd: options.toDate,
+      processType,
+      pageSize: options.limit,
+      nextPage: options.nextPage
+    });
+    const reqOptions = { folderKey: options.folderKey };
+    const result = await withPimsCall((config2) => pimsGet(config2, `/instances${query}`, reqOptions), "Error listing instances");
+    if (!result)
+      return;
+    const instanceList = extractProcessInstances(result);
+    const cursor = extractInstanceCursor(result);
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: "InstanceList",
+      Data: instanceList,
+      Pagination: new Pagination({
+        returned: instanceList.length,
+        limit: options.limit,
+        hasMore: cursor.hasMore,
+        nextPage: cursor.nextPage
+      })
+    });
+  });
+  const getCmd = instances.command("get").description(`Get a ${toolLabel} process instance by ID`).argument("<instance-id>", "Process instance ID");
+  withFolderKey(getCmd).trackedAction(processContext, async (instanceId, options) => {
+    const result = await withPimsCall((config2) => pimsGet(config2, `/instances/${instanceId}`, { folderKey: options.folderKey }), "Error getting instance", { resource: "instance", id: instanceId });
+    if (!result)
+      return;
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: "InstanceGet",
+      Data: result
+    });
+  });
+  const pauseCmd = instances.command("pause").description(`Pause a running ${toolLabel} process instance`).argument("<instance-id>", "Process instance ID");
+  withFolderKey(pauseCmd).option("--comment <text>", "Optional comment for the operation").trackedAction(processContext, async (instanceId, options) => {
+    const body = { comment: options.comment || "" };
+    const reqOptions = { folderKey: options.folderKey };
+    const result = await withPimsCall((config2) => pimsPost(config2, `/instances/${instanceId}/pause`, body, reqOptions), "Error pausing instance");
+    if (!result)
+      return;
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: "InstancePaused",
+      Data: result
+    });
+  });
+  const resumeCmd = instances.command("resume").description(`Resume a paused ${toolLabel} process instance`).argument("<instance-id>", "Process instance ID");
+  withFolderKey(resumeCmd).option("--comment <text>", "Optional comment for the operation").trackedAction(processContext, async (instanceId, options) => {
+    const body = { comment: options.comment || "" };
+    const reqOptions = { folderKey: options.folderKey };
+    const result = await withPimsCall((config2) => pimsPost(config2, `/instances/${instanceId}/resume`, body, reqOptions), "Error resuming instance");
+    if (!result)
+      return;
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: "InstanceResumed",
+      Data: result
+    });
+  });
+  const cancelCmd = instances.command("cancel").description(`Cancel a ${toolLabel} process instance`).argument("<instance-id>", "Process instance ID");
+  withFolderKey(cancelCmd).option("--comment <text>", "Optional comment for the operation").trackedAction(processContext, async (instanceId, options) => {
+    const body = { comment: options.comment || "" };
+    const reqOptions = { folderKey: options.folderKey };
+    const result = await withPimsCall((config2) => pimsPost(config2, `/instances/${instanceId}/cancel`, body, reqOptions), "Error canceling instance");
+    if (!result)
+      return;
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: "InstanceCanceled",
+      Data: result
+    });
+  });
+  const variablesCmd = instances.command("variables").description(`Get variables for a ${toolLabel} process instance`).argument("<instance-id>", "Process instance ID");
+  withFolderKey(variablesCmd).option("--parent-element-id <id>", "Filter variables by parent element ID").trackedAction(processContext, async (instanceId, options) => {
+    const query = buildQueryString({
+      parentElementId: options.parentElementId
+    });
+    const reqOptions = { folderKey: options.folderKey };
+    const result = await withPimsCall((config2) => pimsGet(config2, `/instances/${instanceId}/variables${query}`, reqOptions), "Error getting variables");
+    if (!result)
+      return;
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: "InstanceVariables",
+      Data: result
+    });
+  });
+  const incidentsCmd = instances.command("incidents").description(`Get incidents for a ${toolLabel} process instance`).argument("<instance-id>", "Process instance ID");
+  withFolderKey(incidentsCmd).trackedAction(processContext, async (instanceId, options) => {
+    const result = await withPimsCall((config2) => pimsGet(config2, `/instances/${instanceId}/incidents`, { folderKey: options.folderKey }), "Error getting incidents");
+    if (!result)
+      return;
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: "InstanceIncidents",
+      Data: result
+    });
+  });
+  const assetCmd = instances.command("asset").description(`Get the ${toolLabel} definition for a process instance`).argument("<instance-id>", "Process instance ID");
+  withFolderKey(assetCmd).trackedAction(processContext, async (instanceId, options) => {
+    const result = await withPimsCall((config2) => pimsGet(config2, `/instances/${instanceId}/asset?type=${assetType}`, { folderKey: options.folderKey }), "Error getting asset");
+    if (!result)
+      return;
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: "InstanceAsset",
+      Data: result
+    });
+  });
+  const retryCmd = instances.command("retry").description(`Retry a faulted ${toolLabel} process instance`).argument("<instance-id>", "Process instance ID");
+  withFolderKey(retryCmd).option("--comment <text>", "Optional comment for the operation").trackedAction(processContext, async (instanceId, options) => {
+    const body = { comment: options.comment || "" };
+    const reqOptions = { folderKey: options.folderKey };
+    const result = await withPimsCall((config2) => pimsPost(config2, `/instances/${instanceId}/retry`, body, reqOptions), "Error retrying instance");
+    if (!result)
+      return;
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: "InstanceRetried",
+      Data: result
+    });
+  });
+  const migrateCmd = instances.command("migrate").description(`Migrate a ${toolLabel} process instance to a different package version`).argument("<instance-id>", "Process instance ID").argument("<new-version>", "Target package version");
+  withFolderKey(migrateCmd).option("--comment <text>", "Optional comment for the operation").trackedAction(processContext, async (instanceId, newVersion, options) => {
+    const body = {
+      newVersion,
+      comment: options.comment || ""
+    };
+    const reqOptions = { folderKey: options.folderKey };
+    const result = await withPimsCall((config2) => pimsPost(config2, `/instances/${instanceId}/upgrade`, body, reqOptions), "Error migrating instance");
+    if (!result)
+      return;
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: "InstanceMigrated",
+      Data: result
+    });
+  });
+  const gotoCmd = instances.command("goto").description("Move execution cursor from one element to another").argument("<instance-id>", "Process instance ID").argument("<transitions>", `JSON array of transitions, e.g. '[{"sourceElementId":"A","targetElementId":"B"}]'`);
+  withFolderKey(gotoCmd).trackedAction(processContext, async (instanceId, transitionsJson, options) => {
+    const [parseError, transitions] = catchError(() => JSON.parse(transitionsJson));
+    const isValidShape = !parseError && Array.isArray(transitions) && transitions.every((t) => t?.sourceElementId != null && t?.targetElementId != null);
+    if (!isValidShape) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: "Error applying goto",
+        Instructions: parseError ? `Invalid transitions JSON: ${parseError.message}` : 'Each transition must have "sourceElementId" and "targetElementId"'
+      });
+      processContext.exit(1);
+      return;
+    }
+    const body = { transitions };
+    const reqOptions = { folderKey: options.folderKey };
+    const result = await withPimsCall((config2) => pimsPost(config2, `/instances/${instanceId}/goto`, body, reqOptions), "Error applying goto");
+    if (!result)
+      return;
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: "InstanceGoto",
+      Data: result
+    });
+  });
+  const cursorsCmd = instances.command("cursors").description(`Get current execution cursor positions for a ${toolLabel} process instance`).argument("<instance-id>", "Process instance ID");
+  withFolderKey(cursorsCmd).trackedAction(processContext, async (instanceId, options) => {
+    const result = await withPimsCall((config2) => pimsGet(config2, `/instances/${instanceId}/goto/cursors`, { folderKey: options.folderKey }), "Error getting cursors");
+    if (!result)
+      return;
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: "InstanceCursors",
+      Data: result
+    });
+  });
+  const messageCmd = instances.command("message").description(`Manage ${toolLabel} instance messages`);
+  messageCmd.command("send").description(`Send a message to ${toolLabel} workflow subscriptions`).requiredOption("-f, --folder-key <key>", "Folder key (GUID)").option("--inputs <value>", "Message payload as JSON string, @file path, or piped via stdin").trackedAction(processContext, async (options) => {
+    const [readError, body] = await catchError(resolveJsonInput({
+      inline: options.inputs,
+      allowStdin: true
+    }));
+    if (readError) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: "Error reading message input",
+        Instructions: readError.message
+      });
+      processContext.exit(1);
+      return;
+    }
+    if (body === undefined) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: "Missing message payload",
+        Instructions: "Provide --inputs <json|@file> or pipe JSON via stdin."
+      });
+      processContext.exit(1);
+      return;
+    }
+    const reqOptions = { folderKey: options.folderKey };
+    const result = await withPimsCall((config2) => pimsPost(config2, "/instances/messages/send", body, reqOptions), "Error sending message");
+    if (!result)
+      return;
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: "MessageSent",
+      Data: result
+    });
+  });
+  if (includeElementExecutions) {
+    const elementExeCmd = instances.command("element-executions").description(`Get element executions for a ${toolLabel} process instance`).argument("<instance-id>", "Process instance ID");
+    withFolderKey(elementExeCmd).trackedAction(processContext, async (instanceId, options) => {
+      const result = await withPimsCall((config2) => pimsGet(config2, `/instances/${instanceId}/element-executions`, { folderKey: options.folderKey }), "Error getting element executions");
+      if (!result)
+        return;
+      OutputFormatter.success({
+        Result: RESULTS.Success,
+        Code: "InstanceElementExecutions",
+        Data: result
+      });
+    });
+  }
+  const variablesSetCmd = instances.command("variables-set").description(`Update variables for a ${toolLabel} process instance`).argument("<instance-id>", "Process instance ID");
+  withFolderKey(variablesSetCmd).option("--inputs <value>", "Patch variables payload as JSON string, @file path, or piped via stdin").trackedAction(processContext, async (instanceId, options) => {
+    const [readError, data] = await catchError(resolveJsonInput({
+      inline: options.inputs,
+      allowStdin: true
+    }));
+    if (readError) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: "Error reading variables input",
+        Instructions: readError.message
+      });
+      processContext.exit(1);
+      return;
+    }
+    if (data === undefined) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: "Missing variables payload",
+        Instructions: "Provide --inputs <json|@file> or pipe JSON via stdin."
+      });
+      processContext.exit(1);
+      return;
+    }
+    const body = data;
+    const reqOptions = { folderKey: options.folderKey };
+    const result = await withPimsCall((config2) => pimsPatch(config2, `/instances/${instanceId}/variables`, body, reqOptions), "Error updating variables");
+    if (!result)
+      return;
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: "InstanceVariablesSet",
+      Data: result
+    });
+  });
+  const variablesAllCmd = instances.command("variables-all").description(`Get all variables (including subprocesses) for a ${toolLabel} process instance`).argument("<instance-id>", "Process instance ID");
+  withFolderKey(variablesAllCmd).trackedAction(processContext, async (instanceId, options) => {
+    const result = await withPimsCall((config2) => pimsGet(config2, `/instances/${instanceId}/variables-all`, { folderKey: options.folderKey }), "Error getting all variables");
+    if (!result)
+      return;
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: "InstanceVariablesAll",
+      Data: result
+    });
+  });
+  const globalVarsCmd = instances.command("global-variables").description(`Get global variables for a ${toolLabel} process instance`).argument("<instance-id>", "Process instance ID");
+  withFolderKey(globalVarsCmd).trackedAction(processContext, async (instanceId, options) => {
+    const result = await withPimsCall((config2) => pimsGet(config2, `/instances/${instanceId}/global-variables`, { folderKey: options.folderKey }), "Error getting global variables");
+    if (!result)
+      return;
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: "InstanceGlobalVariables",
+      Data: result
+    });
+  });
+  const element = instances.command("element").description(`Manage elements within a ${toolLabel} process instance`);
+  const elementCancelCmd = element.command("cancel").description(`Cancel a specific element in a ${toolLabel} process instance`).argument("<instance-id>", "Process instance ID").argument("<element-id>", "Element ID");
+  withFolderKey(elementCancelCmd).option("--comment <text>", "Optional comment for the operation").trackedAction(processContext, async (instanceId, elementId, options) => {
+    const body = { comment: options.comment || "" };
+    const reqOptions = { folderKey: options.folderKey };
+    const result = await withPimsCall((config2) => pimsPost(config2, `/instances/${instanceId}/element/${elementId}/cancel`, body, reqOptions), "Error canceling element");
+    if (!result)
+      return;
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: "ElementCanceled",
+      Data: result
+    });
+  });
+  const elementRetryCmd = element.command("retry").description(`Retry a faulted element in a ${toolLabel} process instance`).argument("<instance-id>", "Process instance ID").argument("<element-id>", "Element ID");
+  withFolderKey(elementRetryCmd).option("--comment <text>", "Optional comment for the operation").trackedAction(processContext, async (instanceId, elementId, options) => {
+    const body = { comment: options.comment || "" };
+    const reqOptions = { folderKey: options.folderKey };
+    const result = await withPimsCall((config2) => pimsPost(config2, `/instances/${instanceId}/element/${elementId}/retry`, body, reqOptions), "Error retrying element");
+    if (!result)
+      return;
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: "ElementRetried",
+      Data: result
+    });
+  });
+};
+
+// ../maestro-sdk/src/shared-commands/process.ts
+var SEARCHABLE_TAG = "Searchable";
+var parseBooleanFlag = (value) => {
+  if (value === "true")
+    return true;
+  if (value === "false")
+    return false;
+  throw new InvalidArgumentError(`Expected 'true' or 'false', got '${value}'.`);
+};
+var collectValue = (value, previous) => [
+  ...previous,
+  value
+];
+var parseTagList = (csv) => csv === undefined ? [] : csv.split(",").map((tag) => tag.trim()).filter((tag) => tag.length > 0);
+var applyFriendlyVariableTags = (variableTags, flags) => {
+  const elements = variableTags.elements ?? {};
+  const allOutputs = Object.entries(elements).flatMap(([elementId, el]) => (el.outputs ?? []).map((output) => ({ elementId, output })));
+  const available = allOutputs.map((o) => `${o.output.name} (element ${o.elementId})`).join(", ");
+  let targets;
+  if (flags.all) {
+    if (allOutputs.length === 0) {
+      throw new Error("This process has no taggable variables.");
+    }
+    targets = allOutputs;
+  } else {
+    const seen = new Set;
+    targets = [];
+    for (const name of flags.variable ?? []) {
+      const matches = allOutputs.filter((o) => o.output.name === name && (flags.elementId === undefined || o.elementId === flags.elementId));
+      if (matches.length === 0) {
+        throw new Error(available ? `No variable matched "${name}"${flags.elementId ? ` in element ${flags.elementId}` : ""}. Available: ${available}.` : "This process has no taggable variables.");
+      }
+      if (flags.elementId === undefined && new Set(matches.map((m) => m.elementId)).size > 1) {
+        const where = matches.map((m) => m.elementId).join(", ");
+        throw new Error(`Variable "${name}" exists in multiple elements (${where}). Pass --element-id to disambiguate (one --variable at a time), or --all to tag every occurrence.`);
+      }
+      for (const m of matches) {
+        if (!seen.has(m.output)) {
+          seen.add(m.output);
+          targets.push(m);
+        }
+      }
+    }
+  }
+  const replaceTags = flags.tags !== undefined ? parseTagList(flags.tags) : undefined;
+  const addTags = parseTagList(flags.addTags);
+  const removeSet = new Set(parseTagList(flags.removeTags));
+  return targets.map(({ elementId, output }) => {
+    const next = replaceTags !== undefined ? [...new Set(replaceTags)] : [...new Set([...output.tags ?? [], ...addTags])].filter((tag) => !removeSet.has(tag));
+    output.tags = next;
+    return { elementId, name: output.name, tags: next };
+  });
+};
+var buildSettingsPath = (processKey) => `/processes/${encodeURIComponent(processKey)}/settings`;
+var validateFriendlyTagFlags = (options) => {
+  const variableCount = options.variable.length;
+  if (variableCount > 0 && options.all) {
+    return "Use either --variable or --all, not both.";
+  }
+  if (variableCount === 0 && !options.all) {
+    return "Specify the target with --variable <name> (repeatable, plus optional --element-id) or --all.";
+  }
+  if (variableCount > 1 && options.elementId !== undefined) {
+    return "--element-id only works with a single --variable; pass one --variable, or drop --element-id.";
+  }
+  const hasSearchable = options.searchable !== undefined;
+  const hasReplace = options.tags !== undefined;
+  const hasIncremental = options.addTags !== undefined || options.removeTags !== undefined;
+  if (hasSearchable && (hasReplace || hasIncremental)) {
+    return "Use --searchable <true|false>, or the low-level --tags/--add-tags/--remove-tags flags — not both.";
+  }
+  if (!hasSearchable && !hasReplace && !hasIncremental) {
+    return "Specify --searchable <true|false> to mark the variable searchable, or --tags/--add-tags/--remove-tags for other tags.";
+  }
+  if (hasReplace && hasIncremental) {
+    return "Use --tags to replace tags, or --add-tags/--remove-tags to adjust them — not both.";
+  }
+  return null;
+};
+var resolveTagFlags = (options) => {
+  if (options.searchable === undefined)
+    return options;
+  return {
+    variable: options.variable,
+    elementId: options.elementId,
+    all: options.all,
+    addTags: options.searchable ? SEARCHABLE_TAG : undefined,
+    removeTags: options.searchable ? undefined : SEARCHABLE_TAG
+  };
+};
+var setVariableTagsFromPayload = async (processKey, options) => {
+  const [fileError, variableTags] = await catchError(resolveJsonInput({ inline: options.inputs, allowStdin: true }));
+  if (fileError) {
+    OutputFormatter.error({
+      Result: RESULTS.Failure,
+      Message: "Error reading variable tags input",
+      Instructions: fileError.message
+    });
+    processContext.exit(1);
+    return;
+  }
+  if (variableTags === undefined) {
+    OutputFormatter.error({
+      Result: RESULTS.Failure,
+      Message: "Missing variable tags payload",
+      Instructions: "Provide --inputs <json|@file>, pipe JSON via stdin, or use the --variable/--all flags."
+    });
+    processContext.exit(1);
+    return;
+  }
+  const reqOptions = { folderKey: options.folderKey };
+  const currentSettings = await withPimsCall((config) => pimsGet(config, buildSettingsPath(processKey), reqOptions), "Error reading current process settings");
+  if (!currentSettings)
+    return;
+  const merged = { ...currentSettings, variableTags };
+  const result = await withPimsCall((config) => pimsPut(config, buildSettingsPath(processKey), merged, reqOptions), "Error updating variable tags");
+  if (!result)
+    return;
+  OutputFormatter.success({
+    Result: RESULTS.Success,
+    Code: "ProcessVariableTagsSet",
+    Data: result
+  });
+};
+var setVariableTagsFromFlags = async (processKey, options) => {
+  const reqOptions = { folderKey: options.folderKey };
+  const currentSettings = await withPimsCall((config) => pimsGet(config, buildSettingsPath(processKey), reqOptions), "Error reading current process settings");
+  if (!currentSettings)
+    return;
+  const variableTags = currentSettings.variableTags ?? {
+    elements: {},
+    sourcePackageVersion: "",
+    lastUpdateTimeUtc: ""
+  };
+  const [mutateError, updated] = catchError(() => applyFriendlyVariableTags(variableTags, resolveTagFlags(options)));
+  if (mutateError) {
+    OutputFormatter.error({
+      Result: RESULTS.Failure,
+      Message: "Error updating variable tags",
+      Instructions: mutateError.message
+    });
+    processContext.exit(1);
+    return;
+  }
+  const merged = { ...currentSettings, variableTags };
+  const result = await withPimsCall((config) => pimsPut(config, buildSettingsPath(processKey), merged, reqOptions), "Error updating variable tags");
+  if (!result)
+    return;
+  OutputFormatter.success({
+    Result: RESULTS.Success,
+    Code: "ProcessVariableTagsSet",
+    Data: { updated, variableTags }
+  });
+};
+var registerSharedProcessCommands = (processCmd, config) => {
+  const { toolLabel } = config;
+  const settingsCmd = processCmd.command("settings").description(`Manage ${toolLabel} process settings`);
+  settingsCmd.command("get").description(`Get settings for a ${toolLabel} process`).argument("<process-key>", "Process definition key").requiredOption("-f, --folder-key <key>", "Folder key (GUID)").trackedAction(processContext, async (processKey, options) => {
+    const reqOptions = { folderKey: options.folderKey };
+    const result = await withPimsCall((config2) => pimsGet(config2, `/processes/${encodeURIComponent(processKey)}/settings`, reqOptions), "Error getting process settings", { resource: "process", id: processKey });
+    if (!result)
+      return;
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: "ProcessSettingsGet",
+      Data: result
+    });
+  });
+  settingsCmd.command("set").description(`Update settings for a ${toolLabel} process`).argument("<process-key>", "Process definition key").requiredOption("-f, --folder-key <key>", "Folder key (GUID)").option("--inputs <value>", "Settings payload as JSON string, @file path, or piped via stdin").trackedAction(processContext, async (processKey, options) => {
+    const [fileError, body] = await catchError(resolveJsonInput({
+      inline: options.inputs,
+      allowStdin: true
+    }));
+    if (fileError) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: "Error reading settings input",
+        Instructions: fileError.message
+      });
+      processContext.exit(1);
+      return;
+    }
+    if (body === undefined) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: "Missing settings payload",
+        Instructions: "Provide --inputs <json|@file> or pipe JSON via stdin."
+      });
+      processContext.exit(1);
+      return;
+    }
+    const reqOptions = { folderKey: options.folderKey };
+    const result = await withPimsCall((config2) => pimsPut(config2, `/processes/${encodeURIComponent(processKey)}/settings`, body, reqOptions), "Error updating process settings");
+    if (!result)
+      return;
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: "ProcessSettingsSet",
+      Data: result
+    });
+  });
+  const variableTagsCmd = processCmd.command("variable-tags").description(`Manage ${toolLabel} process variable tags`);
+  variableTagsCmd.command("get").description(`Get variable tags for a ${toolLabel} process`).argument("<process-key>", "Process definition key").requiredOption("-f, --folder-key <key>", "Folder key (GUID)").trackedAction(processContext, async (processKey, options) => {
+    const reqOptions = { folderKey: options.folderKey };
+    const result = await withPimsCall((config2) => pimsGet(config2, `/processes/${encodeURIComponent(processKey)}/settings`, reqOptions), "Error getting variable tags", { resource: "process", id: processKey });
+    if (!result)
+      return;
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: "ProcessVariableTagsGet",
+      Data: result.variableTags ?? {}
+    });
+  });
+  variableTagsCmd.command("set").description(`Update variable tags for a ${toolLabel} process`).argument("<process-key>", "Process definition key").requiredOption("-f, --folder-key <key>", "Folder key (GUID)").option("--variable <name>", "Name of a variable (output) to tag. Repeatable — pass it multiple times to tag several variables in one call.", collectValue, []).option("--element-id <id>", "Element that owns the variable (disambiguates when the same name appears in multiple elements). Only valid with a single --variable.").option("--all", "Apply the change to every taggable variable").option("--searchable <boolean>", "Mark the variable searchable for instance filtering ('true' or 'false')", parseBooleanFlag).option("--tags <list>", "Advanced: comma-separated tags to set, replacing the variable's current tags (empty value clears them)").option("--add-tags <list>", "Comma-separated tags to add to the variable's current tags").option("--remove-tags <list>", "Comma-separated tags to remove from the variable's current tags").option("--inputs <value>", "Full variable tags payload as JSON string, @file path, or piped via stdin").trackedAction(processContext, async (processKey, options) => {
+    const friendlyRequested = options.variable.length > 0 || options.elementId !== undefined || options.all === true || options.searchable !== undefined || options.tags !== undefined || options.addTags !== undefined || options.removeTags !== undefined;
+    if (options.inputs !== undefined && friendlyRequested) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: "Error updating variable tags",
+        Instructions: "Provide either --inputs (full JSON payload) or the --searchable/--variable/--all flags, not both."
+      });
+      processContext.exit(1);
+      return;
+    }
+    if (friendlyRequested) {
+      const validationError = validateFriendlyTagFlags(options);
+      if (validationError) {
+        OutputFormatter.error({
+          Result: RESULTS.Failure,
+          Message: "Error updating variable tags",
+          Instructions: validationError
+        });
+        processContext.exit(1);
+        return;
+      }
+      await setVariableTagsFromFlags(processKey, options);
+      return;
+    }
+    await setVariableTagsFromPayload(processKey, options);
+  });
+};
+
+// ../maestro-sdk/src/shared-commands/processes.ts
+function findProcessSummary(summaries, processKey) {
+  return summaries.find((summary) => summary.processKey === processKey) ?? null;
+}
+var registerSharedProcessesCommands = (program, config) => {
+  const { toolLabel, processType } = config;
+  const processes = program.command("processes").description(`Manage ${toolLabel} process summaries`);
+  processes.command("list").description(`List all ${toolLabel} process summaries`).option("--folder-key <key>", "Folder key").option("-l, --limit <number>", "Number of items to return (1-10000)", parseLimit).option("--offset <number>", "Number of items to skip (0-1000000)", parseOffset, 0).option("--status <status>", "Filter by process status").trackedAction(processContext, async (options) => {
+    const query = buildQueryString({
+      processType,
+      status: options.status,
+      $top: options.limit,
+      $skip: options.offset !== 0 ? options.offset : undefined
+    });
+    const reqOptions = { folderKey: options.folderKey };
+    const result = await withPimsCall((config2) => pimsGet(config2, `/processes/summary${query}`, reqOptions), "Error listing processes");
+    if (!result)
+      return;
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: "ProcessList",
+      Data: result
+    });
+  });
+  processes.command("incidents").description(`Get incidents for a specific ${toolLabel} process`).argument("<process-key>", "Process definition key").requiredOption("--folder-key <key>", "Folder key").trackedAction(processContext, async (processKey, options) => {
+    const reqOptions = { folderKey: options.folderKey };
+    const result = await withPimsCall((config2) => pimsGet(config2, `/incidents/process/${encodeURIComponent(processKey)}`, reqOptions), "Error getting process incidents", { resource: "process", id: processKey });
+    if (!result)
+      return;
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: "ProcessIncidents",
+      Data: result
+    });
+  });
+  processes.command("diagnose").description(`Correlate ${toolLabel} process summary, incidents, and error codes`).argument("<process-key>", "Process definition key").requiredOption("--folder-key <key>", "Folder key").trackedAction(processContext, async (processKey, options) => {
+    const result = await withPimsCall(async (config2) => {
+      const query = processType ? buildQueryString({ processType }) : "";
+      const summaries = await pimsGet(config2, `/processes/summary${query}`);
+      const incidents = await pimsGet(config2, `/incidents/process/${encodeURIComponent(processKey)}`, { folderKey: options.folderKey });
+      const errorCodes = await pimsGet(config2, `/incidents/process/${encodeURIComponent(processKey)}/error-codes`, { folderKey: options.folderKey });
+      return {
+        summary: findProcessSummary(summaries, processKey),
+        incidents,
+        errorCodes: errorCodes.errorCodes || []
+      };
+    }, "Error diagnosing process");
+    if (!result)
+      return;
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: "ProcessDiagnostics",
+      Data: {
+        ProcessKey: processKey,
+        FolderKey: options.folderKey,
+        Summary: result.summary,
+        FaultedCount: result.summary?.faultedCount ?? null,
+        RunningCount: result.summary?.runningCount ?? null,
+        Incidents: result.incidents,
+        IncidentCount: result.incidents.length,
+        ErrorCodes: result.errorCodes,
+        ErrorCodeCount: result.errorCodes.length
+      }
+    });
+  });
+  processes.command("error-codes").description(`Get unique error codes for a specific ${toolLabel} process`).argument("<process-key>", "Process definition key").requiredOption("--folder-key <key>", "Folder key").trackedAction(processContext, async (processKey, options) => {
+    const reqOptions = { folderKey: options.folderKey };
+    const result = await withPimsCall((config2) => pimsGet(config2, `/incidents/process/${encodeURIComponent(processKey)}/error-codes`, reqOptions), "Error getting process error codes", { resource: "process", id: processKey });
+    if (!result)
+      return;
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: "ProcessIncidentErrorCodes",
+      Data: result.errorCodes || []
+    });
+  });
+};
+
+export { registerSharedIncidentCommands, registerSharedInstanceCommands, registerSharedProcessCommands, registerSharedProcessesCommands };
+
+//# debugId=8FE5E6DBD97B7F2164756E2164756E21