@uipath/maestro-builder-sdk 6.66.1 → 6.66.3

package/dist/nodes/hitl/flow/check.js

@@ -25,6 +25,7 @@ export const HITL_DIAGNOSTICS = {
     HITL_APP_INPUT_UNKNOWN: { severity: 'error', summary: 'an app input the action schema does not declare' },
     HITL_APP_INPUT_REQUIRED: { severity: 'error', summary: 'a required app input left unbound' },
     HITL_APP_OUTCOME_UNKNOWN: { severity: 'error', summary: 'an outcome the app has no button for' },
+    HITL_APP_LOCAL_HAS_FOLDER: { severity: 'error', summary: 'an in-solution app with a folderPath' },
     HITL_NO_FIELDS: { severity: 'error', summary: 'no fields array' },
     HITL_FIELD_NO_ID: { severity: 'error', summary: 'a form field with no id' },
     HITL_DUP_FIELD: { severity: 'error', summary: 'a form field id declared twice' },
@@ -185,11 +186,23 @@ export function checkHitl(inputs, ctx) {
                 + `App — but names no app, so nothing tells the platform which form to show.`, `app: { name: 'Expense Review', key: '<guid>', folderPath: 'Shared' }`);
             return;
         }
-        for (const k of ['name', 'key', 'folderPath']) {
+        // An in-solution app has no folder to author. A published one does: with
+        // none it is serialized as an inline app, and on a serializer before
+        // flow-v1 #4076 the task loses its folderPath context and fails at run
+        // time (170004, "Invalid input for the HITL task").
+        const inSolution = app.location === 'in-solution';
+        for (const k of inSolution ? ['name', 'key'] : ['name', 'key', 'folderPath']) {
             if (typeof app[k] !== 'string' || !app[k].trim()) {
-                at('HITL_APP_INCOMPLETE', `Human task "${step}" names an Action App with no ${k}. An app is resolved by its key plus `
-                    + `the folder it is deployed in, with the name shown to the reviewer — all three are needed `
-                    + `for the platform to find it.`, `app: { name: 'Expense Review', key: '<guid>', folderPath: 'Shared' }`);
+                at('HITL_APP_INCOMPLETE', inSolution
+                    ? `Human task "${step}" names an in-solution Action App with no ${k}. An in-solution app is `
+                        + `resolved by its key (\`resource.key\` in resources/solution_folder/app/codedAction/<App>.json), `
+                        + `with the name shown to the reviewer — both are needed for the platform to find it.`
+                    : `Human task "${step}" names an Action App with no ${k}. An app is resolved by its key plus `
+                        + `the folder it is deployed in, with the name shown to the reviewer — all three are needed `
+                        + `for the platform to find it. If the app is in the same solution as the flow, set `
+                        + `\`location: 'in-solution'\` instead of a folder.`, inSolution
+                    ? `app: { name: 'InvoiceReview', key: '<resource.key>', location: 'in-solution' }`
+                    : `app: { name: 'Expense Review', key: '<guid>', folderPath: 'Shared' }`);
                 return;
             }
         }
@@ -235,6 +248,12 @@ export function checkHitl(inputs, ctx) {
                 }
             }
         }
+        if (inSolution && app.folderPath !== undefined && app.folderPath !== '') {
+            at('HITL_APP_LOCAL_HAS_FOLDER', `Human task "${step}" names an in-solution Action App with folderPath ${JSON.stringify(app.folderPath)}. `
+                + `An in-solution app has no folder — it is emitted with the empty folder the platform's app picker `
+                + `writes for an app inline to the solution — so the value would be dropped. Remove it, or drop `
+                + `\`location: 'in-solution'\` to call an app published to that folder.`, `Delete \`folderPath\`.`);
+        }
         // Outcomes still matter for an app task: the flow's own routing and its
         // `Action`/`status` outputs are derived from them, so fall through to the
         // outcome rules below rather than returning here.

package/dist/nodes/hitl/flow/node-type.js

@@ -22,6 +22,7 @@ import { wireExprBody } from '../../../core/wire-expr.js';
 import { appAnswerSchemas, appInputSchema, liftActionSchema, normalizeActionSchema } from './action-schema.js';
 import { checkHitl, checkHitlRead } from './check.js';
 import { CompileRefusal } from '../../../core/compile-refusal.js';
