@uipath/maestro-builder-sdk 5.2.0

package/dist/cli/commands/bpmn.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from 'commander';
+export declare function registerBpmnCommands(program: Command): void;

package/dist/cli/commands/bpmn.js

@@ -0,0 +1,73 @@
+import { addValue, inferCheckMode, invoke, loadTool } from '../common.js';
+export function registerBpmnCommands(program) {
+    const family = program.command('bpmn').description('Build, inspect, and merge BPMN artifacts.');
+    family.command('compile')
+        .description('Compile authored TypeScript to a .bpmn artifact.')
+        .argument('<source>', 'a .bpmn.ts path or bare name')
+        .option('-o, --output <file>', 'output .bpmn path')
+        .option('--library <dir>', 'connector library directory')
+        .option('--bindings <file>', 'bindings.json path')
+        .action(async (source, options) => {
+        const argv = [source];
+        addValue(argv, '-o', options.output);
+        addValue(argv, '--library', options.library);
+        addValue(argv, '--bindings', options.bindings);
+        await invoke('bpmn compile', () => loadTool(import.meta.url, '../../bpmn/compile-cli.js'), argv);
+    });
+    family.command('check')
+        .description('Check authored TypeScript; use the product CLI for compiled BPMN.')
+        .argument('<input>', 'source or .bpmn artifact')
+        .option('--source', 'check authored TypeScript')
+        .option('--compiled', 'identify a compiled artifact')
+        .action(async (input, options) => {
+        let mode;
+        try {
+            mode = inferCheckMode('bpmn', input, options.source === true, options.compiled === true);
+        }
+        catch (error) {
+            console.error(`flow-sdk bpmn check: ${error instanceof Error ? error.message : String(error)}`);
+            process.exitCode = 2;
+            return;
+        }
+        if (mode === 'compiled') {
+            console.error('flow-sdk bpmn check --compiled: use `uip maestro bpmn validate <file.bpmn>`');
+            process.exitCode = 2;
+            return;
+        }
+        await invoke('bpmn check', () => loadTool(import.meta.url, '../../bpmn/check-cli.js'), [input]);
+    });
+    family.command('tidy')
+        .description('Add diagram layout to a compiled .bpmn artifact.')
+        .argument('<input>', 'input .bpmn path')
+        .option('-o, --output <file>', 'output .bpmn path')
+        .action(async (input, options) => {
+        const argv = [input];
+        addValue(argv, '-o', options.output);
+        await invoke('bpmn tidy', () => loadTool(import.meta.url, '../../bpmn/tidy-cli.js'), argv);
+    });
+    family
+        .command('decompile')
+        .description('Convert a .bpmn artifact to authored TypeScript.')
+        .argument('<input>', 'input .bpmn path')
+        .option('-o, --output <file>', 'output .bpmn.ts path')
+        .option('--import <specifier>', 'SDK import specifier in generated source')
+        .action(async (input, options) => {
+        const argv = [input];
+        addValue(argv, '-o', options.output);
+        addValue(argv, '--import', options.import);
+        await invoke('bpmn decompile', () => loadTool(import.meta.url, '../../bpmn/decompile-cli.js'), argv);
+    });
+    family
+        .command('merge')
+        .description('Merge an edited process with its original BPMN artifact.')
+        .argument('<original>', 'original .bpmn path')
+        .argument('<edited>', 'edited .bpmn path')
+        .option('-o, --output <file>', 'merged output path')
+        .option('--baseline <file>', 'compiled pristine decompile')
+        .action(async (original, edited, options) => {
+        const argv = [original, edited];
+        addValue(argv, '-o', options.output);
+        addValue(argv, '--baseline', options.baseline);
+        await invoke('bpmn merge', () => loadTool(import.meta.url, '../../bpmn/merge-cli.js'), argv);
+    });
+}

package/dist/cli/commands/case.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from 'commander';
+export declare function registerCaseCommands(program: Command): void;

package/dist/cli/commands/case.js

