@uipath/solution-tool 1.1.0 → 1.196.0

package/dist/services/activation.d.ts

@@ -0,0 +1,51 @@
+import { type PollUntilResult } from "@uipath/common";
+import type { DeploymentStatus } from "@uipath/pipelines-sdk";
+import type { DeploymentSearchItemDto2 } from "@uipath/solution-sdk";
+import type { SolutionAuthContext } from "./auth-helper";
+export type ActivationOptions = {
+    timeoutSeconds: number;
+    pollIntervalMs: number;
+    /** Host-side cancellation. Falls back to `processContext.pollSignal` (CLI's Ctrl-C) when omitted. */
+    signal?: AbortSignal;
+};
+export type ActivationResult = 
+/** Pre-activate steps lookup or activate call failed. */
+{
+    kind: "RequestFailed";
+    phase: "preActivateSteps" | "activate";
+    message: string;
+    details: string;
+    deployment?: DeploymentSearchItemDto2;
+}
+/** Activation API returned no instance id — completed without polling. */
+ | {
+    kind: "NoInstance";
+}
+/** Polling did not complete (timeout/failed/interrupted/aborted). */
+ | {
+    kind: "PollFailed";
+    poll: PollUntilResult<unknown>;
+}
+/** Polled to a terminal non-success status. */
+ | {
+    kind: "ActivationFailed";
+    status: DeploymentStatus;
+    instanceId: string;
+    errorMessage: string;
+}
+/** Activation succeeded. */
+ | {
+    kind: "Success";
+    status: DeploymentStatus;
+    instanceId: string;
+};
+/**
+ * Run the full activation flow for a deployment:
+ * preActivateSteps lookup -> pipelinesActivate -> poll instance status.
+ *
+ * Returns a discriminated result so callers can decide how to render output
+ * (the standalone `activate` command emits its own success/error payload;
+ * `deploy run --activate` merges activation info into the deploy success
+ * payload).
+ */
+export declare function activateDeployment(auth: SolutionAuthContext, deploymentName: string, options: ActivationOptions): Promise<ActivationResult>;

package/dist/services/auth-helper.d.ts

@@ -0,0 +1,13 @@
+export interface SolutionAuthContext {
+    accessToken: string;
+    basePath: string;
+    organizationId: string;
+    tenantName: string;
+}
+export declare function getSolutionAuthContext(options: {
+    tenant?: string;
+    loginValidity?: number;
+    /** Pin auth to this exact `.uipath/.auth` path (forwarded to
+     *  `getAuthContext`) instead of resolving from `process.cwd()`. */
+    envFilePath?: string;
+}): Promise<SolutionAuthContext>;

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

@@ -0,0 +1,47 @@
+export type ActivateDeploymentFailureReason = "auth_failed"
+/** 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 {
+    /**
+     * Override the active tenant for auth resolution. The CLI's deprecated
+     * `--tenant` flag flows through here; library callers usually omit it.
+     */
+    tenant?: string;
+    /** Pin auth to this exact `.uipath/.auth` path. */
+    envFilePath?: string;
+    /** Timeout in seconds for activation polling. Default 360. */
+    timeout?: number;
+    /** Milliseconds between activation status polls. Default 5000. */
+    pollInterval?: number;
+    /** Minimum minutes before token expiration to trigger a refresh. Default 10. */
+    loginValidity?: number;
+    /** Host-side cancellation for the activation poll. */
+    signal?: AbortSignal;
+}
+export interface ActivateDeploymentSuccess {
+    ok: true;
+    /** `"SuccessfulActivate"` for terminal success, or `"Activation completed (no instance to poll)"` for the NoInstance short-circuit. */
+    status: string;
+    deploymentName: string;
+    /** Allows `null` so `"InstanceId": null` reaches JSON output when the SDK reports null. */
+    instanceId?: string | null;
+}
+export interface ActivateDeploymentFailure {
+    ok: false;
+    reason: ActivateDeploymentFailureReason;
+    message: string;
+    instructions: string;
+    exitCode: number;
+}
+export type ActivateDeploymentResult = ActivateDeploymentSuccess | ActivateDeploymentFailure;
+/**
+ * Programmatic core of `uip solution deploy activate`. Wraps the shared
+ * `activateDeployment(...)` helper and maps its 5 outcomes (RequestFailed,
+ * NoInstance, PollFailed, ActivationFailed, Success) to {@link ActivateDeploymentResult}.
+ * Does not touch `OutputFormatter`/`processContext`.
+ */
+export declare function activateDeploymentAsync(deploymentName: string, options?: ActivateDeploymentOptions): Promise<ActivateDeploymentResult>;

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

