@goplausible/algorand-mcp 3.0.7

package/dist/resources/knowledge/taxonomy/algokit:cli:features:compile.md

@@ -0,0 +1,98 @@
+# AlgoKit Compile
+
+The AlgoKit Compile feature enables you to compile smart contracts (apps) and smart signatures (logic signatures) written in a supported high-level language to a format deployable on the Algorand Virtual Machine (AVM).
+
+When running the compile command, AlgoKit will take care of working out which compiler you need and dynamically resolve it. Additionally, AlgoKit will detect if a matching compiler version is already installed globally on your machine or is included in your project and use that.
+
+## Prerequisites
+
+See [Compile Python - Prerequisites](#prerequisites-1) for details.
+
+## What is Algorand Python & PuyaPy?
+
+Algorand Python is a semantically and syntactically compatible, typed Python language that works with standard Python tooling and allows you to express smart contracts (apps) and smart signatures (logic signatures) for deployment on the Algorand Virtual Machine (AVM).
+
+Algorand Python can be deployed to Algorand by using the PuyaPy optimising compiler, which takes Algorand Python and outputs [ARC-32](https://github.com/algorandfoundation/ARCs/blob/main/ARCs/arc-0032.md) application spec files (among other formats) which, [when deployed](https://github.com/algorandfoundation/algokit-cli/blob/main/docs/features/generate.md#1-typed-clients), will result in AVM bytecode execution semantics that match the given Python code.
+
+If you want to learn more, check out the [PuyaPy docs](https://github.com/algorandfoundation/puya/blob/main/docs/index.md).
+
+Below is an example Algorand Python smart contract.
+
+```py
+from algopy import ARC4Contract, arc4
+
+class HelloWorldContract(ARC4Contract):
+    @arc4.abimethod
+    def hello(self, name: arc4.String) -> arc4.String:
+        return "Hello, " + name
+```
+
+For more complex examples, see the [examples](https://github.com/algorandfoundation/puya/tree/main/examples) in the [PuyaPy repo](https://github.com/algorandfoundation/puya).
+
+## Usage
+
+Available commands and possible usage are as follows:
+
+```
+Usage: algokit compile [OPTIONS] COMMAND [ARGS]...
+
+  Compile smart contracts and smart signatures written in a supported high-level language to a format deployable on
+  the Algorand Virtual Machine (AVM).
+
+Options:
+  -v, --version TEXT  The compiler version to pin to, for example, 1.0.0. If no version is specified, AlgoKit checks
+                      if the compiler is installed and runs the installed version. If the compiler is not installed,
+                      AlgoKit runs the latest version. If a version is specified, AlgoKit checks if an installed
+                      version matches and runs the installed version. Otherwise, AlgoKit runs the specified version.
+  -h, --help          Show this message and exit.
+
+Commands:
+  py      Compile Algorand Python contract(s) using the PuyaPy compiler.
+  python  Compile Algorand Python contract(s) using the PuyaPy compiler.
+```
+
+### Compile Python
+
+The command `algokit compile python` or `algokit compile py` will run the [PuyaPy](https://github.com/algorandfoundation/puya) compiler against the supplied Algorand Python smart contract.
+
+All arguments supplied to the command are passed directly to PuyaPy, therefore this command supports all options supported by the PuyaPy compiler.
+
+Any errors detected by PuyaPy during the compilation process will be printed to the output.
+
+#### Prerequisites
+
+PuyaPy requires Python 3.12+, so please ensure your Python version satisfies this requirement.
+
+This command will attempt to resolve a matching installed PuyaPy compiler, either globally installed in the system or locally installed in your project (via [Poetry](https://python-poetry.org/)). If no appropriate match is found, the PuyaPy compiler will be dynamically run using [pipx](https://pipx.pypa.io/stable/). In this case pipx is also required.
+
+#### Examples
+
+To see a list of the supported PuyaPy options, run the following:
+
+```shell
+algokit compile python -h
+```
+
+To determine the version of the PuyaPy compiler in use, execute the following command:
+
+```shell
+algokit compile python --version
+```
+
+To compile a single Algorand Python smart contract and write the output to a specific location, run the following:
+
+```shell
+algokit compile python hello_world/contract.py --out-dir hello_world/out
+```
+
+To compile multiple Algorand Python smart contracts and write the output to a specific location, run the following:
+
+```shell
+algokit compile python hello_world/contract.py calculator/contract.py --out-dir my_contracts
+```
+
+To compile a directory of Algorand Python smart contracts and write the output to the default location, run the following:
+
+```shell
+algokit compile python my_contracts
+```

package/dist/resources/knowledge/taxonomy/algokit:cli:features:completions.md

@@ -0,0 +1,56 @@
+# AlgoKit Completions
+
+AlgoKit supports shell completions for zsh and bash shells, e.g.
+
+**bash**
+
+```
+$ algokit <Press Tab>
+bootstrap    completions  config       doctor       explore      goal         init         sandbox
+```
+
+**zsh**
+
+```
+$ ~ algokit <Press Tab>
+bootstrap    -- Bootstrap AlgoKit project dependencies.
+completions  -- Install and Uninstall AlgoKit shell integration.
+config       -- Configure AlgoKit options.
+doctor       -- Run the Algorand doctor CLI.
+explore      -- Explore the specified network in the...
+goal         -- Run the Algorand goal CLI against the AlgoKit Sandbox.
+init         -- Initializes a new project.
+sandbox      -- Manage the AlgoKit sandbox.
+```
+
+## Installing
+
+To setup the completions, AlgoKit provides commands that will modify the current users interactive shell script (`.bashrc`/`.zshrc`).
+
+> **Note**
+> If you would prefer AlgoKit to not modify your interactive shell scripts you can install the completions yourself by following the instructions [here](https://click.palletsprojects.com/en/8.1.x/shell-completion/).
+
+To [install](../cli/index.md#install) completions for the current shell execute `algokit completions install`. You should see output similar to below:
+
+```
+$ ~ algokit completions install
+AlgoKit completions installed for zsh 🎉
+Restart shell or run `. ~/.zshrc` to enable completions
+```
+
+After installing the completions don't forget to restart the shell to begin using them!
+
+## Uninstalling
+
+To [uninstall](../cli/index.md#uninstall) completions for the current shell run `algokit completions uninstall`:
+
+```
+$ ~ algokit completions uninstall
+AlgoKit completions uninstalled for zsh 🎉
+```
+
+## Shell Option
+
+To install/uninstall the completions for a specific [shell](../cli/index.md#shell) the `--shell` option can be used e.g. `algokit completions install --shell bash`.
+
+To learn more about the `algokit completions` command, please refer to [completions](../cli/index.md#completions) in the AlgoKit CLI reference documentation.

package/dist/resources/knowledge/taxonomy/algokit:cli:features:config.md

@@ -0,0 +1,37 @@
+# AlgoKit Config
+
+The `algokit config` command allows you to manage various global settings used by AlgoKit CLI. This feature is essential for customizing your AlgoKit environment to suit your needs.
+
+## Usage
+
+This command group provides a set of subcommands to configure AlgoKit settings.
+Subcommands
+
+- `version-prompt`: Configure the version prompt settings.
+- `container-engine`: Configure the container engine settings.
+
+### Version Prompt Configuration
+
+```zsh
+$ algokit config version-prompt [OPTIONS]
+```
+
+This command configures the version prompt settings for AlgoKit.
+
+- `--enable`: Enable the version prompt.
+- `--disable`: Disable the version prompt.
+
+### Container Engine Configuration
+
+```zsh
+$ algokit config container-engine [OPTIONS]
+```
+
+This command configures the container engine settings for AlgoKit.
+
+- `--engine`, -e: Specify the container engine to use (e.g., Docker, Podman). This option is required.
+- `--path`, -p: Specify the path to the container engine executable. Optional.
+
+## Further Reading
+
+For in-depth details, visit the [configuration section](../cli/index.md#config) in the AlgoKit CLI reference documentation.

package/dist/resources/knowledge/taxonomy/algokit:cli:features:dispenser.md

@@ -0,0 +1,90 @@
+# AlgoKit TestNet Dispenser
+
+The AlgoKit Dispenser feature allows you to interact with the AlgoKit TestNet Dispenser. This feature is essential for funding your wallet with TestNet ALGOs, refunding ALGOs back to the dispenser wallet, and getting information about current fund limits on your account.
+
+## Usage
+
+```zsh
+$ algokit dispenser [OPTIONS] COMMAND [ARGS]...
+```
+
+This command provides a set of subcommands to interact with the AlgoKit TestNet Dispenser.
+Subcommands
+
+- `login`: Login to your Dispenser API account.
+- `logout`: Logout of your Dispenser API account.
+- `fund`: Fund your wallet address with TestNet ALGOs.
+- `refund`: Refund ALGOs back to the dispenser wallet address.
+- `limit`: Get information about current fund limits on your account.
+
+### API Documentation
+
+For detailed API documentation, visit the [AlgoKit Dispenser API](https://github.com/algorandfoundation/algokit/blob/main/docs/testnet_api.md) documentation.
+
+### CI Access Token
+
+All dispenser commands can work in CI mode by using a CI access token that can be generated by passing `--ci` flag to `login` command. Once a token is obtained, setting the value to the following environment variable `ALGOKIT_DISPENSER_ACCESS_TOKEN` will enable CI mode for all dispenser commands. If both a user mode and CI mode access token is available, the CI mode will take precedence.
+
+## Login
+
+```zsh
+$ algokit dispenser login [OPTIONS]
+```
+
+This command logs you into your Dispenser API account if you are not already logged in.
+Options
+
+- `--ci`: Generate an access token for CI. Issued for 30 days.
+- `--output`, -o: Output mode where you want to store the generated access token. Defaults to stdout. Only applicable when --ci flag is set.
+- `--file`, -f: Output filename where you want to store the generated access token. Defaults to `ci_token.txt`. Only applicable when --ci flag is set and --output mode is `file`.
+
+> Please note, algokit relies on [keyring](https://pypi.org/project/keyring/) for storing your API credentials. This implies that your credentials are stored in your system's keychain. By default it will prompt for entering your system password unless you have set it up to always allow access for `algokit-cli` to obtain API credentials.
+
+## Logout
+
+```zsh
+$ algokit dispenser logout
+```
+
+This command logs you out of your Dispenser API account if you are logged in.
+
+## Fund
+
+```zsh
+$ algokit dispenser fund [OPTIONS]
+```
+
+This command funds your wallet address with TestNet ALGOs.
+Options
+
+- `--receiver`, -r: Receiver [alias](./tasks/wallet.md#add) or address to fund with TestNet ALGOs. This option is required.
+- `--amount`, -a: Amount to fund. Defaults to microAlgos. This option is required.
+- `--whole-units`: Use whole units (Algos) instead of smallest divisible units (microAlgos). Disabled by default.
+
+## Refund
+
+```zsh
+$ algokit dispenser refund [OPTIONS]
+```
+
+This command refunds ALGOs back to the dispenser wallet address.
+Options
+
+- `--txID`, -t: Transaction ID of your refund operation. This option is required. The receiver address of the transaction must be the same as the dispenser wallet address that you can obtain by observing a `sender` field of [`fund`](#fund) transaction.
+
+> Please note, performing a refund operation will not immedately change your daily fund limit. Your daily fund limit is reset daily at midnigth UTC. If you have reached your daily fund limit, you will not be able to perform a refund operation until your daily fund limit is reset.
+
+## Limit
+
+```zsh
+$ algokit dispenser limit [OPTIONS]
+```
+
+This command gets information about current fund limits on your account. The limits reset daily.
+Options
+
+- `--whole-units`: Use whole units (Algos) instead of smallest divisible units (microAlgos). Disabled by default.
+
+## Further Reading
+
+For in-depth details, visit the [dispenser section](../cli/index.md#dispenser) in the AlgoKit CLI reference documentation.

package/dist/resources/knowledge/taxonomy/algokit:cli:features:doctor.md

@@ -0,0 +1,51 @@
+# AlgoKit Doctor
+
+The AlgoKit Doctor feature allows you to check your AlgoKit installation along with its dependencies. This is useful for diagnosing potential issues with using AlgoKit.
+
+## Functionality
+
+The AlgoKit Doctor allows you to make sure that your system has the correct dependencies installed and that they satisfy the minimum required versions. All passed checks will appear in your command line natural color while warnings will be in yellow (warning) and errors or missing critical services will be in red (error). The critical services that AlgoKit will check for (since they are [directly used by certain commands](../../README.md#prerequisites)): Docker, docker compose and git.
+
+Please run this command to if you are facing an issue running AlgoKit. It is recommended to run it before [submitting an issue to AlgoKit](https://github.com/algorandfoundation/algokit-cli/issues/new). You can copy the contents of the Doctor command message (in Markdown format) to your clipboard by providing the `-c` flag to the command as follows `algokit doctor -c`.
+
+# Examples
+
+For example, running `algokit doctor` with all prerequisites installed will result in output similar to the following:
+
+```
+$ ~ algokit doctor
+timestamp: 2023-03-29T03:58:05+00:00
+AlgoKit: 0.6.0
+AlgoKit Python: 3.11.2 (main, Mar 24 2023, 00:16:47) [Clang 14.0.0 (clang-1400.0.29.202)] (location: /Users/algokit/.local/pipx/venvs/algokit)
+OS: macOS-13.2.1-arm64-arm-64bit
+docker: 20.10.22
+docker compose: 2.15.1
+git: 2.39.1
+python: 3.10.9 (location: /Users/algokit/.asdf/shims/python)
+python3: 3.10.9 (location: /Users/algokit/.asdf/shims/python3)
+pipx: 1.2.0
+poetry: 1.3.2
+node: 18.12.1
+npm: 8.19.2
+brew: 4.0.10-34-gb753315
+
+If you are experiencing a problem with AlgoKit, feel free to submit an issue via:
+https://github.com/algorandfoundation/algokit-cli/issues/new
+Please include this output, if you want to populate this message in your clipboard, run `algokit doctor -c`
+```
+
+The doctor command will indicate if there is any issues to address, for example:
+
+If AlgoKit detects a newer version, this will be indicated next to the AlgoKit version
+```
+AlgoKit: 1.2.3 (latest: 4.5.6)
+```
+
+If the detected version of docker compose is unsupported, this will be shown:
+```
+docker compose: 2.1.3
+  Docker Compose 2.5.0 required to run `algokit localnet command`;
+  install via https://docs.docker.com/compose/install/
+```
+
+For more details about the `AlgoKit doctor` command, please refer to the [AlgoKit CLI reference documentation](../cli/index.md#doctor).

package/dist/resources/knowledge/taxonomy/algokit:cli:features:explore.md

@@ -0,0 +1,21 @@
+# AlgoKit explore
+
+AlgoKit provides a quick shortcut to [explore](../cli/index.md#explore) various Algorand networks using [lora](https://lora.algokit.io/) including [AlgoKit LocalNet](./localnet.md)!
+
+## LocalNet
+
+The following three commands are all equivalent and will open lora pointing to the local [AlgoKit LocalNet](./localnet.md) instance:
+
+- `algokit explore`
+- `algokit explore localnet`
+- `algokit localnet explore`
+
+## Testnet
+
+`algokit explore testnet` will open lora pointing to TestNet via the <https://testnet-api.algonode.cloud> [node](https://algonode.io/api/).
+
+## Mainnet
+
+`algokit explore mainnet` will open lora pointing to MainNet via the <https://mainnet-api.algonode.cloud> [node](https://algonode.io/api/).
+
+To learn more about the `algokit explore` command, please refer to [explore](../cli/index.md#explore) in the AlgoKit CLI reference documentation.

package/dist/resources/knowledge/taxonomy/algokit:cli:features:generate.md

@@ -0,0 +1,179 @@
+# AlgoKit Generate
+
+The `algokit generate` [command](../cli/index.md#generate) is used to generate components used in an AlgoKit project. It also allows for custom generate commands which are loaded from the .algokit.toml file in your project directory.
+
+## 1. Typed clients
+
+The `algokit generate client` [command](../cli/index.md#client) can be used to generate a typed client from an [ARC-0032](https://arc.algorand.foundation/ARCs/arc-0032) or [ARC-0056](https://github.com/algorandfoundation/ARCs/pull/258) application specification with both Python and TypeScript available as target languages.
+
+### Prerequisites
+
+To generate Python clients an installation of pip and pipx is required.
+To generate TypeScript clients an installation of Node.js and npx is also required.
+
+Each generated client will also have a dependency on `algokit-utils` libraries for the target language.
+
+### Input file / directory
+
+You can either specify a path to an ARC-0032 JSON file, an ARC-0056 JSON file or to a directory that is recursively scanned for `application.json`, `*.arc32.json`, `*.arc56.json` file(s).
+
+### Output tokens
+
+The output path is interpreted as relative to the current working directory, however an absolute path may also be specified e.g.
+`algokit generate client application.json --output /absolute/path/to/client.py`
+
+There are two tokens available for use with the `-o`, `--output` [option](../cli/index.md#-o---output-):
+
+- `{contract_name}`: This will resolve to a name based on the ARC-0032/ARC-0056 contract name, formatted appropriately for the target language.
+- `{app_spec_dir}`: This will resolve to the parent directory of the `application.json`, `*.arc32.json`, `*.arc56.json` file which can be useful to output a client relative to its source file.
+
+### Version Pinning
+
+If you want to ensure typed client output stability across different environments and additionally protect yourself from any potential breaking changes introduced in the client generator packages, you can specify a version you'd like to pin to.
+
+To make use of this feature, pass `-v`, `--version`, for example `algokit generate client --version 1.2.3 path/to/application.json`.
+
+Alternatively, you can achieve output stability by installing the underlying [Python](https://github.com/algorandfoundation/algokit-client-generator-py) or [TypeScript](https://github.com/algorandfoundation/algokit-client-generator-ts) client generator package either locally in your project (via `poetry` or `npm` respectively) or globally on your system (via `pipx` or `npm` respectively). AlgoKit will search for a matching installed version before dynamically resolving.
+
+### Usage
+
+Usage examples of using a generated client are below, typed clients allow your favourite IDE to provide better intellisense to provide better discoverability
+of available operations and parameters.
+
+#### Python
+
+```python
+# A similar working example can be seen in the algokit python template, when using Python deployment
+from smart_contracts.artifacts.HelloWorldApp.client import (
+    HelloWorldAppClient,
+)
+
+app_client = HelloWorldAppClient(
+    algod_client,
+    creator=deployer,
+    indexer_client=indexer_client,
+)
+deploy_response = app_client.deploy(
+    on_schema_break=OnSchemaBreak.ReplaceApp,
+    on_update=OnUpdate.UpdateApp,
+    allow_delete=True,
+    allow_update=True,
+)
+
+response = app_client.hello(name="World")
+```
+
+#### TypeScript
+
+```typescript
+// A similar working example can be seen in the algokit python template with typescript deployer, when using TypeScript deployment
+import { HelloWorldAppClient } from "./artifacts/HelloWorldApp/client";
+
+const appClient = new HelloWorldAppClient(
+  {
+    resolveBy: "creatorAndName",
+    findExistingUsing: indexer,
+    sender: deployer,
+    creatorAddress: deployer.addr,
+  },
+  algod
+);
+const app = await appClient.deploy({
+  allowDelete: isLocal,
+  allowUpdate: isLocal,
+  onSchemaBreak: isLocal ? "replace" : "fail",
+  onUpdate: isLocal ? "update" : "fail",
+});
+const response = await appClient.hello({ name: "world" });
+```
+
+### Examples
+
+To output a single application.json to a python typed client:
+`algokit generate client path/to/application.json --output client.py`
+
+To process multiple application.json in a directory structure and output to a typescript client for each in the current directory:
+`algokit generate client smart_contracts/artifacts --output {contract_name}.ts`
+
+To process multiple application.json in a directory structure and output to a python client alongside each application.json:
+`algokit generate client smart_contracts/artifacts --output {app_spec_path}/client.py`
+
+## 2. Using Custom Generate Commands
+
+Custom generate commands are defined in the `.algokit.toml` file within the project directory, typically supplied by community template builders or official AlgoKit templates. These commands are specified under the `generate` key and serve to execute a generator at a designated path with provided answer key/value pairs.
+
+### Understanding `Generators`
+
+A `generator` is essentially a compact, self-sufficient `copier` template. This template can optionally be defined within the primary `algokit templates` to offer supplementary functionality after a project is initialized from the template. For instance, the official [`algokit-python-template`](https://github.com/algorandfoundation/algokit-python-template/tree/main/template_content) provides a generator within the `.algokit/generators` directory. This generator can be employed for executing extra tasks on AlgoKit projects that have been initiated from this template, such as adding new smart contracts to an existing project. For a comprehensive explanation, please refer to the [`architecture decision record`](../architecture-decisions/2023-07-19_advanced_generate_command.md).
+
+### Requirements
+
+To utilize custom generate commands, you must have `copier` installed. This installation is included by default in the AlgoKit CLI. Therefore, no additional installation is necessary if you have already installed the `algokit cli`.
+
+### How to Use
+
+A custom command can be defined in the `.algokit.toml` as shown:
+
+```toml
+[generate.my_generator]
+path = "path/to/my_generator"
+description = "A brief description of the function of my_generator"
+```
+
+Following this, you can execute the command as follows:
+
+`algokit generate my_generator --answer key value --path path/to/my_generator`
+
+If no `path` is given, the command will use the path specified in the `.algokit.toml`. If no `answer` is provided, the command will initiate an interactive `copier` prompt to request answers (similar to `algokit init`).
+
+The custom command employs the `copier` library to duplicate the files from the generator's path to the current working directory, substituting any values from the `answers` dictionary.
+
+### Examples
+
+As an example, let's use the `smart-contract` generator from the `algokit-python-template` to add new contract to an existing project based on that template. The `smart-contract` generator is defined as follows:
+
+```toml
+[algokit]
+min_version = "v1.3.1"
+
+... # other keys
+
+[generate.smart_contract]
+description = "Adds a new smart contract to the existing project"
+path = ".algokit/generators/create_contract"
+```
+
+To execute this generator, ensure that you are operating from the same directory as the `.algokit.toml` file, and then run:
+
+```bash
+$ algokit generate
+
+# The output will be as follows:
+# Note how algokit dynamically injects a new `smart-contract` command based
+# on the `.algokit.toml` file
+
+Usage: algokit generate [OPTIONS] COMMAND [ARGS]...
+
+  Generate code for an Algorand project.
+
+Options:
+  -h, --help  Show this message and exit.
+
+Commands:
+  client          Create a typed ApplicationClient from an ARC-32 application.json
+  smart-contract  Adds a new smart contract to the existing project
+```
+
+To execute the `smart-contract` generator, run:
+
+```bash
+$ algokit generate smart-contract
+
+# or
+
+$ algokit generate smart-contract -a contract_name "MyCoolContract"
+```
+
+#### Third Party Generators
+
+It is important to understand that by default, AlgoKit will always prompt you before executing a generator to ensure it's from a trusted source. If you are confident about the source of the generator, you can use the `--force` or `-f` option to execute the generator without this confirmation prompt. Be cautious while using this option and ensure the generator is from a trusted source. At the moment, a trusted source for a generator is defined as _a generator that is included in the official AlgoKit templates (e.g. `smart-contract` generator in `algokit-python-template`)_

package/dist/resources/knowledge/taxonomy/algokit:cli:features:goal.md

@@ -0,0 +1,139 @@
+# AlgoKit goal
+
+AlgoKit goal command provides the user with a mechanism to run [goal cli](https://developer.algorand.org/docs/clis/goal/goal/) commands against the current [AlgoKit LocalNet](./localnet.md).
+
+You can explore all possible goal commands by running `algokit goal` e.g.:
+
+```
+$ ~ algokit goal
+ GOAL is the CLI for interacting Algorand software instance. The binary 'goal' is installed alongside the algod binary and is considered an integral part of the complete installation. The binaries should be used in tandem - you should not try to use a version of goal with a different version of algod.
+
+ Usage:
+ goal [flags]
+ goal [command]
+
+ Available Commands:
+ account     Control and manage Algorand accounts
+ app         Manage applications
+ asset       Manage assets
+ clerk       Provides the tools to control transactions
+ completion  Shell completion helper
+ help        Help about any command
+ kmd         Interact with kmd, the key management daemon
+ ledger      Access ledger-related details
+ license     Display license information
+ logging     Control and manage Algorand logging
+ network     Create and manage private, multi-node, locally-hosted networks
+ node        Manage a specified algorand node
+ protocols
+ report
+ version     The current version of the Algorand daemon (algod)
+ wallet      Manage wallets: encrypted collections of Algorand account keys
+
+ Flags:
+ -d, --datadir stringArray   Data directory for the node
+ -h, --help                  help for goal
+ -k, --kmddir string         Data directory for kmd
+ -v, --version               Display and write current build version and exit
+
+ Use "goal [command] --help" for more information about a command.
+```
+
+For instance, running `algokit goal report` would result in output like:
+
+```
+$ ~ algokit goal report
+ 12885688322
+ 3.12.2.dev [rel/stable] (commit #181490e3)
+ go-algorand is licensed with AGPLv3.0
+ source code available at https://github.com/algorand/go-algorand
+
+ Linux ff7828f2da17 5.15.49-linuxkit #1 SMP PREEMPT Tue Sep 13 07:51:32 UTC 2022 aarch64 GNU/Linux
+
+ Genesis ID from genesis.json: sandnet-v1
+
+ Last committed block: 0
+ Time since last block: 0.0s
+ Sync Time: 0.0s
+ Last consensus protocol: future
+ Next consensus protocol: future
+ Round for next consensus protocol: 1
+ Next consensus protocol supported: true
+ Last Catchpoint:
+ Genesis ID: sandnet-v1
+ Genesis hash: vEg1NCh6SSXwS6O5HAfjYCCNAs4ug328s3RYMr9syBg=
+```
+
+If the AlgoKit Sandbox `algod` docker container is not present or not running, the command will fail with a clear error, e.g.:
+
+```
+$ ~ algokit goal
+ Error: No such container: algokit_algod
+ Error: Error executing goal; ensure the Sandbox is started by executing `algokit sandbox status`
+```
+
+```
+$ ~ algokit goal
+ Error response from daemon: Container 5a73961536e2c98e371465739053d174066c40d00647c8742f2bb39eb793ed7e is not running
+ Error: Error executing goal; ensure the Sandbox is started by executing `algokit sandbox status`
+```
+
+## Working with Files in the Container
+
+When interacting with the container, especially if you're using tools like goal, you might need to reference files or directories. Here's how to efficiently deal with files and directories:
+
+### Automatic File Mounting
+
+When you specify a file or directory path in your `goal` command, the system will automatically mount that path from your local filesystem into the container. This way, you don't need to copy files manually each time.
+
+For instance, if you want to compile a `teal` file:
+
+```
+algokit goal clerk compile /Path/to/inputfile/approval.teal -o /Path/to/outputfile/approval.compiled
+```
+
+Here, `/Path/to/inputfile/approval.teal` and `/Path/to/outputfile/approval.compiled` are paths on your local file system, and they will be automatically accessible to the `goal` command inside the container.
+
+### Manual Copying of Files
+
+In case you want to manually copy files into the container, you can do so using `docker cp`:
+
+```
+docker cp foo.txt algokit_algod:/root
+```
+
+This command copies the `foo.txt` from your local system into the root directory of the `algokit_algod` container.
+
+Note: Manual copying is optional and generally only necessary if you have specific reasons for doing so since the system will auto-mount paths specified in commands.
+
+## Running multiple commands
+
+If you want to run multiple commands or interact with the filesystem you can execute `algokit goal --console`. This will open a [Bash](https://www.gnu.org/software/bash/) shell session on the `algod` Docker container and from there you can execute goal directly, e.g.:
+
+```bash
+$ algokit goal --console
+Opening Bash console on the algod node; execute `exit` to return to original console
+root@82d41336608a:~# goal account list
+[online]        C62QEFC7MJBPHAUDMGVXGZ7WRWFAF3XYPBU3KZKOFHYVUYDGU5GNWS4NWU      C62QEFC7MJBPHAUDMGVXGZ7WRWFAF3XYPBU3KZKOFHYVUYDGU5GNWS4NWU      4000000000000000 microAlgos
+[online]        DVPJVKODAVEKWQHB4G7N6QA3EP7HKAHTLTZNWMV4IVERJQPNGKADGURU7Y      DVPJVKODAVEKWQHB4G7N6QA3EP7HKAHTLTZNWMV4IVERJQPNGKADGURU7Y      4000000000000000 microAlgos
+[online]        4BH5IKMDDHEJEOZ7T5LLT4I7EVIH5XCOTX3TPVQB3HY5TUBVT4MYXJOZVA      4BH5IKMDDHEJEOZ7T5LLT4I7EVIH5XCOTX3TPVQB3HY5TUBVT4MYXJOZVA      2000000000000000 microAlgos
+```
+
+## Interactive Mode
+
+Some `goal` commands require interactive input from the user. By default, AlgoKit will attempt to run commands in non-interactive mode first, and automatically switch to interactive mode if needed. You can force a command to run in interactive mode by using the `--interactive` flag:
+
+```bash
+$ algokit goal --interactive wallet new algodev
+Please choose a password for wallet 'algodev':
+Please confirm the password:
+Creating wallet...
+Created wallet 'algodev'
+Your new wallet has a backup phrase that can be used for recovery.
+Keeping this backup phrase safe is extremely important.
+Would you like to see it now? (Y/n): n
+```
+
+This is particularly useful when you know a command will require user input, such as creating new accounts, importing keys, or signing transactions.
+
+For more details about the `AlgoKit goal` command, please refer to the [AlgoKit CLI reference documentation](../cli/index.md#goal).