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

package/dist/packager-tool-v86fdwvs.js

@@ -0,0 +1,262 @@
+import {
+  ensureDirectory
+} from "./packager-tool-jc34wvrw.js";
+import {
+  buildInlineAgentContract,
+  isInlineAgentNodeType,
+  operateRuntimeOptions,
+  readInlineAgentSource
+} from "./packager-tool-6m078z5s.js";
+import {
+  catchError,
+  logger
+} from "./packager-tool-5qaxht3k.js";
+import {
+  EntryPointType,
+  ProjectType,
+  generateBindingsJson,
+  generateEntryPointsJson,
+  generateOperateJson,
+  getBindingResources,
+  getEntryPoints,
+  isConversationalOrVoiceAgentNodeType,
+  mergeBindingResources
+} from "./packager-tool-m5qfverj.js";
+
+// src/services/packaging-utils.ts
+function fileNodesToPackagingNodes(nodes) {
+  return nodes.map((node) => ({
+    id: node.id,
+    type: node.type,
+    typeVersion: node.typeVersion ?? "1.0",
+    display: node.display,
+    inputs: node.inputs,
+    outputs: node.outputs,
+    ...node.model ? { model: node.model } : {}
+  }));
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function toResourceList(value) {
+  if (!Array.isArray(value))
+    return;
+  const resources = value.filter(isRecord);
+  return resources.length === value.length ? resources : undefined;
+}
+function normalizePackagingBindingsJson(value) {
+  if (!isRecord(value))
+    return;
+  const resources = toResourceList(value.resources);
+  if (!resources)
+    return;
+  return {
+    ...value,
+    version: typeof value.version === "string" ? value.version : "2.0",
+    resources
+  };
+}
+function emptyPackagingBindingsJson() {
+  return { version: "2.0", resources: [] };
+}
+function mergePackagingBindingsJson(bindingsJsons) {
+  const first = bindingsJsons.find((bindingsJson) => bindingsJson !== undefined);
+  return {
+    ...first ?? emptyPackagingBindingsJson(),
+    resources: mergeBindingResources(bindingsJsons.flatMap((bindingsJson) => bindingsJson?.resources ?? []))
+  };
+}
+var inlineAgentPackagerLogger = {
+  debug: (message) => logger.debug(message),
+  info: (message) => logger.info(message),
+  warn: (message) => logger.warn(message),
+  error: (message) => logger.error(message),
+  progress: (message) => logger.info(message),
+  log: (message, level) => {
+    if (level === "Error" /* Error */)
+      logger.error(message);
+    else if (level === "Warning" /* Warn */)
+      logger.warn(message);
+    else if (level === "Debug" /* Debug */)
+      logger.debug(message);
+    else
+      logger.info(message);
+  },
+  logMessage: (message) => inlineAgentPackagerLogger.log(message.message, message.logLevel)
+};
+async function createInlineAgentContract(fs, agentDir) {
+  const outputPath = fs.path.join(fs.env.tmpdir(), `.inline-agent-contract-${crypto.randomUUID()}`);
+  await fs.mkdir(outputPath);
+  try {
+    const built = await buildInlineAgentContract({
+      fileSystem: fs,
+      logger: inlineAgentPackagerLogger,
+      projectPath: agentDir,
+      outputPath
+    });
+    const bindingsJson = normalizePackagingBindingsJson(built.bindingsJson);
+    if (!bindingsJson) {
+      throw new Error("Agent packager returned an invalid binding contract");
+    }
+    return { agentJson: built.agentJson, bindingsJson };
+  } finally {
+    const [cleanupError] = await catchError(fs.rm(outputPath, { recursive: true }));
+    if (cleanupError) {
+      logger.debug(`Could not remove inline-agent contract directory ${outputPath}: ${cleanupError.message}`);
+    }
+  }
+}
+async function inlineAgentExists(fs, projectDir, source) {
+  const agentJsonPath = fs.path.join(projectDir, source, "agent.json");
+  return fs.exists(agentJsonPath);
+}
+async function packageInlineAgents(fs, projectDir, nodes) {
+  const result = [];
+  for (const node of nodes) {
+    if (!isInlineAgentNodeType(node.type))
+      continue;
+    const source = readInlineAgentSource(node);
+    if (!source)
+      continue;
+    if (/[/\\.]/.test(source))
+      continue;
+    if (!await inlineAgentExists(fs, projectDir, source))
+      continue;
+    const contract = await createInlineAgentContract(fs, fs.path.join(projectDir, source));
+    const inputSchema = contract.agentJson.inputSchema ?? {
+      type: "object",
+      properties: {}
+    };
+    const outputSchema = contract.agentJson.outputSchema ?? {
+      type: "object",
+      properties: {}
+    };
+    result.push({
+      source,
+      entryPoint: {
+        filePath: `content/${source}/agent.json`,
+        uniqueId: contract.agentJson.projectId ?? source,
+        type: EntryPointType.Agent,
+        input: inputSchema,
+        output: outputSchema,
+        displayName: contract.agentJson.name ?? "Agent"
+      },
+      agentJson: contract.agentJson,
+      bindingsJson: contract.bindingsJson
+    });
+    logger.info(`Packaged inline agent "${source}" for entry-points`);
+  }
+  return result;
+}
+async function stageInlineAgentPackageFiles(fs, sourceProjectPath, stagingProjectDir, inlineAgents, formatLogMessage) {
+  for (const agent of inlineAgents) {
+    const srcDir = fs.path.join(sourceProjectPath, agent.source);
+    const destDir = fs.path.join(stagingProjectDir, agent.source);
+    if (fs.path.resolve(srcDir) !== fs.path.resolve(destDir) && await fs.exists(srcDir)) {
+      await fs.copyDirectory(srcDir, destDir);
+    }
+    const agentBuilderDir = fs.path.join(destDir, ".agent-builder");
+    await ensureDirectory(fs, agentBuilderDir);
+    await fs.writeFile(fs.path.join(agentBuilderDir, "agent.json"), JSON.stringify({
+      ...agent.agentJson,
+      resources: agent.agentJson.resources ?? [],
+      features: agent.agentJson.features ?? []
+    }, null, 2));
+    await fs.writeFile(fs.path.join(agentBuilderDir, "bindings.json"), `${JSON.stringify(agent.bindingsJson ?? emptyPackagingBindingsJson(), null, 2)}
+`);
+    logger.info(formatLogMessage(agent.source));
+  }
+}
+function buildInlineAgentDescriptors(nodes) {
+  const out = [];
+  for (const node of nodes) {
+    if (!isInlineAgentNodeType(node.type))
+      continue;
+    const source = readInlineAgentSource(node);
+    if (!source)
+      continue;
+    const label = node.display?.label ?? "Agent";
+    out.push({
+      name: label,
+      agentProjectId: source,
+      isConversational: isConversationalOrVoiceAgentNodeType(node.type),
+      entryPointPath: `${source}/agent.json`
+    });
+  }
+  return out;
+}
+async function writePackagingArtifacts(fs, projectDir, projectId, packagingNodes, bindings, variables, bpmnFileName, startEventId, flowFileName, definitions = [], options = {}) {
+  const { entryPoints } = await writePackagingArtifactsDetailed(fs, projectDir, projectId, packagingNodes, bindings, variables, bpmnFileName, startEventId, flowFileName, definitions, options);
+  return entryPoints;
+}
+async function writePackagingArtifactsDetailed(fs, projectDir, projectId, packagingNodes, bindings, variables, bpmnFileName, startEventId, flowFileName, definitions = [], options = {}) {
+  const flowEntryPoints = getEntryPoints(bpmnFileName, packagingNodes, variables, definitions, ProjectType.Flow);
+  const entryPoints = [
+    ...flowEntryPoints,
+    ...options.additionalEntryPoints ?? []
+  ];
+  await fs.writeFile(fs.path.join(projectDir, "entry-points.json"), `${JSON.stringify(generateEntryPointsJson(entryPoints), null, 2)}
+`);
+  const bindingResources = getBindingResources(packagingNodes, bindings, definitions);
+  const bindingsJson = normalizePackagingBindingsJson(generateBindingsJson(bindingResources)) ?? emptyPackagingBindingsJson();
+  const stagedBindingsJson = mergePackagingBindingsJson([
+    bindingsJson,
+    ...options.additionalBindingsJsons ?? []
+  ]);
+  await fs.writeFile(fs.path.join(projectDir, "bindings_v2.json"), `${JSON.stringify(stagedBindingsJson, null, 2)}
+`);
+  const mainEntryPoint = `/${bpmnFileName}#${startEventId}`;
+  const operateJson = generateOperateJson(projectId, mainEntryPoint, operateRuntimeOptions(packagingNodes));
+  await fs.writeFile(fs.path.join(projectDir, "operate.json"), `${JSON.stringify(operateJson, null, 2)}
+`);
+  const packageDescriptorJson = options.packageDescriptorJson ?? {
+    $schema: "https://cloud.uipath.com/draft/2024-12/package-descriptor",
+    files: {
+      "operate.json": "operate.json",
+      "entry-points.json": "entry-points.json",
+      "bindings.json": "bindings_v2.json",
+      [bpmnFileName]: bpmnFileName,
+      ...flowFileName ? { [flowFileName]: flowFileName } : {}
+    }
+  };
+  await fs.writeFile(fs.path.join(projectDir, "package-descriptor.json"), `${JSON.stringify(packageDescriptorJson, null, 2)}
+`);
+  return { entryPoints, bindingsJson: stagedBindingsJson };
+}
+function backfillNodeModelsFromDefinitions(nodes, definitions) {
+  if (definitions.length === 0)
+    return nodes;
+  const definitionByType = new Map;
+  for (const def of definitions) {
+    if (def?.nodeType)
+      definitionByType.set(def.nodeType, def);
+  }
+  return nodes.map((n) => {
+    if (n.model)
+      return n;
+    const def = definitionByType.get(n.type);
+    if (!def?.model)
+      return n;
+    return { ...n, model: def.model };
+  });
+}
+async function regenerateBindingsFile(fs, flowFilePath) {
+  const absolutePath = fs.path.resolve(flowFilePath);
+  const projectDir = fs.path.dirname(absolutePath);
+  const content = await fs.readFile(absolutePath, "utf-8");
+  if (!content) {
+    throw new Error(`Could not read .flow file at ${absolutePath}`);
+  }
+  const [parseErr, flowData] = catchError(() => JSON.parse(content));
+  if (parseErr) {
+    throw new Error(`Failed to parse .flow file at ${absolutePath}: ${parseErr.message}`);
+  }
+  const packagingNodes = backfillNodeModelsFromDefinitions(fileNodesToPackagingNodes(flowData.nodes ?? []), flowData.definitions ?? []);
+  const bindingResources = getBindingResources(packagingNodes, flowData.bindings ?? [], flowData.definitions ?? []);
+  await fs.writeFile(fs.path.join(projectDir, "bindings_v2.json"), `${JSON.stringify(generateBindingsJson(bindingResources), null, 2)}
+`);
+}
+
+export { fileNodesToPackagingNodes, packageInlineAgents, stageInlineAgentPackageFiles, buildInlineAgentDescriptors, writePackagingArtifacts, writePackagingArtifactsDetailed, regenerateBindingsFile };
+
+//# debugId=D58F45C9E111C57064756E2164756E21