# Advanced Commands

These commands cover lower-level operations and edge cases. Most users won't need them day-to-day, but they're invaluable for scripting, integrations, and debugging.

## Sandboxes (`duvo sandboxes`)

Sandboxes are isolated file environments where you can stage files before starting a Job. Create a sandbox, upload files into it, then pass the sandbox ID when starting a Job with `duvo runs start --sandbox <sandbox-id>`.

```bash
duvo sandboxes create                              # create a new sandbox
duvo sandboxes files <sandbox-id>                  # list files in a sandbox
duvo sandboxes upload <sandbox-id> <file>          # upload a local file (max 10 MB)
duvo sandboxes prepare-upload-url <sandbox-id> \
  --path /workspace/data.csv                       # get a presigned URL for files over 10 MB
```

`--path` is the destination path inside the sandbox. After getting the URL, upload the file directly via HTTP.

## Revision integrations (`duvo revision-integrations`)

Revision integrations control which integrations (Connections) are attached to a specific Revision of an Assignment, and let you pin particular Connection accounts to individual integration slots.

```bash
duvo revision-integrations list \
  --agent <agent-id> --revision <revision-id>             # list integrations on a Revision
duvo revision-integrations attach \
  --agent <agent-id> --revision <revision-id> \
  --integration <integration-id>                          # attach an integration (repeat --integration for multiple)
duvo revision-integrations remove <integration-id> \
  --agent <agent-id> --revision <revision-id> [-y]        # remove an integration from a Revision (prompts unless -y)
```

Use `duvo integrations list` to find integration IDs and `duvo connections list` to find Connection IDs.

### Pinned Connections

Pin a specific Connection account to an integration slot so the Assignment always uses that account, regardless of who runs it.

```bash
duvo revision-integrations connections list \
  --agent <agent-id> --revision <revision-id> \
  --integration <integration-id>                          # list pinned Connections for a slot

duvo revision-integrations connections pin <connection-id> \
  --agent <agent-id> --revision <revision-id> \
  --integration <integration-id>                          # pin a Connection to a slot

duvo revision-integrations connections unpin <connection-id> \
  --agent <agent-id> --revision <revision-id> \
  --integration <integration-id> [-y]                     # unpin a Connection from a slot
```

## Build integrations (`duvo build-integrations`)

Newer Builds use `duvo build-integrations` to manage integration attachments. The interface mirrors `revision-integrations` but is keyed by Build ID instead of Revision ID.

```bash
duvo build-integrations list --build <build-id>
duvo build-integrations attach --build <build-id> --integration <integration-id>
duvo build-integrations remove <integration-id> --build <build-id>
duvo build-integrations connections-list --build <build-id> --integration <integration-id>
duvo build-integrations connections-pin <connection-id> --build <build-id> --integration <integration-id>
duvo build-integrations connections-unpin <connection-id> --build <build-id> --integration <integration-id>
```

Run `duvo build-integrations --help` for the latest flag set.

## Plugins (`duvo plugins`)

```bash
duvo plugins list                                  # list available plugins that can be referenced in Revisions
```

## Team (`duvo team`)

```bash
duvo team members [--team <team-id>] [--limit <n>] [--offset <n>]   # list team members
```

If `--team` is omitted, the command uses the team scoped to your API key or active profile.

## Profiles (`duvo profiles`)

```bash
duvo whoami                          # show active profile and key prefix
duvo profiles list                   # list all stored profiles
duvo profiles use [name]             # switch the default profile (interactive picker if name omitted)
duvo profiles rename <old> <new>     # rename a profile
duvo profiles remove <name>          # remove a profile locally
duvo logout                          # sign out (revokes OAuth tokens server-side and removes the profile)
duvo logout --name <profile>         # sign out of a specific profile
duvo logout --all                    # sign out of every stored profile
```

## Raw API access (`duvo api`)

Call any Duvo API endpoint directly. Use this when you need an endpoint that doesn't have a dedicated `duvo` command yet, or when you want to inspect the raw API response.

```bash
duvo api GET /v1/health
duvo api POST /v1/runs --data '{"agent_id":"...","input":"..."}'
duvo api GET /v1/agents --query 'limit=10'
```

The CLI authenticates the request using your active profile, so you don't have to handle headers manually.

## Related

* [Public API Reference](https://github.com/duvoai/monorepo/blob/gitbook-prod/knowledge-base/api-reference/README.md) — full schema for every endpoint
* [Managing Connections](/cli/managing-connections.md) — pair with `duvo revision-integrations` to control which Connections an Assignment uses


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.duvo.ai/cli/advanced.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.