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

package/dist/{authoring-aaaqwck3.js → authoring-jj4zkqer.js}

@@ -1,17 +1,17 @@
 import {
   resolveMaestroRegistry
-} from "./packager-tool-we1phz71.js";
+} from "./packager-tool-hxw1a9ac.js";
 import {
   OutputFormatter,
   RESULTS,
   getOutputFormat,
   getOutputFormatExplicit,
   processContext
-} from "./packager-tool-zx48pq4v.js";
+} from "./packager-tool-ygwa3sc0.js";
 import {
   getFileSystem
-} from "./packager-tool-1cb0d5e0.js";
-import"./packager-tool-wckvcay0.js";
+} from "./packager-tool-0v3s8r01.js";
+import"./packager-tool-1yh8g550.js";
 
 // ../builder-sdk/src/argv.ts
 function addValue(argv, flag, value) {
@@ -23,7 +23,10 @@ function addValue(argv, flag, value) {
 // ../builder-sdk/src/delegate.ts
 import { spawn } from "node:child_process";
 import { createRequire } from "node:module";
-var MINIMUM_FLOW_SDK_VERSION = "1.1.0";
+var FLOW_SDK_PACKAGES = [
+  { name: "@uipath/maestro-builder-sdk", minimumVersion: "4.0.0" },
+  { name: "@uipath/flow-sdk", minimumVersion: "1.1.0" }
+];
 function commandLabel(family, verb) {
   return `uip maestro ${family} ${verb}`;
 }
@@ -77,53 +80,66 @@ async function runChild(cliPath, args, cwd, label) {
     });
   });
 }
