@uipath/maestro-builder-sdk 6.18.8 → 6.18.10

package/dist/bpmn/uipath-moddle.v1.json

@@ -714,6 +714,11 @@
           "name": "exponentialBase",
           "isAttr": true,
           "type": "String"
+        },
+        {
+          "name": "enforceLimits",
+          "isAttr": true,
+          "type": "String"
         }
       ]
     },

package/dist/case/decompile-cli.js

@@ -25,6 +25,7 @@ import { Library } from '../core/library.js';
 import { decompileWithDiagnostics } from './decompile.js';
 import { CASE_IMPORT } from '../package-name.js';
 import { commentText } from '../core/comment-text.js';
+import { pipelineFrontDoor } from '../registry/uip/pipeline-front-door.js';
 /** Derive a PascalCase base name from the case name for the default output file. */
 function baseName(plan) {
     const src = plan.name ?? plan.id ?? 'Case';
@@ -90,8 +91,7 @@ function pipelineScript(originalPath, tsPath, pipelinePath, importSpecifier, bes
     const base = pipelinePath.replace(/\.pipeline\.mjs$/, '');
     return `#!/usr/bin/env node
 // Generated by case decompile — edit ${commentText(basename(tsPath))}, then run this file.
-import { execFileSync, spawnSync } from 'node:child_process';
-import { existsSync } from 'node:fs';
+${pipelineFrontDoor('case')}
 
 const ORIGINAL = ${JSON.stringify(originalPath)};
 const TS       = ${JSON.stringify(tsPath)};
@@ -100,12 +100,6 @@ const IMPORT   = ${JSON.stringify(importSpecifier)};
 const LIBRARY  = ${JSON.stringify(libraryDir)};
 const BEST_EFFORT = ${JSON.stringify(bestEffort)};
 
-const uipProbe = spawnSync('uip', ['maestro', 'case', 'compile', '--help'], { stdio: 'ignore' });
-const frontDoor = !uipProbe.error && uipProbe.status === 0
-  ? { file: 'uip', prefix: ['maestro', 'case'] }
-  : { file: 'npx', prefix: ['--no-install', 'flow-sdk', 'case'] };
-const run = (verb, args) =>
-  execFileSync(frontDoor.file, [...frontDoor.prefix, verb, ...args], { stdio: 'inherit' });
 const withLibrary = (args) => LIBRARY ? [...args, '--library', LIBRARY] : args;
 
 if (!existsSync(TS)) {

package/dist/decompile-cli.js

@@ -26,6 +26,7 @@ import { resolveFlowRefs } from './ref-resolve.js';
 import { flagValue, runWhenInvokedDirectly } from './cli-run.js';
 import { PACKAGE_NAME } from './package-name.js';
 import { commentText } from './core/comment-text.js';
+import { pipelineFrontDoor } from './registry/uip/pipeline-front-door.js';
 /** Derive a PascalCase base name from the flow name/id for the default output file. */
 function baseName(flow) {
     const src = flow.name ?? flow.id ?? 'Flow';
@@ -103,8 +104,7 @@ function pipelineScript(originalPath, tsPath, pipelinePath) {
     return `#!/usr/bin/env node
 // Generated by flow-decompile — the brownfield read/modify/write pipeline for
 // ${commentText(basename(originalPath))}. Run it, edit ${commentText(basename(tsPath))}, run it again.
-import { execFileSync, spawnSync } from 'node:child_process';
-import { existsSync } from 'node:fs';
+${pipelineFrontDoor('flow')}
 
 const ORIGINAL = ${JSON.stringify(originalPath)};
 const TS       = ${JSON.stringify(tsPath)};
@@ -112,13 +112,6 @@ const BASELINE = ${JSON.stringify(base + '.baseline.flow')};
 const EDITED   = ${JSON.stringify(base + '.edited.flow')};
 const MERGED   = ${JSON.stringify(base + '.merged.flow')};
 
-const uipProbe = spawnSync('uip', ['maestro', 'flow', 'compile', '--help'], { stdio: 'ignore' });
-const frontDoor = !uipProbe.error && uipProbe.status === 0
-  ? { file: 'uip', prefix: ['maestro', 'flow'] }
-  : { file: 'npx', prefix: ['--no-install', 'flow-sdk', 'flow'] };
-const run = (verb, args) =>
-  execFileSync(frontDoor.file, [...frontDoor.prefix, verb, ...args], { stdio: 'inherit' });
-
 // Ensure the decompiled source exists (a fresh clone may have only the .flow).
 if (!existsSync(TS)) run('decompile', [ORIGINAL, '-o', TS, '--no-pipeline']);
 

package/dist/registry/pull-cli.d.ts

@@ -20,4 +20,25 @@ export declare const CONNECTORS_LIBRARY_VERSION_ENV = "CONNECTORS_LIBRARY_VERSIO
  * rather than guessed at, so a typo cannot fall back to "latest" silently.
  */
 export declare function connectorsLibraryUrl(argv: string[], env?: Record<string, string | undefined>): string;
+/**
+ * Point `current` at an entry, replacing whatever it named.
+ *
+ * Nothing to do when `current` already resolves to the entry — the unchanged
+ * pull, which is most of them.
+ *
+ * Otherwise the new link is made under a temp name and renamed over `current`.
+ * On POSIX that rename is atomic over an existing symlink, so a concurrent
+ * compile never finds the link missing. On Windows `current` is a junction, and
+ * a rename onto an existing junction fails with `EPERM` (flow-builder-sdk#945),
+ * so there the old link is parked under `current.old-<pid>` first, the new one
+ * renamed in, and the parked one removed; a failed rename puts the parked link
+ * back. That leaves a moment where `current` does not exist, which Windows
+ * gives no way to avoid with a junction.
+ *
+ * Links are removed with `unlink`, never a recursive `rm`: the link's target is
+ * the extracted library, and removing the link must not reach into it.
+ *
+ * @param platform - Which branch to take; a parameter so both run in tests.
+ */
+export declare function pointCurrentAt(root: string, sha256: string, platform?: NodeJS.Platform): Promise<void>;
 export declare function run(argv: string[]): Promise<number>;

package/dist/registry/pull-cli.js

@@ -1,6 +1,6 @@
 import { reportResult } from '../cli-result.js';
 import { createHash } from "node:crypto";
-import { mkdir, readFile, rename, rm, stat, symlink, writeFile, } from "node:fs/promises";
+import { mkdir, readFile, realpath, rename, rm, stat, symlink, unlink, writeFile, } from "node:fs/promises";
 import { join, resolve } from "node:path";
 import { writeJsonFile } from "../core/json-file.js";
 import { CURRENT_LINK, LIBRARY_JSON_DIR, LIBRARY_MARKDOWN_DIR, cacheEntry, libraryCacheRoot, referencedConnectorKeys, } from "../core/library-cache.js";
@@ -215,16 +215,81 @@ async function writeSource(libraryPath, archive, sha256, archiveSha256, overlayS
 /**
  * Point `current` at an entry, replacing whatever it named.
  *
- * Written to a temp name and renamed, so a reader never sees the link missing —
- * `rename` over an existing symlink is atomic, while unlink-then-create leaves a
- * window where a concurrent compile finds nothing.
+ * Nothing to do when `current` already resolves to the entry — the unchanged
+ * pull, which is most of them.
+ *
+ * Otherwise the new link is made under a temp name and renamed over `current`.
+ * On POSIX that rename is atomic over an existing symlink, so a concurrent
+ * compile never finds the link missing. On Windows `current` is a junction, and
+ * a rename onto an existing junction fails with `EPERM` (flow-builder-sdk#945),
+ * so there the old link is parked under `current.old-<pid>` first, the new one
+ * renamed in, and the parked one removed; a failed rename puts the parked link
+ * back. That leaves a moment where `current` does not exist, which Windows
+ * gives no way to avoid with a junction.
+ *
+ * Links are removed with `unlink`, never a recursive `rm`: the link's target is
+ * the extracted library, and removing the link must not reach into it.
+ *
+ * @param platform - Which branch to take; a parameter so both run in tests.
  */
-async function pointCurrentAt(root, sha256) {
+export async function pointCurrentAt(root, sha256, platform = process.platform) {
     const link = join(root, CURRENT_LINK);
+    if (await resolvesTo(link, join(root, sha256)))
+        return;
     const temporary = `${link}.tmp-${process.pid}`;
-    await rm(temporary, { recursive: true, force: true });
-    await symlink(sha256, temporary, "junction");
-    await rename(temporary, link);
+    await removeLink(temporary);
+    try {
+        await symlink(sha256, temporary, "junction");
+        if (platform !== "win32") {
+            await rename(temporary, link);
+            return;
+        }
+        const parked = `${link}.old-${process.pid}`;
+        await removeLink(parked);
+        let wasParked = false;
+        try {
+            await rename(link, parked);
+            wasParked = true;
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                throw error;
+        }
+        try {
+            await rename(temporary, link);
+        }
+        catch (error) {
+            if (wasParked)
+                await rename(parked, link).catch(() => undefined);
+            throw error;
+        }
+        if (wasParked)
+            await removeLink(parked);
+    }
+    finally {
+        // Gone already after a successful rename; this is for every way out that
+        // is not one, so a failed pull leaves no `current.tmp-<pid>` behind.
+        await removeLink(temporary);
+    }
+}
+/** Whether `link` and `entry` name the same directory; false when either is missing. */
+async function resolvesTo(link, entry) {
+    try {
+        return (await realpath(link)) === (await realpath(entry));
+    }
+    catch {
+        return false;
+    }
+}
+/** Remove a symlink or junction without following it; a missing one is fine. */
+async function removeLink(path) {
+    try {
+        await unlink(path);
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+    }
 }
 export async function run(argv) {
     if (has(argv, "--help") || has(argv, "-h")) {

package/dist/registry/uip/launch.d.ts

@@ -1,3 +1,4 @@
+import { win32 } from "node:path";
 export interface Launch {
     file: string;
     args: string[];
@@ -13,12 +14,21 @@ export interface LaunchHost {
     execPath: string;
     isFile(path: string): boolean;
     readFile(path: string): string;
+    /** Windows path operations (`node:path`'s `win32`), passed in so {@link resolveLaunch} imports nothing. */
+    win32: Pick<typeof win32, "join" | "dirname" | "extname">;
 }
+/** The host this process runs on. */
+export declare function ambientLaunchHost(): LaunchHost;
 /**
- * The file and arguments to spawn for `executable args`, without a shell.
+ * The file and arguments to spawn for `executable args` on `host`, without a shell.
+ *
+ * Self-contained on purpose (see the module comment): generated scripts embed
+ * `resolveLaunch.toString()`.
  *
  * @throws when, on Windows, the name resolves to a batch shim this cannot read
  * a script out of — naming the shim, so the remedy is not "put uip on PATH"
  * for a `uip` that is on PATH.
  */
+export declare function resolveLaunch(executable: string, args: readonly string[], host: LaunchHost): Launch;
+/** {@link resolveLaunch} on this process's host. */
 export declare function launchFor(executable: string, args: readonly string[], host?: LaunchHost): Launch;

package/dist/registry/uip/launch.js

@@ -22,6 +22,13 @@
  * A name that is not bare (a path, or one with an extension) is spawned as
  * given, and so is anything on another platform.
  *
+ * The rules live in ONE self-contained function, {@link resolveLaunch}, because
+ * a second copy runs outside this package: the brownfield pipeline scripts that
+ * `flow decompile` and `case decompile` write embed its source text
+ * (`pipeline-front-door.ts`, flow-builder-sdk#1120). So it may reference only
+ * its parameters and globals — no module constant, no import — and a test runs
+ * its source text in an empty context to hold that.
+ *
  * Example, on Windows with npm's global bin on PATH:
  *   launchFor("uip", ["--version"])
  *   // -> { file: "C:\\Program Files\\nodejs\\node.exe",
@@ -29,14 +36,8 @@
  */
 import { readFileSync, statSync } from "node:fs";
 import { win32 } from "node:path";
-const DEFAULT_PATHEXT = ".COM;.EXE;.BAT;.CMD";
-/**
- * The script an npm (`cmd-shim`) or pnpm shim hands its arguments to: the last
- * quoted `%dp0%\…` / `%~dp0\…` path followed by `%*`. Only a JavaScript target
- * counts; a shim around something else is not one this module can run directly.
- */
-const SHIM_TARGET = /"%~?dp0%?\\([^"]+\.[cm]?js)"\s+%\*/g;
-function ambientHost() {
+/** The host this process runs on. */
+export function ambientLaunchHost() {
     return {
         platform: process.platform,
         path: process.env.PATH,
@@ -51,55 +52,61 @@ function ambientHost() {
             }
         },
         readFile: (path) => readFileSync(path, "utf8"),
+        win32,
     };
 }
-/** True for a name `PATH` lookup applies to: no directory part and no extension. */
-function isBareName(executable) {
-    return executable !== "" && !/[\\/]/.test(executable) && win32.extname(executable) === "";
-}
-/** The first `<dir>\<executable><ext>` on PATH, in cmd.exe's order, or undefined. */
-function findOnPath(executable, host) {
-    const extensions = (host.pathExt || DEFAULT_PATHEXT).split(";").filter(Boolean);
-    for (const dir of (host.path ?? "").split(";")) {
-        const trimmed = dir.trim().replace(/^"(.*)"$/, "$1");
-        if (trimmed === "")
-            continue;
-        for (const ext of extensions) {
-            const candidate = win32.join(trimmed, executable + ext.toLowerCase());
-            if (host.isFile(candidate))
-                return candidate;
-        }
-    }
-    return undefined;
-}
-/** The script a `.cmd`/`.bat` shim runs, as an absolute path, or undefined. */
-function shimTarget(shim, host) {
-    const matches = [...host.readFile(shim).matchAll(SHIM_TARGET)];
-    const last = matches.at(-1);
-    return last ? win32.join(win32.dirname(shim), last[1]) : undefined;
-}
 /**
- * The file and arguments to spawn for `executable args`, without a shell.
+ * The file and arguments to spawn for `executable args` on `host`, without a shell.
+ *
+ * Self-contained on purpose (see the module comment): generated scripts embed
+ * `resolveLaunch.toString()`.
  *
  * @throws when, on Windows, the name resolves to a batch shim this cannot read
  * a script out of — naming the shim, so the remedy is not "put uip on PATH"
  * for a `uip` that is on PATH.
  */
-export function launchFor(executable, args, host = ambientHost()) {
-    if (host.platform !== "win32" || !isBareName(executable))
+export function resolveLaunch(executable, args, host) {
+    const path = host.win32;
+    // Bare: no directory part and no extension. Only a bare name is looked up.
+    const bare = executable !== "" && !/[\\/]/.test(executable) && path.extname(executable) === "";
+    if (host.platform !== "win32" || !bare)
         return { file: executable, args: [...args] };
-    const found = findOnPath(executable, host);
+    // The first `<dir>\<executable><ext>` on PATH, in cmd.exe's PATHEXT order.
+    const extensions = (host.pathExt || ".COM;.EXE;.BAT;.CMD").split(";").filter(Boolean);
+    let found;
+    search: for (const dir of (host.path ?? "").split(";")) {
+        const trimmed = dir.trim().replace(/^"(.*)"$/, "$1");
+        if (trimmed === "")
+            continue;
+        for (const ext of extensions) {
+            const candidate = path.join(trimmed, executable + ext.toLowerCase());
+            if (host.isFile(candidate)) {
+                found = candidate;
+                break search;
+            }
+        }
+    }
     // Not on PATH: spawn the bare name and let the ENOENT say so.
-    if (!found)
+    if (found === undefined)
         return { file: executable, args: [...args] };
-    const ext = win32.extname(found).toLowerCase();
+    const ext = path.extname(found).toLowerCase();
     if (ext !== ".cmd" && ext !== ".bat")
         return { file: found, args: [...args] };
-    const script = shimTarget(found, host);
-    if (!script || !host.isFile(script)) {
+    // The script an npm (cmd-shim) or pnpm shim hands its arguments to: the last
+    // quoted `%dp0%\…` / `%~dp0\…` JavaScript path followed by `%*`.
+    const matches = [...host.readFile(found).matchAll(/"%~?dp0%?\\([^"]+\.[cm]?js)"\s+%\*/g)];
+    const last = matches[matches.length - 1];
+    const script = last ? path.join(path.dirname(found), last[1]) : undefined;
+    if (script === undefined || !host.isFile(script)) {
         throw new Error(`Could not start ${executable}: ${found} is a batch file, which Node cannot run without a shell, ` +
-            (script ? `and the script it names (${script}) does not exist.` : "and it names no JavaScript entry point to run instead.") +
-            " Reinstall the UiPath CLI with npm (`npm install -g @uipath/cli`).");
+            (script !== undefined
+                ? `and the script it names (${script}) does not exist.`
+                : "and it names no JavaScript entry point to run instead.") +
+            " Reinstall it with npm (for the UiPath CLI, `npm install -g @uipath/cli`).");
     }
     return { file: host.execPath, args: [script, ...args] };
 }
+/** {@link resolveLaunch} on this process's host. */
+export function launchFor(executable, args, host = ambientLaunchHost()) {
+    return resolveLaunch(executable, args, host);
+}

package/dist/registry/uip/pipeline-front-door.d.ts

@@ -0,0 +1,2 @@
+/** The script text: imports, the embedded resolver, `frontDoor`, and `run(verb, args)`. */
+export declare function pipelineFrontDoor(kind: 'flow' | 'case'): string;

package/dist/registry/uip/pipeline-front-door.js

@@ -0,0 +1,88 @@
+/**
+ * The "front door" block of a generated brownfield pipeline script: how the
+ * script finds a CLI to run `compile`, `decompile` and `merge` with.
+ *
+ * `flow decompile` and `case decompile` each write a `<Name>.pipeline.mjs`
+ * beside the source. Both used to carry their own copy of this block, and both
+ * spawned the bare names `uip` and `npx` without a shell. On Windows both are
+ * `.cmd` shims, which Node cannot start that way, so the probe for `uip` failed,
+ * the `npx` fallback failed too, and the pipeline could not run at all
+ * (flow-builder-sdk#1120, the same defect as #940 in the registry).
+ *
+ * Now there is one block, and it starts programs through the same rules the
+ * registry uses: it embeds the source text of `resolveLaunch`
+ * (`registry/uip/launch.ts`), so a fix there reaches every pipeline written
+ * after it. The order is unchanged:
+ *   1. `uip maestro <kind>`, when `uip maestro <kind> compile --help` exits 0
+ *      (a CLI that carries the authoring commands);
+ *   2. otherwise the SDK's own `flow-sdk` bin, found the way
+ *      `npx --no-install flow-sdk` found it: `node_modules/.bin` in the script's
+ *      folder and every folder above it, then `PATH`.
+ *
+ * The block brings its own imports, `existsSync` among them, and defines
+ * `run(verb, args)`; the pipeline body uses both. Nothing in it names a path on
+ * the machine that generated it, so a pipeline stays relocatable.
+ *
+ * Example, for `kind = 'flow'` on a machine whose `uip` has the commands:
+ *   run('compile', ['A.flow.ts', '-o', 'A.edited.flow'])
+ *   // POSIX:   uip maestro flow compile A.flow.ts -o A.edited.flow
+ *   // Windows: node.exe <npm>\node_modules\@uipath\cli\dist\index.js maestro flow compile …
+ */
+import { resolveLaunch } from './launch.js';
+/** The script text: imports, the embedded resolver, `frontDoor`, and `run(verb, args)`. */
+export function pipelineFrontDoor(kind) {
+    return `import { execFileSync, spawnSync } from 'node:child_process';
+import { existsSync, readFileSync, statSync } from 'node:fs';
+import { dirname, join, win32 } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const KIND = ${JSON.stringify(kind)};
+
+// How to start a program by name without a shell, Windows .cmd shims included.
+// Copied from the SDK's registry/uip/launch.ts when this file was generated.
+${resolveLaunch.toString()}
+
+const launchHost = (path) => ({
+  platform: process.platform,
+  path,
+  pathExt: process.env.PATHEXT,
+  execPath: process.execPath,
+  isFile: (p) => { try { return statSync(p).isFile(); } catch { return false; } },
+  readFile: (p) => readFileSync(p, 'utf8'),
+  win32,
+});
+
+// 1. \`uip maestro <kind>\`, when this CLI carries the authoring commands.
+function uipFrontDoor() {
+  let uip;
+  try {
+    uip = resolveLaunch('uip', [], launchHost(process.env.PATH));
+  } catch {
+    return undefined; // a uip shim that cannot be read: use the SDK instead
+  }
+  const probe = spawnSync(uip.file, [...uip.args, 'maestro', KIND, 'compile', '--help'], { stdio: 'ignore' });
+  return !probe.error && probe.status === 0 ? { file: uip.file, prefix: [...uip.args, 'maestro', KIND] } : undefined;
+}
+
+// 2. The SDK's flow-sdk bin, where \`npx --no-install flow-sdk\` looked for it.
+function sdkFrontDoor() {
+  const bins = [];
+  for (let dir = dirname(fileURLToPath(import.meta.url)); ; dir = dirname(dir)) {
+    bins.push(join(dir, 'node_modules', '.bin'));
+    if (dirname(dir) === dir) break;
+  }
+  let sdk;
+  if (process.platform === 'win32') {
+    sdk = resolveLaunch('flow-sdk', [], launchHost([...bins, process.env.PATH ?? ''].join(';')));
+  } else {
+    const local = bins.map((bin) => join(bin, 'flow-sdk')).find((p) => existsSync(p));
+    sdk = { file: local ?? 'flow-sdk', args: [] };
+  }
+  return { file: sdk.file, prefix: [...sdk.args, KIND] };
+}
+
+const frontDoor = uipFrontDoor() ?? sdkFrontDoor();
+const run = (verb, args) =>
+  execFileSync(frontDoor.file, [...frontDoor.prefix, verb, ...args], { stdio: 'inherit' });
+`;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uipath/maestro-builder-sdk",
-  "version": "6.18.8",
+  "version": "6.18.10",
   "description": "Build UiPath Flow, Case, and BPMN artifacts by writing TypeScript.",
   "license": "MIT",
   "homepage": "https://docs.uipath.com/maestro",
@@ -92,5 +92,5 @@
     "@types/node": "^22.7.0",
     "esbuild": "^0.28.1"
   },
-  "gitref": "ce161efe130f6a6cdee895d8a7fab2faddcec0fd"
+  "gitref": "0bbd0a5b9951750e0b3009b17b0188e485266cbe"
 }