@uipath/solution-tool 1.204.0 → 1.205.0-preview.258

package/dist/packager-tool-09fwj7e8.js

@@ -0,0 +1,171 @@
+import {
+  PackService
+} from "./packager-tool-85pen8t9.js";
+import {
+  Path
+} from "./packager-tool-pbmqk39a.js";
+// ../packager/solution-packager/src/services/package-id-reader.ts
+var legacySolutionResourcesFileName = "resources.json";
+
+class PackageIdReader {
+  fileSystem;
+  packService;
+  projectTypesToFolderNameMapping = {
+    processorchestration: "processOrchestration",
+    casemanagement: "caseManagement",
+    agent: "agent",
+    api: "api",
+    webapp: "webApp",
+    process: "process",
+    flow: "flow"
+  };
+  static projectTypeMap = {
+    process: "Rpa",
+    library: "Lib",
+    tests: "Tests",
+    webapp: "App",
+    processorchestration: "Agentic",
+    casemanagement: "Case",
+    api: "Api",
+    agent: "Agent",
+    flow: "Flow"
+  };
+  constructor(fileSystem, packService) {
+    this.fileSystem = fileSystem;
+    this.packService = packService;
+  }
+  async read(project, solutionPath, solutionName) {
+    try {
+      if (!solutionPath || solutionPath.trim() === "") {
+        return this.defaultToProjectFolder(project, solutionPath, solutionName);
+      }
+      return await this.readFromResourcesDirectory(project, solutionPath) || await this.readFromLegacyResourcesJson(project, solutionPath) || this.defaultToProjectFolder(project, solutionPath, solutionName);
+    } catch (ex) {
+      console.error("Error reading package ID:", ex);
+      return this.defaultToProjectFolder(project, solutionPath, solutionName);
+    }
+  }
+  defaultToProjectFolder(project, solutionPath, solutionName) {
+    const projectFolderName = Path.dirname(project.ProjectRelativePath);
+    const id = this.packService.sanitizePackageId(projectFolderName);
+    return this.getPackageId(id, project, solutionPath, solutionName);
+  }
+  getPackageId(rootPackageId, project, solutionPath, solutionName) {
+    const packageId = this.composePackageId(rootPackageId, project, solutionPath, solutionName);
+    return this.packService.sanitizePackageId(packageId);
+  }
+  composePackageId(rootPackageId, project, solutionPath, solutionName) {
+    if (!solutionName && (!solutionPath || solutionPath.trim() === "")) {
+      return rootPackageId;
+    }
+    const resolvedSolutionName = solutionName || this.deriveSolutionName(solutionPath);
+    const parts = [resolvedSolutionName];
+    if (project.Type) {
+      parts.push(PackageIdReader.normalizeProjectType(project.Type));
+    }
+    parts.push(rootPackageId);
+    return parts.join(".");
+  }
+  static normalizeProjectType(projectType) {
+    const normalizedKey = projectType.toLowerCase();
+    return PackageIdReader.projectTypeMap[normalizedKey] || projectType;
+  }
+  deriveSolutionName(solutionPath) {
+    const ext = Path.extname(solutionPath);
+    const base = Path.basename(solutionPath);
+    return ext ? base.substring(0, base.length - ext.length) : base;
+  }
+  async readFromLegacyResourcesJson(project, solutionPath) {
+    const resourcesFilePath = Path.join(solutionPath, legacySolutionResourcesFileName);
+    const exists = await this.fileSystem.exists(resourcesFilePath);
+    if (!exists) {
+      return null;
+    }
+    const data = await this.fileSystem.readFile(resourcesFilePath);
+    if (!data) {
+      return null;
+    }
+    const json = new TextDecoder().decode(data);
+    return this.getProjectIdFromJson(project, json);
+  }
+  getProjectIdFromJson(project, json) {
+    try {
+      const jsonObject = JSON.parse(json);
+      const resources = this.getProperty(jsonObject, "resources");
+      if (!Array.isArray(resources)) {
+        return null;
+      }
+      const resource = resources.find((r) => {
+        const projectKey = this.getProperty(r, "projectKey");
+        const kind = this.getProperty(r, "kind");
+        return projectKey === project.Id && typeof kind === "string" && kind.toLowerCase() === "process";
+      });
+      if (!resource) {
+        return null;
+      }
+      const spec = this.getProperty(resource, "spec");
+      if (!spec) {
+        return null;
+      }
+      const packageName = this.getProperty(spec, "packageName");
+      if (!packageName || typeof packageName !== "string" || packageName.trim() === "") {
+        return null;
+      }
+      return packageName;
+    } catch (ex) {
+      console.error("Error parsing legacy resources JSON:", ex);
+      return null;
+    }
+  }
+  async readFromResourcesDirectory(project, solutionPath) {
+    const projectTypeLower = project.Type.toLowerCase();
+    const projectTypeFolder = this.projectTypesToFolderNameMapping[projectTypeLower] || Path.dirname(project.ProjectRelativePath);
+    const processDirectory = Path.join(solutionPath, "resources", "solution_folder", "process", projectTypeFolder);
+    const stats = await this.fileSystem.stat(processDirectory);
+    if (!stats?.isDirectory()) {
+      return null;
+    }
+    const files = await this.fileSystem.readdir(processDirectory);
+    const jsonFiles = files.filter((f) => f.endsWith(".json")).map((f) => Path.join(processDirectory, f));
+    for (const jsonFile of jsonFiles) {
+      try {
+        const data = await this.fileSystem.readFile(jsonFile);
+        if (!data) {
+          continue;
+        }
+        const json = new TextDecoder().decode(data);
+        const jsonObject = JSON.parse(json);
+        const resource = this.getProperty(jsonObject, "resource");
+        const projectKey = this.getProperty(resource, "projectKey");
+        if (projectKey === project.Id) {
+          const spec = this.getProperty(resource, "spec");
+          const packageName = this.getProperty(spec, "packageName");
+          if (typeof packageName !== "string" || packageName.trim() === "") {
+            return null;
+          }
+          return packageName;
+        }
+      } catch (ex) {
+        console.error("Error reading resource file:", jsonFile, ex);
+      }
+    }
+    return null;
+  }
+  getProperty(obj, propertyName) {
+    if (!obj || typeof obj !== "object") {
+      return null;
+    }
+    const keys = Object.keys(obj);
+    const matchingKey = keys.find((key) => key.toLowerCase() === propertyName.toLowerCase());
+    return matchingKey ? obj[matchingKey] : null;
+  }
+}
+async function readMemberPackageIdAsync(fileSystem, project, solutionPath, solutionName) {
+  const packService = new PackService;
+  const packageId = await new PackageIdReader(fileSystem, packService).read(project, solutionPath, solutionName);
+  return packageId ? packService.sanitizePackageId(packageId) : packageId;
+}
+
+export { PackageIdReader, readMemberPackageIdAsync };
+
+//# debugId=95D09CBD9B00686D64756E2164756E21

