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

package/dist/restore-command-service-eyx911f2.js

@@ -0,0 +1,155 @@
+import {
+  SOLUTION_PATH_INSTRUCTIONS,
+  applyAuthConnection,
+  checkSolutionPathAsync,
+  createSolutionPackager,
+  readSolutionFileAsUint8Array,
+  resolveSdkLogLevel
+} from "./packager-tool-8rg0s4w9.js";
+import {
+  ensurePackagerTools,
+  isUnpackableProjectTypeError
+} from "./packager-tool-b2nhscfk.js";
+import"./packager-tool-60af1hw2.js";
+import {
+  SolutionPackOptions
+} from "./packager-tool-5y09xhx5.js";
+import"./packager-tool-09fwj7e8.js";
+import"./packager-tool-bqw7edje.js";
+import"./packager-tool-85pen8t9.js";
+import"./packager-tool-5ddtwzva.js";
+import {
+  ToolResult
+} from "./packager-tool-pbmqk39a.js";
+import"./packager-tool-43ahv5mn.js";
+import {
+  OutputFormatter,
+  RESULTS,
+  logger
+} from "./packager-tool-tx834spe.js";
+import {
+  carriedInstructions,
+  catchError
+} from "./packager-tool-6ybywxxn.js";
+import {
+  getFileSystem
+} from "./packager-tool-v1f5e8t9.js";
+import"./packager-tool-dfrk01gn.js";
+import"./packager-tool-1de529jm.js";
+
+// src/services/restore-command-service.ts
+class RestoreCommandService {
+  packager = null;
+  fs;
+  constructor() {
+    this.fs = getFileSystem();
+  }
+  async execute(solutionPath, options, context) {
+    const check = await checkSolutionPathAsync(this.fs, solutionPath);
+    if (!check.ok) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: check.message,
+        Instructions: SOLUTION_PATH_INSTRUCTIONS,
+        ErrorCode: check.errorCode
+      });
+      if (check.statError?.stack) {
+        logger.error("Stack trace:");
+        logger.error(check.statError.stack);
+      }
+      context.exit(1);
+      return;
+    }
+    const { absoluteSolutionPath, isUisFile } = check;
+    const solutionName = isUisFile ? this.fs.path.basename(solutionPath, ".uis") : this.fs.path.basename(solutionPath);
+    logger.info(`
+Restoring solution dependencies...
+`);
+    logger.info("Details:");
+    logger.info(`  Solution: ${absoluteSolutionPath}`);
+    logger.info("");
+    const [error, result] = await catchError(this.executeAsync(solutionPath, options));
+    if (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        ...isUnpackableProjectTypeError(error) ? { ErrorCode: "invalid_argument" } : {},
+        Message: msg,
+        Instructions: carriedInstructions(error) ?? "Check that you are logged in (`uip auth login`) and that the solution path is accessible, then rerun: uip solution restore <solution-path>"
+      });
+      if (error instanceof Error && error.stack && !isUnpackableProjectTypeError(error)) {
+        logger.error("Stack trace:");
+        logger.error(error.stack);
+      }
+      context.exit(1);
+      return;
+    }
+    if (result.errorCode !== "SUCCESS" /* Success */) {
+      OutputFormatter.error({
+        Result: RESULTS.Failure,
+        Message: `Error code: ${result.errorCode} : ${result.message}`,
+        Instructions: "Resolve the reported dependency issue, ensure you are logged in with `uip auth login`, then rerun: uip solution restore <solution-path>"
+      });
+      context.exit(1);
+      return;
+    }
+    OutputFormatter.success({
+      Result: RESULTS.Success,
+      Code: "SolutionRestore",
+      Data: {
+        Solution: solutionName,
+        Status: "Restored"
+      }
+    });
+  }
+  async executeAsync(solutionPath, options) {
+    const check = await checkSolutionPathAsync(this.fs, solutionPath);
+    if (!check.ok) {
+      if (check.statError) {
+        throw check.statError;
+      }
+      return new ToolResult("INTERNAL_ERROR" /* InternalError */, check.message, []);
+    }
+    const { absoluteSolutionPath, isUisFile } = check;
+    const solutionName = isUisFile ? this.fs.path.basename(solutionPath, ".uis") : this.fs.path.basename(solutionPath);
+    const packager = await this.ensurePackagerAsync();
+    let inputPath;
+    if (isUisFile) {
+      const uint8Array = await readSolutionFileAsUint8Array(this.fs, absoluteSolutionPath);
+      inputPath = await packager.setupAsync(uint8Array);
+    } else {
+      inputPath = await packager.setupAsync(absoluteSolutionPath);
+    }
+    await ensurePackagerTools(inputPath, this.fs);
+    const restoreOptions = await this.createRestoreOptions(inputPath, solutionName, options);
+    return packager.restoreSolutionAsync(restoreOptions);
+  }
+  async ensurePackagerAsync() {
+    if (!this.packager) {
+      this.packager = await createSolutionPackager();
+    }
+    return this.packager;
+  }
+  async createRestoreOptions(inputPath, solutionName, options) {
+    const restoreOptions = new SolutionPackOptions;
+    restoreOptions.inputPath = inputPath;
+    restoreOptions.configuration = "Release" /* Release */;
+    restoreOptions.excludeConfiguredSources = options.excludeConfiguredSources ?? false;
+    restoreOptions.package = {
+      id: solutionName,
+      version: "1.0.0",
+      author: "",
+      description: ""
+    };
+    restoreOptions.logLevel = resolveSdkLogLevel();
+    restoreOptions.nuGetSourcesConfigPath = options.nugetSourcesConfigPath;
+    restoreOptions.feedFolder = options.feedFolder;
+    await applyAuthConnection(restoreOptions, options.loginValidity);
+    return restoreOptions;
+  }
+}
+export {
+  RestoreCommandService
+};
+
+//# debugId=B15EA9113DA4F34C64756E2164756E21

