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

package/dist/packager-tool-ks8spnq8.js

@@ -0,0 +1,166 @@
+import {
+  SolutionDeploymentAction
+} from "./packager-tool-00vh1ktg.js";
+import {
+  catchError
+} from "./packager-tool-5fjp60dk.js";
+
+// src/services/deployment-state.ts
+function quoteForShell(name) {
+  return `'${name.replace(/'/g, "'\\''")}'`;
+}
+var RESOURCES_PAGE_SIZE = 50;
+var RESOURCES_MAX_PAGES = 10;
+async function readPendingResourcesAsync(api, deploymentKey, scope) {
+  const pending = [];
+  let complete = false;
+  for (let page = 0, skip = 0;page < RESOURCES_MAX_PAGES; page++) {
+    const [readError, result] = await catchError(api.deploymentsGetDeploymentResources({ deploymentKey, skip, take: RESOURCES_PAGE_SIZE }, scope));
+    if (readError || !result) {
+      return;
+    }
+    const values = result.values ?? [];
+    for (const resource of values) {
+      if (resource.requiresConfiguration) {
+        pending.push(toPendingResource(resource));
+      }
+    }
+    skip += values.length;
+    if (values.length < RESOURCES_PAGE_SIZE || typeof result.count === "number" && skip >= result.count) {
+      complete = true;
+      break;
+    }
+  }
+  if (!complete) {
+    return;
+  }
+  if (pending.length > 0) {
+    await attachActivationReasonsAsync(api, deploymentKey, pending, scope);
+  }
+  return pending;
+}
+function toPendingResource(resource) {
+  return {
+    key: resource.key,
+    name: resource.name,
+    kind: resource.kind,
+    type: resource.type
+  };
+}
+async function attachActivationReasonsAsync(api, deploymentKey, pending, scope) {
+  const [readError, validation] = await catchError(() => api.deploymentsGetValidationResult({
+    deploymentKey,
+    deploymentAction: SolutionDeploymentAction.Activate
+  }, scope));
+  if (readError || !validation) {
+    return;
+  }
+  const reasons = new Map;
+  for (const resource of validation.resourceValidationErrors ?? []) {
+    const texts = (resource.errors ?? []).map((error) => error.errorCode ? `[${error.errorCode}] ${error.text}` : error.text).filter(Boolean);
+    if (texts.length > 0) {
+      reasons.set(resourceIdentity(resource.name, resource.type), texts.join("; "));
+    }
+  }
+  for (const resource of pending) {
+    const reason = reasons.get(resourceIdentity(resource.name, resource.type));
+    if (reason) {
+      resource.reason = reason;
+    }
+  }
+}
+function resourceIdentity(name, type) {
+  return `${name}\x00${type ?? ""}`;
+}
+var MAX_LISTED_RESOURCES = 10;
+function formatPendingResources(resources) {
+  const described = resources.slice(0, MAX_LISTED_RESOURCES).map((resource) => {
+    const type = resource.type && resource.type !== resource.kind ? ` (${resource.type})` : "";
+    const reason = resource.reason ? `: ${resource.reason}` : "";
+    return `${resource.kind} '${resource.name}'${type}${reason}`;
+  }).join("; ");
+  const remaining = resources.length - MAX_LISTED_RESOURCES;
+  return remaining > 0 ? `${described}; and ${remaining} more` : described;
+}
+function activationNextSteps(deployment, pendingResources) {
+  const name = deployment.name;
+  const version = deployment.currentPackageVersion ?? deployment.packageVersion;
+  const installed = `Deployment '${name}' is installed${version ? ` at version ${version}` : ""}`;
+  switch (deployment.activationStatus) {
+    case "NeedsSetupToActivate": {
+      const steps = [
+        `${installed} but not live: it needs 'Setup activation' before it can be activated.`,
+        describePendingResources(pendingResources)
+      ];
+      steps.push(`Complete 'Setup activation' for '${name}' in Orchestrator (Tenant > Solutions > Deployments, open the deployment). The CLI has no command for this step on an existing deployment: 'uip solution deploy config link' applies only to a new 'deploy run', an upgrade takes no config file, and 'uip solution deploy activate' is refused until the setup is done.`);
+      return steps;
+    }
+    case "ReadyToActivate":
+    case "Inactive":
+      return [
+        `${installed} but inactive. Activate it with: uip solution deploy activate ${quoteForShell(name)}.`
+      ];
+    case "ActivationFailed":
+      return [
+        `Activation of '${name}' failed. Inspect the deployment in Orchestrator, then retry with: uip solution deploy activate ${quoteForShell(name)}.`
+      ];
+    default:
+      return;
+  }
+}
+function appendDeploymentStateInstructions(instructions, deployment, pendingResources, feedSelector = "") {
+  const steps = deployment ? explainRefusal(deployment, pendingResources, feedSelector) : undefined;
+  return steps ? `${instructions}
+${steps.join(`
+`)}` : instructions;
+}
+function explainRefusal(deployment, pendingResources, feedSelector = "") {
+  const explains = deployment.operationStatus === "Draft" || deployment.operationStatus === "Successful" && deployment.activationStatus === "NeedsSetupToActivate";
+  if (!explains) {
+    return;
+  }
+  const steps = deploymentNextSteps(deployment, pendingResources, feedSelector);
+  return steps && steps.length > 0 ? steps : undefined;
+}
+function needsPendingResources(deployment) {
+  return deployment.activationStatus === "NeedsSetupToActivate" || deployment.operationStatus === "Draft" && deployment.operation === "ActivationSetup";
+}
+function deploymentNextSteps(deployment, pendingResources, feedSelector = "") {
+  if (deployment.operationStatus === "Draft") {
+    const steps = [describeDraft(deployment, feedSelector)];
+    if (deployment.operation === "ActivationSetup") {
+      steps.push(describePendingResources(pendingResources));
+    }
+    return steps;
+  }
+  return activationNextSteps(deployment, pendingResources);
+}
+function describePendingResources(pendingResources) {
+  if (pendingResources === undefined) {
+    return "The CLI could not read which resources need configuration; the deployment's Resources tab in Orchestrator lists them.";
+  }
+  if (pendingResources.length === 0) {
+    return "The service lists no resource as needing configuration; the deployment's Resources tab in Orchestrator shows what it asks for.";
+  }
+  return `Resources that need configuration: ${formatPendingResources(pendingResources)}.`;
+}
+function describeDraft(deployment, feedSelector) {
+  const name = deployment.name;
+  const state = `(Operation: ${deployment.operation}, OperationStatus: Draft, ActivationStatus: ${deployment.activationStatus})`;
+  switch (deployment.operation) {
+    case "ActivationSetup":
+      return `Deployment '${name}' has a 'Setup activation' that was started but not completed ${state} and cannot be activated until it is. Finish it in Orchestrator (Tenant > Solutions > Deployments, open the deployment; the UI lists it as 'Activation setup / Draft'). The CLI has no command for this step on an existing deployment. To discard the unfinished setup instead, run: uip solution deploy delete ${quoteForShell(name)} --yes. That removes the draft alone; the deployment returns to its previous record, still waiting for setup.`;
+    case "VersionChange":
+      return `Deployment '${name}' has an upgrade that was queued but never installed ${state} and cannot be activated until it settles. 'uip solution deploy upgrade' installs the draft it queues; a draft left by another client stays until it is installed or removed; check it with: uip solution deploy list${feedSelector}.`;
+    case "Install":
+    case undefined:
+    case null:
+      return `Deployment '${name}' exists but is still in Draft state (OperationStatus: ${deployment.operationStatus}, ActivationStatus: ${deployment.activationStatus}). Draft deployments are created by deploy runs that did not complete successfully and cannot be activated. Fix the deploy run validation errors, rerun 'uip solution deploy run', then activate after 'uip solution deploy list${feedSelector}' shows the deployment is no longer Draft.`;
+    default:
+      return `Deployment '${name}' has a pending ${deployment.operation} ${state} and cannot be activated until it settles. Check it with: uip solution deploy list${feedSelector}.`;
+  }
+}
+
+export { quoteForShell, readPendingResourcesAsync, appendDeploymentStateInstructions, explainRefusal, needsPendingResources, deploymentNextSteps };
+
+//# debugId=ABAB11E889A49E7364756E2164756E21

