@uipath/flow-tool 1.197.0 → 1.198.0-preview.100

package/dist/packager-tool.js

@@ -25047,6 +25047,7 @@ var require_fast_uri = __commonJS((exports, module) => {
     return uriTokens.join("");
   }
   var URI_PARSE = /^(?:([^#/:?]+):)?(?:\/\/((?:([^#/?@]*)@)?(\[[^#/?\]]+\]|[^#/:?]*)(?::(\d*))?))?([^#?]*)(?:\?([^#]*))?(?:#((?:.|[\n\r])*))?/u;
+  var AUTHORITY_PREFIX = /^(?:[^#/:?]+:)?\/\/([^/?#]*)/;
   function getParseError(parsed, matches) {
     if (matches[2] !== undefined && parsed.path && parsed.path[0] !== "/") {
       return 'URI path must start with "/" when authority is present.';
@@ -25076,6 +25077,11 @@ var require_fast_uri = __commonJS((exports, module) => {
         uri2 = "//" + uri2;
       }
     }
+    const authorityMatch = uri2.match(AUTHORITY_PREFIX);
+    if (authorityMatch !== null && authorityMatch[1].indexOf("\\") !== -1) {
+      parsed.error = "URI authority must not contain a literal backslash.";
+      malformedAuthorityOrPort = true;
+    }
     const matches = uri2.match(URI_PARSE);
     if (matches) {
       parsed.scheme = matches[1];
@@ -25119,7 +25125,7 @@ var require_fast_uri = __commonJS((exports, module) => {
       if (!options.unicodeSupport && (!schemeHandler || !schemeHandler.unicodeSupport)) {
         if (parsed.host && (options.domainHost || schemeHandler && schemeHandler.domainHost) && isIP === false && nonSimpleDomain(parsed.host)) {
           try {
-            parsed.host = URL.domainToASCII(parsed.host.toLowerCase());
+            parsed.host = new URL("http://" + parsed.host).hostname;
           } catch (e) {
             parsed.error = parsed.error || "Host's domain name can not be converted to ASCII: " + e;
           }
@@ -159757,6 +159763,10 @@ class ProjectTool {
     this.logger.info("Pack operation is a noop");
     return ToolResult.success();
   }
+  async cleanupAsync(_options, _cancellationToken) {
+    this.logger.info("Cleanup operation is a noop");
+    return ToolResult.success();
+  }
   async getUiProjectAsync(projectPath) {
     const filePath = Path.join(projectPath, ProjectTool.ProjectFileName);
     if (!await this.fileSystem.exists(filePath)) {
@@ -159836,7 +159846,7 @@ init_dist6();
 // ../packager/packager-tool-flow/package.json
 var package_default = {
   name: "@uipath/packager-tool-flow",
-  version: "1.197.0",
+  version: "1.198.0-preview.100",
   description: "UiPath Flow tool implementation",
   type: "module",
   exports: {
@@ -171779,10 +171789,14 @@ var PROCESS_NODE_PREFIXES = [
   "uipath.core.agent.",
   "uipath.core.api-workflow."
 ];
-var UNRESOLVED_BINDING_PATTERN = /^<bindings\.\w+>$/;
+var CONNECTOR_TOOL_PREFIX = "uipath.agent.resource.tool.connector.";
+var UNRESOLVED_BINDING_PATTERN = /^<bindings\.[^>]+>$/;
 function isProcessNode(nodeType) {
   return PROCESS_NODE_PREFIXES.some((prefix2) => nodeType?.startsWith(prefix2));
 }
+function isConnectorToolNode(nodeType) {
+  return nodeType?.startsWith(CONNECTOR_TOOL_PREFIX) ?? false;
+}
 function extractProcessGuid(nodeType) {
   const match = nodeType.match(/^(?:uipath\.core\.rpa-workflow|uipath\.agent\.resource\.tool\.process|uipath\.core\.agent|uipath\.core\.api-workflow)\.([0-9a-f-]+)$/i);
   if (!match) {
@@ -171834,13 +171848,50 @@ function resolveContextPlaceholders(context, storedName, storedFolder) {
     }
   }
 }
+function createConnectorToolBindings(node, definition95) {
+  const model = definition95.model;
+  const detail = node.inputs?.detail;
+  const connectionId = detail?.connectionId ?? "";
+  const connectionFolderKey = detail?.connectionFolderKey ?? "";
+  const values = model?.bindings?.values ?? [];
+  const connValue = values.find((v2) => v2.propertyAttribute === "ConnectionId");
+  const folderValue = values.find((v2) => v2.propertyAttribute === "FolderKey");
+  const connectionBinding = createBinding2({
+    name: connValue?.name ?? "connection",
+    value: connectionId,
+    resource: "Connection",
+    resourceKey: connectionId,
+    propertyAttribute: "ConnectionId"
+  });
+  const folderKeyBinding = createBinding2({
+    name: folderValue?.name ?? "FolderKey",
+    value: connectionFolderKey,
+    resource: "Connection",
+    resourceKey: connectionId,
+    propertyAttribute: "FolderKey"
+  });
+  return { connectionBinding, folderKeyBinding };
+}
+function resolveConnectorContextPlaceholders(context, storedConnection, storedFolderKey) {
+  if (!context)
+    return;
+  for (const entry of context) {
+    if (typeof entry.value === "string" && UNRESOLVED_BINDING_PATTERN.test(entry.value)) {
+      if (entry.name === "connection") {
+        entry.default = storedConnection.default;
+        entry.value = `=bindings.${storedConnection.id}`;
+      } else if (entry.name === "folderKey") {
+        entry.default = storedFolderKey.default;
+        entry.value = `=bindings.${storedFolderKey.id}`;
+      }
+    }
+  }
+}
 function ensureProcessBindings(workflow, logger) {
   const nodes = workflow.nodes ?? [];
   const definitions = workflow.definitions ?? [];
   let bindingsCreated = 0;
   for (const node of nodes) {
-    if (!isProcessNode(node.type))
-      continue;
     const nodeModel = node.model;
     const defModel = definitions.find((d2) => d2.nodeType === node.type)?.model;
     const hasUnresolved = [nodeModel, defModel].some((m2) => m2?.context?.some((entry) => typeof entry.value === "string" && UNRESOLVED_BINDING_PATTERN.test(entry.value)));
@@ -171849,25 +171900,49 @@ function ensureProcessBindings(workflow, logger) {
     const definition95 = definitions.find((d2) => d2.nodeType === node.type);
     if (!definition95)
       continue;
-    let nameBinding;
-    let folderBinding;
-    try {
-      ({ nameBinding, folderBinding } = createProcessBindings(definition95));
-    } catch (err2) {
-      logger.warn(`Skipping binding resolution for node "${node.id}": ${err2 instanceof Error ? err2.message : String(err2)}`);
+    if (isProcessNode(node.type)) {
+      let nameBinding;
+      let folderBinding;
+      try {
+        ({ nameBinding, folderBinding } = createProcessBindings(definition95));
+      } catch (err2) {
+        logger.warn(`Skipping binding resolution for node "${node.id}": ${err2 instanceof Error ? err2.message : String(err2)}`);
+        continue;
+      }
+      const beforeCount = workflow.bindings?.length ?? 0;
+      addBinding(workflow, nameBinding);
+      addBinding(workflow, folderBinding);
+      const storedBindings = workflow.bindings;
+      const storedName = storedBindings.find((b2) => b2.resourceKey === nameBinding.resourceKey && b2.propertyAttribute === nameBinding.propertyAttribute) ?? nameBinding;
+      const storedFolder = storedBindings.find((b2) => b2.resourceKey === folderBinding.resourceKey && b2.propertyAttribute === folderBinding.propertyAttribute) ?? folderBinding;
+      resolveContextPlaceholders(nodeModel?.context, storedName, storedFolder);
+      resolveContextPlaceholders(defModel?.context, storedName, storedFolder);
+      const added = (workflow.bindings?.length ?? 0) - beforeCount;
+      bindingsCreated += added;
+      logger.info(`Resolved process bindings for node "${node.id}" (${node.type})`);
       continue;
     }
-    const beforeCount = workflow.bindings?.length ?? 0;
-    addBinding(workflow, nameBinding);
-    addBinding(workflow, folderBinding);
-    const storedBindings = workflow.bindings;
-    const storedName = storedBindings.find((b2) => b2.resourceKey === nameBinding.resourceKey && b2.propertyAttribute === nameBinding.propertyAttribute) ?? nameBinding;
-    const storedFolder = storedBindings.find((b2) => b2.resourceKey === folderBinding.resourceKey && b2.propertyAttribute === folderBinding.propertyAttribute) ?? folderBinding;
-    resolveContextPlaceholders(nodeModel?.context, storedName, storedFolder);
-    resolveContextPlaceholders(defModel?.context, storedName, storedFolder);
-    const added = (workflow.bindings?.length ?? 0) - beforeCount;
-    bindingsCreated += added;
-    logger.info(`Resolved process bindings for node "${node.id}" (${node.type})`);
+    if (isConnectorToolNode(node.type)) {
+      let connectionBinding;
+      let folderKeyBinding;
+      try {
+        ({ connectionBinding, folderKeyBinding } = createConnectorToolBindings(node, definition95));
+      } catch (err2) {
+        logger.warn(`Skipping connector binding resolution for node "${node.id}": ${err2 instanceof Error ? err2.message : String(err2)}`);
+        continue;
+      }
+      const beforeCount = workflow.bindings?.length ?? 0;
+      addBinding(workflow, connectionBinding);
+      addBinding(workflow, folderKeyBinding);
+      const storedBindings = workflow.bindings;
+      const storedConn = storedBindings.find((b2) => b2.resourceKey === connectionBinding.resourceKey && b2.propertyAttribute === connectionBinding.propertyAttribute) ?? connectionBinding;
+      const storedFk = storedBindings.find((b2) => b2.resourceKey === folderKeyBinding.resourceKey && b2.propertyAttribute === folderKeyBinding.propertyAttribute) ?? folderKeyBinding;
+      resolveConnectorContextPlaceholders(nodeModel?.context, storedConn, storedFk);
+      resolveConnectorContextPlaceholders(defModel?.context, storedConn, storedFk);
+      const added = (workflow.bindings?.length ?? 0) - beforeCount;
+      bindingsCreated += added;
+      logger.info(`Resolved connector bindings for node "${node.id}" (${node.type})`);
+    }
   }
   if (bindingsCreated > 0) {
     logger.info(`ensureProcessBindings: created ${bindingsCreated} binding(s) for directly-authored nodes`);
@@ -174488,4 +174563,4 @@ var toolsFactoryRepository2 = _global2[REGISTRY_KEY2];
 // src/packager-tool.ts
 toolsFactoryRepository2.registerProjectToolFactory(new FlowToolFactory);
 
-//# debugId=7BFF9F271C5C8D6564756E2164756E21
+//# debugId=B3BEA5A9D74B5A4C64756E2164756E21

package/dist/services/flow-eval-file-store.d.ts

@@ -0,0 +1,11 @@
+import type { IFileSystem } from "@uipath/filesystem";
+export declare function ensureDirectory(fs: IFileSystem, path: string): Promise<void>;
+export declare class FlowEvalFileStore {
+    private readonly fs;
+    constructor(fs: IFileSystem);
+    readJsonFiles<T extends {
+        fileName?: string;
+    }>(dir: string): Promise<T[]>;
+    writeJsonFile(path: string, value: unknown): Promise<void>;
+    remove(path: string): Promise<void>;
+}

package/dist/services/flow-migration-check.d.ts

@@ -0,0 +1,51 @@
+import { type MigrationErrorTracker, type MigrationWorkflow } from "@uipath/flow-migrations";
+/**
+ * Studio Web runs the workflow migration chain when it opens a `.flow`, and
+ * rejects the flow if any step fails (e.g. "Workflow migration failed at
+ * 1.3->1.4: Invalid input for migration 1.3 -> 1.4"). The CLI bundles the same
+ * `@uipath/flow-migrations` engine, so it can reproduce that failure locally —
+ * this module is the shared plumbing that both `flow migrate` and `flow
+ * validate` use to do so (UV-15030).
+ *
+ * `migrateWorkflow` does NOT throw on a failed step; it returns the ORIGINAL
+ * workflow with `migrated: false` and a populated `error: { step, message }`.
+ * The offending field paths are only reachable through the optional
+ * `errorTracker`, not the returned `error`. `captureMigrationIssues` wires that
+ * tracker up so callers can enrich the bare "Invalid input" message with the
+ * exact nodes/fields that failed.
+ */
+export declare function captureMigrationIssues(): {
+    tracker: MigrationErrorTracker;
+    fieldPaths: () => string[];
+};
+/**
+ * Human-facing explanation for a failed workflow migration step, shared by
+ * `flow migrate` (as a thrown error message) and `flow validate` (as a
+ * validation issue). `step` and `rawMessage` come straight from
+ * `migrateWorkflow`'s returned `error`; `fieldPaths` come from
+ * `captureMigrationIssues`.
+ */
+export declare function formatMigrationFailureMessage(step: string, rawMessage: string, fieldPaths: string[]): string;
+export type ForwardMigrationCheck = {
+    ok: true;
+} | {
+    ok: false;
+    step: string;
+    rawMessage: string;
+    message: string;
+    fieldPaths: string[];
+};
+/**
+ * Run the forward migration Studio Web would run when opening this flow, in
+ * memory — no write, no network. Returns `{ ok: false, ... }` only when a
+ * migration STEP fails (the flow is at a known version but its shape is
+ * invalid for the next step); that flow will not open in Studio Web until
+ * fixed.
+ *
+ * Returns `{ ok: true }` when the flow migrates cleanly, is already current,
+ * OR when the chain can't be built at all — a missing/unknown/newer-than-
+ * bundled `version` makes `migrateWorkflow` throw before running any step.
+ * That last case means the CLI's bundled migrations are out of step with the
+ * flow (version skew), which is not a flow defect we should hard-fail on.
+ */
+export declare function checkForwardMigration(rawWorkflow: MigrationWorkflow): ForwardMigrationCheck;

package/dist/services/flow-validate-service.d.ts

@@ -82,6 +82,18 @@ export declare class FlowValidateService {
     private loadCurrentManifestMap;
     private loadCurrentManifestMapUncached;
     validateFile(flowFilePath: string): Promise<FlowValidateResult>;
+    /**
+     * Forward-migration preflight (UV-15030).
+     *
+     * Studio Web runs the `@uipath/flow-migrations` chain when it opens a
+     * `.flow`; a flow that fails a migration step (e.g. 1.3->1.4) passes every
+     * structural/semantic check here yet never opens in the browser. The CLI
+     * bundles the same engine, so we run it in-memory (no write, no network)
+     * and turn a failed step into a blocking error naming the offending
+     * fields. A flow that migrates cleanly, is already current, or carries an
+     * unknown/skewed version yields no issue — see `checkForwardMigration`.
+     */
+    private validateForwardMigration;
     /**
      * For agent nodes that reference an external agent definition via a
      * `projectId` UUID, read the sibling `<uuid>/agent.json` file and

package/dist/services/packaging-utils.d.ts

@@ -55,7 +55,24 @@ export interface InlineAgentPackage {
     entryPoint: EntryPoint;
     /** The raw agent.json content (for .agent-builder/agent.json). */
     agentJson: Record<string, unknown>;
+    bindingsJson?: PackagingBindingsJson;
 }
+export interface PackagingBindingsJson extends Record<string, unknown> {
+    version: string;
+    resources: Record<string, unknown>[];
+}
+export interface PackagingArtifacts {
+    entryPoints: EntryPoint[];
+    bindingsJson: PackagingBindingsJson;
+}
+export interface PackagingArtifactOptions {
+    additionalEntryPoints?: EntryPoint[];
+    additionalBindingsJsons?: Array<PackagingBindingsJson | undefined>;
+    packageDescriptorJson?: Record<string, unknown>;
+}
+export declare function normalizePackagingBindingsJson(value: unknown): PackagingBindingsJson | undefined;
+export declare function emptyPackagingBindingsJson(): PackagingBindingsJson;
+export declare function mergePackagingBindingsJson(bindingsJsons: Array<PackagingBindingsJson | undefined>): PackagingBindingsJson;
 /**
  * Scan workflow nodes for inline agents, read their agent.json,
  * and build entry points + metadata for packaging.
@@ -71,6 +88,12 @@ export declare function packageInlineAgents(fs: IFileSystem, projectDir: string,
     inputs?: Record<string, unknown>;
     model?: Record<string, unknown>;
 }>): Promise<InlineAgentPackage[]>;
+/**
+ * Copy each referenced inline agent's directory into the staging project and
+ * write its `.agent-builder` files (agent.json + bindings.json) — the agent's
+ * runtime execution contract the runtime loads when it runs the agent.
+ */
+export declare function stageInlineAgentPackageFiles(fs: IFileSystem, sourceProjectPath: string, stagingProjectDir: string, inlineAgents: InlineAgentPackage[], formatLogMessage: (source: string) => string): Promise<void>;
 /**
  * Build inline-agent descriptors for a debug session's FpsProperties
  * injection. Mirrors flow-workbench's `extractInlineAgents` shape:
@@ -101,7 +124,8 @@ export declare function buildInlineAgentDescriptors(nodes: Array<{
  * Returns the computed entry points so callers can derive PIMS entry point paths
  * without calling getEntryPoints again.
  */
-export declare function writePackagingArtifacts(fs: IFileSystem, projectDir: string, projectId: string, packagingNodes: PackagingNode[], bindings: PackagingBinding[], variables: PackagingWorkflowVariables, bpmnFileName: string, startEventId: string, flowFileName?: string, definitions?: PackagingNodeManifest[]): Promise<EntryPoint[]>;
+export declare function writePackagingArtifacts(fs: IFileSystem, projectDir: string, projectId: string, packagingNodes: PackagingNode[], bindings: PackagingBinding[], variables: PackagingWorkflowVariables, bpmnFileName: string, startEventId: string, flowFileName?: string, definitions?: PackagingNodeManifest[], options?: PackagingArtifactOptions): Promise<EntryPoint[]>;
+export declare function writePackagingArtifactsDetailed(fs: IFileSystem, projectDir: string, projectId: string, packagingNodes: PackagingNode[], bindings: PackagingBinding[], variables: PackagingWorkflowVariables, bpmnFileName: string, startEventId: string, flowFileName?: string, definitions?: PackagingNodeManifest[], options?: PackagingArtifactOptions): Promise<PackagingArtifacts>;
 /**
  * Re-read a .flow file and regenerate bindings_v2.json in the same project directory.
  * Called after `node add` (process nodes), `node delete`, and `node configure` to