+import { processResourceBindings } from '../../../core/process-resource.js';
 const BASE = 'uipath.human-in-the-loop';
 const QUICK_FORM = 'uipath.human-in-the-loop.quick-form';
 const ACTION_APP = 'uipath.human-in-the-loop.coded-action-app';
@@ -131,6 +132,14 @@ function hitlInputs(inputs, nodeType, ctx) {
     for (const [name, value] of Object.entries(app?.inputs ?? {})) {
         appInputBindings[name] = appBindingExpr(value, ctx);
     }
+    const emitsApp = (isApp || (nodeType === DOC_VALIDATION && inputs?.document?.render === 'custom')) && app !== undefined;
+    // An in-solution app has no folder: the platform's own picker writes `''`,
+    // and its serializer keeps that `''` in the task context (flow-v1 #4076).
+    const appFolder = app?.location === 'in-solution' ? '' : (app?.folderPath ?? '');
+    if (emitsApp) {
+        for (const b of appResourceBindings({ name: app.name, key: app.key, folderPath: appFolder }, ctx.bindings))
+            ctx.bind(b);
+    }
     // The author's recipient when given; the definition's own default otherwise
     // (unchanged — that default is what 203 of 233 deployed v1 tasks carry).
     // `1.0`: every human-task type's first bundled definition, which is the one
@@ -189,13 +198,13 @@ function hitlInputs(inputs, nodeType, ctx) {
             ...(inputs?.labels !== undefined ? { labels: inputs.labels } : {}),
             recipient,
             ...docvalInputs,
-            ...((isApp || (nodeType === DOC_VALIDATION && doc?.render === 'custom')) && app
+            ...(emitsApp
                 ? {
                     app: {
                         displayName: app.name,
                         name: app.name,
                         key: app.key,
-                        folderPath: app.folderPath,
+                        folderPath: appFolder,
                         ...(app.appSystemName !== undefined ? { appSystemName: app.appSystemName } : {}),
                         // What types the task's arguments (see action-schema.ts): lowered
                         // from the action schema, or the decompiled node's own, verbatim.
@@ -230,6 +239,34 @@ function hitlInputs(inputs, nodeType, ctx) {
         },
     };
 }
+/**
+ * The canvas's legacy placeholder folder for an app inline to the solution. The
+ * platform's own app picker clears it to `''` (flow-v1 `HITLAppPicker.tsx`
+ * `INLINE_APP_FOLDER_TOKEN`, #4076): an inline app has no deploy-time
+ * overwrite, so the token would reach the engine literally and be refused
+ * (170000). Read back as `location: 'in-solution'`, never emitted.
+ */
+const INLINE_APP_FOLDER_TOKEN = 'solution_folder';
+/**
+ * The `app` binding pair for one Action App, through the shared
+ * {@link processResourceBindings}: one pair per app, keyed the way flow-v1's app
+ * picker creates them — by the app's `key` once it has a folder, by its `name`
+ * while it has none (an in-solution app) (`hitl-serialization.ts`,
+ * `HITLAppPicker.tsx`, flow-v1 #3910). The serializer resolves the task's
+ * `<bindings.name>` / `<bindings.folderPath>` context against them; without a
+ * row the placeholder text reaches the engine, and packaging leaves the app out
+ * of `bindings_v2.json`. Serializers before #3910 (flow-converter 0.69) key the
+ * app by name only and fall back to the FIRST row named `name`/`folderPath` of
+ * any resource.
+ */
+function appResourceBindings(spec, existing) {
+    return processResourceBindings({
+        name: spec.name,
+        folderPath: spec.folderPath,
+        resource: 'app',
+        resourceKey: spec.folderPath ? spec.key : spec.name,
+    }, existing).entries;
+}
 /**
  * One `appInputBindings` value: the expression sent to a deployed app's input.
  *
@@ -416,7 +453,10 @@ function liftHitl(node, typeName, ctx) {
         // `displayName` is serialize's echo of `name`; only `name` is authored.
         name: String(app.name ?? ''),
         key: String(app.key ?? ''),
-        ...(typeof app.folderPath === 'string' && app.folderPath !== '' ? { folderPath: app.folderPath } : {}),
+        // No folder (or the canvas's legacy inline placeholder) is how the platform
+        // writes an app inline to the solution.
+        ...(typeof app.folderPath === 'string' && app.folderPath !== '' && app.folderPath !== INLINE_APP_FOLDER_TOKEN
+            ? { folderPath: app.folderPath } : { location: 'in-solution' }),
         ...(app.appSystemName === null ? { appSystemName: null }
             : typeof app.appSystemName === 'string' ? { appSystemName: app.appSystemName } : {}),
         ...(appInputs !== undefined ? { inputs: appInputs } : {}),
@@ -517,6 +557,7 @@ function printHitl({ inputs }, ctx) {
     const app = h.app === undefined ? undefined : obj([
         ['name', ctx.string(h.app.name)],
         ['key', ctx.string(h.app.key)],
+        ['location', h.app.location !== undefined ? ctx.string(h.app.location) : undefined],
         ['folderPath', h.app.folderPath !== undefined ? ctx.string(h.app.folderPath) : undefined],
         ['appSystemName', h.app.appSystemName === null ? 'null'
                 : h.app.appSystemName !== undefined ? ctx.string(h.app.appSystemName) : undefined],

package/dist/nodes/hitl/flow/spec.d.ts

@@ -6,7 +6,7 @@
  * `core/actions.ts`: an agent's quick-form escalation shares them.
  */
 import type { Expr } from '../../../core/expr.js';
-import type { FormField } from '../../../core/actions.js';
+import type { FormField, ProcessLocation } from '../../../core/actions.js';
 /**
  * Where the task is delivered. The four ids are the platform's own — including
  * the lowercase `'teams'`, which is how every deployed recipient spells
@@ -164,15 +164,44 @@ export type HitlVariant = 'quick-form' | 'action-app' | 'document-validation';
  *   },
  *   outcomes: ['Approve', 'Reject'],
  * })
+ *
+ * // A coded action app in the same solution as the flow:
+ * hitl({
+ *   variant: 'action-app',
+ *   app: { name: 'InvoiceReview', key: '<resource.key>', location: 'in-solution' },
+ *   outcomes: ['Approve', 'Reject'],
+ * })
  * ```
  */
 export interface AppRef {
     /** The app's display title, e.g. `'Expense Review'`. */
     name: string;
-    /** The app's key (a GUID) — how the platform resolves which app this is. */
+    /**
+     * The app's key (a GUID) — how the platform resolves which app this is.
+     *
+     * For an in-solution app it is `resource.key` from
+     * `resources/solution_folder/app/codedAction/<App>.json`.
+     */
     key: string;
-    /** Fully-qualified folder the app is deployed in, e.g. `'Shared'`. */
-    folderPath: string;
+    /**
+     * Where the app lives. `'published'` (the default) is an app deployed to
+     * `folderPath`. `'in-solution'` is a coded action app in the same solution as
+     * the flow: it takes no `folderPath` — it is emitted with the empty folder
+     * and name-keyed bindings the platform's own app picker writes for an app
+     * inline to the solution. Needs a `uip` CLI with flow-converter 0.100.3 or
+     * later (or a process engine with MST-15436); older ones fail at run time
+     * with 170004.
+     *
+     * @enforcedBy HITL_APP_LOCAL_HAS_FOLDER An in-solution app takes no folderPath.
+     */
+    location?: ProcessLocation;
+    /**
+     * Fully-qualified folder the app is deployed in, e.g. `'Shared'`. Required
+     * for a published app; omit it for an in-solution one.
+     *
+     * @enforcedBy HITL_APP_INCOMPLETE A published app needs its folder.
+     */
+    folderPath?: string;
     /**
      * The app's stable system name. `null` until the app's first deployment
      * assigns one, which is why it is optional and why `null` is a legal value

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uipath/maestro-builder-sdk",
-  "version": "6.66.1",
+  "version": "6.66.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": "02d8fadeacf6db38788390221a4550dffd114a69"
+  "gitref": "e7e32040e5596319cf1bccea2a6caa9124d79bbb"
 }