py-wlcli 0.8.0__py3-none-any.whl

wl_cli/mcp/gitlab.py

@@ -0,0 +1,553 @@
+"""GitLab MCP tools and API v4 client."""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+import socket
+import subprocess
+import sys
+import time
+import urllib.error
+import urllib.parse
+import urllib.request
+from typing import Any, cast
+
+from .protocol import serve as serve_protocol
+
+try:
+    import pwd
+except ImportError:  # pragma: no cover - Windows
+    pwd = None  # type: ignore[assignment]
+
+GITLAB_URL = os.environ.get("GITLAB_URL", "https://gitlab.gewinnrobo.com")
+SERVER_NAME = "gitlab"
+
+
+def _cred_user() -> str:
+    """Return the OS account name used to derive the token.enc passphrase."""
+    if pwd is not None:
+        return pwd.getpwuid(os.getuid()).pw_name
+    try:
+        import ctypes
+
+        windll = getattr(ctypes, "windll", None)
+        if windll is not None:
+            buf = ctypes.create_unicode_buffer(256)
+            size = ctypes.c_ulong(len(buf))
+            if windll.advapi32.GetUserNameW(buf, ctypes.byref(size)):
+                return buf.value
+    except Exception:
+        pass
+    return ""
+
+
+def _get_token() -> str:
+    """Read GITLAB_TOKEN from the environment or decrypt the wlcc token file."""
+    token = os.environ.get("GITLAB_TOKEN", "")
+    if token:
+        return token
+
+    config = os.path.expanduser("~/.config/wlcc/token.enc")
+    if not os.path.exists(config):
+        return ""
+
+    key = f"{socket.gethostname().split('.')[0]}-{_cred_user()}"
+    try:
+        with open(config, "rb") as token_file:
+            ciphertext = token_file.read()
+        result = subprocess.run(
+            ["openssl", "enc", "-d", "-aes-256-cbc", "-pbkdf2", "-pass", f"pass:{key}"],
+            input=ciphertext,
+            capture_output=True,
+            timeout=5,
+        )
+        return result.stdout.decode().strip() if result.returncode == 0 else ""
+    except FileNotFoundError:
+        print(
+            f"Warning: failed to decrypt {config}: openssl is not available",
+            file=sys.stderr,
+        )
+        return ""
+    except Exception as exc:
+        print(f"Warning: failed to decrypt {config}: {exc}", file=sys.stderr)
+        return ""
+
+
+GITLAB_TOKEN = _get_token()
+
+
+def _api(path: str, method: str = "GET", data: dict | None = None) -> Any:
+    """Call GitLab API v4 and return the parsed JSON response."""
+    url = f"{GITLAB_URL}/api/v4/{path.lstrip('/')}"
+    headers = {"PRIVATE-TOKEN": GITLAB_TOKEN, "Content-Type": "application/json"}
+    body = json.dumps(data).encode() if data else None
+    req = urllib.request.Request(url, data=body, headers=headers, method=method)
+    try:
+        resp = urllib.request.urlopen(req, timeout=30)
+        return json.loads(resp.read())
+    except urllib.error.HTTPError as exc:
+        err = exc.read().decode()[:500]
+        raise Exception(f"HTTP {exc.code}: {err}") from exc
+
+
+def _api_raw(path: str) -> str:
+    """Fetch a raw text response, used for repository files and job logs."""
+    url = f"{GITLAB_URL}/api/v4/{path.lstrip('/')}"
+    headers = {"PRIVATE-TOKEN": GITLAB_TOKEN}
+    req = urllib.request.Request(url, headers=headers)
+    try:
+        resp = urllib.request.urlopen(req, timeout=30)
+        return cast("str", resp.read().decode())
+    except urllib.error.HTTPError as exc:
+        err = exc.read().decode()[:500]
+        raise Exception(f"HTTP {exc.code}: {err}") from exc
+
+
+def list_projects(page: int = 1, per_page: int = 20, search: str = "") -> list[dict]:
+    """List GitLab projects, with optional search."""
+    query = f"membership=true&per_page={per_page}&page={page}"
+    if search:
+        query += f"&search={urllib.parse.quote(search)}"
+    return cast("list[dict]", _api(f"projects?{query}"))
+
+
+def get_file(project_id: int, file_path: str, ref: str = "main") -> dict:
+    """Read a file from a repository."""
+    content = _api_raw(
+        f"projects/{project_id}/repository/files/{urllib.parse.quote(file_path, safe='')}/raw?ref={ref}"
+    )
+    return {"path": file_path, "ref": ref, "content": content}
+
+
+def update_file(
+    project_id: int,
+    file_path: str,
+    content: str,
+    commit_message: str,
+    branch: str = "main",
+) -> dict:
+    """Create or update a file in a repository."""
+    result = _api(
+        f"projects/{project_id}/repository/files/{urllib.parse.quote(file_path, safe='')}",
+        "PUT",
+        {"branch": branch, "content": content, "commit_message": commit_message},
+    )
+    return {
+        "status": "updated",
+        "path": result.get("file_path", file_path),
+        "branch": branch,
+    }
+
+
+def list_project_files(project_id: int, path: str = "") -> list[dict]:
+    """List files in a repository directory."""
+    query = "per_page=50&ref=main"
+    if path:
+        query += f"&path={urllib.parse.quote(path)}"
+    files = _api(f"projects/{project_id}/repository/tree?{query}")
+    return [{"name": item["name"], "type": item["type"]} for item in files]
+
+
+def list_merge_requests(project_id: int, state: str = "opened") -> list[dict]:
+    """List merge requests for a project."""
+    merge_requests = _api(
+        f"projects/{project_id}/merge_requests?state={state}&per_page=20"
+    )
+    return [
+        {
+            "iid": merge_request["iid"],
+            "title": merge_request["title"],
+            "state": merge_request["state"],
+            "author": merge_request["author"]["username"],
+        }
+        for merge_request in merge_requests
+    ]
+
+
+def trigger_pipeline(project_id: int, ref: str = "main") -> dict:
+    """Trigger a new CI/CD pipeline."""
+    result = _api(f"projects/{project_id}/pipeline", "POST", {"ref": ref})
+    return {
+        "status": "triggered",
+        "pipeline_id": result["id"],
+        "ref": ref,
+        "web_url": result.get(
+            "web_url", f"{GITLAB_URL}/projects/{project_id}/pipelines/{result['id']}"
+        ),
+    }
+
+
+def list_pipelines(project_id: int, per_page: int = 10, scope: str = "") -> list[dict]:
+    """List recent pipelines for a project."""
+    query = f"per_page={min(per_page, 50)}"
+    if scope:
+        query += f"&scope={scope}"
+    return cast("list[dict]", _api(f"projects/{project_id}/pipelines?{query}"))
+
+
+def get_pipeline(project_id: int, pipeline_id: int | None = None) -> dict:
+    """Get pipeline details, or the latest pipeline when no ID is supplied."""
+    if pipeline_id:
+        return cast("dict", _api(f"projects/{project_id}/pipelines/{pipeline_id}"))
+    pipelines = cast("list[dict]", _api(f"projects/{project_id}/pipelines?per_page=1"))
+    if pipelines:
+        return pipelines[0]
+    return {"status": "no pipelines"}
+
+
+def cancel_pipeline(project_id: int, pipeline_id: int) -> dict:
+    """Cancel a running pipeline."""
+    result = _api(f"projects/{project_id}/pipelines/{pipeline_id}/cancel", "POST")
+    return {"status": "canceled", "pipeline_id": pipeline_id, "ref": result.get("ref")}
+
+
+def retry_job(project_id: int, job_id: int) -> dict:
+    """Retry a failed job."""
+    result = _api(f"projects/{project_id}/jobs/{job_id}/retry", "POST")
+    return {"status": "retried", "job_id": job_id, "new_job_id": result.get("id")}
+
+
+_ERROR_PATTERNS = (
+    "FAILED",
+    "Error",
+    "ERROR",
+    "E   ",
+    "assert",
+    "AssertionError",
+    "Traceback",
+    "exit code",
+    "non-zero",
+    "cannot",
+    "not found",
+    "timeout",
+)
+
+
+def get_job_log(
+    project_id: int, job_id: int, tail: int = 50, error_only: bool = False
+) -> dict:
+    """Get a job trace, optionally filtered to likely error lines."""
+    log = _api_raw(f"projects/{project_id}/jobs/{job_id}/trace")
+    lines = log.split("\n")
+
+    if error_only:
+        pattern = re.compile(
+            r"(?i)(FAILED|Error|ERROR|E |assert|AssertionError|Traceback|except|exit code|non-zero)"
+        )
+        matched = [line for line in lines if pattern.search(line)]
+        lines = matched if matched else lines[-20:]
+
+    if tail and len(lines) > tail:
+        lines = lines[-tail:]
+
+    return {
+        "job_id": job_id,
+        "total_lines": len(log.split("\n")),
+        "returned_lines": len(lines),
+        "log": "\n".join(lines),
+    }
+
+
+def wait_for_pipeline(
+    project_id: int,
+    pipeline_id: int,
+    timeout_min: int = 10,
+) -> dict:
+    """Poll a pipeline with adaptive intervals until it reaches a terminal state."""
+    schedule = [(30, 5), (120, 15), (float("inf"), 30)]
+    deadline = time.time() + timeout_min * 60
+    start = time.time()
+    polls = 0
+
+    while time.time() < deadline:
+        elapsed = time.time() - start
+        interval = next(seconds for maximum, seconds in schedule if elapsed <= maximum)
+        time.sleep(interval)
+        polls += 1
+
+        pipeline = _api(f"projects/{project_id}/pipelines/{pipeline_id}")
+        status = pipeline.get("status", "unknown")
+        elapsed = round(time.time() - start, 1)
+
+        if status not in ("success", "failed", "canceled"):
+            continue
+
+        jobs = _api(f"projects/{project_id}/pipelines/{pipeline_id}/jobs")
+        job_summary = [
+            {
+                "id": job["id"],
+                "name": job["name"],
+                "stage": job["stage"],
+                "status": job["status"],
+                "duration_sec": job.get("duration"),
+            }
+            for job in jobs
+        ]
+
+        result: dict[str, Any] = {
+            "status": status,
+            "pipeline_id": pipeline_id,
+            "duration_sec": elapsed,
+            "polls": polls,
+            "jobs": job_summary,
+            "failed_jobs": [],
+        }
+
+        for job in jobs:
+            if job["status"] != "failed":
+                continue
+            try:
+                raw_log = _api_raw(f"projects/{project_id}/jobs/{job['id']}/trace")
+                lines = raw_log.split("\n")
+                error_lines = [
+                    line
+                    for line in lines
+                    if re.search(r"(?i)" + "|".join(_ERROR_PATTERNS), line)
+                ]
+                if not error_lines:
+                    error_lines = lines[-30:]
+                result["failed_jobs"].append(
+                    {
+                        "name": job["name"],
+                        "stage": job["stage"],
+                        "log_total_lines": len(lines),
+                        "log_errors": "\n".join(error_lines[-50:]),
+                    }
+                )
+            except Exception as exc:
+                result["failed_jobs"].append(
+                    {
+                        "name": job["name"],
+                        "stage": job["stage"],
+                        "log_errors": f"(failed to fetch: {exc})",
+                    }
+                )
+
+        return result
+
+    return {
+        "status": "timeout",
+        "pipeline_id": pipeline_id,
+        "duration_sec": round(time.time() - start, 1),
+        "polls": polls,
+        "jobs": [],
+        "failed_jobs": [],
+    }
+
+
+TOOLS: dict[str, dict] = {
+    "list_projects": {
+        "fn": list_projects,
+        "desc": "List GitLab projects with optional search",
+        "params": {
+            "page": {"type": "int", "required": False, "desc": "page number"},
+            "per_page": {"type": "int", "required": False, "desc": "results per page"},
+            "search": {
+                "type": "str",
+                "required": False,
+                "desc": "search by project name",
+            },
+        },
+    },
+    "get_file": {
+        "fn": get_file,
+        "desc": "Read a file from a repository",
+        "params": {
+            "project_id": {
+                "type": "int",
+                "required": True,
+                "desc": "GitLab project ID",
+            },
+            "file_path": {
+                "type": "str",
+                "required": True,
+                "desc": "path in the repository",
+            },
+            "ref": {"type": "str", "required": False, "desc": "branch/tag name"},
+        },
+    },
+    "update_file": {
+        "fn": update_file,
+        "desc": "Create or update a file in a repository",
+        "params": {
+            "project_id": {
+                "type": "int",
+                "required": True,
+                "desc": "GitLab project ID",
+            },
+            "file_path": {
+                "type": "str",
+                "required": True,
+                "desc": "path in the repository",
+            },
+            "content": {"type": "str", "required": True, "desc": "file content"},
+            "commit_message": {
+                "type": "str",
+                "required": True,
+                "desc": "commit message",
+            },
+            "branch": {"type": "str", "required": False, "desc": "branch name"},
+        },
+    },
+    "list_project_files": {
+        "fn": list_project_files,
+        "desc": "List files in a repository directory",
+        "params": {
+            "project_id": {
+                "type": "int",
+                "required": True,
+                "desc": "GitLab project ID",
+            },
+            "path": {"type": "str", "required": False, "desc": "directory path"},
+        },
+    },
+    "list_merge_requests": {
+        "fn": list_merge_requests,
+        "desc": "List merge requests for a project",
+        "params": {
+            "project_id": {
+                "type": "int",
+                "required": True,
+                "desc": "GitLab project ID",
+            },
+            "state": {
+                "type": "str",
+                "required": False,
+                "desc": "opened / merged / closed / all",
+            },
+        },
+    },
+    "trigger_pipeline": {
+        "fn": trigger_pipeline,
+        "desc": "Trigger a new CI/CD pipeline on a branch",
+        "params": {
+            "project_id": {
+                "type": "int",
+                "required": True,
+                "desc": "GitLab project ID",
+            },
+            "ref": {"type": "str", "required": False, "desc": "branch/tag name"},
+        },
+    },
+    "get_pipeline": {
+        "fn": get_pipeline,
+        "desc": "Get pipeline status details (omitting pipeline_id returns latest)",
+        "params": {
+            "project_id": {
+                "type": "int",
+                "required": True,
+                "desc": "GitLab project ID",
+            },
+            "pipeline_id": {
+                "type": "int",
+                "required": False,
+                "desc": "pipeline ID (omit to get the latest)",
+            },
+        },
+    },
+    "list_pipelines": {
+        "fn": list_pipelines,
+        "desc": "List recent pipelines for a project",
+        "params": {
+            "project_id": {
+                "type": "int",
+                "required": True,
+                "desc": "GitLab project ID",
+            },
+            "per_page": {
+                "type": "int",
+                "required": False,
+                "desc": "results per page (max 50)",
+            },
+            "scope": {
+                "type": "str",
+                "required": False,
+                "desc": "filter: running/pending/finished/branches/tags",
+            },
+        },
+    },
+    "cancel_pipeline": {
+        "fn": cancel_pipeline,
+        "desc": "Cancel a running pipeline",
+        "params": {
+            "project_id": {
+                "type": "int",
+                "required": True,
+                "desc": "GitLab project ID",
+            },
+            "pipeline_id": {
+                "type": "int",
+                "required": True,
+                "desc": "pipeline ID to cancel",
+            },
+        },
+    },
+    "retry_job": {
+        "fn": retry_job,
+        "desc": "Retry a single failed job",
+        "params": {
+            "project_id": {
+                "type": "int",
+                "required": True,
+                "desc": "GitLab project ID",
+            },
+            "job_id": {"type": "int", "required": True, "desc": "job ID to retry"},
+        },
+    },
+    "get_job_log": {
+        "fn": get_job_log,
+        "desc": "Get job trace/log, smart-truncated to relevant errors",
+        "params": {
+            "project_id": {
+                "type": "int",
+                "required": True,
+                "desc": "GitLab project ID",
+            },
+            "job_id": {"type": "int", "required": True, "desc": "job ID"},
+            "tail": {
+                "type": "int",
+                "required": False,
+                "desc": "last N lines (0 = full log)",
+            },
+            "error_only": {
+                "type": "bool",
+                "required": False,
+                "desc": "only return lines matching error patterns",
+            },
+        },
+    },
+    "wait_for_pipeline": {
+        "fn": wait_for_pipeline,
+        "desc": "Poll pipeline with adaptive intervals until done. Returns structured result with job details and auto-fetched failure logs.",
+        "params": {
+            "project_id": {
+                "type": "int",
+                "required": True,
+                "desc": "GitLab project ID",
+            },
+            "pipeline_id": {
+                "type": "int",
+                "required": True,
+                "desc": "pipeline ID to poll",
+            },
+            "timeout_min": {
+                "type": "int",
+                "required": False,
+                "desc": "max wait time in minutes",
+            },
+        },
+    },
+}
+
+
+def serve() -> None:
+    """Validate credentials, then run the GitLab MCP stdio server."""
+    if not GITLAB_TOKEN:
+        print(
+            "ERROR: GITLAB_TOKEN not available (set env var or configure ~/.config/wlcc/token.enc)",
+            file=sys.stderr,
+        )
+        raise SystemExit(1)
+    serve_protocol(TOOLS, SERVER_NAME)