Merge PR #64: signed SHA256SUMS for releases (#63)

Publish SHA-256 checksums for every release artifact and sign them with a
domain-separated Ed25519 signature. Skips signing (loudly) if the key secret
is absent rather than failing the release. README documents verification and
states the limit plainly: this proves the file is the one we published; it
does not remove Gatekeeper/SmartScreen warnings.

.github/workflows/ci.yml

@@ -62,8 +62,9 @@ jobs:
 
       # 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
+        run: pip install pytest cryptography
 
       - name: Run tests
         run: python -m pytest -v

.github/workflows/release.yml

@@ -107,11 +107,72 @@ 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) generated via the Catalog Console (#62). 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. Add the secret (base64 raw Ed25519 seed, generated via the Catalog Console, #62) before the next tag."
+
       - name: Create GitHub Release
         uses: softprops/action-gh-release@v2
         with:
@@ -119,7 +180,9 @@ jobs:
           draft: false
           prerelease: false
           generate_release_notes: false
-          files: artifacts/**/*
+          files: |
+            artifacts/**/*
+            release-files/SHA256SUMS*
           body: |
             ## Better Claude Config ${{ github.ref_name }}
 
@@ -139,5 +202,8 @@ 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.

README.md

@@ -19,6 +19,65 @@ 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.
+
+**Release signing public key** (Ed25519, base64, raw 32 bytes):
+
+```
+<PLACEHOLDER — AJ: paste the public key from the Catalog Console (#62) here>
+```
+
+### 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 public key above>"
+```
+
+### 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.
+
 ## Run from source
 
 ```bash
@@ -92,6 +151,7 @@ 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)).
 
 ## Building from source
 

bcc.py

@@ -23,6 +23,7 @@ from PySide6.QtGui import (
     QDesktopServices,
     QGuiApplication,
     QIcon,
+    QKeySequence,
     QPainter,
     QPixmap,
 )
@@ -38,6 +39,7 @@ from PySide6.QtWidgets import (
     QGridLayout,
     QHBoxLayout,
     QHeaderView,
+    QInputDialog,
     QLabel,
     QLineEdit,
     QListWidget,
@@ -1686,11 +1688,45 @@ 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)
-        v.addWidget(self.search_box)
+        search_row.addWidget(self.search_box, 1)
+        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
@@ -1774,6 +1810,12 @@ 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)
@@ -1800,6 +1842,19 @@ 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()
@@ -1892,6 +1947,7 @@ 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:
@@ -1991,6 +2047,73 @@ 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"]
@@ -2309,11 +2432,23 @@ class MainWindow(QMainWindow):
             self.validation_lbl.setStyleSheet(f"color: {WARN};")
             self.save_btn.setEnabled(False)
             return False
-        self.validation_lbl.setText("✓ valid")
-        self.validation_lbl.setStyleSheet(f"color: {GOOD};")
+        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

bcc.spec