@@ -0,0 +1,59 @@
+/**
+ * Per-deployment row in {@link ListDeploymentsSuccess.deployments}. Mirrors
+ * the 10 SDK fields the CLI emits; string-enums widened to `string` so the
+ * published `.d.ts` stays off the SDK's const-enum types.
+ */
+export interface DeploymentSummary {
+    key: string;
+    installDeploymentKey: string;
+    name: string;
+    packageName: string;
+    packageVersion: string;
+    operationStatus: string;
+    activationStatus: string;
+    folderPath?: string | null;
+    installedRootFolderKey?: string | null;
+    deploymentCreationTime: Date;
+}
+export type ListDeploymentsFailureReason = "auth_failed" | "folder_resolution_failed" | "list_request_failed";
+/** Local mirror of solution-sdk's `OrderByDirection`; declared here so the `.d.ts` stays off the SDK type. */
+export type SortDirection = "Ascending" | "Descending";
+export interface ListDeploymentsOptions {
+    /** Override the active tenant for auth + folder-lookup. The CLI's deprecated `--tenant` flag flows through here. */
+    tenant?: string;
+    /** Pin auth (+ folder lookup) to this exact `.uipath/.auth` path. */
+    envFilePath?: string;
+    /** Filter by parent folder path (e.g., `"Shared"`). Post-fetch substring match. */
+    folderPath?: string;
+    /** Filter by parent folder key (GUID). Alternative to {@link folderPath}. */
+    folderKey?: string;
+    /** Max deployments to fetch. Default `DEFAULT_PAGE_SIZE`. */
+    limit?: number;
+    /** Column to sort by. Default `"startTime"`. */
+    sortBy?: string;
+    /** Sort direction. Default `"Descending"`. */
+    sortOrder?: SortDirection;
+    /** Minimum minutes before token expiration to trigger a refresh. Default 10. */
+    loginValidity?: number;
+}
+export interface ListDeploymentsSuccess {
+    ok: true;
+    deployments: DeploymentSummary[];
+    /** Echo of the request limit so callers can render pagination UI without re-deriving. */
+    limit: number;
+}
+export interface ListDeploymentsFailure {
+    ok: false;
+    reason: ListDeploymentsFailureReason;
+    message: string;
+    instructions: string;
+    exitCode: number;
+}
+export type ListDeploymentsResult = ListDeploymentsSuccess | ListDeploymentsFailure;
+/**
+ * Programmatic core of `uip solution deploy list`. Returns a tagged
+ * {@link ListDeploymentsResult}; does not touch `OutputFormatter`/`processContext`.
+ * Folder filtering is post-fetch (search API has no folder filter), so
+ * `deployments.length` may be less than `limit`.
+ */
+export declare function listDeploymentsAsync(options?: ListDeploymentsOptions): Promise<ListDeploymentsResult>;

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

