@uipath/solution-tool 1.0.4 → 1.195.0

package/dist/services/resource-refresh-service.d.ts

@@ -0,0 +1,32 @@
+/** Discriminator for {@link ResourceRefreshFailure}; library callers can ignore the tag and read `.message` / `.ok`. */
+export type ResourceRefreshFailureReason = "solution_not_found" | "not_a_solution" | "auth_failed" | "sync_failed";
+export interface ResourceRefreshOptions {
+    /** Minimum minutes before token expiration to trigger a refresh. Default `10` (matches the CLI's `--login-validity`). */
+    loginValidity?: number;
+}
+export interface ResourceRefreshSuccess {
+    ok: true;
+    /** Resources newly created (virtualized) in the solution this run. */
+    created: number;
+    /** Resources imported from Orchestrator into the solution this run. */
+    imported: number;
+    /** Bindings whose cloud key was already in the solution (no-op this run). */
+    skipped: number;
+    /** Non-fatal advisories (e.g. unresolved connections, link-before-deploy hints). */
+    warnings: string[];
+}
+export interface ResourceRefreshFailure {
+    ok: false;
+    reason: ResourceRefreshFailureReason;
+    /** Human-readable summary suitable for top-level surfacing. */
+    message: string;
+}
+export type ResourceRefreshResult = ResourceRefreshSuccess | ResourceRefreshFailure;
+/**
+ * Programmatic core of `uip solution resource refresh`: re-scans every project's
+ * `bindings_v2.json` and syncs resource declarations into the solution, importing
+ * from Orchestrator when a match exists and virtualizing the rest. Returns a tagged
+ * {@link ResourceRefreshResult}; re-throws only on unexpected errors. Mirrors
+ * `./pack` / `./publish` / `./deploy`.
+ */
+export declare function resourceRefreshAsync(solutionPath?: string, options?: ResourceRefreshOptions): Promise<ResourceRefreshResult>;

package/dist/services/solution-init-service.d.ts

@@ -0,0 +1,37 @@
+/** Which step of {@link solutionInitAsync} failed, so the CLI can map it to a stage-specific message. */
+export type SolutionInitStage = "directory" | "briefing" | "manifest";
+/** Thrown by {@link solutionInitAsync}, tagged with the failing {@link SolutionInitStage}; `message` mirrors the cause. */
+export declare class SolutionInitError extends Error {
+    readonly stage: SolutionInitStage;
+    constructor(stage: SolutionInitStage, cause: unknown);
+}
+export interface SolutionInitOptions {
+    /**
+     * AGENTS.md / CLAUDE.md content, written to both files before the `.uipx` manifest.
+     * The CLI passes its version-stamped template; library callers usually omit it.
+     */
+    briefingContent?: string;
+    /**
+     * Base dir a relative `solutionName` resolves against. Defaults to `process.cwd()`;
+     * lets library callers set a root without mutating global cwd. Ignored if `solutionName` is absolute.
+     */
+    cwd?: string;
+}
+export interface SolutionInitResult {
+    /** Absolute path to the created `.uipx` manifest. */
+    solutionFile: string;
+    /** Absolute path to the created solution directory. */
+    solutionDir: string;
+    /** Solution name without extension. */
+    solutionName: string;
+    /** Absolute path to the written AGENTS.md, when `briefingContent` was provided. */
+    agentsPath?: string;
+    /** Absolute path to the written CLAUDE.md, when `briefingContent` was provided. */
+    claudePath?: string;
+}
+/**
+ * Programmatic core of `uip solution init`: creates the solution dir, an optional
+ * AGENTS.md/CLAUDE.md briefing (before the manifest), and the `.uipx` manifest. Throws on
+ * failure; does not touch `OutputFormatter`/`processContext`.
+ */
+export declare function solutionInitAsync(solutionName: string, options?: SolutionInitOptions): Promise<SolutionInitResult>;

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

@@ -0,0 +1,9 @@
+/**
+ * Throw if `dir` doesn't directly contain a `.uipx` manifest. Stricter than
+ * `findSolutionFile` (which walks up to find one) — write commands should not
+ * silently mutate the wrong folder when run from an arbitrary cwd.
+ *
+ * Lives in `services/` (not `commands/project.ts`) so callers can mock the
+ * check without pulling in the full project-commands module.
+ */
+export declare function assertSolutionManifest(dir: string): Promise<void>;

