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

package/dist/packager-tool-fjaa8d3v.js

@@ -0,0 +1,289 @@
+import {
+  logger
+} from "./packager-tool-5qaxht3k.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-g0eha8ge.js

@@ -0,0 +1,121 @@
+import {
+  isRecord
+} from "./packager-tool-8j92afwp.js";
+import {
+  collectAgentInputLeaves,
+  isInlineAgentNodeType
+} from "./packager-tool-6m078z5s.js";
+import {
+  catchError
+} from "./packager-tool-5qaxht3k.js";
+
+// src/services/flow-eval-node-target.ts
+function findFlowNode(flowContent, nodeId) {
+  const [parseError, parsed] = catchError(() => JSON.parse(flowContent));
+  if (parseError || !isRecord(parsed)) {
+    return { flowParsed: false };
+  }
+  const topLevel = Array.isArray(parsed.nodes) ? parsed.nodes : [];
+  const subflows = isRecord(parsed.subflows) ? Object.values(parsed.subflows) : [];
+  const nested = subflows.flatMap((subflow) => isRecord(subflow) && Array.isArray(subflow.nodes) ? subflow.nodes : []);
+  const node = [...topLevel, ...nested].find((candidate) => isRecord(candidate) && candidate.id === nodeId);
+  return { flowParsed: true, node };
+}
+function readAgentSourceId(node) {
+  const inputs = isRecord(node.inputs) ? node.inputs : undefined;
+  const source = inputs?.source;
+  if (typeof source !== "string") {
+    return;
+  }
+  const normalized = source.trim();
+  return normalized.length > 0 ? normalized : undefined;
+}
+function isNodeEvalTarget(node) {
+  const type = typeof node.type === "string" ? node.type.toLowerCase() : undefined;
+  return isInlineAgentNodeType(type) && readAgentSourceId(node) !== undefined;
+}
+var DOCUMENT_EVAL_NODE_TYPES = new Set([
+  "uipath.ixp.extract-document-builder",
+  "uipath.document.classify"
+]);
+function isDocumentEvalNode(node) {
+  const type = typeof node.type === "string" ? node.type.toLowerCase() : "";
+  return DOCUMENT_EVAL_NODE_TYPES.has(type);
+}
+function readNodeTargetId(set) {
+  if (set.target) {
+    return set.target.kind === "agentNode" ? set.target.nodeId : undefined;
+  }
+  if (set.nodeEval === true && set.targetKind === undefined) {
+    return set.selectedEntrypoint;
+  }
+  return;
+}
+var NO_AGENT = {
+  agentFound: false,
+  inputs: [],
+  outputs: new Set
+};
+
+class FlowAgentNodeSchemaReader {
+  fs;
+  pathResolver;
+  constructor(fs, pathResolver) {
+    this.fs = fs;
+    this.pathResolver = pathResolver;
+  }
+  async read(projectPath, nodeId) {
+    const root = await this.pathResolver.resolveFlowProjectPath(projectPath);
+    const [flowError, flowFilePath] = await catchError(this.pathResolver.findFlowFile(root));
+    if (flowError || !flowFilePath) {
+      return NO_AGENT;
+    }
+    const [readError, flowContent] = await catchError(this.fs.readFile(flowFilePath, "utf-8"));
+    if (readError) {
+      return NO_AGENT;
+    }
+    const lookup = findFlowNode(String(flowContent), nodeId);
+    if (!lookup.node) {
+      return NO_AGENT;
+    }
+    const sourceId = readAgentSourceId(lookup.node);
+    if (sourceId === undefined || /[/\\.]/.test(sourceId)) {
+      return NO_AGENT;
+    }
+    const agentJsonPath = this.fs.path.join(this.fs.path.dirname(flowFilePath), sourceId, "agent.json");
+    const [agentReadError, raw] = await catchError(this.fs.readFile(agentJsonPath, "utf-8"));
+    if (agentReadError) {
+      return NO_AGENT;
+    }
+    const [parseError, agent] = catchError(() => JSON.parse(String(raw)));
+    if (parseError || !isRecord(agent)) {
+      return NO_AGENT;
+    }
+    return {
+      agentFound: true,
+      agentJsonPath,
+      inputs: collectAgentInputLeaves(agent.inputSchema),
+      outputs: readOutputKeys(agent.outputSchema)
+    };
+  }
+}
+function readOutputKeys(outputSchema) {
+  if (!isRecord(outputSchema) || !isRecord(outputSchema.properties)) {
+    return new Set;
+  }
+  return new Set(Object.keys(outputSchema.properties));
+}
+function readEvalSetScope(set) {
+  if (readNodeTargetId(set) !== undefined) {
+    return "node";
+  }
+  const kind = set.target?.kind ?? set.targetKind;
+  if (kind === "documentExtraction" || kind === "documentClassification") {
+    return "document";
+  }
+  return "flow";
+}
+
+export { findFlowNode, readAgentSourceId, isNodeEvalTarget, isDocumentEvalNode, readNodeTargetId, FlowAgentNodeSchemaReader, readEvalSetScope };
+
+//# debugId=D51E7B5AE34841EC64756E2164756E21

package/dist/packager-tool-g9y14b10.js

