openprocessor

#!/bin/bash
# =============================================================================
# OpenProcessor Management CLI
# =============================================================================
# Unified command-line interface for managing OpenProcessor deployments.
# Ships at the root of every install dir (installer plan section 5.5); a
# checkout keeps a 3-line exec shim at scripts/openprocessor.sh so existing
# muscle memory / docs keep working.
#
# Usage: ./openprocessor <command> [options]
# =============================================================================

set -eo pipefail

# =============================================================================
# Configuration
# =============================================================================

# Physical path (-P): compose records the resolved working_dir, and the
# installer compares against the same form.
PROJECT_DIR="$(cd -P "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
SCRIPT_DIR="${PROJECT_DIR}/scripts"
export PROJECT_DIR

# Source library functions
source "${SCRIPT_DIR}/lib/colors.sh"
source "${SCRIPT_DIR}/lib/gpu.sh"
source "${SCRIPT_DIR}/lib/ports.sh"
source "${SCRIPT_DIR}/lib/bind_dirs.sh"
source "${SCRIPT_DIR}/lib/vlm_catalog.sh"
source "${SCRIPT_DIR}/lib/vlm_switch.sh"
source "${SCRIPT_DIR}/lib/retired_env.sh"

# Installer plan section 5.1: every compose call goes through dc(), which
# always passes -p, --env-file and --project-directory. Section 5.5:
# PROJECT_DIR is the directory holding docker-compose.yml, whether that's a
# checkout or an install dir; in a checkout (src/main.py exists next to the
# compose file) it adds the dev overlay for hot-reload.
DC_FILES=(-f "$PROJECT_DIR/docker-compose.yml")
if [[ -f "$PROJECT_DIR/src/main.py" ]]; then
    DC_FILES+=(-f "$PROJECT_DIR/docker-compose.dev.yml")
    IS_CHECKOUT=1
else
    IS_CHECKOUT=0
fi
if [[ -f "$PROJECT_DIR/docker-compose.cpu.yml" ]]; then
    DC_FILES+=(-f "$PROJECT_DIR/docker-compose.cpu.yml")
fi
# The user's own overrides (extra bind mounts, a second source root), last so
# they win. docker-compose.override.yml is not read: the file name is yours.
if [[ -f "$PROJECT_DIR/docker-compose.local.yml" ]]; then
    DC_FILES+=(-f "$PROJECT_DIR/docker-compose.local.yml")
fi

_env_value() {
    local key="$1" file="${2:-$PROJECT_DIR/.env}"
    [[ -f "$file" ]] || return 0
    awk -v k="$key" '{ i = index($0, "=") } i > 1 && substr($0, 1, i - 1) == k { v = substr($0, i + 1) } END { print v }' "$file"
}

