@uipath/maestro-builder-sdk 6.70.4 → 6.70.6

package/dist/compile-cli.js

@@ -24,7 +24,7 @@
  */
 import { diagnosticLine, reportDiagnostics, reportResult, thrownDiagnostic } from './cli-result.js';
 import { writeJsonFile } from './core/json-file.js';
-import { copyFileSync, existsSync, mkdirSync, readdirSync, readFileSync, rmSync } from 'node:fs';
+import { copyFileSync, existsSync, mkdirSync, readdirSync, readFileSync, realpathSync, rmSync } from 'node:fs';
 import { basename, dirname, join, relative, resolve } from 'node:path';
 import { resolveFlowFile, loadBuiltFlow } from './load.js';
 import { serializeWithSidecars } from './serialize.js';
@@ -36,7 +36,7 @@ import { connectionResources, inlineAgentResources, mergeBindingsV2, refreshInli
 import { readBindingsV2, readInlineAgentFiles } from './bindings-v2-files.js';
 import { ensureTypeScriptRuntime } from './node-runtime.js';
 import { defaultBindingsFile } from './workdir.js';
-import { isWithin } from './path-within.js';
+import { isWithin, physicalPath } from './path-within.js';
 import { flowSources, resourceSourcesOfOtherFlows } from './project-resource-users.js';
 import { fnv1aX4Uuid } from './core/stable-id.js';
 import { CompileRefusal } from './core/compile-refusal.js';
@@ -86,7 +86,20 @@ export async function run(argv) {
     // BYOA-only event on a connection `prepare` never checked
     // (EVENT_BYOA_UNVERIFIED): printed in the same `✗ [CODE]` shape `check` uses
     // for it. Nothing is written.
-    const out = flagValue(argv, '-o') ?? `${built.name || basename(file).replace(/\.flow\.ts$|\.ts$/, '')}.flow`;
+    const explicitOut = flagValue(argv, '-o');
+    const out = explicitOut ?? `${built.name || basename(file).replace(/\.flow\.ts$|\.ts$/, '')}.flow`;
+    // The default is named after the flow, which decompile copies from the input: keep it inside cwd.
+    if (explicitOut === undefined) {
+        const target = physicalPath(resolve(out));
+        if (target === undefined || !isWithin(realpathSync.native(process.cwd()), target)) {
+            const message = `refusing to write ${out} outside the working directory: without -o the output is named after`
+                + ` the flow (${JSON.stringify(built.name)}). Pass -o <file>.flow to choose where it is written`;
+            console.error(`compile: ${message}; not emitting.`);
+            diagnostics.push({ level: 'error', code: 'FLOW_NAME_OUTSIDE_WORKING_DIR', message });
+            reportDiagnostics(diagnostics);
+            return 1;
+        }
+    }
     const outDir = dirname(resolve(out));
     // ONE FOLDER, ONE FLOW (#1184). An agent's `source` is the name of the folder
     // beside the `.flow` that holds its `agent.json` and `resources/`. Decompile

package/dist/decompile.js

@@ -35,6 +35,7 @@ import { DEFAULT_TRIGGER_ID, Expr } from './core/expr.js';
 import { FLOW_NODE_TYPES } from './flow-node-registry.js';
 import { SUBFLOW_START_LABEL } from './core/subflow-start.js';
 import { commentText } from './core/comment-text.js';
+import { escapeRegExp } from './core/escape-regexp.js';
 import { tsKey as key, tsLiteral, tsNumber, tsObject as objLit, tsOptions as opts, tsText } from './core/ts-literal.js';
 import { wireExprBody } from './core/wire-expr.js';
 import { hasExits } from './core/step-ports.js';
@@ -2864,7 +2865,7 @@ function emitChildFlow(name, childFile, ctx) {
  */
 function readChildStartAsStart(child, startId) {
     const renamed = renameVarRoot(child, startId, DEFAULT_TRIGGER_ID);
-    const path = new RegExp(`^(=?vars\\.)${startId.replace(/[$]/g, '\\$&')}(?![A-Za-z0-9_$])`);
+    const path = new RegExp(`^(=?vars\\.)${escapeRegExp(startId)}(?![A-Za-z0-9_$])`);
     const walk = (x, key, parentKey) => {
         if (typeof x === 'string')
             return key === 'binding' || parentKey === 'appInputBindings' ? x.replace(path, `$1${DEFAULT_TRIGGER_ID}`) : x;
@@ -2954,8 +2955,9 @@ const RAW_JS_FIELDS = new Set(['script', 'expression', 'condition', 'completionC
  * script stays as written, the way `serialize` left it (#1092 review).
  */
 function renameVarRoot(v, from, to) {
-    const re = new RegExp(`\\$vars\\.${from.replace(/[$]/g, '\\$&')}(?![A-Za-z0-9_$])`, 'g');
-    const inCode = (js) => mapJsCode(js, (code) => code.replace(re, `$vars.${to}`));
+    const re = new RegExp(`\\$vars\\.${escapeRegExp(from)}(?![A-Za-z0-9_$])`, 'g');
+    // a function: `$&` in `to` is data
+    const inCode = (js) => mapJsCode(js, (code) => code.replace(re, () => `$vars.${to}`));
     const walk = (x, key) => {
         if (typeof x === 'string') {
             if (x.startsWith('=js:'))

package/dist/path-within.d.ts

@@ -1,20 +1,3 @@
-/**
- * path-within — the one path-containment test for anything that writes files.
- *
- * "Is `child` inside `parent`?" looks like a string-prefix question and is not
- * one. `child.startsWith(parent + '/')` is correct only where the separator is
- * `/`: on Windows `path.resolve` returns `C:\proj\P\x`, the check refuses every
- * path, and compile refused every inline agent's `<source>/agent.json`
- * (flow-builder-sdk#946). A prefix test without a trailing separator has the
- * opposite bug: it accepts the sibling `C:\proj\P2\x` as inside `C:\proj\P`.
- *
- * So the test is `relative(parent, child)` instead, which gets both right on
- * every platform, and Windows' case-insensitive drive letters and
- * cross-drive paths (`relative` returns the absolute `D:\x` there) with them.
- *
- * The path implementation is a parameter so the Windows rules can be tested on
- * a Linux runner (`isWithin(a, b, path.win32)`). Callers leave it out.
- */
 import * as nodePath from 'node:path';
 /** The slice of `node:path` the test needs; `path.win32` and `path.posix` both fit. */
 export type PathApi = Pick<typeof nodePath, 'relative' | 'isAbsolute' | 'sep'>;
@@ -31,3 +14,18 @@ export type PathApi = Pick<typeof nodePath, 'relative' | 'isAbsolute' | 'sep'>;
  *   isWithin('C:\\proj\\P', 'D:\\agent.json', path.win32)  // false — other drive
  */
 export declare function isWithin(parent: string, child: string, path?: PathApi): boolean;
+/**
+ * Where `dir` lands on disk: the real path of its deepest ancestor that
+ * exists, every link on the way followed, then the rest of `dir`, which does
+ * not exist yet and so holds no link. `undefined` when that ancestor's real
+ * path cannot be read: a link to nothing, or a loop of links. A caller treats
+ * `undefined` as outside.
+ *
+ * The agent SDK's CLI keeps a copy of this function for its default output
+ * folder, so both CLIs follow links the same way.
+ *
+ * @example
+ *   // ./work/sw-basic/l is a link to /elsewhere, and X does not exist:
+ *   physicalPath('/cwd/work/sw-basic/l/X')  // '/elsewhere/X'
+ */
+export declare function physicalPath(dir: string): string | undefined;

package/dist/path-within.js

@@ -12,10 +12,16 @@
  * every platform, and Windows' case-insensitive drive letters and
  * cross-drive paths (`relative` returns the absolute `D:\x` there) with them.
  *
+ * `isWithin` reads only the spelling of its paths, so a link inside `parent`
+ * that points out of it passes. A check that guards a write compares
+ * `physicalPath`s instead.
+ *
  * The path implementation is a parameter so the Windows rules can be tested on
  * a Linux runner (`isWithin(a, b, path.win32)`). Callers leave it out.
  */
+import { lstatSync, realpathSync } from 'node:fs';
 import * as nodePath from 'node:path';
+import { basename, dirname, join } from 'node:path';
 /**
  * `child` is `parent` itself or somewhere beneath it.
  *
@@ -39,3 +45,41 @@ export function isWithin(parent, child, path = nodePath) {
     // Windows: a child on another drive has no relative spelling.
     return !path.isAbsolute(rel);
 }
+/**
+ * Where `dir` lands on disk: the real path of its deepest ancestor that
+ * exists, every link on the way followed, then the rest of `dir`, which does
+ * not exist yet and so holds no link. `undefined` when that ancestor's real
+ * path cannot be read: a link to nothing, or a loop of links. A caller treats
+ * `undefined` as outside.
+ *
+ * The agent SDK's CLI keeps a copy of this function for its default output
+ * folder, so both CLIs follow links the same way.
+ *
+ * @example
+ *   // ./work/sw-basic/l is a link to /elsewhere, and X does not exist:
+ *   physicalPath('/cwd/work/sw-basic/l/X')  // '/elsewhere/X'
+ */
+export function physicalPath(dir) {
+    const rest = [];
+    let at = dir;
+    for (;;) {
+        try {
+            lstatSync(at);
+            break;
+        }
+        catch {
+            // Missing: its parent, then.
+        }
+        const parent = dirname(at);
+        if (parent === at)
+            break;
+        rest.unshift(basename(at));
+        at = parent;
+    }
+    try {
+        return join(realpathSync.native(at), ...rest);
+    }
+    catch {
+        return undefined;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uipath/maestro-builder-sdk",
-  "version": "6.70.4",
+  "version": "6.70.6",
   "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": "e9ad3d42f515a19663813c7befb4f6afdea2b87c"
+  "gitref": "acb0888df4770ee4db5ebb89ef2116cf400ee1b9"
 }