package/dist/packager-tool-q3tgpemc.js

@@ -0,0 +1,113 @@
+import {
+  INCOMPLETE_SWEEP_ADVICE,
+  findDeploymentAcrossFeeds,
+  reportIncompleteSweepAsync
+} from "./packager-tool-40vcj4wv.js";
+import {
+  Configuration,
+  DeploymentsApi,
+  WorkflowAction
+} from "./packager-tool-00vh1ktg.js";
+import {
+  getSolutionAuthContext
+} from "./packager-tool-f5gq77m5.js";
+import {
+  catchError,
+  extractErrorDetails
+} from "./packager-tool-5fjp60dk.js";
+
+// src/services/deploy-delete-service.ts
+var fail = (reason, message, instructions, extras = {}) => ({
+  ok: false,
+  reason,
+  message,
+  instructions,
+  exitCode: extras.exitCode ?? 1,
+  errorCode: extras.errorCode,
+  retry: extras.retry
+});
+var AUTH_INSTRUCTIONS = "Run 'uip login' to refresh credentials, then retry. If the deployment is in a different tenant, switch with 'uip login tenant set <tenant>'.";
+function buildUnavailableInstructions(deployment) {
+  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}. Wait for it to finish — run 'uip solution deploy list' to recheck — then retry. Available actions: ${availableActions}.`;
+  }
+  if (deployment.actions?.includes(WorkflowAction.Uninstall)) {
+    return `Deployment '${deployment.name}' offers Uninstall but not Delete ${status}. Run: uip solution deploy uninstall '${deployment.name}' --yes, then retry the delete. Available actions: ${availableActions}.`;
+  }
+  return `Deployment '${deployment.name}' cannot be deleted in its current state ${status}. Available actions: ${availableActions}. Run 'uip solution deploy list' to recheck its state.`;
+}
+function requestErrorInstructions(deploymentName, errorCode, details) {
+  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 delete 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 `Deployment '${deploymentName}' was found by name but the delete reported it missing — it may have been removed already. Run 'uip solution deploy list' to confirm. Details: ${details}`;
+    default:
+      return `Delete request failed. Run 'uip solution deploy list' to check the deployment's state, then retry. Details: ${details}`;
+  }
+}
+async function deleteDeploymentAsync(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, {
+      errorCode: "authentication_required",
+      retry: "RetryWillNotFix"
+    });
+  }
+  const sweep = await findDeploymentAcrossFeeds(auth, deploymentName, {
+    tenant: options.tenant,
+    loginValidity: options.loginValidity,
+    envFilePath: options.envFilePath,
+    includeUninstalled: true
+  });
+  const { location } = sweep;
+  if (!location && !sweep.complete) {
+    const report = await reportIncompleteSweepAsync(deploymentName, sweep.skipped);
+    const oneFeed = report.oneFeedFlags.map((flag) => `'uip solution deploy list ${flag}'`).join(" or ");
+    return fail("lookup_failed", report.message, `${INCOMPLETE_SWEEP_ADVICE} ${report.nextStep}${oneFeed ? ` To check one feed yourself, run ${oneFeed}.` : ""} Details: ${report.details}`, { errorCode: report.errorCode, retry: report.retry });
+  }
+  if (!location) {
+    return fail("deployment_not_found", `No deployment named '${deploymentName}' was found.`, "Run 'uip solution deploy list' to see valid deployment names.", { errorCode: "not_found", retry: "RetryWillNotFix" });
+  }
+  const { deployment, scope } = location;
+  if (deployment.actions?.length && !deployment.actions.includes(WorkflowAction.Delete)) {
+    const inProgress = deployment.operationStatus === "InProgress";
+    return fail("delete_unavailable", `Deployment '${deploymentName}' cannot be deleted in its current state.`, buildUnavailableInstructions(deployment), {
+      errorCode: "invalid_argument",
+      retry: inProgress ? "RetryLater" : "RetryWillNotFix"
+    });
+  }
+  const config = new Configuration({
+    basePath: auth.basePath,
+    accessToken: auth.accessToken
+  });
+  const deploymentsApi = new DeploymentsApi(config);
+  const [deleteError] = await catchError(deploymentsApi.deploymentsDelete({ deploymentKey: deployment.key }, scope));
+  if (deleteError) {
+    const detail = await extractErrorDetails(deleteError);
+    return fail("delete_request_failed", detail.message, requestErrorInstructions(deploymentName, detail.errorCode, detail.details), { errorCode: detail.errorCode, retry: detail.retry });
+  }
+  return {
+    ok: true,
+    deploymentName,
+    deploymentKey: deployment.key
+  };
+}
+
+export { deleteDeploymentAsync };
+
+//# debugId=D4EB3B798936BE2864756E2164756E21

