PyPI - jiradc-cli - Versions diffs - 0.1.0__py3-none-any.whl - Mend

jiradc-cli 0.1.0__py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (10) hide show

jiradc_cli/__init__.py +5 -0
jiradc_cli/__main__.py +5 -0
jiradc_cli/client.py +109 -0
jiradc_cli/config.py +138 -0
jiradc_cli/main.py +509 -0
jiradc_cli-0.1.0.dist-info/METADATA +107 -0
jiradc_cli-0.1.0.dist-info/RECORD +10 -0
jiradc_cli-0.1.0.dist-info/WHEEL +5 -0
jiradc_cli-0.1.0.dist-info/entry_points.txt +2 -0
jiradc_cli-0.1.0.dist-info/top_level.txt +1 -0

jiradc_cli/__init__.py ADDED Viewed

@@ -0,0 +1,5 @@
+"""Jira Data Center CLI package."""
+__all__ = ["__version__"]
+__version__ = "0.1.0"

jiradc_cli/__main__.py ADDED Viewed

@@ -0,0 +1,5 @@
+from .main import main
+if __name__ == "__main__":
+    main()

jiradc_cli/client.py ADDED Viewed

@@ -0,0 +1,109 @@
+from __future__ import annotations
+import re
+from dataclasses import dataclass
+from typing import Any
+import requests
+from .config import JiraConfig
+@dataclass(slots=True)
+class JiraApiError(RuntimeError):
+    status_code: int
+    message: str
+    def __str__(self) -> str:
+        return f"HTTP {self.status_code}: {self.message}"
+@dataclass(slots=True)
+class JiraTransportError(RuntimeError):
+    message: str
+    def __str__(self) -> str:
+        return self.message
+class JiraClient:
+    def __init__(self, config: JiraConfig, timeout_seconds: int = 30) -> None:
+        self.base_url = config.base_url.rstrip("/")
+        self.timeout_seconds = timeout_seconds
+        self.session = requests.Session()
+        self.session.headers.update(
+            {
+                "Accept": "application/json",
+                "Cookie": config.cookie,
+                "X-Requested-With": "XMLHttpRequest",
+                "User-Agent": (
+                    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) "
+                    "AppleWebKit/537.36 (KHTML, like Gecko) "
+                    "Chrome/124.0.0.0 Safari/537.36"
+                ),
+            }
+        )
+    def request(
+        self,
+        method: str,
+        path: str,
+        *,
+        params: dict[str, Any] | None = None,
+        json_body: dict[str, Any] | list[Any] | None = None,
+    ) -> Any:
+        url = f"{self.base_url}/rest{path}"
+        try:
+            response = self.session.request(
+                method=method.upper(),
+                url=url,
+                params=params,
+                json=json_body,
+                timeout=self.timeout_seconds,
+            )
+        except requests.RequestException as exc:
+            raise JiraTransportError(str(exc)) from exc
+        if response.status_code >= 400:
+            raise JiraApiError(response.status_code, _error_message(response))
+        if response.status_code == 204 or not response.text.strip():
+            return None
+        try:
+            return response.json()
+        except ValueError:
+            return response.text
+def _error_message(response: requests.Response) -> str:
+    try:
+        payload = response.json()
+    except ValueError:
+        text = response.text.strip()
+        if _looks_like_html(text):
+            return _summarize_html_error(text, response.status_code)
+        return text or response.reason
+    if isinstance(payload, dict):
+        errors = []
+        if isinstance(payload.get("errorMessages"), list):
+            errors.extend(str(item) for item in payload["errorMessages"])
+        if isinstance(payload.get("errors"), dict):
+            errors.extend(f"{key}: {value}" for key, value in payload["errors"].items())
+        if errors:
+            return "; ".join(errors)
+    return str(payload)
+def _looks_like_html(text: str) -> bool:
+    lowered = text.lstrip().lower()
+    return lowered.startswith("<!doctype html") or lowered.startswith("<html")
+def _summarize_html_error(text: str, status_code: int) -> str:
+    referral_match = re.search(r"log-referral-id\">([^<]+)<", text, re.IGNORECASE)
+    referral = referral_match.group(1).strip() if referral_match else None
+    title_match = re.search(r"<title>([^<]+)</title>", text, re.IGNORECASE)
+    title = title_match.group(1).strip() if title_match else "HTML error page"
+    if referral:
+        return f"{title} (HTTP {status_code}, referral id: {referral})"
+    return f"{title} (HTTP {status_code})"