@@ -0,0 +1,60 @@
+import { addValue, inferCheckMode, invoke, loadTool } from '../common.js';
+export function registerCaseCommands(program) {
+    const family = program.command('case').description('Build and check Case artifacts.');
+    family.command('compile')
+        .description('Compile authored TypeScript to caseplan.json.')
+        .argument('<source>', 'a .case.ts path or bare name')
+        .option('-o, --output <file>', 'output caseplan.json path')
+        .option('--library <dir>', 'connector library directory')
+        .option('--bindings <file>', 'bindings.json path')
+        .option('--connectors-local <dir>', 'connection-resolved connector overlay')
+        .action(async (source, options) => {
+        const argv = [source];
+        addValue(argv, '-o', options.output);
+        addValue(argv, '--library', options.library);
+        addValue(argv, '--bindings', options.bindings);
+        addValue(argv, '--connectors-local', options.connectorsLocal);
+        await invoke('case compile', () => loadTool(import.meta.url, '../../case/compile-cli.js'), argv);
+    });
+    family.command('check')
+        .description('Check authored TypeScript; use the product CLI for caseplan.json.')
+        .argument('<input>', 'source or caseplan.json')
+        .option('--source', 'check authored TypeScript')
+        .option('--compiled', 'identify a compiled artifact')
+        .action(async (input, options) => {
+        let mode;
+        try {
+            mode = inferCheckMode('case', input, options.source === true, options.compiled === true);
+        }
+        catch (error) {
+            console.error(`flow-sdk case check: ${error instanceof Error ? error.message : String(error)}`);
+            process.exitCode = 2;
+            return;
+        }
+        if (mode === 'compiled') {
+            console.error('flow-sdk case check --compiled: use `uip maestro case validate caseplan.json`');
+            process.exitCode = 2;
+            return;
+        }
+        await invoke('case check', () => loadTool(import.meta.url, '../../case/check-cli.js'), [input]);
+    });
+    family.command('decompile')
+        .description('Convert a caseplan.json to authored TypeScript.')
+        .argument('<input>', 'input caseplan.json path')
+        .option('-o, --output <file>', 'output .case.ts path')
+        .option('--import <specifier>', 'SDK import specifier in generated source')
+        .option('--library <dir>', 'connector library directory')
+        .option('--best-effort', 'emit a marked repair scaffold for unsupported constructs')
+        .option('--no-pipeline', 'do not emit a brownfield pipeline helper')
+        .action(async (input, options) => {
+        const argv = [input];
+        addValue(argv, '-o', options.output);
+        addValue(argv, '--import', options.import);
+        addValue(argv, '--library', options.library);
+        if (options.bestEffort === true)
+            argv.push('--best-effort');
+        if (options.pipeline === false)
+            argv.push('--no-pipeline');
+        await invoke('case decompile', () => loadTool(import.meta.url, '../../case/decompile-cli.js'), argv);
+    });
+}

package/dist/cli/commands/flow.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from 'commander';
+export declare function registerFlowCommands(program: Command): void;

package/dist/cli/commands/flow.js

