@uipath/flow-tool 1.203.0-preview.205 → 1.204.0-preview.206

package/dist/packager-tool-krzxg3ga.js

@@ -0,0 +1,804 @@
+import {
+  resolveMaestroRegistry
+} from "./packager-tool-32czz9mq.js";
+import {
+  Option,
+  OutputFormatter,
+  RESULTS,
+  getOutputSink,
+  pascalCaseDataKeys,
+  processContext
+} from "./packager-tool-r7xy9sew.js";
+import {
+  getFileSystem
+} from "./packager-tool-3h2ktz6q.js";
+
+// ../builder-sdk/src/argv.ts
+function addValue(argv, flag, value) {
+  if (typeof value === "string") {
+    argv.push(flag, value);
+  }
+}
+
+// ../builder-sdk/src/delegate.ts
+import { spawn as spawn2 } from "node:child_process";
+import { createRequire } from "node:module";
+import { StringDecoder } from "node:string_decoder";
+
+// ../builder-sdk/src/npm-global-root.ts
+import { spawn } from "node:child_process";
+var NPM_ROOT_TIMEOUT_MS = 5000;
+var npmRootLookup;
+function npmGlobalRoot() {
+  const prefix = npmConfigPrefix(process.env);
+  if (prefix.trim() !== "") {
+    return Promise.resolve(process.platform === "win32" ? getFileSystem().path.join(prefix, "node_modules") : getFileSystem().path.join(prefix, "lib", "node_modules"));
+  }
+  npmRootLookup ??= runNpmRootGlobal();
+  return npmRootLookup;
+}
+function runNpmRootGlobal() {
+  return new Promise((resolve) => {
+    const stdio = ["ignore", "pipe", "ignore"];
+    const onWindows = { shell: true, stdio, windowsHide: true };
+    const proc = process.platform === "win32" ? spawn("npm root -g", [], onWindows) : spawn("npm", ["root", "-g"], { stdio });
+    let stdout = "";
+    proc.stdout?.on("data", (d) => {
+      stdout += d.toString();
+    });
+    const timer = setTimeout(() => {
+      proc.kill("SIGTERM");
+      resolve(null);
+    }, NPM_ROOT_TIMEOUT_MS);
+    proc.on("error", () => {
+      clearTimeout(timer);
+      resolve(null);
+    });
+    proc.on("close", (code) => {
+      clearTimeout(timer);
+      const root = stdout.trim();
+      resolve(code === 0 && root && !root.includes("***") ? root : null);
+    });
+  });
+}
+function npmConfigPrefix(env) {
+  let prefix = "";
+  for (const [key, value] of Object.entries(env)) {
+    if (key.toLowerCase() === "npm_config_prefix" && value !== undefined) {
+      prefix = value;
+    }
+  }
+  return prefix;
+}
+
+// ../builder-sdk/src/delegate.ts
+var FLOW_SDK_PACKAGE = {
+  name: "@uipath/maestro-builder-sdk",
+  minimumVersion: "6.11.1"
+};
+var BPMN_CONNECTOR_OPTIONS_VERSION = "6.15.0";
+function commandLabel(family, verb) {
+  return `uip maestro ${family} ${verb}`;
+}
+function parseVersion(version) {
+  const match = /^(\d+)\.(\d+)\.(\d+)(-[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/.exec(version);
+  if (!match)
+    return null;
+  return [
+    Number(match[1]),
+    Number(match[2]),
+    Number(match[3]),
+    match[4] !== undefined
+  ];
+}
+function versionMeetsFloor(version, floor) {
+  const installed = parseVersion(version);
+  const minimum = parseVersion(floor);
+  if (!installed || !minimum)
+    return false;
+  for (let index = 0;index < 3; index++) {
+    if (installed[index] !== minimum[index]) {
+      return installed[index] > minimum[index];
+    }
+  }
+  return !installed[3] || minimum[3];
+}
+var FLOW_SDK_INVOKED_AS = "uip maestro";
+function resultCode(family, verb) {
+  return [family, verb].map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join("");
+}
+function stdoutAsData(stdout) {
+  const text = stdout.trimEnd();
+  const trimmed = text.trimStart();
+  if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
+    try {
+      const parsed = JSON.parse(trimmed);
+      if (parsed !== null && typeof parsed === "object") {
+        if (!Array.isArray(parsed) && "ok" in parsed) {
+          const { ok: _ok, ...fields } = parsed;
+          return fields;
+        }
+        return parsed;
+      }
+    } catch {}
+  }
+  return { Output: text };
+}
+function failureReason(out, err) {
+  try {
+    const parsed = JSON.parse(out.trim());
+    if (parsed !== null && typeof parsed === "object" && typeof parsed.error === "string") {
+      return parsed.error;
+    }
+  } catch {}
+  const lines = err.split(`
+`).filter((line) => line.trim() !== "");
+  return lines.at(-1)?.trim() ?? out.trim();
+}
+function spawnSdk(cliPath, args, cwd) {
+  return new Promise((settle) => {
+    let settled = false;
+    const resolve = (outcome) => {
+      if (settled)
+        return;
+      settled = true;
+      settle(outcome);
+    };
+    const child = spawn2("node", [cliPath, ...args], {
+      cwd,
+      env: {
+        ...process.env,
+        FLOW_SDK_INVOKED_AS
+      },
+      stdio: ["inherit", "pipe", "pipe"]
+    });
+    const stdout = [];
+    const stderr = [];
+    const decoderErr = new StringDecoder("utf8");
+    const writeLive = (text) => {
+      if (text)
+        getOutputSink().writeErr(text);
+    };
+    child.stdout?.on("data", (chunk) => {
+      stdout.push(chunk);
+    });
+    child.stderr?.on("data", (chunk) => {
+      stderr.push(chunk);
+      writeLive(decoderErr.write(chunk));
+    });
+    child.once("error", (error) => {
+      resolve({ kind: "spawn-error", message: error.message });
+    });
+    child.once("close", (exitCode, signal) => {
+      if (settled)
+        return;
+      writeLive(decoderErr.end());
+      resolve({
+        kind: "closed",
+        exitCode,
+        signal,
+        out: Buffer.concat(stdout).toString("utf-8"),
+        err: Buffer.concat(stderr).toString("utf-8").trim()
+      });
+    });
+  });
+}
+async function runChild(cliPath, args, cwd, label) {
+  const outcome = await spawnSdk(cliPath, args, cwd);
+  if (outcome.kind === "spawn-error") {
+    return {
+      ok: false,
+      exitCode: 1,
+      result: RESULTS.Failure,
+      message: `${label}: ${outcome.message}`,
+      instructions: "Check that node is on PATH, then retry."
+    };
+  }
+  const { exitCode, signal, out, err } = outcome;
+  if (exitCode === 0) {
+    return { ok: true, data: stdoutAsData(out) };
+  }
+  if (exitCode !== null) {
+    const detail = failureReason(out, err) || `SDK exited with code ${exitCode}`;
+    return {
+      ok: false,
+      exitCode,
+      result: RESULTS.Failure,
+      message: `${label}: ${detail}`,
+      instructions: err ? "Fix what the builder SDK reported (on stderr, and in Message), then retry." : "Fix what the builder SDK reported (see Message), then retry.",
+      ...out.trim() ? { data: stdoutAsData(out) } : {}
+    };
+  }
+  return {
+    ok: false,
+    exitCode: 1,
+    result: RESULTS.Failure,
+    message: `${label}: SDK process ended with signal ${signal ?? "unknown"}.`,
+    instructions: "Retry the command."
+  };
+}
+function upgradeInstructions(found) {
+  return found === "workspace" ? `npm install --save-dev ${FLOW_SDK_PACKAGE.name}@latest` : `npm install -g ${FLOW_SDK_PACKAGE.name}@latest`;
+}
+function resolveLocalPackageJson(workspace) {
+  const require2 = createRequire(import.meta.url);
+  try {
+    return require2.resolve(`${FLOW_SDK_PACKAGE.name}/package.json`, {
+      paths: [workspace]
+    });
+  } catch {
+    return null;
+  }
+}
+async function resolveGlobalPackageJson() {
+  const root = await npmGlobalRoot();
+  if (!root)
+    return null;
+  const fs = getFileSystem();
+  const candidate = fs.path.join(root, ...FLOW_SDK_PACKAGE.name.split("/"), "package.json");
+  return await fs.exists(candidate) ? candidate : null;
+}
+async function resolveFlowSdk(workspace, label) {
+  const fs = getFileSystem();
+  const { name, minimumVersion } = FLOW_SDK_PACKAGE;
+  const localPath = resolveLocalPackageJson(workspace);
+  const packagePath = localPath ?? await resolveGlobalPackageJson();
+  const found = localPath ? "workspace" : packagePath ? "global" : "none";
+  if (!packagePath) {
+    return {
+      ok: false,
+      message: `${label}: ${name} is not installed in this workspace or globally.`,
+      instructions: upgradeInstructions(found)
+    };
+  }
+  const packageText = await fs.readFile(packagePath, "utf-8");
+  if (packageText === null) {
+    return {
+      ok: false,
+      message: `${label}: could not read ${packagePath}.`,
+      instructions: `Reinstall ${name}, then retry.`
+    };
+  }
+  let version = "";
+  try {
+    const parsed = JSON.parse(packageText);
+    version = typeof parsed.version === "string" ? parsed.version : "";
+  } catch {
+    version = "";
+  }
+  if (!versionMeetsFloor(version, minimumVersion)) {
+    return {
+      ok: false,
+      message: `${label}: found ${name} ${version || "with no valid version"}; need >= ${minimumVersion}.`,
+      instructions: upgradeInstructions(found)
+    };
+  }
+  return {
+    ok: true,
+    packageDir: fs.path.dirname(packagePath),
+    version,
+    found: found === "workspace" ? "workspace" : "global"
+  };
+}
+async function runFlowSdk({
+  family,
+  commandVerb,
+  sdkVerb = commandVerb,
+  argv,
+  cwd,
+  requiresSdkVersion
+}) {
+  const fs = getFileSystem();
+  const workspace = cwd ?? fs.env.cwd();
+  const label = commandLabel(family, commandVerb);
+  const resolution = await resolveFlowSdk(workspace, label);
+  if (!resolution.ok) {
+    return {
+      ok: false,
+      exitCode: 1,
+      result: RESULTS.ConfigError,
+      message: resolution.message,
+      instructions: resolution.instructions
+    };
+  }
+  if (requiresSdkVersion && !versionMeetsFloor(resolution.version, requiresSdkVersion.version)) {
+    return {
+      ok: false,
+      exitCode: 1,
+      result: RESULTS.ConfigError,
+      message: `${label}: ${requiresSdkVersion.because} needs ${FLOW_SDK_PACKAGE.name} >= ${requiresSdkVersion.version}; found ${resolution.version}.`,
+      instructions: upgradeInstructions(resolution.found)
+    };
+  }
+  const cliPath = fs.path.join(resolution.packageDir, "dist", "cli", "index.js");
+  const sdkArgv = argv.includes("--json") ? [...argv] : [...argv, "--json"];
+  return await runChild(cliPath, [family, sdkVerb, ...sdkArgv], workspace, label);
+}
+async function delegateToFlowSdk(request) {
+  const result = await runFlowSdk(request);
+  if (result.ok) {
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: resultCode(request.family, request.commandVerb),
+      Data: result.data
+    });
+    return 0;
+  }
+  OutputFormatter.error({
+    Result: result.result,
+    Message: result.message,
+    Instructions: result.instructions,
+    ...result.data ? { Data: pascalCaseDataKeys(result.data) } : {}
+  });
+  return result.exitCode;
+}
+
+// ../builder-sdk/src/examples.ts
+function sdkCliExample(family, verb, description, command, data) {
+  return [
+    {
+      Description: description,
+      Command: command,
+      Output: {
+        Code: resultCode(family, verb),
+        Data: data
+      }
+    }
+  ];
+}
+
+// ../builder-sdk/src/library-option.ts
+async function resolveLibraryOption(explicit) {
+  if (explicit !== undefined)
+    return explicit;
+  if (getFileSystem().env.getenv("FLOW_SDK_LIBRARY_JSON"))
+    return;
+  const registry = await resolveMaestroRegistry();
+  return registry?.libraryJson;
+}
+async function connectorLibraryInPlay(explicit) {
+  if (explicit !== undefined)
+    return true;
+  if (getFileSystem().env.getenv("FLOW_SDK_LIBRARY_JSON"))
+    return true;
+  return (await resolveMaestroRegistry())?.libraryJson !== undefined;
+}
+
+// ../builder-sdk/src/commands/check.ts
+var CHECK_EXAMPLES = {
+  flow: { input: "Order.flow.ts" },
+  case: { input: "Claims.case.ts" },
+  bpmn: { input: "Approval.bpmn.ts" }
+};
+var CHECK_RESULT = { Errors: 0, Warnings: 0, Diagnostics: [] };
+var registerCheckCommand = (program, family) => {
+  const command = program.command("check <input>").description("Check a source file for authoring errors before compiling it.").option("--source", "Check authored TypeScript");
+  if (family === "flow" || family === "bpmn") {
+    command.option("--library <dir>", "Connector library directory (defaults to $FLOW_SDK_LIBRARY_JSON, else the pulled library)").option("--connectors-local <dir>", "Connection-resolved connector overlay (default: ./connectors-local)");
+  }
+  if (family === "bpmn") {
+    command.option("--graph", "Also print the resolved wiring: every element with the flows leaving it, implied edges marked ~>");
+  }
+  const example = CHECK_EXAMPLES[family];
+  command.examples(sdkCliExample(family, "check", `Check a ${family} source file before compiling it`, `uip maestro ${family} check ${example.input} --source`, CHECK_RESULT)).trackedAction(processContext, async (input, options) => {
+    const argv = [input];
+    if (options.source)
+      argv.push("--source");
+    const connectorOptions = family === "flow" || family === "bpmn";
+    const library = connectorOptions ? await resolveLibraryOption(options.library) : undefined;
+    addValue(argv, "--library", library);
+    addValue(argv, "--connectors-local", connectorOptions ? options.connectorsLocal : undefined);
+    if (options.graph)
+      argv.push("--graph");
+    const gateBpmnConnectors = family === "bpmn" && (options.connectorsLocal !== undefined || await connectorLibraryInPlay(options.library));
+    const code = await delegateToFlowSdk({
+      family,
+      commandVerb: "check",
+      argv,
+      ...gateBpmnConnectors ? {
+        requiresSdkVersion: {
+          version: BPMN_CONNECTOR_OPTIONS_VERSION,
+          because: "the connector library on bpmn check"
+        }
+      } : {}
+    });
+    if (code !== 0)
+      processContext.exit(code);
+  });
+};
+// ../builder-sdk/src/commands/compile.ts
+var COMPILE_EXAMPLES = {
+  flow: {
+    source: "Order.flow.ts",
+    output: "Order.flow",
+    result: {
+      Path: "/work/Order.flow",
+      Nodes: 3,
+      Edges: 2,
+      Sidecars: [],
+      Errors: 0,
+      Warnings: 0,
+      Diagnostics: []
+    }
+  },
+  case: {
+    source: "Claims.case.ts",
+    output: "caseplan.json",
+    result: { Path: "/work/caseplan.json", Stages: 3 }
+  },
+  bpmn: {
+    source: "Approval.bpmn.ts",
+    output: "Approval.bpmn",
+    result: { Path: "/work/Approval.bpmn", Elements: 4 }
+  }
+};
+var registerCompileCommand = (program, family) => {
+  const command = program.command("compile <source>").description(`Compile authored TypeScript to a ${family} artifact.`).option("-o, --output <file>", "Output artifact path").option("--library <dir>", "Connector library directory (defaults to the pulled registry)").option("--bindings <file>", "bindings.json path").option("--connectors-local <dir>", "Connection-resolved connector overlay (default: ./connectors-local)");
+  if (family === "flow") {
+    command.option("--no-check", "Skip the source-level check");
+  }
+  const example = COMPILE_EXAMPLES[family];
+  command.examples(sdkCliExample(family, "compile", `Compile a ${family} source file to an artifact`, `uip maestro ${family} compile ${example.source} --output ${example.output}`, example.result)).trackedAction(processContext, async (source, options) => {
+    const argv = [source];
+    addValue(argv, "-o", options.output);
+    addValue(argv, "--library", await resolveLibraryOption(options.library));
+    addValue(argv, "--bindings", options.bindings);
+    addValue(argv, "--connectors-local", options.connectorsLocal);
+    if (options.check === false)
+      argv.push("--no-check");
+    const code = await delegateToFlowSdk({
+      family,
+      commandVerb: "compile",
+      argv,
+      ...family === "bpmn" && options.connectorsLocal !== undefined ? {
+        requiresSdkVersion: {
+          version: BPMN_CONNECTOR_OPTIONS_VERSION,
+          because: "--connectors-local on bpmn compile"
+        }
+      } : {}
+    });
+    if (code !== 0)
+      processContext.exit(code);
+  });
+};
+// ../builder-sdk/src/commands/decompile.ts
+var DECOMPILE_EXAMPLES = {
+  flow: {
+    input: "Order.flow",
+    output: "Order.flow.ts",
+    result: {
+      Path: "/work/Order.flow.ts",
+      Pipeline: "/work/Order.pipeline.mjs"
+    }
+  },
+  case: {
+    input: "caseplan.json",
+    output: "Claims.case.ts",
+    result: {
+      Path: "/work/Claims.case.ts",
+      Pipeline: "/work/Claims.pipeline.mjs",
+      Diagnostics: []
+    }
+  },
+  bpmn: {
+    input: "Approval/Approval.bpmn",
+    output: "Approval.bpmn.ts",
+    result: { Path: "/work/Approval.bpmn.ts" },
+    extra: " --style nested"
+  }
+};
+var ARTIFACT = {
+  flow: { artifact: ".flow", source: ".flow.ts" },
+  case: { artifact: "caseplan.json", source: ".case.ts" },
+  bpmn: { artifact: ".bpmn", source: ".bpmn.ts" }
+};
+var registerDecompileCommand = (program, family) => {
+  const command = program.command("decompile <input>").description(`Convert a ${ARTIFACT[family].artifact} artifact to authored TypeScript.`).option("-o, --output <file>", `Output ${ARTIFACT[family].source} path`).option("--import <specifier>", "SDK import specifier in generated source");
+  if (family === "flow") {
+    command.option("--strict", "Fail on unsupported constructs");
+  } else if (family === "case") {
+    command.option("--library <dir>", "Connector library directory (defaults to the pulled registry)").option("--best-effort", "Emit a marked repair scaffold for unsupported constructs");
+  } else {
+    command.addOption(new Option("--style <style>", "explicit (default) or nested: lift boundary events, gateways and event sub-processes into the nesting constructs where the graph is provably the same").choices(["explicit", "nested"]));
+  }
+  if (family !== "bpmn") {
+    command.option("--no-pipeline", "Do not emit a brownfield pipeline helper");
+  }
+  const example = DECOMPILE_EXAMPLES[family];
+  command.examples(sdkCliExample(family, "decompile", `Convert a ${family} artifact back to authored TypeScript`, `uip maestro ${family} decompile ${example.input} --output ${example.output}${example.extra ?? ""}`, example.result)).trackedAction(processContext, async (input, options) => {
+    const argv = [input];
+    addValue(argv, "-o", options.output);
+    addValue(argv, "--import", options.import);
+    if (family === "case") {
+      addValue(argv, "--library", await resolveLibraryOption(options.library));
+    }
+    if (options.strict)
+      argv.push("--strict");
+    if (options.bestEffort)
+      argv.push("--best-effort");
+    if (options.pipeline === false)
+      argv.push("--no-pipeline");
+    addValue(argv, "--style", options.style);
+    const code = await delegateToFlowSdk({
+      family,
+      commandVerb: "decompile",
+      argv
+    });
+    if (code !== 0)
+      processContext.exit(code);
+  });
+};
+// ../builder-sdk/src/named-second.ts
+function namedOrLegacy(spec) {
+  if (spec.named !== undefined && spec.legacy !== undefined) {
+    usageError(`pass ${spec.flag} or a second argument, not both`, spec.usage);
+  }
+  if (spec.named === "") {
+    usageError(`option '${spec.flag}' argument missing`, spec.usage);
+  }
+  if (spec.named !== undefined)
+    return spec.named;
+  if (spec.legacy === undefined) {
+    usageError(`required option '${spec.flag}' not specified`, spec.usage);
+  }
+  getOutputSink().writeErr(`[WARN] The two-argument form is deprecated. Use \`${spec.usage}\` instead.
+`);
+  return spec.legacy;
+}
+function usageError(message, usage) {
+  throw Object.assign(new Error(message), {
+    result: RESULTS.ValidationError,
+    errorCode: "invalid_argument",
+    retry: "RetryWillNotFix",
+    instructions: `Usage: ${usage}`
+  });
+}
+
+// ../builder-sdk/src/commands/merge.ts
+var MERGE_EXAMPLES = {
+  flow: {
+    description: "Merge edited authored content into the original Flow artifact",
+    command: "uip maestro flow merge Edited.flow --original Original.flow --output Merged.flow --baseline Baseline.flow",
+    result: { Path: "/work/Merged.flow", Nodes: 3, Edges: 2 }
+  },
+  case: {
+    description: "Merge edited authored content into the original Case artifact",
+    command: "uip maestro case merge edited.caseplan.json --original original.caseplan.json --output merged.caseplan.json",
+    result: { Path: "/work/merged.caseplan.json", Stages: 3 }
+  },
+  bpmn: {
+    description: "Merge an edited process into the original BPMN artifact, keeping untouched elements byte for byte",
+    command: "uip maestro bpmn merge Edited.bpmn --original Original.bpmn --output Merged.bpmn --baseline Baseline.bpmn",
+    result: {
+      Path: "/work/Merged.bpmn",
+      Preserved: 5,
+      Authored: 1,
+      Removed: 0
+    }
+  }
+};
+var registerMergeCommand = (program, family) => {
+  const command = program.command("merge <edited>").description(`Merge an edited ${family} with its original artifact.`).option("--original <file>", "Original artifact to merge into (required)").option("-o, --output <file>", "Merged output path").allowExcessArguments(true);
+  if (family !== "case") {
+    command.option("--baseline <file>", "Compiled pristine decompile");
+  }
+  const example = MERGE_EXAMPLES[family];
+  command.examples(sdkCliExample(family, "merge", example.description, example.command, example.result)).trackedAction(processContext, async (first, options, cmd) => {
+    const usage = `uip maestro ${family} merge <edited> --original <file>`;
+    if (cmd.args.length > 2) {
+      usageError(`unexpected argument '${cmd.args[2]}'`, usage);
+    }
+    const legacyEdited = cmd.args[1];
+    const original = namedOrLegacy({
+      named: options.original,
+      legacy: legacyEdited === undefined ? undefined : first,
+      flag: "--original",
+      usage
+    });
+    const edited = legacyEdited ?? first;
+    const tail = [];
+    addValue(tail, "-o", options.output);
+    addValue(tail, "--baseline", options.baseline);
+    const code = await delegateToFlowSdk({
+      family,
+      commandVerb: "merge",
+      argv: [edited, "--original", original, ...tail]
+    });
+    if (code !== 0)
+      processContext.exit(code);
+  });
+};
+// ../builder-sdk/src/commands/registry.ts
+function collect(value, previous) {
+  return [...previous, value];
+}
+async function delegate(commandVerb, argv) {
+  const code = await delegateToFlowSdk({
+    family: "registry",
+    commandVerb,
+    argv
+  });
+  if (code !== 0)
+    processContext.exit(code);
+}
+var registerPull = (registry) => {
+  registry.command("pull").description("Download the connector library into the shared cache and generate the descriptors this project imports.").option("--connectors <dir>", "TypeScript descriptor output (default: ./connectors)").option("--connector <key>", "only generate this connector (repeatable; default: whatever the project references)", collect, []).option("--library <dir>", "extract here instead of the shared cache").option("--library-md <dir>", "generate Markdown here instead").option("--url <url>", "archive URL to pull from").option("--archive <zip>", "use a zip already on disk").option("--force", "re-download and regenerate").option("--import <specifier>", "module specifier for descriptors").option("--triggers <path>", "registry-triggers.json for triggers").option("--python <executable>", "Python interpreter for the generators").option("--cache <dir>", "where downloaded archives are kept").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").examples(sdkCliExample("registry", "pull", "Pull the library and generate the Slack descriptor", "uip maestro registry pull --connector uipath-salesforce-slack", {
+    Sha256: "f2ae49be22ec…",
+    Library: "~/.uipath/cache/flow-sdk/library/f2ae49be22ec…/library-json",
+    LibraryMarkdown: "~/.uipath/cache/flow-sdk/library/f2ae49be22ec…/library-md",
+    MadeCurrent: true,
+    Connectors: "/work/connectors",
+    Generated: ["uipath-salesforce-slack"]
+  })).trackedAction(processContext, async (options) => {
+    const argv = [];
+    addValue(argv, "--connectors", options.connectors);
+    for (const key of options.connector ?? []) {
+      argv.push("--connector", key);
+    }
+    addValue(argv, "--library", options.library);
+    addValue(argv, "--library-md", options.libraryMd);
+    addValue(argv, "--url", options.url);
+    addValue(argv, "--archive", options.archive);
+    if (options.force)
+      argv.push("--force");
+    addValue(argv, "--import", options.import);
+    addValue(argv, "--triggers", options.triggers);
+    addValue(argv, "--python", options.python);
+    addValue(argv, "--cache", options.cache);
+    addValue(argv, "--root", options.root);
+    addValue(argv, "--extractor", options.extractor);
+    addValue(argv, "--generator", options.generator);
+    await delegate("pull", argv);
+  });
+};
+var registerSearch = (registry) => {
+  registry.command("search [query...]").description("Find connector operations in the cached library.").passThroughOptions().allowExcessArguments(true).option("--library <dir>", "library-json directory (default: the cache)").option("--library-md <dir>", "markdown tree").option("--connector <key>", "restrict to one connector key").option("--limit <n>", "maximum results").examples(sdkCliExample("registry", "search", "Find the Slack channel-message operation", "uip maestro registry search slack send message --limit 5", { Total: 2, Operations: ["…"] })).trackedAction(processContext, async (_query, options, cmd) => {
+    const argv = [...cmd.args];
+    addValue(argv, "--library", options.library);
+    addValue(argv, "--library-md", options.libraryMd);
+    addValue(argv, "--connector", options.connector);
+    addValue(argv, "--limit", options.limit);
+    await delegate("search", argv);
+  });
+};
+var registerPath = (registry) => {
+  registry.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 markdown directory").option("--root", "print only the cache root").option("--sha", "print only the checksum current points at").examples(sdkCliExample("registry", "path", "Print the Markdown library directory, bare, for $(…) capture", "uip maestro registry path --library-md --output plain", {
+    LibraryMarkdown: "~/.uipath/cache/flow-sdk/library/current/library-md"
+  })).trackedAction(processContext, async (options) => {
+    const argv = [];
+    if (options.libraryJson)
+      argv.push("--library-json");
+    if (options.libraryMd)
+      argv.push("--library-md");
+    if (options.root)
+      argv.push("--root");
+    if (options.sha)
+      argv.push("--sha");
+    await delegate("path", argv);
+  });
+};
+function strayPositional(cmd, tail) {
+  for (let index = 0;index < tail.length; index++) {
+    const token = tail[index];
+    if (!token.startsWith("-"))
+      return token;
+    if (token.includes("="))
+      continue;
+    const option = cmd.options.find((candidate) => candidate.long === token || candidate.short === token);
+    if (option === undefined)
+      return;
+    if (option.required || option.optional)
+      index++;
+  }
+  return;
+}
+var PREPARE_USAGE = "uip maestro registry prepare <connector-key> --action <name>";
+var registerPrepare = (registry) => {
+  registry.command("prepare <connector-key>").description("Resolve one operation's schema against a live connection into ./connectors-local, and record the connection in bindings.json.").passThroughOptions().allowExcessArguments(true).option("--action <name>", "operation to resolve, e.g. insert-record (required)", (value, previous) => [
+    ...previous ?? [],
+    value
+  ]).option("--connection-id <id>", "connection to read the schema through (default: discovered)").option("--connection <name>", "pick the connection by name when several match").option("--connection-folder <folder>", "pick the connection in the folder the flow runs in (name or key) 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)").option("--connector-version <version>", "connector version to resolve against").option("--import <specifier>", "module specifier for descriptors").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("--json-only", "write the JSON overlay without TypeScript").option("--python <executable>", "Python interpreter for the generator").option("--generator <path>", "prepare_connector.py to run instead of the packaged copy").examples([
+    ...sdkCliExample("registry", "prepare", "Resolve a Salesforce custom object the shipped library cannot know", "uip maestro registry prepare uipath-salesforce-sfdc --action insert-record --object Company__c", {
+      Connector: "uipath-salesforce-sfdc",
+      Action: "insert-record",
+      Overlay: "/work/connectors-local"
+    }),
+    ...sdkCliExample("registry", "prepare", "Resolve Slack lookup fields to ids and pick one of several connections", "uip maestro registry prepare uipath-salesforce-slack --action send-message-to-channel --connection is-sandboxes --resolve channel:name=general --resolve send_as:name=user", {
+      Connector: "uipath-salesforce-slack",
+      Action: "send-message-to-channel",
+      Overlay: "/work/connectors-local"
+    })
+  ]).trackedAction(processContext, async (connectorKey, options, cmd) => {
+    const tail = cmd.args.slice(1);
+    const before = options.action ?? [];
+    if (before.length > 1) {
+      usageError("pass --action once", PREPARE_USAGE);
+    }
+    let named = before[0];
+    const at = tail.findIndex((token) => token === "--action" || token.startsWith("--action="));
+    if (at >= 0) {
+      const token = tail[at];
+      const inline = token.startsWith("--action=");
+      const value = inline ? token.slice("--action=".length) : tail[at + 1];
+      if (!value || value.startsWith("-")) {
+        usageError("option '--action <name>' argument missing", PREPARE_USAGE);
+      }
+      if (named !== undefined) {
+        usageError("pass --action once", PREPARE_USAGE);
+      }
+      named = value;
+      tail.splice(at, inline ? 1 : 2);
+      if (tail.some((token2) => token2 === "--action" || token2.startsWith("--action="))) {
+        usageError("pass --action once", PREPARE_USAGE);
+      }
+    }
+    const legacy = tail[0] !== undefined && !tail[0].startsWith("-") ? tail.shift() : undefined;
+    const extra = strayPositional(cmd, tail);
+    if (extra !== undefined) {
+      usageError(`unexpected argument '${extra}'`, PREPARE_USAGE);
+    }
+    const action = namedOrLegacy({
+      named,
+      legacy,
+      flag: "--action",
+      usage: PREPARE_USAGE
+    });
+    const argv = tail;
+    addValue(argv, "--connection-id", options.connectionId);
+    addValue(argv, "--connection", options.connection);
+    addValue(argv, "--connection-folder", options.connectionFolder);
+    addValue(argv, "--bindings", options.bindings);
+    addValue(argv, "--bind-connection", options.bindConnection);
+    addValue(argv, "--bind-folder", options.bindFolder);
+    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, "--connector-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, "--python", options.python);
+    addValue(argv, "--generator", options.generator);
+    await delegate("prepare", [
+      connectorKey,
+      "--action",
+      action,
+      ...argv
+    ]);
+  });
+};
+var registerRegistryCommands = (program) => {
+  const registry = program.command("registry").description("Acquire, locate, search and prepare the connector library shared by Flow, Case, and BPMN.").enablePositionalOptions();
+  registerPull(registry);
+  registerSearch(registry);
+  registerPath(registry);
+  registerPrepare(registry);
+};
+// ../builder-sdk/src/commands/tidy.ts
+var registerTidyCommand = (program) => {
+  program.command("tidy <input>").description("Add diagram layout to a compiled .bpmn artifact.").option("-o, --output <file>", "Output .bpmn path").examples(sdkCliExample("bpmn", "tidy", "Add diagram layout and write the result to a separate BPMN artifact", "uip maestro bpmn tidy Approval.bpmn --output Approval.tidied.bpmn", { Path: "/work/Approval.tidied.bpmn", Shapes: 4 })).trackedAction(processContext, async (input, options) => {
+    const argv = [input];
+    addValue(argv, "-o", options.output);
+    const code = await delegateToFlowSdk({
+      family: "bpmn",
+      commandVerb: "tidy",
+      argv
+    });
+    if (code !== 0)
+      processContext.exit(code);
+  });
+};
+export { resolveFlowSdk, runFlowSdk, registerCheckCommand, registerCompileCommand, registerDecompileCommand, registerMergeCommand, registerRegistryCommands, registerTidyCommand };
+
+//# debugId=1EE1D7D6FDBF346264756E2164756E21