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

package/dist/packager-tool-rqvr63x5.js

@@ -0,0 +1,1217 @@
+import {
+  resolveMaestroRegistry
+} from "./packager-tool-885mmrvr.js";
+import {
+  ConnectionsApi,
+  ElementsApi,
+  createApiClient,
+  getConnectorActivityMetadataV4,
+  isV4ActivityConfiguration
+} from "./packager-tool-mp59jtpm.js";
+import {
+  MANIFEST_FEATURE_FLAGS,
+  ManifestClient,
+  extractIOFromEntryPoints,
+  getServiceType,
+  listKnownSdkNodes,
+  taskDefinitionsToNodeManifests
+} from "./packager-tool-jhdf8gt1.js";
+import {
+  getLoginStatusAsync
+} from "./packager-tool-dqs5qy9s.js";
+import {
+  UIPATH_HOME_DIR,
+  catchError,
+  hashContent,
+  logger
+} from "./packager-tool-5ax2ywcg.js";
+import {
+  getFileSystem
+} from "./packager-tool-0v3s8r01.js";
+
+// ../maestro-sdk/src/registry/filter-engine.ts
+function filterNodes(nodes, parsedFilters) {
+  if (!parsedFilters.filters || parsedFilters.filters.length === 0) {
+    return nodes;
+  }
+  return nodes.filter((node) => {
+    if (parsedFilters.logic === "AND") {
+      return parsedFilters.filters.every((condition) => matchesCondition(node, condition));
+    } else {
+      return parsedFilters.filters.some((condition) => matchesCondition(node, condition));
+    }
+  });
+}
+function matchesCondition(node, condition) {
+  const fieldValue = getFieldValue(node, condition.field);
+  if (fieldValue === null || fieldValue === undefined) {
+    return false;
+  }
+  const searchValue = condition.value.toString().toLowerCase();
+  if (Array.isArray(fieldValue)) {
+    return matchesArrayField(fieldValue, condition.operator, searchValue);
+  }
+  const fieldString = fieldValue.toString().toLowerCase();
+  switch (condition.operator) {
+    case "equals":
+      return fieldString === searchValue;
+    case "contains":
+      return fieldString.includes(searchValue);
+    case "startsWith":
+      return fieldString.startsWith(searchValue);
+    case "endsWith":
+      return fieldString.endsWith(searchValue);
+    case "in": {
+      const values = searchValue.split(",").map((v) => v.trim());
+      return values.includes(fieldString);
+    }
+    default:
+      return fieldString === searchValue;
+  }
+}
+function matchesArrayField(arrayValue, operator, searchValue) {
+  const lowerArray = arrayValue.map((v) => v.toLowerCase());
+  switch (operator) {
+    case "equals":
+      return lowerArray.includes(searchValue);
+    case "contains":
+      return lowerArray.some((tag) => tag.includes(searchValue));
+    case "in": {
+      const values = searchValue.split(",").map((v) => v.trim());
+      return lowerArray.some((tag) => values.includes(tag));
+    }
+    default:
+      return lowerArray.includes(searchValue);
+  }
+}
+function getFieldValue(node, field) {
+  switch (field) {
+    case "category":
+      return node.category;
+    case "type":
+    case "nodetype":
+      return node.nodeType;
+    case "tags":
+      return node.tags;
+    case "displayname":
+      return node.display?.label;
+    case "description":
+      return node.description ?? node.display?.description;
+    default:
+      return node[field];
+  }
+}
+function searchWithFilters(nodes, keyword, filters) {
+  let results = nodes;
+  if (filters && filters.filters.length > 0) {
+    results = filterNodes(results, filters);
+  }
+  if (keyword && keyword.trim() !== "") {
+    const lowerKeyword = keyword.toLowerCase();
+    results = results.filter((node) => {
+      if (node.nodeType?.toLowerCase().includes(lowerKeyword)) {
+        return true;
+      }
+      if (node.category?.toLowerCase().includes(lowerKeyword)) {
+        return true;
+      }
+      if (node.tags?.some((tag) => tag.toLowerCase().includes(lowerKeyword))) {
+        return true;
+      }
+      if (node.display?.label?.toLowerCase().includes(lowerKeyword)) {
+        return true;
+      }
+      if (node.description?.toString().toLowerCase().includes(lowerKeyword)) {
+        return true;
+      }
+      if (node.display?.description?.toLowerCase().includes(lowerKeyword)) {
+        return true;
+      }
+      return false;
+    });
+  }
+  return results;
+}
+
+// ../maestro-sdk/src/registry/integration-service-fetcher.ts
+function parseContext(node) {
+  const context = node.model?.context;
+  if (!Array.isArray(context))
+    return null;
+  const connectorKey = context.find((c) => c.name === "connectorKey")?.value;
+  const objectName = context.find((c) => c.name === "objectName")?.value;
+  const method = context.find((c) => c.name === "method")?.value ?? "POST";
+  const operation = context.find((c) => c.name === "operation")?.value;
+  if (!connectorKey || !objectName)
+    return null;
+  return { connectorKey, objectName, method, operation };
+}
+function applyOptionalFieldProps(compact, field) {
+  if (field.enum?.length)
+    compact.enum = field.enum;
+  if (field.reference) {
+    compact.reference = {
+      objectName: field.reference.objectName,
+      lookupValue: field.reference.lookupValue,
+      lookupNames: field.reference.lookupNames,
+      path: field.reference.path,
+      childPath: field.reference.childPath
+    };
+  }
+}
+function extractFields(metadata, method, requestOnly) {
+  const fieldsObj = metadata?.fields ?? {};
+  const fields = Array.isArray(fieldsObj) ? fieldsObj : Object.values(fieldsObj);
+  return fields.filter((field) => {
+    const methodInfo = field.method?.[method];
+    if (!methodInfo)
+      return false;
+    return requestOnly ? methodInfo.request === true || methodInfo.requestCurated === true : methodInfo.response === true || methodInfo.responseCurated === true;
+  }).map((field) => {
+    const compact = {
+      name: field.name,
+      displayName: field.displayName,
+      type: field.type,
+      dataType: field.type,
+      required: requestOnly ? field.method?.[method]?.required === true : false,
+      description: field.description
+    };
+    if (!requestOnly)
+      compact.responseOnly = true;
+    applyOptionalFieldProps(compact, field);
+    return compact;
+  });
+}
+function isConnectorNode(node) {
+  const nodeType = node.nodeType;
+  return nodeType?.startsWith("uipath.connector") || false;
+}
+function isConnectorTriggerNode(node) {
+  const nodeType = node.nodeType;
+  return nodeType?.startsWith("uipath.connector.trigger") || false;
+}
+function toCompactField(field, required) {
+  const compact = {
+    name: field.name,
+    displayName: field.displayName,
+    type: field.type,
+    dataType: field.type,
+    required,
+    description: field.description
+  };
+  applyOptionalFieldProps(compact, field);
+  return compact;
+}
+function extractTriggerEventParameters(metadata, operationName) {
+  const fields = Object.values(metadata?.fields ?? {});
+  return fields.filter((field) => !!field.events?.[operationName]).map((field) => toCompactField(field, field.events?.[operationName]?.required === true));
+}
+function extractTriggerFilterFields(metadata) {
+  const fields = Object.values(metadata?.fields ?? {});
+  return fields.filter((field) => field.order === 1).map((field) => toCompactField(field, false));
+}
+function extractActivityFilterFields(metadata, _method) {
+  const fieldsObj = metadata?.fields ?? {};
+  const fields = Array.isArray(fieldsObj) ? fieldsObj : Object.values(fieldsObj);
+  return fields.filter((field) => field.searchable === true).map((field) => {
+    const compact = {
+      name: field.name,
+      displayName: field.displayName,
+      type: field.type,
+      dataType: field.type,
+      required: false,
+      description: field.description
+    };
+    if (field.searchableOperators?.length) {
+      compact.searchableOperators = [...field.searchableOperators];
+    }
+    if (field.searchableNames?.length) {
+      compact.searchableNames = [...field.searchableNames];
+    }
+    applyOptionalFieldProps(compact, field);
+    return compact;
+  });
+}
+function extractTriggerOutputFields(metadata) {
+  const fields = Object.values(metadata?.fields ?? {});
+  return fields.map((field) => {
+    const compact = toCompactField(field, false);
+    compact.responseOnly = true;
+    return compact;
+  });
+}
+async function fetchConnectorTriggerMetadata(connectorKey, operationName, objectName, connectionId) {
+  const api = await createApiClient(ElementsApi);
+  const triggerMetadata = await api.getInstanceEventObjectMetadata({
+    connectionOrInstanceId: connectionId,
+    elementKey: connectorKey,
+    operationName,
+    objectName,
+    allFields: true
+  });
+  return triggerMetadata;
+}
+function getConfigurationString(node) {
+  const modelConfig = node.model?.configuration;
+  if (modelConfig)
+    return modelConfig;
+  const form = node.form;
+  for (const section of form?.sections ?? []) {
+    for (const field of section.fields ?? []) {
+      const config = field.componentProps?.connectorDetail?.configuration;
+      if (config)
+        return config;
+    }
+  }
+  return;
+}
+function getConnectorConfiguration(node) {
+  const configStr = getConfigurationString(node);
+  if (!configStr)
+    return null;
+  const [err, parsed] = catchError(() => JSON.parse(configStr));
+  return err ? null : parsed;
+}
+async function fetchConnectionInfo(connectionId) {
+  const api = await createApiClient(ConnectionsApi);
+  const response = await api.apiV1ConnectionsConnectionIdGet({
+    connectionId
+  });
+  const connector = response.connector;
+  return {
+    id: response.id ?? connectionId,
+    name: response.name ?? connectionId,
+    connectorKey: connector?.key ?? "",
+    connectorName: connector?.name ?? "",
+    connectorVersion: response.elementVersion ?? null,
+    pollingInterval: response.pollingIntervalInMinutes ?? null,
+    byoaConnection: response.byoaConnection === true,
+    elementInstanceId: response.elementInstanceId ?? null,
+    folderKey: response.folder?.key ?? null
+  };
+}
+async function fetchConnectorMetadata(connectorKey, objectName, connectionId) {
+  const api = await createApiClient(ElementsApi);
+  if (connectionId) {
+    const response2 = await api.getInstanceObjectMetadataRaw({
+      connectionOrInstanceId: connectionId,
+      elementKey: connectorKey,
+      objectName,
+      includeParentArray: true
+    });
+    return await response2.raw.json();
+  }
+  const response = await api.getObjectMetadataRaw({
+    elementKey: connectorKey,
+    objectName,
+    includeParentArray: true
+  });
+  return await response.raw.json();
+}
+async function fetchConnectorActivityMetadataV4(connectorKey, activityName) {
+  return await getConnectorActivityMetadataV4(undefined, connectorKey, activityName);
+}
+function buildEnrichedActivityNode(node, metadata, method) {
+  const connectorMethodInfo = metadata?.metadata?.method?.[method];
+  const inputFields = extractFields(metadata, method, true);
+  const outputFields = extractFields(metadata, method, false);
+  const filterFields = extractActivityFilterFields(metadata, method);
+  return {
+    ...node,
+    ...connectorMethodInfo && { connectorMethodInfo },
+    inputDefinition: node.inputDefinition && Object.keys(node.inputDefinition).length > 0 ? node.inputDefinition : { fields: inputFields },
+    outputResponseDefinition: { fields: outputFields },
+    ...filterFields.length > 0 && {
+      filterFields: { fields: filterFields }
+    }
+  };
+}
+async function enrichConnectorActivityNode(node, connectionId) {
+  const parsed = parseContext(node);
+  const config = getConnectorConfiguration(node);
+  if (isV4ActivityConfiguration(config)) {
+    return enrichV4ConnectorActivityNode(node, connectionId, config);
+  }
+  if (!parsed)
+    return node;
+  const { connectorKey, objectName, method } = parsed;
+  const [error, metadata] = await catchError(fetchConnectorMetadata(connectorKey, objectName, connectionId));
+  if (error) {
+    return node;
+  }
+  return buildEnrichedActivityNode(node, metadata, method);
+}
+async function enrichV4ConnectorActivityNode(node, connectionId, config) {
+  const connectorKey = config?.connectorKey;
+  const activityName = config?.activityName;
+  const method = config?.httpMethod;
+  if (!connectorKey || !activityName || !method) {
+    logger.warn("v4 IS enrichment skipped: node configuration carries no connectorKey/activityName/httpMethod.");
+    return node;
+  }
+  if (connectionId) {
+    logger.warn("v4 metadata endpoints are not connection-scoped — --connection-id is ignored for 4.0.0 enrichment.");
+  }
+  const [error, metadata] = await catchError(fetchConnectorActivityMetadataV4(connectorKey, activityName));
+  if (error) {
+    logger.warn(`IS v4 enrichment failed: ${error.message}`);
+    return node;
+  }
+  return buildEnrichedActivityNode(node, metadata, method);
+}
+async function enrichConnectorNode(node, connectionId) {
+  if (!isConnectorNode(node))
+    return node;
+  return isConnectorTriggerNode(node) ? enrichConnectorTriggerNode(node, connectionId) : enrichConnectorActivityNode(node, connectionId);
+}
+async function enrichConnectorTriggerNode(node, connectionId) {
+  if (!connectionId) {
+    throw new Error("Trigger nodes require --connection-id for IS enrichment. Provide it with --connection-id <id>.");
+  }
+  const parsed = parseContext(node);
+  if (!parsed?.operation)
+    return node;
+  const { connectorKey, objectName, operation } = parsed;
+  const metadata = await fetchConnectorTriggerMetadata(connectorKey, operation, objectName, connectionId);
+  const eventParameters = extractTriggerEventParameters(metadata, operation);
+  const filterFields = extractTriggerFilterFields(metadata);
+  const outputFields = extractTriggerOutputFields(metadata);
+  let byoaConnection = false;
+  let elementInstanceId = null;
+  if (connectionId) {
+    const [connErr, connInfo] = await catchError(fetchConnectionInfo(connectionId));
+    if (!connErr) {
+      byoaConnection = connInfo.byoaConnection;
+      elementInstanceId = connInfo.elementInstanceId;
+    } else {
+      logger.warn(`Failed to fetch connection info for ${connectionId}: ${connErr.message}`);
+    }
+  }
+  return {
+    ...node,
+    eventMode: metadata.eventMode,
+    byoaConnection,
+    elementInstanceId,
+    eventParameters: { fields: eventParameters },
+    filterFields: { fields: filterFields },
+    outputResponseDefinition: { fields: outputFields }
+  };
+}
+
+// ../maestro-sdk/src/registry/is-precache.ts
+async function resolveLibraryJsonDir() {
+  const snapshot = await resolveMaestroRegistry();
+  return snapshot?.libraryJson ?? null;
+}
+async function readIndex() {
+  const fs = getFileSystem();
+  const dir = await resolveLibraryJsonDir();
+  if (!dir)
+    return null;
+  const indexPath = fs.path.join(dir, "index.json");
+  const [readError, content] = await catchError(fs.readFile(indexPath, "utf-8"));
+  if (readError || content === null)
+    return null;
+  const [parseError, parsed] = catchError(() => JSON.parse(content));
+  if (parseError || !parsed || !Array.isArray(parsed.entries))
+    return null;
+  return parsed.entries;
+}
+async function listPrecacheEntries() {
+  const entries = await readIndex();
+  return entries ?? [];
+}
+async function getPrecacheNode(nodeType, options) {
+  const fs = getFileSystem();
+  const dir = await resolveLibraryJsonDir();
+  if (!dir)
+    return null;
+  const indexPath = fs.path.join(dir, "index.json");
+  const [indexReadError, indexContent] = await catchError(fs.readFile(indexPath, "utf-8"));
+  if (indexReadError || indexContent === null)
+    return null;
+  const [indexParseError, parsed] = catchError(() => JSON.parse(indexContent));
+  if (indexParseError || !parsed || !Array.isArray(parsed.entries))
+    return null;
+  const lowerNodeType = nodeType.toLowerCase();
+  let matches = parsed.entries.filter((e) => e.nodeType.toLowerCase() === lowerNodeType);
+  if (options?.objectName) {
+    const lowerObject = options.objectName.toLowerCase();
+    matches = matches.filter((e) => e.objectName.toLowerCase() === lowerObject);
+  }
+  if (matches.length !== 1)
+    return null;
+  const entry = matches[0];
+  const v1defPath = fs.path.join(dir, entry.path.replace(/\.json$/, ".v1def.json"));
+  const [readError, content] = await catchError(fs.readFile(v1defPath, "utf-8"));
+  if (readError || content === null)
+    return null;
+  const [parseError, manifest] = catchError(() => JSON.parse(content));
+  if (parseError || !manifest)
+    return null;
+  return manifest;
+}
+
+// ../maestro-sdk/src/registry/node-storage.ts
+var CACHE_FORMAT_VERSION = 3;
+var INDEX_FILE = "index.json";
+var METADATA_FILE = "index.meta.json";
+var SEARCH_INDEX_FILE = "search-index.json";
+var ESSENTIALS_INDEX_FILE = "get-essentials.json";
+var WRITE_LOCK_FILE = ".index-write.lock";
+async function resolveNodeStorageDir() {
+  const fs = getFileSystem();
+  return fs.path.join(fs.env.homedir(), UIPATH_HOME_DIR, "nodes");
+}
+function buildSearchIndex(nodes) {
+  return nodes.map((node) => ({
+    nodeType: node.nodeType,
+    category: node.category,
+    tags: node.tags,
+    version: node.version,
+    description: node.description,
+    display: node.display === undefined ? undefined : {
+      label: node.display.label,
+      description: node.display.description
+    }
+  }));
+}
+function isEssentialNodeType(nodeType) {
+  if (typeof nodeType !== "string" || nodeType.length === 0)
+    return false;
+  const lowerNodeType = nodeType.toLowerCase();
+  return lowerNodeType.startsWith("core.") || lowerNodeType.startsWith("uipath.core.") || lowerNodeType === "uipath.human-in-the-loop";
+}
+function buildEssentialsIndex(nodes) {
+  return nodes.filter((node) => isEssentialNodeType(node.nodeType));
+}
+function createDerivedArtifact(nodes, sourceHash) {
+  return {
+    cacheVersion: CACHE_FORMAT_VERSION,
+    sourceHash,
+    generatedAt: Date.now(),
+    nodes
+  };
+}
+function normalizeMetadata(metadata) {
+  return {
+    ...metadata,
+    cacheVersion: metadata.cacheVersion ?? 0
+  };
+}
+async function writeTempAndRename(fs, targetPath, content) {
+  const tempPath = `${targetPath}.tmp-${Date.now()}-${Math.random().toString(36).slice(2)}`;
+  await fs.writeFile(tempPath, content);
+  await fs.rename(tempPath, targetPath);
+}
+async function writeNodeArtifacts(fs, dir, nodes) {
+  const indexPath = fs.path.join(dir, INDEX_FILE);
+  const searchIndexPath = fs.path.join(dir, SEARCH_INDEX_FILE);
+  const essentialsIndexPath = fs.path.join(dir, ESSENTIALS_INDEX_FILE);
+  const metaPath = fs.path.join(dir, METADATA_FILE);
+  const indexContent = JSON.stringify(nodes);
+  const hash = await hashContent(indexContent);
+  const searchContent = JSON.stringify(createDerivedArtifact(buildSearchIndex(nodes), hash));
+  const essentialsContent = JSON.stringify(createDerivedArtifact(buildEssentialsIndex(nodes), hash));
+  const metadataContent = JSON.stringify({
+    lastSync: Date.now(),
+    nodeCount: nodes.length,
+    hash,
+    cacheVersion: CACHE_FORMAT_VERSION
+  });
+  await writeTempAndRename(fs, searchIndexPath, searchContent);
+  await writeTempAndRename(fs, essentialsIndexPath, essentialsContent);
+  await writeTempAndRename(fs, indexPath, indexContent);
+  await writeTempAndRename(fs, metaPath, metadataContent);
+  return nodes.length;
+}
+async function saveNodeIndex(nodes) {
+  const fs = getFileSystem();
+  const dir = await resolveNodeStorageDir();
+  await fs.mkdir(dir);
+  const lockPath = fs.path.join(dir, WRITE_LOCK_FILE);
+  const releaseLock = await fs.acquireLock(lockPath);
+  let result;
+  let writeError;
+  try {
+    result = await writeNodeArtifacts(fs, dir, nodes);
+  } catch (error) {
+    writeError = error;
+  }
+  const [releaseError] = await catchError(releaseLock());
+  if (writeError)
+    throw writeError;
+  if (releaseError)
+    throw releaseError;
+  if (result === undefined) {
+    throw new Error("Node index write did not complete.");
+  }
+  return result;
+}
+async function loadNodeIndex() {
+  const fs = getFileSystem();
+  const dir = await resolveNodeStorageDir();
+  const indexPath = fs.path.join(dir, INDEX_FILE);
+  if (!await fs.exists(indexPath)) {
+    throw new Error("No node index found. Please run 'uip [flow|maestro] registry pull' to sync nodes first.");
+  }
+  const metadata = await loadIndexMetadata();
+  if (!metadata || metadata.cacheVersion !== CACHE_FORMAT_VERSION) {
+    throw new Error("Node index is outdated. Please run 'uip [flow|maestro] registry pull' to sync nodes first.");
+  }
+  const [error, content] = await catchError(fs.readFile(indexPath, "utf-8"));
+  if (error) {
+    throw new Error(`Failed to load node index: ${error.message}`);
+  }
+  if (content === null) {
+    throw new Error("No node index found. Please run 'uip [flow|maestro] registry pull' to sync nodes first.");
+  }
+  const [parseError, parsed] = catchError(() => JSON.parse(content));
+  if (parseError) {
+    throw new Error(`Failed to load node index: ${parseError.message}`);
+  }
+  return parsed;
+}
+async function saveIndexMetadata(metadata) {
+  const fs = getFileSystem();
+  const dir = await resolveNodeStorageDir();
+  await fs.mkdir(dir);
+  const metaPath = fs.path.join(dir, METADATA_FILE);
+  await fs.writeFile(metaPath, JSON.stringify({
+    ...metadata,
+    cacheVersion: metadata.cacheVersion ?? CACHE_FORMAT_VERSION
+  }));
+}
+async function loadIndexMetadata() {
+  const fs = getFileSystem();
+  const dir = await resolveNodeStorageDir();
+  const metaPath = fs.path.join(dir, METADATA_FILE);
+  if (!await fs.exists(metaPath)) {
+    return null;
+  }
+  const [error, content] = await catchError(fs.readFile(metaPath, "utf-8"));
+  if (error || content === null) {
+    return null;
+  }
+  const [parseError, parsed] = catchError(() => JSON.parse(content));
+  if (parseError || parsed === null) {
+    return null;
+  }
+  return normalizeMetadata(parsed);
+}
+function isDerivedArtifact(value) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  const artifact = value;
+  return typeof artifact.cacheVersion === "number" && typeof artifact.sourceHash === "string" && typeof artifact.generatedAt === "number" && Array.isArray(artifact.nodes);
+}
+async function loadValidDerivedArtifact(fileName) {
+  const fs = getFileSystem();
+  const dir = await resolveNodeStorageDir();
+  const indexPath = fs.path.join(dir, INDEX_FILE);
+  if (!await fs.exists(indexPath)) {
+    return null;
+  }
+  const metadata = await loadIndexMetadata();
+  if (!metadata || metadata.cacheVersion !== CACHE_FORMAT_VERSION || typeof metadata.hash !== "string") {
+    return null;
+  }
+  const artifactPath = fs.path.join(dir, fileName);
+  const [readError, content] = await catchError(fs.readFile(artifactPath, "utf-8"));
+  if (readError || content === null) {
+    return null;
+  }
+  const [parseError, parsed] = catchError(() => JSON.parse(content));
+  if (parseError || !isDerivedArtifact(parsed)) {
+    return null;
+  }
+  if (parsed.cacheVersion !== CACHE_FORMAT_VERSION || parsed.sourceHash !== metadata.hash) {
+    return null;
+  }
+  return parsed.nodes;
+}
+async function loadValidSearchIndex() {
+  return loadValidDerivedArtifact(SEARCH_INDEX_FILE);
+}
+async function loadValidEssentialsIndex() {
+  return loadValidDerivedArtifact(ESSENTIALS_INDEX_FILE);
+}
+async function areDerivedArtifactsCurrent() {
+  const searchIndex = await loadValidSearchIndex();
+  if (searchIndex === null)
+    return false;
+  const essentialsIndex = await loadValidEssentialsIndex();
+  return essentialsIndex !== null;
+}
+async function rederiveNodeIndexArtifacts() {
+  const nodes = await loadNodeIndex();
+  return saveNodeIndex(nodes);
+}
+
+// ../maestro-sdk/src/registry/solution-discovery.ts
+var EMPTY_IO = {
+  inputs: {},
+  outputs: {}
+};
+var agentProjectMetadataReader;
+function findEnclosingProjectId(solutionDir, projects, cwd) {
+  const fs = getFileSystem();
+  for (const p of projects) {
+    const projDir = fs.path.resolve(solutionDir, fs.path.dirname(p.ProjectRelativePath));
+    if (cwd === projDir)
+      return p.Id;
+    const rel = fs.path.relative(projDir, cwd);
+    if (rel !== "" && !rel.startsWith("..") && !fs.path.isAbsolute(rel)) {
+      return p.Id;
+    }
+  }
+  return;
+}
+async function findSolutionFromCwd() {
+  const fs = getFileSystem();
+  const cwd = fs.env.cwd();
+  const dirsToCheck = [
+    cwd,
+    fs.path.resolve(cwd, ".."),
+    fs.path.resolve(cwd, "../..")
+  ];
+  for (const dir of dirsToCheck) {
+    const [readErr, entries] = await catchError(fs.readdir(dir));
+    if (readErr)
+      continue;
+    const uipxName = entries.find((e) => e.endsWith(".uipx"));
+    if (!uipxName)
+      continue;
+    const uipxPath = fs.path.join(dir, uipxName);
+    const [fileErr, content] = await catchError(fs.readFile(uipxPath, "utf-8"));
+    if (fileErr || !content)
+      continue;
+    const [parseErr, parsed] = catchError(() => JSON.parse(content));
+    if (parseErr || !parsed.SolutionId)
+      continue;
+    const projects = parsed.Projects ?? [];
+    return {
+      solutionId: parsed.SolutionId,
+      solutionDir: dir,
+      projects,
+      currentProjectId: findEnclosingProjectId(dir, projects, cwd)
+    };
+  }
+  return null;
+}
+async function readProjectEntryPointIO(projectDir) {
+  const fs = getFileSystem();
+  const candidates = [
+    fs.path.join(projectDir, "entry-points.json"),
+    fs.path.join(projectDir, "content", "entry-points.json")
+  ];
+  for (const filePath of candidates) {
+    const [err, content] = await catchError(fs.readFile(filePath, "utf-8"));
+    if (err || !content)
+      continue;
+    const [parseErr, parsed] = catchError(() => JSON.parse(content));
+    if (parseErr || !parsed.entryPoints?.length)
+      continue;
+    return extractIOFromEntryPoints(parsed);
+  }
+  const fromFlow = await readProjectIOFromFlowVariables(projectDir);
+  if (fromFlow)
+    return fromFlow;
+  return EMPTY_IO;
+}
+async function readProjectIOFromFlowVariables(projectDir) {
+  const fs = getFileSystem();
+  const [readErr, entries] = await catchError(fs.readdir(projectDir));
+  if (readErr || !Array.isArray(entries))
+    return;
+  const flowFileName = entries.find((entry) => entry.endsWith(".flow"));
+  if (!flowFileName)
+    return;
+  const flowPath = fs.path.join(projectDir, flowFileName);
+  const [readFileErr, content] = await catchError(fs.readFile(flowPath, "utf-8"));
+  if (readFileErr || !content)
+    return;
+  const [parseErr, parsed] = catchError(() => JSON.parse(content));
+  if (parseErr)
+    return;
+  const globals = parsed.variables?.globals;
+  if (!Array.isArray(globals) || globals.length === 0)
+    return;
+  const inputProps = {};
+  const outputProps = {};
+  for (const variable of globals) {
+    if (!variable?.id || !variable.direction)
+      continue;
+    const schema = {
+      type: variable.type ?? "string"
+    };
+    if (variable.description) {
+      schema.description = variable.description;
+    }
+    if (variable.direction === "in" || variable.direction === "inout") {
+      inputProps[variable.id] = schema;
+    }
+    if (variable.direction === "out" || variable.direction === "inout") {
+      outputProps[variable.id] = schema;
+    }
+  }
+  const hasInputs = Object.keys(inputProps).length > 0;
+  const hasOutputs = Object.keys(outputProps).length > 0;
+  if (!hasInputs && !hasOutputs)
+    return;
+  const synthetic = {
+    entryPoints: [
+      {
+        filePath: flowFileName,
+        input: hasInputs ? { type: "object", properties: inputProps } : undefined,
+        output: hasOutputs ? { type: "object", properties: outputProps } : undefined
+      }
+    ]
+  };
+  return extractIOFromEntryPoints(synthetic);
+}
+async function readProjectName(projectDir) {
+  const fs = getFileSystem();
+  const uiprojPath = fs.path.join(projectDir, "project.uiproj");
+  const [err, content] = await catchError(fs.readFile(uiprojPath, "utf-8"));
+  if (!err && content) {
+    const [parseErr, parsed] = catchError(() => JSON.parse(content));
+    if (!parseErr && parsed.Name)
+      return parsed.Name;
+  }
+  return fs.path.basename(projectDir);
+}
+async function loadResourceKeyMap(solutionDir) {
+  const fs = getFileSystem();
+  const map = new Map;
+  const processDir = fs.path.join(solutionDir, "resources", "solution_folder", "process");
+  const [dirErr, typeDirs] = await catchError(fs.readdir(processDir));
+  if (dirErr)
+    return map;
+  for (const typeDir of typeDirs) {
+    const typePath = fs.path.join(processDir, typeDir);
+    const [filesErr, files] = await catchError(fs.readdir(typePath));
+    if (filesErr)
+      continue;
+    for (const file of files) {
+      if (!file.endsWith(".json"))
+        continue;
+      const filePath = fs.path.join(typePath, file);
+      const [readErr, content] = await catchError(fs.readFile(filePath, "utf-8"));
+      if (readErr || !content)
+        continue;
+      const [parseErr, parsed] = catchError(() => JSON.parse(content));
+      if (parseErr)
+        continue;
+      const projectKey = parsed.resource?.projectKey;
+      const resourceKey = parsed.resource?.key;
+      if (projectKey && resourceKey) {
+        map.set(projectKey, resourceKey);
+      }
+    }
+  }
+  return map;
+}
+async function buildInSolutionNodeManifests(ctx) {
+  const fs = getFileSystem();
+  const manifests = [];
+  const resourceKeyMap = await loadResourceKeyMap(ctx.solutionDir);
+  for (const project of ctx.projects) {
+    if (ctx.currentProjectId && project.Id === ctx.currentProjectId)
+      continue;
+    const serviceType = getServiceType(project.Type);
+    if (!serviceType)
+      continue;
+    const projectDir = fs.path.resolve(ctx.solutionDir, fs.path.dirname(project.ProjectRelativePath));
+    const reader = agentProjectMetadataReader;
+    const [name, io, projectMetadata] = await Promise.all([
+      readProjectName(projectDir),
+      readProjectEntryPointIO(projectDir),
+      reader ? reader(projectDir, project.Type).catch((err) => {
+        logger.debug(`Agent metadata reader failed for ${projectDir}: ${String(err)}`);
+        return {};
+      }) : Promise.resolve({})
+    ]);
+    const resourceKey = resourceKeyMap.get(project.Id) ?? project.Id;
+    const task = {
+      name,
+      type: serviceType,
+      resourceKey,
+      inputs: io.inputs,
+      outputs: io.outputs,
+      metadata: {
+        ...projectMetadata,
+        description: `(In-solution) ${name}`,
+        key: resourceKey,
+        name,
+        tags: ["in-solution", "local"],
+        projectId: project.Id,
+        entryPointUniqueId: io.entryPointUniqueId,
+        inputProperties: io.inputProperties
+      }
+    };
+    const nodes = taskDefinitionsToNodeManifests({ [resourceKey]: task }, project.Type);
+    manifests.push(...nodes);
+  }
+  return manifests;
+}
+
+// ../maestro-sdk/src/registry/node-sync-service.ts
+var CACHE_EXPIRATION = 30 * 60 * 1000;
+var NODE_EXCLUSIONS = [
+  (t) => t.includes("uipath-uipath-dataservice") && /-v3-?$/i.test(t)
+];
+function isExcludedNodeType(nodeType) {
+  return typeof nodeType === "string" && NODE_EXCLUSIONS.some((match) => match(nodeType));
+}
+function isMissingIndexError(error) {
+  return error.message.includes("No node index found") || error.message.includes("Node index is outdated");
+}
+async function pullNodes(options = {}) {
+  const { force = false } = options;
+  if (force) {
+    const refreshResult2 = await refreshNodes();
+    const meta2 = await loadIndexMetadata();
+    return {
+      syncedCount: refreshResult2.nodeCount || meta2?.nodeCount || 0,
+      fromCache: false,
+      source: refreshResult2.source,
+      cacheWritten: refreshResult2.cacheWritten,
+      info: refreshResult2.info
+    };
+  }
+  const meta = await loadIndexMetadata();
+  if (meta) {
+    const ageMs = Date.now() - meta.lastSync;
+    let needsRefresh = false;
+    if (ageMs < CACHE_EXPIRATION) {
+      if (!await areDerivedArtifactsCurrent()) {
+        const [rederiveError, nodeCount] = await catchError(rederiveNodeIndexArtifacts());
+        if (rederiveError) {
+          if (!isMissingIndexError(rederiveError)) {
+            throw rederiveError;
+          }
+          needsRefresh = true;
+        } else {
+          return {
+            syncedCount: nodeCount,
+            fromCache: true,
+            ageMinutes: Math.round(ageMs / 60000)
+          };
+        }
+      }
+      if (!needsRefresh) {
+        return {
+          syncedCount: meta.nodeCount,
+          fromCache: true,
+          ageMinutes: Math.round(ageMs / 60000)
+        };
+      }
+    }
+  }
+  const refreshResult = await refreshNodes();
+  const refreshedMeta = await loadIndexMetadata();
+  return {
+    syncedCount: refreshResult.nodeCount || refreshedMeta?.nodeCount || 0,
+    fromCache: false,
+    source: refreshResult.source,
+    cacheWritten: refreshResult.cacheWritten,
+    info: refreshResult.info
+  };
+}
+async function refreshNodes() {
+  const oldMeta = await loadIndexMetadata();
+  const pullResult = await pullRemoteNodes();
+  const allNodes = pullResult.nodes;
+  if (!pullResult.cacheable) {
+    return {
+      cacheWritten: false,
+      nodeCount: allNodes.length,
+      source: pullResult.source,
+      info: pullResult.info
+    };
+  }
+  const content = JSON.stringify(allNodes);
+  const newHash = await hashContent(content);
+  if (oldMeta && oldMeta.hash === newHash) {
+    if (!await areDerivedArtifactsCurrent()) {
+      await saveNodeIndex(allNodes);
+      return {
+        cacheWritten: true,
+        nodeCount: allNodes.length,
+        source: pullResult.source
+      };
+    }
+    await saveIndexMetadata({
+      lastSync: Date.now(),
+      nodeCount: oldMeta.nodeCount,
+      hash: oldMeta.hash
+    });
+    return {
+      cacheWritten: true,
+      nodeCount: oldMeta.nodeCount,
+      source: pullResult.source
+    };
+  }
+  await saveNodeIndex(allNodes);
+  return {
+    cacheWritten: true,
+    nodeCount: allNodes.length,
+    source: pullResult.source
+  };
+}
+var ENABLED_MANIFEST_FLAGS = new Set([
+  MANIFEST_FEATURE_FLAGS.CONNECTOR_NODES,
+  MANIFEST_FEATURE_FLAGS.EXTRACT_DOCUMENT,
+  MANIFEST_FEATURE_FLAGS.HITL,
+  MANIFEST_FEATURE_FLAGS.LOOP_CONTAINER,
+  MANIFEST_FEATURE_FLAGS.BATCH_TRANSFORM,
+  MANIFEST_FEATURE_FLAGS.SUMMARIZE,
+  MANIFEST_FEATURE_FLAGS.CONVERSATION_TRIGGER,
+  MANIFEST_FEATURE_FLAGS.CONVERSATIONAL_WAIT_FOR_MESSAGE,
+  MANIFEST_FEATURE_FLAGS.CONVERSATIONAL_SEND_MESSAGE,
+  MANIFEST_FEATURE_FLAGS.CONVERSATIONAL_GET_CONVERSATION_CONTEXT,
+  MANIFEST_FEATURE_FLAGS.CONVERSATIONAL_VOICE_INCOMING_CALL_TRIGGER,
+  MANIFEST_FEATURE_FLAGS.CONVERSATIONAL_VOICE_CREATE_OUTGOING_CALL,
+  MANIFEST_FEATURE_FLAGS.CONVERSATIONAL_VOICE_END_CALL
+]);
+async function pullRemoteNodes() {
+  const loginStatus = await getLoginStatusAsync();
+  const client = new ManifestClient({
+    baseUrl: loginStatus.baseUrl || "localhost",
+    getFeatureFlag: (flag) => ENABLED_MANIFEST_FLAGS.has(flag)
+  });
+  if (loginStatus.loginStatus !== "Logged in" || !loginStatus.baseUrl || !loginStatus.accessToken || !loginStatus.tenantId || !loginStatus.organizationId) {
+    const manifest2 = await client.getManifest({
+      inlineAgentNodes: true
+    });
+    return {
+      nodes: applyExclusions(manifest2.nodes || []),
+      source: "ootb",
+      cacheable: false,
+      info: "Using OOTB nodes because you are not logged in. Cache was not updated."
+    };
+  }
+  const authContext = {
+    accessToken: loginStatus.accessToken,
+    tenantId: loginStatus.tenantId,
+    organizationId: loginStatus.organizationId
+  };
+  const [manifestError, manifest] = await catchError(client.getManifest({
+    auth: authContext,
+    includeIntegrationTriggers: true,
+    inlineAgentNodes: true,
+    conversationalAgentNodes: true,
+    excludeIntsvcConnectorHttpRequest: true
+  }));
+  if (!manifestError) {
+    return {
+      nodes: applyExclusions(manifest.nodes || []),
+      source: "authenticated",
+      cacheable: true
+    };
+  }
+  const fallbackManifest = await client.getManifest({
+    inlineAgentNodes: true
+  });
+  return {
+    nodes: applyExclusions(fallbackManifest.nodes || []),
+    source: "ootb",
+    cacheable: false,
+    info: `Failed to refresh authenticated nodes with error: ${manifestError}. Using OOTB nodes without updating cache.`
+  };
+}
+function applyExclusions(nodes) {
+  return nodes.filter((n) => !isExcludedNodeType(n.nodeType));
+}
+async function getNodesWithCacheFallback() {
+  const [error, nodes] = await catchError(loadNodeIndex());
+  if (error) {
+    if (!isMissingIndexError(error)) {
+      throw error;
+    }
+    const pullResult = await pullRemoteNodes();
+    if (pullResult.cacheable) {
+      await saveNodeIndex(pullResult.nodes);
+    }
+    return pullResult.nodes;
+  }
+  return nodes;
+}
+async function getLocalSolutionNodes() {
+  const ctx = await findSolutionFromCwd();
+  if (!ctx) {
+    throw new Error("No .uipx solution file found in current directory, its parent, or its grandparent. " + "Run this command from inside a solution project directory.");
+  }
+  return buildInSolutionNodeManifests(ctx);
+}
+async function listNodes(options) {
+  if (options?.local)
+    return getLocalSolutionNodes();
+  const precacheEntries = await listPrecacheEntries();
+  const registryCacheNodes = await getNodesWithCacheFallback();
+  if (precacheEntries.length === 0)
+    return registryCacheNodes;
+  const byType = new Map;
+  for (const entry of precacheEntries) {
+    const key = entry.nodeType.toLowerCase();
+    const bucket = byType.get(key) ?? [];
+    bucket.push(entry);
+    byType.set(key, bucket);
+  }
+  const uniquePrecache = [];
+  for (const [, entries] of byType) {
+    if (entries.length !== 1)
+      continue;
+    uniquePrecache.push(entries[0]);
+  }
+  const precacheTypes = new Set(uniquePrecache.map((e) => e.nodeType.toLowerCase()));
+  const merged = registryCacheNodes.filter((n) => typeof n.nodeType !== "string" || !precacheTypes.has(n.nodeType.toLowerCase()));
+  for (const entry of uniquePrecache) {
+    merged.push({
+      nodeType: entry.nodeType,
+      version: entry.version,
+      category: "connector",
+      tags: ["connector"],
+      display: { label: entry.label }
+    });
+  }
+  return merged;
+}
+function unionWithKnownSdkNodes(tenantNodes) {
+  const seen = new Set;
+  const result = [];
+  for (const node of tenantNodes) {
+    const type = typeof node.nodeType === "string" ? node.nodeType.toLowerCase() : null;
+    if (type !== null) {
+      if (seen.has(type))
+        continue;
+      seen.add(type);
+    }
+    result.push(node);
+  }
+  for (const known of listKnownSdkNodes()) {
+    const type = typeof known.nodeType === "string" ? known.nodeType.toLowerCase() : null;
+    if (type === null || seen.has(type))
+      continue;
+    seen.add(type);
+    result.push(known);
+  }
+  return result;
+}
+async function loadSearchSummariesWithCacheFallback() {
+  const validSearchIndex = await loadValidSearchIndex();
+  if (validSearchIndex)
+    return validSearchIndex;
+  const [repairError] = await catchError(rederiveNodeIndexArtifacts());
+  if (!repairError) {
+    const repairedSearchIndex = await loadValidSearchIndex();
+    if (repairedSearchIndex)
+      return repairedSearchIndex;
+  }
+  return buildSearchIndex(await getNodesWithCacheFallback());
+}
+async function loadEssentialsIndexWithRepair() {
+  const validEssentialsIndex = await loadValidEssentialsIndex();
+  if (validEssentialsIndex)
+    return validEssentialsIndex;
+  const [repairError] = await catchError(rederiveNodeIndexArtifacts());
+  if (repairError)
+    return null;
+  return loadValidEssentialsIndex();
+}
+async function searchNodeSummariesWithAvailability(keyword, filters) {
+  const tenantNodes = await loadSearchSummariesWithCacheFallback();
+  const tenantTypes = new Set(tenantNodes.map((node) => node.nodeType?.toLowerCase()).filter((type) => typeof type === "string"));
+  const merged = tenantNodes.map((node) => ({
+    node,
+    availableOnTenant: true
+  }));
+  for (const knownNode of listKnownSdkNodes()) {
+    const type = knownNode.nodeType?.toLowerCase();
+    if (typeof type !== "string" || tenantTypes.has(type))
+      continue;
+    tenantTypes.add(type);
+    merged.push({
+      node: buildSearchIndex([knownNode])[0],
+      availableOnTenant: false
+    });
+  }
+  const availabilityByType = new Map(merged.map((entry) => typeof entry.node.nodeType === "string" ? [
+    entry.node.nodeType.toLowerCase(),
+    entry.availableOnTenant
+  ] : null).filter((entry) => entry !== null));
+  return searchWithFilters(merged.map((entry) => entry.node), keyword, filters).map((node) => ({
+    node,
+    availableOnTenant: typeof node.nodeType === "string" ? availabilityByType.get(node.nodeType.toLowerCase()) ?? true : true
+  }));
+}
+async function searchNodes(keyword, options) {
+  let nodes;
+  if (options?.local) {
+    nodes = await getLocalSolutionNodes();
+  } else {
+    const tenantNodes = await getNodesWithCacheFallback();
+    nodes = unionWithKnownSdkNodes(tenantNodes);
+  }
+  const lowerKeyword = keyword.toLowerCase();
+  return nodes.filter((node) => {
+    if (node.nodeType?.toLowerCase().includes(lowerKeyword)) {
+      return true;
+    }
+    if (node.category?.toLowerCase().includes(lowerKeyword)) {
+      return true;
+    }
+    if (node.tags?.some((tag) => tag.toLowerCase().includes(lowerKeyword))) {
+      return true;
+    }
+    if (node.display?.label?.toLowerCase().includes(lowerKeyword)) {
+      return true;
+    }
+    if (node.description?.toLowerCase().includes(lowerKeyword)) {
+      return true;
+    }
+    if (node.display?.description?.toLowerCase().includes(lowerKeyword)) {
+      return true;
+    }
+    return false;
+  });
+}
+async function getNode(nodeType, options) {
+  const lowerNodeType = nodeType.toLowerCase();
+  if (!options?.local && lowerNodeType.startsWith("uipath.connector.")) {
+    const precached = await getPrecacheNode(nodeType);
+    if (precached)
+      return precached;
+  }
+  if (!options?.local && isEssentialNodeType(nodeType)) {
+    const essentials = await loadEssentialsIndexWithRepair();
+    const node2 = essentials?.find((node3) => node3.nodeType?.toLowerCase() === lowerNodeType) ?? null;
+    if (node2)
+      return node2;
+  }
+  const nodes = options?.local ? await getLocalSolutionNodes() : await getNodesWithCacheFallback();
+  const node = nodes.find((node2) => node2.nodeType?.toLowerCase() === lowerNodeType) ?? null;
+  return node;
+}
+async function getNodeEnriched(nodeType, connectionId, options) {
+  const node = await getNode(nodeType, options);
+  if (!node) {
+    return null;
+  }
+  return await enrichConnectorNode(node, connectionId);
+}
+async function searchNodesWithFilters(keyword, filters, options) {
+  let nodes;
+  if (options?.local) {
+    nodes = await getLocalSolutionNodes();
+  } else {
+    const tenantNodes = await getNodesWithCacheFallback();
+    nodes = unionWithKnownSdkNodes(tenantNodes);
+  }
+  return searchWithFilters(nodes, keyword, filters);
+}
+
+export { extractTriggerEventParameters, extractTriggerFilterFields, extractActivityFilterFields, fetchConnectorTriggerMetadata, fetchConnectionInfo, fetchConnectorMetadata, findSolutionFromCwd, isExcludedNodeType, pullNodes, pullRemoteNodes, listNodes, searchNodeSummariesWithAvailability, searchNodes, getNode, getNodeEnriched, searchNodesWithFilters };
+
+//# debugId=1F22B346AB51E6F164756E2164756E21