@@ -0,0 +1,99 @@
+import { addValue, emitOnlyEnabled, inferCheckMode, invoke, loadTool } from '../common.js';
+export function registerFlowCommands(program) {
+    const flow = program.command('flow').description('Build and check Flow artifacts.');
+    flow.command('compile')
+        .description('Compile authored TypeScript to a .flow artifact.')
+        .argument('<source>', 'a .flow.ts path or bare name')
+        .option('-o, --output <file>', 'output .flow path')
+        .option('--library <dir>', 'connector library directory')
+        .option('--bindings <file>', 'bindings.json path')
+        .option('--connectors-local <dir>', 'connection-resolved connector overlay')
+        .option('--no-check', 'skip the source-level check')
+        .action(async (source, options) => {
+        const argv = [source];
+        addValue(argv, '-o', options.output);
+        addValue(argv, '--library', options.library);
+        addValue(argv, '--bindings', options.bindings);
+        addValue(argv, '--connectors-local', options.connectorsLocal);
+        if (options.check === false || emitOnlyEnabled())
+            argv.push('--no-check');
+        await invoke('flow compile', () => loadTool(import.meta.url, '../../compile-cli.js'), argv);
+    });
+    flow.command('check')
+        .description('Check authored TypeScript or a compiled .flow artifact.')
+        .argument('<input>', 'source or compiled artifact')
+        .option('--source', 'check authored TypeScript')
+        .option('--compiled', 'check the emitted artifact')
+        .option('--library <dir>', 'connector library directory')
+        .option('--json', 'print compiled-check diagnostics as JSON')
+        .option('--uip', 'resolve missing schemas with the UiPath CLI')
+        .option('--max-errors <count>', 'stop after this many compiled-check errors')
+        .option('--script-determinism', 'check script blocks for non-deterministic calls')
+        .option('--quiet', 'suppress warnings and information')
+        .option('--debug-internal', 'include internal compile context')
+        .option('--dump-ir', 'print the generated intermediate representation')
+        .action(async (input, options) => {
+        if (emitOnlyEnabled()) {
+            console.error('flow-sdk flow check: disabled by emit-only mode; use `uip maestro flow validate` or `uip maestro flow debug`');
+            process.exitCode = 2;
+            return;
+        }
+        let mode;
+        try {
+            mode = inferCheckMode('flow', input, options.source === true, options.compiled === true);
+        }
+        catch (error) {
+            console.error(`flow-sdk flow check: ${error instanceof Error ? error.message : String(error)}`);
+            process.exitCode = 2;
+            return;
+        }
+        if (mode === 'source') {
+            const argv = [input];
+            addValue(argv, '--library', options.library);
+            await invoke('flow check', () => loadTool(import.meta.url, '../../check-cli.js'), argv);
+            return;
+        }
+        // The COMPILED-artifact analyser is gone: it was a standalone tool bundled into this
+        // package by a `prepack` step, and it was retired because the product answers this
+        // question itself now, and better — it answers it about what it will actually run.
+        //
+        // Nothing regressed by removing it. In emit-only mode — which is what every task workspace
+        // and every current authoring flow uses — this path already refused, with the same two
+        // suggestions repeated here. What is checked at author time is `check.ts`, reached above by
+        // the `source` arm, and that is untouched.
+        console.error('flow-sdk flow check: checking a COMPILED .flow is no longer supported here. ' +
+            'Use `uip maestro flow validate <file.flow>` for the product static check, or ' +
+            '`uip maestro flow debug` / `flow-debug <file.flow>` to run it. ' +
+            'Authoring-time checks still work on a .flow.ts source (--source).');
+        process.exitCode = 2;
+    });
+    flow.command('decompile')
+        .description('Convert a .flow artifact to authored TypeScript.')
+        .argument('<input>', 'input .flow path')
+        .option('-o, --output <file>', 'output .flow.ts path')
+        .option('--import <specifier>', 'SDK import specifier in generated source')
+        .option('--strict', 'fail on unsupported constructs')
+        .option('--no-pipeline', 'do not emit a brownfield pipeline helper')
+        .action(async (input, options) => {
+        const argv = [input];
+        addValue(argv, '-o', options.output);
+        addValue(argv, '--import', options.import);
+        if (options.strict)
+            argv.push('--strict');
+        if (options.pipeline === false)
+            argv.push('--no-pipeline');
+        await invoke('flow decompile', () => loadTool(import.meta.url, '../../decompile-cli.js'), argv);
+    });
+    flow.command('merge')
+        .description('Merge an edited flow with its original artifact.')
+        .argument('<original>', 'original .flow path')
+        .argument('<edited>', 'edited .flow path')
+        .option('-o, --output <file>', 'merged output path')
+        .option('--baseline <file>', 'compiled pristine decompile')
+        .action(async (original, edited, options) => {
+        const argv = [original, edited];
+        addValue(argv, '-o', options.output);
+        addValue(argv, '--baseline', options.baseline);
+        await invoke('flow merge', () => loadTool(import.meta.url, '../../merge-cli.js'), argv);
+    });
+}

package/dist/cli/commands/registry.d.ts

@@ -0,0 +1,10 @@
+import type { Command } from 'commander';
+/**
+ * The `registry` family: work with an extracted connector library.
+ *
+ * Registered beside flow/case/bpmn so these verbs are reachable the same way
+ * every other verb is — `flow-sdk registry <verb>` — rather than only through
+ * their own bins. Unlike the other families these take no positional artifact
+ * apart from the search query, so the actions are mostly `addValue` calls.
+ */
+export declare function registerRegistryCommands(program: Command): void;

package/dist/cli/commands/registry.js

