@uipath/flow-tool 1.201.0-preview.133 → 1.202.0-preview.134

package/dist/{packager-tool-y3dezh8k.js → packager-tool-rs6jm14d.js}

@@ -1,4 +1,4 @@
-// ../../node_modules/@uipath/flow-migrations/dist/chunk-PF22ZHE3.js
+// ../../node_modules/@uipath/flow-migrations/dist/chunk-PLXZTKXD.js
 var createMigration_invalidDownInput_message = "Invalid input for down-migration {{fromVersion}} → {{toVersion}}";
 var createMigration_invalidDownOutput_message = "Invalid output for down-migration {{fromVersion}} → {{toVersion}}";
 var createMigration_invalidInput_message = "Invalid input for migration {{fromVersion}} → {{toVersion}}";
@@ -6,6 +6,7 @@ var createMigration_invalidOutput_message = "Invalid output for migration {{from
 var downgradeWorkflow_missingDown_message = "Downgrade path is missing {{fromVersion}} → {{toVersion}}";
 var downgradeWorkflow_noPath_message = "No downgrade path from {{fromVersion}} to {{toVersion}}";
 var migrate_chain_noMigrationFound_message = "No migration found from version {{current}}. Cannot reach {{toVersion}}.";
+var migrationValidation_deprecatedNode_message = "{{label}} is on version {{currentVersion}}, which is no longer supported. Upgrade to {{latestVersion}} before running this process.";
 var en_default = {
   createMigration_invalidDownInput_message,
   createMigration_invalidDownOutput_message,
@@ -13,9 +14,10 @@ var en_default = {
   createMigration_invalidOutput_message,
   downgradeWorkflow_missingDown_message,
   downgradeWorkflow_noPath_message,
-  migrate_chain_noMigrationFound_message
+  migrate_chain_noMigrationFound_message,
+  migrationValidation_deprecatedNode_message
 };
 
-export { createMigration_invalidDownInput_message, createMigration_invalidDownOutput_message, createMigration_invalidInput_message, createMigration_invalidOutput_message, downgradeWorkflow_missingDown_message, downgradeWorkflow_noPath_message, migrate_chain_noMigrationFound_message, en_default };
+export { createMigration_invalidDownInput_message, createMigration_invalidDownOutput_message, createMigration_invalidInput_message, createMigration_invalidOutput_message, downgradeWorkflow_missingDown_message, downgradeWorkflow_noPath_message, migrate_chain_noMigrationFound_message, migrationValidation_deprecatedNode_message, en_default };
 
-//# debugId=F2DA66301ADBA78364756E2164756E21
+//# debugId=BC7DD8AD7874F44864756E2164756E21

package/dist/{packager-tool-c42dp002.js → packager-tool-s36jpqhd.js}

@@ -1,9 +1,9 @@
 import {
   toolsFactoryRepository
-} from "./packager-tool-7yjpwj92.js";
+} from "./packager-tool-4hx14snw.js";
 import {
   FlowToolFactory
-} from "./packager-tool-gasyxww9.js";
+} from "./packager-tool-1r8c83fc.js";
 
 // src/packager-tool.ts
 function registerPackagerFactories() {

package/dist/packager-tool-s9ff3kk4.js

@@ -0,0 +1,6 @@
+// ../../node_modules/@uipath/flow-expression-model/dist/chunk-EYTLLV4Z.js
+var EXPRESSION_MODEL_NAMESPACE = "expressionModel";
+
+export { EXPRESSION_MODEL_NAMESPACE };
+
+//# debugId=84A1129EBE7188B564756E2164756E21

package/dist/packager-tool-ss7cz4qx.js

@@ -0,0 +1,289 @@
+import {
+  logger
+} from "./packager-tool-226mh80j.js";
+
+// ../maestro-sdk/src/debug-http-client.ts
+function parseBackendErrorBody(body) {
+  if (!body)
+    return {};
+  let parsed;
+  try {
+    parsed = JSON.parse(body);
+  } catch {
+    return {};
+  }
+  if (!parsed || typeof parsed !== "object")
+    return {};
+  const obj = parsed;
+  const result = {};
+  if (typeof obj.message === "string")
+    result.message = obj.message;
+  if (typeof obj.errorCode === "number" || typeof obj.errorCode === "string") {
+    result.errorCode = String(obj.errorCode);
+  }
+  if (typeof obj.traceId === "string")
+    result.traceId = obj.traceId;
+  if (typeof obj.requestId === "string")
+    result.requestId = obj.requestId;
+  return result;
+}
+
+class MaestroHttpError extends Error {
+  service;
+  method;
+  endpoint;
+  url;
+  httpStatus;
+  statusText;
+  body;
+  stage;
+  parsedErrorCode;
+  parsedErrorMessage;
+  parsedTraceId;
+  parsedRequestId;
+  attempts;
+  traceIds;
+  constructor(details) {
+    super(MaestroHttpError.formatMessage(details));
+    this.name = "MaestroHttpError";
+    this.service = details.service;
+    this.method = details.method;
+    this.endpoint = details.endpoint;
+    this.url = details.url;
+    this.httpStatus = details.httpStatus;
+    this.statusText = details.statusText;
+    this.body = details.body;
+    this.stage = details.stage;
+    this.parsedErrorCode = details.parsedErrorCode;
+    this.parsedErrorMessage = details.parsedErrorMessage;
+    this.parsedTraceId = details.parsedTraceId;
+    this.parsedRequestId = details.parsedRequestId;
+    this.attempts = details.attempts;
+    this.traceIds = details.traceIds;
+  }
+  recordAttempts(attempts, traceIds) {
+    this.attempts = attempts;
+    this.traceIds = traceIds;
+    return this;
+  }
+  static formatMessage(d) {
+    const prefix = d.stage ? `Failed during ${d.stage}` : `${d.service} API request failed`;
+    const where = `${d.method} ${d.endpoint}`;
+    const traceSuffix = d.parsedTraceId ? ` (traceId=${d.parsedTraceId})` : "";
+    const messageSuffix = d.parsedErrorMessage ? ` — ${d.parsedErrorMessage}` : "";
+    return `${prefix}: ${d.httpStatus} ${d.statusText} on ${where}${traceSuffix}${messageSuffix}`;
+  }
+}
+async function buildHttpErrorDetails(response, init) {
+  let body = "";
+  try {
+    body = await response.text();
+  } catch {}
+  const parsed = parseBackendErrorBody(body);
+  return {
+    service: init.service,
+    method: init.method,
+    endpoint: init.endpoint,
+    url: init.url,
+    httpStatus: response.status,
+    statusText: response.statusText,
+    body,
+    stage: init.stage,
+    parsedErrorCode: parsed.errorCode,
+    parsedErrorMessage: parsed.message,
+    parsedTraceId: parsed.traceId,
+    parsedRequestId: parsed.requestId
+  };
+}
+function buildCommonHeaders(config, options) {
+  const headers = {
+    Authorization: `Bearer ${config.authToken}`,
+    Accept: "application/json"
+  };
+  if (options?.includeContentType !== false) {
+    headers["Content-Type"] = "application/json";
+  }
+  if (config.organizationUnitId) {
+    headers["X-UIPATH-OrganizationUnitId"] = config.organizationUnitId.toString();
+  }
+  if (config.folderKey) {
+    headers["x-uipath-folderkey"] = config.folderKey;
+  }
+  return headers;
+}
+function buildOrchestratorUrl(config, path) {
+  return `${config.baseUrl}/${config.organizationId}/${config.tenantName}/orchestrator_${path}`;
+}
+function buildPimsUrl(config, path) {
+  return `${config.baseUrl}/${config.organizationId}/${config.tenantId}/pims_${path}`;
+}
+function buildAutomationSolutionsUrl(config, path) {
+  return `${config.baseUrl}/${config.organizationId}/${config.tenantId}/automationsolutions_${path}`;
+}
+async function automationSolutionsGet(config, path, stage, signal) {
+  const url = buildAutomationSolutionsUrl(config, path);
+  const headers = buildCommonHeaders(config, { includeContentType: false });
+  if (config.tenantId) {
+    headers["X-UIPATH-TenantId"] = config.tenantId;
+  }
+  if (typeof process !== "undefined" && process.env?.DEBUG) {
+    logger.info(`DEBUG AUTOMATION SOLUTIONS GET: ${url}`);
+  }
+  const response = await fetch(url, { method: "GET", headers, signal });
+  if (!response.ok) {
+    throw new MaestroHttpError(await buildHttpErrorDetails(response, {
+      service: "automation-solutions",
+      method: "GET",
+      endpoint: path,
+      url,
+      stage
+    }));
+  }
+  return response.json();
+}
+async function orchestratorGet(config, path, stage) {
+  const url = buildOrchestratorUrl(config, path);
+  const headers = buildCommonHeaders(config);
+  if (typeof process !== "undefined" && process.env?.DEBUG) {
+    logger.info(`DEBUG GET: ${url}`);
+  }
+  const response = await fetch(url, { method: "GET", headers });
+  if (!response.ok) {
+    throw new MaestroHttpError(await buildHttpErrorDetails(response, {
+      service: "orchestrator",
+      method: "GET",
+      endpoint: path,
+      url,
+      stage
+    }));
+  }
+  return response.json();
+}
+async function orchestratorPost(config, path, body, stage) {
+  const url = buildOrchestratorUrl(config, path);
+  const headers = buildCommonHeaders(config);
+  if (typeof process !== "undefined" && process.env?.DEBUG) {
+    logger.info(`DEBUG POST: ${url}`);
+  }
+  const response = await fetch(url, {
+    method: "POST",
+    headers,
+    body: JSON.stringify(body)
+  });
+  if (!response.ok) {
+    throw new MaestroHttpError(await buildHttpErrorDetails(response, {
+      service: "orchestrator",
+      method: "POST",
+      endpoint: path,
+      url,
+      stage
+    }));
+  }
+  return response.json();
+}
+async function debugPimsGet(config, path, stage, options) {
+  const url = buildPimsUrl(config, path);
+  const headers = buildCommonHeaders(config, { includeContentType: false });
+  if (typeof process !== "undefined" && process.env?.DEBUG) {
+    logger.info(`DEBUG PIMS GET: ${url}`);
+  }
+  const response = await fetch(url, {
+    method: "GET",
+    headers,
+    ...options?.signal ? { signal: options.signal } : {}
+  });
+  if (!response.ok) {
+    throw new MaestroHttpError(await buildHttpErrorDetails(response, {
+      service: "pims",
+      method: "GET",
+      endpoint: path,
+      url,
+      stage
+    }));
+  }
+  return response.json();
+}
+async function readOptionalJsonResponse(response) {
+  const text = await response.text();
+  return text ? JSON.parse(text) : {};
+}
+async function debugPimsWrite(config, path, body, method, stage) {
+  const url = buildPimsUrl(config, path);
+  const headers = buildCommonHeaders(config);
+  if (typeof process !== "undefined" && process.env?.DEBUG) {
+    logger.info(`DEBUG PIMS ${method}: ${url}`);
+  }
+  const response = await fetch(url, {
+    method,
+    headers,
+    body: JSON.stringify(body)
+  });
+  if (!response.ok) {
+    throw new MaestroHttpError(await buildHttpErrorDetails(response, {
+      service: "pims",
+      method,
+      endpoint: path,
+      url,
+      stage
+    }));
+  }
+  return readOptionalJsonResponse(response);
+}
+async function debugPimsPost(config, path, body, stage) {
+  return debugPimsWrite(config, path, body, "POST", stage);
+}
+async function debugPimsPut(config, path, body, stage) {
+  return debugPimsWrite(config, path, body, "PUT", stage);
+}
+async function debugPimsPatch(config, path, body, stage) {
+  return debugPimsWrite(config, path, body, "PATCH", stage);
+}
+async function studioWebPost(config, organizationName, path, body, extraHeaders, stage) {
+  const url = `${config.baseUrl}/${organizationName}/studio_/backend/api${path}`;
+  const headers = {
+    Authorization: `Bearer ${config.authToken}`,
+    ...extraHeaders
+  };
+  if (typeof process !== "undefined" && process.env?.DEBUG) {
+    logger.info(`DEBUG STUDIO POST: ${url}`);
+  }
+  const isFormData = body instanceof FormData;
+  const response = await fetch(url, {
+    method: "POST",
+    headers: isFormData ? headers : { ...headers, "Content-Type": "application/json" },
+    body: isFormData ? body : JSON.stringify(body)
+  });
+  if (!response.ok) {
+    throw new MaestroHttpError(await buildHttpErrorDetails(response, {
+      service: "studio-web",
+      method: "POST",
+      endpoint: path,
+      url,
+      stage
+    }));
+  }
+  return response.json();
+}
+async function studioWebDelete(config, organizationName, path, stage) {
+  const url = `${config.baseUrl}/${organizationName}/studio_/backend/api${path}`;
+  const headers = {
+    Authorization: `Bearer ${config.authToken}`
+  };
+  if (typeof process !== "undefined" && process.env?.DEBUG) {
+    logger.info(`DEBUG STUDIO DELETE: ${url}`);
+  }
+  const response = await fetch(url, { method: "DELETE", headers });
+  if (!response.ok) {
+    throw new MaestroHttpError(await buildHttpErrorDetails(response, {
+      service: "studio-web",
+      method: "DELETE",
+      endpoint: path,
+      url,
+      stage
+    }));
+  }
+}
+
+export { parseBackendErrorBody, MaestroHttpError, automationSolutionsGet, orchestratorGet, orchestratorPost, debugPimsGet, debugPimsPost, debugPimsPut, debugPimsPatch, studioWebPost, studioWebDelete };
+
+//# debugId=4C72C920A6F1BEF764756E2164756E21

package/dist/packager-tool-tf3d2y8z.js

@@ -0,0 +1,31 @@
+// src/utils/pending-stall.ts
+var PENDING_NORMAL_SECONDS = 60;
+var PENDING_STALLED_SECONDS = 600;
+function pendingSecondsFor(state, creationTime, now = Date.now()) {
+  if (state !== "Pending" || !creationTime) {
+    return;
+  }
+  const created = creationTime instanceof Date ? creationTime : new Date(creationTime);
+  const elapsedMs = now - created.getTime();
+  if (Number.isNaN(elapsedMs) || elapsedMs < 0) {
+    return;
+  }
+  return Math.round(elapsedMs / 1000);
+}
+function pendingStallInstructions(pendingSeconds) {
+  if (pendingSeconds >= PENDING_STALLED_SECONDS) {
+    return `Pending for ${pendingSeconds}s, past the ${PENDING_STALLED_SECONDS}s mark where the Flow runtime counts ` + `as stalled rather than slow. Stop polling this job — more polling will not start it. Check that the ` + `tenant can run Flow processes ('uip or machines list', 'uip maestro flow job list --state Pending' for ` + `a backlog), then escalate with this job key.`;
+  }
+  if (pendingSeconds >= PENDING_NORMAL_SECONDS) {
+    return `Pending for ${pendingSeconds}s. A Flow job normally starts within ${PENDING_NORMAL_SECONDS}s. Keep ` + `polling until ${PENDING_STALLED_SECONDS}s, then treat the runtime as stalled and stop.`;
+  }
+  return `Pending for ${pendingSeconds}s — normal. A Flow job usually starts within ${PENDING_NORMAL_SECONDS}s; ` + `treat it as stalled once it has been Pending for ${PENDING_STALLED_SECONDS}s.`;
+}
+
+// src/utils/wait-for-flow-job-defaults.ts
+var DEFAULT_TIMEOUT_MS = 1800000;
+var DEFAULT_INTERVAL_MS = 5000;
+
+export { PENDING_NORMAL_SECONDS, PENDING_STALLED_SECONDS, pendingSecondsFor, pendingStallInstructions, DEFAULT_TIMEOUT_MS, DEFAULT_INTERVAL_MS };
+
+//# debugId=D37FC2A9077F372264756E2164756E21