package/dist/{packager-tool-nfmygm61.js → packager-tool-361zx07h.js}

@@ -1,20 +1,37 @@
+import {
+  resolveFeedSelectionAsync
+} from "./packager-tool-y2k2f6yg.js";
 import {
   INCOMPLETE_SWEEP_ADVICE,
   findDeploymentAcrossFeeds,
   reportIncompleteSweepAsync
-} from "./packager-tool-gfhdpkp3.js";
+} from "./packager-tool-4bq36bf5.js";
+import {
+  hasServerErrorCode,
+  isBareResponse
+} from "./packager-tool-act5r386.js";
+import {
+  feedSelectorFlag
+} from "./packager-tool-6x35kvbx.js";
 import {
   Configuration,
+  PipelinesApi
+} from "./packager-tool-97rcgwvv.js";
+import {
+  Configuration as Configuration2,
   DeploymentsApi,
   WorkflowAction
-} from "./packager-tool-j3520gxw.js";
+} from "./packager-tool-an5bpbwe.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-37jmavap.js

@@ -0,0 +1,42 @@
+import {
+  PackCommandService
+} from "./packager-tool-4jekgh4s.js";
+import {
+  isUnpackableProjectTypeError
+} from "./packager-tool-b2nhscfk.js";
+import {
+  carriedErrorCode
+} from "./packager-tool-tx834spe.js";
+import {
+  carriedInstructions,
+  catchError
+} from "./packager-tool-6ybywxxn.js";
+
+// src/services/pack-service.ts
+async function packSolutionAsync(solutionPath, options) {
+  const service = new PackCommandService;
+  const [error, result] = await catchError(service.executeAsync(solutionPath, options));
+  if (error) {
+    if (!isUnpackableProjectTypeError(error) && carriedErrorCode(error) === undefined) {
+      throw error;
+    }
+    const message = error instanceof Error ? error.message : String(error);
+    const instructions = carriedInstructions(error);
+    return {
+      ok: false,
+      errorCode: "INTERNAL_ERROR" /* InternalError */,
+      message: instructions ? `${message} ${instructions}` : message,
+      packages: []
+    };
+  }
+  return {
+    ok: result.errorCode === "SUCCESS" /* Success */,
+    errorCode: result.errorCode,
+    message: result.message ?? "",
+    packages: result.packages
+  };
+}
+
+export { packSolutionAsync };
+
+//# debugId=79D5D443E78F177864756E2164756E21

package/dist/{packager-tool-px1j9kre.js → packager-tool-3bwnkjdq.js}

@@ -1,9 +1,9 @@
 import {
   catchError
-} from "./packager-tool-kswwd3hp.js";
+} from "./packager-tool-6ybywxxn.js";
 import {
   getFileSystem
-} from "./packager-tool-zf3929se.js";
+} from "./packager-tool-v1f5e8t9.js";
 
 // src/services/solution-init-service.ts
 var AGENTS_FILENAME = "AGENTS.md";