@@ -0,0 +1,170 @@
+import { addValue, invoke, loadTool } from '../common.js';
+/** Commander hands a repeatable option one value at a time. */
+function collect(value, previous) {
+    return [...previous, value];
+}
+/**
+ * The `registry` family: work with an extracted connector library.
+ *
+ * Registered beside flow/case/bpmn so these verbs are reachable the same way
+ * every other verb is — `flow-sdk registry <verb>` — rather than only through
+ * their own bins. Unlike the other families these take no positional artifact
+ * apart from the search query, so the actions are mostly `addValue` calls.
+ */
+export function registerRegistryCommands(program) {
+    const family = program
+        .command('registry')
+        .description('Acquire, locate, materialize, search and prepare the connector library.');
+    family.command('pull')
+        .description('Download the published connector library and generate its Markdown and TypeScript views.')
+        .option('--library <dir>', 'where library-json lands (default: ./library)')
+        .option('--library-md <dir>', 'markdown output (default: ./library-md)')
+        .option('--connectors <dir>', 'TypeScript descriptor output (default: ./connectors)')
+        .option('--connector <key>', 'only generate this connector (repeatable; default: whatever the project references)', collect, [])
+        .option('--url <url>', 'archive URL to pull from')
+        .option('--archive <zip>', 'use a zip already on disk instead of downloading')
+        .option('--cache <dir>', 'where downloaded archives are kept')
+        .option('--force', 're-download and regenerate even if the archive is cached')
+        .option('--import <specifier>', 'module specifier for generated descriptors')
+        .option('--triggers <path>', 'registry-triggers.json for trigger descriptors')
+        .option('--python <executable>', 'Python interpreter to run the generators with')
+        .option('--root <prefix>', 'only extract archive entries under this prefix')
+        .option('--extractor <path>', 'extract_library.py to run instead of the packaged copy')
+        .option('--generator <path>', 'materialize_registry.py to run instead of the packaged copy')
+        .action(async (options) => {
+        const argv = [];
+        addValue(argv, '--library', options.library);
+        addValue(argv, '--library-md', options.libraryMd);
+        addValue(argv, '--connectors', options.connectors);
+        for (const key of options.connector ?? [])
+            argv.push('--connector', key);
+        addValue(argv, '--url', options.url);
+        addValue(argv, '--archive', options.archive);
+        addValue(argv, '--cache', options.cache);
+        if (options.force)
+            argv.push('--force');
+        addValue(argv, '--import', options.import);
+        addValue(argv, '--triggers', options.triggers);
+        addValue(argv, '--python', options.python);
+        addValue(argv, '--root', options.root);
+        addValue(argv, '--extractor', options.extractor);
+        addValue(argv, '--generator', options.generator);
+        await invoke('registry pull', () => loadTool(import.meta.url, '../../registry/pull-cli.js'), argv);
+    });
+    family.command('materialize')
+        .description('Generate library-md and connectors/ from an extracted library-json.')
+        .requiredOption('--library-json <dir>', 'extracted library-json directory')
+        .requiredOption('--library-md <dir>', 'markdown output directory')
+        .requiredOption('--connectors <dir>', 'TypeScript descriptor output directory')
+        .option('--import <specifier>', 'module specifier for generated descriptors')
+        .option('--triggers <path>', 'registry-triggers.json for trigger descriptors')
+        .option('--python <executable>', 'Python interpreter to run the generators with')
+        .option('--generator <path>', 'materialize_registry.py to run instead of the packaged copy')
+        .action(async (options) => {
+        const argv = [];
+        addValue(argv, '--library-json', options.libraryJson);
+        addValue(argv, '--library-md', options.libraryMd);
+        addValue(argv, '--connectors', options.connectors);
+        addValue(argv, '--import', options.import);
+        addValue(argv, '--triggers', options.triggers);
+        addValue(argv, '--python', options.python);
+        addValue(argv, '--generator', options.generator);
+        await invoke('registry materialize', () => loadTool(import.meta.url, '../../registry/materialize-cli.js'), argv);
+    });
+    family.command('prepare')
+        .description("Resolve one operation's schema against a live connection into ./connectors-local.")
+        .argument('<connector-key>', 'connector key, e.g. uipath-salesforce')
+        .argument('<action>', 'operation to resolve, e.g. InsertRecord')
+        // Optional: without one the command discovers the connection itself from
+        // `uip is connections list` and writes both keys into bindings.json.
+        .option('--connection-id <id>', 'connection to read the schema through')
+        .option('--connection <name>', 'pick the connection by name when several match')
+        .option('--bindings <file>', 'bindings file to update (default: ./bindings.json)')
+        .option('--bind-connection <name>', 'symbolic connection name (default: the connector suffix)')
+        .option('--bind-folder <name>', 'symbolic folder name (default: shared)')
+        .option('--no-bindings', 'discover the connection but leave bindings.json alone')
+        .option('--object <name>', 'one connection-discovered object')
+        .option('--all-objects', 'every connection-discovered object')
+        .option('-f, --field <name=value>', 'parent field that selects the schema (repeatable)', collect, [])
+        .option('--out <dir>', 'overlay directory (default: ./connectors-local)')
+        // Not `--version`: the program's own version option shadows a subcommand's,
+        // so `prepare --version 2.0` printed the package version instead of parsing.
+        .option('--connector-version <version>', 'connector version to resolve against')
+        .option('--import <specifier>', 'module specifier for generated descriptors')
+        .option('--json-only', 'write the JSON overlay without generating TypeScript')
+        .option('--python <executable>', 'Python interpreter to run the generator with')
+        .option('--generator <path>', 'prepare_connector.py to run instead of the packaged copy')
+        // Commander declares the surface; the inner CLI only ever sees what is
+        // forwarded below. Adding `--resolve` to prepare-cli.ts without adding it
+        // HERE made the flag unreachable through the shipped command, while the
+        // usage string printed by that same command advertised it — a worse failure
+        // than omitting it, because the reader has documentation telling them to
+        // pass an option the parser rejects.
+        .option('--resolve <field:by=value>', 'resolve a lookup field to the id the connector wants (repeatable)', collect, [])
+        .option('--refresh-lookups', 're-resolve lookups already recorded in resolutions.json')
+        .option('--source <flow.ts>', 'the flow whose import to repoint at the prepared descriptor')
+        .option('--no-source-rewrite', 'print the import line instead of editing the source')
+        .action(async (connectorKey, action, options) => {
+        const argv = [connectorKey, action];
+        addValue(argv, '--connection-id', options.connectionId);
+        addValue(argv, '--connection', options.connection);
+        addValue(argv, '--bindings', options.bindings);
+        addValue(argv, '--bind-connection', options.bindConnection);
+        addValue(argv, '--bind-folder', options.bindFolder);
+        // commander sets `bindings` false for `--no-bindings`.
+        if (options.bindings === false)
+            argv.push('--no-bindings');
+        addValue(argv, '--object', options.object);
+        if (options.allObjects)
+            argv.push('--all-objects');
+        for (const field of options.field ?? [])
+            argv.push('-f', field);
+        addValue(argv, '--out', options.out);
+        addValue(argv, '--version', options.connectorVersion);
+        addValue(argv, '--import', options.import);
+        for (const one of options.resolve ?? [])
+            argv.push('--resolve', one);
+        if (options.refreshLookups)
+            argv.push('--refresh-lookups');
+        if (options.jsonOnly)
+            argv.push('--json-only');
+        addValue(argv, '--source', options.source);
+        // commander sets `sourceRewrite` false for `--no-source-rewrite`.
+        if (options.sourceRewrite === false)
+            argv.push('--no-source-rewrite');
+        addValue(argv, '--python', options.python);
+        addValue(argv, '--generator', options.generator);
+        await invoke('registry prepare', () => loadTool(import.meta.url, '../../registry/prepare-cli.js'), argv);
+    });
+    family.command('path')
+        .description('Print where the cached connector library is.')
+        .option('--library-json', 'print only the library-json directory')
+        .option('--library-md', 'print only the library-md directory')
+        .option('--root', 'print only the cache root')
+        .option('--sha', 'print only the checksum current points at')
+        .action(async (options) => {
+        const argv = [];
+        for (const flag of ['library-json', 'library-md', 'root', 'sha']) {
+            // commander camel-cases: --library-json -> libraryJson
+            const key = flag.replace(/-(.)/g, (_, c) => c.toUpperCase());
+            if (options[key])
+                argv.push(`--${flag}`);
+        }
+        await invoke('registry path', () => loadTool(import.meta.url, '../../registry/path-cli.js'), argv);
+    });
+    family.command('search')
+        .description('Find connector operations in an extracted library.')
+        .argument('[query...]', 'words that must all match somewhere on an entry')
+        .option('--library <dir>', 'extracted library-json directory (default: the cached one)')
+        .option('--library-md <dir>', 'markdown tree (defaults to a library-md sibling)')
+        .option('--connector <key>', 'restrict to one connector key')
+        .option('--limit <n>', 'maximum results to print')
+        .action(async (query, options) => {
+        const argv = [...query];
+        addValue(argv, '--library', options.library);
+        addValue(argv, '--library-md', options.libraryMd);
+        addValue(argv, '--connector', options.connector);
+        addValue(argv, '--limit', options.limit);
+        await invoke('registry search', () => loadTool(import.meta.url, '../../registry/search-cli.js'), argv);
+    });
+}

