kubek 0.4.2__tar.gz

kubek-0.4.2/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 ohmycoffe
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

kubek-0.4.2/PKG-INFO

@@ -0,0 +1,117 @@
+Metadata-Version: 2.4
+Name: kubek
+Version: 0.4.2
+Summary: kubectl extensions
+License-Expression: MIT
+License-File: LICENSE
+Keywords: kubernetes,kubectl,kubectl plugins,cli,devtools,port forwarding,dotenv
+Author: ohmycoffe
+Author-email: ohmycoffe1@gmail.com
+Requires-Python: >=3.11
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Build Tools
+Classifier: Topic :: System :: Systems Administration
+Classifier: Topic :: Utilities
+Requires-Dist: psutil (>=7.2.2,<8.0.0)
+Requires-Dist: pydantic (>=2.13.4,<3.0.0)
+Requires-Dist: questionary (>=2.1.1,<3.0.0)
+Requires-Dist: rich (>=15.0.0,<16.0.0)
+Requires-Dist: typer (>=0.25.1,<0.26.0)
+Project-URL: Repository, https://github.com/ohmycoffe/kubek
+Description-Content-Type: text/markdown
+
+<div align="center">
+
+# kubek
+
+> `kubectl` plugins for friendlier Kubernetes interactions.
+
+**kubek** (**kub**ernetes **e**xtension **k**it) is a collection of CLI tools that plug into `kubectl` and add interactive, developer-friendly shortcuts on top of it.
+
+![CI](https://github.com/ohmycoffe/kubek/actions/workflows/ci.yml/badge.svg?branch=main)
+![Python](https://img.shields.io/badge/python-3.11%2B-blue)
+![License](https://img.shields.io/badge/license-MIT-green)
+
+</div>
+
+---
+
+## Plugins
+
+### 🔌 portfwd — Interactive port forwarding
+
+Forwarding ports to Kubernetes services usually means running a separate `kubectl port-forward` command for each service, keeping track of which local port maps to what, and restarting them when they die. **portfwd** (**port** **f**or**w**ar**d**) replaces all of that with a single interactive command — pick your services, and it handles the rest.
+
+- Fuzzy-search namespaces and services interactively
+- Forward multiple services simultaneously in one command
+- Live status table with real-time updates when a process dies
+- Pin preferred local ports per service in a TOML config
+- Fallback to a random free port if the preferred port is taken
+- Inform user which services are currently forwarded and on which ports
+
+![portfwd demo](https://github.com/user-attachments/assets/18e1b913-b1f4-420a-8d76-2a717d604b3e)
+
+→ [Full documentation](kubectl-portfwd/README.md)
+
+---
+
+### 📦 envx — Export env vars from Kubernetes manifests
+
+Getting credentials out of a running deployment usually means digging through `kubectl get deployment -o yaml`, copying values by hand, and reformatting them into a `.env` file. **envx** (**env**ironment e**x**porter) does it in one command — pick any Deployment or Argo WorkflowTemplate you have access to and get its env vars exported instantly.
+
+- Fully interactive (fuzzy-search, arrow key navigation)
+- Output as `.env` or JSON
+- Pipe directly: `kubectl envx ... > .env` to produce a dotenv file
+
+![envx demo](https://github.com/user-attachments/assets/232d778b-77db-4de6-9b79-929a525419d4)
+
+→ [Full documentation](kubectl-envx/README.md)
+
+---
+
+## Installation
+
+### Prerequisites
+
+- Python 3.11+
+- `kubectl` installed and configured with cluster access
+
+### Install
+
+The recommended way to install kubek is with [pipx](https://pipx.pypa.io/), which installs it in an isolated environment and automatically makes the plugin executables available on your PATH:
+
+```bash
+# Latest stable release (recommended)
+pipx install kubek
+
+# Newest development version
+pipx install git+https://github.com/ohmycoffe/kubek.git
+```
+
+If you use pip or another package manager, make sure the installation's `bin/` directory is on your PATH — `kubectl` discovers plugins by scanning PATH for executables prefixed with `kubectl-`.
+
+### Verify
+
+After installing, confirm both plugins are available:
+
+```bash
+kubectl portfwd --help
+kubectl envx --help
+```
+
+See each plugin's README for full usage details.
+
+---
+
+## License
+
+MIT — see [LICENSE](LICENSE).
+

kubek-0.4.2/README.md

@@ -0,0 +1,86 @@
+<div align="center">
+
+# kubek
+
+> `kubectl` plugins for friendlier Kubernetes interactions.
+
+**kubek** (**kub**ernetes **e**xtension **k**it) is a collection of CLI tools that plug into `kubectl` and add interactive, developer-friendly shortcuts on top of it.
+
+![CI](https://github.com/ohmycoffe/kubek/actions/workflows/ci.yml/badge.svg?branch=main)
+![Python](https://img.shields.io/badge/python-3.11%2B-blue)
+![License](https://img.shields.io/badge/license-MIT-green)
+
+</div>
+
+---
+
+## Plugins
+
+### 🔌 portfwd — Interactive port forwarding
+
+Forwarding ports to Kubernetes services usually means running a separate `kubectl port-forward` command for each service, keeping track of which local port maps to what, and restarting them when they die. **portfwd** (**port** **f**or**w**ar**d**) replaces all of that with a single interactive command — pick your services, and it handles the rest.
+
+- Fuzzy-search namespaces and services interactively
+- Forward multiple services simultaneously in one command
+- Live status table with real-time updates when a process dies
+- Pin preferred local ports per service in a TOML config
+- Fallback to a random free port if the preferred port is taken
+- Inform user which services are currently forwarded and on which ports
+
+![portfwd demo](https://github.com/user-attachments/assets/18e1b913-b1f4-420a-8d76-2a717d604b3e)
+
+→ [Full documentation](kubectl-portfwd/README.md)
+
+---
+
+### 📦 envx — Export env vars from Kubernetes manifests
+
+Getting credentials out of a running deployment usually means digging through `kubectl get deployment -o yaml`, copying values by hand, and reformatting them into a `.env` file. **envx** (**env**ironment e**x**porter) does it in one command — pick any Deployment or Argo WorkflowTemplate you have access to and get its env vars exported instantly.
+
+- Fully interactive (fuzzy-search, arrow key navigation)
+- Output as `.env` or JSON
+- Pipe directly: `kubectl envx ... > .env` to produce a dotenv file
+
+![envx demo](https://github.com/user-attachments/assets/232d778b-77db-4de6-9b79-929a525419d4)
+
+→ [Full documentation](kubectl-envx/README.md)
+
+---
+
+## Installation
+
+### Prerequisites
+
+- Python 3.11+
+- `kubectl` installed and configured with cluster access
+
+### Install
+
+The recommended way to install kubek is with [pipx](https://pipx.pypa.io/), which installs it in an isolated environment and automatically makes the plugin executables available on your PATH:
+
+```bash
+# Latest stable release (recommended)
+pipx install kubek
+
+# Newest development version
+pipx install git+https://github.com/ohmycoffe/kubek.git
+```
+
+If you use pip or another package manager, make sure the installation's `bin/` directory is on your PATH — `kubectl` discovers plugins by scanning PATH for executables prefixed with `kubectl-`.
+
+### Verify
+
+After installing, confirm both plugins are available:
+
+```bash
+kubectl portfwd --help
+kubectl envx --help
+```
+
+See each plugin's README for full usage details.
+
+---
+
+## License
+
+MIT — see [LICENSE](LICENSE).

kubek-0.4.2/kubectl-envx/src/envx/__main__.py

@@ -0,0 +1,18 @@
+import logging
+
+from envx.cli.main import app
+from envx.console import console
+from envx.style import COLOR_WARNING
+
+logging.basicConfig()
+
+
+def deprecated_entry() -> None:
+    console.print(
+        f"[bold {COLOR_WARNING}]Warning:[/] 'envx' has been deprecated, use 'kenvx' instead."
+    )
+    app()
+
+
+if __name__ == "__main__":
+    app()

kubek-0.4.2/kubectl-envx/src/envx/cli/main.py

@@ -0,0 +1,159 @@
+from __future__ import annotations
+
+import enum
+import json
+import subprocess
+from typing import Annotated
+
+import questionary
+import typer
+
+from envx.console import console, print_error
+from envx.kube import (
+    get_available_deployments,
+    get_available_namespaces,
+    get_available_workflowtemplates,
+    get_deployment_envs,
+    get_workflowtemplate_envs,
+)
+from envx.style import COLOR_MUTED, STYLE
+from envx.utils import export_as_dotenv, resolve_namespace, setup_logging
+
+
+class ResourceKind(str, enum.Enum):
+    DEPLOYMENT = "deployment"
+    WORKFLOWTEMPLATE = "workflowtemplate"
+
+
+class ExportFormat(str, enum.Enum):
+    ENV = "env"
+    JSON = "json"
+
+
+app = typer.Typer()
+
+
+def select_resource_kind() -> ResourceKind:
+    selected = questionary.select(
+        "Select a kind:",
+        choices=[
+            questionary.Choice(
+                title="Deployment",
+                value=ResourceKind.DEPLOYMENT,
+                description="(Kubernetes Deployment)",
+            ),
+            questionary.Choice(
+                title="WorkflowTemplate",
+                value=ResourceKind.WORKFLOWTEMPLATE,
+                description="(Argo WorkflowTemplate)",
+            ),
+        ],
+        use_jk_keys=False,
+        style=STYLE,
+    ).ask()
+    if not selected:
+        raise typer.Exit(code=0)
+    return ResourceKind(selected)
+
+
+@app.callback(invoke_without_command=True)
+def get(
+    kind: Annotated[
+        ResourceKind | None,
+        typer.Option(
+            help="Kind of resource to get parameters for. If not provided, you will be prompted to select one.",
+        ),
+    ] = None,
+    namespace: Annotated[
+        str | None,
+        typer.Option(
+            envvar="KENVX_NAMESPACE",
+            help="Kubernetes namespace. If not provided, you will be prompted to select one.",
+        ),
+    ] = None,
+    name: Annotated[
+        str | None,
+        typer.Option(
+            help="Name of the resource. If not provided, you will be prompted to select one.",
+        ),
+    ] = None,
+    output: ExportFormat = ExportFormat.ENV,
+    verbose: Annotated[
+        int,
+        typer.Option(
+            "--verbose", "-v", count=True, help="Verbose output. Use -vv for debug."
+        ),
+    ] = 0,
+):
+    """
+    Get environment variables for a Kubernetes deployment or Argo WorkflowTemplate.
+    """
+    setup_logging(verbose)
+    if kind is None:
+        kind = select_resource_kind()
+
+    try:
+        with console.status(f"[italic {COLOR_MUTED}]Fetching available namespaces…[/]"):
+            namespaces = get_available_namespaces()
+    except subprocess.CalledProcessError as e:
+        print_error(e, "Failed to fetch available namespaces")
+        raise typer.Exit(code=1) from None
+
+    namespace = resolve_namespace(namespace, available_namespaces=namespaces)
+
+    try:
+        with console.status(
+            f"[italic {COLOR_MUTED}]Fetching available {kind.value}s in {namespace}…[/]"
+        ):
+            if kind == ResourceKind.DEPLOYMENT:
+                resources = get_available_deployments(namespace=namespace)
+            else:
+                resources = get_available_workflowtemplates(namespace=namespace)
+    except subprocess.CalledProcessError as e:
+        print_error(
+            e, f"Failed to fetch available {kind.value}s in namespace '{namespace}'"
+        )
+        raise typer.Exit(code=1) from None
+    if not resources:
+        console.print(f"[red]Error: no {kind.value}s found in namespace '{namespace}'")
+        raise typer.Exit(code=1)
+
+    if not name:
+        name = questionary.select(
+            f"Select a {kind.value}:",
+            choices=resources,
+            use_search_filter=True,
+            use_jk_keys=False,
+            style=STYLE,
+        ).ask()
+        if not name:
+            raise typer.Exit(code=0)
+
+    if name not in resources:
+        console.print(
+            f"[red]Error:[/red] {kind.value} '{name}' not found in namespace '{namespace}'."
+        )
+        raise typer.Exit(code=1)
+
+    try:
+        with console.status(
+            f"[italic {COLOR_MUTED}]Fetching environment variables…[/]"
+        ):
+            if kind == ResourceKind.DEPLOYMENT:
+                vals = get_deployment_envs(namespace=namespace, name=name)
+            else:
+                vals = get_workflowtemplate_envs(namespace=namespace, name=name)
+    except subprocess.CalledProcessError as e:
+        print_error(e, f"Failed to fetch environment variables for '{name}'")
+        raise typer.Exit(code=1) from None
+
+    if output == ExportFormat.JSON:
+        formatted = json.dumps(vals, sort_keys=True)
+    elif output == ExportFormat.ENV:
+        formatted = export_as_dotenv(vals=vals, name=name)
+    print(formatted)
+    raise typer.Exit(code=0)
+
+
+if __name__ == "__main__":
+    app()

kubek-0.4.2/kubectl-envx/src/envx/console.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+import logging
+import subprocess
+
+from rich.console import Console
+from rich.panel import Panel
+
+from envx.style import COLOR_ERROR
+
+console = Console(stderr=True)
+
+logger = logging.getLogger(__name__)
+
+
+def print_error(e: subprocess.CalledProcessError, msg: str) -> None:
+    logger.debug("kubectl error", exc_info=e, stack_info=True)
+    stderr = (e.stderr or "no output").strip()
+    stdout = (e.stdout or "no output").strip()
+    cmd = " ".join(e.cmd)
+    content = "\n".join(
+        [
+            "[dim]stderr:[/dim]",
+            f"[{COLOR_ERROR}]{stderr}[/]",
+            "",
+            "[dim]stdout:[/dim]",
+            stdout,
+            "",
+            f"[dim]command:[/dim] {cmd}",
+            f"[dim]exit code:[/dim] {e.returncode}",
+        ]
+    )
+    console.print(
+        Panel(
+            content,
+            title=f"[bold {COLOR_ERROR}]{msg}[/]",
+            border_style=COLOR_ERROR,
+            expand=False,
+        )
+    )

kubek-0.4.2/kubectl-envx/src/envx/kube.py

@@ -0,0 +1,168 @@
+from __future__ import annotations
+
+import json
+import logging
+import re
+import subprocess
+from collections.abc import Callable
+from functools import lru_cache
+from typing import Any
+
+from envx.utils import decode
+
+logger = logging.getLogger(__name__)
+
+
+def call_subprocess(cmd: list[str]) -> str:
+    logger.debug("%s", " ".join(cmd))
+    result = subprocess.run(cmd, capture_output=True, text=True, check=True)
+    return result.stdout
+
+
+def get_available_namespaces() -> list[str]:
+    cmd = ["kubectl", "get", "namespaces", "-o", "json"]
+    result = call_subprocess(cmd)
+    data = json.loads(result)
+    return [el["metadata"]["name"] for el in data["items"]]
+
+
+@lru_cache
+def get_secret(namespace: str, name: str) -> dict[str, Any]:
+    cmd = ["kubectl", "get", "secret", name, "-n", namespace, "-o", "json"]
+    result = call_subprocess(cmd)
+    secret = json.loads(result)
+    return secret
+
+
+@lru_cache
+def get_configmap(namespace: str, name: str) -> dict[str, Any]:
+    cmd = ["kubectl", "get", "configmap", name, "-n", namespace, "-o", "json"]
+    result = call_subprocess(cmd)
+    configmap = json.loads(result)
+    return configmap
+
+
+def _clean_key(key: str) -> str:
+    def strip_argo_inputs_param(key: str) -> str:
+        match = re.match(r"^\{\{inputs\.parameters\.(?P<param_name>\w+)\}\}$", key)
+        return match.group("param_name") if match else key
+
+    cleanups: list[Callable[[str], str]] = [
+        strip_argo_inputs_param,
+    ]
+
+    for cleanup in cleanups:
+        key = cleanup(key)
+    return key
+
+
+def get_available_deployments(namespace: str) -> list[str]:
+    cmd = ["kubectl", "get", "deployment", "-n", namespace, "-o", "json"]
+    result = call_subprocess(cmd)
+    data = json.loads(result)
+    return [el["metadata"]["name"] for el in data["items"]]
+
+
+def get_deployment_envs(namespace: str, name: str) -> dict[str, str]:
+    cmd = ["kubectl", "get", "deployment", name, "-n", namespace, "-o", "json"]
+    result = call_subprocess(cmd)
+    deployment = json.loads(result)
+    containers = deployment["spec"]["template"]["spec"]["containers"]
+    if len(containers) != 1:
+        raise ValueError(f"Expected 1 container, got {len(containers)}")
+    return extract_envs_from_container(namespace=namespace, container=containers[0])
+
+
+def get_available_workflowtemplates(namespace: str) -> list[str]:
+    cmd = ["kubectl", "get", "workflowtemplate", "-n", namespace, "-o", "json"]
+    result = call_subprocess(cmd)
+    data = json.loads(result)
+    return [el["metadata"]["name"] for el in data["items"]]
+
+
+def get_workflowtemplate_envs(namespace: str, name: str) -> dict[str, str]:
+    cmd = ["kubectl", "get", "workflowtemplate", name, "-n", namespace, "-o", "json"]
+    result = call_subprocess(cmd)
+    workflow = json.loads(result)
+    envs = {}
+    for template in workflow["spec"]["templates"]:
+        if "container" not in template:
+            continue
+        fallback_keys = {
+            p["name"]: p["default"]
+            for p in template.get("inputs", {}).get("parameters", [])
+            if "default" in p
+        }
+        envs.update(
+            extract_envs_from_container(
+                namespace, template["container"], fallback_keys=fallback_keys
+            )
+        )
+    return envs
+
+
+def extract_envs_from_container(
+    namespace: str,
+    container: dict[str, Any],
+    fallback_keys: dict[str, str] | None = None,
+) -> dict[str, str]:
+    if fallback_keys is None:
+        fallback_keys = {}
+    result = {}
+    if "envFrom" in container:
+        for env_from in container["envFrom"]:
+            if "configMapRef" in env_from:
+                configmap = get_configmap(namespace, env_from["configMapRef"]["name"])
+                result.update(configmap["data"])
+            elif "secretRef" in env_from:
+                secret_name = env_from["secretRef"]["name"]
+                secret = get_secret(namespace, secret_name)
+                encoded = {k: decode(v) for k, v in secret["data"].items()}
+                result.update(encoded)
+            else:
+                raise ValueError(f"Unknown envFrom format: {env_from}")
+
+    if "env" in container:
+        for env in container["env"]:
+            name = env["name"]
+            if "value" in env:
+                value = env["value"]
+                result[name] = value
+            elif "valueFrom" in env:
+                value_from = env["valueFrom"]
+                if "configMapKeyRef" in value_from:
+                    configmap = get_configmap(
+                        namespace, value_from["configMapKeyRef"]["name"]
+                    )
+                    key = value_from["configMapKeyRef"]["key"]
+                    if key not in configmap["data"]:
+                        key = fallback_keys.get(_clean_key(key), key)
+                    if key not in configmap["data"]:
+                        logger.warning(
+                            f"{name} won't be set: key {key} not found in ConfigMap {value_from['configMapKeyRef']['name']}"
+                        )
+                        value = ""
+                    else:
+                        value = configmap["data"][key]
+                    result[name] = value
+                elif "secretKeyRef" in value_from:
+                    secret_name = value_from["secretKeyRef"]["name"]
+                    encoded = get_secret(namespace, secret_name)
+                    key = value_from["secretKeyRef"]["key"]
+                    if key not in encoded["data"]:
+                        key = fallback_keys.get(_clean_key(key), key)
+                    if key not in encoded["data"]:
+                        logger.warning(
+                            f"{name} won't be set: key {key} not found in Secret {secret_name}"
+                        )
+                        value = ""
+                    else:
+                        value = decode(encoded["data"][key])
+                    result[name] = value
+                else:
+                    logger.warning(
+                        f"Unknown valueFrom format: {value_from} for {name} ({env})"
+                    )
+            else:
+                logger.warning(f"Unknown env format: {env}")
+    return result

kubek-0.4.2/kubectl-envx/src/envx/style.py

@@ -0,0 +1,27 @@
+from questionary import Style
+
+# fmt: off
+COLOR_ACCENT  = "#e5c07b"  # yellow     — draws attention (qmark)
+COLOR_SUCCESS = "#98c379"  # green      — confirmed / selected
+COLOR_ACTIVE  = "#61afef"  # blue       — navigation / pointer
+COLOR_WARNING  = "#d19a66"  # orange     — warnings / cautions
+COLOR_ERROR   = "#e06c75"  # red        — errors / failures
+COLOR_MUTED   = "#5c6370"  # gray       — secondary elements
+COLOR_SUBTLE  = "#4b5263"  # dark gray  — near-invisible hints
+
+# fmt: off
+STYLE = Style(
+    [
+        ("qmark",       f"fg:{COLOR_ACCENT} bold"),
+        ("question",    "bold"),
+        ("answer",      f"fg:{COLOR_SUCCESS} bold"),
+        ("pointer",     f"fg:{COLOR_ACTIVE} bold"),
+        ("highlighted", f"fg:{COLOR_ACTIVE} bold"),
+        ("selected",    f"fg:{COLOR_SUCCESS}"),
+        ("separator",   f"fg:{COLOR_MUTED}"),
+        ("instruction", f"fg:{COLOR_SUBTLE} italic"),
+        ("text",        ""),
+        ("disabled",    f"fg:{COLOR_SUBTLE} italic"),
+    ]
+)
+# fmt: on