package/dist/services/sync-resources-from-bindings.d.ts

@@ -0,0 +1,132 @@
+import { type IResourceBuilderServices, type ISolutionBuilder, type ResourceDefinition } from "@uipath/resource-builder-sdk";
+interface RequiredPropertyDefault {
+    property: string;
+    /** Empty placeholder value matching the property's declared type. */
+    placeholder: unknown;
+}
+interface ResolvedKindMetadata {
+    /** Subtype to pass to createVirtualResourceAsync (e.g. "StringAsset"). */
+    type?: string;
+    /** SDK's `supportsInLineCreation` — whether a virtual stub can be created. */
+    virtualizable: boolean;
+    /**
+     * Required spec properties that have no default in SDK metadata. Deploy
+     * validation rejects virtualized resources missing these (e.g. Asset.value).
+     * We fill them in-memory after `createVirtualResourceAsync` with a
+     * type-appropriate placeholder.
+     */
+    requiredDefaults: RequiredPropertyDefault[];
+}
+/**
+ * Normalize a folder path for comparisons. `.` and `solution_folder` both
+ * encode "no folder" (tenant/root scope) — collapsing them to undefined lets
+ * us compare a binding's folder against an existing resource's folder
+ * consistently regardless of which placeholder either side carries.
+ */
+export declare function normalizeFolderPath(path: string | undefined): string | undefined;
+interface SyncResult {
+    created: number;
+    imported: number;
+    skipped: number;
+    warnings: string[];
+}
+/**
+ * Reads bindings_v2.json from project paths and creates/imports matching
+ * resources in the solution using the resource-builder-sdk.
+ *
+ * @param solutionDir - Path to the solution directory
+ * @param projectPaths - Specific project paths to scan (if omitted, scans all projects in .uipx)
+ */
+export declare function syncResourcesFromBindings(solutionDir: string, projectPaths?: string[]): Promise<SyncResult>;
+/**
+ * Mirror of SDK's private `addResourceWithUniqueName`
+ * (resource-builder-sdk index.js:673): if any other resource of the same
+ * kind already carries `name` (or a `name_<N>` suffix variant), return
+ * `name_<N+1>`. Otherwise return `name` unchanged. Excludes `excludeKey`
+ * so the resource we just created doesn't collide with itself.
+ */
+export declare function uniqueNameForResource(name: string, kind: string, excludeKey: string, solution: {
+    resources: Array<{
+        key: string;
+        kind?: string;
+        name?: string;
+    }>;
+}): string;
+export interface RcsMatch {
+    key: string;
+    name: string;
+    /** Subtype as RCS reports it (e.g. `Text` for Asset). `undefined` for
+     * kinds without a subtype (Queue). Callers may need to forward this to
+     * `addOrUpdateResourceToSolutionAsync`, which rejects type-less imports
+     * for kinds that SDK metadata indexes by (kind, type). */
+    type?: string;
+    folder?: {
+        fullyQualifiedName: string;
+        folderKey: string;
+        path?: string;
+    };
+}
+/**
+ * Page through RCS for a given (kind, name) and collect every match. Returns
+ * an empty array on lookup error (logged as a warning). Callers decide what
+ * to do with 0/1/many matches.
+ */
+export declare function searchRcsResources(builder: ISolutionBuilder, kind: string, name: string): Promise<RcsMatch[]>;
+export declare function findResourceInRcs(builder: ISolutionBuilder, kind: string, name: string, folderPath?: string): Promise<RcsMatch | undefined>;
+/**
+ * Resolve a resource kind's metadata via the SDK (`kind`, optional `type`) so
+ * callers outside the bindings sync can fill required spec defaults the same
+ * way `createVirtualForBinding` does. Returns undefined if the kind isn't
+ * indexed by SDK metadata.
+ */
+export declare function resolveResourceKindMetadata(services: IResourceBuilderServices, kind: string, type?: string): Promise<ResolvedKindMetadata | undefined>;
+export interface CreateLocalResourceParams {
+    builder: ISolutionBuilder;
+    services: IResourceBuilderServices;
+    kind: string;
+    type?: string;
+    name: string;
+    folderPath?: string;
+}
+export interface CreateLocalResourceResult {
+    resource: ResourceDefinition;
+    /** Final name on the resource — may differ from input if SDK conflict suffix kicked in. */
+    finalName: string;
+}
+/**
+ * Create a virtual (local-only) resource via the SDK and rename it to `name`,
+ * mirroring the rename + spec-default flow `createVirtualForBinding` runs
+ * during refresh. Returns the freshly created `SolutionResource` after the
+ * mutation, or undefined if the SDK failed to allocate a key.
+ *
+ * Callers must:
+ *   - Persist the change (e.g. `builder.disposeAsync()` or
+ *     `context.saveAsync()`); this helper only mutates in-memory state.
+ *   - Have already done an idempotency check — this helper *always* creates,
+ *     and SDK's `addResourceWithUniqueName` will suffix the name on conflict.
+ */
+export declare function createLocalResource(params: CreateLocalResourceParams): Promise<CreateLocalResourceResult | undefined>;
+export interface UipxProject {
+    /** Project type as written in `.uipx` (e.g. "Agent", "Process"). */
+    type: string;
+    /** Design-time UUID used as `projectKey` in reconcile. */
+    id: string;
+    /** Path to the project directory (parent of `project.uiproj`). */
+    path: string;
+    /** Project name read from `project.uiproj` (`Name` field). */
+    name: string;
+}
+/**
+ * Read solution's `.uipx` and each project's `project.uiproj` to assemble the
+ * data needed for `reconcileProjectsAsync`. Without this, sync would only see
+ * resource bindings (Queue/Asset/etc.) and miss the project artefacts
+ * (process/<type>, package, app/<subType>, appVersion) the SDK generates from
+ * project templates.
+ */
+export declare function readUipxProjects(solutionDir: string): Promise<UipxProject[]>;
+/**
+ * Sync resources from bindings with logging. Non-fatal — logs warnings
+ * on failure and continues. Used by pack and upload before packaging.
+ */
+export declare function syncAndLog(solutionDir: string): Promise<void>;
+export {};

