@uipath/flow-tool 1.205.0-preview.276 → 1.206.0-preview.279

package/dist/{de-B3EKCNFC-zdwybhh7.js → de-VQWT6L5Y-mch4qwyv.js}

@@ -1,7 +1,16 @@
-import"./packager-tool-m3wkcxf5.js";
-import"./packager-tool-1yh8g550.js";
-
-// ../../node_modules/@uipath/flow-expression-model/dist/de-B3EKCNFC.js
+// ../../node_modules/@uipath/flow-expression-model/dist/de-VQWT6L5Y.js
+var entityFilter_operatorName_contains = "Enthält";
+var entityFilter_operatorName_endsWith = "Endet mit";
+var entityFilter_operatorName_equals = "Ist gleich";
+var entityFilter_operatorName_greaterThan = "größer als";
+var entityFilter_operatorName_greaterThanOrEqual = "größer als oder gleich";
+var entityFilter_operatorName_in = "In";
+var entityFilter_operatorName_lessThan = "weniger als";
+var entityFilter_operatorName_lessThanOrEqual = "weniger als oder gleich";
+var entityFilter_operatorName_notContains = "Not Contains";
+var entityFilter_operatorName_notEquals = "Not Equals";
+var entityFilter_operatorName_notIn = "Nicht in";
+var entityFilter_operatorName_startsWith = "Beginnt mit";
 var expressionDiagnostic_dollarHint_replacement = ". Verwenden Sie „$vars“.<name>`, `$self.<field>` oder eine andere definierte Variable.";
 var schemaPanel_arrayItemType_description = "Array-Elementtyp";
 var scopeService_outputDescription_fallback = "Ausgabe von {{nodeLabel}}";
