@uipath/vertical-solutions-tool 1.204.0 → 1.205.0-preview.258

package/dist/tool-tjhwq0ez.js

@@ -0,0 +1,261 @@
+import {
+  catchError,
+  extractErrorDetails
+} from "./tool-pz9qm3dv.js";
+import {
+  __require
+} from "./tool-1yh8g550.js";
+
+// src/api/solution-deployments.ts
+class SolutionDeploymentsError extends Error {
+  errorCode;
+  refusal;
+  name = "SolutionDeploymentsError";
+  constructor(message, errorCode, refusal) {
+    super(message);
+    this.errorCode = errorCode;
+    this.refusal = refusal;
+  }
+}
+var INSTALLED_ACTIVATION_STATUSES = new Set([
+  "Active",
+  "NeedsSetupToActivate",
+  "ReadyToActivate",
+  "Inactive",
+  "ActivationFailed",
+  "DeactivationFailed"
+]);
+var FAILED_OPERATION_STATUSES = new Set(["Failed", "FailedRollback"]);
+var PENDING_SETUP_OPERATIONS = new Set(["ActivationSetup", "VersionChange"]);
+function newestDeployment(deployments) {
+  let newest;
+  let newestAt = Number.NEGATIVE_INFINITY;
+  for (const deployment of deployments) {
+    const at = startedMillis(deployment);
+    if (newest === undefined || at > newestAt) {
+      newest = deployment;
+      newestAt = at;
+    }
+  }
+  return newest;
+}
+function startedMillis(deployment) {
+  const millis = timeOf(deployment.deploymentCreationTime ?? deployment.startTime);
+  return Number.isFinite(millis) ? millis : 0;
+}
+function timeOf(value) {
+  return value ? new Date(value).getTime() : Number.NaN;
+}
+function isCompletedUninstall(deployment) {
+  return deployment.operation === "Uninstall" && deployment.operationStatus === "Successful";
+}
+function isInstalledDeployment(deployment) {
+  if (isCompletedUninstall(deployment))
+    return false;
+  if (deployment.operation === "Install" && FAILED_OPERATION_STATUSES.has(deployment.operationStatus ?? "")) {
+    return false;
+  }
+  if (INSTALLED_ACTIVATION_STATUSES.has(deployment.activationStatus ?? "")) {
+    return true;
+  }
+  return deployment.operationStatus === "Draft" && PENDING_SETUP_OPERATIONS.has(deployment.operation ?? "");
+}
+var DEPLOYMENT_PAGE_SIZE = 100;
+var MAX_DEPLOYMENT_PAGES = 100;
+async function listSolutionDeployments(config, signal, packageName) {
+  const auth = await solutionAuth(config);
+  const { searchDeployments } = await import("./deployment-search-arbm2z06.js");
+  const [error, raw] = await catchError(searchDeployments(auth, {
+    orderByColumn: "startTime",
+    orderByDirection: "Descending",
+    ...packageName ? { packageName } : {},
+    ...signal ? { scope: { signal } } : {},
+    pageSize: DEPLOYMENT_PAGE_SIZE,
+    maxPages: MAX_DEPLOYMENT_PAGES
+  }));
+  if (error || !raw)
+    throw await toSolutionDeploymentsError(error);
+  return raw.map(toSolutionDeployment);
+}
+var NAMED_DEPLOYMENT_PAGE_SIZE = 50;
+async function listDeploymentsNamed(config, name, signal) {
+  const auth = await solutionAuth(config);
+  const { searchDeploymentsPage } = await import("./deployment-search-arbm2z06.js");
+  const wanted = name.toLowerCase();
+  const readAll = async (filter) => {
+    const rows = [];
+    let skip = 0;
+    for (let page = 0;page < MAX_DEPLOYMENT_PAGES; page += 1) {
+      const [error, result] = await catchError(searchDeploymentsPage(auth, {
+        ...filter,
+        take: NAMED_DEPLOYMENT_PAGE_SIZE,
+        skip,
+        orderByColumn: "startTime",
+        orderByDirection: "Descending"
+      }, signal ? { signal } : undefined));
+      if (error || !result)
+        throw await toSolutionDeploymentsError(error);
+      for (const record of result.values) {
+        if (record.name.toLowerCase() === wanted) {
+          rows.push(toSolutionDeployment(record));
+        }
+      }
+      skip += result.values.length;
+      const lastPage = result.values.length < NAMED_DEPLOYMENT_PAGE_SIZE || result.count !== undefined && skip >= result.count;
+      if (lastPage)
+        return rows;
+    }
+    throw new SolutionDeploymentsError(`Could not check the deployment name "${name}": the search kept returning records after ${skip} of them.`, "server_error");
+  };
+  const byName = await readAll({ deploymentName: name });
+  if (byName.length > 0)
+    return byName;
+  return readAll({ searchTerm: name });
+}
+async function solutionAuth(config) {
+  const tenantName = requireSolutionRouteContext(config);
+  const { getSolutionAuthContext } = await import("./solution-auth-zq6gyxsv.js");
+  return getSolutionAuthContext({ tenant: tenantName });
+}
+async function toSolutionDeploymentsError(error) {
+  const {
+    DeploymentSearchNeedsUserSessionError,
+    DeploymentSearchTruncatedError
+  } = await import("./deployment-search-arbm2z06.js");
+  if (error instanceof DeploymentSearchNeedsUserSessionError) {
+    return new SolutionDeploymentsError("Could not list solution deployments: this tenant's Automation Solutions search reads user logins only, and this login is an application.", "permission_denied", "needs-user-session");
+  }
+  if (error instanceof DeploymentSearchTruncatedError) {
+    return new SolutionDeploymentsError(`Could not read every solution deployment on this tenant: read ${error.rowsRead} rows and more remain.`, "server_error");
+  }
+  const { errorCode, message } = await extractErrorDetails(error);
+  return new SolutionDeploymentsError(`Could not list solution deployments: ${message}`, errorCode);
+}
+function requireSolutionRouteContext(config) {
+  if (!config.tenantName) {
+    throw new SolutionDeploymentsError("No tenant selected — run 'uip login tenant set <tenant>' first.", "configuration_error");
+  }
+  if (!config.organizationId) {
+    throw new SolutionDeploymentsError("The login carries no organization id, which the Automation Solutions route " + "needs — run 'uip login' again.", "configuration_error");
+  }
+  return config.tenantName;
+}
+function toSolutionDeployment(record) {
+  return {
+    name: record.name,
+    packageName: record.packageName,
+    packageVersion: record.currentPackageVersion || record.packageVersion,
+    installedRootFolderKey: record.installedRootFolderKey || undefined,
+    folderPath: record.folderPath ?? undefined,
+    activationStatus: record.activationStatus,
+    operation: record.operation,
+    operationStatus: record.operationStatus,
+    startTime: isoOf(record.startTime),
+    deploymentCreationTime: isoOf(record.deploymentCreationTime)
+  };
+}
+function isoOf(value) {
+  if (value === null || value === undefined)
+    return;
+  return typeof value === "string" ? value : value.toISOString();
+}
+function solutionNameFromManifest(manifest) {
+  const artifact = manifest.solution?.artifactFilename ?? "";
+  if (!artifact.endsWith(".zip"))
+    return "";
+  const version = manifest.packageVersion ?? "";
+  const versionSuffix = `_${version}.zip`;
+  if (version && artifact.endsWith(versionSuffix)) {
+    return artifact.slice(0, -versionSuffix.length);
+  }
+  const stem = artifact.slice(0, -".zip".length);
+  const lastUnderscore = stem.lastIndexOf("_");
+  return lastUnderscore > 0 ? stem.slice(0, lastUnderscore) : stem;
+}
+function resolveInstalledFolder(input) {
+  if (!input.solutionName)
+    return { kind: "none" };
+  if (input.deploymentName) {
+    const wanted = input.deploymentName.toLowerCase();
+    const generation = newestDeployment(input.deployments.filter((deployment) => deployment.name.toLowerCase() === wanted));
+    const match = generation && asInstalled(generation);
+    if (!match || !isSameInstall(match, input))
+      return { kind: "none" };
+    return {
+      kind: "resolved",
+      folderKey: match.installedRootFolderKey,
+      deployment: match
+    };
+  }
+  const candidates = newestPerName(input.deployments).flatMap((deployment) => {
+    const installed = asInstalled(deployment);
+    return installed && isSameInstall(installed, input) ? [installed] : [];
+  });
+  const [only, ...others] = candidates;
+  if (only === undefined)
+    return { kind: "none" };
+  if (others.length === 0) {
+    return {
+      kind: "resolved",
+      folderKey: only.installedRootFolderKey,
+      deployment: only
+    };
+  }
+  const newest = input.preferNewest ? newestDeployment(candidates) : undefined;
+  if (newest) {
+    return {
+      kind: "resolved",
+      folderKey: newest.installedRootFolderKey,
+      deployment: newest
+    };
+  }
+  return { kind: "ambiguous", candidates };
+}
+function asInstalled(deployment) {
+  const folderKey = deployment.installedRootFolderKey;
+  if (!folderKey || !isInstalledDeployment(deployment))
+    return;
+  return { ...deployment, installedRootFolderKey: folderKey };
+}
+function newestPerName(deployments) {
+  const byName = new Map;
+  for (const deployment of deployments) {
+    const key = deployment.name.toLowerCase();
+    const rows = byName.get(key);
+    if (rows)
+      rows.push(deployment);
+    else
+      byName.set(key, [deployment]);
+  }
+  const newest = [];
+  for (const rows of byName.values()) {
+    const row = newestDeployment(rows);
+    if (row)
+      newest.push(row);
+  }
+  return newest;
+}
+function isSameInstall(deployment, input) {
+  const solution = input.solutionName?.toLowerCase();
+  const recorded = (deployment.packageName || deployment.name).toLowerCase();
+  if (solution && recorded !== solution)
+    return false;
+  return !input.packageVersion || deployment.packageVersion === input.packageVersion;
+}
+async function listDeploymentsOfSolution(config, solutionName, signal, deploymentName) {
+  if (!solutionName)
+    return [];
+  if (deploymentName) {
+    return listDeploymentsNamed(config, deploymentName, signal);
+  }
+  const narrowed = await listSolutionDeployments(config, signal, solutionName);
+  const wanted = solutionName.toLowerCase();
+  const hasMatch = narrowed.some((deployment) => (deployment.packageName || deployment.name).toLowerCase() === wanted);
+  if (hasMatch)
+    return narrowed;
+  return listSolutionDeployments(config, signal);
+}
+
+export { SolutionDeploymentsError, newestDeployment, isCompletedUninstall, isInstalledDeployment, DEPLOYMENT_PAGE_SIZE, MAX_DEPLOYMENT_PAGES, listSolutionDeployments, NAMED_DEPLOYMENT_PAGE_SIZE, listDeploymentsNamed, solutionNameFromManifest, resolveInstalledFolder, listDeploymentsOfSolution };
+
+//# debugId=4483E08B7F109E9D64756E2164756E21

