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

package/dist/{packager-tool-zbrda9sn.js → packager-tool-rk25wp3c.js}

@@ -1,6 +1,6 @@
 import {
   getAuthContext
-} from "./packager-tool-v99ygh9f.js";
+} from "./packager-tool-yn33pw57.js";
 
 // ../solution-sdk/src/solution-auth.ts
 async function getSolutionAuthContext(options) {

package/dist/{packager-tool-xcd87qyx.js → packager-tool-v2kcgjbf.js}

@@ -7,7 +7,6 @@ import {
 } from "./packager-tool-nj4seavy.js";
 
 // src/utils/case-document.ts
-var CASE_PLAN_FILENAME = "caseplan.json";
 function buildMinimalCaseDocument(options) {
   return {
     id: prefixedId("case-", 10),
@@ -39,6 +38,6 @@ function buildMinimalCaseDocument(options) {
   };
 }
 
-export { CASE_PLAN_FILENAME, buildMinimalCaseDocument };
+export { buildMinimalCaseDocument };
 
-//# debugId=5271E14EC19FCE1A64756E2164756E21
+//# debugId=F5C6C653548DE78B64756E2164756E21

package/dist/{case-bindings-service-d9vezn69.js → packager-tool-wekqkmgn.js}

@@ -3,11 +3,10 @@ import {
 } from "./packager-tool-5qp9xza1.js";
 import {
   catchError
-} from "./packager-tool-3q3d1hk8.js";
+} from "./packager-tool-83v804p7.js";
 import {
   getFileSystem
-} from "./packager-tool-xdxr3ync.js";
-import"./packager-tool-1yh8g550.js";
+} from "./packager-tool-hdxtgckw.js";
 
 // src/services/bindings-v2.ts
 var BINDINGS_V2_FILE_NAME = "bindings_v2.json";
@@ -36,6 +35,18 @@ var readBindingsV2Resources = (raw) => {
   return resources.filter((entry) => entry !== null && typeof entry === "object" && typeof entry.key === "string");
 };
 var identity = (entry) => `${entry.resource}:${entry.key}`;
+var asSaved = (entry, found) => {
+  let saved = entry;
+  if (entry.resource === "Connection" && entry.value[FOLDER_KEY_PROPERTY] !== undefined && found.value?.[FOLDER_KEY_PROPERTY] === undefined) {
+    const { [FOLDER_KEY_PROPERTY]: _dropped, ...value } = entry.value;
+    saved = { ...saved, value };
+  }
+  if (saved.metadata?.ActivityName !== undefined && found.metadata?.ActivityName === undefined) {
+    const { ActivityName: _label, ...metadata } = saved.metadata;
+    saved = { ...saved, metadata };
+  }
+  return saved;
+};
 var diffBindingsV2 = (expected, actual) => {
   const expectedByKey = new Map(expected.map((e) => [identity(e), e]));
   const actualByKey = new Map(actual.map((e) => [identity(e), e]));
@@ -45,7 +56,7 @@ var diffBindingsV2 = (expected, actual) => {
     const found = actualByKey.get(key);
     if (found === undefined) {
       missing.push(entry.key);
-    } else if (JSON.stringify(found) !== JSON.stringify(entry)) {
+    } else if (JSON.stringify(found) !== JSON.stringify(asSaved(entry, found))) {
       changed.push(entry.key);
     }
   }
@@ -86,7 +97,9 @@ function entryPointIdsByNode(entryPoints) {
     const hash = filePath?.lastIndexOf("#") ?? -1;
     if (filePath === undefined || uniqueId === undefined || hash < 0)
       continue;
-    ids.set(filePath.slice(hash + 1), uniqueId);
+    const node = filePath.slice(hash + 1);
+    if (!ids.has(node))
+      ids.set(node, uniqueId);
   }
   return ids;
 }
@@ -247,230 +260,6 @@ function deriveEventTriggerResources(nodes, bindings, entryPointIds) {
   });
 }
 
