A Claude Code change added a local MCP tool that opened any absolute path, so a local client could probe which files exist and read handler names from them.

@@ -219,6 +219,158 @@ def get_view_schema(view_name: str) -> str:             }         ) +    @mcp.tool()+    def find_handlers_for_template(template_path: str) -> str:+        """List every view that uses a template, and which dj-* handlers+        are wired in that template.++        Args:+            template_path: Either a logical template name (e.g.+                'demos/counter.html' — what you'd pass to `render`) OR+                an absolute filesystem path. Both are searched.++        Returns JSON:+          {+            "template_path": "...",+            "resolved_path": "/abs/path.html",+            "dj_handlers_in_template": ["increment", "decrement", ...],+            "views": [

+              {"class": "CounterView", "template_name": "...",+               "matched_handlers": ["increment", "decrement"],+               "handlers_in_view_not_in_template": [...],+               "handlers_in_template_not_in_view": [...]}+            ]+          }++        Pure static analysis — no framework hooks. Precursor to automated+        refactoring ("renaming this handler, who's affected?").+        """+        if not _ensure_django():+            return json.dumps(+                {+                    "error": "Django not configured. Run via 'python manage.py djust_mcp'.",+                }+            )++        import os+        import re++        from djust.schema import get_project_schema+

+        # Resolve the template to an absolute path. Accept both logical+        # names and absolute paths so callers can hand either form.+        resolved_path: str | None = None+        if os.path.isabs(template_path) and os.path.isfile(template_path):+            resolved_path = template_path+        else:+            try:+                from django.template.loader import get_template++                tpl = get_template(template_path)+                origin = getattr(tpl, "origin", None)+                if origin and getattr(origin, "name", None):+                    resolved_path = origin.name+            except Exception as e:  # noqa: BLE001+                return json.dumps(+                    {+                        "error": f"Could not resolve template '{template_path}': {e}",+                        "hint": "Pass either a logical name (e.g. 'demos/counter.html') or an absolute filesystem path.",+                    }+                )

+

+        if not resolved_path or not os.path.isfile(resolved_path):+            return json.dumps(+                {+                    "error": f"Template file not found for '{template_path}'",+                    "resolved_path": resolved_path,+                }+            )

++        # Scan the template for dj-* handler references.+        # Matches e.g. dj-click="increment" / dj-submit='add_todo'.+        # Deliberately doesn't match dj-params / dj-id / dj-view / dj-loading+        # etc. — only the event-wiring attrs.+        dj_event_attr_re = re.compile(+            r'\b(dj-(?:click|submit|change|input|keydown|keyup))\s*=\s*[\'"]([^\'"]+)[\'"]',+            re.IGNORECASE,+        )+        with open(resolved_path, "r", encoding="utf-8", errors="replace") as f:+            source = f.read()+        handler_names_in_template = sorted({m.group(2) for m in dj_event_attr_re.finditer(source)})++        # Match against the project's views. A view matches when its

+        # template_name maps to the same resolved path. Compare by basename+        # + tail so both logical and absolute inputs can match.+        schema = get_project_schema()+        logical_tail = template_path.replace(os.sep, "/")+        resolved_tail_components = resolved_path.replace(os.sep, "/").split("/")+

@@ -24,6 +24,53 @@  __all__ = ["create_server", "_django_ready"] 

+# ---------------------------------------------------------------------------+# Path containment shared by the tools that take a filesystem path

+# ---------------------------------------------------------------------------+++def _path_within(path: str, roots: "list[Any]") -> bool:+    """Whether ``path`` resolves inside one of ``roots``.++    Both sides go through ``os.path.realpath``, so ``..`` segments and symlinks

+    are followed before comparing, and the comparison is+    ``os.path.commonpath`` on whole path components, so ``/app-data`` is not+    inside ``/app``. An empty ``roots`` contains nothing.+    """+    real = os.path.realpath(path)+    for root in roots:+        if not root:+            continue+        base = os.path.realpath(str(root))+        try:+            if os.path.commonpath([real, base]) == base:+                return True+        except ValueError:  # different drives, or mixed absolute/relative+            continue

+    return False+++def _template_roots(engine: Any) -> "list[str]":+    """Directories ``engine``'s loaders serve templates from, plus ``BASE_DIR``."""+    from django.conf import settings++    roots: list[str] = [str(d) for d in getattr(engine, "dirs", None) or []]

+    pending = list(getattr(engine, "template_loaders", None) or [])+    while pending:+        loader = pending.pop()+        pending.extend(getattr(loader, "loaders", None) or [])  # cached.Loader+        get_dirs = getattr(loader, "get_dirs", None)+        if callable(get_dirs):+            try:

+                roots.extend(str(d) for d in get_dirs())+            except Exception:  # noqa: BLE001 -- a loader without dirs contributes none+                pass+    base_dir = getattr(settings, "BASE_DIR", None)+    if base_dir:+        roots.append(str(base_dir))+    return roots++

 # --------------------------------------------------------------------------- # Template handler cross-reference (find_handlers_for_template) # ---------------------------------------------------------------------------@@ -55,16 +102,29 @@ def template_handler_report(template_path: str) -> Dict[str, Any]:         return {"error": "No Django template engine is configured."}     resolved_path: Optional[str] = None     template = None-    if os.path.isabs(template_path) and os.path.isfile(template_path):

-        resolved_path = template_path+    hint = (+        "Pass either a logical name (e.g. 'demos/counter.html') or an "+        "absolute path inside the project's template directories or BASE_DIR."+    )+    if os.path.isabs(template_path):+        # Read directly only a file that resolves (symlinks and ``..``+        # followed) inside a directory the template loaders serve, or inside+        # BASE_DIR. Anything else gets the answer a missing template gets, so+        # the reply says nothing about files elsewhere on disk.+        real_path = os.path.realpath(template_path)+        if not (os.path.isfile(real_path) and _path_within(real_path, _template_roots(engine))):+            return {+                "error": "Could not resolve template %r: %s" % (template_path, template_path),+                "hint": hint,

+            }+        resolved_path = real_path     else:         try:             template = engine.get_template(template_path)         except Exception as exc:  # noqa: BLE001 -- any loader failure is reported to the caller             return {                 "error": "Could not resolve template %r: %s" % (template_path, exc),-                "hint": "Pass either a logical name (e.g. 'demos/counter.html') or an "-                "absolute filesystem path.",+                "hint": hint,             }         resolved_path = getattr(getattr(template, "origin", None), "name", None)     if not resolved_path or not os.path.isfile(resolved_path):@@ -411,7 +471,8 @@ def seed_fixtures(fixture_paths: list[str]) -> str:             fixture_paths: Absolute or relative paths to fixture files