@uipath/solution-tool 1.204.0-preview.255 → 1.205.0-preview.256

package/dist/packager-tool-kvcxg0zv.js

@@ -0,0 +1,1510 @@
+import {
+  resolveFeedSelectionAsync
+} from "./packager-tool-zq16e1xv.js";
+import {
+  INCOMPLETE_SWEEP_ADVICE,
+  findDeploymentAcrossFeeds,
+  isNameOrFeedRefusal,
+  reportIncompleteSweepAsync,
+  retryAdvice
+} from "./packager-tool-rc3hwn4b.js";
+import {
+  ACKNOWLEDGE_PERMANENT_DELETION_FLAG,
+  NO_SERVER_REASON,
+  acknowledgedButNotRunHint,
+  activateDeployment,
+  describeValidationFailureAsync,
+  formatPermanentDeletionResources,
+  isPermanentDeletionRefusal,
+  listPermanentDeletionResourcesAsync,
+  pollPipelineDeploymentAsync,
+  remainingTimeoutMs,
+  resolveParentFolder,
+  settlePermanentDeletionRefusalAsync,
+  stillRequiresConfirmation
+} from "./packager-tool-frr2xmkr.js";
+import {
+  deploymentNextSteps,
+  explainRefusal,
+  isCurrentRecordAsync,
+  needsPendingResources,
+  pendingResourceApis,
+  readPendingResourcesAsync,
+  reportedActivationStatus
+} from "./packager-tool-5n6jsn41.js";
+import {
+  DRAFT_VERSION_MISMATCH_CODE,
+  coerceWorkflowErrorMessages,
+  explainPipelineStatusAfterInstall,
+  formatDeploymentFailureDetails,
+  formatServiceErrors,
+  hasServerErrorCode,
+  installLandedDespiteStatus,
+  isBareResponse,
+  leavesPendingDraft
+} from "./packager-tool-act5r386.js";
+import {
+  DeploymentSearchNeedsUserSessionError,
+  findDeploymentByName,
+  findDeploymentsByName,
+  isApplicationSession,
+  isAuthRefusal,
+  isCompletedUninstall,
+  isMissingPipelinesRoute,
+  newestDeploymentRow,
+  parseSearchPage,
+  readDeploymentByKeyAsync,
+  searchDeploymentsPage
+} from "./packager-tool-d6rrfd46.js";
+import {
+  describeFeedResolutionFailureAsync,
+  feedScopeInitOverride,
+  feedSelectorFlag,
+  folderKeyInitOverride,
+  resolveFeedScope,
+  resolvePersonalWorkspace
+} from "./packager-tool-rvt68c1t.js";
+import {
+  Configuration,
+  DeploymentOperation,
+  DeploymentStatus,
+  PipelinesApi
+} from "./packager-tool-97rcgwvv.js";
+import {
+  Configuration as Configuration2,
+  DeploymentsApi,
+  PackageInfoFromJSON,
+  SearchApi,
+  SolutionDeploymentAction,
+  WorkflowAction
+} from "./packager-tool-9t26kde1.js";
+import {
+  classifyFeedSession,
+  feedReadRefusalForApplication,
+  feedSessionRefusal
+} from "./packager-tool-qw47eyw7.js";
+import {
+  getSolutionAuthContext
+} from "./packager-tool-61pwb567.js";
+import {
+  DEFAULT_PAGE_SIZE,
+  PollOutcome,
+  logger,
+  mapPollFailure,
+  pollUntil,
+  quoteForShell
+} from "./packager-tool-tx834spe.js";
+import {
+  catchError,
+  extractErrorDetails
+} from "./packager-tool-6ybywxxn.js";
+
+// src/services/deploy-activate-service.ts
+var fail = (reason, message, instructions, exitCode = 1) => ({
+  ok: false,
+  reason,
+  message,
+  instructions,
+  exitCode
+});
+var AUTH_INSTRUCTIONS = "Run 'uip login' to refresh credentials, then retry activation. If the deployment is in a different tenant, switch with 'uip login tenant set <tenant>'.";
+async function incompleteSweepRefusalAsync(deploymentName, skipped, result) {
+  const details = `Details: ${result.details}`;
+  if (!isNameOrFeedRefusal(result.errorCode, result.httpStatus)) {
+    return {
+      ...fail("request_failed", result.message, `The activation request failed. ${retryAdvice(result.errorCode, result.retry, "Orchestrator")} ${details}`),
+      errorCode: result.errorCode,
+      retry: result.retry
+    };
+  }
+  const report = await reportIncompleteSweepAsync(deploymentName, skipped);
+  return {
+    ...fail("request_failed", report.message, `${INCOMPLETE_SWEEP_ADVICE} Without its feed the activation went to the tenant feed, which refused it. ${report.nextStep} ${details} (feed search: ${report.details})`),
+    errorCode: report.errorCode,
+    retry: report.retry
+  };
+}
+async function activateDeploymentAsync(deploymentName, options = {}) {
+  const [authError, auth] = await catchError(getSolutionAuthContext({
+    tenant: options.tenant,
+    loginValidity: options.loginValidity,
+    envFilePath: options.envFilePath
+  }));
+  if (authError) {
+    return fail("auth_failed", authError.message, AUTH_INSTRUCTIONS);
+  }
+  const selection = await resolveFeedSelectionAsync(auth, options, "Activating a deployment");
+  if (!selection.ok) {
+    return {
+      ...fail(selection.reason, selection.message, selection.instructions),
+      errorCode: selection.errorCode,
+      retry: selection.retry
+    };
+  }
+  const { selectedFeed } = selection;
+  const sweep = await findDeploymentAcrossFeeds(auth, deploymentName, {
+    tenant: options.tenant,
+    loginValidity: options.loginValidity,
+    envFilePath: options.envFilePath,
+    selectedFeed
+  });
+  const location = sweep.location;
+  const scope = location?.scope ?? (selectedFeed ? feedScopeInitOverride(selectedFeed) : undefined);
+  const result = await activateDeployment(auth, deploymentName, {
+    timeoutSeconds: options.timeout ?? 360,
+    pollIntervalMs: options.pollInterval ?? 5000,
+    signal: options.signal,
+    scope
+  });
+  if (result.kind === "RequestFailed") {
+    const details = `Details: ${result.details}`;
+    const known = result.deployment ?? location?.deployment;
+    if (!known && !sweep.complete) {
+      return incompleteSweepRefusalAsync(deploymentName, sweep.skipped, result);
+    }
+    const pendingResources = known && needsPendingResources(known) ? await readPendingResourcesAsync(pendingResourceApis(auth), known, scope) : undefined;
+    const feedSelector = feedSelectorFlag(location?.feed ?? selectedFeed);
+    const explanation = known ? explainRefusal(known, pendingResources, feedSelector) : undefined;
+    const instructions = explanation ? [...explanation, details].join(`
+`) : known ? `Deployment '${known.name}' exists (Operation: ${known.operation}, OperationStatus: ${known.operationStatus}, ActivationStatus: ${known.activationStatus}) but the service refused to activate it. Check it with: uip solution deploy status ${known.key}${feedSelector}. ${details}` : selectedFeed ? `No deployment named '${deploymentName}' was found in the selected feed. Check the name with 'uip solution deploy list${feedSelector}', or drop the feed flag to search every feed you can reach. ${details}` : result.phase === "preActivateSteps" ? `Check deployment name. Deploy first with: uip solution deploy run. ${details}` : `Check deployment name matches an existing deployment. ${details}`;
+    return fail("request_failed", result.message, instructions);
+  }
+  if (result.kind === "NoInstance") {
+    return {
+      ok: true,
+      status: "Activation completed (no instance to poll)",
+      deploymentName
+    };
+  }
+  if (result.kind === "PollFailed") {
+    const { reason, message, exitCode } = mapPollFailure(result.poll, "Activation");
+    return fail(reason, message, "Activation may still be in progress.", exitCode);
+  }
+  if (result.kind === "ActivationFailed") {
+    return fail("activation_failed", `Activation failed with status: ${result.status}`, result.errorMessage);
+  }
+  return {
+    ok: true,
+    status: result.status,
+    deploymentName,
+    instanceId: result.instanceId
+  };
+}
+
+// src/services/search-failure.ts
+async function describeSearchFailureAsync(error, what) {
+  const details = await extractErrorDetails(error);
+  return {
+    message: `Failed to list ${what}: ${details.message}`,
+    instructions: searchFailureInstructions(details.errorCode, details.retry),
+    errorCode: details.errorCode,
+    retry: details.retry,
+    context: details.context
+  };
+}
+function searchFailureInstructions(errorCode, retry) {
+  if (errorCode === "authentication_required") {
+    return "Run 'uip login' to refresh the session, then run the command again.";
+  }
+  if (errorCode === "permission_denied") {
+    return "Use an account that can read Automation Solutions in this tenant.";
+  }
+  if (retry === "RetryLater") {
+    return "Wait a moment, then run the command again.";
+  }
+  return "Check the options and the session ('uip login status --detailed'), then run the command again.";
+}
+
+// src/services/deploy-list-service.ts
+var fail2 = (reason, message, instructions, extras = {}) => ({
+  ok: false,
+  reason,
+  message,
+  instructions,
+  exitCode: 1,
+  ...extras
+});
+var refuseFeedRead = (refusal) => fail2("feed_requires_user_session", refusal.message, refusal.instructions, {
+  errorCode: "permission_denied",
+  retry: "RetryWillNotFix"
+});
+async function listDeploymentsAsync(options = {}) {
+  const limit = options.limit ?? DEFAULT_PAGE_SIZE;
+  const offset = options.offset ?? 0;
+  const [authError, auth] = await catchError(getSolutionAuthContext({
+    tenant: options.tenant,
+    loginValidity: options.loginValidity,
+    envFilePath: options.envFilePath
+  }));
+  if (authError) {
+    return fail2("auth_failed", authError.message, authError.message);
+  }
+  if (options.personalWorkspace) {
+    const refusal = feedReadRefusalForApplication(auth, "Listing the Personal Workspace's deployments");
+    if (refusal) {
+      return refuseFeedRead(refusal);
+    }
+  }
+  const [folderError, folderPathFilter] = await catchError(resolveParentFolder({
+    folderPath: options.folderPath,
+    folderKey: options.folderKey,
+    tenant: options.tenant,
+    loginValidity: options.loginValidity,
+    envFilePath: options.envFilePath
+  }));
+  if (folderError) {
+    return fail2("folder_resolution_failed", folderError.message, "Provide a valid --folder-path or --folder-key to filter by folder.");
+  }
+  const [scopeError, scope] = await catchError(resolveFeedScope({
+    personalWorkspace: options.personalWorkspace,
+    feed: options.feed,
+    tenant: options.tenant,
+    loginValidity: options.loginValidity,
+    envFilePath: options.envFilePath
+  }));
+  if (scopeError) {
+    const { message, instructions, ...extras } = await describeFeedResolutionFailureAsync(scopeError, options, auth);
+    return fail2("feed_resolution_failed", message, instructions, extras);
+  }
+  if (scope.kind !== "tenant") {
+    const refusal = feedReadRefusalForApplication(auth, `Listing the deployments of the feed '${scope.name ?? scope.folderKey}'`);
+    if (refusal) {
+      return refuseFeedRead(refusal);
+    }
+  }
+  const [listError, result] = await catchError(searchDeploymentsPage(auth, {
+    take: limit,
+    skip: offset,
+    orderByColumn: options.sortBy ?? "startTime",
+    orderByDirection: options.sortOrder ?? "Descending",
+    operationStatuses: options.operationStatuses ?? [],
+    activationStatuses: options.activationStatuses ?? [],
+    ...folderPathFilter ? { targetFolderName: folderPathFilter } : {}
+  }, feedScopeInitOverride(scope)));
+  if (listError instanceof DeploymentSearchNeedsUserSessionError) {
+    return fail2("list_request_failed", `Failed to list deployments: ${listError.message}`, "Run it with a user session ('uip login'). A client-credentials login cannot list deployments on this server.", { errorCode: "permission_denied", retry: "RetryWillNotFix" });
+  }
+  if (listError) {
+    const { message, instructions, ...extras } = await describeSearchFailureAsync(listError, "deployments");
+    return fail2("list_request_failed", message, instructions, extras);
+  }
+  const values = result.values ?? [];
+  const deployments = values.map((d) => ({
+    key: d.key,
+    installDeploymentKey: d.installDeploymentKey,
+    name: d.name,
+    packageName: d.packageName,
+    packageVersion: d.packageVersion,
+    currentPackageVersion: d.currentPackageVersion,
+    targetPackageVersion: d.targetPackageVersion,
+    newPackageVersionAvailable: d.newPackageVersionAvailable,
+    operation: d.operation,
+    operationStatus: d.operationStatus,
+    activationStatus: d.activationStatus,
+    folderPath: d.folderPath,
+    installedRootFolderKey: d.installedRootFolderKey,
+    deploymentCreationTime: d.deploymentCreationTime,
+    actions: d.actions ?? []
+  }));
+  return { ok: true, deployments, limit, offset, total: result.count };
+}
+
+// src/services/uninstall-consent.ts
+var JOBS_NOT_IN_FINAL_STATE_CODE = "2824";
+var UNINSTALL_CONFIRMATION_REQUIRED_CODE = "4026";
+function isJobsNotInFinalState(row) {
+  return row.errorCode === JOBS_NOT_IN_FINAL_STATE_CODE;
+}
+function isRequiresConfirmation(row) {
+  return row.errorKind === "RequiresConfirmation";
+}
+function isForceable(row) {
+  return isJobsNotInFinalState(row) || isRequiresConfirmation(row);
+}
+function uninstallConsentFacts(rows) {
+  return {
+    jobsNotInFinalState: rows.some(isJobsNotInFinalState),
+    requiresConfirmation: rows.some(isRequiresConfirmation),
+    permanentDeletionResources: selectPermanentDeletionResources(rows)
+  };
+}
+function selectPermanentDeletionResources(rows) {
+  const byKey = new Map;
+  for (const row of rows) {
+    if (row.errorKind !== "RequiresConfirmation" || row.level !== "Warning") {
+      continue;
+    }
+    const identity = row.key ?? `${row.kind ?? ""}/${row.name ?? ""}`;
+    if (byKey.has(identity)) {
+      continue;
+    }
+    byKey.set(identity, {
+      key: row.key ?? undefined,
+      kind: row.kind ?? undefined,
+      name: row.name ?? undefined
+    });
+  }
+  return [...byKey.values()];
+}
+function isBlocking(row) {
+  return !isForceable(row) && row.level !== "Warning" && row.level !== "Info";
+}
+function describeBlockingRows(rows) {
+  return rows.filter(isBlocking).map((row) => {
+    const subject = row.name ? `${row.kind ? `${row.kind} ` : ""}'${row.name}': ` : "";
+    const code = row.errorCode ? `[${row.errorCode}] ` : "";
+    const text = row.text || row.errorKind || row.errorType;
+    return `${subject}${code}${text}`;
+  }).join("; ");
+}
+function classifyUninstallValidation(result) {
+  const rows = result.validationErrors ?? [];
+  let outcome = "clear";
+  if (rows.some(isBlocking)) {
+    outcome = "blocked";
+  } else if (rows.some(isForceable)) {
+    outcome = "force-required";
+  }
+  return { outcome, ...uninstallConsentFacts(rows) };
+}
+async function readUninstallValidationAsync(api, deploymentName, deploymentKey, scope) {
+  if (!deploymentKey) {
+    return;
+  }
+  const [readError, result] = await catchError(() => api.pipelinesGetDeploymentValidationResult({ deploymentName, deploymentAction: "Uninstall" }, scope));
+  if (readError || !result || result.deploymentAction !== "Uninstall") {
+    return;
+  }
+  if (!await isCurrentRecordAsync(api, deploymentKey)) {
+    return;
+  }
+  return result;
+}
+function servicesReportJobsNotInFinalState(serviceLines) {
+  return serviceLines.some((line) => line.includes(`[${JOBS_NOT_IN_FINAL_STATE_CODE}]`));
+}
+function formatPermanentDeletionResource(resource) {
+  const label = resource.name ?? resource.key ?? "unnamed resource";
+  return resource.kind ? `${resource.kind} '${label}'` : `'${label}'`;
+}
+function describePermanentDeletion(resources) {
+  return resources.length > 0 ? `uninstalling it permanently deletes these resources and their data: ${resources.map(formatPermanentDeletionResource).join(", ")}` : "uninstalling it permanently deletes resources and their data";
+}
+function describeForceableCauses(facts) {
+  const causes = [];
+  if (facts.jobsNotInFinalState) {
+    causes.push("this deployment has uncompleted jobs; --force uninstalls anyway");
+  }
+  if (facts.requiresConfirmation) {
+    causes.push(describePermanentDeletion(facts.permanentDeletionResources));
+  }
+  return causes.join("; and ");
+}
+function consentData(facts, extra) {
+  return {
+    DeploymentName: extra.deploymentName,
+    ...extra.instanceId ? { InstanceId: extra.instanceId } : {},
+    JobsNotInFinalState: facts.jobsNotInFinalState,
+    PermanentDeletionResources: facts.permanentDeletionResources.map((resource) => ({
+      Key: resource.key ?? null,
+      Kind: resource.kind ?? null,
+      Name: resource.name ?? null
+    }))
+  };
+}
+
+// src/services/deploy-uninstall-service.ts
+var TERMINAL_STATUSES = new Set([
+  "SuccessfulUninstall",
+  "FailedUninstall"
+]);
+var fail3 = (reason, message, instructions, extras = {}) => ({
+  ok: false,
+  reason,
+  message,
+  instructions,
+  exitCode: extras.exitCode ?? 1,
+  errorCode: extras.errorCode,
+  retry: extras.retry,
+  ...extras.data ? { data: extras.data } : {}
+});
+function forceRetryCommand(deploymentName, feedSelector) {
+  return `uip solution deploy uninstall ${quoteForShell(deploymentName)}${feedSelector} --force`;
+}
+function consentFailure(message, instructions, facts, ids) {
+  return fail3("uninstall_confirmation_required", message, instructions, {
+    errorCode: "invalid_argument",
+    retry: "RetryWillNotFix",
+    data: consentData(facts, ids)
+  });
+}
+function blockedUninstallFailure(deploymentName, feedSelector, rows) {
+  return fail3("uninstall_failed", `Deployment '${deploymentName}' was not uninstalled: its Uninstall validation reports errors that --force cannot get past: ${describeBlockingRows(rows)}.`, `Resolve the reason above in Orchestrator, then run the uninstall again: uip solution deploy uninstall ${quoteForShell(deploymentName)}${feedSelector} --yes. It then asks again to confirm the permanent deletion of the resources that were replaced by links.`, { errorCode: "invalid_argument", retry: "RetryLater" });
+}
+async function confirmationRequiredFailureAsync(api, deploymentName, ctx) {
+  const { feedSelector, details } = ctx;
+  const validation = await readUninstallValidationAsync(api, deploymentName, ctx.deploymentKey, ctx.scope);
+  if (validation && classifyUninstallValidation(validation).outcome === "blocked") {
+    return blockedUninstallFailure(deploymentName, feedSelector, validation.validationErrors ?? []);
+  }
+  const facts = {
+    ...uninstallConsentFacts(validation?.validationErrors ?? []),
+    requiresConfirmation: true
+  };
+  const causes = describeForceableCauses(facts);
+  return consentFailure(`Deployment '${deploymentName}' was not uninstalled: ${causes}.`, `Re-run with --force to confirm: ${forceRetryCommand(deploymentName, feedSelector)}. Details: ${details}`, facts, { deploymentName });
+}
+async function forceableUninstallFailureAsync(api, deploymentName, ctx) {
+  const validation = await readUninstallValidationAsync(api, deploymentName, ctx.deploymentKey, ctx.scope);
+  let facts;
+  if (validation) {
+    const classification = classifyUninstallValidation(validation);
+    if (classification.outcome !== "force-required") {
+      return;
+    }
+    facts = classification;
+  } else if (servicesReportJobsNotInFinalState(ctx.serviceLines)) {
+    facts = {
+      jobsNotInFinalState: true,
+      requiresConfirmation: false,
+      permanentDeletionResources: []
+    };
+  } else {
+    return;
+  }
+  const causes = describeForceableCauses(facts);
+  const retry = forceRetryCommand(deploymentName, ctx.feedSelector);
+  const waitForJobs = facts.jobsNotInFinalState ? " Or let the jobs finish (or stop them) in Orchestrator, then run the uninstall again without --force." : "";
+  const reported = ctx.errors ? `${ctx.errors}
+` : "";
+  return consentFailure(`Uninstall failed with status: FailedUninstall: ${causes}.`, `${reported}Re-run with --force to uninstall anyway: ${retry}.${waitForJobs}`, facts, { deploymentName, instanceId: ctx.instanceId });
+}
+function requestErrorInstructions(deploymentName, errorCode, details, feedSelector = "") {
+  switch (errorCode) {
+    case "authentication_required":
+      return `Your session may have expired. Run 'uip login' and retry. Details: ${details}`;
+    case "permission_denied":
+      return `Your account lacks permission to uninstall this deployment. Check your Orchestrator roles, then retry. Details: ${details}`;
+    case "rate_limited":
+      return `Too many requests. Wait a moment and retry. Details: ${details}`;
+    case "network_error":
+      return `Could not reach Orchestrator. Check your connection and retry. Details: ${details}`;
+    case "server_error":
+      return `Orchestrator returned a server error. Wait and retry; if it persists, check Orchestrator status. Details: ${details}`;
+    case "not_found":
+      return `No deployment named '${deploymentName}' was found. Run 'uip solution deploy list${feedSelector}' to see valid deployment names. Details: ${details}`;
+    default:
+      return `Uninstall request failed. Run 'uip solution deploy list${feedSelector}' to check the deployment's state, then retry. Details: ${details}`;
+  }
+}
+function buildDeploymentStateInstructions(deployment, details, feedSelector = "") {
+  const availableActions = deployment.actions?.length ? deployment.actions.join(", ") : "none";
+  const status = `(ActivationStatus: ${deployment.activationStatus}, OperationStatus: ${deployment.operationStatus})`;
+  if (deployment.operationStatus === "InProgress") {
+    return `Deployment '${deployment.name}' has an operation in progress ${status}, so it can't be uninstalled yet. Wait for it to finish — run 'uip solution deploy list${feedSelector}' to recheck — then retry. Available actions: ${availableActions}. Details: ${details}`;
+  }
+  if (deployment.actions?.includes("Uninstall")) {
+    return `Deployment '${deployment.name}' lists uninstall as available but Orchestrator rejected the request ${status}. Run 'uip solution deploy list${feedSelector}' to recheck its state, then retry. If it stays stuck, uninstall it from the Orchestrator Solutions UI. Details: ${details}`;
+  }
+  const removalAdvice = deployment.actions?.includes(WorkflowAction.Delete) ? `Delete it with: uip solution deploy delete ${quoteForShell(deployment.name)}${feedSelector} --yes.` : "Remove it from the Orchestrator Solutions UI.";
+  if (deployment.activationStatus === "Inactive") {
+    return `Deployment '${deployment.name}' cannot be uninstalled in its current state ${status}. Available actions: ${availableActions}. Superseded or inactive deployments are never uninstallable. ${removalAdvice} Details: ${details}`;
+  }
+  return `Deployment '${deployment.name}' cannot be uninstalled in its current state ${status}. Available actions: ${availableActions}. Run 'uip solution deploy list${feedSelector}' to recheck its state. ${removalAdvice} Details: ${details}`;
+}
+async function waitForOperationToFinishAsync(auth, deploymentName, opts) {
+  let last;
+  let byKey = opts.deploymentKey !== undefined;
+  let solutionsOnly = false;
+  let operationStatus;
+  const readState = async () => {
+    if (byKey && opts.deploymentKey) {
+      const info = await readDeploymentByKeyAsync(auth, opts.deploymentKey, { scope: opts.scope, solutionsOnly });
+      if (info) {
+        solutionsOnly = info.source === "solutions";
+        operationStatus = info.operationStatus;
+        return operationStatus;
+      }
+      byKey = false;
+    }
+    last = await findDeploymentByName(auth, deploymentName, opts.scope);
+    operationStatus = last?.operationStatus;
+    return last ? operationStatus : undefined;
+  };
+  const poll = await pollUntil({
+    fn: readState,
+    until: (status) => status !== undefined && status !== "InProgress",
+    getStatus: (status) => status ?? "Unknown",
+    label: `deployment '${deploymentName}' to finish its current operation`,
+    logPrefix: "uninstall",
+    timeoutMs: opts.remainingMs(),
+    intervalMs: opts.intervalMs,
+    signal: opts.signal
+  });
+  if (byKey) {
+    const [, row] = await catchError(findDeploymentByName(auth, deploymentName, opts.scope));
+    const held = row ?? opts.known;
+    last = row ?? (held && operationStatus ? { ...held, operationStatus } : held);
+  }
+  return { outcome: poll.outcome, state: last, error: poll.error };
+}
+async function requestUninstallAsync(api, auth, deploymentName, ctx) {
+  const { options, sweep, scope, intervalMs, remainingMs } = ctx;
+  const { location } = sweep;
+  const sweepIncomplete = !location && !sweep.complete;
+  const feedSelector = feedSelectorFlag(location?.feed ?? ctx.selectedFeed);
+  let state = location?.deployment;
+  let waited = false;
+  let rechecked = false;
+  for (;; ) {
+    const [uninstallError, result] = await catchError(api.pipelinesUninstall(options.force ? { deploymentName, forceUninstall: true } : { deploymentName }, scope));
+    if (!uninstallError) {
+      return { ok: true, result };
+    }
+    const { message, details, errorCode, retry, context } = await extractErrorDetails(uninstallError);
+    if (!options.force && hasServerErrorCode(details, UNINSTALL_CONFIRMATION_REQUIRED_CODE)) {
+      return confirmationRequiredFailureAsync(api, deploymentName, {
+        deploymentKey: state?.key ?? location?.deployment.key,
+        scope,
+        feedSelector,
+        details
+      });
+    }
+    if (errorCode !== "invalid_argument") {
+      if (errorCode === "not_found" && sweepIncomplete) {
+        return incompleteSweepFailureAsync(deploymentName, sweep, details);
+      }
+      return fail3("uninstall_request_failed", message, requestErrorInstructions(deploymentName, errorCode, details, feedSelector), { errorCode, retry });
+    }
+    if (!rechecked && !waited && state?.operationStatus !== "InProgress") {
+      rechecked = true;
+      const [readError, fresh] = await catchError(findDeploymentByName(auth, deploymentName, scope));
+      if (!readError) {
+        state = fresh;
+      }
+    }
+    if (!waited && state?.operationStatus === "InProgress") {
+      waited = true;
+      const wait = await waitForOperationToFinishAsync(auth, deploymentName, {
+        scope,
+        deploymentKey: state?.key ?? location?.deployment.key,
+        known: state,
+        intervalMs,
+        remainingMs,
+        signal: options.signal
+      });
+      if (wait.outcome === PollOutcome.Timeout) {
+        return fail3("uninstall_blocked", `Deployment '${deploymentName}' still had an operation running after ${options.timeout ?? 360}s, so it could not be uninstalled.`, buildDeploymentStateInstructions(wait.state ?? state, details, feedSelector), { exitCode: 2, errorCode: "timeout", retry: "RetryLater" });
+      }
+      if (wait.outcome !== PollOutcome.Completed) {
+        const {
+          reason,
+          message: pollMessage,
+          exitCode,
+          errorCode: pollErrorCode,
+          retry: pollRetry
+        } = mapPollFailure(wait, "Deployment");
+        return fail3(reason, pollMessage, `The deployment may still be installing. Check it with: uip solution deploy list${feedSelector}, then retry the uninstall.`, { exitCode, errorCode: pollErrorCode, retry: pollRetry });
+      }
+      state = wait.state;
+      continue;
+    }
+    if (sweepIncomplete && (!state || isCompletedUninstall(state))) {
+      if (isNameOrFeedRefusal(errorCode, context?.httpStatus)) {
+        return incompleteSweepFailureAsync(deploymentName, sweep, details);
+      }
+      return fail3("uninstall_request_failed", message, requestErrorInstructions(deploymentName, errorCode, details, feedSelector), { errorCode, retry });
+    }
+    const instructions = state ? buildDeploymentStateInstructions(state, details, feedSelector) : ctx.selectedFeed ? `No deployment named '${deploymentName}' was found in the selected feed. Check the name with 'uip solution deploy list${feedSelector}', or drop the feed flag to search every feed you can reach. Details: ${details}` : `No deployment named '${deploymentName}' was found in any feed you can reach (tenant, Personal Workspace, or a folder feed). Check the name with 'uip solution deploy list'. Details: ${details}`;
+    return fail3("uninstall_request_failed", message, instructions, {
+      errorCode,
+      retry
+    });
+  }
+}
+async function incompleteSweepFailureAsync(deploymentName, sweep, refusalDetails) {
+  const report = await reportIncompleteSweepAsync(deploymentName, sweep.skipped);
+  return fail3("uninstall_request_failed", report.message, `${INCOMPLETE_SWEEP_ADVICE} Without its feed the uninstall request went to the tenant feed, which refused it. ${report.nextStep} Details: ${refusalDetails} (feed search: ${report.details})`, { errorCode: report.errorCode, retry: report.retry });
+}
+async function uninstallDeploymentAsync(deploymentName, options = {}) {
+  const [authError, auth] = await catchError(getSolutionAuthContext({
+    tenant: options.tenant,
+    loginValidity: options.loginValidity,
+    envFilePath: options.envFilePath
+  }));
+  if (authError) {
+    return fail3("auth_failed", authError.message, authError.message);
+  }
+  const api = new PipelinesApi(new Configuration({
+    basePath: auth.basePath,
+    accessToken: auth.accessToken
+  }));
+  const deadline = Date.now() + (options.timeout ?? 360) * 1000;
+  const intervalMs = options.pollInterval ?? 5000;
+  const remainingMs = () => Math.max(deadline - Date.now(), 1);
+  const selection = await resolveFeedSelectionAsync(auth, options, "Uninstalling a deployment");
+  if (!selection.ok) {
+    return fail3(selection.reason, selection.message, selection.instructions, {
+      errorCode: selection.errorCode,
+      retry: selection.retry
+    });
+  }
+  const { selectedFeed } = selection;
+  const sweep = await findDeploymentAcrossFeeds(auth, deploymentName, {
+    ...options,
+    selectedFeed
+  });
+  const location = sweep.location;
+  const scope = location?.scope ?? (selectedFeed ? feedScopeInitOverride(selectedFeed) : undefined);
+  const [requestError, requested] = await catchError(requestUninstallAsync(api, auth, deploymentName, {
+    options,
+    sweep,
+    scope,
+    selectedFeed,
+    intervalMs,
+    remainingMs
+  }));
+  if (requestError) {
+    throw requestError;
+  }
+  if (!requested.ok) {
+    return requested;
+  }
+  const uninstallResult = requested.result;
+  if (uninstallResult.complete) {
+    return {
+      ok: true,
+      status: "Uninstall completed immediately",
+      deploymentName
+    };
+  }
+  const instanceId = uninstallResult.instanceId;
+  if (!instanceId) {
+    return {
+      ok: true,
+      status: "Uninstall scheduled",
+      deploymentName,
+      scheduled: uninstallResult.scheduled
+    };
+  }
+  const pollResult = await pollUntil({
+    fn: () => api.pipelinesGetDeploymentInstanceStatus({ instanceId }, scope),
+    until: (result) => TERMINAL_STATUSES.has(result.status),
+    getStatus: (result) => result.status,
+    label: `uninstall ${deploymentName}`,
+    logPrefix: "uninstall",
+    timeoutMs: remainingMs(),
+    intervalMs,
+    signal: options.signal
+  });
+  if (pollResult.outcome !== PollOutcome.Completed || !pollResult.data) {
+    const { reason, message, exitCode, errorCode, retry } = mapPollFailure(pollResult, "Uninstall");
+    return fail3(reason, message, "Uninstall may still be in progress.", {
+      exitCode,
+      errorCode,
+      retry
+    });
+  }
+  const finalStatus = pollResult.data;
+  if (finalStatus.status !== "SuccessfulUninstall") {
+    const workflowErrors = coerceWorkflowErrorMessages(finalStatus.errorMessage).map((e) => e.errorMessage).join(", ");
+    const serviceLines = formatServiceErrors(finalStatus.services);
+    const errors = [workflowErrors, ...serviceLines].filter(Boolean).join("; ");
+    const feedFlag = feedSelectorFlag(location?.feed ?? selectedFeed);
+    if (!options.force) {
+      const forceable = await forceableUninstallFailureAsync(api, deploymentName, {
+        deploymentKey: finalStatus.deploymentKey,
+        scope,
+        feedSelector: feedFlag,
+        instanceId,
+        serviceLines,
+        errors
+      });
+      if (forceable) {
+        return forceable;
+      }
+    }
+    const consentFlag = options.force ? "--force" : "--yes";
+    const classification = {
+      errorCode: errors ? "invalid_argument" : "unknown_error",
+      retry: "RetryLater"
+    };
+    return fail3("uninstall_failed", `Uninstall failed with status: ${finalStatus.status}`, errors ? `${errors}
+Resolve the reason above in Orchestrator, then run the uninstall again: uip solution deploy uninstall ${quoteForShell(deploymentName)}${feedFlag} ${consentFlag}` : `Orchestrator ended the uninstall in a FailedUninstall state without an error detail. Run 'uip solution deploy list${feedFlag}' to recheck the deployment's state and retry. If it stays in a failed state and that listing shows Delete among its actions, remove the record with: uip solution deploy delete ${quoteForShell(deploymentName)}${feedFlag} --yes. Remove it from the Orchestrator Solutions UI when it does not.`, classification);
+  }
+  return {
+    ok: true,
+    status: finalStatus.status,
+    deploymentName,
+    instanceId
+  };
+}
+
+// src/services/deploy-upgrade-service.ts
+var fail4 = (reason, message, instructions, extras = {}) => ({
+  ok: false,
+  reason,
+  message,
+  instructions,
+  exitCode: extras.exitCode ?? 1,
+  errorCode: extras.errorCode,
+  retry: extras.retry,
+  ...extras.pipelineDeploymentId !== undefined && {
+    pipelineDeploymentId: extras.pipelineDeploymentId
+  },
+  ...extras.deploymentKey !== undefined && {
+    deploymentKey: extras.deploymentKey
+  },
+  ...extras.permanentDeletionResources !== undefined && {
+    permanentDeletionResources: extras.permanentDeletionResources
+  }
+});
+var failPermanentDeletion = (refusal, pipelineDeploymentId, deploymentKey) => fail4(refusal.reason, refusal.message, refusal.instructions, {
+  ...refusal.classification,
+  pipelineDeploymentId,
+  deploymentKey,
+  permanentDeletionResources: refusal.resources
+});
+var DEFAULT_TIMEOUT_SECONDS = 300;
+var DEFAULT_POLL_INTERVAL_MS = 5000;
+var AUTH_INSTRUCTIONS2 = "Run 'uip login' to refresh credentials, then retry. If the deployment is in a different tenant, switch with 'uip login tenant set <tenant>'.";
+var PACKAGE_INSTRUCTIONS = "Confirm the version is published to the tenant (or Personal Workspace) feed: uip solution packages list.";
+var TARGET_INSTRUCTIONS = "Address the deployment either by key — uip solution deploy upgrade <deployment-key> — or by name with its package: uip solution deploy upgrade --name <deployment-name> --package-name <package>. 'uip solution deploy list' reports all three.";
+var DEPLOYMENT_NOT_FOUND_INSTRUCTIONS = "Check the key with 'uip solution deploy list'. A server without the Pipelines deployment lookup answers 404 to every key for an external app; on one of those, address the deployment with --name and --package-name instead.";
+var LOOKUP_FAILED_INSTRUCTIONS = "The deployment lookup failed before any upgrade was requested. Retry, or address the deployment with --name and --package-name.";
+var INVALID_TARGET = {
+  errorCode: "invalid_argument",
+  retry: "RetryWillNotFix"
+};
+var GUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+var UPGRADE_REFUSED_INSTRUCTIONS = "The server refused to start the upgrade. The deployment name may not exist, or may belong to a different package — check both with 'uip solution deploy list'. Another operation may still be running on it (wait, then retry), or it may be in a state the platform does not offer upgrades for.";
+async function upgradeDeploymentAsync(first, second) {
+  const options = typeof first === "string" ? { ...second, deploymentKey: first } : first;
+  const targetError = validateTarget(options);
+  if (targetError) {
+    return targetError;
+  }
+  const [authError, auth] = await catchError(getSolutionAuthContext({
+    tenant: options.tenant,
+    loginValidity: options.loginValidity,
+    envFilePath: options.envFilePath
+  }));
+  if (authError) {
+    return fail4("auth_failed", authError.message, AUTH_INSTRUCTIONS2);
+  }
+  const pipelinesApi = new PipelinesApi(new Configuration({
+    basePath: auth.basePath,
+    accessToken: auth.accessToken
+  }));
+  const target = options.deploymentKey ? await resolveTargetByKeyAsync(pipelinesApi, auth, options, options.deploymentKey) : await resolveTargetByNameAsync(pipelinesApi, auth, options);
+  if (!target.ok) {
+    return target;
+  }
+  const { deploymentName, packageName, scope } = target;
+  let targetVersion = options.version ?? target.pendingDraftVersion;
+  if (targetVersion === undefined) {
+    const [versionError, latest] = await catchError(pipelinesApi.pipelinesGetPackageVersion({ packageName, packageVersion: null }, scope));
+    if (versionError || !latest) {
+      const detail = versionError && await extractErrorDetails(versionError);
+      if (!detail || detail.context?.httpStatus === 404) {
+        return fail4("package_not_found", detail?.details ? `Package '${packageName}' was not found in the feed: ${detail.details}` : `Package '${packageName}' was not found in the feed.`, PACKAGE_INSTRUCTIONS, { errorCode: "not_found", retry: "RetryWillNotFix" });
+      }
+      return fail4("lookup_failed", detail.details ? `${detail.message}: ${detail.details}` : detail.message, `The version lookup for '${packageName}' failed before any upgrade was requested. Retry, or pass --version explicitly to skip the lookup.`, { errorCode: detail.errorCode, retry: detail.retry });
+    }
+    targetVersion = latest.packageVersion;
+  }
+  const installAsync = async () => {
+    const [installError, installResult] = await catchError(pipelinesApi.pipelinesInstall({
+      deploymentName,
+      packageName,
+      packageVersion: targetVersion,
+      solutionRootFolderName: deploymentName
+    }, scope));
+    if (installError || !installResult?.pipelineDeploymentId) {
+      return describeInstallRefusalAsync(installError, {
+        options,
+        target,
+        deploymentName,
+        packageName
+      });
+    }
+    return {
+      ok: true,
+      pipelineDeploymentId: installResult.pipelineDeploymentId
+    };
+  };
+  const installed = await installAsync();
+  if (!installed.ok) {
+    return installed;
+  }
+  const targetFields = {
+    ...target.fromVersion !== undefined && {
+      fromVersion: target.fromVersion
+    },
+    ...target.installDeploymentKey !== undefined && {
+      installDeploymentKey: target.installDeploymentKey
+    },
+    ...target.discardedDraftKey !== undefined && {
+      discardedDraftKey: target.discardedDraftKey
+    }
+  };
+  if (options.noWait) {
+    return {
+      ok: true,
+      deploymentName,
+      toVersion: targetVersion,
+      pipelineDeploymentId: installed.pipelineDeploymentId,
+      ...targetFields,
+      status: "Accepted"
+    };
+  }
+  const timeoutSeconds = Number.isFinite(options.timeout) ? options.timeout : DEFAULT_TIMEOUT_SECONDS;
+  const timeoutMs = timeoutSeconds * 1000;
+  const deadline = Date.now() + timeoutMs;
+  const pollAsync = (pipelineDeploymentId2) => pollPipelineDeploymentAsync(pipelinesApi, auth, {
+    pipelineDeploymentId: pipelineDeploymentId2,
+    deploymentName,
+    scope,
+    timeoutMs: remainingTimeoutMs(timeoutMs, deadline),
+    intervalMs: Number.isFinite(options.pollInterval) ? options.pollInterval : DEFAULT_POLL_INTERVAL_MS,
+    signal: options.signal,
+    logPrefix: "deploy upgrade"
+  });
+  let pipelineDeploymentId = installed.pipelineDeploymentId;
+  let poll = await pollAsync(pipelineDeploymentId);
+  let permanentlyDeletedResources;
+  if (poll.outcome === PollOutcome.Completed && isPermanentDeletionRefusal(poll.data)) {
+    const refused = poll.data;
+    const refusedKey = refused.deploymentKey || undefined;
+    const keepCopiesHint = `discard the draft and upgrade without those links: ${discardRetryCommand(options, target, refusedKey)}, or remove the links from the deployment in Orchestrator first`;
+    const consent = await settlePermanentDeletionRefusalAsync({
+      api: pipelinesApi,
+      deploymentName,
+      scope,
+      signal: options.signal,
+      acknowledge: options.acknowledgePermanentDeletion === true,
+      status: refused,
+      verb: "Upgrading",
+      confirmHint: `re-run the same command with ${ACKNOWLEDGE_PERMANENT_DELETION_FLAG}: ${acknowledgeRetryCommand(options, target)}`,
+      keepCopiesHint
+    });
+    if (!consent.ok) {
+      return failPermanentDeletion(consent, pipelineDeploymentId, refusedKey);
+    }
+    const reinstalled = await installAsync();
+    if (!reinstalled.ok) {
+      return {
+        ...reinstalled,
+        instructions: `${reinstalled.instructions} ${acknowledgedButNotRunHint(consent.resources, keepCopiesHint)}`
+      };
+    }
+    pipelineDeploymentId = reinstalled.pipelineDeploymentId;
+    poll = await pollAsync(pipelineDeploymentId);
+    if (poll.outcome === PollOutcome.Completed && isPermanentDeletionRefusal(poll.data)) {
+      const deploymentKey = poll.data?.deploymentKey || undefined;
+      return failPermanentDeletion(stillRequiresConfirmation(deploymentName, consent.resources, deploymentKey), pipelineDeploymentId, deploymentKey);
+    }
+    permanentlyDeletedResources = consent.resources.map((resource) => formatPermanentDeletionResources([resource]));
+  }
+  const base = {
+    deploymentName,
+    toVersion: targetVersion,
+    pipelineDeploymentId,
+    ...targetFields,
+    ...permanentlyDeletedResources && { permanentlyDeletedResources }
+  };
+  if (poll.outcome !== PollOutcome.Completed) {
+    const failure = mapPollFailure(poll, `Upgrade ${pipelineDeploymentId}`);
+    const isTimeout = poll.outcome === PollOutcome.Timeout;
+    const lastStatus = poll.data?.status ?? "unknown";
+    return fail4(isTimeout ? "install_timeout" : failure.reason, isTimeout ? `The upgrade of '${deploymentName}' to ${targetVersion} did not finish within ${timeoutSeconds}s (last status: ${lastStatus}).` : `${failure.message} while upgrading '${deploymentName}' to ${targetVersion} (last status: ${lastStatus}).`, isTimeout ? `It may still be running. ${trackingHint(pipelineDeploymentId, target.listFlag)} Or pass a longer --timeout.` : `The upgrade may still be running. ${trackingHint(pipelineDeploymentId, target.listFlag)}`, {
+      exitCode: failure.exitCode,
+      errorCode: failure.errorCode,
+      retry: failure.retry
+    });
+  }
+  const finalStatus = poll.data;
+  if (!finalStatus) {
+    return fail4("deploy_failed", `The upgrade of '${deploymentName}' returned no final status.`, trackingHint(pipelineDeploymentId, target.listFlag));
+  }
+  const landedDespiteStatus = installLandedDespiteStatus(finalStatus);
+  if (finalStatus.status !== "DeploymentSucceeded" && !landedDespiteStatus) {
+    return fail4("deploy_failed", `The upgrade of '${deploymentName}' to ${targetVersion} ended in ${finalStatus.status}.`, `${await describeUpgradeFailureAsync(auth.basePath, auth.accessToken, pipelineDeploymentId, finalStatus, scope, options.signal)}
+${leavesPendingDraft(finalStatus.status) ? `Nothing was installed; the deployment stays on the version it was already running. The rejected attempt is kept as a pending draft${finalStatus.deploymentKey ? ` (${finalStatus.deploymentKey})` : ""}, which a plain retry would run into, so once the cause is fixed discard it and retry: ${discardRetryCommand(options, target, finalStatus.deploymentKey || undefined)}` : "Fix the reported problem, then retry the upgrade. The deployment stays on the version it was already running."}`, classifyTerminalFailure(finalStatus.status));
+  }
+  const described = await describeUpgradedDeploymentAsync(auth, deploymentName, finalStatus, scope, target.listFlag);
+  return {
+    ok: true,
+    ...base,
+    deploymentKey: finalStatus.deploymentKey,
+    operation: finalStatus.deploymentResult?.operation ?? finalStatus.synthesizedOperation,
+    status: finalStatus.status,
+    ...finalStatus.deploymentResult?.status && {
+      deploymentStatus: finalStatus.deploymentResult.status,
+      actions: finalStatus.deploymentResult.actions ?? []
+    },
+    ...described,
+    ...landedDespiteStatus && {
+      nextSteps: [
+        explainPipelineStatusAfterInstall(finalStatus),
+        ...described.nextSteps ?? []
+      ]
+    }
+  };
+}
+async function describeUpgradedDeploymentAsync(auth, deploymentName, finalStatus, scope, listFlag) {
+  const record = finalStatus.deploymentResult;
+  const actions = record?.actions ?? [];
+  if (record?.status === "SuccessfulActivate") {
+    return { activationStatus: "Active" };
+  }
+  const reported = reportedActivationStatus(record);
+  const [, rows] = reported ? [undefined, undefined] : await catchError(findDeploymentsByName(auth, deploymentName, scope));
+  const row = rows?.find((candidate) => candidate.key === finalStatus.deploymentKey);
+  const activationStatus = reported ?? row?.activationStatus ?? (actions.includes("SetupActivation") ? "NeedsSetupToActivate" : actions.includes("Activate") ? "ReadyToActivate" : undefined);
+  if (!activationStatus) {
+    return {};
+  }
+  const state = {
+    name: deploymentName,
+    operation: row?.operation ?? record?.operation ?? finalStatus.synthesizedOperation,
+    operationStatus: row?.operationStatus ?? record?.operationStatus ?? "Successful",
+    activationStatus,
+    packageVersion: row?.packageVersion ?? record?.packageVersion,
+    currentPackageVersion: row?.currentPackageVersion ?? record?.packageVersion
+  };
+  const pendingResources = needsPendingResources(state) && finalStatus.deploymentKey ? await readPendingResourcesAsync(pendingResourceApis(auth), { name: deploymentName, key: finalStatus.deploymentKey }, scope) : undefined;
+  const nextSteps = deploymentNextSteps(state, pendingResources, listFlag ? ` ${listFlag}` : "");
+  return {
+    activationStatus,
+    ...pendingResources ? { pendingResources } : {},
+    ...nextSteps && nextSteps.length > 0 ? { nextSteps } : {}
+  };
+}
+async function describeInstallRefusalAsync(installError, context) {
+  const { options, target, deploymentName, packageName } = context;
+  let message = "The upgrade request returned no pipeline deployment.";
+  let classification = {};
+  let instructions = UPGRADE_REFUSED_INSTRUCTIONS;
+  if (installError) {
+    const detail = await extractErrorDetails(installError);
+    message = detail.details ? `${detail.message}: ${detail.details}` : detail.message;
+    classification = {
+      errorCode: detail.errorCode,
+      retry: detail.retry
+    };
+    if (detail.context?.httpStatus === 404) {
+      instructions = `The server knows no such version of '${packageName}' in this feed. ${PACKAGE_INSTRUCTIONS} 'uip solution deploy list' shows the deployment's package and current version.`;
+    }
+    if (hasServerErrorCode(detail.details, DRAFT_VERSION_MISMATCH_CODE)) {
+      return fail4("pending_draft", message, `'${deploymentName}' has a pending draft for another version: an earlier attempt that never completed, usually one rejected by validation, and the server will not upgrade past it. Discard it and upgrade the live version: ${discardRetryCommand(options, target)}${options.deploymentKey ? "" : `
+Under an external app the name form cannot find the draft; pass the deployment's key instead (InstallDeploymentKey from the original deploy, or Key from 'uip solution deploy list').`}`, INVALID_TARGET);
+    }
+  }
+  return fail4("request_failed", message, instructions, classification);
+}
+function trackingHint(pipelineDeploymentId, listFlag) {
+  return listFlag ? `Track it with: uip solution deploy list ${listFlag} (deploy status reads the tenant feed and cannot see this run).` : `Track it with: uip solution deploy status ${pipelineDeploymentId}, or uip solution deploy list.`;
+}
+function acknowledgeRetryCommand(options, target) {
+  const version = versionFlag(options);
+  let address = options.deploymentKey ? quoteForShell(options.deploymentKey) : undefined;
+  if (!address) {
+    const workspace = options.personalWorkspace ? " --personal-workspace" : "";
+    address = `--name ${quoteForShell(target.deploymentName)} --package-name ${quoteForShell(target.packageName)}${workspace}`;
+  }
+  return `uip solution deploy upgrade ${address}${version}${tenantFlag(options)} ${ACKNOWLEDGE_PERMANENT_DELETION_FLAG}`;
+}
+async function consentDraftDecisionAsync(pipelinesApi, options, target, draft, scope) {
+  if (options.noWait && !options.discardDraft) {
+    return;
+  }
+  if (!await draftAwaitsConsentAsync(pipelinesApi, options, target.deploymentName, draft, scope)) {
+    return;
+  }
+  if (options.discardDraft) {
+    return fail4("pending_draft", `Deployment '${target.deploymentName}' has a pending draft (${draft.key}) that awaits the permanent-deletion confirmation, and --discard-draft would drop the links being confirmed.`, `Nothing was changed. To confirm the deletion and upgrade with those links, re-run without --discard-draft: ${acknowledgeRetryCommand(options, target)}. To keep the installed copies instead, re-run without ${ACKNOWLEDGE_PERMANENT_DELETION_FLAG}, which discards the draft: ${discardRetryCommand(options, target, draft.key)}`, INVALID_TARGET);
+  }
+  return "rerun";
+}
+async function draftAwaitsConsentAsync(pipelinesApi, options, deploymentName, draft, scope) {
+  if (!options.acknowledgePermanentDeletion || draft.firstInstall || draft.activationSetup || !draft.targetVersion) {
+    return false;
+  }
+  if (options.version !== undefined && options.version.toLowerCase() !== draft.targetVersion.toLowerCase()) {
+    return false;
+  }
+  const resources = await listPermanentDeletionResourcesAsync(pipelinesApi, deploymentName, draft.key, scope, options.signal);
+  return (resources?.length ?? 0) > 0;
+}
+function discardRetryCommand(options, target, draftKey) {
+  const version = `${versionFlag(options)}${tenantFlag(options)}`;
+  const key = draftKey ?? options.deploymentKey;
+  if (key) {
+    return `uip solution deploy upgrade ${quoteForShell(key)} --discard-draft${version}`;
+  }
+  const workspace = options.personalWorkspace ? " --personal-workspace" : "";
+  return `uip solution deploy upgrade --name ${quoteForShell(target.deploymentName)} --package-name ${quoteForShell(target.packageName)}${workspace} --discard-draft${version}`;
+}
+function tenantFlag(options) {
+  return options.tenant ? ` --tenant ${quoteForShell(options.tenant)}` : "";
+}
+function versionFlag(options) {
+  return options.version ? ` --version ${quoteForShell(options.version)}` : "";
+}
+function validateTarget(options) {
+  const byKey = options.deploymentKey !== undefined;
+  const byName = options.deploymentName !== undefined || options.packageName !== undefined;
+  if (options.version !== undefined && options.version.trim() === "") {
+    return fail4("invalid_target", "--version was given but is empty.", "Pass the version to upgrade to (uip solution packages list shows the published ones), or omit --version to upgrade to the newest.", INVALID_TARGET);
+  }
+  if (byKey && byName) {
+    return fail4("invalid_target", "Pass either a deployment key or --name with --package-name, not both.", TARGET_INSTRUCTIONS, INVALID_TARGET);
+  }
+  if (byKey) {
+    return GUID_PATTERN.test(options.deploymentKey) ? undefined : fail4("invalid_target", `'${options.deploymentKey}' is not a deployment key.`, `A deployment key is a GUID, reported as Key by 'uip solution deploy list'. To address the deployment by name instead: ${TARGET_INSTRUCTIONS}`, INVALID_TARGET);
+  }
+  if (!options.deploymentName || !options.packageName) {
+    return fail4("invalid_target", "--name and --package-name go together: the Pipelines install route needs both.", TARGET_INSTRUCTIONS, INVALID_TARGET);
+  }
+  return;
+}
+async function resolveTargetByNameAsync(pipelinesApi, auth, options) {
+  const deploymentName = options.deploymentName;
+  let scope;
+  if (options.personalWorkspace) {
+    const verdict = classifyFeedSession(auth);
+    if (verdict !== "user") {
+      const { message, instructions } = feedSessionRefusal(verdict, `Upgrading the Personal Workspace deployment '${deploymentName}'`, "address the deployment by key");
+      return fail4("feed_requires_user_session", message, instructions, {
+        errorCode: "permission_denied",
+        retry: "RetryWillNotFix"
+      });
+    }
+    const [pwError, pw] = await catchError(resolvePersonalWorkspace({
+      tenant: options.tenant,
+      loginValidity: options.loginValidity,
+      envFilePath: options.envFilePath
+    }));
+    if (pwError || !pw) {
+      return fail4("personal_workspace_failed", pwError?.message ?? "Personal Workspace could not be resolved.", "Ensure your user has a Personal Workspace, then retry.");
+    }
+    scope = folderKeyInitOverride(pw.key);
+  }
+  const [existsError] = await catchError(pipelinesApi.pipelinesGetPreActivateSteps({ deploymentName }, scope));
+  if (existsError) {
+    const detail = await extractErrorDetails(existsError);
+    const where = scope ? "your Personal Workspace feed" : `the tenant feed of '${auth.tenantName}'`;
+    if (isDeploymentNotFound(detail)) {
+      return fail4("deployment_not_found", `Deployment '${deploymentName}' was not found in ${where}. 'deploy upgrade' never creates a deployment.`, `Check the name with 'uip solution deploy list'${scope ? "" : " (add --personal-workspace for a Personal Workspace deployment)"}. For a first deployment use 'uip solution deploy run'.`, { errorCode: "not_found", retry: "RetryWillNotFix" });
+    }
+    return fail4("lookup_failed", detail.details ? `${detail.message}: ${detail.details}` : detail.message, `The existence check for '${deploymentName}' failed before any upgrade was requested. Retry, or address the deployment by key: uip solution deploy upgrade <deployment-key>.`, { errorCode: detail.errorCode, retry: detail.retry });
+  }
+  const [rowsError, rows] = await catchError(findDeploymentsByName(auth, deploymentName, scope));
+  if (rowsError) {
+    const unreadable = rowsError instanceof DeploymentSearchNeedsUserSessionError || classifyFeedSession(auth) === "application" && isAuthRefusal(rowsError);
+    if (!unreadable) {
+      const detail = await extractErrorDetails(rowsError);
+      return fail4("lookup_failed", `The status check for '${deploymentName}' failed: ${detail.message}`, "The deployment exists, but whether it is still installed could not be confirmed, and upgrading an uninstalled name would deploy the package afresh under it. Retry, or address the deployment by key: uip solution deploy upgrade <deployment-key>.", { errorCode: detail.errorCode, retry: detail.retry });
+    }
+  }
+  if (isCompletedUninstall(rows ? newestDeploymentRow(rows) : undefined)) {
+    return fail4("deployment_uninstalled", `Deployment '${deploymentName}' has been uninstalled, so there is nothing to upgrade.`, "The install route would create a new deployment under that name rather than upgrade this one. Deploy the package afresh with 'uip solution deploy run', or pick a live deployment from 'uip solution deploy list'.", INVALID_TARGET);
+  }
+  const resolved = {
+    deploymentName,
+    packageName: options.packageName,
+    listFlag: scope ? "--personal-workspace" : undefined
+  };
+  let discardedDraftKey;
+  const newest = rows ? newestDeploymentRow(rows) : undefined;
+  if (newest?.operationStatus === "Draft") {
+    const draft = {
+      key: newest.key,
+      firstInstall: newest.operation === "Install",
+      activationSetup: newest.operation === "ActivationSetup",
+      targetVersion: newest.targetPackageVersion ?? newest.packageVersion,
+      liveVersion: newest.currentPackageVersion
+    };
+    const consentDraft = await consentDraftDecisionAsync(pipelinesApi, options, resolved, draft, scope);
+    if (consentDraft && consentDraft !== "rerun") {
+      return consentDraft;
+    }
+    if (consentDraft === "rerun") {
+      return {
+        ok: true,
+        ...resolved,
+        scope,
+        pendingDraftVersion: draft.targetVersion ?? undefined
+      };
+    }
+    const refusal = refusePendingDraft(options, resolved, draft);
+    if (refusal) {
+      return refusal;
+    }
+    const discarded = await discardDraftAsync(pipelinesApi, deploymentName, draft.key, scope);
+    if (discarded) {
+      return discarded;
+    }
+    discardedDraftKey = draft.key;
+  }
+  return {
+    ok: true,
+    ...resolved,
+    scope,
+    discardedDraftKey
+  };
+}
+function isDeploymentNotFound(detail) {
+  const status = detail.context?.httpStatus;
+  if (status === 404) {
+    return true;
+  }
+  return status === 400 && (/"errorCode"\s*:\s*"4004"/.test(detail.details) || (detail.parsedErrors?.deploymentName ?? []).some((message) => /not found/i.test(message)));
+}
+async function resolveTargetByKeyAsync(pipelinesApi, auth, options, deploymentKey) {
+  const [lookupError, info] = await catchError(pipelinesApi.pipelinesGetDeploymentByKey({ key: deploymentKey }));
+  if (lookupError || !info) {
+    const detail = lookupError ? await extractErrorDetails(lookupError) : undefined;
+    if (detail?.context?.httpStatus === 404 && classifyFeedSession(auth) === "user") {
+      return resolveTargetByKeyViaSolutionsAsync(pipelinesApi, auth, options, deploymentKey);
+    }
+    if (!detail || detail.context?.httpStatus === 404) {
+      return fail4("deployment_not_found", `Deployment '${deploymentKey}' was not found in tenant '${auth.tenantName}'.`, DEPLOYMENT_NOT_FOUND_INSTRUCTIONS, { errorCode: "not_found", retry: "RetryWillNotFix" });
+    }
+    return fail4("lookup_failed", detail.details ? `${detail.message}: ${detail.details}` : detail.message, LOOKUP_FAILED_INSTRUCTIONS, { errorCode: detail.errorCode, retry: detail.retry });
+  }
+  if (info.status === DeploymentStatus.SuccessfulUninstall) {
+    return fail4("deployment_uninstalled", `Deployment '${info.deploymentName}' (${deploymentKey}) has been uninstalled, so there is nothing to upgrade.`, "The install route would create a new deployment under that name rather than upgrade this one. Deploy the package afresh with 'uip solution deploy run', or pick a live deployment from 'uip solution deploy list'.", INVALID_TARGET);
+  }
+  let scope;
+  if (info.locationKey) {
+    const verdict = classifyFeedSession(auth);
+    if (verdict !== "user") {
+      const { message, instructions } = feedSessionRefusal(verdict, `Upgrading deployment '${info.deploymentName}', which is in a Personal Workspace or folder feed (folder key ${info.locationKey}),`, "run the upgrade from the Orchestrator UI");
+      return fail4("feed_requires_user_session", message, instructions, {
+        errorCode: "permission_denied",
+        retry: "RetryWillNotFix"
+      });
+    }
+    scope = folderKeyInitOverride(info.locationKey);
+  } else if (options.personalWorkspace) {
+    return fail4("invalid_target", `Deployment '${info.deploymentName}' (${deploymentKey}) is on the tenant feed, not in a Personal Workspace.`, "Drop --personal-workspace: with a deployment key the feed is read from the deployment itself.", INVALID_TARGET);
+  }
+  const listFlag = info.locationKey ? `--feed ${info.locationKey}` : undefined;
+  let live = info;
+  let discardedDraftKey;
+  if (info.status === DeploymentStatus.Draft) {
+    const draft = {
+      key: info.deploymentKey,
+      firstInstall: info.operation === DeploymentOperation.Install,
+      activationSetup: info.operation === DeploymentOperation.ActivationSetup,
+      targetVersion: info.targetPackageVersion ?? info.packageVersion,
+      liveVersion: info.packageVersion
+    };
+    const consentDraft = await consentDraftDecisionAsync(pipelinesApi, options, {
+      deploymentName: info.deploymentName,
+      packageName: info.packageName,
+      listFlag
+    }, draft, scope);
+    if (consentDraft && consentDraft !== "rerun") {
+      return consentDraft;
+    }
+    if (consentDraft === "rerun") {
+      return {
+        ok: true,
+        deploymentName: info.deploymentName,
+        packageName: info.packageName,
+        scope,
+        listFlag,
+        fromVersion: info.packageVersion ?? undefined,
+        installDeploymentKey: info.installDeploymentKey,
+        pendingDraftVersion: draft.targetVersion ?? undefined
+      };
+    }
+    const refusal = refusePendingDraft(options, {
+      deploymentName: info.deploymentName,
+      packageName: info.packageName,
+      listFlag
+    }, draft);
+    if (refusal) {
+      return refusal;
+    }
+    const discarded = await discardDraftAsync(pipelinesApi, info.deploymentName, draft.key, scope);
+    if (discarded) {
+      return discarded;
+    }
+    const [relookupError, current] = await catchError(pipelinesApi.pipelinesGetDeploymentByKey({
+      key: info.installDeploymentKey
+    }));
+    if (relookupError || !current) {
+      const detail = relookupError ? await extractErrorDetails(relookupError) : undefined;
+      return fail4("lookup_failed", `The pending draft ${draft.key} of '${info.deploymentName}' was discarded, but the live deployment could not be looked up again${detail ? `: ${detail.message}` : "."}`, `Nothing was upgraded. Retry the upgrade: uip solution deploy upgrade ${quoteForShell(info.installDeploymentKey)}${versionFlag(options)}${tenantFlag(options)}`, detail ? { errorCode: detail.errorCode, retry: detail.retry } : {});
+    }
+    if (current.status === DeploymentStatus.Draft || current.status === DeploymentStatus.SuccessfulUninstall) {
+      return fail4("pending_draft", `The pending draft ${draft.key} of '${info.deploymentName}' was discarded, but the deployment's newest generation is now ${current.status === DeploymentStatus.Draft ? `another draft (${current.deploymentKey})` : "an uninstall"}.`, "Nothing was upgraded. Another operation on this deployment ran in between; check it with 'uip solution deploy list', then retry.", INVALID_TARGET);
+    }
+    live = current;
+    discardedDraftKey = draft.key;
+  }
+  return {
+    ok: true,
+    deploymentName: live.deploymentName,
+    packageName: live.packageName,
+    scope,
+    listFlag,
+    fromVersion: live.packageVersion ?? undefined,
+    installDeploymentKey: live.installDeploymentKey,
+    discardedDraftKey
+  };
+}
+async function resolveTargetByKeyViaSolutionsAsync(pipelinesApi, auth, options, deploymentKey) {
+  let scope;
+  if (options.personalWorkspace) {
+    const [pwError, pw] = await catchError(resolvePersonalWorkspace({
+      tenant: options.tenant,
+      loginValidity: options.loginValidity,
+      envFilePath: options.envFilePath
+    }));
+    if (pwError || !pw) {
+      return fail4("personal_workspace_failed", pwError?.message ?? "Personal Workspace could not be resolved.", "Ensure your user has a Personal Workspace, then retry.");
+    }
+    scope = folderKeyInitOverride(pw.key);
+  }
+  const deploymentsApi = new DeploymentsApi(new Configuration2({
+    basePath: auth.basePath,
+    accessToken: auth.accessToken
+  }));
+  const [readError, row] = await catchError(deploymentsApi.deploymentsGetByKey({ deploymentKey }, scope));
+  if (readError || !row) {
+    const detail = readError ? await extractErrorDetails(readError) : undefined;
+    if (!detail || detail.context?.httpStatus === 404) {
+      return fail4("deployment_not_found", `Deployment '${deploymentKey}' was not found in ${scope ? "your Personal Workspace feed" : `the tenant feed of '${auth.tenantName}'`}.`, `Check the key with 'uip solution deploy list'. Neither the Pipelines deployment lookup nor the Solutions read found it; the latter reads a key on the tenant feed, or with --personal-workspace in your workspace, so address a folder-feed deployment with --name and --package-name instead.`, { errorCode: "not_found", retry: "RetryWillNotFix" });
+    }
+    return fail4("lookup_failed", detail.details ? `${detail.message}: ${detail.details}` : detail.message, LOOKUP_FAILED_INSTRUCTIONS, { errorCode: detail.errorCode, retry: detail.retry });
+  }
+  if (row.status === "SuccessfulUninstall") {
+    return fail4("deployment_uninstalled", `Deployment '${row.name}' (${deploymentKey}) has been uninstalled, so there is nothing to upgrade.`, "The install route would create a new deployment under that name rather than upgrade this one. Deploy the package afresh with 'uip solution deploy run', or pick a live deployment from 'uip solution deploy list'.", INVALID_TARGET);
+  }
+  const target = await resolveTargetByNameAsync(pipelinesApi, auth, {
+    ...options,
+    deploymentName: row.name,
+    packageName: row.packageName
+  });
+  if (!target.ok) {
+    return target;
+  }
+  return { ...target, installDeploymentKey: row.installDeploymentKey };
+}
+function refusePendingDraft(options, target, draft) {
+  const targetVersion = draft.targetVersion ?? "<version>";
+  const feed = target.listFlag ? ` ${target.listFlag}` : "";
+  const packageVersion = draft.targetVersion ? quoteForShell(draft.targetVersion) : "<version>";
+  const retryDraft = `uip solution deploy run --name ${quoteForShell(target.deploymentName)} --package-name ${quoteForShell(target.packageName)} --package-version ${packageVersion} --config-file <fixed-config>${feed}${tenantFlag(options)} --yes`;
+  if (draft.firstInstall) {
+    return fail4("pending_draft", `Deployment '${target.deploymentName}' was never installed: its first install (${draft.key}) is still a pending draft, so there is nothing to upgrade.`, `The draft is an attempt that never completed, usually one rejected by validation, or one still running. To retry it with a corrected configuration: ${retryDraft} (the server re-validates the draft with the new file). To abandon it, delete it in Orchestrator.`, INVALID_TARGET);
+  }
+  if (options.discardDraft) {
+    return;
+  }
+  if (draft.activationSetup) {
+    return fail4("pending_draft", `Deployment '${target.deploymentName}' has an unfinished Setup activation (${draft.key}): the Orchestrator "Setup activation" wizard was started on version ${targetVersion} and not completed.`, `While that draft exists the server would run it in place of this upgrade, or refuse a different version. Finish the setup in Orchestrator (Solutions, the deployment, Setup activation), then retry; or discard it and upgrade the live version: ${discardRetryCommand(options, target, draft.key)}`, INVALID_TARGET);
+  }
+  const live = draft.liveVersion ? ` ${draft.liveVersion}` : "";
+  return fail4("pending_draft", `Deployment '${target.deploymentName}' has a pending draft (${draft.key}) for version ${targetVersion}: an earlier attempt that never completed, usually one rejected by validation, or one still running.`, `The server would run that draft, with the configuration it was built with, in place of this upgrade, or refuse a different version. To discard it and upgrade the live version${live}: ${discardRetryCommand(options, target, draft.key)}
+To retry the draft itself with a corrected configuration instead: ${retryDraft}`, INVALID_TARGET);
+}
+async function discardDraftAsync(pipelinesApi, deploymentName, draftKey, scope) {
+  const [error] = await catchError(pipelinesApi.pipelinesDeleteDeploymentByKey({ deploymentKey: draftKey }, scope));
+  if (!error) {
+    return;
+  }
+  const detail = await extractErrorDetails(error);
+  const status = detail.context?.httpStatus;
+  const hasBody = !isBareResponse(detail.details);
+  if (hasServerErrorCode(detail.details, "DeploymentNotFound") || status === 404 && hasBody) {
+    return;
+  }
+  const message = `The pending draft ${draftKey} of '${deploymentName}' could not be discarded: ${hasBody ? `${detail.message}: ${detail.details}` : detail.message}`;
+  if (status === 405 || status === 404 && !hasBody) {
+    return fail4("discard_draft_failed", message, "This server cannot discard drafts through the Pipelines API yet. Nothing was upgraded. Delete the draft in Orchestrator, then retry the upgrade.", {
+      errorCode: status === 405 ? "method_not_allowed" : "not_found",
+      retry: "RetryWillNotFix"
+    });
+  }
+  if (hasServerErrorCode(detail.details, "DeploymentAlreadyInProgress")) {
+    return fail4("discard_draft_failed", message, "The draft is still being validated. Nothing was upgraded. Wait for its run to finish (uip solution deploy list shows it), then retry.", { errorCode: "invalid_argument", retry: "RetryLater" });
+  }
+  if (hasServerErrorCode(detail.details, "DeploymentInvalidState")) {
+    return fail4("discard_draft_failed", message, "The draft is no longer one that can be discarded: it moved on (it was promoted, or it is a rollback). Nothing was upgraded. Check the deployment with 'uip solution deploy list', then retry.", INVALID_TARGET);
+  }
+  return fail4("discard_draft_failed", message, "Nothing was upgraded. Retry, or delete the draft in Orchestrator and then retry the upgrade.", { errorCode: detail.errorCode, retry: detail.retry });
+}
+function classifyTerminalFailure(status) {
+  return status === "ValidationFailed" || status === "ConflictFixingError" ? { errorCode: "invalid_argument", retry: "RetryWillNotFix" } : {};
+}
+async function describeUpgradeFailureAsync(basePath, accessToken, pipelineDeploymentId, finalStatus, scope, signal) {
+  const fromPipeline = formatDeploymentFailureDetails(pipelineDeploymentId, finalStatus);
+  const explained = finalStatus.validationResult?.validationErrors?.length || finalStatus.validationResult?.conflictErrors?.length || finalStatus.conflictFixingErrors?.length || finalStatus.deploymentScheduleErrors?.length || finalStatus.deploymentResult?.errorMessage;
+  if (explained || !finalStatus.deploymentKey) {
+    return fromPipeline;
+  }
+  const deploymentsApi = new DeploymentsApi(new Configuration2({ basePath, accessToken }));
+  const reason = await describeValidationFailureAsync(deploymentsApi, finalStatus.deploymentKey, SolutionDeploymentAction.Upgrade, scope, signal);
+  return reason === NO_SERVER_REASON ? fromPipeline : `Validation: ${reason}
+${fromPipeline}`;
+}
+
+// ../solution-sdk/src/legacy-package-search.ts
+var LEGACY_PACKAGE_SEARCH_ROUTE = "POST /api/search/packages";
+async function searchPackagesLegacy(auth, query, scope) {
+  const api = new SearchApi(new Configuration2({
+    basePath: auth.basePath,
+    accessToken: auth.accessToken
+  }));
+  const response = await api.searchSearchPackagesRaw({
+    searchFilter: {
+      take: query.take,
+      skip: query.skip,
+      searchTerm: query.searchTerm,
+      orderByColumn: query.orderByColumn,
+      orderByDirection: query.orderByDirection
+    }
+  }, scope);
+  return response.raw.json();
+}
+
+// ../solution-sdk/src/package-search.ts
+var PIPELINES_SEARCH_ROUTE = "POST /v1/pipelines/packages/search";
+
+class PackageSearchNeedsUserSessionError extends Error {
+  constructor() {
+    super("This server's package search reads user sessions only; an application (client-credentials) login cannot read it. Sign in with 'uip login' to use it.");
+    this.name = "PackageSearchNeedsUserSessionError";
+  }
+}
+var PACKAGE_ROWS = {
+  singular: "package",
+  plural: "packages",
+  fromJSON: PackageInfoFromJSON,
+  isRow: (row) => isNonEmptyString(row, "key") && isNonEmptyString(row, "name")
+};
+function isNonEmptyString(row, field) {
+  const value = field in row ? row[field] : undefined;
+  return typeof value === "string" && value !== "";
+}
+var serversWithoutPipelinesSearch = new Set;
+async function searchPackagesPage(auth, query, scope) {
+  if (!serversWithoutPipelinesSearch.has(auth.basePath)) {
+    const [error, body2] = await catchError(searchViaPipelines(auth, query, scope));
+    if (!error) {
+      return {
+        ...parseSearchPage(body2, PIPELINES_SEARCH_ROUTE, PACKAGE_ROWS),
+        source: "pipelines"
+      };
+    }
+    if (!await isMissingPipelinesRoute(error)) {
+      throw error;
+    }
+    serversWithoutPipelinesSearch.add(auth.basePath);
+    logger.debug(`${PIPELINES_SEARCH_ROUTE} is not served at ${auth.basePath}; using the deprecated ${LEGACY_PACKAGE_SEARCH_ROUTE}.`);
+  }
+  if (isApplicationSession(auth)) {
+    throw new PackageSearchNeedsUserSessionError;
+  }
+  const body = await searchPackagesLegacy(auth, query, scope);
+  return {
+    ...parseSearchPage(body, LEGACY_PACKAGE_SEARCH_ROUTE, PACKAGE_ROWS),
+    source: "legacy"
+  };
+}
+async function searchViaPipelines(auth, query, scope) {
+  const api = new PipelinesApi(new Configuration({
+    basePath: auth.basePath,
+    accessToken: auth.accessToken
+  }));
+  const response = await api.pipelinesSearchPackagesRaw({
+    pipelinePackagesSearchRequest: {
+      take: query.take,
+      skip: query.skip,
+      searchTerm: query.searchTerm,
+      orderByColumn: query.orderByColumn,
+      orderByDirection: query.orderByDirection
+    }
+  }, scope);
+  return response.raw.json();
+}
+// src/services/packages-list-service.ts
+var fail5 = (reason, message, instructions, extras = {}) => ({
+  ok: false,
+  reason,
+  message,
+  instructions,
+  exitCode: 1,
+  ...extras
+});
+var refuseFeedRead2 = (refusal) => fail5("feed_requires_user_session", refusal.message, refusal.instructions, {
+  errorCode: "permission_denied",
+  retry: "RetryWillNotFix"
+});
+async function listPackagesAsync(options = {}) {
+  const limit = options.limit ?? DEFAULT_PAGE_SIZE;
+  const offset = options.offset ?? 0;
+  const [authError, auth] = await catchError(getSolutionAuthContext({
+    tenant: options.tenant,
+    loginValidity: options.loginValidity,
+    envFilePath: options.envFilePath
+  }));
+  if (authError) {
+    return fail5("auth_failed", authError.message, authError.message);
+  }
+  if (options.personalWorkspace) {
+    const refusal = feedReadRefusalForApplication(auth, "Listing the Personal Workspace's packages");
+    if (refusal) {
+      return refuseFeedRead2(refusal);
+    }
+  }
+  const [scopeError, scope] = await catchError(resolveFeedScope({
+    personalWorkspace: options.personalWorkspace,
+    feed: options.feed,
+    tenant: options.tenant,
+    loginValidity: options.loginValidity,
+    envFilePath: options.envFilePath
+  }));
+  if (scopeError) {
+    const { message, instructions, ...extras } = await describeFeedResolutionFailureAsync(scopeError, options, auth);
+    return fail5("feed_resolution_failed", message, instructions, extras);
+  }
+  if (scope.kind !== "tenant") {
+    const refusal = feedReadRefusalForApplication(auth, `Listing the packages of the feed '${scope.name ?? scope.folderKey}'`);
+    if (refusal) {
+      return refuseFeedRead2(refusal);
+    }
+  }
+  const [listError, result] = await catchError(searchPackagesPage(auth, {
+    take: limit,
+    skip: offset,
+    orderByColumn: options.sortBy ?? "publishDate",
+    orderByDirection: options.sortOrder ?? "Descending",
+    searchTerm: options.name
+  }, feedScopeInitOverride(scope)));
+  if (listError instanceof PackageSearchNeedsUserSessionError) {
+    return fail5("list_request_failed", `Failed to list packages: ${listError.message}`, "Run it with a user session ('uip login'). A client-credentials login cannot list packages on this server.", { errorCode: "permission_denied", retry: "RetryWillNotFix" });
+  }
+  if (listError) {
+    const { message, instructions, ...extras } = await describeSearchFailureAsync(listError, "packages");
+    return fail5("list_request_failed", message, instructions, extras);
+  }
+  const packages = result.values;
+  return {
+    ok: true,
+    packages,
+    limit,
+    offset,
+    total: result.count
+  };
+}
+
+export { activateDeploymentAsync, listDeploymentsAsync, uninstallDeploymentAsync, upgradeDeploymentAsync, listPackagesAsync };
+
+//# debugId=AC06BACB6D23A44764756E2164756E21