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

package/dist/packager-tool-6c3szt0w.js

@@ -1,265 +0,0 @@
-import {
-  ensureDirectory
-} from "./packager-tool-pz5nqg0s.js";
-import {
-  buildInlineAgentContract,
-  isInlineAgentNodeType,
-  operateRuntimeOptions,
-  readInlineAgentSource
-} from "./packager-tool-0d375dbz.js";
-import {
-  withRuntimeProfile
-} from "./packager-tool-hhy1gr2k.js";
-import {
-  EntryPointType,
-  ProjectType,
-  generateBindingsJson,
-  generateEntryPointsJson,
-  generateOperateJson,
-  getBindingResources,
-  getEntryPoints,
-  isConversationalOrVoiceAgentNodeType,
-  mergeBindingResources
-} from "./packager-tool-bhqx9kez.js";
-import {
-  catchError,
-  logger
-} from "./packager-tool-02f63a08.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 = withRuntimeProfile(generateOperateJson(projectId, mainEntryPoint, operateRuntimeOptions(packagingNodes)), options.profile ?? "Standard" /* Standard */);
-  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=FF54069E2277B66C64756E2164756E21

package/dist/packager-tool-8ak76pc3.js

@@ -1,15 +0,0 @@
-import {
-  FlowToolFactory
-} from "./packager-tool-0d375dbz.js";
-import {
-  toolsFactoryRepository
-} from "./packager-tool-stq8800d.js";
-
-// src/packager-tool.ts
-function registerPackagerFactories() {
-  toolsFactoryRepository.registerProjectToolFactory(new FlowToolFactory);
-}
-
-export { registerPackagerFactories };
-
-//# debugId=094DABA57E9A36F764756E2164756E21

package/dist/packager-tool-pz5nqg0s.js

@@ -1,64 +0,0 @@
-import {
-  catchError
-} from "./packager-tool-02f63a08.js";
-
-// src/services/flow-eval-file-store.ts
-async function ensureDirectory(fs, path) {
-  if (await fs.exists(path)) {
-    return;
-  }
-  const parent = fs.path.dirname(path);
-  if (parent && parent !== path && !await fs.exists(parent)) {
-    await ensureDirectory(fs, parent);
-  }
-  const [error] = await catchError(fs.mkdir(path));
-  if (error && !await fs.exists(path)) {
-    throw error;
-  }
-}
-
-class FlowEvalFileStore {
-  fs;
-  constructor(fs) {
-    this.fs = fs;
-  }
-  async readJsonFiles(dir) {
-    const [readDirError, files] = await catchError(this.fs.readdir(dir));
-    if (readDirError) {
-      return [];
-    }
-    const items = [];
-    for (const file of files) {
-      if (!file.endsWith(".json")) {
-        continue;
-      }
-      const filePath = this.fs.path.join(dir, file);
-      const [readError, raw] = await catchError(this.fs.readFile(filePath, "utf-8"));
-      if (readError) {
-        throw new Error(`Failed to read JSON file "${filePath}": ${readError.message}`);
-      }
-      if (raw === null) {
-        continue;
-      }
-      const [parseError, data] = catchError(() => JSON.parse(String(raw)));
-      if (parseError) {
-        throw new Error(`Invalid JSON in "${filePath}": ${parseError.message}`);
-      }
-      data.fileName = file;
-      items.push(data);
-    }
-    return items;
-  }
-  async writeJsonFile(path, value) {
-    await ensureDirectory(this.fs, this.fs.path.dirname(path));
-    await this.fs.writeFile(path, `${JSON.stringify(value, null, 2)}
-`);
-  }
-  async remove(path) {
-    await this.fs.rm(path);
-  }
-}
-
-export { ensureDirectory, FlowEvalFileStore };
-
-//# debugId=2DF0307602E51A6664756E2164756E21