dev-setup 1.0.0__py3-none-any.whl

dev_setup/generic.py

@@ -0,0 +1,302 @@
+from __future__ import annotations
+
+import json
+import shutil
+import subprocess
+from pathlib import Path
+from typing import Optional
+
+from dev_setup.base import Tool
+
+CUSTOM_DIR = Path.home() / ".config" / "dev-setup" / "packages"
+_CUSTOM_DIR = CUSTOM_DIR
+
+
+class GenericTool(Tool):
+    category = "custom"
+    builtin = False
+
+    def __init__(
+        self,
+        key: str,
+        name: str,
+        description: str = "",
+        category: str = "custom",
+        install_type: str = "unknown",
+        check_cmd: str = "",
+        npm_name: str = "",
+        pip_name: str = "",
+        git_url: str = "",
+        git_install_cmd: str = "",
+        git_remove_cmd: str = "",
+        apt_packages: str = "",
+        script_url: str = "",
+        install_script: str = "",
+        remove_script: str = "",
+        help_cmd: str = "",
+    ) -> None:
+        self.key = key
+        self.name = name
+        self.description = description
+        self.category = category
+        self.install_type = install_type
+        self.check_cmd = check_cmd
+        self.npm_name = npm_name
+        self.pip_name = pip_name
+        self.git_url = git_url
+        self.git_install_cmd = git_install_cmd
+        self.git_remove_cmd = git_remove_cmd
+        self.apt_packages = apt_packages
+        self.script_url = script_url
+        self.install_script = install_script
+        self.remove_script = remove_script
+        self.help_cmd = help_cmd
+
+    @classmethod
+    def from_dict(cls, data: dict, key: str) -> "GenericTool":
+        return cls(
+            key=key,
+            name=data.get("name", key),
+            description=data.get("description", ""),
+            category=data.get("category", "custom"),
+            install_type=data.get("type", "unknown"),
+            check_cmd=data.get("check_cmd", ""),
+            npm_name=data.get("npm_name", ""),
+            pip_name=data.get("pip_name", ""),
+            git_url=data.get("git_url", ""),
+            git_install_cmd=data.get("git_install_cmd", ""),
+            git_remove_cmd=data.get("git_remove_cmd", ""),
+            apt_packages=data.get("apt_packages", ""),
+            script_url=data.get("script_url", ""),
+            install_script=data.get("install_script", ""),
+            remove_script=data.get("remove_script", ""),
+            help_cmd=data.get("help_cmd", ""),
+        )
+
+    def to_dict(self) -> dict:
+        d: dict = {
+            "name": self.name,
+            "description": self.description,
+            "category": self.category,
+            "type": self.install_type,
+        }
+        for field, val in [
+            ("check_cmd", self.check_cmd),
+            ("npm_name", self.npm_name),
+            ("pip_name", self.pip_name),
+            ("git_url", self.git_url),
+            ("git_install_cmd", self.git_install_cmd),
+            ("git_remove_cmd", self.git_remove_cmd),
+            ("apt_packages", self.apt_packages),
+            ("script_url", self.script_url),
+            ("install_script", self.install_script),
+            ("remove_script", self.remove_script),
+            ("help_cmd", self.help_cmd),
+        ]:
+            if val:
+                d[field] = val
+        return d
+
+    def save(self) -> None:
+        CUSTOM_DIR.mkdir(parents=True, exist_ok=True)
+        path = CUSTOM_DIR / f"{self.key}.json"
+        path.write_text(json.dumps(self.to_dict(), indent=2))
+
+    def is_installed(self) -> bool:
+        if self.check_cmd:
+            return shutil.which(self.check_cmd) is not None
+        t = self.install_type
+        if t == "npm":
+            return self.npm_name and _npm_global_installed(self.npm_name)
+        if t == "pip":
+            return bool(self.pip_name) and shutil.which(self.pip_name) is not None
+        if t == "git":
+            return bool(self.git_url) and _git_clone_dest(self.git_url).exists()
+        if t == "apt":
+            return bool(self.apt_packages) and _apt_installed(self.apt_packages.split()[0])
+        return False
+
+    def get_version(self) -> str:
+        cmd = self.check_cmd or _type_cmd(self)
+        if not cmd or not shutil.which(cmd):
+            return ""
+        for flag in ["--version", "-v", "version"]:
+            try:
+                r = subprocess.run([cmd, flag], capture_output=True, text=True, timeout=5)
+                if r.returncode == 0 and r.stdout.strip():
+                    return r.stdout.strip().splitlines()[0]
+            except Exception:
+                pass
+        return "installed"
+
+    def install(self) -> Optional[str]:
+        from dev_setup import ui
+        t = self.install_type
+
+        if t == "npm":
+            if not self.npm_name:
+                raise RuntimeError("npm_name not set")
+            with ui.spinner(f"Installing {self.name} via npm..."):
+                subprocess.run(
+                    ["npm", "install", "-g", self.npm_name],
+                    check=True, capture_output=True,
+                )
+        elif t == "pip":
+            if not self.pip_name:
+                raise RuntimeError("pip_name not set")
+            uv = shutil.which("uv")
+            with ui.spinner(f"Installing {self.name} via pip..."):
+                if uv:
+                    subprocess.run(
+                        [uv, "tool", "install", self.pip_name],
+                        check=True, capture_output=True,
+                    )
+                else:
+                    subprocess.run(
+                        ["pip3", "install", "--user", self.pip_name],
+                        check=True, capture_output=True,
+                    )
+        elif t == "git":
+            if not self.git_url:
+                raise RuntimeError("git_url not set")
+            dest = _git_clone_dest(self.git_url)
+            with ui.spinner(f"Cloning {self.name}..."):
+                subprocess.run(
+                    ["git", "clone", "--depth=1", self.git_url, str(dest)],
+                    check=True, capture_output=True,
+                )
+            if self.git_install_cmd:
+                with ui.spinner(f"Running install command..."):
+                    subprocess.run(
+                        ["bash", "-c", self.git_install_cmd],
+                        cwd=dest, check=True, capture_output=True,
+                    )
+        elif t == "apt":
+            if not self.apt_packages:
+                raise RuntimeError("apt_packages not set")
+            with ui.spinner(f"Installing {self.name} via apt..."):
+                subprocess.run(
+                    ["sudo", "apt-get", "install", "-y"] + self.apt_packages.split(),
+                    check=True, capture_output=True,
+                )
+        elif t == "script":
+            if not self.script_url:
+                raise RuntimeError("script_url not set")
+            with ui.spinner(f"Running install script for {self.name}..."):
+                subprocess.run(
+                    ["bash", "-c", f"curl -fsSL '{self.script_url}' | sh"],
+                    check=True, capture_output=True,
+                )
+        elif t == "bash":
+            if not self.install_script:
+                raise RuntimeError("install_script not set")
+            with ui.spinner(f"Installing {self.name}..."):
+                _run_bash_script(self.install_script)
+        else:
+            raise RuntimeError(f"Unsupported install type: {t!r}")
+
+        return self.get_version() or None
+
+    def remove(self) -> None:
+        from dev_setup import ui
+        t = self.install_type
+
+        if t == "npm":
+            with ui.spinner(f"Removing {self.name}..."):
+                subprocess.run(
+                    ["npm", "uninstall", "-g", self.npm_name],
+                    check=True, capture_output=True,
+                )
+        elif t == "pip":
+            uv = shutil.which("uv")
+            with ui.spinner(f"Removing {self.name}..."):
+                if uv:
+                    subprocess.run(
+                        [uv, "tool", "uninstall", self.pip_name],
+                        check=True, capture_output=True,
+                    )
+                else:
+                    subprocess.run(
+                        ["pip3", "uninstall", "-y", self.pip_name],
+                        check=True, capture_output=True,
+                    )
+        elif t == "git":
+            dest = _git_clone_dest(self.git_url)
+            if self.git_remove_cmd:
+                with ui.spinner(f"Running remove command..."):
+                    subprocess.run(
+                        ["bash", "-c", self.git_remove_cmd],
+                        cwd=dest, capture_output=True,
+                    )
+            import shutil as _shutil
+            if dest.exists():
+                _shutil.rmtree(dest)
+        elif t == "apt":
+            with ui.spinner(f"Removing {self.name}..."):
+                subprocess.run(
+                    ["sudo", "apt-get", "remove", "-y"] + self.apt_packages.split(),
+                    check=True, capture_output=True,
+                )
+        elif t == "script":
+            raise RuntimeError(
+                "Script-type packages cannot be auto-removed. "
+                "Remove manually then run: dev-setup delete " + self.key
+            )
+        elif t == "bash":
+            if not self.remove_script:
+                raise RuntimeError(
+                    f"No remove script defined for '{self.key}'. "
+                    "Remove manually then run: dev-setup delete " + self.key
+                )
+            with ui.spinner(f"Removing {self.name}..."):
+                _run_bash_script(self.remove_script)
+        else:
+            raise RuntimeError(f"Unsupported remove type: {t!r}")
+
+
+def _npm_global_installed(pkg: str) -> bool:
+    try:
+        r = subprocess.run(["npm", "list", "-g", "--depth=0", pkg], capture_output=True, text=True)
+        return pkg in r.stdout
+    except Exception:
+        return False
+
+
+def _apt_installed(pkg: str) -> bool:
+    try:
+        r = subprocess.run(["dpkg", "-s", pkg], capture_output=True, text=True)
+        return "Status: install ok installed" in r.stdout
+    except Exception:
+        return False
+
+
+def _git_clone_dest(url: str) -> Path:
+    repo_name = url.rstrip("/").split("/")[-1].removesuffix(".git")
+    return Path.home() / ".local" / "share" / "dev-setup" / repo_name
+
+
+def _run_bash_script(script: str) -> None:
+    """Write script to a temp file and execute it with bash, capturing output."""
+    import os
+    import tempfile
+
+    with tempfile.NamedTemporaryFile(mode="w", suffix=".sh", delete=False) as f:
+        f.write(script)
+        tmp = f.name
+    try:
+        result = subprocess.run(["bash", tmp], capture_output=True, text=True)
+        if result.returncode != 0:
+            raise RuntimeError(
+                result.stderr.strip() or f"Script exited with code {result.returncode}"
+            )
+    finally:
+        os.unlink(tmp)
+
+
+def _type_cmd(tool: GenericTool) -> str:
+    t = tool.install_type
+    if t == "npm":
+        return tool.npm_name
+    if t == "pip":
+        return tool.pip_name
+    return ""

