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

package/dist/{packager-tool-v8bkkqdb.js → packager-tool-gmwva4yv.js}

@@ -1,9 +1,9 @@
-import {
-  catchError
-} from "./packager-tool-kswwd3hp.js";
 import {
   getAuthContext
-} from "./packager-tool-gb35b4qs.js";
+} from "./packager-tool-43ahv5mn.js";
+import {
+  catchError
+} from "./packager-tool-6ybywxxn.js";
 
 // src/services/studio-web-auth-middleware.ts
 var studioWebAuthByCommand = new WeakMap;
@@ -66,4 +66,4 @@ async function resolveStudioWebAuthContext(options) {
 
 export { useStudioWebAuth, getStudioWebAuth, getStudioWebAuthWithOrganizationId };
 
-//# debugId=407AA4762D049D2964756E2164756E21
+//# debugId=FCF746C59C6BE72F64756E2164756E21

package/dist/packager-tool-gs3f3tf7.js

@@ -0,0 +1,103 @@
+import {
+  catchError
+} from "./packager-tool-6ybywxxn.js";
+
+// src/services/pack-project-selection.ts
+function validatePackProjectOptions(options) {
+  if (options.project !== undefined && options.project.trim() === "") {
+    return "--project was given an empty value.";
+  }
+  if (options.project !== undefined && options.name !== undefined) {
+    return "--name cannot be used together with --project: it names the solution package, and --project packs a project package. Use --package-id to name that.";
+  }
+  if (options.packageId === undefined) {
+    return;
+  }
+  if (options.project === undefined) {
+    return "--package-id can only be used together with --project.";
+  }
+  if (options.packageId.trim() === "") {
+    return "--package-id was given an empty value.";
+  }
+  return;
+}
+
+class PackProjectError extends Error {
+  instructions;
+  errorCode = "invalid_argument";
+  constructor(message, instructions) {
+    super(message);
+    this.instructions = instructions;
+    this.name = "PackProjectError";
+  }
+}
+async function resolvePackProjectAsync(fs, solutionDir, selector) {
+  const { projects, solutionName } = await readPackProjectEntriesAsync(fs, solutionDir);
+  const wanted = normalizeRelativePath(selector);
+  const byId = projects.filter((p) => p.id.toLowerCase() === selector.trim().toLowerCase());
+  const matches = byId.length > 0 ? byId : projects.filter((p) => {
+    const file = normalizeRelativePath(p.relativePath);
+    return wanted !== "" && (file === wanted || projectFolder(file) === wanted);
+  });
+  if (matches.length === 1) {
+    assertInsideSolution(fs, solutionDir, selector, matches[0]);
+    return { project: matches[0], solutionName };
+  }
+  throw new PackProjectError(matches.length === 0 ? `Project '${selector}' is not part of the solution.` : `Project '${selector}' matches more than one project of the solution.`, choicesInstructions(matches.length === 0 ? projects : matches));
+}
+function assertInsideSolution(fs, solutionDir, selector, project) {
+  const instructions = "Fix the project's ProjectRelativePath in the .uipx so it names a project file inside the solution folder, then rerun.";
+  if (project.relativePath.trim() === "") {
+    throw new PackProjectError(`Project '${selector}' has no ProjectRelativePath in the .uipx.`, instructions);
+  }
+  const relative = fs.path.relative(solutionDir, fs.path.resolve(solutionDir, projectFolder(project.relativePath)));
+  if (relative === ".." || relative.startsWith("../") || relative.startsWith("..\\") || fs.path.isAbsolute(relative)) {
+    throw new PackProjectError(`Project '${selector}' points outside the solution folder: '${project.relativePath}'.`, instructions);
+  }
+  if (relative === "") {
+    throw new PackProjectError(`Project '${selector}' sits at the solution root ('${project.relativePath}'), so packing it on its own would pack the whole solution with it.`, "Move the project into its own folder inside the solution, update its ProjectRelativePath in the .uipx to match, then rerun.");
+  }
+}
+function choicesInstructions(projects) {
+  if (projects.length === 0) {
+    return "The solution lists no projects. Add one with 'uip solution project add', then rerun.";
+  }
+  const choices = projects.map((p) => `'${projectFolder(p.relativePath) || p.relativePath}' (Id: ${p.id})`).join(", ");
+  return `Pass --project with one of the solution's project Ids or paths: ${choices}.`;
+}
+async function readPackProjectEntriesAsync(fs, solutionDir) {
+  const entries = await fs.readdir(solutionDir);
+  const uipxFile = entries.find((entry) => entry.endsWith(".uipx"));
+  if (!uipxFile) {
+    throw new PackProjectError(`No .uipx solution file found in ${solutionDir}.`, "Pass the solution folder, the one that contains the .uipx file.");
+  }
+  const content = await fs.readFile(fs.path.join(solutionDir, uipxFile), "utf-8");
+  const [parseError, manifest] = catchError(() => JSON.parse(content ?? ""));
+  if (parseError) {
+    throw new PackProjectError(`Failed to parse ${uipxFile}: ${parseError.message}`, `Fix the JSON in ${uipxFile}, then rerun.`);
+  }
+  const projects = [];
+  for (const raw of Array.isArray(manifest?.Projects) ? manifest.Projects : []) {
+    const entry = raw;
+    if (typeof entry?.Id !== "string" || !entry.Id)
+      continue;
+    projects.push({
+      id: entry.Id,
+      type: typeof entry.Type === "string" ? entry.Type : "",
+      relativePath: typeof entry.ProjectRelativePath === "string" ? entry.ProjectRelativePath : ""
+    });
+  }
+  return { projects, solutionName: uipxFile.slice(0, -".uipx".length) };
+}
+function normalizeRelativePath(path) {
+  return path.trim().replace(/\\/g, "/").replace(/\/+/g, "/").replace(/^(\.\/)+/, "").replace(/\/$/, "").toLowerCase();
+}
+function projectFolder(relativePath) {
+  const normalized = relativePath.replace(/\\/g, "/");
+  const slash = normalized.lastIndexOf("/");
+  return slash === -1 ? "" : normalized.slice(0, slash);
+}
+
+export { validatePackProjectOptions, PackProjectError, resolvePackProjectAsync, projectFolder };
+
+//# debugId=A02E54BA1CA9A95764756E2164756E21

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

package/dist/{packager-tool-ds45xby2.js → packager-tool-m74zqwmh.js}

@@ -1,17 +1,106 @@
 import {
+  Configuration,
+  PipelinesApi
+} from "./packager-tool-97rcgwvv.js";
+import {
+  Configuration as Configuration2,
+  DeploymentsApi,
   SolutionDeploymentAction
-} from "./packager-tool-j3520gxw.js";
+} from "./packager-tool-an5bpbwe.js";
+import {
+  quoteForShell
+} from "./packager-tool-tx834spe.js";
 import {
   catchError
-} from "./packager-tool-kswwd3hp.js";
+} from "./packager-tool-6ybywxxn.js";
 
 // src/services/deployment-state.ts
