@uipath/maestro-builder-sdk 6.18.10 → 6.20.0

package/dist/cli/commands/flow.js

@@ -108,6 +108,7 @@ export function registerFlowCommands(program) {
         .option('--original <file>', '(required) original .flow path, the artifact to merge into')
         .option('-o, --output <file>', 'merged output path')
         .option('--baseline <file>', 'compiled pristine decompile')
+        .option('--strict', 'refuse when the no-edit round trip (--baseline) differs from the original')
         .allowExcessArguments()
         .action(async (_edited, options, command) => {
         const pair = namedOrLegacySecond(command, {
@@ -120,6 +121,8 @@ export function registerFlowCommands(program) {
         const argv = [original, edited];
         addValue(argv, '-o', options.output);
         addValue(argv, '--baseline', options.baseline);
+        if (options.strict)
+            argv.push('--strict');
         await invoke('flow merge', () => loadTool(import.meta.url, '../../merge-cli.js'), argv);
     });
 }

package/dist/compile-cli.js

@@ -167,7 +167,14 @@ export async function run(argv) {
     // families the SDK cannot into the same directory (including `internal`
     // built-ins such as `load-attachments`), so anything else found there is
     // someone else's and is left alone.
+    //
+    // Owning the TYPE is not owning the FILE, though. Decompile keeps a canvas
+    // agent's `source` directory, so compiling decompiled source to another `.flow`
+    // in the same project writes into the ORIGINAL flow's agent directory, and the
+    // canvas resources there are still that flow's. A resource another
+    // `.flow` beside this one references by `inputs.source` is never pruned.
     const removedResources = [];
+    const referencedElsewhere = resourceSourcesOfOtherFlows(outDir, resolve(out));
     const owned = new Set(sidecars
         .filter((s) => /\/resources\/[^/]+\/resource\.json$/.test(s.path))
         .map((s) => resolve(outDir, s.path)));
@@ -182,6 +189,11 @@ export async function run(argv) {
             const file = join(resourcesDir, entry, 'resource.json');
             if (!existsSync(file) || owned.has(file))
                 continue;
+            const user = referencedElsewhere.get(entry);
+            if (user !== undefined) {
+                console.log(`compile: kept ${join('resources', entry, 'resource.json')}: ${user} still references it`);
+                continue;
+            }
             let body;
             try {
                 body = JSON.parse(readFileSync(file, 'utf8'));
@@ -248,3 +260,42 @@ function serializeWarningDiagnostic(w) {
     return { level: 'warning', code: w.code, message: w.message };
 }
 runWhenInvokedDirectly(import.meta.url, 'compile', run);
+/**
+ * The `inputs.source` uuids the OTHER `.flow` files in `dir` reference, each
+ * mapped to the first file that does. `dir` is the namespace sidecar paths are
+ * relative to, so these are the agent resources another flow still uses. The
+ * flow being written (`self`) is left out: what it no longer references is what
+ * pruning is for. Subflow bodies are included; an unreadable file contributes
+ * nothing.
+ */
+function resourceSourcesOfOtherFlows(dir, self) {
+    const users = new Map();
+    let entries;
+    try {
+        entries = readdirSync(dir).filter((f) => f.endsWith('.flow') && resolve(dir, f) !== self);
+    }
+    catch {
+        return users;
+    }
+    for (const f of entries) {
+        let flow;
+        try {
+            flow = JSON.parse(readFileSync(join(dir, f), 'utf8'));
+        }
+        catch {
+            continue;
+        }
+        const walk = (scope) => {
+            const s = scope;
+            for (const n of Array.isArray(s?.nodes) ? s.nodes : []) {
+                const src = n?.inputs?.source;
+                if (typeof src === 'string' && !users.has(src))
+                    users.set(src, f);
+            }
+            if (s?.subflows && typeof s.subflows === 'object')
+                Object.values(s.subflows).forEach(walk);
+        };
+        walk(flow);
+    }
+    return users;
+}