dev_setup/packages/aws_cli.py

@@ -0,0 +1,73 @@
+from __future__ import annotations
+
+import platform
+import shutil
+import subprocess
+import tempfile
+import zipfile
+from pathlib import Path
+from typing import Optional
+
+from dev_setup.base import Tool
+
+_AWS_CLI_DIR = Path("/usr/local/aws-cli")
+_AWS_BIN = Path("/usr/local/bin/aws")
+
+
+class AwsCliTool(Tool):
+    key = "aws"
+    name = "AWS CLI"
+    description = "Amazon Web Services command line interface (v2)"
+    category = "tools"
+    install_type = "script"
+    help_cmd = "aws help"
+
+    def is_installed(self) -> bool:
+        return shutil.which("aws") is not None
+
+    def get_version(self) -> str:
+        r = subprocess.run(["aws", "--version"], capture_output=True, text=True)
+        return r.stdout.strip() or r.stderr.strip()
+
+    def install(self) -> Optional[str]:
+        from dev_setup import ui
+
+        arch = "aarch64" if platform.machine() == "aarch64" else "x86_64"
+        url = f"https://awscli.amazonaws.com/awscli-exe-linux-{arch}.zip"
+
+        with tempfile.TemporaryDirectory() as tmpdir:
+            zip_path = Path(tmpdir) / "awscliv2.zip"
+
+            with ui.spinner("Downloading AWS CLI v2..."):
+                subprocess.run(
+                    ["curl", "-fsSL", url, "-o", str(zip_path)],
+                    check=True, capture_output=True,
+                )
+
+            with ui.spinner("Extracting AWS CLI..."):
+                with zipfile.ZipFile(zip_path) as zf:
+                    zf.extractall(tmpdir)
+
+            with ui.spinner("Installing AWS CLI (sudo)..."):
+                subprocess.run(
+                    ["sudo", str(Path(tmpdir) / "aws" / "install")],
+                    check=True, capture_output=True,
+                )
+
+        if not self.is_installed():
+            raise RuntimeError("AWS CLI installation failed — aws binary not found")
+        return self.get_version()
+
+    def remove(self) -> None:
+        from dev_setup import ui
+
+        with ui.spinner("Removing AWS CLI..."):
+            for path in [
+                _AWS_CLI_DIR,
+                _AWS_BIN,
+                Path("/usr/local/bin/aws_completer"),
+            ]:
+                if path.is_dir():
+                    subprocess.run(["sudo", "rm", "-rf", str(path)], check=True, capture_output=True)
+                elif path.exists():
+                    subprocess.run(["sudo", "rm", "-f", str(path)], check=True, capture_output=True)

