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

package/dist/services/permanent-deletion-consent.d.ts

@@ -0,0 +1,110 @@
+import { type CliErrorCode, extractErrorDetails, type RetryHint } from "@uipath/common";
+import type { DeploymentValidationErrorDto, PipelineDeploymentResult, PipelinesApi } from "@uipath/pipelines-sdk";
+import type { InitOverrideFunction } from "@uipath/solution-sdk";
+/**
+ * An installed resource the deployment replaces with a link, which the server
+ * deletes — with its data — when the deployment runs.
+ */
+export interface PermanentDeletionResource {
+    /** `DeploymentResource.Key`: what the acknowledge route takes. */
+    key: string;
+    name: string;
+    kind?: string;
+}
+/**
+ * Did the pipeline stop because the server wants the permanent deletion of
+ * linked-over resources confirmed? A structured match on the schedule error's
+ * code, never on its text.
+ */
+export declare function isPermanentDeletionRefusal(status: Pick<PipelineDeploymentResult, "status" | "deploymentScheduleErrors"> | undefined): boolean;
+/**
+ * The rows the UI's confirmation dialog lists: `RequiresConfirmation` warnings
+ * with a key, one per key, named by their name (or key).
+ */
+export declare function selectPermanentDeletionResources(validationErrors: readonly DeploymentValidationErrorDto[]): PermanentDeletionResource[];
+/**
+ * The resources the deployment's current validation flags for permanent
+ * deletion, or undefined when they cannot be read — a 409 while the
+ * validation is still running, a server without the route, anything else.
+ * The caller decides what an unreadable list means; it must never be taken
+ * for "nothing to confirm".
+ *
+ * The route reads the name's newest record, not a key. Its answer is the
+ * record this run acted on (`deploymentKey`) only while that key is still the
+ * current one, so the by-key lookup is read after the answer and the answer
+ * kept only when it resolves the key to itself — the same check
+ * `readActivationBlockersAsync` makes. No key, a key another actor superseded
+ * meanwhile, or a failed lookup is unreadable: otherwise the CLI could
+ * acknowledge, and re-run, someone else's draft. The lookup is bounded like
+ * the read, but carries no feed header: by-key reads span every feed.
+ */
+export declare function listPermanentDeletionResourcesAsync(api: PipelinesApi, deploymentName: string, deploymentKey: string | undefined, scope: InitOverrideFunction | undefined, signal: AbortSignal | undefined): Promise<PermanentDeletionResource[] | undefined>;
+/** A PATCH the server refused, with the resource it was for. */
+export declare class AcknowledgePermanentDeletionError extends Error {
+    readonly resource: PermanentDeletionResource;
+    readonly detail: Awaited<ReturnType<typeof extractErrorDetails>>;
+    constructor(resource: PermanentDeletionResource, detail: Awaited<ReturnType<typeof extractErrorDetails>>);
+}
+/**
+ * Acknowledge each resource, one PATCH at a time, stopping at the first the
+ * server refuses ({@link AcknowledgePermanentDeletionError}).
+ */
+export declare function acknowledgePermanentDeletionAsync(api: PipelinesApi, deploymentName: string, resources: readonly PermanentDeletionResource[], scope: InitOverrideFunction | undefined, signal: AbortSignal | undefined): Promise<void>;
+/** `bucket 'Invoices', queue 'Orders'`. */
+export declare function formatPermanentDeletionResources(resources: readonly PermanentDeletionResource[]): string;
+export declare const ACKNOWLEDGE_PERMANENT_DELETION_FLAG = "--acknowledge-permanent-deletion";
+/** How a deploy that stopped for confirmation is reported. */
+export interface PermanentDeletionRefusal {
+    reason: "permanent_deletion_confirmation_required" | "acknowledge_failed";
+    message: string;
+    instructions: string;
+    /** The flagged resources, when they could be read. */
+    resources?: PermanentDeletionResource[];
+    classification: {
+        errorCode?: CliErrorCode;
+        retry?: RetryHint;
+    };
+}
+export interface PermanentDeletionConsentRequest {
+    api: PipelinesApi;
+    deploymentName: string;
+    scope: InitOverrideFunction | undefined;
+    signal: AbortSignal | undefined;
+    /** `--acknowledge-permanent-deletion` was passed. */
+    acknowledge: boolean;
+    /** The refused run's terminal status. */
+    status: PipelineDeploymentResult;
+    /** "Deploying" / "Upgrading", to open the message. */
+    verb: string;
+    /** How to confirm, as a clause naming the flag ("re-run the same command with …"). */
+    confirmHint: string;
+    /** How to keep the installed copies instead, as a clause. */
+    keepCopiesHint: string;
+}
+/**
+ * Settle a refusal {@link isPermanentDeletionRefusal} matched: read what the
+ * server wants confirmed, then either report it (no flag) or acknowledge it.
+ * Returns the acknowledged resources, after which the caller re-runs the same
+ * install once, or the failure to report. Never acknowledges a list it could
+ * not read: consent is given for named resources only.
+ *
+ * The acknowledge route is name-scoped and takes no key precondition, so an
+ * install that replaces the draft between the identity check and the PATCHes
+ * would receive this consent. The CLI cannot close that window; it narrows it
+ * by re-checking the record after the PATCHes and, when it changed, refuses
+ * to re-run the install — a narrowing, not a guarantee.
+ */
+export declare function settlePermanentDeletionRefusalAsync(request: PermanentDeletionConsentRequest): Promise<{
+    ok: true;
+    resources: PermanentDeletionResource[];
+} | ({
+    ok: false;
+} & PermanentDeletionRefusal)>;
+/**
+ * The sentence a synchronously refused re-run adds to its failure: the
+ * acknowledgement stays on the kept draft, while nothing was deleted yet —
+ * the deletion happens only when an install runs.
+ */
+export declare function acknowledgedButNotRunHint(resources: readonly PermanentDeletionResource[], keepCopiesHint: string): string;
+/** A second refusal after every listed resource was acknowledged: no loop. */
+export declare function stillRequiresConfirmation(deploymentName: string, resources: readonly PermanentDeletionResource[], deploymentKey: string | undefined): PermanentDeletionRefusal;