@@ -0,0 +1,102 @@
+/** Discriminator for {@link DeployFailure}; library callers can ignore the tag and read `.message`/`.instructions`. */
+export type DeployFailureReason = "auth_failed" | "folder_resolution_failed" | "config_file_not_found" | "config_file_read_failed" | "config_file_parse_failed" | "install_request_failed"
+/** Personal Workspace deploy via AS auto-deploy failed (publish first, then retry). */
+ | "personal_workspace_deploy_failed"
+/** Recovery: deployment completed but flagged "Needs Setup" — manual config required before activation. */
+ | "needs_setup_to_activate"
+/** Recovery: deployment completed, ready to activate — auto-activation didn't run. */
+ | "ready_to_activate"
+/** Recovery: deployment completed but activation failed (terminal). */
+ | "activation_failed_post_deploy"
+/** Recovery or final-status: the deploy itself failed (e.g. ValidationFailed). */
+ | "deploy_failed"
+/** Poll completed with `outcome === Completed` but `data` is undefined (defensive). */
+ | "no_final_status"
+/** Poll loop didn't complete cleanly AND the search service had no recovery to surface. */
+ | "poll_timeout" | "poll_failed" | "poll_aborted"
+/** Activation HTTP request failed (post-deploy path). */
+ | "activation_request_failed"
+/** Activation poll didn't reach a terminal state. */
+ | "activation_poll_failed"
+/** Activation reached a terminal state but it was a failure. */
+ | "activation_failed";
+export interface DeployOptions {
+    /** Override the active tenant for auth + folder-lookup. The CLI's deprecated `--tenant` flag flows through here. */
+    tenant?: string;
+    /** Pin auth (+ folder lookup) to this exact `.uipath/.auth` path. */
+    envFilePath?: string;
+    /** Name for the deployment (`uip solution deploy run -n`). */
+    deploymentName: string;
+    /** Package name to deploy. */
+    packageName: string;
+    /** Package version (semver) to deploy. */
+    packageVersion: string;
+    /** Name of the new Orchestrator folder created for this deployment. */
+    folderName: string;
+    /** Mutually exclusive with `parentFolderKey` and `personalWorkspace`. */
+    parentFolderPath?: string;
+    /** Mutually exclusive with `parentFolderPath` and `personalWorkspace`. */
+    parentFolderKey?: string;
+    /** Deploy into the user's Personal Workspace; resolves the workspace name automatically. */
+    personalWorkspace?: boolean;
+    /** Path to a JSON / YAML configuration file. */
+    configFile?: string;
+    /** Per-poll-phase timeout in seconds (deploy and, when not skipped, activate). Default 360. */
+    timeout?: number;
+    /** Milliseconds between polls. Default 5000. */
+    pollInterval?: number;
+    /** Minimum minutes before token expiration to trigger a refresh. Default 10. */
+    loginValidity?: number;
+    /** Skip auto-activation; leave deployment in "Inactive (Ready to activate)" state. */
+    skipActivate?: boolean;
+    /** Host-side cancellation for both poll loops (e.g. VS Code's cancel button); replaces `processContext.pollSignal`. */
+    signal?: AbortSignal;
+}
+export interface DeploySuccess {
+    ok: true;
+    /**
+     * Tenant path: `"DeploymentSucceeded"` after polling reaches terminal.
+     * PW path: `"DeploymentStarted"` — the AS auto-deploy endpoint returns
+     * at request acceptance, before terminal state is observable.
+     */
+    status: string;
+    /** Tenant only — populated from Pipelines install result. PW returns no key. */
+    deploymentKey?: string | null;
+    /** Tenant only — Pipelines deployment id. Undefined for PW (no Pipelines call). */
+    pipelineDeploymentId?: string;
+    /** Allows `null` so `"InstanceId": null` reaches JSON output when the SDK reports null. */
+    instanceId?: string | null;
+    folderName: string;
+    folderPath: string;
+    /** "SuccessfulActivate" | "Skipped" | "NoInstance" — short canonical token. PW path emits `"Auto"`. */
+    activationStatus: string;
+    /** PW only — server-assigned auto-name (`AutoDeploy-<solution>`). */
+    deploymentName?: string;
+    /** PW only — package name as deployed. */
+    packageName?: string;
+    /** PW only — package version as deployed. */
+    packageVersion?: string;
+    /** PW only — future-tense human guidance ("Check status with..."). */
+    nextSteps?: string;
+}
+export interface DeployFailure {
+    ok: false;
+    reason: DeployFailureReason;
+    /** OutputFormatter.error Message: short summary. */
+    message: string;
+    /** OutputFormatter.error Instructions: remediation guidance. */
+    instructions: string;
+    /** Recommended exit code (1 default; 2 reserved for `poll_timeout` — CI distinguishability). */
+    exitCode: number;
+    /** Set whenever an install was initiated (post-`pipelinesInstall` paths). */
+    pipelineDeploymentId?: string;
+}
+export type DeployResult = DeploySuccess | DeployFailure;
+/**
+ * Programmatic core of `uip solution deploy run`: auth → folder → optional
+ * config file → install → poll (with 404 → search-service fallback) →
+ * optional auto-activate. Returns a tagged {@link DeployResult}; re-throws
+ * only on unexpected SDK errors. Threads `options.signal` through both polls.
+ * Does not touch `OutputFormatter`/`processContext`.
+ */
+export declare function deployRunAsync(options: DeployOptions): Promise<DeployResult>;

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