dev_setup/packages/docker.py

@@ -0,0 +1,93 @@
+from __future__ import annotations
+
+import os
+import shutil
+import subprocess
+import tempfile
+from pathlib import Path
+from typing import Optional
+
+from dev_setup.base import Tool
+
+
+class DockerTool(Tool):
+    key = "docker"
+    name = "Docker"
+    description = "Container runtime + docker compose plugin"
+    category = "core"
+    install_type = "script"
+    help_cmd = "docker --help"
+
+    def is_installed(self) -> bool:
+        return shutil.which("docker") is not None
+
+    def get_version(self) -> str:
+        r = subprocess.run(["docker", "--version"], capture_output=True, text=True)
+        return r.stdout.strip() if r.returncode == 0 else ""
+
+    def install(self) -> Optional[str]:
+        from dev_setup import ui
+
+        tmp = tempfile.NamedTemporaryFile(suffix=".sh", delete=False)
+        tmp.close()
+        try:
+            with ui.spinner("Downloading Docker install script..."):
+                subprocess.run(
+                    ["curl", "-fsSL", "https://get.docker.com", "-o", tmp.name],
+                    check=True, capture_output=True,
+                )
+            with ui.spinner("Installing Docker (this may take a minute)..."):
+                subprocess.run(["sudo", "sh", tmp.name], check=True, capture_output=True)
+        finally:
+            Path(tmp.name).unlink(missing_ok=True)
+
+        user = os.environ.get("USER", "")
+        if user:
+            r = subprocess.run(["groups", user], capture_output=True, text=True)
+            if "docker" not in r.stdout:
+                ui.info(f"Adding {user} to docker group...")
+                subprocess.run(
+                    ["sudo", "usermod", "-aG", "docker", user],
+                    check=True, capture_output=True,
+                )
+                ui.warn("Log out and back in for docker group to take effect")
+
+        subprocess.run(["sudo", "systemctl", "enable", "docker"], capture_output=True)
+        subprocess.run(["sudo", "systemctl", "start", "docker"], capture_output=True)
+        self._ensure_compose(ui)
+
+        if not self.is_installed():
+            raise RuntimeError("Docker installation failed — docker binary not found")
+        return self.get_version()
+
+    def _ensure_compose(self, ui) -> None:  # type: ignore[no-untyped-def]
+        r = subprocess.run(["docker", "compose", "version"], capture_output=True)
+        if r.returncode == 0:
+            return
+        ui.info("Installing docker-compose-plugin...")
+        for mgr_cmd in [
+            ["sudo", "apt-get", "install", "-y", "docker-compose-plugin"],
+            ["sudo", "yum", "install", "-y", "docker-compose-plugin"],
+            ["sudo", "dnf", "install", "-y", "docker-compose-plugin"],
+        ]:
+            r = subprocess.run(mgr_cmd, capture_output=True)
+            if r.returncode == 0:
+                return
+        ui.warn("docker-compose-plugin not available via package manager")
+
+    def remove(self) -> None:
+        from dev_setup import ui
+
+        with ui.spinner("Stopping Docker service..."):
+            subprocess.run(["sudo", "systemctl", "stop", "docker"], capture_output=True)
+            subprocess.run(["sudo", "systemctl", "disable", "docker"], capture_output=True)
+
+        with ui.spinner("Removing Docker packages..."):
+            subprocess.run(
+                ["bash", "-c",
+                 "sudo apt-get remove -y docker-ce docker-ce-cli containerd.io "
+                 "docker-buildx-plugin docker-compose-plugin docker-ce-rootless-extras "
+                 "2>/dev/null || sudo yum remove -y docker-ce docker-ce-cli containerd.io "
+                 "docker-compose-plugin 2>/dev/null || true"],
+                capture_output=True,
+            )

