@uipath/maestro-tool 1.200.0-preview.109 → 1.201.0-preview.115

package/README.md

@@ -2,6 +2,22 @@
 
 CLI tool for UiPath Maestro orchestration projects. The tool is exposed under `uip maestro` and groups BPMN, Flow, and Case commands.
 
+## Shared Registry
+
+Install or refresh the connector authoring library shared by Flow, Case, and
+BPMN. The command verifies the published checksum, generates Markdown and
+TypeScript views with the installed Flow SDK materializer, and activates the
+result as an immutable local snapshot.
+
+```bash
+uip maestro registry pull
+uip maestro registry pull --force
+```
+
+The cache is stored under `~/.uipath/maestro/registry`. Connection-specific
+connector schemas are prepared separately and are not downloaded by this
+command.
+
 ## BPMN Commands
 
 ### `maestro bpmn init`

package/dist/authoring-0dk6xpfc.js

@@ -0,0 +1,22 @@
+import {
+  registerCheckCommand,
+  registerCompileCommand,
+  registerDecompileCommand,
+  registerMergeCommand
+} from "./packager-tool-jxb33prs.js";
+import"./packager-tool-066fzdae.js";
+import"./packager-tool-1cb0d5e0.js";
+import"./packager-tool-wckvcay0.js";
+
+// ../flow-tool/src/commands/authoring.ts
+var registerFlowAuthoringCommands = (program) => {
+  registerCompileCommand(program, "flow");
+  registerCheckCommand(program, "flow");
+  registerDecompileCommand(program, "flow");
+  registerMergeCommand(program);
+};
+export {
+  registerFlowAuthoringCommands
+};
+
+//# debugId=312B5FA52AB0810D64756E2164756E21

package/dist/authoring-de0qdv9t.js

@@ -0,0 +1,20 @@
+import {
+  registerCheckCommand,
+  registerCompileCommand,
+  registerDecompileCommand
+} from "./packager-tool-jxb33prs.js";
+import"./packager-tool-066fzdae.js";
+import"./packager-tool-1cb0d5e0.js";
+import"./packager-tool-wckvcay0.js";
+
+// ../case-tool/src/commands/authoring.ts
+var registerCaseAuthoringCommands = (program) => {
+  registerCompileCommand(program, "case");
+  registerCheckCommand(program, "case");
+  registerDecompileCommand(program, "case");
+};
+export {
+  registerCaseAuthoringCommands
+};
+
+//# debugId=E3E3EE7B4978FB6064756E2164756E21

package/dist/authoring-gqzd8ngc.js

@@ -0,0 +1,20 @@
+import {
+  registerCheckCommand,
+  registerCompileCommand,
+  registerTidyCommand
+} from "./packager-tool-jxb33prs.js";
+import"./packager-tool-066fzdae.js";
+import"./packager-tool-1cb0d5e0.js";
+import"./packager-tool-wckvcay0.js";
+
+// src/commands/authoring.ts
+var registerBpmnAuthoringCommands = (program) => {
+  registerCompileCommand(program, "bpmn");
+  registerCheckCommand(program, "bpmn");
+  registerTidyCommand(program);
+};
+export {
+  registerBpmnAuthoringCommands
+};
+
+//# debugId=2D1464E0B968BA6664756E2164756E21

package/dist/bpmn-refresh-service-vksd8z0m.js

