mcp-apollo-explorer 0.1.0__py3-none-any.whl

mcp_apollo_explorer/__init__.py

@@ -0,0 +1,3 @@
+"""mcp-apollo-explorer: Apollo config center explorer MCP server."""
+
+__version__ = "0.1.0"

mcp_apollo_explorer/apollo_client.py

@@ -0,0 +1,178 @@
+"""Apollo Portal API client (cookie auth)."""
+
+from __future__ import annotations
+
+import os
+from typing import Any
+from urllib.parse import quote
+
+import httpx
+
+DEFAULT_PORTAL_URL = "http://config-portal.beisencorp.com"
+DEFAULT_ENV = "DEV"
+DEFAULT_CLUSTER = "default"
+PAGE_SIZE = 200
+
+
+class ApolloAuthError(RuntimeError):
+    """Cookie 缺失或失效。"""
+
+
+def _seg(value: Any) -> str:
+    """URL-encode a single path segment."""
+    return quote(str(value), safe="")
+
+
+def _item_kv(i: dict) -> dict:
+    """从 namespace/release 的 item 元素提取 {key, value}。
+
+    Apollo 对 xml/json/yaml 等"文件型" namespace,item 元素结构是
+    {item: {key, value, ...}, isModified, isDeleted};对 properties 是
+    直接的 {key, value, ...}。这里统一拍平到 {key, value}。
+    """
+    inner = i.get("item")
+    if not isinstance(inner, dict):
+        inner = i
+    return {"key": inner.get("key"), "value": inner.get("value")}
+
+
+class ApolloClient:
+    """通过 cookie 认证访问 Apollo Portal 管理 API。"""
+
+    def __init__(
+        self,
+        portal_url: str | None = None,
+        cookie: str | None = None,
+        timeout: float = 15.0,
+    ) -> None:
+        self.portal_url = (
+            portal_url
+            or os.environ.get("APOLLO_PORTAL_URL")
+            or DEFAULT_PORTAL_URL
+        ).rstrip("/")
+        self.cookie = (cookie or os.environ.get("APOLLO_COOKIE", "")).strip()
+        if not self.cookie:
+            raise ApolloAuthError("Missing APOLLO_COOKIE environment variable.")
+        self.timeout = timeout
+
+    def _headers(self) -> dict[str, str]:
+        return {"Cookie": self.cookie, "Accept": "application/json"}
+
+    def _get(self, path: str, params: dict[str, Any] | None = None) -> Any:
+        url = f"{self.portal_url}{path}"
+        try:
+            resp = httpx.get(
+                url,
+                headers=self._headers(),
+                params=params,
+                timeout=self.timeout,
+                follow_redirects=False,
+            )
+        except httpx.RequestError as exc:
+            raise RuntimeError(f"Apollo request failed: {exc}") from exc
+
+        if resp.status_code in (301, 302, 303, 307, 308):
+            raise ApolloAuthError(
+                "Apollo redirected (cookie likely expired). Re-export cookie from browser."
+            )
+        content_type = resp.headers.get("content-type", "")
+        text = resp.text
+        lowered = text[:4000].lower()
+        if (
+            "text/html" in content_type.lower()
+            and ("signin" in lowered or "login-submit" in lowered)
+        ):
+            raise ApolloAuthError(
+                "Apollo returned login page (cookie expired). Re-export cookie from browser."
+            )
+        if resp.status_code >= 400:
+            raise RuntimeError(f"Apollo HTTP {resp.status_code}: {text[:200]}")
+        try:
+            return resp.json()
+        except ValueError:
+            return text
+
+    @staticmethod
+    def _ns_name(ns: dict) -> str:
+        return (
+            (ns.get("baseInfo") or {}).get("namespaceName")
+            or ns.get("namespaceName")
+            or ns.get("name")
+            or ""
+        )
+
+    def list_namespaces(
+        self, app_id: str, env: str, cluster: str
+    ) -> list[dict]:
+        path = (
+            f"/apps/{_seg(app_id)}/envs/{_seg(env)}"
+            f"/clusters/{_seg(cluster)}/namespaces"
+        )
+        data = self._get(path)
+        if not isinstance(data, list):
+            raise RuntimeError(f"Unexpected namespace response: {str(data)[:200]}")
+        return data
+
+    def get_namespace_content(
+        self, app_id: str, namespace: str, env: str, cluster: str
+    ) -> dict:
+        # 走单 namespace 详情接口,而非复用 list 接口:
+        # list 接口对 xml/json/yaml 等"文件型"namespace 不回填 items,
+        # 只有 /namespaces/{ns} 详情接口才返回完整配置内容。
+        path = (
+            f"/apps/{_seg(app_id)}/envs/{_seg(env)}/clusters/{_seg(cluster)}"
+            f"/namespaces/{_seg(namespace)}"
+        )
+        ns = self._get(path)
+        if not isinstance(ns, dict):
+            raise RuntimeError(f"Unexpected namespace response: {str(ns)[:200]}")
+        items = ns.get("items") or []
+        base = ns.get("baseInfo") or {}
+        fmt = ns.get("format") or base.get("format") or "properties"
+        return {
+            "app_id": app_id,
+            "namespace": namespace,
+            "env": env,
+            "cluster": cluster,
+            "format": fmt,
+            "items": [_item_kv(i) for i in items],
+        }
+
+    def fetch_commits(
+        self,
+        app_id: str,
+        namespace: str,
+        env: str,
+        cluster: str,
+        since: str | None = None,
+        max_commits: int = 500,
+    ) -> list[dict]:
+        """分页拉提交历史，按时间倒序（[0] 最新）。拉到覆盖 since 或拉完或达 max_commits。
+
+        commit 记录的是"改动人"的提交（dataChangeCreatedBy），与发布人分离。
+        """
+        base = (
+            f"/apps/{_seg(app_id)}/envs/{_seg(env)}/clusters/{_seg(cluster)}"
+            f"/namespaces/{_seg(namespace)}/commits"
+        )
+        all_commits: list[dict] = []
+        page = 0
+        while page < 50:
+            data = self._get(base, params={"page": page, "size": PAGE_SIZE})
+            arr = (
+                data
+                if isinstance(data, list)
+                else (data.get("content") if isinstance(data, dict) else [])
+            )
+            if not arr:
+                break
+            all_commits.extend(arr)
+            if len(arr) < PAGE_SIZE:
+                break
+            if len(all_commits) >= max_commits:
+                break
+            oldest = arr[-1].get("dataChangeCreatedTime") or ""
+            if since and oldest and oldest < since:
+                break
+            page += 1
+        return all_commits