jiradc_cli/config.py ADDED Viewed

@@ -0,0 +1,138 @@
+from __future__ import annotations
+import json
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Iterable
+DEFAULT_CONFIG_PATH = Path.home() / ".config" / "jiradc-cli" / "config.json"
+class ConfigError(RuntimeError):
+    """Raised when the local CLI configuration is missing or invalid."""
+@dataclass(slots=True)
+class JiraConfig:
+    base_url: str
+    cookie: str
+def normalize_base_url(base_url: str) -> str:
+    value = base_url.strip().rstrip("/")
+    if not value.startswith("http://") and not value.startswith("https://"):
+        raise ConfigError("Base URL must start with http:// or https://")
+    return value
+def normalize_cookie(cookie: str) -> str:
+    value = cookie.strip()
+    if value.lower().startswith("cookie:"):
+        value = value.split(":", 1)[1].strip()
+    if not value:
+        raise ConfigError("Cookie value cannot be empty.")
+    if "=" not in value:
+        value = f"JSESSIONID={value}"
+    return value
+def parse_cookie_pairs(cookie: str) -> dict[str, str]:
+    pairs: dict[str, str] = {}
+    normalized = normalize_cookie(cookie)
+    for part in normalized.split(";"):
+        chunk = part.strip()
+        if not chunk or "=" not in chunk:
+            continue
+        key, value = chunk.split("=", 1)
+        key = key.strip()
+        value = value.strip()
+        if key:
+            pairs[key] = value
+    return pairs
+def format_cookie_header(cookies: dict[str, str]) -> str:
+    return "; ".join(f"{key}={value}" for key, value in cookies.items())
+def pick_session_cookies(cookie: str) -> str:
+    """Keep cookies most likely required for Jira session/auth routing."""
+    all_pairs = parse_cookie_pairs(cookie)
+    if not all_pairs:
+        raise ConfigError("Cookie value does not contain valid key=value pairs.")
+    preferred_names: list[str] = [
+        "JSESSIONID",
+        "atlassian.xsrf.token",
+        "seraph.rememberme.cookie",
+        "AWSALB",
+        "AWSALBCORS",
+        "ROUTEID",
+        "GCP_IAP_UID",
+        "BIGipServer",
+    ]
+    selected: dict[str, str] = {}
+    for name in preferred_names:
+        if name in all_pairs:
+            selected[name] = all_pairs[name]
+    for name, value in all_pairs.items():
+        lowered = name.lower()
+        if lowered.startswith("atlassian.") or lowered.startswith("seraph."):
+            selected.setdefault(name, value)
+        if "oauth" in lowered and "proxy" in lowered:
+            selected.setdefault(name, value)
+    if "JSESSIONID" not in selected and "JSESSIONID" in all_pairs:
+        selected["JSESSIONID"] = all_pairs["JSESSIONID"]
+    if selected:
+        return format_cookie_header(selected)
+    return normalize_cookie(cookie)
+def cookie_variants_for_auth(cookie: str) -> Iterable[str]:
+    normalized = normalize_cookie(cookie)
+    minimized = pick_session_cookies(normalized)
+    if minimized != normalized:
+        return [minimized, normalized]
+    return [normalized]
+def save_config(config: JiraConfig, path: Path = DEFAULT_CONFIG_PATH) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    try:
+        path.parent.chmod(0o700)
+    except OSError:
+        pass
+    payload = {"base_url": normalize_base_url(config.base_url), "cookie": normalize_cookie(config.cookie)}
+    path.write_text(json.dumps(payload, indent=2), encoding="utf-8")
+    try:
+        path.chmod(0o600)
+    except OSError:
+        pass
+def load_config(path: Path = DEFAULT_CONFIG_PATH) -> JiraConfig:
+    if not path.exists():
+        raise ConfigError(f"Config file not found at {path}")
+    try:
+        data = json.loads(path.read_text(encoding="utf-8"))
+    except json.JSONDecodeError as exc:
+        raise ConfigError(f"Config file is not valid JSON: {path}") from exc
+    base_url = data.get("base_url")
+    cookie = data.get("cookie")
+    if not isinstance(base_url, str) or not isinstance(cookie, str):
+        raise ConfigError("Config file must contain string values for 'base_url' and 'cookie'.")
+    return JiraConfig(base_url=normalize_base_url(base_url), cookie=normalize_cookie(cookie))
+def clear_config(path: Path = DEFAULT_CONFIG_PATH) -> bool:
+    if not path.exists():
+        return False
+    path.unlink()
+    return True