package/dist/run-service-p1vzzqe3.js

@@ -0,0 +1,428 @@
+import {
+  ProjectRunner,
+  RunResult,
+  ensureExecutorFactory,
+  executorsFactoryRepository
+} from "./packager-tool-kkfb5kgn.js";
+import {
+  packSolutionAsync
+} from "./packager-tool-37jmavap.js";
+import"./packager-tool-4jekgh4s.js";
+import"./packager-tool-t8gh825q.js";
+import"./packager-tool-wy4fx250.js";
+import"./packager-tool-47wzvqw0.js";
+import"./packager-tool-8rg0s4w9.js";
+import"./packager-tool-b2nhscfk.js";
+import"./packager-tool-60af1hw2.js";
+import"./packager-tool-5y09xhx5.js";
+import"./packager-tool-09fwj7e8.js";
+import"./packager-tool-bqw7edje.js";
+import"./packager-tool-85pen8t9.js";
+import"./packager-tool-5ddtwzva.js";
+import"./packager-tool-gs3f3tf7.js";
+import {
+  publishSolutionAsync
+} from "./packager-tool-wknfv4p5.js";
+import {
+  listSelectablePublishLocations
+} from "./packager-tool-6x35kvbx.js";
+import"./packager-tool-97rcgwvv.js";
+import {
+  getProjectDebugStatus,
+  isDebugProvisioningSucceeded,
+  isDebugProvisioningTerminal
+} from "./packager-tool-an5bpbwe.js";
+import"./packager-tool-qw47eyw7.js";
+import {
+  createResourceBuilderServices
+} from "./packager-tool-6kz1pv9f.js";
+import"./packager-tool-gdtpsdn7.js";
+import"./packager-tool-53w8skv5.js";
+import"./packager-tool-pbmqk39a.js";
+import {
+  getSolutionAuthContext
+} from "./packager-tool-61pwb567.js";
+import"./packager-tool-8ptbmmmp.js";
+import"./packager-tool-5edvzz80.js";
+import {
+  getLoginStatusAsync
+} from "./packager-tool-43ahv5mn.js";
+import {
+  PollOutcome,
+  logger,
+  pollUntil,
+  processContext
+} from "./packager-tool-tx834spe.js";
+import {
+  carriedInstructions,
+  catchError
+} from "./packager-tool-6ybywxxn.js";
+import {
+  getFileSystem
+} from "./packager-tool-v1f5e8t9.js";
+import"./packager-tool-dfrk01gn.js";
+import"./packager-tool-1de529jm.js";
+
+// src/services/executor-tool-resolver.ts
+var PROJECT_TYPE_TO_TOOL = new Map([
+  ["Process", "rpa"],
+  ["Tests", "rpa"],
+  ["WebApp", "rpa"],
+  ["Agent", "agent"],
+  ["Api", "api-workflow"]
+]);
+var TOOL_TO_PACKAGE = new Map([
+  ["rpa", "@uipath/rpa-tool"],
+  ["agent", "@uipath/agent-tool"],
+  ["api-workflow", "@uipath/api-workflow-tool"]
+]);
+function hasExecutorToolFor(projectType) {
+  return PROJECT_TYPE_TO_TOOL.has(projectType);
+}
+async function ensureExecutorTools(projectTypes) {
+  const neededTools = new Set;
+  for (const type of projectTypes) {
+    if (executorsFactoryRepository.canHandleProject(type))
+      continue;
+    const toolVerb = PROJECT_TYPE_TO_TOOL.get(type);
+    if (toolVerb) {
+      neededTools.add(toolVerb);
+    } else {
+      logger.warn(`No installable tool runs project type '${type}'. Run may fail.`);
+    }
+  }
+  for (const toolVerb of neededTools) {
+    logger.info(`Loading executor factory for '${toolVerb}' to run project types...`);
+    await ensureExecutorFactory(toolVerb, TOOL_TO_PACKAGE.get(toolVerb));
+  }
+}
+function projectDirOf(fs, declaredPath) {
+  const dir = fs.path.dirname(declaredPath);
+  return dir && dir !== "." ? dir : "";
+}
+async function readSolutionProjects(solutionDir, fs) {
+  const entries = await fs.readdir(solutionDir);
+  const uipxFile = entries.find((f) => f.endsWith(".uipx"));
+  if (!uipxFile) {
+    throw new Error(`No .uipx solution file found in '${solutionDir}'. ` + `Pass a solution directory or run 'uip solution init' first.`);
+  }
+  const content = await fs.readFile(fs.path.join(solutionDir, uipxFile));
+  if (!content) {
+    throw new Error(`Solution file '${uipxFile}' is empty.`);
+  }
+  const json = typeof content === "string" ? content : new TextDecoder().decode(content);
+  const [parseError, solution] = catchError(() => JSON.parse(json));
+  if (parseError) {
+    throw new Error(`Failed to parse ${uipxFile}: ${parseError.message}`);
+  }
+  return (solution.Projects ?? []).map((p) => {
+    const relativePath = projectDirOf(fs, p.ProjectRelativePath ?? "");
+    return {
+      name: p.Name || fs.path.basename(relativePath || solutionDir) || "",
+      projectType: p.Type ?? "",
+      relativePath
+    };
+  });
+}
+
+// src/services/provision-debug-service.ts
+function nextDebugVersion() {
+  return `1.0.${Math.floor(Date.now() / 1000)}`;
+}
+async function defaultGetSolutionBuilder(solutionDir) {
+  const services = await createResourceBuilderServices();
+  return services.getSolutionBuilder(solutionDir, true);
+}
+async function provisionSolutionForDebugAsync(options, deps = {}) {
+  const listLocations = deps.listLocations ?? listSelectablePublishLocations;
+  const pack = deps.pack ?? packSolutionAsync;
+  const publish = deps.publish ?? publishSolutionAsync;
+  const getBuilder = deps.getSolutionBuilder ?? defaultGetSolutionBuilder;
+  const newSessionId = deps.newSessionId ?? (() => crypto.randomUUID());
+  const authOptions = {
+    tenant: options.tenant,
+    loginValidity: options.loginValidity
+  };
+  const getDebugStatus = deps.getDebugStatus ?? (async (solutionKey2, debugSessionId) => {
+    const auth = await getSolutionAuthContext(authOptions);
+    return getProjectDebugStatus({ basePath: auth.basePath, accessToken: auth.accessToken }, solutionKey2, debugSessionId);
+  });
+  logger.info("Resolving the personal workspace to deploy into...");
+  const [locationsError, locations] = await catchError(listLocations(authOptions));
+  if (locationsError) {
+    return fail(`Could not resolve a personal workspace to deploy into: ${locationsError.message}`);
+  }
+  const personal = locations.find((l) => l.isMyPersonalWorkspace);
+  if (!personal) {
+    return fail("This account has no personal workspace, so there is nowhere to deploy the solution for a debug run. " + "Ask an administrator to enable a personal workspace, or run with --no-provision-resources — " + "the run then starts without a deployment, and cross-project calls will not resolve.");
+  }
+  const version = options.version ?? nextDebugVersion();
+  const fs = getFileSystem();
+  const outputPath = fs.path.join(fs.env.tmpdir(), "uip-solution-run", newSessionId());
+  const uploaded = await packAndUploadAsync({
+    options,
+    authOptions,
+    pack,
+    publish,
+    version,
+    outputPath
+  });
+  if (!uploaded.ok) {
+    return fail(uploaded.message);
+  }
+  const packageVersionKey = uploaded.packageVersionKey;
+  logger.info("Provisioning the solution's resources for the run...");
+  const [builderError, builder] = await catchError(getBuilder(options.solutionDir));
+  if (builderError) {
+    return fail(`Could not read the solution: ${builderError.message}`);
+  }
+  const sessionId = newSessionId();
+  const [debugError, debug] = await catchError(builder.debugProjectAsync(personal.key, options.solutionName, sessionId, packageVersionKey, true));
+  let solutionKey;
+  if (!debugError && debug.complete === false) {
+    const [, definition] = await catchError(builder.context.loadAsync());
+    solutionKey = definition?.key;
+  }
+  await builder.disposeAsync().catch(() => {});
+  if (debugError) {
+    return fail(`Provisioning the solution failed: ${debugError.message}`);
+  }
+  if (debug.complete === false) {
+    if (!solutionKey) {
+      return fail("The cloud is still provisioning the solution, but its key could not be read back from the .uipx, so the provisioning cannot be waited on. Retry the run.");
+    }
+    return waitForProvisioningAsync({
+      solutionKey,
+      sessionId,
+      packageVersionKey,
+      options,
+      getDebugStatus
+    });
+  }
+  const folderPath = debug.folderFullyQualifiedName;
+  logger.info(folderPath ? `Solution provisioned into ${folderPath}.` : "Solution provisioned.");
+  return {
+    ok: true,
+    folderPath,
+    packageVersionKey
+  };
+}
+function fail(message) {
+  return { ok: false, message };
+}
+async function packAndUploadAsync(args) {
+  const { options, authOptions, version } = args;
+  logger.info("Packing the solution...");
+  const [packError, packed] = await catchError(args.pack(options.solutionDir, {
+    output: args.outputPath,
+    name: options.solutionName,
+    version,
+    loginValidity: options.loginValidity
+  }));
+  if (packError) {
+    return {
+      ok: false,
+      message: `Packing the solution failed: ${packError.message}`
+    };
+  }
+  if (!packed.ok) {
+    return {
+      ok: false,
+      message: `Packing the solution failed: ${packed.message}`
+    };
+  }
+  const packagePath = packed.packages?.[0];
+  if (!packagePath) {
+    return {
+      ok: false,
+      message: "Packing the solution produced no package."
+    };
+  }
+  logger.info("Uploading the solution to the personal workspace...");
+  const [publishError, published] = await catchError(args.publish(packagePath, {
+    ...authOptions,
+    personalWorkspace: true,
+    packageVersion: version
+  }));
+  if (publishError) {
+    return {
+      ok: false,
+      message: `Uploading the solution failed: ${publishError.message}`
+    };
+  }
+  if (!published.ok) {
+    return {
+      ok: false,
+      message: `Uploading the solution failed: ${published.message}`
+    };
+  }
+  if (!published.packageVersionKey) {
+    return {
+      ok: false,
+      message: "The solution was uploaded but the feed did not report a package version, so it cannot be provisioned. Retry the run."
+    };
+  }
+  return { ok: true, packageVersionKey: published.packageVersionKey };
+}
+async function waitForProvisioningAsync(args) {
+  const { solutionKey, sessionId, packageVersionKey, options } = args;
+  const timeoutMs = options.provisioningTimeoutMs ?? 360000;
+  logger.info("Waiting for the cloud to finish provisioning...");
+  const poll = await pollUntil({
+    fn: () => args.getDebugStatus(solutionKey, sessionId),
+    until: (info2) => isDebugProvisioningTerminal(info2.status),
+    getStatus: (info2) => info2.status ?? "pending",
+    label: `solution provisioning (session ${sessionId})`,
+    logPrefix: "provision",
+    timeoutMs,
+    intervalMs: options.provisioningPollIntervalMs ?? 5000,
+    maxConsecutiveErrors: 5,
+    signal: processContext.pollSignal
+  });
+  if (poll.outcome !== PollOutcome.Completed || !poll.data) {
+    return fail(describeIncompleteWait(poll, timeoutMs));
+  }
+  const info = poll.data;
+  if (!isDebugProvisioningSucceeded(info.status)) {
+    const details = (info.errors ?? []).map((error) => error.resource ? `${error.resource.kind ?? "resource"} '${error.resource.name ?? error.resource.key ?? ""}': ${error.message}` : error.message).join(`
+`);
+    return fail(`Provisioning the solution failed (${info.status}).` + (details ? `
+${details}` : ""));
+  }
+  logger.info("Solution provisioned.");
+  return { ok: true, packageVersionKey };
+}
+function describeIncompleteWait(poll, timeoutMs) {
+  const lastStatus = poll.data?.status ?? "unknown";
+  if (poll.outcome === PollOutcome.Interrupted) {
+    return `The wait for the solution's provisioning was cancelled (last status: ${lastStatus}). ` + "The cloud may still finish it.";
+  }
+  if (poll.outcome === PollOutcome.Failed || poll.outcome === PollOutcome.Aborted) {
+    return `Checking the solution's provisioning status failed: ${poll.error?.message ?? "too many consecutive errors"} ` + `(last status: ${lastStatus}). The provisioning itself may still be running or have finished — ` + "retry the run to check.";
+  }
+  return `The solution was uploaded, but the cloud did not finish provisioning it within ${Math.round(timeoutMs / 1000)}s ` + `(last status: ${lastStatus}). ` + "Running again will not help: each run uploads a new version and provisions that one too. " + "To run a project that calls another project, deploy the solution once " + "('uip solution pack' → 'publish' → 'deploy run') and then run with " + "--no-provision-resources --folder-path <deployed folder>.";
+}
+
+// src/services/run-service.ts
+async function runSolutionAsync(options, deps, cancellationToken) {
+  const { fileSystem } = deps;
+  const solutionDir = fileSystem.path.resolve(options.solutionPath);
+  const [readError, projects] = await catchError(readSolutionProjects(solutionDir, fileSystem));
+  if (readError) {
+    return RunResult.failed("InvalidInput" /* InvalidInput */, readError.message);
+  }
+  const runnable = projects.filter((p) => hasExecutorToolFor(p.projectType));
+  if (runnable.length === 0) {
+    const seen = projects.map((p) => `${p.name} (${p.projectType})`).join(", ") || "none";
+    return RunResult.failed("UnsupportedProjectType" /* UnsupportedProjectType */, `No project in this solution can be run. Projects: ${seen}.`);
+  }
+  const [selectionError, selected] = selectProject(runnable, options.projectName);
+  if (selectionError) {
+    return RunResult.failed("InvalidInput" /* InvalidInput */, selectionError);
+  }
+  const provision = deps.provisionForDebug ?? provisionSolutionForDebugAsync;
+  const shouldProvision = options.provisionResources ?? projects.length > 1;
+  const [executorOutcome, provisionOutcome] = await Promise.allSettled([
+    ensureExecutorTools([selected.projectType]),
+    shouldProvision ? provision({
+      solutionDir,
+      solutionName: fileSystem.path.basename(solutionDir),
+      tenant: options.tenant,
+      loginValidity: options.loginValidity
+    }) : Promise.resolve(undefined)
+  ]);
+  if (executorOutcome.status === "rejected") {
+    return RunResult.failed("PrepareFailed" /* PrepareFailed */, `Could not load the runner for project type '${selected.projectType}': ${describeError(executorOutcome.reason)}`);
+  }
+  if (provisionOutcome.status === "rejected") {
+    return RunResult.failed("PrepareFailed" /* PrepareFailed */, `Could not deploy the solution before the run: ${describeError(provisionOutcome.reason)}`);
+  }
+  let folderPath = options.folderPath;
+  const provisioned = provisionOutcome.value;
+  if (provisioned) {
+    if (!provisioned.ok) {
+      return RunResult.failed("PrepareFailed" /* PrepareFailed */, provisioned.message ?? "Could not deploy the solution before the run.");
+    }
+    folderPath = provisioned.folderPath;
+  }
+  const projectPath = fileSystem.path.resolve(solutionDir, selected.relativePath);
+  logger.debug(`Running '${selected.name}' (${selected.projectType}) from ${projectPath}` + `${options.entryPoint ? ` with entry point ${options.entryPoint}` : " with its default entry point"}`);
+  const connection = await resolveConnection(folderPath, options, deps);
+  const runner = new ProjectRunner({
+    fileSystem,
+    logger: deps.logger
+  });
+  return runner.runAsync({
+    project: {
+      name: selected.name,
+      projectType: selected.projectType,
+      projectPath
+    },
+    entryPoint: options.entryPoint,
+    inputArguments: options.inputArguments,
+    target: "Local" /* Local */,
+    connection,
+    siblingProjects: projects.filter((p) => p !== selected).map((p) => ({
+      name: p.name,
+      projectType: p.projectType,
+      projectPath: fileSystem.path.resolve(solutionDir, p.relativePath)
+    })),
+    timeoutMs: options.timeoutMs
+  }, cancellationToken);
+}
+async function resolveConnection(folderPath, options, deps) {
+  const getLoginStatus = deps.getLoginStatus ?? getLoginStatusAsync;
+  const [loginError, status] = await catchError(getLoginStatus({
+    ensureTokenValidityMinutes: options.loginValidity
+  }));
+  if (loginError || status.loginStatus !== "Logged in") {
+    logger.debug(`No signed-in session for the run: ${loginError?.message ?? status.loginStatus}. ` + "A project type that needs one will say so.");
+    return {
+      folderPath,
+      baseUrl: "",
+      accessToken: "",
+      organizationId: "",
+      organizationName: ""
+    };
+  }
+  return {
+    folderPath,
+    baseUrl: status.baseUrl ?? "",
+    accessToken: status.accessToken ?? "",
+    organizationId: status.organizationId ?? "",
+    organizationName: status.organizationName ?? "",
+    tenantId: status.tenantId,
+    tenantName: status.tenantName
+  };
+}
+function describeError(reason) {
+  const message = reason instanceof Error ? reason.message : String(reason);
+  const instructions = carriedInstructions(reason);
+  return instructions ? `${message} ${instructions}` : message;
+}
+function selectProject(runnable, requested) {
+  if (requested) {
+    const match = runnable.find((p) => p.name === requested);
+    if (!match) {
+      const names = runnable.map((p) => p.name).join(", ");
+      return [
+        `Project '${requested}' is not a runnable project in this solution. Runnable projects: ${names}.`,
+        runnable[0]
+      ];
+    }
+    return [undefined, match];
+  }
+  if (runnable.length > 1) {
+    const names = runnable.map((p) => p.name).join(", ");
+    return [
+      `This solution has more than one runnable project, so one has to be named with --project-name. Runnable projects: ${names}.`,
+      runnable[0]
+    ];
+  }
+  return [undefined, runnable[0]];
+}
+export {
+  runSolutionAsync
+};
+
+//# debugId=56CE2FF893D2961664756E2164756E21