package/dist/tool-v15vxc4x.js

@@ -0,0 +1,183 @@
+import {
+  forDisplay
+} from "./tool-rr9fensp.js";
+import {
+  OutputFormatter,
+  ScreenLogger,
+  getOutputFormat,
+  getOutputFormatExplicit,
+  getOutputSink
+} from "./tool-pz9qm3dv.js";
+
+// src/services/job-output.ts
+function renderForHuman() {
+  if (getOutputFormatExplicit())
+    return getOutputFormat() !== "json";
+  return getOutputSink().capabilities.isInteractive;
+}
+function emitLines(message, key) {
+  for (const line of message.split(`
+`)) {
+    if (line === "")
+      continue;
+    OutputFormatter.log({ [key]: line });
+  }
+}
+var SERVICE_SUCCESS_LINE = "Deployment succeeded.";
+function logLineText(message) {
+  return forDisplay(message).replaceAll(`
+`, " ");
+}
+function writeJobLogLine(line) {
+  const message = logLineText(line.message);
+  if (renderForHuman()) {
+    ScreenLogger.progress(`  ${message}`);
+    return;
+  }
+  OutputFormatter.log({
+    Seq: typeof line.seq === "string" ? logLineText(line.seq) : line.seq,
+    Level: line.level === undefined ? undefined : logLineText(line.level),
+    Message: message
+  });
+}
+function writeProgress(text) {
+  const message = forDisplay(text);
+  if (renderForHuman()) {
+    ScreenLogger.progress(message);
+    return;
+  }
+  emitLines(message, "Message");
+}
+function writeWarning(text) {
+  const message = forDisplay(text);
+  if (renderForHuman()) {
+    const [first, ...rest] = message.split(`
+`);
+    ScreenLogger.progress(`Warning: ${first}`);
+    for (const line of rest)
+      ScreenLogger.progress(line);
+    return;
+  }
+  emitLines(message, "Warning");
+}
+function collapseRowProblems(problems) {
+  const ROW = /^(.*?) row (\d+)([:,] .*)$/;
+  const entries = [];
+  const groups = new Map;
+  const seen = new Set;
+  for (const problem of problems) {
+    const match = ROW.exec(problem);
+    if (!match) {
+      if (!seen.has(problem)) {
+        seen.add(problem);
+        entries.push(problem);
+      }
+      continue;
+    }
+    const [, prefix, row, suffix] = match;
+    const key = `${prefix}${suffix}`;
+    const existing = groups.get(key);
+    if (existing) {
+      existing.rows.push(Number(row));
+      continue;
+    }
+    const group = { prefix, suffix, rows: [Number(row)] };
+    groups.set(key, group);
+    entries.push(group);
+  }
+  return entries.map((entry) => {
+    if (typeof entry === "string")
+      return entry;
+    const rows = entry.rows.length === 1 ? `row ${entry.rows[0]}` : `rows ${formatRanges(entry.rows)}`;
+    return `${entry.prefix} ${rows}${entry.suffix}`;
+  });
+}
+function formatRanges(rows) {
+  const sorted = [...rows].sort((a, b) => a - b);
+  const parts = [];
+  let start = sorted[0];
+  let previous = sorted[0];
+  for (const row of sorted.slice(1)) {
+    if (row === previous + 1) {
+      previous = row;
+      continue;
+    }
+    parts.push(start === previous ? `${start}` : `${start}-${previous}`);
+    start = row;
+    previous = row;
+  }
+  parts.push(start === previous ? `${start}` : `${start}-${previous}`);
+  return parts.join(", ");
+}
+var STEP_MARKERS = {
+  succeeded: "✓",
+  failed: "✗",
+  running: "…"
+};
+function stepLabel(step) {
+  return step.key.toLowerCase().replaceAll("_", "-");
+}
+function formatStepSummary(job) {
+  const executed = job.steps.filter((step) => step.status !== "skipped");
+  if (executed.length === 0)
+    return "No steps recorded.";
+  return inExecutionOrder(executed).map((step) => `${STEP_MARKERS[step.status] ?? "?"} ${stepLabel(step)}`).join(" → ");
+}
+function inExecutionOrder(steps) {
+  const timedSlots = [];
+  const timed = [];
+  steps.forEach((step, index) => {
+    const at = Date.parse(step.startedAt ?? "");
+    if (!Number.isFinite(at))
+      return;
+    timedSlots.push(index);
+    timed.push({ step, at, index });
+  });
+  if (timed.length < 2)
+    return steps;
+  timed.sort((a, b) => a.at - b.at || a.index - b.index);
+  const ordered = [...steps];
+  timedSlots.forEach((slot, position) => {
+    ordered[slot] = timed[position].step;
+  });
+  return ordered;
+}
+function formatSkippedSteps(job) {
+  const skipped = job.steps.filter((step) => step.status === "skipped").map(stepLabel).sort((a, b) => a.localeCompare(b));
+  if (skipped.length === 0)
+    return;
+  return `Skipped (not applicable): ${skipped.join(", ")}`;
+}
+function writeStepSummary(job) {
+  writeProgress(`  Steps: ${formatStepSummary(job)}`);
+  const skipped = formatSkippedSteps(job);
+  if (skipped)
+    writeProgress(`  ${skipped}`);
+}
+function failedStepsOf(job) {
+  return job.steps.filter((step) => step.status === "failed").map((step) => forDisplay(step.key));
+}
+function writeSuccessSummary(job, lastLogMessage) {
+  const failed = job.steps.filter((step) => step.status === "failed");
+  if (failed.length === 0) {
+    if (lastLogMessage?.trim() !== SERVICE_SUCCESS_LINE) {
+      writeProgress(`
+${SERVICE_SUCCESS_LINE}`);
+    }
+  } else {
+    writeWarning("Deployment succeeded — with warnings:");
+    for (const step of failed) {
+      writeProgress(`  !  ${stepLabel(step)} — ${step.detail ?? "failed"}`);
+    }
+    writeProgress("  These optional steps did not block the deployment. Fix the cause in the " + "package and deploy a new version to address them.");
+  }
+  writeStepSummary(job);
+}
+function runningStepOf(job) {
+  const running = job.steps.find((step) => step.status === "running");
+  return running ? stepLabel(running) : undefined;
+}
+
+export { logLineText, writeJobLogLine, writeProgress, writeWarning, collapseRowProblems, stepLabel, formatStepSummary, inExecutionOrder, formatSkippedSteps, writeStepSummary, failedStepsOf, writeSuccessSummary, runningStepOf };
+
+//# debugId=0843E80C22EE50B464756E2164756E21