jiradc_cli/main.py ADDED Viewed

@@ -0,0 +1,509 @@
+from __future__ import annotations
+import json
+import shutil
+import subprocess
+import sys
+from typing import Any, Callable
+import typer
+from .client import JiraApiError, JiraClient, JiraTransportError
+from .config import (
+    ConfigError,
+    JiraConfig,
+    clear_config,
+    cookie_variants_for_auth,
+    load_config,
+    normalize_base_url,
+    normalize_cookie,
+    save_config,
+)
+app = typer.Typer(help="CLI for Jira Data Center using browser session cookies.")
+project_app = typer.Typer(help="Project-related operations.")
+issue_app = typer.Typer(help="Issue-related operations.")
+app.add_typer(project_app, name="project")
+app.add_typer(issue_app, name="issue")
+def _echo_json(payload: Any) -> None:
+    typer.echo(json.dumps(payload, indent=2, ensure_ascii=False))
+def _require_client() -> JiraClient:
+    try:
+        config = load_config()
+    except ConfigError as exc:
+        raise typer.Exit(code=_fail(f"{exc}. Run 'jiradc login' first."))
+    return JiraClient(config)
+def _fail(message: str) -> int:
+    typer.secho(message, fg=typer.colors.RED, err=True)
+    return 1
+def _require_success(label: str, action: Callable[[], Any]) -> Any:
+    try:
+        return action()
+    except (ConfigError, JiraApiError, JiraTransportError) as exc:
+        raise typer.Exit(code=_fail(f"{label} failed: {exc}"))
+def _read_clipboard() -> str:
+    candidates: list[list[str]] = []
+    if sys.platform == "darwin" and shutil.which("pbpaste"):
+        candidates.append(["pbpaste"])
+    elif sys.platform.startswith("win"):
+        candidates.append(["powershell", "-NoProfile", "-Command", "Get-Clipboard"])
+    else:
+        if shutil.which("wl-paste"):
+            candidates.append(["wl-paste", "--no-newline"])
+        if shutil.which("xclip"):
+            candidates.append(["xclip", "-selection", "clipboard", "-o"])
+        if shutil.which("xsel"):
+            candidates.append(["xsel", "--clipboard", "--output"])
+    last_error = "No clipboard utility found."
+    for cmd in candidates:
+        try:
+            result = subprocess.run(cmd, capture_output=True, text=True, check=True)
+            value = result.stdout.strip()
+            if value:
+                return value
+            last_error = "Clipboard is empty."
+        except Exception as exc:  # pragma: no cover
+            last_error = str(exc)
+    raise ConfigError(f"Unable to read cookie from clipboard. {last_error}")
+def _looks_like_url(value: str) -> bool:
+    lowered = value.strip().lower()
+    return lowered.startswith("http://") or lowered.startswith("https://")
+def _extract_username(payload: Any) -> str | None:
+    if not isinstance(payload, dict):
+        return None
+    name = payload.get("name")
+    if isinstance(name, str) and name:
+        return name
+    display_name = payload.get("displayName")
+    if isinstance(display_name, str) and display_name:
+        return display_name
+    session = payload.get("session")
+    if isinstance(session, dict):
+        session_name = session.get("name")
+        if isinstance(session_name, str) and session_name:
+            return session_name
+    return None
+def _verify_cookie_session(config: JiraConfig) -> tuple[JiraConfig, str]:
+    errors: list[str] = []
+    endpoints = ["/api/2/myself", "/auth/1/session"]
+    for candidate_cookie in cookie_variants_for_auth(config.cookie):
+        candidate = JiraConfig(base_url=config.base_url, cookie=candidate_cookie)
+        client = JiraClient(candidate)
+        for endpoint in endpoints:
+            try:
+                payload = client.request("GET", endpoint)
+            except (JiraApiError, JiraTransportError) as exc:
+                errors.append(f"{endpoint}: {exc}")
+                continue
+            username = _extract_username(payload)
+            return JiraConfig(base_url=config.base_url, cookie=candidate_cookie), (username or "unknown")
+    joined_errors = " | ".join(errors)
+    raise ConfigError(
+        "Cookie verification failed on Jira endpoints. "
+        "Try copying only Jira session cookies (JSESSIONID, atlassian.xsrf.token, AWSALB/AWSALBCORS). "
+        f"Details: {joined_errors}"
+    )
+@app.command()
+def login(
+    base_url: str = typer.Option(
+        ...,
+        "--base-url",
+        prompt="Jira base URL (example: https://jira.example.com)",
+        help="Base URL for your Jira Data Center instance.",
+    ),
+    cookie: str | None = typer.Option(
+        None,
+        "--cookie",
+        help="Cookie header value copied from an already logged-in browser session (overrides clipboard).",
+    ),
+    cookie_from_clipboard: bool = typer.Option(
+        True,
+        "--cookie-from-clipboard/--no-cookie-from-clipboard",
+        help="Read cookie from your system clipboard when --cookie is not provided.",
+    ),
+    skip_verify: bool = typer.Option(
+        False,
+        "--skip-verify",
+        help="Save the configuration without calling Jira to verify the cookie.",
+    ),
+) -> None:
+    """Save Jira URL + browser cookie and verify auth session."""
+    if cookie is None:
+        if not cookie_from_clipboard:
+            raise typer.Exit(
+                code=_fail("No cookie provided. Use --cookie or enable --cookie-from-clipboard.")
+            )
+        typer.echo("Copy your logged-in Jira Cookie header value to clipboard.")
+        typer.prompt("Press Enter to read clipboard", default="", show_default=False)
+        attempts = 3
+        for idx in range(attempts):
+            try:
+                candidate = _read_clipboard()
+            except ConfigError as exc:
+                raise typer.Exit(code=_fail(str(exc)))
+            if _looks_like_url(candidate):
+                if idx == attempts - 1:
+                    raise typer.Exit(
+                        code=_fail(
+                            "Clipboard content looks like a URL, not a Cookie header value. "
+                            "Copy the cookie from browser devtools and try again."
+                        )
+                    )
+                typer.secho(
+                    "Clipboard currently looks like a URL. Copy the Cookie header value, then press Enter to retry.",
+                    fg=typer.colors.YELLOW,
+                    err=True,
+                )
+                typer.prompt("Retry", default="", show_default=False)
+                continue
+            cookie = candidate
+            break
+        else:
+            raise typer.Exit(code=_fail("Unable to read a valid cookie value from clipboard."))
+    try:
+        config = JiraConfig(base_url=normalize_base_url(base_url), cookie=normalize_cookie(cookie))
+    except ConfigError as exc:
+        raise typer.Exit(code=_fail(str(exc)))
+    if not skip_verify:
+        try:
+            verified, user = _verify_cookie_session(config)
+        except ConfigError as exc:
+            raise typer.Exit(code=_fail(str(exc)))
+        if verified.cookie != config.cookie:
+            typer.secho(
+                "Using minimized Jira-focused cookie set for CLI requests.",
+                fg=typer.colors.YELLOW,
+            )
+        config = verified
+        typer.secho(f"Verified session for user: {user}", fg=typer.colors.GREEN)
+    save_config(config)
+    typer.secho("Saved configuration to ~/.config/jiradc-cli/config.json", fg=typer.colors.GREEN)
+@app.command()
+def logout() -> None:
+    """Delete locally stored Jira URL + cookie."""
+    removed = clear_config()
+    if removed:
+        typer.secho("Removed local Jira CLI config.", fg=typer.colors.GREEN)
+    else:
+        typer.echo("No local config found.")
+@app.command("whoami")
+def whoami(raw: bool = typer.Option(False, "--raw", help="Print full JSON response.")) -> None:
+    """Show the currently authenticated Jira user."""
+    def run() -> Any:
+        return _require_client().request("GET", "/api/2/myself")
+    payload = _require_success("whoami", run)
+    if raw:
+        _echo_json(payload)
+        return
+    if not isinstance(payload, dict):
+        typer.echo(str(payload))
+        return
+    typer.echo(f"Name: {payload.get('displayName') or payload.get('name')}")
+    typer.echo(f"Username: {payload.get('name')}")
+    typer.echo(f"Email: {payload.get('emailAddress')}")
+    typer.echo(f"Active: {payload.get('active')}")
+@project_app.command("list")
+def project_list(raw: bool = typer.Option(False, "--raw", help="Print full JSON response.")) -> None:
+    """List visible projects."""
+    def run() -> Any:
+        return _require_client().request("GET", "/api/2/project")
+    payload = _require_success("project list", run)
+    if raw:
+        _echo_json(payload)
+        return
+    if not isinstance(payload, list):
+        typer.echo(str(payload))
+        return
+    for project in payload:
+        if not isinstance(project, dict):
+            continue
+        key = project.get("key")
+        name = project.get("name")
+        project_type = project.get("projectTypeKey")
+        typer.echo(f"{str(key):10} {name} [{project_type}]")
+@issue_app.command("get")
+def issue_get(
+    issue_key: str = typer.Argument(..., help="Issue key (example: PROJ-123)."),
+    expand: str | None = typer.Option(None, "--expand", help="Optional fields to expand."),
+    raw: bool = typer.Option(False, "--raw", help="Print full JSON response."),
+) -> None:
+    """Get issue details by key."""
+    def run() -> Any:
+        params = {"expand": expand} if expand else None
+        return _require_client().request("GET", f"/api/2/issue/{issue_key}", params=params)
+    payload = _require_success("issue get", run)
+    if raw:
+        _echo_json(payload)
+        return
+    if not isinstance(payload, dict):
+        typer.echo(str(payload))
+        return
+    fields = payload.get("fields", {}) if isinstance(payload.get("fields"), dict) else {}
+    status_name = None
+    status = fields.get("status")
+    if isinstance(status, dict):
+        status_name = status.get("name")
+    summary = fields.get("summary")
+    assignee = fields.get("assignee")
+    assignee_name = assignee.get("displayName") if isinstance(assignee, dict) else None
+    typer.echo(f"Key: {payload.get('key')}")
+    typer.echo(f"Summary: {summary}")
+    typer.echo(f"Status: {status_name}")
+    typer.echo(f"Assignee: {assignee_name}")
+@issue_app.command("search")
+def issue_search(
+    jql: str = typer.Option(..., "--jql", help="JQL query."),
+    max_results: int = typer.Option(20, "--max-results", min=1, max=200),
+    start_at: int = typer.Option(0, "--start-at", min=0),
+    fields: str = typer.Option("summary,status,assignee", "--fields", help="Comma-separated Jira fields."),
+    raw: bool = typer.Option(False, "--raw", help="Print full JSON response."),
+) -> None:
+    """Search issues with JQL."""
+    def run() -> Any:
+        params = {
+            "jql": jql,
+            "maxResults": max_results,
+            "startAt": start_at,
+            "fields": fields,
+        }
+        return _require_client().request("GET", "/api/2/search", params=params)
+    payload = _require_success("issue search", run)
+    if raw:
+        _echo_json(payload)
+        return
+    if not isinstance(payload, dict):
+        typer.echo(str(payload))
+        return
+    issues = payload.get("issues")
+    if not isinstance(issues, list):
+        _echo_json(payload)
+        return
+    for issue in issues:
+        if not isinstance(issue, dict):
+            continue
+        issue_key = issue.get("key")
+        issue_fields = issue.get("fields", {})
+        if not isinstance(issue_fields, dict):
+            issue_fields = {}
+        summary = issue_fields.get("summary")
+        status_name = None
+        status = issue_fields.get("status")
+        if isinstance(status, dict):
+            status_name = status.get("name")
+        assignee_name = None
+        assignee = issue_fields.get("assignee")
+        if isinstance(assignee, dict):
+            assignee_name = assignee.get("displayName") or assignee.get("name")
+        typer.echo(f"{str(issue_key):12} {status_name or '-':14} {assignee_name or '-':20} {summary}")
+@issue_app.command("create")
+def issue_create(
+    project: str = typer.Option(..., "--project", help="Project key, e.g. PROJ."),
+    summary: str = typer.Option(..., "--summary", help="Issue summary."),
+    issue_type: str = typer.Option("Task", "--issue-type", help="Jira issue type name."),
+    description: str | None = typer.Option(None, "--description", help="Issue description."),
+    assignee: str | None = typer.Option(None, "--assignee", help="Username to assign at creation."),
+    raw: bool = typer.Option(False, "--raw", help="Print full JSON response."),
+) -> None:
+    """Create an issue."""
+    def run() -> Any:
+        fields: dict[str, Any] = {
+            "project": {"key": project},
+            "summary": summary,
+            "issuetype": {"name": issue_type},
+        }
+        if description:
+            fields["description"] = description
+        if assignee:
+            fields["assignee"] = {"name": assignee}
+        return _require_client().request("POST", "/api/2/issue", json_body={"fields": fields})
+    payload = _require_success("issue create", run)
+    if raw:
+        _echo_json(payload)
+        return
+    if isinstance(payload, dict):
+        typer.echo(f"Created issue: {payload.get('key')} (id={payload.get('id')})")
+    else:
+        typer.echo(str(payload))
+@issue_app.command("comments")
+def issue_comments(
+    issue_key: str = typer.Argument(..., help="Issue key (example: PROJ-123)."),
+    raw: bool = typer.Option(False, "--raw", help="Print full JSON response."),
+) -> None:
+    """List comments for an issue."""
+    def run() -> Any:
+        return _require_client().request("GET", f"/api/2/issue/{issue_key}/comment")
+    payload = _require_success("issue comments", run)
+    if raw:
+        _echo_json(payload)
+        return
+    if not isinstance(payload, dict):
+        typer.echo(str(payload))
+        return
+    comments = payload.get("comments")
+    if not isinstance(comments, list):
+        _echo_json(payload)
+        return
+    for comment in comments:
+        if not isinstance(comment, dict):
+            continue
+        author = comment.get("author") if isinstance(comment.get("author"), dict) else {}
+        created = comment.get("created")
+        body = str(comment.get("body", "")).replace("\n", " ")
+        trimmed_body = body[:180] + ("..." if len(body) > 180 else "")
+        typer.echo(f"[{comment.get('id')}] {author.get('displayName') or author.get('name')} @ {created}")
+        typer.echo(f"  {trimmed_body}")
+@issue_app.command("comment-add")
+def issue_comment_add(
+    issue_key: str = typer.Argument(..., help="Issue key (example: PROJ-123)."),
+    body: str = typer.Option(..., "--body", prompt=True, help="Comment body."),
+    raw: bool = typer.Option(False, "--raw", help="Print full JSON response."),
+) -> None:
+    """Add a comment to an issue."""
+    def run() -> Any:
+        return _require_client().request(
+            "POST",
+            f"/api/2/issue/{issue_key}/comment",
+            json_body={"body": body},
+        )
+    payload = _require_success("issue comment-add", run)
+    if raw:
+        _echo_json(payload)
+        return
+    if isinstance(payload, dict):
+        typer.echo(f"Added comment {payload.get('id')} to {issue_key}")
+    else:
+        typer.echo(str(payload))
+@issue_app.command("transitions")
+def issue_transitions(
+    issue_key: str = typer.Argument(..., help="Issue key (example: PROJ-123)."),
+    raw: bool = typer.Option(False, "--raw", help="Print full JSON response."),
+) -> None:
+    """List available transitions for an issue."""
+    def run() -> Any:
+        return _require_client().request("GET", f"/api/2/issue/{issue_key}/transitions")
+    payload = _require_success("issue transitions", run)
+    if raw:
+        _echo_json(payload)
+        return
+    if not isinstance(payload, dict):
+        typer.echo(str(payload))
+        return
+    transitions = payload.get("transitions")
+    if not isinstance(transitions, list):
+        _echo_json(payload)
+        return
+    for transition in transitions:
+        if not isinstance(transition, dict):
+            continue
+        to_state = transition.get("to") if isinstance(transition.get("to"), dict) else {}
+        typer.echo(f"{transition.get('id'):>4}  {transition.get('name')} -> {to_state.get('name')}")
+@issue_app.command("transition")
+def issue_transition(
+    issue_key: str = typer.Argument(..., help="Issue key (example: PROJ-123)."),
+    transition_id: str = typer.Option(..., "--id", help="Transition id from 'issue transitions'."),
+    comment: str | None = typer.Option(None, "--comment", help="Optional transition comment."),
+) -> None:
+    """Perform a transition on an issue."""
+    def run() -> Any:
+        payload: dict[str, Any] = {"transition": {"id": transition_id}}
+        if comment:
+            payload["update"] = {"comment": [{"add": {"body": comment}}]}
+        return _require_client().request(
+            "POST",
+            f"/api/2/issue/{issue_key}/transitions",
+            json_body=payload,
+        )
+    _require_success("issue transition", run)
+    typer.secho(f"Transitioned {issue_key} via id {transition_id}", fg=typer.colors.GREEN)
+@issue_app.command("assign")
+def issue_assign(
+    issue_key: str = typer.Argument(..., help="Issue key (example: PROJ-123)."),
+    username: str = typer.Option(..., "--username", prompt=True, help="Jira username."),
+) -> None:
+    """Assign an issue to a user."""
+    def run() -> Any:
+        return _require_client().request(
+            "PUT",
+            f"/api/2/issue/{issue_key}/assignee",
+            json_body={"name": username},
+        )
+    _require_success("issue assign", run)
+    typer.secho(f"Assigned {issue_key} to {username}", fg=typer.colors.GREEN)
+def main() -> None:
+    app()
+if __name__ == "__main__":
+    main()

