Merge pull request 'fix: spawn_test never raises — str-coerce env/command, wrap unexpected errors (#34)' (#41) from fix/34-spawn-test-env into main

Closes #34

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

bcc.py

@@ -72,6 +72,12 @@ WARN = "#fbbf24"
 STATUS_COLORS = {"ok": GOOD, "missing": BAD, "warn": WARN, "remote": "#60a5fa", "unknown": WARN}
 STATUS_GLYPH = {"ok": "●", "missing": "●", "warn": "▲", "remote": "◆", "unknown": "○"}
 
+# Health dot (spawn-test outcome, see core.HealthStatus) shown per row in the
+# server tables' "Health" column -- distinct from the PATH-dependency Status
+# column above.
+HEALTH_COLORS = {"ok": GOOD, "failed": BAD, "untested": MUTED}
+HEALTH_GLYPH = {"ok": "●", "failed": "●", "untested": "○"}
+
 STYLESHEET = f"""
 /* No font-family here on purpose: Qt already uses the native system UI font
    on every platform (San Francisco / Segoe UI / desktop default). Naming
@@ -1247,6 +1253,31 @@ class LogViewerDialog(QDialog):
         super().closeEvent(event)
 
 
+# --------------------------------------------------------------------------- #
+# Bundled assets (icons) — resolves both a normal source run and a frozen
+# PyInstaller build (onefile extracts assets under sys._MEIPASS).
+# --------------------------------------------------------------------------- #
+def _asset_dir() -> Path:
+    base = getattr(sys, "_MEIPASS", None)
+    return Path(base) if base else Path(__file__).resolve().parent
+
+
+def _app_icon() -> QIcon:
+    """Multi-resolution app/window icon from the bundled PNGs (falls back to
+    the .ico). Returns a null QIcon if no asset is found."""
+    icon = QIcon()
+    base = _asset_dir() / "icons" / "twin-gears" / "rounded"
+    for size in (16, 32, 48, 64, 128, 256, 512):
+        f = base / f"icon-{size}.png"
+        if f.is_file():
+            icon.addFile(str(f))
+    if icon.isNull():
+        ico = _asset_dir() / "icons" / "app.ico"
+        if ico.is_file():
+            icon.addFile(str(ico))
+    return icon
+
+
 # --------------------------------------------------------------------------- #
 # About dialog
 # --------------------------------------------------------------------------- #
@@ -1268,9 +1299,7 @@ class AboutDialog(QDialog):
         self._worker: UpdateCheckWorker | None = None
         self._release_url: str | None = None
 
-        icon_path = (
-            Path(__file__).resolve().parent / "icons" / "twin-gears" / "rounded" / "icon-128.png"
-        )
+        icon_path = _asset_dir() / "icons" / "twin-gears" / "rounded" / "icon-128.png"
         if icon_path.is_file():
             self.setWindowIcon(QIcon(str(icon_path)))
 
@@ -1416,6 +1445,12 @@ class MainWindow(QMainWindow):
         self._focused_table = None
         self._row_of_index: dict[int, tuple] = {}
         self._undo_stack: list[list] = []  # each entry: snapshot of self.servers
+        self._filter_query = ""
+        self._health: dict[str, tuple[str, str]] = {}  # server name -> (HealthStatus, summary)
+        self._test_all_queue: list[core.ServerEntry] = []
+        self._test_all_total = 0
+        self._test_all_done = 0
+        self._health_tester: SpawnTester | None = None
 
         central = QWidget()
         self.setCentralWidget(central)
@@ -1533,10 +1568,10 @@ class MainWindow(QMainWindow):
 
     # --- left (server table) -------------------------------------------- #
     def _make_server_table(self, object_name=None):
-        t = QTableWidget(0, 4)
+        t = QTableWidget(0, 5)
         if object_name:
             t.setObjectName(object_name)
-        t.setHorizontalHeaderLabels(["On", "Name", "Type", "Status"])
+        t.setHorizontalHeaderLabels(["On", "Name", "Type", "Status", "Health"])
         t.verticalHeader().setVisible(False)
         t.setSelectionBehavior(QAbstractItemView.SelectionBehavior.SelectRows)
         t.setSelectionMode(QAbstractItemView.SelectionMode.SingleSelection)
@@ -1546,6 +1581,7 @@ class MainWindow(QMainWindow):
         h.setSectionResizeMode(1, QHeaderView.ResizeMode.Stretch)
         h.setSectionResizeMode(2, QHeaderView.ResizeMode.ResizeToContents)
         h.setSectionResizeMode(3, QHeaderView.ResizeMode.ResizeToContents)
+        h.setSectionResizeMode(4, QHeaderView.ResizeMode.ResizeToContents)
         t.itemSelectionChanged.connect(lambda tbl=t: self._on_selection(tbl))
         t.itemChanged.connect(self._table_item_changed)
         return t
@@ -1560,6 +1596,12 @@ class MainWindow(QMainWindow):
         head.setObjectName("h1")
         v.addWidget(head)
 
+        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)
+
         # Active and Disabled sections live in a vertical splitter so the user
         # can drag the divider instead of being stuck with a fixed-height
         # disabled list.
@@ -1616,12 +1658,17 @@ class MainWindow(QMainWindow):
         self.undo_btn = QPushButton("Undo")
         self.undo_btn.setEnabled(False)
         self.undo_btn.setToolTip("Undo last change  (Ctrl+Z)")
+        self.test_all_btn = QPushButton("Test all")
+        self.test_all_btn.setToolTip(
+            "Spawn-test every enabled local server, one at a time, and fill in the Health column"
+        )
         self.add_btn.clicked.connect(self.add_server)
         self.dup_btn.clicked.connect(self.duplicate_server)
         self.del_btn.clicked.connect(self.delete_server)
         self.paste_btn.clicked.connect(self.paste_json)
         self.copy_btn.clicked.connect(self.copy_to_menu)
         self.undo_btn.clicked.connect(self._undo)
+        self.test_all_btn.clicked.connect(self._test_all_servers)
         for b in (
             self.add_btn,
             self.dup_btn,
@@ -1629,6 +1676,7 @@ class MainWindow(QMainWindow):
             self.paste_btn,
             self.copy_btn,
             self.undo_btn,
+            self.test_all_btn,
         ):
             bar.addWidget(b)
         # Ctrl+Z shortcut
@@ -1679,6 +1727,22 @@ class MainWindow(QMainWindow):
             self.load_profile(self.profiles[0])
         else:
             self.status.setText('No Claude installs found. Use "Add config…" to point at one.')
+        self._maybe_warn_msix()
+
+    def _maybe_warn_msix(self):
+        """
+        Windows-only, no-op everywhere else: if Claude Desktop looks like an
+        MSIX/Store install with a virtualized config, append a warning to the
+        status bar so edits to the plain %APPDATA% path aren't silently lost.
+        Defensive on purpose -- this must never block startup or profile load.
+        """
+        try:
+            warning = core.msix_warning_text()
+        except Exception:
+            return
+        if warning:
+            self.status.setText(f"{self.status.text()}  ⚠ {warning}")
+            self.status.setToolTip(warning)
 
     def add_custom_config(self):
         start = str(core.app_support_base())
@@ -1733,6 +1797,7 @@ class MainWindow(QMainWindow):
         self.restart_btn.hide()
         self._undo_stack.clear()
         self.undo_btn.setEnabled(False)
+        self._health.clear()  # health results are per-profile; a fresh load invalidates them
         self._refresh_tables(select_index=0 if self.servers else -1)
         self._update_status(saved=False)
         if repaired:
@@ -1769,6 +1834,14 @@ class MainWindow(QMainWindow):
             QColor(STATUS_COLORS.get(dep["status"], MUTED))
         )  # status stays colored even when off
         table.setItem(r, 3, st)
+        health_status, health_summary = self._health.get(s.name, (core.HealthStatus.UNTESTED, ""))
+        if s.kind == "remote" and s.name not in self._health:
+            health_summary = "remote server — use “Test connection” in the editor"
+        health_item = QTableWidgetItem(HEALTH_GLYPH.get(health_status, "○"))
+        health_item.setForeground(QColor(HEALTH_COLORS.get(health_status, MUTED)))
+        health_item.setTextAlignment(Qt.AlignmentFlag.AlignCenter)
+        health_item.setToolTip(health_summary or health_status)
+        table.setItem(r, 4, health_item)
         self._row_of_index[master_idx] = (table, r)
 
     def _refresh_tables(self, select_index=None):
@@ -1777,8 +1850,16 @@ class MainWindow(QMainWindow):
         self._row_of_index = {}
         self.active_table.setRowCount(0)
         self.disabled_table.setRowCount(0)
+        query = self._filter_query
         n_active = n_disabled = 0
+        total_active = total_disabled = 0
         for i, s in enumerate(self.servers):
+            if s.enabled:
+                total_active += 1
+            else:
+                total_disabled += 1
+            if not core.server_matches_filter(s, query):
+                continue
             if s.enabled:
                 self._add_row(self.active_table, i, s)
                 n_active += 1
@@ -1787,8 +1868,18 @@ class MainWindow(QMainWindow):
                 n_disabled += 1
         self.active_table.setVisible(n_active > 0)
         self.active_empty.setVisible(n_active == 0)
+        self.active_empty.setText(
+            "No matches."
+            if query.strip() and total_active and not n_active
+            else "No active servers. Add one, or Paste JSON."
+        )
         self.disabled_table.setVisible(n_disabled > 0)
         self.disabled_empty.setVisible(n_disabled == 0)
+        self.disabled_empty.setText(
+            "No matches."
+            if query.strip() and total_disabled and not n_disabled
+            else "Nothing disabled."
+        )
         self._refresh_badges()
         self._suppress_table = False
         self._suppress_sel = False
@@ -1800,6 +1891,58 @@ class MainWindow(QMainWindow):
             self._load_editor_from_selection()
         self._validate()
 
+    # --- search / filter -------------------------------------------------- #
+    def _on_search_changed(self, text):
+        self._filter_query = text
+        cur = self._current_index()
+        self._refresh_tables(select_index=cur if cur >= 0 else None)
+
+    # --- 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"]
+        if not targets:
+            self.status.setText("No enabled local servers to test.")
+            return
+        self._test_all_queue = list(targets)
+        self._test_all_total = len(targets)
+        self._test_all_done = 0
+        self.test_all_btn.setEnabled(False)
+        self.test_all_btn.setText(f"Testing 0/{self._test_all_total}…")
+        self._run_next_health_test()
+
+    def _run_next_health_test(self):
+        if not self._test_all_queue:
+            self.test_all_btn.setEnabled(True)
+            self.test_all_btn.setText("Test all")
+            self.status.setText(f"Tested {self._test_all_done} server(s).")
+            return
+        entry = self._test_all_queue.pop(0)
+        self._health_tester = SpawnTester(dict(entry.data), timeout=3.0)
+        self._health_tester.done.connect(
+            lambda result, name=entry.name: self._on_health_test_done(name, result)
+        )
+        self._health_tester.start()
+
+    def _on_health_test_done(self, name, result):
+        status, summary = core.health_from_spawn_result(result)
+        self._health[name] = (status, summary)
+        self._test_all_done += 1
+        self.test_all_btn.setText(f"Testing {self._test_all_done}/{self._test_all_total}…")
+        self._update_health_cell(name, status, summary)
+        self._run_next_health_test()
+
+    def _update_health_cell(self, name, status, summary):
+        idx = next((i for i, s in enumerate(self.servers) if s.name == name), None)
+        if idx is None or idx not in self._row_of_index:
+            return
+        table, row = self._row_of_index[idx]
+        item = table.item(row, 4)
+        if item is None:
+            return
+        item.setText(HEALTH_GLYPH.get(status, "○"))
+        item.setForeground(QColor(HEALTH_COLORS.get(status, MUTED)))
+        item.setToolTip(summary or status)
+
     def _section_html(self, title, n, miss, warn):
         base = f"{title}  ·  {n}"
         if miss:
@@ -1906,6 +2049,9 @@ class MainWindow(QMainWindow):
         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.
+        self._health.pop(entry.name, None)
         loc = self._row_of_index.get(idx)
         if loc:
             table, row = loc
@@ -1916,6 +2062,13 @@ class MainWindow(QMainWindow):
             st = table.item(row, 3)
             st.setText(f"{STATUS_GLYPH.get(dep['status'], '○')}  {dep['label']}")
             st.setForeground(QColor(STATUS_COLORS.get(dep["status"], MUTED)))
+            health_item = table.item(row, 4)
+            if health_item is not None:
+                health_item.setText(HEALTH_GLYPH.get(core.HealthStatus.UNTESTED, "○"))
+                health_item.setForeground(
+                    QColor(HEALTH_COLORS.get(core.HealthStatus.UNTESTED, MUTED))
+                )
+                health_item.setToolTip("Not tested since last edit.")
             self._suppress_table = False
         self._refresh_badges()
         self._mark_dirty()
@@ -2236,9 +2389,23 @@ class MainWindow(QMainWindow):
 
 
 def main():
+    if sys.platform == "win32":
+        # Without an explicit AppUserModelID, Windows taskbar groups the app
+        # under the default host/Python icon instead of our own window icon.
+        try:
+            import ctypes
+
+            ctypes.windll.shell32.SetCurrentProcessExplicitAppUserModelID(
+                "io.avezzano.better-claude-config"
+            )
+        except Exception:
+            pass
     app = QApplication(sys.argv)
     app.setApplicationName("Better Claude Config")
     app.setApplicationDisplayName("Better Claude Config")
+    icon = _app_icon()
+    if not icon.isNull():
+        app.setWindowIcon(icon)
     app.setStyleSheet(STYLESHEET)
     win = MainWindow()
     win.show()

bcc.spec

@@ -31,7 +31,7 @@ a = Analysis(
     ["bcc.py"],
     pathex=[],
     binaries=[],
-    datas=[],
+    datas=[("icons", "icons")],
     hiddenimports=[],
     hookspath=[],
     hooksconfig={},

bcc_core.py

@@ -191,6 +191,97 @@ def app_support_base() -> Path:
     return Path(os.environ.get("XDG_CONFIG_HOME", Path.home() / ".config"))
 
 
+def msix_config_paths(localappdata: str | os.PathLike | None = None) -> list[Path]:
+    """
+    Find MSIX/Store-packaged Claude Desktop configs.
+
+    When Claude Desktop is installed from the Microsoft Store (MSIX), Windows
+    virtualizes its filesystem writes to a per-package folder under
+    `%LOCALAPPDATA%\\Packages\\<PackageFamilyName>\\LocalCache\\Roaming\\Claude\\`
+    instead of the normal `%APPDATA%\\Claude\\`. A user (or BCC) editing the
+    plain %APPDATA% path can end up changing a file the running app never
+    reads -- see anthropics/claude-code issues #26073, #29100, #38830.
+
+    Globs `<localappdata>/Packages/*Claude*/LocalCache/Roaming/Claude/
+    claude_desktop_config.json` and returns every match that actually exists,
+    sorted for determinism. `localappdata` defaults to the %LOCALAPPDATA% env
+    var (falling back to the usual Windows path) but is accepted as a
+    parameter so this is unit-testable with tmp_path on any platform.
+
+    This function itself is platform-independent (it just globs whatever
+    directory it's given); callers that care about the *current* machine
+    should gate on sys.platform -- see `detect_msix_claude`.
+    """
+    base = (
+        Path(localappdata)
+        if localappdata is not None
+        else Path(os.environ.get("LOCALAPPDATA", str(Path.home() / "AppData" / "Local")))
+    )
+    packages = base / "Packages"
+    if not packages.is_dir():
+        return []
+    out: list[Path] = []
+    for pkg_dir in sorted(packages.glob("*Claude*")):
+        cfg = pkg_dir / "LocalCache" / "Roaming" / "Claude" / CONFIG_FILENAME
+        if cfg.is_file():
+            out.append(cfg)
+    return out
+
+
+def detect_msix_claude(
+    appdata: str | os.PathLike | None = None,
+    localappdata: str | os.PathLike | None = None,
+) -> Path | None:
+    """
+    Best-effort detection of an MSIX-virtualized Claude Desktop install.
+
+    Returns the first virtualized `claude_desktop_config.json` found (see
+    `msix_config_paths`), or None when not running on Windows, no matching
+    package folder exists, or a package folder exists but has no config file
+    written yet. The sys.platform gate makes this a safe no-op to call
+    unconditionally from discovery/diagnostics code on macOS/Linux.
+
+    `appdata`/`localappdata` are threaded through (rather than read straight
+    from os.environ) purely so the whole detection path is unit-testable via
+    tmp_path + monkeypatch without mutating real env vars.
+    """
+    if not sys.platform.startswith("win"):
+        return None
+    hits = msix_config_paths(localappdata)
+    return hits[0] if hits else None
+
+
+def msix_warning_text(
+    appdata: str | os.PathLike | None = None,
+    localappdata: str | os.PathLike | None = None,
+) -> str | None:
+    """
+    A one-line, paste-safe warning for the diagnostics/status surface when
+    Claude Desktop looks like an MSIX/Store install whose real config lives
+    somewhere other than the plain %APPDATA%\\Claude\\ path. Returns None
+    when nothing was detected (including on non-Windows platforms) or when
+    the virtualized path and the plain path happen to coincide -- i.e. there
+    is nothing surprising to warn about. Contains only filesystem paths, no
+    env values or secrets.
+    """
+    real = detect_msix_claude(appdata, localappdata)
+    if real is None:
+        return None
+    plain_base = (
+        Path(appdata)
+        if appdata is not None
+        else Path(os.environ.get("APPDATA", str(Path.home() / "AppData" / "Roaming")))
+    )
+    plain_cfg = plain_base / "Claude" / CONFIG_FILENAME
+    if plain_cfg == real:
+        return None
+    return (
+        "Claude Desktop looks like it's installed from the Microsoft Store (MSIX). "
+        f"Windows virtualizes its config, so edits to {plain_cfg} may be silently "
+        f"ignored by the running app. The real config is at: {real}"
+    )
+
+
 def discover_profiles() -> list[Profile]:
     """
     Find every `Claude*` data directory in the platform's app-support base
@@ -198,6 +289,11 @@ def discover_profiles() -> list[Profile]:
 
     Claude Desktop: scans the platform app-support folder for any `Claude*`
     directory (catches `Claude`, `Claude-Work`, etc.).
+    Windows/MSIX: if Claude Desktop was installed from the Microsoft Store,
+    its real config lives in a virtualized per-package folder rather than the
+    plain %APPDATA%\\Claude\\ path above (see `detect_msix_claude`); when
+    that's detected, it's surfaced here as its own profile so the user can
+    edit the file the app actually reads.
     Claude Code: user-scope MCP servers live in ~/.claude.json (that's what
     `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
@@ -213,6 +309,12 @@ def discover_profiles() -> list[Profile]:
                 cfg = d / CONFIG_FILENAME
                 out.append(Profile(label=d.name, path=cfg, config_exists=cfg.is_file()))
 
+    msix_cfg = detect_msix_claude()
+    if msix_cfg is not None and str(msix_cfg) not in {str(p.path) for p in out}:
+        out.append(
+            Profile(label="Claude (Microsoft Store / MSIX)", path=msix_cfg, config_exists=True)
+        )
+
     home = Path.home()
     cc_cfg = home / ".claude.json"
     out.append(Profile(label="Claude Code", path=cc_cfg, config_exists=cc_cfg.is_file()))
@@ -1111,6 +1213,32 @@ def validate_servers(servers: list[ServerEntry]) -> list[str]:
     return problems
 
 
+# --------------------------------------------------------------------------- #
+# Search / filter
+# --------------------------------------------------------------------------- #
+def server_matches_filter(entry: ServerEntry, query: str) -> bool:
+    """
+    Case-insensitive substring match against a server's name, and its
+    command (stdio) or url (remote). An empty/whitespace-only query matches
+    everything -- that's what lets the search box double as "no filter".
+    """
+    q = (query or "").strip().lower()
+    if not q:
+        return True
+    if q in entry.name.lower():
+        return True
+    if entry.kind == "remote":
+        haystack = str(entry.data.get("url", ""))
+    else:
+        haystack = str(entry.data.get("command", ""))
+    return q in haystack.lower()
+
+
+def filter_servers(entries: list[ServerEntry], query: str) -> list[ServerEntry]:
+    """Return only the entries that match `query` (see server_matches_filter)."""
+    return [e for e in entries if server_matches_filter(e, query)]
+
+
 # --------------------------------------------------------------------------- #
 # Dependency / PATH checking
 # --------------------------------------------------------------------------- #
@@ -1463,12 +1591,29 @@ def spawn_test(data: dict, timeout: float = 3.0) -> dict:
                 "crashed"        — exited with a non-zero code before timeout
                 "not_found"      — command could not be resolved to an executable
                 "not_applicable" — remote server or no command; nothing to spawn
+                "error"          — unexpected internal failure while spawning/observing
       returncode: int | None
       stderr:    str  (first ~4 KB)
       detail:    str
 
+    Never raises: the GUI threads (Test launch / Test all) re-enable their
+    buttons only when a result arrives, so an escaping exception would leave
+    the UI stuck. Anything unexpected comes back as outcome "error".
+
     Run this off the UI thread — it blocks for up to `timeout` seconds.
     """
+    try:
+        return _spawn_test_impl(data, timeout)
+    except Exception as e:
+        return {
+            "outcome": "error",
+            "returncode": None,
+            "stderr": "",
+            "detail": f"unexpected error: {e!r}",
+        }
+
+
+def _spawn_test_impl(data: dict, timeout: float) -> dict:
     if "url" in data and "command" not in data:
         return {
             "outcome": "not_applicable",
@@ -1477,7 +1622,9 @@ def spawn_test(data: dict, timeout: float = 3.0) -> dict:
             "detail": "remote server",
         }
 
-    cmd = (data.get("command") or "").strip()
+    # str() first: pasted JSON can legally carry a non-string here and the
+    # value never round-trips through the editor before a Test all run.
+    cmd = str(data.get("command") or "").strip()
     if not cmd:
         return {
             "outcome": "not_applicable",
@@ -1499,7 +1646,8 @@ def spawn_test(data: dict, timeout: float = 3.0) -> dict:
     args_list = [resolved_cmd] + [str(a) for a in (data.get("args") or [])]
 
     merged_env = {**os.environ, "PATH": augmented_path()}
-    merged_env.update(data.get("env") or {})
+    # Popen rejects non-string env values; pasted JSON may carry numbers.
+    merged_env.update({str(k): str(v) for k, v in (data.get("env") or {}).items()})
 
     stderr_chunks: list[bytes] = []
 
@@ -1580,6 +1728,53 @@ def spawn_test(data: dict, timeout: float = 3.0) -> dict:
     }
 
 
+# --------------------------------------------------------------------------- #
+# Health status (maps a spawn_test() result to a simple tri-state for the
+# server-list UI's per-row status dot; see "Test all" in bcc.py)
+# --------------------------------------------------------------------------- #
+class HealthStatus:
+    """
+    Tri-state health for the server-list status dot. A plain class of string
+    constants -- not an Enum -- to match the plain-string status values used
+    elsewhere in this module (see check_dependency's 'status').
+    """
+
+    UNTESTED = "untested"
+    OK = "ok"
+    FAILED = "failed"
+
+
+def health_from_spawn_result(result: dict) -> tuple[str, str]:
+    """
+    Map a spawn_test() result dict to (HealthStatus, short_summary) for the
+    server-list status column. Reuses spawn_test's own outcome classification
+    rather than re-deriving pass/fail from returncode/stderr:
+
+      outcome "ok"             -> OK       (server started and kept running)
+      outcome "not_applicable" -> UNTESTED (remote server, or no command set)
+      anything else            -> FAILED   (exited, crashed, or not found)
+
+    The summary is short enough for a table cell/tooltip; when the process
+    wrote to stderr before dying, its first line is appended for context.
+    """
+    outcome = result.get("outcome", "")
+    detail = result.get("detail", "") or ""
+    stderr = (result.get("stderr") or "").strip()
+
+    if outcome == "ok":
+        return HealthStatus.OK, detail or "started"
+    if outcome == "not_applicable":
+        return HealthStatus.UNTESTED, detail or "not applicable"
+
+    # exited / crashed / not_found: the server didn't come up cleanly.
+    summary = detail or outcome
+    if stderr:
+        first_line = stderr.splitlines()[0].strip()
+        if first_line:
+            summary = f"{summary} — {first_line}"
+    return HealthStatus.FAILED, summary
+
+
 def test_remote(url: str, timeout: float = 5.0) -> tuple[bool, str]:
     """
     Reachability check for a url-based MCP server. ANY HTTP response (even 4xx/5xx)

tests/test_core.py

@@ -326,6 +326,42 @@ def test_spawn_test_large_stderr_does_not_deadlock():
     assert len(r["stderr"]) <= c._STDERR_CAP
 
 
+def test_spawn_test_non_string_env_value():
+    # Pasted JSON can carry numeric env values ("env": {"PORT": 8080}) that never
+    # round-trip through the editor. Popen rejects non-str env; spawn_test must
+    # coerce instead of letting TypeError escape (which would leave the GUI's
+    # Test launch / Test all buttons stuck disabled).
+    r = c.spawn_test(
+        {
+            "command": sys.executable,
+            "args": ["-c", "import os; raise SystemExit(0 if os.environ['PORT'] == '8080' else 1)"],
+            "env": {"PORT": 8080},
+        },
+        timeout=2.0,
+    )
+    assert r["outcome"] == "exited"
+    assert r["returncode"] == 0
+
+
+def test_spawn_test_non_string_command():
+    # A non-string command must classify, not raise (str(123) resolves to nothing).
+    r = c.spawn_test({"command": 123}, timeout=0.3)
+    assert r["outcome"] == "not_found"
+
+
+def test_spawn_test_internal_error_yields_result(monkeypatch):
+    # Any unexpected exception inside the spawn path must come back as a result
+    # dict (outcome "error"), never escape — the UI only re-enables its buttons
+    # when a result arrives.
+    def boom(*a, **k):
+        raise RuntimeError("simulated internal failure")
+
+    monkeypatch.setattr(c.shutil, "which", boom)
+    r = c.spawn_test({"command": "python3"}, timeout=0.3)
+    assert r["outcome"] == "error"
+    assert "simulated internal failure" in r["detail"]
+
+
 # --------------------------------------------------------------------------- #
 # 8. Backup restore
 # --------------------------------------------------------------------------- #
@@ -758,6 +794,152 @@ def test_server_log_path_unsupported_platform_returns_none(tmp_path, monkeypatch
     assert c.server_log_path("brave-search") is None
 
 
+# --------------------------------------------------------------------------- #
+# MSIX-virtualized Claude Desktop config detection (issue #7)
+# --------------------------------------------------------------------------- #
+def _make_msix_pkg(localappdata, pkg_name="AnthropicClaude_abc123xyz", with_config=True):
+    cfg_dir = localappdata / "Packages" / pkg_name / "LocalCache" / "Roaming" / "Claude"
+    cfg_dir.mkdir(parents=True)
+    cfg_path = cfg_dir / c.CONFIG_FILENAME
+    if with_config:
+        cfg_path.write_text('{"mcpServers": {}}')
+    return cfg_path
+
+
+def test_msix_config_paths_finds_package_config(tmp_path):
+    local = tmp_path / "Local"
+    expected = _make_msix_pkg(local)
+    assert c.msix_config_paths(local) == [expected]
+
+
+def test_msix_config_paths_ignores_non_claude_packages(tmp_path):
+    local = tmp_path / "Local"
+    (local / "Packages" / "SomeOtherApp_xyz" / "LocalCache" / "Roaming").mkdir(parents=True)
+    assert c.msix_config_paths(local) == []
+
+
+def test_msix_config_paths_empty_when_package_dir_has_no_config_yet(tmp_path):
+    local = tmp_path / "Local"
+    _make_msix_pkg(local, with_config=False)
+    assert c.msix_config_paths(local) == []
+
+
+def test_msix_config_paths_empty_when_no_packages_dir(tmp_path):
+    assert c.msix_config_paths(tmp_path / "Local") == []
+
+
+def test_msix_config_paths_uses_localappdata_env_by_default(tmp_path, monkeypatch):
+    local = tmp_path / "Local"
+    expected = _make_msix_pkg(local)
+    monkeypatch.setenv("LOCALAPPDATA", str(local))
+    assert c.msix_config_paths() == [expected]
+
+
+def test_detect_msix_claude_returns_none_on_non_windows(tmp_path, monkeypatch):
+    monkeypatch.setattr(c.sys, "platform", "darwin")
+    local = tmp_path / "Local"
+    _make_msix_pkg(local)
+    assert c.detect_msix_claude(localappdata=local) is None
+
+
+def test_detect_msix_claude_finds_virtualized_config_on_windows(tmp_path, monkeypatch):
+    monkeypatch.setattr(c.sys, "platform", "win32")
+    local = tmp_path / "Local"
+    expected = _make_msix_pkg(local)
+    assert c.detect_msix_claude(localappdata=local) == expected
+
+
+def test_detect_msix_claude_none_when_nothing_present_on_windows(tmp_path, monkeypatch):
+    monkeypatch.setattr(c.sys, "platform", "win32")
+    local = tmp_path / "Local"
+    assert c.detect_msix_claude(localappdata=local) is None
+
+
+def test_msix_warning_text_none_on_non_windows(tmp_path, monkeypatch):
+    monkeypatch.setattr(c.sys, "platform", "darwin")
+    local = tmp_path / "Local"
+    _make_msix_pkg(local)
+    assert c.msix_warning_text(localappdata=local) is None
+
+
+def test_msix_warning_text_none_when_nothing_detected(tmp_path, monkeypatch):
+    monkeypatch.setattr(c.sys, "platform", "win32")
+    local = tmp_path / "Local"
+    assert c.msix_warning_text(localappdata=local) is None
+
+
+def test_msix_warning_text_warns_when_virtualized_path_differs(tmp_path, monkeypatch):
+    monkeypatch.setattr(c.sys, "platform", "win32")
+    roaming = tmp_path / "Roaming"
+    local = tmp_path / "Local"
+    real = _make_msix_pkg(local)
+    warning = c.msix_warning_text(appdata=roaming, localappdata=local)
+    assert warning is not None
+    assert "Microsoft Store" in warning
+    assert str(real) in warning
+    assert str(roaming / "Claude" / c.CONFIG_FILENAME) in warning
+
+
+def test_msix_warning_text_none_when_plain_and_virtualized_paths_match(tmp_path, monkeypatch):
+    # Degenerate case: if the "plain" APPDATA base is pointed at the exact
+    # same tree the MSIX scan found (e.g. a symlink setup), there's nothing
+    # surprising to warn about.
+    monkeypatch.setattr(c.sys, "platform", "win32")
+    local = tmp_path / "Local"
+    pkg_claude_dir = local / "Packages" / "AnthropicClaude_abc123xyz" / "LocalCache" / "Roaming"
+    pkg_claude_dir.mkdir(parents=True)
+    (pkg_claude_dir / "Claude").mkdir()
+    (pkg_claude_dir / "Claude" / c.CONFIG_FILENAME).write_text("{}")
+    warning = c.msix_warning_text(appdata=pkg_claude_dir, localappdata=local)
+    assert warning is None
+
+
+def test_discover_profiles_adds_msix_profile_on_windows(tmp_path, monkeypatch):
+    monkeypatch.setattr(c.sys, "platform", "win32")
+    base = tmp_path / "AppSupport"
+    base.mkdir()
+    monkeypatch.setattr(c, "app_support_base", lambda: base)
+    monkeypatch.setattr(c.Path, "home", lambda: tmp_path / "home")
+    (tmp_path / "home" / ".claude").mkdir(parents=True)
+    local = tmp_path / "Local"
+    real = _make_msix_pkg(local)
+    monkeypatch.setenv("LOCALAPPDATA", str(local))
+
+    profs = c.discover_profiles()
+    msix = [p for p in profs if "MSIX" in p.label]
+    assert len(msix) == 1
+    assert msix[0].path == real
+    assert msix[0].config_exists
+
+
+def test_discover_profiles_no_msix_profile_when_nothing_detected(tmp_path, monkeypatch):
+    monkeypatch.setattr(c.sys, "platform", "win32")
+    base = tmp_path / "AppSupport"
+    base.mkdir()
+    monkeypatch.setattr(c, "app_support_base", lambda: base)
+    monkeypatch.setattr(c.Path, "home", lambda: tmp_path / "home")
+    (tmp_path / "home" / ".claude").mkdir(parents=True)
+    monkeypatch.setenv("LOCALAPPDATA", str(tmp_path / "Local"))
+
+    profs = c.discover_profiles()
+    assert not any("MSIX" in p.label for p in profs)
+
+
+def test_discover_profiles_no_msix_profile_on_non_windows(tmp_path, monkeypatch):
+    monkeypatch.setattr(c.sys, "platform", "darwin")
+    base = tmp_path / "AppSupport"
+    base.mkdir()
+    monkeypatch.setattr(c, "app_support_base", lambda: base)
+    monkeypatch.setattr(c.Path, "home", lambda: tmp_path / "home")
+    (tmp_path / "home" / ".claude").mkdir(parents=True)
+    local = tmp_path / "Local"
+    _make_msix_pkg(local)
+    monkeypatch.setenv("LOCALAPPDATA", str(local))
+
+    profs = c.discover_profiles()
+    assert not any("MSIX" in p.label for p in profs)
+
+
 # --------------------------------------------------------------------------- #
 # restart_claude_desktop / profile_targets_claude_desktop (issue #9)
 # --------------------------------------------------------------------------- #
@@ -1054,3 +1236,144 @@ def test_fetch_latest_release_malformed_json_returns_none(monkeypatch):
         urllib.request, "urlopen", lambda req, timeout=None: _FakeHTTPResponse(b"not json")
     )
     assert c.fetch_latest_release() is None
+
+
+# --------------------------------------------------------------------------- #
+# Server search / filter (#27)
+# --------------------------------------------------------------------------- #
+def test_filter_matches_name():
+    e = c.ServerEntry("brave-search", {"command": "npx", "args": ["-y", "@x/brave"]}, True)
+    assert c.server_matches_filter(e, "brave")
+
+
+def test_filter_matches_stdio_command():
+    e = c.ServerEntry("filesystem", {"command": "uvx", "args": []}, True)
+    assert c.server_matches_filter(e, "uvx")
+
+
+def test_filter_matches_remote_url():
+    e = c.ServerEntry("hosted", {"url": "https://mcp.example.com/sse"}, True)
+    assert c.server_matches_filter(e, "example.com")
+
+
+def test_filter_is_case_insensitive():
+    e = c.ServerEntry("BraveSearch", {"command": "NPX", "args": []}, True)
+    assert c.server_matches_filter(e, "bravesearch")
+    assert c.server_matches_filter(e, "npx")
+
+
+def test_filter_empty_query_matches_everything():
+    e = c.ServerEntry("anything", {"command": "node", "args": []}, True)
+    assert c.server_matches_filter(e, "")
+    assert c.server_matches_filter(e, "   ")
+
+
+def test_filter_no_match_returns_false():
+    e = c.ServerEntry("filesystem", {"command": "uvx", "args": []}, True)
+    assert not c.server_matches_filter(e, "nonexistent")
+
+
+def test_filter_remote_query_does_not_match_stdio_command_field():
+    e = c.ServerEntry("hosted", {"url": "https://mcp.example.com/sse"}, True)
+    assert not c.server_matches_filter(e, "npx")
+
+
+def test_filter_servers_returns_only_matches():
+    servers = [
+        c.ServerEntry("brave-search", {"command": "npx", "args": []}, True),
+        c.ServerEntry("filesystem", {"command": "uvx", "args": []}, True),
+        c.ServerEntry("hosted", {"url": "https://mcp.example.com/sse"}, True),
+    ]
+    assert [s.name for s in c.filter_servers(servers, "brave")] == ["brave-search"]
+    assert [s.name for s in c.filter_servers(servers, "")] == [s.name for s in servers]
+    assert c.filter_servers(servers, "zzz-nope") == []
+
+
+# --------------------------------------------------------------------------- #
+# Health status mapping (#28)
+# --------------------------------------------------------------------------- #
+def test_health_from_spawn_result_ok():
+    result = {
+        "outcome": "ok",
+        "returncode": None,
+        "stderr": "",
+        "detail": "still running after 3s — server started successfully",
+    }
+    status, summary = c.health_from_spawn_result(result)
+    assert status == c.HealthStatus.OK
+    assert "started" in summary
+
+
+def test_health_from_spawn_result_not_applicable_is_untested():
+    result = {
+        "outcome": "not_applicable",
+        "returncode": None,
+        "stderr": "",
+        "detail": "remote server",
+    }
+    status, summary = c.health_from_spawn_result(result)
+    assert status == c.HealthStatus.UNTESTED
+    assert summary == "remote server"
+
+
+def test_health_from_spawn_result_crashed_is_failed():
+    result = {
+        "outcome": "crashed",
+        "returncode": 1,
+        "stderr": "Traceback: boom\nsecond line",
+        "detail": "process exited with code 1",
+    }
+    status, summary = c.health_from_spawn_result(result)
+    assert status == c.HealthStatus.FAILED
+    assert "process exited with code 1" in summary
+    assert "Traceback: boom" in summary
+
+
+def test_health_from_spawn_result_exited_is_failed():
+    result = {
+        "outcome": "exited",
+        "returncode": 0,
+        "stderr": "",
+        "detail": "process exited cleanly (code 0) — unusual",
+    }
+    status, summary = c.health_from_spawn_result(result)
+    assert status == c.HealthStatus.FAILED
+    assert "exited cleanly" in summary
+
+
+def test_health_from_spawn_result_not_found_is_failed():
+    result = {
+        "outcome": "not_found",
+        "returncode": None,
+        "stderr": "",
+        "detail": "command not found: totallybogus",
+    }
+    status, summary = c.health_from_spawn_result(result)
+    assert status == c.HealthStatus.FAILED
+    assert "not found" in summary
+
+
+def test_health_from_spawn_result_failed_without_stderr_has_no_dash():
+    result = {
+        "outcome": "not_found",
+        "returncode": None,
+        "stderr": "",
+        "detail": "command not found: x",
+    }
+    _, summary = c.health_from_spawn_result(result)
+    assert "—" not in summary
+
+
+# --------------------------------------------------------------------------- #
+# App icon assets present (issue #20 — icons must exist to be bundled/loaded)
+# --------------------------------------------------------------------------- #
+def test_app_icon_assets_present():
+    from pathlib import Path
+
+    root = Path(c.__file__).resolve().parent
+    rounded = root / "icons" / "twin-gears" / "rounded"
+    # The window-icon builder in bcc.py loads these sizes; keep them present.
+    for size in (16, 32, 128, 256):
+        assert (rounded / f"icon-{size}.png").is_file(), f"missing icon-{size}.png"
+    assert (root / "icons" / "app.ico").is_file()
+    assert (root / "icons" / "app.icns").is_file()