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

package/dist/packager-tool-v2rkcehq.js

@@ -0,0 +1,457 @@
+import {
+  regenerateBindingsFile
+} from "./packager-tool-v86fdwvs.js";
+import {
+  getConnectorInfo,
+  getNode,
+  isConnectorNode
+} from "./packager-tool-v9psxdy5.js";
+import {
+  isKnownSdkNodeType
+} from "./packager-tool-7exrv6w7.js";
+import {
+  readFlowWorkflow,
+  writeFlowWorkflow
+} from "./packager-tool-94w17vf8.js";
+import {
+  addBinding,
+  addNode,
+  createBinding,
+  generateNodeIdAndName
+} from "./packager-tool-tn5e7wnb.js";
+import {
+  catchError,
+  logger
+} from "./packager-tool-5qaxht3k.js";
+import {
+  getFileSystem
+} from "./packager-tool-0v3s8r01.js";
+
+// src/services/node-service.ts
+class NodeTypeNotFoundError extends Error {
+  code = "NodeTypeNotFound";
+  instructions;
+  constructor(message, instructions) {
+    super(message);
+    this.name = "NodeTypeNotFoundError";
+    this.instructions = instructions;
+  }
+}
+
+class NodeTypeNotEnabledError extends Error {
+  code = "NodeTypeNotEnabled";
+  instructions;
+  constructor(message, instructions) {
+    super(message);
+    this.name = "NodeTypeNotEnabledError";
+    this.instructions = instructions;
+  }
+}
+
+class SourceRequiredError extends Error {
+  code = "SourceRequired";
+  instructions;
+  constructor(message, instructions) {
+    super(message);
+    this.name = "SourceRequiredError";
+    this.instructions = instructions;
+  }
+}
+var listNodesInFlow = async (filePath) => {
+  const { workflow } = await readFlowWorkflow(filePath);
+  const nodes = workflow.nodes.map((n) => ({
+    id: n.id,
+    type: n.type,
+    label: n.display.label ?? "",
+    position: n.ui.position
+  }));
+  return { nodes, count: nodes.length };
+};
+var PROCESS_NODE_PREFIXES = [
+  "uipath.core.rpa-workflow.",
+  "uipath.agent.resource.tool.process.",
+  "uipath.core.agent.",
+  "uipath.core.api-workflow."
+];
+function isProcessNode(manifest) {
+  return PROCESS_NODE_PREFIXES.some((prefix) => manifest.nodeType?.startsWith(prefix));
+}
+function extractProcessGuid(nodeType) {
+  const match = nodeType.match(/^(?:uipath\.core\.rpa-workflow|uipath\.agent\.resource\.tool\.process|uipath\.core\.agent|uipath\.core\.api-workflow)\.([0-9a-f-]+)$/i);
+  if (!match) {
+    throw new Error(`Invalid process node type: "${nodeType}". ` + "Expected a known prefix followed by a process GUID.");
+  }
+  return match[1];
+}
+function resolveProcessTarget(node, definitions) {
+  if (!isProcessNode({ nodeType: node.type }))
+    return;
+  let subType = "Process";
+  if (definitions) {
+    const sameType = definitions.filter((d) => d.nodeType === node.type);
+    const def = sameType.find((d) => node.typeVersion !== undefined && d.version === node.typeVersion) ?? sameType[0];
+    const model = def?.model;
+    const defBindings = model?.bindings;
+    if (defBindings?.resourceSubType)
+      subType = defBindings.resourceSubType;
+    if (defBindings?.resourceKey) {
+      return { key: defBindings.resourceKey, subType };
+    }
+  }
+  return { key: extractProcessGuid(node.type), subType };
+}
+function resolveProcessTargetKey(node, definitions) {
+  return resolveProcessTarget(node, definitions)?.key;
+}
+function createProcessBindings(manifest) {
+  const processGuid = extractProcessGuid(manifest.nodeType);
+  const model = manifest.model;
+  const rawValues = model?.bindings?.values;
+  let processName;
+  let folderPath;
+  if (Array.isArray(rawValues)) {
+    processName = rawValues.find((v) => v.propertyAttribute === "name")?.default ?? "";
+    folderPath = rawValues.find((v) => v.propertyAttribute === "folderPath")?.default;
+  } else {
+    processName = rawValues?.name ?? "";
+    folderPath = rawValues?.folderPath;
+  }
+  if (folderPath == null) {
+    throw new Error("Manifest is missing model.bindings.values.folderPath. " + "Cannot create process bindings without a folder path.");
+  }
+  const subType = model?.bindings?.resourceSubType ?? "Process";
+  const resourceKey = model?.bindings?.resourceKey ?? processGuid;
+  const nameBinding = createBinding({
+    name: "name",
+    value: processName,
+    resource: "process",
+    resourceKey,
+    propertyAttribute: "name",
+    resourceSubType: subType
+  });
+  const folderBinding = createBinding({
+    name: "folderPath",
+    value: folderPath,
+    resource: "process",
+    resourceKey,
+    propertyAttribute: "folderPath",
+    resourceSubType: subType
+  });
+  if (folderPath === "" && folderBinding.default === undefined) {
+    folderBinding.default = "";
+  }
+  return { nameBinding, folderBinding };
+}
+function resolveProcessBindingsInContext(node, nameBinding, folderBinding) {
+  const model = node.model;
+  if (!model?.context)
+    return;
+  for (const entry of model.context) {
+    if (entry.name === "name" && typeof entry.value === "string") {
+      entry.default = nameBinding.default;
+      entry.value = `=bindings.${nameBinding.id}`;
+    } else if (entry.name === "folderPath" && typeof entry.value === "string") {
+      entry.default = folderBinding.default;
+      entry.value = `=bindings.${folderBinding.id}`;
+    }
+  }
+}
+var UNRESOLVED_BINDING_PATTERN = /^<bindings\.\w+>$/;
+function ensureProcessBindings(workflow) {
+  const nodes = workflow.nodes;
+  const definitions = workflow.definitions ?? [];
+  let bindingsCreated = 0;
+  for (const node of nodes) {
+    if (!isProcessNode({ nodeType: node.type }))
+      continue;
+    const nodeModel = node.model;
+    const defModel = definitions.find((d) => d.nodeType === node.type)?.model;
+    const hasUnresolved = [nodeModel, defModel].some((m) => m?.context?.some((entry) => typeof entry.value === "string" && UNRESOLVED_BINDING_PATTERN.test(entry.value)));
+    if (!hasUnresolved)
+      continue;
+    const definition = definitions.find((d) => d.nodeType === node.type);
+    if (!definition)
+      continue;
+    const [err, bindings] = catchError(() => createProcessBindings(definition));
+    if (err) {
+      logger.warn(`Skipping binding resolution for node "${node.id}": ${err.message}`);
+      continue;
+    }
+    const { nameBinding, folderBinding } = bindings;
+    const beforeCount = workflow.bindings?.length ?? 0;
+    addBinding(workflow, nameBinding);
+    addBinding(workflow, folderBinding);
+    const storedBindings = workflow.bindings;
+    const storedName = storedBindings.find((b) => b.resourceKey === nameBinding.resourceKey && b.propertyAttribute === nameBinding.propertyAttribute) ?? nameBinding;
+    const storedFolder = storedBindings.find((b) => b.resourceKey === folderBinding.resourceKey && b.propertyAttribute === folderBinding.propertyAttribute) ?? folderBinding;
+    resolveProcessBindingsInContext(node, storedName, storedFolder);
+    if (defModel?.context) {
+      for (const entry of defModel.context) {
+        if (entry.name === "name" && typeof entry.value === "string" && UNRESOLVED_BINDING_PATTERN.test(entry.value)) {
+          entry.default = storedName.default;
+          entry.value = `=bindings.${storedName.id}`;
+        } else if (entry.name === "folderPath" && typeof entry.value === "string" && UNRESOLVED_BINDING_PATTERN.test(entry.value)) {
+          entry.default = storedFolder.default;
+          entry.value = `=bindings.${storedFolder.id}`;
+        }
+      }
+    }
+    const added = (workflow.bindings?.length ?? 0) - beforeCount;
+    bindingsCreated += added;
+    logger.info(`Resolved process bindings for node "${node.id}" (${node.type})`);
+  }
+  if (bindingsCreated > 0) {
+    logger.info(`ensureProcessBindings: created ${bindingsCreated} binding(s) for directly-authored nodes`);
+  }
+  return bindingsCreated;
+}
+var BINDING_REF_PATTERN = /^=bindings\.(.+)$/;
+function collectNodeBindingRefs(node) {
+  const refs = new Set;
+  if (node.inputs) {
+    for (const value of Object.values(node.inputs)) {
+      if (typeof value === "string") {
+        const match = value.match(BINDING_REF_PATTERN);
+        if (match)
+          refs.add(match[1]);
+      }
+    }
+  }
+  return refs;
+}
+function collectNodeBindingResourceKeys(node, bindings, definitions) {
+  const keys = new Set;
+  const processKey = resolveProcessTargetKey(node, definitions);
+  if (processKey) {
+    keys.add(processKey);
+  }
+  const inputs = node.inputs;
+  if (typeof inputs?.detail?.connectionResourceId === "string") {
+    keys.add(inputs.detail.connectionResourceId);
+  }
+  const refs = collectNodeBindingRefs(node);
+  for (const binding of bindings) {
+    if (refs.has(binding.id)) {
+      keys.add(binding.resourceKey);
+    }
+  }
+  return keys;
+}
+var addNodeToFlow = async (filePath, nodeType, options = {}) => {
+  const [registryErr, registryManifest] = await catchError(getNode(nodeType));
+  let manifest = registryManifest ?? null;
+  if (registryErr) {
+    logger.debug(`Registry node lookup failed for ${nodeType}: ${registryErr.message}`);
+  }
+  let localErr = null;
+  if (!manifest) {
+    const [err, localManifest] = await catchError(getNode(nodeType, { local: true }));
+    manifest = localManifest ?? null;
+    if (err) {
+      localErr = err;
+      logger.warn(`In-solution node lookup failed for ${nodeType}: ${err.message}`);
+    }
+  }
+  if (!manifest) {
+    if (isKnownSdkNodeType(nodeType)) {
+      throw new NodeTypeNotEnabledError(`Node type '${nodeType}' is not enabled for this tenant.`, "Ask an admin to enable the feature flag for this node type, " + "or run `uip maestro flow registry list` to see every " + "known type with its `AvailableOnTenant` flag.");
+    }
+    const details = [
+      registryErr && `Registry lookup failed: ${registryErr.message}`,
+      localErr && `In-solution lookup failed: ${localErr.message}`
+    ].filter(Boolean).join(". ");
+    const hint = details || "If this is an in-solution node, make sure you are running " + "from inside a solution directory (with a .uipx file in CWD, parent, or grandparent).";
+    throw new NodeTypeNotFoundError(`Node type not found: ${nodeType}. ${hint}`, "Run `uip maestro flow registry search <keyword>` to find the " + "correct node type, or `uip maestro flow registry list` " + "to see every known type (including ones not enabled on this tenant).");
+  }
+  if (manifest.model?.source === true) {
+    const fromFlag = typeof options.source === "string" && options.source.length > 0;
+    const inputsSourceCandidate = options.inputs?.source;
+    const fromInputs = typeof inputsSourceCandidate === "string" && inputsSourceCandidate.length > 0;
+    if (!fromFlag && !fromInputs) {
+      throw new SourceRequiredError(`Node type "${nodeType}" requires a source UUID at inputs.source. Pass --source <uuid>.`, "Use the agent's ProjectId (returned by " + '`uip agent init "<flow-dir>" --inline-in-flow`) for inline ' + "agent nodes, or the resource id declared in the parent " + "inline agent's `resources[]` for agent-tool resource nodes. " + '`--input \'{"source":"<uuid>"}\'` is also accepted.');
+    }
+  }
+  const { workflow, refMap } = await readFlowWorkflow(filePath);
+  const existingIds = new Set(workflow.nodes.map((n) => n.id));
+  const existingDefCount = workflow.definitions.length;
+  const { id, displayName } = generateNodeIdAndName(options.label ?? manifest.display.label, existingIds);
+  const bindingsBefore = workflow.bindings?.length ?? 0;
+  const node = addNode(workflow, manifest, id, options.position ?? { x: 0, y: 0 }, options.label ?? displayName);
+  const schema = manifest.inputDefinition;
+  if (manifest.inputDefaults === undefined && schema?.type === "object") {
+    for (const schemaKey of Object.keys(schema)) {
+      delete node.inputs[schemaKey];
+    }
+  }
+  let bindingsCreated = 0;
+  if (isProcessNode(manifest)) {
+    const { nameBinding, folderBinding } = createProcessBindings(manifest);
+    addBinding(workflow, nameBinding);
+    addBinding(workflow, folderBinding);
+    const storedBindings = workflow.bindings;
+    const storedName = storedBindings.find((b) => b.resourceKey === nameBinding.resourceKey && b.propertyAttribute === nameBinding.propertyAttribute) ?? nameBinding;
+    const storedFolder = storedBindings.find((b) => b.resourceKey === folderBinding.resourceKey && b.propertyAttribute === folderBinding.propertyAttribute) ?? folderBinding;
+    if (folderBinding.default === "" && storedFolder.default === undefined) {
+      storedFolder.default = "";
+    }
+    resolveProcessBindingsInContext(node, storedName, storedFolder);
+    bindingsCreated = (workflow.bindings?.length ?? 0) - bindingsBefore;
+  }
+  if (options.inputs && Object.keys(options.inputs).length > 0) {
+    node.inputs = { ...node.inputs ?? {}, ...options.inputs };
+  }
+  const manifestModel = manifest.model;
+  if (manifestModel?.source === true) {
+    if (typeof options.source === "string" && options.source.length > 0) {
+      const inputs = node.inputs ?? {};
+      inputs.source = options.source;
+      node.inputs = inputs;
+    }
+    if (node.model) {
+      delete node.model;
+    }
+  }
+  if (typeof options.parent === "string" && options.parent.length > 0) {
+    const allNodes = workflow.nodes;
+    if (!allNodes.some((n) => n.id === options.parent)) {
+      throw new Error(`--parent value "${options.parent}" is not an existing node id in this flow. ` + "Run 'uip maestro flow node list <file>' to see valid ids.");
+    }
+    node.parentId = options.parent;
+  }
+  await writeFlowWorkflow(filePath, workflow, refMap);
+  if (isProcessNode(manifest)) {
+    const fs = getFileSystem();
+    const [regenErr] = await catchError(regenerateBindingsFile(fs, filePath));
+    if (regenErr) {
+      logger.warn(`Failed to regenerate bindings_v2.json after adding ${manifest.nodeType}: ${regenErr.message}`);
+    }
+  }
+  const definitionAdded = workflow.definitions.length > existingDefCount;
+  const variableCount = workflow.variables?.nodes?.length ?? 0;
+  if (isConnectorNode(manifest)) {
+    const connInfo = getConnectorInfo(manifest);
+    return {
+      node,
+      definitionAdded,
+      bindingsCreated,
+      variableCount,
+      connectorInfo: connInfo ?? undefined
+    };
+  } else {
+    return { node, definitionAdded, bindingsCreated, variableCount };
+  }
+};
+function removeConnectedEdges(workflow, nodeId) {
+  const edges = workflow.edges ?? [];
+  const before = edges.length;
+  workflow.edges = edges.filter((e) => e.sourceNodeId !== nodeId && e.targetNodeId !== nodeId);
+  return before - workflow.edges.length;
+}
+function removeOrphanedBindings(workflow, deletedNodeKeys, remainingNodes, bindings) {
+  if (deletedNodeKeys.size === 0 || bindings.length === 0)
+    return 0;
+  const defs = workflow.definitions ?? [];
+  const remainingKeys = new Set;
+  for (const node of remainingNodes) {
+    for (const key of collectNodeBindingResourceKeys(node, bindings, defs)) {
+      remainingKeys.add(key);
+    }
+  }
+  const before = bindings.length;
+  workflow.bindings = bindings.filter((b) => !deletedNodeKeys.has(b.resourceKey) || remainingKeys.has(b.resourceKey));
+  return before - workflow.bindings.length;
+}
+function connectorConnectionBindingName(node, definitions) {
+  if (!node.type.startsWith("uipath.connector"))
+    return "";
+  const def = definitions.find((d) => d.nodeType === node.type);
+  const context = def?.model?.context;
+  const connectorKey = context?.find((c) => c.name === "connectorKey")?.value;
+  return typeof connectorKey === "string" && connectorKey.length > 0 ? `${connectorKey} connection` : "";
+}
+function removeOrphanedConnectorStub(workflow, deletedNode, remainingNodes, definitions) {
+  const stubName = connectorConnectionBindingName(deletedNode, definitions);
+  if (!stubName)
+    return 0;
+  const stillOwned = remainingNodes.some((n) => connectorConnectionBindingName(n, definitions) === stubName);
+  if (stillOwned)
+    return 0;
+  const bindings = workflow.bindings ?? [];
+  if (bindings.length === 0)
+    return 0;
+  const before = bindings.length;
+  workflow.bindings = bindings.filter((b) => !(b.resource?.toLowerCase() === "connection" && b.propertyAttribute === "ConnectionId" && !b.resourceKey && !b.default && b.name === stubName));
+  return before - workflow.bindings.length;
+}
+function removeOrphanedDefinitions(workflow, remainingNodes) {
+  const definitions = workflow.definitions ?? [];
+  const usedKeys = new Set(remainingNodes.map((n) => `${n.type}:${n.typeVersion}`));
+  const before = definitions.length;
+  workflow.definitions = definitions.filter((d) => usedKeys.has(`${d.nodeType}:${d.version}`));
+  return before - workflow.definitions.length;
+}
+function removeVariableUpdates(workflow, nodeId) {
+  const variables = workflow.variables;
+  if (!variables?.variableUpdates)
+    return 0;
+  const updates = variables.variableUpdates[nodeId];
+  if (!updates)
+    return 0;
+  const count = updates.length;
+  delete variables.variableUpdates[nodeId];
+  return count;
+}
+function removeNodeVariables(workflow, nodeId) {
+  const variables = workflow.variables;
+  if (!variables?.nodes)
+    return 0;
+  const before = variables.nodes.length;
+  variables.nodes = variables.nodes.filter((v) => v.binding.nodeId !== nodeId);
+  return before - variables.nodes.length;
+}
+var deleteNodeFromFlow = async (filePath, nodeId) => {
+  const { workflow, refMap } = await readFlowWorkflow(filePath);
+  const nodes = workflow.nodes;
+  const nodeIndex = nodes.findIndex((n) => n.id === nodeId);
+  if (nodeIndex === -1) {
+    const available = nodes.map((n) => n.id).join(", ") || "(none)";
+    throw new Error(`Node not found: "${nodeId}". Available node IDs: ${available}`);
+  }
+  const targetNode = nodes[nodeIndex];
+  const deletedWasProcessNode = isProcessNode({ nodeType: targetNode.type });
+  const deletedNode = {
+    id: targetNode.id,
+    type: targetNode.type,
+    label: targetNode.display.label ?? "",
+    position: targetNode.ui.position
+  };
+  const bindings = workflow.bindings ?? [];
+  const definitions = workflow.definitions ?? [];
+  const deletedNodeResourceKeys = collectNodeBindingResourceKeys(targetNode, bindings, definitions);
+  nodes.splice(nodeIndex, 1);
+  const edgesRemoved = removeConnectedEdges(workflow, nodeId);
+  const bindingsRemoved = removeOrphanedBindings(workflow, deletedNodeResourceKeys, nodes, bindings) + removeOrphanedConnectorStub(workflow, targetNode, nodes, definitions);
+  const definitionsRemoved = removeOrphanedDefinitions(workflow, nodes);
+  const variablesRemoved = removeNodeVariables(workflow, nodeId);
+  const variableUpdatesRemoved = removeVariableUpdates(workflow, nodeId);
+  await writeFlowWorkflow(filePath, workflow, refMap);
+  if (deletedWasProcessNode || bindingsRemoved > 0) {
+    const fs = getFileSystem();
+    const [regenErr] = await catchError(regenerateBindingsFile(fs, filePath));
+    if (regenErr) {
+      logger.warn(`Failed to regenerate bindings_v2.json after deleting ${targetNode.type}: ${regenErr.message}`);
+    }
+  }
+  return {
+    deletedNode,
+    edgesRemoved,
+    bindingsRemoved,
+    definitionsRemoved,
+    variablesRemoved,
+    variableUpdatesRemoved
+  };
+};
+
+export { NodeTypeNotFoundError, NodeTypeNotEnabledError, SourceRequiredError, listNodesInFlow, PROCESS_NODE_PREFIXES, isProcessNode, resolveProcessTarget, resolveProcessTargetKey, ensureProcessBindings, collectNodeBindingResourceKeys, addNodeToFlow, deleteNodeFromFlow };
+
+//# debugId=77D74C5CA8BE20AA64756E2164756E21