@uipath/solution-tool 1.203.0-preview.212 → 1.204.0-preview.211

package/dist/{packager-tool-grtmkd54.js → packager-tool-3m36mxn7.js}

@@ -1,25 +1,25 @@
 import {
   Configuration,
-  PipelinesApi,
+  PipelinesApi
+} from "./packager-tool-qgaqqq41.js";
+import {
   feedScopeInitOverride,
   resolveFeedScope
-} from "./packager-tool-2p5yh1q9.js";
-import {
-  Configuration as Configuration2,
-  PackagesApi
-} from "./packager-tool-7qmx64kz.js";
+} from "./packager-tool-qdtjywsk.js";
 import {
   getSolutionAuthContext
-} from "./packager-tool-2syrt51a.js";
+} from "./packager-tool-f5gq77m5.js";
 import {
   PollOutcome,
   catchError,
   extractErrorDetails,
-  getFileSystem,
   logger,
   mapPollFailure,
   pollUntil
-} from "./packager-tool-0f0wt9vh.js";
+} from "./packager-tool-5fjp60dk.js";
+import {
+  getFileSystem
+} from "./packager-tool-zf3929se.js";
 import {
   strFromU8,
   strToU8,
@@ -248,15 +248,16 @@ async function publishSolutionAsync(packagePath, options = {}) {
       message: scopeError.message
     };
   }
-  if (scope.kind !== "tenant") {
-    return publishToFeed(auth, fileBuffer, scope, options);
-  }
   const configuration = new Configuration({
     basePath: auth.basePath,
     accessToken: auth.accessToken
   });
   const api = new PipelinesApi(configuration);
-  const [uploadError, uploadResult] = await catchError(api.pipelinesPackageUpload({ body: fileBuffer }));
+  const feedScope = feedScopeInitOverride(scope);
+  const [uploadError, uploadResult] = await catchError(api.pipelinesPackageUpload({
+    body: fileBuffer,
+    locationKey: scope.folderKey
+  }));
   if (uploadError) {
     return mapUploadError(uploadError);
   }
@@ -266,7 +267,7 @@ async function publishSolutionAsync(packagePath, options = {}) {
       fn: () => api.pipelinesGetPackageVersion({
         packageName: uploadResult.packageName,
         packageVersion: uploadResult.packageVersion
-      }),
+      }, feedScope),
       until: (result) => TERMINAL_STATES.has(result.state),
       getStatus: (result) => result.state,
       label: `publish ${uploadResult.packageName}:${uploadResult.packageVersion}`,
@@ -301,65 +302,6 @@ async function publishSolutionAsync(packagePath, options = {}) {
     packageName: packageVersionInfo.packageName,
     packageVersion: packageVersionInfo.packageVersion,
     state: packageVersionInfo.state,
-    feedKind: "tenant"
-  };
-}
-async function publishToFeed(auth, fileBuffer, scope, options) {
-  const config = new Configuration2({
-    basePath: auth.basePath,
-    accessToken: auth.accessToken
-  });
-  const api = new PackagesApi(config);
-  const [uploadError, packageVersionKey] = await catchError(api.packagesUpload({
-    body: fileBuffer,
-    locationKey: scope.folderKey
-  }));
-  if (uploadError) {
-    return mapUploadError(uploadError);
-  }
-  const feedScope = feedScopeInitOverride(scope);
-  const [getError, initialInfo] = await catchError(api.packagesGetVersion({ packageVersionKey }, feedScope));
-  if (getError) {
-    logger.warn(`Package uploaded (key ${packageVersionKey}) but its metadata was not yet retrievable; PackageName/PackageVersion/State will be absent from output: ${getError.message}`);
-  }
-  let packageVersionInfo = getError ? undefined : initialInfo;
-  if (options.wait) {
-    const pollResult = await pollUntil({
-      fn: () => api.packagesGetVersion({ packageVersionKey }, feedScope),
-      until: (result) => TERMINAL_STATES.has(result.state),
-      getStatus: (result) => result.state,
-      label: `publish ${packageVersionInfo ? `${packageVersionInfo.packageName}:${packageVersionInfo.packageVersion}` : packageVersionKey}`,
-      logPrefix: "publish",
-      timeoutMs: (options.timeout ?? 360) * 1000,
-      intervalMs: options.pollInterval ?? 5000,
-      signal: options.signal
-    });
-    if (pollResult.outcome !== PollOutcome.Completed) {
-      const { reason, message } = mapPollFailure(pollResult, "Package publish");
-      return { ok: false, reason, message };
-    }
-    if (!pollResult.data) {
-      return {
-        ok: false,
-        reason: "poll_failed",
-        message: "Package publish did not return a final state."
-      };
-    }
-    packageVersionInfo = pollResult.data;
-    if (packageVersionInfo.state === "Failed") {
-      return {
-        ok: false,
-        reason: "publish_failed",
-        message: `Package publish failed with state: ${packageVersionInfo.state}`
-      };
-    }
-  }
-  return {
-    ok: true,
-    packageVersionKey: packageVersionInfo?.key ?? packageVersionKey,
-    packageName: packageVersionInfo?.packageName,
-    packageVersion: packageVersionInfo?.packageVersion,
-    state: packageVersionInfo?.state,
     feedKind: scope.kind
   };
 }