@@ -0,0 +1,47 @@
+export type UninstallDeploymentFailureReason = "auth_failed" | "uninstall_request_failed"
+/** 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 {
+    /**
+     * Override the active tenant for auth resolution. The CLI's deprecated
+     * `--tenant` flag flows through here; library callers usually omit it.
+     */
+    tenant?: string;
+    /** Pin auth to this exact `.uipath/.auth` path. */
+    envFilePath?: string;
+    /** Timeout in seconds for uninstall polling. Default 360. */
+    timeout?: number;
+    /** Milliseconds between uninstall status polls. Default 5000. */
+    pollInterval?: number;
+    /** Minimum minutes before token expiration to trigger a refresh. Default 10. */
+    loginValidity?: number;
+    /** Host-side cancellation for the poll loop; replaces `processContext.pollSignal`. */
+    signal?: AbortSignal;
+}
+export interface UninstallDeploymentSuccess {
+    ok: true;
+    /** `"SuccessfulUninstall"`, `"Uninstall completed immediately"`, or `"Uninstall scheduled"`. */
+    status: string;
+    deploymentName: string;
+    /** Polled instance id when present; preserves the SDK nullable so `"InstanceId": null` reaches JSON output. */
+    instanceId?: string | null;
+    /** Set only on the "scheduled" branch — surfaces `Scheduled` in JSON output. */
+    scheduled?: unknown;
+}
+export interface UninstallDeploymentFailure {
+    ok: false;
+    reason: UninstallDeploymentFailureReason;
+    message: string;
+    instructions: string;
+    exitCode: number;
+}
+export type UninstallDeploymentResult = UninstallDeploymentSuccess | UninstallDeploymentFailure;
+/**
+ * Programmatic core of `uip solution deploy uninstall`: three success shapes
+ * (immediate-complete / scheduled / polled-to-`SuccessfulUninstall`) and the
+ * usual failure taxonomy. `poll_timeout` → exit 2. Does not touch
+ * `OutputFormatter`/`processContext`.
+ */
+export declare function uninstallDeploymentAsync(deploymentName: string, options?: UninstallDeploymentOptions): Promise<UninstallDeploymentResult>;

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