+function upgradeInstructions() {
+  const [current, legacy] = FLOW_SDK_PACKAGES;
+  return `npm install --save-dev ${current.name}` + ` (the previous name ${legacy.name} also works and needs an .npmrc` + ` routing @uipath to https://npm.pkg.github.com/).`;
+}
 async function resolveFlowSdk(workspace, label) {
   const fs = getFileSystem();
-  let packagePath;
-  try {
-    packagePath = createRequire(import.meta.url).resolve("@uipath/flow-sdk/package.json", { paths: [workspace] });
-  } catch {
-    return {
-      ok: false,
-      message: `${label}: @uipath/flow-sdk is not installed in this workspace.`,
-      instructions: "Add it to this project's dependencies: npm install --save-dev @uipath/flow-sdk (requires an .npmrc routing @uipath to https://npm.pkg.github.com/)."
-    };
-  }
-  const packageText = await fs.readFile(packagePath, "utf-8");
-  if (packageText === null) {
-    return {
-      ok: false,
-      message: `${label}: could not read ${packagePath}.`,
-      instructions: "Reinstall @uipath/flow-sdk, then retry."
-    };
-  }
-  let version = "";
-  let bin = {};
-  try {
-    const parsed = JSON.parse(packageText);
-    version = typeof parsed.version === "string" ? parsed.version : "";
-    if (parsed.bin && typeof parsed.bin === "object") {
-      for (const [name, target] of Object.entries(parsed.bin)) {
-        if (typeof target === "string")
-          bin[name] = target;
+  const require2 = createRequire(import.meta.url);
+  let firstFailure;
+  for (const candidate of FLOW_SDK_PACKAGES) {
+    let packagePath;
+    try {
+      packagePath = require2.resolve(`${candidate.name}/package.json`, {
+        paths: [workspace]
+      });
+    } catch {
+      continue;
+    }
+    const packageText = await fs.readFile(packagePath, "utf-8");
+    if (packageText === null) {
+      firstFailure ??= {
+        ok: false,
+        message: `${label}: could not read ${packagePath}.`,
+        instructions: `Reinstall ${candidate.name}, then retry.`
+      };
+      continue;
+    }
+    let version = "";
+    let bin = {};
+    try {
+      const parsed = JSON.parse(packageText);
+      version = typeof parsed.version === "string" ? parsed.version : "";
+      if (parsed.bin && typeof parsed.bin === "object") {
+        for (const [name, target] of Object.entries(parsed.bin)) {
+          if (typeof target === "string")
+            bin[name] = target;
+        }
       }
+    } catch {
+      version = "";
+      bin = {};
+    }
+    if (!versionMeetsFloor(version, candidate.minimumVersion)) {
+      firstFailure ??= {
+        ok: false,
+        message: `${label}: found ${candidate.name} ${version || "with no valid version"}; need >= ${candidate.minimumVersion}.`,
+        instructions: upgradeInstructions()
+      };
+      continue;
     }
-  } catch {
-    version = "";
-    bin = {};
-  }
-  if (!versionMeetsFloor(version, MINIMUM_FLOW_SDK_VERSION)) {
     return {
-      ok: false,
-      message: `${label}: found @uipath/flow-sdk ${version || "with no valid version"}; need >= ${MINIMUM_FLOW_SDK_VERSION}.`,
-      instructions: "Run: npm install --save-dev @uipath/flow-sdk@latest."
+      ok: true,
+      packageDir: fs.path.dirname(packagePath),
+      version,
+      bin
     };
   }
-  return {
-    ok: true,
-    packageDir: fs.path.dirname(packagePath),
-    version,
-    bin
+  return firstFailure ?? {
+    ok: false,
+    message: `${label}: ${FLOW_SDK_PACKAGES[0].name} is not installed in this workspace.`,
+    instructions: upgradeInstructions()
   };
 }
 async function delegateToFlowSdk({
@@ -162,6 +178,8 @@ function sdkCliExample(description, command, message) {
 async function resolveLibraryOption(explicit) {
   if (explicit !== undefined)
     return explicit;
+  if (getFileSystem().env.getenv("FLOW_SDK_LIBRARY_JSON"))
+    return;
   const registry = await resolveMaestroRegistry();
   return registry?.libraryJson;
 }
@@ -175,7 +193,7 @@ var CHECK_EXAMPLES = {
 var registerCheckCommand = (program, family) => {
   const command = program.previewCommand("check <input>").description("Run the authoring-time SDK analyzer on source or an artifact.").option("--source", "Check authored TypeScript").option("--compiled", "Check the compiled artifact");
   if (family === "flow") {
-    command.option("--library <dir>", "Connector library directory (defaults to the pulled registry; source checks also honor $FLOW_SDK_LIBRARY_JSON)").option("--json", "Print compiled-check diagnostics as JSON").option("--uip", "Resolve missing schemas with the UiPath CLI").option("--max-errors <count>", "Stop after this many compiled-check errors").option("--script-determinism", "Check script blocks for non-deterministic calls").option("--quiet", "Suppress warnings and information");
+    command.option("--library <dir>", "Connector library directory (defaults to $FLOW_SDK_LIBRARY_JSON, else the pulled library)").option("--json", "Print compiled-check diagnostics as JSON").option("--uip", "Resolve missing schemas with the UiPath CLI").option("--max-errors <count>", "Stop after this many compiled-check errors").option("--script-determinism", "Check script blocks for non-deterministic calls").option("--quiet", "Suppress warnings and information");
   }
   const example = CHECK_EXAMPLES[family];
   command.examples(sdkCliExample(`Check a ${family} source file before compiling it`, `uip maestro ${family} check ${example.input} --source`, example.message)).trackedAction(processContext, async (input, options) => {
@@ -263,15 +281,23 @@ var DECOMPILE_EXAMPLES = {
 var registerDecompileCommand = (program, family) => {
   const command = program.previewCommand("decompile <input>").description(`Convert a ${family === "flow" ? ".flow" : "caseplan.json"} artifact to authored TypeScript.`).option("-o, --output <file>", `Output ${family === "flow" ? ".flow.ts" : ".case.ts"} path`).option("--import <specifier>", "SDK import specifier in generated source");
   if (family === "flow") {
-    command.option("--strict", "Fail on unsupported constructs").option("--no-pipeline", "Do not emit a brownfield pipeline helper");
+    command.option("--strict", "Fail on unsupported constructs");
+  } else {
+    command.option("--library <dir>", "Connector library directory (defaults to the pulled registry)").option("--best-effort", "Emit a marked repair scaffold for unsupported constructs");
   }
+  command.option("--no-pipeline", "Do not emit a brownfield pipeline helper");
   const example = DECOMPILE_EXAMPLES[family];
   command.examples(sdkCliExample(`Convert a ${family} artifact back to authored TypeScript`, `uip maestro ${family} decompile ${example.input} --output ${example.output}`, example.message)).trackedAction(processContext, async (input, options) => {
     const argv = [input];
     addValue(argv, "-o", options.output);
     addValue(argv, "--import", options.import);
+    if (family === "case") {
+      addValue(argv, "--library", await resolveLibraryOption(options.library));
+    }
     if (options.strict)
       argv.push("--strict");
+    if (options.bestEffort)
+      argv.push("--best-effort");
     if (options.pipeline === false)
       argv.push("--no-pipeline");
     const code = await delegateToFlowSdk({
@@ -293,4 +319,4 @@ export {
   registerCaseAuthoringCommands
 };
 
-//# debugId=847E8056C2AECFF464756E2164756E21
+//# debugId=1A1E49FDDB5AEC9264756E2164756E21

package/dist/{browser-strategy-rkcvc6tn.js → browser-strategy-6atc7v8s.js}

@@ -1,10 +1,10 @@
 import {
   getGlobalThis
-} from "./packager-tool-9qecd4wb.js";
+} from "./packager-tool-0gctz400.js";
 import {
   AUTH_CANCELLED_ERROR_CODE
-} from "./packager-tool-5arsyj36.js";
-import"./packager-tool-wckvcay0.js";
+} from "./packager-tool-yc4kw997.js";
+import"./packager-tool-1yh8g550.js";
 
 // ../auth/src/strategies/browser-strategy.ts
 class BrowserAuthStrategy {

package/dist/case-api-2nfc0ynz.js

@@ -0,0 +1,381 @@
+import {
+  JobsApi,
+  ReleasesApi,
+  createOrchestratorConfig,
+  resolveFolder
+} from "./packager-tool-a190917w.js";
+import {
+  parseJsonInputOrFile
+} from "./packager-tool-ay3zvfcv.js";
+import"./packager-tool-vepqrsse.js";
+import"./packager-tool-dqs5qy9s.js";
+import"./packager-tool-qa9gftnj.js";
+import {
+  OutputFormatter,
+  catchError
+} from "./packager-tool-ygwa3sc0.js";
+import"./packager-tool-0v3s8r01.js";
+import"./packager-tool-0gctz400.js";
+import"./packager-tool-yc4kw997.js";
+import"./packager-tool-1yh8g550.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) {
+    OutputFormatter.log({ Message: `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/case-api.ts
+async function listCaseProcesses(config, filter) {
+  const organizationUnitId = await resolveOrganizationUnitId(config);
+  const sdkConfig = await createOrchestratorConfig({
+    folderId: organizationUnitId?.toString(),
+    tenant: config.tenantName
+  });
+  const releasesApi = new ReleasesApi(sdkConfig);
+  const filters = ["ProcessType eq 'CaseManagement'"];
+  if (config.folderKey) {
+    const guidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+    if (!guidRegex.test(config.folderKey)) {
+      throw new Error(`Invalid folder key format: "${config.folderKey}". Expected GUID ex. 01234567-0123-0123-0123-0123456789ab`);
+    }
+    filters.push(`FolderKey eq '${config.folderKey}'`);
+  }
+  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 getCaseEntryPoints(config) {
+  const organizationUnitId = await resolveOrganizationUnitId(config);
+  const apiConfig = {
+    baseUrl: config.baseUrl,
+    organizationId: config.organizationId,
+    tenantName: config.tenantName,
+    authToken: config.authToken,
+    organizationUnitId
+  };
+  const feedIdParam = config.feedId ? `?feedId=${encodeURIComponent(config.feedId)}` : "";
+  if (!/^[a-zA-Z0-9._-]+$/.test(config.processKey)) {
+    throw new Error(`Invalid process key format: "${config.processKey}"`);
+  }
+  const path = `/odata/Processes/UiPath.Server.Configuration.OData.GetPackageEntryPointsV2(key='${config.processKey}')${feedIdParam}`;
+  const response = await orchestratorGet(apiConfig, path);
+  return response.value;
+}
+async function startCaseJob(config) {
+  const organizationUnitId = await resolveOrganizationUnitId(config);
+  const sdkConfig = await createOrchestratorConfig({
+    folderId: organizationUnitId?.toString(),
+    tenant: config.tenantName
+  });
+  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 getCaseTraces(config, traceId) {
+  if (!config.tenantId) {
+    throw new Error("Tenant ID is required for Traces API. Please ensure you're logged in properly.");
+  }
+  const serviceName = config.tracesServiceName || "llmopstenant_";
+  const url = `${config.baseUrl}/${config.organizationId}/${config.tenantId}/${serviceName}/api/Traces/spans/?traceId=${traceId}`;
+  const headers = {
+    Authorization: `Bearer ${config.authToken}`,
+    "Content-Type": "application/json",
+    Accept: "application/json"
+  };
+  if (config.organizationUnitId) {
+    headers["X-UIPATH-OrganizationUnitId"] = config.organizationUnitId.toString();
+  }
+  if (process.env.DEBUG) {
+    OutputFormatter.log({ Message: `DEBUG GET TRACES: ${url}` });
+  }
+  const response = await fetch(url, {
+    method: "GET",
+    headers
+  });
+  if (process.env.DEBUG) {
+    OutputFormatter.log({
+      Message: `DEBUG TRACES RESPONSE: ${response.status} ${response.statusText}`
+    });
+  }
+  if (!response.ok) {
+    const errorText = await response.text();
+    if (process.env.DEBUG) {
+      OutputFormatter.log({
+        Message: `DEBUG TRACES ERROR BODY: ${errorText.substring(0, 200)}`
+      });
+    }
+    throw new Error(`Traces API failed: ${response.status} ${response.statusText} - ${errorText}`);
+  }
+  const data = await response.json();
+  if (process.env.DEBUG) {
+    OutputFormatter.log({
+      Message: `DEBUG TRACES DATA: ${JSON.stringify(data).substring(0, 200)}`
+    });
+  }
+  return data;
+}
+function spanToTraceEvent(span) {
+  let attributes = {};
+  const [parseError, parsed] = catchError(() => JSON.parse(span.Attributes));
+  if (!parseError) {
+    attributes = parsed;
+  }
+  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 startCaseProjectJob(config) {
+  if (!config.releaseKey) {
+    throw new Error("Release key is required. Use 'case process list' to find it.");
+  }
+  return startCaseJob(config);
+}
+async function streamJobTraces(config, jobKey, options = {}) {
+  const startTime = Date.now();
+  const pollInterval = options.pollInterval || 2000;
+  const maxPolls = options.maxPolls || 300;
+  const traceId = jobKey;
+  let pollCount = 0;
+  const seenSpanIds = new Set;
+  let tracesFound = false;
+  const [outerError, outerResult] = await catchError((async () => {
+    while (pollCount < maxPolls) {
+      const [tracesError, fetchedSpans] = await catchError(getCaseTraces(config, traceId));
+      let spans = [];
+      if (tracesError) {
+        if (tracesError instanceof Error && (tracesError.message.includes("404") || tracesError.message.includes("400"))) {
+          if (!tracesFound && pollCount % 5 === 0) {
+            OutputFormatter.log({
+              Message: `⏳ Waiting for traces... (${(pollCount * pollInterval / 1000).toFixed(1)}s)`
+            });
+          }
+          await new Promise((resolve) => setTimeout(resolve, pollInterval));
+          pollCount++;
+          continue;
+        }
+        throw tracesError;
+      } else {
+        spans = fetchedSpans;
+        if (!tracesFound && spans.length > 0) {
+          tracesFound = true;
+          OutputFormatter.log({
+            Message: "✓ Execution started, streaming traces..."
+          });
+        }
+      }
+      for (const span of spans) {
+        if (!seenSpanIds.has(span.Id)) {
+          seenSpanIds.add(span.Id);
+          const traceEvent = spanToTraceEvent(span);
+          options.onTrace?.(traceEvent);
+        }
+      }
+      const processRunSpan = spans.find((s) => s.SpanType === "ProcessRun");
+      if (processRunSpan) {
+        const [parseError, attributes] = catchError(() => JSON.parse(processRunSpan.Attributes));
+        if (parseError || !attributes) {
+          await new Promise((resolve) => setTimeout(resolve, pollInterval));
+          pollCount++;
+          continue;
+        }
+        const status = String(attributes.status ?? "");
+        const terminalStates = [
+          "Completed",
+          "Faulted",
+          "Cancelled"
+        ];
+        if (terminalStates.includes(status)) {
+          const success = status === "Completed";
+          const result = {
+            success,
+            jobKey,
+            traceId,
+            finalState: status,
+            duration: Date.now() - startTime
+          };
+          options.onComplete?.(result);
+          return result;
+        }
+      }
+      await new Promise((resolve) => setTimeout(resolve, pollInterval));
+      pollCount++;
+    }
+    throw new Error(`Polling timed out after ${(maxPolls * pollInterval / 1000).toFixed(1)}s`);
+  })());
+  if (outerError) {
+    const err = outerError instanceof Error ? outerError : new Error("Unknown error");
+    options.onError?.(err);
+    return {
+      success: false,
+      jobKey,
+      traceId,
+      error: err.message,
+      duration: Date.now() - startTime,
+      finalState: "Failed"
+    };
+  }
+  return outerResult;
+}
+async function getJobStatusDetailed(config, jobKey) {
+  const organizationUnitId = await resolveOrganizationUnitId(config);
+  const sdkConfig = await createOrchestratorConfig({
+    folderId: organizationUnitId?.toString(),
+    tenant: config.tenantName
+  });
+  const jobsApi = new JobsApi(sdkConfig);
+  if (!/^[0-9a-fA-F-]+$/.test(jobKey)) {
+    throw new Error(`Invalid job key format: "${jobKey}"`);
+  }
+  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];
+}
+async function resolveOrganizationUnitId(config) {
+  if (config.organizationUnitId !== undefined) {
+    return config.organizationUnitId;
+  }
+  if (!config.folderKey) {
+    return;
+  }
+  const folder = await resolveFolder({ folderKey: config.folderKey }, { tenant: config.tenantName });
+  if (folder?.id === undefined || folder.id === null) {
+    throw new Error(`Folder with key '${config.folderKey}' could not be resolved to an organization unit ID.`);
+  }
+  config.organizationUnitId = folder.id;
+  return folder.id;
+}
+async function validateCaseInputs(config, inputs) {
+  const [error, validationResult] = await catchError((async () => {
+    const entryPoints = await getCaseEntryPoints(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" && 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
+    };
+  })());
+  if (error) {
+    return {
+      valid: false,
+      errors: [
+        `Failed to validate inputs: ${error instanceof Error ? error.message : String(error)}`
+      ]
+    };
+  }
+  return validationResult;
+}
+async function parseCaseInputs(inputSource) {
+  return await parseJsonInputOrFile(inputSource);
+}
+export {
+  getCaseEntryPoints,
+  getJobStatusDetailed,
+  listCaseProcesses,
+  parseCaseInputs,
+  resolveOrganizationUnitId,
+  spanToTraceEvent,
+  startCaseProjectJob,
+  streamJobTraces,
+  validateCaseInputs
+};
+
+//# debugId=9AD4F87B84A79AEF64756E2164756E21