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

package/dist/packager-tool-wcha0e5r.js

@@ -0,0 +1,443 @@
+import {
+  parseJsonInputOrFile
+} from "./packager-tool-g9y14b10.js";
+import {
+  JobsApi,
+  ReleasesApi,
+  createOrchestratorConfig,
+  resolveFolder
+} from "./packager-tool-5z1eg3ea.js";
+import {
+  getPersonalFolderKey
+} from "./packager-tool-v9rrz038.js";
+import {
+  ErrorDecision,
+  MIN_INTERVAL_MS,
+  PollOutcome,
+  catchError,
+  logger,
+  pollUntil,
+  processContext
+} from "./packager-tool-5qaxht3k.js";
+
+// src/services/http-client.ts
+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 buildOrchestratorHeaders(config) {
+  return buildCommonHeaders(config);
+}
+function buildOrchestratorUrl(config, path) {
+  return `${config.baseUrl}/${config.organizationId}/${config.tenantName}/orchestrator_${path}`;
+}
+async function orchestratorGet(config, path) {
+  const url = buildOrchestratorUrl(config, path);
+  const headers = buildOrchestratorHeaders(config);
+  if (typeof process !== "undefined" && process.env?.DEBUG) {
+    logger.info(`DEBUG GET: ${url}`);
+  }
+  const response = await fetch(url, {
+    method: "GET",
+    headers
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(`API request failed: ${response.status} ${response.statusText} - ${errorText}`);
+  }
+  return response.json();
+}
+
+// src/services/flow-api.ts
+function escapeODataStringLiteral(value) {
+  return value.replace(/'/g, "''");
+}
+async function resolveFlowFolderId(config) {
+  if (config.folderKey) {
+    const folder = await resolveFolder({ folderKey: config.folderKey }, { tenant: config.tenantName });
+    return folder.id.toString();
+  }
+  const personalFolder = await getPersonalFolderKey({
+    baseUrl: config.baseUrl,
+    organizationId: config.organizationId,
+    tenantName: config.tenantName,
+    tenantId: config.tenantId,
+    authToken: config.authToken
+  });
+  return personalFolder.id.toString();
+}
+async function listFlowProcesses(config, filter) {
+  const folder = await resolveFolder({ folderKey: config.folderKey }, { tenant: config.tenantName });
+  const sdkConfig = await createOrchestratorConfig({
+    folderId: folder.id.toString()
+  });
+  const releasesApi = new ReleasesApi(sdkConfig);
+  const filters = ["ProcessType eq 'Flow'"];
+  if (filter) {
+    filters.push(filter);
+  }
+  const filterQuery = filters.length > 0 ? filters.join(" and ") : undefined;
+  const response = await releasesApi.releasesGet({
+    $filter: filterQuery
+  });
+  return response.value || [];
+}
+async function listFlowJobs(config, options = {}) {
+  const folderId = await resolveFlowFolderId(config);
+  const sdkConfig = await createOrchestratorConfig({
+    folderId
+  });
+  const jobsApi = new JobsApi(sdkConfig);
+  const filters = ["ProcessType eq 'Flow'"];
+  if (options.state) {
+    filters.push(`State eq '${escapeODataStringLiteral(options.state)}'`);
+  }
+  if (options.processName) {
+    filters.push(`contains(ReleaseName, '${escapeODataStringLiteral(options.processName)}')`);
+  }
+  const response = await jobsApi.jobsGet({
+    $filter: filters.join(" and "),
+    $expand: "Release,Machine",
+    $top: options.limit,
+    $skip: options.offset,
+    $orderby: options.orderBy
+  });
+  return response.value || [];
+}
+async function getFlowEntryPoints(config) {
+  const folder = await resolveFolder({ folderKey: config.folderKey }, { tenant: config.tenantName });
+  const apiConfig = {
+    baseUrl: config.baseUrl,
+    organizationId: config.organizationId,
+    tenantName: config.tenantName,
+    authToken: config.authToken,
+    organizationUnitId: folder.id
+  };
+  const feedIdParam = config.feedId ? `?feedId=${config.feedId}` : "";
+  const path = `/odata/Processes/UiPath.Server.Configuration.OData.GetPackageEntryPointsV2(key='${config.processKey}')${feedIdParam}`;
+  const response = await orchestratorGet(apiConfig, path);
+  return response.value;
+}
+async function startFlowJob(config) {
+  const folder = await resolveFolder({ folderKey: config.folderKey }, { tenant: config.tenantName });
+  const sdkConfig = await createOrchestratorConfig({
+    folderId: folder.id.toString()
+  });
+  const jobsApi = new JobsApi(sdkConfig);
+  const inputArguments = config.inputs ? JSON.stringify(config.inputs) : "{}";
+  const startInfo = {
+    releaseKey: config.releaseKey,
+    inputArguments,
+    runAsMe: true
+  };
+  if (config.robotIds && config.robotIds.length > 0) {
+    startInfo.robotIds = config.robotIds;
+  }
+  const response = await jobsApi.jobsStartJobs({
+    body: { startInfo }
+  });
+  if (!response.value || response.value.length === 0) {
+    throw new Error("Failed to start job: No job returned from API");
+  }
+  return response.value[0];
+}
+async function _getJobStatus(config, jobKey) {
+  const folder = config.folderKey ? await resolveFolder({ folderKey: config.folderKey }, { tenant: config.tenantName }) : await getPersonalFolderKey({
+    baseUrl: config.baseUrl,
+    organizationId: config.organizationId,
+    tenantName: config.tenantName,
+    tenantId: config.tenantId,
+    authToken: config.authToken
+  });
+  const sdkConfig = await createOrchestratorConfig({
+    folderId: folder.id.toString()
+  });
+  const jobsApi = new JobsApi(sdkConfig);
+  const response = await jobsApi.jobsGet({
+    $filter: `Key eq ${jobKey}`,
+    $top: 1
+  });
+  if (!response.value || response.value.length === 0) {
+    throw new Error(`Job not found: ${jobKey}`);
+  }
+  return response.value[0];
+}
+async function getFlowTraces(config, traceId) {
+  if (!config.tenantName) {
+    throw new Error("Tenant name is required for Traces API. Please ensure you're logged in properly.");
+  }
+  const serviceName = config.tracesServiceName || "llmopstenant_";
+  const traceIdNoHyphens = traceId.replaceAll("-", "");
+  const url = `${config.baseUrl}/${config.organizationId}/${config.tenantName}/${serviceName}/api/Traces/v2/spans/otel?traceId=${traceIdNoHyphens}`;
+  const headers = {
+    Authorization: `Bearer ${config.authToken}`,
+    "Content-Type": "application/json",
+    Accept: "application/json"
+  };
+  if (config.folderKey) {
+    headers["x-uipath-folderkey"] = config.folderKey;
+  }
+  logger.debug(`GET TRACES: ${url}`);
+  const response = await fetch(url, {
+    method: "GET",
+    headers
+  });
+  logger.debug(`TRACES RESPONSE: ${response.status} ${response.statusText}`);
+  if (!response.ok) {
+    const errorText = await response.text();
+    logger.debug(`TRACES ERROR BODY: ${errorText.substring(0, 200)}`);
+    throw new Error(`Traces API failed: ${response.status} ${response.statusText} - ${errorText}`);
+  }
+  const parsed = await response.json();
+  const data = Array.isArray(parsed) ? parsed : parsed.Spans ?? [];
+  logger.debug(`TRACES DATA: ${JSON.stringify(data).substring(0, 200)}`);
+  return data;
+}
+function spanToTraceEvent(span) {
+  let attributes = {};
+  try {
+    attributes = JSON.parse(span.Attributes);
+  } catch {}
+  const duration = span.EndTime ? new Date(span.EndTime).getTime() - new Date(span.StartTime).getTime() : undefined;
+  return {
+    timestamp: span.StartTime,
+    spanId: span.Id,
+    parentId: span.ParentId,
+    name: span.Name,
+    type: span.SpanType,
+    status: attributes.status || "Unknown",
+    duration,
+    attributes
+  };
+}
+async function startFlowProjectJob(config) {
+  if (!config.releaseKey) {
+    throw new Error("Release key is required. Use 'flow project list' to find it.");
+  }
+  return startFlowJob(config);
+}
+var TRACE_TERMINAL_STATES = ["Completed", "Faulted", "Cancelled"];
+var JOB_TERMINAL_STATES = [
+  "Successful",
+  "Completed",
+  "Faulted",
+  "Stopped",
+  "Cancelled"
+];
+function isTransientTraceError(error) {
+  return error.message.includes("404") || error.message.includes("400");
+}
+function getJobState(job) {
+  return job.state;
+}
+function isTerminalJobState(state) {
+  return state !== undefined && JOB_TERMINAL_STATES.includes(state);
+}
+function extractTerminalStatus(spans) {
+  const processRunSpan = spans.find((s) => s.SpanType === "ProcessRun");
+  if (!processRunSpan) {
+    return;
+  }
+  try {
+    const attributes = JSON.parse(processRunSpan.Attributes);
+    const status = attributes.status;
+    if (status && TRACE_TERMINAL_STATES.includes(status)) {
+      return status;
+    }
+  } catch {
+    logger.warn("Failed to parse ProcessRun span attributes");
+  }
+  return;
+}
+async function streamJobTraces(config, jobKey, options = {}) {
+  const startTime = Date.now();
+  const pollInterval = options.pollInterval || 2000;
+  const maxPolls = options.maxPolls || 300;
+  const traceId = jobKey;
+  const effectiveInterval = Math.max(pollInterval, MIN_INTERVAL_MS);
+  const timeoutMs = maxPolls * effectiveInterval;
+  const seenSpanIds = new Set;
+  let tracesFound = false;
+  let transientErrorCount = 0;
+  let terminalJobState;
+  const result = await pollUntil({
+    fn: () => getFlowTraces(config, traceId),
+    until: (spans) => extractTerminalStatus(spans) !== undefined,
+    label: `job ${jobKey}`,
+    logPrefix: "flow",
+    intervalMs: pollInterval,
+    timeoutMs,
+    maxConsecutiveErrors: 0,
+    signal: processContext.pollSignal,
+    onPoll: (spans) => {
+      transientErrorCount = 0;
+      if (!tracesFound && spans.length > 0) {
+        tracesFound = true;
+        logger.info("Execution started, streaming traces...");
+      }
+      for (const span of spans) {
+        if (!seenSpanIds.has(span.Id)) {
+          seenSpanIds.add(span.Id);
+          options.onTrace?.(spanToTraceEvent(span));
+        }
+      }
+    },
+    onError: async (error) => {
+      if (isTransientTraceError(error)) {
+        const [statusError, job] = await catchError(_getJobStatus(config, jobKey));
+        if (statusError) {
+          logger.debug(`Failed to check job status after traces error: ${statusError.message}`);
+        } else {
+          const state = getJobState(job);
+          if (isTerminalJobState(state)) {
+            terminalJobState = state;
+            return ErrorDecision.Abort;
+          }
+        }
+        if (!tracesFound && transientErrorCount % 5 === 0) {
+          logger.info("Waiting for traces...");
+        }
+        transientErrorCount++;
+        return;
+      }
+      return ErrorDecision.Abort;
+    }
+  });
+  const elapsed = Date.now() - startTime;
+  if (result.outcome === PollOutcome.Completed && result.data) {
+    const status = extractTerminalStatus(result.data);
+    const finalState = status ?? "Unknown";
+    const runResult = {
+      success: finalState === "Completed",
+      jobKey,
+      traceId,
+      finalState,
+      duration: elapsed
+    };
+    options.onComplete?.(runResult);
+    return runResult;
+  }
+  if (result.outcome === PollOutcome.Timeout) {
+    return {
+      success: false,
+      jobKey,
+      traceId,
+      error: `Polling timed out after ${timeoutMs / 1000}s`,
+      duration: elapsed,
+      finalState: "Failed"
+    };
+  }
+  if (terminalJobState) {
+    return {
+      success: false,
+      jobKey,
+      traceId,
+      error: `Job already completed or reached terminal state '${terminalJobState}' before trace data became available.`,
+      duration: elapsed,
+      finalState: terminalJobState
+    };
+  }
+  const errorMsg = result.error?.message ?? `Polling ended: ${result.outcome}`;
+  return {
+    success: false,
+    jobKey,
+    traceId,
+    error: errorMsg,
+    duration: elapsed,
+    finalState: "Failed"
+  };
+}
+async function getJobStatusDetailed(config, jobKey) {
+  const folderId = await resolveFlowFolderId(config);
+  const sdkConfig = await createOrchestratorConfig({
+    folderId
+  });
+  const jobsApi = new JobsApi(sdkConfig);
+  const response = await jobsApi.jobsGet({
+    $filter: `Key eq ${jobKey}`,
+    $expand: "Robot,Release,Machine",
+    $top: 1
+  });
+  if (!response.value || response.value.length === 0) {
+    throw new Error(`Job not found: ${jobKey}`);
+  }
+  return response.value[0];
+}
+function isJobAttachmentReference(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  const ref = value;
+  return typeof ref.ID === "string" && typeof ref.FullName === "string";
+}
+async function validateFlowInputs(config, inputs) {
+  try {
+    const entryPoints = await getFlowEntryPoints(config);
+    if (entryPoints.length === 0) {
+      return {
+        valid: false,
+        errors: ["No entry points found for this process"]
+      };
+    }
+    const entryPoint = entryPoints[0];
+    const inputSchema = JSON.parse(entryPoint.InputArguments);
+    if (inputSchema.type !== "object") {
+      return { valid: true };
+    }
+    const errors = [];
+    const requiredProps = inputSchema.required || [];
+    for (const prop of requiredProps) {
+      if (!(prop in inputs)) {
+        errors.push(`Missing required property: ${prop}`);
+      }
+    }
+    if (inputSchema.properties) {
+      for (const [key, value] of Object.entries(inputs)) {
+        if (inputSchema.properties[key]?.type) {
+          const expectedType = inputSchema.properties[key].type;
+          const actualType = typeof value;
+          if (expectedType === "string" && isJobAttachmentReference(value)) {
+            continue;
+          }
+          if (expectedType === "string" && actualType !== "string") {
+            errors.push(`Property '${key}' should be string, got ${actualType}`);
+          } else if (expectedType === "number" && actualType !== "number") {
+            errors.push(`Property '${key}' should be number, got ${actualType}`);
+          } else if (expectedType === "boolean" && actualType !== "boolean") {
+            errors.push(`Property '${key}' should be boolean, got ${actualType}`);
+          }
+        }
+      }
+    }
+    return {
+      valid: errors.length === 0,
+      errors: errors.length > 0 ? errors : undefined
+    };
+  } catch (error) {
+    return {
+      valid: false,
+      errors: [
+        `Failed to validate inputs: ${error instanceof Error ? error.message : String(error)}`
+      ]
+    };
+  }
+}
+async function parseFlowInputs(inputSource) {
+  return await parseJsonInputOrFile(inputSource);
+}
+
+export { listFlowProcesses, listFlowJobs, getFlowEntryPoints, spanToTraceEvent, startFlowProjectJob, streamJobTraces, getJobStatusDetailed, validateFlowInputs, parseFlowInputs };
+
+//# debugId=3818A92E7448BBB464756E2164756E21

package/dist/{packager-tool-1gt6js73.js → packager-tool-xhzfwa5p.js}

@@ -1064,6 +1064,7 @@ var ProjectTypes;
 ((ProjectTypes2) => {
   ProjectTypes2["Agent"] = "Agent";
   ProjectTypes2["Api"] = "Api";
+  ProjectTypes2["BusinessRules"] = "BusinessRules";
   ProjectTypes2["Connector"] = "Connector";
   ProjectTypes2["CaseManagement"] = "CaseManagement";
   ProjectTypes2["Flow"] = "Flow";
@@ -1424,7 +1425,8 @@ class ToolsFactoryRepository {
   getProjectToolFactory(projectType) {
     const factory = this.projectFactoryMap.get(projectType);
     if (!factory) {
-      throw new Error(`No tool factory found for project type '${projectType}'`);
+      const known = [...this.projectFactoryMap.keys()].join(", ");
+      throw new Error(`Cannot pack project type '${projectType}': no packager is installed for it. ` + `Project types that can be packed: ${known || "none"}.`);
     }
     return factory;
   }
@@ -1802,9 +1804,9 @@ var init_is_in_ssh = __esm(() => {
 });
 var exports_open = {};
 __export(exports_open, {
-  openApp: () => openApp,
+  apps: () => apps,
   default: () => open_default,
-  apps: () => apps
+  openApp: () => openApp
 });
 function detectArchBinary(binary) {
   if (typeof binary === "string" || Array.isArray(binary)) {
@@ -2337,4 +2339,4 @@ var getFileSystem = () => fsInstance;
 
 export { Path, TemporaryStorageService, ZipService, I18nManager, translate, LogLevel, LogMessage, NugetConstants, ProjectTypes, TargetFramework, ToolErrorCodes, ToolResult, ensureProjectId, writeContentOperateFile, NugetPackager, ProjectTool, toolsFactoryRepository, NodeFileSystem, getFileSystem };
 
-//# debugId=D251160E950936A664756E2164756E21
+//# debugId=CC33302D6CFC9F7764756E2164756E21

package/dist/{packager-tool-5arsyj36.js → packager-tool-yc4kw997.js}

@@ -5,7 +5,9 @@ var DEFAULT_BASE_URL = "https://cloud.uipath.com";
 var DEFAULT_AUTH_TIMEOUT_MS = 5 * 60 * 1000;
 var AUTH_TIMEOUT_ERROR_CODE = "EAUTHTIMEOUT";
 var AUTH_CANCELLED_ERROR_CODE = "EAUTHCANCELLED";
+var AUTH_RECLAIMED_ERROR_CODE = "EAUTHRECLAIMED";
+var DEFAULT_REDIRECT_URI = "http://localhost:8104/oidc/login";
 
-export { UIPATH_HOME_DIR, AUTH_FILENAME, DEFAULT_BASE_URL, DEFAULT_AUTH_TIMEOUT_MS, AUTH_TIMEOUT_ERROR_CODE, AUTH_CANCELLED_ERROR_CODE };
+export { UIPATH_HOME_DIR, AUTH_FILENAME, DEFAULT_BASE_URL, DEFAULT_AUTH_TIMEOUT_MS, AUTH_TIMEOUT_ERROR_CODE, AUTH_CANCELLED_ERROR_CODE, AUTH_RECLAIMED_ERROR_CODE, DEFAULT_REDIRECT_URI };
 
-//# debugId=E98AE5255EE78AC164756E2164756E21
+//# debugId=75C147C6FAA3208364756E2164756E21

package/dist/{packager-tool-pkq70dec.js → packager-tool-ywqc9rtf.js}

@@ -1,9 +1,9 @@
 import {
   catchError
-} from "./packager-tool-cvwr40ax.js";
+} from "./packager-tool-5qaxht3k.js";
 import {
   getFileSystem
-} from "./packager-tool-1cb0d5e0.js";
+} from "./packager-tool-0v3s8r01.js";
 
 // ../maestro-sdk/src/registry/snapshot.ts
 function maestroRegistryRoot(filesystem) {
@@ -14,8 +14,36 @@ function maestroRegistryCurrentPath(filesystem) {
   const fs = filesystem ?? getFileSystem();
   return fs.path.join(maestroRegistryRoot(fs), "current.json");
 }
+var CACHE_CURRENT = "current";
+var CACHE_LIBRARY_JSON = "library-json";
+var CACHE_LIBRARY_MARKDOWN = "library-md";
+var PROJECT_CONNECTORS = "connectors";
+function libraryCacheRoot(fs) {
+  return fs.env.getenv("UIP_FLOW_SDK_LIBRARY_CACHE") || fs.path.join(fs.env.homedir(), ".uipath", "cache", "flow-sdk", "library");
+}
+async function findCachedLibrary(fs) {
+  const current = fs.path.join(libraryCacheRoot(fs), CACHE_CURRENT);
+  const libraryJson = fs.path.join(current, CACHE_LIBRARY_JSON);
+  if (!await fs.exists(fs.path.join(libraryJson, "index.json")))
+    return null;
+  return {
+    libraryHash: "",
+    snapshotPath: current,
+    libraryJson,
+    libraryMarkdown: fs.path.join(current, CACHE_LIBRARY_MARKDOWN),
+    connectors: fs.path.join(fs.path.resolve(fs.env.cwd()), PROJECT_CONNECTORS),
+    updatedAt: ""
+  };
+}
+async function resolveProjectLibrary(fs) {
+  const [error, found] = await catchError(findCachedLibrary(fs));
+  return error ? null : found ?? null;
+}
 async function resolveMaestroRegistry(filesystem) {
   const fs = filesystem ?? getFileSystem();
+  const project = await resolveProjectLibrary(fs);
+  if (project)
+    return project;
   const [readError, content] = await catchError(fs.readFile(maestroRegistryCurrentPath(fs), "utf-8"));
   if (readError || content === null)
     return null;
@@ -38,4 +66,4 @@ async function resolveMaestroRegistry(filesystem) {
 
 export { resolveMaestroRegistry };
 
-//# debugId=4F930E85411BFAC964756E2164756E21
+//# debugId=00A1694DAA6FB01064756E2164756E21