-// src/services/case-bindings-service.ts
-var asBinding = (value) => {
-  if (value === null || typeof value !== "object" || Array.isArray(value)) {
-    return;
-  }
-  const record = value;
-  return typeof record.id === "string" && typeof record.resource === "string" && typeof record.resourceKey === "string" && record.resourceKey !== "" && typeof record.propertyAttribute === "string" && (record.default === undefined || typeof record.default === "string") ? value : undefined;
-};
-var CONNECTION_RESOURCE = "Connection";
-var NAME_ATTRIBUTE = "name";
-var FOLDER_PATH_ATTRIBUTE = "folderPath";
-var SOLUTION_FOLDER_PREFIX = "solution_folder.";
-var SOLUTION_FOLDER_SENTINEL = "solution_folder";
-var BINDING_REFERENCE_PREFIX2 = "=bindings.";
-var CONNECTOR_KEY_ENTRY = "connectorKey";
-var CONNECTION_ENTRY = "connection";
-var readConnectorContext = (value) => {
-  if (!Array.isArray(value))
-    return;
-  const byName = new Map;
-  for (const entry of value) {
-    if (entry === null || typeof entry !== "object" || Array.isArray(entry))
-      return;
-    const { name, value: entryValue } = entry;
-    if (typeof name !== "string")
-      return;
-    if (typeof entryValue === "string")
-      byName.set(name, entryValue);
-  }
-  return byName.has(CONNECTOR_KEY_ENTRY) ? byName : undefined;
-};
-var ownLabel = (node) => {
-  const record = node;
-  for (const candidate of [
-    record.displayName,
-    record.display?.label,
-    record.label
-  ]) {
-    if (typeof candidate === "string" && candidate !== "")
-      return candidate;
-  }
-  return;
-};
-var collectConnectorKeys = (document) => {
-  const byBindingId = new Map;
-  const visit = (node, label) => {
-    if (Array.isArray(node)) {
-      const context = readConnectorContext(node);
-      const connection = context?.get(CONNECTION_ENTRY);
-      const connectorKey = context?.get(CONNECTOR_KEY_ENTRY);
-      const bindingId = connection?.startsWith(BINDING_REFERENCE_PREFIX2) ? connection.slice(BINDING_REFERENCE_PREFIX2.length) : undefined;
-      if (connectorKey !== undefined && bindingId !== undefined && !byBindingId.has(bindingId)) {
-        byBindingId.set(bindingId, {
-          connectorKey,
-          activityName: label
-        });
-      }
-      for (const item of node)
-        visit(item, label);
-      return;
-    }
-    if (node === null || typeof node !== "object")
-      return;
-    const scoped = ownLabel(node) ?? label;
-    for (const value of Object.values(node))
-      visit(value, scoped);
-  };
-  visit(document, undefined);
-  return byBindingId;
-};
-var attributeDefault = (group, attribute) => group.find((binding) => binding.propertyAttribute === attribute)?.default;
-var connectionEntry = (group, connectorKeys) => {
-  const key = group[0].resourceKey;
-  const value = {
-    [CONNECTION_ID_PROPERTY]: {
-      defaultValue: attributeDefault(group, CONNECTION_ID_PROPERTY) ?? key
-    }
-  };
-  const folderKey = attributeDefault(group, FOLDER_KEY_PROPERTY);
-  if (folderKey !== undefined) {
-    value[FOLDER_KEY_PROPERTY] = { defaultValue: folderKey };
-  }
-  const use = group.map((binding) => connectorKeys.get(binding.id)).find((found) => found !== undefined);
-  const displayLabel = (group.find((binding) => binding.propertyAttribute === CONNECTION_ID_PROPERTY) ?? group[0]).name;
-  return {
-    resource: CONNECTION_RESOURCE,
-    key,
-    id: `${CONNECTION_RESOURCE}${key}`,
-    value,
-    metadata: {
-      ...use?.activityName !== undefined && {
-        ActivityName: use.activityName
-      },
-      BindingsVersion: RESOURCE_BINDINGS_VERSION,
-      ...typeof displayLabel === "string" && displayLabel !== "" && { DisplayLabel: displayLabel },
-      UseConnectionService: "true",
-      ...use !== undefined && { Connector: use.connectorKey }
-    }
-  };
-};
-var resourceEntry = (group) => {
-  const key = group[0].resourceKey;
-  const value = {};
-  const name = attributeDefault(group, NAME_ATTRIBUTE);
-  if (name !== undefined)
-    value.name = { defaultValue: name };
-  const folderPath = key.startsWith(SOLUTION_FOLDER_PREFIX) ? SOLUTION_FOLDER_SENTINEL : attributeDefault(group, FOLDER_PATH_ATTRIBUTE);
-  if (folderPath !== undefined) {
-    value.folderPath = { defaultValue: folderPath };
-  }
-  const subType = group.find((binding) => binding.resourceSubType !== undefined)?.resourceSubType;
-  return {
-    resource: group[0].resource,
-    key,
-    value,
-    ...subType !== undefined && { metadata: { subType } }
-  };
-};
-var deriveCaseBindingsV2 = (document, entryPointIds = new Map) => {
-  const connectorKeys = collectConnectorKeys(document);
-  const groups = new Map;
-  const bindings = [];
-  for (const entry of Array.isArray(document.bindings) ? document.bindings : []) {
-    const binding = asBinding(entry);
-    if (binding === undefined)
-      continue;
-    bindings.push(binding);
-    const groupKey = `${binding.resource}:${binding.resourceKey}`;
-    const group = groups.get(groupKey);
-    if (group === undefined)
-      groups.set(groupKey, [binding]);
-    else
-      group.push(binding);
-  }
-  return [
-    ...[...groups.values()].map((group) => group[0].resource === CONNECTION_RESOURCE ? connectionEntry(group, connectorKeys) : resourceEntry(group)),
-    ...deriveEventTriggerResources(document.nodes, bindings, entryPointIds)
-  ];
-};
-var bindingsV2PathFor = (casePlanPath) => {
-  const fs = getFileSystem();
-  return fs.path.join(fs.path.dirname(fs.path.resolve(casePlanPath)), BINDINGS_V2_FILE_NAME);
-};
-var compareCaseBindingsV2 = async (casePlanPath, document) => {
-  const fs = getFileSystem();
-  const path = bindingsV2PathFor(casePlanPath);
-  const entryPoints = await readEntryPointIds(casePlanPath);
-  if ("error" in entryPoints) {
-    return {
-      status: "entry-points-unreadable",
-      path: entryPoints.path,
-      expectedCount: 0,
-      reason: entryPoints.error
-    };
-  }
-  const expected = deriveCaseBindingsV2(document, entryPoints.ids);
-  const expectedCount = expected.length;
-  if (!await fs.exists(path))
-    return { status: "absent", path, expectedCount };
-  const [readError, raw] = await catchError(fs.readFile(path, "utf-8"));
-  if (readError || raw == null)
-    return { status: "unreadable", path, expectedCount };
-  const actual = readBindingsV2Resources(raw);
-  if (actual === undefined)
-    return { status: "unreadable", path, expectedCount };
-  const difference = diffBindingsV2(expected, actual);
-  return hasBindingsV2Difference(difference) ? { status: "differs", path, expectedCount, difference } : { status: "match", path, expectedCount };
-};
-var syncCaseBindings = async (casePlanPath) => {
-  const fs = getFileSystem();
-  const resolved = fs.path.resolve(casePlanPath);
-  if (!await fs.exists(resolved)) {
-    return {
-      ok: false,
-      message: `Case plan file not found: ${resolved}`,
-      instructions: "Pass the path to an existing caseplan JSON file, for example 'uip maestro case bindings sync case.json'."
-    };
-  }
-  const [readError, raw] = await catchError(fs.readFile(resolved, "utf-8"));
-  if (readError || raw == null) {
-    return {
-      ok: false,
-      message: `Failed to read case plan: ${readError?.message ?? "empty content"}`,
-      instructions: `Verify read permissions on ${resolved}.`
-    };
-  }
-  const [parseError, document] = catchError(() => JSON.parse(raw));
-  if (parseError || document == null || typeof document !== "object" || Array.isArray(document)) {
-    return {
-      ok: false,
-      message: `Case plan is not valid JSON: ${parseError?.message ?? "not a JSON object"}`,
-      instructions: `Verify the contents of ${resolved}.`
-    };
-  }
-  const entryPoints = await readEntryPointIds(resolved);
-  if ("error" in entryPoints) {
-    return {
-      ok: false,
-      message: entryPoints.error,
-      instructions: `Fix or remove ${entryPoints.path}, then run \`uip maestro case bindings sync\` again.`
-    };
-  }
-  const resources = deriveCaseBindingsV2(document, entryPoints.ids);
-  const path = bindingsV2PathFor(resolved);
-  const [writeError] = await catchError(fs.writeFile(path, serializeBindingsV2File(resources)));
-  if (writeError) {
-    return {
-      ok: false,
-      message: `Failed to write bindings file: ${writeError.message}`,
-      instructions: `Verify write permissions on ${fs.path.dirname(path)}.`
-    };
-  }
-  return {
-    ok: true,
-    path,
-    resourceCount: resources.length,
-    connectionCount: resources.filter((entry) => entry.resource === CONNECTION_RESOURCE).length
-  };
-};
-export {
-  bindingsV2PathFor,
-  compareCaseBindingsV2,
-  deriveCaseBindingsV2,
-  syncCaseBindings
-};
+export { BINDINGS_V2_FILE_NAME, CONNECTION_ID_PROPERTY, FOLDER_KEY_PROPERTY, RESOURCE_BINDINGS_VERSION, serializeBindingsV2File, readBindingsV2Resources, diffBindingsV2, hasBindingsV2Difference, entryPointIdsByNode, readEntryPointIds, deriveEventTriggerResources };
 