dev_setup/packages/htop.py

@@ -0,0 +1,53 @@
+from __future__ import annotations
+
+import shutil
+import subprocess
+from typing import Optional
+
+from dev_setup.base import Tool
+
+
+class HtopTool(Tool):
+    key = "htop"
+    name = "htop"
+    description = "Interactive process and resource monitor"
+    category = "tools"
+    install_type = "apt"
+    help_cmd = "man htop"
+
+    def is_installed(self) -> bool:
+        return shutil.which("htop") is not None
+
+    def get_version(self) -> str:
+        r = subprocess.run(["htop", "--version"], capture_output=True, text=True)
+        return r.stdout.strip().splitlines()[0] if r.returncode == 0 else ""
+
+    def install(self) -> Optional[str]:
+        from dev_setup import ui
+
+        with ui.spinner("Installing htop..."):
+            result = subprocess.run(
+                ["bash", "-c",
+                 "sudo apt-get install -y htop 2>/dev/null || "
+                 "sudo yum install -y htop 2>/dev/null || "
+                 "sudo dnf install -y htop 2>/dev/null || "
+                 "sudo pacman -S --noconfirm htop 2>/dev/null"],
+                capture_output=True,
+            )
+
+        if not self.is_installed():
+            raise RuntimeError("htop installation failed — no supported package manager found")
+        return self.get_version()
+
+    def remove(self) -> None:
+        from dev_setup import ui
+
+        with ui.spinner("Removing htop..."):
+            subprocess.run(
+                ["bash", "-c",
+                 "sudo apt-get remove -y htop 2>/dev/null || "
+                 "sudo yum remove -y htop 2>/dev/null || "
+                 "sudo dnf remove -y htop 2>/dev/null || "
+                 "sudo pacman -R --noconfirm htop 2>/dev/null"],
+                capture_output=True,
+            )

