code-aide 1.0.0__py3-none-any.whl

code_aide/install.py

@@ -0,0 +1,305 @@
+"""Install implementations for script, npm, and direct-download tools."""
+
+import hashlib
+import io
+import os
+import platform
+import shutil
+import subprocess
+import tarfile
+from typing import Any, Dict, Optional
+
+from code_aide.constants import TOOLS
+from code_aide.console import command_exists, error, info, run_command, success, warning
+from code_aide.versions import fetch_url
+
+
+def run_install_script(
+    install_url: str,
+    tool_name: str,
+    expected_sha256: Optional[str] = None,
+    dryrun: bool = False,
+) -> bool:
+    """Download and run an installation script with SHA256 verification."""
+    try:
+        info(f"Downloading install script from: {install_url}")
+        script_content, _ = fetch_url(install_url)
+
+        if expected_sha256:
+            info("Verifying script integrity with SHA256...")
+            actual_sha256 = hashlib.sha256(script_content).hexdigest()
+
+            if actual_sha256 != expected_sha256:
+                error(f"SHA256 verification FAILED for {tool_name}!")
+                error(f"Expected: {expected_sha256}")
+                error(f"Actual:   {actual_sha256}")
+                error("")
+                error("The install script has changed and needs to be reviewed.")
+                error("This could indicate a security issue or a legitimate update.")
+                error(
+                    "Please review the new script and update the SHA256 if it's safe."
+                )
+                return False
+
+            success("SHA256 verification passed")
+        else:
+            warning(
+                "No SHA256 checksum configured - script integrity cannot be verified!"
+            )
+
+        if dryrun:
+            info(f"[DRYRUN] Would execute install script for {tool_name}")
+            return True
+
+        warning(f"About to execute install script for {tool_name}")
+        warning("This will run with your user privileges. Press Ctrl+C to cancel.")
+
+        bash_process = subprocess.Popen(
+            ["bash"],
+            stdin=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+        )
+        _, stderr = bash_process.communicate(input=script_content)
+
+        if bash_process.returncode == 0:
+            return True
+
+        stderr_text = stderr.decode("utf-8", errors="replace")
+        error(f"Failed to install {tool_name}: {stderr_text}")
+        return False
+    except subprocess.CalledProcessError as exc:
+        error(f"Failed to download install script for {tool_name}: {exc.stderr}")
+        return False
+    except Exception as exc:
+        error(f"Failed to install {tool_name}: {exc}")
+        return False
+
+
+ARCH_MAP = {
+    "x86_64": "x64",
+    "amd64": "x64",
+    "arm64": "arm64",
+    "aarch64": "arm64",
+}
+
+
+def detect_os_arch() -> tuple:
+    """Detect OS and architecture for direct download URLs."""
+    os_name = platform.system().lower()
+    if os_name not in ("linux", "darwin"):
+        raise RuntimeError(f"Unsupported OS: {os_name}")
+
+    machine = platform.machine()
+    arch = ARCH_MAP.get(machine)
+    if not arch:
+        raise RuntimeError(f"Unsupported architecture: {machine}")
+
+    return os_name, arch
+
+
+def extract_tar_member(
+    tar_file: tarfile.TarFile, member: tarfile.TarInfo, destination: str
+) -> None:
+    """Extract a tar member using the safest API available."""
+    try:
+        tar_file.extract(member, destination, filter="data")
+    except TypeError:
+        tar_file.extract(member, destination)
+
+
+def install_direct_download(
+    tool_name: str,
+    tool_config: Dict[str, Any],
+    dryrun: bool = False,
+    install_dir_override: Optional[str] = None,
+    bin_dir_override: Optional[str] = None,
+) -> bool:
+    """Download, extract, and install a tool via direct tarball download."""
+    try:
+        version = tool_config["latest_version"]
+        install_url = tool_config["install_url"]
+        expected_sha256 = tool_config.get("install_sha256")
+
+        info(f"Verifying install script from: {install_url}")
+        script_content, _ = fetch_url(install_url)
+
+        if expected_sha256:
+            actual_sha256 = hashlib.sha256(script_content).hexdigest()
+            if actual_sha256 != expected_sha256:
+                error(f"SHA256 verification FAILED for {tool_name} install script!")
+                error(f"Expected: {expected_sha256}")
+                error(f"Actual:   {actual_sha256}")
+                error("")
+                error("The install script has changed and needs to be reviewed.")
+                return False
+            success("Install script SHA256 verified")
+
+        os_name, arch = detect_os_arch()
+        info(f"Platform: {os_name}/{arch}")
+
+        url_template = tool_config["download_url_template"]
+        download_url = url_template.format(version=version, os=os_name, arch=arch)
+        info(f"Download URL: {download_url}")
+
+        install_dir_template = tool_config["install_dir"]
+        install_dir = os.path.expanduser(install_dir_template.format(version=version))
+        bin_dir = os.path.expanduser(tool_config["bin_dir"])
+
+        if install_dir_override:
+            install_dir = install_dir_override
+        if bin_dir_override:
+            bin_dir = bin_dir_override
+
+        if dryrun:
+            info(f"[DRYRUN] Would download: {download_url}")
+            info(f"[DRYRUN] Would extract to: {install_dir}")
+            info(f"[DRYRUN] Would create symlinks in: {bin_dir}")
+            for link_name, target in tool_config.get("symlinks", {}).items():
+                info(f"[DRYRUN]   {link_name} -> {install_dir}/{target}")
+            return True
+
+        info("Downloading package...")
+        tarball_data, _ = fetch_url(download_url, timeout=120)
+        success(f"Downloaded {len(tarball_data)} bytes")
+
+        temp_dir = install_dir + f".tmp-{os.getpid()}"
+        os.makedirs(temp_dir, exist_ok=True)
+
+        try:
+            with tarfile.open(fileobj=io.BytesIO(tarball_data), mode="r:gz") as tf:
+                for member in tf.getmembers():
+                    parts = member.name.split("/", 1)
+                    if len(parts) <= 1 and not member.isdir():
+                        continue
+                    if len(parts) > 1:
+                        member_name = parts[1]
+                    else:
+                        continue
+
+                    normalized_name = os.path.normpath(member_name)
+                    if normalized_name in ("", "."):
+                        continue
+                    if normalized_name.startswith("..") or os.path.isabs(
+                        normalized_name
+                    ):
+                        continue
+
+                    member.name = normalized_name
+                    extract_tar_member(tf, member, temp_dir)
+
+            if os.path.exists(install_dir):
+                shutil.rmtree(install_dir)
+            os.rename(temp_dir, install_dir)
+            success(f"Extracted to {install_dir}")
+
+        except Exception:
+            if os.path.exists(temp_dir):
+                shutil.rmtree(temp_dir)
+            raise
+
+        os.makedirs(bin_dir, exist_ok=True)
+        symlinks = tool_config.get("symlinks", {})
+        for link_name, target_name in symlinks.items():
+            link_path = os.path.join(bin_dir, link_name)
+            target_path = os.path.join(install_dir, target_name)
+
+            if os.path.lexists(link_path):
+                os.remove(link_path)
+
+            os.symlink(target_path, link_path)
+            info(f"Symlink: {link_path} -> {target_path}")
+
+        success(f"{tool_config['name']} installed successfully")
+        return True
+
+    except RuntimeError as exc:
+        error(str(exc))
+        return False
+    except Exception as exc:
+        error(f"Failed to install {tool_name}: {exc}")
+        return False
+
+
+def install_tool(tool_name: str, dryrun: bool = False) -> bool:
+    """Install a tool based on its configuration."""
+    tool_config = TOOLS.get(tool_name)
+    if not tool_config:
+        error(f"Unknown tool: {tool_name}")
+        return False
+
+    if dryrun:
+        info(f"[DRYRUN] Checking {tool_config['name']}...")
+    else:
+        info(f"Installing {tool_config['name']}...")
+
+    if command_exists(tool_config["command"]):
+        tool_path = shutil.which(tool_config["command"])
+        if dryrun:
+            info(f"{tool_config['command']} already installed at {tool_path}")
+        else:
+            warning(f"{tool_config['command']} already installed at {tool_path}")
+        return True
+
+    try:
+        install_type = tool_config["install_type"]
+
+        if install_type == "npm":
+            npm_package = tool_config["npm_package"]
+            if dryrun:
+                info(f"[DRYRUN] Would install npm package: {npm_package}")
+            else:
+                run_command(["npm", "install", "-g", npm_package], check=True)
+                success(f"{tool_config['name']} installed successfully")
+                info(tool_config["next_steps"])
+                if "docs_url" in tool_config:
+                    info(f"Documentation: {tool_config['docs_url']}")
+
+        elif install_type == "script":
+            install_url = tool_config["install_url"]
+            expected_sha256 = tool_config.get("install_sha256")
+            if run_install_script(
+                install_url, tool_config["name"], expected_sha256, dryrun
+            ):
+                if dryrun:
+                    success(f"{tool_config['name']} verification passed")
+                else:
+                    success(f"{tool_config['name']} installed successfully")
+                    info(tool_config["next_steps"])
+                    if "docs_url" in tool_config:
+                        info(f"Documentation: {tool_config['docs_url']}")
+            else:
+                return False
+
+        elif install_type == "direct_download":
+            if install_direct_download(tool_name, tool_config, dryrun):
+                if dryrun:
+                    success(f"{tool_config['name']} verification passed")
+                else:
+                    info(tool_config["next_steps"])
+                    if "docs_url" in tool_config:
+                        info(f"Documentation: {tool_config['docs_url']}")
+            else:
+                return False
+
+        elif install_type == "self_managed":
+            npm_package = tool_config.get("npm_package")
+            if not npm_package:
+                error(f"No npm package configured for {tool_config['name']}")
+                return False
+            if dryrun:
+                info(f"[DRYRUN] Would install npm package: {npm_package}")
+            else:
+                run_command(["npm", "install", "-g", npm_package], check=True)
+                success(f"{tool_config['name']} installed successfully")
+                info(tool_config["next_steps"])
+                if "docs_url" in tool_config:
+                    info(f"Documentation: {tool_config['docs_url']}")
+
+        return True
+
+    except subprocess.CalledProcessError as exc:
+        error(f"Failed to install {tool_config['name']}: {exc.stderr}")
+        return False
+    except Exception as exc:
+        error(f"Failed to install {tool_config['name']}: {exc}")
+        return False

