gl-pipeline-watcher 0.1.0__tar.gz

gl_pipeline_watcher-0.1.0/.gitignore

@@ -0,0 +1,6 @@
+__pycache__/
+*.py[cod]
+*.egg-info/
+dist/
+build/
+.venv/

gl_pipeline_watcher-0.1.0/PKG-INFO

@@ -0,0 +1,86 @@
+Metadata-Version: 2.4
+Name: gl-pipeline-watcher
+Version: 0.1.0
+Summary: Curses TUI for watching GitLab CI pipelines
+Project-URL: Repository, https://gitlab.com/alexandra.tapkova/gl-pipeline-watcher
+Author-email: Alexandra Ťapková <git@ouppy.space>
+License: MIT
+Keywords: ci,curses,devops,gitlab,pipeline,tui
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console :: Curses
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development :: Build Tools
+Requires-Python: >=3.9
+Provides-Extra: dev
+Requires-Dist: build; extra == 'dev'
+Requires-Dist: twine; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# gl-pipeline-watcher
+
+Terminal UI for watching GitLab CI pipelines. Shows pipeline status, job states, last few log lines, and Docker build progress for running and recently failed pipelines.
+
+## Install
+
+```
+pip install gl-pipeline-watcher
+```
+
+No dependencies outside the standard library.
+
+## Usage
+
+Run from inside a git repo:
+
+```
+wp [branch]
+```
+
+If no branch is given, the current branch is detected automatically. The GitLab URL and project path are detected from `git remote get-url origin`. Both SSH (`git@host:group/repo`) and HTTPS remotes work.
+
+## Token setup
+
+You need a GitLab personal access token with `read_api` scope.
+
+**Simple:** set `GITLAB_TOKEN` in your environment.
+
+**Per-domain:** create `~/.config/gitlab-pipeline-tokens.json` mapping hostnames to files containing tokens:
+
+```json
+{
+  "gitlab.example.com": "/path/to/token-file"
+}
+```
+
+`GITLAB_TOKEN` takes priority over the file map when both are set.
+
+## Environment variables
+
+| Variable | Default | Description |
+|---|---|---|
+| `GITLAB_TOKEN` | | Token (takes priority over token map) |
+| `GITLAB_URL` | auto | Base URL, e.g. `https://gitlab.com` |
+| `GITLAB_PROJECT` | auto | Project path, e.g. `mygroup/myrepo` |
+| `REFRESH` | `10` | Polling interval in seconds |
+| `LOG_LINES` | `5` | Trace lines shown per running/failed job |
+
+## Keys
+
+| Key | Action |
+|---|---|
+| `j` / `k`, arrow keys | Scroll |
+| `PgUp` / `PgDn` | Page up/down |
+| `Home` / `End` | Jump to top/bottom |
+| `r` | Force refresh |
+| `q`, `Esc` | Quit |
+
+## License
+
+MIT

gl_pipeline_watcher-0.1.0/README.md

@@ -0,0 +1,61 @@
+# gl-pipeline-watcher
+
+Terminal UI for watching GitLab CI pipelines. Shows pipeline status, job states, last few log lines, and Docker build progress for running and recently failed pipelines.
+
+## Install
+
+```
+pip install gl-pipeline-watcher
+```
+
+No dependencies outside the standard library.
+
+## Usage
+
+Run from inside a git repo:
+
+```
+wp [branch]
+```
+
+If no branch is given, the current branch is detected automatically. The GitLab URL and project path are detected from `git remote get-url origin`. Both SSH (`git@host:group/repo`) and HTTPS remotes work.
+
+## Token setup
+
+You need a GitLab personal access token with `read_api` scope.
+
+**Simple:** set `GITLAB_TOKEN` in your environment.
+
+**Per-domain:** create `~/.config/gitlab-pipeline-tokens.json` mapping hostnames to files containing tokens:
+
+```json
+{
+  "gitlab.example.com": "/path/to/token-file"
+}
+```
+
+`GITLAB_TOKEN` takes priority over the file map when both are set.
+
+## Environment variables
+
+| Variable | Default | Description |
+|---|---|---|
+| `GITLAB_TOKEN` | | Token (takes priority over token map) |
+| `GITLAB_URL` | auto | Base URL, e.g. `https://gitlab.com` |
+| `GITLAB_PROJECT` | auto | Project path, e.g. `mygroup/myrepo` |
+| `REFRESH` | `10` | Polling interval in seconds |
+| `LOG_LINES` | `5` | Trace lines shown per running/failed job |
+
+## Keys
+
+| Key | Action |
+|---|---|
+| `j` / `k`, arrow keys | Scroll |
+| `PgUp` / `PgDn` | Page up/down |
+| `Home` / `End` | Jump to top/bottom |
+| `r` | Force refresh |
+| `q`, `Esc` | Quit |
+
+## License
+
+MIT