@@ -0,0 +1,77 @@
+import type { PipelineDeploymentResult, PipelineDeploymentStatus } from "@uipath/pipelines-sdk";
+import type { DeploymentOperationStatus, DeploymentSearchItemDto2 } from "@uipath/solution-sdk";
+import type { SolutionAuthContext } from "./auth-helper";
+/**
+ * Look up a deployment by name in the persistent search/list service.
+ * Returns the matching record, or undefined when no deployment with that
+ * exact name exists.
+ *
+ * Throws on transport / server errors. Use {@link findDeploymentForError}
+ * when you want a best-effort lookup that swallows failures.
+ */
+export declare function findDeploymentByName(auth: SolutionAuthContext, deploymentName: string): Promise<DeploymentSearchItemDto2 | undefined>;
+/**
+ * Best-effort lookup for use in error-handling paths — returns undefined on
+ * any failure instead of propagating, so it never masks the original error.
+ */
+export declare function findDeploymentForError(auth: SolutionAuthContext, deploymentName: string): Promise<DeploymentSearchItemDto2 | undefined>;
+/**
+ * Append a hint to error instructions when the deployment in question is
+ * stuck in `Draft` state — that condition has a specific remediation that
+ * generic instructions don't cover.
+ */
+export declare function appendDraftDeploymentInstructions(instructions: string, deployment?: DeploymentSearchItemDto2): string;
+/**
+ * The pipelines service `pipelinesGetPipelineDeploymentStatus` endpoint
+ * returns 404 with errorCode `PipelineDeploymentNotFound` once a deployment
+ * reaches a terminal state — the in-flight tracking record is recycled and
+ * final state lives in the search/list service instead.
+ *
+ * This helper detects that specific signal so callers can fall back to
+ * {@link findDeploymentByName} for the persistent record instead of treating
+ * the 404 as a fatal poll error.
+ */
+export declare function isPipelineDeploymentNotFoundError(error: unknown): Promise<boolean>;
+/**
+ * When the deploy poll exhausts consecutive errors, the deployment may still
+ * have reached a terminal state on the server — the search service is the
+ * source of truth. Turn the search record into a verdict the caller can use
+ * to render a specific message instead of the generic "polling failed" line.
+ *
+ * `undefined` means the record is missing or in a non-terminal/unknown state,
+ * and the caller should fall through to the generic poll-failure path.
+ */
+export type DeployPollRecovery = {
+    kind: "Active";
+    instanceId: string | null | undefined;
+} | {
+    kind: "NeedsSetupToActivate";
+} | {
+    kind: "ReadyToActivate";
+} | {
+    kind: "ActivationFailed";
+} | {
+    kind: "DeployFailed";
+    operationStatus: DeploymentOperationStatus;
+};
+export declare function interpretFailedDeployPoll(deployment: DeploymentSearchItemDto2 | undefined): DeployPollRecovery | undefined;
+/**
+ * Map a search-service `DeploymentOperationStatus` onto the corresponding
+ * terminal `PipelineDeploymentStatus`. Returns undefined for non-terminal
+ * states (caller should keep polling).
+ */
+export declare function mapOperationStatusToPipelineStatus(operationStatus: DeploymentOperationStatus | undefined | null): PipelineDeploymentStatus | undefined;
+/**
+ * Build a synthesized terminal `PipelineDeploymentResult` from a deployment
+ * record fetched via the search API. Used as a fallback when the pipelines
+ * service has already cleaned up its in-flight record (404).
+ *
+ * Returns undefined when the deployment is in a non-terminal state — caller
+ * should keep polling the original endpoint.
+ *
+ * The synthesized result only has the fields the search record exposes;
+ * validation/error details from the pipelines service are not available.
+ * Callers should treat fallback failures as a generic "Deployment failed"
+ * and direct users to `solution deploy list` for richer state.
+ */
+export declare function deploymentToTerminalPipelineResult(deployment: DeploymentSearchItemDto2): PipelineDeploymentResult | undefined;

package/dist/services/emit-runtime-dependencies.d.ts

