@uipath/maestro-builder-sdk 6.17.2 → 6.17.4

package/dist/core/cli-library.js

@@ -96,7 +96,8 @@ export function connectorCheckOpts(library, bindings, inputErrors = (rc, inputs,
         },
         // The refusal compile throws for an operation it cannot resolve, with its
         // code and text: CONNECTOR_NOT_IN_LIBRARY, CONNECTOR_OBJECT_REQUIRED,
-        // CONNECTOR_OBJECT_NOT_GENERIC.
+        // CONNECTOR_OBJECT_NOT_GENERIC, CONNECTOR_LIBRARY_ENTRY_UNREADABLE, or
+        // CONNECTOR_RESOLVE_FAILED for any other throw.
         connectorResolveError: (spec) => {
             const r = resolve(spec);
             return 'error' in r ? r.error : undefined;
@@ -114,11 +115,19 @@ export function connectorCheckOpts(library, bindings, inputErrors = (rc, inputs,
         ...(bindings ? { bindings } : {}),
     };
 }
+/** `check`'s code for an untyped throw from `library.resolve`; see {@link connectorResolver}. */
+const CONNECTOR_RESOLVE_FAILED = 'CONNECTOR_RESOLVE_FAILED';
 /**
  * `library.resolve` for one connector step, memoized per step for the life of
- * one check's options. A {@link ConnectorResolveError} is the refusal compile
- * throws and becomes `error`; anything else thrown is not a verdict about the
- * author's source and stays "unknown", as before.
+ * one check's options.
+ *
+ * This is the exact call `serialize` makes, so ANY throw here is a throw compile
+ * makes too, and becomes `error`. A {@link ConnectorResolveError} keeps its own
+ * code (CONNECTOR_NOT_IN_LIBRARY, CONNECTOR_LIBRARY_ENTRY_UNREADABLE, …).
+ * Anything else, which `library.resolve` does not throw on purpose, is reported
+ * as CONNECTOR_RESOLVE_FAILED with its message. Treating an untyped throw as
+ * "unknown" used to let `check` pass a step `compile` then died on (#1015); the
+ * event twin, `eventResolveErrorFor`, already reported every throw.
  */
 function connectorResolver(library) {
     const memo = new Map();
@@ -132,7 +141,7 @@ function connectorResolver(library) {
             catch (error) {
                 r = error instanceof ConnectorResolveError
                     ? { error: { code: error.code, message: error.message } }
-                    : { unknown: true };
+                    : { error: { code: CONNECTOR_RESOLVE_FAILED, message: error instanceof Error ? error.message : String(error) } };
             }
             memo.set(id, r);
         }

package/dist/core/library.d.ts

@@ -225,7 +225,12 @@ export type ConnectorResolveCode =
 /** A GENERIC operation (one entry per object) named without an `object`. */
  | 'CONNECTOR_OBJECT_REQUIRED'
 /** An `object` on a single, non-generic operation. */
- | 'CONNECTOR_OBJECT_NOT_GENERIC';
+ | 'CONNECTOR_OBJECT_NOT_GENERIC'
+/**
+ * The index lists the operation, but its entry file or `.v1def.json` sidecar is
+ * missing or not valid JSON: the library on disk is incomplete (#1015).
+ */
+ | 'CONNECTOR_LIBRARY_ENTRY_UNREADABLE';
 /**
  * The refusal {@link Library.resolve} throws, with a `code` for each reason.
  *

package/dist/core/library.js

@@ -827,8 +827,13 @@ export class Library {
     }
     build(dir, e, nodeType, opts = {}) {
         const entryPath = join(dir, e.path);
-        const entry = JSON.parse(readFileSync(entryPath, 'utf8'));
-        const v1def = readV1def(entryPath);
+        // The two files the index row promises. A missing or corrupt one is a fault in
+        // the library on disk, not in the author's source, but compile cannot go on
+        // without it, so it is a typed refusal like the others: `check` reports it with
+        // the same code and text instead of passing a step compile then dies on with a
+        // bare ENOENT (#1015).
+        const entry = readLibraryFile(nodeType, entryPath, () => JSON.parse(readFileSync(entryPath, 'utf8')));
+        const v1def = readLibraryFile(nodeType, v1defPathOf(entryPath), () => readV1def(entryPath));
         // A stamped object (case 4) reaches here with the index entry's `objectName`
         // replaced but the sibling's FILE on disk — so restate the object and derive
         // the endpoint from the sibling's own template, rather than shipping a node
@@ -944,6 +949,33 @@ function deriveObjectPath(operation, objectName) {
     }
     return out;
 }
+/** The `.v1def.json` sidecar path beside a library entry file. */
+function v1defPathOf(entryPath) {
+    return entryPath.replace(/\.json$/, '.v1def.json');
+}
+/**
+ * Read one file an index row points at, turning a missing or unparsable file
+ * into {@link ConnectorResolveError} `CONNECTOR_LIBRARY_ENTRY_UNREADABLE`.
+ *
+ * The library build refuses to write an entry without its sidecar
+ * (`registry/library-build/plan.ts`), so this only fires for a library that was
+ * damaged after it was built: an interrupted pull, a hand-edited overlay. The
+ * remedy is the same either way: rebuild the layer the file belongs to.
+ */
+function readLibraryFile(nodeType, path, read) {
+    try {
+        return read();
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        // ENOENT already names the path; a JSON SyntaxError does not.
+        const reason = message.includes(path) ? message : `${path}: ${message}`;
+        throw new ConnectorResolveError('CONNECTOR_LIBRARY_ENTRY_UNREADABLE', `connector library entry for ${nodeType} is unreadable: ${reason}. The library index lists `
+            + `this operation, but the file is missing or not valid JSON, so the library on disk is incomplete. `
+            + `Refresh it with \`${PULL_COMMAND}\`; if the file is in the \`connectors-local\` overlay, `
+            + `re-run the \`${prepareCommand()}\` that wrote it.`);
+    }
+}
 /**
  * Read the `.v1def.json` sidecar beside a library entry file, with a connection
  * definition's `model.bindings.resource` in the designer's canonical casing.
@@ -961,7 +993,7 @@ function deriveObjectPath(operation, objectName) {
  * validate and debug — which fold the case — passed.
  */
 function readV1def(entryPath) {
-    const raw = JSON.parse(readFileSync(entryPath.replace(/\.json$/, '.v1def.json'), 'utf8'));
+    const raw = JSON.parse(readFileSync(v1defPathOf(entryPath), 'utf8'));
     const v1def = Array.isArray(raw) ? raw[0] : raw;
     const bindings = v1def?.model?.bindings;
     if (typeof bindings?.resource === 'string' && bindings.resource.toLowerCase() === 'connection') {

package/dist/decompile.js

@@ -1710,6 +1710,27 @@ function emitEventSubscription(node, imp, inputNames) {
         ['folder', folder !== undefined ? str(folder) : undefined],
     ]) + unboundMarker(node, { connection: conn, folder }, connector, event);
 }
+/**
+ * Read back the expression template older SDK builds emitted on an in-solution
+ * `agent()` input (#1013): `{ type: 'literal', expression: '{{ <js> }}' }`.
+ * serialize now emits the platform's `{ type: 'jsExpression', expression }`
+ * instead, but `.flow` files written between 2026-08-10 and the fix still carry
+ * the template, and the runtime evaluates it (the agent receives the value, not
+ * the braces). So on an in-solution agent node a literal that is exactly one
+ * `{{ … }}` is that expression, and it decompiles to the reference it was
+ * written from rather than to a string. Anything else is returned unchanged.
+ */
+function legacyAgentTemplateInput(v) {
+    if (!v || typeof v !== 'object' || Array.isArray(v))
+        return v;
+    const o = v;
+    if (o.type !== 'literal' || typeof o.expression !== 'string')
+        return v;
+    const m = /^\{\{\s*([\s\S]+?)\s*\}\}$/.exec(o.expression);
+    if (!m || m[1].includes('}}') || m[1].includes('{{'))
+        return v;
+    return { ...o, type: 'jsExpression', expression: m[1] };
+}
 function emitPublishedResource(node, imp, inputNames) {
     const FAMILIES = [
         { prefix: 'uipath.core.rpa-workflow.', factory: 'rpaWorkflow' },
@@ -1751,6 +1772,10 @@ function emitPublishedResource(node, imp, inputNames) {
     // author's map, so it comes back off here.
     const fireAndForget = unwrapPlain(inputs.fireAndForget) === true;
     delete inputs.fireAndForget;
+    if (family.factory === 'agent' && (def?.model?.isInSolution === true || def?.model?.projectId !== undefined)) {
+        for (const [k, v] of Object.entries(inputs))
+            inputs[k] = legacyAgentTemplateInput(v);
+    }
     const inputRows = Object.entries(inputs)
         .map(([k, v]) => [k, emitVal(v, imp, inputNames)]);
     const schema = def?.outputDefinition?.output?.schema?.properties;

package/dist/serialize.js

@@ -5284,18 +5284,15 @@ export function serialize(built, opts = {}) {
             // three published families — 58 of 61 deployed agent instances carry no
             // node-level `model` at all.
             delete node.model;
+            // Expression inputs stay `=js:` strings here, published or in-solution, and
+            // the format migration wraps them as `{ type: 'jsExpression', expression }`
+            // — the shape flow-core writes for an in-solution agent (52 of 54 v1
+            // expression inputs, 09-01 → 10-08; the other 2 are bare `=js:` strings,
+            // none is a `{{ }}` template). A `{ type: 'literal',
+            // expression: '{{ … }}' }` template used to be emitted instead (#1013): it
+            // ran, but it is the same envelope as a literal string, so decompile read
+            // it back as one.
             node.inputs = renderMap(s.inputs, scope.rename);
-            if (inSolution) {
-                for (const [name, value] of Object.entries(node.inputs)) {
-                    if (typeof value === 'string' && value.startsWith('=js:')) {
-                        node.inputs[name] = {
-                            type: 'literal',
-                            expression: `{{ ${value.slice(4)} }}`,
-                            fieldType: def.inputDefinition?.properties?.[name]?.type ?? 'string',
-                        };
-                    }
-                }
-            }
             scope.nodes.push(node);
             for (const t of tails)
                 addEdge(scope, t, id);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uipath/maestro-builder-sdk",
-  "version": "6.17.2",
+  "version": "6.17.4",
   "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": "629eba0e7332894902dec4cd1ef5c7072c02adf6"
+  "gitref": "6a0dfa03e18d92bd2452c96704c1c80fa122fc11"
 }