package/dist/cli/common.d.ts

@@ -0,0 +1,30 @@
+export type ToolRun = (argv: string[]) => Promise<number> | number;
+export declare function loadTool(baseUrl: string, relativePath: string): Promise<{
+    run: ToolRun;
+}>;
+export declare function invoke(label: string, load: () => Promise<{
+    run: ToolRun;
+}>, argv: string[]): Promise<void>;
+export declare function addValue(argv: string[], flag: string, value: unknown): void;
+/**
+ * Is emit-only mode on for the PROJECT containing `cwd`?
+ *
+ * Emit-only is a property of the project, not of the directory you happen to be
+ * standing in, so this walks up for the nearest `package.json` that actually
+ * declares `flowSdk.emitOnly` — the way Node tooling resolves project config.
+ *
+ * Anchoring it to `process.cwd()` alone was #392. Compiling the same project from
+ * a subdirectory found no `package.json`, silently re-armed the checker, and —
+ * because check GATES EMISSION — turned a working build into
+ * `compile: 1 error(s); not emitting.` The same anchoring let `flow check` slip
+ * past its own emit-only refusal simply by being run one directory down.
+ *
+ * Nearest DECLARATION wins, not nearest package.json: a nested `package.json`
+ * that says nothing about `flowSdk` must not lift an ancestor's emit-only, since
+ * scaffolders (`uip solution init`) drop exactly such a file into a subdirectory
+ * of an emit-only project. A nested package that explicitly sets
+ * `emitOnly: false` still opts out — silence and denial are different answers.
+ */
+export declare function emitOnlyEnabled(cwd?: string, env?: NodeJS.ProcessEnv): boolean;
+export type CheckMode = 'source' | 'compiled';
+export declare function inferCheckMode(family: 'flow' | 'case' | 'bpmn', input: string, source: boolean, compiled: boolean): CheckMode;

