git-juggler 0.2.2__tar.gz → 0.2.3__tar.gz

{git_juggler-0.2.2 → git_juggler-0.2.3}/.gitignore

@@ -27,3 +27,5 @@ secrets.env
 
 # Personal task notes (see CLAUDE.md)
 todo.txt
+
+plans/

{git_juggler-0.2.2 → git_juggler-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: git-juggler
-Version: 0.2.2
+Version: 0.2.3
 Summary: A local Git dashboard for people juggling agents and too many repos.
 License-Expression: MIT
 License-File: LICENSE
@@ -11,7 +11,7 @@ Requires-Dist: pywinpty>=2.0; sys_platform == 'win32'
 Requires-Dist: uvicorn[standard]>=0.29
 Description-Content-Type: text/markdown
 
-# git-juggler
+<img src="https://github.com/franz38/git-juggler/blob/main/src/frontend/public/logo.png?raw=true" alt="git-juggler" width="400">
 
 A local Git dashboard for people juggling agents and too many repos.
 

{git_juggler-0.2.2 → git_juggler-0.2.3}/README.md

@@ -1,4 +1,4 @@
-# git-juggler
+<img src="https://github.com/franz38/git-juggler/blob/main/src/frontend/public/logo.png?raw=true" alt="git-juggler" width="400">
 
 A local Git dashboard for people juggling agents and too many repos.
 

git_juggler-0.2.3/src/backend/git_juggler/agents/__init__.py

@@ -0,0 +1 @@
+"""Agent hook and activity tracking helpers."""

git_juggler-0.2.2/src/backend/git_juggler/agent_hook_events.py → git_juggler-0.2.3/src/backend/git_juggler/agents/hook_events.py

@@ -12,12 +12,12 @@ from dataclasses import dataclass, replace
 from pathlib import Path
 from typing import Any
 
-from .agent_hooks import EVENT_PATH
-from .agent_tracking.activity_models import ActivityEvidence, AgentRepositoryScan, AgentWorktreeActivity, SessionDetails
-from .agent_tracking.claude_sessions import CLAUDE_SESSIONS_DIR, ClaudeSession, read_registry, registry_signature
-from .agent_tracking.claude_transcripts import CLAUDE_PROJECTS_DIR, TranscriptInfo, find_transcript, read_transcript_info, transcript_signature
-from .agent_tracking.git_resolver import GitResolver, GitWorktreeInfo
-from .agent_tracking.opencode_sessions import OPENCODE_DB_PATH, OpenCodeSession, db_signature, read_session
+from .hooks import EVENT_PATH
+from .tracking.activity_models import ActivityEvidence, AgentRepositoryScan, AgentWorktreeActivity, SessionDetails
+from .tracking.claude_sessions import CLAUDE_SESSIONS_DIR, ClaudeSession, read_registry, registry_signature
+from .tracking.claude_transcripts import CLAUDE_PROJECTS_DIR, TranscriptInfo, find_transcript, read_transcript_info, transcript_signature
+from .tracking.git_resolver import GitResolver, GitWorktreeInfo
+from .tracking.opencode_sessions import OPENCODE_DB_PATH, OpenCodeSession, db_signature, read_session
 
 
 HOOK_ACTIVITY_TTL_MS = 120_000

git_juggler-0.2.3/src/backend/git_juggler/api/__init__.py

@@ -0,0 +1 @@
+"""FastAPI route modules."""

git_juggler-0.2.3/src/backend/git_juggler/api/agents.py

@@ -0,0 +1,97 @@
+from __future__ import annotations
+
+from fastapi import APIRouter
+
+from ..agents.hook_events import AgentHookEventReader
+from ..agents.hooks import hooks_status, install_claude_hooks, install_opencode_hooks
+from ..agents.tracking.activity_models import AgentRepositoryScan
+from ..schemas import (
+    AgentActivityResponse,
+    AgentHookProviderStatusResponse,
+    AgentHooksResponse,
+    AgentRepositoryScanResponse,
+)
+
+
+router = APIRouter()
+hook_event_reader = AgentHookEventReader()
+
+
+def _agent_scan_response(scan: AgentRepositoryScan) -> AgentRepositoryScanResponse:
+    return AgentRepositoryScanResponse(
+        agent_pid=scan.agent_pid,
+        session_directory=scan.session_directory,
+        worktrees=[
+            {
+                "repository_id": activity.repository_id,
+                "worktree_path": activity.worktree_path,
+                "branch": activity.branch,
+                "commit": activity.commit,
+                "process_ids": activity.process_ids,
+                "first_seen": activity.first_seen,
+                "last_seen": activity.last_seen,
+                "last_activity": activity.last_activity,
+                "evidence": [evidence.__dict__ for evidence in activity.evidence],
+                "activity_score": activity.activity_score,
+                "state": activity.state,
+                "is_home": activity.is_home,
+            }
+            for activity in scan.worktrees
+        ],
+        scanned_at=scan.scanned_at,
+        state=scan.state,
+        provider=scan.provider,
+        session_id=scan.session_id,
+        process_pid=scan.process_pid,
+        name=scan.name,
+        details=scan.details.__dict__ if scan.details is not None else None,
+        waiting_for=scan.waiting_for,
+    )
+
+
+def _hook_status_response(status) -> AgentHookProviderStatusResponse:
+    return AgentHookProviderStatusResponse(**status.__dict__)
+
+
+@router.get("/api/agents/activity", response_model=AgentActivityResponse)
+def api_agent_activity() -> AgentActivityResponse:
+    hook_scans = hook_event_reader.recent_scans()
+    scans = [_agent_scan_response(scan) for scan in hook_scans]
+    scanned_at = max((scan.scanned_at for scan in scans), default=0)
+    return AgentActivityResponse(
+        agents=[
+            {
+                "pid": scan.agent_pid,
+                "command_line": "hook activity",
+                "matched_pattern": "hook",
+            }
+            for scan in hook_scans
+        ],
+        scans=scans,
+        scanned_at=scanned_at,
+    )
+
+
+@router.get("/api/agents/hooks", response_model=AgentHooksResponse)
+def api_agent_hooks() -> AgentHooksResponse:
+    statuses = hooks_status()
+    return AgentHooksResponse(
+        claude=_hook_status_response(statuses["claude"]),
+        opencode=_hook_status_response(statuses["opencode"]),
+    )
+
+
+@router.post(
+    "/api/agents/hooks/claude/install",
+    response_model=AgentHookProviderStatusResponse,
+)
+def api_install_claude_hooks() -> AgentHookProviderStatusResponse:
+    return _hook_status_response(install_claude_hooks())
+
+
+@router.post(
+    "/api/agents/hooks/opencode/install",
+    response_model=AgentHookProviderStatusResponse,
+)
+def api_install_opencode_hooks() -> AgentHookProviderStatusResponse:
+    return _hook_status_response(install_opencode_hooks())

git_juggler-0.2.3/src/backend/git_juggler/api/ci.py

@@ -0,0 +1,97 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Annotated
+
+from fastapi import APIRouter, HTTPException, Query
+
+from .. import config
+from ..ci import github_actions, jenkins
+from ..ci import get_active_pipelines, get_ci_run_stages, get_ci_runs, poll_ci_runs
+from ..git.data import get_commit_hashes
+from ..repo_discovery import list_repos, resolve_repo_path
+from ..schemas import (
+    ActivePipeline,
+    CiConnectionTestResponse,
+    CiRunInfo,
+    CiStage,
+    GitHubConfig,
+    JenkinsConfig,
+)
+
+
+router = APIRouter()
+
+
+def _resolve_repo_path(repo_id: str) -> Path:
+    path = resolve_repo_path(config.load_repo_paths(), repo_id)
+    if path is None:
+        raise HTTPException(status_code=404, detail="repo not found")
+    return path
+
+
+@router.get("/api/repos/{repo_id}/ci/runs", response_model=dict[str, list[CiRunInfo]])
+def api_ci_runs(repo_id: str) -> dict[str, list[CiRunInfo]]:
+    path = _resolve_repo_path(repo_id)
+    return get_ci_runs(
+        path,
+        get_commit_hashes(path),
+        config.load_github_config(),
+        config.load_jenkins_config(),
+    )
+
+
+# Live poll of a repo's pipelines. Without `run`, every active run of the
+# repo (`head_sha` narrows it where the provider can filter): used right
+# after a commit action, when the run may not be known yet. With one or more
+# `run=<provider>:<run_id>` (CiRunInfo.provider / run_id), only those runs,
+# including their final status once finished.
+@router.get("/api/repos/{repo_id}/ci/poll", response_model=list[CiRunInfo])
+def api_ci_poll(
+    repo_id: str,
+    run: Annotated[list[str] | None, Query()] = None,
+    head_sha: str | None = None,
+) -> list[CiRunInfo]:
+    path = _resolve_repo_path(repo_id)
+    return poll_ci_runs(
+        path, run, head_sha, config.load_github_config(), config.load_jenkins_config()
+    )
+
+
+# Stages (GitHub jobs / Jenkins pipeline stages) of one run. `run_id` is the
+# value CiRunInfo.run_id carried; 404 when the provider has no stage data.
+@router.get("/api/repos/{repo_id}/ci/stages", response_model=list[CiStage])
+def api_ci_stages(repo_id: str, provider: str, run_id: str) -> list[CiStage]:
+    path = _resolve_repo_path(repo_id)
+    stages = get_ci_run_stages(
+        path,
+        provider,
+        run_id,
+        config.load_github_config(),
+        config.load_jenkins_config(),
+    )
+    if stages is None:
+        raise HTTPException(status_code=404, detail="stages not available")
+    return stages
+
+
+# Queued/running pipelines across all repos, for the Pipelines tab.
+@router.get("/api/ci/active", response_model=list[ActivePipeline])
+def api_ci_active() -> list[ActivePipeline]:
+    return get_active_pipelines(
+        list_repos(config.load_repo_paths()),
+        config.load_github_config(),
+        config.load_jenkins_config(),
+    )
+
+
+@router.post("/api/ci/github/test", response_model=CiConnectionTestResponse)
+def api_test_github_connection(body: GitHubConfig) -> CiConnectionTestResponse:
+    ok, message = github_actions.test_connection(body.model_dump())
+    return CiConnectionTestResponse(ok=ok, message=message)
+
+
+@router.post("/api/ci/jenkins/test", response_model=CiConnectionTestResponse)
+def api_test_jenkins_connection(body: JenkinsConfig) -> CiConnectionTestResponse:
+    ok, message = jenkins.test_connection(body.model_dump())
+    return CiConnectionTestResponse(ok=ok, message=message)

git_juggler-0.2.3/src/backend/git_juggler/api/config.py

@@ -0,0 +1,114 @@
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+
+from fastapi import APIRouter, HTTPException
+
+from .. import config
+from ..schemas import (
+    ConfigResponse,
+    ConfigUpdateRequest,
+    PickFolderResponse,
+    Preferences,
+    ThemesResponse,
+    VscodeTheme,
+)
+from ..themes import discover_themes
+from ..ui.folder_picker import NativePickerUnavailable, pick_folder
+
+
+def create_config_router(root_path: Path) -> APIRouter:
+    router = APIRouter()
+    terminal_shell = "cmd" if sys.platform == "win32" else "posix"
+
+    def _current_config() -> ConfigResponse:
+        return ConfigResponse(
+            repo_paths=[str(p) for p in config.load_repo_paths()],
+            pinned_repo_paths=config.load_pinned_repo_paths(),
+            repo_groups=config.load_repo_groups(),
+            excluded_paths=config.load_excluded_paths(),
+            github=config.load_github_config(),
+            jenkins=config.load_jenkins_config(),
+            terminal_shell=terminal_shell,
+        )
+
+    @router.get("/api/config", response_model=ConfigResponse)
+    def api_get_config() -> ConfigResponse:
+        return _current_config()
+
+    @router.put("/api/config", response_model=ConfigResponse)
+    def api_update_config(body: ConfigUpdateRequest) -> ConfigResponse:
+        if body.repo_paths is not None:
+            resolved: list[Path] = []
+            seen: set[str] = set()
+            for raw in body.repo_paths:
+                path = Path(raw).expanduser().resolve()
+                if not path.is_dir():
+                    raise HTTPException(status_code=400, detail=f"not a directory: {raw}")
+                key = str(path)
+                if key in seen:
+                    continue
+                seen.add(key)
+                resolved.append(path)
+            config.save_repo_paths(resolved)
+
+        if body.pinned_repo_paths is not None:
+            deduped = list(dict.fromkeys(body.pinned_repo_paths))
+            config.save_pinned_repo_paths(deduped)
+
+        if body.repo_groups is not None:
+            config.save_repo_groups([group.model_dump() for group in body.repo_groups])
+
+        if body.excluded_paths is not None:
+            config.save_excluded_paths(body.excluded_paths)
+
+        if body.github is not None:
+            config.save_github_config(body.github.model_dump())
+
+        if body.jenkins is not None:
+            config.save_jenkins_config(body.jenkins.model_dump())
+
+        return _current_config()
+
+    # Wipes every stored setting back to a first-run state. App settings only,
+    # nothing here touches a repo.
+    @router.post("/api/config/reset", response_model=ConfigResponse)
+    def api_reset_config() -> ConfigResponse:
+        config.reset_to_factory(root_path)
+        return _current_config()
+
+    @router.post("/api/pick-folder", response_model=PickFolderResponse)
+    def api_pick_folder() -> PickFolderResponse:
+        try:
+            return PickFolderResponse(path=pick_folder())
+        except NativePickerUnavailable as e:
+            raise HTTPException(status_code=501, detail=str(e))
+
+    def _current_themes() -> ThemesResponse:
+        imported = [VscodeTheme(**theme) for theme in config.load_imported_themes()]
+        return ThemesResponse(installed=discover_themes(), imported=imported)
+
+    @router.get("/api/themes", response_model=ThemesResponse)
+    def api_get_themes() -> ThemesResponse:
+        return _current_themes()
+
+    # Stores theme *files* the user imported in the UI (app settings, not repo
+    # state, so this doesn't fall under the git-mutations-via-terminal rule).
+    @router.put("/api/themes/imported", response_model=ThemesResponse)
+    def api_put_imported_themes(body: list[VscodeTheme]) -> ThemesResponse:
+        config.save_imported_themes([theme.model_dump() for theme in body])
+        return _current_themes()
+
+    # UI preferences (theme, pinned themes, key bindings, agent settings, ...)
+    # kept server-side so every browser shows the same setup. App settings only,
+    # nothing here touches a repo.
+    @router.get("/api/preferences", response_model=Preferences)
+    def api_get_preferences() -> Preferences:
+        return config.load_preferences()
+
+    @router.put("/api/preferences", response_model=Preferences)
+    def api_put_preferences(body: Preferences) -> Preferences:
+        return config.update_preferences(body.model_dump(mode="json", exclude_unset=True))
+
+    return router

git_juggler-0.2.3/src/backend/git_juggler/api/git.py

@@ -0,0 +1,77 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from fastapi import APIRouter, HTTPException, Query
+
+from .. import config
+from ..git.data import GRAPH_PAGE_SIZE, HistoryChangedError, get_graph, get_repo_status
+from ..git.detail import get_commit_detail
+from ..git.diff import get_commit_file_diff, get_working_file_diff
+from ..repo_discovery import resolve_repo_path
+from ..schemas import CommitDetail, FileDiff, GraphResponse, RepoStatusResponse
+
+
+router = APIRouter()
+
+
+def _resolve_repo_path(repo_id: str) -> Path:
+    path = resolve_repo_path(config.load_repo_paths(), repo_id)
+    if path is None:
+        raise HTTPException(status_code=404, detail="repo not found")
+    return path
+
+
+@router.get("/api/repos/{repo_id}/graph", response_model=GraphResponse)
+def api_graph(
+    repo_id: str,
+    before: str | None = None,
+    limit: int = Query(GRAPH_PAGE_SIZE, ge=1, le=10 * GRAPH_PAGE_SIZE),
+) -> GraphResponse:
+    path = _resolve_repo_path(repo_id)
+    try:
+        return GraphResponse(**get_graph(path, limit=limit, before=before)._asdict())
+    except HistoryChangedError as exc:
+        # The cursor commit is gone (history rewritten): the client should reload from the first page.
+        raise HTTPException(status_code=409, detail="graph history changed") from exc
+
+
+@router.get("/api/repos/{repo_id}/status", response_model=RepoStatusResponse)
+def api_repo_status(repo_id: str) -> RepoStatusResponse:
+    path = _resolve_repo_path(repo_id)
+    return get_repo_status(path)
+
+
+@router.get("/api/repos/{repo_id}/commits/{sha}", response_model=CommitDetail)
+def api_commit_detail(repo_id: str, sha: str) -> CommitDetail:
+    path = _resolve_repo_path(repo_id)
+    try:
+        return get_commit_detail(path, sha)
+    except Exception as exc:  # noqa: BLE001 - surfaced as a 404 either way
+        raise HTTPException(status_code=404, detail="commit not found") from exc
+
+
+@router.get("/api/repos/{repo_id}/commits/{sha}/diff", response_model=FileDiff)
+def api_commit_file_diff(
+    repo_id: str,
+    sha: str,
+    path: str,
+    old_path: str | None = None,
+    full: bool = False,
+) -> FileDiff:
+    repo_path = _resolve_repo_path(repo_id)
+    try:
+        return get_commit_file_diff(repo_path, sha, path, old_path, full)
+    except Exception as exc:  # noqa: BLE001 - surfaced as a 404 either way
+        raise HTTPException(status_code=404, detail="diff not found") from exc
+
+
+@router.get("/api/repos/{repo_id}/diff", response_model=FileDiff)
+def api_working_file_diff(
+    repo_id: str, path: str, old_path: str | None = None, full: bool = False
+) -> FileDiff:
+    repo_path = _resolve_repo_path(repo_id)
+    try:
+        return get_working_file_diff(repo_path, path, old_path, full)
+    except Exception as exc:  # noqa: BLE001 - surfaced as a 404 either way
+        raise HTTPException(status_code=404, detail="diff not found") from exc

git_juggler-0.2.3/src/backend/git_juggler/api/repos.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+
+from fastapi import APIRouter
+
+from .. import config
+from ..repo_discovery import get_scan_progress, list_repos
+from ..schemas import BrowseDirectoryResponse, RepoScanProgress, RepoSummary
+from ..ui.folder_picker import browse_directory
+
+
+router = APIRouter()
+
+
+@router.get("/api/repos", response_model=list[RepoSummary])
+def api_list_repos() -> list[RepoSummary]:
+    return list_repos(config.load_repo_paths())
+
+
+@router.get("/api/repos/scan-progress", response_model=RepoScanProgress)
+def api_repos_scan_progress() -> RepoScanProgress:
+    return RepoScanProgress(**get_scan_progress())
+
+
+@router.get("/api/browse", response_model=BrowseDirectoryResponse)
+def api_browse(path: str | None = None) -> BrowseDirectoryResponse:
+    return browse_directory(path)

git_juggler-0.2.3/src/backend/git_juggler/api/terminal.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from fastapi import APIRouter, WebSocket, WebSocketDisconnect
+
+from .. import config
+from ..repo_discovery import resolve_repo_path
+from ..terminal import run_terminal_session
+
+
+def create_terminal_router(root_path: Path) -> APIRouter:
+    router = APIRouter()
+
+    @router.websocket("/ws/terminal")
+    async def ws_terminal(websocket: WebSocket) -> None:
+        repo_id = websocket.query_params.get("repo")
+        cwd = root_path
+        if repo_id:
+            resolved = resolve_repo_path(config.load_repo_paths(), repo_id)
+            if resolved is None:
+                await websocket.close(code=1008)
+                return
+            cwd = resolved
+        await websocket.accept()
+        try:
+            await run_terminal_session(websocket, cwd=cwd)
+        except WebSocketDisconnect:
+            pass
+
+    return router

git_juggler-0.2.3/src/backend/git_juggler/app.py

@@ -0,0 +1,51 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import FileResponse
+from fastapi.staticfiles import StaticFiles
+
+from . import config
+from .api.agents import router as agents_router
+from .api.ci import router as ci_router
+from .api.config import create_config_router
+from .api.git import router as git_router
+from .api.repos import router as repos_router
+from .api.terminal import create_terminal_router
+
+
+def create_app(root_path: Path, frontend_dist: Path | None = None) -> FastAPI:
+    app = FastAPI(title="git-juggler")
+    app.state.root_path = root_path
+    config.ensure_seeded(root_path)
+
+    # Only needed for local dev, when the Vite dev server (a different origin)
+    # talks to this API directly instead of through its proxy.
+    app.add_middleware(
+        CORSMiddleware,
+        allow_origins=["http://localhost:5173", "http://127.0.0.1:5173"],
+        allow_methods=["*"],
+        allow_headers=["*"],
+    )
+    app.include_router(repos_router)
+    app.include_router(git_router)
+    app.include_router(ci_router)
+    app.include_router(agents_router)
+    app.include_router(create_config_router(root_path))
+    app.include_router(create_terminal_router(root_path))
+
+    if frontend_dist and frontend_dist.exists():
+        assets_dir = frontend_dist / "assets"
+        if assets_dir.exists():
+            app.mount("/assets", StaticFiles(directory=assets_dir), name="assets")
+
+        @app.get("/{full_path:path}")
+        def spa(full_path: str) -> FileResponse:
+            candidate = frontend_dist / full_path
+            if full_path and candidate.is_file():
+                return FileResponse(candidate)
+            return FileResponse(frontend_dist / "index.html")
+
+    return app

git_juggler-0.2.2/src/backend/git_juggler/ci.py → git_juggler-0.2.3/src/backend/git_juggler/ci/__init__.py

@@ -6,7 +6,7 @@ from pathlib import Path
 from typing import Protocol
 
 from . import github_actions, jenkins
-from .schemas import ActivePipeline, CiRunInfo, CiStage, RepoSummary
+from ..schemas import ActivePipeline, CiRunInfo, CiStage, RepoSummary
 
 
 class CiProvider(Protocol):

{git_juggler-0.2.2/src/backend/git_juggler → git_juggler-0.2.3/src/backend/git_juggler/ci}/github_actions.py

@@ -10,7 +10,8 @@ from urllib.request import Request, urlopen
 
 from git import Repo
 
-from .schemas import CiRunInfo, CiStage
+from .http import fetch_json
+from ..schemas import CiRunInfo, CiStage
 
 
 GITHUB_RUNS_PER_PAGE = 100
@@ -130,17 +131,7 @@ def _repo_api_url(github_config: dict, repo_config: dict) -> str | None:
 
 
 def _get_json(url: str, headers: dict[str, str]) -> dict | None:
-    request = Request(url, headers=headers)
-    try:
-        with urlopen(request, timeout=10) as response:  # noqa: S310 - configured user URL, read-only local app integration
-            body = response.read().decode("utf-8")
-    except (HTTPError, URLError, TimeoutError, OSError):
-        return None
-    try:
-        data = json.loads(body)
-    except json.JSONDecodeError:
-        return None
-    return data if isinstance(data, dict) else None
+    return fetch_json(url, headers, opener=urlopen)
 
 
 # Conditional-request cache for the polling calls: GitHub answers a request

git_juggler-0.2.3/src/backend/git_juggler/ci/http.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+import json
+from typing import Callable, ContextManager, Protocol
+from urllib.error import HTTPError, URLError
+from urllib.request import Request, urlopen
+
+
+class _Response(Protocol):
+    def read(self) -> bytes: ...
+
+
+def fetch_json(
+    url: str,
+    headers: dict[str, str],
+    opener: Callable[..., ContextManager[_Response]] = urlopen,
+) -> dict | None:
+    request = Request(url, headers=headers)
+    try:
+        with opener(request, timeout=10) as response:  # noqa: S310 - configured user URL, read-only local app integration
+            body = response.read().decode("utf-8")
+    except (HTTPError, URLError, TimeoutError, OSError):
+        return None
+    try:
+        data = json.loads(body)
+    except json.JSONDecodeError:
+        return None
+    return data if isinstance(data, dict) else None

{git_juggler-0.2.2/src/backend/git_juggler → git_juggler-0.2.3/src/backend/git_juggler/ci}/jenkins.py

@@ -1,15 +1,14 @@
 from __future__ import annotations
 
 import base64
-import json
 import os
 from datetime import datetime, timezone
 from pathlib import Path
-from urllib.error import HTTPError, URLError
 from urllib.parse import unquote, urlencode, urlparse
-from urllib.request import Request, urlopen
+from urllib.request import urlopen
 
-from .schemas import CiRunInfo, CiStage
+from .http import fetch_json
+from ..schemas import CiRunInfo, CiStage
 
 
 def _matching_job_configs(jenkins_config: dict, repo_path: Path) -> list[dict]:
@@ -42,17 +41,7 @@ def _headers(jenkins_config: dict) -> dict[str, str]:
 
 
 def _fetch_json(url: str, headers: dict[str, str]) -> dict | None:
-    request = Request(url, headers=headers)
-    try:
-        with urlopen(request, timeout=10) as response:  # noqa: S310 - configured user URL, read-only local app integration
-            body = response.read().decode("utf-8")
-    except (HTTPError, URLError, TimeoutError, OSError):
-        return None
-    try:
-        data = json.loads(body)
-    except json.JSONDecodeError:
-        return None
-    return data if isinstance(data, dict) else None
+    return fetch_json(url, headers, opener=urlopen)
 
 
 def _normalize_status(result: object, building: object) -> str: