From 814bc903d8ec9bf9cc7ea10e6e65e5ddd1a522bb Mon Sep 17 00:00:00 2001
From: wangchenguang <darion.yaphets@gmail.com>
Date: Wed, 17 Jun 2026 20:52:57 +0800
Subject: [PATCH 1/4] fix(extensions): close path traversal and make `list
 --available` query the catalog

- extension add --from: sanitize the extension label before building the
  download filename so "../" path separators can no longer escape the
  downloads dir and overwrite arbitrary files
- extension list --available/--all: actually query the catalog and list
  uninstalled extensions (filtering out installed IDs), instead of only
  printing a static install hint that contradicted the CLI help and docs
---
 src/specify_cli/extensions/_commands.py | 44 +++++++++++++++++++++----
 1 file changed, 38 insertions(+), 6 deletions(-)

diff --git a/src/specify_cli/extensions/_commands.py b/src/specify_cli/extensions/_commands.py
index 3b60b6d52d..dc40df6ec9 100644
--- a/src/specify_cli/extensions/_commands.py
+++ b/src/specify_cli/extensions/_commands.py
@@ -208,19 +208,24 @@ def extension_list(
     all_extensions: bool = typer.Option(False, "--all", help="Show both installed and available"),
 ):
     """List installed extensions."""
-    from . import ExtensionManager
+    from . import ExtensionManager, ExtensionCatalog, ExtensionError
 
     project_root = _require_specify_project()
     manager = ExtensionManager(project_root)
     installed = manager.list_installed()
 
-    if not installed and not (available or all_extensions):
+    # Default (no flags) lists installed; --all also lists installed.
+    # --available alone lists only catalog extensions, not installed.
+    show_installed = all_extensions or not available
+    show_available = available or all_extensions
+
+    if not installed and not show_available:
         console.print("[yellow]No extensions installed.[/yellow]")
         console.print("\nInstall an extension with:")
         console.print("  specify extension add <extension-name>")
         return
 
-    if installed:
+    if show_installed and installed:
         console.print("\n[bold cyan]Installed Extensions:[/bold cyan]\n")
 
         for ext in installed:
@@ -233,9 +238,36 @@ def extension_list(
             console.print(f"     Commands: {ext['command_count']} | Hooks: {ext['hook_count']} | Priority: {ext['priority']} | Status: {'Enabled' if ext['enabled'] else 'Disabled'}")
             console.print()
 
-    if available or all_extensions:
-        console.print("\nInstall an extension:")
-        console.print("  [cyan]specify extension add <name>[/cyan]")
+    if show_available:
+        # Query the catalog and show extensions that are not already installed.
+        catalog = ExtensionCatalog(project_root)
+        installed_ids = {ext["id"] for ext in installed}
+
+        try:
+            results = catalog.search()
+        except ExtensionError as e:
+            console.print(f"\n[red]Error:[/red] Could not query extension catalog: {e}")
+            console.print("[dim]The catalog may be temporarily unavailable. Try again later.[/dim]")
+            raise typer.Exit(1)
+
+        available_exts = [ext for ext in results if ext.get("id") not in installed_ids]
+
+        console.print("\n[bold cyan]Available Extensions:[/bold cyan]\n")
+        if not available_exts:
+            console.print("  [dim]No additional extensions available in the catalog.[/dim]")
+        else:
+            for ext in available_exts:
+                verified_badge = " [green]✓ Verified[/green]" if ext.get("verified") else ""
+                console.print(f"  [bold]{ext['name']}[/bold] (v{ext['version']}){verified_badge}")
+                console.print(f"     [dim]{ext['id']}[/dim]")
+                console.print(f"     {ext.get('description', '')}")
+                install_allowed = ext.get("_install_allowed", True)
+                if install_allowed:
+                    console.print(f"     [cyan]Install:[/cyan] specify extension add {ext['id']}")
+                else:
+                    catalog_name = ext.get("_catalog_name", "")
+                    console.print(f"     [yellow]Discovery only — not installable from '{catalog_name}'[/yellow]")
+                console.print()
 
 
 @catalog_app.command("list")

From d468c0220d28f657f74e0da24e6b9c5d30d57b05 Mon Sep 17 00:00:00 2001
From: wangchenguang <darion.yaphets@gmail.com>
Date: Thu, 18 Jun 2026 12:01:54 +0800
Subject: [PATCH 2/4] test(extensions): cover list --available catalog query
 and add --from path traversal

Add regression coverage for the two behaviors wired up in the preceding fix:

- list --available/--all: queries the catalog, filters installed IDs,
  marks discovery-only entries, reports an empty catalog, and exits 1 on
  catalog failure.
- add --from <url>: a label containing path separators is sanitized so the
  download cannot escape the downloads cache dir.

Both suites were verified red against the pre-fix behavior and green after.
---
 tests/test_extension_add_path_traversal.py |  69 +++++++++++
 tests/test_extension_list_available.py     | 135 +++++++++++++++++++++
 2 files changed, 204 insertions(+)
 create mode 100644 tests/test_extension_add_path_traversal.py
 create mode 100644 tests/test_extension_list_available.py

diff --git a/tests/test_extension_add_path_traversal.py b/tests/test_extension_add_path_traversal.py
new file mode 100644
index 0000000000..e426e34b1e
--- /dev/null
+++ b/tests/test_extension_add_path_traversal.py
@@ -0,0 +1,69 @@
+"""Security test for `specify extension add <label> --from <url>`.
+
+The raw extension label is interpolated into the downloaded ZIP filename. A
+label containing path separators (e.g. "../../etc/evil") must not let the
+download escape the downloads cache directory. The handler sanitizes the
+label before building the filename; this test asserts the resulting path
+stays inside the downloads dir.
+"""
+
+import contextlib
+
+import pytest
+from typer.testing import CliRunner
+
+from specify_cli import app
+from specify_cli.extensions import ExtensionManager
+
+runner = CliRunner()
+
+
+@pytest.fixture
+def project_dir(tmp_path):
+    proj_dir = tmp_path / "project"
+    proj_dir.mkdir()
+    (proj_dir / ".specify").mkdir()
+    (proj_dir / ".specify" / "config.toml").write_text("ai = 'claude'")
+    return proj_dir
+
+
+def test_add_from_url_sanitizes_traversal_label(project_dir, monkeypatch):
+    monkeypatch.chdir(project_dir)
+
+    captured = {}
+
+    @contextlib.contextmanager
+    def fake_open_url(url, timeout=60):
+        class _Resp:
+            def read(self):
+                return b"not-a-real-zip"
+        yield _Resp()
+
+    monkeypatch.setattr("specify_cli.authentication.http.open_url", fake_open_url)
+
+    def fake_install_from_zip(self, zip_path, *args, **kwargs):
+        captured["zip_path"] = zip_path
+        # Stop the flow before real install/registration runs.
+        raise RuntimeError("stop after capture")
+
+    monkeypatch.setattr(ExtensionManager, "install_from_zip", fake_install_from_zip)
+
+    malicious = "../../../etc/evil"
+    runner.invoke(
+        app,
+        ["extension", "add", malicious, "--from", "https://example.com/payload.zip"],
+        obj={"project_root": project_dir},
+        input="y\n",  # confirm the "Untrusted Source" prompt for --from URLs
+    )
+
+    zip_path = captured.get("zip_path")
+    assert zip_path is not None, "install_from_zip was never reached"
+
+    download_dir = (project_dir / ".specify" / "extensions" / ".cache" / "downloads").resolve()
+    resolved = zip_path.resolve()
+
+    # The download must stay inside the downloads cache dir...
+    assert resolved.parent == download_dir
+    # ...and the filename must not carry path separators from the raw label.
+    assert "/" not in zip_path.name
+    assert ".." not in zip_path.name
diff --git a/tests/test_extension_list_available.py b/tests/test_extension_list_available.py
new file mode 100644
index 0000000000..911a6d2881
--- /dev/null
+++ b/tests/test_extension_list_available.py
@@ -0,0 +1,135 @@
+"""Behavior tests for `specify extension list --available/--all`.
+
+These flags were documented from the original extension system (#1551) as
+"Show available extensions from catalog", but the implementation was a static
+hint that never queried the catalog. This suite covers the wired-up behavior:
+the catalog is queried, already-installed IDs are filtered out, and a clear
+error is surfaced when the catalog is unavailable.
+"""
+
+import pytest
+from typer.testing import CliRunner
+
+from specify_cli import app
+from specify_cli.extensions import ExtensionManager, ExtensionCatalog, ExtensionError
+
+runner = CliRunner()
+
+
+@pytest.fixture
+def project_dir(tmp_path):
+    """Create a minimal spec-kit project directory."""
+    proj_dir = tmp_path / "project"
+    proj_dir.mkdir()
+    (proj_dir / ".specify").mkdir()
+    (proj_dir / ".specify" / "config.toml").write_text("ai = 'claude'")
+    return proj_dir
+
+
+def _catalog_entry(ext_id, name, version="1.0.0", verified=False, install_allowed=True, catalog_name="default"):
+    return {
+        "id": ext_id,
+        "name": name,
+        "version": version,
+        "description": f"{name} description",
+        "verified": verified,
+        "_install_allowed": install_allowed,
+        "_catalog_name": catalog_name,
+    }
+
+
+def test_list_available_queries_catalog_and_filters_installed(project_dir, monkeypatch):
+    """--available must query the catalog and drop already-installed IDs."""
+    monkeypatch.chdir(project_dir)
+
+    monkeypatch.setattr(ExtensionManager, "list_installed", lambda self: [{"id": "already-installed"}])
+    monkeypatch.setattr(ExtensionCatalog, "search", lambda self: [
+        _catalog_entry("already-installed", "Already Installed"),
+        _catalog_entry("fresh-ext", "Fresh Ext", verified=True),
+    ])
+
+    result = runner.invoke(app, ["extension", "list", "--available"], obj={"project_root": project_dir})
+
+    assert result.exit_code == 0
+    assert "Available Extensions:" in result.output
+    # Uninstalled catalog extension is shown...
+    assert "fresh-ext" in result.output
+    assert "✓ Verified" in result.output
+    assert "specify extension add fresh-ext" in result.output
+    # ...and the installed one is filtered out.
+    assert "already-installed" not in result.output
+
+
+def test_list_available_marks_discovery_only_entries(project_dir, monkeypatch):
+    """Entries whose catalog disallows install render a discovery-only note."""
+    monkeypatch.chdir(project_dir)
+
+    monkeypatch.setattr(ExtensionManager, "list_installed", lambda self: [])
+    monkeypatch.setattr(ExtensionCatalog, "search", lambda self: [
+        _catalog_entry("locked-ext", "Locked Ext", install_allowed=False, catalog_name="curated"),
+    ])
+
+    result = runner.invoke(app, ["extension", "list", "--available"], obj={"project_root": project_dir})
+
+    assert result.exit_code == 0
+    assert "Discovery only" in result.output
+    assert "curated" in result.output
+    assert "specify extension add locked-ext" not in result.output
+
+
+def test_list_available_empty_catalog_message(project_dir, monkeypatch):
+    """An empty (post-filter) catalog reports no additional extensions."""
+    monkeypatch.chdir(project_dir)
+
+    monkeypatch.setattr(ExtensionManager, "list_installed", lambda self: [])
+    monkeypatch.setattr(ExtensionCatalog, "search", lambda self: [])
+
+    result = runner.invoke(app, ["extension", "list", "--available"], obj={"project_root": project_dir})
+
+    assert result.exit_code == 0
+    assert "Available Extensions:" in result.output
+    assert "No additional extensions available" in result.output
+
+
+def test_list_available_catalog_error_exits(project_dir, monkeypatch):
+    """A catalog failure surfaces a clear error and exits non-zero."""
+    monkeypatch.chdir(project_dir)
+
+    def _boom(self):
+        raise ExtensionError("catalog unreachable")
+
+    monkeypatch.setattr(ExtensionManager, "list_installed", lambda self: [])
+    monkeypatch.setattr(ExtensionCatalog, "search", _boom)
+
+    result = runner.invoke(app, ["extension", "list", "--available"], obj={"project_root": project_dir})
+
+    assert result.exit_code == 1
+    assert "Could not query extension catalog" in result.output
+    assert "catalog unreachable" in result.output
+
+
+def test_list_all_shows_installed_and_available(project_dir, monkeypatch):
+    """--all lists installed extensions and available catalog extensions."""
+    monkeypatch.chdir(project_dir)
+
+    monkeypatch.setattr(ExtensionManager, "list_installed", lambda self: [{
+        "id": "my-ext",
+        "name": "My Ext",
+        "version": "2.0.0",
+        "description": "installed one",
+        "command_count": 1,
+        "hook_count": 0,
+        "priority": 10,
+        "enabled": True,
+    }])
+    monkeypatch.setattr(ExtensionCatalog, "search", lambda self: [
+        _catalog_entry("other-ext", "Other Ext"),
+    ])
+
+    result = runner.invoke(app, ["extension", "list", "--all"], obj={"project_root": project_dir})
+
+    assert result.exit_code == 0
+    assert "Installed Extensions:" in result.output
+    assert "My Ext" in result.output
+    assert "Available Extensions:" in result.output
+    assert "other-ext" in result.output

From dbd8d9d5228306796be8fc82d02db42457a99777 Mon Sep 17 00:00:00 2001
From: wangchenguang <darion.yaphets@gmail.com>
Date: Tue, 23 Jun 2026 09:34:06 +0800
Subject: [PATCH 3/4] fix(extensions): escape catalog markup and always render
 installed section

- Escape untrusted catalog fields (name, version, id, description,
  catalog name) and the catalog-query error before embedding them in
  Rich markup, preventing markup injection in `extension list
  --available/--all` output
- Always print the "Installed Extensions:" header when the installed
  section is shown, with a "No extensions installed." note when empty,
  so `--all` output is no longer missing the section on an empty project
- Update the command docstring to reflect --available/--all catalog
  listing so `--help` is accurate
---
 src/specify_cli/extensions/_commands.py | 22 ++++++++++++++--------
 1 file changed, 14 insertions(+), 8 deletions(-)

diff --git a/src/specify_cli/extensions/_commands.py b/src/specify_cli/extensions/_commands.py
index dc40df6ec9..2104d9809e 100644
--- a/src/specify_cli/extensions/_commands.py
+++ b/src/specify_cli/extensions/_commands.py
@@ -207,7 +207,7 @@ def extension_list(
     available: bool = typer.Option(False, "--available", help="Show available extensions from catalog"),
     all_extensions: bool = typer.Option(False, "--all", help="Show both installed and available"),
 ):
-    """List installed extensions."""
+    """List installed extensions, and available catalog extensions with --available/--all."""
     from . import ExtensionManager, ExtensionCatalog, ExtensionError
 
     project_root = _require_specify_project()
@@ -225,9 +225,12 @@ def extension_list(
         console.print("  specify extension add <extension-name>")
         return
 
-    if show_installed and installed:
+    if show_installed:
         console.print("\n[bold cyan]Installed Extensions:[/bold cyan]\n")
 
+        if not installed:
+            console.print("  [dim]No extensions installed.[/dim]")
+            console.print()
         for ext in installed:
             status_icon = "✓" if ext["enabled"] else "✗"
             status_color = "green" if ext["enabled"] else "red"
@@ -246,7 +249,7 @@ def extension_list(
         try:
             results = catalog.search()
         except ExtensionError as e:
-            console.print(f"\n[red]Error:[/red] Could not query extension catalog: {e}")
+            console.print(f"\n[red]Error:[/red] Could not query extension catalog: {_escape_markup(str(e))}")
             console.print("[dim]The catalog may be temporarily unavailable. Try again later.[/dim]")
             raise typer.Exit(1)
 
@@ -257,15 +260,18 @@ def extension_list(
             console.print("  [dim]No additional extensions available in the catalog.[/dim]")
         else:
             for ext in available_exts:
+                # Catalog fields are untrusted (remote/community catalogs); escape
+                # before embedding in Rich markup to prevent markup injection.
+                safe_id = _escape_markup(str(ext.get("id", "")))
                 verified_badge = " [green]✓ Verified[/green]" if ext.get("verified") else ""
-                console.print(f"  [bold]{ext['name']}[/bold] (v{ext['version']}){verified_badge}")
-                console.print(f"     [dim]{ext['id']}[/dim]")
-                console.print(f"     {ext.get('description', '')}")
+                console.print(f"  [bold]{_escape_markup(str(ext['name']))}[/bold] (v{_escape_markup(str(ext['version']))}){verified_badge}")
+                console.print(f"     [dim]{safe_id}[/dim]")
+                console.print(f"     {_escape_markup(str(ext.get('description', '')))}")
                 install_allowed = ext.get("_install_allowed", True)
                 if install_allowed:
-                    console.print(f"     [cyan]Install:[/cyan] specify extension add {ext['id']}")
+                    console.print(f"     [cyan]Install:[/cyan] specify extension add {safe_id}")
                 else:
-                    catalog_name = ext.get("_catalog_name", "")
+                    catalog_name = _escape_markup(str(ext.get("_catalog_name", "")))
                     console.print(f"     [yellow]Discovery only — not installable from '{catalog_name}'[/yellow]")
                 console.print()
 

From 68972c52f10fb332a46ed582638bc1f2dec82741 Mon Sep 17 00:00:00 2001
From: wangchenguang <darion.yaphets@gmail.com>
Date: Tue, 23 Jun 2026 21:54:40 +0800
Subject: [PATCH 4/4] fix(extensions): harden catalog-driven commands against
 malformed entries

Catalog entries are untrusted (remote/community catalogs) and only
guaranteed to carry an injected `id`; every other field comes straight
from `**ext_data`. Hard subscripts and unguarded `.get()` chains on that
data could crash `search`, `info`, `add`, and `update`, and a couple of
catalog-controlled values were printed without Rich-markup escaping.

- Use `.get()` fallbacks for name/version/description across
  search/info/add resolution and the download message
- Guard `requires`/`provides` with isinstance(dict) before `.get()`, and
  skip non-dict tool entries
- Catch KeyError alongside InvalidVersion in `update` version parsing
- Escape catalog-controlled `stars` before printing
- Correct the add --from path-traversal test docstring to describe the
  real mitigation (generated tempfile in the downloads dir, not label
  sanitization)
- Add regression tests for malformed catalog entries in list/search/info
---
 src/specify_cli/extensions/_commands.py    |  41 +++++----
 tests/test_extension_add_path_traversal.py |  12 ++-
 tests/test_extension_catalog_robustness.py | 101 +++++++++++++++++++++
 tests/test_extension_list_available.py     |  22 +++++
 4 files changed, 153 insertions(+), 23 deletions(-)
 create mode 100644 tests/test_extension_catalog_robustness.py

diff --git a/src/specify_cli/extensions/_commands.py b/src/specify_cli/extensions/_commands.py
index 2104d9809e..0c713ed0df 100644
--- a/src/specify_cli/extensions/_commands.py
+++ b/src/specify_cli/extensions/_commands.py
@@ -168,7 +168,7 @@ def _resolve_catalog_extension(
 
         # Try by display name - search using argument as query, then filter for exact match
         search_results = catalog.search(query=argument)
-        name_matches = [ext for ext in search_results if ext["name"].lower() == argument.lower()]
+        name_matches = [ext for ext in search_results if str(ext.get("name", "")).lower() == argument.lower()]
 
         if len(name_matches) == 1:
             return (name_matches[0], None)
@@ -264,7 +264,9 @@ def extension_list(
                 # before embedding in Rich markup to prevent markup injection.
                 safe_id = _escape_markup(str(ext.get("id", "")))
                 verified_badge = " [green]✓ Verified[/green]" if ext.get("verified") else ""
-                console.print(f"  [bold]{_escape_markup(str(ext['name']))}[/bold] (v{_escape_markup(str(ext['version']))}){verified_badge}")
+                safe_name = _escape_markup(str(ext.get("name", "(unnamed)")))
+                safe_version = _escape_markup(str(ext.get("version", "?")))
+                console.print(f"  [bold]{safe_name}[/bold] (v{safe_version}){verified_badge}")
                 console.print(f"     [dim]{safe_id}[/dim]")
                 console.print(f"     {_escape_markup(str(ext.get('description', '')))}")
                 install_allowed = ext.get("_install_allowed", True)
@@ -615,7 +617,7 @@ def extension_add(
 
                         # Download extension ZIP (use resolved ID, not original argument which may be display name)
                         extension_id = ext_info['id']
-                        console.print(f"Downloading {_escape_markup(str(ext_info['name']))} v{_escape_markup(str(ext_info.get('version', 'unknown')))}...")
+                        console.print(f"Downloading {_escape_markup(str(ext_info.get('name', extension_id)))} v{_escape_markup(str(ext_info.get('version', 'unknown')))}...")
                         zip_path = catalog.download_extension(extension_id)
 
                         try:
@@ -767,8 +769,8 @@ def extension_search(
         for ext in results:
             # Extension header
             verified_badge = " [green]✓ Verified[/green]" if ext.get("verified") else ""
-            console.print(f"[bold]{_escape_markup(str(ext['name']))}[/bold] (v{_escape_markup(str(ext['version']))}){verified_badge}")
-            console.print(f"  {_escape_markup(str(ext['description']))}")
+            console.print(f"[bold]{_escape_markup(str(ext.get('name', '(unnamed)')))}[/bold] (v{_escape_markup(str(ext.get('version', '?')))}){verified_badge}")
+            console.print(f"  {_escape_markup(str(ext.get('description', '')))}")
 
             # Metadata
             console.print(f"\n  [dim]Author:[/dim] {_escape_markup(str(ext.get('author', 'Unknown')))}")
@@ -790,7 +792,7 @@ def extension_search(
             if ext.get('downloads') is not None:
                 stats.append(f"Downloads: {ext['downloads']:,}")
             if ext.get('stars') is not None:
-                stats.append(f"Stars: {ext['stars']}")
+                stats.append(f"Stars: {_escape_markup(str(ext['stars']))}")
             if stats:
                 console.print(f"  [dim]{' | '.join(stats)}[/dim]")
 
@@ -911,12 +913,12 @@ def _print_extension_info(ext_info: dict, manager):
 
     # Header
     verified_badge = " [green]✓ Verified[/green]" if ext_info.get("verified") else ""
-    console.print(f"\n[bold]{_escape_markup(str(ext_info['name']))}[/bold] (v{_escape_markup(str(ext_info['version']))}){verified_badge}")
+    console.print(f"\n[bold]{_escape_markup(str(ext_info.get('name', '(unnamed)')))}[/bold] (v{_escape_markup(str(ext_info.get('version', '?')))}){verified_badge}")
     console.print(f"ID: {_escape_markup(str(ext_info['id']))}")
     console.print()
 
     # Description
-    console.print(f"{_escape_markup(str(ext_info['description']))}")
+    console.print(f"{_escape_markup(str(ext_info.get('description', '')))}")
     console.print()
 
     # Author and License
@@ -937,23 +939,26 @@ def _print_extension_info(ext_info: dict, manager):
     console.print()
 
     # Requirements
-    if ext_info.get('requires'):
+    reqs = ext_info.get('requires')
+    if isinstance(reqs, dict) and reqs:
         console.print("[bold]Requirements:[/bold]")
-        reqs = ext_info['requires']
         if reqs.get('speckit_version'):
             console.print(f"  • Spec Kit: {_escape_markup(str(reqs['speckit_version']))}")
-        if reqs.get('tools'):
-            for tool in reqs['tools']:
-                tool_name = _escape_markup(str(tool['name']))
+        tools = reqs.get('tools')
+        if isinstance(tools, list):
+            for tool in tools:
+                if not isinstance(tool, dict):
+                    continue
+                tool_name = _escape_markup(str(tool.get('name', '(unnamed)')))
                 tool_version = _escape_markup(str(tool.get('version', 'any')))
                 required = " (required)" if tool.get('required') else " (optional)"
                 console.print(f"  • {tool_name}: {tool_version}{required}")
         console.print()
 
     # Provides
-    if ext_info.get('provides'):
+    provides = ext_info.get('provides')
+    if isinstance(provides, dict) and provides:
         console.print("[bold]Provides:[/bold]")
-        provides = ext_info['provides']
         if provides.get('commands'):
             console.print(f"  • Commands: {_escape_markup(str(provides['commands']))}")
         if provides.get('hooks'):
@@ -971,7 +976,7 @@ def _print_extension_info(ext_info: dict, manager):
     if ext_info.get('downloads') is not None:
         stats.append(f"Downloads: {ext_info['downloads']:,}")
     if ext_info.get('stars') is not None:
-        stats.append(f"Stars: {ext_info['stars']}")
+        stats.append(f"Stars: {_escape_markup(str(ext_info['stars']))}")
     if stats:
         console.print(f"[bold]Statistics:[/bold] {' | '.join(stats)}")
         console.print()
@@ -1078,8 +1083,8 @@ def extension_update(
                 continue
 
             try:
-                catalog_version = pkg_version.Version(ext_info["version"])
-            except pkg_version.InvalidVersion:
+                catalog_version = pkg_version.Version(str(ext_info["version"]))
+            except (pkg_version.InvalidVersion, KeyError):
                 console.print(
                     f"⚠  {safe_ext_id}: Invalid catalog version '{_escape_markup(str(ext_info.get('version')))}' (skipping)"
                 )
diff --git a/tests/test_extension_add_path_traversal.py b/tests/test_extension_add_path_traversal.py
index e426e34b1e..d99a52a704 100644
--- a/tests/test_extension_add_path_traversal.py
+++ b/tests/test_extension_add_path_traversal.py
@@ -1,10 +1,12 @@
 """Security test for `specify extension add <label> --from <url>`.
 
-The raw extension label is interpolated into the downloaded ZIP filename. A
-label containing path separators (e.g. "../../etc/evil") must not let the
-download escape the downloads cache directory. The handler sanitizes the
-label before building the filename; this test asserts the resulting path
-stays inside the downloads dir.
+A label containing path separators (e.g. "../../etc/evil") must not let the
+download escape the downloads cache directory. The handler does not let the
+label participate in the path at all: it downloads to a generated tempfile
+(``extension-url-download-*.zip``) created with ``dir=download_dir``, so the
+filename is machine-generated and confined to the downloads cache. This test
+asserts the resulting path stays inside that directory and carries no path
+separators from the raw label.
 """
 
 import contextlib
diff --git a/tests/test_extension_catalog_robustness.py b/tests/test_extension_catalog_robustness.py
new file mode 100644
index 0000000000..ed3e6d08a0
--- /dev/null
+++ b/tests/test_extension_catalog_robustness.py
@@ -0,0 +1,101 @@
+"""Robustness tests for catalog-driven extension commands.
+
+Catalog entries are untrusted (remote/community catalogs) and only guaranteed
+to be dicts with an injected ``id`` — ``_get_merged_extensions`` does not
+validate any other field. ``extension search`` and ``extension info`` must
+therefore tolerate entries missing ``name``/``version``/``description`` (no
+KeyError), entries whose ``requires``/``provides`` are non-dicts (no
+AttributeError), and must escape catalog-controlled values like ``stars``
+before printing them as Rich markup.
+"""
+
+import pytest
+from typer.testing import CliRunner
+
+from specify_cli import app
+from specify_cli.extensions import ExtensionManager, ExtensionCatalog
+
+runner = CliRunner()
+
+
+@pytest.fixture
+def project_dir(tmp_path):
+    proj_dir = tmp_path / "project"
+    proj_dir.mkdir()
+    (proj_dir / ".specify").mkdir()
+    (proj_dir / ".specify" / "config.toml").write_text("ai = 'claude'")
+    return proj_dir
+
+
+def test_search_tolerates_entry_missing_name_version_description(project_dir, monkeypatch):
+    """A malformed catalog entry must not crash `extension search`."""
+    monkeypatch.chdir(project_dir)
+
+    monkeypatch.setattr(
+        ExtensionCatalog,
+        "search",
+        lambda self, **kwargs: [{"id": "broken-ext"}],  # only id present
+    )
+
+    result = runner.invoke(app, ["extension", "search"], obj={"project_root": project_dir})
+
+    assert result.exit_code == 0, result.output
+    assert "broken-ext" in result.output
+    assert "(unnamed)" in result.output
+    assert "(v?)" in result.output
+
+
+def test_search_escapes_markup_in_stars(project_dir, monkeypatch):
+    """Catalog-controlled `stars` must be escaped, not parsed as Rich markup."""
+    monkeypatch.chdir(project_dir)
+
+    monkeypatch.setattr(
+        ExtensionCatalog,
+        "search",
+        lambda self, **kwargs: [{
+            "id": "starry",
+            "name": "Starry",
+            "version": "1.0.0",
+            "description": "d",
+            "stars": "[red]999[/red]",
+        }],
+    )
+
+    result = runner.invoke(app, ["extension", "search"], obj={"project_root": project_dir})
+
+    assert result.exit_code == 0, result.output
+    # Escaped markup is rendered literally rather than swallowed by Rich.
+    assert "[red]999[/red]" in result.output
+
+
+def test_info_tolerates_missing_fields_and_non_dict_sections(project_dir, monkeypatch):
+    """`extension info` must survive a malformed catalog entry.
+
+    Missing name/version/description → placeholders (no KeyError); requires as a
+    list and provides as a string → skipped, not `.get()`-crashed.
+    """
+    monkeypatch.chdir(project_dir)
+
+    monkeypatch.setattr(ExtensionManager, "list_installed", lambda self: [])
+    monkeypatch.setattr(
+        ExtensionCatalog,
+        "get_extension_info",
+        lambda self, ext_id: {
+            "id": "broken-ext",
+            "requires": ["not", "a", "dict"],
+            "provides": "junk",
+            "stars": "[bold]42[/bold]",
+        },
+    )
+
+    result = runner.invoke(app, ["extension", "info", "broken-ext"], obj={"project_root": project_dir})
+
+    assert result.exit_code == 0, result.output
+    assert "broken-ext" in result.output
+    assert "(unnamed)" in result.output
+    assert "(v?)" in result.output
+    # Non-dict requires/provides are skipped, not crashed on.
+    assert "Requirements:" not in result.output
+    assert "Provides:" not in result.output
+    # stars is escaped.
+    assert "[bold]42[/bold]" in result.output
diff --git a/tests/test_extension_list_available.py b/tests/test_extension_list_available.py
index 911a6d2881..011d48ed90 100644
--- a/tests/test_extension_list_available.py
+++ b/tests/test_extension_list_available.py
@@ -108,6 +108,28 @@ def _boom(self):
     assert "catalog unreachable" in result.output
 
 
+def test_list_available_tolerates_entry_missing_name_or_version(project_dir, monkeypatch):
+    """A malformed catalog entry missing name/version must not crash listing.
+
+    Catalog entries are untrusted (remote/community catalogs) and only
+    guaranteed to be dicts with an injected ``id``. A missing ``name`` or
+    ``version`` must degrade to a placeholder, not raise KeyError.
+    """
+    monkeypatch.chdir(project_dir)
+
+    monkeypatch.setattr(ExtensionManager, "list_installed", lambda self: [])
+    monkeypatch.setattr(ExtensionCatalog, "search", lambda self: [
+        {"id": "broken-ext"},  # no name, no version, no description
+    ])
+
+    result = runner.invoke(app, ["extension", "list", "--available"], obj={"project_root": project_dir})
+
+    assert result.exit_code == 0
+    assert "broken-ext" in result.output
+    assert "(unnamed)" in result.output
+    assert "(v?)" in result.output
+
+
 def test_list_all_shows_installed_and_available(project_dir, monkeypatch):
     """--all lists installed extensions and available catalog extensions."""
     monkeypatch.chdir(project_dir)