package/dist/cli/common.js

@@ -0,0 +1,92 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+export function loadTool(baseUrl, relativePath) {
+    return import(new URL(relativePath, baseUrl).href);
+}
+export async function invoke(label, load, argv) {
+    try {
+        const code = await (await load()).run(argv);
+        if (code !== 0)
+            process.exitCode = code;
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(`flow-sdk ${label}: ${message}`);
+        process.exitCode = 1;
+    }
+}
+export function addValue(argv, flag, value) {
+    if (typeof value === 'string')
+        argv.push(flag, value);
+}
+/**
+ * `flowSdk.emitOnly` as declared by ONE package.json, or `undefined` when that
+ * file says nothing about it — absent, unreadable, malformed, or non-boolean.
+ * "Says nothing" is deliberately distinct from "says false": only the former
+ * lets the search continue to the parent directory.
+ */
+function declaredEmitOnly(packagePath) {
+    if (!existsSync(packagePath))
+        return undefined;
+    try {
+        const pkg = JSON.parse(readFileSync(packagePath, 'utf8'));
+        const declared = pkg.flowSdk?.emitOnly;
+        return typeof declared === 'boolean' ? declared : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Is emit-only mode on for the PROJECT containing `cwd`?
+ *
+ * Emit-only is a property of the project, not of the directory you happen to be
+ * standing in, so this walks up for the nearest `package.json` that actually
+ * declares `flowSdk.emitOnly` — the way Node tooling resolves project config.
+ *
+ * Anchoring it to `process.cwd()` alone was #392. Compiling the same project from
+ * a subdirectory found no `package.json`, silently re-armed the checker, and —
+ * because check GATES EMISSION — turned a working build into
+ * `compile: 1 error(s); not emitting.` The same anchoring let `flow check` slip
+ * past its own emit-only refusal simply by being run one directory down.
+ *
+ * Nearest DECLARATION wins, not nearest package.json: a nested `package.json`
+ * that says nothing about `flowSdk` must not lift an ancestor's emit-only, since
+ * scaffolders (`uip solution init`) drop exactly such a file into a subdirectory
+ * of an emit-only project. A nested package that explicitly sets
+ * `emitOnly: false` still opts out — silence and denial are different answers.
+ */
+export function emitOnlyEnabled(cwd = process.cwd(), env = process.env) {
+    if (env.FLOW_SDK_EMIT_ONLY === '1')
+        return true;
+    for (let dir = resolve(cwd);;) {
+        const declared = declaredEmitOnly(join(dir, 'package.json'));
+        if (declared !== undefined)
+            return declared;
+        const parent = dirname(dir);
+        if (parent === dir)
+            return false; // filesystem root, nothing declared it
+        dir = parent;
+    }
+}
+export function inferCheckMode(family, input, source, compiled) {
+    if (source && compiled)
+        throw new Error('choose exactly one of --source or --compiled');
+    const lower = input.toLowerCase();
+    const inferred = lower.endsWith('.ts')
+        ? 'source'
+        : family === 'flow' && lower.endsWith('.flow')
+            ? 'compiled'
+            : family === 'case' && lower.endsWith('caseplan.json')
+                ? 'compiled'
+                : family === 'bpmn' && lower.endsWith('.bpmn')
+                    ? 'compiled'
+                    : 'source';
+    if (source && inferred === 'compiled') {
+        throw new Error(`--source does not accept compiled artifact '${input}'`);
+    }
+    if (compiled && inferred === 'source' && lower.endsWith('.ts')) {
+        throw new Error(`--compiled does not accept TypeScript source '${input}'`);
+    }
+    return source ? 'source' : compiled ? 'compiled' : inferred;
+}

package/dist/cli/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli/index.js

@@ -0,0 +1,18 @@
+#!/usr/bin/env node
+import { readFileSync } from 'node:fs';
+import { Command } from 'commander';
+import { registerBpmnCommands } from './commands/bpmn.js';
+import { registerCaseCommands } from './commands/case.js';
+import { registerFlowCommands } from './commands/flow.js';
+import { registerRegistryCommands } from './commands/registry.js';
+const pkg = JSON.parse(readFileSync(new URL('../../package.json', import.meta.url), 'utf8'));
+const program = new Command();
+program
+    .name('flow-sdk')
+    .description('Build and check UiPath Flow, Case, and BPMN artifacts, and manage the connector library.')
+    .version(pkg.version);
+registerFlowCommands(program);
+registerCaseCommands(program);
+registerBpmnCommands(program);
+registerRegistryCommands(program);
+await program.parseAsync(process.argv);

package/dist/cli-run.d.ts

@@ -0,0 +1,2 @@
+export type CliExitCode = 0 | 1 | 2;
+export declare function runWhenInvokedDirectly(moduleUrl: string, label: string, run: (argv: string[]) => Promise<CliExitCode> | CliExitCode): void;

package/dist/cli-run.js

@@ -0,0 +1,42 @@
+import { realpathSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+/**
+ * Resolve a path to its real location, following symlinks. Falls back to the
+ * lexical form when the path cannot be stat'd, so a missing file still compares
+ * (and still fails) rather than throwing out of the guard.
+ */
+function realOrAbsolute(path) {
+    try {
+        return realpathSync(path);
+    }
+    catch {
+        return resolve(path);
+    }
+}
+export function runWhenInvokedDirectly(moduleUrl, label, run) {
+    const entry = process.argv[1];
+    if (!entry)
+        return;
+    // Compare REAL paths, not lexical ones. `npm install` links every `bin` into
+    // `node_modules/.bin/<name>` as a symlink, so invoking the package's own CLI
+    // the documented way — `npx bpmn-decompile`, or the bare name on PATH — sets
+    // `process.argv[1]` to the LINK while `import.meta.url` is the link's TARGET
+    // inside `dist/`. A lexical comparison never matches, and because this guard
+    // returns quietly the process then exits 0 having done nothing at all: no
+    // output, no file written, no error. That silence made 10 of the package's 12
+    // bins inert, and hid it — the ladder scripts and tests all invoke
+    // `node dist/**/*-cli.js` directly, the one form that does match.
+    if (realOrAbsolute(fileURLToPath(moduleUrl)) !== realOrAbsolute(entry))
+        return;
+    Promise.resolve()
+        .then(() => run(process.argv.slice(2)))
+        .then((code) => {
+        process.exitCode = code;
+    })
+        .catch((error) => {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(`${label}: ${message}`);
+        process.exitCode = 1;
+    });
+}

package/dist/compile-cli.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import { type CliExitCode } from './cli-run.js';
+export declare function run(argv: string[]): Promise<CliExitCode>;