@@ -78,8 +78,8 @@ if sys.platform == "darwin":
         info_plist={
             "CFBundleName": "Better Claude Config",
             "CFBundleDisplayName": "Better Claude Config",
-            "CFBundleShortVersionString": "1.2.1",
-            "CFBundleVersion": "1.2.1",
+            "CFBundleShortVersionString": "1.3.0",
+            "CFBundleVersion": "1.3.0",
             "NSHighResolutionCapable": True,
             "NSRequiresAquaSystemAppearance": False,  # supports dark mode
             "LSMinimumSystemVersion": "11.0",

bcc_core.py

@@ -39,6 +39,12 @@ CONFIG_FILENAME = "claude_desktop_config.json"
 # we can toggle it back on without losing the definition.
 DISABLED_KEY = "_disabledMcpServers"
 
+# Named server sets: {set_name: [enabled server names]}. Same pattern as
+# DISABLED_KEY — a bcc-owned key Claude ignores, stored in the config file so
+# sets travel with it. Applying a set enables exactly the listed servers and
+# parks the rest under DISABLED_KEY.
+SETS_KEY = "_bccServerSets"
+
 BACKUP_DIRNAME = ".bcc_backups"
 MAX_BACKUPS = 15
 
@@ -59,7 +65,7 @@ KNOWN_FIELDS = {"command", "args", "env", "url", "type", "headers"}
 # binary. All network I/O here is fail-quiet (returns None on any problem)
 # so it's safe to run unattended, off the UI thread, at startup.
 # --------------------------------------------------------------------------- #
-__version__ = "1.2.1"
+__version__ = "1.3.0"
 
 REPO_URL = "https://git.avezzano.io/the_og/better-claude-config"
 ISSUES_URL = f"{REPO_URL}/issues"
@@ -282,10 +288,43 @@ def msix_warning_text(
     )
 
 
+def discover_project_configs(claude_json_path: str | os.PathLike) -> list[Profile]:
+    """
+    Find project-scope `.mcp.json` configs known to Claude Code.
+
+    `~/.claude.json` keeps a `projects` map keyed by absolute project
+    directory path (that's what the CLI writes as it's used in each repo).
+    Any project whose directory has a `.mcp.json` file next to it -- a
+    standalone file with a top-level `mcpServers` object, same shape BCC
+    already edits -- is surfaced here as its own profile so it can be opened
+    via 'Add config...' without hunting for the path by hand.
+
+    Fails quiet: a missing/unreadable/malformed `claude_json_path`, or a
+    `projects` value that isn't a dict, just yields an empty list rather than
+    raising -- this is best-effort discovery, not a required config load.
+    """
+    try:
+        cfg = load_config(claude_json_path)
+    except Exception:
+        return []
+    projects = cfg.get("projects")
+    if not isinstance(projects, dict):
+        return []
+    out: list[Profile] = []
+    for key in sorted(k for k in projects if isinstance(k, str)):
+        mcp_path = Path(key) / ".mcp.json"
+        if mcp_path.is_file():
+            out.append(
+                Profile(label=f"Project: {Path(key).name}", path=mcp_path, config_exists=True)
+            )
+    return out
+
+
 def discover_profiles() -> list[Profile]:
     """
     Find every `Claude*` data directory in the platform's app-support base
-    (Claude Desktop installs), then also check for a Claude Code global config.
+    (Claude Desktop installs), then also check for a Claude Code global config
+    and any project-scope `.mcp.json` configs it knows about.
 
     Claude Desktop: scans the platform app-support folder for any `Claude*`
     directory (catches `Claude`, `Claude-Work`, etc.).
@@ -298,6 +337,10 @@ def discover_profiles() -> list[Profile]:
     `claude mcp add` writes; project scope is a per-repo .mcp.json, which can
     be opened via 'Add config…'). NOT ~/.claude/settings.json — that file is
     for permissions/hooks and rejects an mcpServers key with a schema error.
+    Project scope: ~/.claude.json also tracks a `projects` map, one entry per
+    directory Claude Code has been run in; any of those with a `.mcp.json`
+    file are surfaced as their own profiles too (see
+    `discover_project_configs`).
     """
     base = app_support_base()
     out: list[Profile] = []
@@ -319,6 +362,12 @@ def discover_profiles() -> list[Profile]:
     cc_cfg = home / ".claude.json"
     out.append(Profile(label="Claude Code", path=cc_cfg, config_exists=cc_cfg.is_file()))
 
+    existing_paths = {str(p.path) for p in out}
+    for proj in discover_project_configs(cc_cfg):
+        if str(proj.path) not in existing_paths:
+            existing_paths.add(str(proj.path))
+            out.append(proj)
+
     # Legacy: earlier BCC versions (and hand-edits) may have parked servers in
     # ~/.claude/settings.json, where Claude Code ignores them. Surface that
     # file only when it actually contains an mcpServers block, so the user can
@@ -409,6 +458,70 @@ def extract_servers(cfg: dict) -> list[ServerEntry]:
     return out
 
 
+# --------------------------------------------------------------------------- #
+# Named server sets (issue #52)
+# --------------------------------------------------------------------------- #
+def list_server_sets(cfg: dict) -> dict[str, list[str]]:
+    """
+    Return {set_name: [enabled server names]} from cfg's SETS_KEY.
+
+    Fail-soft: entries whose value isn't a list of strings (hand-edited or
+    corrupted) are skipped rather than raising, so one bad set never hides
+    the rest.
+    """
+    raw = cfg.get(SETS_KEY)
+    if not isinstance(raw, dict):
+        return {}
+    out: dict[str, list[str]] = {}
+    for name, members in raw.items():
+        if isinstance(members, list) and all(isinstance(m, str) for m in members):
+            out[str(name)] = list(members)
+    return out
+
+
+def save_server_set(cfg: dict, name: str, servers: list[ServerEntry]) -> list[str]:
+    """
+    Snapshot the current enabled-server names into cfg under SETS_KEY as
+    `name` (overwriting an existing set of that name). Returns the saved
+    member list. The caller decides when cfg reaches disk (normal Save flow).
+    """
+    members = [s.name for s in servers if s.enabled]
+    sets = cfg.get(SETS_KEY)
+    if not isinstance(sets, dict):
+        sets = {}
+        cfg[SETS_KEY] = sets
+    sets[name] = members
+    return members
+
+
+def delete_server_set(cfg: dict, name: str) -> bool:
+    """Remove set `name` from cfg. Drops SETS_KEY entirely when the last set
+    goes, so untouched configs don't grow an empty bcc key. Returns True if
+    something was deleted."""
+    sets = cfg.get(SETS_KEY)
+    if not isinstance(sets, dict) or name not in sets:
+        return False
+    del sets[name]
+    if not sets:
+        cfg.pop(SETS_KEY, None)
+    return True
+
+
+def apply_server_set(servers: list[ServerEntry], enabled_names: list[str]) -> list[str]:
+    """
+    Enable exactly the servers named in `enabled_names`; disable every other
+    entry (in place). Returns the set members that no longer exist in
+    `servers` — the caller surfaces those as a warning, and the rest of the
+    set still applies.
+    """
+    wanted = set(enabled_names)
+    present: set[str] = set()
+    for s in servers:
+        s.enabled = s.name in wanted
+        present.add(s.name)
+    return sorted(wanted - present)
+
+
 def resolve_name_collision(name: str, existing: set[str]) -> str:
     """
     Return a name guaranteed not to collide with `existing`.
@@ -1213,6 +1326,63 @@ def validate_servers(servers: list[ServerEntry]) -> list[str]:
     return problems
 
 
+def lint_server(name: str, data: dict) -> list[str]:
+    """Return non-blocking structural warnings for a single server definition.
+
+    Unlike validate_servers, nothing here blocks Save -- these are advisory
+    notes about shapes that will round-trip through JSON fine but are
+    probably not what the user intended (args given as a plain string
+    instead of a list, an env value that isn't a string, an unrecognized
+    `type`, unknown top-level fields, etc.).
+    """
+    nm = name.strip() or "(unnamed)"
+    warnings: list[str] = []
+
+    if "command" in data and not isinstance(data["command"], str):
+        warnings.append(f"'{nm}': 'command' should be a string")
+
+    if "args" in data:
+        args = data["args"]
+        if not isinstance(args, list):
+            warnings.append(f"'{nm}': 'args' should be a list (one argument per item)")
+        elif any(not isinstance(a, str) for a in args):
+            warnings.append(
+                f"'{nm}': 'args' contains non-string values "
+                "(they will be saved as-is; Claude expects strings)"
+            )
+
+    for field in ("env", "headers"):
+        if field not in data:
+            continue
+        val = data[field]
+        if not isinstance(val, dict):
+            warnings.append(f"'{nm}': '{field}' should be an object of string key/value pairs")
+        elif any(not isinstance(v, str) for v in val.values()):
+            warnings.append(
+                f"'{nm}': '{field}' contains non-string values "
+                "(they will be saved as-is; Claude expects strings)"
+            )
+
+    if "type" in data:
+        t = data["type"]
+        if t not in ("http", "sse", "stdio"):
+            warnings.append(f"'{nm}': 'type' should be one of http, sse, stdio (found {t!r})")
+
+    extra = sorted(k for k in data if k not in KNOWN_FIELDS)
+    if extra:
+        warnings.append(f"'{nm}': extra fields preserved as-is: {', '.join(extra)}")
+
+    return warnings
+
+
+def lint_servers(servers: list[ServerEntry]) -> list[str]:
+    """Concatenate lint_server warnings across every entry, in order."""
+    out: list[str] = []
+    for s in servers:
+        out.extend(lint_server(s.name, s.data))
+    return out
+
+
 # --------------------------------------------------------------------------- #
 # Search / filter
 # --------------------------------------------------------------------------- #

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "better-claude-config"
-version = "1.2.1"
+version = "1.3.0"
 description = "Cross-platform GUI for editing the mcpServers block of Claude Desktop and Claude Code configs"
 readme = "README.md"
 license = { file = "LICENSE" }

requirements-dev.txt

@@ -8,3 +8,4 @@ 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)

scripts/sign_checksums.py

@@ -0,0 +1,235 @@
+#!/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|"
+
+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")
+
+
+# --------------------------------------------------------------------------- #
+# 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())

tests/test_checksums.py

@@ -0,0 +1,234 @@
+"""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

tests/test_core.py

@@ -67,6 +67,64 @@ def test_legacy_settings_json_surfaced_only_with_servers(fake_home):
     assert any("legacy" in p.label for p in c.discover_profiles())
 
 
+def test_project_with_mcp_json_is_discovered(tmp_path):
+    proj = tmp_path / "my-project"
+    proj.mkdir()
+    (proj / ".mcp.json").write_text('{"mcpServers": {"x": {"command": "npx"}}}')
+    claude_json = tmp_path / ".claude.json"
+    claude_json.write_text(json.dumps({"projects": {str(proj): {}}}))
+
+    profs = c.discover_project_configs(claude_json)
+    assert len(profs) == 1
+    assert profs[0].label == f"Project: {proj.name}"
+    assert profs[0].path == proj / ".mcp.json"
+    assert profs[0].config_exists
+
+
+def test_project_without_mcp_json_not_listed(tmp_path):
+    proj = tmp_path / "no-mcp-project"
+    proj.mkdir()
+    claude_json = tmp_path / ".claude.json"
+    claude_json.write_text(json.dumps({"projects": {str(proj): {}}}))
+
+    assert c.discover_project_configs(claude_json) == []
+
+
+def test_projects_missing_or_not_dict_yields_no_profiles(tmp_path):
+    claude_json = tmp_path / ".claude.json"
+
+    claude_json.write_text(json.dumps({}))
+    assert c.discover_project_configs(claude_json) == []
+
+    claude_json.write_text(json.dumps({"projects": ["not", "a", "dict"]}))
+    assert c.discover_project_configs(claude_json) == []
+
+
+def test_malformed_claude_json_fails_quiet(fake_home):
+    (fake_home / ".claude.json").write_text("{not valid json")
+    assert c.discover_project_configs(fake_home / ".claude.json") == []
+    # discover_profiles as a whole must still work and just skip project profiles
+    profs = c.discover_profiles()
+    assert not any(p.label.startswith("Project:") for p in profs)
+
+
+def test_project_configs_deduped_against_existing_profiles(fake_home):
+    # Point a project directly at the Claude Code profile's own .mcp.json-shaped
+    # path to prove discover_profiles() won't duplicate an already-listed path.
+    proj = fake_home / "dup-project"
+    proj.mkdir()
+    mcp_path = proj / ".mcp.json"
+    mcp_path.write_text('{"mcpServers": {"x": {"command": "npx"}}}')
+    (fake_home / ".claude.json").write_text(json.dumps({"projects": {str(proj): {}}}))
+
+    direct = c.discover_project_configs(fake_home / ".claude.json")
+    assert len(direct) == 1
+
+    profs = c.discover_profiles()
+    project_profiles = [p for p in profs if str(p.path) == str(mcp_path)]
+    assert len(project_profiles) == 1
+
+
 # --------------------------------------------------------------------------- #
 # 2. Write pipeline: preserves other keys + order, only touches mcpServers
 # --------------------------------------------------------------------------- #
@@ -181,6 +239,85 @@ def test_valid_set_passes_clean():
     assert c.validate_servers([c.ServerEntry("good", {"command": "node"}, True)]) == []
 
 
+# --------------------------------------------------------------------------- #
+# 4b. Lint: non-blocking structural warnings
+# --------------------------------------------------------------------------- #
+def test_lint_flags_non_string_command():
+    warnings = c.lint_server("x", {"command": 5})
+    assert any("'command' should be a string" in w for w in warnings)
+
+
+def test_lint_flags_args_not_a_list():
+    warnings = c.lint_server("x", {"command": "node", "args": "-y foo"})
+    assert any("'args' should be a list" in w for w in warnings)
+
+
+def test_lint_flags_args_with_non_string_items():
+    warnings = c.lint_server("x", {"command": "node", "args": ["-y", 5]})
+    assert any("'args' contains non-string values" in w for w in warnings)
+
+
+def test_lint_flags_env_not_a_dict():
+    warnings = c.lint_server("x", {"command": "node", "env": ["FOO=bar"]})
+    assert any("'env' should be an object" in w for w in warnings)
+
+
+def test_lint_flags_env_with_non_string_values():
+    warnings = c.lint_server("x", {"command": "node", "env": {"FOO": 5}})
+    assert any("'env' contains non-string values" in w for w in warnings)
+
+
+def test_lint_flags_headers_not_a_dict():
+    warnings = c.lint_server("x", {"url": "https://x", "headers": ["Authorization: x"]})
+    assert any("'headers' should be an object" in w for w in warnings)
+
+
+def test_lint_flags_headers_with_non_string_values():
+    warnings = c.lint_server("x", {"url": "https://x", "headers": {"Authorization": 5}})
+    assert any("'headers' contains non-string values" in w for w in warnings)
+
+
+def test_lint_flags_bad_type_value():
+    warnings = c.lint_server("x", {"url": "https://x", "type": "websocket"})
+    assert any("'type'" in w and "websocket" in w for w in warnings)
+
+
+def test_lint_flags_extra_unknown_fields():
+    warnings = c.lint_server("x", {"command": "node", "cwd": "/tmp", "timeout": 30})
+    matches = [w for w in warnings if "extra fields preserved as-is" in w]
+    assert len(matches) == 1
+    assert "cwd" in matches[0]
+    assert "timeout" in matches[0]
+
+
+def test_lint_clean_server_yields_no_warnings():
+    assert c.lint_server("good", {"command": "node", "args": ["a.js"]}) == []
+    assert (
+        c.lint_server(
+            "remote", {"url": "https://x", "type": "http", "headers": {"Authorization": "x"}}
+        )
+        == []
+    )
+
+
+def test_lint_servers_aggregates_across_entries():
+    entries = [
+        c.ServerEntry("a", {"command": 5}, True),
+        c.ServerEntry("b", {"url": "https://x", "type": "bogus"}, True),
+    ]
+    warnings = c.lint_servers(entries)
+    assert any("'a'" in w and "'command' should be a string" in w for w in warnings)
+    assert any("'b'" in w and "'type'" in w for w in warnings)
+
+
+def test_lint_warning_is_not_a_blocking_problem():
+    # args given as a single string isn't caught by validate_servers (a
+    # command is still present), but it's a lint warning.
+    entry = c.ServerEntry("x", {"command": "node", "args": "-y foo"}, True)
+    assert c.validate_servers([entry]) == []
+    assert c.lint_servers([entry]) != []
+
+
 # --------------------------------------------------------------------------- #
 # 5. Secrets: detection + redaction
 # --------------------------------------------------------------------------- #
@@ -769,6 +906,68 @@ def test_args_secret_warning_empty():
     assert c.args_secret_warning({"args": []}) is None
 
 
+# --------------------------------------------------------------------------- #
+# Named server sets (issue #52)
+# --------------------------------------------------------------------------- #
+def _three_servers():
+    return [
+        c.ServerEntry("alpha", {"command": "npx"}, True),
+        c.ServerEntry("beta", {"command": "uvx"}, True),
+        c.ServerEntry("gamma", {"url": "https://x.example/mcp"}, False),
+    ]
+
+
+def test_save_and_list_server_sets_roundtrip():
+    cfg: dict = {}
+    members = c.save_server_set(cfg, "webdev", _three_servers())
+    assert members == ["alpha", "beta"]  # only the enabled ones
+    assert c.list_server_sets(cfg) == {"webdev": ["alpha", "beta"]}
+
+
+def test_apply_server_set_enables_exactly_the_members():
+    servers = _three_servers()
+    missing = c.apply_server_set(servers, ["gamma"])
+    assert missing == []
+    assert [s.enabled for s in servers] == [False, False, True]
+
+
+def test_apply_server_set_reports_missing_members():
+    servers = _three_servers()
+    missing = c.apply_server_set(servers, ["alpha", "vanished", "gone"])
+    assert missing == ["gone", "vanished"]
+    assert [s.enabled for s in servers] == [True, False, False]  # rest still applied
+
+
+def test_delete_server_set_drops_empty_key():
+    cfg: dict = {}
+    c.save_server_set(cfg, "only", _three_servers())
+    assert c.delete_server_set(cfg, "only") is True
+    assert c.SETS_KEY not in cfg  # no empty bcc key left behind
+    assert c.delete_server_set(cfg, "only") is False
+
+
+def test_server_sets_survive_write_and_reload(tmp_path):
+    cfgpath = tmp_path / "cfg.json"
+    cfg = {"mcpServers": {"alpha": {"command": "npx"}}}
+    c.save_server_set(cfg, "webdev", [c.ServerEntry("alpha", {"command": "npx"}, True)])
+    c.write_config(cfgpath, cfg)
+    reloaded = c.load_config(cfgpath)
+    assert c.list_server_sets(reloaded) == {"webdev": ["alpha"]}
+
+
+def test_apply_servers_preserves_sets_key():
+    cfg: dict = {"mcpServers": {}}
+    c.save_server_set(cfg, "s", [c.ServerEntry("alpha", {"command": "npx"}, True)])
+    c.apply_servers(cfg, _three_servers())
+    assert c.SETS_KEY in cfg  # the server writer never touches sets
+
+
+def test_list_server_sets_skips_malformed_entries():
+    cfg = {c.SETS_KEY: {"good": ["a"], "bad-not-list": "a", "bad-items": ["a", 3]}}
+    assert c.list_server_sets(cfg) == {"good": ["a"]}
+    assert c.list_server_sets({c.SETS_KEY: "junk"}) == {}
+
+
 # --------------------------------------------------------------------------- #
 # resolve_name_collision (paste/import duplicate-name handling — issue #8)
 # --------------------------------------------------------------------------- #