package/dist/services/deploy-activate-service.d.ts

@@ -1,12 +1,17 @@
 import { type CliErrorCode, type RetryHint } from "@uipath/common";
+import { type FeedSelectionFlags } from "./feed-selection";
 export type ActivateDeploymentFailureReason = "auth_failed"
+/** `--feed` named no feed this session can reach. */
+ | "feed_resolution_failed"
+/** `--feed` / `--personal-workspace` with a session the server would not scope. */
+ | "feed_requires_user_session"
 /** Activation HTTP request failed (e.g. unknown deployment name). */
  | "request_failed"
 /** Activation poll didn't reach a terminal state — recommended exit 2 (CI distinguishability). */
  | "poll_timeout" | "poll_failed" | "poll_aborted"
 /** Activation reached a terminal state but was a failure. */
  | "activation_failed";
-export interface ActivateDeploymentOptions {
+export interface ActivateDeploymentOptions extends Pick<FeedSelectionFlags, "personalWorkspace" | "feed"> {
     /**
      * Override the active tenant for auth resolution. The CLI's deprecated
      * `--tenant` flag flows through here; library callers usually omit it.
@@ -39,10 +44,10 @@ export interface ActivateDeploymentFailure {
     exitCode: number;
     /**
      * Set only when the service knows better than the formatter's guess from
-     * the message — today, a refusal that followed a feed sweep which could
-     * not ask every feed: the sweep's classification for a refusal about the
-     * name or feed, the request's own for any other. Absent everywhere else,
-     * as before.
+     * the message: a refused feed selection, or a refusal that followed a
+     * feed sweep which could not ask every feed (the sweep's classification
+     * for a refusal about the name or feed, the request's own for any other).
+     * Absent everywhere else, as before.
      */
     errorCode?: CliErrorCode;
     retry?: RetryHint;

package/dist/services/deploy-delete-service.d.ts

@@ -1,5 +1,10 @@
 import { type CliErrorCode, type RetryHint } from "@uipath/common";
+import { type FeedSelectionFlags } from "./feed-selection";
 export type DeleteDeploymentFailureReason = "auth_failed"
+/** `--feed` named no feed this session can reach. */
+ | "feed_resolution_failed"
+/** `--feed` / `--personal-workspace` with a session the server would not scope. */
+ | "feed_requires_user_session"
 /**
  * No deployment with that name in the tenant feed or any feed swept after
  * it — and every one of those feeds answered.
@@ -20,7 +25,7 @@ export type DeleteDeploymentFailureReason = "auth_failed"
  | "delete_unavailable"
 /** The DELETE request itself failed. */
  | "delete_request_failed";
-export interface DeleteDeploymentOptions {
+export interface DeleteDeploymentOptions extends Pick<FeedSelectionFlags, "personalWorkspace" | "feed"> {
     /**
      * Override the active tenant for auth resolution. The CLI's deprecated
      * `--tenant` flag flows through here; library callers usually omit it.
@@ -49,9 +54,8 @@ export type DeleteDeploymentResult = DeleteDeploymentSuccess | DeleteDeploymentF
 /**
  * Programmatic core of `uip solution deploy delete` (UV-16671, UV-16341).
  *
- * Calls `DELETE /api/deployments/{key}`, which the CLI never reached before:
- * the SDK generator kept only `get` for that path, so the route looked absent
- * and both tickets were read as a platform gap.
+ * Sends the delete through the Pipelines route, so a CI/CD pipeline logged in
+ * as an external application can run it (see {@link sendDeleteAsync}).
  *
  * Delete is not a second name for uninstall. `deploy uninstall` removes the
  * provisioned resources and the solution folder of a live deployment, and