jiradc_cli-0.1.0.dist-info/METADATA ADDED Viewed

@@ -0,0 +1,107 @@
+Metadata-Version: 2.4
+Name: jiradc-cli
+Version: 0.1.0
+Summary: Typer CLI for Jira Data Center using browser session cookies.
+Project-URL: Homepage, https://github.com/marcosgalleterobbva/jiradc-cli
+Project-URL: Repository, https://github.com/marcosgalleterobbva/jiradc-cli
+Project-URL: Issues, https://github.com/marcosgalleterobbva/jiradc-cli/issues
+Keywords: jira,jira-data-center,cli,typer,sso,cookie-auth
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Utilities
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.31.0
+Requires-Dist: typer>=0.12.0
+Provides-Extra: release
+Requires-Dist: build>=1.2.2; extra == "release"
+Requires-Dist: twine>=5.1.1; extra == "release"
+# jiradc-cli
+Typer CLI for Jira Data Center that authenticates with a browser session cookie (no PAT required).
+Agent-oriented project docs:
+- `AGENTS.md`
+- `docs/PROJECT_OVERVIEW.md`
+- `docs/COMMAND_REFERENCE.md`
+- `docs/DEVELOPMENT_NOTES.md`
+- `docs/PUBLISHING.md`
+The endpoint set was selected from the OpenAPI/Postman files in `resources/` for common end-user workflows:
+- Authentication/session validation (`/rest/auth/1/session`)
+- User identity (`/rest/api/2/myself`)
+- Project discovery (`/rest/api/2/project`)
+- Issue search/read/create (`/rest/api/2/search`, `/rest/api/2/issue`, `/rest/api/2/issue/{issueIdOrKey}`)
+- Comments (`/rest/api/2/issue/{issueIdOrKey}/comment`)
+- Workflow transitions (`/rest/api/2/issue/{issueIdOrKey}/transitions`)
+- Assignment (`/rest/api/2/issue/{issueIdOrKey}/assignee`)
+## Install
+```bash
+pip install -e .
+```
+## Login with Browser Cookie
+Export the cookie from an already logged-in Jira browser session, then run:
+```bash
+jiradc login --base-url https://jira.example.com
+```
+The command then pauses and asks you to copy your Jira `Cookie` header value to clipboard, reads it from clipboard, and validates it against `/rest/auth/1/session`.
+On macOS this uses `pbpaste`.
+During login, the CLI automatically reduces large browser cookie sets to Jira-relevant session cookies first (for better compatibility with SSO/WAF setups), and falls back to the full cookie if needed.
+You can also pass it directly:
+```bash
+jiradc login --base-url https://jira.example.com --cookie "JSESSIONID=...; atlassian.xsrf.token=..."
+```
+Config is saved in:
+- `~/.config/jiradc-cli/config.json`
+## Commands
+```bash
+jiradc whoami
+jiradc project list
+jiradc issue search --jql "assignee = currentUser() AND statusCategory != Done"
+jiradc issue get PROJ-123
+jiradc issue create --project PROJ --summary "New task" --issue-type Task --description "Created from CLI"
+jiradc issue comments PROJ-123
+jiradc issue comment-add PROJ-123 --body "Working on this now."
+jiradc issue transitions PROJ-123
+jiradc issue transition PROJ-123 --id 31 --comment "Moving to In Progress"
+jiradc issue assign PROJ-123 --username alice
+jiradc logout
+```
+## Build and publish
+Project metadata includes GitHub links in `pyproject.toml`:
+- Homepage: `https://github.com/marcosgalleterobbva/jiradc-cli`
+- Repository: `https://github.com/marcosgalleterobbva/jiradc-cli`
+- Issues: `https://github.com/marcosgalleterobbva/jiradc-cli/issues`
+Release tooling:
+```bash
+pip install -e ".[release]"
+make build
+make check
+make publish-testpypi
+make publish-pypi
+```
+See `docs/PUBLISHING.md` for the full release workflow.

