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

package/dist/run-service-tg6b67wp.js

@@ -0,0 +1,428 @@
+import {
+  ProjectRunner,
+  RunResult,
+  ensureExecutorFactory,
+  executorsFactoryRepository
+} from "./packager-tool-kkfb5kgn.js";
+import {
+  packSolutionAsync
+} from "./packager-tool-n3jfjn5r.js";
+import"./packager-tool-jg692f13.js";
+import"./packager-tool-t8gh825q.js";
+import"./packager-tool-wy4fx250.js";
+import"./packager-tool-47wzvqw0.js";
+import"./packager-tool-jmpb786m.js";
+import"./packager-tool-b2nhscfk.js";
+import"./packager-tool-60af1hw2.js";
+import"./packager-tool-wz34ma3s.js";
+import"./packager-tool-09swr9cp.js";
+import"./packager-tool-b03rva43.js";
+import"./packager-tool-n5d5dx5j.js";
+import"./packager-tool-5ddtwzva.js";
+import"./packager-tool-gs3f3tf7.js";
+import {
+  publishSolutionAsync
+} from "./packager-tool-w77d72a7.js";
+import {
+  listSelectablePublishLocations
+} from "./packager-tool-rvt68c1t.js";
+import"./packager-tool-97rcgwvv.js";
+import {
+  getProjectDebugStatus,
+  isDebugProvisioningSucceeded,
+  isDebugProvisioningTerminal
+} from "./packager-tool-9t26kde1.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

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

@@ -1,6 +1,7 @@
 import { type CliErrorCode, type RetryHint } from "@uipath/common";
 import { type PendingResource } from "./deployment-state";
 import { type FeedScope } from "./feed-resolver";
+import { type PermanentDeletionResource } from "./permanent-deletion-consent";
 /** Discriminator for {@link DeployFailure}; library callers can ignore the tag and read `.message`/`.instructions`. */
 export type DeployFailureReason = "auth_failed"
 /**
@@ -41,7 +42,16 @@ export type DeployFailureReason = "auth_failed"
 /** Activation poll didn't reach a terminal state. */
  | "activation_poll_failed"
 /** Activation reached a terminal state but it was a failure. */