@@ -12,6 +21,18 @@ var scopeService_variableName_reservedWordError = "„{{name}}“ ist ein reserv
 var scopeService_variableName_startsWithNumberError = "Variablenname darf nicht mit einer Ziffer beginnen";
 var validation_expression_fileExpected_message = "Dieser Wert muss eine Datei sein. Um eine Remote-Datei zu verwenden, laden Sie die Datei zuerst mit einer Aktion herunter, die eine Datei ausgibt, und verweisen Sie dann auf diese Ausgabe.";
 var de_default = {
+  entityFilter_operatorName_contains,
+  entityFilter_operatorName_endsWith,
+  entityFilter_operatorName_equals,
+  entityFilter_operatorName_greaterThan,
+  entityFilter_operatorName_greaterThanOrEqual,
+  entityFilter_operatorName_in,
+  entityFilter_operatorName_lessThan,
+  entityFilter_operatorName_lessThanOrEqual,
+  entityFilter_operatorName_notContains,
+  entityFilter_operatorName_notEquals,
+  entityFilter_operatorName_notIn,
+  entityFilter_operatorName_startsWith,
   expressionDiagnostic_dollarHint_replacement,
   schemaPanel_arrayItemType_description,
   scopeService_outputDescription_fallback,
@@ -24,6 +45,18 @@ var de_default = {
 };
 export {
   de_default as default,
+  entityFilter_operatorName_contains,
+  entityFilter_operatorName_endsWith,
+  entityFilter_operatorName_equals,
+  entityFilter_operatorName_greaterThan,
+  entityFilter_operatorName_greaterThanOrEqual,
+  entityFilter_operatorName_in,
+  entityFilter_operatorName_lessThan,
+  entityFilter_operatorName_lessThanOrEqual,
+  entityFilter_operatorName_notContains,
+  entityFilter_operatorName_notEquals,
+  entityFilter_operatorName_notIn,
+  entityFilter_operatorName_startsWith,
   expressionDiagnostic_dollarHint_replacement,
   schemaPanel_arrayItemType_description,
   scopeService_outputDescription_fallback,
@@ -35,4 +68,4 @@ export {
   validation_expression_fileExpected_message
 };
 
-//# debugId=078F22BEC23FEC5A64756E2164756E21
+//# debugId=00017AA0E1B2392264756E2164756E21

package/dist/{de-XNTCMP5Z-xfkfqg20.js → de-XNTCMP5Z-nd4scb43.js}

@@ -1,6 +1,3 @@
-import"./packager-tool-hk1gxnth.js";
-import"./packager-tool-1yh8g550.js";
-
 // ../../node_modules/@uipath/flow-migrations/dist/de-XNTCMP5Z.js
 var createMigration_invalidDownInput_message = "Ungültige Eingabe für Abwärtsmigration {{fromVersion}} → {{toVersion}}";
 var createMigration_invalidDownOutput_message = "Ungültige Ausgabe für Abwärtsmigration {{fromVersion}} → {{toVersion}}";
@@ -32,4 +29,4 @@ export {
   migrationValidation_deprecatedNode_message
 };
 
-//# debugId=71505C50F60B9F8564756E2164756E21
+//# debugId=F402BF8FC01B4CB164756E2164756E21

package/dist/debug-conversation-trigger-3wzy90kj.js

@@ -0,0 +1,23 @@
+import {
+  CONVERSATION_TRIGGER_NODE_TYPE2
+} from "./packager-tool-fzgfb0jt.js";
+import"./packager-tool-vgrswa8p.js";
+import"./packager-tool-pxq0bwp0.js";
+import"./packager-tool-8ed52y5r.js";
+import"./packager-tool-ac6rvny7.js";
+import {
+  resolveEntryPointNodeId
+} from "./packager-tool-q0f1dvtd.js";
+import"./packager-tool-jd3v0bh1.js";
+
+// src/commands/debug-conversation-trigger.ts
+function startsOnConversationTrigger(workflow, entryPoint) {
+  const nodes = workflow.nodes ?? [];
+  const startNodeId = resolveEntryPointNodeId(nodes, entryPoint);
+  return nodes.find((node) => node.id === startNodeId)?.type === CONVERSATION_TRIGGER_NODE_TYPE2;
+}
+export {
+  startsOnConversationTrigger
+};
+
+//# debugId=5EE16F00CD4AA30064756E2164756E21

package/dist/debug-http-client-zydr7tna.js

@@ -0,0 +1,31 @@
+import {
+  parseBackendErrorBody2,
+  MaestroHttpError2,
+  automationSolutionsGet2,
+  orchestratorGet2,
+  orchestratorPost2,
+  debugPimsGet2,
+  debugPimsPost2,
+  debugPimsPut2,
+  debugPimsPatch2,
+  studioWebPost2,
+  studioWebDelete2
+} from "./packager-tool-508ka40b.js";
+import"./packager-tool-8ed52y5r.js";
+import"./packager-tool-pxq0bwp0.js";
+import"./packager-tool-vgrswa8p.js";
+export {
+  MaestroHttpError2 as MaestroHttpError,
+  automationSolutionsGet2 as automationSolutionsGet,
+  debugPimsGet2 as debugPimsGet,
+  debugPimsPatch2 as debugPimsPatch,
+  debugPimsPost2 as debugPimsPost,
+  debugPimsPut2 as debugPimsPut,
+  orchestratorGet2 as orchestratorGet,
+  orchestratorPost2 as orchestratorPost,
+  parseBackendErrorBody2 as parseBackendErrorBody,
+  studioWebDelete2 as studioWebDelete,
+  studioWebPost2 as studioWebPost
+};
+
+//# debugId=BD98984956ACE11664756E2164756E21

package/dist/debug-service-hdktqeek.js

@@ -0,0 +1,60 @@
+import {
+  FpsPropertiesInjectionError2,
+  injectInlineAgentProcessEntries2,
+  injectSolutionProjectProcessEntries2,
+  extractStartEventId2,
+  getPersonalFolderKey2,
+  getPersonalFolderInfo2,
+  DebugProvisioningFailedError2,
+  prepareForCustomDebug2,
+  getFolderInfoById2,
+  beginDebugSession2,
+  DEBUG_MODE_MAP2,
+  SIMULATION_MODE_MAP2,
+  createDebugInstance2,
+  DebugPollTimeoutError2,
+  buildPollTimeoutFailureOutput2,
+  pollDebugInstanceStatus2,
+  fetchDebugInstanceIncidents2,
+  DebugVariablesFetchFailedError2,
+  fetchDebugInstanceVariables2,
+  isFaultedDebugStatus2,
+  isSuccessfulDebugStatus2,
+  resolveFaultIncidents2,
+  buildStudioWebDesignerUrl2,
+  uploadAndDebugSolution2,
+  patchConnectionOverwrites2
+} from "./packager-tool-jmrhzfyj.js";
+import"./packager-tool-508ka40b.js";
+import"./packager-tool-8ed52y5r.js";
+import"./packager-tool-pxq0bwp0.js";
+import"./packager-tool-vgrswa8p.js";
+export {
+  DEBUG_MODE_MAP2 as DEBUG_MODE_MAP,
+  DebugPollTimeoutError2 as DebugPollTimeoutError,
+  DebugProvisioningFailedError2 as DebugProvisioningFailedError,
+  DebugVariablesFetchFailedError2 as DebugVariablesFetchFailedError,
+  FpsPropertiesInjectionError2 as FpsPropertiesInjectionError,
+  SIMULATION_MODE_MAP2 as SIMULATION_MODE_MAP,
+  beginDebugSession2 as beginDebugSession,
+  buildPollTimeoutFailureOutput2 as buildPollTimeoutFailureOutput,
+  buildStudioWebDesignerUrl2 as buildStudioWebDesignerUrl,
+  createDebugInstance2 as createDebugInstance,
+  extractStartEventId2 as extractStartEventId,
+  fetchDebugInstanceIncidents2 as fetchDebugInstanceIncidents,
+  fetchDebugInstanceVariables2 as fetchDebugInstanceVariables,
+  getFolderInfoById2 as getFolderInfoById,
+  getPersonalFolderInfo2 as getPersonalFolderInfo,
+  getPersonalFolderKey2 as getPersonalFolderKey,
+  injectInlineAgentProcessEntries2 as injectInlineAgentProcessEntries,
+  injectSolutionProjectProcessEntries2 as injectSolutionProjectProcessEntries,
+  isFaultedDebugStatus2 as isFaultedDebugStatus,
+  isSuccessfulDebugStatus2 as isSuccessfulDebugStatus,
+  patchConnectionOverwrites2 as patchConnectionOverwrites,
+  pollDebugInstanceStatus2 as pollDebugInstanceStatus,
+  prepareForCustomDebug2 as prepareForCustomDebug,
+  resolveFaultIncidents2 as resolveFaultIncidents,
+  uploadAndDebugSolution2 as uploadAndDebugSolution
+};
+
+//# debugId=80165F2915F0572464756E2164756E21

package/dist/edge-service-zck3s9ss.js

@@ -0,0 +1,267 @@
+import"./packager-tool-fzgfb0jt.js";
+import {
+  addEdge2
+} from "./packager-tool-2b0tn4p4.js";
+import"./packager-tool-vgrswa8p.js";
+import"./packager-tool-pxq0bwp0.js";
+import"./packager-tool-8ed52y5r.js";
+import"./packager-tool-ze3fnf3s.js";
+import"./packager-tool-mdf7bws6.js";
+import {
+  readFlowWorkflow2,
+  writeFlowWorkflow2
+} from "./packager-tool-6jpvvxyb.js";
+import {
+  containerBodyPorts
+} from "./packager-tool-7atc775f.js";
+import {
+  ERROR_SOURCE_PORT,
+  enableErrorHandlingForErrorEdges,
+  parseVisibleInputKey,
+  isHandleVisible,
+  applyInstanceSourceHandles,
+  expandHandleIds,
+  isTemplatedHandleId,
+  portMatchesTemplate
+} from "./packager-tool-yewnsyag.js";
+import"./packager-tool-14rdgz3c.js";
+import"./packager-tool-jd3v0bh1.js";
+import"./packager-tool-4g87fbz6.js";
+
+// src/services/edge-service.ts
+function setContainerParentForEdge(workflow, edge) {
+  const nodes = workflow.nodes;
+  const source = nodes.find((n) => n.id === edge.sourceNodeId);
+  const target = nodes.find((n) => n.id === edge.targetNodeId);
+  if (!source || !target || source === target)
+    return;
+  const definitions = workflow.definitions;
+  const definitionOf = (node) => definitions.find((d) => d.nodeType === node.type && d.version === node.typeVersion);
+  if (target.parentId === undefined && containerBodyPorts(definitionOf(source), "source").has(edge.sourcePort)) {
+    target.parentId = source.id;
+  } else if (source.parentId === undefined && containerBodyPorts(definitionOf(target), "target").has(edge.targetPort)) {
+    source.parentId = target.id;
+  }
+}
+var listEdgesInFlow = async (filePath) => {
+  const { workflow } = await readFlowWorkflow2(filePath);
+  const edges = workflow.edges.map((e) => ({
+    id: e.id,
+    source: `${e.sourceNodeId}:${e.sourcePort}`,
+    target: `${e.targetNodeId}:${e.targetPort}`
+  }));
+  return { edges, count: edges.length };
+};
+var FLOW_HANDLE_TYPE = {
+  source: "output",
+  target: "input"
+};
+var CONVENTIONAL_PORT = {
+  source: "output",
+  target: "input"
+};
+
+class EdgeError extends Error {
+  errorCode;
+  constructor(message, errorCode = "invalid_argument") {
+    super(message);
+    this.errorCode = errorCode;
+    this.name = "EdgeError";
+  }
+}
+var listPorts = ({ ports, templates }) => [...ports.keys(), ...templates.map((t) => t.templateId)].join(", ");
+var getNodePorts = (workflow, nodeId, direction, requested) => {
+  const nodes = workflow.nodes;
+  const node = nodes.find((n) => n.id === nodeId);
+  if (!node) {
+    throw new EdgeError(`Node not found: "${nodeId}".`, "not_found");
+  }
+  const definitions = workflow.definitions;
+  const key = `${node.type}:${node.typeVersion}`;
+  const definition = definitions.find((d) => `${d.nodeType}:${d.version}` === key);
+  if (!definition) {
+    throw new EdgeError(`No definition found for node "${nodeId}" (type: ${key}). The flow's "definitions" array must include a matching entry.`, "not_found");
+  }
+  if (!definition.handleConfiguration?.length) {
+    throw new EdgeError(`Node "${nodeId}" (type: ${key}) has no "handleConfiguration" in its definition. Cannot validate ${direction} port.`);
+  }
+  const handles = {
+    source: new Map,
+    sourceTemplates: []
+  };
+  for (const group of definition.handleConfiguration) {
+    for (const handle of group.handles) {
+      if (handle.type !== direction)
+        continue;
+      const info = {
+        position: group.position,
+        handleType: handle.handleType,
+        isDefaultForType: handle.isDefaultForType,
+        visible: handle.visible,
+        declared: true
+      };
+      for (const id of expandHandleIds(handle, node)) {
+        if (isTemplatedHandleId(id)) {
+          handles.sourceTemplates.push({ templateId: id, info });
+        } else {
+          handles.source.set(id, info);
+        }
+      }
+    }
+  }
+  if (direction === "source") {
+    if (definition.supportsErrorHandling === true && !handles.source.has(ERROR_SOURCE_PORT)) {
+      handles.source.set(ERROR_SOURCE_PORT, {
+        handleType: FLOW_HANDLE_TYPE.source,
+        declared: true
+      });
+    }
+    applyInstanceSourceHandles(handles, node, { deriveOutcomes: true });
+  }
+  const shown = (id, info) => direction === "target" || id === ERROR_SOURCE_PORT || isHandleVisible(info, node);
+  const nodePorts = {
+    ports: new Map([...handles.source].filter(([id, info]) => shown(id, info))),
+    templates: handles.sourceTemplates.filter((t) => shown(t.templateId, t.info)),
+    hiddenPorts: new Map([...handles.source].filter(([id, info]) => !shown(id, info))),
+    hiddenTemplates: handles.sourceTemplates.filter((t) => !shown(t.templateId, t.info))
+  };
+  if (nodePorts.ports.size === 0 && nodePorts.templates.length === 0) {
+    if (requested !== undefined && (nodePorts.hiddenPorts.has(requested) || nodePorts.hiddenTemplates.some((t) => portMatchesTemplate(requested, t.templateId)))) {
+      return nodePorts;
+    }
+    const hidden = [
+      ...handles.source.values(),
+      ...handles.sourceTemplates.map((t) => t.info)
+    ];
+    if (hidden.length === 0) {
+      throw new EdgeError(`Node "${nodeId}" (type: ${key}) has no ${direction} handles defined.`);
+    }
+    const gates = [
+      ...new Set(hidden.flatMap((info) => {
+        const input = parseVisibleInputKey("visible" in info ? info.visible : undefined);
+        return input === null ? [] : [`inputs.${input}`];
+      }))
+    ];
+    throw new EdgeError(gates.length > 0 ? `Node "${nodeId}" (type: ${key}) has no visible ${direction} handles: they show only when ${gates.join(" or ")} is true. Run "uip maestro flow format" or set ${gates.join(" or ")} to true on the node, then retry.` : `Node "${nodeId}" (type: ${key}) has no visible ${direction} handles. Check its handle configuration and visibility gates.`);
+  }
+  return nodePorts;
+};
+var resolveDefaultPort = (nodeId, direction, nodePorts, handleType) => {
+  const compatiblePorts = [...nodePorts.ports].filter(([id, info]) => id !== ERROR_SOURCE_PORT && (info.handleType ?? FLOW_HANDLE_TYPE[direction]) === handleType);
+  const allDeclared = compatiblePorts.every(([, info]) => info.declared === true);
+  const port = (allDeclared ? compatiblePorts.find(([, info]) => info.isDefaultForType === true) ?? compatiblePorts.find(([id]) => id === CONVENTIONAL_PORT[direction]) : undefined) ?? (compatiblePorts.length === 1 && !nodePorts.templates.some((template) => (template.info.handleType ?? FLOW_HANDLE_TYPE[direction]) === handleType) ? compatiblePorts[0] : undefined);
+  if (port) {
+    return port[0];
+  }
+  throw new EdgeError(`Node "${nodeId}" has no default ${direction} port. Pass --${direction}-port with one of: ${listPorts(nodePorts)}`);
+};
+var resolvePort = (workflow, nodeId, direction, requested, source) => {
+  const nodePorts = getNodePorts(workflow, nodeId, direction, requested);
+  const defaultHandleType = direction === "target" && source !== undefined ? source.handleType === FLOW_HANDLE_TYPE.source ? FLOW_HANDLE_TYPE.target : source.handleType : FLOW_HANDLE_TYPE[direction];
+  if (direction === "target" && requested === undefined && source) {
+    const availableByType = new Map;
+    for (const [id, info] of [
+      ...nodePorts.ports,
+      ...nodePorts.templates.map((template) => [
+        template.templateId,
+        template.info
+      ])
+    ]) {
+      const type = info.handleType ?? FLOW_HANDLE_TYPE.target;
+      availableByType.set(type, [
+        ...availableByType.get(type) ?? [],
+        id
+      ]);
+    }
+    if (!availableByType.has(defaultHandleType)) {
+      const available = [...availableByType].map(([type, ids]) => `${type}: ${ids.join(", ")}`).join("; ");
+      const sourceTypes = [
+        ...new Set([...availableByType.keys()].map((type) => type === FLOW_HANDLE_TYPE.target ? FLOW_HANDLE_TYPE.source : type))
+      ];
+      const sourcePorts = getNodePorts(workflow, source.nodeId, "source", undefined);
+      const compatibleSourcePorts = [...sourcePorts.ports].filter(([id, info]) => id !== ERROR_SOURCE_PORT && sourceTypes.includes(info.handleType ?? FLOW_HANDLE_TYPE.source)).map(([id]) => id);
+      const compatibleSourcePatterns = sourcePorts.templates.filter((template) => sourceTypes.includes(template.info.handleType ?? FLOW_HANDLE_TYPE.source)).map((template) => template.templateId);
+      const nextStep = compatibleSourcePorts.length > 0 ? `Pass --source-port with one of: ${compatibleSourcePorts.join(", ")} on "${source.nodeId}".` : compatibleSourcePatterns.length > 0 ? `Pass --source-port on "${source.nodeId}" with a concrete port matching: ${compatibleSourcePatterns.join(", ")}.` : `No visible source port on "${source.nodeId}" matches the target handle types. Choose a source node with a compatible port or a target node with handle type ${defaultHandleType}.`;
+      throw new EdgeError(`Node "${nodeId}" has no ${defaultHandleType} target port for source port "${source.id}" (${source.handleType}). Available target ports: ${available}. ${nextStep}`);
+    }
+  }
+  const port = requested ?? resolveDefaultPort(nodeId, direction, nodePorts, defaultHandleType);
+  const info = nodePorts.ports.get(port) ?? nodePorts.templates.find((t) => portMatchesTemplate(port, t.templateId))?.info;
+  if (!info) {
+    const hidden = nodePorts.hiddenPorts.get(port) ?? nodePorts.hiddenTemplates.find((t) => portMatchesTemplate(port, t.templateId))?.info;
+    if (hidden) {
+      const gate = parseVisibleInputKey(hidden.visible);
+      throw new EdgeError(gate === null ? `Source port "${port}" is hidden on node "${nodeId}". Check its handle configuration and visibility gate.` : `Source port "${port}" is hidden on node "${nodeId}" until inputs.${gate} is true. Run "uip maestro flow format" or set inputs.${gate} to true on the source node, then retry.`);
+    }
+    const side = direction === "source" ? "Source" : "Target";
+    throw new EdgeError(`${side} port "${port}" not found on node "${nodeId}". Available ${direction} ports: ${listPorts(nodePorts)}`);
+  }
+  return {
+    id: port,
+    handleType: info.handleType ?? FLOW_HANDLE_TYPE[direction]
+  };
+};
+var addEdgeToFlow = async (filePath, sourceId, targetId, options = {}) => {
+  const { workflow, refMap } = await readFlowWorkflow2(filePath);
+  const nodeIds = new Set(workflow.nodes.map((n) => n.id));
+  if (!nodeIds.has(sourceId)) {
+    const available = [...nodeIds].join(", ") || "(none)";
+    throw new EdgeError(`Source node not found: "${sourceId}". Available node IDs: ${available}`, "not_found");
+  }
+  if (!nodeIds.has(targetId)) {
+    const available = [...nodeIds].join(", ") || "(none)";
+    throw new EdgeError(`Target node not found: "${targetId}". Available node IDs: ${available}`, "not_found");
+  }
+  const sourcePort = resolvePort(workflow, sourceId, "source", options.sourcePort);
+  const targetPort = resolvePort(workflow, targetId, "target", options.targetPort, { ...sourcePort, nodeId: sourceId });
+  const resolvedSourcePort = sourcePort.id;
+  const resolvedTargetPort = targetPort.id;
+  const existingEdges = workflow.edges;
+  const duplicate = existingEdges.find((e) => e.sourceNodeId === sourceId && e.sourcePort === resolvedSourcePort && e.targetNodeId === targetId && e.targetPort === resolvedTargetPort);
+  if (duplicate) {
+    const updated = enableErrorHandlingForErrorEdges(workflow.nodes, [duplicate]);
+    if (updated > 0) {
+      await writeFlowWorkflow2(filePath, workflow, refMap);
+    }
+    const existingEdge = {
+      id: duplicate.id,
+      sourceNodeId: duplicate.sourceNodeId,
+      sourcePort: duplicate.sourcePort,
+      targetNodeId: duplicate.targetNodeId,
+      targetPort: duplicate.targetPort
+    };
+    return { edge: existingEdge, alreadyExists: true };
+  }
+  const edge = addEdge2(workflow, {
+    source: sourceId,
+    target: targetId,
+    sourcePort: resolvedSourcePort,
+    targetPort: resolvedTargetPort
+  });
+  if (resolvedSourcePort === ERROR_SOURCE_PORT) {
+    enableErrorHandlingForErrorEdges(workflow.nodes, [
+      edge
+    ]);
+  }
+  setContainerParentForEdge(workflow, edge);
+  await writeFlowWorkflow2(filePath, workflow, refMap);
+  return { edge };
+};
+var deleteEdgeFromFlow = async (filePath, edgeId) => {
+  const { workflow, refMap } = await readFlowWorkflow2(filePath);
+  const edges = workflow.edges;
+  const edgeToDelete = edges.find((e) => e.id === edgeId);
+  if (!edgeToDelete) {
+    throw new Error(`Edge "${edgeId}" not found. Use 'uip maestro flow edges list' to see available edges.`);
+  }
+  workflow.edges = edges.filter((e) => e.id !== edgeId);
+  await writeFlowWorkflow2(filePath, workflow, refMap);
+  return { deletedEdge: edgeToDelete };
+};
+export {
+  addEdgeToFlow,
+  deleteEdgeFromFlow,
+  listEdgesInFlow
+};
+
+//# debugId=9F62968D80F37B9C64756E2164756E21