@@ -0,0 +1,37 @@
+export interface EmitRuntimeDependenciesResult {
+    processed: number;
+    warnings: string[];
+}
+/**
+ * Pack-time mirror of Orchestrator BE's
+ * `ProcessesExportHandlerBase.GetRuntimeDependenciesAsync`. For each process
+ * resource that originates from a `.uipx` project (signalled by a non-empty
+ * `projectKey`), build a `runtimeDependencies` list from the project's
+ * `bindings_v2.json`, enriching each entry with the matching solution
+ * resource's key/name. Without this Orchestrator's `RuntimeDependencyService`
+ * has no per-process binding context at deploy time and falls back to lossy
+ * heuristics.
+ *
+ * Per Gabriel Raducu's spec the entries are entirely solution-side:
+ *   resourceKey  ← solution resource key (= debug_overwrites.solutionResourceKey)
+ *   resourceName ← solution resource name (post-AddOrUpdate)
+ *   folderKey    ← `solution_folder.key` (deterministic
+ *                  `GuidGenerator.From("solution_folder")`, generated by
+ *                  Automation Solutions on import; mirrored here so the
+ *                  pack output is stable without a server round-trip).
+ *
+ * Emits one entry per declared binding only — no transitive dependency
+ * walking. The C# producer has the same contract (1 binding ⇒ 1 runtime
+ * dep). Resources that are dependencies of a binding (e.g. an index's
+ * storage bucket) are handled by Orchestrator's deploy pipeline through
+ * the resource graph, not via the parent process's runtimeDependencies.
+ *
+ * Round-trips through `builder.context.saveAsync(solution)`. The SDK's
+ * `ResourceDefinition.isOverridable` field is currently optional in TS but
+ * non-nullable with default `true` in C# (see SOL-7012) — `saveAsync` strips
+ * it when undefined, which Studio Web reads to decide whether bindings can
+ * be linked. We defensively force `isOverridable = true` on every resource
+ * that doesn't have it set before save; that workaround can come out once
+ * SOL-7012 lands (cleanup tracked under SOL-7013).
+ */
+export declare function emitRuntimeDependenciesForProcesses(solutionDir: string): Promise<EmitRuntimeDependenciesResult>;

package/dist/services/entry-point-spec-enhancer.d.ts

@@ -0,0 +1,31 @@
+import { type IFileSystem } from "@uipath/filesystem";
+import type { IArtifactResourceSpecEnhancer, ISolutionContext, ResourceDefinition, ResourcePropertyMetadata } from "@uipath/resource-builder-sdk";
+/**
+ * Reads the project's `entry-points.json` at GET time and projects the primary
+ * entry points onto the resource spec, so consumers see the current on-disk
+ * state — not the snapshot captured at `solution project add`.
+ *
+ * Mirrors the shape Studio Web returns from its process configuration
+ * endpoint: `entryPoints` always carries the raw `entry-points.json` text;
+ * `entryPointName` / `entryPointUniqueId` are populated only when the project
+ * has exactly one entry, and are explicit `null` for multi-entry or empty
+ * projects.
+ *
+ * Read-only by design: never mutates the on-disk resource JSON. Spec
+ * degradation (missing/malformed file) is swallowed so `resource get` stays
+ * functional.
+ */
+export declare class EntryPointSpecEnhancer implements IArtifactResourceSpecEnhancer {
+    private readonly fs;
+    constructor(fs?: IFileSystem);
+    enhanceSpecAsync(context: ISolutionContext, resource: ResourceDefinition, _propertiesMetadata: Map<string, ResourcePropertyMetadata>, spec: Map<string, unknown>, _cancellationToken?: AbortSignal): Promise<void>;
+    private applyEntryPointAsync;
+    private findSolutionFileAsync;
+}
+/**
+ * Applies `EntryPointSpecEnhancer` against a plain-object spec returned by the
+ * SDK's `getConfigurationAsync` path. Used by `resource get` until the SDK
+ * invokes `enhanceSpecAsync` itself from `GetMappedResourceConfigurationRequestHandler`;
+ * once that lands this becomes a redundant no-op for the same on-disk state.
+ */
+export declare function applyEntryPointEnhancementAsync(context: ISolutionContext, resource: ResourceDefinition, spec: Record<string, unknown>): Promise<Record<string, unknown>>;

