@uipath/maestro-builder-sdk 6.70.2 → 6.70.3

package/dist/check.js

@@ -16,6 +16,7 @@ import { checkEventResolution, checkEventSubscription, eventParamsFor, } from '.
 import { checkCookedEscapes } from './flow-expr-check.js';
 import { FLOW_EXPR_DIALECT, checkBindingLabels, checkConnectorLookups as coreCheckConnectorLookups, checkConnectorSchema as coreCheckConnectorSchema, } from './core/connector-checks.js';
 import { nearestName } from './core/edit-distance.js';
+import { escapeRegExp } from './core/escape-regexp.js';
 import { hitlDerivesOutcomeHandles, hitlExitModel, hitlRoutesPerOutcome, outcomeIdOf } from './core/hitl-routing.js';
 import { hasExits } from './core/step-ports.js';
 import { actionTails, armReachesJoin } from './flow-parallel-hitl.js';
@@ -1916,12 +1917,14 @@ function checkTrigger(spec, diags, opts = {}, entryPointId) {
  * INPUT — which is what `input('x')` lowers to, since inputs are published as the
  * trigger node's output. Matching only the bare form (as three call sites used
  * to) made every input-typed check silently stop firing.
+ *
+ * The trigger id is matched as literal text.
  */
 function declaredRefName(js, triggerId) {
     const bare = /^\$vars\.([A-Za-z0-9_]+)$/.exec(js.trim());
     if (bare)
         return bare[1];
-    const viaTrigger = new RegExp(`^\\$vars\\.${triggerId}\\.output\\.([A-Za-z0-9_]+)$`).exec(js.trim());
+    const viaTrigger = new RegExp(`^\\$vars\\.${escapeRegExp(triggerId)}\\.output\\.([A-Za-z0-9_]+)$`).exec(js.trim());
     return viaTrigger?.[1];
 }
 /**

package/dist/core/escape-regexp.d.ts

@@ -0,0 +1,6 @@
+/**
+ * `s` with every regex metacharacter escaped, so `new RegExp(escapeRegExp(s))`
+ * matches `s` as literal text. Use it wherever an id or name is spliced into a
+ * pattern. FB005 holds the name here.
+ */
+export declare function escapeRegExp(s: string): string;

package/dist/core/escape-regexp.js

@@ -0,0 +1,8 @@
+/**
+ * `s` with every regex metacharacter escaped, so `new RegExp(escapeRegExp(s))`
+ * matches `s` as literal text. Use it wherever an id or name is spliced into a
+ * pattern. FB005 holds the name here.
+ */
+export function escapeRegExp(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}

package/dist/core/expr-check.js

@@ -30,6 +30,7 @@
  * (which node / task / field) it came from.
  */
 import { typescript } from './typescript-module.js';
