main.py

#!/usr/bin/env python3
import os
import sys
import subprocess
import platform
import time
import socket
import signal
import threading

# --- CONFIGURATION ---
# Path to the directory containing the docker-compose.yml file
VM_DIR = os.path.abspath(os.path.join(os.path.dirname(__file__), "app", "gui"))
# The main python command to run after setup (args added at runtime)
PYTHON_APP_BASE_CMD = [sys.executable, "-m", "app.main"]
# Service readiness check
READY_HOST = "localhost"
READY_PORT = 3001
MAX_WAIT_SECONDS = 60
# ---------------------


# --- HELPER FUNCTIONS ---


def run_command(
    cmd: list,
    cwd: str = None,
    check: bool = True,
    capture: bool = False,
    quiet: bool = False,
) -> subprocess.CompletedProcess:
    """Helper to run subprocess commands robustly."""
    try:
        use_shell = platform.system() == "Windows"
        # Always capture output when quiet mode is enabled
        should_capture = capture or quiet
        result = subprocess.run(
            cmd,
            cwd=cwd,
            check=check,
            shell=use_shell,
            stdout=subprocess.PIPE if should_capture else sys.stdout,
            stderr=subprocess.PIPE if should_capture else sys.stderr,
            text=True if should_capture else False,
        )
        return result
    except subprocess.CalledProcessError as e:
        print(f"\n[ERROR] Command failed: {' '.join(cmd)}")
        if capture or quiet:
            print(f"STDOUT:\n{e.stdout}\nSTDERR:\n{e.stderr}")
        raise
    except FileNotFoundError:
        print(f"\n[ERROR] Command executable not found: {cmd[0]}")
        raise


def is_port_open(host: str, port: int, timeout: int = 1) -> bool:
    """Checks if a TCP port is open on a given host."""
    try:
        with socket.create_connection((host, port), timeout=timeout):
            return True
    except (socket.timeout, ConnectionRefusedError, OSError):
        return False


# --- MAIN LOGIC ---


def main():
    # === IGNORE CTRL+C ===
    # Tell this Python wrapper script to completely ignore SIGINT (Ctrl+C).
    # It will not raise KeyboardInterrupt. It will just keep doing what it's doing.
    # The child process will still receive the signal from the terminal driver.
    if threading.current_thread() is threading.main_thread():
        signal.signal(signal.SIGINT, signal.SIG_IGN)
    # ------------------------------

    # Check if GUI mode is enabled
    # [V1.2.2] GUI mode is temporarily disabled - always force False
    gui_mode_enabled = False  # os.getenv("GUI_MODE_ENABLED", "False").lower() == "true"
    docker_started = False

    # Check if browser startup UI is active (suppress verbose output)
    browser_startup_ui = os.getenv("BROWSER_STARTUP_UI", "0") == "1"

    if not browser_startup_ui:
        print("--- Starting Launch Sequence ---")
    final_exit_code = 0

    # === TRY BLOCK: Setup and Run ===
    try:
        # 1. Start Docker VM (only if GUI mode is enabled)
        if gui_mode_enabled:
            if not browser_startup_ui:
                print("\n[1/3] Launching VM Docker containers in background...")
            if not os.path.isdir(VM_DIR):
                print(f"[ERROR] Docker directory not found: {VM_DIR}")
                sys.exit(1)
            run_command(["docker", "compose", "up", "-d"], cwd=VM_DIR)
            docker_started = True

            # 2. Wait Loop
            if not browser_startup_ui:
                print(
                    f"\n[2/3] Waiting for VM service to be ready on port {READY_PORT}..."
                )
            waited = 0
            while not is_port_open(READY_HOST, READY_PORT):
                if waited >= MAX_WAIT_SECONDS:
                    print(f"\n[ERROR] Timed out waiting for VM port {READY_PORT}.")
                    raise TimeoutError(
                        f"Service on port {READY_PORT} did not become ready."
                    )
                if not browser_startup_ui:
                    print(".", end="", flush=True)
                time.sleep(1)
                waited += 1
            if not browser_startup_ui:
                print(f"\n[OK] VM Service is reachable after {waited}s!")

            # 3. Start Python Agent
            if not browser_startup_ui:
                print("\n[3/3] Launching Python Agent...")
        else:
            if not browser_startup_ui:
                print("\n[1/1] Launching Python Agent (CLI Mode)...")

        if not browser_startup_ui:
            print("--------------------------------")
            print("Type '/exit' or use your defined quit hotkey to stop.")
            print("--------------------------------")

        # Run the main Python app in the foreground.
        # This call BLOCKS until the app exits.
        if getattr(sys, "frozen", False):
            # PyInstaller binary: import and run directly instead of subprocess
            # (sys.executable points to the binary, not Python)
            from app.main import main as app_main

            app_main()
            final_exit_code = 0
        else:
            python_app_cmd = PYTHON_APP_BASE_CMD + sys.argv[1:]
            result = subprocess.run(
                python_app_cmd,
                stdin=sys.stdin,
                stdout=sys.stdout,
                stderr=sys.stderr,
                check=False,
            )
            final_exit_code = result.returncode

    except (subprocess.CalledProcessError, TimeoutError, FileNotFoundError) as e:
        import traceback

        print(f"\n[main] {type(e).__name__}: {e}")
        traceback.print_exc()
        final_exit_code = 1

    except Exception as e:
        import traceback

        print(f"\n[main] Unhandled {type(e).__name__}: {e}")
        traceback.print_exc()
        final_exit_code = 1

    # === FINALLY BLOCK: Guaranteed Cleanup ===
    # This block runs only when the 'try' block finishes naturally or hits a non-signal error.
    finally:
        print(f"\n\n--- Cleanup Initiated (Exit Status: {final_exit_code}) ---")

        # 1. Stop Docker containers (only if started)
        if docker_started:
            print("[*] Stopping Docker VM containers...")
            try:
                run_command(["docker", "compose", "down"], cwd=VM_DIR, check=False)
            except Exception as e:
                print(f"[!] Warning: Error during docker shutdown: {e}")
            # No port sweep afterwards: `compose down` stops exactly the
            # containers we started. Killing whatever else listens on the
            # port would hit processes CraftBot never launched.
        else:
            print("[*] Skipping Docker cleanup (not started in CLI mode).")

        sys.exit(final_exit_code)


if __name__ == "__main__":
    main()