-//# debugId=DF4BCD662409114064756E2164756E21
+//# debugId=27D60FC3500F9DFB64756E2164756E21

package/dist/packager-tool-yct6zp4m.js

@@ -0,0 +1,335 @@
+import {
+  extractIOFromEntryPoints,
+  getServiceType,
+  taskDefinitionsToNodeManifests,
+  withErrorHandles
+} from "./packager-tool-4rtktkhv.js";
+import {
+  catchError,
+  logger,
+  quoteForShell
+} from "./packager-tool-83v804p7.js";
+import {
+  getFileSystem
+} from "./packager-tool-hdxtgckw.js";
+
+// ../maestro-sdk/src/registry/agent-metadata-reader.ts
+var agentProjectMetadataReader;
+function setAgentProjectMetadataReader(reader) {
+  agentProjectMetadataReader = reader;
+}
+function getAgentProjectMetadataReader() {
+  return agentProjectMetadataReader;
+}
+
+// ../maestro-sdk/src/registry/solution-discovery.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+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;
+    }
+  }
+  return;
+}
+function solutionSearchDirs() {
+  const fs = getFileSystem();
+  const cwd = fs.env.cwd();
+  return [cwd, fs.path.resolve(cwd, ".."), fs.path.resolve(cwd, "../..")];
+}
+async function readSolutionAt(dir) {
+  const fs = getFileSystem();
+  const [readErr, entries] = await catchError(fs.readdir(dir));
+  if (readErr)
+    return null;
+  const uipxName = entries.find((e) => e.endsWith(".uipx"));
+  if (!uipxName)
+    return null;
+  const uipxPath = fs.path.join(dir, uipxName);
+  const [fileErr, content] = await catchError(fs.readFile(uipxPath, "utf-8"));
+  if (fileErr || !content)
+    return null;
+  const [parseErr, parsed] = catchError(() => JSON.parse(content));
+  if (parseErr || !parsed.SolutionId)
+    return null;
+  return {
+    solutionId: parsed.SolutionId,
+    solutionDir: dir,
+    projects: parsed.Projects ?? []
+  };
+}
+async function findSolutionFromCwd() {
+  const cwd = getFileSystem().env.cwd();
+  for (const dir of solutionSearchDirs()) {
+    const solution = await readSolutionAt(dir);
+    if (solution === null)
+      continue;
+    return {
+      ...solution,
+      currentProjectId: findEnclosingProjectId(dir, solution.projects, cwd)
+    };
+  }
+  return null;
+}
+async function resolveProjectEntryPointIO(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.io)
+    return { io: fromSource.io, contract: "known" };
+  const fromFlow = await readProjectIOFromFlowVariables(projectDir);
+  if (fromFlow.io)
+    return { io: fromFlow.io, contract: "known" };
+  const fromBuild = await readEntryPointsFile(fs.path.join(projectDir, ".local", "content", "entry-points.json"));
+  if (fromBuild.io)
+    return { io: fromBuild.io, contract: "known" };
+  const states = [fromSource.state, fromFlow.state, fromBuild.state];
+  const contract = states.includes("valid") ? "known" : states.includes("invalid") ? "unreadable" : "missing";
+  return { io: EMPTY_IO, contract };
+}
+async function readEntryPointsFile(...candidates) {
+  const fs = getFileSystem();
+  let state = "absent";
+  for (const filePath of candidates) {
+    const [err, content] = await catchError(fs.readFile(filePath, "utf-8"));
+    if (err || content === null)
+      continue;
+    const [parseErr, parsed] = catchError(() => JSON.parse(content));
+    const entryPoints = parsed?.entryPoints;
+    if (parseErr || !Array.isArray(entryPoints) || entryPoints.length > 0 && !isRecord(entryPoints[0])) {
+      if (state === "absent")
+        state = "invalid";
+      continue;
+    }
+    state = "valid";
+    if (entryPoints.length === 0)
+      continue;
+    return { io: extractIOFromEntryPoints({ entryPoints }), state };
+  }
+  return { state };
+}
+async function readProjectIOFromFlowVariables(projectDir) {
+  const fs = getFileSystem();
+  const [readErr, entries] = await catchError(fs.readdir(projectDir));
+  if (readErr || !Array.isArray(entries))
+    return { state: "absent" };
+  const flowFileName = entries.find((entry) => entry.endsWith(".flow"));
+  if (!flowFileName)
+    return { state: "absent" };
+  const flowPath = fs.path.join(projectDir, flowFileName);
+  const [readFileErr, content] = await catchError(fs.readFile(flowPath, "utf-8"));
+  if (readFileErr || !content)
+    return { state: "invalid" };
+  const [parseErr, parsed] = catchError(() => JSON.parse(content));
+  if (parseErr || !isRecord(parsed))
+    return { state: "invalid" };
+  const variables = parsed.variables;
+  if (variables !== undefined && !isRecord(variables))
+    return { state: "invalid" };
+  const globals = variables?.globals;
+  if (globals !== undefined && (!Array.isArray(globals) || !globals.every(isRecord)))
+    return { state: "invalid" };
+  if (!globals || globals.length === 0)
+    return { state: "valid" };
+  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 { state: "valid" };
+  const synthetic = {
+    entryPoints: [
+      {
+        filePath: flowFileName,
+        input: hasInputs ? { type: "object", properties: inputProps } : undefined,
+        output: hasOutputs ? { type: "object", properties: outputProps } : undefined
+      }
+    ]
+  };
+  return { io: extractIOFromEntryPoints(synthetic), state: "valid" };
+}
+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 && isRecord(parsed) && typeof parsed.Name === "string" && parsed.Name.length > 0) {
+      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 || !isRecord(parsed))
+        continue;
+      const resource = parsed.resource;
+      if (!isRecord(resource))
+        continue;
+      const projectKey = resource.projectKey;
+      const resourceKey = resource.key;
+      if (typeof projectKey === "string" && projectKey.length > 0 && typeof resourceKey === "string" && resourceKey.length > 0) {
+        map.set(projectKey.toLowerCase(), resourceKey);
+      }
+    }
+  }
+  return map;
+}
+function invokableSiblings(ctx) {
+  const fs = getFileSystem();
+  const currentId = ctx.currentProjectId?.toLowerCase();
+  return ctx.projects.flatMap((project) => {
+    const serviceType = getServiceType(project.Type);
+    if (!serviceType)
+      return [];
+    if (typeof project.Id !== "string")
+      return [];
+    if (project.Id.toLowerCase() === currentId)
+      return [];
+    const projectDir = fs.path.resolve(ctx.solutionDir, fs.path.dirname(project.ProjectRelativePath));
+    return [{ project, serviceType, projectDir }];
+  });
+}
+async function buildInSolutionNodes(ctx) {
+  const manifests = [];
+  const unknownContracts = [];
+  const resourceKeyMap = await loadResourceKeyMap(ctx.solutionDir);
+  for (const { project, serviceType, projectDir } of invokableSiblings(ctx)) {
+    const resourceKey = resourceKeyMap.get(project.Id.toLowerCase());
+    if (!resourceKey)
+      continue;
+    const reader = getAgentProjectMetadataReader();
+    const [name, { io, contract }, projectMetadata] = await Promise.all([
+      readProjectName(projectDir),
+      resolveProjectEntryPointIO(projectDir),
+      reader ? reader(projectDir, project.Type).catch((err) => {
+        logger.debug(`Agent metadata reader failed for ${projectDir}: ${String(err)}`);
+        return {};
+      }) : Promise.resolve({})
+    ]);
+    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);
+    if (contract !== "known") {
+      unknownContracts.push({
+        name,
+        type: project.Type,
+        projectDir,
+        nodeTypes: nodes.map((n) => n.nodeType).filter((t) => typeof t === "string"),
+        contract
+      });
+    }
+  }
+  return { manifests: withErrorHandles(manifests), unknownContracts };
+}
+function unknownContractWarning(projects) {
+  if (projects.length === 0)
+    return;
+  const describe = (p) => `'${p.name}' (${p.type}, ${p.projectDir}): ${p.contract === "missing" ? "no entry-points.json yet" : "its entry-points.json or .flow file could not be read"}`;
+  const one = projects.length === 1;
+  const steps = [];
+  if (projects.some((p) => p.contract === "missing"))
+    steps.push("build the project so it writes entry-points.json");
+  if (projects.some((p) => p.contract === "unreadable"))
+    steps.push("fix the file that could not be read");
+  const next = steps.join(", and ");
+  return `No usable argument contract for ${projects.map(describe).join("; ")}. ` + `${one ? "Its node shows" : "Their nodes show"} no inputs or outputs; the arguments are unknown, not empty. ` + `${next[0].toUpperCase()}${next.slice(1)}, then run this command again.`;
+}
+async function findProjectsWithoutProcessResource(ctx) {
+  const resourceKeyMap = await loadResourceKeyMap(ctx.solutionDir);
+  return Promise.all(invokableSiblings(ctx).filter(({ project }) => !resourceKeyMap.has(project.Id.toLowerCase())).map(async ({ project, projectDir }) => ({
+    id: project.Id,
+    name: await readProjectName(projectDir),
+    type: project.Type
+  })));
+}
+function describeProjectsWithoutProcessResource(projects, solutionDir) {
+  if (projects.length === 0)
+    return {};
+  const names = projects.map((p) => `${p.name} (${p.type})`).join(", ");
+  return {
+    Warning: projects.length === 1 ? `Left out 1 project that has no process resource yet: ${names}.` : `Left out ${projects.length} projects that have no process resource yet: ${names}.`,
+    Instructions: `Create the missing process resources, then list the in-solution nodes again to get their node types. Run: ${resourcesRefreshCommand(solutionDir)}`
+  };
+}
+async function explainNodeTypeWithoutProcessResource(nodeType) {
+  const ctx = await findSolutionFromCwd();
+  if (!ctx)
+    return;
+  const lowerNodeType = nodeType.toLowerCase();
+  const project = (await findProjectsWithoutProcessResource(ctx)).find((p) => lowerNodeType.endsWith(`.${p.id.toLowerCase()}`));
+  if (!project)
+    return;
+  return {
+    message: `Project '${project.name}' has no process resource yet, so it has no node type.`,
+    instructions: `Create its process resource, then list the in-solution nodes to get its node type. Run: ${resourcesRefreshCommand(ctx.solutionDir)}`
+  };
+}
+function resourcesRefreshCommand(solutionDir) {
+  return `uip solution resources refresh --solution-folder ${quoteForShell(solutionDir)}`;
+}
+
+export { setAgentProjectMetadataReader, solutionSearchDirs, readSolutionAt, findSolutionFromCwd, resolveProjectEntryPointIO, loadResourceKeyMap, buildInSolutionNodes, unknownContractWarning, findProjectsWithoutProcessResource, describeProjectsWithoutProcessResource, explainNodeTypeWithoutProcessResource, resourcesRefreshCommand };
+
+//# debugId=C0E01C7FA4AA2D1564756E2164756E21

