# Migration: command map

> Every legacy `uipcli` verb with its `uip` equivalent. Legacy entries reflect the public `uipcli` surface documented for `2025.10` and earlier; the `uip` column matches the published [reference pages](./command-reference.md).

Every legacy `uipcli` verb with its `uip` equivalent. Legacy entries reflect the public `uipcli` surface documented for `2025.10` and earlier; the `uip` column matches the published [reference pages](./command-reference.md).

**How to read this page.** Rows are grouped by legacy verb family (`package`, `job`, `test`, `asset`, `solution`, `run`). Each row carries a classification:

- **1:1** — direct rename; the new flag set is close enough that a mechanical port works.
- **2 steps** / **N steps** — one legacy verb maps to multiple `uip` calls.
- **Removed — replacement: …** — the legacy verb has no direct successor; the "replacement" column tells you the idiomatic new-CLI flow for the same outcome.

For flag-level detail inside each verb, see [Flag renames](./migration-flag-renames.md). For the underlying auth/output changes that apply to every verb, see [Breaking changes](./migration-breaking-changes.md).

## package

| Legacy command | `uip` equivalent | Notes |
|---|---|---|
| `uipcli package pack <project>` | `uip rpa pack <project>` | **1:1.** The new flag surface uses kebab-case; `--outputType` → `--output-type`, `--autoVersion` → `--auto-version`, etc. `uip rpa` commands invoke the Studio packager, which is .NET-backed — the runner still needs a .NET runtime available. See [uip rpa pack](./uip-rpa-pack.md). |
| `uipcli package analyze <project>` | `uip rpa analyze <project> --governance-file-path <policy>` | **1:1.** `--governanceFilePath` becomes `--governance-file-path` (kebab-case). Workflow analyzer rules are unchanged. .NET backend applies, same as `rpa pack`. See [uip rpa analyze](./uip-rpa-analyze.md). |
| `uipcli package deploy <path> <url> <tenant>` | `uip or packages upload <path>` **then** `uip or processes create --name <n> --package-key <k> --package-version <v> --folder-path <path>` | **2 steps.** Legacy deploy uploads the `.nupkg` **and** creates a process in one call; the new CLI splits those concerns. See [uip or packages upload](./uip-orchestrator-packages.md#uip-or-packages-upload) and [uip or processes create](./uip-orchestrator-processes.md#uip-or-processes-create). |
| `uipcli package restore <project>` | `uip rpa restore <project> [outputPath]` | **1:1.** Restores NuGet package dependencies; supports air-gapped and custom NuGet configs through the same flags as legacy. .NET backend applies. See [uip rpa restore](./uip-rpa-restore.md). |

### package pack

```bash
# Legacy
uipcli package pack "C:\proj\project.json" -o "C:\dist" \
    --outputType Process --autoVersion \
    --traceLevel Information

# uip
uip rpa pack ./proj --output-type Process --auto-version
```

See [uip rpa pack](./uip-rpa-pack.md) for the full flag list. The tool wraps the same Studio packager the legacy CLI used, so output format and project support are identical.

### package analyze

```bash
# Legacy
uipcli package analyze "C:\proj\project.json" \
    --governanceFilePath "C:\policy.json" \
    --resultPath "C:\result.json" \
    --stopOnRuleViolation

# uip
uip rpa analyze ./proj \
    --governance-file-path ./policy.json \
    --result-path ./result.json \
    --stop-on-rule-violation
```

### package deploy

This is the row that catches every pipeline port. Legacy `deploy` is a one-shot upload-and-create; `uip` splits it into two explicit steps so the package can be uploaded once and bound to multiple folders.

```bash
# Legacy — upload and create a process in one call
uipcli package deploy "C:\pkg\InvoiceProcessing.1.0.3.nupkg" \
    "https://cloud.uipath.com/" "TenantName" \
    -A "myOrg" -I "<app-id>" -S "<app-secret>" \
    --applicationScope "OR.Folders OR.Execution" \
    -o "Shared" \
    --processName "InvoiceProcessing" \
    --entryPointsPath "Main.xaml"

# uip — upload, then create the process
uip login \
  --client-id env.UIPATH_CLIENT_ID \
  --client-secret env.UIPATH_CLIENT_SECRET \
  --tenant TenantName

uip or packages upload ./InvoiceProcessing.1.0.3.nupkg
#    response includes "body": "InvoiceProcessing:1.0.3"

uip or processes create \
    --name InvoiceProcessing \
    --package-key InvoiceProcessing \
    --package-version 1.0.3 \
    --folder-path Shared \
    --entry-point Main.xaml
```

Notes:

- The positional `<orchestrator_url>` and `<orchestrator_tenant>` from legacy are replaced by session context from `uip login` (plus optional `-t, --tenant` override on each call). They never appear as positional args in `uip`.
- Legacy `--processName` is a custom display name for the created process. In `uip` the equivalent is `--name` on `processes create` — not `--process` (which does not exist).
- Legacy `--processNames <csv>` (multi-process bulk create in 25.10) has **no direct equivalent**; script a loop over rows, or read [Solutions](#solution) for the recommended multi-process flow.
- Legacy `--entryPointsPath` (CSV) becomes `--entry-point` (single path) on `uip or processes create`; run `processes create` once per entry point for multi-entry-point packages.

### package restore

```bash
# Legacy
uipcli package restore "C:\proj" \
    --restoreFolder "C:\deps" \
    --nugetConfigFilePath "C:\NuGet.Config"

# uip
uip rpa restore ./proj ./deps
```

## job

| Legacy command | `uip` equivalent | Notes |
|---|---|---|
| `uipcli job run <processName> <url> <tenant>` | `uip or jobs start <process-key>` | 1:1 on intent; **identity is a GUID, not a name.** The legacy CLI took the process release name as the positional argument; the new CLI takes the process key (GUID) returned by `uip or processes list`. Use `--wait-for-completion` for the legacy `-w true` + `-W <timeout>` behavior. See [uip or jobs start](./uip-orchestrator-jobs.md#uip-or-jobs-start). |

```bash
# Legacy
uipcli job run "InvoiceProcessing" \
    "https://cloud.uipath.com/" "TenantName" \
    -A "myOrg" -I "<app-id>" -S "<app-secret>" \
    --applicationScope "OR.Folders OR.Execution OR.Jobs" \
    -o "Shared" \
    -i "C:\input.json" \
    -w true -W 3600

# uip — resolve the name to a key, then start with wait-for-completion
PROCESS_KEY=$(uip or processes list --folder-path Shared \
    --name InvoiceProcessing \
    --output-filter "Data[0].Key" \
    --output plain)

uip or jobs start "$PROCESS_KEY" \
    --input-file ./input.json \
    --wait-for-completion \
    --timeout 3600
```

Flag-level detail:

- Legacy `-i, --input_path <file>` → `uip` offers two alternatives: `--input-arguments '<json>'` for inline JSON, or `--input-file <path>` for a file payload. They are mutually exclusive.
- Legacy `-j, --jobscount <n>` → `--jobs-count <n>`.
- Legacy `-P, --priority <Low|Normal|High>` → `--job-priority <Low|Normal|High>`.
- Legacy `-r, --robots <csv>` → no direct equivalent (classic-folder-only concept in legacy). Target machines with `--machine-keys <csv>` (GUIDs) or users with `--user-keys <csv>` (GUIDs).
- Legacy `-f, --fail_when_job_fails` (default `true`) → the new CLI always exits `1` if a waited-for job ends `Faulted`; there is no opt-out.
- Legacy `-R, --result_path <file>` → the new CLI prints the job envelope to stdout; redirect with `> result.json`, or use `--output-filter` to extract specific fields.
- Legacy `-b, --job_type <Unattended|NonProduction>` → `--runtime-type <Unattended|Headless|Serverless|NonProduction|Development|TestAutomation>`.

## test

| Legacy command | `uip` equivalent | Notes |
|---|---|---|
| `uipcli test run <url> <tenant> -s <testset>` | `uip tm testsets run --test-set-key <key>` **then** `uip tm wait --execution-id <id>` **then** `uip tm report get --execution-id <id>` | **3 steps (launch → wait → verify).** The new CLI separates "fire the run" from "block on it" from "read the verdict", so CI scripts can branch cleanly on each. See [uip tm testsets run](./uip-test-manager-testsets.md#uip-tm-testsets-run). The new verb lives on the `testsets` resource as `uip tm testsets run` — **not** on the `executions` resource (there is no `uip tm executions run`). |
| `uipcli test run <url> <tenant> -P <project.json>` (pack + test a project) | `uip rpa pack` → `uip or packages upload` → author a test set in Test Manager → `uip tm testsets run` | **N steps.** The legacy one-shot "pack this project, deploy it, run its tests" flow is split across the `rpa`, `or`, and `tm` tools. Authoring the test set is typically a one-time setup done in Test Manager's web UI. |
| `uipcli test parallel <url> <tenant> --testsConfigurationFilePath <file>` | No direct equivalent — loop over `uip tm testsets run` calls | **Removed — replacement:** script a parallel launch of independent test sets with `uip tm testsets run` (each returns an `ExecutionId`), then a single `uip tm wait` per execution. The legacy `parallel` verb's test-project driver (which invoked `uipcli test run` internally) has no counterpart; the new model assumes test sets are already authored in Test Manager. |

### test run (single test set)

```bash
# Legacy
uipcli test run \
    "https://cloud.uipath.com/" "TenantName" \
    -A "myOrg" -I "<app-id>" -S "<app-secret>" \
    --applicationScope "OR.Folders OR.TestSets OR.TestSetExecutions" \
    -o "Shared" \
    -s "Smoke Suite" \
    --out junit \
    --result_path "C:\results.xml" \
    --timeout 1800

# uip — three verbs, clean exit-code branching
EXECUTION_ID=$(uip tm testsets run \
    --test-set-key DEMO:10 \
    --output-filter "Data.ExecutionId" \
    --output plain)

if ! uip tm wait --execution-id "$EXECUTION_ID" --project-key DEMO --timeout 1800; then
    case $? in
        2) echo "timeout" >&2; exit 2 ;;
        *) echo "wait failed" >&2; exit 1 ;;
    esac
fi

FAILED=$(uip tm report get --execution-id "$EXECUTION_ID" --project-key DEMO \
    --output-filter "Data.Failed" --output plain)

if [ "$FAILED" -gt 0 ]; then
    uip tm result download --execution-id "$EXECUTION_ID" --project-key DEMO \
        --destination ./results.xml
    exit 1
fi
```

Flag-level notes:

- Legacy `-s, --testset <name>` takes a display name; the new `--test-set-key <key>` takes the Test Manager key (format `PROJECT:NN`). Look it up with `uip tm testsets list --project-key <key>`.
- Legacy `-t, --testsetkey <key>` (a newer legacy alias) also exists — those values port directly to the new `--test-set-key`.
- Legacy `--out junit|uipath` becomes the new `uip tm result download --output-format junit` (JUnit is the default; UiPath-native XML is also supported).
- Legacy `--attachRobotLogs` → attach artifacts via `uip tm attachment download --execution-id <id>` after the run.
- Legacy `--retryCount <n>` → `uip tm executions retry --execution-id <id>` re-runs only the failed cases of a finished execution. There is no automatic retry flag at launch; script it with the `report get` exit-branch above.

### test parallel

There is no `uip` verb that mirrors legacy `test parallel`. The closest idiom is a shell loop that launches several `uip tm testsets run` calls concurrently, captures each `ExecutionId`, then waits on each:

```bash
# Launch in parallel (bash)
EXEC1=$(uip tm testsets run --test-set-key DEMO:10 --output-filter Data.ExecutionId --output plain) &
EXEC2=$(uip tm testsets run --test-set-key DEMO:11 --output-filter Data.ExecutionId --output plain) &
wait

# Then wait on each
uip tm wait --execution-id "$EXEC1" --project-key DEMO --timeout 1800 &
uip tm wait --execution-id "$EXEC2" --project-key DEMO --timeout 1800 &
wait
```

The legacy `--testsConfigurationFilePath` schema (which listed per-project paths and their test sets) has no `uip` counterpart; drive the loop from your CI matrix or a simple shell list of test set keys.

## asset

| Legacy command | `uip` equivalent | Notes |
|---|---|---|
| `uipcli asset deploy <csv> <url> <tenant>` | Loop over `uip resource assets create <name> <value>` per row | **Removed — replacement:** iterate the CSV in a shell loop and call `create` per row. The new CLI does not offer a one-shot CSV deploy; see [uip resource assets](./uip-resource-assets.md). |
| `uipcli asset delete <csv> <url> <tenant>` | Loop over `uip resource assets delete <key>` per row | **Removed — replacement:** iterate and delete by key. `delete` takes the asset GUID, not the name — resolve names to keys first with `uip resource assets list --folder-path <path>`. |

```bash
# Legacy — bulk CSV
uipcli asset deploy "C:\assets.csv" "https://cloud.uipath.com/" "TenantName" \
    -A "myOrg" -I "<app-id>" -S "<app-secret>" \
    --applicationScope "OR.Assets" -o "Shared"

# uip — script the loop
# CSV columns: name,type,value,description
while IFS=, read -r NAME TYPE VALUE DESCRIPTION; do
    [ "$NAME" = "name" ] && continue    # skip header
    uip resource assets create "$NAME" "$VALUE" \
        --folder-path Shared \
        --type "$TYPE" \
        --description "$DESCRIPTION"
done < assets.csv
```

:::note
Credential-type assets in legacy use the `username::password` value form. With `uip resource assets create`, the Credential value format is `username:password` (single colon), and secrets require `--credential-store-key <guid>`. See [uip resource assets — create](./uip-resource-assets.md#create).
:::

## solution

| Legacy command | `uip` equivalent | Notes |
|---|---|---|
| `uipcli solution pack <path>` | `uip solution pack <solutionPath> <outputPath>` | 1:1 on intent. Output is a `.zip` in both generations (contains inner `.nupkg` files); argument shape changed from `-o` to a positional output directory. |
| `uipcli solution analyze <path>` | `uip rpa analyze <project>` per project | **N steps.** Run the analyzer on each project inside the solution; there is no single `uip solution analyze` verb. |
| `uipcli solution restore <path>` | `uip rpa restore <project>` per project | **N steps.** Same pattern as `solution analyze`. |
| `uipcli solution upload-package <zip>` | `uip solution publish <zip>` | 1:1. New name is `publish`; behavior (upload to tenant solution feed) is unchanged. |
| `uipcli solution download-package <name> <version>` | No direct equivalent | **Removed — replacement:** download the underlying `.nupkg` package(s) with `uip or packages download <key>`, or fetch the published solution record via the Orchestrator REST API. |
| `uipcli solution delete-package <name> <version>` | `uip solution packages delete <packageName> <packageVersion>` | 1:1. |
| `uipcli solution download-config <name>` | `uip solution deploy config get <package-name> [--package-version <v>] [-d <path>]` | 1:1. |
| `uipcli solution deploy <...>` | `uip solution deploy run --name <n> --package-name <n> --package-version <v> --folder-name <n> [--folder-path <path>]` | 1:1 on intent; flag names changed. `--name` is the **deployment** name, not the package name. See [first-pipeline.md — Step 3](./first-pipeline.md#step-3-deploy-to-orchestrator). |
| `uipcli solution deploy-activate <...>` | `uip solution deploy activate <deployment-name>` | 1:1. |
| `uipcli solution deploy-uninstall <...>` | `uip solution deploy uninstall <deployment-name>` | 1:1. |

```bash
# Legacy — pack + upload + deploy, one verb each
uipcli solution pack "C:\my-solution" \
    -o "C:\dist" \
    -v 1.2.0
uipcli solution upload-package "C:\dist\my-solution.1.2.0.zip" \
    "https://cloud.uipath.com/" "TenantName" \
    -A "myOrg" -I "<app-id>" -S "<app-secret>" \
    --applicationScope "OR.Folders"
uipcli solution deploy "..." "..."

# uip — publish replaces upload-package; positional --version in pack
uip login --client-id env.UIPATH_CLIENT_ID --client-secret env.UIPATH_CLIENT_SECRET --tenant TenantName
uip solution pack ./my-solution ./dist --version 1.2.0
uip solution publish ./dist/my-solution.1.2.0.zip
uip solution deploy run \
    --name "my-solution-deployment" \
    --package-name my-solution \
    --package-version 1.2.0 \
    --folder-name MySolution \
    --folder-path Shared
```

See [Your first pipeline](./first-pipeline.md) for a walkthrough with explanations for each step.

## run

| Legacy command | `uip` equivalent | Notes |
|---|---|---|
| `uipcli run <arguments.json>` | No direct equivalent | **Removed — replacement:** rewrite the pipeline step as a shell script that calls `uip` directly with flags. The legacy `run` verb consumed a JSON file that serialized a full `uipcli <verb> <args>` invocation (produced by the hidden `--captureCommandToJsonFile` flag); `uip` does not ship an equivalent. |

:::note
The 1.x CLI does not expose a universal `--from-file` flag for bulk argument replay. If your pipeline depends on this pattern (common with the legacy `captureCommandToJsonFile` + `uipcli run` workflow), convert the JSON payload into direct `uip` invocations.
:::

## Commands with no legacy equivalent

These `uip` verbs have no counterpart in the legacy CLI; they open up workflows that were not possible with `uipcli` alone. None of them require migration — they are new capability.

- `uip login`, `uip login tenant list/set`, `uip logout`, `uip login status` — full session management.
- `uip or folders *`, `uip or machines *`, `uip or users *`, `uip or roles *`, `uip or licenses *`, `uip or sessions *`, `uip or audit-logs *`, `uip or calendars *`, `uip or credential-stores *`, `uip or feeds *`, `uip or settings *` — full Orchestrator admin surface.
- `uip or jobs list / get / stop / restart / resume / logs / traces / healing-data / history`, `uip or processes list / get / edit / update-version / rollback`, `uip or packages list / get / versions / entry-points / download` — introspection verbs that legacy did not expose.
- `uip resource buckets / bucket-files / libraries / queues / queue-items / triggers / webhooks` — Orchestrator resource CRUD.
- `uip agent *`, `uip codedagent *`, `uip codedapp *`, `uip flow *`, `uip maestro *`, `uip api-workflow *`, `uip df *`, `uip insights *`, `uip traces *`, `uip docsai *`, `uip vss *` — entirely new surfaces.
- `uip tools *`, `uip skills *`, `uip mcp`, `uip completion` — host-level management.

## See also

- [Flag renames](./migration-flag-renames.md) — every flag that changed name between `uipcli` and `uip`, with the mapping rule.
- [Breaking changes](./migration-breaking-changes.md) — semantic changes behind the rename (auth, stdout format, exit codes).
- [Pipeline examples](./migration-pipelines.md) — before/after Azure DevOps and Jenkins pipelines.
- [Reference index](./command-reference.md) — every `uip` tool and verb in one place.