package/dist/services/folder-helper.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Resolve parent folder from --parent-folder-path, --parent-folder-key, or
+ * --personal-workspace options.
+ *
+ * Returns the fully qualified folder path string the deploy endpoint expects
+ * as `folderFullyQualifiedName`, or undefined if none of the three options
+ * was provided.
+ *
+ * Mutual exclusivity is enforced at parse time by Commander via
+ * `Option#conflicts()` in the calling command — see `deploy-run.ts`.
+ * Personal Workspace is resolved via Orchestrator's `GetPersonalWorkspace`
+ * endpoint using the current auth context — see
+ * {@link resolvePersonalWorkspace} for the contract.
+ */
+export declare function resolveParentFolder(options: {
+    folderPath?: string;
+    folderKey?: string;
+    personalWorkspace?: boolean;
+    tenant?: string;
+    loginValidity?: number;
+    /** Pin folder-lookup auth to this exact `.uipath/.auth` path, forwarded to
+     *  `resolvePersonalWorkspace`/`resolveFolder` so it matches the deploy auth. */
+    envFilePath?: string;
+}): Promise<string | undefined>;

package/dist/services/pack-command-service.d.ts

@@ -0,0 +1,24 @@
+import { type CommandContext } from "@uipath/common";
+import { ToolResult } from "@uipath/solutionpackager-tool-core";
+import type { PackCommandOptions } from "../models";
+/**
+ * Service for packing UiPath solutions from folders or .uis files
+ */
+export declare class PackCommandService {
+    private packager;
+    private readonly fs;
+    constructor();
+    /**
+     * Execute the pack command with formatted CLI output and process exit handling.
+     * When `options.dryRun` is true, the pipeline writes to a temporary directory
+     * which is discarded on exit — useful as a pre-deploy validation gate.
+     */
+    execute(solutionPath: string, options: PackCommandOptions, context: CommandContext): Promise<void>;
+    /**
+     * Execute the pack command and return result (for programmatic usage and testing)
+     */
+    executeAsync(solutionPath: string, options: PackCommandOptions): Promise<ToolResult>;
+    private ensurePackagerAsync;
+    private readFileAsUint8Array;
+    private createPackOptions;
+}

package/dist/services/pack-service.d.ts

@@ -0,0 +1,32 @@
+import "@uipath/packager-tool-apiworkflow";
+import "@uipath/packager-tool-bpmn";
+import "@uipath/packager-tool-case";
+import "@uipath/packager-tool-connector";
+import "@uipath/packager-tool-flow";
+import "@uipath/packager-tool-functions";
+import "@uipath/packager-tool-webapp";
+import "@uipath/packager-tool-workflowcompiler";
+import "@uipath/resource-builder-tool";
+import "@uipath/tool-agent";
+import type { PackCommandOptions } from "../models/pack-command-types";
+export type { PackCommandOptions };
+/**
+ * Inlined mirror of solutionpackager-tool-core's `ToolResult`, kept local so
+ * the published `pack.d.ts` stays free of the private SDK type.
+ */
+export interface PackResult {
+    /** True iff `errorCode === "SUCCESS"`. */
+    ok: boolean;
+    /** Packager error code; `"SUCCESS"`, `"INTERNAL_ERROR"`, `"CANCELED"`, or a tool-specific code. */
+    errorCode: string;
+    /** Human-readable message; populated on failure. */
+    message: string;
+    /** Absolute paths to the produced `.zip` package(s). */
+    packages: string[];
+}
+/**
+ * Programmatic core of `uip solution pack`: packs a UiPath solution into a
+ * deployable `.zip`. Returns `{ ok: false, … }` on pack failure (does not
+ * throw); only propagates unexpected JS errors.
+ */
+export declare function packSolutionAsync(solutionPath: string, options: PackCommandOptions): Promise<PackResult>;

package/dist/services/packager-tool-resolver.d.ts

@@ -0,0 +1,6 @@
+import type { IFileSystem } from "@uipath/filesystem";
+/**
+ * Reads project types from the .uipx, checks toolsFactoryRepository for
+ * unhandled types, and installs the corresponding CLI tools.
+ */
+export declare function ensurePackagerTools(solutionDir: string, fs: IFileSystem): Promise<void>;