mcp_apollo_explorer/diff.py

@@ -0,0 +1,220 @@
+"""Line-level diff using difflib, structured output."""
+
+from __future__ import annotations
+
+import difflib
+import json
+from typing import Any
+
+from mcp_apollo_explorer.xml_parent import parse_xml_tree, parent_paths_for_lines
+
+
+def diff_values(old: str | None, new: str | None) -> dict[str, Any]:
+    """对比单个 value，返回 {type, old_lines, new_lines}。
+
+    type: added / removed / modified / unchanged
+    多行 value 用 SequenceMatcher 按行对比，只保留变化的行。
+    """
+    old = "" if old is None else str(old)
+    new = "" if new is None else str(new)
+    if old == new:
+        return {"type": "unchanged", "old_lines": [], "new_lines": []}
+    if not old and new:
+        return {"type": "added", "old_lines": [], "new_lines": new.split("\n")}
+    if old and not new:
+        return {"type": "removed", "old_lines": old.split("\n"), "new_lines": []}
+
+    old_lines = old.split("\n")
+    new_lines = new.split("\n")
+    sm = difflib.SequenceMatcher(a=old_lines, b=new_lines, autojunk=False)
+    old_out: list[str] = []
+    new_out: list[str] = []
+    for tag, i1, i2, j1, j2 in sm.get_opcodes():
+        if tag == "equal":
+            continue
+        old_out.extend(old_lines[i1:i2])
+        new_out.extend(new_lines[j1:j2])
+    return {"type": "modified", "old_lines": old_out, "new_lines": new_out}
+
+
+def _diff_with_lines(old: str | None, new: str | None) -> dict[str, Any]:
+    """对比单个 value,返回 {type, old_lines, new_lines, old_line_nums, new_line_nums}。
+
+    与 diff_values 同样的 type/old_lines/new_lines,额外给出变化的行号
+    (1-based,基于各自原文行列表),供 xml 父元素定位使用。
+    """
+    old = "" if old is None else str(old)
+    new = "" if new is None else str(new)
+    if old == new:
+        return {
+            "type": "unchanged",
+            "old_lines": [],
+            "new_lines": [],
+            "old_line_nums": [],
+            "new_line_nums": [],
+        }
+    if not old and new:
+        nl = new.split("\n")
+        return {
+            "type": "added",
+            "old_lines": [],
+            "new_lines": nl,
+            "old_line_nums": [],
+            "new_line_nums": list(range(1, len(nl) + 1)),
+        }
+    if old and not new:
+        ol = old.split("\n")
+        return {
+            "type": "removed",
+            "old_lines": ol,
+            "new_lines": [],
+            "old_line_nums": list(range(1, len(ol) + 1)),
+            "new_line_nums": [],
+        }
+
+    old_lines = old.split("\n")
+    new_lines = new.split("\n")
+    sm = difflib.SequenceMatcher(a=old_lines, b=new_lines, autojunk=False)
+    old_out: list[str] = []
+    new_out: list[str] = []
+    old_nums: list[int] = []
+    new_nums: list[int] = []
+    for tag, i1, i2, j1, j2 in sm.get_opcodes():
+        if tag == "equal":
+            continue
+        old_out.extend(old_lines[i1:i2])
+        new_out.extend(new_lines[j1:j2])
+        old_nums.extend(range(i1 + 1, i2 + 1))  # 1-based
+        new_nums.extend(range(j1 + 1, j2 + 1))
+    return {
+        "type": "modified",
+        "old_lines": old_out,
+        "new_lines": new_out,
+        "old_line_nums": old_nums,
+        "new_line_nums": new_nums,
+    }
+
+
+def _commit_item_kv(item: dict | None) -> tuple[str | None, str | None]:
+    """从 commit 的 change item 取 (key, value)。
+
+    兼容嵌套 {oldItem/newItem: {key, value}} 与扁平 {key, value} / {key, oldValue/newValue}。
+    调用方决定传入 oldItem 还是 newItem。
+    """
+    if not isinstance(item, dict):
+        return None, None
+    key = item.get("key")
+    value = item.get("value")
+    if value is None:
+        value = item.get("newValue", item.get("oldValue"))
+    return key, value
+
+
+def _is_xml_value(v: object) -> bool:
+    """粗判 value 是否为 xml 文本(以 '<' 开头)。避免对普通值调 expat。"""
+    return (v or "").lstrip().startswith("<")
+
+
+def _parent_paths(
+    old_val: object,
+    new_val: object,
+    old_line_nums: list[int],
+    new_line_nums: list[int],
+) -> list[str]:
+    """根据变化的行号,定位 xml 改动节点的父元素路径(去重)。
+
+    new 侧改动行(增/改)在新版本 xml 树里定位;old 侧改动行(删/改)在旧版本
+    树里定位。非 xml 值(_is_xml_value 为假)不参与,返回空。
+    一个 change 的多处改动可能落在不同父元素下,故返回列表。
+    """
+    out: list[str] = []
+    seen: set[str] = set()
+    if new_line_nums and _is_xml_value(new_val):
+        root = parse_xml_tree(str(new_val))
+        for p in parent_paths_for_lines(root, new_line_nums):
+            if p not in seen:
+                seen.add(p)
+                out.append(p)
+    if old_line_nums and _is_xml_value(old_val):
+        root = parse_xml_tree(str(old_val))
+        for p in parent_paths_for_lines(root, old_line_nums):
+            if p not in seen:
+                seen.add(p)
+                out.append(p)
+    return out
+
+
+def diff_commit(change_sets: Any) -> list[dict]:
+    """解析 commit 的 changeSets，返回 changes 列表。
+
+    changeSets 可能是 JSON 字符串（xml/文件型 namespace 实测为此形式）
+    或 dict。每个 change: {key, type:added|removed|modified, old_lines, new_lines, parent_paths};
+    parent_paths 为 xml 文件型改动行的父元素路径列表(非 xml 为空)。
+    """
+    if isinstance(change_sets, str):
+        try:
+            change_sets = json.loads(change_sets)
+        except (ValueError, TypeError):
+            return []
+    if not isinstance(change_sets, dict):
+        return []
+
+    changes: list[dict] = []
+    for it in change_sets.get("createItems") or []:
+        inner = it.get("newItem") if isinstance(it, dict) else None
+        key, new_val = _commit_item_kv(inner or it)
+        d = _diff_with_lines(None, new_val)
+        changes.append(
+            {
+                "key": key,
+                "type": "added",
+                "old_lines": d["old_lines"],
+                "new_lines": d["new_lines"],
+                "parent_paths": _parent_paths(
+                    None, new_val, d["old_line_nums"], d["new_line_nums"]
+                ),
+            }
+        )
+    for it in change_sets.get("updateItems") or []:
+        if not isinstance(it, dict):
+            continue
+        old_inner = it.get("oldItem")
+        new_inner = it.get("newItem")
+        if isinstance(old_inner, dict) or isinstance(new_inner, dict):
+            # 嵌套:{oldItem:{key,value}, newItem:{key,value}}
+            k_old, old_val = _commit_item_kv(old_inner)
+            k_new, new_val = _commit_item_kv(new_inner)
+            key = k_new or k_old
+        else:
+            # 扁平:{key, oldValue, newValue}（须分别取,不能共用 _commit_item_kv）
+            key = it.get("key")
+            old_val = it.get("oldValue")
+            new_val = it.get("newValue", it.get("value"))
+        d = _diff_with_lines(old_val, new_val)
+        changes.append(
+            {
+                "key": key,
+                "type": "modified",
+                "old_lines": d["old_lines"],
+                "new_lines": d["new_lines"],
+                "parent_paths": _parent_paths(
+                    old_val, new_val, d["old_line_nums"], d["new_line_nums"]
+                ),
+            }
+        )
+    for it in change_sets.get("deleteItems") or []:
+        inner = it.get("oldItem") if isinstance(it, dict) else None
+        key, old_val = _commit_item_kv(inner or it)
+        d = _diff_with_lines(old_val, None)
+        changes.append(
+            {
+                "key": key,
+                "type": "removed",
+                "old_lines": d["old_lines"],
+                "new_lines": d["new_lines"],
+                "parent_paths": _parent_paths(
+                    old_val, None, d["old_line_nums"], d["new_line_nums"]
+                ),
+            }
+        )
+    return changes

