@uipath/flow-tool 1.204.0-preview.255 → 1.205.0-preview.256

package/dist/packager-tool-phw8ydjx.js

@@ -0,0 +1,331 @@
+import {
+  getAgentProjectMetadataReader
+} from "./packager-tool-8qp60s20.js";
+import {
+  extractIOFromEntryPoints,
+  getServiceType,
+  taskDefinitionsToNodeManifests,
+  withErrorHandles
+} from "./packager-tool-dwd6cc01.js";
+import {
+  logger,
+  quoteForShell
+} from "./packager-tool-apawc11t.js";
+import {
+  catchError
+} from "./packager-tool-t7ahhaer.js";
+import {
+  getFileSystem
+} from "./packager-tool-myhbp761.js";
+
+// ../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 { solutionSearchDirs, readSolutionAt, findSolutionFromCwd, resolveProjectEntryPointIO, loadResourceKeyMap, buildInSolutionNodes, unknownContractWarning, findProjectsWithoutProcessResource, describeProjectsWithoutProcessResource, explainNodeTypeWithoutProcessResource, resourcesRefreshCommand };
+
+//# debugId=37AAA458DDB8A49264756E2164756E21

package/dist/{packager-tool-mx0gg6yh.js → packager-tool-q8akejne.js}

@@ -3,7 +3,7 @@ var package_default = {
   name: "@uipath/flow-tool",
   author: "UiPath",
   license: "SEE LICENSE IN LICENSE.txt",
-  version: "1.204.0-preview.255",
+  version: "1.205.0-preview.256",
   description: "Create, debug, and run UiPath Flow projects and jobs.",
   private: false,
   repository: {
@@ -52,15 +52,17 @@ var package_default = {
     "@uipath/auth": "workspace:*",
     "@uipath/builder-sdk": "workspace:*",
     "@uipath/common": "workspace:*",
+    "@uipath/eval-sdk": "workspace:*",
     "@uipath/filesystem": "workspace:*",
     "@uipath/flow-converter": "0.69.3",
-    "@uipath/flow-core": "0.115.4-develop",
+    "@uipath/flow-core": "^0.129.1",
     "@uipath/flow-expression-model": "0.11.4",
-    "@uipath/flow-migrations": "0.56.2",
+    "@uipath/flow-migrations": "^0.71.1",
     "@uipath/flow-schema": "0.68.0",
     "@uipath/integrationservice-sdk": "workspace:*",
     "@uipath/maestro-sdk": "workspace:*",
     "@uipath/orchestrator-sdk": "workspace:*",
+    "@uipath/packager-tool-datafabric": "workspace:*",
     "@uipath/packager-tool-flow": "workspace:*",
     "@uipath/project-packager": "workspace:*",
     "@uipath/solution-sdk": "workspace:*",
@@ -75,4 +77,4 @@ var package_default = {
 
 export { package_default };
 
-//# debugId=186533C14708898664756E2164756E21
+//# debugId=0A4388A16196E3FD64756E2164756E21

package/dist/packager-tool-qcqb9hf8.js

@@ -0,0 +1,26 @@
+import {
+  isStartEventNode
+} from "./packager-tool-bhqx9kez.js";
+
+// ../packager/packager-tool-flow/src/entry-point-triggers.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function entryPointTriggers(nodes) {
+  return nodes.filter((node) => isRecord(node) && typeof node.id === "string" && typeof node.type === "string" && isStartEventNode({
+    id: node.id,
+    type: node.type,
+    typeVersion: typeof node.typeVersion === "string" ? node.typeVersion : "1.0"
+  }));
+}
+function isDefaultEntryPoint(node) {
+  return isRecord(node.inputs) && node.inputs.isDefaultEntryPoint === true || isRecord(node.model) && node.model.isDefaultEntryPoint === true;
+}
+function defaultEntryPointNodeId(nodes) {
+  const triggers = entryPointTriggers(nodes);
+  return (triggers.find(isDefaultEntryPoint) ?? triggers[0])?.id;
+}
+
+export { entryPointTriggers, defaultEntryPointNodeId };
+
+//# debugId=5CDC1671D6970ABC64756E2164756E21