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

package/dist/packager-tool-v9rrz038.js

@@ -0,0 +1,602 @@
+import {
+  MaestroHttpError,
+  automationSolutionsGet,
+  debugPimsGet,
+  debugPimsPost,
+  orchestratorGet,
+  orchestratorPost,
+  studioWebPost
+} from "./packager-tool-fjaa8d3v.js";
+import {
+  RESULTS,
+  catchError,
+  logger
+} from "./packager-tool-5qaxht3k.js";
+
+// ../maestro-sdk/src/debug-service.ts
+import { randomUUID } from "node:crypto";
+var AGENT_TARGET_RUNTIME = "pythonAgent";
+
+class FpsPropertiesInjectionError extends Error {
+  fpsProperties;
+  agentCount;
+  cause;
+  constructor(fpsProperties, agentCount, cause) {
+    super(`Cannot inject ${agentCount} inline agent(s): FpsProperties is not valid JSON.`);
+    this.fpsProperties = fpsProperties;
+    this.agentCount = agentCount;
+    this.name = "FpsPropertiesInjectionError";
+    this.cause = cause;
+  }
+}
+function injectInlineAgentProcessEntries(fpsProperties, inlineAgents, flowProjectId) {
+  if (!inlineAgents || inlineAgents.length === 0)
+    return fpsProperties;
+  const entries = inlineAgents.map((agent) => ({
+    name: agent.name,
+    projectType: "Agent",
+    isConversational: agent.isConversational,
+    entryPointPath: agent.entryPointPath,
+    targetRuntime: AGENT_TARGET_RUNTIME,
+    targetFramework: "Portable",
+    requiresUserInteraction: false,
+    executorInfo: JSON.stringify({
+      projectId: agent.hostProjectId ?? flowProjectId ?? agent.agentProjectId,
+      command: "debug",
+      args: ["--attach=none"],
+      entryPoint: agent.entryPointPath
+    })
+  }));
+  return appendProcessEntries(fpsProperties, entries, inlineAgents.length);
+}
+function injectSolutionProjectProcessEntries(fpsProperties, solutionProjects) {
+  if (!solutionProjects || solutionProjects.length === 0) {
+    return fpsProperties;
+  }
+  const entries = solutionProjects.map((project) => ({
+    name: project.name,
+    projectType: project.projectType,
+    executorInfo: JSON.stringify({
+      projectId: project.projectId,
+      debugArgs: {
+        debugMode: project.debugMode ?? DEBUG_MODE_MAP.Default,
+        studioWebProjectId: project.projectId,
+        processType: project.projectType,
+        solutionId: project.solutionId,
+        entryPoint: project.entryPoint
+      }
+    })
+  }));
+  return appendProcessEntries(fpsProperties, entries, solutionProjects.length);
+}
+function appendProcessEntries(fpsProperties, entries, entryCount) {
+  try {
+    const outer = fpsProperties ? JSON.parse(fpsProperties) : {};
+    const masterRaw = outer["debug.master"];
+    const master = typeof masterRaw === "string" ? JSON.parse(masterRaw) : masterRaw ?? {};
+    const existing = Array.isArray(master.processes) ? master.processes : [];
+    master.processes = [...existing, ...entries];
+    outer["debug.master"] = JSON.stringify(master);
+    if (!("debug.source" in outer)) {
+      outer["debug.source"] = "studioweb";
+    }
+    return JSON.stringify(outer);
+  } catch (err) {
+    throw new FpsPropertiesInjectionError(fpsProperties ?? "", entryCount, err);
+  }
+}
+function extractStartEventId(bpmnXml) {
+  const match = bpmnXml.match(/<bpmn:startEvent\s+id="([^"]+)"/);
+  return match?.[1] ?? "start";
+}
+async function getPersonalFolderKey(config) {
+  const result = await orchestratorGet(config, "/api/Folders/GetAllForCurrentUser", "get-personal-folder");
+  const personal = result.PageItems?.find((f) => f.FolderType === "Personal");
+  if (!personal) {
+    throw new Error("No personal workspace folder found. Ensure your account has a personal workspace.");
+  }
+  return { key: personal.Key, id: personal.Id };
+}
+async function getPersonalFolderInfo(config) {
+  const result = await orchestratorGet(config, "/api/Folders/GetAllForCurrentUser", "get-personal-folder");
+  const personal = result.PageItems?.find((f) => f.FolderType === "Personal");
+  if (!personal) {
+    throw new Error("No personal workspace folder found. Ensure your account has a personal workspace.");
+  }
+  return {
+    key: personal.Key,
+    id: personal.Id,
+    displayName: personal.DisplayName,
+    fullyQualifiedName: personal.FullyQualifiedName,
+    parentKey: personal.ParentKey
+  };
+}
+var PROJECT_DEBUG_TIMEOUT_MS = 2 * 60 * 1000;
+var PROJECT_DEBUG_POLL_INTERVAL_MS = 1000;
+var TERMINAL_PROJECT_DEBUG_STATUSES = new Set([
+  "creationsucceeded",
+  "creationfailed",
+  "validationfailed"
+]);
+var delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+async function waitForProjectProvisioning(config, solutionId, sessionId, timeoutMs, pollIntervalMs) {
+  const deadline = Date.now() + timeoutMs;
+  const path = `/api/v1/solutions/${encodeURIComponent(solutionId)}/projects/debug/status` + `?debugSessionId=${encodeURIComponent(sessionId)}`;
+  while (Date.now() < deadline) {
+    const remainingMs = deadline - Date.now();
+    if (remainingMs <= 0)
+      break;
+    const [pollError, info] = await catchError(automationSolutionsGet(config, path, "poll-project-debug-status", AbortSignal.timeout(remainingMs)));
+    if (pollError) {
+      if (Date.now() >= deadline)
+        break;
+      throw pollError;
+    }
+    const status = info.status?.toLowerCase();
+    logger.debug(`Project debug provisioning status: ${info.status ?? "unknown"}`);
+    if (status && TERMINAL_PROJECT_DEBUG_STATUSES.has(status)) {
+      if (status !== "creationsucceeded") {
+        throw new Error(`Studio Web resource provisioning failed with status ${info.status ?? "unknown"}` + (info.errors?.length ? ` (${JSON.stringify(info.errors)})` : "."));
+      }
+      logger.info(`Studio Web resources provisioned${info.folderFullyQualifiedName ? ` in ${info.folderFullyQualifiedName}` : ""}`);
+      return;
+    }
+    const remainingAfterPollMs = deadline - Date.now();
+    if (remainingAfterPollMs <= 0)
+      break;
+    await delay(Math.min(pollIntervalMs, remainingAfterPollMs));
+  }
+  throw new Error(`Timed out waiting for Studio Web resource provisioning after ${timeoutMs}ms.`);
+}
+async function prepareForCustomDebug(params) {
+  const sessionId = params.sessionId ?? randomUUID();
+  const query = new URLSearchParams({
+    sessionId,
+    solutionName: params.solutionName,
+    debugSessionId: sessionId,
+    solutionRootFolderName: params.solutionName,
+    installationFolderKey: params.folderKey,
+    forceProvisioning: "false"
+  });
+  const tenantIdHeader = params.config.tenantId ? { "X-UIPATH-TenantId": params.config.tenantId } : {};
+  const result = await studioWebPost(params.config, params.config.organizationName, `/resourcebuilder/solutions/${encodeURIComponent(params.solutionId)}/projects/${encodeURIComponent(params.projectId)}/debug?${query.toString()}`, new FormData, tenantIdHeader, "prepare-custom-debug");
+  let complete = result.complete;
+  if (complete === false) {
+    await waitForProjectProvisioning(params.config, params.solutionId, sessionId, params.provisioningTimeoutMs ?? PROJECT_DEBUG_TIMEOUT_MS, params.provisioningPollIntervalMs ?? PROJECT_DEBUG_POLL_INTERVAL_MS);
+    complete = true;
+  }
+  const hasDebugIds = typeof result.projectDebugId === "string" && typeof result.solutionDebugId === "string";
+  if (!hasDebugIds && complete !== true) {
+    throw new Error("Studio Web prepare custom debug response did not include projectDebugId and solutionDebugId.");
+  }
+  return {
+    projectDebugId: result.projectDebugId ?? params.projectId,
+    solutionDebugId: result.solutionDebugId ?? params.solutionId
+  };
+}
+async function getFolderInfoById(config, folderId) {
+  const result = await orchestratorGet(config, `/odata/Folders(${folderId})`, "get-folder-by-id");
+  return {
+    key: result.Key,
+    id: result.Id,
+    displayName: result.DisplayName,
+    fullyQualifiedName: result.FullyQualifiedName,
+    parentKey: result.ParentKey
+  };
+}
+async function beginDebugSession(config, inputArguments = "{}", options) {
+  const fpsProperties = injectSolutionProjectProcessEntries(injectInlineAgentProcessEntries(options?.fpsProperties, options?.inlineAgents, options?.flowProjectId), options?.solutionProjects);
+  const body = {
+    JobsCount: 1,
+    JobPriority: null,
+    SpecificPriorityValue: null,
+    Strategy: "ModernJobsCount",
+    AutopilotForRobots: {},
+    ResumeOnSameContext: false,
+    RunAsMe: false,
+    RuntimeType: "Flow",
+    Source: "StudioWeb",
+    InputArguments: inputArguments,
+    ...fpsProperties ? { FpsProperties: fpsProperties } : {}
+  };
+  const result = await orchestratorPost(config, "/api/robotdebug/BeginSession", body, "begin-debug-session");
+  if (!result.jobKey) {
+    throw new Error("BeginSession returned success but no jobKey was provided");
+  }
+  return result;
+}
+var DEBUG_MODE_MAP = {
+  None: 0,
+  Default: 1,
+  StepByStep: 2,
+  SingleStep: 3
+};
+var SIMULATION_MODE_MAP = {
+  None: 0,
+  All: 1,
+  Selective: 2
+};
+var CREATE_DEBUG_INSTANCE_RETRY_DELAYS_MS = [2000, 5000];
+var CREATE_DEBUG_INSTANCE_RETRYABLE_STATUSES = new Set([500, 503]);
+async function createDebugInstance(config, jobKey, solutionId, studioWebProjectId, entryPoint, processType = "Flow", debugMode = "Default", simulationMode = "None") {
+  const body = {
+    jobKey,
+    debugArgs: {
+      breakPoints: [],
+      debugMode: DEBUG_MODE_MAP[debugMode],
+      entryPoint,
+      processType,
+      simulationMode: SIMULATION_MODE_MAP[simulationMode],
+      solutionId,
+      studioWebProjectId,
+      variables: {}
+    }
+  };
+  const totalAttempts = CREATE_DEBUG_INSTANCE_RETRY_DELAYS_MS.length + 1;
+  const traceIds = [];
+  let lastError;
+  for (let attempt = 1;attempt <= totalAttempts; attempt++) {
+    const [error, result] = await catchError(debugPimsPost(config, "/api/v1/debug-instances", body, "create-debug-instance"));
+    if (!error) {
+      if (!result.instanceId) {
+        throw new Error(`debug-instances API returned no instanceId: ${JSON.stringify(result)}`);
+      }
+      return result;
+    }
+    if (!(error instanceof MaestroHttpError) || !CREATE_DEBUG_INSTANCE_RETRYABLE_STATUSES.has(error.httpStatus)) {
+      if (attempt > 1 && error instanceof MaestroHttpError) {
+        if (error.parsedTraceId) {
+          traceIds.push(error.parsedTraceId);
+        }
+        throw error.recordAttempts(attempt, traceIds);
+      }
+      throw error;
+    }
+    lastError = error;
+    if (error.parsedTraceId) {
+      traceIds.push(error.parsedTraceId);
+    }
+    const retryDelay = CREATE_DEBUG_INSTANCE_RETRY_DELAYS_MS[attempt - 1];
+    if (retryDelay === undefined) {
+      break;
+    }
+    logger.warn(`create-debug-instance returned HTTP ${error.httpStatus} (attempt ${attempt}/${totalAttempts}); retrying in ${retryDelay / 1000}s.`);
+    await delay(retryDelay);
+  }
+  if (!lastError) {
+    throw new Error("create-debug-instance failed without an error.");
+  }
+  throw lastError.recordAttempts(totalAttempts, traceIds);
+}
+var PIMS_TERMINAL_STATUSES = [
+  "Completed",
+  "Faulted",
+  "Cancelled",
+  "Failed"
+];
+var ORCHESTRATOR_TERMINAL_STATUSES = [
+  "Successful",
+  "Faulted",
+  "Stopped",
+  "Suspended"
+];
+var SUCCESS_DEBUG_STATUSES = new Set([
+  "Completed",
+  "Successful"
+]);
+var FAULTED_DEBUG_STATUSES = new Set([...PIMS_TERMINAL_STATUSES, ...ORCHESTRATOR_TERMINAL_STATUSES].filter((status) => !SUCCESS_DEBUG_STATUSES.has(status)));
+
+class DebugPollTimeoutError extends Error {
+  instanceId;
+  jobKey;
+  lastStatus;
+  timeoutSeconds;
+  constructor(details) {
+    super(`Debug polling timed out after ${details.timeoutSeconds}s — instance ${details.instanceId} was still "${details.lastStatus}" (not a terminal status)`);
+    this.name = "DebugPollTimeoutError";
+    this.instanceId = details.instanceId;
+    this.jobKey = details.jobKey;
+    this.lastStatus = details.lastStatus;
+    this.timeoutSeconds = details.timeoutSeconds;
+  }
+}
+function buildPollTimeoutFailureOutput(err, inspectCommand) {
+  const inspect = inspectCommand ? `Check it with '${inspectCommand} ${err.instanceId}', or re-run` : "Re-run";
+  return {
+    Result: RESULTS.Failure,
+    ErrorCode: "timeout",
+    Message: err.message,
+    Instructions: "The run was still going when the CLI stopped waiting — it is not " + `known to have failed. ${inspect} with a longer '--timeout' (seconds).`,
+    Retry: "RetryLater",
+    Context: { stage: "poll-instance-status" },
+    Data: {
+      instanceId: err.instanceId,
+      jobKey: err.jobKey,
+      lastStatus: err.lastStatus,
+      timeoutSeconds: err.timeoutSeconds
+    }
+  };
+}
+async function pollDebugInstanceStatus(config, instanceId, callbacks, pollInterval = 2000, maxPolls = 300, jobKey) {
+  let pollCount = 0;
+  let lastStatus = "";
+  while (pollCount < maxPolls) {
+    const status = await debugPimsGet(config, `/api/v1/debug-instances/${instanceId}/element-executions`, "poll-instance-status");
+    if (status.status !== lastStatus) {
+      lastStatus = status.status;
+      const elementExecutions = status.elementExecutions.map((e) => ({
+        elementId: e.elementId,
+        elementType: e.elementType,
+        status: e.status,
+        startedAt: e.startedTimeUtc,
+        completedAt: e.completedTimeUtc || undefined
+      }));
+      callbacks?.onStatusChange?.(status.status, elementExecutions);
+    } else if (pollCount % 5 === 0) {
+      const elapsed = (pollCount + 1) * pollInterval / 1000;
+      logger.info(`Still polling... status: ${lastStatus} (${elapsed}s elapsed)`);
+    }
+    if (PIMS_TERMINAL_STATUSES.includes(status.status)) {
+      logger.info(`Debug session reached terminal status: ${status.status}`);
+      return status;
+    }
+    if (jobKey && pollCount > 0 && pollCount % 5 === 0) {
+      const [, jobResponse] = await catchError(orchestratorGet(config, `/odata/Jobs?$filter=Key eq '${jobKey}'&$top=1`, "check-orchestrator-job-status"));
+      const jobState = jobResponse?.value?.[0]?.State;
+      if (jobState && ORCHESTRATOR_TERMINAL_STATUSES.includes(jobState)) {
+        const jobInfo = jobResponse?.value?.[0]?.Info ?? "";
+        logger.info(`Orchestrator job reached terminal status: ${jobState}${jobInfo ? ` — ${jobInfo}` : ""}`);
+        return { ...status, status: jobState };
+      }
+    }
+    await new Promise((resolve) => setTimeout(resolve, pollInterval));
+    pollCount++;
+  }
+  throw new DebugPollTimeoutError({
+    instanceId,
+    ...jobKey === undefined ? {} : { jobKey },
+    lastStatus: lastStatus || "unknown",
+    timeoutSeconds: maxPolls * pollInterval / 1000
+  });
+}
+async function fetchDebugInstanceIncidents(config, instanceId) {
+  const result = await debugPimsGet(config, `/api/v1/debug-instances/${instanceId}/incidents`, "get-debug-instance-incidents");
+  return result ?? [];
+}
+var FETCH_VARIABLES_RETRY_DELAYS_MS = [2000, 4000];
+var FETCH_VARIABLES_ATTEMPT_TIMEOUT_MS = 8000;
+
+class DebugVariablesFetchFailedError extends Error {
+  details;
+  constructor(details) {
+    super(`Could not fetch output variables after ${details.attempts} attempt(s): ${details.message}`);
+    this.details = details;
+    this.name = "DebugVariablesFetchFailedError";
+  }
+}
+async function fetchDebugInstanceVariables(config, instanceId, options) {
+  const endpoint = `/api/v1/debug-instances/${encodeURIComponent(instanceId)}/variables`;
+  const delays = options?.delays ?? FETCH_VARIABLES_RETRY_DELAYS_MS;
+  const attemptTimeoutMs = options?.attemptTimeoutMs ?? FETCH_VARIABLES_ATTEMPT_TIMEOUT_MS;
+  const totalAttempts = delays.length + 1;
+  const traceIds = [];
+  let lastMessage = "";
+  let lastStatus;
+  for (let attempt = 1;attempt <= totalAttempts; attempt++) {
+    const controller = new AbortController;
+    const timer = setTimeout(() => controller.abort(), attemptTimeoutMs);
+    const [error, result] = await catchError(debugPimsGet(config, endpoint, "fetch-output-variables", { signal: controller.signal }));
+    clearTimeout(timer);
+    if (!error) {
+      return result;
+    }
+    if (controller.signal.aborted) {
+      lastMessage = `timed out after ${attemptTimeoutMs / 1000}s`;
+      lastStatus = undefined;
+    } else if (error instanceof MaestroHttpError) {
+      lastMessage = error.message;
+      lastStatus = error.httpStatus;
+      if (error.parsedTraceId) {
+        traceIds.push(error.parsedTraceId);
+      }
+    } else {
+      lastMessage = error.message;
+      lastStatus = undefined;
+    }
+    const retryDelay = delays[attempt - 1];
+    if (retryDelay === undefined) {
+      break;
+    }
+    logger.warn(`fetch-output-variables failed (attempt ${attempt}/${totalAttempts}): ${lastMessage}; retrying in ${retryDelay / 1000}s.`);
+    await delay(retryDelay);
+  }
+  throw new DebugVariablesFetchFailedError({
+    message: lastMessage,
+    ...lastStatus === undefined ? {} : { httpStatus: lastStatus },
+    attempts: totalAttempts,
+    traceIds,
+    endpoint
+  });
+}
+function isFaultedDebugStatus(status) {
+  return FAULTED_DEBUG_STATUSES.has(status);
+}
+function isSuccessfulDebugStatus(status) {
+  return SUCCESS_DEBUG_STATUSES.has(status);
+}
+async function resolveFaultIncidents(config, instanceId, status) {
+  if (!isFaultedDebugStatus(status)) {
+    return;
+  }
+  const [incidentError, fetched] = await catchError(fetchDebugInstanceIncidents(config, instanceId));
+  if (incidentError) {
+    logger.warn(`Could not fetch debug incidents: ${incidentError.message}`);
+    return;
+  }
+  if (fetched.length === 0) {
+    return;
+  }
+  const first = fetched[0];
+  logger.warn(`Debug session faulted with ${fetched.length} incident(s). ` + `First: [${first.errorCode ?? "no-code"}] ${first.errorMessage}` + (first.elementId ? ` (element ${first.elementId})` : ""));
+  return fetched;
+}
+function buildStudioWebDesignerUrl(params) {
+  return `${params.baseUrl}/${encodeURIComponent(params.organizationName)}` + `/studio_/designer/${encodeURIComponent(params.projectId)}` + `?solutionId=${encodeURIComponent(params.solutionId)}`;
+}
+async function uploadAndDebugSolution(params) {
+  const { apiConfig } = params;
+  logger.info("Uploading solution to Studio Web...");
+  const importResult = await params.upload();
+  const solutionId = importResult.id;
+  if (params.onSolutionId) {
+    await params.onSolutionId(solutionId);
+  }
+  const matchedProject = importResult.projects.find((p) => p.name === params.projectName);
+  const studioWebProjectId = (matchedProject ?? importResult.projects[0]).id;
+  const studioWebUrl = buildStudioWebDesignerUrl({
+    baseUrl: apiConfig.baseUrl,
+    organizationName: params.organizationName,
+    projectId: studioWebProjectId,
+    solutionId
+  });
+  logger.info(`Solution uploaded — solutionId: ${solutionId}, projectId: ${studioWebProjectId}`);
+  logger.info(`Studio Web URL: ${studioWebUrl}`);
+  params.callbacks?.onStudioWebUrl?.(studioWebUrl);
+  const folder = params.folder ?? await getPersonalFolderKey(apiConfig);
+  apiConfig.folderKey = folder.key;
+  apiConfig.organizationUnitId = folder.id;
+  logger.info(`Personal folder — key: ${folder.key}, id: ${folder.id}`);
+  const solutionProjects = params.buildSolutionProjects ? await params.buildSolutionProjects(importResult.projects, solutionId) : undefined;
+  if (solutionProjects && solutionProjects.length > 0) {
+    logger.info(`Registering ${solutionProjects.length} solution project(s) for debug: ${solutionProjects.map((p) => p.name).join(", ")}`);
+  }
+  const inlineAgents = params.inlineAgents?.map((agent) => {
+    if (!agent.hostProjectName)
+      return agent;
+    const hostProject = importResult.projects.find((project) => project.name === agent.hostProjectName);
+    if (!hostProject) {
+      throw new Error(`Could not match inline agent "${agent.name}" to uploaded host Flow "${agent.hostProjectName}".`);
+    }
+    return { ...agent, hostProjectId: hostProject.id };
+  });
+  let debugSolutionId = solutionId;
+  let debugProjectId = studioWebProjectId;
+  if (apiConfig.tenantId) {
+    const studioWebConfig = {
+      baseUrl: apiConfig.baseUrl,
+      organizationId: apiConfig.organizationId,
+      tenantId: apiConfig.tenantId,
+      tenantName: apiConfig.tenantName,
+      authToken: apiConfig.authToken,
+      organizationUnitId: apiConfig.organizationUnitId,
+      organizationName: params.organizationName
+    };
+    const [prepErr, prepIds] = await catchError(prepareForCustomDebug({
+      config: studioWebConfig,
+      solutionId,
+      projectId: studioWebProjectId,
+      solutionName: params.solutionName ?? params.projectName,
+      folderKey: folder.key
+    }));
+    if (prepErr) {
+      if (params.requireDebugPreparation)
+        throw prepErr;
+      logger.warn(`prepareForCustomDebug failed (${prepErr.message}) — continuing with original solution/project IDs. ` + "Sub-jobs (api-workflow / agent / process orchestration) may fault with a missing debugSessionId.");
+    } else {
+      debugSolutionId = prepIds.solutionDebugId;
+      debugProjectId = prepIds.projectDebugId;
+      logger.info(`Studio Web debug provisioned — solutionDebugId: ${debugSolutionId}, projectDebugId: ${debugProjectId}`);
+    }
+  } else {
+    if (params.requireDebugPreparation) {
+      throw new Error("Cannot prepare Studio Web debug because apiConfig.tenantId is not set.");
+    }
+    logger.warn("Skipping prepareForCustomDebug — apiConfig.tenantId is not set. " + "Sub-jobs (api-workflow / agent / process orchestration) may fault with a missing debugSessionId.");
+  }
+  logger.info("Beginning debug session in Orchestrator...");
+  const session = await beginDebugSession(apiConfig, params.beginSessionPayload, {
+    inlineAgents,
+    flowProjectId: studioWebProjectId,
+    ...solutionProjects ? { solutionProjects } : {}
+  });
+  logger.info(`Debug session started — jobKey: ${session.jobKey}`);
+  logger.info("Creating debug instance in PIMS...");
+  const debugInstance = await createDebugInstance(apiConfig, session.jobKey, debugSolutionId, debugProjectId, params.entryPoint, params.projectType);
+  logger.info(`Debug instance created — instanceId: ${debugInstance.instanceId}`);
+  logger.info("Polling for completion...");
+  const finalResponse = await pollDebugInstanceStatus(apiConfig, debugInstance.instanceId, params.callbacks, params.pollInterval, params.maxPolls, session.jobKey);
+  const incidents = await resolveFaultIncidents(apiConfig, debugInstance.instanceId, finalResponse.status);
+  return {
+    jobKey: session.jobKey,
+    instanceId: debugInstance.instanceId,
+    runId: debugInstance.runId,
+    finalStatus: finalResponse.status,
+    elementExecutions: finalResponse.elementExecutions.map((e) => ({
+      elementId: e.elementId,
+      elementType: e.elementType,
+      status: e.status,
+      startedAt: e.startedTimeUtc,
+      completedAt: e.completedTimeUtc || undefined
+    })),
+    solutionId,
+    projectId: studioWebProjectId,
+    studioWebUrl,
+    incidents
+  };
+}
+async function patchConnectionOverwrites(config, organizationName, solutionId, solutionDir, folder, fs) {
+  const connectionsDir = fs.path.join(solutionDir, "resources", "solution_folder", "connection");
+  if (!await fs.exists(connectionsDir)) {
+    return 0;
+  }
+  const connectorDirs = await fs.readdir(connectionsDir);
+  const connectionResources = (await Promise.all(connectorDirs.map(async (connectorDir) => {
+    const connectorPath = fs.path.join(connectionsDir, connectorDir);
+    const stat = await fs.stat(connectorPath);
+    if (!stat.isDirectory())
+      return [];
+    const files = await fs.readdir(connectorPath);
+    const results = await Promise.all(files.filter((file) => file.endsWith(".json")).map(async (file) => {
+      const filePath = fs.path.join(connectorPath, file);
+      const [readErr, content] = await catchError(fs.readFile(filePath, "utf-8"));
+      if (readErr || !content)
+        return;
+      const [parseErr, parsed] = catchError(() => JSON.parse(content));
+      if (parseErr || parsed.resource?.kind !== "connection")
+        return;
+      return parsed;
+    }));
+    return results.filter((r) => r !== undefined);
+  }))).flat();
+  if (connectionResources.length === 0) {
+    return 0;
+  }
+  const tenantIdHeader = config.tenantId ? { "x-uipath-tenantid": config.tenantId } : {};
+  const folderPath = folder.parentKey ? `${folder.parentKey}.${folder.key}` : folder.key;
+  const folderPayload = {
+    fullyQualifiedName: folder.fullyQualifiedName || folder.displayName,
+    path: folderPath,
+    folderKey: folder.key
+  };
+  const apiPath = `/resourcebuilder/solutions/${solutionId}/resources/reference?api-version=2&forceUpdate=true`;
+  const validResources = connectionResources.filter((cr) => cr.resource.key && cr.resource.type);
+  let successCount = 0;
+  for (const cr of validResources) {
+    const [err] = await catchError(studioWebPost(config, organizationName, apiPath, {
+      kind: "connection",
+      type: cr.resource.type,
+      key: cr.resource.key,
+      folder: folderPayload
+    }, tenantIdHeader, "register-connection-resource"));
+    if (err) {
+      logger.warn(`Could not register connection resource ${cr.resource.key}: ${err.message}`);
+      continue;
+    }
+    successCount++;
+  }
+  return successCount;
+}
+
+export { FpsPropertiesInjectionError, injectInlineAgentProcessEntries, injectSolutionProjectProcessEntries, extractStartEventId, getPersonalFolderKey, getPersonalFolderInfo, prepareForCustomDebug, getFolderInfoById, beginDebugSession, DEBUG_MODE_MAP, SIMULATION_MODE_MAP, createDebugInstance, DebugPollTimeoutError, buildPollTimeoutFailureOutput, pollDebugInstanceStatus, fetchDebugInstanceIncidents, DebugVariablesFetchFailedError, fetchDebugInstanceVariables, isFaultedDebugStatus, isSuccessfulDebugStatus, resolveFaultIncidents, buildStudioWebDesignerUrl, uploadAndDebugSolution, patchConnectionOverwrites };
+
+//# debugId=50B9C8A084F4991B64756E2164756E21