- | "activation_failed";
+ | "activation_failed"
+/**
+ * The server wants the permanent deletion of installed resources replaced
+ * by links confirmed (schedule error 4026), and `acknowledgePermanentDeletion`
+ * was not set, the resources could not be listed, or the re-run after
+ * acknowledging them was refused again. Nothing was installed.
+ */
+ | "permanent_deletion_confirmation_required"
+/** Acknowledging a flagged resource failed; the install was not re-run. */
+ | "acknowledge_failed";
 export interface DeployOptions {
     /** Override the active tenant for auth + folder-lookup. The CLI's deprecated `--tenant` flag flows through here. */
     tenant?: string;
@@ -85,6 +95,15 @@ export interface DeployOptions {
      * that really do want a second, independent copy opt in here.
      */
     yes?: boolean;
+    /**
+     * Confirm that installed resources this deployment replaces with a link
+     * are permanently deleted with their data. Without it a deploy the server
+     * stops for that confirmation fails with
+     * `permanent_deletion_confirmation_required` and lists them; with it they
+     * are acknowledged and the identical install runs once more, inside the
+     * same `timeout`.
+     */
+    acknowledgePermanentDeletion?: boolean;
     /** Host-side cancellation for both poll loops (e.g. VS Code's cancel button); replaces `processContext.pollSignal`. */
     signal?: AbortSignal;
 }
@@ -131,6 +150,11 @@ export interface DeploySuccess {
     packageVersion?: string;
     /** Which feed the deploy targeted — drives telemetry `target`. */
     feedKind: FeedScope["kind"];
+    /**
+     * The installed resources acknowledged for permanent deletion before the
+     * install that succeeded (`kind 'name'`). Absent when none were.
+     */
+    permanentlyDeletedResources?: string[];
 }
 export interface DeployFailure {
     ok: false;
@@ -152,6 +176,15 @@ export interface DeployFailure {
      */
     errorCode?: CliErrorCode;
     retry?: RetryHint;
+    /** The refused attempt's draft, on a permanent-deletion refusal. */
+    deploymentKey?: string;
+    /** What the server wants confirmed, on a permanent-deletion refusal. */
+    permanentDeletionResources?: PermanentDeletionResource[];
+    /**
+     * Resources already acknowledged for permanent deletion when the deploy
+     * failed after the install that deleted them (activation failures).
+     */
+    permanentlyDeletedResources?: string[];
 }
 export type DeployResult = DeploySuccess | DeployFailure;
 /**

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

@@ -1,5 +1,10 @@
 import { type CliErrorCode, type RetryHint } from "@uipath/common";
-export type UninstallDeploymentFailureReason = "auth_failed" | "uninstall_request_failed"
+import { type FeedSelectionFlags } from "./feed-selection";
+export type UninstallDeploymentFailureReason = "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" | "uninstall_request_failed"
 /**
  * Orchestrator refused the uninstall because the deployment still had an
  * operation running, and it was still running when the wait ran out —
@@ -9,8 +14,13 @@ export type UninstallDeploymentFailureReason = "auth_failed" | "uninstall_reques
 /** Uninstall poll didn't reach a terminal state — recommended exit 2 (CI distinguishability). */
  | "poll_timeout" | "poll_failed" | "poll_aborted"
 /** Uninstall reached a terminal state but it was `FailedUninstall`. */
- | "uninstall_failed";
-export interface UninstallDeploymentOptions {
+ | "uninstall_failed"
+/**
+ * Refused for a cause only `--force` gets past: uncompleted jobs, or the
+ * permanent deletion of installed resources replaced by links.
+ */
+ | "uninstall_confirmation_required";
+export interface UninstallDeploymentOptions 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.
@@ -30,6 +40,12 @@ export interface UninstallDeploymentOptions {
     loginValidity?: number;
     /** Host-side cancellation for the poll loop; replaces `processContext.pollSignal`. */
     signal?: AbortSignal;
+    /**
+     * Send `forceUninstall`: uninstall past uncompleted jobs and the
+     * permanent deletion of resources replaced by links. The caller's consent;
+     * never set on the caller's behalf.
+     */
+    force?: boolean;
 }
 export interface UninstallDeploymentSuccess {
     ok: true;
@@ -55,6 +71,8 @@ export interface UninstallDeploymentFailure {
      */
     errorCode?: CliErrorCode;
     retry?: RetryHint;
+    /** Structured facts for the failure envelope's `Data`, keys as printed. */
+    data?: Record<string, unknown>;
 }
 export type UninstallDeploymentResult = UninstallDeploymentSuccess | UninstallDeploymentFailure;
 /**

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

@@ -1,6 +1,7 @@
 import type { CliErrorCode, PollFailureReason, RetryHint } from "@uipath/common";
 import type { PipelineDeploymentStatus } from "@uipath/pipelines-sdk";
 import { type PendingResource } from "./deployment-state";
+import { type PermanentDeletionResource } from "./permanent-deletion-consent";
 export type UpgradeDeploymentFailureReason = 
 /** Neither a deployment key nor a name+package pair was given, or both were. */
 "invalid_target" | "auth_failed"
@@ -51,7 +52,16 @@ export type UpgradeDeploymentFailureReason =
  * interrupted / aborted. Distinct from `install_timeout`: the deadline was
  * never reached, so a longer `--timeout` is not the fix.
  */
- | PollFailureReason;
+ | PollFailureReason
+/**
+ * The server wants the permanent deletion of installed resources replaced
+ * by links confirmed (schedule error 4026), and `acknowledgePermanentDeletion`
+ * was not set, the resources could not be listed, or the re-run after
+ * acknowledging them was refused again. Nothing was installed.
+ */
+ | "permanent_deletion_confirmation_required"
+/** Acknowledging a flagged resource failed; the upgrade was not re-run. */
+ | "acknowledge_failed";
 export interface UpgradeDeploymentOptions {
     /**
      * Key of the deployment to upgrade, as `deploy list` reports it. Resolved
@@ -105,6 +115,19 @@ export interface UpgradeDeploymentOptions {
      * the deployment by key.
      */
     discardDraft?: boolean;
+    /**
+     * Confirm that installed resources the new version replaces with a link
+     * are permanently deleted with their data. Without it an upgrade the
+     * server stops for that confirmation fails with
+     * `permanent_deletion_confirmation_required` and lists them; with it they
+     * are acknowledged and the identical install runs once more, inside the
+     * same `timeout`. Has no effect with `noWait`, which never sees the run end.
+     * Also lets through a pending draft of the requested version (or, with no
+     * version given, of its own) whose only open question is this
+     * confirmation: that draft is re-run instead of refused, so the links it
+     * carries are kept and acknowledged.
+     */
+    acknowledgePermanentDeletion?: boolean;
     /** Minimum minutes before token expiration to trigger a refresh. Default 10. */
     loginValidity?: number;
     /**
@@ -192,6 +215,11 @@ export interface UpgradeDeploymentSuccess {
     pendingResources?: PendingResource[];
     /** What is left before the new version runs; absent when it does. */
     nextSteps?: string[];
+    /**
+     * The installed resources acknowledged for permanent deletion before the
+     * install that succeeded (`kind 'name'`). Absent when none were.
+     */
+    permanentlyDeletedResources?: string[];
 }
 export interface UpgradeDeploymentFailure {
     ok: false;
@@ -208,6 +236,12 @@ export interface UpgradeDeploymentFailure {
      */
     errorCode?: CliErrorCode;
     retry?: RetryHint;
+    /** The refused run, on a permanent-deletion refusal. */
+    pipelineDeploymentId?: string;
+    /** The refused attempt's draft, on a permanent-deletion refusal. */
+    deploymentKey?: string;
+    /** What the server wants confirmed, on a permanent-deletion refusal. */
+    permanentDeletionResources?: PermanentDeletionResource[];
 }
 export type UpgradeDeploymentResult = UpgradeDeploymentSuccess | UpgradeDeploymentFailure;
 /**