# B3: the project name comes from this directory's own .env (and must match
# .install/state.json), never from a default. With nothing resolvable the
# CLI refuses: a default name could be another stack's.
_PROJECT_RESOLVED=""
resolve_project() {
    [[ -n "$_PROJECT_RESOLVED" ]] && return 0
    local from_env from_state=""
    from_env="$(_env_value COMPOSE_PROJECT_NAME)"
    if [[ "$IS_CHECKOUT" != 1 ]]; then
        [[ -f "$PROJECT_DIR/.env" ]] || { log_error "no .env in ${PROJECT_DIR}: not an OpenProcessor install dir"; exit 3; }
        [[ -n "$from_env" ]] || { log_error "${PROJECT_DIR}/.env has no COMPOSE_PROJECT_NAME; refusing to guess a compose project"; exit 3; }
        # The install's own state.json is the proof this directory (and so
        # this project) was created by setup-openprocessor.sh.
        local state="$PROJECT_DIR/.install/state.json" from_dir
        [[ -f "$state" ]] || { log_error "${PROJECT_DIR} has no .install/state.json: not an install made by setup-openprocessor.sh"; exit 3; }
        from_state="$(sed -n -E 's/^  "project": "([^"]*)",?$/\1/p' "$state" | head -n1)"
        from_dir="$(sed -n -E 's/^  "install_dir": "([^"]*)",?$/\1/p' "$state" | head -n1)"
        if [[ "$from_state" != "$from_env" ]]; then
            log_error "project mismatch: .env says '${from_env}', .install/state.json says '${from_state}'"
            exit 3
        fi
        if [[ "$from_dir" != "$PROJECT_DIR" ]]; then
            log_error ".install/state.json belongs to ${from_dir:-another dir}, not ${PROJECT_DIR}"
            exit 3
        fi
    fi
    if [[ -n "$from_env" ]]; then
        if [[ -n "${OP_PROJECT:-}" && "$OP_PROJECT" != "$from_env" ]]; then
            log_error "OP_PROJECT=${OP_PROJECT} conflicts with this directory's project '${from_env}'"
            exit 3
        fi
        OP_PROJECT="$from_env"
    elif [[ -z "${OP_PROJECT:-}" ]]; then
        # Only a checkout gets here: an install dir exited above. docker-compose.yml
        # names the project this way too; assert_project_owned still refuses a
        # project whose containers came from another directory.
        log_warn "no COMPOSE_PROJECT_NAME in ${PROJECT_DIR}/.env: using the default project 'openprocessor' (set COMPOSE_PROJECT_NAME or OP_PROJECT to choose another)"
        OP_PROJECT="openprocessor"
    fi
    if [[ ! "$OP_PROJECT" =~ ^[a-z0-9][a-z0-9_-]*$ ]]; then
        log_error "invalid compose project name '${OP_PROJECT}'"
        exit 3
    fi
    _PROJECT_RESOLVED=1
}

_dc_is_readonly() {
    while (( $# > 0 )); do
        case "$1" in
            --profile) shift 2 ;;
            -*) shift ;;
            config|ps|version|images|ls|logs|port|top) return 0 ;;
            *) return 1 ;;
        esac
    done
    return 1
}

# assert_project_owned PROJECT DIR -- every container labelled with PROJECT
# was created from DIR. Fails closed when Docker cannot be queried.
declare -A _OWNED_OK=()
assert_project_owned() {
    local project="$1" dir="$2" out wd
    [[ -n "${_OWNED_OK[$project]:-}" ]] && return 0
    if ! out="$(docker ps -a --filter "label=com.docker.compose.project=${project}" \
            --format '{{.Names}}|{{.Label "com.docker.compose.project.working_dir"}}' 2>&1)"; then
        log_error "cannot query Docker (${out}); refusing to change project '${project}'"
        exit 5
    fi
    [[ -z "$out" ]] && { _OWNED_OK[$project]=1; return 0; }
    while IFS= read -r wd; do
        wd="${wd#*|}"
        if [[ -z "$wd" ]]; then
            log_error "a container of project '${project}' has no working_dir label; cannot prove ownership, refusing"
            exit 3
        fi
        if [[ "$wd" != "$dir" ]]; then
            log_error "compose project '${project}' belongs to ${wd}, not ${dir}; refusing"
            exit 3
        fi
    done <<< "$out"
    _OWNED_OK[$project]=1
}

# m12: a non-loopback bind must be the one recorded (consented) in .env.
assert_bind_consented() {
    local recorded shell_value="${OP_BIND_ADDRESS:-}"
    recorded="$(_env_value OP_BIND_ADDRESS)"
    [[ -z "$shell_value" || "$shell_value" == "$recorded" || "$shell_value" == 127.* ]] && return 0
    log_error "OP_BIND_ADDRESS=${shell_value} in your shell differs from this install's .env (${recorded:-127.0.0.1});"
    log_error "a public bind needs consent: re-run ./setup-openprocessor.sh --bind ${shell_value}"
    exit 9
}

dc() {
    resolve_project
    local -a cmd=(docker compose -p "$OP_PROJECT")
    [[ -f "$PROJECT_DIR/.env" ]] && cmd+=(--env-file "$PROJECT_DIR/.env")
    cmd+=(--project-directory "$PROJECT_DIR" "${DC_FILES[@]}" "$@")
    if ! _dc_is_readonly "$@"; then
        assert_project_owned "$OP_PROJECT" "$PROJECT_DIR"
        assert_bind_consented
    fi
    if [[ "$IS_CHECKOUT" == 1 ]]; then
        COMPOSE_PROJECT_NAME="$OP_PROJECT" "${cmd[@]}"
    else
        env -u COMPOSE_PROFILES -u COMPOSE_FILE -u COMPOSE_ENV_FILES \
            COMPOSE_PROJECT_NAME="$OP_PROJECT" "${cmd[@]}"
    fi
}

require_checkout() {
    if [[ "$IS_CHECKOUT" != "1" ]]; then
        log_error "'$1' requires a source checkout"
        return 1
    fi
}

# resolve every port from THIS deployment's .env (falling back to the
# stock defaults) instead of hardcoding localhost:4603/4600/4607/4605. On a
# shared host running a second isolated stack (remapped ports via .env),
# the hardcoded literals used to report ANOTHER stack's /health as this
# one's.
API_PORT="$(env_port API_PORT 4603)"
TRITON_HTTP_PORT="$(env_port TRITON_HTTP_PORT 4600)"
OPENSEARCH_PORT="$(env_port OPENSEARCH_PORT 4607)"
GRAFANA_PORT="$(env_port GRAFANA_PORT 4605)"

# Source optional libraries only when needed
load_download_lib() {
    source "${SCRIPT_DIR}/lib/download.sh"
}

load_export_lib() {
    source "${SCRIPT_DIR}/lib/export.sh"
}

load_config_lib() {
    source "${SCRIPT_DIR}/lib/config.sh"
}

# Command groups, loaded by main() only for the command that needs them.
load_cli_core_lib() {
    source "${SCRIPT_DIR}/lib/cli_core.sh"
}

load_cli_dev_lib() {
    source "${SCRIPT_DIR}/lib/cli_dev.sh"
}

load_cli_gpu_lib() {
    source "${SCRIPT_DIR}/lib/cli_gpu.sh"
}

# =============================================================================
# Service Management
# =============================================================================

cmd_start() {
    log_step "Starting OpenProcessor services..."
    cd "$PROJECT_DIR"
    ensure_bind_mount_dirs "$PROJECT_DIR"
    dc up -d --remove-orphans
    log_success "Services started"
    echo ""
    cmd_status
}

cmd_stop() {
    log_step "Stopping OpenProcessor services..."
    cd "$PROJECT_DIR"
    dc down
    log_success "Services stopped"
}

cmd_restart() {
    local service="${1:-}"

    if [[ -n "$service" ]]; then
        log_step "Restarting $service..."
        cd "$PROJECT_DIR"
        dc restart "$service"
        log_success "$service restarted"
    else
        log_step "Restarting all services..."
        cd "$PROJECT_DIR"
        dc restart
        log_success "All services restarted"
    fi
}

cmd_logs() {
    local service="${1:-}"
    local follow="${2:-}"

    cd "$PROJECT_DIR"

    if [[ -n "$service" ]]; then
        if [[ "$follow" == "-f" ]] || [[ "$follow" == "--follow" ]]; then
            dc logs -f "$service"
        else
            dc logs --tail=100 "$service"
        fi
    else
        if [[ "$1" == "-f" ]] || [[ "$1" == "--follow" ]]; then
            dc logs -f
        else
            dc logs --tail=50
        fi
    fi
}

cmd_status() {
    print_header "OpenProcessor Status"

    cd "$PROJECT_DIR"

    # Container status
    echo -e "${BOLD}Containers:${NC}"
    dc ps --format "table {{.Name}}\t{{.Status}}\t{{.Ports}}" 2>/dev/null || \
        dc ps

    echo ""

    # Health checks
    echo -e "${BOLD}Health Checks:${NC}"

    # API health
    local api_status
    api_status=$(curl -s -o /dev/null -w "%{http_code}" "localhost:${API_PORT}/health" 2>/dev/null || echo "000")
    if [[ "$api_status" == "200" ]]; then
        echo -e "  API (${API_PORT}):       ${GREEN}healthy${NC}"
    else
        echo -e "  API (${API_PORT}):       ${RED}unavailable${NC} (HTTP $api_status)"
    fi

    # Triton health
    local triton_status
    triton_status=$(curl -s -o /dev/null -w "%{http_code}" "localhost:${TRITON_HTTP_PORT}/v2/health/ready" 2>/dev/null || echo "000")
    if [[ "$triton_status" == "200" ]]; then
        echo -e "  Triton (${TRITON_HTTP_PORT}):    ${GREEN}healthy${NC}"
    else
        echo -e "  Triton (${TRITON_HTTP_PORT}):    ${RED}unavailable${NC} (HTTP $triton_status)"
    fi

    # OpenSearch health
    local opensearch_status
    opensearch_status=$(curl -s -o /dev/null -w "%{http_code}" "localhost:${OPENSEARCH_PORT}" 2>/dev/null || echo "000")
    if [[ "$opensearch_status" == "200" ]]; then
        echo -e "  OpenSearch (${OPENSEARCH_PORT}): ${GREEN}healthy${NC}"
    else
        echo -e "  OpenSearch (${OPENSEARCH_PORT}): ${RED}unavailable${NC} (HTTP $opensearch_status)"
    fi

    # Grafana health
    local grafana_status
    grafana_status=$(curl -s -o /dev/null -w "%{http_code}" "localhost:${GRAFANA_PORT}/api/health" 2>/dev/null || echo "000")
    if [[ "$grafana_status" == "200" ]]; then
        echo -e "  Grafana (${GRAFANA_PORT}):   ${GREEN}healthy${NC}"
    else
        echo -e "  Grafana (${GRAFANA_PORT}):   ${YELLOW}unavailable${NC}"
    fi

    echo ""

    # GPU status
    if command -v nvidia-smi &> /dev/null; then
        echo -e "${BOLD}GPU:${NC}"
        check_gpu_memory_usage 0
    fi
}

cmd_health() {
    log_info "Checking API health..."

    local response
    response=$(curl -s "localhost:${API_PORT}/health" 2>/dev/null)

    if [[ -n "$response" ]]; then
        echo "$response" | python3 -m json.tool 2>/dev/null || echo "$response"
    else
        log_error "API not responding"
        return 1
    fi
}


# =============================================================================
# Main
# =============================================================================

main() {
    local command="${1:-help}"
    shift 2>/dev/null || true

    # Only here: dc() often runs inside a command substitution, where an exit is swallowed.
    case "$command" in
        help|--help|-h|version) ;;
        *) refuse_retired_env "$PROJECT_DIR/.env" ;;
    esac

    case "$command" in
        start)
            cmd_start "$@"
            ;;
        stop)
            cmd_stop "$@"
            ;;
        restart)
            cmd_restart "$@"
            ;;
        logs)
            cmd_logs "$@"
            ;;
        status)
            cmd_status "$@"
            ;;
        health)
            cmd_health "$@"
            ;;
        models)
            load_cli_core_lib
            cmd_models "$@"
            ;;
        export)
            load_cli_core_lib
            cmd_export "$@"
            ;;
        download)
            load_cli_core_lib
            cmd_download "$@"
            ;;
        profile)
            load_cli_dev_lib
            require_checkout "profile" && cmd_profile "$@"
            ;;
        test)
            load_cli_dev_lib
            require_checkout "test" && cmd_test "$@"
            ;;
        curation)
            load_cli_core_lib
            cmd_curation "$@"
            ;;
        bench)
            load_cli_dev_lib
            require_checkout "bench" && cmd_bench "$@"
            ;;
        clean)
            load_cli_dev_lib
            cmd_clean "$@"
            ;;
        update)
            load_cli_core_lib
            cmd_update "$@"
            ;;
        setup)
            require_checkout "setup" && exec "${SCRIPT_DIR}/setup.sh" "$@"
            ;;
        sample)
            load_cli_core_lib
            cmd_sample "$@"
            ;;
        config)
            load_cli_core_lib
            cmd_config "$@"
            ;;
        gpu)
            load_cli_gpu_lib
            cmd_gpu "$@"
            ;;
        vlm)
            load_cli_gpu_lib
            cmd_vlm "$@"
            ;;
        train-mode)
            load_cli_gpu_lib
            cmd_train_mode "$@"
            ;;
        upgrade)
            load_cli_core_lib
            cmd_upgrade "$@"
            ;;
        repair)
            load_cli_core_lib
            cmd_repair "$@"
            ;;
        uninstall)
            load_cli_core_lib
            cmd_uninstall "$@"
            ;;
        version)
            echo "openprocessor CLI ${OP_CLI_VERSION:-0.6.0}"
            ;;
        help|--help|-h)
            load_cli_core_lib
            show_help
            ;;
        *)
            log_error "Unknown command: $command"
            load_cli_core_lib
            echo ""
            show_help
            exit 1
            ;;
    esac
}

main "$@"