witan-code 0.16.0__tar.gz → 0.17.0__tar.gz

{witan_code-0.16.0 → witan_code-0.17.0}/CHANGELOG.md

@@ -6,7 +6,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/) (pre-1.0:
 a MINOR bump may include breaking changes).
 
-## [Unreleased]
+## [0.17.0] - 2026-09-01
 
 ### Fixed
 
@@ -55,6 +55,16 @@ a MINOR bump may include breaking changes).
 
 ### Changed
 
+- **Floor raised to `fastmcp>=4,<5`; the optional `tasks` extra moves to
+  `fastmcp-tasks>=4,<5`.** FastMCP 4.0 went GA, so the `fastmcp>=3.4.2,<5`
+  straddle is dropped, along with the `witan-code[tasks]`-only reason that
+  extra used to also need `--prerelease=allow` under uv. No behavior change on
+  this package's own code — witan-core's version-sniffing shims are what
+  actually moved (see its changelog); this is a dependency-floor release,
+  breaking only for a caller still resolving fastmcp 3.4.x, which pre-1.0
+  semver treats as a MINOR bump. Closes
+  `tk-move-the-fastmcp-floor-to-4-when-4-0-goes-ga-454f78`.
+
 - **`graph.check_writable` requires `actor`; `None` now means "no identity",
   full stop.** It used to fall back to `identity.actor_id()`, which gave the
   parameter two meanings depending on the caller. Every call site

