codebox.sh

#!/usr/bin/env bash
set -Eeuo pipefail

# Always surface a useful error message on unexpected failures
trap 'exit_error "🛑 Error: unexpected failure at line $LINENO while running: $BASH_COMMAND"' ERR

# Helper function to print error and exit
exit_error() {
    local message="$1"
    echo "--------------------------------------------------------------------------------" >&2
    echo "$message" >&2
    echo "--------------------------------------------------------------------------------" >&2
    exit 1
}

# Docker cleanup helper to control storage growth
run_docker_prune() {
    local prune_max_age="$1"

    echo "---------------------------------------------------------------"
    echo "🧹 Pruning unused Docker cache and dangling images..."
    echo "   Cache max age: ${prune_max_age}"
    echo "---------------------------------------------------------------"

    if ! docker image prune -f --filter "dangling=true" >/dev/null; then
        echo "⚠️  Warning: docker image prune failed; continuing"
    fi

    if ! docker builder prune -f --filter "until=${prune_max_age}" >/dev/null; then
        echo "⚠️  Warning: docker builder prune failed; continuing"
    fi

    echo "✅ Docker prune complete"
    echo ""
}

# Read a key from .env (returns empty if missing)
read_env_value() {
    local key="$1"
    local env_file="$OPENCODE_DOCKER_DIR/.env"
    if [ -f "$env_file" ]; then
        grep -m1 "^${key}=" "$env_file" 2>/dev/null | cut -d= -f2 || true
    fi
}