package/dist/templates/AGENTS.md

@@ -0,0 +1,265 @@
+# UiPath Solution Workspace
+
+> **A `.uipx` file in this directory marks a UiPath solution. Drive every solution operation through the `uip` CLI — packing, publishing, deploying, and deployment configuration.** Do not hand-edit `.uipx`; manage projects via `uip solution project ...` so the manifest stays internally consistent.
+
+This file is a static snapshot, scaffolded by the `uip` CLI version `{{cli_version}}`. If the CLI version you have access to is different, there may be inconsistencies in the commands or options listed below. When you encounter one, look up the current form with `uip <group> --help` and **edit this file in place** — find and replace the stale command with the working one.
+
+## The `.uipx` Manifest
+
+`<solution>.uipx` is a JSON document at the solution root listing every project in the solution. Skeleton:
+
+```json
+{
+    "DocVersion": "1.0.0",
+    "StudioMinVersion": "2025.10.0",
+    "SolutionId": "<uuid>",
+    "Projects": [
+        {
+            "Type": "Process",
+            "ProjectRelativePath": "MyProcess/project.json",
+            "Id": "<uuid>"
+        }
+    ]
+}
+```
+
+Typical layout:
+
+```text
+my-solution/
+    my-solution.uipx          ← solution manifest
+    AGENTS.md                 ← this file (Codex, Cursor, generic agents)
+    CLAUDE.md                 ← identical copy (Claude Code)
+    ProjectA/
+        project.json
+        bindings_v2.json      ← per-project resource declarations
+        ...
+    ProjectB/
+        project.uiproj
+        ...
+```
+
+You must manage membership via the CLI, never by editing the manifest. All these operations work entirely on local files (`.uipx` plus the solution-builder artefacts on disk) and do not require `uip login` — auth is only needed once you reach `pack` / `publish` / `deploy` / `upload`.
+
+| Intent | Command |
+|---|---|
+| Create a solution | `uip solution init <name>` |
+| Register an existing subfolder of the solution dir as a project (no copying — use after scaffolding *inside* the solution dir, e.g. `uip rpa create-project --location <solution-dir>`) | `uip solution project add <project-path> [<solution-file>]` |
+| Add a project from outside the solution — copies the folder at `<path>` into the solution dir and registers it (`<path>` is a local filesystem path) | `uip solution project import --source <path>` |
+| Unregister a project (does not delete the project files on disk) | `uip solution project remove <project-path> [<solution-file>]` |
+| List projects in the solution | `uip solution project list` |
+
+## Project Types
+
+A solution can contain multiple projects of different types. The table below lists each project type and the `uip` command that scaffolds a fresh one (or marks the row when no scaffolding command exists).
+
+| Type | Description | Scaffold with | Skill |
+|---|---|---|---|
+| `Process` | RPA process — Studio workflow (XAML, Coded C#, or Hybrid) | `uip rpa create-project --name <name>` | `uipath-rpa` |
+| `Library` | Reusable RPA library | `uip rpa create-project --template-id LibraryProcessTemplate --name <name>` | `uipath-rpa` |
+| `Tests` | Test Automation project | `uip rpa create-project --template-id TestAutomationProjectTemplate --name <name>` | `uipath-rpa` |
+| `Flow` | Maestro Flow — long-running orchestrated workflow | `uip maestro flow init <name>` | `uipath-maestro-flow` |
+| `CaseManagement` | Maestro Case — stateful business process (SLA, approvals, HITL) | `uip maestro case init <name>` | `uipath-maestro-case` |
+| `ProcessOrchestration` | Maestro BPMN — long-running orchestrated process | `uip maestro bpmn init <name>` | `uipath-maestro-bpmn` |
+| `Agent` | LLM agent project — **low-code** (configured via `agent.json`; no Python) or **coded** (Python: LangGraph / LlamaIndex / OpenAI Agents). Both subtypes share `ProjectType: "Agent"`; the discriminator is `agent.json#type`. | `uip agent init <path>` (low-code) · `uip codedagent new [name]` (coded — see the `uipath-agents` skill for the full flow) | `uipath-agents` |
+| `AppV2` | Coded App — web application | `uip codedapp init <path>` | `uipath-coded-apps` |
+| `Function` | UiPath Function (JS / TS / Python) | `uip functions new [name]` | none |
+| `Api` | API Workflow project | no CLI scaffolding | none |
+| `Connector` | Integration Service connector | no CLI scaffolding — use `uip is connectors` to list / get / export existing connectors | none |
+| `WebApp` | Legacy low-code UiPath App (the coded variant is `AppV2`) | no CLI scaffolding | none |
+
+All skill should be installed by running the command: `uip skills install`. The general-purpose `uipath-platform` skill covers what isn't in a type-specific skill.
+
+The type lives in either `project.uiproj` (top-level `ProjectType`) or `project.json` (`designOptions.outputType`, falling back to top-level `ProjectType` when `outputType` is absent — read or write either field). After scaffolding, register the project with the solution: `uip solution project import --source <path>`. If you pass an unknown type to that command, it rejects with the exhaustive accepted list — trust that error over this table.
+
+## End-to-End Lifecycle
+
+Run `uip login` first — most steps below need an authenticated session, including `solution pack` in some cases.
+
+```bash
+# 1. Authenticate
+#    Interactive (browser OAuth):
+uip login
+#    Non-interactive (CI / CD) with client credentials:
+uip login --client-id <ID> --client-secret <SECRET> --tenant <TENANT>
+
+# 2. Pack the solution into a .zip. Two positional args:
+#    <solutionPath>  — solution dir (containing .uipx) or a .uis file
+#    <output-path>   — directory where the .zip is written (required unless --dry-run)
+uip solution pack . ./out
+
+# 2a. (Optional) Validate the solution against the strict deploy-time
+#     pipeline without producing a package — useful as a CI gate.
+uip solution pack . --dry-run
+
+# 3. Publish the packed .zip to Orchestrator
+uip solution publish ./out/<package>.zip
+
+# 4. Fetch the default deployment configuration for the published package
+uip solution deploy config get <package-name> --destination config.json
+
+# 5. (Optional) Customize the config — see "Deployment Configuration" below
+
+# 6. Deploy. By default this also activates; pass --skip-activate to defer.
+uip solution deploy run \
+    --name <deployment-name> \
+    --package-name <package-name> \
+    --package-version <version> \
+    --folder-name <new-folder> \
+    --parent-folder-path Shared \
+    --config-file config.json
+
+# 7. The deploy returns a pipeline deployment ID — track it:
+uip solution deploy status <pipeline-deployment-id>
+
+# 8. List every deployment in the active tenant
+uip solution deploy list
+```
+
+**Activation lifecycle.** `deploy run` activates by default. To split the steps:
+
+```bash
+uip solution deploy run --skip-activate ...                      # leaves "Inactive (Ready to activate)"
+uip solution deploy activate <deployment-name>     # activate later
+uip solution deploy uninstall <deployment-name>    # remove the deployment + its resources
+```
+
+`uninstall` and `activate` take the deployment name as a **positional** argument (no `--name` flag). `status` takes the **pipeline deployment ID** (the GUID returned by `deploy run`), also positional.
+
+## Studio Web (Browser Editing)
+
+Studio Web is a separate target from the Orchestrator deploy chain — it hosts a browser-based collaborative editor for solutions. The `solution upload` command pushes the local solution there and returns a `DesignerUrl` to open the solution in a browser; this is independent of `pack` / `publish` / `deploy` and does *not* produce a runtime-deployable artifact.
+
+```bash
+uip solution upload .                      # upload solution dir to Studio Web as a new solution; returns DesignerUrl
+uip solution upload . --force              # force-replace the existing Studio Web solution referenced by .uipx (destroys cloud version history)
+uip solution download <solution-id>        # round-trip a Studio Web solution back to disk
+uip solution delete <solution-id>          # remove a solution from Studio Web
+```
+
+`upload` accepts a solution directory, a `.uipx` file, or a `.uis` file. It probes Studio Web for the bundled `SolutionId` first: if the cloud has no solution with that id, the upload imports as new; if a solution with that id already exists, the upload is refused unless `--force` is passed. Forcing replaces the cloud project in place and **wipes its Studio Web version history**, so use `--force` deliberately. To upload a copy as an unrelated cloud solution instead of overwriting, scaffold a fresh solution with `uip solution init` (or remove the `SolutionId` from the local `.uipx`) and re-run upload.
+
+## Per-Project Bindings (`bindings_v2.json`)
+
+Each project declares the resources it needs (assets, queues, buckets, processes, …) in a `bindings_v2.json` file at the project root. These declarations drive the solution's resource inventory.
+
+After editing a project's bindings, or after `solution project import` (which doesn't auto-sync resources), reconcile the solution-level inventory:
+
+```bash
+uip solution resource refresh     # re-scan every project, sync new / removed resources
+```
+
+`solution resource refresh` creates new resources for bindings not yet in the solution and imports from Orchestrator when a matching resource already exists.
+
+Inspect the current solution inventory:
+
+```bash
+uip solution resource list        # everything declared in this solution
+```
+
+## Deployment Configuration
+
+The deploy config is a JSON file fetched from Orchestrator that lists every resource the solution will provision (or reuse) and every property you can override. It is **separate from `bindings_v2.json`** — bindings declare *what a project needs*, the deploy config decides *how that maps to Orchestrator at deploy time*.
+
+```bash
+# Fetch the default config to a file
+uip solution deploy config get <package-name> --destination config.json
+
+# Set a property on a single resource
+uip solution deploy config set config.json <resource-name> <property> <value>
+# e.g. set config.json MyQueue maxNumberOfRetries 5
+
+# Set a property on every resource (limited; supports e.g. conflictFixingAction)
+uip solution deploy config set config.json --all <property> <value>
+
+# Link a resource slot to an existing Orchestrator resource (instead of creating a new one)
+uip solution deploy config link config.json <resource-name> \
+    --name <existing-resource-name> \
+    --folder-path Shared/Production
+
+# Remove a link — the resource will be created at deploy time again
+uip solution deploy config unlink config.json <resource-name>
+
+# Apply the customized config:
+uip solution deploy run ... --config-file config.json
+```
+
+If a deploy fails on a configuration issue, the CLI prints the offending resource and an `Instructions` field. Read those before retrying — most failures are an `existing-resource-name` typo, a wrong `--folder-path`, or a property that the resource type does not accept.
+
+## Resource Types in Orchestrator
+
+The CLI talks about the same resource types Orchestrator does:
+
+- **Assets** — key-value configuration. Asset value types: `Text`, `Bool`, `Integer`, `Credential`, `Secret`.
+- **Queues** & **Queue Items** — work-item queues for distributed transactional processing; queue items are the rows.
+- **Storage Buckets** & **Bucket Files** — file storage for automation data.
+- **Connections** — Integration Service connections to external systems (Salesforce, ServiceNow, …).
+- **Processes / Releases** — published packages bound to a folder.
+- **Triggers** & **Webhooks** — event-, time-, or queue-based job firing; outbound HTTP notifications.
+
+Resources outside a solution are managed under the orchestrator tool, which exposes per-type subgroups (`uip or assets …`, `uip or queues …`, `uip or buckets …`, `uip or bucket-files …`, `uip or libraries …`, `uip or queue-items …`, `uip or triggers …`, `uip or webhooks …`). Run `uip or --help` for the live list. Example:
+
+```bash
+uip or assets list          # list assets in the active folder
+uip or assets create        # create an asset (see --help)
+```
+
+## Output Conventions for Agents
+
+Two rules make automation reliable:
+
+1. **Never redirect or drop stderr.** Errors and confirmations go to stderr — `2>/dev/null` will silently hide failures and produce false retries.
+2. **Use `--output-filter <jmespath>`** to extract specific fields rather than piping JSON through external tools. The expression is applied to the `Data` array — start with `[]`, not with `Data[]`. Example: `uip solution packages list --output-filter "[].name"`.
+
+Standard success shape: `{ "Result": "Success", "Code": "<CommandCode>", "Data": ... }`.
+Standard failure shape: `{ "Result": "Failure", "Message": "<short>", "Instructions": "<actionable>" }`.
+
+List commands always return `Data: []` on empty results — never a message object — so consumers can rely on a consistent array shape.
+
+## Discovering Commands
+
+This file is a starting map, not a reference. The live source of truth is the CLI itself:
+
+```bash
+uip --help                       # top-level groups
+uip solution --help              # every solution verb
+uip solution deploy --help       # the deploy subgroup
+uip <command> --help             # full options for any command
+```
+
+For concept or API documentation beyond CLI usage, fetch `https://docs.uipath.com/llms.txt` for the product index, then the relevant `.md` page (e.g. `https://docs.uipath.com/orchestrator/automation-cloud/latest/api-guide/assets-requests.md`).
+
+Adjacent groups commonly used alongside solutions:
+
+| Group | Purpose |
+|---|---|
+| `uip login`, `uip login tenant` | Authenticate, switch tenants |
+| `uip or folders` | Manage Orchestrator folders |
+| `uip or assets`, `uip or queues`, `uip or buckets`, `uip or bucket-files`, `uip or libraries`, `uip or queue-items`, `uip or triggers`, `uip or webhooks` | Manage Orchestrator resources directly |
+| `uip rpa` | RPA workflow lifecycle (compile, validate, execute, scaffold) |
+| `uip maestro` | Maestro Flow / Case / BPMN scaffolding |
+| `uip agent`, `uip codedagent` | Coded agent lifecycle |
+| `uip codedapp` | Coded Apps lifecycle |
+| `uip functions` | UiPath Functions |
+| `uip tm` | Test Manager (test projects, sets, executions) |
+| `uip is` | Integration Service (connectors, connections) |
+| `uip tools` | Manage CLI tool extensions |
+
+## Troubleshooting Quick Map
+
+| Symptom | First thing to check |
+|---|---|
+| `Not authenticated` / 401 | `uip login`, then re-run |
+| Command targets the wrong tenant | `uip login tenant set <tenant>`; verify with `uip login status` |
+| Pack succeeds but publish 409s | Version conflict — bump the version (`uip solution pack . ./out -v <new-version>`) or delete the colliding version with `uip solution packages delete <package-name> <version>` (only if intentional) |
+| `deploy run` fails on a resource conflict | `uip solution deploy config link config.json <resource> --name <existing> --folder-path <path>` to map to the existing one, or change `conflictFixingAction` via `config set` |
+| `Resource not found` after deploy | `uip solution resource refresh` to re-sync from each project's `bindings_v2.json`; if still missing, the resource was never declared in any project |
+| Output looks empty | You may have redirected stderr — confirmations and errors go there. Re-run without `2>` |
+
+---
+
+For deeper detail, consult:
+
+- The official Solutions Management guide: <https://docs.uipath.com/solutions-management/automation-cloud/latest>
+- The `uipath-platform` skill — auth, Orchestrator (folders, assets, queues, buckets, robots, packages, processes), solution lifecycle (pack / publish / deploy), Integration Service, and the `uip` CLI.
+- The `uipath-solution-design` skill — turn a Process Design Document (PDD) into an implementation-ready Solution Design Document (SDD) and pick scope (single product vs. multi-project Solution composing RPA / Flow / Case / Agents / Apps / API Workflows).