zenkins 0.1.0__tar.gz

zenkins-0.1.0/PKG-INFO

@@ -0,0 +1,63 @@
+Metadata-Version: 2.4
+Name: zenkins
+Version: 0.1.0
+Summary: CLI tool for Jenkins. List jobs, check builds, view logs, trigger builds.
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/vivainio/zenkins
+Project-URL: Repository, https://github.com/vivainio/zenkins
+Project-URL: Issues, https://github.com/vivainio/zenkins/issues
+Keywords: jenkins,cli,ci,builds
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+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
+Classifier: Topic :: Utilities
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.31.0
+Requires-Dist: platformdirs>=4.0.0
+
+# zenkins
+
+CLI tool for Jenkins. List jobs, check builds, view logs, trigger builds.
+
+## Install
+
+```bash
+pip install zenkins
+```
+
+## Setup
+
+Run `zenkins init` to configure your Jenkins connection. This creates `~/.config/jenkins/config` with your Jenkins URL and credentials.
+
+## Usage
+
+```bash
+zenkins jobs              # List all jobs with status
+zenkins status <job>      # Show last build info
+zenkins builds <job>      # List recent builds
+zenkins builds <job> -n 5 # List last 5 builds
+zenkins log <job>         # Show console output (last build)
+zenkins log <job> 42      # Show console output for build #42
+zenkins queue             # Show build queue
+zenkins build <job>       # Trigger a build
+```
+
+## Library usage
+
+```python
+import zenkins
+
+s = zenkins.client()
+resp = s.get("http://jenkins.example.com/api/json")
+```
+
+## License
+
+MIT

zenkins-0.1.0/README.md

@@ -0,0 +1,39 @@
+# zenkins
+
+CLI tool for Jenkins. List jobs, check builds, view logs, trigger builds.
+
+## Install
+
+```bash
+pip install zenkins
+```
+
+## Setup
+
+Run `zenkins init` to configure your Jenkins connection. This creates `~/.config/jenkins/config` with your Jenkins URL and credentials.
+
+## Usage
+
+```bash
+zenkins jobs              # List all jobs with status
+zenkins status <job>      # Show last build info
+zenkins builds <job>      # List recent builds
+zenkins builds <job> -n 5 # List last 5 builds
+zenkins log <job>         # Show console output (last build)
+zenkins log <job> 42      # Show console output for build #42
+zenkins queue             # Show build queue
+zenkins build <job>       # Trigger a build
+```
+
+## Library usage
+
+```python
+import zenkins
+
+s = zenkins.client()
+resp = s.get("http://jenkins.example.com/api/json")
+```
+
+## License
+
+MIT

zenkins-0.1.0/pyproject.toml

