jt-mcp 0.2.0__tar.gz

jt_mcp-0.2.0/.github/dependabot.yml

@@ -0,0 +1,37 @@
+# Dependabot: security updates only, grouped into one pull request.
+#
+# WHY THIS FILE EXISTS (2026-10-25). There was no dependabot.yml in any of the 22
+# servers. Without one Dependabot runs *security* updates only -- those need no
+# config -- and they are ungrouped by default: one advisory x one package x one
+# repository = one pull request. Four upgrades produced **57 open pull requests**
+# across the fleet, and KI7MT's objection was the right one: nobody could say
+# what 57 pull requests did. Measured, they were four dependency upgrades closing
+# 130 alerts, one of them CRITICAL. The volume was not noise, it was signal
+# nobody could read.
+#
+# `groups` with `applies-to: security-updates` collapses that to one pull request
+# per repository.
+#
+# open-pull-requests-limit: 0 disables *version* updates, which we do not want --
+# ci.yml audits the locked dependencies on every pull request and weekly, so a
+# stale lock already fails CI and does not need a bot to notice. Security updates
+# are unaffected by this limit: they have their own fixed limit of 10, which
+# cannot be configured. Checked against the Dependabot options reference rather
+# than assumed, because setting this wrong would silently switch off the thing
+# that found those 130 alerts.
+#
+# `uv` is the ecosystem for a uv.lock project, also checked against that
+# reference and not inferred from the file name.
+version: 2
+updates:
+  - package-ecosystem: "uv"
+    directory: "/"
+    schedule:
+      interval: "weekly"
+      day: "monday"
+    open-pull-requests-limit: 0
+    groups:
+      security:
+        applies-to: security-updates
+        patterns:
+          - "*"

jt_mcp-0.2.0/.github/workflows/ci.yml

