@uipath/flow-tool 1.202.2 → 1.203.0-preview.180

package/dist/packager-tool-35hg551a.js

@@ -0,0 +1,1889 @@
+import {
+  resolveJsonInput
+} from "./packager-tool-h9d8c9rf.js";
+import {
+  DEBUG_MODE_MAP,
+  SIMULATION_MODE_MAP,
+  beginDebugSession,
+  createDebugInstance,
+  getPersonalFolderKey
+} from "./packager-tool-9kx94sj5.js";
+import {
+  debugPimsGet,
+  debugPimsPatch,
+  debugPimsPost,
+  debugPimsPut
+} from "./packager-tool-s0mzv3sx.js";
+import {
+  getAuthContext,
+  getLoginStatusAsync
+} from "./packager-tool-26ydwf12.js";
+import {
+  DEFAULT_PAGE_SIZE,
+  EXIT_CODES,
+  InvalidArgumentError,
+  OutputFormatter,
+  Pagination,
+  RESULTS,
+  catchError,
+  extractErrorMessage,
+  isGuid,
+  logger,
+  parseBoundedInt,
+  parseLimit,
+  parseOffset,
+  processContext
+} from "./packager-tool-6k8s7pt9.js";
+import {
+  __require
+} from "./packager-tool-1yh8g550.js";
+
+// ../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/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/registry/filter-parser.ts
+class FilterParseError extends Error {
+  code;
+  token;
+  constructor(message, code, token) {
+    super(message);
+    this.code = code;
+    this.token = token;
+    this.name = "FilterParseError";
+  }
+}
+function parseFilterString(filterString) {
+  if (!filterString || filterString.trim() === "") {
+    return { filters: [], logic: "AND" };
+  }
+  const parts = filterString.split(/,(?=[a-zA-Z_][a-zA-Z0-9_]*(?::[a-zA-Z]+)?=)/);
+  const conditions = [];
+  for (const part of parts) {
+    const condition = parseFilterCondition(part.trim());
+    conditions.push(condition);
+  }
+  return {
+    filters: conditions,
+    logic: "AND"
+  };
+}
+function parseFilterCondition(conditionString) {
+  const match = conditionString.match(/^([^:=]+)(?::([^=]+))?=(.+)$/);
+  if (!match) {
+    throw new FilterParseError(`Invalid filter format: '${conditionString}'. Expected 'field=value' or 'field:operator=value'.`, "INVALID_FORMAT", conditionString);
+  }
+  const [, fieldStr, operatorStr, valueStr] = match;
+  const field = normalizeField(fieldStr.trim());
+  const operator = operatorStr?.trim() || "equals";
+  const value = valueStr.trim();
+  if (!isValidField(field)) {
+    throw new FilterParseError(`Invalid filter field: '${field}'. Supported fields: category, type, tags, displayname, nodetype, description.`, "INVALID_FIELD", field);
+  }
+  if (!isValidOperator(operator)) {
+    throw new FilterParseError(`Invalid filter operator: '${operator}'. Supported operators: equals, contains, in, startsWith, endsWith.`, "INVALID_OPERATOR", operator);
+  }
+  return {
+    field,
+    operator,
+    value
+  };
+}
+function normalizeField(field) {
+  const fieldMap = {
+    category: "category",
+    cat: "category",
+    type: "type",
+    nodetype: "nodetype",
+    node_type: "nodetype",
+    tags: "tags",
+    tag: "tags",
+    displayname: "displayname",
+    display_name: "displayname",
+    displayName: "displayname",
+    name: "displayname",
+    label: "displayname"
+  };
+  const normalized = field.toLowerCase().replace(/[-_\s]/g, "");
+  return fieldMap[normalized] || field;
+}
+function isValidField(field) {
+  const validFields = [
+    "category",
+    "type",
+    "tags",
+    "displayname",
+    "nodetype",
+    "description"
+  ];
+  return validFields.includes(field);
+}
+function isValidOperator(operator) {
+  const validOperators = [
+    "equals",
+    "contains",
+    "in",
+    "startsWith",
+    "endsWith"
+  ];
+  return validOperators.includes(operator);
+}
+
+// ../maestro-sdk/src/registry/command.ts
+function flattenNodeForDisplay(n) {
+  return {
+    NodeType: n.nodeType,
+    Category: n.category ?? "",
+    DisplayName: n.display?.label ?? "",
+    Description: n.description ?? n.display?.description ?? "",
+    Version: n.version ?? "",
+    Tags: (n.tags ?? []).join(", ")
+  };
+}
+function flattenNodeWithAvailability(n, availableOnTenant) {
+  return {
+    ...flattenNodeForDisplay(n),
+    AvailableOnTenant: availableOnTenant
+  };
+}
+async function mergeWithKnownSdkNodes(tenantNodes) {
+  const { listKnownSdkNodes } = await import("./known-types-8dhhqk35.js");
+  const tenantTypes = new Set(tenantNodes.map((n) => n.nodeType?.toLowerCase()).filter((t) => typeof t === "string"));
+  const merged = tenantNodes.map((node) => ({ node, availableOnTenant: true }));
+  for (const known of listKnownSdkNodes()) {
+    const type = known.nodeType?.toLowerCase();
+    if (typeof type !== "string")
+      continue;
+    if (tenantTypes.has(type))
+      continue;
+    merged.push({ node: known, availableOnTenant: false });
+  }
+  return merged;
+}
+var registerRegistryCommand = (program, commandPrefix) => {
+  const cmd = `uip ${commandPrefix} registry`;
+  const registry = program.command("registry").description(`Browse and search the ${commandPrefix} node registry to discover available activities and connectors (OOTB + authenticated). Use 'pull' to sync, 'search' to find nodes, 'get' to inspect a node's full input/output schema.`).addHelpText("after", `
+Typical workflow:
+  0. Login for full registry (optional, OOTB nodes available without login):
+                          uip login
+  1. Sync the registry:   ${cmd} pull
+  2. Search for a node:   ${cmd} search slack
+  3. Inspect its schema:  ${cmd} get <node-type>
+  4. Extract input fields: ${cmd} get <node-type> --output-filter "Node.inputDefinition.fields"
+
+Note: Without login, only built-in (OOTB) nodes are available. Login to access the full node registry including custom connectors.
+
+In-solution discovery (--local):
+  Run from inside a solution project directory (with a .uipx file in CWD, parent, or grandparent).
+  Shows sibling projects (Agent, Process, Flow, Api) as invokable nodes.
+  cd MySolution/MyFlow && ${cmd} list --local
+
+Subcommands:
+  pull    Fetch and cache the full node registry (run once per session)
+  list    List cached nodes (default: first 20, --limit -1 for everything)
+  search  Find nodes by keyword and/or field filters  ← start here
+  get     Get full schema for a single node (with connector input/output enrichment)`);
+  const pullExamples = [
+    {
+      Description: "Sync the node registry",
+      Command: `${cmd} pull`,
+      Output: {
+        Code: "NodePullSuccess",
+        Data: {
+          NodesCount: 184,
+          FromCache: false,
+          Source: "authenticated",
+          CacheWritten: true,
+          Message: "Synced fresh nodes"
+        }
+      }
+    }
+  ];
+  const listExamples = [
+    {
+      Description: "List cached nodes (every row carries AvailableOnTenant; FF-gated SDK-known nodes are included)",
+      Command: `${cmd} list --limit 2`,
+      Output: {
+        Code: "NodeListSuccess",
+        Data: [
+          {
+            NodeType: "uipath.slack.connector.send-message",
+            Category: "connector",
+            DisplayName: "Send Message",
+            Description: "Post a message to a Slack channel",
+            Version: "1.0.0",
+            Tags: "slack, messaging",
+            AvailableOnTenant: true
+          },
+          {
+            NodeType: "uipath.human-in-the-loop",
+            Category: "human-task",
+            DisplayName: "Human in the Loop",
+            Description: "Assign a task to a human and wait for completion",
+            Version: "1.0.0",
+            Tags: "human-task, hitl, human-in-the-loop, approval",
+            AvailableOnTenant: false
+          }
+        ]
+      }
+    }
+  ];
+  const searchExamples = [
+    {
+      Description: "Search nodes by keyword (every row carries AvailableOnTenant; FF-gated SDK-known nodes are included)",
+      Command: `${cmd} search slack`,
+      Output: {
+        Code: "NodeSearchSuccess",
+        Data: [
+          {
+            NodeType: "uipath.slack.connector.send-message",
+            Category: "connector",
+            DisplayName: "Send Message",
+            Description: "Post a message to a Slack channel",
+            Version: "1.0.0",
+            Tags: "slack, messaging",
+            AvailableOnTenant: true
+          }
+        ]
+      }
+    }
+  ];
+  const getExamples = [
+    {
+      Description: "Get the full schema for a node",
+      Command: `${cmd} get uipath.slack.connector.send-message`,
+      Output: {
+        Code: "NodeGetSuccess",
+        Data: {
+          Node: {
+            nodeType: "uipath.slack.connector.send-message",
+            category: "connector",
+            display: { label: "Send Message" },
+            inputDefinition: {
+              fields: [{ name: "channel", required: true }]
+            }
+          }
+        }
+      }
+    }
+  ];
+  registry.command("pull").description(`Pull and sync node data from ${commandPrefix} registry (login first for full registry)`).option("-f, --force", "Force refresh, ignore cache").examples(pullExamples).trackedAction(processContext, async (options) => {
+    const { pullNodes } = await import("./node-sync-service-zq2ptsep.js");
+    const [error, result] = await catchError(pullNodes({
+      force: options.force
+    }));
+    if (error) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: "Error pulling nodes",
+        Instructions: error.message
+      });
+      processContext.exit(1);
+      return;
+    }
+    const message = result.fromCache ? `Using cached nodes (age: ${result.ageMinutes}m)` : "Synced fresh nodes";
+    const finalMessage = result.info ? `${message}. ${result.info}` : message;
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: "NodePullSuccess",
+      Data: {
+        NodesCount: result.syncedCount,
+        FromCache: result.fromCache,
+        AgeMinutes: result.ageMinutes,
+        Source: result.source,
+        CacheWritten: result.cacheWritten,
+        Message: finalMessage,
+        Info: result.info
+      }
+    });
+  });
+  registry.command("list").description("Sample cached nodes to inspect their config structure (default: first 20). Output merges tenant nodes with the SDK-known catalog; every row carries `AvailableOnTenant` so callers can filter FF-gated rows. Use 'search' to find nodes — use --limit -1 only if you need the full list (the result can be huge and unreadable).").addHelpText("after", `
+Examples:
+  ${cmd} list
+  ${cmd} list --limit 200
+  ${cmd} list --limit -1
+
+In-solution (--local):
+  cd MySolution/MyFlow && ${cmd} list --local`).option("-l, --limit <n>", "Number of nodes to return (default: 20, -1 for all)", (v) => Number.parseInt(v, 10), 20).option("--local", "Show only in-solution project nodes (requires .uipx in CWD, parent, or grandparent). Omits `AvailableOnTenant` (no tenant lookup).").examples(listExamples).trackedAction(processContext, async (options) => {
+    if (Number.isNaN(options.limit) || options.limit < 1 && options.limit !== -1) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: "Invalid --limit value",
+        Instructions: "Provide a positive integer (e.g. --limit 100) or -1 for all nodes"
+      });
+      processContext.exit(1);
+      return;
+    }
+    const { listNodes } = await import("./node-sync-service-zq2ptsep.js");
+    const [error, tenantNodes] = await catchError(listNodes({ local: options.local }));
+    if (error) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: "Error listing nodes",
+        Instructions: error.message
+      });
+      processContext.exit(1);
+      return;
+    }
+    const showAll = options.limit === -1;
+    if (options.local) {
+      const totalCount2 = tenantNodes.length;
+      const effectiveLimit2 = showAll ? totalCount2 : options.limit;
+      const nodes = tenantNodes.slice(0, effectiveLimit2);
+      const truncated2 = nodes.length < totalCount2;
+      OutputFormatter.success({
+        Result: RESULTS.Success,
+        Code: "NodeListSuccess",
+        Data: nodes.map(flattenNodeForDisplay)
+      });
+      if (truncated2) {
+        logger.info(`Showing first ${nodes.length} of ${totalCount2}. Use --limit or --limit -1 to get more, or use 'search' to filter.`);
+      }
+      return;
+    }
+    const merged = await mergeWithKnownSdkNodes(tenantNodes);
+    const totalCount = merged.length;
+    const effectiveLimit = showAll ? totalCount : options.limit;
+    const slice = merged.slice(0, effectiveLimit);
+    const truncated = slice.length < totalCount;
+    const gatedCount = merged.filter((m) => !m.availableOnTenant).length;
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: "NodeListSuccess",
+      Data: slice.map((m) => flattenNodeWithAvailability(m.node, m.availableOnTenant))
+    });
+    if (truncated) {
+      logger.info(`Showing first ${slice.length} of ${totalCount} (${gatedCount} not enabled on this tenant). Use --limit or --limit -1 to get more.`);
+    } else if (gatedCount > 0) {
+      logger.info(`${gatedCount} of ${totalCount} node type(s) are not enabled on this tenant (AvailableOnTenant=false).`);
+    }
+  });
+  registry.command("search").description("Find nodes by keyword and/or field filters").addHelpText("after", `
+Filter syntax:
+  field=value                    equality (default operator)
+  field:contains=value           field contains value
+  field:startsWith=value         field starts with value
+  field:endsWith=value           field ends with value
+  field:in=value1,value2         field matches any of the values
+  field1=v1,field2=v2            multiple conditions (AND logic)
+
+Filterable fields:
+  category / cat                 e.g. "connector", "agent"
+  type / nodetype                node type identifier
+  tags / tag                     node tags
+  displayname / name / label     human-readable display name
+
+Examples:
+  ${cmd} search slack
+  ${cmd} search --filter "category=connector"
+  ${cmd} search --filter "displayname:contains=send message"
+  ${cmd} search slack --filter "category=connector"
+  ${cmd} search --filter "tags:in=ai,automation"
+  ${cmd} search --filter "category=connector,displayname:contains=slack"
+
+Tip: pipe through --output-filter to extract just the nodeType values:
+  ${cmd} search slack --output-filter "[*].NodeType"
+
+In-solution (--local):
+  cd MySolution/MyFlow && ${cmd} search agent --local`).argument("[keyword]", "Search term matched against nodeType, category, tags, display name, and description").option("-f, --filter <filter>", "Structured field filter: field=value or field:operator=value. Comma-separated = AND. Fields: category, type, tags, displayname, description.").option("--local", "Search only in-solution project nodes (requires .uipx in CWD, parent, or grandparent). Omits `AvailableOnTenant` (no tenant lookup).").examples(searchExamples).trackedAction(processContext, async (keyword, options) => {
+    let parsedFilters;
+    if (options.filter) {
+      const [parseError, parsed] = catchError(() => parseFilterString(options.filter));
+      if (parseError) {
+        if (parseError instanceof FilterParseError) {
+          OutputFormatter.error({
+            Result: RESULTS.Failure,
+            Message: "Invalid filter syntax",
+            Instructions: `${parseError.message} Examples: category=agent, displayname:contains=http, tags:in=ai,automation.`
+          });
+          processContext.exit(1);
+          return;
+        }
+        OutputFormatter.error({
+          Result: RESULTS.Failure,
+          Message: "Error searching nodes",
+          Instructions: parseError.message
+        });
+        processContext.exit(1);
+        return;
+      }
+      parsedFilters = parsed;
+    }
+    if (!keyword && !parsedFilters) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: "Search requires either a keyword or filters",
+        Instructions: "Provide a keyword or use --filter flag"
+      });
+      processContext.exit(1);
+      return;
+    }
+    const {
+      searchNodeSummariesWithAvailability,
+      searchNodes,
+      searchNodesWithFilters
+    } = await import("./node-sync-service-zq2ptsep.js");
+    if (options.local) {
+      const [searchError2, results2] = await catchError(parsedFilters ? searchNodesWithFilters(keyword, parsedFilters, {
+        local: true
+      }) : searchNodes(keyword, { local: true }));
+      if (searchError2) {
+        OutputFormatter.error({
+          Result: RESULTS.Failure,
+          Message: "Error searching nodes",
+          Instructions: searchError2.message
+        });
+        processContext.exit(1);
+        return;
+      }
+      OutputFormatter.success({
+        Result: RESULTS.Success,
+        Code: "NodeSearchSuccess",
+        Data: results2.map(flattenNodeForDisplay)
+      });
+      return;
+    }
+    const [searchError, results] = await catchError(searchNodeSummariesWithAvailability(keyword, parsedFilters));
+    if (searchError) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: "Error searching nodes",
+        Instructions: searchError.message
+      });
+      processContext.exit(1);
+      return;
+    }
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: "NodeSearchSuccess",
+      Data: results.map((result) => flattenNodeWithAvailability(result.node, result.availableOnTenant))
+    });
+  });
+  registry.command("get").description("Get the full schema for a single node. For connector nodes (uipath.connector.*), the base manifest is automatically enriched with live metadata from Integration Service.").addHelpText("after", `
+IS-enriched fields (connector nodes only, fetched live from Integration Service):
+
+  Activity nodes (uipath.connector.*, not trigger):
+    inputDefinition.fields    Fields to configure. Each field has: name, displayName, type, required, and optionally reference (lookup: objectName, path, lookupValue, lookupNames, childPath; 4.0.0 activities carry scriptRef instead of objectName — resolve with 'uip is resources run script --script-ref') or enum.
+    outputResponseDefinition  Fields produced after the node runs.
+    connectorMethodInfo       HTTP details (method, path, operationId).
+    --connection-id optional — adds custom fields specific to that account.
+
+  Trigger nodes (uipath.connector.trigger.*):
+    eventParameters           Fields that configure the trigger (e.g. which folder to watch).
+    filterFields              Fields used to filter which events fire the trigger.
+    outputResponseDefinition  Fields produced by the trigger event payload.
+    eventMode                 "webhooks" or "polling".
+    login + --connection-id required — without both, no enrichment is returned.
+
+Examples:
+  ${cmd} get uipath.slack.connector.send-message
+  ${cmd} get uipath.connector.uipath-salesforce-slack.send-message --connection-id <id>
+  ${cmd} get uipath.connector.trigger.uipath-microsoft-outlook365.email-received --connection-id <id>
+
+In-solution (--local):
+  cd MySolution/MyFlow && ${cmd} get <node-type> --local`).argument("<node-type>", `Node type identifier — get it from '${cmd} search'`).option("--connection-id <id>", "Connection ID for Integration Service connector node enrichment. Required for connector trigger nodes; optional for connector activity nodes.").option("--local", "Get node from in-solution projects only (requires .uipx in CWD, parent, or grandparent)").examples(getExamples).trackedAction(processContext, async (nodeType, options) => {
+    const { getNodeEnriched } = await import("./node-sync-service-zq2ptsep.js");
+    const [error, result] = await catchError(getNodeEnriched(nodeType, options.connectionId, {
+      local: options.local
+    }));
+    if (error) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: "Error retrieving node",
+        Instructions: error.message
+      });
+      processContext.exit(1);
+      return;
+    }
+    if (!result) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: "Node not found",
+        Instructions: `No node found with node type: ${nodeType}`
+      });
+      processContext.exit(1);
+      return;
+    }
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: "NodeGetSuccess",
+      Data: {
+        Node: result
+      }
+    }, { preserveDataKeys: true });
+  });
+};
+
+// ../maestro-sdk/src/with-debug-pims-call.ts
+async function createDebugPimsConfig() {
+  const status = await getLoginStatusAsync({
+    ensureTokenValidityMinutes: 10
+  });
+  if (status.loginStatus !== "Logged in" || !status.baseUrl || !status.accessToken) {
+    throw new Error(status.hint ? `Not logged in. ${status.hint}` : "Not logged in. Run 'uip login' first.");
+  }
+  if (!status.organizationId) {
+    throw new Error("Organization ID not available. Ensure you are logged in with an organization context.");
+  }
+  if (!status.tenantId) {
+    throw new Error("Tenant ID not available. Ensure UIPATH_TENANT_ID is set.");
+  }
+  if (!status.tenantName) {
+    throw new Error("Tenant name not available. Ensure you are logged in with a tenant context.");
+  }
+  return {
+    baseUrl: status.baseUrl,
+    organizationId: status.organizationId,
+    tenantName: status.tenantName,
+    tenantId: status.tenantId,
+    authToken: status.accessToken
+  };
+}
+async function withDebugPimsCall(fn, errorMessage) {
+  const [configError, config] = await catchError(createDebugPimsConfig());
+  if (configError) {
+    logger.warn(`${errorMessage}: ${configError.message}`);
+    OutputFormatter.error({
+      Result: RESULTS.Failure,
+      Message: errorMessage,
+      Instructions: configError.message
+    });
+    processContext.exit(1);
+    return;
+  }
+  if (!config.folderKey) {
+    const [folderError, folder] = await catchError(getPersonalFolderKey(config));
+    if (folderError) {
+      logger.warn(`Could not resolve personal folder: ${folderError.message}`);
+    } else {
+      config.folderKey = folder.key;
+      config.organizationUnitId = folder.id;
+    }
+  }
+  const [error, result] = await catchError(fn(config));
+  if (error) {
+    const msg = await extractErrorMessage(error);
+    logger.warn(`${errorMessage}: ${msg}`);
+    OutputFormatter.error({
+      Result: RESULTS.Failure,
+      Message: errorMessage,
+      Instructions: msg
+    });
+    processContext.exit(1);
+    return;
+  }
+  return result;
+}
+
+// ../maestro-sdk/src/shared-commands/debug-instances.ts
+var DEBUG_API_PREFIX = "/api/v1/debug-instances";
+var VALID_DEBUG_MODES = Object.keys(DEBUG_MODE_MAP);
+var VALID_SIMULATION_MODES = Object.keys(SIMULATION_MODE_MAP);
+var registerSharedDebugInstanceCommands = (program, config) => {
+  const { toolLabel } = config;
+  const debugInstance = program.command("debug-instance").description(`Manage ${toolLabel} debug instance operations`);
+  debugInstance.command("create").description(`Create a ${toolLabel} debug instance from an already-uploaded solution`).requiredOption("--solution-id <id>", "Solution ID (from a previous upload or Studio Web)").requiredOption("--project-id <id>", "Studio Web project ID within the solution").requiredOption("--entry-point <path>", 'Entry point path (e.g. "/Main.bpmn#start")').option("--process-type <type>", "Process type", "processOrchestration").option("--debug-mode <mode>", "Debug mode: Default (pause at breakpoints), StepByStep (pause at every step), SingleStep (one step only)", "Default").option("--simulation-mode <mode>", "Simulation mode: None, All (simulate all elements), Selective (simulate except opt-outs)", "None").option("-i, --inputs <json>", "Input arguments as JSON string", "{}").trackedAction(processContext, async (options) => {
+    if (!VALID_DEBUG_MODES.includes(options.debugMode)) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: `Invalid --debug-mode "${options.debugMode}". Valid values: ${VALID_DEBUG_MODES.join(", ")}.`,
+        Instructions: ""
+      });
+      processContext.exit(1);
+      return;
+    }
+    if (!VALID_SIMULATION_MODES.includes(options.simulationMode)) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: `Invalid --simulation-mode "${options.simulationMode}". Valid values: ${VALID_SIMULATION_MODES.join(", ")}.`,
+        Instructions: ""
+      });
+      processContext.exit(1);
+      return;
+    }
+    const [configError, config2] = await catchError(createDebugPimsConfig());
+    if (configError) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: "Error creating debug instance",
+        Instructions: configError.message
+      });
+      processContext.exit(1);
+      return;
+    }
+    const [folderError, folder] = await catchError(getPersonalFolderKey(config2));
+    if (folderError) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: "Error getting personal workspace folder",
+        Instructions: folderError.message
+      });
+      processContext.exit(1);
+      return;
+    }
+    config2.folderKey = folder.key;
+    config2.organizationUnitId = folder.id;
+    const [sessionError, session] = await catchError(beginDebugSession(config2, options.inputs));
+    if (sessionError) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: "Error beginning debug session",
+        Instructions: sessionError.message
+      });
+      processContext.exit(1);
+      return;
+    }
+    const [createError, result] = await catchError(createDebugInstance(config2, session.jobKey, options.solutionId, options.projectId, options.entryPoint, options.processType, options.debugMode, options.simulationMode));
+    if (createError) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: "Error creating debug instance",
+        Instructions: createError.message
+      });
+      processContext.exit(1);
+      return;
+    }
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: "DebugInstanceCreated",
+      Data: {
+        instanceId: result.instanceId,
+        runId: result.runId,
+        jobKey: session.jobKey
+      },
+      Instructions: "Use 'debug-instance status <instance-id>' to check the run. Use 'debug-instance incidents <instance-id>' or 'debug-instance variables <instance-id>' to inspect it."
+    });
+  });
+  debugInstance.command("status").description(`Get the current status of a ${toolLabel} debug instance`).argument("<instance-id>", "Debug instance ID").trackedAction(processContext, async (instanceId) => {
+    const result = await withDebugPimsCall((cfg) => debugPimsGet(cfg, `${DEBUG_API_PREFIX}/${instanceId}/element-executions`, "get-debug-instance-status"), "Error getting debug instance status");
+    if (!result)
+      return;
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: "DebugInstanceStatus",
+      Data: result
+    });
+  });
+  debugInstance.command("breakpoints").description(`Update breakpoints for a ${toolLabel} debug instance`).argument("<instance-id>", "Debug instance ID").option("--inputs <value>", "Breakpoints 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 breakpoints input",
+        Instructions: readError.message
+      });
+      processContext.exit(1);
+      return;
+    }
+    const body = data ?? {
+      breakpoints: []
+    };
+    const result = await withDebugPimsCall((cfg) => debugPimsPut(cfg, `${DEBUG_API_PREFIX}/${instanceId}/breakpoints`, body), "Error updating breakpoints");
+    if (!result)
+      return;
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: "DebugInstanceBreakpointsUpdated",
+      Data: result
+    });
+  });
+  debugInstance.command("cancel").description(`Cancel a ${toolLabel} debug instance`).argument("<instance-id>", "Debug instance ID").trackedAction(processContext, async (instanceId) => {
+    const result = await withDebugPimsCall((cfg) => debugPimsPost(cfg, `${DEBUG_API_PREFIX}/${instanceId}/cancel`, { comment: "" }), "Error canceling debug instance");
+    if (!result)
+      return;
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: "DebugInstanceCanceled",
+      Data: result
+    });
+  });
+  debugInstance.command("continue").description(`Continue execution on a paused ${toolLabel} debug instance`).argument("<instance-id>", "Debug instance ID").option("--inputs <value>", "Continue 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 continue input",
+        Instructions: readError.message
+      });
+      processContext.exit(1);
+      return;
+    }
+    const body = data ?? {
+      nextStep: false
+    };
+    const result = await withDebugPimsCall((cfg) => debugPimsPost(cfg, `${DEBUG_API_PREFIX}/${instanceId}/continue`, body), "Error continuing debug instance");
+    if (!result)
+      return;
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: "DebugInstanceContinued",
+      Data: result
+    });
+  });
+  debugInstance.command("incidents").description(`Get incidents for a ${toolLabel} debug instance`).argument("<instance-id>", "Debug instance ID").trackedAction(processContext, async (instanceId) => {
+    const result = await withDebugPimsCall((cfg) => debugPimsGet(cfg, `${DEBUG_API_PREFIX}/${instanceId}/incidents`), "Error getting debug instance incidents");
+    if (!result)
+      return;
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: "DebugInstanceIncidents",
+      Data: result ?? []
+    });
+  });
+  debugInstance.command("variables").description(`Get variables for a ${toolLabel} debug instance`).argument("<instance-id>", "Debug instance ID").option("--parent-element-id <id>", "Filter variables by parent element ID").trackedAction(processContext, async (instanceId, options) => {
+    const query = buildQueryString({
+      parentElementId: options.parentElementId
+    });
+    const result = await withDebugPimsCall((cfg) => debugPimsGet(cfg, `${DEBUG_API_PREFIX}/${instanceId}/variables${query}`), "Error getting debug instance variables");
+    if (!result)
+      return;
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: "DebugInstanceVariables",
+      Data: result
+    });
+  });
+  debugInstance.command("variables-set").description(`Update variables for a ${toolLabel} debug instance`).argument("<instance-id>", "Debug instance ID").option("--inputs <value>", "Patch variables payload as JSON string, @file path, or piped via stdin").option("--parent-element-id <id>", "Filter by parent element ID").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 payload",
+        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 query = buildQueryString({
+      parentElementId: options.parentElementId
+    });
+    const result = await withDebugPimsCall((cfg) => debugPimsPatch(cfg, `${DEBUG_API_PREFIX}/${instanceId}/variables${query}`, body), "Error updating debug instance variables");
+    if (!result)
+      return;
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: "DebugInstanceVariablesSet",
+      Data: result
+    });
+  });
+  debugInstance.command("variables-all").description(`Get all variables including subprocesses for a ${toolLabel} debug instance`).argument("<instance-id>", "Debug instance ID").trackedAction(processContext, async (instanceId) => {
+    const result = await withDebugPimsCall((cfg) => debugPimsGet(cfg, `${DEBUG_API_PREFIX}/${instanceId}/variables-all`), "Error getting all debug instance variables");
+    if (!result)
+      return;
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: "DebugInstanceVariablesAll",
+      Data: result
+    });
+  });
+};
+
+// ../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 { registerRegistryCommand, registerSharedDebugInstanceCommands, registerSharedIncidentCommands, registerSharedInstanceCommands, registerSharedProcessCommands, registerSharedProcessesCommands };
+
+//# debugId=74DC721665AE8F4764756E2164756E21