code_aide/operations.py

@@ -0,0 +1,264 @@
+"""Upgrade and remove operations for managed tools."""
+
+import glob as globmod
+import os
+import shutil
+import subprocess
+import sys
+from typing import List
+
+from code_aide.constants import TOOLS
+from code_aide.detection import detect_install_method
+from code_aide.install import install_direct_download, run_install_script
+from code_aide.console import error, info, run_command, success, warning
+from code_aide.prereqs import is_tool_installed
+
+
+def upgrade_tool(tool_name: str) -> bool:
+    """Upgrade a tool based on its configuration."""
+    tool_config = TOOLS.get(tool_name)
+    if not tool_config:
+        error(f"Unknown tool: {tool_name}")
+        return False
+
+    if not is_tool_installed(tool_name):
+        warning(f"{tool_config['name']} is not installed. Use 'install' command first.")
+        return False
+
+    install_info = detect_install_method(tool_name)
+    method = install_info["method"]
+    detail = install_info["detail"]
+
+    info(f"Upgrading {tool_config['name']} (installed via {method})...")
+
+    try:
+        if method == "brew_formula":
+            run_command(["brew", "upgrade", detail], check=True, capture=False)
+            success(f"{tool_config['name']} upgraded successfully")
+
+        elif method == "brew_cask":
+            run_command(
+                ["brew", "upgrade", "--cask", detail], check=True, capture=False
+            )
+            success(f"{tool_config['name']} upgraded successfully")
+
+        elif method in ("npm", "brew_npm"):
+            npm_package = detail or tool_config.get("npm_package")
+            if not npm_package:
+                error(f"No npm package configured for {tool_config['name']}")
+                return False
+            run_command(["npm", "install", "-g", f"{npm_package}@latest"], check=True)
+            success(f"{tool_config['name']} upgraded successfully")
+
+        elif method == "script":
+            install_url = tool_config["install_url"]
+            expected_sha256 = tool_config.get("install_sha256")
+            if run_install_script(install_url, tool_config["name"], expected_sha256):
+                success(f"{tool_config['name']} upgraded successfully")
+            else:
+                return False
+
+        elif method == "direct_download":
+            if not install_direct_download(tool_name, tool_config):
+                return False
+
+        elif method == "self_managed":
+            upgrade_cmd = tool_config.get("upgrade_command")
+            if not upgrade_cmd:
+                error(f"No upgrade_command configured for {tool_config['name']}")
+                return False
+            run_command(upgrade_cmd, check=True, capture=False)
+            success(f"{tool_config['name']} upgraded successfully")
+
+        elif method == "system":
+            error(
+                f"{tool_config['name']} is managed by the system package manager. "
+                "Use your package manager to upgrade it."
+            )
+            return False
+
+        else:
+            error(
+                f"Don't know how to upgrade {tool_config['name']} "
+                f"(install method: {method})"
+            )
+            return False
+
+        return True
+
+    except subprocess.CalledProcessError as exc:
+        error(f"Failed to upgrade {tool_config['name']}: {exc.stderr}")
+        return False
+    except Exception as exc:
+        error(f"Failed to upgrade {tool_config['name']}: {exc}")
+        return False
+
+
+def remove_tool(tool_name: str) -> bool:
+    """Remove a tool based on its configuration."""
+    tool_config = TOOLS.get(tool_name)
+    if not tool_config:
+        error(f"Unknown tool: {tool_name}")
+        return False
+
+    if not is_tool_installed(tool_name):
+        warning(f"{tool_config['name']} is not installed.")
+        return True
+
+    install_info = detect_install_method(tool_name)
+    method = install_info["method"]
+    detail = install_info["detail"]
+
+    info(f"Removing {tool_config['name']} (installed via {method})...")
+
+    try:
+        if method == "brew_formula":
+            run_command(["brew", "uninstall", detail], check=True, capture=False)
+            success(f"{tool_config['name']} removed successfully")
+
+        elif method == "brew_cask":
+            run_command(
+                ["brew", "uninstall", "--cask", detail], check=True, capture=False
+            )
+            success(f"{tool_config['name']} removed successfully")
+
+        elif method in ("npm", "brew_npm"):
+            npm_package = detail or tool_config.get("npm_package")
+            if not npm_package:
+                error(f"No npm package configured for {tool_config['name']}")
+                return False
+            run_command(["npm", "uninstall", "-g", npm_package], check=True)
+            success(f"{tool_config['name']} removed successfully")
+
+        elif method == "script":
+            command = tool_config["command"]
+            command_path = shutil.which(command)
+
+            if command_path:
+                try:
+                    os.remove(command_path)
+                    success(f"{tool_config['name']} removed successfully")
+                except PermissionError:
+                    try:
+                        run_command(
+                            ["sudo", "rm", command_path], check=True, capture=False
+                        )
+                        success(f"{tool_config['name']} removed successfully")
+                    except subprocess.CalledProcessError as exc:
+                        error(
+                            f"Failed to remove {tool_config['name']}: {exc.stderr}. "
+                            f"Please remove manually: {command_path}"
+                        )
+                        return False
+                except Exception as exc:
+                    error(f"Failed to remove {tool_config['name']}: {exc}")
+                    return False
+            else:
+                warning(f"Could not find {command} binary to remove")
+                return True
+
+        elif method == "direct_download":
+            bin_dir = os.path.expanduser(tool_config.get("bin_dir", "~/.local/bin"))
+            removed_links = set()
+            for link_name in tool_config.get("symlinks", {}):
+                link_path = os.path.join(bin_dir, link_name)
+                if os.path.lexists(link_path):
+                    os.remove(link_path)
+                    info(f"Removed symlink: {link_path}")
+                    removed_links.add(link_path)
+
+            command_path = shutil.which(tool_config["command"])
+            if (
+                command_path
+                and command_path not in removed_links
+                and os.path.lexists(command_path)
+            ):
+                os.remove(command_path)
+                info(f"Removed: {command_path}")
+
+            install_dir_template = tool_config.get("install_dir")
+            if install_dir_template:
+                if "{version}" in install_dir_template:
+                    install_pattern = os.path.expanduser(
+                        install_dir_template.replace("{version}", "*")
+                    )
+                    for install_path in sorted(globmod.glob(install_pattern)):
+                        if os.path.isdir(install_path):
+                            shutil.rmtree(install_path)
+                            info(f"Removed: {install_path}")
+                        elif os.path.lexists(install_path):
+                            os.remove(install_path)
+                            info(f"Removed: {install_path}")
+                else:
+                    install_path = os.path.expanduser(install_dir_template)
+                    if os.path.isdir(install_path):
+                        shutil.rmtree(install_path)
+                        info(f"Removed: {install_path}")
+                    elif os.path.lexists(install_path):
+                        os.remove(install_path)
+                        info(f"Removed: {install_path}")
+
+            success(f"{tool_config['name']} removed successfully")
+
+        elif method == "self_managed":
+            command = tool_config["command"]
+            command_path = shutil.which(command)
+            removed_any = False
+            if command_path:
+                real_path = os.path.realpath(command_path)
+                remove_paths = [command_path]
+                if real_path != command_path:
+                    remove_paths.append(real_path)
+
+                for path in remove_paths:
+                    if not os.path.lexists(path):
+                        continue
+                    is_link = os.path.islink(path)
+                    if os.path.isdir(path) and not is_link:
+                        shutil.rmtree(path)
+                    else:
+                        os.remove(path)
+                    if is_link:
+                        info(f"Removed symlink: {path}")
+                    else:
+                        info(f"Removed: {path}")
+                    removed_any = True
+
+            if removed_any:
+                success(f"{tool_config['name']} removed successfully")
+            else:
+                warning(f"Could not find {command} binary to remove")
+
+        elif method == "system":
+            error(
+                f"{tool_config['name']} is managed by the system package manager. "
+                "Use your package manager to remove it."
+            )
+            return False
+
+        else:
+            error(
+                f"Don't know how to remove {tool_config['name']} "
+                f"(install method: {method})"
+            )
+            return False
+
+        return True
+
+    except subprocess.CalledProcessError as exc:
+        error(f"Failed to remove {tool_config['name']}: {exc.stderr}")
+        return False
+    except Exception as exc:
+        error(f"Failed to remove {tool_config['name']}: {exc}")
+        return False
+
+
+def validate_tools(tools: List[str]) -> None:
+    """Validate that all tool names are valid."""
+    invalid_tools = [tool for tool in tools if tool not in TOOLS]
+
+    if invalid_tools:
+        error(f"Invalid tool name(s): {', '.join(invalid_tools)}")
+        available = ", ".join(TOOLS.keys())
+        print(f"\nAvailable tools: {available}")
+        sys.exit(1)