-function quoteForShell(name) {
-  return `'${name.replace(/'/g, "'\\''")}'`;
+function pendingResourceApis(auth) {
+  const settings = { basePath: auth.basePath, accessToken: auth.accessToken };
+  return {
+    pipelines: new PipelinesApi(new Configuration(settings)),
+    deployments: new DeploymentsApi(new Configuration2(settings))
+  };
+}
+function reportedActivationStatus(record) {
+  const status = record?.activationStatus;
+  return status && status !== "None" ? status : undefined;
 }
 var RESOURCES_PAGE_SIZE = 50;
 var RESOURCES_MAX_PAGES = 10;
-async function readPendingResourcesAsync(api, deploymentKey, scope) {
+async function readPendingResourcesAsync(apis, deployment, scope) {
+  const blockers = await readActivationBlockersAsync(apis.pipelines, deployment, scope);
+  if (blockers) {
+    return blockers;
+  }
+  return readSolutionsPendingResourcesAsync(apis.deployments, deployment.key, scope);
+}
+async function readActivationBlockersAsync(api, deployment, scope) {
+  const [readError, result] = await catchError(() => api.pipelinesGetDeploymentValidationResult({ deploymentName: deployment.name }, scope));
+  if (readError || !result || result.deploymentAction !== "Activate") {
+    return;
+  }
+  const blockers = toBlockers(result.validationErrors ?? []);
+  if (!blockers || !await isCurrentRecordAsync(api, deployment.key)) {
+    return;
+  }
+  return blockers;
+}
+async function isCurrentRecordAsync(api, key, init) {
+  const [lookupError, info] = await catchError(() => init ? api.pipelinesGetDeploymentByKey({ key }, init) : api.pipelinesGetDeploymentByKey({ key }));
+  return !lookupError && info?.deploymentKey === key;
+}
+function toBlockers(errors) {
+  const byResource = new Map;
+  for (const error of errors) {
+    if (error.level !== "Error") {
+      continue;
+    }
+    const name = error.name ?? error.resource;
+    if (!name) {
+      return;
+    }
+    const identity = error.key ?? resourceIdentity(name, error.type);
+    const existing = byResource.get(identity);
+    if (existing) {
+      mergeBlocker(existing, error);
+    } else {
+      byResource.set(identity, toBlocker(error, name));
+    }
+  }
+  return [...byResource.values()];
+}
+function toBlocker(error, name) {
+  const reason = formatValidationText(error.errorCode, error.text);
+  return {
+    key: error.key ?? "",
+    name,
+    kind: error.kind ?? "",
+    type: error.type,
+    ...reason ? { reason } : {},
+    ...error.folderPaths && error.folderPaths.length > 0 ? { folderPaths: [...error.folderPaths] } : {}
+  };
+}
+function mergeBlocker(blocker, error) {
+  const reason = formatValidationText(error.errorCode, error.text);
+  if (reason) {
+    blocker.reason = blocker.reason ? `${blocker.reason}; ${reason}` : reason;
+  }
+  const folders = new Set([
+    ...blocker.folderPaths ?? [],
+    ...error.folderPaths ?? []
+  ]);
+  if (folders.size > 0) {
+    blocker.folderPaths = [...folders];
+  }
+}
+function formatValidationText(errorCode, text) {
+  if (!text) {
+    return;
+  }
+  return errorCode ? `[${errorCode}] ${text}` : text;
+}
+async function readSolutionsPendingResourcesAsync(api, deploymentKey, scope) {
   const pending = [];
   let complete = false;
   for (let page = 0, skip = 0;page < RESOURCES_MAX_PAGES; page++) {
@@ -57,7 +146,7 @@ async function attachActivationReasonsAsync(api, deploymentKey, pending, scope)
   }
   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);
+    const texts = (resource.errors ?? []).map((error) => formatValidationText(error.errorCode, error.text)).filter((text) => Boolean(text));
     if (texts.length > 0) {
       reasons.set(resourceIdentity(resource.name, resource.type), texts.join("; "));
     }
@@ -76,13 +165,14 @@ 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 folders = resource.folderPaths?.length ? ` in ${resource.folderPaths.map((path) => `'${path}'`).join(", ")}` : "";
     const reason = resource.reason ? `: ${resource.reason}` : "";
-    return `${resource.kind} '${resource.name}'${type}${reason}`;
+    return `${resource.kind} '${resource.name}'${type}${folders}${reason}`;
   }).join("; ");
   const remaining = resources.length - MAX_LISTED_RESOURCES;
   return remaining > 0 ? `${described}; and ${remaining} more` : described;
 }
