# Main commands

{% hint style="info" %}
These are <mark style="color:blue;">general purpose commands</mark> that will help you to set up and interact with your development environment.
{% endhint %}

## aragon run <a href="#aragon-run" id="aragon-run"></a>

{% hint style="danger" %}
**Warning**

**`aragon run`** commands are deprecated and will be removed in a future release. aragonCLI is not making use of the [Aragon Buidler plugin](https://github.com/aragon/buidler-aragon). For in case your app runs on an older version of aragonCLI, we have left this documentation.

Read [here](/developers/tools/guides/buidler-plugin-migration.md) how to migrate your existing Aragon App to the Buidler plugin.
{% endhint %}

The `run` command **used to** take care of completely setting up the environment needed for running your Aragon app.

```
aragon run
```

These are all the things that running `aragon run` will do for you:

1. It checks whether **IPFS** and a local **Ethereum development chain** (devchain) are running and if not it will start them. Once aragon is terminated, any IPFS or dev chain it started will also be terminated.
2. It will **publish your app** to the local aragonPM registry running in your devchain. This step executes the `aragon apm publish` internally. You can check the options and how the command works in depth [here](/developers/tools/aragoncli/apm-commands.md).
3. Once the package is published it will **create a DAO** with your app installed. If you are running your app without a Template it will grant permissions to the first account printed in the console to perform all the actions protected by the ACL (Access Control List) in your app.
4. After the DAO is created it will download the [Aragon client](https://github.com/aragon/aragon), install its dependencies and start it up so you can interact with the DAO in your web browser.

Available options to customize the `run` command:

* `--reset`: If reset is present it will reset the devchain before running. The chain will then start from scratch and all published packages will need to be recreated.
* `--port`: The port where the devchain will be started.
* `--network-id`: Network id to connect with.
* `--hardfork`: Allows to specify which hardfork should be used. Supported hardforks are byzantium, constantinople, petersburg, and istanbul (default).
* `--block-time`: Specify blockTime in seconds for automatic mining.
* `--accounts`: Number of accounts to print. Defaults to `2`.
* `--files`: The path to the files that will be published. Defaults to the current directory.
* `bump`: Type of bump (major, minor or patch) or version number to publish the app.
* `--build`: A flag to specify whether the webapp should be built while publishing, running the script specified in `build-script` of `package.json`. Defaults to `true`.
* `--build-script`: The name of the NPM script in your app that will be used for building the webapp.
* `--prepublish`: A flag to specify whether to run a prepublish script specified in `prepublish-script` of `package.json`. Defaults to `true`.
* `--prepublish-script`: The name of the NPM script in your app that will be run before publishing the app. Defaults to `prepublishOnly`.
* `--template`: The name of the contract that will be deployed as the [DAO template](/developers/tools/the-basics/templates.md) that will be used to create your DAO. If no Template is provided it will use a default Template that sets up the DAO with just your app (`bare-template.aragonpm.eth`).
* `--template-init [argument1 ... argumentN]`: The constructor arguments for the Template contract, each separated by a space. See the [deploy command](/developers/tools/aragoncli/main-commands.md) for more information on constructor arguments.
* `--template-deploy-event`: Event name that the template will fire on success. Defaults to `DeployDao`.
* `--template-new-instance`: The function on the template that is called to create a new DAO. Defaults to the `newInstance` function for `bare-template.aragonpm.eth`.
* `--template-args`: The arguments that the function to create the template is called with. Defaults to an array of arguments. To use arrays use the following format `["'0xB24b...73a7', '0xB24b...73a7'"]`.
* `--client`: Whether to start the Aragon client or not. Defaults to `true`.
* `--client-version`: Version of Aragon client used to run your sandboxed app.
* `--client-repo`: Repository of Aragon client to clone and run in your sandboxed app. Defaults to `https://github.com/aragon/aragon`.
* `--client-port`: Port being used by Aragon client.
* `--client-path`: A path pointing to an existing Aragon client installation.
* `--app-init`: Name of the function that will be called to initialize an app. Defaults to `initialize`.
* `--app-init-args`: Arguments for calling the app init function. To use arrays use the following format `["'0xB24b...73a7', '0xB24b...73a7'"]`.

**Running your app from a development HTTP server**

`aragon run` by default will replicate Aragon's production environment and publish your app using IPFS. However, when developing the webapp part of your Aragon app, using IPFS would require you to repeat the entire publishing process every time you make a change and want to try it out.

Using the HTTP mode for running your app requires starting an HTTP server to serve your app files before executing `aragon run` or `aragon apm publish`

```
# start your app server before
aragon run --http [server-uri] --http-served-from [path]
```

* `http`: This is the flag that indicates that you wish to run your app using HTTP. The URI of the server must be provided here (e.g. `localhost:4001`).
* `http-served-from`: Path to the directory that the HTTP server exposes. Some artifacts are generated and placed in this directory during the publishing process of your app. The server needs serve these new files when they are created and the server is already running.

If your HTTP server supports hot-reloading your app's frontend will be hot-reloaded inside the Aragon client.

However, when **making changes to the background script** of your app, a refresh of the client is required so the new script can be loaded. Also, depending on how the background script of your app is being built, you may need to manually trigger the compilation of the script.

The [React boilerplate](https://github.com/aragon/aragon-react-boilerplate) supports serving your app using HTTP.

## aragon start <a href="#aragon-start" id="aragon-start"></a>

{% hint style="danger" %}
**Warning**

**`aragon start`** commands are deprecated and will be removed in a future release. aragonCLI is not making use of the [Aragon Buidler plugin](https://github.com/aragon/buidler-aragon). For in case your app runs on an older version of aragonCLI, we have left this documentation.

Read [here](/developers/tools/guides/buidler-plugin-migration.md) how to migrate your existing Aragon App to the Buidler plugin.
{% endhint %}

Start the Aragon GUI (graphical user interface). It uses [aragen](https://github.com/aragon/aragen) snapshot to try fetching a prebuild of the client if it was not previously fetched. Otherwise, the command downloads the client repo and build it to use it locally.

```
aragon start [client-repo] [client-version]
```

* `client-repo`: Repository of Aragon client to clone and run in your sandboxed app. Defaults to `https://github.com/aragon/aragon`.
* `client-version`: Version of Aragon client used to run your sandboxed app (commit hash, branch name or tag name)

Options:

* `--client-port`: Port being used by Aragon client.
* `--client-path`: A path pointing to an existing Aragon client installation.

## aragon devchain <a href="#aragon-devchain" id="aragon-devchain"></a>

The `devchain` command is used for starting a local development testnet with all the required components already deployed and ready to use.

```
aragon devchain
```

It uses [aragen](https://github.com/aragon/aragen) for setting up the snapshot from which the chain starts. At any point `aragon devchain --reset` can be run which will reset the devchain to the original snapshot.

This snapshot contains a local instance of ENS, the first-party [Aragon apps](https://github.com/aragon/aragon-apps) published to aragonPM (e.g. `voting.aragonpm.eth` or `token-manager.aragonpm.eth`) and the first-party [DAO Templates](https://github.com/aragon/dao-templates) (e.g. `bare-template.aragonpm.eth`).

Devchains can be started on different ports and will keep their state independent from other chains.

Options:

* `--reset`: Resets the devchain to the snapshot.
* `--port`: The port number where the devchain will be started. Defaults to `8545`.
* `--network-id`: Network id to connect with.
* `--hardfork`: Allows to specify which hardfork should be used. Supported hardforks are byzantium, constantinople, petersburg, and istanbul (default).
* `--block-time`: Specify blockTime in seconds for automatic mining.
* `--gas-limit`: Block gas limit. Must be specified as a hex string.
* `--accounts`: Number of accounts to print.
* `--verbose`: Enable verbose output. Similar to ganache-cli.

{% hint style="warning" %}
**Note**\
The ENS instance is used both for the aragonPM registry `aragonpm.eth` and for the [aragon-id](https://github.com/aragon/aragon-id) `aragonid.eth`.
{% endhint %}

#### aragon devchain status <a href="#aragon-devchain-status" id="aragon-devchain-status"></a>

Used to check the status of the local devchain.

```
aragon devchain status
```

Options:

* `--port`: The port to check. Defaults to `8545`.

## aragon deploy <a href="#aragon-deploy" id="aragon-deploy"></a>

{% hint style="danger" %}
**Warning**

**`aragon deploy`** commands are deprecated and will be removed in a future release. aragonCLI is not making use of the [Aragon Buidler plugin](https://github.com/aragon/buidler-aragon). In case your app runs on an older version of aragonCLI, we have left this documentation.

Read [here](/developers/tools/guides/buidler-plugin-migration.md) how to migrate your existing Aragon App to the Buidler plugin.
{% endhint %}

The `deploy` command could be used for deploying an Ethereum contract to the devchain.

```
aragon deploy [contract-name] --init [argument1 ... argumentN]
```

The `contract-name` defaults to the contract at the path in arapp.json.

Running `aragon deploy` will compile your contracts using `truffle compile` and will deploy the contract with the constructor arguments provided.

Options:

* `--init`: Arguments to be passed to contract constructor on deploy. Need to be separated by a space. The `@ARAGON_ENS` alias can be used and it will be replaced by the address of the ENS registry in the devchain.

## aragon contracts <a href="#aragon-contracts" id="aragon-contracts"></a>

The `aragon contracts` command can be used to execute commands using the same [truffle](https://github.com/trufflesuite/truffle) version that aragonCLI uses behind the scenes to assist in compiling your app's contracts.

```
aragon contracts <command>
```

It is equivalent to executing `npx truffle <command>`


---

# 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://legacy-docs.aragon.org/developers/tools/aragoncli/main-commands.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.