@@ -0,0 +1,41 @@
+[project]
+name = "zenkins"
+version = "0.1.0"
+description = "CLI tool for Jenkins. List jobs, check builds, view logs, trigger builds."
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.11"
+keywords = ["jenkins", "cli", "ci", "builds"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Software Development",
+    "Topic :: Utilities",
+]
+dependencies = [
+    "requests>=2.31.0",
+    "platformdirs>=4.0.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/vivainio/zenkins"
+Repository = "https://github.com/vivainio/zenkins"
+Issues = "https://github.com/vivainio/zenkins/issues"
+
+[project.scripts]
+zenkins = "zenkins.cli:main"
+
+[dependency-groups]
+dev = ["pytest>=8.0"]
+
+[tool.uv]
+package = true
+
+[tool.setuptools]
+packages = ["zenkins"]

zenkins-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

zenkins-0.1.0/tests/test_builds.py

@@ -0,0 +1,86 @@
+"""Tests for zenkins.builds and zenkins.status."""
+
+import argparse
+from unittest.mock import MagicMock, patch
+
+from zenkins.builds import builds_command, format_duration
+from zenkins.status import status_command, format_timestamp
+
+
+def test_format_duration_seconds():
+    assert format_duration(5000) == "5s"
+
+
+def test_format_duration_minutes():
+    assert format_duration(125000) == "2m 5s"
+
+
+def test_format_duration_hours():
+    assert format_duration(3725000) == "1h 2m"
+
+
+def test_format_timestamp():
+    ts = format_timestamp(1700000000000)
+    # Exact date depends on timezone, just check format
+    assert "2023-11-1" in ts
+    assert ":" in ts
+
+
+def test_builds_command(mock_session, capsys):
+    """Test builds listing."""
+    mock_resp = MagicMock()
+    mock_resp.json.return_value = {
+        "builds": [
+            {
+                "number": 42,
+                "result": "SUCCESS",
+                "timestamp": 1700000000000,
+                "duration": 60000,
+                "building": False,
+            },
+            {
+                "number": 41,
+                "result": "FAILURE",
+                "timestamp": 1699990000000,
+                "duration": 30000,
+                "building": False,
+            },
+        ]
+    }
+    mock_session.get.return_value = mock_resp
+
+    args = argparse.Namespace(job="test-job", n=10)
+    with patch("zenkins.client.get_base_url", return_value="http://j"):
+        builds_command(args)
+
+    out = capsys.readouterr().out
+    assert "#42" in out
+    assert "#41" in out
+    assert "SUCCESS" in out
+    assert "FAILURE" in out
+
+
+def test_status_command(mock_session, capsys):
+    """Test status display."""
+    mock_resp = MagicMock()
+    mock_resp.json.return_value = {
+        "lastBuild": {
+            "number": 99,
+            "result": "SUCCESS",
+            "timestamp": 1700000000000,
+            "duration": 120000,
+            "building": False,
+            "displayName": "#99",
+            "description": None,
+        }
+    }
+    mock_session.get.return_value = mock_resp
+
+    args = argparse.Namespace(job="my-job")
+    with patch("zenkins.client.get_base_url", return_value="http://j"):
+        status_command(args)
+
+    out = capsys.readouterr().out
+    assert "my-job" in out
+    assert "#99" in out
+    assert "SUCCESS" in out

zenkins-0.1.0/tests/test_client.py

@@ -0,0 +1,76 @@
+"""Tests for zenkins.client."""
+
+from unittest.mock import MagicMock, patch
+from pathlib import Path
+
+from zenkins.client import load_credentials, api_get, api_post
+
+
+def test_load_credentials(tmp_path):
+    """Test loading KEY=VALUE config file."""
+    config = tmp_path / "config"
+    config.write_text(
+        "JENKINS_URL=http://jenkins.example.com\n"
+        "JENKINS_USER=testuser\n"
+        "JENKINS_TOKEN=abc123\n"
+    )
+
+    with patch("zenkins.client.CONFIG_FILE", config):
+        creds = load_credentials()
+
+    assert creds["url"] == "http://jenkins.example.com"
+    assert creds["user"] == "testuser"
+    assert creds["token"] == "abc123"
+
+
+def test_load_credentials_missing_file(tmp_path):
+    """Test loading from nonexistent file returns empty dict."""
+    config = tmp_path / "nonexistent"
+
+    with patch("zenkins.client.CONFIG_FILE", config):
+        creds = load_credentials()
+
+    assert creds == {}
+
+
+def test_load_credentials_comments_and_blanks(tmp_path):
+    """Test that comments and blank lines are ignored."""
+    config = tmp_path / "config"
+    config.write_text(
+        "# This is a comment\n"
+        "\n"
+        "JENKINS_URL=http://jenkins.example.com\n"
+        "  \n"
+        "JENKINS_USER=testuser\n"
+    )
+
+    with patch("zenkins.client.CONFIG_FILE", config):
+        creds = load_credentials()
+
+    assert creds["url"] == "http://jenkins.example.com"
+    assert creds["user"] == "testuser"
+    assert "token" not in creds
+
+
+def test_api_get(mock_session):
+    """Test api_get combines base URL and path."""
+    mock_resp = MagicMock()
+    mock_session.get.return_value = mock_resp
+
+    with patch("zenkins.client.get_base_url", return_value="http://jenkins.example.com"):
+        resp = api_get("/api/json")
+
+    mock_session.get.assert_called_once_with("http://jenkins.example.com/api/json")
+    mock_resp.raise_for_status.assert_called_once()
+
+
+def test_api_post(mock_session):
+    """Test api_post combines base URL and path."""
+    mock_resp = MagicMock()
+    mock_session.post.return_value = mock_resp
+
+    with patch("zenkins.client.get_base_url", return_value="http://jenkins.example.com"):
+        resp = api_post("/job/test/build")
+
+    mock_session.post.assert_called_once_with("http://jenkins.example.com/job/test/build")
+    mock_resp.raise_for_status.assert_called_once()

zenkins-0.1.0/tests/test_jobs.py

@@ -0,0 +1,46 @@
+"""Tests for zenkins.jobs."""
+
+import argparse
+from unittest.mock import MagicMock, patch
+
+from zenkins.jobs import jobs_command, STATUS_MAP, COLOR_MAP
+
+
+def test_jobs_command(mock_session, capsys):
+    """Test jobs listing."""
+    mock_resp = MagicMock()
+    mock_resp.json.return_value = {
+        "jobs": [
+            {"name": "my-job", "color": "blue", "url": "http://j/job/my-job/"},
+            {"name": "broken-job", "color": "red", "url": "http://j/job/broken-job/"},
+        ]
+    }
+    mock_session.get.return_value = mock_resp
+
+    with patch("zenkins.client.get_base_url", return_value="http://j"):
+        jobs_command(argparse.Namespace())
+
+    out = capsys.readouterr().out
+    assert "my-job" in out
+    assert "broken-job" in out
+    assert "SUCCESS" in out
+    assert "FAILURE" in out
+
+
+def test_jobs_empty(mock_session, capsys):
+    """Test empty jobs list."""
+    mock_resp = MagicMock()
+    mock_resp.json.return_value = {"jobs": []}
+    mock_session.get.return_value = mock_resp
+
+    with patch("zenkins.client.get_base_url", return_value="http://j"):
+        jobs_command(argparse.Namespace())
+
+    out = capsys.readouterr().out
+    assert "No jobs found" in out
+
+
+def test_status_map_covers_colors():
+    """All colors in COLOR_MAP should have a STATUS_MAP entry."""
+    for color in COLOR_MAP:
+        assert color in STATUS_MAP

zenkins-0.1.0/zenkins/__init__.py

@@ -0,0 +1,24 @@
+"""Zenkins - Jenkins CLI tool."""
+
+from importlib.metadata import version
+
+__version__ = version("zenkins")
+
+
+def client() -> "requests.Session":
+    """Get an authenticated Jenkins session.
+
+    Returns a requests.Session configured with Jenkins credentials
+    from ~/.config/jenkins/config.
+
+    Usage:
+        import zenkins
+        s = zenkins.client()
+        resp = s.get("http://jenkins.example.com/api/json")
+
+    Returns:
+        requests.Session: Authenticated session
+    """
+    from zenkins.client import get_session
+
+    return get_session()

zenkins-0.1.0/zenkins/__main__.py

@@ -0,0 +1,6 @@
+"""Entry point for python -m zenkins."""
+
+from zenkins.cli import main
+
+if __name__ == "__main__":
+    main()

zenkins-0.1.0/zenkins/build.py

@@ -0,0 +1,15 @@
+"""zenkins build <job> - trigger a build."""
+
+import argparse
+
+from zenkins.client import api_post
+
+GREEN = "\033[32m"
+RESET = "\033[0m"
+
+
+def build_command(args: argparse.Namespace) -> None:
+    """Trigger a build for a job."""
+    job = args.job
+    api_post(f"/job/{job}/build")
+    print(f"{GREEN}Build triggered:{RESET} {job}")

zenkins-0.1.0/zenkins/builds.py

@@ -0,0 +1,71 @@
+"""zenkins builds <job> [-n N] - recent builds."""
+
+import argparse
+from datetime import datetime, timezone
+
+from zenkins.client import api_get
+
+GREEN = "\033[32m"
+RED = "\033[31m"
+YELLOW = "\033[33m"
+GRAY = "\033[90m"
+RESET = "\033[0m"
+
+RESULT_COLORS = {
+    "SUCCESS": GREEN,
+    "FAILURE": RED,
+    "UNSTABLE": YELLOW,
+    "ABORTED": GRAY,
+    None: YELLOW,
+}
+
+
+def format_duration(ms: int) -> str:
+    """Format milliseconds to human-readable duration."""
+    seconds = ms // 1000
+    if seconds < 60:
+        return f"{seconds}s"
+    minutes = seconds // 60
+    secs = seconds % 60
+    if minutes < 60:
+        return f"{minutes}m {secs}s"
+    hours = minutes // 60
+    mins = minutes % 60
+    return f"{hours}h {mins}m"
+
+
+def builds_command(args: argparse.Namespace) -> None:
+    """List recent builds for a job."""
+    job = args.job
+    n = args.n
+    tree = f"builds[number,result,timestamp,duration,building]{{{0},{n}}}"
+    resp = api_get(f"/job/{job}/api/json?tree={tree}")
+    data = resp.json()
+
+    builds = data.get("builds", [])
+    if not builds:
+        print(f"No builds found for {job}")
+        return
+
+    for build in builds:
+        number = build["number"]
+        result = build.get("result")
+        building = build.get("building", False)
+        ts = build.get("timestamp", 0)
+        dur = build.get("duration", 0)
+
+        dt = datetime.fromtimestamp(ts / 1000, tz=timezone.utc).astimezone()
+        date_str = dt.strftime("%Y-%m-%d %H:%M")
+        dur_str = format_duration(dur)
+
+        if building:
+            color = YELLOW
+            status = "BUILDING"
+        elif result:
+            color = RESULT_COLORS.get(result, GRAY)
+            status = result
+        else:
+            color = GRAY
+            status = "?"
+
+        print(f"  #{number:<6} {color}{status:>10}{RESET}  {date_str}  {dur_str}")

zenkins-0.1.0/zenkins/cli.py

@@ -0,0 +1,73 @@
+"""Zenkins CLI - Main entry point."""
+
+import argparse
+import sys
+
+from zenkins import __version__
+from zenkins.build import build_command
+from zenkins.builds import builds_command
+from zenkins.init import init_command
+from zenkins.jobs import jobs_command
+from zenkins.log import log_command
+from zenkins.queue import queue_command
+from zenkins.status import status_command
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(
+        prog="zenkins",
+        description="Jenkins CLI tool",
+    )
+    parser.add_argument(
+        "-V",
+        "--version",
+        action="version",
+        version=f"%(prog)s {__version__}",
+    )
+
+    subparsers = parser.add_subparsers(dest="command", help="Commands")
+
+    # init
+    subparsers.add_parser("init", help="Verify Jenkins configuration and connectivity")
+
+    # jobs
+    subparsers.add_parser("jobs", help="List all jobs with status")
+
+    # status
+    status_parser = subparsers.add_parser("status", help="Show last build info for a job")
+    status_parser.add_argument("job", help="Job name")
+
+    # builds
+    builds_parser = subparsers.add_parser("builds", help="List recent builds for a job")
+    builds_parser.add_argument("job", help="Job name")
+    builds_parser.add_argument("-n", type=int, default=10, help="Number of builds (default: 10)")
+
+    # log
+    log_parser = subparsers.add_parser("log", help="Show console output for a build")
+    log_parser.add_argument("job", help="Job name")
+    log_parser.add_argument("build", nargs="?", help="Build number (default: last build)")
+
+    # queue
+    subparsers.add_parser("queue", help="Show build queue")
+
+    # build
+    build_parser = subparsers.add_parser("build", help="Trigger a build")
+    build_parser.add_argument("job", help="Job name")
+
+    args = parser.parse_args()
+
+    if not args.command:
+        parser.print_help()
+        sys.exit(1)
+
+    commands = {
+        "init": init_command,
+        "jobs": jobs_command,
+        "status": status_command,
+        "builds": builds_command,
+        "log": log_command,
+        "queue": queue_command,
+        "build": build_command,
+    }
+
+    commands[args.command](args)

zenkins-0.1.0/zenkins/client.py

@@ -0,0 +1,126 @@
+"""Jenkins HTTP client - session management and credential loading."""
+
+import sys
+from functools import lru_cache
+from pathlib import Path
+
+import requests
+
+from zenkins.types import Credentials
+
+CONFIG_FILE = Path.home() / ".config" / "jenkins" / "config"
+
+
+def load_credentials() -> Credentials:
+    """Load credentials from ~/.config/jenkins/config (KEY=VALUE format)."""
+    if not CONFIG_FILE.exists():
+        return {}
+
+    creds: Credentials = {}
+    for line in CONFIG_FILE.read_text().splitlines():
+        line = line.strip()
+        if not line or line.startswith("#"):
+            continue
+        if "=" not in line:
+            continue
+        key, _, value = line.partition("=")
+        key = key.strip()
+        value = value.strip()
+        if key == "JENKINS_URL":
+            creds["url"] = value
+        elif key == "JENKINS_USER":
+            creds["user"] = value
+        elif key == "JENKINS_TOKEN":
+            creds["token"] = value
+    return creds
+
+
+def get_credentials() -> tuple[str, str, str]:
+    """Get Jenkins credentials.
+
+    Returns:
+        Tuple of (url, user, token)
+    """
+    creds = load_credentials()
+    url = creds.get("url")
+    user = creds.get("user")
+    token = creds.get("token")
+
+    if not url or not user or not token:
+        print(f"Error: Credentials not configured in {CONFIG_FILE}", file=sys.stderr)
+        print("\nRun 'zenkins init' to check configuration.", file=sys.stderr)
+        sys.exit(1)
+
+    return url.rstrip("/"), user, token
+
+
+# Injected session for testing
+_session: requests.Session | None = None
+
+
+def get_session() -> requests.Session:
+    """Get the requests session (cached or injected)."""
+    global _session
+    if _session is not None:
+        return _session
+    return _get_default_session()
+
+
+@lru_cache(maxsize=1)
+def _get_default_session() -> requests.Session:
+    """Create the default authenticated session."""
+    url, user, token = get_credentials()
+    s = requests.Session()
+    s.auth = (user, token)
+    return s
+
+
+def set_session(session: requests.Session | None) -> None:
+    """Inject a session for testing. Pass None to reset."""
+    global _session
+    _session = session
+
+
+def reset_session() -> None:
+    """Reset to default session and clear cache."""
+    global _session
+    _session = None
+    _get_default_session.cache_clear()
+
+
+def get_base_url() -> str:
+    """Get the Jenkins base URL."""
+    url, _, _ = get_credentials()
+    return url
+
+
+def api_get(path: str, **kwargs) -> requests.Response:
+    """GET a Jenkins API path.
+
+    Args:
+        path: API path (e.g., "/api/json" or "/job/foo/api/json")
+        **kwargs: Extra arguments passed to session.get()
+
+    Returns:
+        Response object
+    """
+    url = get_base_url() + path
+    resp = get_session().get(url, **kwargs)
+    resp.raise_for_status()
+    return resp
+
+
+def api_post(path: str, **kwargs) -> requests.Response:
+    """POST to a Jenkins API path.
+
+    Args:
+        path: API path (e.g., "/job/foo/build")
+        **kwargs: Extra arguments passed to session.post()
+
+    Returns:
+        Response object
+    """
+    url = get_base_url() + path
+    resp = get_session().post(url, **kwargs)
+    resp.raise_for_status()
+    return resp

zenkins-0.1.0/zenkins/init.py

@@ -0,0 +1,39 @@
+"""zenkins init - verify Jenkins configuration."""
+
+import argparse
+import sys
+
+from zenkins.client import CONFIG_FILE, load_credentials, api_get
+
+
+def init_command(args: argparse.Namespace) -> None:
+    """Verify Jenkins credentials and connectivity."""
+    print(f"Config file: {CONFIG_FILE}")
+
+    if not CONFIG_FILE.exists():
+        print(f"\nError: Config file not found at {CONFIG_FILE}", file=sys.stderr)
+        print("Create it with:", file=sys.stderr)
+        print("  JENKINS_URL=http://your-jenkins.example.com", file=sys.stderr)
+        print("  JENKINS_USER=your-username", file=sys.stderr)
+        print("  JENKINS_TOKEN=your-api-token", file=sys.stderr)
+        sys.exit(1)
+
+    creds = load_credentials()
+    url = creds.get("url", "")
+    user = creds.get("user", "")
+    token = creds.get("token", "")
+
+    print(f"URL:  {url}")
+    print(f"User: {user}")
+    print(f"Token: {'*' * 8}...{token[-4:]}" if len(token) > 4 else f"Token: {'*' * len(token)}")
+
+    # Test connectivity
+    print("\nTesting connection...")
+    try:
+        resp = api_get("/api/json?tree=mode,nodeDescription,useSecurity")
+        data = resp.json()
+        print(f"Connected: {data.get('nodeDescription', 'Jenkins')}")
+        print(f"Security:  {'enabled' if data.get('useSecurity') else 'disabled'}")
+    except Exception as e:
+        print(f"Connection failed: {e}", file=sys.stderr)
+        sys.exit(1)

zenkins-0.1.0/zenkins/jobs.py

@@ -0,0 +1,66 @@
+"""zenkins jobs - list all jobs with status."""
+
+import argparse
+
+from zenkins.client import api_get
+
+# ANSI colors
+GREEN = "\033[32m"
+RED = "\033[31m"
+YELLOW = "\033[33m"
+BLUE = "\033[34m"
+GRAY = "\033[90m"
+BOLD = "\033[1m"
+RESET = "\033[0m"
+
+COLOR_MAP = {
+    "blue": GREEN,           # success
+    "blue_anime": GREEN,     # success + building
+    "red": RED,              # failure
+    "red_anime": RED,        # failure + building
+    "yellow": YELLOW,        # unstable
+    "yellow_anime": YELLOW,  # unstable + building
+    "aborted": GRAY,
+    "aborted_anime": GRAY,
+    "disabled": GRAY,
+    "notbuilt": GRAY,
+    "notbuilt_anime": GRAY,
+}
+
+STATUS_MAP = {
+    "blue": "SUCCESS",
+    "blue_anime": "BUILDING",
+    "red": "FAILURE",
+    "red_anime": "BUILDING",
+    "yellow": "UNSTABLE",
+    "yellow_anime": "BUILDING",
+    "aborted": "ABORTED",
+    "aborted_anime": "BUILDING",
+    "disabled": "DISABLED",
+    "notbuilt": "NOT BUILT",
+    "notbuilt_anime": "BUILDING",
+}
+
+
+def jobs_command(args: argparse.Namespace) -> None:
+    """List all jobs with their current status."""
+    tree = "jobs[name,color,url]"
+    resp = api_get(f"/api/json?tree={tree}")
+    data = resp.json()
+    jobs = data.get("jobs", [])
+
+    if not jobs:
+        print("No jobs found.")
+        return
+
+    # Calculate column width
+    max_name = max(len(j["name"]) for j in jobs)
+
+    for job in sorted(jobs, key=lambda j: j["name"]):
+        color_code = job.get("color", "notbuilt")
+        ansi = COLOR_MAP.get(color_code, GRAY)
+        status = STATUS_MAP.get(color_code, color_code)
+        building = " *" if "_anime" in (color_code or "") else ""
+
+        name = job["name"].ljust(max_name)
+        print(f"  {ansi}{status:>10}{RESET}  {name}{building}")

zenkins-0.1.0/zenkins/log.py

@@ -0,0 +1,14 @@
+"""zenkins log <job> [build] - console output."""
+
+import argparse
+
+from zenkins.client import api_get
+
+
+def log_command(args: argparse.Namespace) -> None:
+    """Show console output for a build."""
+    job = args.job
+    build = args.build or "lastBuild"
+
+    resp = api_get(f"/job/{job}/{build}/consoleText")
+    print(resp.text)

zenkins-0.1.0/zenkins/queue.py

@@ -0,0 +1,38 @@
+"""zenkins queue - build queue."""
+
+import argparse
+
+from zenkins.client import api_get
+
+YELLOW = "\033[33m"
+RED = "\033[31m"
+GRAY = "\033[90m"
+RESET = "\033[0m"
+
+
+def queue_command(args: argparse.Namespace) -> None:
+    """Show the Jenkins build queue."""
+    resp = api_get("/queue/api/json?tree=items[id,task[name],why,stuck,blocked,buildable]")
+    data = resp.json()
+
+    items = data.get("items", [])
+    if not items:
+        print("Build queue is empty.")
+        return
+
+    print(f"Queue: {len(items)} item(s)\n")
+    for item in items:
+        task_name = item.get("task", {}).get("name", "?")
+        why = item.get("why", "")
+        stuck = item.get("stuck", False)
+
+        if stuck:
+            color = RED
+            flag = " [STUCK]"
+        else:
+            color = YELLOW
+            flag = ""
+
+        print(f"  {color}{task_name}{RESET}{flag}")
+        if why:
+            print(f"    {GRAY}{why}{RESET}")

zenkins-0.1.0/zenkins/status.py

@@ -0,0 +1,73 @@
+"""zenkins status <job> - last build info."""
+
+import argparse
+from datetime import datetime, timezone
+
+from zenkins.client import api_get
+
+GREEN = "\033[32m"
+RED = "\033[31m"
+YELLOW = "\033[33m"
+GRAY = "\033[90m"
+BOLD = "\033[1m"
+RESET = "\033[0m"
+
+RESULT_COLORS = {
+    "SUCCESS": GREEN,
+    "FAILURE": RED,
+    "UNSTABLE": YELLOW,
+    "ABORTED": GRAY,
+    None: YELLOW,
+}
+
+
+def format_duration(ms: int) -> str:
+    """Format milliseconds to human-readable duration."""
+    seconds = ms // 1000
+    if seconds < 60:
+        return f"{seconds}s"
+    minutes = seconds // 60
+    secs = seconds % 60
+    if minutes < 60:
+        return f"{minutes}m {secs}s"
+    hours = minutes // 60
+    mins = minutes % 60
+    return f"{hours}h {mins}m"
+
+
+def format_timestamp(ts: int) -> str:
+    """Format Unix millisecond timestamp."""
+    dt = datetime.fromtimestamp(ts / 1000, tz=timezone.utc).astimezone()
+    return dt.strftime("%Y-%m-%d %H:%M:%S")
+
+
+def status_command(args: argparse.Namespace) -> None:
+    """Show status of the last build for a job."""
+    job = args.job
+    tree = "lastBuild[number,result,timestamp,duration,building,displayName,description]"
+    resp = api_get(f"/job/{job}/api/json?tree={tree}")
+    data = resp.json()
+
+    build = data.get("lastBuild")
+    if not build:
+        print(f"No builds found for {job}")
+        return
+
+    result = build.get("result")
+    building = build.get("building", False)
+    color = RESULT_COLORS.get(result, GRAY)
+
+    if building:
+        status_str = f"{YELLOW}BUILDING{RESET}"
+    elif result:
+        status_str = f"{color}{result}{RESET}"
+    else:
+        status_str = f"{GRAY}UNKNOWN{RESET}"
+
+    print(f"{BOLD}{job}{RESET}  #{build['number']}")
+    print(f"  Status:   {status_str}")
+    print(f"  Started:  {format_timestamp(build['timestamp'])}")
+    print(f"  Duration: {format_duration(build['duration'])}")
+
+    if build.get("description"):
+        print(f"  Desc:     {build['description']}")

zenkins-0.1.0/zenkins/types.py

@@ -0,0 +1,46 @@
+"""Type definitions for Jenkins API responses."""
+
+from typing import TypedDict
+
+
+class HealthReport(TypedDict, total=False):
+    description: str
+    score: int
+
+
+class Job(TypedDict, total=False):
+    name: str
+    url: str
+    color: str
+    healthReport: list[HealthReport]
+    lastBuild: "Build | None"
+    lastSuccessfulBuild: "Build | None"
+    lastFailedBuild: "Build | None"
+    inQueue: bool
+
+
+class Build(TypedDict, total=False):
+    number: int
+    url: str
+    result: str | None
+    timestamp: int
+    duration: int
+    building: bool
+    displayName: str
+    description: str | None
+    fullDisplayName: str
+
+
+class QueueItem(TypedDict, total=False):
+    id: int
+    task: Job
+    why: str | None
+    stuck: bool
+    buildable: bool
+    blocked: bool
+
+
+class Credentials(TypedDict, total=False):
+    url: str
+    user: str
+    token: str

zenkins-0.1.0/zenkins.egg-info/PKG-INFO

@@ -0,0 +1,63 @@
+Metadata-Version: 2.4
+Name: zenkins
+Version: 0.1.0
+Summary: CLI tool for Jenkins. List jobs, check builds, view logs, trigger builds.
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/vivainio/zenkins
+Project-URL: Repository, https://github.com/vivainio/zenkins
+Project-URL: Issues, https://github.com/vivainio/zenkins/issues
+Keywords: jenkins,cli,ci,builds
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+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
+Classifier: Topic :: Utilities
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.31.0
+Requires-Dist: platformdirs>=4.0.0
+
+# zenkins
+
+CLI tool for Jenkins. List jobs, check builds, view logs, trigger builds.
+
+## Install
+
+```bash
+pip install zenkins
+```
+
+## Setup
+
+Run `zenkins init` to configure your Jenkins connection. This creates `~/.config/jenkins/config` with your Jenkins URL and credentials.
+
+## Usage
+
+```bash
+zenkins jobs              # List all jobs with status
+zenkins status <job>      # Show last build info
+zenkins builds <job>      # List recent builds
+zenkins builds <job> -n 5 # List last 5 builds
+zenkins log <job>         # Show console output (last build)
+zenkins log <job> 42      # Show console output for build #42
+zenkins queue             # Show build queue
+zenkins build <job>       # Trigger a build
+```
+
+## Library usage
+
+```python
+import zenkins
+
+s = zenkins.client()
+resp = s.get("http://jenkins.example.com/api/json")
+```
+
+## License
+
+MIT

zenkins-0.1.0/zenkins.egg-info/SOURCES.txt

@@ -0,0 +1,23 @@
+README.md
+pyproject.toml
+tests/test_builds.py
+tests/test_client.py
+tests/test_jobs.py
+zenkins/__init__.py
+zenkins/__main__.py
+zenkins/build.py
+zenkins/builds.py
+zenkins/cli.py
+zenkins/client.py
+zenkins/init.py
+zenkins/jobs.py
+zenkins/log.py
+zenkins/queue.py
+zenkins/status.py
+zenkins/types.py
+zenkins.egg-info/PKG-INFO
+zenkins.egg-info/SOURCES.txt
+zenkins.egg-info/dependency_links.txt
+zenkins.egg-info/entry_points.txt
+zenkins.egg-info/requires.txt
+zenkins.egg-info/top_level.txt

zenkins-0.1.0/zenkins.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

zenkins-0.1.0/zenkins.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+zenkins = zenkins.cli:main

zenkins-0.1.0/zenkins.egg-info/requires.txt

@@ -0,0 +1,2 @@
+requests>=2.31.0
+platformdirs>=4.0.0

zenkins-0.1.0/zenkins.egg-info/top_level.txt

@@ -0,0 +1 @@
+zenkins