mcp_apollo_explorer/server.py

@@ -0,0 +1,202 @@
+"""MCP server for exploring Apollo config center (cookie auth)."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from mcp.server.fastmcp import FastMCP
+
+from mcp_apollo_explorer.apollo_client import (
+    DEFAULT_CLUSTER,
+    DEFAULT_ENV,
+    ApolloClient,
+)
+
+from mcp_apollo_explorer.diff import diff_commit
+
+mcp = FastMCP("mcp-apollo-explorer")
+
+
+def _client() -> ApolloClient:
+    """从环境变量构造 client（cookie / portal_url）。"""
+    return ApolloClient()
+
+
+def _ns_name(ns: dict) -> str:
+    return (
+        (ns.get("baseInfo") or {}).get("namespaceName")
+        or ns.get("namespaceName")
+        or ns.get("name")
+        or ""
+    )
+
+
+def _time_ge(value: str, bound: str) -> bool:
+    """value 是否 >= bound(前缀截断比较)。
+
+    Apollo 时间形如 '2026-07-23T10:00:00.000+0800';bound 可传日期
+    '2026-07-23' 或完整时间戳。按 bound 精度截断 value 再比较,使
+    '当天' 边界正确:since='2026-07-23' 应包含当天的所有时刻。
+    """
+    return value[: len(bound)] >= bound
+
+
+def _time_le(value: str, bound: str) -> bool:
+    """value 是否 <= bound(前缀截断比较)。
+
+    until='2026-07-23' 应包含当天所有时刻,故截断到日期精度比较;
+    否则 '2026-07-23T10:00...' 字典序大于 '2026-07-23' 会被误排除。
+    """
+    return value[: len(bound)] <= bound
+
+
+@mcp.tool()
+def apollo_list_namespaces(
+    app_id: str,
+    env: str = DEFAULT_ENV,
+    cluster: str = DEFAULT_CLUSTER,
+) -> dict[str, Any]:
+    """根据 appId 查询有多少个 namespace 及其名称列表。
+
+    Args:
+        app_id: Apollo appId
+        env: 环境，默认 DEV
+        cluster: 集群，默认 default
+
+    Returns:
+        {app_id, env, cluster, count, namespaces:[name,...]}
+    """
+    client = _client()
+    ns_list = client.list_namespaces(app_id, env, cluster)
+    names = [_ns_name(n) for n in ns_list]
+    return {
+        "app_id": app_id,
+        "env": env,
+        "cluster": cluster,
+        "count": len(names),
+        "namespaces": names,
+    }
+
+
+@mcp.tool()
+def apollo_get_namespace_content(
+    app_id: str,
+    namespace: str,
+    env: str = DEFAULT_ENV,
+    cluster: str = DEFAULT_CLUSTER,
+) -> dict[str, Any]:
+    """根据 appId 和 namespace 查询当前配置内容（items）。
+
+    Args:
+        app_id: Apollo appId
+        namespace: namespace 名称
+        env: 环境，默认 DEV
+        cluster: 集群，默认 default
+
+    Returns:
+        {app_id, namespace, env, cluster, format, items:[{key,value}]}
+    """
+    client = _client()
+    return client.get_namespace_content(app_id, namespace, env, cluster)
+
+
+@mcp.tool()
+def apollo_change_history(
+    app_ids: list[str],
+    since: str,
+    env: str = DEFAULT_ENV,
+    cluster: str = DEFAULT_CLUSTER,
+    user: str | None = None,
+    until: str | None = None,
+    max_commits_per_namespace: int = 500,
+) -> dict[str, Any]:
+    """查询 Apollo 变更历史：按 appId 列表查指定时间区间的提交，含每次提交的行级 diff。
+
+    基于 commit（提交）而非 release（发布），user 筛的是"改动人"而非"发布人"——
+    即使我改的内容被别人发布，也能按我的 userId 查到。
+
+    Args:
+        app_ids: 要查的 appId 列表
+        since: 起始日期/时间 ISO 格式，如 2026-06-07 或 2026-06-07T00:00:00（含）
+        env: 环境，默认 DEV
+        cluster: 集群，默认 default
+        user: 可选，按改动人 userId 过滤；不传则返回所有人
+        until: 可选，截止日期/时间 ISO 格式（含该时刻），如 2026-07-23 或
+            2026-07-23T18:00:00；不传则上不封顶；应 >= since，否则结果为空
+        max_commits_per_namespace: 每个 namespace 最多拉取的 commit 数，默认 500
+
+    Returns:
+        每个匹配提交含 time/user/changes，changes 为
+        {key, type:added|removed|modified, old_lines, new_lines, parent_paths} 列表；
+        parent_paths 为 xml 文件型改动行所属元素的父路径(如 /root/config/db)，非 xml 为空列表。
+    """
+    client = _client()
+    result: dict[str, Any] = {
+        "env": env,
+        "cluster": cluster,
+        "since": since,
+        "until": until,
+        "user": user,
+        "apps": [],
+    }
+    for app_id in app_ids:
+        app_entry: dict[str, Any] = {"app_id": app_id, "namespaces": []}
+        try:
+            ns_list = client.list_namespaces(app_id, env, cluster)
+        except Exception as exc:  # noqa: BLE001
+            app_entry["error"] = str(exc)
+            result["apps"].append(app_entry)
+            continue
+        for ns in ns_list:
+            ns_name = _ns_name(ns)
+            try:
+                commits = client.fetch_commits(
+                    app_id,
+                    ns_name,
+                    env,
+                    cluster,
+                    since=since,
+                    max_commits=max_commits_per_namespace,
+                )
+            except Exception as exc:  # noqa: BLE001
+                app_entry["namespaces"].append(
+                    {"namespace": ns_name, "error": str(exc)}
+                )
+                continue
+            truncated = len(commits) >= max_commits_per_namespace
+            matched: list[dict[str, Any]] = []
+            for c in commits:
+                who = c.get("dataChangeCreatedBy")
+                when = c.get("dataChangeCreatedTime") or ""
+                if not _time_ge(when, since):
+                    continue
+                if until and not _time_le(when, until):
+                    continue
+                if user and who != user:
+                    continue
+                changes = diff_commit(c.get("changeSets"))
+                matched.append(
+                    {
+                        "time": when,
+                        "user": who,
+                        "changes": changes,
+                    }
+                )
+            if matched:
+                app_entry["namespaces"].append(
+                    {
+                        "namespace": ns_name,
+                        "truncated": truncated,
+                        "matched_commits": matched,
+                    }
+                )
+        result["apps"].append(app_entry)
+    return result
+
+
+def main() -> None:
+    mcp.run(transport="stdio")
+
+
+if __name__ == "__main__":
+    main()

mcp_apollo_explorer/xml_parent.py

@@ -0,0 +1,117 @@
+"""xml 文件型 namespace 改动行的父元素定位。
+
+Apollo 的 xml/json/yaml 等"文件型" namespace 把整个文件文本作为单个 item
+(key 固定 'content'),diff 出来的 old_lines/new_lines 是文件文本行的片段。
+这里用 expat 解析 xml,为每个元素记录起止行号(1-based),构建带行号的元素树;
+给定 diff 改动行号,定位包含该行的最深层元素(即"改动节点"),返回其父元素
+的标签路径(如 /RecruitV6AIInterviewConfig/Styles)。
+
+只用标准库 expat,不引入 lxml。
+"""
+
+from __future__ import annotations
+
+import xml.parsers.expat
+
+
+class _Node:
+    __slots__ = ("tag", "start", "end", "parent", "children")
+
+    def __init__(self, tag: str, start: int, parent: "_Node | None") -> None:
+        self.tag = tag
+        self.start = start  # '<tag' 所在行(1-based)
+        self.end = -1  # '</tag>' 所在行;自闭合 start==end;未闭合 -1
+        self.parent = parent
+        self.children: list[_Node] = []
+
+    @property
+    def depth(self) -> int:
+        d = 0
+        p = self.parent
+        while p is not None:
+            d += 1
+            p = p.parent
+        return d
+
+
+def parse_xml_tree(text: str) -> _Node | None:
+    """解析 xml 文本为带行号的元素树,返回根节点;解析失败返回 None。
+
+    起止行号取自 expat 的 CurrentLineNumber:start 在 StartElementHandler,
+    end 在 EndElementHandler(自闭合标签同行)。
+    """
+    parser = xml.parsers.expat.ParserCreate()
+    stack: list[_Node] = []
+    root: list[_Node | None] = [None]
+
+    def on_start(tag: str, _attrs) -> None:
+        parent = stack[-1] if stack else None
+        node = _Node(tag, parser.CurrentLineNumber, parent)
+        if parent is not None:
+            parent.children.append(node)
+        else:
+            root[0] = node
+        stack.append(node)
+
+    def on_end(_tag: str) -> None:
+        if stack:
+            stack.pop().end = parser.CurrentLineNumber
+
+    parser.StartElementHandler = on_start
+    parser.EndElementHandler = on_end
+    try:
+        parser.Parse(text or "", True)
+    except xml.parsers.expat.ExpatError:
+        return None
+    return root[0]
+
+
+def _path(node: _Node) -> str:
+    parts: list[str] = []
+    p: _Node | None = node
+    while p is not None:
+        parts.append(p.tag)
+        p = p.parent
+    parts.reverse()
+    return "/" + "/".join(parts)
+
+
+def _deepest_containing(root: _Node, line: int) -> _Node | None:
+    """找 start <= line <= end 的最深层节点(改动行所属元素);无则 None。"""
+    best: _Node | None = None
+    stack = [root]
+    while stack:
+        n = stack.pop()
+        end = n.end if n.end >= 0 else n.start
+        if n.start <= line <= end:
+            if best is None or n.depth > best.depth:
+                best = n
+        stack.extend(n.children)
+    return best
+
+
+def parent_path_for_line(root: _Node, line: int) -> str | None:
+    """改动行号 line 所属最深层元素(改动节点)的父元素路径。
+
+    根元素自身无父、或行号不在任何元素范围内,返回 None。
+    """
+    if root is None:
+        return None
+    node = _deepest_containing(root, line)
+    if node is None or node.parent is None:
+        return None
+    return _path(node.parent)
+
+
+def parent_paths_for_lines(root: _Node | None, lines: list[int]) -> list[str]:
+    """批量返回多个改动行号的父元素路径(去重,保持首次出现顺序)。"""
+    out: list[str] = []
+    if root is None:
+        return out
+    seen: set[str] = set()
+    for ln in lines:
+        p = parent_path_for_line(root, ln)
+        if p and p not in seen:
+            seen.add(p)
+            out.append(p)
+    return out

mcp_apollo_explorer-0.1.0.dist-info/METADATA

@@ -0,0 +1,7 @@
+Metadata-Version: 2.4
+Name: mcp-apollo-explorer
+Version: 0.1.0
+Summary: MCP server for exploring Apollo config center (history/namespace/content) via cookie auth
+Requires-Python: >=3.10
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: mcp[cli]>=1.2.0

mcp_apollo_explorer-0.1.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+mcp_apollo_explorer/__init__.py,sha256=uOHvXk7xPoIE6qqQQHgajsR1S_oDZG1HMF9Is3kdSSY,92
+mcp_apollo_explorer/apollo_client.py,sha256=sHM2ZJ8lqimO6xFvkeTQ1smUotqzFHL4lnzo9Vt-8mo,5916
+mcp_apollo_explorer/diff.py,sha256=whv_yNqYA8Pk3sCNWe6JKKtsoWjPXwdhSDBqH46sF70,7842
+mcp_apollo_explorer/server.py,sha256=9kL7tbAoTSG1NtACQDPg1BJUW2ceLOFu_EnR8VGNrvY,6351
+mcp_apollo_explorer/xml_parent.py,sha256=ETcxb6zytVu88-RewInabgJlvlNftsXAxpfJzMsCFkw,3678
+mcp_apollo_explorer-0.1.0.dist-info/METADATA,sha256=kkCbYW_6lWx3p_iG2tEQM8P6AnR7o2fePm4v4QC9jkg,246
+mcp_apollo_explorer-0.1.0.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+mcp_apollo_explorer-0.1.0.dist-info/entry_points.txt,sha256=qb0mGiPQ7cxrYZvrVUjE8Mc7jLk1OCnxxg0dt2sgAV0,72
+mcp_apollo_explorer-0.1.0.dist-info/RECORD,,

mcp_apollo_explorer-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.31.0
+Root-Is-Purelib: true
+Tag: py3-none-any

mcp_apollo_explorer-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+mcp-apollo-explorer = mcp_apollo_explorer.server:main