package/dist/{packager-tool-kpqr938m.js → packager-tool-ydyvtknp.js}

@@ -1,6 +1,6 @@
 import {
   catchError
-} from "./packager-tool-3q3d1hk8.js";
+} from "./packager-tool-83v804p7.js";
 
 // src/services/schema-utils.ts
 function getMutatedType(variable) {
@@ -303,6 +303,29 @@ function mapVariablesToInputOutput(variables, getTypeFromVar, isOutput, existing
 function mapEntryPointVariablesToInputOutput(entryPointVariables, isOutput, existingInputOutputs = []) {
   return mapVariablesToInputOutput(entryPointVariables, (v) => v.type, isOutput, existingInputOutputs, (v) => v);
 }
+var RESULT_OUTPUT_NAME = "output";
+var RESULT_OUTPUT_SOURCE = "=result";
+var HTTP_REQUEST_OUTPUT_SOURCES = {
+  code: "=response.code",
+  headers: "=response.headers",
+  body: "=response.body",
+  error: "=Error"
+};
+var httpRequestOutputName = (field) => {
+  const name = field.trim().replace(/^response\./i, "").toLowerCase();
+  return name in HTTP_REQUEST_OUTPUT_SOURCES ? name : undefined;
+};
+var WHOLE_RESULT_TASK_TYPES = new Set(["business-rule"]);
+var outputSourceFor = (taskType, field) => {
+  if (taskType === "http-request") {
+    const name = httpRequestOutputName(field);
+    const own = name === undefined ? undefined : HTTP_REQUEST_OUTPUT_SOURCES[name];
+    if (own !== undefined)
+      return own;
+  }
+  return taskType !== undefined && WHOLE_RESULT_TASK_TYPES.has(taskType) && field === RESULT_OUTPUT_NAME ? RESULT_OUTPUT_SOURCE : `=${field}`;
+};
+var BUSINESS_RULE_TASK_VERSION = "v3";
 function buildErrorOutput() {
   return {
     name: "Error",
@@ -351,6 +374,6 @@ function addVarIdsToInputsOutputs(params) {
   return { inputsWithVars, outputsWithVars };
 }
 
-export { transformSchemaToVariables, convertActionArgsToVariables, FILE_TYPE_JSON_SCHEMA, mapEntryPointVariablesToInputOutput, buildErrorOutput, addVarIdsToInputsOutputs };
+export { transformSchemaToVariables, convertActionArgsToVariables, FILE_TYPE_JSON_SCHEMA, camelizeDisplayName, mapEntryPointVariablesToInputOutput, RESULT_OUTPUT_NAME, RESULT_OUTPUT_SOURCE, httpRequestOutputName, outputSourceFor, BUSINESS_RULE_TASK_VERSION, buildErrorOutput, addVarIdsToInputsOutputs };
 
-//# debugId=DBAEB71CB3648B7264756E2164756E21
+//# debugId=7F1F2D07BCEF978264756E2164756E21