fix: spawn_test never raises — coerce env/command to str, wrap unexpected errors (#34 )

Closes #34 Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2026-07-12 12:48:03 -04:00
19 changed files with 215 additions and 7541 deletions
@@ -29,148 +29,25 @@ jobs:
        run: ruff format --check .
  test:
-    runs-on: ${{ matrix.os }}
+    runs-on: ubuntu-latest
-    name: Tests (py${{ matrix.python }} / ${{ matrix.os }})
+    name: Tests (py${{ matrix.python }})
    strategy:
      fail-fast: false
      matrix:
-        os: [ubuntu-latest]
+        python: ["3.10", "3.12"]
        python: ["3.10", "3.12", "3.13"]
        include:
          # Windows tests on 3.12 only — the version the release binaries ship
          # with. The self-hosted Windows runner blocks setup-python's install
          # script (PowerShell execution policy), so it uses the host's `py`
          # launcher + venv, same as release.yml.
          - os: windows-latest
            python: "3.12"
    steps:
      - name: Checkout
        uses: actions/checkout@v4
-      - name: Set up Python ${{ matrix.python }} (Linux)
+      - name: Set up Python ${{ matrix.python }}
        if: runner.os == 'Linux'
        uses: actions/setup-python@v5
        with:
          python-version: ${{ matrix.python }}
      - name: Set up Python venv (Windows)
        if: runner.os == 'Windows'
        shell: pwsh
        run: |
          py -${{ matrix.python }} -m venv .venv
          Add-Content -Path $env:GITHUB_PATH -Value "$env:GITHUB_WORKSPACE\.venv\Scripts"
      # bcc_core has no GUI imports, so the test suite needs no PySide6 —
      # keeps CI fast and avoids Qt system-library headaches on the runner.
      # cryptography is for tests/test_checksums.py (release signing helper).
      - name: Install test dependencies
-        run: pip install pytest cryptography
+        run: pip install pytest
      - name: Run tests
        run: python -m pytest -v
  # ── Catalog signature gate (#61) ─────────────────────────────────────────
  #
  # data/catalog.json is a list of command+args entries that BCC writes into
  # the user's Claude config, which Claude then EXECUTES. The catalog is only
  # trusted if it carries a valid Ed25519 signature from the maintainer key.
  #
  # The threat this gate exists for is NOT an outsider pushing to the repo —
  # it is the maintainer merging a friendly-looking PR without really reading
  # it. A contributor can change catalog.json but cannot produce a matching
  # signature, so a blindly-merged PR lands here as a RED BUILD within a
  # minute, instead of quietly riding into the next release.
  #
  # Public-key verification only. No secret is used or needed.
  catalog-signature:
    name: Catalog signature
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-python@v5
        with:
          python-version: "3.12"
      - name: Install dependencies
        run: pip install cryptography
      # 🔴 TRUST ANCHOR — issue #68 finding 4.
      #
      # This step used to do `import bcc_core as c` FROM THE CHECKED-OUT PR
      # BRANCH and verify the catalog against c.CATALOG_PUBKEYS — i.e. it
      # trusted the public key shipped in the very diff it was reviewing. A
      # PR that changed data/catalog.json AND bcc_core.CATALOG_PUBKEYS (to
      # an attacker key, with a matching signature produced by the attacker's
      # matching private key) went green, because there was nothing outside
      # the PR's own content to check the key against. The gate's whole
      # point is catching a friendly-looking PR the maintainer merges
      # without really reading it — and that hole made it a two-file diff.
      #
      # EXPECTED_CATALOG_PUBKEY_B64 below is hardcoded HERE, in the workflow
      # file, independent of whatever bcc_core.py says on the PR branch. It
      # is intentionally the only line in this step that matters for
      # security review: changing it changes what this gate is willing to
      # trust. THIS CONSTANT IS A TRUST ANCHOR. A PR that changes this line
      # in the same diff as a catalog change is exactly the attack this gate
      # exists to prevent — review a change to this line on its own,
      # never bundled with a catalog update.
      #
      # NOTE for the next key rotation: update EXPECTED_CATALOG_PUBKEY_B64
      # below to the new key's base64 form, as its own reviewed change.
      - name: Verify data/catalog.json.sig
        env:
          EXPECTED_CATALOG_PUBKEY_B64: "0s24PmkZcTT5yxNDdyTPHl5fyxArrHNPJKBjnXoQd8k="
        run: |
          python - <<'PY'
          import base64, os, pathlib, sys
          import bcc_core as c
          expected_pubkey_b64 = os.environ["EXPECTED_CATALOG_PUBKEY_B64"]
          raw = pathlib.Path("data/catalog.json").read_bytes()
          sig_path = pathlib.Path("data/catalog.json.sig")
          if not sig_path.exists():
              sys.exit("FAIL: data/catalog.json.sig is missing. The catalog must be "
                       "signed via the Catalog Console (#62) before it can land.")
          if b"\x00" * 32 in c.CATALOG_PUBKEYS:
              sys.exit("FAIL: CATALOG_PUBKEYS still holds the placeholder key.")
          # Trust anchor check FIRST, before verifying anything against
          # bcc_core.CATALOG_PUBKEYS: a PR is not allowed to bring its own
          # key. CATALOG_PUBKEYS on the checked-out branch must be EXACTLY
          # the key(s) this workflow file itself expects -- no more, no
          # fewer, no substitutions.
          actual_pubkeys_b64 = [base64.b64encode(k).decode() for k in c.CATALOG_PUBKEYS]
          if actual_pubkeys_b64 != [expected_pubkey_b64]:
              sys.exit(
                  "FAIL: bcc_core.CATALOG_PUBKEYS on this branch does not match the "
                  "trust anchor hardcoded in .github/workflows/ci.yml.\n"
                  f"  expected: {[expected_pubkey_b64]}\n"
                  f"  actual:   {actual_pubkeys_b64}\n"
                  "\n"
                  "This PR is changing (or has changed) the catalog signing key. That "
                  "change must be reviewed on its own, separately from any catalog "
                  "content change, and the workflow's EXPECTED_CATALOG_PUBKEY_B64 "
                  "updated deliberately -- not accepted because it happened to match "
                  "whatever bcc_core.py says on this branch."
              )
          if not c.verify_catalog_signature(raw, sig_path.read_bytes(), c.CATALOG_PUBKEYS):
              sys.exit(
                  "FAIL: data/catalog.json does NOT match its signature.\n"
                  "\n"
                  "The catalog changed without being re-signed. Either someone edited\n"
                  "it directly (a PR you merged?), or a signing pass was forgotten.\n"
                  "Re-review and re-sign with the Catalog Console — do not bypass this."
              )
          problems = c.validate_catalog(c.load_catalog(raw))
          if problems:
              sys.exit("FAIL: catalog failed validation:\n  " + "\n  ".join(problems))
          print("OK: catalog signature verifies, the pubkey matches the CI trust anchor, "
                "and the catalog validates clean.")
          PY
@@ -95,92 +95,6 @@ jobs:
          name: ${{ matrix.artifact }}
          path: ${{ matrix.artifact }}
  # ── Signing-key smoke test (workflow_dispatch only) ─────────────────────
  #
  # The Publish job is gated on a tag, so a manual run never exercises the
  # signing step — which means a wrong/missing RELEASE_SIGNING_KEY secret
  # would only be discovered at the worst possible moment: during a real
  # release. This job signs a throwaway manifest with the secret and verifies
  # the result against scripts/sign_checksums.RELEASE_PUBKEYS.
  #
  # IMPORTANT (issue #68 finding 5): this must verify against the RELEASE
  # public key, never bcc_core.CATALOG_PUBKEYS. The catalog key is the
  # offline, maintainer-held root of trust for what BCC executes; it must
  # NEVER be compared against a value that lives in a CI secret, because
  # that comparison is itself a way to smuggle a catalog-trusted key through
  # CI review ("does this repo secret match the catalog key" is a question
  # this workflow must never even ask). The release key is a SEPARATE
  # keypair, generated via `catalog_console.py keygen --release`, that only
  # ever signs release SHA256SUMS manifests -- a CI/secret compromise burns
  # this key, not the catalog key.
  #
  # It proves the two halves of the RELEASE keypair actually match, without
  # publishing anything. Run it from the Actions tab after setting or
  # rotating the secret.
  signing-smoke-test:
    name: Signing key smoke test
    runs-on: ubuntu-latest
    if: github.event_name == 'workflow_dispatch'
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-python@v5
        with:
          python-version: "3.12"
      - name: Install dependencies
        run: pip install cryptography
      - name: Sign a throwaway manifest and verify against the RELEASE pubkey
        env:
          RELEASE_SIGNING_KEY: ${{ secrets.RELEASE_SIGNING_KEY }}
        run: |
          if [ -z "$RELEASE_SIGNING_KEY" ]; then
            echo "FAIL: RELEASE_SIGNING_KEY secret is not set."
            echo "Generate the RELEASE key (NOT the catalog key) with:"
            echo "    python catalog_console.py keygen --release"
            echo "then add its seed under Settings -> Actions -> Secrets, via:"
            echo "    python catalog_console.py show-seed-b64 --release"
            exit 1
          fi
          mkdir -p smoke && echo "smoke test payload" > smoke/hello.txt
          python3 scripts/sign_checksums.py generate smoke --out smoke/SHA256SUMS
          python3 scripts/sign_checksums.py sign --sums smoke/SHA256SUMS --out smoke/SHA256SUMS.sig
          python - <<'PY'
          import pathlib, sys
          from scripts.sign_checksums import RELEASE_PUBKEYS, verify_checksums_against_any
          # Deliberately does NOT import bcc_core / CATALOG_PUBKEYS at all --
          # this smoke test must never be able to compare the CI secret
          # against the catalog's root of trust (issue #68 finding 5). Only
          # RELEASE_PUBKEYS (scripts/sign_checksums.py) is a legitimate
          # target for a CI-resident key.
          if not RELEASE_PUBKEYS:
              sys.exit(
                  "FAIL: scripts/sign_checksums.RELEASE_PUBKEYS is empty.\n"
                  "\n"
                  "Generate the release keypair with:\n"
                  "    python catalog_console.py keygen --release\n"
                  "then paste the printed public key into RELEASE_PUBKEYS in\n"
                  "scripts/sign_checksums.py and commit that change."
              )
          sums = pathlib.Path("smoke/SHA256SUMS").read_text()
          sig = pathlib.Path("smoke/SHA256SUMS.sig").read_bytes()
          if not verify_checksums_against_any(RELEASE_PUBKEYS, sums, sig):
              sys.exit(
                  "FAIL: the signature produced by RELEASE_SIGNING_KEY does NOT verify\n"
                  "against any key in scripts/sign_checksums.RELEASE_PUBKEYS.\n"
                  "\n"
                  "The secret and the shipped release public key are different keypairs.\n"
                  "Downloaders would reject every signature this CI produces. Re-copy the\n"
                  "seed from `catalog_console.py show-seed-b64 --release`, or update\n"
                  "RELEASE_PUBKEYS with the matching public key."
              )
          print("OK: RELEASE_SIGNING_KEY matches a key in RELEASE_PUBKEYS.")
          PY
  # ── Create GitHub Release with all three artifacts ──────────────────────
  release:
@@ -193,76 +107,11 @@ jobs:
      contents: write
    steps:
      # Needed for scripts/sign_checksums.py — the release job otherwise
      # only downloads build artifacts, it doesn't check out the repo.
      - name: Checkout
        uses: actions/checkout@v4
      - name: Download all artifacts
        uses: actions/download-artifact@v3
        with:
          path: artifacts
      - name: Set up Python 3.12
        uses: actions/setup-python@v5
        with:
          python-version: "3.12"
      # download-artifact@v3 nests each artifact under a directory named
      # after it (artifacts/<name>/<name>). Flatten into one directory so
      # SHA256SUMS lists plain filenames, matching what `sha256sum -c`
      # expects when run from inside an extracted release download.
      - name: Collect release files
        run: |
          mkdir -p release-files
          find artifacts -type f -exec cp {} release-files/ \;
          ls -la release-files
      - name: Generate SHA256SUMS
        run: python3 scripts/sign_checksums.py generate release-files --out release-files/SHA256SUMS
      # ── Sign the checksum manifest (best-effort) ──────────────────────
      #
      # BCC binaries are not code-signed (no budget for a paid cert). This
      # is the free half: a checksum manifest, detached-signed with
      # Ed25519, so a tampered download is detectable by anyone who
      # checks. It does NOT remove Gatekeeper/SmartScreen warnings.
      #
      # The private key is a repo secret (RELEASE_SIGNING_KEY, base64 raw
      # Ed25519 seed) for the RELEASE key -- a SEPARATE keypair from the
      # catalog key, generated via `python catalog_console.py keygen
      # --release` (issue #68 finding 5; #62). This key is intentionally
      # CI-resident and signs ONLY this checksum manifest; it is never
      # trusted to sign data/catalog.json. If it's not set, we still
      # publish the release — just without a .sig — rather than fail the
      # release outright.
      - name: Check for signing key
        id: signing
        run: |
          if [ -n "${{ secrets.RELEASE_SIGNING_KEY }}" ]; then
            echo "has_key=true" >> "$GITHUB_OUTPUT"
          else
            echo "has_key=false" >> "$GITHUB_OUTPUT"
          fi
      - name: Install signing dependencies
        if: steps.signing.outputs.has_key == 'true'
        run: pip install cryptography
      - name: Sign SHA256SUMS
        if: steps.signing.outputs.has_key == 'true'
        env:
          RELEASE_SIGNING_KEY: ${{ secrets.RELEASE_SIGNING_KEY }}
        run: |
          python3 scripts/sign_checksums.py sign \
            --sums release-files/SHA256SUMS \
            --out release-files/SHA256SUMS.sig
      - name: Warn — release will be unsigned
        if: steps.signing.outputs.has_key != 'true'
        run: |
          echo "::warning::RELEASE_SIGNING_KEY secret is not set — this release is being published WITHOUT a signed SHA256SUMS.sig. Generate the RELEASE key (python catalog_console.py keygen --release) and add its seed (python catalog_console.py show-seed-b64 --release) as this secret before the next tag."
      - name: Create GitHub Release
        uses: softprops/action-gh-release@v2
        with:
@@ -270,9 +119,7 @@ jobs:
          draft: false
          prerelease: false
          generate_release_notes: false
-          files: |
+          files: artifacts/**/*
            artifacts/**/*
            release-files/SHA256SUMS*
          body: |
            ## Better Claude Config ${{ github.ref_name }}
@@ -292,8 +139,5 @@ jobs:
            xattr -cr /Applications/BetterClaudeConfig.app
            ```
            ### Verifying your download
            Every release includes `SHA256SUMS` (and, when the signing key is configured, a detached `SHA256SUMS.sig`). See [Verifying your download](https://git.avezzano.io/the_og/better-claude-config#verifying-your-download) in the README for commands. This proves you got the file we published — it does not remove Gatekeeper/SmartScreen warnings.
            ### Requirements
            No Python installation needed — the app is self-contained.
@@ -19,135 +19,6 @@ Pre-built self-contained binaries are attached to every [GitHub Release](../../r
 > **macOS Gatekeeper note:** the app is not notarized. On first launch, right-click → **Open**, or run `xattr -cr /Applications/BetterClaudeConfig.app` in a terminal.
 ## Verifying your download
 BCC isn't code-signed — there's no budget for a paid certificate (macOS
 Developer ID, Windows Authenticode). Instead, every release publishes a
 `SHA256SUMS` file listing the checksum of each archive, detached-signed with
 Ed25519 as `SHA256SUMS.sig`. Both are attached to the release alongside the
 binaries.
 **What this proves:** the file you downloaded is byte-for-byte what we
 published, and the manifest itself was signed by our release key.
 **What this does NOT do:** it does not make the binary "safe," and it does
 **not** remove the macOS Gatekeeper or Windows SmartScreen warning — those
 are only suppressed by a paid OS-vendor certificate, which this project
 doesn't have. Verifying checksums is about detecting tampering in transit or
 on a mirror, not about vouching for the software.
 This manifest is signed with BCC's **release key**, which is a different
 key from the one that signs the MCP server catalog — see
 [Signing keys](#signing-keys) below for why, and for the public key value
 to use with `--pubkey-b64` below.
 ### macOS / Linux
 ```bash
 # From inside the folder you downloaded the release files into:
 sha256sum -c SHA256SUMS
 ```
 If your `sha256sum` complains about missing files, download `SHA256SUMS`
 into the same directory as the archive you downloaded — it lists every
 platform's archive, and only the one(s) present will be checked.
 To also verify the manifest's signature (optional, requires Python +
 `pip install cryptography` and a checkout of this repo):
 ```bash
 python3 scripts/sign_checksums.py verify \
  --sums SHA256SUMS --sig SHA256SUMS.sig \
  --pubkey-b64 "<the release public key from Signing keys, below>"
 ```
 ### Windows (PowerShell)
 ```powershell
 Get-FileHash .\BetterClaudeConfig-Windows.zip -Algorithm SHA256
 ```
 Compare the printed hash (case-insensitively) against the matching line in
 `SHA256SUMS`.
 ### If a release has no `SHA256SUMS.sig`
 The signing key is a repo secret that has to be configured manually; if a
 release is missing the `.sig` file, the checksums themselves are still
 valid and safe to check against — the release workflow only skips signing,
 never checksum generation.
 ## Signing keys
 BCC uses **two separate Ed25519 keypairs**, deliberately never the same
 key, because they protect different things and live in different places:
 | | Catalog key | Release key |
 |---|---|---|
 | Signs | `data/catalog.json` (the MCP server catalog every user's app trusts) | `SHA256SUMS` (the checksum manifest for release binaries) |
 | Verified by | `bcc_core.CATALOG_PUBKEYS` | `scripts/sign_checksums.RELEASE_PUBKEYS` |
 | Lives | Offline, passphrase-encrypted, maintainer's machine only (OS keychain or an encrypted file outside the repo — see the [Catalog Console](#files), issue #62) | A Gitea Actions repo secret, `RELEASE_SIGNING_KEY` — **intentionally CI-resident** |
 | Generated with | `python catalog_console.py keygen` | `python catalog_console.py keygen --release` |
 | Exported for CI with | *(never — there is no supported way to export this key)* | `python catalog_console.py show-seed-b64 --release` |
 **Confused about which key is which, or what state either is in?** Run:
 ```bash
 python catalog_console.py keys
 ```
 It needs no passphrase (it never touches private key bytes) and prints a
 plain-English report for both keys: where each private half lives, whether
 it's present on this machine, its fingerprint, whether that fingerprint
 matches what's actually committed in `bcc_core.py`, `ci.yml`'s trust
 anchor, and `scripts/sign_checksums.py`, and whether
 `data/catalog.json.sig` currently verifies — ending with the exact command
 to run next for whatever state it finds. This is the check that would have
 caught [issue #68](../../issues/68)'s finding 5 incident before it happened.
 **Why two keys:** the catalog key is the root of trust for what BCC
 actually *executes* on a user's machine — every `command`/`args` pair in
 the shipped catalog is only there because this key signed it. If that key
 and the release-checksum key were the same (as they briefly were — see
 [issue #68](../../issues/68)), then anything that can exfiltrate a Gitea
 Actions secret (a malicious workflow-file PR, a compromised runner, a leaky
 log) could sign a catalog every user's copy of BCC would trust, not just a
 checksum manifest. Splitting them means **a CI/secret compromise burns the
 release key, never the catalog key** — checksums for a future release could
 be forged, which is bad, but no attacker gains the ability to make BCC run
 arbitrary commands on installs that trust the catalog. That asymmetry is
 the entire point of having two keys instead of one.
 The catalog key is **never** meant to leave the maintainer's machine: it's
 generated, stored, unlocked, and used to sign entirely inside the Catalog
 Console (`catalog_console.py`), and `catalog_console.py show-seed-b64`
 refuses to run without `--release` specifically so the catalog seed can't
 be exported by habit or muscle memory.
 **Release signing public key** (Ed25519, base64, raw 32 bytes) — this is
 the RELEASE key, which signs `SHA256SUMS` (release checksums). It does
 **not** sign `data/catalog.json` and is not the key `bcc_core.CATALOG_PUBKEYS`
 trusts:
 ```
 6BnPgJEHJFyVltFoLTCNadIsehjy00iiW8IRlC1TfhA=
 ```
 The catalog public key (Ed25519, base64, raw 32 bytes) — this is the key
 that signs `data/catalog.json` and is trusted via `bcc_core.CATALOG_PUBKEYS`
 and the CI trust anchor in `.github/workflows/ci.yml`. It is listed here
 for completeness, not because you need it to verify a download — use the
 *release* key above for that:
 ```
 0s24PmkZcTT5yxNDdyTPHl5fyxArrHNPJKBjnXoQd8k=
 ```
 Both keys above were rotated 2026-07 — see [issue #68](../../issues/68)
 finding 5. The prior (shared) key is retired and is deliberately **not**
 kept in either trust list; retaining a burned key would defeat the point
 of rotating it.
 ## Run from source
 ```bash
@@ -221,8 +92,6 @@ file is also listed, marked *legacy*, so you can copy them over.
 - `test_core.py` — unit suite for the core (`python test_core.py`).
 - `bcc.spec` — PyInstaller build spec (cross-platform).
 - `scripts/build_icons.py` — regenerates `icons/app.icns` and `icons/app.ico` from source PNGs.
 - `scripts/sign_checksums.py` — generates and Ed25519-signs the release `SHA256SUMS` manifest (see [Verifying your download](#verifying-your-download)).
 - `catalog_console.py` / `catalog_review.py` — **maintainer-only**, never shipped to users (excluded from `bcc.spec`; see `tests/test_catalog_console_packaging.py`). The Catalog Console: review + sign `data/catalog.json` (against `main`, an open PR, or the branch you have checked out — `--ref <branch>` to be explicit, e.g. mid key-rotation, so a rotation can be signed and pushed to its own branch *before* it's merged, never forcing a red `main`), generate/manage both signing keys (`keygen`, `keygen --release`), and report on their status (`keys`, no passphrase needed) — see [Signing keys](#signing-keys).
 ## Building from source
@@ -0,0 +1,112 @@
 # BCC Roadmap — v1.2.0 readiness + what's next (Cowork planning, 2026-07-07)
 Written by the Cowork supervisor session. Captures (1) what's ready for the next
 release, (2) the remaining tracked backlog, and (3) genuinely-missing features
 worth planning. Priorities are suggestions for AJ, not commitments.
 ---
 ## 1. v1.2.0 — ready to ship
 Five feature branches landed as green, isolated, reviewed PRs (all approved by the
 supervisor session; each touches only `bcc.py` / `bcc_core.py` / `tests/test_core.py`
 and passes CI):
 | PR | Issue | Feature | CI |
 |----|-------|---------|----|
 | #25 | #18 + #19 | About dialog (Help menu, repo/issues/license links) + notify-only update checker (`__version__`, numeric version-compare, fail-quiet Gitea releases fetch, throttled once/day startup check) | run 160 ✓ |
 | #24 | #9 | Restart Claude Desktop button (post-save, Desktop-profile-only, platform-abstracted `restart_claude_desktop()`) | run 159 ✓ |
 | #23 | #6 | In-app MCP server log viewer (`server_log_path()`, read-only auto-tailing panel per server) | run 158 ✓ |
 | #22 | #17 | Stale-file detection hardened with size (`ConfigStat` mtime+size fingerprint) | run 157 ✓ |
 | #21 | #8 | Duplicate-name collision fix — closes a real silent-overwrite on drag-and-drop import | run 164 ✓ |
 Combined they take the suite from 92 tests toward ~130+ (each PR adds 3–20 tests).
 ### Merge / release checklist (needs AJ — this is the open decision)
 The five branches all edit overlapping regions of `bcc.py`/`bcc_core.py`, so they
 will **not** merge cleanly in sequence without conflict resolution:
 - **Shared conflict:** #22/#23/#24/#25 each rewrote the one `_normalize_unicode`
  non-breaking-space line (all behavior-identical). Merge one, then take that line
  from any branch for the rest.
 - **Save-flow region:** #21 (import prompt), #22 (stale fingerprint), #24 (restart
  button) all touch the save path in `bcc.py` — review the merged result once.
 - **Version bump:** at cut, set both `__version__` (bcc_core.py) and
  `pyproject.toml` to `1.2.0` and update `test_dunder_version_matches_pyproject`.
 - **Release is tag-triggered:** push a `v1.2.0` tag → `.github/workflows/release.yml`
  builds macOS/Windows/Linux and publishes. Don't hand-create the release.
 Suggested merge order (least- to most-conflict-prone): **#21 → #22 → #23 → #24 → #25**.
 Recommend AJ does the merges + conflict resolution locally (cleaner than the Gitea
 API for overlapping diffs), or greenlights the supervisor to merge sequentially and
 patch conflicts on each branch via the API.
 ---
 ## 2. Remaining tracked backlog (open issues)
 **Windows-specific — deferred (can't build/test in the Linux/mac sandbox):**
 - **#20** Windows release shows no app icon (P?) — build-config fix in `bcc.spec` /
  `release.yml`; needs a Windows build to verify. Low risk, cosmetic.
 - **#7** Windows MSIX virtualized-path detection (P1) — config edits silently ignored
  on MSIX installs. Core path-detection is unit-testable; the runtime behavior needs
  a real MSIX Windows box. Genuinely valuable (silent failure class).
 - **#13** Windows process-tree kill is best-effort (P1) — follow-up refinement to #9;
  hard to verify without Windows.
 **Deferred by design:**
 - **#5** Cross-client support (Cursor `.cursor/mcp.json`, Windsurf
  `~/.codeium/windsurf/mcp_config.json`, VS Code `servers` key) — P1 but a behemoth;
  its own branch, revisit after single-client UX is solid. Not a v1.2 item.
 - **#10** Server catalog / one-click add — P2, design-first. See §3 overlap with search.
 ---
 ## 3. Genuinely-missing features (not yet tracked) — planning candidates
 Grounded against what already exists (enable/disable toggle, duplicate-server,
 `_disabledMcpServers` round-trip, backup/restore, spawn-test, secret masking, JSON
 repair pipeline — all shipped, so not repeated here).
 **P1 candidates**
 1. **Server search / filter box.** Once a user has many servers (and especially once
   #10's catalog lands), there's no way to filter the list. Small, high-utility:
   a `QLineEdit` above the table filtering by name/command. Pure-ish; testable filter
   fn in core.
 2. **"Test all" / health column.** Extends spawn-test (#2) + log viewer (#6): a status
   dot per server (untested / ok / crashed) and a one-click "test all". Turns three
   separate features into an at-a-glance dashboard — the single biggest "is my config
   actually working?" answer.
 3. **Project-level `.mcp.json` discovery (Claude Code).** Claude Code reads project
   `.mcp.json` files; BCC only sees the global config. Detect and offer to edit the
   project file when relevant. Previously listed "not in backlog" — worth reconsidering
   now that Claude Code support is solid.
 **P2 candidates**
 4. **`${VAR}` / `.env` environment-variable expansion.** Previously declined (AJ's
   call). Revisit only if secret-handling demand grows — pairs with keychain below.
 5. **OS keychain integration for secrets.** Previously declined. Bigger lift; would
   let env secrets live outside the JSON entirely. Design-first if pursued.
 6. **Config schema/lint for well-known servers.** Warn on obvious mistakes (missing
   `command`, `args` not a list, unknown top-level keys) beyond the JSON-repair layer.
 7. **Theming / dark-mode follow-through.** Style constants (`MUTED`/`ACCENT`/`GOOD`)
   already exist; a proper light/dark toggle is a polish item.
 **Explicitly out (recorded decisions):** renaming BCC (deferred until cross-client
 actually ships — do not raise before then).
 ---
 ## 4. Suggested next sprint (after v1.2.0 ships)
 1. Merge + release v1.2.0 (decision above).
 2. **#7 MSIX detection** — highest-value untracked-runtime P1; land the testable core
   path-detection now, gate the runtime behavior behind a Windows verification.
 3. **Server search/filter (§3.1)** + **Test-all health column (§3.2)** — small, high
   daily-utility, and they compound with the log viewer/spawn-test already in 1.2.
 4. Design pass on **#10 catalog** and **#5 cross-client** (both need design before code).
@@ -13,17 +13,14 @@ from __future__ import annotations
 import sys
 import time
 from pathlib import Path
 from typing import ClassVar
 from PySide6.QtCore import QRect, QSettings, QSize, Qt, QThread, QTimer, QUrl, Signal
 from PySide6.QtGui import (
    QAction,
    QColor,
    QCursor,
    QDesktopServices,
    QGuiApplication,
    QIcon,
    QKeySequence,
    QPainter,
    QPixmap,
 )
@@ -39,7 +36,6 @@ from PySide6.QtWidgets import (
    QGridLayout,
    QHBoxLayout,
    QHeaderView,
    QInputDialog,
    QLabel,
    QLineEdit,
    QListWidget,
@@ -54,17 +50,12 @@ from PySide6.QtWidgets import (
    QStyledItemDelegate,
    QTableWidget,
    QTableWidgetItem,
    QToolTip,
    QVBoxLayout,
    QWidget,
 )
 import bcc_core as core
 # A full ~/.claude.json with history can be huge; parsing happens on the UI
 # thread during drag-and-drop import, so skip anything larger than this.
 MAX_DROP_IMPORT_BYTES = 5 * 1024 * 1024  # 5 MB
 # --- One-line rebrand: change this to recolor the whole app --------------- #
 ACCENT = "#f97316"  # warm orange
 ACCENT_DIM = "#c2570b"
@@ -129,7 +120,6 @@ QScrollBar:vertical {{ background: transparent; width: 10px; margin: 2px; }}
 QScrollBar::handle:vertical {{ background: {BORDER}; border-radius: 5px; min-height: 24px; }}
 QScrollBar::add-line, QScrollBar::sub-line {{ height: 0; }}
 QLabel#statusbar {{ color: {MUTED}; padding: 4px 2px; }}
 QLabel#warnBanner {{ color: #1a1205; background: {WARN}; border-radius: 8px; padding: 8px 10px; font-weight: 600; }}
 QLabel#section {{ color: {MUTED}; font-weight: 600; font-size: 12px; padding: 2px 2px; }}
 QLabel#sectionDisabled {{ color: {MUTED}; font-weight: 600; font-size: 12px; padding: 2px 2px; }}
 QLabel#placeholder {{ color: {MUTED}; padding: 12px; background: {PANEL_2}; border: 1px dashed {BORDER}; border-radius: 8px; }}
@@ -182,30 +172,10 @@ class UpdateCheckWorker(QThread):
    running binary. Fails quiet — emits None on any network problem — so
    it's safe to fire unattended from a silent startup check as well as from
    the About dialog's "Check for updates" button.
    Lifetime: the class keeps every instance alive in `_live` until its
    thread has finished. Without this, a caller whose own reference dies
    early (the About dialog is a temporary — closing it mid-check used to
    GC the dialog and the running QThread with it) crashes the process with
    "QThread: Destroyed while thread is still running". Callers may drop
    their reference at any time; signal connections to a destroyed receiver
    are disconnected by Qt, so a late result is simply discarded.
    """
    done = Signal(object)  # dict | None
    _live: ClassVar[set[UpdateCheckWorker]] = set()
    def __init__(self):
        super().__init__()
        UpdateCheckWorker._live.add(self)
        self.finished.connect(self._release_keepalive)
    def _release_keepalive(self):
        # Delivered on the main thread after run() has returned; only now is
        # it safe for the last reference to drop.
        UpdateCheckWorker._live.discard(self)
    def run(self):
        self.done.emit(core.fetch_latest_release())
@@ -275,31 +245,10 @@ class KeyValueTable(QWidget):
        self.reveal_btn.setText("Hide secrets" if on else "Show secrets")
        self.table.viewport().update()
-    def _changed(self, item=None, *_):
+    def _changed(self, *_):
        if item is not None and item.column() == 0:
            new_key = item.text().strip()
            row = item.row()
            if new_key and self._is_duplicate_key(new_key, row):
                prev_key = item.data(Qt.ItemDataRole.UserRole)
                prev_key = prev_key if prev_key is not None else ""
                self.table.blockSignals(True)
                item.setText(prev_key)
                self.table.blockSignals(False)
                QToolTip.showText(QCursor.pos(), f"Duplicate key '{new_key}' — reverted.")
                return
            item.setData(Qt.ItemDataRole.UserRole, new_key)
        if self._on_change:
            self._on_change()
    def _is_duplicate_key(self, key: str, ignore_row: int) -> bool:
        for r in range(self.table.rowCount()):
            if r == ignore_row:
                continue
            other = self.table.item(r, 0)
            if other and other.text().strip() == key:
                return True
        return False
    def _add_row(self):
        dlg = QDialog(self.window())
        dlg.setWindowTitle(f"Add {self._key_label}")
@@ -326,13 +275,6 @@ class KeyValueTable(QWidget):
        grid.addWidget(val_edit, 1, 1)
        v.addLayout(grid)
        # Shown when the typed key already exists in the table.
        dup_warn = QLabel("")
        dup_warn.setStyleSheet(f"color: {WARN};")
        dup_warn.setWordWrap(True)
        dup_warn.hide()
        v.addWidget(dup_warn)
        # Type an API_KEY/TOKEN-style name and the value field masks itself.
        def _sync_echo(text):
            secret = core.is_secret_key(text)
@@ -348,15 +290,7 @@ class KeyValueTable(QWidget):
        ok_btn = btns.button(QDialogButtonBox.StandardButton.Ok)
        ok_btn.setObjectName("primary")
        ok_btn.setEnabled(False)
-
+        key_edit.textChanged.connect(lambda t: ok_btn.setEnabled(bool(t.strip())))
        def _validate(text):
            k = text.strip()
            dup = bool(k) and self._is_duplicate_key(k, ignore_row=-1)
            ok_btn.setEnabled(bool(k) and not dup)
            dup_warn.setText(f"'{k}' already exists" if dup else "")
            dup_warn.setVisible(dup)
        key_edit.textChanged.connect(_validate)
        btns.accepted.connect(dlg.accept)
        btns.rejected.connect(dlg.reject)
        v.addWidget(btns)
@@ -370,15 +304,13 @@ class KeyValueTable(QWidget):
            return
        k = key_edit.text().strip()
        val = val_edit.text()
-        if not k or self._is_duplicate_key(k, ignore_row=-1):
+        if not k:
            return
        if self._before_change:
            self._before_change()
        r = self.table.rowCount()
        self.table.insertRow(r)
-        key_item = QTableWidgetItem(k)
+        self.table.setItem(r, 0, QTableWidgetItem(k))
        key_item.setData(Qt.ItemDataRole.UserRole, k)
        self.table.setItem(r, 0, key_item)
        self.table.setItem(r, 1, QTableWidgetItem(val))
        self._changed()
@@ -397,9 +329,7 @@ class KeyValueTable(QWidget):
        for k, v in (d or {}).items():
            r = self.table.rowCount()
            self.table.insertRow(r)
-            key_item = QTableWidgetItem(str(k))
+            self.table.setItem(r, 0, QTableWidgetItem(str(k)))
            key_item.setData(Qt.ItemDataRole.UserRole, str(k))
            self.table.setItem(r, 0, key_item)
            self.table.setItem(r, 1, QTableWidgetItem(str(v)))
        self.table.blockSignals(False)
@@ -1493,17 +1423,6 @@ class AboutDialog(QDialog):
        QDesktopServices.openUrl(QUrl(self._release_url or core.RELEASES_URL))
 # --------------------------------------------------------------------------- #
 # Restart worker: core.restart_claude_desktop() blocks up to ~5 s on macOS
 # waiting for the old instance to exit, so it must run off the UI thread.
 # --------------------------------------------------------------------------- #
 class RestartWorker(QThread):
    done = Signal(object)  # core.RestartResult
    def run(self):
        self.done.emit(core.restart_claude_desktop())
 # --------------------------------------------------------------------------- #
 # Main window
 # --------------------------------------------------------------------------- #
@@ -1541,15 +1460,6 @@ class MainWindow(QMainWindow):
        root.addLayout(self._build_topbar())
        # Persistent warning banner (MSIX-virtualized config, etc.). Lives in
        # its own widget because the status bar is rewritten on every action,
        # which used to wipe the warning before the user could read it.
        self.warn_banner = QLabel("")
        self.warn_banner.setObjectName("warnBanner")
        self.warn_banner.setWordWrap(True)
        self.warn_banner.hide()
        root.addWidget(self.warn_banner)
        # User-draggable divider between the server list and the editor.
        split = QSplitter(Qt.Orientation.Horizontal)
        split.setChildrenCollapsible(False)
@@ -1601,16 +1511,14 @@ class MainWindow(QMainWindow):
        last = float(st.value("update/lastCheck", 0.0, type=float) or 0.0)
        if (time.time() - last) < 86400:  # at most once/day
            return
        st.setValue("update/lastCheck", time.time())
        self._startup_update_worker = UpdateCheckWorker()
        self._startup_update_worker.done.connect(self._on_startup_update_checked)
        self._startup_update_worker.start()
    def _on_startup_update_checked(self, release: dict | None):
        self._startup_update_worker = None
-        if release is None:
+        if release and core.is_newer_version(core.__version__, release["version"]):
            return  # offline/failed check: don't advance lastCheck, allow retry
        QSettings("BCC", "BetterClaudeConfig").setValue("update/lastCheck", time.time())
        if core.is_newer_version(core.__version__, release["version"]):
            self.status.setText(
                f"Update available: {release['version']}  ·  Help ▸ About to view it."
            )
@@ -1688,45 +1596,11 @@ class MainWindow(QMainWindow):
        head.setObjectName("h1")
        v.addWidget(head)
        search_row = QHBoxLayout()
        self.search_box = QLineEdit()
        self.search_box.setPlaceholderText("Search servers by name, command, or url…")
        self.search_box.setClearButtonEnabled(True)
        self.search_box.textChanged.connect(self._on_search_changed)
-        search_row.addWidget(self.search_box, 1)
+        v.addWidget(self.search_box)
        self.enable_all_btn = QPushButton("All on")
        self.enable_all_btn.setToolTip("Enable every server")
        self.enable_all_btn.clicked.connect(lambda: self._set_all_enabled(True))
        search_row.addWidget(self.enable_all_btn)
        self.disable_all_btn = QPushButton("All off")
        self.disable_all_btn.setToolTip("Disable every server")
        self.disable_all_btn.clicked.connect(lambda: self._set_all_enabled(False))
        search_row.addWidget(self.disable_all_btn)
        v.addLayout(search_row)
        # Named server sets (issue #52): apply a saved Active/Disabled split
        # in one click. Sets live in the config file under _bccServerSets.
        sets_row = QHBoxLayout()
        sets_lbl = QLabel("Set")
        sets_lbl.setObjectName("muted")
        sets_row.addWidget(sets_lbl)
        self.sets_combo = QComboBox()
        self.sets_combo.setMinimumWidth(120)
        sets_row.addWidget(self.sets_combo, 1)
        self.apply_set_btn = QPushButton("Apply")
        self.apply_set_btn.setToolTip("Enable exactly this set's servers; disable the rest")
        self.apply_set_btn.clicked.connect(self._apply_selected_set)
        sets_row.addWidget(self.apply_set_btn)
        self.save_set_btn = QPushButton("Save set…")
        self.save_set_btn.setToolTip("Save the current Active/Disabled split as a named set")
        self.save_set_btn.clicked.connect(self._save_set)
        sets_row.addWidget(self.save_set_btn)
        self.del_set_btn = QPushButton("−")
        self.del_set_btn.setToolTip("Delete the selected set")
        self.del_set_btn.setMaximumWidth(32)
        self.del_set_btn.clicked.connect(self._delete_set)
        sets_row.addWidget(self.del_set_btn)
        v.addLayout(sets_row)
        # Active and Disabled sections live in a vertical splitter so the user
        # can drag the divider instead of being stuck with a fixed-height
@@ -1810,12 +1684,6 @@ class MainWindow(QMainWindow):
        undo_action.setShortcut("Ctrl+Z")
        undo_action.triggered.connect(self._undo)
        self.addAction(undo_action)
        # Ctrl+S / Cmd+S shortcut — routed through a guard so it respects
        # the same dirty/validation gating as the Save button.
        save_action = QAction(self)
        save_action.setShortcut(QKeySequence.StandardKey.Save)
        save_action.triggered.connect(self._save_shortcut)
        self.addAction(save_action)
        bar.addStretch()
        self.validation_lbl = QLabel("")
        bar.addWidget(self.validation_lbl)
@@ -1842,19 +1710,6 @@ class MainWindow(QMainWindow):
        self._mark_dirty()
        self.status.setText("Undone.")
    def _set_all_enabled(self, enabled: bool):
        """Flip every server's enabled flag in one step (one undo snapshot)."""
        if not self.servers or all(s.enabled == enabled for s in self.servers):
            return  # nothing to change
        cur = self._current_index()
        self._push_undo()
        for s in self.servers:
            s.enabled = enabled
        sel = cur if 0 <= cur < len(self.servers) else None
        self._refresh_tables(select_index=sel)
        self._mark_dirty()
        self.status.setText("All servers enabled." if enabled else "All servers disabled.")
    # --- profiles -------------------------------------------------------- #
    def reload_profiles(self):
        discovered = core.discover_profiles()
@@ -1877,9 +1732,8 @@ class MainWindow(QMainWindow):
    def _maybe_warn_msix(self):
        """
        Windows-only, no-op everywhere else: if Claude Desktop looks like an
-        MSIX/Store install with a virtualized config, show a persistent banner
+        MSIX/Store install with a virtualized config, append a warning to the
-        so edits to the plain %APPDATA% path aren't silently lost. (The status
+        status bar so edits to the plain %APPDATA% path aren't silently lost.
        bar is the wrong home for this: it's rewritten on every action.)
        Defensive on purpose -- this must never block startup or profile load.
        """
        try:
@@ -1887,11 +1741,8 @@ class MainWindow(QMainWindow):
        except Exception:
            return
        if warning:
-            self.warn_banner.setText(f"⚠  {warning}")
+            self.status.setText(f"{self.status.text()}  ⚠ {warning}")
-            self.warn_banner.setToolTip(warning)
+            self.status.setToolTip(warning)
            self.warn_banner.show()
        else:
            self.warn_banner.hide()
    def add_custom_config(self):
        start = str(core.app_support_base())
@@ -1947,7 +1798,6 @@ class MainWindow(QMainWindow):
        self._undo_stack.clear()
        self.undo_btn.setEnabled(False)
        self._health.clear()  # health results are per-profile; a fresh load invalidates them
        self._refresh_sets_combo()  # sets are per-config; repopulate from the loaded file
        self._refresh_tables(select_index=0 if self.servers else -1)
        self._update_status(saved=False)
        if repaired:
@@ -2047,73 +1897,6 @@ class MainWindow(QMainWindow):
        cur = self._current_index()
        self._refresh_tables(select_index=cur if cur >= 0 else None)
    # --- named server sets (issue #52) ------------------------------------ #
    def _refresh_sets_combo(self, select: str | None = None):
        sets = core.list_server_sets(self.full_config)
        self.sets_combo.blockSignals(True)
        self.sets_combo.clear()
        for name in sorted(sets):
            self.sets_combo.addItem(name)
        if select is not None:
            idx = self.sets_combo.findText(select)
            if idx >= 0:
                self.sets_combo.setCurrentIndex(idx)
        self.sets_combo.blockSignals(False)
        has_sets = bool(sets)
        self.apply_set_btn.setEnabled(has_sets)
        self.del_set_btn.setEnabled(has_sets)
    def _apply_selected_set(self):
        name = self.sets_combo.currentText()
        sets = core.list_server_sets(self.full_config)
        if name not in sets:
            return
        self._push_undo()
        missing = core.apply_server_set(self.servers, sets[name])
        self._refresh_tables(select_index=self._current_index() if self.servers else None)
        self._mark_dirty()
        on = sum(1 for s in self.servers if s.enabled)
        msg = f"Applied set “{name}”  ·  {on} enabled. Review and Save."
        if missing:
            msg += f"  ⚠ no longer in this config: {', '.join(missing)}"
        self.status.setText(msg)
    def _save_set(self):
        name, ok = QInputDialog.getText(
            self,
            "Save server set",
            "Set name (saves which servers are currently Active):",
            text=self.sets_combo.currentText(),
        )
        name = name.strip()
        if not ok or not name:
            return
        if name in core.list_server_sets(self.full_config) and (
            QMessageBox.question(self, "Set exists", f"Replace set “{name}”?")
            != QMessageBox.StandardButton.Yes
        ):
            return
        members = core.save_server_set(self.full_config, name, self.servers)
        self._refresh_sets_combo(select=name)
        self._mark_dirty()  # the set is written on the next Save
        self.status.setText(
            f"Set “{name}” saved ({len(members)} server(s)). Press Save to write it."
        )
    def _delete_set(self):
        name = self.sets_combo.currentText()
        if not name:
            return
        if (
            QMessageBox.question(self, "Delete set", f"Delete set “{name}”?")
            != QMessageBox.StandardButton.Yes
        ):
            return
        if core.delete_server_set(self.full_config, name):
            self._refresh_sets_combo()
            self._mark_dirty()
            self.status.setText(f"Set “{name}” deleted. Press Save to write the change.")
    # --- test all (spawn-test every enabled local server) ---------------- #
    def _test_all_servers(self):
        targets = [s for s in self.servers if s.enabled and s.kind == "stdio"]
@@ -2262,17 +2045,12 @@ class MainWindow(QMainWindow):
        if not (0 <= idx < len(self.servers)):
            return
        entry = self.servers[idx]
        old_name = entry.name
        entry.name = self.editor.current_name()
        entry.data = self.editor.dump_data()
        # The server stays in its section (enable state unchanged), so update
        # its existing row in place rather than re-rendering.
        # An edit invalidates any cached "Test all" result -- the server that
-        # was spawn-tested no longer matches what's on disk once saved. Pop
+        # was spawn-tested no longer matches what's on disk once saved.
        # both names: the old one (so a rename doesn't leave a stale entry
        # for whoever takes that name next) and the new one (so we don't
        # inherit a stale result cached under the name being renamed to).
        self._health.pop(old_name, None)
        self._health.pop(entry.name, None)
        loc = self._row_of_index.get(idx)
        if loc:
@@ -2432,23 +2210,11 @@ class MainWindow(QMainWindow):
            self.validation_lbl.setStyleSheet(f"color: {WARN};")
            self.save_btn.setEnabled(False)
            return False
        lint_warnings = core.lint_servers(self.servers)
        if lint_warnings:
            self.validation_lbl.setText(f"⚠ {lint_warnings[0]}")
            self.validation_lbl.setStyleSheet(f"color: {WARN};")
        else:
        self.validation_lbl.setText("✓ valid")
        self.validation_lbl.setStyleSheet(f"color: {GOOD};")
        self.save_btn.setEnabled(self.dirty)
        return True
    def _save_shortcut(self):
        """Ctrl+S / Cmd+S handler — only fires when the Save button itself
        would accept a click, so the shortcut can't bypass validation/dirty
        gating."""
        if self.save_btn.isEnabled():
            self.save()
    def save(self):
        if not self.current_profile:
            return
@@ -2518,30 +2284,18 @@ class MainWindow(QMainWindow):
    def _offer_restart_button(self):
        """Show the 'Restart Claude Desktop' button after a successful save,
        but only when the just-saved profile is Claude Desktop -- restarting
-        makes no sense for Claude Code, which has no GUI process to bounce --
+        makes no sense for Claude Code, which has no GUI process to bounce."""
-        and only on platforms where Claude Desktop exists (never Linux, where
+        if self.current_profile and core.profile_targets_claude_desktop(self.current_profile):
        'claude' is the Claude Code CLI)."""
        if (
            self.current_profile
            and core.profile_targets_claude_desktop(self.current_profile)
            and core.restart_supported()
        ):
            self.restart_btn.show()
        else:
            self.restart_btn.hide()
    def _restart_claude_desktop(self):
        self.restart_btn.setEnabled(False)
-        self.restart_btn.setText("Restarting…")
+        try:
-        # Held on self (MainWindow outlives the worker); replaced only after
+            result = core.restart_claude_desktop()
-        # done re-enables the button, so a running thread is never dropped.
+        finally:
        self._restart_worker = RestartWorker()
        self._restart_worker.done.connect(self._on_restart_done)
        self._restart_worker.start()
    def _on_restart_done(self, result):
            self.restart_btn.setEnabled(True)
        self.restart_btn.setText("Restart Claude Desktop")
        self.restart_btn.hide()
        if result.success:
            self.status.setText(f"{self.status.text()}  ·  {result.detail}")
@@ -2602,44 +2356,29 @@ class MainWindow(QMainWindow):
            e.acceptProposedAction()
    def dropEvent(self, e):
        total_added, total_replaced, files_imported = 0, 0, 0
        undo_pushed = False
        for u in e.mimeData().urls():
            path = u.toLocalFile()
            if not path.endswith(".json"):
                continue
-            p = Path(path)
+            text = Path(path).read_text(encoding="utf-8")
            if p.stat().st_size > MAX_DROP_IMPORT_BYTES:
                QMessageBox.warning(
                    self,
                    "File too large",
                    f"{p.name}:\nFile exceeds the 5 MB import limit and was skipped.",
                )
                continue
            text = p.read_text(encoding="utf-8")
            try:
                servers = core.parse_pasted_json(text)
            except Exception as ex:
-                QMessageBox.warning(self, "Couldn't import", f"{p.name}:\n{ex}")
+                QMessageBox.warning(self, "Couldn't import", f"{Path(path).name}:\n{ex}")
                continue
            if not undo_pushed:
            self._push_undo()
                undo_pushed = True
            added, replaced = 0, 0
            for name, data in servers.items():
                a, r = self._import_server(name, data)
                added += int(a)
                replaced += int(r)
            total_added += added
            total_replaced += replaced
            files_imported += 1
        if files_imported:
            self._refresh_tables(select_index=len(self.servers) - 1)
            self._mark_dirty()
            self.status.setText(
-                f"Imported {total_added} added, {total_replaced} replaced from "
+                f"Imported {added} added, {replaced} replaced from {Path(path).name}. "
-                f"{files_imported} file(s). Review and Save."
+                "Review and Save."
            )
            break
    def closeEvent(self, e):
        if self.dirty and not self._confirm_discard():
@@ -31,7 +31,7 @@ a = Analysis(
    ["bcc.py"],
    pathex=[],
    binaries=[],
-    datas=[("icons", "icons"), ("data/catalog.json", "data")],
+    datas=[("icons", "icons")],
    hiddenimports=[],
    hookspath=[],
    hooksconfig={},
@@ -78,8 +78,8 @@ if sys.platform == "darwin":
        info_plist={
            "CFBundleName": "Better Claude Config",
            "CFBundleDisplayName": "Better Claude Config",
-            "CFBundleShortVersionString": "1.3.0",
+            "CFBundleShortVersionString": "1.0.0",
-            "CFBundleVersion": "1.3.0",
+            "CFBundleVersion": "1.0.0",
            "NSHighResolutionCapable": True,
            "NSRequiresAquaSystemAppearance": False,  # supports dark mode
            "LSMinimumSystemVersion": "11.0",
@@ -1,454 +0,0 @@
 {
  "schema": 1,
  "version": 1,
  "updated": "2026-07-12",
  "signed_at": "2026-07-12T21:35:19Z",
  "servers": [
    {
      "id": "filesystem",
      "display": "Filesystem",
      "description": "Lets Claude read, write, search, and edit files in directories you explicitly allow.",
      "category": "files",
      "homepage": "https://github.com/modelcontextprotocol/servers/tree/main/src/filesystem",
      "stars": 85995,
      "official": true,
      "setup": "basic",
      "config": {
        "command": "npx",
        "args": [
          "-y",
          "@modelcontextprotocol/server-filesystem@2026.7.10",
          "<ALLOWED_DIR>"
        ]
      },
      "placeholders": {
        "<ALLOWED_DIR>": "Absolute path to a directory the server may read/write. Add more directories as additional args."
      },
      "env_required": {},
      "docs_url": "https://github.com/modelcontextprotocol/servers/tree/main/src/filesystem",
      "notes": "Part of the official modelcontextprotocol/servers reference monorepo (star count is for the whole repo). Clients that support MCP 'roots' can also grant directories dynamically instead of via args.",
      "last_release": "2026-07-10"
    },
    {
      "id": "fetch",
      "display": "Fetch",
      "description": "Fetches a URL and converts the page to clean markdown so Claude can read web content.",
      "category": "dev",
      "homepage": "https://github.com/modelcontextprotocol/servers/tree/main/src/fetch",
      "stars": 85995,
      "official": true,
      "setup": "basic",
      "config": {
        "command": "uvx",
        "args": [
          "mcp-server-fetch@2026.7.10"
        ]
      },
      "placeholders": {},
      "env_required": {},
      "docs_url": "https://github.com/modelcontextprotocol/servers/tree/main/src/fetch",
      "notes": "Can access local/internal IPs, so treat as a mild security risk on untrusted networks. Add '--ignore-robots-txt' or '--user-agent=...' as extra args if needed.",
      "last_release": "2026-07-10"
    },
    {
      "id": "memory",
      "display": "Memory",
      "description": "Gives Claude a persistent knowledge-graph memory that survives across conversations.",
      "category": "ai",
      "homepage": "https://github.com/modelcontextprotocol/servers/tree/main/src/memory",
      "stars": 85995,
      "official": true,
      "setup": "basic",
      "config": {
        "command": "npx",
        "args": [
          "-y",
          "@modelcontextprotocol/server-memory@2026.7.4"
        ]
      },
      "placeholders": {},
      "env_required": {},
      "docs_url": "https://github.com/modelcontextprotocol/servers/tree/main/src/memory",
      "notes": "Stores entities/relations as a local JSON knowledge graph (path configurable via MEMORY_FILE_PATH env var).",
      "last_release": "2026-07-04"
    },
    {
      "id": "sequential-thinking",
      "display": "Sequential Thinking",
      "description": "Gives Claude a structured, step-by-step reasoning tool for breaking down complex problems.",
      "category": "ai",
      "homepage": "https://github.com/modelcontextprotocol/servers/tree/main/src/sequentialthinking",
      "stars": 85995,
      "official": true,
      "setup": "basic",
      "config": {
        "command": "npx",
        "args": [
          "-y",
          "@modelcontextprotocol/server-sequential-thinking@2026.7.4"
        ]
      },
      "placeholders": {},
      "env_required": {},
      "docs_url": "https://github.com/modelcontextprotocol/servers/tree/main/src/sequentialthinking",
      "notes": "Set DISABLE_THOUGHT_LOGGING=true to stop it from printing each thought step to the console.",
      "last_release": "2026-07-04"
    },
    {
      "id": "git",
      "display": "Git",
      "description": "Lets Claude read history, diff, branch, and search a local git repository.",
      "category": "dev",
      "homepage": "https://github.com/modelcontextprotocol/servers/tree/main/src/git",
      "stars": 85995,
      "official": true,
      "setup": "basic",
      "config": {
        "command": "uvx",
        "args": [
          "mcp-server-git@2026.7.10",
          "--repository",
          "<REPO_PATH>"
        ]
      },
      "placeholders": {
        "<REPO_PATH>": "Absolute path to the local git repository"
      },
      "env_required": {},
      "docs_url": "https://github.com/modelcontextprotocol/servers/tree/main/src/git",
      "notes": "Operates on a local checkout only; it does not talk to GitHub/GitLab APIs (pair with the GitHub or GitLab server for that).",
      "last_release": "2026-07-10"
    },
    {
      "id": "github",
      "display": "GitHub",
      "description": "Lets Claude read repos/code, and manage issues, pull requests, and Actions on GitHub.",
      "category": "code-hosting",
      "homepage": "https://github.com/github/github-mcp-server",
      "stars": 30202,
      "official": true,
      "setup": "basic",
      "config": {
        "command": "docker",
        "args": [
          "run",
          "-i",
          "--rm",
          "-e",
          "GITHUB_PERSONAL_ACCESS_TOKEN",
          "ghcr.io/github/github-mcp-server:v1.0.1"
        ]
      },
      "placeholders": {},
      "env_required": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": ""
      },
      "docs_url": "https://github.com/github/github-mcp-server/blob/main/docs/installation-guides/README.md",
      "notes": "The old '@modelcontextprotocol/server-github' npm package is discontinued (deprecated April 2025). GitHub now ships a Docker-based local server (requires Docker installed/running) plus a hosted remote server at https://api.githubcopilot.com/mcp/ that supports OAuth or PAT auth without Docker."
    },
    {
      "id": "playwright",
      "display": "Playwright",
      "description": "Lets Claude drive a real browser (click, type, navigate, screenshot) using Playwright's accessibility-tree snapshots.",
      "category": "browser",
      "homepage": "https://github.com/microsoft/playwright-mcp",
      "stars": 34000,
      "official": true,
      "setup": "basic",
      "config": {
        "command": "npx",
        "args": [
          "@playwright/mcp@0.0.78"
        ]
      },
      "placeholders": {},
      "env_required": {},
      "docs_url": "https://github.com/microsoft/playwright-mcp#readme",
      "notes": "Maintained by the Playwright team at Microsoft. Add '--isolated' for a throwaway profile, or '--browser firefox|webkit|msedge' to change engine. A persistent browser profile is used by default so logins carry over between sessions.",
      "last_release": "2026-07-09"
    },
    {
      "id": "chrome-devtools",
      "display": "Chrome DevTools",
      "description": "Lets Claude control Chrome and use real DevTools features: performance traces, network inspection, console logs, screenshots.",
      "category": "browser",
      "homepage": "https://github.com/ChromeDevTools/chrome-devtools-mcp",
      "stars": 45000,
      "official": true,
      "setup": "basic",
      "config": {
        "command": "npx",
        "args": [
          "-y",
          "chrome-devtools-mcp@1.5.0"
        ]
      },
      "placeholders": {},
      "env_required": {},
      "docs_url": "https://github.com/ChromeDevTools/chrome-devtools-mcp#readme",
      "notes": "Maintained by the Google Chrome DevTools team; only officially supports Google Chrome / Chrome for Testing. Exposes the browser's content to the MCP client, so avoid sensitive sites while connected. Add '--slim --headless' for a minimal 3-tool basic-automation mode.",
      "last_release": "2026-07-03"
    },
    {
      "id": "postgres",
      "display": "Postgres MCP Pro",
      "description": "Lets Claude query, inspect schema, and analyze/tune performance of a PostgreSQL database.",
      "category": "database",
      "homepage": "https://github.com/crystaldba/postgres-mcp",
      "stars": 2400,
      "official": false,
      "setup": "basic",
      "config": {
        "command": "uvx",
        "args": [
          "postgres-mcp@0.3.0",
          "--access-mode=restricted"
        ]
      },
      "placeholders": {},
      "env_required": {
        "DATABASE_URI": ""
      },
      "docs_url": "https://github.com/crystaldba/postgres-mcp#readme",
      "notes": "The official reference Postgres server was archived by the MCP team; this community server (Crystal DBA) is the most capable/most-referenced replacement, adding index tuning and EXPLAIN-plan analysis. Use --access-mode=restricted for read-only/production use. Docker image also available (crystaldba/postgres-mcp). Catalog ships --access-mode=restricted (read-only); switch to unrestricted yourself if you want writes.",
      "last_release": "2025-05-16"
    },
    {
      "id": "n8n",
      "display": "n8n",
      "description": "Build, validate, and deploy n8n workflows with full node documentation for the AI.",
      "category": "infra",
      "homepage": "https://github.com/czlonkowski/n8n-mcp",
      "stars": 22257,
      "official": false,
      "setup": "basic",
      "config": {
        "command": "npx",
        "args": [
          "n8n-mcp@2.63.2"
        ]
      },
      "placeholders": {},
      "env_required": {
        "MCP_MODE": "",
        "N8N_API_URL": "",
        "N8N_API_KEY": ""
      },
      "docs_url": "https://github.com/czlonkowski/n8n-mcp",
      "notes": "Set MCP_MODE=stdio (required for Claude Desktop, prevents debug logs from breaking the protocol). N8N_API_URL/N8N_API_KEY are optional — without them you still get full node documentation, validation, and template search; with them you get live workflow create/update/execute against your own n8n instance. A hosted free-tier alternative exists at dashboard.n8n-mcp.com.",
      "last_release": "2026-07-09"
    },
    {
      "id": "notion",
      "display": "Notion",
      "description": "Read, search, and edit Notion pages, databases, and comments from your AI assistant.",
      "category": "productivity",
      "homepage": "https://github.com/makenotion/notion-mcp-server",
      "stars": 4400,
      "official": true,
      "setup": "basic",
      "config": {
        "command": "npx",
        "args": [
          "-y",
          "@notionhq/notion-mcp-server@2.4.1"
        ]
      },
      "placeholders": {},
      "env_required": {
        "NOTION_TOKEN": ""
      },
      "docs_url": "https://developers.notion.com/docs/mcp",
      "notes": "Notion is prioritizing its hosted remote MCP (OAuth, https://mcp.notion.com/mcp) and may eventually sunset this local package, but the stdio server still works today and is the simplest way to get a static config with an internal-integration token.",
      "last_release": "2026-06-22"
    },
    {
      "id": "obsidian",
      "display": "Obsidian",
      "description": "Read, search, and edit notes in your Obsidian vault.",
      "category": "personal",
      "homepage": "https://github.com/MarkusPfundstein/mcp-obsidian",
      "stars": 4067,
      "official": false,
      "setup": "basic",
      "config": {
        "command": "uvx",
        "args": [
          "mcp-obsidian@0.2.2"
        ]
      },
      "placeholders": {},
      "env_required": {
        "OBSIDIAN_API_KEY": "",
        "OBSIDIAN_HOST": "",
        "OBSIDIAN_PORT": ""
      },
      "docs_url": "https://github.com/MarkusPfundstein/mcp-obsidian",
      "notes": "Requires the Obsidian Local REST API community plugin installed and enabled in Obsidian; copy the API key from the plugin settings. OBSIDIAN_HOST defaults to 127.0.0.1 and OBSIDIAN_PORT to 27124 if omitted.",
      "last_release": "2025-04-01"
    },
    {
      "id": "brave-search",
      "display": "Brave Search",
      "description": "Search the web, news, images, and videos using Brave's independent search index.",
      "category": "search",
      "homepage": "https://github.com/brave/brave-search-mcp-server",
      "stars": 1288,
      "official": true,
      "setup": "basic",
      "config": {
        "command": "npx",
        "args": [
          "-y",
          "@brave/brave-search-mcp-server@2.0.85",
          "--transport",
          "stdio"
        ]
      },
      "placeholders": {},
      "env_required": {
        "BRAVE_API_KEY": ""
      },
      "docs_url": "https://github.com/brave/brave-search-mcp-server",
      "notes": "Official Brave server; replaced the old archived modelcontextprotocol/servers brave-search entry (now in modelcontextprotocol/servers-archived). Get an API key from the Brave Search API dashboard.",
      "last_release": "2026-06-15"
    },
    {
      "id": "tavily",
      "display": "Tavily",
      "description": "AI-optimized web search, extract, map, and crawl API built for LLM agents.",
      "category": "search",
      "homepage": "https://github.com/tavily-ai/tavily-mcp",
      "stars": 2206,
      "official": true,
      "setup": "basic",
      "config": {
        "command": "npx",
        "args": [
          "tavily-mcp@0.2.21"
        ]
      },
      "placeholders": {},
      "env_required": {
        "TAVILY_API_KEY": ""
      },
      "docs_url": "https://github.com/tavily-ai/tavily-mcp",
      "notes": "Tavily also offers a hosted remote MCP endpoint (mcp.tavily.com) with OAuth as an alternative to running the local npx server.",
      "last_release": "2026-07-10"
    },
    {
      "id": "home-assistant",
      "display": "Home Assistant",
      "description": "Control smart home devices, query states, and troubleshoot automations in Home Assistant.",
      "category": "smart-home",
      "homepage": "https://github.com/voska/hass-mcp",
      "stars": 308,
      "official": false,
      "setup": "basic",
      "config": {
        "command": "docker",
        "args": [
          "run",
          "-i",
          "--rm",
          "-e",
          "HA_URL",
          "-e",
          "HA_TOKEN",
          "voska/hass-mcp:0.5.0"
        ]
      },
      "placeholders": {},
      "env_required": {
        "HA_URL": "",
        "HA_TOKEN": ""
      },
      "docs_url": "https://github.com/voska/hass-mcp",
      "notes": "HA_URL example: http://homeassistant.local:8123 (use http://host.docker.internal:8123 if HA runs in Docker on the same machine). HA_TOKEN is a Home Assistant long-lived access token from your profile page. A more actively developed alternative is the community 'HA-MCP' integration (homeassistant-ai/ha-mcp, ~3.9k stars), but it installs inside Home Assistant itself via HACS rather than as an external stdio process, so it doesn't fit this catalog's launch-line format."
    },
    {
      "id": "kubernetes",
      "display": "Kubernetes",
      "description": "Lets Claude inspect and manage Kubernetes/OpenShift resources — pods, deployments, logs, Helm releases — using your local kubeconfig.",
      "category": "infra",
      "homepage": "https://github.com/containers/kubernetes-mcp-server",
      "stars": 1626,
      "official": false,
      "setup": "basic",
      "config": {
        "command": "npx",
        "args": [
          "-y",
          "kubernetes-mcp-server@0.0.64"
        ]
      },
      "placeholders": {},
      "env_required": {},
      "docs_url": "https://github.com/containers/kubernetes-mcp-server#readme",
      "notes": "Not an official Kubernetes SIG project, but a Go-native (no kubectl dependency) implementation maintained under the 'containers' GitHub org (Podman/Red Hat-adjacent) that's widely regarded as the most capable K8s MCP server, supporting Kubernetes and OpenShift. Uses your existing ~/.kube/config automatically; add --read-only to prevent writes.",
      "last_release": "2026-07-10"
    },
    {
      "id": "aws-api-mcp-server",
      "display": "AWS API MCP Server (AWS Labs)",
      "description": "Lets your AI assistant run AWS CLI commands to inspect and manage AWS resources across virtually every AWS service.",
      "category": "cloud",
      "homepage": "https://github.com/awslabs/mcp",
      "stars": 9431,
      "official": true,
      "setup": "basic",
      "config": {
        "command": "uvx",
        "args": [
          "awslabs.aws-api-mcp-server@1.3.46"
        ]
      },
      "placeholders": {},
      "env_required": {},
      "docs_url": "https://awslabs.github.io/mcp/servers/aws-api-mcp-server",
      "notes": "AWS credentials are NOT set in this MCP config — configure them beforehand via `aws configure` (or set AWS_API_MCP_PROFILE_NAME to pick a named profile) so boto3's standard credential chain can find them. Optional env vars: AWS_REGION (default us-east-1), READ_OPERATIONS_ONLY=true to block all mutating AWS calls. AWS notes this server is being superseded by a newer unified AWS MCP server referenced in their agent-toolkit docs.",
      "last_release": "2026-06-25"
    },
    {
      "id": "grafana",
      "display": "Grafana",
      "description": "Query dashboards, datasources, alerts and incidents in Grafana from your AI assistant.",
      "category": "observability",
      "homepage": "https://github.com/grafana/mcp-grafana",
      "stars": 3227,
      "official": true,
      "setup": "basic",
      "config": {
        "command": "uvx",
        "args": [
          "mcp-grafana@0.17.1"
        ],
        "env": {
          "GRAFANA_URL": "<GRAFANA_URL>"
        }
      },
      "placeholders": {
        "<GRAFANA_URL>": "Your Grafana instance URL, e.g. http://localhost:3000 or https://yourstack.grafana.net"
      },
      "env_required": {
        "GRAFANA_SERVICE_ACCOUNT_TOKEN": ""
      },
      "docs_url": "https://grafana.com/docs/grafana/latest/developer-resources/mcp/",
      "notes": "Requires Grafana 9.0+ for full functionality — datasource-related tools may not work correctly on older versions.",
      "last_release": "2026-07-07"
    },
    {
      "id": "slack",
      "display": "Slack",
      "description": "Search Slack messages, files, and members, and send messages or manage channels from your AI assistant.",
      "category": "communication",
      "homepage": "https://slack.com/help/articles/48855576908307-Guide-to-the-Slack-MCP-server",
      "stars": null,
      "official": true,
      "setup": "link-only",
      "env_required": {},
      "docs_url": "https://docs.slack.dev/changelog/2026/02/17/slack-mcp/",
      "notes": "Slack's own MCP server went GA Feb 17, 2026 (streamable HTTP at https://mcp.slack.com/mcp, OAuth). No stdio one-liner is published because it's a hosted, permissioned connector. A well-known community alternative, korotovsky/slack-mcp-server (~1.6k GitHub stars, MIT, not an official Slack product), supports stdio/SSE/HTTP with bot or browser-session tokens and no app-install requirement if a stdio option is preferred."
    }
  ]
 }
@@ -1,2 +0,0 @@
 ы<8¶ђt2ішл„»‰/НЕ0Тjcw&`
 тrH«MўК›єrBL,0AS€!Х2–иже.SТ°ч–'Agm
@@ -1,13 +1,12 @@
 [project]
 name = "better-claude-config"
-version = "1.3.0"
+version = "1.2.0"
 description = "Cross-platform GUI for editing the mcpServers block of Claude Desktop and Claude Code configs"
 readme = "README.md"
 license = { file = "LICENSE" }
 requires-python = ">=3.10"
 dependencies = [
    "PySide6>=6.6",
    "cryptography>=42.0",
 ]
 [project.optional-dependencies]
@@ -8,4 +8,3 @@ pillow>=10.0        # generates icons/app.ico during CI (Windows build)
 # Test / lint
 pytest>=8.0
 ruff>=0.6
 cryptography>=42.0   # release checksum signing (scripts/sign_checksums.py)
@@ -1,271 +0,0 @@
 #!/usr/bin/env python3
 """
 Generate a SHA256SUMS file for release artifacts and sign it with Ed25519.
 BCC ships PyInstaller binaries that are not code-signed (no budget for a
 macOS Developer ID / Windows Authenticode certificate). This script provides
 the free half of supply-chain integrity: a checksum manifest, detached-signed
 so downloaders can verify the file they got is the file we published.
 This does NOT remove Gatekeeper/SmartScreen warnings and does NOT prove the
 binary is safe to run -- only that it matches what the release signing key
 attested to.
 Usage:
    # Hash every file in a directory into a SHA256SUMS-format manifest.
    python scripts/sign_checksums.py generate <dir> --out SHA256SUMS
    # Sign a manifest, producing a detached signature.
    # Private key comes from $RELEASE_SIGNING_KEY (base64 raw Ed25519 seed)
    # unless --key-b64 is given explicitly (mostly for tests).
    python scripts/sign_checksums.py sign --sums SHA256SUMS --out SHA256SUMS.sig
    # Verify a manifest against a detached signature and a public key.
    python scripts/sign_checksums.py verify --sums SHA256SUMS --sig SHA256SUMS.sig \
        --pubkey-b64 <base64 raw Ed25519 public key>
 The private key is generated and rotated via the Catalog Console (#62) --
 this script never generates or stores a key itself.
 """
 from __future__ import annotations
 import argparse
 import base64
 import hashlib
 import os
 import sys
 from pathlib import Path
 # Domain separation prefix: ties every signature to "a BCC release checksum
 # manifest" so a signature can never be replayed against an unrelated
 # message signed by the same key.
 DOMAIN_PREFIX = b"bcc-release-v1|"
 # Public half of the RELEASE signing key(s) -- a SEPARATE keypair from
 # bcc_core.CATALOG_PUBKEYS (issue #68 finding 5). The catalog key is the
 # offline, Console-only root of trust for what BCC executes; this key is
 # CI-resident and signs ONLY the release SHA256SUMS manifest, never the
 # catalog. Keeping them apart means a CI/repo-secret compromise burns the
 # release key -- annoying, but it never lets an attacker sign a catalog a
 # user's binary would trust. A LIST (not a single key), mirroring
 # CATALOG_PUBKEYS, so the release key can be rotated without invalidating
 # the signature on every past release: verification accepts a match against
 # ANY key here.
 #
 # Populated by the maintainer via:
 #     python catalog_console.py keygen --release
 # Rotated 2026-07 (issue #68 finding 5 / #68 CI-exposure incident): the
 # original key was shared with the catalog key and had been exposed to CI,
 # so both keypairs were regenerated as separate, disjoint keys. This list
 # holds only the current release key -- if release.yml's signing-smoke-test
 # ever sees this list empty, it fails closed (loudly) rather than silently
 # verifying against nothing.
 RELEASE_PUBKEYS: list[bytes] = [
    base64.b64decode("6BnPgJEHJFyVltFoLTCNadIsehjy00iiW8IRlC1TfhA="),
 ]
 CHUNK_SIZE = 1024 * 1024
 def sha256_file(path: Path) -> str:
    """Return the lowercase hex SHA-256 digest of a file's contents."""
    digest = hashlib.sha256()
    with open(path, "rb") as fh:
        while chunk := fh.read(CHUNK_SIZE):
            digest.update(chunk)
    return digest.hexdigest()
 def build_checksums_text(files: dict[str, str]) -> str:
    """Build a sha256sum(1)-compatible manifest body.
    `files` maps filename -> hex digest. Entries are sorted by filename for
    a deterministic, diffable output. Format matches `sha256sum` exactly:
    "<hash>  <filename>\n" (two spaces, no path components).
    """
    lines = [f"{digest}  {name}" for name, digest in sorted(files.items())]
    body = "\n".join(lines)
    return body + "\n" if body else ""
 def generate_checksums(directory: Path, *, exclude: set[str] | None = None) -> str:
    """Hash every regular file directly inside `directory` (non-recursive)
    and return the SHA256SUMS text. Filenames are recorded without any
    directory prefix so the manifest can be verified from inside the
    directory it describes.
    """
    exclude = exclude or set()
    files: dict[str, str] = {}
    for entry in sorted(directory.iterdir()):
        if not entry.is_file():
            continue
        if entry.name in exclude:
            continue
        files[entry.name] = sha256_file(entry)
    return build_checksums_text(files)
 def _signing_message(sums_text: str) -> bytes:
    """The exact bytes that get signed: the domain prefix followed by the
    raw bytes of the SHA256SUMS file content."""
    return DOMAIN_PREFIX + sums_text.encode("utf-8")
 def sign_checksums(seed_b64: str, sums_text: str) -> bytes:
    """Sign `sums_text` with the Ed25519 private key encoded (base64, raw
    32-byte seed) in `seed_b64`. Returns the raw 64-byte signature."""
    # Imported lazily so `generate` mode (used on every CI run) never
    # requires the `cryptography` package to be installed.
    from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PrivateKey
    seed = base64.b64decode(seed_b64)
    if len(seed) != 32:
        raise ValueError(f"expected a 32-byte raw Ed25519 seed, got {len(seed)} bytes")
    private_key = Ed25519PrivateKey.from_private_bytes(seed)
    return private_key.sign(_signing_message(sums_text))
 def verify_checksums(pubkey_b64: str, sums_text: str, signature: bytes) -> bool:
    """Verify `signature` over `sums_text` against the base64-encoded raw
    32-byte Ed25519 public key. Returns True/False; never raises for a bad
    signature (only for malformed inputs)."""
    from cryptography.exceptions import InvalidSignature
    from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PublicKey
    pubkey_bytes = base64.b64decode(pubkey_b64)
    if len(pubkey_bytes) != 32:
        raise ValueError(
            f"expected a 32-byte raw Ed25519 public key, got {len(pubkey_bytes)} bytes"
        )
    public_key = Ed25519PublicKey.from_public_bytes(pubkey_bytes)
    try:
        public_key.verify(signature, _signing_message(sums_text))
        return True
    except InvalidSignature:
        return False
 def public_key_b64_from_seed(seed_b64: str) -> str:
    """Derive the base64 raw public key from a base64 raw seed. Handy for
    local key-pair sanity checks; not used by the release workflow."""
    from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PrivateKey
    from cryptography.hazmat.primitives.serialization import Encoding, PublicFormat
    seed = base64.b64decode(seed_b64)
    private_key = Ed25519PrivateKey.from_private_bytes(seed)
    raw = private_key.public_key().public_bytes(Encoding.Raw, PublicFormat.Raw)
    return base64.b64encode(raw).decode("ascii")
 def verify_checksums_against_any(pubkeys: list[bytes], sums_text: str, signature: bytes) -> bool:
    """Verify `signature` against ANY key in `pubkeys` (each a raw 32-byte
    Ed25519 public key). Mirrors bcc_core.verify_catalog_signature's
    rotation-friendly "any currently-trusted key" semantics, applied to
    RELEASE_PUBKEYS instead of the catalog's key list. Returns False (never
    raises) for an empty `pubkeys` list -- fails closed rather than
    vacuously verifying against nothing."""
    return any(
        verify_checksums(base64.b64encode(pk).decode("ascii"), sums_text, signature)
        for pk in pubkeys
    )
 # --------------------------------------------------------------------------- #
 # CLI
 # --------------------------------------------------------------------------- #
 def _cmd_generate(args: argparse.Namespace) -> int:
    directory = Path(args.directory)
    exclude = {"SHA256SUMS", "SHA256SUMS.sig"}
    text = generate_checksums(directory, exclude=exclude)
    out_path = Path(args.out)
    out_path.write_text(text, encoding="utf-8")
    print(f"Wrote {out_path} ({len(text.splitlines())} entries)")
    return 0
 def _cmd_sign(args: argparse.Namespace) -> int:
    seed_b64 = args.key_b64 or os.environ.get(args.key_env, "")
    if not seed_b64:
        print(
            f"error: no signing key provided (checked --key-b64 and ${args.key_env})",
            file=sys.stderr,
        )
        return 1
    sums_text = Path(args.sums).read_text(encoding="utf-8")
    signature = sign_checksums(seed_b64, sums_text)
    Path(args.out).write_bytes(signature)
    print(f"Wrote {args.out} ({len(signature)} bytes)")
    return 0
 def _cmd_verify(args: argparse.Namespace) -> int:
    pubkey_b64 = args.pubkey_b64 or os.environ.get(args.pubkey_env, "")
    if not pubkey_b64:
        print(
            f"error: no public key provided (checked --pubkey-b64 and ${args.pubkey_env})",
            file=sys.stderr,
        )
        return 1
    sums_text = Path(args.sums).read_text(encoding="utf-8")
    signature = Path(args.sig).read_bytes()
    ok = verify_checksums(pubkey_b64, sums_text, signature)
    if ok:
        print("OK: signature is valid")
        return 0
    print("FAILED: signature is invalid", file=sys.stderr)
    return 1
 def build_parser() -> argparse.ArgumentParser:
    parser = argparse.ArgumentParser(
        description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter
    )
    sub = parser.add_subparsers(dest="mode", required=True)
    p_gen = sub.add_parser(
        "generate", help="hash every file in a directory into a SHA256SUMS manifest"
    )
    p_gen.add_argument("directory", help="directory whose files should be hashed (non-recursive)")
    p_gen.add_argument("--out", required=True, help="path to write the SHA256SUMS manifest to")
    p_gen.set_defaults(func=_cmd_generate)
    p_sign = sub.add_parser("sign", help="detached-sign a SHA256SUMS manifest with Ed25519")
    p_sign.add_argument("--sums", required=True, help="path to the SHA256SUMS manifest to sign")
    p_sign.add_argument("--out", required=True, help="path to write the detached signature to")
    p_sign.add_argument(
        "--key-b64", default=None, help="base64 raw Ed25519 seed (overrides --key-env)"
    )
    p_sign.add_argument(
        "--key-env",
        default="RELEASE_SIGNING_KEY",
        help="environment variable holding the base64 seed (default: RELEASE_SIGNING_KEY)",
    )
    p_sign.set_defaults(func=_cmd_sign)
    p_verify = sub.add_parser(
        "verify", help="verify a SHA256SUMS manifest against a detached signature"
    )
    p_verify.add_argument("--sums", required=True, help="path to the SHA256SUMS manifest")
    p_verify.add_argument("--sig", required=True, help="path to the detached signature")
    p_verify.add_argument(
        "--pubkey-b64", default=None, help="base64 raw Ed25519 public key (overrides --pubkey-env)"
    )
    p_verify.add_argument(
        "--pubkey-env",
        default="RELEASE_SIGNING_PUBKEY",
        help="environment variable holding the base64 public key (default: RELEASE_SIGNING_PUBKEY)",
    )
    p_verify.set_defaults(func=_cmd_verify)
    return parser
 def main(argv: list[str] | None = None) -> int:
    parser = build_parser()
    args = parser.parse_args(argv)
    return args.func(args)
 if __name__ == "__main__":
    raise SystemExit(main())
@@ -1,215 +0,0 @@
 """Tests for catalog_console.py's non-Qt git plumbing and ref-resolution
 seam (issue #68 rotation-completability fix).
 catalog_console.py is importable here WITHOUT PySide6 -- its Qt import is
 guarded (`_PYSIDE6_AVAILABLE`) precisely so `keygen`, `show-seed-b64`,
 `keys`, and this git plumbing stay usable (and testable) wherever PySide6
 isn't installed, including this CI test job, which never installs it. If
 PySide6 genuinely isn't importable in this environment, that itself
 exercises the guard path -- see test_module_imports_without_pyside6.
 """
 from __future__ import annotations
 import subprocess
 import sys
 from pathlib import Path
 sys.path.insert(0, str(Path(__file__).resolve().parent.parent))
 import catalog_console as cc
 import catalog_review as review
 _SEED_CATALOG = b'{"schema": 1, "version": 1, "servers": []}'
 _SEED_SIG = b"\x00" * 64
 def _run(*args: str, cwd: Path) -> None:
    subprocess.run(["git", *args], cwd=cwd, check=True, capture_output=True)
 def _init_bare_and_clone(tmp_path: Path) -> tuple[Path, Path]:
    """A bare "origin" repo with `main` and `rotation-branch` both seeded
    with a catalog + (dummy) signature, plus a working clone with `origin`
    already configured -- mirroring the tokened-remote clone
    catalog_console.py's git plumbing is always run against."""
    origin = tmp_path / "origin.git"
    _run("init", "--bare", str(origin), cwd=tmp_path)
    seed = tmp_path / "seed"
    _run("clone", str(origin), str(seed), cwd=tmp_path)
    _run("config", "user.email", "test@example.com", cwd=seed)
    _run("config", "user.name", "Test", cwd=seed)
    (seed / "data").mkdir()
    (seed / "data" / "catalog.json").write_bytes(_SEED_CATALOG)
    (seed / "data" / "catalog.json.sig").write_bytes(_SEED_SIG)
    _run("add", "-A", cwd=seed)
    _run("commit", "-m", "seed", cwd=seed)
    _run("push", "origin", "HEAD:refs/heads/main", cwd=seed)
    _run("checkout", "-b", "rotation-branch", cwd=seed)
    _run("push", "origin", "HEAD:refs/heads/rotation-branch", cwd=seed)
    clone = tmp_path / "work"
    _run("clone", str(origin), str(clone), cwd=tmp_path)
    _run("config", "user.email", "test@example.com", cwd=clone)
    _run("config", "user.name", "Test", cwd=clone)
    return origin, clone
 # --------------------------------------------------------------------------- #
 # The module must stay importable without PySide6 -- this IS the fix that
 # lets `keys`/`keygen`/`show-seed-b64` (and this whole test file) run
 # somewhere PySide6 isn't installed.
 # --------------------------------------------------------------------------- #
 def test_module_imports_without_pyside6():
    assert hasattr(cc, "_PYSIDE6_AVAILABLE")
    # This CI test job never installs PySide6 (see .github/workflows/ci.yml
    # "Install test dependencies": pytest + cryptography only) -- so on CI,
    # this assertion is itself proof the guard is doing its job. Locally,
    # where a maintainer's env DOES have PySide6, it's fine either way; the
    # only real assertion this test needs is "importing the module never
    # raises", which happened just by getting this far.
    assert cc._PYSIDE6_AVAILABLE in (True, False)
 def test_cmd_gui_fails_soft_without_pyside6(monkeypatch, capsys):
    if cc._PYSIDE6_AVAILABLE:
        return  # nothing to prove where PySide6 IS available
    import argparse
    args = argparse.Namespace(repo=".", ref=None)
    assert cc.cmd_gui(args) == 1
    assert "PySide6" in capsys.readouterr().err
 # --------------------------------------------------------------------------- #
 # compute_own_refs: the PURE ref-resolution seam. No git, no Qt.
 # --------------------------------------------------------------------------- #
 def test_compute_own_refs_defaults_to_main_only():
    assert cc.compute_own_refs(None, None) == ["main"]
 def test_compute_own_refs_adds_detected_branch():
    assert cc.compute_own_refs(None, "chore/68-key-rotation") == [
        "main",
        "chore/68-key-rotation",
    ]
 def test_compute_own_refs_explicit_ref_overrides_detected_branch():
    assert cc.compute_own_refs("explicit-branch", "detected-branch") == [
        "main",
        "explicit-branch",
    ]
 def test_compute_own_refs_does_not_duplicate_main():
    assert cc.compute_own_refs(None, "main") == ["main"]
    assert cc.compute_own_refs("main", "some-other-branch") == ["main"]
 # --------------------------------------------------------------------------- #
 # current_branch: git plumbing, no Qt.
 # --------------------------------------------------------------------------- #
 def test_current_branch_detects_checked_out_branch(tmp_path):
    _origin, clone = _init_bare_and_clone(tmp_path)
    _run("fetch", "origin", "rotation-branch", cwd=clone)
    _run("checkout", "-B", "rotation-branch", "origin/rotation-branch", cwd=clone)
    assert cc.current_branch(clone) == "rotation-branch"
 def test_current_branch_none_on_detached_head(tmp_path):
    _origin, clone = _init_bare_and_clone(tmp_path)
    commit = cc.fetch_ref(clone, "main")
    _run("checkout", commit, cwd=clone)
    assert cc.current_branch(clone) is None
 # --------------------------------------------------------------------------- #
 # commit_and_push_signed_catalog: MUST target the given branch, never a
 # hardcoded "main" -- issue #68's completability fix. This is exactly the
 # bug that, before the fix, would have made ReviewWindow._on_sign push a
 # PR/branch review's signature straight to main regardless of what was
 # actually reviewed.
 # --------------------------------------------------------------------------- #
 def test_commit_and_push_signed_catalog_targets_the_given_branch_not_main(tmp_path):
    _origin, clone = _init_bare_and_clone(tmp_path)
    new_raw = b'{"schema": 1, "version": 2, "servers": []}'
    new_sig = b"\x01" * 64
    cc.commit_and_push_signed_catalog(clone, new_raw, new_sig, branch="rotation-branch")
    rotation_commit = cc.fetch_ref(clone, "rotation-branch")
    rotation_raw, _sha = cc.read_catalog_at_commit(clone, rotation_commit)
    assert rotation_raw == new_raw
    # main on the shared origin must be COMPLETELY untouched by a sign that
    # was reviewed and pushed against rotation-branch.
    main_commit = cc.fetch_ref(clone, "main")
    main_raw, _sha = cc.read_catalog_at_commit(clone, main_commit)
    assert main_raw == _SEED_CATALOG
 def test_commit_and_push_signed_catalog_still_defaults_to_main(tmp_path):
    """Backward-compatible default: callers that don't pass `branch` (there
    are none left in catalog_console.py itself, but the signature keeps the
    default for any other caller / test fixture) still push to main."""
    _origin, clone = _init_bare_and_clone(tmp_path)
    new_raw = b'{"schema": 1, "version": 2, "servers": []}'
    new_sig = b"\x01" * 64
    cc.commit_and_push_signed_catalog(clone, new_raw, new_sig)
    main_commit = cc.fetch_ref(clone, "main")
    main_raw, _sha = cc.read_catalog_at_commit(clone, main_commit)
    assert main_raw == new_raw
    rotation_commit = cc.fetch_ref(clone, "rotation-branch")
    rotation_raw, _sha = cc.read_catalog_at_commit(clone, rotation_commit)
    assert rotation_raw == _SEED_CATALOG  # untouched
 # --------------------------------------------------------------------------- #
 # catalog_sig_status_on_disk: the check behind `keys`' "does catalog.json.sig
 # currently verify?" line -- this is precisely the check that would have
 # caught the current chore/68-key-rotation state (bcc_core.CATALOG_PUBKEYS
 # rotated, data/catalog.json.sig still signed by the retired key).
 # --------------------------------------------------------------------------- #
 def test_catalog_sig_status_on_disk_valid(tmp_path):
    seed, pub = review.generate_keypair()
    raw = b'{"schema": 1, "version": 1, "servers": []}'
    sig = review.sign_catalog_bytes(raw, seed)
    (tmp_path / "data").mkdir()
    (tmp_path / "data" / "catalog.json").write_bytes(raw)
    (tmp_path / "data" / "catalog.json.sig").write_bytes(sig)
    assert cc.catalog_sig_status_on_disk(tmp_path, [pub]) == "valid"
 def test_catalog_sig_status_on_disk_invalid_when_pubkey_rotated(tmp_path):
    """The exact chore/68-key-rotation scenario: signed by an OLD key, but
    the committed pubkey list now only has the NEW key."""
    old_seed, _old_pub = review.generate_keypair()
    _new_seed, new_pub = review.generate_keypair()
    raw = b'{"schema": 1, "version": 1, "servers": []}'
    sig = review.sign_catalog_bytes(raw, old_seed)
    (tmp_path / "data").mkdir()
    (tmp_path / "data" / "catalog.json").write_bytes(raw)
    (tmp_path / "data" / "catalog.json.sig").write_bytes(sig)
    assert cc.catalog_sig_status_on_disk(tmp_path, [new_pub]) == "invalid"
 def test_catalog_sig_status_on_disk_missing_when_no_sig_file(tmp_path):
    (tmp_path / "data").mkdir()
    (tmp_path / "data" / "catalog.json").write_bytes(b"{}")
    assert cc.catalog_sig_status_on_disk(tmp_path, []) == "missing"
 def test_catalog_sig_status_on_disk_missing_when_no_catalog_file(tmp_path):
    (tmp_path / "data").mkdir()
    (tmp_path / "data" / "catalog.json.sig").write_bytes(b"\x00" * 64)
    assert cc.catalog_sig_status_on_disk(tmp_path, []) == "missing"
@@ -1,66 +0,0 @@
 """Asserts the maintainer-only Catalog Console (catalog_console.py,
 catalog_review.py) is never bundled into the release binary.
 A signing/review tool shipping to end users would be an own-goal (issue
 #62): it has no reason to run on a user's machine, and its presence would
 be a confusing artefact of a build that's supposed to be a thin GUI over
 mcpServers config editing."""
 from __future__ import annotations
 from pathlib import Path
 REPO_ROOT = Path(__file__).resolve().parent.parent
 SPEC_PATH = REPO_ROOT / "bcc.spec"
 _EXCLUDED_FILES = ("catalog_console.py", "catalog_review.py")
 def test_spec_file_exists():
    assert SPEC_PATH.exists()
 def test_console_files_not_named_in_spec():
    """The spec text must never reference either maintainer-only module --
    not as the Analysis entry point, not in datas, not anywhere."""
    spec_text = SPEC_PATH.read_text(encoding="utf-8")
    for filename in _EXCLUDED_FILES:
        assert filename not in spec_text, (
            f"{filename} must never be referenced by bcc.spec -- it is a "
            "maintainer-only tool and must not ship to users."
        )
 def test_spec_analysis_entry_point_is_bcc_py_only():
    """PyInstaller's Analysis(...) call determines the dependency-scanned
    entry point(s); it must be bcc.py alone."""
    spec_text = SPEC_PATH.read_text(encoding="utf-8")
    assert 'Analysis(\n    ["bcc.py"],' in spec_text or 'Analysis(["bcc.py"]' in spec_text, (
        "bcc.spec's Analysis(...) entry point changed shape -- re-verify by hand "
        "that catalog_console.py / catalog_review.py are still excluded."
    )
 def test_console_modules_exist_but_are_standalone_top_level_files():
    """Sanity check the files this test is guarding actually exist as
    top-level modules (not, say, silently moved into a package PyInstaller's
    Analysis would still pick up as an implicit import of bcc.py)."""
    for filename in _EXCLUDED_FILES:
        assert (REPO_ROOT / filename).exists()
        # bcc.py must not import them.
        bcc_text = (REPO_ROOT / "bcc.py").read_text(encoding="utf-8")
        module_name = filename.removesuffix(".py")
        assert f"import {module_name}" not in bcc_text
        assert f"from {module_name}" not in bcc_text
 def test_requirements_files_do_not_reference_console_only_needs():
    """catalog_console.py's only import beyond the shipped stack is the
    optional `keyring` package, which is intentionally NOT added as a hard
    dependency anywhere a user install would pick it up."""
    for req_file in ("requirements.txt", "requirements-dev.txt"):
        path = REPO_ROOT / req_file
        if not path.exists():
            continue
        text = path.read_text(encoding="utf-8").lower()
        assert "keyring" not in text
@@ -1,234 +0,0 @@
 """Tests for scripts/sign_checksums.py: SHA256SUMS generation and detached
 Ed25519 signing/verification for release artifacts."""
 from __future__ import annotations
 import base64
 import subprocess
 import sys
 from pathlib import Path
 import pytest
 sys.path.insert(0, str(Path(__file__).resolve().parent.parent / "scripts"))
 import sign_checksums as sc
 cryptography = pytest.importorskip("cryptography")
 from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PrivateKey  # noqa: E402
 from cryptography.hazmat.primitives.serialization import Encoding, PublicFormat  # noqa: E402
 def _make_keypair() -> tuple[str, str]:
    """Return (seed_b64, pubkey_b64) for a fresh Ed25519 keypair."""
    private_key = Ed25519PrivateKey.generate()
    seed = private_key.private_bytes_raw()
    pubkey = private_key.public_key().public_bytes(Encoding.Raw, PublicFormat.Raw)
    return base64.b64encode(seed).decode("ascii"), base64.b64encode(pubkey).decode("ascii")
 # --------------------------------------------------------------------------- #
 # sha256_file / build_checksums_text / generate_checksums
 # --------------------------------------------------------------------------- #
 def test_sha256_file_matches_hashlib(tmp_path):
    f = tmp_path / "a.txt"
    f.write_bytes(b"hello world")
    import hashlib
    assert sc.sha256_file(f) == hashlib.sha256(b"hello world").hexdigest()
 def test_build_checksums_text_sorted_and_formatted():
    files = {"zeta.zip": "aa" * 32, "alpha.zip": "bb" * 32}
    text = sc.build_checksums_text(files)
    lines = text.splitlines()
    assert lines[0].endswith("alpha.zip")
    assert lines[1].endswith("zeta.zip")
    # Standard sha256sum format: hash, two spaces, filename.
    assert lines[0] == f"{'bb' * 32}  alpha.zip"
 def test_build_checksums_text_empty():
    assert sc.build_checksums_text({}) == ""
 def test_generate_checksums_from_directory(tmp_path):
    (tmp_path / "b.bin").write_bytes(b"second")
    (tmp_path / "a.bin").write_bytes(b"first")
    (tmp_path / "subdir").mkdir()
    (tmp_path / "subdir" / "ignored.bin").write_bytes(b"nested, not hashed")
    text = sc.generate_checksums(tmp_path)
    lines = text.splitlines()
    assert len(lines) == 2
    assert lines[0].endswith("a.bin")
    assert lines[1].endswith("b.bin")
    assert "subdir" not in text
 def test_generate_checksums_excludes_manifest_files(tmp_path):
    (tmp_path / "archive.zip").write_bytes(b"payload")
    (tmp_path / "SHA256SUMS").write_text("stale")
    (tmp_path / "SHA256SUMS.sig").write_bytes(b"stale-sig")
    text = sc.generate_checksums(tmp_path, exclude={"SHA256SUMS", "SHA256SUMS.sig"})
    assert "archive.zip" in text
    assert "SHA256SUMS" not in text.replace("archive.zip", "")
 # --------------------------------------------------------------------------- #
 # sign_checksums / verify_checksums
 # --------------------------------------------------------------------------- #
 def test_sign_then_verify_roundtrip():
    seed_b64, pubkey_b64 = _make_keypair()
    sums_text = "deadbeef" * 8 + "  BetterClaudeConfig-Linux.tar.gz\n"
    signature = sc.sign_checksums(seed_b64, sums_text)
    assert len(signature) == 64
    assert sc.verify_checksums(pubkey_b64, sums_text, signature) is True
 def test_verify_rejects_tampered_checksums():
    seed_b64, pubkey_b64 = _make_keypair()
    sums_text = "aa" * 32 + "  file.zip\n"
    signature = sc.sign_checksums(seed_b64, sums_text)
    tampered = "bb" * 32 + "  file.zip\n"
    assert sc.verify_checksums(pubkey_b64, tampered, signature) is False
 def test_verify_rejects_wrong_key():
    seed_b64, _ = _make_keypair()
    _, other_pubkey_b64 = _make_keypair()
    sums_text = "cc" * 32 + "  file.zip\n"
    signature = sc.sign_checksums(seed_b64, sums_text)
    assert sc.verify_checksums(other_pubkey_b64, sums_text, signature) is False
 def test_domain_prefix_is_applied():
    """The signed message must be prefixed, not the raw manifest bytes --
    otherwise a signature over this manifest could be replayed as a
    signature over an unrelated message with the same bytes elsewhere."""
    seed_b64, pubkey_b64 = _make_keypair()
    sums_text = "11" * 32 + "  file.zip\n"
    from cryptography.hazmat.primitives.asymmetric.ed25519 import Ed25519PrivateKey as PK
    seed = base64.b64decode(seed_b64)
    raw_signature = PK.from_private_bytes(seed).sign(sums_text.encode("utf-8"))
    # A signature over the raw (unprefixed) bytes must NOT verify via our
    # domain-separated verify function.
    assert sc.verify_checksums(pubkey_b64, sums_text, raw_signature) is False
    # But our own sign_checksums() output does verify.
    good_signature = sc.sign_checksums(seed_b64, sums_text)
    assert sc.verify_checksums(pubkey_b64, sums_text, good_signature) is True
 def test_sign_checksums_rejects_bad_seed_length():
    bad_seed_b64 = base64.b64encode(b"too-short").decode("ascii")
    with pytest.raises(ValueError):
        sc.sign_checksums(bad_seed_b64, "irrelevant\n")
 def test_verify_checksums_rejects_bad_pubkey_length():
    seed_b64, _ = _make_keypair()
    sig = sc.sign_checksums(seed_b64, "irrelevant\n")
    bad_pubkey_b64 = base64.b64encode(b"too-short").decode("ascii")
    with pytest.raises(ValueError):
        sc.verify_checksums(bad_pubkey_b64, "irrelevant\n", sig)
 def test_public_key_b64_from_seed_matches_generated_pubkey():
    seed_b64, pubkey_b64 = _make_keypair()
    assert sc.public_key_b64_from_seed(seed_b64) == pubkey_b64
 # --------------------------------------------------------------------------- #
 # CLI (end-to-end, via subprocess so argparse wiring is exercised too)
 # --------------------------------------------------------------------------- #
 SCRIPT = Path(__file__).resolve().parent.parent / "scripts" / "sign_checksums.py"
 def _run(*args, env=None):
    return subprocess.run(
        [sys.executable, str(SCRIPT), *args],
        capture_output=True,
        text=True,
        env=env,
    )
 def test_cli_generate_sign_verify_roundtrip(tmp_path, monkeypatch):
    seed_b64, pubkey_b64 = _make_keypair()
    release_dir = tmp_path / "release-files"
    release_dir.mkdir()
    (release_dir / "BetterClaudeConfig-Linux.tar.gz").write_bytes(b"fake archive contents")
    (release_dir / "BetterClaudeConfig-macOS.zip").write_bytes(b"fake zip contents")
    sums_path = release_dir / "SHA256SUMS"
    sig_path = release_dir / "SHA256SUMS.sig"
    gen = _run("generate", str(release_dir), "--out", str(sums_path))
    assert gen.returncode == 0, gen.stderr
    assert sums_path.exists()
    body = sums_path.read_text()
    assert "BetterClaudeConfig-Linux.tar.gz" in body
    assert "BetterClaudeConfig-macOS.zip" in body
    sign = _run("sign", "--sums", str(sums_path), "--out", str(sig_path), "--key-b64", seed_b64)
    assert sign.returncode == 0, sign.stderr
    assert sig_path.exists()
    assert sig_path.stat().st_size == 64
    verify = _run(
        "verify",
        "--sums",
        str(sums_path),
        "--sig",
        str(sig_path),
        "--pubkey-b64",
        pubkey_b64,
    )
    assert verify.returncode == 0, verify.stderr
    assert "OK" in verify.stdout
 def test_cli_sign_without_key_fails_loudly(tmp_path):
    sums_path = tmp_path / "SHA256SUMS"
    sums_path.write_text("aa" * 32 + "  file.zip\n")
    sig_path = tmp_path / "SHA256SUMS.sig"
    import os
    env = {k: v for k, v in os.environ.items() if k != "RELEASE_SIGNING_KEY"}
    result = _run("sign", "--sums", str(sums_path), "--out", str(sig_path), env=env)
    assert result.returncode != 0
    assert not sig_path.exists(), "must never write a bogus/empty signature file"
    assert "no signing key" in result.stderr.lower()
 def test_cli_verify_detects_tampering(tmp_path):
    seed_b64, pubkey_b64 = _make_keypair()
    sums_path = tmp_path / "SHA256SUMS"
    sums_path.write_text("aa" * 32 + "  file.zip\n")
    sig_path = tmp_path / "SHA256SUMS.sig"
    _run("sign", "--sums", str(sums_path), "--out", str(sig_path), "--key-b64", seed_b64)
    sums_path.write_text("bb" * 32 + "  file.zip\n")  # tamper after signing
    verify = _run(
        "verify",
        "--sums",
        str(sums_path),
        "--sig",
        str(sig_path),
        "--pubkey-b64",
        pubkey_b64,
    )
    assert verify.returncode != 0
    assert "FAILED" in verify.stdout + verify.stderr
		`@@ -1,2 +0,0 @@`
			ы<8¶ђt2ішл„»‰/НЕ0Тjcw&`
			`тrH«MўК›єrBL,0AS€!Х2–иже.SТ°ч–'Agm`