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

package/dist/{packager-tool-4ytxbjez.js → packager-tool-kds8ytzw.js}

@@ -1,20 +1,37 @@
+import {
+  resolveFeedSelectionAsync
+} from "./packager-tool-zq16e1xv.js";
 import {
   INCOMPLETE_SWEEP_ADVICE,
   findDeploymentAcrossFeeds,
   reportIncompleteSweepAsync
-} from "./packager-tool-erp9bv22.js";
+} from "./packager-tool-rc3hwn4b.js";
+import {
+  hasServerErrorCode,
+  isBareResponse
+} from "./packager-tool-act5r386.js";
+import {
+  feedSelectorFlag
+} from "./packager-tool-rvt68c1t.js";
 import {
   Configuration,
+  PipelinesApi
+} from "./packager-tool-97rcgwvv.js";
+import {
+  Configuration as Configuration2,
   DeploymentsApi,
   WorkflowAction
-} from "./packager-tool-9z1yxjme.js";
+} from "./packager-tool-9t26kde1.js";
+import {
+  classifyFeedSession
+} from "./packager-tool-qw47eyw7.js";
 import {
   getSolutionAuthContext
-} from "./packager-tool-f5gq77m5.js";
+} from "./packager-tool-61pwb567.js";
 import {
   catchError,
   extractErrorDetails
-} from "./packager-tool-kswwd3hp.js";
+} from "./packager-tool-6ybywxxn.js";
 
 // src/services/deploy-delete-service.ts
 var fail = (reason, message, instructions, extras = {}) => ({
@@ -27,18 +44,18 @@ var fail = (reason, message, instructions, extras = {}) => ({
   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) {
+function buildUnavailableInstructions(deployment, 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}. Wait for it to finish — run 'uip solution deploy list' to recheck — then retry. Available actions: ${availableActions}.`;
+    return `Deployment '${deployment.name}' has an operation in progress ${status}. Wait for it to finish — run 'uip solution deploy list${feedSelector}' 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}' offers Uninstall but not Delete ${status}. Run: uip solution deploy uninstall '${deployment.name}'${feedSelector} --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.`;
+  return `Deployment '${deployment.name}' cannot be deleted in its current state ${status}. Available actions: ${availableActions}. Run 'uip solution deploy list${feedSelector}' to recheck its state.`;
 }
-function requestErrorInstructions(deploymentName, errorCode, details) {
+function requestErrorInstructions(deploymentName, errorCode, details, feedSelector) {
   switch (errorCode) {
     case "authentication_required":
       return `Your session may have expired. Run 'uip login' and retry. Details: ${details}`;
@@ -51,11 +68,36 @@ function requestErrorInstructions(deploymentName, errorCode, 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}`;
+      return `Deployment '${deploymentName}' was found by name but the delete reported it missing — it may have been removed already. Run 'uip solution deploy list${feedSelector}' to confirm. Details: ${details}`;
     default:
-      return `Delete request failed. Run 'uip solution deploy list' to check the deployment's state, then retry. Details: ${details}`;
+      return `Delete request failed. Run 'uip solution deploy list${feedSelector}' to check the deployment's state, then retry. Details: ${details}`;
   }
 }
+async function sendDeleteAsync(auth, deploymentKey, scope) {
+  const pipelinesApi = new PipelinesApi(new Configuration({
+    basePath: auth.basePath,
+    accessToken: auth.accessToken
+  }));
+  const [pipelinesError] = await catchError(pipelinesApi.pipelinesDeleteDeploymentByKey({ deploymentKey }, scope));
+  if (!pipelinesError) {
+    return;
+  }
+  const detail = await extractErrorDetails(pipelinesError);
+  const status = detail.context?.httpStatus;
+  const missingRoute = status === 405 || status === 404 && isBareResponse(detail.details);
+  if (!missingRoute) {
+    return detail;
+  }
+  if (classifyFeedSession(auth) === "application") {
+    return "missing_route_for_application";
+  }
+  const deploymentsApi = new DeploymentsApi(new Configuration2({
+    basePath: auth.basePath,
+    accessToken: auth.accessToken
+  }));
+  const [solutionsError] = await catchError(deploymentsApi.deploymentsDelete({ deploymentKey }, scope));
+  return solutionsError ? extractErrorDetails(solutionsError) : undefined;
+}
 async function deleteDeploymentAsync(deploymentName, options = {}) {
   const [authError, auth] = await catchError(getSolutionAuthContext({
     tenant: options.tenant,
@@ -68,10 +110,19 @@ async function deleteDeploymentAsync(deploymentName, options = {}) {
       retry: "RetryWillNotFix"
     });
   }
+  const selection = await resolveFeedSelectionAsync(auth, options, "Deleting 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,
     includeUninstalled: true
   });
   const { location } = sweep;
@@ -81,25 +132,25 @@ async function deleteDeploymentAsync(deploymentName, options = {}) {
     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" });
+    return fail("deployment_not_found", `No deployment named '${deploymentName}' was found.`, selectedFeed ? `Run 'uip solution deploy list${feedSelectorFlag(selectedFeed)}' to see the deployment names in the selected feed, or drop the feed flag to search every feed you can reach.` : "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), {
+    return fail("delete_unavailable", `Deployment '${deploymentName}' cannot be deleted in its current state.`, buildUnavailableInstructions(deployment, feedSelectorFlag(location.feed)), {
       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 });
+  const detail = await sendDeleteAsync(auth, deployment.key, scope);
+  if (detail === "missing_route_for_application") {
+    return fail("delete_request_failed", `This server cannot delete deployment '${deploymentName}' for an external application.`, "The server has no Pipelines delete route yet, and the deprecated route it replaces accepts user sessions only. Nothing was deleted. Run the delete with a user session ('uip login'), or remove the record in the Orchestrator Solutions UI.", { errorCode: "permission_denied", retry: "RetryWillNotFix" });
+  }
+  if (detail) {
+    if (hasServerErrorCode(detail.details, "DeploymentAlreadyInProgress")) {
+      return fail("delete_request_failed", detail.message, `Deployment '${deploymentName}' is still being validated. Wait for its run to finish (run 'uip solution deploy list${feedSelectorFlag(location.feed)}' to recheck), then retry. Details: ${detail.details}`, { errorCode: "invalid_argument", retry: "RetryLater" });
+    }
+    return fail("delete_request_failed", detail.message, requestErrorInstructions(deploymentName, detail.errorCode, detail.details, feedSelectorFlag(location.feed)), { errorCode: detail.errorCode, retry: detail.retry });
   }
   return {
     ok: true,
@@ -110,4 +161,4 @@ async function deleteDeploymentAsync(deploymentName, options = {}) {
 
 export { deleteDeploymentAsync };
 
-//# debugId=D4EB3B798936BE2864756E2164756E21
+//# debugId=6645C240B208006964756E2164756E21

package/dist/packager-tool-kkfb5kgn.js

@@ -0,0 +1,182 @@
+// ../executor/project-executor/src/models/run-status.ts
+var TERMINAL_RUN_STATUSES = [
+  "Succeeded" /* Succeeded */,
+  "Faulted" /* Faulted */,
+  "Cancelled" /* Cancelled */
+];
+function isTerminalRunStatus(status) {
+  return TERMINAL_RUN_STATUSES.includes(status);
+}
+
+// ../executor/project-executor/src/models/run-result.ts
+class RunResult {
+  status;
+  errorCode;
+  rawStatus;
+  message;
+  jobKey;
+  instanceId;
+  runId;
+  traceId;
+  steps;
+  output;
+  url;
+  details;
+  constructor(status, errorCode = "None" /* None */, message) {
+    this.status = status;
+    this.errorCode = errorCode;
+    this.message = message;
+  }
+  get isSuccess() {
+    return this.status === "Succeeded" /* Succeeded */ && this.errorCode === "None" /* None */;
+  }
+  get isTerminal() {
+    return isTerminalRunStatus(this.status);
+  }
+  static succeeded(init = {}) {
+    return Object.assign(new RunResult("Succeeded" /* Succeeded */, "None" /* None */), init);
+  }
+  static failed(errorCode, message, init = {}) {
+    return Object.assign(new RunResult("Faulted" /* Faulted */, errorCode, message), init);
+  }
+}
+
+// ../executor/project-executor/src/services/executor-logger.ts
+var noopExecutorLogger = {
+  info: () => {},
+  warn: () => {},
+  error: () => {}
+};
+
+// ../executor/project-executor/src/services/executors-factory-repository.ts
+class ExecutorsFactoryRepository {
+  factoryMap = new Map;
+  onConflict;
+  constructor(onConflict) {
+    this.onConflict = onConflict ?? ((message) => console.warn(message));
+  }
+  registerProjectExecutorFactory(factory) {
+    for (const projectType of factory.supportedTypes) {
+      const existing = this.factoryMap.get(projectType);
+      if (existing) {
+        if (existing.constructor?.name !== factory.constructor?.name) {
+          this.onConflict(`Executor factory conflict for project type '${projectType}': ` + `'${existing.constructor?.name}' already registered, ` + `ignoring '${factory.constructor?.name}'.`);
+        }
+        continue;
+      }
+      this.factoryMap.set(projectType, factory);
+    }
+  }
+  canHandleProject(projectType) {
+    return this.factoryMap.has(projectType);
+  }
+  getProjectExecutorFactory(projectType) {
+    const factory = this.factoryMap.get(projectType);
+    if (!factory) {
+      throw new Error(`Cannot run project type '${projectType}': no runner is installed for it. ` + `Project types that can be run: ${this.registeredTypes.join(", ") || "none"}.`);
+    }
+    return factory;
+  }
+  get registeredTypes() {
+    return [...this.factoryMap.keys()];
+  }
+  reset() {
+    this.factoryMap.clear();
+  }
+}
+var REGISTRY_KEY = Symbol.for("@uipath/project-executor/executorsFactoryRepository");
+var _global = globalThis;
+if (!_global[REGISTRY_KEY]) {
+  _global[REGISTRY_KEY] = new ExecutorsFactoryRepository;
+}
+var executorsFactoryRepository = _global[REGISTRY_KEY];
+
+// ../executor/project-executor/src/services/project-runner.ts
+class ProjectRunner {
+  fileSystem;
+  logger;
+  registry;
+  constructor(deps) {
+    this.fileSystem = deps.fileSystem;
+    this.logger = deps.logger ?? noopExecutorLogger;
+    this.registry = deps.registry ?? executorsFactoryRepository;
+  }
+  canRun(projectType) {
+    return this.registry.canHandleProject(projectType);
+  }
+  get runnableTypes() {
+    return this.registry.registeredTypes;
+  }
+  async runAsync(options, cancellationToken) {
+    const { projectType, name } = options.project;
+    if (!this.canRun(projectType)) {
+      const known = this.runnableTypes.join(", ") || "none";
+      return RunResult.failed("UnsupportedProjectType" /* UnsupportedProjectType */, `Cannot run project '${name}' (project type '${projectType}'): ` + `no runner is installed for it. Project types that can be run: ${known}.`);
+    }
+    let executor;
+    try {
+      const factory = this.registry.getProjectExecutorFactory(projectType);
+      executor = await factory.createAsync(this.logger, this.fileSystem);
+      this.logger.info(`Running ${name} (${projectType}) on ${options.target}.`);
+      return await executor.runAsync(options, cancellationToken);
+    } catch (error) {
+      return RunResult.failed("Unknown" /* Unknown */, messageOf(error));
+    } finally {
+      try {
+        await executor?.dispose();
+      } catch (error) {
+        this.logger.warn(`Failed to dispose the ${projectType} executor: ${messageOf(error)}`);
+      }
+    }
+  }
+}
+function messageOf(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+// ../executor/project-executor/src/services/executor-tool-import.ts
+async function importExecutorToolModule(specifier) {
+  try {
+    return { module: await import(specifier) };
+  } catch (error) {
+    return {
+      error: error instanceof Error ? error : new Error(String(error))
+    };
+  }
+}
+
+// ../executor/project-executor/src/services/executor-tool-module.ts
+var EXECUTOR_FACTORY_EXPORT = "createExecutorFactory";
+function isExecutorFactoryModule(module) {
+  return typeof module === "object" && module !== null && typeof module[EXECUTOR_FACTORY_EXPORT] === "function";
+}
+
+// ../executor/project-executor/src/services/executor-factory-provider.ts
+var PROVIDER_KEY = Symbol.for("@uipath/project-executor/executorFactoryProvider");
+var _global2 = globalThis;
+function registerExecutorFactoryFromModule(module, source) {
+  if (!isExecutorFactoryModule(module)) {
+    throw new Error(`${source} does not export ${EXECUTOR_FACTORY_EXPORT}().`);
+  }
+  const factory = module.createExecutorFactory();
+  executorsFactoryRepository.registerProjectExecutorFactory(factory);
+  return factory;
+}
+async function ensureExecutorFactory(verb, packageName) {
+  const provider = _global2[PROVIDER_KEY];
+  if (provider) {
+    await provider(verb);
+    return;
+  }
+  if (!packageName) {
+    throw new Error(`Running this project type needs the executor factory for '${verb}', and no package provides it.`);
+  }
+  const specifier = `${packageName}/executor-tool`;
+  const { module, error } = await importExecutorToolModule(specifier);
+  if (error) {
+    throw new Error(`Running this project type needs '${packageName}'. Install it.`, { cause: error });
+  }
+  registerExecutorFactoryFromModule(module, specifier);
+}
+export { RunResult, executorsFactoryRepository, ensureExecutorFactory, ProjectRunner };
+
+//# debugId=C724855DC65EEE6264756E2164756E21