@@ -0,0 +1,154 @@
+name: CI
+
+# A pull request is tested whatever it targets, and deliberately has no branch
+# filter. `main` is the one long-lived branch now, so `push` names it; but a filter
+# here would mean a pull request into any other branch ran no ruff, no mypy and no
+# pytest while still reporting green. That is not hypothetical: narrowing this to
+# [main] is what let the pull request making this very change merge with CodeQL as
+# its only check.
+on:
+  pull_request:
+  push:
+    branches: [main]
+  # Weekly, because an advisory is published against a lockfile that has not
+  # changed. Nothing in a pull-request-and-push trigger fires when the danger
+  # arrives from outside the repository -- see the audit job below.
+  schedule:
+    - cron: "17 6 * * 1"
+
+concurrency:
+  group: ci-${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+permissions:
+  contents: read
+
+jobs:
+  # Lint and types, once rather than per Python: both read the source, and
+  # neither answer changes with the interpreter running them (qso-graph-devel#66).
+  lint:
+    name: ruff and mypy
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v5
+
+      - uses: astral-sh/setup-uv@v7
+        with:
+          # Exact patch, not the minor line. Asking for "3.12" lets uv satisfy
+          # it with whatever interpreter the runner already has -- on
+          # ubuntu-latest that is the system /usr/bin/python3.12 at 3.12.3,
+          # twelve releases behind and without the eMudhra CA fix. The same
+          # run downloaded patched 3.11.18 and 3.13.18 only because no system
+          # copy existed to satisfy those. Naming the patch forces the managed,
+          # current build. https://discuss.python.org/t/109576
+          python-version: "3.11.18"
+          enable-cache: true
+
+      - name: Install (locked)
+        run: uv sync --group dev --frozen
+
+      - name: Lint (ruff)
+        run: uv run ruff check .
+
+      - name: Type-check (mypy)
+        run: uv run mypy src
+
+  test:
+    name: pytest (${{ matrix.python-version }})
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.11.18", "3.12.16", "3.13.18"]
+    steps:
+      - uses: actions/checkout@v5
+
+      - uses: astral-sh/setup-uv@v7
+        with:
+          python-version: ${{ matrix.python-version }}
+          enable-cache: true
+
+      - name: Install (locked)
+        run: uv sync --group dev --frozen
+
+      - name: Unit tests
+        run: uv run pytest tests --ignore=tests/test_security.py -v
+
+      - name: Security tests
+        run: uv run pytest tests/test_security.py -v
+
+  # Audits the LOCKED environment, which is a different question from the one
+  # the release gate asks.
+  #
+  # publish.yml runs `pip-audit --strict --desc on .` -- the project's *declared*
+  # dependencies, resolved fresh. That protects the people who `pip install` this
+  # package, because the ranges we publish must not resolve to something
+  # vulnerable. It cannot see uv.lock at all: `certifi` is declared unpinned, so a
+  # fresh resolve always picks the newest and the locked version is never examined.
+  #
+  # This job syncs `--frozen` and audits what that produced, so a stale lock
+  # cannot sit unnoticed. That is not hypothetical. On 2026-10-25 five
+  # repositories carried certifi 2026.7.22 against a CRITICAL advisory
+  # (GHSA-6q48-6c7w-9gw2, emSign roots with compromised intermediate CA keys) and
+  # **Dependabot had never opened a pull request for any of them** -- alerts on,
+  # security updates on, no pull request, no explanation available over the API.
+  # The release gate could not see it and nothing else was looking.
+  #
+  # Falsified rather than assumed: with certifi pinned back to 2026.7.22 this
+  # reports `certifi 2026.7.22 PYSEC-2026-4320` and exits 1; with the lock
+  # current it reports no known vulnerabilities and exits 0.
+  audit:
+    name: audit (locked dependencies)
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v5
+
+      - uses: astral-sh/setup-uv@v7
+        with:
+          python-version: "3.12.16"
+          enable-cache: true
+
+      - name: Install (locked)
+        run: uv sync --group dev --frozen
+
+      - name: No known vulnerability in the locked dependencies
+        # No --strict, deliberately. --strict fails on any distribution it
+        # could not audit, and `uv sync` installs the project itself -- so the
+        # moment a release bumps the version to one not yet on PyPI, pip-audit
+        # cannot look the project up and --strict turns that into a failure.
+        # It blocked every version bump in all 23 repositories, which is how it
+        # was found: the first real release, dxe-mcp 0.0.3, went red on it with
+        #   "dxe-mcp: Dependency not found on PyPI and could not be audited"
+        # while the lockfile was perfectly clean.
+        #
+        # Without --strict, pip-audit still exits 1 when it FINDS a
+        # vulnerability, which is the whole job. An unauditable local project is
+        # reported as skipped, with its reason, and does not fail the run.
+        #
+        # Verified in both directions against a lock holding certifi 2026.7.22
+        # with the version bumped past PyPI: it reports PYSEC-2026-4320 and
+        # exits 1; with the lock current it reports no vulnerabilities, names the
+        # project as skipped, and exits 0.
+        run: uv run --with pip-audit pip-audit
+
+  ci-all-green:
+    name: ci-all-green
+    needs: [lint, test, audit]
+    runs-on: ubuntu-latest
+    if: always()
+    steps:
+      - name: Verify required jobs all succeeded
+        run: |
+          if [[ "${{ needs.lint.result }}" != "success" ]]; then
+            echo "FAIL: ruff or mypy did not pass (result=${{ needs.lint.result }})"
+            exit 1
+          fi
+          if [[ "${{ needs.test.result }}" != "success" ]]; then
+            echo "FAIL: test matrix did not all succeed (result=${{ needs.test.result }})"
+            exit 1
+          fi
+          if [[ "${{ needs.audit.result }}" != "success" ]]; then
+            echo "FAIL: the locked dependencies have a known vulnerability (result=${{ needs.audit.result }})"
+            exit 1
+          fi
+          echo "All required CI jobs passed."

jt_mcp-0.2.0/.github/workflows/publish.yml

@@ -0,0 +1,449 @@
+name: Publish to PyPI
+
+# A release happens on purpose, not as a side effect of merging (KI7MT, 2026-10-25).
+#
+# This used to fire on a push to `main`, which made "merge the release PR" the act of
+# publishing — and that is what forced two pull requests per release: one to prepare the
+# version, and a second to merge `develop` into `main` and ship it.
+#
+# Now `main` is the one working branch. Merging into it builds and tests and publishes
+# nothing; a release is Actions -> Publish to PyPI -> Run workflow, with the version
+# typed in. Typed, because it is a decision: it must match what the tree already says,
+# and every gate below refuses anything it cannot confirm.
+on:
+  workflow_dispatch:
+    inputs:
+      version:
+        description: "The version to publish, e.g. 0.2.1 — must match pyproject.toml"
+        required: true
+        type: string
+
+concurrency:
+  group: publish
+  cancel-in-progress: false
+
+permissions:
+  contents: read
+
+jobs:
+  security:
+    name: Security gates
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      checks: read
+    outputs:
+      version: ${{ steps.version.outputs.version }}
+      # "yes" when this version is on PyPI with no tag: an interrupted release
+      # being finished rather than a new one being made.
+      resume: ${{ steps.version.outputs.resume }}
+    steps:
+      - uses: actions/checkout@v5
+
+      # workflow_dispatch offers a branch picker, so unlike the old push trigger this
+      # workflow can be started from anywhere. The lock is the pypi Environment's
+      # deployment branch rule (main only); this is the same rule stated where a failed
+      # run can show it, because an Environment rule rejects the deployment with no
+      # explanation of what was wrong.
+      - name: This runs from main
+        run: |
+          if [ "$GITHUB_REF" != "refs/heads/main" ]; then
+            echo "FAIL: a release is published from main only (this is $GITHUB_REF)"
+            exit 1
+          fi
+
+      # Merging no longer publishes, so nothing else guarantees that what is about to
+      # be released is the code CI passed on. Under the old trigger the release PR had
+      # to be green before the merge that published it; this restores that property.
+      - name: CI passed on the commit being published
+        env:
+          GH_TOKEN: ${{ github.token }}
+        run: |
+          PASSED="$(gh api \
+            "repos/${GITHUB_REPOSITORY}/commits/${GITHUB_SHA}/check-runs?check_name=ci-all-green" \
+            --jq '[.check_runs[] | select(.conclusion == "success")] | length')"
+          if [ "${PASSED:-0}" -lt 1 ]; then
+            echo "FAIL: ci-all-green has not passed on ${GITHUB_SHA}"
+            exit 1
+          fi
+          echo "ci-all-green passed on ${GITHUB_SHA}"
+
+      # A release publishes a version that is not out yet. PyPI publishes
+      # pyproject's version and the Registry server.json's, so they must agree too.
+      # Computed once; every later job uses this value (needs.security.outputs.version).
+      # The gate fails closed: anything it cannot confirm stops the release.
+      - name: The version is the one asked for, new, and consistent
+        id: version
+        env:
+          # Through the environment rather than interpolated into the script: a
+          # ${{ }} expansion inside run: is substituted before the shell sees it, so
+          # the input would be script rather than data. Only a writer can dispatch
+          # this, and the rule is still input validation on every supplied string.
+          ASKED: ${{ inputs.version }}
+        run: |
+          VERSION="$(grep -m1 '^version' pyproject.toml | cut -d'"' -f2)"
+          if ! printf '%s' "$ASKED" | grep -Eq '^[0-9]+\.[0-9]+\.[0-9]+([a-z0-9.-]*)$'; then
+            echo "FAIL: '$ASKED' is not a version"
+            exit 1
+          fi
+          # Typed by the person releasing, so a slip names a version that is not here
+          # rather than shipping whatever happens to be on main.
+          if [ "$ASKED" != "$VERSION" ]; then
+            echo "FAIL: asked to publish ${ASKED}, but this tree is ${VERSION}"
+            exit 1
+          fi
+          PACKAGE="$(jq -r '.packages[0].identifier' server.json)"
+          echo "pyproject=${VERSION} server.json=$(jq -r '.version' server.json)/$(jq -r '.packages[0].version' server.json)"
+          if [ "$(jq -r '.version' server.json)" != "$VERSION" ] || [ "$(jq -r '.packages[0].version' server.json)" != "$VERSION" ]; then
+            echo "FAIL: server.json does not match pyproject.toml version ${VERSION}"
+            exit 1
+          fi
+          # Only a 404 means "not published yet"; unreachable or 5xx is not a yes.
+          # PyPI and the tag are read together, because neither alone says
+          # whether this version is releasable.
+          #
+          # This gate used to refuse on PyPI 200 full stop, and that made every
+          # interruption after the upload cost a version. The tag is written by
+          # the last job, so a transient failure in between -- the MCP Registry
+          # 504s on 2026-10-26, nine bytes served for the mcp-publisher
+          # download on 2026-10-27 -- left the version on PyPI, which is
+          # immutable, with no tag and no registry entry. The only recovery was
+          # to bump and release again, abandoning the version. Three releases
+          # went that way.
+          #
+          # So the four states are named, and only two of them refuse:
+          #
+          #   PyPI 404, no tag   a new release
+          #   PyPI 200, no tag   a release that was interrupted after the
+          #                      upload. RESUMABLE: the upload is skipped and
+          #                      the remaining jobs finish the release
+          #   PyPI 200, tagged   already released
+          #   PyPI 404, tagged   a tag with nothing behind it; something is
+          #                      wrong and guessing is worse than stopping
+          CODE="$(curl -s -o /dev/null -w '%{http_code}' "https://pypi.org/pypi/${PACKAGE}/${VERSION}/json")"
+          case "$CODE" in
+            404|200) : ;;
+            *) echo "FAIL: PyPI returned ${CODE}; cannot tell whether ${VERSION} is published"; exit 1 ;;
+          esac
+          # git ls-remote --exit-code: 2 means no such tag; anything else (0, 128) stops.
+          set +e
+          git ls-remote --exit-code --tags origin "refs/tags/v${VERSION}" > /dev/null
+          RC=$?
+          set -e
+          case "$RC" in
+            0) TAGGED=yes ;;
+            2) TAGGED=no ;;
+            *) echo "FAIL: could not check tags (git ls-remote exited ${RC})"; exit 1 ;;
+          esac
+
+          RESUME=false
+          if [ "$CODE" = 404 ] && [ "$TAGGED" = no ]; then
+            echo "PyPI: ${PACKAGE} ${VERSION} is new, tag v${VERSION} is free"
+          elif [ "$CODE" = 200 ] && [ "$TAGGED" = no ]; then
+            RESUME=true
+            echo "NOTE: ${PACKAGE} ${VERSION} is already on PyPI with no tag v${VERSION}."
+            echo "      A previous run uploaded it and did not finish. Resuming:"
+            echo "      the PyPI upload is skipped and the registry, verify and"
+            echo "      tag jobs will complete this release."
+          elif [ "$CODE" = 200 ] && [ "$TAGGED" = yes ]; then
+            echo "FAIL: ${PACKAGE} ${VERSION} is on PyPI and tagged v${VERSION} — already released."
+            echo "      Bump the version to release again."
+            exit 1
+          else
+            echo "FAIL: tag v${VERSION} exists but PyPI has no ${VERSION}."
+            echo "      That is not a state this workflow created; stopping rather than guessing."
+            exit 1
+          fi
+          echo "version=${VERSION}" >> "$GITHUB_OUTPUT"
+          echo "resume=${RESUME}" >> "$GITHUB_OUTPUT"
+
+
+
+      - uses: actions/setup-python@v6
+        with:
+          python-version: "3.12.16"
+
+      - name: Install test dependencies
+        run: |
+          # pip loads its OWN vendored certifi in addition to the system
+          # trust store, and there is no supported way to disable that, so a
+          # current certifi in uv.lock does not cover pip itself. 26.2.2 is
+          # the eMudhra fix. https://discuss.python.org/t/109576
+          python -m pip install --upgrade 'pip>=26.2.2'
+          python -m pip --version   # in the log, not assumed
+          pip install pytest pip-audit
+
+      - name: Run security test suite
+        run: python -m pytest tests/test_security.py -v
+
+      - name: Audit dependencies for vulnerabilities
+        # Audits this package's declared dependencies, and can fail: a known CVE stops the release.
+        # A finding with no fix yet is excepted only explicitly: --ignore-vuln ID, with a reason and date.
+        run: pip-audit --strict --desc on .
+
+      - name: Grep check — no subprocess/shell
+        run: |
+          if grep -rn 'subprocess\.\|os\.system\|shell=True' src/; then
+            echo "FAIL: subprocess/shell found in source"
+            exit 1
+          fi
+
+      - name: Grep check — no plaintext http://
+        run: |
+          # Tests the output rather than the pipeline's exit status, because the
+          # output is what this gate is actually asking about: are there any
+          # plaintext URLs. An exit status answers a different question and
+          # answers it through whichever grep is on PATH.
+          #
+          # The earlier comment here blamed macOS /usr/bin/grep for exiting 0 on
+          # empty input. Measured 2026-10-25, that is false: /usr/bin/grep exits
+          # 1 when no line is selected, as POSIX requires and as GNU grep does.
+          # The FAIL-on-a-clean-tree that prompted this form came from a
+          # non-conforming grep shim in an agent's shell. The form is kept
+          # because it is right for its own reason, not for that one.
+          hits="$(grep -rn 'http://' src/ | grep -v 'localhost\|127\.0\.0\.1\|::1' || true)"
+          if [ -n "$hits" ]; then
+            echo "$hits"
+            echo "FAIL: non-HTTPS URL found in source"
+            exit 1
+          fi
+
+      - name: Grep check — no credential logging
+        run: |
+          if grep -rn -i 'print.*password\|print.*api_key\|logging.*password\|logging.*api_key' src/; then
+            echo "FAIL: credential logging found in source"
+            exit 1
+          fi
+
+  publish:
+    name: Build and publish to PyPI
+    needs: security
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      id-token: write  # Required for trusted publishing (OIDC)
+    steps:
+      - uses: actions/checkout@v5
+
+      - uses: actions/setup-python@v6
+        with:
+          python-version: "3.12.16"
+
+      - name: Install build dependencies
+        if: needs.security.outputs.resume != 'true'
+        run: pip install build
+
+      - name: Build package
+        if: needs.security.outputs.resume != 'true'
+        run: python -m build
+
+      - name: Publish to PyPI
+        if: needs.security.outputs.resume != 'true'
+        uses: pypa/gh-action-pypi-publish@release/v1
+
+      - name: Already on PyPI — resuming
+        if: needs.security.outputs.resume == 'true'
+        run: |
+          # The upload happened in an earlier run that did not finish. PyPI
+          # rejects a second upload of the same version anyway, so skipping it
+          # is required rather than merely tidy. The jobs after this one are
+          # what the resume is for.
+          echo "skipped the upload: this version is already on PyPI"
+
+  # ---------------------------------------------------------------------------
+  # Registry-publish — pushes server.json to the Official MCP Registry after
+  # PyPI publish succeeds, so discovery surfaces stay in sync with PyPI.
+  # Canonical template: https://github.com/qso-graph/.github/blob/main/TEMPLATES.md
+  # ---------------------------------------------------------------------------
+  registry-publish:
+    name: Publish to MCP Registry
+    needs: [security, publish]  # waits for PyPI publish to succeed
+    runs-on: ubuntu-latest
+    permissions:
+      id-token: write   # GitHub OIDC
+      contents: read
+
+    steps:
+      - uses: actions/checkout@v5
+
+      - name: Install jq (server.json bump)
+        run: sudo apt-get update && sudo apt-get install -y jq
+
+      - name: Install mcp-publisher
+        run: |
+          # Downloaded to a file, not piped into tar, and with --fail.
+          #
+          # A bare `curl -L | tar xz` cannot fail usefully: curl writes the
+          # error body to stdout, so a 404 becomes nine bytes of "Not Found"
+          # fed to tar, which exits 2 with "not in gzip format" and says
+          # nothing about what actually went wrong. That is what happened on
+          # 2026-10-27 at 14:45:53Z -- the asset existed and the URL was right;
+          # GitHub served nine bytes for one request. --retry turns that into a
+          # retry instead of a failed release.
+          URL="https://github.com/modelcontextprotocol/registry/releases/latest/download/mcp-publisher_$(uname -s | tr '[:upper:]' '[:lower:]')_$(uname -m | sed 's/x86_64/amd64/;s/aarch64/arm64/').tar.gz"
+          curl --fail --location --retry 5 --retry-all-errors --retry-delay 3 \
+               --output mcp-publisher.tar.gz "$URL"
+          tar xzf mcp-publisher.tar.gz mcp-publisher
+          ./mcp-publisher --help > /dev/null  # smoke test
+
+      - name: Set server.json to the released version
+        run: |
+          VERSION="${{ needs.security.outputs.version }}"
+          echo "Setting server.json to ${VERSION}"
+          jq --arg v "$VERSION" \
+             '.version = $v | .packages[0].version = $v' \
+             server.json > /tmp/server.json
+          mv /tmp/server.json server.json
+          cat server.json
+
+      # The Registry checks PyPI itself and refuses a version PyPI isn't
+      # serving yet, which can lag the upload by a minute or more.
+      - name: Wait until PyPI serves this version
+        run: |
+          VERSION="${{ needs.security.outputs.version }}"
+          PACKAGE="$(jq -r '.packages[0].identifier' server.json)"
+          for i in $(seq 1 40); do
+            if curl -fsS "https://pypi.org/pypi/${PACKAGE}/${VERSION}/json" > /dev/null; then
+              echo "PyPI serves ${PACKAGE} ${VERSION}"
+              exit 0
+            fi
+            echo "attempt ${i}: PyPI doesn't serve ${PACKAGE} ${VERSION} yet"
+            sleep 15
+          done
+          echo "FAIL: PyPI never served ${PACKAGE} ${VERSION}"
+          exit 1
+
+      # One step, because authentication has to happen INSIDE the retry loop.
+      #
+      # The Registry JWT lives about six minutes. This loop sleeps 30+60+90+120+150
+      # seconds and each attempt can take another minute, so it is built to run for
+      # roughly twelve. pota-mcp 0.5.0 on 2026-10-26 spent its last two attempts on
+      # a dead credential:
+      #   17:48:52  login
+      #   17:49:53  attempt 1  504   <- the Registry was genuinely down
+      #   17:51:28  attempt 2  504
+      #   17:53:29  attempt 3  504
+      #   17:54:59  attempt 4  401 "token has invalid claims: token is expired"
+      #   17:57:00  attempt 5  401
+      # PyPI had already accepted the upload, so the run failed after publishing,
+      # the tag job never ran, and 0.5.0 is on PyPI untagged and unregistered for
+      # good -- PyPI is immutable. The outage was theirs; not surviving it was ours.
+      - name: Authenticate and publish to the MCP Registry
+        run: |
+          VERSION="${{ needs.security.outputs.version }}"
+          NAME="$(jq -r '.name' server.json)"
+          REGISTRY="https://registry.modelcontextprotocol.io/v0/servers?search=${NAME}&version=latest"
+          for i in 1 2 3 4 5; do
+            # Fresh token per attempt. A login failure is not fatal on its own:
+            # if the Registry is down it will fail here too, and the next attempt
+            # after the backoff is the one that matters.
+            ./mcp-publisher login github-oidc || echo "login attempt ${i} failed"
+            if ./mcp-publisher publish; then
+              exit 0
+            fi
+            echo "attempt ${i} failed; retrying in $((i * 30)) s"
+            sleep $((i * 30))
+            REG="$(curl -fsS "$REGISTRY" | jq -r --arg n "$NAME" '[.servers[] | select(.server.name == $n) | .server.version][0] // empty' || true)"
+            if [ "$REG" = "$VERSION" ]; then
+              echo "The Registry already has ${NAME} ${VERSION}; an earlier attempt landed"
+              exit 0
+            fi
+          done
+          echo "FAIL: the MCP Registry refused the publish 5 times"
+          exit 1
+
+  # ---------------------------------------------------------------------------
+  # Verify — a release is complete only when PyPI AND the MCP Registry both
+  # serve the tagged version. If either doesn't within 10 minutes, this run
+  # fails: a green run means published everywhere, a red one means not done.
+  # ---------------------------------------------------------------------------
+  verify:
+    name: Verify PyPI and MCP Registry
+    needs: [security, registry-publish]
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v5
+
+      - name: PyPI and Registry serve the released version
+        run: |
+          VERSION="${{ needs.security.outputs.version }}"
+          PACKAGE="$(jq -r '.packages[0].identifier' server.json)"
+          NAME="$(jq -r '.name' server.json)"
+          REGISTRY="https://registry.modelcontextprotocol.io/v0/servers?search=${NAME}&version=latest"
+          for i in $(seq 1 40); do
+            PYPI="$(curl -fsS "https://pypi.org/pypi/${PACKAGE}/json" | jq -r '.info.version' || true)"
+            REG="$(curl -fsS "$REGISTRY" | jq -r --arg n "$NAME" '[.servers[] | select(.server.name == $n) | .server.version][0] // empty' || true)"
+            echo "attempt ${i}: PyPI=${PYPI:-none} Registry=${REG:-none} want=${VERSION}"
+            if [ "$PYPI" = "$VERSION" ] && [ "$REG" = "$VERSION" ]; then
+              echo "Published everywhere: ${PACKAGE} ${VERSION} on PyPI and ${NAME} ${VERSION} in the MCP Registry"
+              exit 0
+            fi
+            sleep 15
+          done
+          echo "FAIL: release incomplete. PyPI=${PYPI:-none} Registry=${REG:-none}, expected ${VERSION}"
+          exit 1
+
+  # ---------------------------------------------------------------------------
+  # Tag the release, once it is published everywhere. The tag marks the commit on
+  # main that was released; nothing is triggered by it. If this job fails after a
+  # green verify, the release IS published: re-running this job is safe.
+  # ---------------------------------------------------------------------------
+  tag:
+    name: Tag the release
+    needs: [security, verify]
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+    steps:
+      - uses: actions/checkout@v5
+
+      - name: Create and push vX.Y.Z
+        run: |
+          VERSION="${{ needs.security.outputs.version }}"
+          git config user.name "github-actions[bot]"
+          git config user.email "41898282+github-actions[bot]@users.noreply.github.com"
+          git tag -a "v${VERSION}" -m "${GITHUB_REPOSITORY#*/} ${VERSION}" "$GITHUB_SHA"
+          git push origin "v${VERSION}"
+
+      # The tag alone left every Releases page in this org empty. The body is
+      # this version's own CHANGELOG section, extracted by heading rather than
+      # by line count, because the fleet has three heading styles:
+      #   ## [0.4.0] — date    ## [2.0.0] - date    ## 0.2.0 (date)
+      # It stops at the next "## " heading, and returns nothing for a version
+      # it cannot find -- so a missing section falls back to GitHub's own
+      # generated notes rather than publishing the whole changelog.
+      #
+      # After `verify` by construction: a Release only ever describes a version
+      # already confirmed on PyPI and the MCP Registry.
+      - name: Create the GitHub Release
+        env:
+          GH_TOKEN: ${{ github.token }}
+        run: |
+          VERSION="${{ needs.security.outputs.version }}"
+          python3 - "$VERSION" CHANGELOG.md > /tmp/notes.md <<'EXTRACT'
+          import re, sys, pathlib
+          ver, path = sys.argv[1], sys.argv[2]
+          text = pathlib.Path(path).read_text()
+          start = re.search(r'(?m)^##\s+\[?%s\]?\b.*$' % re.escape(ver), text)
+          if not start:
+              raise SystemExit(0)
+          rest = text[start.end():]
+          nxt = re.search(r'(?m)^##\s', rest)
+          print((rest[:nxt.start()] if nxt else rest).strip())
+          EXTRACT
+
+          # A version with a suffix (0.2.1rc1) is a pre-release, not Latest.
+          PRE=""
+          case "$VERSION" in
+            *[!0-9.]*) PRE="--prerelease" ;;
+          esac
+
+          if [ -s /tmp/notes.md ]; then
+            echo "release notes: this version's CHANGELOG section ($(wc -l < /tmp/notes.md) lines)"
+            gh release create "v${VERSION}" --verify-tag --title "v${VERSION}" \
+              --notes-file /tmp/notes.md $PRE
+          else
+            echo "release notes: no CHANGELOG section for ${VERSION}; using generated notes"
+            gh release create "v${VERSION}" --verify-tag --title "v${VERSION}" \
+              --generate-notes $PRE
+          fi

jt_mcp-0.2.0/.gitignore

@@ -0,0 +1,8 @@
+__pycache__/
+*.pyc
+*.egg-info/
+dist/
+build/
+.venv/
+.pytest_cache/
+published/