dev_setup/packages/nvm.py

@@ -0,0 +1,84 @@
+from __future__ import annotations
+
+import json
+import subprocess
+import urllib.request
+from pathlib import Path
+from typing import Optional
+
+from dev_setup.base import Tool, patch_bashrc, remove_bashrc_block
+
+NVM_DIR = Path.home() / ".nvm"
+NVM_INIT_BLOCK = "nvm"
+NVM_INIT_LINES = (
+    'export NVM_DIR="$HOME/.nvm"\n'
+    '[ -s "$NVM_DIR/nvm.sh" ] && . "$NVM_DIR/nvm.sh"\n'
+    '[ -s "$NVM_DIR/bash_completion" ] && . "$NVM_DIR/bash_completion"'
+)
+
+
+class NvmTool(Tool):
+    key = "nvm"
+    name = "NVM + Node LTS"
+    description = "Node Version Manager + latest Node LTS"
+    category = "core"
+    install_type = "script"
+    help_cmd = "nvm help"
+
+    def is_installed(self) -> bool:
+        return (NVM_DIR / "nvm.sh").exists()
+
+    def get_version(self) -> str:
+        r = subprocess.run(
+            ["bash", "-c", f'. "{NVM_DIR}/nvm.sh" && nvm --version'],
+            capture_output=True, text=True,
+        )
+        return f"nvm v{r.stdout.strip()}" if r.returncode == 0 else ""
+
+    def install(self) -> Optional[str]:
+        from dev_setup import ui
+
+        tag = self._latest_release_tag()
+        url = f"https://raw.githubusercontent.com/nvm-sh/nvm/{tag}/install.sh"
+
+        with ui.spinner(f"Installing NVM {tag}..."):
+            subprocess.run(
+                ["bash", "-c", f"curl -o- '{url}' | bash"],
+                check=True, capture_output=True,
+            )
+
+        if not self.is_installed():
+            raise RuntimeError("NVM installation failed — nvm.sh not found")
+
+        patch_bashrc(NVM_INIT_BLOCK, NVM_INIT_LINES)
+        ui.success("NVM init added to ~/.bashrc")
+
+        with ui.spinner("Installing Node LTS..."):
+            subprocess.run(
+                ["bash", "-c", f'. "{NVM_DIR}/nvm.sh" && nvm install --lts'],
+                check=True, capture_output=True,
+            )
+
+        return self.get_version()
+
+    def remove(self) -> None:
+        from dev_setup import ui
+
+        if NVM_DIR.exists():
+            import shutil as _shutil
+            with ui.spinner("Removing NVM directory..."):
+                _shutil.rmtree(NVM_DIR)
+
+        remove_bashrc_block(NVM_INIT_BLOCK)
+        ui.info("NVM init removed from ~/.bashrc")
+
+    @staticmethod
+    def _latest_release_tag() -> str:
+        try:
+            url = "https://api.github.com/repos/nvm-sh/nvm/releases/latest"
+            req = urllib.request.Request(url, headers={"User-Agent": "dev-setup"})
+            with urllib.request.urlopen(req, timeout=10) as resp:
+                data = json.loads(resp.read())
+                return data["tag_name"]
+        except Exception:
+            return "v0.40.3"