-function activationNextSteps(deployment, pendingResources) {
+function activationNextSteps(deployment, pendingResources, feedSelector = "") {
   const name = deployment.name;
   const version = deployment.currentPackageVersion ?? deployment.packageVersion;
   const installed = `Deployment '${name}' is installed${version ? ` at version ${version}` : ""}`;
@@ -98,11 +188,11 @@ function activationNextSteps(deployment, pendingResources) {
     case "ReadyToActivate":
     case "Inactive":
       return [
-        `${installed} but inactive. Activate it with: uip solution deploy activate ${quoteForShell(name)}.`
+        `${installed} but inactive. Activate it with: uip solution deploy activate ${quoteForShell(name)}${feedSelector}.`
       ];
     case "ActivationFailed":
       return [
-        `Activation of '${name}' failed. Inspect the deployment in Orchestrator, then retry with: uip solution deploy activate ${quoteForShell(name)}.`
+        `Activation of '${name}' failed. Inspect the deployment in Orchestrator, then retry with: uip solution deploy activate ${quoteForShell(name)}${feedSelector}.`
       ];
     default:
       return;
@@ -133,7 +223,7 @@ function deploymentNextSteps(deployment, pendingResources, feedSelector = "") {
     }
     return steps;
   }
-  return activationNextSteps(deployment, pendingResources);
+  return activationNextSteps(deployment, pendingResources, feedSelector);
 }
 function describePendingResources(pendingResources) {
   if (pendingResources === undefined) {
@@ -149,7 +239,7 @@ function describeDraft(deployment, feedSelector) {
   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.`;
+      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)}${feedSelector} --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":
@@ -161,6 +251,6 @@ function describeDraft(deployment, feedSelector) {
   }
 }
 
-export { quoteForShell, readPendingResourcesAsync, appendDeploymentStateInstructions, explainRefusal, needsPendingResources, deploymentNextSteps };
+export { pendingResourceApis, reportedActivationStatus, readPendingResourcesAsync, readActivationBlockersAsync, isCurrentRecordAsync, appendDeploymentStateInstructions, explainRefusal, needsPendingResources, deploymentNextSteps };
 
-//# debugId=ABAB11E889A49E7364756E2164756E21
+//# debugId=A8B3431B53CA127F64756E2164756E21