package/dist/packager-tool-qdtjywsk.js

@@ -0,0 +1,173 @@
+import {
+  getAvailablePublishLocationsV2
+} from "./packager-tool-00vh1ktg.js";
+import {
+  classifyFeedSession
+} from "./packager-tool-bqre28m1.js";
+import {
+  PersonalWorkspacesApi,
+  createOrchestratorConfig
+} from "./packager-tool-3fv6zc86.js";
+import {
+  extractErrorDetails
+} from "./packager-tool-5fjp60dk.js";
+import {
+  getLoginStatusAsync
+} from "./packager-tool-gb35b4qs.js";
+
+// src/services/personal-workspace-resolver.ts
+async function resolvePersonalWorkspace(options) {
+  const config = await createOrchestratorConfig(options);
+  const api = new PersonalWorkspacesApi(config);
+  const pw = await api.personalWorkspacesGetPersonalWorkspace();
+  if (!pw?.key || !pw.name) {
+    throw new Error("Personal Workspace not configured for the current user. " + "Enable Personal Workspace in Orchestrator (or sign in as a user that has one), then retry.");
+  }
+  return { key: pw.key, name: pw.name };
+}
+
+// src/services/publish-locations-service.ts
+async function resolveStudioWebTarget(options) {
+  const loginStatus = await getLoginStatusAsync({
+    ensureTokenValidityMinutes: options?.loginValidity,
+    envFilePath: options?.envFilePath
+  });
+  if (loginStatus.loginStatus !== "Logged in" || !loginStatus.accessToken || !loginStatus.baseUrl) {
+    throw new Error("Not logged in. Run 'uip login' first.");
+  }
+  if (!loginStatus.organizationName) {
+    throw new Error("Organization name is not available. Re-authenticate with 'uip login'.");
+  }
+  if (options?.tenant && loginStatus.tenantName && options.tenant.toLowerCase() !== loginStatus.tenantName.toLowerCase()) {
+    throw new Error(`Feeds are resolved for the logged-in tenant ('${loginStatus.tenantName}'), so --tenant '${options.tenant}' can't apply here. Switch tenants first with: uip login tenant set ${options.tenant}.`);
+  }
+  return {
+    config: {
+      baseUrl: loginStatus.baseUrl,
+      authToken: loginStatus.accessToken,
+      tenantId: loginStatus.tenantId
+    },
+    organizationName: loginStatus.organizationName
+  };
+}
+function isSelectableFeed(location) {
+  switch (location.type) {
+    case "Tenant":
+    case "Folder":
+      return true;
+    case "PersonalWorkspace":
+      return location.isMyPersonalWorkspace;
+    default:
+      return false;
+  }
+}
+async function listSelectablePublishLocations(options) {
+  const { config, organizationName } = await resolveStudioWebTarget(options);
+  const all = await getAvailablePublishLocationsV2(config, organizationName);
+  return all.filter(isSelectableFeed);
+}
+
+// src/services/feed-resolver.ts
+function folderKeyInitOverride(folderKey) {
+  return async ({ init }) => ({
+    headers: { ...init.headers, "X-UIPATH-FolderKey": folderKey }
+  });
+}
+function feedScopeInitOverride(scope) {
+  const { folderKey } = scope;
+  if (!folderKey) {
+    return;
+  }
+  return folderKeyInitOverride(folderKey);
+}
+function feedSelectorFlag(scope) {
+  if (!scope || scope.kind === "tenant" || !scope.folderKey) {
+    return "";
+  }
+  return scope.kind === "personal" ? " --personal-workspace" : ` --feed ${scope.folderKey}`;
+}
+function feedResolutionFailureInstructions(options) {
+  if (options.personalWorkspace) {
+    return "Personal Workspace resolution needs an interactive user session and an enabled Personal Workspace. Log in as a user with a Personal Workspace, or omit --personal-workspace to use the tenant feed.";
+  }
+  if (options.feed !== undefined) {
+    return "List the feeds you can target with: uip solution feeds list.";
+  }
+  return "Check the selected feed and try again.";
+}
+async function describeFeedResolutionFailureAsync(error, options, session) {
+  const details = await extractErrorDetails(error);
+  if (options.personalWorkspace && isRefusal(details.context?.httpStatus) && classifyFeedSession(session) === "application") {
+    return {
+      message: "--personal-workspace needs a user session; this session is an external app, which has no Personal Workspace.",
+      instructions: "Run it with a user session that has a Personal Workspace ('uip login'). A client-credentials login cannot target one.",
+      errorCode: "permission_denied",
+      retry: "RetryWillNotFix",
+      context: details.context
+    };
+  }
+  return {
+    message: details.message,
+    instructions: feedResolutionFailureInstructions(options),
+    errorCode: details.errorCode,
+    retry: details.retry,
+    context: details.context
+  };
+}
+function isRefusal(status) {
+  return status !== undefined && status >= 400 && status < 500 && status !== 408 && status !== 429;
+}
+async function resolveFeedScope(options) {
+  const { personalWorkspace, feed } = options;
+  if (personalWorkspace && feed !== undefined) {
+    throw new Error("Use either --personal-workspace or --feed, not both.");
+  }
+  if (personalWorkspace) {
+    const pw = await resolvePersonalWorkspace({
+      tenant: options.tenant,
+      loginValidity: options.loginValidity,
+      envFilePath: options.envFilePath
+    });
+    return { kind: "personal", folderKey: pw.key, name: pw.name };
+  }
+  if (feed !== undefined) {
+    return resolveNamedFeed(feed, options);
+  }
+  return { kind: "tenant" };
+}
+async function resolveNamedFeed(feed, options) {
+  const locations = await listSelectablePublishLocations({
+    tenant: options.tenant,
+    envFilePath: options.envFilePath,
+    loginValidity: options.loginValidity
+  });
+  const match = matchFeed(feed, locations);
+  const kind = match.type === "Tenant" ? "tenant" : match.type === "PersonalWorkspace" ? "personal" : "folder";
+  if (kind !== "tenant" && !match.key) {
+    throw new Error(`Feed '${match.name || feed}' has no folder key in the publish-locations response, so it can't be targeted. Run 'uip solution feeds list' and pick a feed with a Key.`);
+  }
+  return {
+    kind,
+    folderKey: kind === "tenant" ? undefined : match.key,
+    name: match.name
+  };
+}
+function matchFeed(feed, locations) {
+  const byKey = locations.find((location) => location.key === feed);
+  if (byKey) {
+    return byKey;
+  }
+  const target = feed.toLowerCase();
+  const byName = locations.filter((location) => location.name.toLowerCase() === target);
+  if (byName.length === 1) {
+    return byName[0];
+  }
+  if (byName.length > 1) {
+    throw new Error(`More than one feed is named '${feed}'. Pass its key instead — ` + "'uip solution feeds list' shows each feed's key.");
+  }
+  throw new Error(`Feed '${feed}' is not an available publish location. ` + "Run 'uip solution feeds list' to see the feeds you can publish to.");
+}
+
+export { resolvePersonalWorkspace, listSelectablePublishLocations, folderKeyInitOverride, feedScopeInitOverride, feedSelectorFlag, feedResolutionFailureInstructions, describeFeedResolutionFailureAsync, resolveFeedScope };
+
+//# debugId=F37E07288EA6F3E164756E2164756E21