@uipath/case-tool 1.204.0 → 1.205.0-preview.258

package/dist/{packager-tool-pdhhzfr5.js → packager-tool-29x6vran.js}

@@ -1,137 +1,40 @@
 import {
   resolveMaestroRegistry
-} from "./packager-tool-c31qx8kc.js";
+} from "./packager-tool-ezds6t5e.js";
 import {
   ConnectionsApi,
   ElementsApi,
   createApiClient,
   getConnectorActivityMetadataV4,
   isV4ActivityConfiguration
-} from "./packager-tool-w1b5pyj6.js";
+} from "./packager-tool-r6b5ktzb.js";
+import {
+  searchWithFilters
+} from "./packager-tool-7hw344bt.js";
+import {
+  listKnownSdkNodes
+} from "./packager-tool-n7w9wx62.js";
+import {
+  buildInSolutionNodes,
+  findSolutionFromCwd,
+  unknownContractWarning
+} from "./packager-tool-yct6zp4m.js";
 import {
   MANIFEST_FEATURE_FLAGS,
-  ManifestClient,
-  extractIOFromEntryPoints,
-  getServiceType,
-  listKnownSdkNodes,
-  taskDefinitionsToNodeManifests
-} from "./packager-tool-25hng8h4.js";
+  ManifestClient
+} from "./packager-tool-4rtktkhv.js";
 import {
   getLoginStatusAsync
-} from "./packager-tool-v99ygh9f.js";
+} from "./packager-tool-yn33pw57.js";
 import {
   UIPATH_HOME_DIR,
   catchError,
   hashContent,
   logger
-} from "./packager-tool-3q3d1hk8.js";
+} from "./packager-tool-83v804p7.js";
 import {
   getFileSystem
-} from "./packager-tool-xdxr3ync.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;
-}
+} from "./packager-tool-hdxtgckw.js";
 
 // ../maestro-sdk/src/registry/integration-service-fetcher.ts
 function parseContext(node) {
@@ -273,6 +176,22 @@ function getConnectorConfiguration(node) {
   const [err, parsed] = catchError(() => JSON.parse(configStr));
   return err ? null : parsed;
 }
+function getConnectorInfo(node) {
+  const context = parseContext(node);
+  const config = getConnectorConfiguration(node);
+  if (!context && !config)
+    return null;
+  const connectorKey = config?.connectorKey ?? context?.connectorKey ?? "";
+  const objectName = config?.objectName ?? context?.objectName ?? "";
+  if (!connectorKey || !objectName)
+    return null;
+  return {
+    connectorKey,
+    objectName,
+    method: config?.httpMethod ?? context?.method ?? "POST",
+    activityType: config?.activityType ?? ""
+  };
+}
 async function fetchConnectionInfo(connectionId) {
   const api = await createApiClient(ConnectionsApi);
   const response = await api.apiV1ConnectionsConnectionIdGet({
@@ -454,12 +373,20 @@ async function getPrecacheNode(nodeType, options) {
 }
 
 // ../maestro-sdk/src/registry/node-storage.ts
-var CACHE_FORMAT_VERSION = 5;
+var CACHE_FORMAT_VERSION = 6;
 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";
+function nodeCacheScope(login) {
+  const baseUrl = login.baseUrl?.trim().replace(/\/+$/, "");
+  const organizationId = login.organizationId?.trim();
+  const tenantId = login.tenantId?.trim();
+  if (!baseUrl || !organizationId || !tenantId)
+    return;
+  return [baseUrl, organizationId, tenantId].join("|").toLowerCase();
+}
 async function resolveNodeStorageDir() {
   const fs = getFileSystem();
   return fs.path.join(fs.env.homedir(), UIPATH_HOME_DIR, "nodes");
@@ -505,7 +432,7 @@ async function writeTempAndRename(fs, targetPath, content) {
   await fs.writeFile(tempPath, content);
   await fs.rename(tempPath, targetPath);
 }
-async function writeNodeArtifacts(fs, dir, nodes) {
+async function writeNodeArtifacts(fs, dir, nodes, scope, missingSources) {
   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);
@@ -518,7 +445,9 @@ async function writeNodeArtifacts(fs, dir, nodes) {
     lastSync: Date.now(),
     nodeCount: nodes.length,
     hash,
-    cacheVersion: CACHE_FORMAT_VERSION
+    cacheVersion: CACHE_FORMAT_VERSION,
+    ...scope && { scope },
+    ...missingSources?.length && { missingSources }
   });
   await writeTempAndRename(fs, searchIndexPath, searchContent);
   await writeTempAndRename(fs, essentialsIndexPath, essentialsContent);
@@ -526,7 +455,7 @@ async function writeNodeArtifacts(fs, dir, nodes) {
   await writeTempAndRename(fs, metaPath, metadataContent);
   return nodes.length;
 }
-async function saveNodeIndex(nodes) {
+async function saveNodeIndex(nodes, scope, missingSources) {
   const fs = getFileSystem();
   const dir = await resolveNodeStorageDir();
   await fs.mkdir(dir);
@@ -535,7 +464,7 @@ async function saveNodeIndex(nodes) {
   let result;
   let writeError;
   try {
-    result = await writeNodeArtifacts(fs, dir, nodes);
+    result = await writeNodeArtifacts(fs, dir, nodes, scope, missingSources);
   } catch (error) {
     writeError = error;
   }
@@ -549,6 +478,49 @@ async function saveNodeIndex(nodes) {
   }
   return result;
 }
+async function commitNodeIndex(nodes, scope, missingSources) {
+  const fs = getFileSystem();
+  const dir = await resolveNodeStorageDir();
+  await fs.mkdir(dir);
+  const releaseLock = await fs.acquireLock(fs.path.join(dir, WRITE_LOCK_FILE));
+  const [writeError, count] = await catchError((async () => {
+    const current = await loadIndexMetadata();
+    const hash = await hashContent(JSON.stringify(nodes));
+    if (current && current.cacheVersion === CACHE_FORMAT_VERSION && current.hash === hash && current.scope === scope && await areDerivedArtifactsCurrent()) {
+      const { missingSources: _previous, ...rest } = current;
+      await writeTempAndRename(fs, fs.path.join(dir, METADATA_FILE), JSON.stringify({
+        ...rest,
+        lastSync: Date.now(),
+        ...missingSources?.length && { missingSources }
+      }));
+      return current.nodeCount;
+    }
+    return writeNodeArtifacts(fs, dir, nodes, scope, missingSources);
+  })());
+  const [releaseError] = await catchError(releaseLock());
+  if (writeError)
+    throw writeError;
+  if (releaseError)
+    throw releaseError;
+  return count;
+}
+async function loadScopedNodeIndex(scope) {
+  const metadata = await loadIndexMetadata();
+  if (!metadata || metadata.cacheVersion !== CACHE_FORMAT_VERSION || metadata.scope !== scope) {
+    return null;
+  }
+  const fs = getFileSystem();
+  const indexPath = fs.path.join(await resolveNodeStorageDir(), INDEX_FILE);
+  const [readError, content] = await catchError(fs.readFile(indexPath, "utf-8"));
+  if (readError || content === null)
+    return null;
+  if (await hashContent(content) !== metadata.hash)
+    return null;
+  const [parseError, nodes] = catchError(() => JSON.parse(content));
+  if (parseError || !Array.isArray(nodes))
+    return null;
+  return { nodes, metadata };
+}
 async function loadNodeIndex() {
   const fs = getFileSystem();
   const dir = await resolveNodeStorageDir();
@@ -645,252 +617,101 @@ async function areDerivedArtifactsCurrent() {
   return essentialsIndex !== null;
 }
 async function rederiveNodeIndexArtifacts() {
-  const nodes = await loadNodeIndex();
-  return saveNodeIndex(nodes);
+  const fs = getFileSystem();
+  const dir = await resolveNodeStorageDir();
+  await fs.mkdir(dir);
+  const releaseLock = await fs.acquireLock(fs.path.join(dir, WRITE_LOCK_FILE));
+  const [rederiveError, count] = await catchError((async () => {
+    const nodes = await loadNodeIndex();
+    const metadata = await loadIndexMetadata();
+    const hash = await hashContent(JSON.stringify(nodes));
+    const sameNodes = metadata !== null && metadata.hash === hash;
+    const scope = sameNodes ? metadata.scope : undefined;
+    return writeNodeArtifacts(fs, dir, nodes, scope, sameNodes ? metadata.missingSources : undefined);
+  })());
+  const [releaseError] = await catchError(releaseLock());
+  if (rederiveError)
+    throw rederiveError;
+  if (releaseError)
+    throw releaseError;
+  return count;
 }
 
-// ../maestro-sdk/src/registry/agent-metadata-reader.ts
-var agentProjectMetadataReader;
-function getAgentProjectMetadataReader() {
-  return agentProjectMetadataReader;
-}
+// ../maestro-sdk/src/registry/node-sync-service.ts
+var MANIFEST_VALIDATION_SOURCE = "manifest validation";
+var MANIFEST_VALIDATION_NEXT_STEP = "Fix or remove the tenant resource named in the validation error, then run 'registry pull' again.";
+var TENANT_MANIFEST_INVALID = "TenantManifestInvalid";
 
-// ../maestro-sdk/src/registry/solution-discovery.ts
-var EMPTY_IO = {
-  inputs: {},
-  outputs: {}
-};
-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;
-    }
+class TenantManifestInvalidError extends Error {
+  code = TENANT_MANIFEST_INVALID;
+  ootbNodes;
+  constructor(failures, ootbNodes = []) {
+    super(`The tenant manifest failed validation, so only OOTB nodes are available (${failures.map((f) => `${f.source}: ${f.reason}`).join("; ")}). ${MANIFEST_VALIDATION_NEXT_STEP}`);
+    this.name = "TenantManifestInvalidError";
+    this.ootbNodes = ootbNodes;
   }
-  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;
+function isTenantManifestInvalidError(error) {
+  return error instanceof Error && error.code === TENANT_MANIFEST_INVALID;
 }
-async function readProjectEntryPointIO(projectDir) {
-  const fs = getFileSystem();
-  const fromSource = await readEntryPointsFile(fs.path.join(projectDir, "entry-points.json"), fs.path.join(projectDir, "content", "entry-points.json"));
-  if (fromSource)
-    return fromSource;
-  const fromFlow = await readProjectIOFromFlowVariables(projectDir);
-  if (fromFlow)
-    return fromFlow;
-  const fromBuild = await readEntryPointsFile(fs.path.join(projectDir, ".local", "content", "entry-points.json"));
-  if (fromBuild)
-    return fromBuild;
-  return EMPTY_IO;
-}
-async function readEntryPointsFile(...candidates) {
-  const fs = getFileSystem();
-  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);
+var MAX_FAILURE_REASON_LENGTH = 500;
+function stringifyReason(reason) {
+  if (reason instanceof Error)
+    return reason.message;
+  if (typeof reason === "string")
+    return reason;
+  try {
+    return JSON.stringify(reason) ?? String(reason);
+  } catch {
+    return String(reason);
   }
-  return;
 }
-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);
+function describeFailureReason(reason) {
+  const text = stringifyReason(reason);
+  return text.length > MAX_FAILURE_REASON_LENGTH ? `${text.slice(0, MAX_FAILURE_REASON_LENGTH)}...` : text;
 }
-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);
+function toPullFailures(failures) {
+  return failures.map((failure) => ({
+    source: failure.source,
+    reason: describeFailureReason(failure.reason)
+  }));
 }
-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);
-      }
-    }
+var CACHE_EXPIRATION = 30 * 60 * 1000;
+function loginScope(loginStatus) {
+  if (loginStatus.loginStatus !== "Logged in" || !loginStatus.accessToken) {
+    return;
   }
-  return map;
+  return nodeCacheScope(loginStatus);
 }
-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 = getAgentProjectMetadataReader();
-    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;
+function isFreshFor(meta, scope) {
+  return meta !== null && scope !== undefined && meta.scope === scope && Date.now() - meta.lastSync < CACHE_EXPIRATION;
 }
-
-// ../maestro-sdk/src/registry/node-sync-service.ts
-var CACHE_EXPIRATION = 30 * 60 * 1000;
 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;
+  const loginStatus = await getLoginStatusAsync();
   if (force) {
-    const refreshResult2 = await refreshNodes();
+    const refreshResult2 = await refreshNodes(loginStatus);
     const meta2 = await loadIndexMetadata();
     return {
       syncedCount: refreshResult2.nodeCount || meta2?.nodeCount || 0,
       fromCache: false,
       source: refreshResult2.source,
       cacheWritten: refreshResult2.cacheWritten,
-      info: refreshResult2.info
+      info: refreshResult2.info,
+      failures: refreshResult2.failures,
+      missingSources: refreshResult2.missingSources
     };
   }
   const meta = await loadIndexMetadata();
+  const scope = loginScope(loginStatus);
   if (meta) {
     const ageMs = Date.now() - meta.lastSync;
     let needsRefresh = false;
-    if (ageMs < CACHE_EXPIRATION) {
+    if (isFreshFor(meta, scope)) {
+      let syncedCount = meta.nodeCount;
       if (!await areDerivedArtifactsCurrent()) {
         const [rederiveError, nodeCount] = await catchError(rederiveNodeIndexArtifacts());
         if (rederiveError) {
@@ -899,71 +720,49 @@ async function pullNodes(options = {}) {
           }
           needsRefresh = true;
         } else {
-          return {
-            syncedCount: nodeCount,
-            fromCache: true,
-            ageMinutes: Math.round(ageMs / 60000)
-          };
+          syncedCount = nodeCount;
         }
       }
-      if (!needsRefresh) {
+      const current = await loadIndexMetadata();
+      if (!needsRefresh && isFreshFor(current, scope)) {
         return {
-          syncedCount: meta.nodeCount,
+          syncedCount,
           fromCache: true,
-          ageMinutes: Math.round(ageMs / 60000)
+          ageMinutes: Math.round(ageMs / 60000),
+          missingSources: current.missingSources
         };
       }
     }
   }
-  const refreshResult = await refreshNodes();
+  const refreshResult = await refreshNodes(loginStatus);
   const refreshedMeta = await loadIndexMetadata();
   return {
     syncedCount: refreshResult.nodeCount || refreshedMeta?.nodeCount || 0,
     fromCache: false,
     source: refreshResult.source,
     cacheWritten: refreshResult.cacheWritten,
-    info: refreshResult.info
+    info: refreshResult.info,
+    failures: refreshResult.failures,
+    missingSources: refreshResult.missingSources
   };
 }
-async function refreshNodes() {
-  const oldMeta = await loadIndexMetadata();
-  const pullResult = await pullRemoteNodes();
-  const allNodes = pullResult.nodes;
+async function refreshNodes(loginStatus) {
+  const pullResult = await pullRemoteNodes(loginStatus);
   if (!pullResult.cacheable) {
     return {
       cacheWritten: false,
-      nodeCount: allNodes.length,
+      nodeCount: pullResult.nodes.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
+      info: pullResult.info,
+      failures: pullResult.failures
     };
   }
-  await saveNodeIndex(allNodes);
+  const nodeCount = await commitNodeIndex(pullResult.nodes, pullResult.scope, pullResult.missingSources);
   return {
     cacheWritten: true,
-    nodeCount: allNodes.length,
-    source: pullResult.source
+    nodeCount,
+    source: pullResult.source,
+    missingSources: pullResult.missingSources
   };
 }
 var ENABLED_MANIFEST_FLAGS = new Set([
@@ -985,18 +784,18 @@ var ENABLED_MANIFEST_FLAGS = new Set([
   MANIFEST_FEATURE_FLAGS.UPDATE_ENTITY,
   MANIFEST_FEATURE_FLAGS.DELETE_ENTITY
 ]);
-async function pullRemoteNodes() {
-  const loginStatus = await getLoginStatusAsync();
+async function pullRemoteNodes(loginStatus) {
+  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({
+    const manifest = await client.getManifest({
       inlineAgentNodes: true
     });
     return {
-      nodes: manifest2.nodes || [],
+      nodes: manifest.nodes || [],
       source: "ootb",
       cacheable: false,
       info: "Using OOTB nodes because you are not logged in. Cache was not updated."
@@ -1007,7 +806,7 @@ async function pullRemoteNodes() {
     tenantId: loginStatus.tenantId,
     organizationId: loginStatus.organizationId
   };
-  const [manifestError, manifest] = await catchError(client.getManifest({
+  const [manifestError, diagnostics] = await catchError(client.getManifestWithDiagnostics({
     auth: authContext,
     includeIntegrationTriggers: true,
     inlineAgentNodes: true,
@@ -1015,10 +814,32 @@ async function pullRemoteNodes() {
     excludeIntsvcConnectorHttpRequest: true
   }));
   if (!manifestError) {
+    const nodes = diagnostics.manifest.nodes || [];
+    if (diagnostics.failures.length === 0) {
+      return {
+        nodes,
+        source: "authenticated",
+        cacheable: true,
+        scope: nodeCacheScope(loginStatus)
+      };
+    }
+    const failures = toPullFailures(diagnostics.failures);
+    const ootbOnly = failures.some((failure) => failure.source === MANIFEST_VALIDATION_SOURCE);
+    if (!ootbOnly) {
+      return {
+        nodes,
+        source: "authenticated",
+        cacheable: true,
+        scope: nodeCacheScope(loginStatus),
+        missingSources: failures
+      };
+    }
     return {
-      nodes: manifest.nodes || [],
-      source: "authenticated",
-      cacheable: true
+      nodes,
+      source: "ootb",
+      cacheable: false,
+      failures,
+      info: "The tenant manifest failed validation; using OOTB nodes without updating cache."
     };
   }
   const fallbackManifest = await client.getManifest({
@@ -1038,19 +859,78 @@ async function getNodesWithCacheFallback() {
       throw error;
     }
     const pullResult = await pullRemoteNodes();
+    if (pullResult.failures?.length) {
+      throw new TenantManifestInvalidError(pullResult.failures, pullResult.nodes);
+    }
     if (pullResult.cacheable) {
-      await saveNodeIndex(pullResult.nodes);
+      await saveNodeIndex(pullResult.nodes, pullResult.scope, pullResult.missingSources);
     }
     return pullResult.nodes;
   }
   return nodes;
 }
-async function getLocalSolutionNodes() {
+async function loadCurrentTenantNodes(options = {}) {
+  const [loginError, readStatus] = await catchError(getLoginStatusAsync());
+  const loginStatus = loginError ? { loginStatus: "Not logged in" } : readStatus;
+  const scope = loginScope(loginStatus);
+  if (!options.force && scope !== undefined) {
+    const [, cached] = await catchError(loadScopedNodeIndex(scope));
+    if (cached && isFreshFor(cached.metadata, scope)) {
+      return { nodes: cached.nodes, fromCache: true, source: "cache" };
+    }
+  }
+  const pullResult = await pullRemoteNodes(loginStatus);
+  if (pullResult.cacheable) {
+    await catchError(commitNodeIndex(pullResult.nodes, pullResult.scope, pullResult.missingSources));
+  }
+  return {
+    nodes: pullResult.nodes,
+    fromCache: false,
+    source: pullResult.source,
+    info: pullResult.info
+  };
+}
+async function getLocalSolutionSnapshot() {
   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);
+  return buildInSolutionNodes(ctx);
+}
+async function getLocalSolutionNodes() {
+  return (await getLocalSolutionSnapshot()).manifests;
+}
+function localContractWarning(snapshot, shown) {
+  const types = new Set(shown.map((n) => n.nodeType).filter((t) => typeof t === "string").map((t) => t.toLowerCase()));
+  return unknownContractWarning(snapshot.unknownContracts.filter((p) => p.nodeTypes.some((t) => types.has(t.toLowerCase()))));
+}
+function filterNodesByKeyword(nodes, keyword) {
+  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;
+  });
+}
+function findNodeByType(nodes, nodeType) {
+  const lowerNodeType = nodeType.toLowerCase();
+  return nodes.find((node) => node.nodeType?.toLowerCase() === lowerNodeType) ?? null;
 }
 async function listNodes(options) {
   if (options?.local)
@@ -1161,28 +1041,7 @@ async function searchNodes(keyword, options) {
     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;
-  });
+  return filterNodesByKeyword(nodes, keyword);
 }
 async function getNode(nodeType, options) {
   const lowerNodeType = nodeType.toLowerCase();
@@ -1193,13 +1052,23 @@ async function getNode(nodeType, options) {
   }
   if (!options?.local && isEssentialNodeType(nodeType)) {
     const essentials = await loadEssentialsIndexWithRepair();
-    const node2 = essentials?.find((node3) => node3.nodeType?.toLowerCase() === lowerNodeType) ?? null;
-    if (node2)
-      return node2;
+    const node = essentials?.find((node2) => node2.nodeType?.toLowerCase() === lowerNodeType) ?? null;
+    if (node)
+      return node;
+  }
+  if (options?.local) {
+    return findNodeByType(await getLocalSolutionNodes(), nodeType);
   }
-  const nodes = options?.local ? await getLocalSolutionNodes() : await getNodesWithCacheFallback();
-  const node = nodes.find((node2) => node2.nodeType?.toLowerCase() === lowerNodeType) ?? null;
-  return node;
+  const [error, nodes] = await catchError(getNodesWithCacheFallback());
+  if (error) {
+    if (error instanceof TenantManifestInvalidError) {
+      const ootbNode = findNodeByType(error.ootbNodes, nodeType);
+      if (ootbNode)
+        return ootbNode;
+    }
+    throw error;
+  }
+  return findNodeByType(nodes, nodeType);
 }
 async function getNodeEnriched(nodeType, connectionId, options) {
   const node = await getNode(nodeType, options);
@@ -1208,6 +1077,16 @@ async function getNodeEnriched(nodeType, connectionId, options) {
   }
   return await enrichConnectorNode(node, connectionId);
 }
+async function getLocalNodeEnriched(nodeType, connectionId) {
+  const snapshot = await getLocalSolutionSnapshot();
+  const node = findNodeByType(snapshot.manifests, nodeType);
+  if (!node)
+    return { node: null };
+  return {
+    node: await enrichConnectorNode(node, connectionId),
+    warning: localContractWarning(snapshot, [node])
+  };
+}
 async function searchNodesWithFilters(keyword, filters, options) {
   let nodes;
   if (options?.local) {
@@ -1219,6 +1098,6 @@ async function searchNodesWithFilters(keyword, filters, options) {
   return searchWithFilters(nodes, keyword, filters);
 }
 
-export { extractTriggerEventParameters, extractTriggerFilterFields, extractActivityFilterFields, fetchConnectorTriggerMetadata, fetchConnectionInfo, fetchConnectorMetadata, findSolutionFromCwd, pullNodes, pullRemoteNodes, listNodes, searchNodeSummariesWithAvailability, searchNodes, getNode, getNodeEnriched, searchNodesWithFilters };
+export { isConnectorNode, isConnectorTriggerNode, extractTriggerEventParameters, extractTriggerFilterFields, extractActivityFilterFields, fetchConnectorTriggerMetadata, getConnectorConfiguration, getConnectorInfo, fetchConnectionInfo, fetchConnectorMetadata, fetchConnectorActivityMetadataV4, enrichConnectorNode, resolveNodeStorageDir, saveNodeIndex, loadNodeIndex, saveIndexMetadata, loadIndexMetadata, MANIFEST_VALIDATION_NEXT_STEP, TenantManifestInvalidError, isTenantManifestInvalidError, pullNodes, pullRemoteNodes, loadCurrentTenantNodes, getLocalSolutionSnapshot, localContractWarning, filterNodesByKeyword, findNodeByType, listNodes, searchNodeSummariesWithAvailability, searchNodes, getNode, getNodeEnriched, getLocalNodeEnriched, searchNodesWithFilters };
 
-//# debugId=286F80C1F5E6E17264756E2164756E21
+//# debugId=84A6547C9B12968064756E2164756E21