@@ -392,4 +334,4 @@ async function mapUploadError(uploadError) {
 
 export { publishSolutionAsync };
 
-//# debugId=A863118C75768F1764756E2164756E21
+//# debugId=1A9ADF95167C0E9D64756E2164756E21

package/dist/packager-tool-40vcj4wv.js

@@ -0,0 +1,172 @@
+import {
+  findDeploymentByName,
+  findLiveDeploymentByName
+} from "./packager-tool-482eg22x.js";
+import {
+  folderKeyInitOverride,
+  listSelectablePublishLocations,
+  resolvePersonalWorkspace
+} from "./packager-tool-qdtjywsk.js";
+import {
+  catchError,
+  extractErrorDetails
+} from "./packager-tool-5fjp60dk.js";
+
+// src/services/deployment-feed-locator.ts
+var sweepResult = (location, skipped) => ({
+  location,
+  skipped,
+  complete: skipped.length === 0
+});
+async function nonTenantFeedsAsync(options) {
+  const [listError, locations] = await catchError(listSelectablePublishLocations({
+    tenant: options.tenant,
+    loginValidity: options.loginValidity,
+    envFilePath: options.envFilePath
+  }));
+  if (!listError) {
+    const rank = (location) => location.type === "PersonalWorkspace" ? 0 : 1;
+    const feeds = [];
+    const skipped2 = [];
+    const nonTenant = [...locations].filter((location) => location.type !== "Tenant").sort((a, b) => rank(a) - rank(b));
+    for (const location of nonTenant) {
+      const kind = location.type === "PersonalWorkspace" ? "personal" : "folder";
+      if (location.key) {
+        feeds.push({ kind, folderKey: location.key });
+        continue;
+      }
+      skipped2.push({
+        kind,
+        reason: "no_key",
+        name: location.name,
+        error: new Error(`The list of feeds returned ${kind === "personal" ? "the Personal Workspace" : `folder feed '${location.name}'`} with no folder key, so it could not be searched.`)
+      });
+    }
+    return { feeds, skipped: skipped2 };
+  }
+  const skipped = [
+    { kind: "folder", reason: "listing_failed", error: listError }
+  ];
+  const [workspaceError, personalWorkspace] = await catchError(resolvePersonalWorkspace({
+    tenant: options.tenant,
+    loginValidity: options.loginValidity,
+    envFilePath: options.envFilePath
+  }));
+  if (workspaceError) {
+    skipped.push({
+      kind: "personal",
+      reason: "workspace_unresolved",
+      error: workspaceError
+    });
+  }
+  return {
+    feeds: personalWorkspace?.key ? [{ kind: "personal", folderKey: personalWorkspace.key }] : [],
+    skipped
+  };
+}
+async function findDeploymentAcrossFeeds(auth, deploymentName, options) {
+  const find = options.includeUninstalled ? findDeploymentByName : findLiveDeploymentByName;
+  const [tenantError, tenantMatch] = await catchError(find(auth, deploymentName));
+  if (tenantError) {
+    return sweepResult(undefined, [
+      { kind: "tenant", reason: "search_failed", error: tenantError }
+    ]);
+  }
+  if (tenantMatch) {
+    return sweepResult({ deployment: tenantMatch }, []);
+  }
+  const { feeds, skipped } = await nonTenantFeedsAsync(options);
+  for (const feed of feeds) {
+    const scope = folderKeyInitOverride(feed.folderKey);
+    const [searchError, deployment] = await catchError(find(auth, deploymentName, scope));
+    if (searchError) {
+      skipped.push({
+        ...feed,
+        reason: "search_failed",
+        error: searchError
+      });
+      continue;
+    }
+    if (deployment) {
+      return sweepResult({ deployment, scope, feed }, skipped);
+    }
+  }
+  return sweepResult(undefined, skipped);
+}
+
+// src/services/incomplete-feed-sweep.ts
+function isNameOrFeedRefusal(errorCode, httpStatus) {
+  return errorCode === "not_found" || errorCode === "invalid_argument" && httpStatus === 400;
+}
+var INCOMPLETE_SWEEP_ADVICE = "The deployment may be in a feed that was not searched.";
+function describeSkippedFeed(feed) {
+  const noKey = feed.reason === "no_key" ? " (the list of feeds gave it no key)" : "";
+  switch (feed.kind) {
+    case "tenant":
+      return "the tenant feed";
+    case "personal":
+      return feed.folderKey ? `your Personal Workspace feed (${feed.folderKey})` : `your Personal Workspace feed${noKey}`;
+    case "folder":
+      if (feed.reason === "listing_failed") {
+        return "the folder feeds (the list of feeds could not be read)";
+      }
+      if (feed.folderKey) {
+        return `folder feed ${feed.folderKey}`;
+      }
+      return feed.name ? `folder feed '${feed.name}'${noKey}` : `a folder feed${noKey}`;
+  }
+}
+function retryAdvice(errorCode, retry, service) {
+  switch (errorCode) {
+    case "authentication_required":
+      return "Run 'uip login' to refresh the session, then retry.";
+    case "permission_denied":
+      return "The account or its token lacks access; check the session and its scopes with 'uip login status --detailed', then retry.";
+    case "network_error":
+      return "Check the connection, then retry.";
+    case "rate_limited":
+      return "Wait a moment, then retry.";
+    default:
+      return retry === "RetryWillNotFix" ? "Retrying alone will not help; fix the cause in the details first." : `Retry once ${service} answers.`;
+  }
+}
+var NO_KEY_NEXT_STEP = "Retrying will not help: the list of feeds gives the skipped feeds no folder key, so neither the search nor --feed can reach them. Run 'uip solution feeds list' to see each feed's Key.";
+var keylessOnly = (skipped) => skipped.length > 0 && skipped.every((feed) => feed.reason === "no_key");
+function oneFeedFlags(skipped) {
+  const flags = [];
+  if (!skipped.some((feed) => feed.reason === "workspace_unresolved")) {
+    flags.push("--personal-workspace");
+  }
+  if (!skipped.some((feed) => feed.reason === "listing_failed") && !keylessOnly(skipped)) {
+    flags.push("--feed <name-or-key>");
+  }
+  return flags;
+}
+function isClassified(cause) {
+  return cause.errorCode !== "not_found" && cause.errorCode !== "unknown_error";
+}
+async function reportIncompleteSweepAsync(deploymentName, skipped) {
+  const feeds = skipped.map(describeSkippedFeed).join(", ");
+  const causes = await Promise.all(skipped.map((feed) => extractErrorDetails(feed.error)));
+  const cause = causes.find(isClassified) ?? causes[0] ?? await extractErrorDetails(undefined);
+  const unclassified = !isClassified(cause);
+  const keyless = keylessOnly(skipped);
+  const errorCode = unclassified ? "unknown_error" : cause.errorCode;
+  let retry = unclassified ? "RetryLater" : cause.retry;
+  if (keyless) {
+    retry = "RetryWillNotFix";
+  }
+  const message = skipped.some((feed) => feed.kind === "tenant") ? `Could not look up deployment '${deploymentName}': ${feeds} could not be searched.` : `Deployment '${deploymentName}' was not found in the feeds that answered, but these could not be searched: ${feeds}.`;
+  return {
+    message,
+    errorCode,
+    retry,
+    details: cause.details,
+    nextStep: keyless ? NO_KEY_NEXT_STEP : retryAdvice(errorCode, retry, "the feed service"),
+    oneFeedFlags: oneFeedFlags(skipped)
+  };
+}
+
+export { findDeploymentAcrossFeeds, isNameOrFeedRefusal, INCOMPLETE_SWEEP_ADVICE, retryAdvice, reportIncompleteSweepAsync };
+
+//# debugId=43A92F098DF7C11664756E2164756E21

package/dist/packager-tool-482eg22x.js

@@ -0,0 +1,322 @@
+import {
+  Configuration as Configuration2,
+  PipelinesApi
+} from "./packager-tool-qgaqqq41.js";
+import {
+  Configuration,
+  DeploymentSearchItemDto2FromJSON,
+  SearchApi
+} from "./packager-tool-00vh1ktg.js";
+import {
+  classifyFeedSession
+} from "./packager-tool-bqre28m1.js";
+import {
+  catchError,
+  logger
+} from "./packager-tool-5fjp60dk.js";
+
+// src/services/http-status.ts
+function httpStatusOf(error) {
+  if (!error || typeof error !== "object") {
+    return;
+  }
+  const response = error.response;
+  const fromResponse = response && typeof response === "object" ? response.status : undefined;
+  const status = typeof fromResponse === "number" ? fromResponse : error.status;
+  return typeof status === "number" ? status : undefined;
+}
+function isAuthRefusal(error) {
+  const status = httpStatusOf(error);
+  return status === 401 || status === 403;
+}
+
+// src/services/legacy-deployment-search-v3.ts
+async function searchDeploymentsLegacyV3(auth, query, scope) {
+  const api = new SearchApi(new Configuration({
+    basePath: auth.basePath,
+    accessToken: auth.accessToken
+  }));
+  const result = await api.searchSearchDeployments22({ deploymentsSearchRequest2: toLegacyV3Request(query) }, scope);
+  const values = result.values ?? [];
+  return { count: result.count, values };
+}
+function toLegacyV3Request(query) {
+  return {
+    searchTerm: query.searchTerm ?? query.deploymentName ?? query.packageName,
+    packageName: query.packageName,
+    ...query.targetFolderName ? { targetFolderName: query.targetFolderName } : {},
+    take: query.take,
+    skip: query.skip,
+    orderByColumn: query.orderByColumn,
+    orderByDirection: query.orderByDirection,
+    operationStatuses: query.operationStatuses ?? [],
+    activationStatuses: query.activationStatuses ?? []
+  };
+}
+
+// src/services/deployment-search-client.ts
+var PIPELINES_SEARCH_ROUTE = "POST /v1/pipelines/deployments/search";
+
+class DeploymentSearchNeedsUserSessionError extends Error {
+  constructor() {
+    super("This server's deployment search reads user sessions only; an application (client-credentials) login cannot read it. Sign in with 'uip login' to use it.");
+    this.name = "DeploymentSearchNeedsUserSessionError";
+  }
+}
+var serversWithoutPipelinesSearch = new Set;
+async function isMissingPipelinesSearchRoute(error) {
+  const status = httpStatusOf(error);
+  if (status === 405) {
+    return true;
+  }
+  if (status !== 404) {
+    return false;
+  }
+  const response = error.response;
+  const [, body] = await catchError(response ? response.clone().text() : Promise.resolve(""));
+  return (body ?? "").trim() === "";
+}
+async function searchDeploymentsPage(auth, query, scope) {
+  if (!serversWithoutPipelinesSearch.has(auth.basePath)) {
+    const [error, page2] = await catchError(searchViaPipelines(auth, query, scope));
+    if (!error) {
+      return { ...page2, source: "pipelines" };
+    }
+    if (!await isMissingPipelinesSearchRoute(error)) {
+      throw error;
+    }
+    serversWithoutPipelinesSearch.add(auth.basePath);
+    logger.debug(`${PIPELINES_SEARCH_ROUTE} is not served at ${auth.basePath}; using the deprecated POST /api/v3/search/deployments.`);
+  }
+  if (classifyFeedSession(auth) === "application") {
+    throw new DeploymentSearchNeedsUserSessionError;
+  }
+  const page = await searchDeploymentsLegacyV3(auth, query, scope);
+  return { ...page, source: "legacy-v3" };
+}
+async function searchViaPipelines(auth, query, scope) {
+  const api = new PipelinesApi(new Configuration2({
+    basePath: auth.basePath,
+    accessToken: auth.accessToken
+  }));
+  const response = await api.pipelinesSearchDeploymentsRaw({
+    pipelineDeploymentsSearchRequest: {
+      take: query.take,
+      skip: query.skip,
+      deploymentName: query.deploymentName,
+      packageName: query.packageName,
+      targetFolderName: query.targetFolderName,
+      searchTerm: query.searchTerm,
+      orderByColumn: query.orderByColumn,
+      orderByDirection: query.orderByDirection,
+      operationStatuses: query.operationStatuses,
+      activationStatuses: query.activationStatuses
+    }
+  }, scope);
+  const body = await response.raw.json();
+  const values = (body.values ?? []).map((row) => DeploymentSearchItemDto2FromJSON(row));
+  return { count: body.count, values };
+}
+
+// src/services/deployment-search.ts
+async function findDeploymentByName(auth, deploymentName, scope) {
+  return newestDeploymentRow(await findDeploymentsByName(auth, deploymentName, scope));
+}
+async function findLiveDeploymentByName(auth, deploymentName, scope) {
+  const newest = await findDeploymentByName(auth, deploymentName, scope);
+  return isCompletedUninstall(newest) ? undefined : newest;
+}
+function isCompletedUninstall(row) {
+  return row?.operation === "Uninstall" && row.operationStatus === "Successful";
+}
+async function findDeploymentsByPackageName(auth, packageName, options = {}) {
+  const take = 50;
+  const maxPages = 20;
+  const matches = [];
+  for (let page = 0, skip = 0;page < maxPages; page++) {
+    const result = await searchDeploymentsPage(auth, { packageName, take, skip }, options.scope);
+    const values = result.values ?? [];
+    for (const deployment of values) {
+      if (deployment.packageName === packageName && (options.folderPath === undefined || deployment.folderPath === options.folderPath)) {
+        matches.push(deployment);
+      }
+    }
+    if (values.length < take) {
+      break;
+    }
+    skip += values.length;
+  }
+  return matches;
+}
+async function findCurrentDeploymentAsync(auth, deployment, scope) {
+  const installKey = deployment.installDeploymentKey ?? deployment.key;
+  const rows = await findDeploymentsByPackageName(auth, deployment.packageName, { scope });
+  return rows.find((row) => (row.installDeploymentKey ?? row.key) === installKey);
+}
+function blocksRedeploy(deployment) {
+  if (deployment.operationStatus === "InProgress") {
+    return true;
+  }
+  if (deployment.operationStatus === "Successful") {
+    return deployment.operation !== "Uninstall";
+  }
+  if (deployment.operationStatus === "Draft" || deployment.operationStatus === "Failed" || deployment.operationStatus === "FailedRollback") {
+    return deployment.operation !== undefined && deployment.operation !== null && deployment.operation !== "Install";
+  }
+  return false;
+}
+var MAX_LISTED_DEPLOYMENTS = 5;
+function formatExistingDeployments(deployments, folderByKey) {
+  const described = deployments.slice(0, MAX_LISTED_DEPLOYMENTS).map((deployment) => {
+    const resolved = deployment.installedRootFolderKey ? folderByKey?.get(deployment.installedRootFolderKey) : undefined;
+    const folder = resolved ?? deployment.folderPath ?? "an unknown folder";
+    const current = deployment.currentPackageVersion ?? deployment.packageVersion ?? "an unknown version";
+    const target = deployment.targetPackageVersion ?? deployment.newPackageVersionAvailable;
+    const version = target && target !== current ? `${current} → ${target}` : current;
+    const state = [
+      deployment.operation,
+      deployment.operationStatus,
+      deployment.activationStatus
+    ].filter((part) => part !== undefined && part !== null).join("/");
+    return `'${deployment.name}' in ${folder} (version ${version}${state ? `, ${state}` : ""})`;
+  }).join("; ");
+  const remaining = deployments.length - MAX_LISTED_DEPLOYMENTS;
+  return remaining > 0 ? `${described}; and ${remaining} more (see: uip solution deploy list)` : described;
+}
+async function findDeploymentsByName(auth, deploymentName, scope) {
+  const matches = [];
+  const take = 50;
+  for (let skip = 0;; ) {
+    const result = await searchDeploymentsPage(auth, { deploymentName, take, skip }, scope);
+    const values = result.values ?? [];
+    matches.push(...values.filter((deployment) => deployment.name === deploymentName));
+    skip += values.length;
+    const total = result.count;
+    if (values.length < take || typeof total === "number" && skip >= total || skip >= MAX_SEARCH_ROWS) {
+      return matches;
+    }
+  }
+}
+var MAX_SEARCH_ROWS = 5000;
+async function findDeploymentBestEffort(auth, deploymentName, scope, prefer = {}) {
+  const [lookupError, rows] = await catchError(findDeploymentsByName(auth, deploymentName, scope));
+  if (lookupError || !rows) {
+    return;
+  }
+  if (prefer.deploymentKey) {
+    return rows.find((row) => row.key === prefer.deploymentKey && row.operation !== "Uninstall");
+  }
+  const candidates = rows.filter((row) => row.operation !== "Uninstall");
+  return candidates.sort((a, b) => creationMillis(b) - creationMillis(a))[0];
+}
+function newestDeploymentRow(rows) {
+  return [...rows].sort((a, b) => creationMillis(b) - creationMillis(a))[0];
+}
+function creationMillis(row) {
+  const millis = row.deploymentCreationTime ? new Date(row.deploymentCreationTime).getTime() : Number.NaN;
+  return Number.isFinite(millis) ? millis : 0;
+}
+async function isPipelineDeploymentNotFoundError(error) {
+  if (!error || typeof error !== "object") {
+    return false;
+  }
+  const response = error.response;
+  if (!response || typeof response !== "object") {
+    return false;
+  }
+  const status = response.status;
+  if (status !== 404) {
+    return false;
+  }
+  const [bodyError, body] = await catchError(response.clone().text());
+  if (bodyError || !body) {
+    return false;
+  }
+  return body.includes("PipelineDeploymentNotFound");
+}
+function interpretFailedDeployPoll(deployment) {
+  if (!deployment) {
+    return;
+  }
+  if (deployment.operationStatus === "Failed" || deployment.operationStatus === "FailedRollback") {
+    return {
+      kind: "DeployFailed",
+      operationStatus: deployment.operationStatus
+    };
+  }
+  if (deployment.operationStatus !== "Successful") {
+    return;
+  }
+  switch (deployment.activationStatus) {
+    case "Active":
+      return { kind: "Active", instanceId: deployment.instanceId };
+    case "NeedsSetupToActivate":
+      return { kind: "NeedsSetupToActivate" };
+    case "ReadyToActivate":
+    case "Inactive":
+      return { kind: "ReadyToActivate" };
+    case "ActivationFailed":
+      return { kind: "ActivationFailed" };
+    default:
+      return;
+  }
+}
+function mapOperationStatusToPipelineStatus(operationStatus) {
+  switch (operationStatus) {
+    case "Successful":
+      return "DeploymentSucceeded";
+    case "Failed":
+    case "FailedRollback":
+    case "Draft":
+      return "DeploymentFailed";
+    default:
+      return;
+  }
+}
+function deploymentToTerminalPipelineResult(deployment) {
+  const status = mapOperationStatusToPipelineStatus(deployment.operationStatus);
+  if (!status) {
+    return;
+  }
+  return {
+    status,
+    validationResult: { validationErrors: [], conflictErrors: [] },
+    deploymentKey: deployment.key,
+    configurationKey: deployment.configurationKey,
+    instanceId: deployment.instanceId,
+    conflictFixingErrors: [],
+    deploymentScheduleErrors: []
+  };
+}
+async function resolveInstalledFolder(deployment, requested, resolveFolderByKey) {
+  const fallback = {
+    folderName: requested.folderName,
+    folderPath: requested.folderPath,
+    requestedMatched: true
+  };
+  const pathFor = (name, path) => path ?? (requested.parentFolderPath ? `${requested.parentFolderPath}/${name}` : name);
+  const folderKey = deployment?.installedRootFolderKey;
+  if (folderKey && resolveFolderByKey) {
+    const [lookupError, folder] = await catchError(resolveFolderByKey(folderKey));
+    if (!lookupError && folder?.name) {
+      return {
+        folderName: folder.name,
+        folderPath: pathFor(folder.name, folder.path ?? deployment?.folderPath ?? undefined),
+        requestedMatched: folder.name === requested.folderName
+      };
+    }
+  }
+  const resolvedName = deployment?.installedRootFolderName;
+  if (resolvedName) {
+    return {
+      folderName: resolvedName,
+      folderPath: pathFor(resolvedName, deployment?.folderPath ?? undefined),
+      requestedMatched: resolvedName === requested.folderName
+    };
+  }
+  return fallback;
+}
+
+export { httpStatusOf, isAuthRefusal, DeploymentSearchNeedsUserSessionError, searchDeploymentsPage, findDeploymentByName, findLiveDeploymentByName, isCompletedUninstall, findDeploymentsByPackageName, findCurrentDeploymentAsync, blocksRedeploy, MAX_LISTED_DEPLOYMENTS, formatExistingDeployments, findDeploymentsByName, findDeploymentBestEffort, newestDeploymentRow, isPipelineDeploymentNotFoundError, interpretFailedDeployPoll, mapOperationStatusToPipelineStatus, deploymentToTerminalPipelineResult, resolveInstalledFolder };
+
+//# debugId=982982E1F13E2BA464756E2164756E21

package/dist/{packager-tool-k4mskzww.js → packager-tool-5dzjsw5q.js}

@@ -1,15 +1,15 @@
 import {
   registerPackagerFactories
-} from "./packager-tool-jz2wbfjz.js";
+} from "./packager-tool-zns6n8zp.js";
 import {
   toolsFactoryRepository
-} from "./packager-tool-nzghfa48.js";
+} from "./packager-tool-fv7xyzg2.js";
 import {
   catchError,
   ensurePackagerFactory,
   logger,
   unsupportedSolutionProjectType
-} from "./packager-tool-0f0wt9vh.js";
+} from "./packager-tool-5fjp60dk.js";
 
 // src/services/project-type-tools.ts
 var PROJECT_TYPE_TO_TOOL = new Map([