# OpenCode Docker script - run from any directory
# Usage: codebox [options] [opencode-arguments]
# Options:
#   -n, --name NAME    Use NAME as the container root directory (temporary override)
#   -u, --update       Rebuild docker and update OpenCode before starting container
#   -b, --bash         Open an interactive bash session instead of running OpenCode
#   -o, --oauth        Enable OAuth callback port (127.0.0.1:1455) for OpenAI sign-in
#   -p, --prune        Prune unused Docker build cache and dangling images before start
#   -f, --force        Continue even in protected directories
#   -h, --help         Show this help and OpenCode help
main() {
    # Parse command line arguments first
    local CLI_CODEBOX_NAME=""
    local OPENCODE_ARGS=()
    local UPDATE_REQUESTED=false
    local HELP_REQUESTED=false
    local BASH_MODE=false
    local FORCE_MODE=false
    local OAUTH_ENABLED=false
    local PRUNE_REQUESTED=false

    while [[ $# -gt 0 ]]; do
        case $1 in
            -n|--name)
                CLI_CODEBOX_NAME="$2"
                shift 2
                ;;
            -u|--update)
                UPDATE_REQUESTED=true
                shift
                ;;
            -b|--bash)
                BASH_MODE=true
                shift
                ;;
            -o|--oauth)
                OAUTH_ENABLED=true
                shift
                ;;
            -p|--prune)
                PRUNE_REQUESTED=true
                shift
                ;;
            -f|--force)
                FORCE_MODE=true
                shift
                ;;
            -h|--help)
                HELP_REQUESTED=true
                OPENCODE_ARGS+=("$1")
                shift
                ;;
            *)
                OPENCODE_ARGS+=("$1")
                shift
                ;;
        esac
    done

    # Path to your OpenCode Docker installation (script directory)
    local SCRIPT_SOURCE="${BASH_SOURCE[0]}"
    local SCRIPT_PATH=""
    if command -v realpath >/dev/null 2>&1; then
        SCRIPT_PATH=$(realpath "$SCRIPT_SOURCE")
    else
        SCRIPT_PATH=$(readlink -f "$SCRIPT_SOURCE")
    fi
    local OPENCODE_DOCKER_DIR="$(dirname "$SCRIPT_PATH")"

    if [ -z "$OPENCODE_DOCKER_DIR" ]; then
        exit_error "🛑 Error: failed to resolve OpenCode Docker directory"
    fi

    if [ "$HELP_REQUESTED" = true ]; then
        echo "---------------------------------------------------------------"
        echo "📦 codebox - OpenCode Docker Launcher"
        echo "---------------------------------------------------------------"
        echo "Usage: codebox [options] [opencode-arguments]"
        echo "Options:"
        echo "  -n, --name NAME    Use NAME as the container root directory (temporary override)"
        echo "  -u, --update       Rebuild docker and update OpenCode before starting container"
        echo "  -b, --bash         Open an interactive bash session instead of running OpenCode"
        echo "  -o, --oauth        Enable OAuth callback port (127.0.0.1:1455) for OpenAI sign-in"
        echo "  -p, --prune        Prune unused Docker build cache and dangling images before start"
        echo "  -f, --force        Continue even in protected directories"
        echo "  -h, --help         Show this help and OpenCode help"
        echo "---------------------------------------------------------------"
    fi

    if ! command -v docker >/dev/null 2>&1; then
        echo "---------------------------------------------------------------"
        echo "🛑 Error: Docker is not installed or not on PATH." >&2
        echo "   Install Docker and ensure the 'docker' CLI is available before running codebox." >&2
        echo "---------------------------------------------------------------"
        exit 1
    fi

    # IMPORTANT: Capture current directory BEFORE any operations
    local WORKSPACE_DIR="$PWD"
    local PROTECTED_DIRS=("$HOME")

    # Load additional protected directories from .env if present
    if [ -f "$OPENCODE_DOCKER_DIR/.env" ]; then
        local PROTECTED_DIRS_ENV=$(read_env_value PROTECTED_DIRS)
        if [ -n "$PROTECTED_DIRS_ENV" ]; then
            # Split colon-separated paths and add to PROTECTED_DIRS array
            IFS=':' read -ra ADDITIONAL_DIRS <<< "$PROTECTED_DIRS_ENV"
            for dir in "${ADDITIONAL_DIRS[@]}"; do
                if [ -n "$dir" ]; then
                    PROTECTED_DIRS+=("$dir")
                fi
            done
        fi
    fi

    # Check if running in a protected directory
    NEEDS_FORCE=false
    FORCE_REASON=""

    # Check exact matches with PROTECTED_DIRS (e.g., $HOME itself)
    for PROTECTED_DIR in "${PROTECTED_DIRS[@]}"; do
        if [ "$WORKSPACE_DIR" = "$PROTECTED_DIR" ]; then
            NEEDS_FORCE=true
            FORCE_REASON="Running in protected directory: $PROTECTED_DIR"
            break
        fi
    done

    # Check if WORKSPACE_DIR is outside $HOME (parent or sibling)
    if [ "$NEEDS_FORCE" = false ]; then
        case "$WORKSPACE_DIR" in
            "$HOME"/*)
                # Inside HOME - safe, no force needed
                ;;
            *)
                # Outside HOME - requires force
                NEEDS_FORCE=true
                FORCE_REASON="Running outside your home directory"
                ;;
        esac
    fi

    # Enforce or warn
    if [ "$NEEDS_FORCE" = true ]; then
        if [ "$FORCE_MODE" = true ]; then
            echo "---------------------------------------------------------------"
            echo "⚠️  Running in 'force' mode, use caution."
            echo "    Reason: $FORCE_REASON"
            echo "---------------------------------------------------------------"
            echo ""
        else
            echo "---------------------------------------------------------------"
            echo "⚠️  $FORCE_REASON"
            echo "    This can be dangerous. To continue anyway, rerun with:"
            echo "    codebox --force"
            echo "---------------------------------------------------------------"
            echo ""
            exit 1
        fi
    fi

    # Capture hostname and working directory name for dynamic container path
    local WORKSPACE_NAME="$(basename "$WORKSPACE_DIR")"
    local CONTAINER_HOSTNAME="$(hostname)"

    # Auto-detect current user's UID/GID
    export USER_UID=$(id -u)
    export USER_GID=$(id -g)

    # Username in container (from .env or default)
    local USERNAME="${USERNAME:-dev}"

    # Check if OpenCode Docker directory exists
    if [ ! -d "$OPENCODE_DOCKER_DIR" ]; then
        exit_error "🛑 Error: OpenCode Docker directory not found at $OPENCODE_DOCKER_DIR"
    fi

    # Derive RELATIVE_PATH from OPENCODE_DOCKER_DIR relative to $HOME
    local RELATIVE_PATH=""
    if [[ "$OPENCODE_DOCKER_DIR" == "$HOME/"* ]]; then
        RELATIVE_PATH="${OPENCODE_DOCKER_DIR#"$HOME"/}"
        if [ -z "$RELATIVE_PATH" ]; then
            exit_error "🛑 Error: OPENCODE_DOCKER_DIR must be inside \$HOME and include at least one subdirectory"
        fi
    else
        exit_error "🛑 Error: OPENCODE_DOCKER_DIR must be under \$HOME to derive RELATIVE_PATH"
    fi

    # Create required host directories for OpenCode
    if [ ! -d ~/.local/share/opencode ] || [ ! -d ~/.local/state/opencode ] || [ ! -d ~/.cache/opencode ]; then
        echo "------------------------------------------------------------------------"
        echo "📁 Missing OpenCode directories used to maintain data and state across sessions..."
        if [ ! -d ~/.local/share/opencode ]; then
            echo "  - Creating directory  [OCData]: ${HOME}/.local/share/opencode"
            mkdir -p ~/.local/share/opencode
        fi
        if [ ! -d ~/.local/state/opencode ]; then
            echo "  - Creating directory [OCState]: ${HOME}/.local/state/opencode"
            mkdir -p ~/.local/state/opencode
        fi
        if [ ! -d ~/.cache/opencode ]; then
            echo "  - Creating directory [OCCache]: ${HOME}/.cache/opencode"
            mkdir -p ~/.cache/opencode
        fi
        echo "------------------------------------------------------------------------"
        echo ""
    fi

    # Check if .env exists
    if [ ! -f "$OPENCODE_DOCKER_DIR/.env" ]; then
        echo "------------------------------------------------------------------------"
        echo "⚠️  Warning: .env file not found at $OPENCODE_DOCKER_DIR/.env"
        echo "    - Creating .env from $OPENCODE_DOCKER_DIR/.env.example..."
        if [ ! -f "$OPENCODE_DOCKER_DIR/.env.example" ]; then
            exit_error "🛑 Error: .env.example not found at $OPENCODE_DOCKER_DIR/.env.example"
        fi
        cp "$OPENCODE_DOCKER_DIR/.env.example" "$OPENCODE_DOCKER_DIR/.env"
        echo ""
        echo "📝  Please edit .env and add your API keys (if needed) before continuing"
        echo "    - Edit: vim $OPENCODE_DOCKER_DIR/.env"
        echo "    - Or: rerun codebox now to use the default settings"
        echo "------------------------------------------------------------------------"
        echo ""
        exit 1
    fi

    # Load CODEBOX_NAME from .env if not already set in environment
    # Priority: 1. CLI argument (-n), 2. Shell environment, 3. .env file, 4. default (BOX)
    local CODEBOX_NAME=""
    if [ -n "$CLI_CODEBOX_NAME" ]; then
        CODEBOX_NAME="$CLI_CODEBOX_NAME"
    elif [ -n "${CODEBOX_NAME_ENV:-}" ]; then
        # Allow persistent setting via CODEBOX_NAME_ENV to avoid pollution
        CODEBOX_NAME="${CODEBOX_NAME_ENV}"
    else
        CODEBOX_NAME=$(read_env_value CODEBOX_NAME)
    fi
    CODEBOX_NAME="${CODEBOX_NAME:-BOX}"
    local CONTAINER_WORKDIR="/${CODEBOX_NAME}/${CONTAINER_HOSTNAME}/${WORKSPACE_NAME}"

    if [ "$UPDATE_REQUESTED" = true ]; then
        echo "---------------------------------------------------------------"
        echo "🔄 Updating OpenCode Docker container..."
        echo "---------------------------------------------------------------"
        # Extract build args from .env
        local DOCKER_PACKAGES=$(read_env_value DOCKER_PACKAGES)
        local OPENCODE_VERSION=$(read_env_value OPENCODE_VERSION)
        local ENABLE_SNAKEMAKE_STACK=$(read_env_value ENABLE_SNAKEMAKE_STACK)
        local SNAKEMAKE_VERSION=$(read_env_value SNAKEMAKE_VERSION)
        OPENCODE_VERSION="${OPENCODE_VERSION:-latest}"
        ENABLE_SNAKEMAKE_STACK="${ENABLE_SNAKEMAKE_STACK:-false}"
        SNAKEMAKE_VERSION="${SNAKEMAKE_VERSION:-8.30}"
        docker build \
            --pull \
            --no-cache \
            --build-arg UID="$USER_UID" \
            --build-arg GID="$USER_GID" \
            --build-arg OPENCODE_VERSION="$OPENCODE_VERSION" \
            --build-arg USERNAME="${USERNAME:-dev}" \
            --build-arg CODEBOX_NAME="$CODEBOX_NAME" \
            --build-arg DOCKER_PACKAGES="$DOCKER_PACKAGES" \
            --build-arg ENABLE_SNAKEMAKE_STACK="$ENABLE_SNAKEMAKE_STACK" \
            --build-arg SNAKEMAKE_VERSION="$SNAKEMAKE_VERSION" \
            -t opencode-dev:latest \
            "$OPENCODE_DOCKER_DIR" || exit_error "🛑 Error: Docker build failed during update"
        echo ""
        echo "✅ Update complete!"
        echo ""
    fi

    # Optional Docker cleanup controls
    local AUTO_PRUNE=$(read_env_value AUTO_PRUNE)
    AUTO_PRUNE="${AUTO_PRUNE:-false}"
    local PRUNE_MAX_AGE=$(read_env_value PRUNE_MAX_AGE)
    PRUNE_MAX_AGE="${PRUNE_MAX_AGE:-168h}"

    # Check if image exists or if it was built with different UID/GID/CODEBOX_NAME
    IMAGE_ENV=$(docker inspect --format '{{range .Config.Env}}{{println .}}{{end}}' opencode-dev:latest 2>/dev/null || true)
    IMAGE_UID=$(printf '%s\n' "$IMAGE_ENV" | awk -F= '$1=="UID"{print $2; exit}')
    IMAGE_GID=$(printf '%s\n' "$IMAGE_ENV" | awk -F= '$1=="GID"{print $2; exit}')
    IMAGE_CODEBOX=$(printf '%s\n' "$IMAGE_ENV" | awk -F= '$1=="CODEBOX_NAME"{print $2; exit}')
    IMAGE_ENABLE_SNAKEMAKE_STACK=$(printf '%s\n' "$IMAGE_ENV" | awk -F= '$1=="ENABLE_SNAKEMAKE_STACK"{print $2; exit}')
    IMAGE_SNAKEMAKE_VERSION=$(printf '%s\n' "$IMAGE_ENV" | awk -F= '$1=="SNAKEMAKE_VERSION"{print $2; exit}')

    ENV_ENABLE_SNAKEMAKE_STACK=$(read_env_value ENABLE_SNAKEMAKE_STACK)
    ENV_SNAKEMAKE_VERSION=$(read_env_value SNAKEMAKE_VERSION)
    ENV_ENABLE_SNAKEMAKE_STACK="${ENV_ENABLE_SNAKEMAKE_STACK:-false}"
    ENV_SNAKEMAKE_VERSION="${ENV_SNAKEMAKE_VERSION:-8.30}"

    NEEDS_REBUILD=false
    REBUILD_REASON=""
    IMAGE_REBUILT=false

    if [ -z "$IMAGE_UID" ] || [ "$IMAGE_UID" != "$USER_UID" ] || [ -z "$IMAGE_GID" ] || [ "$IMAGE_GID" != "$USER_GID" ]; then
        NEEDS_REBUILD=true
        REBUILD_REASON="UID/GID mismatch (image: ${IMAGE_UID:-none}/${IMAGE_GID:-none}, current: $USER_UID/$USER_GID)"
    fi

    if [ -n "$IMAGE_CODEBOX" ] && [ "$IMAGE_CODEBOX" != "$CODEBOX_NAME" ]; then
        NEEDS_REBUILD=true
        if [ -n "$REBUILD_REASON" ]; then
            REBUILD_REASON="$REBUILD_REASON; CODEBOX_NAME changed (image: $IMAGE_CODEBOX, current: $CODEBOX_NAME)"
        else
            REBUILD_REASON="CODEBOX_NAME changed (image: $IMAGE_CODEBOX, current: $CODEBOX_NAME)"
        fi
    fi

    if [ -n "$IMAGE_ENABLE_SNAKEMAKE_STACK" ] && [ "$IMAGE_ENABLE_SNAKEMAKE_STACK" != "$ENV_ENABLE_SNAKEMAKE_STACK" ]; then
        NEEDS_REBUILD=true
        if [ -n "$REBUILD_REASON" ]; then
            REBUILD_REASON="$REBUILD_REASON; ENABLE_SNAKEMAKE_STACK changed (image: $IMAGE_ENABLE_SNAKEMAKE_STACK, current: $ENV_ENABLE_SNAKEMAKE_STACK)"
        else
            REBUILD_REASON="ENABLE_SNAKEMAKE_STACK changed (image: $IMAGE_ENABLE_SNAKEMAKE_STACK, current: $ENV_ENABLE_SNAKEMAKE_STACK)"
        fi
    fi

    if [ -n "$IMAGE_SNAKEMAKE_VERSION" ] && [ "$IMAGE_SNAKEMAKE_VERSION" != "$ENV_SNAKEMAKE_VERSION" ]; then
        NEEDS_REBUILD=true
        if [ -n "$REBUILD_REASON" ]; then
            REBUILD_REASON="$REBUILD_REASON; SNAKEMAKE_VERSION changed (image: $IMAGE_SNAKEMAKE_VERSION, current: $ENV_SNAKEMAKE_VERSION)"
        else
            REBUILD_REASON="SNAKEMAKE_VERSION changed (image: $IMAGE_SNAKEMAKE_VERSION, current: $ENV_SNAKEMAKE_VERSION)"
        fi
    fi

    if [ "$NEEDS_REBUILD" = true ]; then
        echo "---------------------------------------------------------------"
        echo "🏗️  Building OpenCode Docker Image"
        echo "    Reason: $REBUILD_REASON"
        echo "    UID=$USER_UID, GID=$USER_GID, CODEBOX_NAME=$CODEBOX_NAME"
        echo "---------------------------------------------------------------"
        # Extract build args from .env
        local DOCKER_PACKAGES=$(read_env_value DOCKER_PACKAGES)
        local OPENCODE_VERSION=$(read_env_value OPENCODE_VERSION)
        local ENABLE_SNAKEMAKE_STACK=$(read_env_value ENABLE_SNAKEMAKE_STACK)
        local SNAKEMAKE_VERSION=$(read_env_value SNAKEMAKE_VERSION)
        OPENCODE_VERSION="${OPENCODE_VERSION:-latest}"
        ENABLE_SNAKEMAKE_STACK="${ENABLE_SNAKEMAKE_STACK:-false}"
        SNAKEMAKE_VERSION="${SNAKEMAKE_VERSION:-8.30}"
        docker build \
            --build-arg UID="$USER_UID" \
            --build-arg GID="$USER_GID" \
            --build-arg OPENCODE_VERSION="$OPENCODE_VERSION" \
            --build-arg USERNAME="${USERNAME:-dev}" \
            --build-arg CODEBOX_NAME="$CODEBOX_NAME" \
            --build-arg DOCKER_PACKAGES="$DOCKER_PACKAGES" \
            --build-arg ENABLE_SNAKEMAKE_STACK="$ENABLE_SNAKEMAKE_STACK" \
            --build-arg SNAKEMAKE_VERSION="$SNAKEMAKE_VERSION" \
            -t opencode-dev:latest \
            "$OPENCODE_DOCKER_DIR"
        IMAGE_REBUILT=true
    fi

    # Manual prune, or optional prune after rebuild/update
    if [ "$PRUNE_REQUESTED" = true ]; then
        run_docker_prune "$PRUNE_MAX_AGE"
    elif [ "$AUTO_PRUNE" = "true" ] && { [ "$UPDATE_REQUESTED" = true ] || [ "$IMAGE_REBUILT" = true ]; }; then
        run_docker_prune "$PRUNE_MAX_AGE"
    fi

    # Check if HOST_OPENCODE_CONFIG_DIR is set in .env
    local HOST_OPENCODE_CONFIG_DIR=$(read_env_value HOST_OPENCODE_CONFIG_DIR)
    if [ -n "$HOST_OPENCODE_CONFIG_DIR" ]; then
        if [ ! -d "$HOST_OPENCODE_CONFIG_DIR" ]; then
            echo "--------------------------------------------------------------------------------" >&2
            echo "🛑 Error: HOST_OPENCODE_CONFIG_DIR does not exist or is not a directory." >&2
            echo "   Path: $HOST_OPENCODE_CONFIG_DIR" >&2
            echo ""
            echo "   Create it first (2 options), then rerun codebox:" >&2
            echo ""
            echo "   - Option 1: Create an empty directory:" >&2
            echo "       mkdir -p $HOST_OPENCODE_CONFIG_DIR" >&2
            echo ""
            echo "   - Option 2: Copy example config to get started:" >&2
            echo "       cp -R ${OPENCODE_DOCKER_DIR}/config.opencode.example $HOST_OPENCODE_CONFIG_DIR" >&2
            echo "--------------------------------------------------------------------------------" >&2
            exit 1
        fi
    fi

    # Resolve TZ from env/.env with Edmonton default
    local TZ_VALUE="${TZ:-}"
    if [ -z "$TZ_VALUE" ]; then
        TZ_VALUE=$(read_env_value TZ)
    fi
    TZ_VALUE="${TZ_VALUE:-America/Edmonton}"

    # Run OpenCode with current directory as workspace
    echo "---------------------------------------------------------------"
    if [ "$BASH_MODE" = true ]; then
        echo "📦 Starting bash session in: $WORKSPACE_DIR"
    else
        echo "📦 Starting OpenCode in: $WORKSPACE_DIR"
    fi
    echo "   Container path: $CONTAINER_WORKDIR"
    echo "   (UID=$USER_UID, GID=$USER_GID, CODEBOX_NAME=$CODEBOX_NAME, TZ=$TZ_VALUE)"
    echo "   Environment: $OPENCODE_DOCKER_DIR/.env"

    # Read SHOW_MOUNTS setting (default to true if not set)
    local SHOW_MOUNTS=$(read_env_value SHOW_MOUNTS)
    SHOW_MOUNTS="${SHOW_MOUNTS:-true}"

    # Display volume mounts if enabled
    if [ "$SHOW_MOUNTS" = "true" ]; then
        echo "   Volume mounts:"
        echo "   - [Working]  $WORKSPACE_DIR → $CONTAINER_WORKDIR"
        if [ -n "$HOST_OPENCODE_CONFIG_DIR" ]; then
            echo "   - [OCConfig] ${HOST_OPENCODE_CONFIG_DIR} → /home/${USERNAME}/.config/opencode"
        fi
        echo "   - [OCData]   ${HOME}/.local/share/opencode → /home/${USERNAME}/.local/share/opencode"
        echo "   - [OCState]  ${HOME}/.local/state/opencode → /home/${USERNAME}/.local/state/opencode"
        echo "   - [OCCache]  ${HOME}/.cache/opencode → /home/${USERNAME}/.cache/opencode"
        if [ "$OAUTH_ENABLED" = true ]; then
            echo "   OAuth callback: http://127.0.0.1:1455"
        fi
    fi

    echo "---------------------------------------------------------------"
    echo ""
    local CONFIG_MOUNT_ARGS=()
    if [ -n "$HOST_OPENCODE_CONFIG_DIR" ]; then
        CONFIG_MOUNT_ARGS=(-v "${HOST_OPENCODE_CONFIG_DIR}:/home/${USERNAME}/.config/opencode")
    fi

    # Build docker run command with common arguments
    local DOCKER_ARGS=(
        --rm -it
        --cap-drop ALL
        --security-opt no-new-privileges
        --env-file "$OPENCODE_DOCKER_DIR/.env"
        -e CODEBOX_NAME="${CODEBOX_NAME}"
        -e TZ="$TZ_VALUE"
        -e BASH_ENV="/home/${USERNAME}/.bashrc"
        -w "$CONTAINER_WORKDIR"
        -v "$WORKSPACE_DIR:$CONTAINER_WORKDIR"
        "${CONFIG_MOUNT_ARGS[@]}"
        -v "${HOME}/.local/share/opencode:/home/${USERNAME}/.local/share/opencode"
        -v "${HOME}/.local/state/opencode:/home/${USERNAME}/.local/state/opencode"
        -v "${HOME}/.cache/opencode:/home/${USERNAME}/.cache/opencode"
    )

    # Add OAuth port binding if requested
    if [ "$OAUTH_ENABLED" = true ]; then
        DOCKER_ARGS+=(-p 127.0.0.1:1455:1455)
    fi

    # Add bash-specific args if in bash mode
    if [ "$BASH_MODE" = true ]; then
        DOCKER_ARGS+=(--entrypoint /bin/bash)
    fi

    # Run the container
    docker run "${DOCKER_ARGS[@]}" opencode-dev:latest "${OPENCODE_ARGS[@]}"

}

main "$@"