{witan_code-0.16.0 → witan_code-0.17.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: witan-code
-Version: 0.16.0
+Version: 0.17.0
 Summary: witan-code — tree-sitter code graph + cross-repo bridge (mounts under `witan code`)
 Project-URL: Homepage, https://github.com/mitodl/agent-kit/tree/main/mcp/servers/witan-code
 Project-URL: Repository, https://github.com/mitodl/agent-kit
@@ -12,7 +12,7 @@ Classifier: Programming Language :: Python :: 3
 Requires-Python: >=3.11
 Requires-Dist: agent-config-kit<1,>=0.4
 Requires-Dist: cyclopts<5,>=4
-Requires-Dist: fastmcp<5,>=3.4.2
+Requires-Dist: fastmcp<5,>=4
 Requires-Dist: joserfc<2,>=1.0
 Requires-Dist: pydantic<3,>=2
 Requires-Dist: pyyaml<7,>=6
@@ -28,7 +28,7 @@ Requires-Dist: tree-sitter-yaml<0.8,>=0.7
 Requires-Dist: tree-sitter<0.26,>=0.25
 Requires-Dist: witan-core[cli,observability,remote,sentry]<1,>=0.32
 Provides-Extra: tasks
-Requires-Dist: fastmcp-tasks<5,>=4.0.0b1; extra == 'tasks'
+Requires-Dist: fastmcp-tasks<5,>=4; extra == 'tasks'
 Description-Content-Type: text/markdown
 
 # witan-code

{witan_code-0.16.0 → witan_code-0.17.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "witan-code"
-version = "0.16.0"
+version = "0.17.0"
 description = "witan-code — tree-sitter code graph + cross-repo bridge (mounts under `witan code`)"
 readme = "README.md"
 license = "BSD-3-Clause"
@@ -122,7 +122,7 @@ dependencies = [
     # conflict, since both sides named the same number. Re-check it by hand on
     # every rebase; a floor one release low here is silent.
     "witan-core[cli,remote,observability,sentry]>=0.32,<1",
-    "fastmcp>=3.4.2,<5",
+    "fastmcp>=4,<5",
     "cyclopts>=4,<5",
     # [targets.<name>] override models (config.py) — also transitively pulled
     # in by fastmcp, declared explicitly since config.py imports it directly.
@@ -162,10 +162,9 @@ dependencies = [
 [project.optional-dependencies]
 # The io.modelcontextprotocol/tasks extension (SEP-2663), which lets a client
 # poll a long `code_reindex` instead of holding the tool call open. Optional
-# because it exists only for fastmcp 4.x while the pin above still spans 3.4.x,
-# and because it pulls a Docket/Redis stack that the default in-process
+# because it pulls a Docket/Redis stack that the default in-process
 # `memory://` backend does not need. server.py registers it when importable.
-tasks = ["fastmcp-tasks>=4.0.0b1,<5"]
+tasks = ["fastmcp-tasks>=4,<5"]
 
 [project.urls]
 Homepage = "https://github.com/mitodl/agent-kit/tree/main/mcp/servers/witan-code"
@@ -195,7 +194,7 @@ witan-core = { workspace = true }
 # cryptography: test_github_app generates a throwaway RSA key so the JWT path
 # is exercised for real rather than mocked. joserfc requires it at runtime, so
 # this only makes an existing import explicit.
-test = ["pytest>=8", "fastmcp-tasks>=4.0.0b1,<5", "cryptography"]
+test = ["pytest>=8", "fastmcp-tasks>=4,<5", "cryptography"]
 
 [tool.pytest.ini_options]
 pythonpath = ["."]
@@ -205,7 +204,7 @@ testpaths = ["tests"]
 packages = ["witan_code"]
 
 [tool.bumpversion]
-current_version = "0.16.0"
+current_version = "0.17.0"
 allow_dirty = true
 
 [[tool.bumpversion.files]]

{witan_code-0.16.0 → witan_code-0.17.0}/tests/test_github_app.py

@@ -20,6 +20,7 @@ from witan_code.github_app import (
     EXIT_ERROR,
     EXIT_NOT_CONFIGURED,
     EXIT_OK,
+    GH_TOKEN_ENV_VAR,
     GITHUB_API_URL,
     INSTALLATION_ID_ENV_VAR,
     KEY_FILE_ENV_VAR,
@@ -27,8 +28,11 @@ from witan_code.github_app import (
     GitHubAppError,
     app_jwt,
     from_env,
+    api_repo_host,
     installation_token,
     main,
+    repo_is_private,
+    repo_owner_name,
 )
 
 _JWT_MAX_LIFETIME = 600  # GitHub's hard limit on an App JWT.
@@ -308,3 +312,218 @@ def test_main_reports_a_mint_failure(tmp_path, pem, monkeypatch, capsys):
 
 def test_main_rejects_an_unknown_argument():
     assert main(["--nope"]) == EXIT_ERROR
+
+
+# ── repo_owner_name / repo_is_private ─────────────────────────────────────────
+
+
+@pytest.mark.parametrize(
+    ("uri", "expected"),
+    [
+        ("https://github.com/mitodl/agent-kit", ("mitodl", "agent-kit")),
+        ("https://github.com/mitodl/agent-kit/", ("mitodl", "agent-kit")),
+        ("https://github.com/mitodl/agent-kit.git", ("mitodl", "agent-kit")),
+    ],
+)
+def test_repo_owner_name_splits_a_canonical_uri(uri, expected):
+    assert repo_owner_name(uri) == expected
+
+
+@pytest.mark.parametrize(
+    "uri",
+    [
+        "agent-kit",
+        "",
+        "https://github.com/",
+        "https://github.com/mitodl",
+        # Scheme-relative: `urlsplit` gives it a netloc and no scheme, so a
+        # scheme check that only looked for "not empty" would let it through.
+        "//github.com/mitodl/agent-kit",
+        "http://github.com/mitodl/agent-kit",
+        "git@github.com:mitodl/agent-kit.git",
+    ],
+)
+def test_repo_owner_name_rejects_something_that_is_not_a_repo_uri(uri):
+    with pytest.raises(GitHubAppError, match="owner and repository name"):
+        repo_owner_name(uri)
+
+
+def test_repo_owner_name_rejects_extra_path_components():
+    """`.../a/b/c/d` must not be cleared by `c/d`'s visibility."""
+    with pytest.raises(GitHubAppError, match="owner and repository name"):
+        repo_owner_name("https://github.com/mitodl/agent-kit/tree/main")
+
+
+def test_repo_owner_name_rejects_a_host_the_api_does_not_answer_for():
+    """The clone uses the whole URI; the check uses only owner/name.
+
+    Left unchecked, `https://other.example/mitodl/agent-kit` would be approved
+    on `github.com/mitodl/agent-kit`'s visibility and then cloned from
+    `other.example` — the guard satisfied by a different repository entirely.
+    """
+    with pytest.raises(GitHubAppError, match="answers for 'github.com'"):
+        repo_owner_name("https://other.example/mitodl/agent-kit")
+
+
+def test_repo_owner_name_follows_an_enterprise_api_host():
+    api = "https://ghe.example/api/v3"
+    assert repo_owner_name("https://ghe.example/mitodl/agent-kit", api_url=api) == (
+        "mitodl",
+        "agent-kit",
+    )
+    # And github.com is then the mismatched host, not the privileged one.
+    with pytest.raises(GitHubAppError, match="answers for 'ghe.example'"):
+        repo_owner_name("https://github.com/mitodl/agent-kit", api_url=api)
+
+
+@pytest.mark.parametrize(
+    ("api_url", "expected"),
+    [
+        ("https://api.github.com", "github.com"),
+        ("https://ghe.example/api/v3", "ghe.example"),
+        ("https://API.GITHUB.COM/", "github.com"),
+    ],
+)
+def test_api_repo_host(api_url, expected):
+    assert api_repo_host(api_url) == expected
+
+
+def test_repo_is_private_asks_github_as_the_installation():
+    seen = {}
+
+    def handler(request: httpx2.Request) -> httpx2.Response:
+        seen["url"] = str(request.url)
+        seen["auth"] = request.headers["Authorization"]
+        seen["method"] = request.method
+        return httpx2.Response(200, json={"private": True})
+
+    private = repo_is_private(
+        "https://github.com/mitodl/secret-thing", "ghs_x", client=_client(handler)
+    )
+
+    assert private is True
+    assert seen["method"] == "GET"
+    assert seen["url"] == "https://api.github.com/repos/mitodl/secret-thing"
+    # The installation token, not the App JWT: the App itself cannot see repos.
+    assert seen["auth"] == "Bearer ghs_x"
+
+
+def test_repo_is_private_is_false_for_a_public_repo():
+    def handler(_: httpx2.Request) -> httpx2.Response:
+        return httpx2.Response(200, json={"private": False})
+
+    assert (
+        repo_is_private(
+            "https://github.com/mitodl/agent-kit", "ghs_x", client=_client(handler)
+        )
+        is False
+    )
+
+
+def test_repo_is_private_raises_on_a_404_rather_than_calling_it_public():
+    """An installation that cannot see a repo has not answered the question."""
+
+    def handler(_: httpx2.Request) -> httpx2.Response:
+        return httpx2.Response(404, json={"message": "Not Found"})
+
+    with pytest.raises(GitHubAppError, match="would not describe"):
+        repo_is_private(
+            "https://github.com/mitodl/gone", "ghs_x", client=_client(handler)
+        )
+
+
+@pytest.mark.parametrize("body", [{}, {"private": "yes"}])
+def test_repo_is_private_raises_when_the_answer_is_not_a_boolean(body):
+    def handler(_: httpx2.Request) -> httpx2.Response:
+        return httpx2.Response(200, json=body)
+
+    with pytest.raises(GitHubAppError):
+        repo_is_private(
+            "https://github.com/mitodl/agent-kit", "ghs_x", client=_client(handler)
+        )
+
+
+def test_repo_is_private_raises_when_github_is_unreachable():
+    def handler(_: httpx2.Request) -> httpx2.Response:
+        raise httpx2.ConnectError("no route")
+
+    with pytest.raises(GitHubAppError, match="Could not reach"):
+        repo_is_private(
+            "https://github.com/mitodl/agent-kit", "ghs_x", client=_client(handler)
+        )
+
+
+def test_repo_is_private_leaves_a_caller_supplied_client_open():
+    client = _client(lambda _: httpx2.Response(200, json={"private": False}))
+    repo_is_private("https://github.com/mitodl/agent-kit", "ghs_x", client=client)
+    assert not client.is_closed
+
+
+# ── main --visibility ─────────────────────────────────────────────────────────
+
+
+def test_main_visibility_prints_the_answer(tmp_path, pem, monkeypatch, capsys):
+    for name, value in _env(tmp_path, pem).items():
+        monkeypatch.setenv(name, value)
+    monkeypatch.setenv(GH_TOKEN_ENV_VAR, "ghs_already_minted")
+    seen = {}
+
+    def fake(repo, token, *, api_url):
+        seen.update(repo=repo, token=token, api_url=api_url)
+        return True
+
+    monkeypatch.setattr("witan_code.github_app.repo_is_private", fake)
+    assert main(["--visibility", "https://github.com/mitodl/x"]) == EXIT_OK
+    assert capsys.readouterr().out.strip() == "private"
+    # Reuses the token the entrypoint already minted rather than exchanging a
+    # second App JWT for another one — see GH_TOKEN_ENV_VAR.
+    assert seen["token"] == "ghs_already_minted"
+    assert seen["repo"] == "https://github.com/mitodl/x"
+
+
+def test_main_visibility_mints_a_token_when_none_is_in_the_environment(
+    tmp_path, pem, monkeypatch, capsys
+):
+    for name, value in _env(tmp_path, pem).items():
+        monkeypatch.setenv(name, value)
+    monkeypatch.delenv(GH_TOKEN_ENV_VAR, raising=False)
+    monkeypatch.setattr(
+        "witan_code.github_app.installation_token",
+        lambda _creds, *, api_url: "ghs_fresh",
+    )
+    monkeypatch.setattr(
+        "witan_code.github_app.repo_is_private",
+        lambda _repo, token, *, api_url: token == "ghs_fresh",
+    )
+    assert main(["--visibility", "https://github.com/mitodl/x"]) == EXIT_OK
+    assert capsys.readouterr().out.strip() == "private"
+
+
+def test_main_visibility_reports_not_configured_without_an_app(monkeypatch):
+    """No App means no private repo could have been cloned in the first place."""
+    for name in (APP_ID_ENV_VAR, INSTALLATION_ID_ENV_VAR, KEY_FILE_ENV_VAR):
+        monkeypatch.delenv(name, raising=False)
+    assert main(["--visibility", "https://github.com/mitodl/x"]) == EXIT_NOT_CONFIGURED
+
+
+def test_main_visibility_reports_a_lookup_failure(tmp_path, pem, monkeypatch, capsys):
+    for name, value in _env(tmp_path, pem).items():
+        monkeypatch.setenv(name, value)
+    monkeypatch.setenv(GH_TOKEN_ENV_VAR, "ghs_x")
+
+    def boom(_repo, _token, *, api_url):
+        raise GitHubAppError("GitHub said no")
+
+    monkeypatch.setattr("witan_code.github_app.repo_is_private", boom)
+    assert main(["--visibility", "https://github.com/mitodl/x"]) == EXIT_ERROR
+    assert "GitHub said no" in capsys.readouterr().err
+
+
+@pytest.mark.parametrize("argv", [["--visibility"], ["--visibility", "a", "b"]])
+def test_main_rejects_a_malformed_visibility_invocation(
+    argv, tmp_path, pem, monkeypatch
+):
+    """The usage error comes before any credential or network work."""
+    for name, value in _env(tmp_path, pem).items():
+        monkeypatch.setenv(name, value)
+    assert main(argv) == EXIT_ERROR

{witan_code-0.16.0 → witan_code-0.17.0}/witan_code/github_app.py

@@ -11,12 +11,30 @@ decision, not a plumbing one:
 - A **user PAT** is one credential, but long-lived and scoped to everything its
   owner can read — far more than the indexer needs, and rotation is manual.
 - A **GitHub App** issues installation tokens that expire in an hour, and its
-  *installation* is itself the list of repositories it can reach. That list is
-  managed by an org admin in GitHub rather than by this deployment's config, so
-  a private repo's code cannot be pulled into a shared graph by a Pulumi change
-  alone — two independently-controlled things have to agree first.
-
-Hence the App. The permission it needs is exactly ``contents: read``.
+  *installation* is the list of repositories it can reach — a list an org admin
+  manages in GitHub rather than one this deployment's config decides.
+
+Hence the App. It needs ``contents: read`` to clone and ``metadata: read`` to
+answer :func:`repo_is_private`; the installed App already holds both (verified
+against ``GET /orgs/mitodl/installations``, 2026-08-28), so the visibility
+guard needed no permission change.
+
+★ THE INSTALLATION IS NOT THE CONTROL IT LOOKS LIKE. It is tempting to read
+the bullet above as "a private repo cannot reach a shared graph by a Pulumi
+change alone, because two independently-controlled things have to agree" —
+this module said exactly that until 2026-08-28, and it is false as installed.
+The same `GET /orgs/mitodl/installations` reports
+``repository_selection: "all"``, so the App can already reach every private
+repo in the org and adding one to ``managed_repos`` is the only step there is.
+
+What actually stops it is the entrypoint's refusal
+(``docker/witan-ci-index.sh``): every repo's visibility is checked before its
+clone, private ones are refused, and ``WITAN_CODE_CI_ALLOW_PRIVATE_REPOS=1`` is
+the explicit opt-in. That is a real second thing to agree, because it lives in
+the deployment where a reviewer sees it. It is a stopgap for a missing read
+control, not the control itself: a shared code graph grants ``read`` to every
+actor holding a token, so a private repo indexed into one is readable by every
+witan user. See ``docs/adr/0010-private-code-graph-read-scoping.md``.
 
 WHY A TOKEN PER REPO, NOT PER SWEEP
 
@@ -50,6 +68,7 @@ import time
 from dataclasses import dataclass
 from pathlib import Path
 from typing import TYPE_CHECKING
+from urllib.parse import urlsplit
 
 from witan_core.observability import get_logger
 
@@ -64,9 +83,12 @@ _MODULE = "witan_code.github_app"
 __all__ = [
     "AppCredentials",
     "GitHubAppError",
+    "api_repo_host",
     "app_jwt",
     "from_env",
     "installation_token",
+    "repo_is_private",
+    "repo_owner_name",
 ]
 
 GITHUB_API_URL = "https://api.github.com"
@@ -82,8 +104,20 @@ _ENV_VARS = (APP_ID_ENV_VAR, INSTALLATION_ID_ENV_VAR, KEY_FILE_ENV_VAR)
 # plumbing is the part most likely to be subtly wrong, and it cannot be tested
 # at all if the API host is a constant. A GitHub Enterprise host would use it
 # for real.
+#
+# Pointing this at a stub also moves the host that repo URIs must be on:
+# `repo_owner_name` refuses a repo this API cannot answer for, so a stub on
+# 127.0.0.1:8731 has to be swept with `https://127.0.0.1:8731/owner/name`
+# URIs, not `https://github.com/...` ones. That is the guard working, not an
+# obstacle to route around.
 API_URL_ENV_VAR = "WITAN_CODE_GITHUB_API_URL"
 
+# Where the entrypoint keeps the installation token it minted for the repo it
+# is about to clone. Named here rather than only in the shell so the two agree:
+# `--visibility` reuses that token when it is set, which is the difference
+# between one API call per repo and three (a JWT exchange plus the lookup).
+GH_TOKEN_ENV_VAR = "WITAN_CODE_GH_TOKEN"
+
 # GitHub rejects an App JWT whose lifetime exceeds 10 minutes. Nine leaves room
 # for the clock skew backdate below without crossing that line.
 _JWT_LIFETIME_SECONDS = 9 * 60
@@ -93,13 +127,14 @@ _JWT_BACKDATE_SECONDS = 60
 
 _HTTP_TIMEOUT = 15
 _HTTP_CREATED = 201
+_HTTP_OK = 200
 # Enough of an error body to identify the failure, bounded so a stray HTML
 # error page does not land in the job log in full.
 _ERROR_BODY_LIMIT = 500
 
 
 class GitHubAppError(RuntimeError):
-    """Minting an installation token failed."""
+    """Minting an installation token, or asking GitHub about a repo, failed."""
 
 
 @dataclass(frozen=True)
@@ -261,6 +296,117 @@ def installation_token(
     return token
 
 
+def api_repo_host(api_url: str) -> str:
+    """The repo host whose repositories ``api_url`` answers for.
+
+    ``https://api.github.com`` serves ``github.com``; a GitHub Enterprise API
+    (``https://ghe.example/api/v3``) serves its own host. Used to refuse a repo
+    URI whose host this API cannot speak for — see :func:`repo_owner_name`.
+    """
+    netloc = urlsplit(api_url.strip()).netloc.lower()
+    return netloc.removeprefix("api.") if netloc == "api.github.com" else netloc
+
+
+def repo_owner_name(repo: str, *, api_url: str = GITHUB_API_URL) -> tuple[str, str]:
+    """``(owner, name)`` from a canonical repo URI, for the API path.
+
+    The sweep works in canonical URIs (``https://github.com/mitodl/agent-kit``)
+    because that is what witan-code detects from a checkout's remote and keys
+    graphs on. GitHub's API wants the two components separately.
+
+    ★ THE URI IS VALIDATED, NOT JUST SPLIT, AND THAT IS THE POINT. The caller
+    is a guard that decides whether a repo may be cloned, and the *clone* uses
+    the whole URI while the *check* uses only these two components against
+    ``api_url``. Anything that lets those two disagree lets the guard approve
+    one repository and the sweep fetch another: `https://other.example/o/r`
+    would be cleared by `github.com/o/r`'s visibility, and
+    `https://github.com/a/b/c/d` by `c/d`'s. So this requires an ``https`` URI
+    whose host is the one ``api_url`` answers for (:func:`api_repo_host`) and
+    whose path is exactly two components — refusing, never repairing, anything
+    else. A repo URI outside the configured host is not "the same repo
+    elsewhere"; it is a question this API cannot answer, and an unanswered
+    question must fail closed.
+    """
+    split = urlsplit(repo.strip())
+    path = split.path.removesuffix(".git")
+    parts = [component for component in path.split("/") if component]
+    expected_host = api_repo_host(api_url)
+    if split.scheme != "https" or len(parts) != 2:  # noqa: PLR2004 — owner and name
+        raise GitHubAppError(
+            f"Cannot read an owner and repository name out of {repo!r}; "
+            f"expected a canonical URI like https://{expected_host}/owner/name."
+        )
+    if split.netloc.lower() != expected_host:
+        raise GitHubAppError(
+            f"Refusing to check {repo!r} against {api_url}: that API answers "
+            f"for {expected_host!r}, so it would report some other "
+            f"repository's visibility while the clone used this URI. Point "
+            f"{API_URL_ENV_VAR} at the API for {split.netloc!r} if that is "
+            "the host meant."
+        )
+    return parts[0], parts[1]
+
+
+def repo_is_private(
+    repo: str,
+    token: str,
+    *,
+    client: httpx2.Client | None = None,
+    api_url: str = GITHUB_API_URL,
+) -> bool:
+    """Whether GitHub considers ``repo`` private, asked as the installation.
+
+    ``private`` rather than ``visibility``: an ``internal`` repo (GitHub
+    Enterprise) is not public and reports ``private: true``, so the boolean is
+    the one that stays correct if this ever runs against an Enterprise host,
+    while a ``visibility != "public"`` test would have to grow a case.
+
+    A 404 raises rather than returning either answer. It means the
+    installation cannot see this repository at all — which is genuinely
+    ambiguous between "private and out of scope" and "does not exist" — and
+    the caller must not read an unanswered question as "public".
+    """
+    import httpx2
+
+    owner, name = repo_owner_name(repo, api_url=api_url)
+    owns = client is None
+    http = client or httpx2.Client(timeout=_HTTP_TIMEOUT)
+    url = f"{api_url.rstrip('/')}/repos/{owner}/{name}"
+    try:
+        response = http.get(
+            url,
+            headers={
+                "Authorization": f"Bearer {token}",
+                "Accept": "application/vnd.github+json",
+                "X-GitHub-Api-Version": "2022-11-28",
+            },
+        )
+    except httpx2.HTTPError as exc:
+        raise GitHubAppError(f"Could not reach {url}: {exc}") from exc
+    finally:
+        if owns:
+            http.close()
+
+    if response.status_code != _HTTP_OK:
+        raise GitHubAppError(
+            f"GitHub would not describe {owner}/{name} "
+            f"(HTTP {response.status_code}): {response.text[:_ERROR_BODY_LIMIT]}"
+        )
+
+    try:
+        private = response.json()["private"]
+    except (ValueError, KeyError, TypeError) as exc:
+        raise GitHubAppError(
+            f"GitHub returned no `private` field describing {owner}/{name}"
+        ) from exc
+    if not isinstance(private, bool):
+        raise GitHubAppError(
+            f"GitHub returned a non-boolean `private` field for {owner}/{name}: "
+            f"{private!r}"
+        )
+    return private
+
+
 # Exit codes, which the entrypoint branches on — see docker/witan-ci-index.sh.
 EXIT_OK = 0
 EXIT_ERROR = 1
@@ -268,28 +414,43 @@ EXIT_NOT_CONFIGURED = 2
 
 
 def main(argv: list[str] | None = None) -> int:
-    """``python -m witan_code.github_app [--check]``.
+    """``python -m witan_code.github_app [--check | --visibility <repo-uri>]``.
 
     Default: print a fresh installation token on stdout. ``--check`` resolves
     the configuration and prints nothing, so a caller can decide once whether
     to take the authenticated path without minting a token it will not use.
+    ``--visibility`` prints ``public`` or ``private`` for one repo, which is
+    what the entrypoint's private-repo refusal is built on.
 
     Exits ``EXIT_NOT_CONFIGURED`` when no App is configured — distinct from
     ``EXIT_ERROR`` because "this deployment has only public repos" and
     "the credentials are broken" call for opposite responses from the caller.
+    ``--visibility`` shares that exit code for the same reason it shares the
+    credential: with no App there is no private repo to refuse, because there
+    is nothing that could have cloned one.
     """
     argv = sys.argv[1:] if argv is None else argv
     check_only = argv == ["--check"]
-    if argv and not check_only:
-        print(f"usage: python -m {_MODULE} [--check]", file=sys.stderr)
+    visibility_of = argv[1] if len(argv) == 2 and argv[0] == "--visibility" else None
+    if argv and not check_only and visibility_of is None:
+        print(
+            f"usage: python -m {_MODULE} [--check | --visibility <repo-uri>]",
+            file=sys.stderr,
+        )
         return EXIT_ERROR
 
     try:
         credentials = from_env()
         if credentials is None:
             return EXIT_NOT_CONFIGURED
-        if not check_only:
-            api_url = os.environ.get(API_URL_ENV_VAR) or GITHUB_API_URL
+        api_url = os.environ.get(API_URL_ENV_VAR) or GITHUB_API_URL
+        if visibility_of is not None:
+            token = os.environ.get(GH_TOKEN_ENV_VAR) or installation_token(
+                credentials, api_url=api_url
+            )
+            private = repo_is_private(visibility_of, token, api_url=api_url)
+            print("private" if private else "public")
+        elif not check_only:
             print(installation_token(credentials, api_url=api_url))
     except GitHubAppError as exc:
         # Logged rather than printed: this runs inside the CI indexer CronJob,

{witan_code-0.16.0 → witan_code-0.17.0}/witan_code/server.py

@@ -74,8 +74,8 @@ mcp.add_middleware(elicit.MRTRElicitationMiddleware())
 
 # The `io.modelcontextprotocol/tasks` extension (SEP-2663), which lets a client
 # take a handle on a long `code_reindex` and poll it instead of holding a tool
-# call open for minutes. Optional (`witan-code[tasks]`): it exists only for
-# fastmcp 4.x, and this package still supports the 3.4.x end of its pin. The
+# call open for minutes. Optional (`witan-code[tasks]`): it pulls a Docket/Redis
+# stack that the default in-process `memory://` backend does not need. The
 # flag has to gate the tool declaration too — a `task=True` tool refuses to
 # serve at all when the extension is missing, rather than degrading.
 #