+import { escapeRegExp } from './escape-regexp.js';
 /**
  * A JSONPath wildcard/filter step — the spelling that reaches for JavaScript and
  * misses. Used only to add a suggestion; the parse decides.
@@ -196,9 +197,6 @@ function maskStringLiterals(expr) {
     return expr.replace(/'(?:\\.|[^'\\])*'|"(?:\\.|[^"\\])*"/g, (m) => m[0] + ' '.repeat(m.length - 2) + m[m.length - 1]);
 }
 const SEGMENT = /\??\.([A-Za-z_$][\w$]*)|\[(\d+)\]/g;
-function escapeRegExp(s) {
-    return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}
 /**
  * A `<namespace>.<root><path>` reference matcher. The root is a JS identifier;
  * the path is any run of `.ident`, `?.ident`, or `[<digits>]` selectors — the

package/dist/registry/generators/descriptors.js

@@ -26,7 +26,7 @@ import { sortedByCodePoint, sortedStrings } from "../compat/compare.js";
 import { afterLast, pyRstrip, pyStr, pyStrip, splitOnce } from "../compat/pystr.js";
 import { referenceOf, specsFromFields } from "../lookup-specs.js";
 import { isEventNodeType, } from "../model/library.js";
-import { symbolIndex } from "../naming.js";
+import { assertModuleConnectorKey, symbolIndex } from "../naming.js";
 import { descriptorInputFields, lookupSpecs, markLookupFields } from "./fields.js";
 import { NamedTypeRegistry } from "./type-registry.js";
 import { buildTypeTree, pyTruthy, subtreeRequired } from "./type-tree.js";
@@ -360,6 +360,7 @@ export function renderDescriptorModules(library, options = {}) {
         const key = row.connectorKey;
         if (subset.size > 0 && !subset.has(key))
             continue;
+        assertModuleConnectorKey(key, `the index.json row for ${JSON.stringify(row.nodeType)} at ${JSON.stringify(row.path)}`);
         const group = byConnector.get(key);
         if (group)
             group.push(row);

package/dist/registry/generators/triggers.js

@@ -16,6 +16,7 @@ import { pyJsonString, pyJsonStringify } from "../codecs/pyjson.js";
 import { sortedByCodePoint, sortedStrings } from "../compat/compare.js";
 import { afterLast, pyRstrip, pyStrip, upperFirst } from "../compat/pystr.js";
 import { TRIGGER_PREFIX } from "../model/library.js";
+import { assertModuleConnectorKey } from "../naming.js";
 /** The trigger generator's own pascal: same split, `Event` as the empty fallback. */
 function pascalEvent(eventId) {
     const joined = eventId
@@ -64,6 +65,7 @@ export function renderTriggerModules(catalogue, options = {}) {
         const key = row.connectorKey;
         if (subset.size > 0 && !subset.has(key))
             continue;
+        assertModuleConnectorKey(key, `the trigger catalogue row for ${JSON.stringify(nodeType)}`);
         const group = byConnector.get(key);
         if (group)
             group.push(row);

package/dist/registry/naming.d.ts

@@ -1,3 +1,7 @@
+/** One plain path segment: a connector key names a file or folder, so it must not climb out of it. */
+export declare const CONNECTOR_KEY_SEGMENT: RegExp;
+/** Refuse a key that cannot be a module file stem: the key comes from an editable project file. */
+export declare function assertModuleConnectorKey(key: unknown, row: string): asserts key is string;
 /** `send-message-to-user` → `SendMessageToUser`. */
 export declare function pascal(actionId: string): string;
 /** A small deterministic singulariser for array field names used as type names. */

package/dist/registry/naming.js

@@ -15,6 +15,16 @@
  */
 import { sortedByCodePoint, sortedStrings } from "./compat/compare.js";
 import { afterLast, beforeLast, upperFirst } from "./compat/pystr.js";
+import { Refusal } from "./errors.js";
+/** One plain path segment: a connector key names a file or folder, so it must not climb out of it. */
+export const CONNECTOR_KEY_SEGMENT = /^[A-Za-z0-9][A-Za-z0-9_.-]*$/;
+/** Refuse a key that cannot be a module file stem: the key comes from an editable project file. */
+export function assertModuleConnectorKey(key, row) {
+    if (typeof key === "string" && CONNECTOR_KEY_SEGMENT.test(key))
+        return;
+    throw new Refusal(`connector key ${JSON.stringify(key) ?? String(key)} of ${row} cannot name a module file: ` +
+        "it must be one plain path segment (a letter or digit, then letters, digits, '_', '.' or '-')", "CONNECTOR_KEY_INVALID");
+}
 /** `send-message-to-user` → `SendMessageToUser`. */
 export function pascal(actionId) {
     const joined = actionId

package/dist/registry/prepare/messages.d.ts

@@ -39,6 +39,8 @@ export declare function describeNextLine(cli: string, nodeType: string, objectNa
 export declare function discardedNote(count: number): string;
 /** A write failed after the run succeeded, so the files written before it remain. */
 export declare function partialWriteMessage(path: string, reason: string): string;
+/** A write that a link would carry out of the folder it belongs in. */
+export declare function writeOutsideMessage(path: string, root: string): string;
 /**
  * A refusal whose message is the COMPLETE text the Python passed to
  * `sys.exit`, prefix included. Every other {@link Refusal} reaching the exit

package/dist/registry/prepare/messages.js

@@ -54,6 +54,11 @@ export function partialWriteMessage(path, reason) {
     return prefixed(`could not write ${path} (${reason}). The files written before it remain, so the overlay or bindings.json `
         + "may be partly updated; fix the cause and run the same prepare again.");
 }
+/** A write that a link would carry out of the folder it belongs in. */
+export function writeOutsideMessage(path, root) {
+    return prefixed(`refusing to write ${path}: it is a link, or a link above it leads outside ${root}. `
+        + "Nothing was written; remove the link and run the same prepare again.");
+}
 /**
  * A refusal whose message is the COMPLETE text the Python passed to
  * `sys.exit`, prefix included. Every other {@link Refusal} reaching the exit

package/dist/registry/prepare/overlay.js

@@ -30,7 +30,8 @@ import { SCHEMA_VERSION } from "../library-build/canonical.js";
 import { sidecarPath, unwrapV1Def } from "../library-reader.js";
 import { catalogReferences, loadInvariantCollections, specsFromFields } from "../lookup-specs.js";
 import { isEventNodeType } from "../model/library.js";
-import { afterWrites, existsSync, mkdirSync, readFileSync, stagedReadText, writeFileSync } from "./staged-files.js";
+import { CONNECTOR_KEY_SEGMENT } from "../naming.js";
+import { afterWrites, existsSync, mkdirSync, readFileSync, stagedReadText, writeInsideSync } from "./staged-files.js";
 import { isPlainObject, pyGet, pyOr, pyStrAny, pyTruthy, pyTypeName } from "./support.js";
 export const INDEX_FILENAME = "index.json";
 export const DESCRIPTORS_ROOT = "descriptors";
@@ -89,7 +90,7 @@ export function migrateLegacyDescriptorRoots(dst, entries) {
                 if (child.isDirectory())
                     walk(join(dir, child.name), join(destination, child.name));
                 else if (child.isFile()) {
-                    writeFileSync(join(destination, child.name), readFileSync(join(dir, child.name)));
+                    writeInsideSync(dst, join(destination, child.name), readFileSync(join(dir, child.name)));
                     moved.push([join(dir, child.name), join(destination, child.name)]);
                 }
             }
@@ -98,8 +99,6 @@ export function migrateLegacyDescriptorRoots(dst, entries) {
         afterWrites(() => moveOver(sourceRoot, moved));
     }
 }
-/** A connector key as the legacy layout named its folder: one plain path segment. */
-const LEGACY_ROOT = /^[A-Za-z0-9][A-Za-z0-9_.-]*$/;
 /**
  * `<dst>/<legacyRoot>`, or `undefined` unless it is a real folder strictly
  * inside `dst`. The name comes from `index.json`, a project file anyone with
@@ -107,7 +106,7 @@ const LEGACY_ROOT = /^[A-Za-z0-9][A-Za-z0-9_.-]*$/;
  * overlay.
  */
 function legacyRootDir(dst, legacyRoot) {
-    if (!LEGACY_ROOT.test(legacyRoot))
+    if (!CONNECTOR_KEY_SEGMENT.test(legacyRoot))
         return undefined;
     const root = resolve(dst, legacyRoot);
     const inside = relative(resolve(dst), root);
@@ -223,13 +222,13 @@ export function mergeFilesInto(files, dst) {
     migrateLegacyDescriptorRoots(dst, dstEntries);
     const srcEntries = isPlainObject(srcIdx) ? pyGet(srcIdx, "entries", []) : [];
     dstIdx.entries = mergeIndexEntries(dstEntries, Array.isArray(srcEntries) ? srcEntries : []);
-    writeFileSync(join(dst, INDEX_FILENAME), formatOverlayIndex(dstIdx), "utf8");
+    writeInsideSync(dst, join(dst, INDEX_FILENAME), formatOverlayIndex(dstIdx));
     for (const [rel, content] of files) {
         if (basename(rel) === INDEX_FILENAME)
             continue;
         const out = join(dst, ...descriptorOverlayPath(rel).split("/"));
         mkdirSync(dirname(out), { recursive: true });
-        writeFileSync(out, content);
+        writeInsideSync(dst, out, content);
     }
 }
 /** Every file under `root`, as `POSIX-relative path → bytes`. */

package/dist/registry/prepare/regenerate.js

@@ -23,7 +23,7 @@ import { Refusal } from "../errors.js";
 import { formatRequiredInputGaps, renderDescriptorModules } from "../generators/descriptors.js";
 import { loadLibrary } from "../library-reader.js";
 import { overlayHasGenericExpanded } from "./overlay.js";
-import { mkdirSync, stagedReadText, writeFileSync } from "./staged-files.js";
+import { mkdirSync, stagedReadText, writeInsideSync } from "./staged-files.js";
 /**
  * Write `<out>/<connectorKey>.ts` for every connector in the overlay and
  * return the module names written; nothing at all under `--json-only`.
@@ -42,7 +42,7 @@ export function regenerateDescriptors(out, importSpecifier, jsonOnly = false) {
     });
     mkdirSync(out, { recursive: true });
     for (const [name, text] of output.modules)
-        writeFileSync(join(out, name), text, "utf8");
+        writeInsideSync(out, join(out, name), text);
     if (output.requiredInputGaps.length > 0) {
         throw new Refusal(formatRequiredInputGaps(output.requiredInputGaps), "REQUIRED_INPUT_GAP");
     }

package/dist/registry/prepare/staged-files.d.ts

@@ -8,6 +8,8 @@ export declare function stagedWrites<T>(work: () => Promise<T>): Promise<T>;
 /** Run `step` once the held files are written: at once outside a run, never for a run that throws. */
 export declare function afterWrites(step: () => void): void;
 export declare function writeFileSync(path: string, content: string | Uint8Array, encoding?: "utf8"): void;
+/** {@link writeFileSync}, refused unless the write lands inside `root` once links are followed. */
+export declare function writeInsideSync(root: string, path: string, content: string | Uint8Array): void;
 /** A held file's parent is made when it is written, so there is nothing to make yet. */
 export declare function mkdirSync(path: string, options: {
     recursive: true;

package/dist/registry/prepare/staged-files.js

@@ -13,11 +13,13 @@
  * helper called on its own (the tests, `mergeInto`) writes at once as before.
  */
 import * as fs from "node:fs";
-import { basename, dirname, resolve } from "node:path";
+import { basename, dirname, isAbsolute, relative, resolve, sep } from "node:path";
 import { defaultReadText } from "../../core/read-text.js";
 import { Refusal, messageOf } from "../errors.js";
-import { PrepareRefusal, discardedNote, partialWriteMessage } from "./messages.js";
+import { PrepareRefusal, discardedNote, partialWriteMessage, writeOutsideMessage } from "./messages.js";
 let pending;
+/** The folder each held file written by {@link writeInsideSync} must land in. */
+let confinedTo = new Map();
 let afterwards = [];
 /**
  * Run `work` with its writes held, then write them all, or none when it throws.
@@ -30,6 +32,8 @@ export async function stagedWrites(work) {
     }
     const files = new Map();
     pending = files;
+    const roots = new Map();
+    confinedTo = roots;
     const then = [];
     afterwards = then;
     let result;
@@ -46,6 +50,11 @@ export async function stagedWrites(work) {
     }
     // An index written before a failed write would name descriptors that are not there.
     const indexLast = [...files].sort(([a], [b]) => Number(basename(a) === "index.json") - Number(basename(b) === "index.json"));
+    for (const [path] of indexLast) {
+        const root = roots.get(path);
+        if (root !== undefined)
+            assertLandsInside(root, path);
+    }
     for (const [path, content] of indexLast) {
         try {
             fs.mkdirSync(dirname(path), { recursive: true });
@@ -75,6 +84,58 @@ export function writeFileSync(path, content, encoding) {
     else
         fs.writeFileSync(path, content, encoding);
 }
+/** {@link writeFileSync}, refused unless the write lands inside `root` once links are followed. */
+export function writeInsideSync(root, path, content) {
+    if (pending !== undefined) {
+        pending.set(resolve(path), content);
+        confinedTo.set(resolve(path), root);
+        return;
+    }
+    assertLandsInside(root, path);
+    fs.mkdirSync(dirname(path), { recursive: true });
+    fs.writeFileSync(path, content);
+}
+/** A project can ship links, and a write follows them, so a link at or above `path` must not lead out of `root`. */
+function assertLandsInside(root, path) {
+    const refuse = () => {
+        throw new PrepareRefusal(writeOutsideMessage(path, root), "PREPARE_WRITE_OUTSIDE_OUT");
+    };
+    if (isLink(path))
+        refuse();
+    // Nothing under a folder that is not there yet can be a link.
+    if (!fs.existsSync(root))
+        return;
+    let dir = dirname(resolve(path));
+    while (!existsLexically(dir))
+        dir = dirname(dir);
+    let real;
+    try {
+        real = fs.realpathSync(dir);
+    }
+    catch {
+        return refuse();
+    }
+    const inside = relative(fs.realpathSync(root), real);
+    if (inside === ".." || inside.startsWith(`..${sep}`) || isAbsolute(inside))
+        refuse();
+}
+function isLink(path) {
+    try {
+        return fs.lstatSync(path).isSymbolicLink();
+    }
+    catch {
+        return false;
+    }
+}
+function existsLexically(path) {
+    try {
+        fs.lstatSync(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 /** A held file's parent is made when it is written, so there is nothing to make yet. */
 export function mkdirSync(path, options) {
     if (pending === undefined)
@@ -93,8 +154,10 @@ export function readFileSync(path, encoding) {
 }
 /** Drops a held file; only outside a run does it reach the disk. */
 export function rmSync(path) {
-    if (pending !== undefined)
+    if (pending !== undefined) {
         pending.delete(resolve(path));
+        confinedTo.delete(resolve(path));
+    }
     else
         fs.rmSync(path);
 }

package/dist/registry/pull-cli.js

@@ -121,6 +121,14 @@ async function download(url) {
     }
     return new Uint8Array(await response.arrayBuffer());
 }
+/** `http://u:p@h` -> `http://***@h` */
+function redactProxyCredentials(proxy) {
+    const at = proxy.lastIndexOf("@");
+    if (at < 0)
+        return proxy;
+    const scheme = /^(?:[a-z][a-z0-9+.-]*:)?\/\//i.exec(proxy)?.[0] ?? "";
+    return `${scheme}***${proxy.slice(at)}`;
+}
 /**
  * Node's built-in fetch ignores HTTP(S)_PROXY unless told otherwise, and it
  * fails in a way that looks like the server is down. Say so up front, and name
@@ -133,7 +141,7 @@ function warnAboutProxy() {
         process.env.http_proxy;
     if (!proxy)
         return;
-    console.error(`registry pull: a proxy is set (${proxy}) and Node's fetch does not use it by default.\n` +
+    console.error(`registry pull: a proxy is set (${redactProxyCredentials(proxy)}) and Node's fetch does not use it by default.\n` +
         "  If the download fails, either run with NODE_USE_ENV_PROXY=1 (Node 24+),\n" +
         "  or fetch the zip yourself and pass --archive <path>.");
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uipath/maestro-builder-sdk",
-  "version": "6.70.2",
+  "version": "6.70.3",
   "description": "Build UiPath Flow, Case, and BPMN artifacts by writing TypeScript.",
   "license": "MIT",
   "homepage": "https://docs.uipath.com/maestro",
@@ -100,5 +100,5 @@
     "@types/node": "^22.7.0",
     "esbuild": "^0.28.1"
   },
-  "gitref": "f3203eee21b892b6b70e41a5bf791aa30fdc0fc2"
+  "gitref": "6b61cee8ad9385d18ac7eb4276abeed39246874e"
 }