jiradc_cli-0.1.0.dist-info/RECORD ADDED Viewed

@@ -0,0 +1,10 @@
+jiradc_cli/__init__.py,sha256=jQ3Fq5w73t1Ie9VVrQwy--OnDi8Si1vu0EUH0tsder0,86
+jiradc_cli/__main__.py,sha256=qs6kN4rXgXytzVlo9nDeC8tm5daCP8xPL2lhUABzuiM,63
+jiradc_cli/client.py,sha256=RXfjOgo-Kl6YOzWUjTHuEXLmynlcWuPL6lGv6dGfiME,3472
+jiradc_cli/config.py,sha256=_RbjTgpN_Tvtj3qTSdGw9GIIxIR-u45UbGJQgr-TJHo,4214
+jiradc_cli/main.py,sha256=VNWdmc0GQimPujEoM4HrMx0TL5fvhTKsSFNxHZu6oek,17831
+jiradc_cli-0.1.0.dist-info/METADATA,sha256=oOS6M9-U6XmVjZLfg1QVdVsoSyWq4zcO0Op2KA-ePRY,3765
+jiradc_cli-0.1.0.dist-info/WHEEL,sha256=YCfwYGOYMi5Jhw2fU4yNgwErybb2IX5PEwBKV4ZbdBo,91
+jiradc_cli-0.1.0.dist-info/entry_points.txt,sha256=Q9VqQLYx-5YzbJVZl4I-_YYF42lOHnQAjQoi_vw8ciQ,48
+jiradc_cli-0.1.0.dist-info/top_level.txt,sha256=WWx2523PAWocZpNk1ZxJJRlcYxcup-99yrOJisE_UqI,11
+jiradc_cli-0.1.0.dist-info/RECORD,,

jiradc_cli-0.1.0.dist-info/WHEEL ADDED Viewed

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any

jiradc_cli-0.1.0.dist-info/entry_points.txt ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ [console_scripts]
2	+ jiradc = jiradc_cli.main:main

jiradc_cli-0.1.0.dist-info/top_level.txt ADDED Viewed

	@@ -0,0 +1 @@
1	+ jiradc_cli