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.

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. For the underlying auth/output changes that apply to every verb, see Breaking changes.

Paquet

Legacy command	uip equivalent	Remarques
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.
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.
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 and 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.

package pack

# 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 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

# 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.

# 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

Remarque :

• 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 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

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

# uip
uip rpa restore ./proj ./deps

Job

Legacy command	uip equivalent	Remarques
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.

# 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	Remarques
uipcli test run <url> <tenant> -s <testset>	uip tm testset execute --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 testset execute. The new verb is uip tm testset execute — not uip tm execution run, which does not exist.
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 testset execute	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 testset execute calls	Removed — replacement: script a parallel launch of independent test sets with uip tm testset execute (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)

# 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 testset execute \
    --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 testset 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 execution 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 testset execute calls concurrently, captures each ExecutionId, then waits on each:

# Launch in parallel (bash)
EXEC1=$(uip tm testset execute --test-set-key DEMO:10 --output-filter Data.ExecutionId --output plain) &
EXEC2=$(uip tm testset execute --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.

Ressource

Legacy command	uip equivalent	Remarques
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.
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>.

# 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

Remarque :

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.

Solution

Legacy command	uip equivalent	Remarques
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.
uipcli solution deploy-activate <...>	uip solution deploy activate <deployment-name>	1:1.
uipcli solution deploy-uninstall <...>	uip solution deploy uninstall <deployment-name>	1:1.

# 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 for a walkthrough with explanations for each step.

run

Legacy command	uip equivalent	Remarques
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.

Remarque :

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.

Voir également

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