@uipath/flow-tool 1.201.0 → 1.202.0-preview.136

package/dist/flow-debug-service-tfbefas6.js

@@ -0,0 +1,741 @@
+import {
+  writeResolvedFlow
+} from "./packager-tool-raq2wbwp.js";
+import {
+  package_default
+} from "./packager-tool-7b6tpg7y.js";
+import {
+  ensureProcessBindings
+} from "./packager-tool-v2rkcehq.js";
+import {
+  buildInlineAgentDescriptors,
+  fileNodesToPackagingNodes,
+  packageInlineAgents,
+  stageInlineAgentPackageFiles,
+  writePackagingArtifacts,
+  writePackagingArtifactsDetailed
+} from "./packager-tool-v86fdwvs.js";
+import"./packager-tool-jc34wvrw.js";
+import"./packager-tool-4hx14snw.js";
+import"./packager-tool-cdwpc9fh.js";
+import"./packager-tool-g9y14b10.js";
+import"./packager-tool-5z1eg3ea.js";
+import {
+  DebugVariablesFetchFailedError,
+  buildStudioWebDesignerUrl,
+  extractStartEventId,
+  fetchDebugInstanceVariables,
+  getFolderInfoById,
+  getPersonalFolderInfo,
+  isSuccessfulDebugStatus,
+  patchConnectionOverwrites,
+  uploadAndDebugSolution
+} from "./packager-tool-v9rrz038.js";
+import"./packager-tool-fjaa8d3v.js";
+import"./packager-tool-v9psxdy5.js";
+import"./packager-tool-ywqc9rtf.js";
+import"./packager-tool-f0kd5kq4.js";
+import"./packager-tool-0gctz400.js";
+import"./packager-tool-qa9gftnj.js";
+import"./packager-tool-yc4kw997.js";
+import"./packager-tool-7exrv6w7.js";
+import {
+  buildSolutionPackageFromDir,
+  createZipFromDir,
+  uploadOrOverwriteSolution
+} from "./packager-tool-8dszjcg5.js";
+import {
+  findNearestParentUipxFile,
+  findSolutionFile,
+  isProjectRegisteredInSolution,
+  readUipxFile,
+  updateSolutionFile
+} from "./packager-tool-eebq62fq.js";
+import {
+  findProjectFlowFile,
+  readFlowWorkflow,
+  resolveProjectFlowFile,
+  writeFlowWorkflow
+} from "./packager-tool-94w17vf8.js";
+import {
+  assertVoiceAgentDefinitionsEmbedded,
+  convertFlowToBpmn,
+  hydrateInlineAgentInputVariables,
+  replaceExporterVersion,
+  voiceConvertOptions
+} from "./packager-tool-6m078z5s.js";
+import"./packager-tool-tn5e7wnb.js";
+import"./packager-tool-xhzfwa5p.js";
+import"./packager-tool-nkrmjr3a.js";
+import"./packager-tool-rs6jm14d.js";
+import"./packager-tool-hk1gxnth.js";
+import"./packager-tool-em5r6g6j.js";
+import"./packager-tool-9bec251q.js";
+import"./packager-tool-z9bfhmm5.js";
+import"./packager-tool-6ejqwbw9.js";
+import"./packager-tool-mcaf4ewf.js";
+import"./packager-tool-eypvc2kv.js";
+import {
+  catchError,
+  logger
+} from "./packager-tool-5qaxht3k.js";
+import {
+  getFileSystem
+} from "./packager-tool-0v3s8r01.js";
+import"./packager-tool-p9stswjj.js";
+import"./packager-tool-vpqyvh4c.js";
+import"./packager-tool-gbgfwx8f.js";
+import"./packager-tool-58q3tvh7.js";
+import"./packager-tool-sc961w0q.js";
+import {
+  inMemoryWorkflowToFileFormat,
+  isVoiceAgentNodeType
+} from "./packager-tool-m5qfverj.js";
+import"./packager-tool-e0p2zsyc.js";
+import"./packager-tool-a42jnpy5.js";
+import"./packager-tool-c23zrhj8.js";
+import {
+  __require
+} from "./packager-tool-1yh8g550.js";
+
+// src/services/flow-debug-service.ts
+var FLOW_DEBUG_MISSING_SOLUTION_MESSAGE = "Flow debug requires this Flow to be inside a solution.";
+var FLOW_DEBUG_MISSING_SOLUTION_INSTRUCTIONS = "Create a solution wrapper and import this Flow before debugging: `uip solution init <name>` then `uip solution projects import <flow-dir>` from inside the solution directory, then re-run `uip maestro flow debug`.";
+var FLOW_DEBUG_UNREGISTERED_PROJECT_MESSAGE = "Flow project is not registered in the enclosing solution.";
+var buildFlowDebugUnregisteredProjectInstructions = (projectDir, solutionFile) => [
+  `The .uipx manifest at ${solutionFile} does not list ${projectDir} in its Projects[] array.`,
+  "Studio Web rejects solution archives with an empty or mismatched Projects[] manifest with an opaque HTTP 400.",
+  `Run 'uip solution projects add "${projectDir}" "${solutionFile}"' to register the project, then re-run 'uip maestro flow debug'.`
+].join(`
+`);
+
+class MissingSolutionWrapperError extends Error {
+  instructions;
+  constructor(message = FLOW_DEBUG_MISSING_SOLUTION_MESSAGE, instructions = FLOW_DEBUG_MISSING_SOLUTION_INSTRUCTIONS) {
+    super(message);
+    this.name = "MissingSolutionWrapperError";
+    this.instructions = instructions;
+  }
+}
+
+class UnregisteredProjectError extends Error {
+  instructions;
+  projectDir;
+  solutionFile;
+  constructor(projectDir, solutionFile) {
+    super(FLOW_DEBUG_UNREGISTERED_PROJECT_MESSAGE);
+    this.name = "UnregisteredProjectError";
+    this.projectDir = projectDir;
+    this.solutionFile = solutionFile;
+    this.instructions = buildFlowDebugUnregisteredProjectInstructions(projectDir, solutionFile);
+  }
+}
+var VOICE_TRIGGER_TYPE = "core.trigger.voice";
+var FLOW_DEBUG_INBOUND_VOICE_MESSAGE = "Inbound voice flows cannot be debugged from the CLI.";
+var buildFlowDebugInboundVoiceInstructions = (triggerLabel) => [
+  `This flow starts from an incoming-call trigger ("${triggerLabel}"), which only a real call can raise.`,
+  "Publish the flow, bind a phone number to it ('uip conversational trunks assign'), then call that number to run it.",
+  "Outbound voice flows (manual trigger + Create outgoing call) do run under 'uip maestro flow debug'."
+].join(`
+`);
+
+class InboundVoiceDebugError extends Error {
+  instructions;
+  constructor(triggerLabel) {
+    super(FLOW_DEBUG_INBOUND_VOICE_MESSAGE);
+    this.name = "InboundVoiceDebugError";
+    this.instructions = buildFlowDebugInboundVoiceInstructions(triggerLabel);
+  }
+}
+function assertNotInboundVoiceFlow(workflow) {
+  const trigger = (workflow.nodes ?? []).find((node) => node.type === VOICE_TRIGGER_TYPE);
+  if (!trigger) {
+    return;
+  }
+  throw new InboundVoiceDebugError(trigger.display?.label ?? trigger.id ?? "Incoming call");
+}
+
+class FlowDebugService {
+  fs;
+  constructor() {
+    this.fs = getFileSystem();
+  }
+  async assertEnclosingSolution(projectPath) {
+    const absoluteProjectPath = this.fs.path.resolve(projectPath);
+    const discovery = await findNearestParentUipxFile(this.fs, absoluteProjectPath);
+    if (discovery.status === "found") {
+      return discovery.solutionFile;
+    }
+    throw new MissingSolutionWrapperError;
+  }
+  async assertProjectRegisteredInSolution(projectPath, solutionFile) {
+    const absoluteProjectPath = this.fs.path.resolve(projectPath);
+    const isRegistered = await isProjectRegisteredInSolution(this.fs, absoluteProjectPath, solutionFile);
+    if (!isRegistered) {
+      throw new UnregisteredProjectError(absoluteProjectPath, solutionFile);
+    }
+  }
+  async readFlowFile(flowFilePath) {
+    const absolutePath = this.fs.path.resolve(flowFilePath);
+    if (!await this.fs.exists(absolutePath)) {
+      throw new Error(`File not found: ${absolutePath}`);
+    }
+    if (!absolutePath.endsWith(".flow")) {
+      throw new Error(`Expected a .flow file but got: ${this.fs.path.basename(absolutePath)}`);
+    }
+    const { workflow } = await readFlowWorkflow(absolutePath);
+    return workflow;
+  }
+  async readBpmnFile(bpmnFilePath) {
+    const absolutePath = this.fs.path.resolve(bpmnFilePath);
+    if (!await this.fs.exists(absolutePath)) {
+      throw new Error(`File not found: ${absolutePath}`);
+    }
+    if (!absolutePath.endsWith(".bpmn")) {
+      throw new Error(`Expected a .bpmn file but got: ${this.fs.path.basename(absolutePath)}`);
+    }
+    const bpmnContent = await this.fs.readFile(absolutePath, "utf-8");
+    return bpmnContent;
+  }
+  async convertToBpmn(workflow, projectDir) {
+    if (projectDir) {
+      await this.hydrateInlineAgentInputs(workflow, projectDir);
+    }
+    const flowNodes = workflow.nodes ?? [];
+    const voiceNodes = flowNodes.filter((node) => isVoiceAgentNodeType(node.type));
+    if (voiceNodes.length > 0 && !projectDir) {
+      throw new Error("This flow contains voice agent nodes; the flow project directory is required to resolve their agent definitions.");
+    }
+    const voiceAgentPackages = projectDir ? await packageInlineAgents(this.fs, projectDir, voiceNodes) : [];
+    const fileFormat = inMemoryWorkflowToFileFormat(workflow);
+    const flowJson = JSON.stringify(fileFormat, null, 2);
+    const { bpmn: rawBpmn } = await convertFlowToBpmn(flowJson, voiceConvertOptions({
+      flowJson,
+      nodes: flowNodes,
+      builtAgents: new Map(voiceAgentPackages.map((agent) => [
+        agent.source,
+        agent.agentJson
+      ])),
+      convertOptions: { detached: true }
+    }));
+    const bpmn = replaceExporterVersion(rawBpmn, package_default.version);
+    assertVoiceAgentDefinitionsEmbedded(bpmn, flowNodes);
+    return bpmn;
+  }
+  async hydrateInlineAgentInputs(workflow, projectDir) {
+    const nodes = workflow.nodes ?? [];
+    await hydrateInlineAgentInputVariables(nodes, async (source) => {
+      const agentJsonPath = this.fs.path.join(projectDir, source, "agent.json");
+      const [readErr, raw] = await catchError(this.fs.readFile(agentJsonPath, "utf-8"));
+      if (readErr || typeof raw !== "string")
+        return;
+      const [parseErr, agent] = catchError(() => JSON.parse(raw));
+      if (parseErr || !agent)
+        return;
+      return agent.inputSchema;
+    }, (source, added) => logger.info(`Reconciled ${added} inline-agent input(s) for "${source}" from agent.json inputSchema`), (source, reason) => logger.warn(reason === "invalid-source" ? `Inline agent "${source}" is not a bare project-id folder, so its inputs were not reconciled — the agent will run with no bound inputs.` : `Could not read an inputSchema for inline agent "${source}", so its inputs were not reconciled — the agent will run with no bound inputs. Check that ${source}/agent.json exists and parses.`));
+  }
+  async generateProjectFiles(flowData, bpmnXml, flowFileContent, startEventId) {
+    const safeName = flowData.name.replace(/[^a-zA-Z0-9_-]/g, "_");
+    const projectDir = this.fs.path.join(this.fs.env.tmpdir(), `.flow-debug-${safeName}-${Date.now()}`);
+    const safeMkdir = async (dir) => {
+      const [err] = await catchError(this.fs.mkdir(dir));
+      if (err && err.code !== "EEXIST") {
+        throw err;
+      }
+    };
+    await safeMkdir(projectDir);
+    const resolvedStartEventId = startEventId ?? extractStartEventId(bpmnXml);
+    const bpmnFileName = `${safeName}.bpmn`;
+    const packagingNodes = fileNodesToPackagingNodes(flowData.nodes);
+    const bindings = flowData.bindings ?? [];
+    const variables = flowData.variables ?? {};
+    const definitions = flowData.definitions ?? [];
+    const projectUiproj = {
+      Name: flowData.name,
+      ProjectType: "Flow"
+    };
+    await this.fs.writeFile(this.fs.path.join(projectDir, "project.uiproj"), `${JSON.stringify(projectUiproj, null, 2)}
+`);
+    await writePackagingArtifacts(this.fs, projectDir, flowData.id, packagingNodes, bindings, variables, bpmnFileName, resolvedStartEventId, `${safeName}.flow`, definitions);
+    await this.fs.writeFile(this.fs.path.join(projectDir, `${safeName}.bpmn`), bpmnXml);
+    if (flowFileContent) {
+      await this.fs.writeFile(this.fs.path.join(projectDir, `${safeName}.flow`), flowFileContent);
+    }
+    await writeResolvedFlow(this.fs, projectDir, safeName, flowData);
+    return projectDir;
+  }
+  async buildSolutionPackage(projectDir, projectName) {
+    const solutionId = crypto.randomUUID();
+    const projectId = crypto.randomUUID();
+    const stagingDir = this.fs.path.join(this.fs.env.tmpdir(), `.flow-debug-solution-${Date.now()}`);
+    await this.fs.mkdir(stagingDir);
+    const solutionStorage = {
+      SolutionId: solutionId,
+      Projects: [
+        {
+          ProjectId: projectId,
+          ProjectRelativePath: `${projectName}/project.uiproj`
+        }
+      ]
+    };
+    await this.fs.writeFile(this.fs.path.join(stagingDir, "SolutionStorage.json"), JSON.stringify(solutionStorage));
+    const uipx = {
+      SolutionId: solutionId,
+      Projects: [
+        {
+          Type: "Flow",
+          ProjectRelativePath: `${projectName}/project.uiproj`,
+          Id: projectId
+        }
+      ]
+    };
+    await this.fs.writeFile(this.fs.path.join(stagingDir, `${projectName}Solution.uipx`), JSON.stringify(uipx, null, 2));
+    const destProjectDir = this.fs.path.join(stagingDir, projectName);
+    await this.fs.mkdir(destProjectDir);
+    await this.fs.copyDirectory(projectDir, destProjectDir);
+    const uisPath = this.fs.path.join(this.fs.env.tmpdir(), `${projectName}Solution-${Date.now()}.uis`);
+    const zipData = await createZipFromDir(this.fs, stagingDir);
+    await this.fs.writeFile(uisPath, zipData);
+    await this.fs.rm(stagingDir).catch(() => {});
+    return uisPath;
+  }
+  async writeSingleProjectSolutionMetadata(stagingDir, projectName, projectRelativeDir) {
+    const solutionId = crypto.randomUUID();
+    const projectId = crypto.randomUUID();
+    const projectRelativePath = `${projectRelativeDir}/project.uiproj`;
+    const solutionStorage = {
+      SolutionId: solutionId,
+      Projects: [
+        {
+          ProjectId: projectId,
+          ProjectRelativePath: projectRelativePath
+        }
+      ]
+    };
+    await this.fs.writeFile(this.fs.path.join(stagingDir, "SolutionStorage.json"), JSON.stringify(solutionStorage, null, 4));
+    const uipx = {
+      SolutionId: solutionId,
+      Projects: [
+        {
+          Type: "Flow",
+          ProjectRelativePath: projectRelativePath,
+          Id: projectId
+        }
+      ]
+    };
+    await this.fs.writeFile(this.fs.path.join(stagingDir, `${projectName}Solution.uipx`), JSON.stringify(uipx, null, 4));
+  }
+  async buildSolutionProjectDescriptors(uploadedProjects, solutionId, stagingDir, leadProjectName, leadEntryPoint) {
+    const descriptors = [];
+    for (const project of uploadedProjects) {
+      const projectStagingDir = this.fs.path.join(stagingDir, project.name);
+      const isLead = project.name === leadProjectName;
+      const projectType = isLead ? "Flow" : this.toWireProjectType(await this.readProjectTypeRaw(projectStagingDir));
+      if (projectType === undefined || projectType === "Agent") {
+        continue;
+      }
+      const fromEntryPoints = isLead ? leadEntryPoint : await this.readFirstEntryPointPath(projectStagingDir);
+      const entryPoint = fromEntryPoints ? this.normalizeEntryPoint(fromEntryPoints) : await this.deriveEntryPointFromBpmn(projectStagingDir);
+      descriptors.push({
+        name: project.name,
+        projectId: project.id,
+        projectType,
+        entryPoint,
+        solutionId
+      });
+    }
+    return descriptors;
+  }
+  async generateSiblingFlowPackage(projectStagingDir, hostProjectName) {
+    const [resolveError, flowFilePath] = await catchError(findProjectFlowFile(projectStagingDir));
+    if (resolveError || !flowFilePath) {
+      logger.warn(`No .flow found for sibling project ${projectStagingDir}; skipping BPMN generation.`);
+      return [];
+    }
+    const flowFileName = this.fs.path.basename(flowFilePath);
+    const { workflow: flowData } = await readFlowWorkflow(flowFilePath);
+    ensureProcessBindings(flowData);
+    const bpmnXml = await this.convertToBpmn(flowData, this.fs.path.dirname(flowFilePath));
+    const inlineAgentPackages = await packageInlineAgents(this.fs, projectStagingDir, flowData.nodes);
+    await this.writeFlowProjectPackage(projectStagingDir, flowData, bpmnXml, flowFileName, inlineAgentPackages);
+    await stageInlineAgentPackageFiles(this.fs, projectStagingDir, projectStagingDir, inlineAgentPackages, (source) => `Staged inline agent "${source}" for sibling Flow debug`);
+    logger.info(`Generated BPMN package for sibling flow "${flowFileName.replace(/\.flow$/i, "")}"`);
+    return buildInlineAgentDescriptors(flowData.nodes).map((agent) => ({
+      ...agent,
+      hostProjectName
+    }));
+  }
+  async writeFlowProjectPackage(projectDir, flowData, bpmnXml, flowFileName, inlineAgentPackages = []) {
+    const bpmnFileName = `${flowFileName.replace(/\.flow$/i, "")}.bpmn`;
+    await writeFlowWorkflow(this.fs.path.join(projectDir, flowFileName), flowData);
+    await this.fs.writeFile(this.fs.path.join(projectDir, bpmnFileName), bpmnXml);
+    const startEventId = extractStartEventId(bpmnXml);
+    const { entryPoints } = await writePackagingArtifactsDetailed(this.fs, projectDir, flowData.id, fileNodesToPackagingNodes(flowData.nodes), flowData.bindings ?? [], flowData.variables ?? {}, bpmnFileName, startEventId, flowFileName, flowData.definitions ?? [], {
+      additionalEntryPoints: inlineAgentPackages.map((agent) => agent.entryPoint),
+      additionalBindingsJsons: inlineAgentPackages.map((agent) => agent.bindingsJson)
+    });
+    await writeResolvedFlow(this.fs, projectDir, flowFileName.replace(/\.flow$/i, ""), flowData);
+    return { bpmnFileName, startEventId, entryPoints };
+  }
+  toWireProjectType(rawType) {
+    switch (rawType?.trim().toLowerCase()) {
+      case "agent":
+        return "Agent";
+      case "flow":
+        return "Flow";
+      case "workflow":
+      case "process":
+        return "Process";
+      case "processorchestration":
+        return "ProcessOrchestration";
+      case "api":
+        return "Api";
+      default:
+        return;
+    }
+  }
+  normalizeEntryPoint(entryPoint) {
+    return entryPoint.replace(/^\//, "").replace(/^content\//, "");
+  }
+  async readFirstEntryPointPath(projectDir) {
+    const path = this.fs.path.join(projectDir, "entry-points.json");
+    if (!await this.fs.exists(path)) {
+      return "";
+    }
+    const content = await this.fs.readFile(path, "utf-8");
+    if (!content) {
+      return "";
+    }
+    const [err, parsed] = catchError(() => JSON.parse(content));
+    const filePath = err ? undefined : parsed.entryPoints?.[0]?.filePath;
+    return typeof filePath === "string" ? filePath : "";
+  }
+  async deriveEntryPointFromBpmn(projectDir) {
+    const entries = await this.fs.readdir(projectDir);
+    const bpmnFile = entries.find((f) => f.endsWith(".bpmn"));
+    if (!bpmnFile) {
+      return "";
+    }
+    const content = await this.fs.readFile(this.fs.path.join(projectDir, bpmnFile), "utf-8");
+    if (!content) {
+      return "";
+    }
+    return `/${bpmnFile}#${extractStartEventId(content)}`;
+  }
+  async readProjectTypeRaw(projectDir) {
+    const path = this.fs.path.join(projectDir, "project.uiproj");
+    if (!await this.fs.exists(path)) {
+      return;
+    }
+    const content = await this.fs.readFile(path, "utf-8");
+    if (!content) {
+      return;
+    }
+    const [err, parsed] = catchError(() => JSON.parse(content));
+    const projectType = err ? undefined : parsed.ProjectType;
+    return typeof projectType === "string" ? projectType : undefined;
+  }
+  async executeProjectViaStudioWeb(projectPath, config, callbacks, pollInterval, options) {
+    const absoluteProjectPath = this.fs.path.resolve(projectPath);
+    const projectUiprojPath = this.fs.path.join(absoluteProjectPath, "project.uiproj");
+    if (!await this.fs.exists(projectUiprojPath)) {
+      throw new Error(`Not a valid flow project directory: missing project.uiproj in ${absoluteProjectPath}`);
+    }
+    const solutionFile = await this.assertEnclosingSolution(absoluteProjectPath);
+    await this.assertProjectRegisteredInSolution(absoluteProjectPath, solutionFile);
+    const projectUiprojContent = await this.fs.readFile(projectUiprojPath, "utf-8");
+    if (projectUiprojContent === null) {
+      throw new Error(`Failed to read project.uiproj in ${absoluteProjectPath}`);
+    }
+    const projectUiproj = JSON.parse(projectUiprojContent);
+    const projectName = projectUiproj.Name;
+    const safeName = projectName.replace(/[^a-zA-Z0-9_-]/g, "_");
+    const flowFilePath = await resolveProjectFlowFile(absoluteProjectPath);
+    const { workflow: flowData } = await readFlowWorkflow(flowFilePath);
+    assertNotInboundVoiceFlow(flowData);
+    if (options?.inputs && flowData.variables?.globals) {
+      for (const variable of flowData.variables.globals) {
+        if (Object.hasOwn(options.inputs, variable.id)) {
+          variable.defaultValue = options.inputs[variable.id];
+        }
+      }
+    }
+    ensureProcessBindings(flowData);
+    logger.info("Found .flow file, converting to BPMN...");
+    const bpmnXml = await this.convertToBpmn(flowData, this.fs.path.dirname(flowFilePath));
+    const solutionDir = this.fs.path.resolve(absoluteProjectPath, "..");
+    const stagingDir = this.fs.path.join(this.fs.env.tmpdir(), `.flow-debug-staging-${safeName}-${Date.now()}`);
+    await this.fs.mkdir(stagingDir);
+    let uisPath;
+    let entryPoint;
+    try {
+      const [uipxError, uipxResult] = await catchError(readUipxFile(this.fs, solutionDir));
+      if (uipxError) {
+        logger.warn(`Could not read .uipx: ${uipxError.message}. Falling back to flow-only upload.`);
+      }
+      const flowProjectRelDir = this.fs.path.basename(absoluteProjectPath);
+      if (uipxResult) {
+        await this.fs.writeFile(this.fs.path.join(stagingDir, uipxResult.uipxFileName), JSON.stringify(uipxResult.uipx, null, 4));
+      } else {
+        await this.writeSingleProjectSolutionMetadata(stagingDir, safeName, flowProjectRelDir);
+      }
+      const resourcesDir = this.fs.path.join(solutionDir, "resources");
+      if (await this.fs.exists(resourcesDir)) {
+        await this.fs.copyDirectory(resourcesDir, this.fs.path.join(stagingDir, "resources"));
+      }
+      const userProfileDir = this.fs.path.join(solutionDir, "userProfile");
+      if (await this.fs.exists(userProfileDir)) {
+        await this.fs.copyDirectory(userProfileDir, this.fs.path.join(stagingDir, "userProfile"));
+      }
+      const siblingInlineAgents = [];
+      if (uipxResult) {
+        for (const project of uipxResult.uipx.Projects) {
+          const projectDir = this.fs.path.dirname(project.ProjectRelativePath);
+          if (projectDir === flowProjectRelDir) {
+            continue;
+          }
+          const srcProjectPath = this.fs.path.join(solutionDir, projectDir);
+          if (await this.fs.exists(srcProjectPath)) {
+            const siblingStagingDir = this.fs.path.join(stagingDir, projectDir);
+            await this.fs.copyDirectory(srcProjectPath, siblingStagingDir);
+            if (project.Type === "Flow") {
+              const [packageError, agents] = await catchError(this.generateSiblingFlowPackage(siblingStagingDir, projectDir));
+              if (packageError) {
+                logger.warn(`Could not package sibling Flow "${projectDir}": ${packageError.message}. Continuing.`);
+              } else {
+                siblingInlineAgents.push(...agents);
+              }
+            }
+            logger.info(`Included project "${projectDir}" (${project.Type}) in solution package`);
+          } else {
+            logger.warn(`Project directory not found: ${srcProjectPath} — skipping`);
+          }
+        }
+      }
+      const stagingProjectDir = this.fs.path.join(stagingDir, flowProjectRelDir);
+      await this.fs.mkdir(stagingProjectDir);
+      await this.fs.writeFile(this.fs.path.join(stagingProjectDir, "project.uiproj"), projectUiprojContent);
+      const inlineAgentPackages = await packageInlineAgents(this.fs, absoluteProjectPath, flowData.nodes);
+      const { bpmnFileName, startEventId, entryPoints } = await this.writeFlowProjectPackage(stagingProjectDir, flowData, bpmnXml, `${safeName}.flow`, inlineAgentPackages);
+      if (inlineAgentPackages.length > 0) {
+        await stageInlineAgentPackageFiles(this.fs, absoluteProjectPath, stagingProjectDir, inlineAgentPackages, (source) => `Staged inline agent "${source}" for debug`);
+      }
+      const inlineAgents = [
+        ...siblingInlineAgents,
+        ...buildInlineAgentDescriptors(flowData.nodes)
+      ];
+      const startNodeId = entryPoints[0]?.filePath.split("#")[1] ?? startEventId;
+      entryPoint = `/${bpmnFileName}#${startNodeId}`;
+      const [refreshError, refreshResult] = await catchError(import("./index-w0z4s69j.js").then((mod) => mod.resourceRefreshAsync(stagingDir)));
+      if (refreshError) {
+        logger.warn(`Resource refresh threw before debug: ${refreshError.message}. Continuing without generated overwrites.`);
+      } else if (refreshResult.ok) {
+        logger.info(`Resource refresh for debug: imported ${refreshResult.imported}, created ${refreshResult.created}.`);
+        for (const warning of refreshResult.warnings) {
+          logger.warn(warning);
+        }
+      } else {
+        logger.warn(`Resource refresh skipped before debug: ${refreshResult.message}. Continuing.`);
+      }
+      logger.info("Building solution package (all projects)...");
+      uisPath = await buildSolutionPackageFromDir(this.fs, stagingDir);
+      logger.info("Looking for .uipx solution file...");
+      const solutionInfo = await findSolutionFile(this.fs, absoluteProjectPath);
+      const existingSolutionId = solutionInfo?.solutionId;
+      const apiConfig = {
+        baseUrl: config.baseUrl,
+        organizationId: config.organizationId,
+        tenantName: config.tenantName,
+        tenantId: config.tenantId,
+        authToken: config.authToken,
+        organizationUnitId: config.organizationUnitId
+      };
+      const folderInfo = config.userProvidedFolderId !== undefined ? await getFolderInfoById(apiConfig, config.userProvidedFolderId) : await getPersonalFolderInfo(apiConfig);
+      const uploadAndPatch = async () => {
+        const importResult = await uploadOrOverwriteSolution(apiConfig, config.organizationName, uisPath, existingSolutionId, this.fs);
+        const patchedCount = await patchConnectionOverwrites(apiConfig, config.organizationName, importResult.id, solutionDir, folderInfo, this.fs);
+        if (patchedCount > 0) {
+          logger.info(`Patched ${patchedCount} connection overwrite(s) on Studio Web`);
+        }
+        return importResult;
+      };
+      if (options?.uploadOnly) {
+        const importResult = await uploadAndPatch();
+        await updateSolutionFile(this.fs, absoluteProjectPath, importResult.id);
+        const project = importResult.projects.find((candidate) => candidate.name === projectName) ?? importResult.projects[0];
+        const studioWebUrl = buildStudioWebDesignerUrl({
+          baseUrl: apiConfig.baseUrl,
+          organizationName: config.organizationName,
+          projectId: project.id,
+          solutionId: importResult.id
+        });
+        logger.info("Uploaded without starting a debug session — only a chat UI can drive this flow.");
+        callbacks?.onStudioWebUrl?.(studioWebUrl);
+        return {
+          uploadedOnly: true,
+          solutionId: importResult.id,
+          studioWebUrl
+        };
+      }
+      const result = await uploadAndDebugSolution({
+        upload: uploadAndPatch,
+        onSolutionId: (id) => updateSolutionFile(this.fs, absoluteProjectPath, id),
+        projectName,
+        entryPoint,
+        projectType: "Flow",
+        apiConfig,
+        organizationName: config.organizationName,
+        callbacks,
+        pollInterval,
+        maxPolls: options?.maxPolls ?? 300,
+        beginSessionPayload: options?.inputs ? JSON.stringify(options.inputs) : undefined,
+        folder: { key: folderInfo.key, id: folderInfo.id },
+        requireDebugPreparation: true,
+        inlineAgents,
+        buildSolutionProjects: (uploadedProjects, solutionId) => this.buildSolutionProjectDescriptors(uploadedProjects, solutionId, stagingDir, projectName, entryPoint)
+      });
+      const outputs = await fetchOutputVariables(apiConfig, result.instanceId, result.finalStatus);
+      return { ...result, folderKey: folderInfo.key, ...outputs };
+    } finally {
+      const [cleanupErr] = await catchError((async () => {
+        if (uisPath)
+          await this.fs.rm(uisPath);
+        await this.fs.rm(stagingDir, { recursive: true });
+      })());
+      if (cleanupErr) {
+        logger.warn(`Cleanup failed: ${cleanupErr.message}`);
+      }
+    }
+  }
+  async executeViaStudioWeb(filePath, config, callbacks, pollInterval, options) {
+    const inputs = options?.inputs;
+    const dotIndex = filePath.lastIndexOf(".");
+    const ext = dotIndex >= 0 ? filePath.slice(dotIndex).toLowerCase() : "";
+    if (ext !== ".flow" && ext !== ".bpmn") {
+      throw new Error(`Unsupported file type "${ext}". Only .flow and .bpmn files are supported.`);
+    }
+    let bpmnXml;
+    let projectDir;
+    let projectName;
+    let entryPointBpmnFile;
+    let startEventId;
+    if (ext === ".flow") {
+      logger.info("Reading .flow file...");
+      const absolutePath = this.fs.path.resolve(filePath);
+      if (!await this.fs.exists(absolutePath)) {
+        throw new Error(`File not found: ${absolutePath}`);
+      }
+      const { workflow: flowData } = await readFlowWorkflow(absolutePath);
+      if (inputs && flowData.variables?.globals) {
+        for (const variable of flowData.variables.globals) {
+          if (Object.hasOwn(inputs, variable.id)) {
+            variable.defaultValue = inputs[variable.id];
+          }
+        }
+      }
+      const flowFileContent = JSON.stringify(inMemoryWorkflowToFileFormat(flowData), null, 2);
+      logger.info("Converting .flow to BPMN...");
+      bpmnXml = await this.convertToBpmn(flowData, this.fs.path.dirname(absolutePath));
+      startEventId = extractStartEventId(bpmnXml);
+      logger.info("Generating project files...");
+      projectDir = await this.generateProjectFiles(flowData, bpmnXml, flowFileContent, startEventId);
+      projectName = flowData.name.replace(/[^a-zA-Z0-9_-]/g, "_");
+      entryPointBpmnFile = `${projectName}.bpmn`;
+    } else {
+      bpmnXml = await this.readBpmnFile(filePath);
+      startEventId = extractStartEventId(bpmnXml);
+      projectName = this.fs.path.basename(filePath, ".bpmn");
+      const safeName = projectName.replace(/[^a-zA-Z0-9_-]/g, "_");
+      projectDir = this.fs.path.join(this.fs.env.tmpdir(), `.flow-debug-${safeName}-${Date.now()}`);
+      const safeMkdir = async (dir) => {
+        const [err] = await catchError(this.fs.mkdir(dir));
+        if (err && err.code !== "EEXIST") {
+          throw err;
+        }
+      };
+      await safeMkdir(projectDir);
+      const bpmnFileName = `${safeName}.bpmn`;
+      const projectUiproj = {
+        Name: projectName,
+        ProjectType: "Flow"
+      };
+      await this.fs.writeFile(this.fs.path.join(projectDir, "project.uiproj"), JSON.stringify(projectUiproj, null, 2));
+      const packagingNodes = [
+        {
+          id: startEventId,
+          type: "core.trigger.manual",
+          typeVersion: "1.0",
+          display: { label: "Manual trigger" },
+          inputs: {
+            entryPointId: crypto.randomUUID()
+          }
+        }
+      ];
+      await writePackagingArtifacts(this.fs, projectDir, crypto.randomUUID(), packagingNodes, [], {}, bpmnFileName, startEventId);
+      await this.fs.writeFile(this.fs.path.join(projectDir, `${safeName}.bpmn`), bpmnXml);
+      projectName = safeName;
+      entryPointBpmnFile = `${safeName}.bpmn`;
+    }
+    logger.info("Building solution package...");
+    const uisPath = await this.buildSolutionPackage(projectDir, projectName);
+    const apiConfig = {
+      baseUrl: config.baseUrl,
+      organizationId: config.organizationId,
+      tenantName: config.tenantName,
+      tenantId: config.tenantId,
+      authToken: config.authToken,
+      organizationUnitId: config.organizationUnitId
+    };
+    const entryPoint = `/${entryPointBpmnFile}#${startEventId}`;
+    const result = await uploadAndDebugSolution({
+      upload: () => uploadOrOverwriteSolution(apiConfig, config.organizationName, uisPath, undefined, this.fs),
+      projectName,
+      entryPoint,
+      projectType: "Flow",
+      apiConfig,
+      organizationName: config.organizationName,
+      callbacks,
+      pollInterval,
+      maxPolls: options?.maxPolls ?? 300,
+      beginSessionPayload: inputs ? JSON.stringify(inputs) : undefined
+    });
+    const outputs = await fetchOutputVariables(apiConfig, result.instanceId, result.finalStatus);
+    return { ...result, ...outputs };
+  }
+}
+async function fetchOutputVariables(apiConfig, instanceId, finalStatus) {
+  logger.info("Fetching output variables...");
+  const [error, variables] = await catchError(fetchDebugInstanceVariables(apiConfig, instanceId, isSuccessfulDebugStatus(finalStatus) ? undefined : { delays: [] }));
+  if (!error) {
+    return { variables };
+  }
+  if (error instanceof DebugVariablesFetchFailedError) {
+    logger.warn(`Could not fetch output variables after ${error.details.attempts} attempt(s): ${error.details.message}. ` + "The run completed; its outputs are unknown, not empty.");
+    return { variablesError: error.details };
+  }
+  logger.warn(`Could not fetch output variables: ${error.message}`);
+  return {
+    variablesError: {
+      message: error.message,
+      attempts: 1,
+      traceIds: [],
+      endpoint: `/api/v1/debug-instances/${encodeURIComponent(instanceId)}/variables`
+    }
+  };
+}
+export {
+  FLOW_DEBUG_INBOUND_VOICE_MESSAGE,
+  FLOW_DEBUG_MISSING_SOLUTION_INSTRUCTIONS,
+  FLOW_DEBUG_MISSING_SOLUTION_MESSAGE,
+  FLOW_DEBUG_UNREGISTERED_PROJECT_MESSAGE,
+  FlowDebugService,
+  InboundVoiceDebugError,
+  MissingSolutionWrapperError,
+  UnregisteredProjectError,
+  assertNotInboundVoiceFlow,
+  buildFlowDebugInboundVoiceInstructions,
+  buildFlowDebugUnregisteredProjectInstructions
+};
+
+//# debugId=FB99027EA78A585E64756E2164756E21