package/dist/services/packages-list-service.d.ts

@@ -0,0 +1,56 @@
+import type { SortDirection } from "./deploy-list-service";
+/**
+ * Per-package row in {@link ListPackagesSuccess.packages}. Mirrors solution-sdk's
+ * `PackageInfo` field-for-field; `state` widened to `string` so the published
+ * `.d.ts` stays off the SDK's const-enum.
+ */
+export interface PackageSummary {
+    key: string;
+    name: string;
+    latestVersion: string;
+    packageVersionKey: string;
+    authorName: string;
+    authorEmail?: string | null;
+    publishDate: Date;
+    description?: string | null;
+    releaseNotes?: string | null;
+    state: string;
+    solutionRootFolderName: string;
+    hasUpgradeableDeployments: boolean;
+}
+export type ListPackagesFailureReason = "auth_failed" | "list_request_failed";
+export interface ListPackagesOptions {
+    /** Override the active tenant for auth. The CLI's deprecated `--tenant` flag flows through here. */
+    tenant?: string;
+    /** Pin auth to this exact `.uipath/.auth` path. */
+    envFilePath?: string;
+    /** Max packages to fetch. Default `DEFAULT_PAGE_SIZE`. */
+    limit?: number;
+    /** Column to sort by. Default `"publishDate"`. */
+    sortBy?: string;
+    /** Sort direction. Default `"Descending"`. */
+    sortOrder?: SortDirection;
+    /** Server-side substring match against the package name. */
+    name?: string;
+    /** Minimum minutes before token expiration to trigger a refresh. Default 10. */
+    loginValidity?: number;
+}
+export interface ListPackagesSuccess {
+    ok: true;
+    packages: PackageSummary[];
+    /** Echo of the request limit so callers can render pagination UI without re-deriving. */
+    limit: number;
+}
+export interface ListPackagesFailure {
+    ok: false;
+    reason: ListPackagesFailureReason;
+    message: string;
+    instructions: string;
+    exitCode: number;
+}
+export type ListPackagesResult = ListPackagesSuccess | ListPackagesFailure;
+/**
+ * Programmatic core of `uip solution packages list`. Returns a tagged
+ * {@link ListPackagesResult}; does not touch `OutputFormatter`/`processContext`.
+ */
+export declare function listPackagesAsync(options?: ListPackagesOptions): Promise<ListPackagesResult>;

package/dist/services/personal-workspace-deploy.d.ts

@@ -0,0 +1,28 @@
+import type { SolutionAuthContext } from "./auth-helper";
+export interface PersonalWorkspaceDeployResult {
+    deploymentName: string;
+    packageName: string;
+    packageVersion: string;
+    folderFQN: string;
+}
+/**
+ * Deploy a Personal-Workspace-feed solution package via the Automation
+ * Solutions auto-deploy endpoint.
+ *
+ * The tenant `deploy run` path (Pipelines `deploy-from-package`) resolves the
+ * package from the tenant feed and cannot see a PW-feed package. This path
+ * uses the feed-aware `POST /api/deployments/deploy` endpoint instead:
+ *  - the PW folder key scopes both the package lookup and the deploy (header
+ *    `X-UIPATH-FolderKey`);
+ *  - `overwrites: []` lets the server apply the package's default resource
+ *    configuration (no caller-side overwrite computation);
+ *  - the endpoint auto-names the deployment `AutoDeploy-<solution>` and
+ *    auto-activates — matching Studio Web's PW autoDeploy behavior.
+ */
+export declare function deployToPersonalWorkspace(auth: SolutionAuthContext, params: {
+    packageName: string;
+    packageVersion: string;
+}, options?: {
+    tenant?: string;
+    loginValidity?: number;
+}): Promise<PersonalWorkspaceDeployResult>;