dev_setup/packages/php.py

@@ -0,0 +1,65 @@
+from __future__ import annotations
+
+import shutil
+import subprocess
+from typing import Optional
+
+from dev_setup.base import Tool
+
+
+class PhpTool(Tool):
+    key = "php"
+    name = "PHP 8.4"
+    description = "PHP 8.4 + common extensions via ondrej/php PPA"
+    category = "tools"
+    install_type = "apt"
+    help_cmd = "php --help"
+
+    def is_installed(self) -> bool:
+        return shutil.which("php") is not None
+
+    def get_version(self) -> str:
+        r = subprocess.run(["php", "--version"], capture_output=True, text=True)
+        return r.stdout.strip().splitlines()[0] if r.returncode == 0 else ""
+
+    def install(self) -> Optional[str]:
+        from dev_setup import ui
+
+        if not shutil.which("add-apt-repository"):
+            with ui.spinner("Installing software-properties-common..."):
+                subprocess.run(
+                    ["sudo", "apt-get", "install", "-y", "software-properties-common"],
+                    check=True, capture_output=True,
+                )
+
+        with ui.spinner("Adding ondrej/php PPA..."):
+            subprocess.run(
+                ["sudo", "add-apt-repository", "-y", "ppa:ondrej/php"],
+                check=True, capture_output=True,
+            )
+
+        with ui.spinner("Updating package index..."):
+            subprocess.run(["sudo", "apt-get", "update", "-q"], check=True, capture_output=True)
+
+        packages = [
+            "php8.4", "php8.4-cli", "php8.4-common",
+            "php8.4-curl", "php8.4-mbstring", "php8.4-xml", "php8.4-zip",
+        ]
+        with ui.spinner("Installing PHP 8.4 + extensions..."):
+            subprocess.run(
+                ["sudo", "apt-get", "install", "-y"] + packages,
+                check=True, capture_output=True,
+            )
+
+        if not self.is_installed():
+            raise RuntimeError("PHP installation failed")
+        return self.get_version()
+
+    def remove(self) -> None:
+        from dev_setup import ui
+
+        with ui.spinner("Removing PHP 8.4 packages..."):
+            subprocess.run(
+                ["bash", "-c", "sudo apt-get remove -y 'php8.4*' && sudo apt-get autoremove -y"],
+                check=True, capture_output=True,
+            )