fix: adding fixes to allow working with local filesystem files when interacting with algokit goal commands

docs/features/goal.md

@@ -78,13 +78,29 @@ $ ~ algokit goal
  Error: Error executing goal; ensure the Sandbox is started by executing `algokit sandbox status`
 ```
 
-## Copying files in to the container
+## 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:
 
-If you want to copy files into the container so you can access them via goal then you can use the following:
+### 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:
+
+```
+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
 

src/algokit/cli/goal.py

@@ -3,7 +3,13 @@
 import click
 
 from algokit.core import proc
-from algokit.core.sandbox import ComposeSandbox
+from algokit.core.goal import (
+    get_volume_mount_path_docker,
+    get_volume_mount_path_local,
+    post_process,
+    preprocess_command_args,
+)
+from algokit.core.sandbox import ComposeFileStatus, ComposeSandbox
 
 logger = logging.getLogger(__name__)
 
@@ -28,6 +34,9 @@ def goal_command(*, console: bool, goal_args: list[str]) -> None:
 
     Look at https://developer.algorand.org/docs/clis/goal/goal/ for more information.
     """
+    volume_mount_path_local = get_volume_mount_path_local()
+    volume_mount_path_docker = get_volume_mount_path_docker()
+    goal_args = list(goal_args)
     try:
         proc.run(["docker", "version"], bad_return_code_error_message="Docker engine isn't running; please start it.")
     except OSError as ex:
@@ -37,22 +46,32 @@ def goal_command(*, console: bool, goal_args: list[str]) -> None:
             "Docker not found; please install Docker and add to path.\n"
             "See https://docs.docker.com/get-docker/ for more information."
         ) from ex
+
+    sandbox = ComposeSandbox()
+    compose_file_status = sandbox.compose_file_status()
+    if compose_file_status is not ComposeFileStatus.UP_TO_DATE:
+        raise click.ClickException("Sandbox definition is out of date; please run `algokit localnet reset` first!")
+
     if console:
         if goal_args:
             logger.warning("--console opens an interactive shell, remaining arguments are being ignored")
         logger.info("Opening Bash console on the algod node; execute `exit` to return to original console")
         result = proc.run_interactive("docker exec -it -w /root algokit_algod bash".split())
     else:
         cmd = "docker exec --interactive --workdir /root algokit_algod goal".split()
-        cmd.extend(goal_args)
+        input_files, output_files, goal_args = preprocess_command_args(
+            goal_args, volume_mount_path_local, volume_mount_path_docker
+        )
+        cmd = cmd + goal_args
         result = proc.run(
             cmd,
             stdout_log_level=logging.INFO,
             prefix_process=False,
             pass_stdin=True,
         )
+        post_process(input_files, output_files, volume_mount_path_local)
+
     if result.exit_code != 0:
-        sandbox = ComposeSandbox()
         ps_result = sandbox.ps("algod")
         match ps_result:
             case [{"State": "running"}]:

src/algokit/core/goal.py

@@ -0,0 +1,80 @@
+import logging
+import re
+import shutil
+from pathlib import Path, PurePath
+
+from algokit.core.conf import get_app_config_dir
+
+logger = logging.getLogger(__name__)
+
+
+def get_volume_mount_path_docker() -> Path:
+    return Path("/root/goal_mount/")
+
+
+def get_volume_mount_path_local() -> Path:
+    return get_app_config_dir().joinpath("sandbox", "goal_mount")
+
+
+def is_path_or_filename(argument: str) -> bool:
+    filename_pattern = re.compile(r"^[\w-]+\.\w+$")
+    return filename_pattern.match(argument) is not None or len(PurePath(argument).parts) > 1
+
+
+def delete_files_from_volume_mount(filename: str, volume_mount_path_docker: Path) -> None:
+    try:
+        volume_mount_path_docker.joinpath(filename).unlink()
+    except Exception as e:
+        logger.error(e)
+
+
+def list_files_in_volume(volume_path: Path) -> list[str]:
+    file_paths = []
+    if volume_path.exists() and volume_path.is_dir():
+        for file in volume_path.rglob("*"):
+            if file.is_file():
+                file_paths.append(str(file))
+    else:
+        logger.error(f"{volume_path} does not exist or is not a directory.")
+    return file_paths
+
+
+def preprocess_command_args(
+    command: list[str], volume_mount_path_local: Path, docker_mount_path_local: Path
+) -> tuple[list[str], list[Path], list[str]]:
+    input_filenames = []
+    output_filenames = []
+    try:
+        for i, arg in enumerate(command):
+            if is_path_or_filename(arg):
+                arg_path = Path(arg)
+                arg_changed = docker_mount_path_local.joinpath(arg_path.name)
+                command[i] = str(arg_changed)
+
+                file_exists = arg_path.exists() or Path.cwd().joinpath(arg_path.name).exists()
+                is_output_arg = i > 0 and command[i - 1] in ["-o", "--outdir", "--outfile"]
+                if file_exists and not is_output_arg:
+                    input_filenames.append(arg_path.name)
+                    shutil.copy(arg_path, volume_mount_path_local)
+                elif is_output_arg:  # it is an output file that is not exist now
+                    output_filenames.append(arg_path)
+                else:
+                    raise FileNotFoundError(f"{arg} does not exist.")
+    except Exception as e:
+        logger.error(e)
+        raise e
+    return input_filenames, output_filenames, command
+
+
+def post_process(input_filenames: list, output_filenames: list[Path], volume_mount_path_local: Path) -> None:
+    for input_filename in input_filenames:
+        delete_files_from_volume_mount(input_filename, volume_mount_path_local)
+
+    files_in_volume_mount = {Path(file).name for file in list_files_in_volume(volume_mount_path_local)}
+    for output_filename in output_filenames:
+        if output_filename.name in files_in_volume_mount:
+            target_path = (
+                output_filename if output_filename.is_absolute() else Path.cwd().joinpath(output_filename.name)
+            )
+            shutil.copy(volume_mount_path_local.joinpath(output_filename.name), target_path)
+            delete_files_from_volume_mount(output_filename.name, volume_mount_path_local)

src/algokit/core/sandbox.py

@@ -185,6 +185,7 @@ def get_docker_compose_yml(
       - type: bind
         source: ./algod_config.json
         target: /etc/algorand/config.json
+      - ./goal_mount:/root/goal_mount
 
   indexer:
     container_name: {name}_indexer