gl_pipeline_watcher-0.1.0/pyproject.toml

@@ -0,0 +1,41 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "gl-pipeline-watcher"
+version = "0.1.0"
+description = "Curses TUI for watching GitLab CI pipelines"
+readme = "README.md"
+license = { text = "MIT" }
+requires-python = ">=3.9"
+authors = [{ name = "Alexandra Ťapková", email = "git@ouppy.space" }]
+keywords = ["gitlab", "ci", "pipeline", "tui", "curses", "devops"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Environment :: Console :: Curses",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Topic :: Software Development :: Build Tools",
+]
+
+dependencies = []
+
+[project.optional-dependencies]
+dev = ["build", "twine"]
+
+[project.scripts]
+wp = "gl_pipeline_watcher.__main__:main"
+gl-pipeline-watcher = "gl_pipeline_watcher.__main__:main"
+
+[project.urls]
+Repository = "https://gitlab.com/alexandra.tapkova/gl-pipeline-watcher"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/gl_pipeline_watcher"]

gl_pipeline_watcher-0.1.0/src/gl_pipeline_watcher/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

gl_pipeline_watcher-0.1.0/src/gl_pipeline_watcher/__main__.py

@@ -0,0 +1,344 @@
+"""GitLab pipeline watcher — curses TUI.
+Usage: wp [branch]
+       gl-pipeline-watcher [branch]
+
+Env:
+  GITLAB_TOKEN    Personal access token (read_api scope). Takes priority over token map.
+  GITLAB_URL      GitLab base URL (auto-detected from git remote if unset).
+  GITLAB_PROJECT  Project path, e.g. mygroup/myrepo (auto-detected from git remote).
+  REFRESH         Polling interval in seconds (default: 10).
+  LOG_LINES       Trace lines shown per job (default: 5).
+
+Token map (~/.config/gitlab-pipeline-tokens.json):
+  Alternative to GITLAB_TOKEN for multi-domain setups. JSON object mapping
+  hostname to a file path containing the token, e.g.:
+    { "gitlab.example.com": "/run/secrets/gitlab_token" }
+  GITLAB_TOKEN takes priority when set.
+
+Keys: ↑↓ / j k  scroll   PgUp/PgDn  page   Home/End   r  refresh   q  quit
+"""
+
+import curses
+import json
+import os
+import re
+import ssl
+import subprocess
+import sys
+import threading
+import time
+import urllib.request
+
+# ── config ────────────────────────────────────────────────────────────────────
+
+TOKENS_MAP = os.path.expanduser("~/.config/gitlab-pipeline-tokens.json")
+GIT        = "git"
+
+# These are module-level so setup() and the Watcher class can share them.
+BRANCH     = ""
+REFRESH    = 10
+LOG_LINES  = 5
+GITLAB_URL = ""
+PROJECT    = ""
+TOKEN      = ""
+
+# ── helpers ───────────────────────────────────────────────────────────────────
+
+def die(msg):
+    sys.exit(f"\033[31mError:\033[0m {msg}")
+
+def git_cmd(*args):
+    try:
+        return subprocess.check_output([GIT] + list(args),
+            stderr=subprocess.DEVNULL).decode().strip()
+    except (subprocess.CalledProcessError, FileNotFoundError):
+        return ""
+
+def _ssl_ctx(verify=True):
+    ctx = ssl.create_default_context()
+    if not verify:
+        ctx.check_hostname = False
+        ctx.verify_mode = ssl.CERT_NONE
+    return ctx
+
+def _get(url):
+    req = urllib.request.Request(url, headers={"PRIVATE-TOKEN": TOKEN})
+    for verify in (True, False):
+        try:
+            with urllib.request.urlopen(req, timeout=15, context=_ssl_ctx(verify)) as r:
+                return r.read()
+        except ssl.SSLError:
+            continue
+    raise RuntimeError(f"SSL error fetching {url}")
+
+def api(path):
+    return json.loads(_get(f"{GITLAB_URL}/api/v4/{path}"))
+
+def strip_ansi(s):
+    return re.sub(r'\x1b\[[0-9;?]*[A-Za-z]|\r', "", s)
+
+_DOCKER_STEP = re.compile(r'^Step\s+(\d+)/(\d+)\s*:\s*(.*)')
+
+# ── setup ─────────────────────────────────────────────────────────────────────
+
+def setup():
+    global TOKEN, BRANCH, GITLAB_URL, PROJECT, REFRESH, LOG_LINES
+
+    REFRESH   = int(os.environ.get("REFRESH", "10"))
+    LOG_LINES = int(os.environ.get("LOG_LINES", "5"))
+    GITLAB_URL = os.environ.get("GITLAB_URL", "")
+    PROJECT    = os.environ.get("GITLAB_PROJECT", "")
+    BRANCH     = sys.argv[1] if len(sys.argv) > 1 else ""
+
+    if not BRANCH:
+        BRANCH = git_cmd("symbolic-ref", "--short", "HEAD")
+    if not BRANCH:
+        die("Could not detect current branch. Pass a branch name as an argument.")
+
+    remote = None
+    if not GITLAB_URL or not PROJECT:
+        remote = git_cmd("remote", "get-url", "origin")
+        if not remote:
+            die('No git remote "origin" found. Set GITLAB_URL and GITLAB_PROJECT.')
+
+    if not PROJECT:
+        m = re.match(r'^git@[^:]+:/?(.+?)(?:\.git)?$', remote) or \
+            re.match(r'^https?://[^/]+/(.+?)(?:\.git)?$', remote)
+        if not m:
+            die(f"Cannot parse project path from remote: {remote}\nSet GITLAB_PROJECT.")
+        PROJECT = m.group(1)
+
+    # Extract hostname (needed for token lookup and scheme probe)
+    if GITLAB_URL:
+        m = re.match(r'^https?://([^/]+)', GITLAB_URL)
+        host = m.group(1) if m else None
+    else:
+        m = re.match(r'^git@([^:]+):', remote) or \
+            re.match(r'^https?://([^/]+)/', remote)
+        host = m.group(1) if m else "gitlab.com"
+
+    # Token resolution: env var takes priority, then per-host file map
+    TOKEN = os.environ.get("GITLAB_TOKEN", "")
+    if not TOKEN:
+        if os.path.exists(TOKENS_MAP):
+            try:
+                tokens_map = json.load(open(TOKENS_MAP))
+            except (OSError, json.JSONDecodeError) as e:
+                die(f"Cannot read token map {TOKENS_MAP}: {e}")
+            token_path = tokens_map.get(host)
+            if token_path:
+                try:
+                    TOKEN = open(token_path).read().strip()
+                except OSError as e:
+                    die(f"Cannot read token for '{host}' from {token_path}: {e}")
+        if not TOKEN:
+            die(
+                f"No token found for '{host}'.\n"
+                f"Set the GITLAB_TOKEN environment variable, or add an entry for\n"
+                f"'{host}' in {TOKENS_MAP}."
+            )
+
+    # Scheme probe (https first, then http; try with and without cert verify)
+    if not GITLAB_URL:
+        for scheme in ("https", "http"):
+            for verify in (True, False):
+                try:
+                    urllib.request.urlopen(
+                        urllib.request.Request(
+                            f"{scheme}://{host}/api/v4/version",
+                            headers={"PRIVATE-TOKEN": TOKEN}),
+                        timeout=5, context=_ssl_ctx(verify))
+                    GITLAB_URL = f"{scheme}://{host}"
+                    break
+                except Exception:
+                    pass
+            if GITLAB_URL:
+                break
+        if not GITLAB_URL:
+            GITLAB_URL = f"https://{host}"
+
+# ── rendering ─────────────────────────────────────────────────────────────────
+
+ICONS = {
+    "success": "✓", "failed": "✗", "running": "●",
+    "pending": "○", "created": "○", "canceled": "⊘",
+    "skipped": "–", "manual":  "▶",
+}
+# (color_pair_n, bold)
+STYLE = {
+    "success": (2, True),  "failed":  (1, True),  "running": (3, True),
+    "pending": (0, False), "created": (0, False), "canceled": (0, False),
+    "skipped": (0, False), "manual":  (4, False),
+}
+
+def fmt_dur(s):
+    if not s: return ""
+    s = int(s); return f"{s//60}m {s%60:02d}s"
+
+# A Row is (text, color_pair, bold, dim)
+def build_rows(pipelines, jobs_map, traces, docker_progress):
+    rows = []
+    for p in pipelines:
+        pid, st = p["id"], p["status"]
+        cp, bold = STYLE.get(st, (0, False))
+        icon = ICONS.get(st, "?")
+        rows.append((f"  Pipeline #{pid}  ·  {icon} {st}  ·  {p['updated_at']}", cp, bold, False))
+        rows.append((f"  {p['web_url']}", 0, False, True))
+        rows.append(("", 0, False, False))
+        last_stage = None
+        for job in jobs_map.get(pid, []):
+            jcp, jbold = STYLE.get(job["status"], (0, False))
+            if job["stage"] != last_stage:
+                rows.append((f"    ── {job['stage']}", 0, False, True))
+                last_stage = job["stage"]
+            rows.append((
+                f"    {ICONS.get(job['status'], '?')}  {job['name']:<30}  {fmt_dur(job.get('duration'))}",
+                jcp, jbold, False))
+            if job["id"] in docker_progress:
+                cur, total, step_name = docker_progress[job["id"]]
+                bar_w = 20
+                filled = round(bar_w * cur / total) if total else 0
+                bar = "█" * filled + "░" * (bar_w - filled)
+                rows.append((f"       │  [{bar}] {cur}/{total}  {step_name[:36]}", 4, False, False))
+            for ln in traces.get(job["id"], []):
+                rows.append((f"       │  {ln}", 0, False, True))
+            if traces.get(job["id"]) or job["id"] in docker_progress:
+                rows.append(("       │", 0, False, True))
+        rows.append(("", 0, False, False))
+    return rows
+
+# ── TUI ───────────────────────────────────────────────────────────────────────
+
+class Watcher:
+    def __init__(self, scr):
+        self.scr = scr
+        self.rows = []
+        self.scroll = 0
+        self.fetching = False
+        self.error = None
+        self.last_fetch = 0.0
+        self._lock = threading.Lock()
+
+    def _fetch(self):
+        self.fetching = True
+        self.error = None
+        enc = PROJECT.replace("/", "%2F")
+        try:
+            pipelines = api(f"projects/{enc}/pipelines?ref={BRANCH}&per_page=4")
+            jobs_map, traces, docker_progress = {}, {}, {}
+            for p in pipelines:
+                pid = p["id"]
+                jobs = sorted(api(f"projects/{enc}/pipelines/{pid}/jobs?per_page=100"),
+                              key=lambda j: j["id"])
+                jobs_map[pid] = jobs
+                for job in jobs:
+                    if job["status"] in ("running", "failed"):
+                        try:
+                            raw = _get(f"{GITLAB_URL}/api/v4/projects/{enc}/jobs/{job['id']}/trace")
+                            lines = [l for l in strip_ansi(
+                                raw.decode("utf-8", errors="replace")).splitlines() if l.strip()]
+                            if lines:
+                                traces[job["id"]] = [l[:80] for l in lines[-LOG_LINES:]]
+                            last_step = None
+                            for ln in lines:
+                                m = _DOCKER_STEP.match(ln)
+                                if m:
+                                    last_step = (int(m.group(1)), int(m.group(2)), m.group(3).strip())
+                            if last_step:
+                                docker_progress[job["id"]] = last_step
+                        except Exception:
+                            pass
+            with self._lock:
+                self.rows = build_rows(pipelines, jobs_map, traces, docker_progress)
+        except Exception as e:
+            self.error = str(e)
+        finally:
+            self.fetching = False
+            self.last_fetch = time.time()
+
+    def spawn(self):
+        threading.Thread(target=self._fetch, daemon=True).start()
+
+    def init_colors(self):
+        curses.start_color()
+        curses.use_default_colors()
+        curses.init_pair(1, curses.COLOR_RED,    -1)
+        curses.init_pair(2, curses.COLOR_GREEN,  -1)
+        curses.init_pair(3, curses.COLOR_YELLOW, -1)
+        curses.init_pair(4, curses.COLOR_BLUE,   -1)
+        curses.init_pair(5, curses.COLOR_CYAN,   -1)
+
+    def draw(self):
+        h, w = self.scr.getmaxyx()
+        self.scr.erase()
+        ch = h - 3  # content rows (header=2, footer=1)
+
+        nxt = max(0, int(REFRESH - (time.time() - self.last_fetch)))
+        state = "⟳" if self.fetching else f"next in {nxt}s"
+        hdr = f"  GitLab Pipelines  ·  {BRANCH}  ·  {PROJECT}  ·  {state}"
+        c5 = curses.color_pair(5) | curses.A_BOLD
+        try:
+            self.scr.addstr(0, 0, ("═" * w)[:w], c5)
+            self.scr.addstr(1, 0, hdr[:w-1], c5)
+        except curses.error:
+            pass
+
+        if not self.last_fetch:
+            try: self.scr.addstr(3, 2, "Fetching…")
+            except curses.error: pass
+        elif self.error:
+            try: self.scr.addstr(3, 2, f"Error: {self.error}"[:w-3], curses.color_pair(1))
+            except curses.error: pass
+        else:
+            with self._lock:
+                visible = self.rows[self.scroll:self.scroll + ch]
+            for i, (text, cp, bold, dim) in enumerate(visible):
+                attr = curses.color_pair(cp)
+                if bold: attr |= curses.A_BOLD
+                if dim:  attr |= curses.A_DIM
+                try: self.scr.addstr(i + 2, 0, text[:w-1], attr)
+                except curses.error: pass
+
+        total = len(self.rows)
+        end = min(self.scroll + ch, total)
+        foot = f"  ↑↓ jk scroll · PgUp/Dn · r refresh · q quit   {self.scroll+1}–{end}/{total} "
+        try: self.scr.addstr(h-1, 0, foot[:w], curses.A_REVERSE)
+        except curses.error: pass
+
+        self.scr.refresh()
+
+    def run(self):
+        self.init_colors()
+        curses.curs_set(0)
+        self.scr.timeout(250)
+        self.spawn()
+        while True:
+            self.draw()
+            h, _ = self.scr.getmaxyx()
+            ch = h - 3
+            total = len(self.rows)
+            max_scroll = max(0, total - ch)
+            key = self.scr.getch()
+            if key in (ord("q"), ord("Q"), 27):
+                break
+            elif key in (curses.KEY_DOWN,  ord("j")): self.scroll = min(self.scroll + 1, max_scroll)
+            elif key in (curses.KEY_UP,    ord("k")): self.scroll = max(0, self.scroll - 1)
+            elif key == curses.KEY_NPAGE:              self.scroll = min(self.scroll + ch, max_scroll)
+            elif key == curses.KEY_PPAGE:              self.scroll = max(0, self.scroll - ch)
+            elif key == curses.KEY_HOME:               self.scroll = 0
+            elif key == curses.KEY_END:                self.scroll = max_scroll
+            elif key in (ord("r"), ord("R")):
+                if not self.fetching: self.spawn()
+            elif key == curses.KEY_RESIZE:
+                self.scr.clear()
+            if not self.fetching and time.time() - self.last_fetch >= REFRESH:
+                self.spawn()
+
+# ── entry point ───────────────────────────────────────────────────────────────
+
+def main():
+    setup()
+    curses.wrapper(lambda scr: Watcher(scr).run())
+
+if __name__ == "__main__":
+    main()