@@ -0,0 +1,451 @@
+import {
+  SimpleBpmnModdle
+} from "./packager-tool-x8d8fpse.js";
+import {
+  isIntsvcActivityExecutionV1
+} from "./packager-tool-bnqptw8n.js";
+import {
+  BPMN_PACKAGE_FILES,
+  BpmnValidateService,
+  buildBpmnPackageMetadata,
+  entryPointDisplayName,
+  formatBpmnPackageFile,
+  isJsonObject
+} from "./packager-tool-fj5bja81.js";
+import"./packager-tool-dmnhzh9p.js";
+import"./packager-tool-9qecd4wb.js";
+import"./packager-tool-qa9gftnj.js";
+import"./packager-tool-5arsyj36.js";
+import {
+  extractErrorMessageSync,
+  isGuid
+} from "./packager-tool-066fzdae.js";
+import {
+  getFileSystem
+} from "./packager-tool-1cb0d5e0.js";
+import"./packager-tool-1yepbxq4.js";
+import"./packager-tool-kvgt1s4z.js";
+import"./packager-tool-sc961w0q.js";
+import"./packager-tool-gbgfwx8f.js";
+import"./packager-tool-5fpetbc1.js";
+import"./packager-tool-973f0r2g.js";
+import"./packager-tool-c23zrhj8.js";
+import"./packager-tool-wckvcay0.js";
+
+// src/services/bpmn-node-utils.ts
+function extensionValues(element) {
+  return element.extensionElements?.values ?? [];
+}
+function childNodes(node) {
+  return node?.$children ?? [];
+}
+function required(value, label) {
+  if (!value?.trim()) {
+    throw new Error(`${label} is required.`);
+  }
+  return value.trim();
+}
+
+// src/services/bpmn-connection-resources.ts
+function buildConnectionResources(processes, existingResources) {
+  const generated = new Map;
+  for (const process of processes) {
+    const workflowActivityConfigurationVersion = extensionValues(process).find((node) => node.$type === "uipath:intsvcActivityConfig")?.version;
+    const connectionBindings = childNodes(extensionValues(process).find((node) => node.$type === "uipath:bindings")).filter((node) => node.$type === "uipath:binding" && node.resource === "Connection" && node.propertyAttribute === "ConnectionId").map(toConnectionBinding);
+    const bindingById = new Map(connectionBindings.map((binding) => [binding.id, binding]));
+    for (const element of allFlowElements(process)) {
+      const activity = extensionValues(element).find((node) => node.$type === "uipath:activity");
+      const type = childNodes(activity).find((node) => node.$type === "uipath:type");
+      if (type?.value !== "Intsvc.ActivityExecution") {
+        continue;
+      }
+      const context = childNodes(activity).find((node) => node.$type === "uipath:context");
+      const values = new Map(childNodes(context).filter((node) => node.$type === "uipath:input" && node.name).map((node) => [
+        node.name,
+        node.value ?? node.$body
+      ]));
+      if (!isIntsvcActivityExecutionV1(values.get("activityConfigurationVersion"), workflowActivityConfigurationVersion)) {
+        continue;
+      }
+      const activityId = required(element.id, "Integration Service activity id");
+      const activityDisplayName = element.name?.trim() || activityId;
+      const connector = required(values.get("connectorKey"), `Activity "${activityDisplayName}" connectorKey`);
+      const bindingId = bindingReference(values.get("connection"), activityDisplayName);
+      const binding = bindingById.get(bindingId);
+      if (!binding) {
+        throw new Error(`Activity "${activityDisplayName}" references missing Connection binding "${bindingId}".`);
+      }
+      const current = connectionResource({
+        activityId,
+        activityDisplayName,
+        connector,
+        binding
+      });
+      const prior = generated.get(binding.resourceKey);
+      if (prior) {
+        if (prior.metadata.Connector !== connector || prior.value.ConnectionId.defaultValue !== binding.connectionId) {
+          throw new Error(`Connection resource "${binding.resourceKey}" is used by Integration Service activities with different connectors or connections.`);
+        }
+        continue;
+      }
+      generated.set(binding.resourceKey, current);
+    }
+  }
+  const updated = existingResources.flatMap((resource) => {
+    const replacement = resource.resource === "Connection" && typeof resource.key === "string" ? generated.get(resource.key) : undefined;
+    if (!replacement)
+      return [resource];
+    generated.delete(replacement.key);
+    return [replacement];
+  });
+  return [
+    ...updated,
+    ...[...generated.values()].sort((left, right) => left.key.localeCompare(right.key))
+  ];
+}
+function connectionResource(options) {
+  const { activityId, activityDisplayName, connector, binding } = options;
+  return {
+    resource: "Connection",
+    key: binding.resourceKey,
+    activityId,
+    activityDisplayName,
+    value: {
+      ConnectionId: {
+        defaultValue: binding.connectionId,
+        isExpression: false
+      }
+    },
+    metadata: {
+      UseConnectionService: "true",
+      Connector: connector,
+      ActivityName: activityDisplayName,
+      BindingsVersion: "2.2",
+      SolutionsSupport: "true"
+    }
+  };
+}
+function toConnectionBinding(node) {
+  const binding = {
+    id: required(node.id, "Connection binding id"),
+    resourceKey: required(node.resourceKey, `Connection binding "${node.id ?? ""}" resourceKey`),
+    connectionId: required(node.default, `Connection binding "${node.id ?? ""}" default`)
+  };
+  if (!isGuid(binding.connectionId)) {
+    throw new Error(`Connection binding "${binding.id}" default must be a GUID.`);
+  }
+  return binding;
+}
+function allFlowElements(element) {
+  const result = [];
+  for (const child of element.flowElements ?? []) {
+    result.push(child, ...allFlowElements(child));
+  }
+  return result;
+}
+function bindingReference(value, activity) {
+  const match = /^=bindings\.([A-Za-z_][\w.-]*)$/.exec(value ?? "");
+  if (!match) {
+    throw new Error(`Activity "${activity}" connection must reference a root binding as "=bindings.<id>".`);
+  }
+  return match[1];
+}
+
+// src/services/bpmn-refresh-service.ts
+class BpmnRefreshService {
+  fs;
+  createUuid;
+  constructor(fs = getFileSystem(), createUuid = () => crypto.randomUUID()) {
+    this.fs = fs;
+    this.createUuid = createUuid;
+  }
+  async execute(projectPath) {
+    const resolvedProjectPath = this.fs.path.resolve(projectPath);
+    const stats = await this.fs.stat(resolvedProjectPath);
+    if (!stats?.isDirectory()) {
+      throw new Error(`Maestro project directory does not exist: ${resolvedProjectPath}`);
+    }
+    const release = await this.fs.acquireLock(this.fs.path.join(resolvedProjectPath, ".bpmn-refresh"));
+    try {
+      const bpmnFile = await this.findBpmnFile(resolvedProjectPath);
+      await this.readProjectFile(resolvedProjectPath);
+      const bpmnPath = this.fs.path.join(resolvedProjectPath, bpmnFile);
+      const xml = await this.fs.readFile(bpmnPath, "utf-8");
+      if (!xml) {
+        throw new Error(`BPMN file is empty: ${bpmnPath}`);
+      }
+      const existing = await this.readGeneratedFiles(resolvedProjectPath);
+      const contents = await this.deriveFiles(bpmnFile, xml, existing);
+      await this.validateProject(resolvedProjectPath, bpmnFile, contents);
+      const planned = BPMN_PACKAGE_FILES.map((name) => ({
+        name,
+        path: this.fs.path.join(resolvedProjectPath, name),
+        content: contents[name],
+        previous: existing[name]
+      }));
+      const changed = planned.filter((file) => file.previous !== file.content);
+      await this.writeFilesWithRollback(changed);
+      return {
+        projectPath: resolvedProjectPath,
+        bpmnFile,
+        writtenFiles: changed.map((file) => file.name),
+        unchangedFiles: planned.filter((file) => file.previous === file.content).map((file) => file.name)
+      };
+    } finally {
+      await release();
+    }
+  }
+  async findBpmnFile(projectPath) {
+    const entries = await this.fs.readdir(projectPath);
+    const files = [];
+    for (const entry of entries.filter((name) => name.endsWith(".bpmn"))) {
+      if ((await this.fs.stat(this.fs.path.join(projectPath, entry)))?.isFile()) {
+        files.push(entry);
+      }
+    }
+    files.sort((left, right) => left.localeCompare(right));
+    if (files.length !== 1) {
+      throw new Error(`Expected one BPMN file in ${projectPath}, found ${files.length}.`);
+    }
+    return files[0];
+  }
+  async readProjectFile(projectPath) {
+    const path = this.fs.path.join(projectPath, "project.uiproj");
+    const raw = await this.fs.readFile(path, "utf-8");
+    if (raw === null)
+      throw new Error(`Required file is missing: ${path}`);
+    const project = parseJson(raw, "project.uiproj");
+    if (project.ProjectType !== "ProcessOrchestration") {
+      throw new Error('project.uiproj must set "ProjectType" to "ProcessOrchestration".');
+    }
+  }
+  async readGeneratedFiles(projectPath) {
+    const result = {};
+    for (const name of BPMN_PACKAGE_FILES) {
+      result[name] = await this.fs.readFile(this.fs.path.join(projectPath, name), "utf-8");
+    }
+    return result;
+  }
+  async deriveFiles(bpmnFile, xml, existing) {
+    const { rootElement } = await new SimpleBpmnModdle().fromXML(xml);
+    const definitions = rootElement;
+    const processes = (definitions.rootElements ?? []).filter((element) => element.$type === "bpmn:Process");
+    if (processes.length === 0) {
+      throw new Error("BPMN file must contain a root process.");
+    }
+    const entryPoints = processes.flatMap((process) => this.deriveEntryPointsForProcess(process));
+    if (entryPoints.length === 0) {
+      throw new Error("BPMN file must contain a root manual start event with a uipath:entryPointId.");
+    }
+    const existingMetadata = {
+      "entry-points.json": null,
+      "bindings_v2.json": null,
+      "operate.json": null,
+      "package-descriptor.json": null
+    };
+    for (const name of [
+      "entry-points.json",
+      "bindings_v2.json",
+      "operate.json"
+    ]) {
+      existingMetadata[name] = parseOptionalJson(existing[name], name);
+    }
+    const existingOperate = existingMetadata["operate.json"];
+    const oldProjectId = existingOperate?.projectId;
+    const projectId = typeof oldProjectId === "string" && isGuid(oldProjectId) ? oldProjectId : this.createUuid();
+    if (!isGuid(projectId)) {
+      throw new Error(`Generated project id "${projectId}" must be a GUID.`);
+    }
+    const oldBindings = existingMetadata["bindings_v2.json"];
+    const existingResources = Array.isArray(oldBindings?.resources) ? oldBindings.resources.filter(isJsonObject) : [];
+    const resources = buildConnectionResources(processes, existingResources);
+    const metadata = buildBpmnPackageMetadata({
+      bpmnFile,
+      entryPoints,
+      projectId,
+      resources,
+      existing: existingMetadata
+    });
+    const contents = Object.fromEntries(BPMN_PACKAGE_FILES.map((name) => [
+      name,
+      formatBpmnPackageFile(metadata[name])
+    ]));
+    return contents;
+  }
+  deriveEntryPointsForProcess(process) {
+    const flowElements = process.flowElements ?? [];
+    const manualStartEvents = flowElements.filter((element) => element.$type === "bpmn:StartEvent" && (element.eventDefinitions?.length ?? 0) === 0 && !extensionValues(element).some((node) => node.$type === "uipath:event"));
+    if (manualStartEvents.length === 0)
+      return [];
+    const variables = childNodes(extensionValues(process).find((node) => node.$type === "uipath:variables"));
+    const inputs = variables.filter((node) => node.$type === "uipath:input");
+    const rootEndIds = new Set(flowElements.filter((element) => element.$type === "bpmn:EndEvent").map((element) => element.id).filter((id) => id !== undefined));
+    const outputs = variables.filter((node) => node.$type === "uipath:output");
+    for (const output of outputs) {
+      if (!output.elementId || !rootEndIds.has(output.elementId)) {
+        throw new Error(`Process output "${required(output.name, "Process output name")}" must target a root end event.`);
+      }
+    }
+    const outputSchema = variableSchema(outputs, "output");
+    return manualStartEvents.map((startEvent) => {
+      const startEventId = required(startEvent.id, "Root manual start event id");
+      const entryPoint = exactlyOne(extensionValues(startEvent).filter((node) => node.$type === "uipath:entryPointId"), `uipath:entryPointId on root manual start event "${startEventId}"`);
+      const entryPointId = required(entryPoint.value, `Root manual start event "${startEventId}" entryPointId`);
+      if (!isGuid(entryPointId)) {
+        throw new Error(`Root manual start event "${startEventId}" entryPointId "${entryPointId}" must be a GUID.`);
+      }
+      return {
+        startEventId,
+        entryPointId,
+        displayName: entryPointDisplayName(startEvent.name),
+        input: variableSchema(inputs.filter((input) => input.elementId === startEventId), "input"),
+        output: outputSchema
+      };
+    });
+  }
+  async validateProject(projectPath, bpmnFile, contents) {
+    const proposedFiles = new Map(BPMN_PACKAGE_FILES.map((name) => [
+      this.fs.path.join(projectPath, name),
+      contents[name]
+    ]));
+    const fileSystem = proposedFileSystem(this.fs, proposedFiles);
+    const result = await new BpmnValidateService(fileSystem).validateFile(this.fs.path.join(projectPath, bpmnFile));
+    if (!result.success) {
+      const errors = result.issues.filter((issue) => issue.severity === "error").map((issue) => issue.ruleCode ? `${issue.ruleCode}: ${issue.message}` : issue.message);
+      throw new Error(`BPMN validation failed: ${errors.join("; ")}`);
+    }
+  }
+  async writeFilesWithRollback(files) {
+    if (files.length === 0)
+      return;
+    const transactionId = this.createUuid();
+    const staged = files.map((file) => ({
+      ...file,
+      stagingPath: `${file.path}.${transactionId}.tmp`,
+      rollbackPath: `${file.path}.${transactionId}.rollback`
+    }));
+    const written = [];
+    try {
+      for (const file of staged) {
+        await this.fs.writeFile(file.stagingPath, file.content);
+      }
+      for (const file of staged) {
+        await this.fs.rename(file.stagingPath, file.path);
+        written.push(file);
+      }
+    } catch (error) {
+      const rollbackErrors = [];
+      for (const file of [...written].reverse()) {
+        try {
+          await this.restoreFile(file);
+        } catch (rollbackError) {
+          rollbackErrors.push(`${file.name}: ${extractErrorMessageSync(rollbackError)}`);
+        }
+      }
+      const rollbackMessage = rollbackErrors.length === 0 ? "" : ` Rollback also failed for ${rollbackErrors.join("; ")}.`;
+      throw new Error(`Could not update all BPMN package files: ${extractErrorMessageSync(error)}.${rollbackMessage}`);
+    } finally {
+      for (const file of staged) {
+        await this.fs.rm(file.stagingPath).catch(() => {
+          return;
+        });
+        await this.fs.rm(file.rollbackPath).catch(() => {
+          return;
+        });
+      }
+    }
+  }
+  async restoreFile(file) {
+    if (file.previous === null) {
+      await this.fs.rm(file.path);
+      return;
+    }
+    await this.fs.writeFile(file.rollbackPath, file.previous);
+    await this.fs.rename(file.rollbackPath, file.path);
+  }
+}
+function proposedFileSystem(fs, proposedFiles) {
+  return new Proxy(fs, {
+    get: (target, property, receiver) => {
+      if (property === "readFile") {
+        return async (path, options) => {
+          const proposed = proposedFiles.get(path);
+          if (proposed !== undefined) {
+            return options ? proposed : new TextEncoder().encode(proposed);
+          }
+          return options ? target.readFile(path, options) : target.readFile(path);
+        };
+      }
+      if (property === "exists") {
+        return (path) => proposedFiles.has(path) ? Promise.resolve(true) : target.exists(path);
+      }
+      const value = Reflect.get(target, property, receiver);
+      return typeof value === "function" ? value.bind(target) : value;
+    }
+  });
+}
+function variableSchema(variables, direction) {
+  const properties = Object.create(null);
+  const names = new Set;
+  for (const variable of variables) {
+    const name = required(variable.name, `Process ${direction} name`);
+    if (names.has(name)) {
+      throw new Error(`Duplicate process ${direction} "${name}".`);
+    }
+    names.add(name);
+    properties[name] = schemaForVariable(variable, direction);
+  }
+  return { type: "object", properties };
+}
+function schemaForVariable(variable, direction) {
+  if (variable.$body?.trim()) {
+    return parseJson(variable.$body, `Process ${direction} "${variable.name}" schema`);
+  }
+  const type = required(variable.type, `Process ${direction} "${variable.name}" type`);
+  return schemaForType(type);
+}
+function schemaForType(type) {
+  switch (type.toLowerCase()) {
+    case "string":
+      return { type: "string" };
+    case "boolean":
+      return { type: "boolean" };
+    case "integer":
+      return { type: "integer" };
+    case "number":
+      return { type: "number" };
+    case "array":
+      return { type: "array" };
+    case "object":
+    case "json":
+      return { type: "object" };
+    default:
+      throw new Error(`Unsupported process input/output type "${type}". Use string, boolean, integer, number, array, object, or json, or add an inline JSON schema.`);
+  }
+}
+function exactlyOne(values, label) {
+  if (values.length !== 1) {
+    throw new Error(`Expected one ${label}, found ${values.length}.`);
+  }
+  return values[0];
+}
+function parseOptionalJson(raw, label) {
+  return raw === null ? null : parseJson(raw, label);
+}
+function parseJson(raw, label) {
+  let value;
+  try {
+    value = JSON.parse(raw);
+  } catch (error) {
+    throw new Error(`${label} is not valid JSON: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  if (!isJsonObject(value)) {
+    throw new Error(`${label} must contain a JSON object.`);
+  }
+  return value;
+}
+export {
+  BpmnRefreshService
+};
+
+//# debugId=E9C48270AC5B3C9564756E2164756E21

package/dist/{browser-strategy-d4zm14fb.js → browser-strategy-rkcvc6tn.js}

@@ -3,7 +3,7 @@ import {
 } from "./packager-tool-9qecd4wb.js";
 import {
   AUTH_CANCELLED_ERROR_CODE
-} from "./packager-tool-1ps2qeqg.js";
+} from "./packager-tool-5arsyj36.js";
 import"./packager-tool-wckvcay0.js";
 
 // ../auth/src/strategies/browser-strategy.ts

package/dist/{conversion-COFE4RVO-yxwte1kj.js → conversion-MQ7TJMHW-avnhwgjk.js}

@@ -10,28 +10,28 @@ import {
   getLatestDefinitionByNodeType,
   isContainerNodeManifest,
   resolveNodeOutputTypeSchema
-} from "./packager-tool-cwgxt2b5.js";
+} from "./packager-tool-anfb35wg.js";
 import"./packager-tool-x8d8fpse.js";
-import {
-  CURRENT_WORKFLOW_VERSION,
-  generateNextId,
-  isSubflowNodeType
-} from "./packager-tool-05gksq3e.js";
 import"./packager-tool-jqtspg41.js";
-import"./packager-tool-hkrpcn6d.js";
+import"./packager-tool-htc0z863.js";
 import"./packager-tool-fr5b9qs6.js";
 import {
   init_esm_shims
 } from "./packager-tool-ahm4ymrp.js";
 import"./packager-tool-c19w8vg9.js";
-import"./packager-tool-9bnpe8n1.js";
-import"./packager-tool-3yjtbs1y.js";
-import"./packager-tool-060a9knt.js";
+import"./packager-tool-gbgfwx8f.js";
+import {
+  MINIMUM_SUPPORTED_SCHEMA_VERSION,
+  generateNextId,
+  isSubflowNodeType
+} from "./packager-tool-5fpetbc1.js";
+import"./packager-tool-973f0r2g.js";
+import"./packager-tool-c23zrhj8.js";
 import {
   __require
 } from "./packager-tool-wckvcay0.js";
 
-// ../../node_modules/@uipath/flow-converter/dist/conversion-COFE4RVO.js
+// ../../node_modules/@uipath/flow-converter/dist/conversion-MQ7TJMHW.js
 init_esm_shims();
 init_esm_shims();
 init_esm_shims();
@@ -732,7 +732,7 @@ function createEmptyWorkflow(id = crypto.randomUUID(), name = "Untitled Workflow
   }
   return {
     id,
-    version: CURRENT_WORKFLOW_VERSION,
+    version: MINIMUM_SUPPORTED_SCHEMA_VERSION,
     name,
     nodes,
     edges: [],
@@ -810,7 +810,7 @@ function applyGlobalInputOverrides(raw, inputs) {
     }
   }
 }
-var warmSerializationChunks = () => Promise.all([import("./index-29kkrpx1.js"), import("./serialization-3RH6P643-z9b9wkfm.js")]);
+var warmSerializationChunks = () => Promise.all([import("./index-y93b9sgy.js"), import("./serialization-JNQMGOXW-3g31rma2.js")]);
 async function flowJsonToBpmnXml(flowJson, options) {
   const [{ fileFormatToInMemoryWorkflow }, { toXml }] = await warmSerializationChunks();
   const raw = JSON.parse(flowJson);
@@ -843,4 +843,4 @@ export {
   applyGlobalInputOverrides
 };
 
-//# debugId=4CD2E0945A754F7D64756E2164756E21
+//# debugId=94A5251CF6EBB5CC64756E2164756E21