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

package/dist/tool-gvmshnq9.js

@@ -0,0 +1,555 @@
+import {
+  failedStepsOf,
+  logLineText,
+  runningStepOf,
+  writeJobLogLine,
+  writeProgress,
+  writeStepSummary,
+  writeWarning
+} from "./tool-v15vxc4x.js";
+import {
+  createVssConfig
+} from "./tool-xd2ejt3h.js";
+import {
+  finishedJobConflict,
+  knownJobStatus
+} from "./tool-r2epw08s.js";
+import {
+  cancelDeployJob,
+  getDeployJob,
+  getDeployJobLogs,
+  resumeDeployJob
+} from "./tool-mn1wkbhw.js";
+import {
+  isCapacityError,
+  isTransientError
+} from "./tool-4z1dy1rn.js";
+import {
+  TERMINAL_JOB_STATUSES
+} from "./tool-s04z9t80.js";
+import {
+  ErrorDecision,
+  PollOutcome,
+  canPrompt,
+  catchError,
+  pollUntil
+} from "./tool-pz9qm3dv.js";
+
+// src/services/watch/state.ts
+function startDeadline(timeoutMs) {
+  if (!timeoutMs || timeoutMs <= 0)
+    return;
+  const controller = new AbortController;
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  return { signal: controller.signal, stop: () => clearTimeout(timer) };
+}
+function noteDeadline(state, options) {
+  if (!deadlineCut(state, options))
+    return false;
+  state.timedOut = true;
+  return true;
+}
+function deadlineCut(state, options) {
+  return !options.signal?.aborted && state.deadlineSignal?.aborted === true;
+}
+function eitherSignal(first, second) {
+  if (!first)
+    return second;
+  if (!second)
+    return first;
+  return AbortSignal.any([first, second]);
+}
+async function withinWatchDeadline(state, options, start) {
+  const remaining = state.deadlineMs === undefined ? undefined : state.deadlineMs - Date.now();
+  if (remaining !== undefined && remaining <= 0) {
+    state.timedOut = true;
+    return [undefined, undefined];
+  }
+  const deadline = remaining === undefined ? undefined : AbortSignal.timeout(remaining);
+  const stops = [deadline, options.signal].filter((signal) => signal !== undefined);
+  const work = catchError(start());
+  if (stops.length === 0)
+    return await work;
+  const giveUp = stops.length === 1 ? stops[0] : AbortSignal.any(stops);
+  const gaveUp = [undefined, undefined];
+  const raced = await Promise.race([
+    work,
+    whenAborted(giveUp).then(() => gaveUp)
+  ]);
+  if (raced[0] !== undefined || raced[1] !== undefined)
+    return raced;
+  if (options.signal?.aborted === true)
+    state.resumeInterrupted = true;
+  else if (deadline?.aborted === true)
+    state.timedOut = true;
+  return [undefined, undefined];
+}
+function whenAborted(signal) {
+  if (signal.aborted)
+    return Promise.resolve();
+  return new Promise((resolve) => {
+    signal.addEventListener("abort", () => resolve(), { once: true });
+  });
+}
+async function beforeDeadline(state, run, interrupt) {
+  if (interrupt?.aborted) {
+    state.resumeInterrupted = true;
+    return { timedOut: true };
+  }
+  if (state.deadlineMs !== undefined && Date.now() >= state.deadlineMs) {
+    state.timedOut = true;
+    return { timedOut: true };
+  }
+  const deadline = state.deadlineMs === undefined ? undefined : new AbortController;
+  const timer = deadline && state.deadlineMs !== undefined ? setTimeout(() => deadline.abort(), Math.max(0, state.deadlineMs - Date.now())) : undefined;
+  const [error, value] = await catchError(run(eitherSignal(deadline?.signal, interrupt)));
+  clearTimeout(timer);
+  if (interrupt?.aborted) {
+    state.resumeInterrupted = true;
+    return { timedOut: true };
+  }
+  if (deadline?.signal.aborted) {
+    state.timedOut = true;
+    return { timedOut: true };
+  }
+  if (error)
+    throw error;
+  return { timedOut: false, value };
+}
+
+// src/services/watch/logs.ts
+async function advanceLogs(state, holder, options, signal, jobFinished) {
+  const [logError, drained] = await catchError(drainLogs(holder.current, options, state.afterSeq, signal));
+  if (!logError) {
+    state.afterSeq = drained.cursor;
+    state.lastLogMessage = drained.lastMessage ?? state.lastLogMessage;
+    return;
+  }
+  if (options.signal?.aborted === true) {
+    throw logError;
+  }
+  if (deadlineCut(state, options)) {
+    if (!jobFinished)
+      state.timedOut = true;
+    return;
+  }
+  if (state.warnedAboutLogs)
+    return;
+  writeWarning(`Could not read the job log (${logError.message}). The deploy is still ` + "being watched; follow it in the service's own log.");
+  state.warnedAboutLogs = true;
+}
+async function drainLogs(config, options, afterSeq, signal) {
+  const lines = await getDeployJobLogs(config, options.jobId, afterSeq, signal);
+  let cursor = afterSeq;
+  let lastMessage;
+  for (const line of lines) {
+    writeJobLogLine(line);
+    lastMessage = logLineText(line.message).trim();
+    const seq = Number(line.seq);
+    if (Number.isFinite(seq))
+      cursor = Math.max(cursor, seq);
+  }
+  return { cursor, lastMessage };
+}
+
+// src/services/capacity-retry.ts
+var CAPACITY_RETRY_ATTEMPTS = 3;
+var CAPACITY_RETRY_DELAY_MS = 5000;
+async function withCapacityRetry(operation, description, sleep = defaultSleep, signal) {
+  for (let attempt = 1;attempt <= CAPACITY_RETRY_ATTEMPTS; attempt += 1) {
+    signal?.throwIfAborted();
+    const [error, value] = await catchError(operation());
+    if (!error)
+      return value;
+    const lastAttempt = attempt === CAPACITY_RETRY_ATTEMPTS;
+    if (!isCapacityError(error) || lastAttempt)
+      throw error;
+    writeWarning(`Service at capacity — retrying ${description} in ` + `${CAPACITY_RETRY_DELAY_MS / 1000}s ` + `(${attempt}/${CAPACITY_RETRY_ATTEMPTS}).`);
+    await sleep(CAPACITY_RETRY_DELAY_MS, signal);
+  }
+  throw new Error(`Failed to ${description}.`);
+}
+function defaultSleep(ms, signal) {
+  return new Promise((resolve, reject) => {
+    if (signal?.aborted) {
+      reject(signal.reason);
+      return;
+    }
+    const onAbort = () => {
+      clearTimeout(timer);
+      reject(signal?.reason);
+    };
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve();
+    }, ms);
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+
+// src/services/watch/recovery.ts
+var CONFIG_REFRESH_INTERVAL_MS = 5 * 60000;
+var TOKEN_REFRESH_ATTEMPTS = 3;
+function reauthenticate(options) {
+  return createVssConfig({
+    tenant: options.tenant,
+    loginValidity: options.loginValidity,
+    serviceUrl: options.serviceUrl
+  });
+}
+async function refreshConfigIfStale(state, holder, options) {
+  if (Date.now() - holder.builtAtMs < CONFIG_REFRESH_INTERVAL_MS)
+    return;
+  const [, refreshed] = await withinWatchDeadline(state, options, () => reauthenticate(options));
+  if (!refreshed)
+    return;
+  holder.current = refreshed;
+  holder.builtAtMs = Date.now();
+}
+async function handleActionRequired(job, holder, options, state, canRefreshToken) {
+  const required = job.actionRequired;
+  const kind = required?.kind ?? "configuration_setup";
+  const url = required?.url;
+  if (kind === "token_expired") {
+    return refreshTokenAndResume(job, holder, options, state, canRefreshToken);
+  }
+  if (kind === "configuration_setup" && options.sentResourceConfigurations) {
+    writeWarning("The deployment paused for configuration although per-resource values were submitted. " + "If the job log above names a rejected value — a routing name already in use, for " + "example — fix it in deploy-config.json (or the file passed with --resource-config), or " + "complete the portal wizard, then resume. If no value is named, the service may " + "predate the per-resource configuration " + "contract and dropped the field.");
+  }
+  const prompt = options.prompt;
+  if (!canPrompt() || !prompt) {
+    return job;
+  }
+  writeProgress(`
+  ${describePause(kind)}`);
+  if (url) {
+    const page = pageNameFor(kind);
+    writeProgress(`  ${page} page: ${url}`);
+    const open = await beforeDeadline(state, (signal) => options.openBrowser ? prompt.confirmOpenBrowser(page, signal) : Promise.resolve(false), options.signal);
+    if (open.timedOut)
+      return job;
+    if (open.value)
+      await openInBrowser(prompt, url);
+  }
+  const done = await beforeDeadline(state, (signal) => prompt.waitForActionRequired(kind, url, signal), options.signal);
+  if (done.timedOut)
+    return job;
+  return resumeWithCapacityRetry(holder, options, state, job);
+}
+async function refreshTokenAndResume(job, holder, options, state, canRefreshToken) {
+  if (!canRefreshToken) {
+    writeWarning(`The job asked for a fresh token ${TOKEN_REFRESH_ATTEMPTS} times and the one this ` + "login hands out is not lasting. Run 'uip login' again, then resume the job.");
+    return job;
+  }
+  const [refreshError, refreshed] = await withinWatchDeadline(state, options, () => reauthenticate(options));
+  if (!refreshed) {
+    if (!state.resumeInterrupted) {
+      writeWarning(`The job's token expired and re-authenticating failed${refreshError ? ` (${refreshError.message})` : ""}. Run 'uip login', then resume the job.`);
+    }
+    return job;
+  }
+  if (options.signal?.aborted) {
+    state.resumeInterrupted = true;
+    return job;
+  }
+  if (holder.sealedToken !== undefined && refreshed.accessToken === holder.sealedToken) {
+    writeWarning("The job's token expired, and this login cannot renew it (a client-credentials " + "or environment login). Run 'uip login', then resume the job.");
+    return job;
+  }
+  holder.current = refreshed;
+  holder.builtAtMs = Date.now();
+  writeProgress("  Token refreshed — resuming.");
+  return resumeWithCapacityRetry(holder, options, state, job);
+}
+async function openInBrowser(prompt, url) {
+  const [openError] = await catchError(prompt.openUrl(url));
+  if (openError) {
+    writeWarning(`Could not open a browser (${openError.message}) — use the URL above.`);
+  }
+}
+function pageNameFor(kind) {
+  switch (kind) {
+    case "activation_setup":
+      return "Setup";
+    case "connection_setup":
+      return "Connections";
+    case "configuration_setup":
+      return "Configuration";
+    default:
+      return "Action";
+  }
+}
+function describePause(kind) {
+  switch (kind) {
+    case "activation_setup":
+      return "The deployment needs activation setup before it can continue.";
+    case "connection_setup":
+      return "The deployment needs its connections authorized before it can continue.";
+    case "configuration_setup":
+      return "The deployment is waiting on the portal's configuration wizard.";
+    default:
+      return "The deployment is paused and needs attention.";
+  }
+}
+async function handleFailure(job, holder, options, state) {
+  const step = job.error?.step ? ` at step ${job.error.step}` : "";
+  writeWarning(`Deployment failed${step}: ${job.error?.message ?? "unknown error"}`);
+  writeStepSummary(job);
+  const prompt = options.prompt;
+  if (!canPrompt() || !prompt)
+    return job;
+  if (state.deadlineSignal?.aborted)
+    return job;
+  const retry = await beforeDeadline(state, (signal) => prompt.confirmResume(job, signal), options.signal);
+  if (retry.timedOut || !retry.value)
+    return job;
+  return resumeWithCapacityRetry(holder, options, state, job);
+}
+async function resumeWithCapacityRetry(holder, options, state, job) {
+  const [error, attempt] = await catchError(beforeDeadline(state, (deadline) => {
+    const signal = eitherSignal(options.signal, deadline);
+    return withCapacityRetry(() => resumeDeployJob(holder.current, options.jobId, undefined, signal), "the resume", undefined, signal);
+  }));
+  if (attempt?.timedOut) {
+    state.resumeUnconfirmed = true;
+    return job;
+  }
+  if (options.signal?.aborted) {
+    state.resumeInterrupted = true;
+    state.resumeUnconfirmed = true;
+    writeProgress("  The resume was sent; its answer did not arrive before you let go. " + "The job may already be running again.");
+    return job;
+  }
+  if (error || !attempt?.value) {
+    const moved = finishedJobConflict(error, "resume");
+    if (moved) {
+      return followMovedJob(holder, options, state, job, error, moved);
+    }
+    state.resumeError = error ?? new Error("The resume returned no job.");
+    throw state.resumeError;
+  }
+  holder.sealedToken = holder.current.accessToken;
+  writeProgress("  Resumed from the last checkpoint.");
+  return attempt.value;
+}
+async function followMovedJob(holder, options, state, job, error, moved) {
+  const status = knownJobStatus(moved.status);
+  writeProgress(`  The resume was refused: the job is ${status ?? moved.status}. Reading it back.`);
+  const moveOn = (next) => {
+    if (next.status === "running" || next.status === "queued") {
+      holder.sealedToken = undefined;
+    }
+    state.lastJob = next;
+    return next;
+  };
+  const withNamedStatus = () => status ? moveOn({ ...job, status }) : job;
+  if (status === "running" || status === "queued") {
+    return moveOn({ ...job, status });
+  }
+  const [readError, read] = await catchError(beforeDeadline(state, (deadline) => getDeployJob(holder.current, options.jobId, eitherSignal(options.signal, deadline))));
+  if (read?.timedOut)
+    return withNamedStatus();
+  if (options.signal?.aborted) {
+    state.resumeInterrupted = true;
+    return withNamedStatus();
+  }
+  const fresh = readError ? undefined : read?.value;
+  if (fresh)
+    return moveOn(fresh);
+  if (!status) {
+    state.resumeError = error ?? new Error("The resume failed.");
+    throw state.resumeError;
+  }
+  return moveOn({ ...job, status });
+}
+
+// src/services/watch-job.ts
+var DEFAULT_POLL_INTERVAL_MS = 3000;
+var POLL_FAILURE_TOLERANCE = 5;
+var QUIET_POLLS_PER_HEARTBEAT = 10;
+function watchOptionsFrom(flags, job) {
+  return {
+    ...job,
+    tenant: flags.tenant,
+    loginValidity: flags.loginValidity,
+    pollIntervalMs: flags.pollInterval,
+    timeoutMs: (flags.timeout ?? 0) * 1000,
+    signal: flags.signal,
+    openBrowser: flags.browser !== false
+  };
+}
+async function watchDeployJob(options) {
+  const holder = {
+    current: options.config,
+    builtAtMs: Date.now(),
+    sealedToken: options.attached ? undefined : options.config.accessToken
+  };
+  const deadline = startDeadline(options.timeoutMs);
+  const state = {
+    afterSeq: options.initialAfterSeq ?? 0,
+    lastLogMessage: undefined,
+    quietPolls: 0,
+    warnedAboutLogs: false,
+    tokenRefreshes: 0,
+    lastError: undefined,
+    deadlineMs: options.timeoutMs && options.timeoutMs > 0 ? Date.now() + options.timeoutMs : undefined,
+    deadlineSignal: deadline?.signal,
+    timedOut: false,
+    lastJob: undefined,
+    resumeInterrupted: false,
+    resumeUnconfirmed: false,
+    resumeError: undefined
+  };
+  const result = await pollUntil({
+    fn: () => pollOnce(state, holder, options),
+    until: (job) => TERMINAL_JOB_STATUSES.has(job.status) || job.status === "action_required",
+    getStatus: (job) => job.status,
+    intervalMs: options.pollIntervalMs ?? DEFAULT_POLL_INTERVAL_MS,
+    timeoutMs: options.timeoutMs ?? 0,
+    maxConsecutiveErrors: POLL_FAILURE_TOLERANCE,
+    signal: options.signal,
+    beforePoll: async () => {
+      await refreshConfigIfStale(state, holder, options);
+    },
+    onError: (error, consecutiveCount) => {
+      state.lastError = error;
+      if (state.timedOut)
+        return ErrorDecision.Abort;
+      if (isPromptInterrupt(error))
+        return ErrorDecision.Abort;
+      if (state.resumeError)
+        return ErrorDecision.Abort;
+      if (!isTransientError(error))
+        return ErrorDecision.Abort;
+      if (options.signal?.aborted)
+        return;
+      writeWarning(`Poll failed (${consecutiveCount}/${POLL_FAILURE_TOLERANCE}) — retrying.`);
+      return;
+    }
+  });
+  deadline?.stop();
+  if (state.timedOut) {
+    return {
+      kind: "timeout",
+      ...state.resumeUnconfirmed ? {} : { job: result.data },
+      elapsedMs: result.elapsedMs
+    };
+  }
+  if (state.resumeInterrupted) {
+    return state.resumeUnconfirmed ? { kind: "detached" } : { kind: "detached", job: state.lastJob ?? result.data };
+  }
+  if (state.resumeError) {
+    return {
+      kind: "rejected",
+      job: result.data,
+      error: state.resumeError,
+      attempting: "resume"
+    };
+  }
+  const outcome = toOutcome(result.outcome, state.lastJob ?? result.data, result.elapsedMs, state.lastError);
+  return outcome.kind === "succeeded" ? {
+    ...outcome,
+    lastLogMessage: state.lastLogMessage,
+    config: holder.current
+  } : outcome;
+}
+async function pollOnce(state, holder, options) {
+  const signal = eitherSignal(options.signal, state.deadlineSignal);
+  const [jobError, job] = await catchError(getDeployJob(holder.current, options.jobId, signal));
+  if (jobError) {
+    noteDeadline(state, options);
+    throw jobError;
+  }
+  state.lastJob = job;
+  const previousSeq = state.afterSeq;
+  const finished = TERMINAL_JOB_STATUSES.has(job.status);
+  await advanceLogs(state, holder, options, signal, finished);
+  if (state.timedOut)
+    return job;
+  if (options.signal?.aborted) {
+    throw options.signal.reason instanceof Error ? options.signal.reason : new Error("The watch was interrupted.");
+  }
+  if (job.status === "queued" || job.status === "running") {
+    heartbeat(state, job, previousSeq);
+    return job;
+  }
+  state.quietPolls = 0;
+  if (job.status === "action_required") {
+    const canRefresh = state.tokenRefreshes < TOKEN_REFRESH_ATTEMPTS;
+    if (job.actionRequired?.kind === "token_expired" && canRefresh) {
+      state.tokenRefreshes += 1;
+    }
+    return latest(state, await handleActionRequired(job, holder, options, state, canRefresh));
+  }
+  if (job.status === "failed") {
+    return latest(state, await handleFailure(job, holder, options, state));
+  }
+  return job;
+}
+function latest(state, job) {
+  if (!state.resumeInterrupted)
+    state.lastJob = job;
+  return job;
+}
+function heartbeat(state, job, previousSeq) {
+  state.quietPolls = state.afterSeq === previousSeq ? state.quietPolls + 1 : 0;
+  if (state.quietPolls > 0 && state.quietPolls % QUIET_POLLS_PER_HEARTBEAT === 0) {
+    const step = runningStepOf(job);
+    const where = step ? ` (${step})` : "";
+    writeProgress(`  … still working${where}`);
+  }
+}
+function isPromptInterrupt(error) {
+  return error instanceof Error && (error.name === "ExitPromptError" || /force closed the prompt/i.test(error.message));
+}
+function toOutcome(outcome, job, elapsedMs, lastError) {
+  if (outcome === PollOutcome.Interrupted) {
+    return { kind: "detached", job };
+  }
+  if (lastError !== undefined && isPromptInterrupt(lastError)) {
+    return { kind: "detached", job };
+  }
+  if (outcome === PollOutcome.Timeout) {
+    return { kind: "timeout", job, elapsedMs };
+  }
+  if (outcome === PollOutcome.Aborted || outcome === PollOutcome.Failed || job === undefined) {
+    return stoppedOutcome(job, lastError);
+  }
+  if (job.status === "succeeded") {
+    return {
+      kind: "succeeded",
+      job,
+      failedSteps: failedStepsOf(job)
+    };
+  }
+  if (job.status === "canceled") {
+    return { kind: "canceled", job };
+  }
+  if (job.status === "action_required") {
+    const required = job.actionRequired;
+    return {
+      kind: "paused",
+      job,
+      actionKind: required?.kind ?? "configuration_setup",
+      url: required?.url
+    };
+  }
+  return { kind: "failed", job };
+}
+function stoppedOutcome(job, lastError) {
+  if (lastError !== undefined && !isTransientError(lastError)) {
+    return { kind: "rejected", job, error: lastError };
+  }
+  return {
+    kind: "lost-contact",
+    job,
+    error: lastError ?? new Error("Lost contact with the deploy job.")
+  };
+}
+async function requestCancel(config, jobId, signal) {
+  return cancelDeployJob(config, jobId, signal);
+}
+
+export { withCapacityRetry, DEFAULT_POLL_INTERVAL_MS, watchOptionsFrom, watchDeployJob, isPromptInterrupt, requestCancel };
+
+//# debugId=7CAE2AF0F0CAEDE264756E2164756E21

package/dist/tool-h4f967yd.js

@@ -0,0 +1,73 @@
+import {
+  forDisplay,
+  forDisplayIfSet
+} from "./tool-rr9fensp.js";
+import {
+  EXIT_CODES,
+  RESULTS
+} from "./tool-pz9qm3dv.js";
+
+// src/services/results.ts
+var REASON_ENVELOPE = {
+  "missing-option": v("invalid_argument"),
+  "invalid-option": v("invalid_argument"),
+  "unknown-package": v("not_found"),
+  "unknown-version": v("not_found"),
+  "unknown-job": v("not_found"),
+  "blocked-major-upgrade": v("invalid_argument"),
+  "ambiguous-deployment": v("invalid_argument"),
+  "name-conflict": v("invalid_argument"),
+  "tenant-resources-declared": f("invalid_argument"),
+  declined: f("unknown_error"),
+  "not-entitled": f("permission_denied"),
+  "entitlement-check-failed": f("server_error", "RetryLater"),
+  capacity: f("rate_limited", "RetryLater"),
+  "service-error": f("unknown_error"),
+  "job-failed": f("unknown_error"),
+  "job-paused": f("unknown_error"),
+  "job-canceled": f("unknown_error"),
+  "poll-timeout": {
+    result: RESULTS.TimeoutError,
+    errorCode: "timeout",
+    retry: "RetryWillNotFix"
+  },
+  "lost-contact": f("network_error")
+};
+function v(errorCode) {
+  return {
+    result: RESULTS.ValidationError,
+    errorCode,
+    retry: "RetryWillNotFix"
+  };
+}
+function f(errorCode, retry = "RetryWillNotFix") {
+  return { result: RESULTS.Failure, errorCode, retry };
+}
+function failure(reason, message, instructions, options = {}) {
+  const envelope = REASON_ENVELOPE[reason];
+  const result = options.result ?? envelope.result;
+  return {
+    ok: false,
+    reason,
+    message: forDisplay(message),
+    instructions: forDisplay(instructions),
+    result,
+    exitCode: options.exitCode ?? EXIT_CODES[result] ?? 1,
+    correlationId: forDisplayIfSet(options.correlationId),
+    errorCode: options.errorCode ?? envelope.errorCode,
+    retry: options.retry ?? envelope.retry
+  };
+}
+function missingOption(what, flag) {
+  return failure("missing-option", `${what} is required.`, `Pass ${flag}, or run from an interactive terminal to be asked for it.`, { result: RESULTS.ValidationError, errorCode: "invalid_argument" });
+}
+function invalidOption(message, instructions) {
+  return failure("invalid-option", message, instructions, {
+    result: RESULTS.ValidationError,
+    errorCode: "invalid_argument"
+  });
+}
+
+export { failure, missingOption, invalidOption };
+
+//# debugId=176414467BA54D3A64756E2164756E21