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

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

@@ -1,9 +1,9 @@
 import {
   catchError
-} from "./packager-tool-cvwr40ax.js";
+} from "./packager-tool-226mh80j.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

package/dist/packager-tool-k99nf3pq.js

@@ -0,0 +1,25 @@
+// ../../node_modules/@uipath/flow-expression-model/dist/chunk-27WH2HMG.js
+var expressionDiagnostic_dollarHint_replacement = ". Use `$vars.<name>`, `$self.<field>`, or another defined variable.";
+var schemaPanel_arrayItemType_description = "Array item type";
+var scopeService_outputDescription_fallback = "Output from {{nodeLabel}}";
+var scopeService_variableName_containsDotsError = "Variable name cannot contain dots";
+var scopeService_variableName_containsSpacesError = "Variable name cannot contain spaces";
+var scopeService_variableName_invalidCharactersError = "Variable name must contain only letters, numbers, and underscores";
+var scopeService_variableName_reservedWordError = '"{{name}}" is a reserved word';
+var scopeService_variableName_startsWithNumberError = "Variable name cannot start with a number";
+var validation_expression_fileExpected_message = "This value must be a file. To use a remote file, download the file first with an action that outputs a file, then reference that output.";
+var en_default = {
+  expressionDiagnostic_dollarHint_replacement,
+  schemaPanel_arrayItemType_description,
+  scopeService_outputDescription_fallback,
+  scopeService_variableName_containsDotsError,
+  scopeService_variableName_containsSpacesError,
+  scopeService_variableName_invalidCharactersError,
+  scopeService_variableName_reservedWordError,
+  scopeService_variableName_startsWithNumberError,
+  validation_expression_fileExpected_message
+};
+
+export { expressionDiagnostic_dollarHint_replacement, schemaPanel_arrayItemType_description, scopeService_outputDescription_fallback, scopeService_variableName_containsDotsError, scopeService_variableName_containsSpacesError, scopeService_variableName_invalidCharactersError, scopeService_variableName_reservedWordError, scopeService_variableName_startsWithNumberError, validation_expression_fileExpected_message, en_default };
+
+//# debugId=B4EDE4DF5DC0FCCF64756E2164756E21

package/dist/packager-tool-kdasymdr.js

@@ -0,0 +1,443 @@
+import {
+  parseJsonInputOrFile
+} from "./packager-tool-d1hvc3jz.js";
+import {
+  JobsApi,
+  ReleasesApi,
+  createOrchestratorConfig,
+  resolveFolder
+} from "./packager-tool-h66mj8f4.js";
+import {
+  getPersonalFolderKey
+} from "./packager-tool-xjbyd9mj.js";
+import {
+  ErrorDecision,
+  MIN_INTERVAL_MS,
+  PollOutcome,
+  catchError,
+  logger,
+  pollUntil,
+  processContext
+} from "./packager-tool-226mh80j.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-jysvpt8p.js → packager-tool-m3wkcxf5.js}

@@ -1,4 +1,4 @@
-// ../../node_modules/@uipath/flow-core/node_modules/@uipath/flow-schema/dist/chunk-QKQ47GQZ.js
+// ../../node_modules/@uipath/flow-expression-model/dist/chunk-QKQ47GQZ.js
 var __glob = (map) => (path) => {
   var fn = map[path];
   if (fn)
@@ -8,4 +8,4 @@ var __glob = (map) => (path) => {
 
 export { __glob };
 
-//# debugId=CD595A1AF45EBB3464756E2164756E21
+//# debugId=9F7CA621D9317B9F64756E2164756E21