package/dist/services/pipeline-deploy-poll.d.ts

@@ -38,6 +38,13 @@ export interface PipelineDeployPollOptions {
 export type PolledPipelineResult = PipelineDeploymentResult & {
     synthesizedOperation?: string;
 };
+/**
+ * What is left of a `timeoutMs` budget that started when `deadline` was set
+ * (`Date.now() + timeoutMs`), for a second poll that must share it. Never 0
+ * once spent: `pollUntil` reads 0 as "no deadline", which would turn an
+ * exhausted budget into an unbounded wait. A budget of 0 stays 0.
+ */
+export declare function remainingTimeoutMs(timeoutMs: number, deadline: number): number;
 /**
  * Poll a Pipelines install to a terminal state.
  *

package/dist/services/prepare-solution-resources.d.ts

@@ -1,4 +1,5 @@
 import type { IFileSystem } from "@uipath/filesystem";
+import { type ContributedBinding } from "@uipath/solution-sdk/resources";
 import { type ProjectContributions } from "./project-contributions";
 export interface PrepareResult {
     /** Contributed problems (when not gating), skips, and unmatched patches. */
@@ -13,6 +14,12 @@ export interface PrepareResult {
  * reconciler, and nothing in between reads it (AGENTS.md Hard Rule #19).
  */
 export declare function projectSubTypesFrom(contributions: ProjectContributions): ReadonlyMap<string, string>;
+/**
+ * The bindings each project's own tool contributed, keyed by `.uipx` project
+ * `Id`. Plain `bindings_v2.json` resource entries; the sync reads them in
+ * place of the project's `bindings_v2.json` file.
+ */
+export declare function projectBindingsFrom(contributions: ProjectContributions): ReadonlyMap<string, readonly ContributedBinding[]>;
 /**
  * Bring a solution directory's resource JSONs in line with its projects'
  * authored files. Every path that reads those resources for real — `pack`,
@@ -28,12 +35,15 @@ export declare function projectSubTypesFrom(contributions: ProjectContributions)
  *    must fail before any write, not leave half-synced resources behind.
  * 4. sync — carries the contributed subTypes, which is what lets reconcile
  *    generate (or repair) artefact resources for a type whose template row is
- *    keyed `<type>_<subType>`.
+ *    keyed `<type>_<subType>`, and the contributed bindings of a type that
+ *    keeps them in its own source format (a Flow's `.flow`).
  * 5. apply — after the sync, because the sync can create the app resource a
  *    patch targets. An unmatched patch here is a contributor bug, not a race,
  *    which is why gating callers also fail on one.
  * 6. runtime dependencies — mirrors Orchestrator BE's
- *    `ProcessesExportHandlerBase.GetRuntimeDependenciesAsync`.
+ *    `ProcessesExportHandlerBase.GetRuntimeDependenciesAsync`. It gets the
+ *    same contributed bindings the sync used, so a project whose source is
+ *    not its `bindings_v2.json` cannot have the two stages disagree.
  */
 export declare function prepareSolutionResources(solutionDir: string, fs: IFileSystem, options?: {
     gate?: boolean;

package/dist/services/project-contributions.d.ts

@@ -4,13 +4,11 @@ import { type ProjectContributionError, type ProjectResourceContribution } from
 export interface ProjectContributions {
     /** Per project key (the `.uipx` `Id`), what that project's factory returned. */
     byProject: Map<string, ProjectResourceContribution>;
-    /** Supported types whose registered factory has no `describeResourcesAsync`. */
-    skipped: string[];
 }
 export interface ApplyContributionsResult {
     /** Number of artefact resources whose spec was rewritten. */
     updated: number;
-    /** Patches that matched no resource, plus the collect-time skip notices. */
+    /** Patches that matched no resource, and entry points that could not be read. */
     warnings: string[];
 }
 /**
@@ -33,8 +31,11 @@ export declare class ProjectContributionsError extends Error {
  *
  * Reads project files only, which `syncAndLog` never touches, so collecting
  * before the sync and applying after it cannot see two different states.
+ *
+ * `onlyProjectId` restricts the walk to one `.uipx` project `Id` — the one a
+ * `pack --project` run packs.
  */
-export declare function collectProjectContributions(solutionDir: string, fs?: IFileSystem): Promise<ProjectContributions>;
+export declare function collectProjectContributions(solutionDir: string, fs?: IFileSystem, onlyProjectId?: string): Promise<ProjectContributions>;
 /** Throws once with every collected error. Pack's gate. */
 export declare function assertNoContributionErrors(contributions: ProjectContributions): void;
 /**

package/dist/services/search-failure.d.ts

@@ -1,5 +1,4 @@
 import { type CliErrorCode, type ErrorContext, type RetryHint } from "@uipath/common";
-import type { SolutionAuthContext } from "@uipath/solution-sdk/auth";
 /** Everything an envelope needs to report a failed Solution Search listing. */
 export interface SearchFailure {
     message: string;
@@ -9,19 +8,16 @@ export interface SearchFailure {
     context?: ErrorContext;
 }
 /**
- * Describe a failed Solution Search listing (`packages list`, `deploy list`).
+ * Describe a failed search listing (`packages list`, `deploy list`): the
+ * service's own message, with its HTTP status classified into `errorCode` /
+ * `retry`.
  *
- * The packages search accepts user tokens only, so it answers an external app
- * with a 401. The generic 401 text says the session is missing or expired,
- * which sends a client-credentials pipeline in a circle: logging in again
- * mints the same kind of token. For that session the failure names the cause
- * instead. The Pipelines deployment search `deploy list` reads accepts
- * application tokens, so it passes `userSessionsOnly: false`: there an app's
- * 401 is the session's own failure. Every other failure keeps the service's
- * own message, with its HTTP status classified into `errorCode` / `retry`.
+ * Both searches go to Pipelines routes that accept application tokens, so an
+ * app's 401 is the session's own failure. The deprecated user-only routes
+ * they fall back to are never asked for an app: the search clients throw
+ * `PackageSearchNeedsUserSessionError` / `DeploymentSearchNeedsUserSessionError`
+ * instead, which the callers report themselves.
  *
  * @param what the rows being listed, e.g. "packages"
  */
-export declare function describeSearchFailureAsync(error: unknown, what: string, session: Pick<SolutionAuthContext, "accessToken" | "identity">, { userSessionsOnly }: {
-    userSessionsOnly: boolean;
-}): Promise<SearchFailure>;
+export declare function describeSearchFailureAsync(error: unknown, what: string): Promise<SearchFailure>;

package/dist/services/solution-packager-helpers.d.ts

@@ -1,7 +1,10 @@
+import { type LoginStatus } from "@uipath/auth";
 import type { IFileSystem } from "@uipath/filesystem";
-import { type ISolutionPackager, type SolutionPackOptions } from "@uipath/solution-packager/node";
+import type { PackagerParameters } from "@uipath/project-packager";
+import { type ISolutionPackager } from "@uipath/solution-packager/node";
 import { LogLevel } from "@uipath/solutionpackager-tool-core";
 export declare function createSolutionPackager(): Promise<ISolutionPackager>;
 export declare function readSolutionFileAsUint8Array(fs: IFileSystem, filePath: string): Promise<Uint8Array>;
 export declare function resolveSdkLogLevel(): LogLevel;
-export declare function applyAuthConnection(options: SolutionPackOptions, loginValidity?: number): Promise<void>;
+/** Sets the session's connection on the options, and returns the session. */
+export declare function applyAuthConnection(options: PackagerParameters, loginValidity?: number): Promise<LoginStatus>;

package/dist/services/solution-path.d.ts

@@ -1,7 +1,7 @@
 import { type CliErrorCode } from "@uipath/common";
 import type { FileSystemStats, IFileSystem } from "@uipath/filesystem";
 /**
- * Next-step hint for a bad `<solutionPath>`. Restore, pack and cleanup accept
+ * Next-step hint for a bad `<solution-path>`. Restore, pack and cleanup accept
  * exactly the same two shapes, so they give the same advice.
  */
 export declare const SOLUTION_PATH_INSTRUCTIONS = "Ensure the solution path exists and points to a solution directory (containing .uipx) or a .uis file.";

package/dist/services/uninstall-consent.d.ts

@@ -0,0 +1,82 @@
+import type { DeploymentValidationErrorDto, PipelineDeploymentValidationResult, PipelinesApi } from "@uipath/pipelines-sdk";
+/** Orchestrator's `JobsNotInFinalState`: the folder still has unfinished jobs. */
+export declare const JOBS_NOT_IN_FINAL_STATE_CODE = "2824";
+/**
+ * The uninstall route's synchronous refusal (HTTP 409): the deployment holds
+ * an Uninstall validation with unacknowledged `RequiresConfirmation` warnings.
+ */
+export declare const UNINSTALL_CONFIRMATION_REQUIRED_CODE = "4026";
+/**
+ * - `blocked`: at least one row fails the validation and `--force` cannot get
+ *   past it.
+ * - `force-required`: nothing blocks, and at least one row is a refusal
+ *   `--force` gets past.
+ * - `clear`: nothing to force.
+ */
+export type UninstallValidationOutcome = "force-required" | "blocked" | "clear";
+/** A resource the uninstall deletes for good (it was replaced by a link). */
+export interface PermanentDeletionResource {
+    key?: string;
+    kind?: string;
+    name?: string;
+}
+export interface UninstallConsentFacts {
+    jobsNotInFinalState: boolean;
+    /** A `RequiresConfirmation` row of any level: the uninstall deletes for good. */
+    requiresConfirmation: boolean;
+    /** The printable subset: the warning-level confirmation rows, one per key. */
+    permanentDeletionResources: PermanentDeletionResource[];
+}
+export interface UninstallValidationClassification extends UninstallConsentFacts {
+    outcome: UninstallValidationOutcome;
+}
+/**
+ * The facts a set of validation rows establishes. The causes come from the
+ * rows themselves: a confirmation row that is not printable (not warning
+ * level) still names permanent deletion, only without the list.
+ */
+export declare function uninstallConsentFacts(rows: readonly DeploymentValidationErrorDto[]): UninstallConsentFacts;
+/**
+ * The resources a forced uninstall deletes permanently: the confirmation
+ * warnings, one entry per resource.
+ */
+export declare function selectPermanentDeletionResources(rows: readonly DeploymentValidationErrorDto[]): PermanentDeletionResource[];
+/**
+ * The rows `--force` cannot get past, one clause each: `[code] text`, led by
+ * the resource (`kind 'name'`) when the row names one.
+ */
+export declare function describeBlockingRows(rows: readonly DeploymentValidationErrorDto[]): string;
+/**
+ * Classify a persisted Uninstall validation row by row. The result's
+ * `success` decides nothing: the SDK may omit it, and an omitted verdict must
+ * not turn a blocking row into a `--force` recommendation.
+ */
+export declare function classifyUninstallValidation(result: Pick<PipelineDeploymentValidationResult, "validationErrors">): UninstallValidationClassification;
+/**
+ * The deployment's persisted Uninstall validation, or `undefined` when it
+ * cannot be had: a server without the route (404), a validation still
+ * running (409), any other failure, or a result for another action.
+ *
+ * The route reads the name's newest record and names no key, so the answer
+ * is kept only while `deploymentKey` (the record the uninstall acted on) is
+ * still that newest record. No key, a superseded or unknown key, or a failed
+ * lookup: the validation may describe another generation, so it is unread.
+ */
+export declare function readUninstallValidationAsync(api: PipelinesApi, deploymentName: string, deploymentKey: string | null | undefined, scope?: Parameters<PipelinesApi["pipelinesGetDeploymentValidationResult"]>[1]): Promise<PipelineDeploymentValidationResult | undefined>;
+/**
+ * Whether a failed run's service errors carry the jobs refusal. The lines are
+ * `formatServiceErrors` output: the `[2824]` comes from a service's
+ * JSON-encoded `errorMessage`, since `serviceErrorMessages` is text-only.
+ */
+export declare function servicesReportJobsNotInFinalState(serviceLines: readonly string[]): boolean;
+/** `kind 'name'`, falling back to the key. */
+export declare function formatPermanentDeletionResource(resource: PermanentDeletionResource): string;
+/** The sentence naming what permanent deletion takes, with the list when known. */
+export declare function describePermanentDeletion(resources: readonly PermanentDeletionResource[]): string;
+/** The force-able causes, joined into one clause. */
+export declare function describeForceableCauses(facts: UninstallConsentFacts): string;
+/** The structured facts for the failure's `Data`, PascalCased as printed. */
+export declare function consentData(facts: UninstallConsentFacts, extra: {
+    deploymentName: string;
+    instanceId?: string | null;
+}): Record<string, unknown>;

package/dist/ship-telemetry-myes7ak5.js

@@ -0,0 +1,21 @@
+import {
+  inspectSolutionPackageProjectTypes,
+  normalizeShipProjectType,
+  summarizeShipProjectTypes,
+  trackSolutionShipSucceeded,
+  unzipProjectManifests
+} from "./packager-tool-amhyxzz6.js";
+import"./packager-tool-tx834spe.js";
+import"./packager-tool-6ybywxxn.js";
+import"./packager-tool-v1f5e8t9.js";
+import"./packager-tool-dfrk01gn.js";
+import"./packager-tool-1de529jm.js";
+export {
+  inspectSolutionPackageProjectTypes,
+  normalizeShipProjectType,
+  summarizeShipProjectTypes,
+  trackSolutionShipSucceeded,
+  unzipProjectManifests
+};
+
+//# debugId=82CFC21EA48BFC2364756E2164756E21

package/dist/solution-auth-aead70sw.js

@@ -0,0 +1,11 @@
+import {
+  getSolutionAuthContext
+} from "./packager-tool-61pwb567.js";
+import"./packager-tool-43ahv5mn.js";
+import"./packager-tool-v1f5e8t9.js";
+import"./packager-tool-1de529jm.js";
+export {
+  getSolutionAuthContext
+};
+
+//# debugId=4D0CD43FE95C1EC164756E2164756E21