@@ -0,0 +1,54 @@
+import {
+  readStdin
+} from "./packager-tool-5qaxht3k.js";
+import {
+  getFileSystem
+} from "./packager-tool-0v3s8r01.js";
+
+// ../maestro-sdk/src/json-input.ts
+async function readJsonFile(filePath) {
+  const fs = getFileSystem();
+  const resolved = fs.path.resolve(filePath);
+  if (!await fs.exists(resolved)) {
+    throw new Error(`File not found: ${resolved}`);
+  }
+  const content = await fs.readFile(resolved, "utf-8");
+  try {
+    return JSON.parse(content);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    throw new Error(`Invalid JSON in '${resolved}': ${message}`);
+  }
+}
+async function parseJsonInputOrFile(inputSource) {
+  if (inputSource.startsWith("@")) {
+    const filePath = inputSource.slice(1);
+    try {
+      return await readJsonFile(filePath);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      throw new Error(`Failed to read input file '${filePath}': ${message}`);
+    }
+  }
+  try {
+    return JSON.parse(inputSource);
+  } catch {
+    throw new Error(`Failed to parse inputs as JSON: ${inputSource}`);
+  }
+}
+async function resolveJsonInput(opts) {
+  if (opts.inline !== undefined && opts.inline !== "") {
+    return parseJsonInputOrFile(opts.inline);
+  }
+  if (opts.allowStdin) {
+    const stdinData = await readStdin();
+    if (stdinData) {
+      return parseJsonInputOrFile(stdinData);
+    }
+  }
+  return;
+}
+
+export { parseJsonInputOrFile, resolveJsonInput };
+
+//# debugId=DFD3DCFE2F7E23A764756E2164756E21

package/dist/packager-tool-gbgfwx8f.js

@@ -0,0 +1,2 @@
+
+//# debugId=7041B570F390EB6464756E2164756E21

package/dist/packager-tool-jc34wvrw.js

@@ -0,0 +1,64 @@
+import {
+  catchError
+} from "./packager-tool-5qaxht3k.js";
+
+// src/services/flow-eval-file-store.ts
+async function ensureDirectory(fs, path) {
+  if (await fs.exists(path)) {
+    return;
+  }
+  const parent = fs.path.dirname(path);
+  if (parent && parent !== path && !await fs.exists(parent)) {
+    await ensureDirectory(fs, parent);
+  }
+  const [error] = await catchError(fs.mkdir(path));
+  if (error && !await fs.exists(path)) {
+    throw error;
+  }
+}
+
+class FlowEvalFileStore {
+  fs;
+  constructor(fs) {
+    this.fs = fs;
+  }
+  async readJsonFiles(dir) {
+    const [readDirError, files] = await catchError(this.fs.readdir(dir));
+    if (readDirError) {
+      return [];
+    }
+    const items = [];
+    for (const file of files) {
+      if (!file.endsWith(".json")) {
+        continue;
+      }
+      const filePath = this.fs.path.join(dir, file);
+      const [readError, raw] = await catchError(this.fs.readFile(filePath, "utf-8"));
+      if (readError) {
+        throw new Error(`Failed to read JSON file "${filePath}": ${readError.message}`);
+      }
+      if (raw === null) {
+        continue;
+      }
+      const [parseError, data] = catchError(() => JSON.parse(String(raw)));
+      if (parseError) {
+        throw new Error(`Invalid JSON in "${filePath}": ${parseError.message}`);
+      }
+      data.fileName = file;
+      items.push(data);
+    }
+    return items;
+  }
+  async writeJsonFile(path, value) {
+    await ensureDirectory(this.fs, this.fs.path.dirname(path));
+    await this.fs.writeFile(path, `${JSON.stringify(value, null, 2)}
+`);
+  }
+  async remove(path) {
+    await this.fs.rm(path);
+  }
+}
+
+export { ensureDirectory, FlowEvalFileStore };
+
+//# debugId=2DF0307602E51A6664756E2164756E21

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-hr0xg6q8.js → packager-tool-kn91khp6.js}

@@ -1,28 +1,32 @@
-import {
-  VALID_PROJECT_NAME_REGEX,
-  nodeModuleRegistry,
-  writeFlowWorkflow
-} from "./packager-tool-3y0k15sv.js";
 import {
   prepareProjectLocation,
   tryRegisterProjectInParentSolution
-} from "./packager-tool-0sz8se22.js";
+} from "./packager-tool-eebq62fq.js";
+import {
+  writeFlowWorkflow
+} from "./packager-tool-94w17vf8.js";
+import {
+  createWorkflow
+} from "./packager-tool-tn5e7wnb.js";
+import {
+  VALID_PROJECT_NAME_REGEX
+} from "./packager-tool-eypvc2kv.js";
 import {
   catchError
-} from "./packager-tool-cvwr40ax.js";
+} from "./packager-tool-5qaxht3k.js";
 import {
   getFileSystem
-} from "./packager-tool-1cb0d5e0.js";
+} from "./packager-tool-0v3s8r01.js";
 import {
-  createWorkflow
-} from "./packager-tool-17cn3xb7.js";
+  nodeModuleRegistry
+} from "./packager-tool-p9stswjj.js";
 import {
   __require
-} from "./packager-tool-wckvcay0.js";
+} from "./packager-tool-1yh8g550.js";
 
 // src/services/project-artifacts.ts
 async function ensureProjectArtifacts(args) {
-  const { addProjectArtifactsToSolutionAsync } = await import("./index-dhcd9b82.js");
+  const { addProjectArtifactsToSolutionAsync } = await import("./index-w0z4s69j.js");
   return addProjectArtifactsToSolutionAsync(args);
 }
 
@@ -105,4 +109,4 @@ async function maybeGenerateProjectArtifacts(registration, projectName) {
 
 export { flowInitAsync };
 
-//# debugId=5364B2B1CFDDFE8864756E2164756E21
+//# debugId=EBC554606544E02D64756E2164756E21

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