diff --git a/astrbot/core/collection/__init__.py b/astrbot/core/collection/__init__.py
new file mode 100644
index 000000000..b2167ef3a
--- /dev/null
+++ b/astrbot/core/collection/__init__.py
@@ -0,0 +1,9 @@
+"""Plugin collection module."""
+
+from .models import CollectionMetadata, CollectionPlugin, PluginCollection
+
+__all__ = [
+    "CollectionMetadata",
+    "CollectionPlugin",
+    "PluginCollection",
+]
diff --git a/astrbot/core/collection/compatibility.py b/astrbot/core/collection/compatibility.py
new file mode 100644
index 000000000..ff64a06ba
--- /dev/null
+++ b/astrbot/core/collection/compatibility.py
@@ -0,0 +1,114 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any
+
+from astrbot.core import logger, sp
+from astrbot.core.star.star_handler import star_handlers_registry
+
+
+@dataclass(slots=True)
+class PriorityApplyResult:
+    persisted: bool
+    applied_in_memory: bool
+
+
+class PriorityCompatibility:
+    """Compatibility layer for handler priority overrides (PR4716)."""
+
+    @staticmethod
+    async def get_priority_overrides() -> dict[str, int]:
+        try:
+            overrides = await sp.global_get("handler_priority_overrides", {})
+            if isinstance(overrides, dict) and overrides:
+                return {str(k): int(v) for k, v in overrides.items()}
+        except Exception as e:
+            logger.debug(f"Failed to read handler_priority_overrides from sp: {e!s}")
+
+        overrides: dict[str, int] = {}
+        for name, handler in star_handlers_registry.star_handlers_map.items():
+            try:
+                priority = int(handler.extras_configs.get("priority", 0) or 0)
+            except Exception:
+                priority = 0
+            if priority != 0:
+                overrides[name] = priority
+        return overrides
+
+    @staticmethod
+    async def apply_priority_overrides(
+        overrides: dict[str, int],
+    ) -> PriorityApplyResult:
+        normalized: dict[str, int] = {
+            str(k): int(v) for k, v in (overrides or {}).items()
+        }
+
+        try:
+            await sp.global_put("handler_priority_overrides", normalized)
+            return PriorityApplyResult(persisted=True, applied_in_memory=False)
+        except Exception as e:
+            logger.debug(f"Failed to write handler_priority_overrides to sp: {e!s}")
+
+        for name, priority in normalized.items():
+            handler = star_handlers_registry.star_handlers_map.get(name)
+            if handler is None:
+                continue
+            handler.extras_configs["priority"] = int(priority)
+
+        # Best-effort compatibility: star_handlers_registry internals may change upstream.
+        try:
+            handlers = getattr(star_handlers_registry, "_handlers", None)
+            if isinstance(handlers, list):
+                handlers.sort(
+                    key=lambda h: -int(h.extras_configs.get("priority", 0) or 0),
+                )
+        except Exception as e:
+            logger.debug(
+                f"Failed to sort handler registry after overrides (best effort): {e!s}"
+            )
+
+        return PriorityApplyResult(persisted=False, applied_in_memory=True)
+
+    @staticmethod
+    async def is_pr4716_available() -> bool:
+        try:
+            await sp.global_get("handler_priority_overrides", {})
+        except Exception:
+            return False
+
+        try:
+            _ = star_handlers_registry.star_handlers_map
+        except Exception:
+            return False
+
+        return True
+
+
+class ConflictDetectionCompatibility:
+    """Compatibility layer for conflict detection (PR4451)."""
+
+    @staticmethod
+    async def check_conflicts(plugins: list[str]) -> dict[str, Any] | None:
+        try:
+            from astrbot.core.star.conflict_detection import (
+                detect_conflicts,  # type: ignore
+            )
+
+            return await detect_conflicts(plugins)
+        except ImportError:
+            return None
+        except Exception as e:
+            logger.warning(f"Conflict detection failed: {e!s}")
+            return None
+
+    @staticmethod
+    def is_conflict_detection_available() -> bool:
+        try:
+            from astrbot.core.star.conflict_detection import (
+                detect_conflicts,  # type: ignore
+            )
+
+            _ = detect_conflicts
+            return True
+        except ImportError:
+            return False
diff --git a/astrbot/core/collection/exporter.py b/astrbot/core/collection/exporter.py
new file mode 100644
index 000000000..02c023f75
--- /dev/null
+++ b/astrbot/core/collection/exporter.py
@@ -0,0 +1,100 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from typing import Any
+
+from astrbot.core import logger
+from astrbot.core.config.default import VERSION
+from astrbot.core.star.star_manager import PluginManager
+
+from .compatibility import PriorityCompatibility
+from .models import CollectionMetadata, CollectionPlugin, PluginCollection
+from .sensitive_filter import SensitiveFilter
+
+
+@dataclass(slots=True)
+class ExportOptions:
+    name: str
+    description: str = ""
+    author: str = ""
+    version: str = "1.0.0"
+    include_configs: bool = True
+    include_priority: bool = True
+    exclude_plugins: list[str] | None = None
+
+
+class CollectionExporter:
+    def __init__(self, plugin_manager: PluginManager) -> None:
+        self.plugin_manager = plugin_manager
+
+    async def export(self, options: ExportOptions) -> dict[str, Any]:
+        exclude = set(options.exclude_plugins or [])
+
+        plugins: list[CollectionPlugin] = []
+        plugin_configs: dict[str, Any] | None = {} if options.include_configs else None
+
+        for plugin in self.plugin_manager.context.get_all_stars():
+            if plugin.name in exclude:
+                continue
+            if not plugin.repo:
+                continue
+
+            if not plugin.name:
+                continue
+
+            plugins.append(
+                CollectionPlugin(
+                    name=str(plugin.name),
+                    repo=plugin.repo,
+                    exported_version=plugin.version or "",
+                    display_name=plugin.display_name,
+                ),
+            )
+
+            if options.include_configs and plugin_configs is not None:
+                cfg = getattr(plugin, "config", None)
+                if cfg is None:
+                    continue
+                try:
+                    cfg_dict = dict(cfg)
+                except Exception as e:
+                    # Log the exception to help diagnose config conversion issues
+                    logger.warning(
+                        f"Failed to convert config for plugin {plugin.name}: {e}"
+                    )
+                    cfg_dict = {}
+
+                # Some plugins may have a missing/None name in edge cases; avoid using None as dict key.
+                if not plugin.name:
+                    continue
+                plugin_configs[str(plugin.name)] = SensitiveFilter.filter_data(cfg_dict)
+
+        created_at = datetime.now(timezone.utc).isoformat()
+        metadata = CollectionMetadata(
+            name=options.name,
+            description=options.description,
+            author=options.author,
+            version=options.version,
+            created_at=created_at,
+            astrbot_version=VERSION,
+            plugin_count=len(plugins),
+        )
+
+        handler_priority_overrides: dict[str, int] | None = None
+        if options.include_priority:
+            handler_priority_overrides = (
+                await PriorityCompatibility.get_priority_overrides()
+            )
+
+        collection = PluginCollection(
+            schema_version=PluginCollection.SCHEMA_VERSION,
+            metadata=metadata,
+            plugins=plugins,
+            plugin_configs=plugin_configs,
+            handler_priority_overrides=handler_priority_overrides,
+        )
+
+        payload = collection.to_dict()
+        PluginCollection.validate_dict(payload)
+        return payload
diff --git a/astrbot/core/collection/importer.py b/astrbot/core/collection/importer.py
new file mode 100644
index 000000000..bd6ce6fee
--- /dev/null
+++ b/astrbot/core/collection/importer.py
@@ -0,0 +1,383 @@
+from __future__ import annotations
+
+import asyncio
+from collections.abc import Awaitable, Callable
+from typing import Any
+
+from astrbot.core import logger
+from astrbot.core.star.star_manager import PluginManager
+
+from .compatibility import ConflictDetectionCompatibility, PriorityCompatibility
+from .models import ImportOptions, PluginCollection
+
+
+class CollectionImporter:
+    def __init__(self, plugin_manager: PluginManager) -> None:
+        self.plugin_manager = plugin_manager
+
+    async def preview(
+        self, collection: PluginCollection, *, import_mode: str
+    ) -> dict[str, Any]:
+        installed = self._get_installed_names()
+
+        plugins_to_install = []
+        plugins_to_skip = []
+        for p in collection.plugins:
+            if p.name in installed:
+                plugins_to_skip.append(
+                    {"name": p.name, "repo": p.repo, "status": "installed"}
+                )
+            else:
+                plugins_to_install.append(
+                    {
+                        "name": p.name,
+                        "repo": p.repo,
+                        "exported_version": p.exported_version,
+                        "status": "not_installed",
+                    },
+                )
+
+        plugins_to_uninstall: list[dict[str, Any]] = []
+        if import_mode == "clean":
+            keep = {p.name for p in collection.plugins}
+            for p in self.plugin_manager.context.get_all_stars():
+                if p.reserved:
+                    continue
+                if p.name in keep:
+                    continue
+                plugins_to_uninstall.append({"name": p.name})
+
+        configs_count = 0
+        if isinstance(collection.plugin_configs, dict):
+            configs_count = len(collection.plugin_configs)
+
+        return {
+            "metadata": collection.metadata.to_dict(),
+            "plugins_to_install": plugins_to_install,
+            "plugins_to_skip": plugins_to_skip,
+            "plugins_to_uninstall": plugins_to_uninstall,
+            "configs_count": configs_count,
+            "has_priority_overrides": bool(collection.handler_priority_overrides),
+            "conflict_detection_available": ConflictDetectionCompatibility.is_conflict_detection_available(),
+        }
+
+    def _get_installed_names(self) -> set[str]:
+        return {p.name for p in self.plugin_manager.context.get_all_stars() if p.name}
+
+    async def _run_install_tasks(
+        self, tasks: list[Awaitable[dict[str, Any]]]
+    ) -> tuple[list[dict[str, Any]], list[dict[str, Any]]]:
+        installed_results: list[dict[str, Any]] = []
+        failed_results: list[dict[str, Any]] = []
+
+        raw = await asyncio.gather(*tasks, return_exceptions=True)
+        for r in raw:
+            if isinstance(r, asyncio.CancelledError):
+                raise r
+            if isinstance(r, BaseException):
+                failed_results.append(
+                    {"name": "unknown", "status": "error", "message": str(r)}
+                )
+            elif r.get("status") == "ok":
+                installed_results.append(r)
+            else:
+                failed_results.append(r)
+
+        return installed_results, failed_results
+
+    def _build_install_task_factory(
+        self, *, proxy: str
+    ) -> Callable[[str, str], Awaitable[dict[str, Any]]]:
+        sem = asyncio.Semaphore(3)
+
+        async def _install_one(name: str, repo: str) -> dict[str, Any]:
+            async with sem:
+                try:
+                    await self.plugin_manager.install_plugin(repo, proxy)
+                    return {
+                        "name": name,
+                        "status": "ok",
+                        "message": "installed",
+                        "exported_version_note": (
+                            "Recorded for reference only; collection import does not lock plugin version."
+                        ),
+                    }
+                except Exception as e:
+                    return {"name": name, "status": "error", "message": str(e)}
+
+        return _install_one
+
+    async def _uninstall_for_clean_mode(
+        self, *, keep_set: set[str], import_mode: str
+    ) -> dict[str, Any]:
+        if import_mode != "clean":
+            return {"ok": [], "failed": [], "skipped": []}
+
+        ok: list[dict[str, Any]] = []
+        failed: list[dict[str, Any]] = []
+        skipped: list[dict[str, Any]] = []
+
+        for p in list(self.plugin_manager.context.get_all_stars()):
+            if p.reserved:
+                skipped.append(
+                    {"name": p.name, "status": "skipped", "reason": "reserved"}
+                )
+                continue
+            if not p.name:
+                skipped.append(
+                    {"name": p.name, "status": "skipped", "reason": "empty_name"}
+                )
+                continue
+            if p.name in keep_set:
+                skipped.append({"name": p.name, "status": "skipped", "reason": "kept"})
+                continue
+
+            try:
+                await self.plugin_manager.uninstall_plugin(p.name)
+                ok.append({"name": p.name, "status": "ok", "message": "uninstalled"})
+            except Exception as e:
+                logger.error(f"Uninstall plugin failed ({p.name}): {e!s}")
+                failed.append({"name": p.name, "status": "error", "message": str(e)})
+
+        return {"ok": ok, "failed": failed, "skipped": skipped}
+
+    async def _install_plugins(
+        self,
+        collection: PluginCollection,
+        *,
+        options: ImportOptions,
+        installed_before: set[str],
+    ) -> dict[str, Any]:
+        ok: list[dict[str, Any]] = []
+        failed: list[dict[str, Any]] = []
+        skipped: list[dict[str, Any]] = []
+
+        install_one = self._build_install_task_factory(proxy=options.proxy)
+        tasks = []
+        for p in collection.plugins:
+            if not p.name:
+                skipped.append(
+                    {"name": p.name, "status": "skipped", "reason": "empty_name"}
+                )
+                continue
+            if options.import_mode == "add" and p.name in installed_before:
+                skipped.append(
+                    {"name": p.name, "status": "skipped", "reason": "already_installed"}
+                )
+                continue
+            tasks.append(install_one(p.name, p.repo))
+
+        installed_results, failed_results = await self._run_install_tasks(tasks)
+        ok.extend(installed_results)
+        failed.extend(failed_results)
+
+        return {"ok": ok, "failed": failed, "skipped": skipped}
+
+    async def _apply_configs(
+        self,
+        collection: PluginCollection,
+        *,
+        options: ImportOptions,
+        installed_before: set[str],
+    ) -> dict[str, Any]:
+        if not options.apply_configs or not isinstance(collection.plugin_configs, dict):
+            return {"ok": [], "failed": [], "skipped": [], "reload_queue": []}
+
+        ok: list[dict[str, Any]] = []
+        failed: list[dict[str, Any]] = []
+        skipped: list[dict[str, Any]] = []
+        reload_queue: list[str] = []
+
+        for plugin_name, cfg in collection.plugin_configs.items():
+            if not isinstance(cfg, dict):
+                skipped.append(
+                    {
+                        "name": str(plugin_name),
+                        "status": "skipped",
+                        "reason": "invalid_config",
+                    }
+                )
+                continue
+
+            md = self.plugin_manager.context.get_registered_star(plugin_name)
+            config = getattr(md, "config", None) if md is not None else None
+            if config is None:
+                skipped.append(
+                    {"name": plugin_name, "status": "skipped", "reason": "no_config"}
+                )
+                continue
+
+            is_existing = plugin_name in installed_before
+            if (
+                options.import_mode == "add"
+                and is_existing
+                and not options.overwrite_existing_configs
+            ):
+                skipped.append(
+                    {
+                        "name": plugin_name,
+                        "status": "skipped",
+                        "reason": "existing_config_not_overwritten",
+                    }
+                )
+                continue
+
+            try:
+                current_cfg = dict(config)
+            except Exception:
+                current_cfg = {}
+
+            merged_cfg = {**current_cfg, **cfg}
+
+            try:
+                config.save_config(merged_cfg)
+                ok.append(
+                    {"name": plugin_name, "status": "ok", "message": "config_applied"}
+                )
+                if plugin_name not in reload_queue:
+                    reload_queue.append(plugin_name)
+            except Exception as e:
+                logger.error(f"Apply config failed ({plugin_name}): {e!s}")
+                failed.append(
+                    {"name": plugin_name, "status": "error", "message": str(e)}
+                )
+
+        return {
+            "ok": ok,
+            "failed": failed,
+            "skipped": skipped,
+            "reload_queue": reload_queue,
+        }
+
+    async def _reload_plugins(self, *, reload_queue: list[str]) -> dict[str, Any]:
+        ok: list[dict[str, Any]] = []
+        failed: list[dict[str, Any]] = []
+
+        for plugin_name in reload_queue:
+            try:
+                await self.plugin_manager.reload(plugin_name)
+                ok.append({"name": plugin_name, "status": "ok", "message": "reloaded"})
+            except Exception as e:
+                logger.error(f"Reload plugin failed ({plugin_name}): {e!s}")
+                failed.append(
+                    {"name": plugin_name, "status": "error", "message": str(e)}
+                )
+
+        return {"ok": ok, "failed": failed}
+
+    async def _apply_priority_overrides(
+        self, collection: PluginCollection, *, options: ImportOptions
+    ) -> dict[str, Any]:
+        if not options.apply_priority or not isinstance(
+            collection.handler_priority_overrides, dict
+        ):
+            return {
+                "ok": [],
+                "failed": [],
+                "skipped": [
+                    {
+                        "name": "priority",
+                        "status": "skipped",
+                        "reason": "disabled_or_missing",
+                    }
+                ],
+                "priority_persisted": False,
+                "priority_applied_in_memory": False,
+                "priority_note": "",
+            }
+
+        apply_result = await PriorityCompatibility.apply_priority_overrides(
+            collection.handler_priority_overrides,
+        )
+        priority_note = ""
+        if apply_result.applied_in_memory and not apply_result.persisted:
+            priority_note = "Priority overrides could not be persisted; applied in memory only for this process."
+
+        return {
+            "ok": [{"name": "priority", "status": "ok", "message": "applied"}],
+            "failed": [],
+            "skipped": [],
+            "priority_persisted": apply_result.persisted,
+            "priority_applied_in_memory": apply_result.applied_in_memory,
+            "priority_note": priority_note,
+        }
+
+    async def import_collection(
+        self, collection: PluginCollection, options: ImportOptions
+    ) -> dict[str, Any]:
+        if options.import_mode not in {"add", "clean"}:
+            raise ValueError("import_mode must be 'add' or 'clean'")
+
+        installed_before = self._get_installed_names()
+
+        conflict_report = await ConflictDetectionCompatibility.check_conflicts(
+            [p.name for p in collection.plugins],
+        )
+
+        keep = {p.name for p in collection.plugins if p.name}
+        uninstall_result = await self._uninstall_for_clean_mode(
+            keep_set=keep,
+            import_mode=options.import_mode,
+        )
+
+        install_result = await self._install_plugins(
+            collection,
+            options=options,
+            installed_before=installed_before,
+        )
+
+        config_result = await self._apply_configs(
+            collection,
+            options=options,
+            installed_before=installed_before,
+        )
+
+        reload_queue = list(config_result.get("reload_queue") or [])
+        reload_result = await self._reload_plugins(reload_queue=reload_queue)
+
+        priority_result = await self._apply_priority_overrides(
+            collection,
+            options=options,
+        )
+
+        uninstalled = list(uninstall_result.get("ok") or [])
+        uninstall_failed = [
+            i.get("name")
+            for i in (uninstall_result.get("failed") or [])
+            if i.get("name")
+        ]
+
+        configs_applied = len(config_result.get("ok") or [])
+        configs_failed = [
+            {"name": i.get("name"), "message": i.get("message")}
+            for i in (config_result.get("failed") or [])
+            if i.get("name")
+        ]
+
+        result: dict[str, Any] = {
+            "installed": list(install_result.get("ok") or []),
+            "failed": list(install_result.get("failed") or []),
+            "skipped": list(install_result.get("skipped") or []),
+            "uninstalled": uninstalled,
+            "uninstall_failed": uninstall_failed,
+            "configs_applied": configs_applied,
+            "configs_failed": configs_failed,
+            "reloaded": reload_queue,
+            "reload_failed": [
+                {"name": i.get("name"), "message": i.get("message")}
+                for i in (reload_result.get("failed") or [])
+                if i.get("name")
+            ],
+            "priority_persisted": bool(priority_result.get("priority_persisted")),
+            "priority_applied_in_memory": bool(
+                priority_result.get("priority_applied_in_memory")
+            ),
+        }
+
+        priority_note = str(priority_result.get("priority_note") or "")
+        if priority_note:
+            result["priority_note"] = priority_note
+        if conflict_report is not None:
+            result["conflicts"] = conflict_report
+
+        return result
diff --git a/astrbot/core/collection/models.py b/astrbot/core/collection/models.py
new file mode 100644
index 000000000..4f89c22c5
--- /dev/null
+++ b/astrbot/core/collection/models.py
@@ -0,0 +1,193 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, ClassVar
+
+from jsonschema import Draft7Validator
+
+
+@dataclass(slots=True)
+class ImportOptions:
+    import_mode: str = "add"  # add | clean
+    apply_configs: bool = True
+    overwrite_existing_configs: bool = False
+    apply_priority: bool = True
+    proxy: str = ""
+
+
+class CollectionValidationError(ValueError):
+    """Raised when a plugin collection payload is invalid."""
+
+
+@dataclass(slots=True)
+class CollectionPlugin:
+    name: str
+    repo: str
+    exported_version: str
+    display_name: str | None = None
+
+    def to_dict(self) -> dict[str, Any]:
+        data: dict[str, Any] = {
+            "name": self.name,
+            "repo": self.repo,
+            "exported_version": self.exported_version,
+        }
+        if self.display_name is not None:
+            data["display_name"] = self.display_name
+        return data
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> CollectionPlugin:
+        exported_version = data.get("exported_version")
+        if exported_version is None:
+            # Backward compatibility for schema 1.0 payloads.
+            exported_version = data.get("version", "")
+        return cls(
+            name=str(data.get("name", "")),
+            repo=str(data.get("repo", "")),
+            exported_version=str(exported_version or ""),
+            display_name=(
+                str(data["display_name"])
+                if data.get("display_name") is not None
+                else None
+            ),
+        )
+
+
+@dataclass(slots=True)
+class CollectionMetadata:
+    name: str
+    description: str
+    author: str
+    version: str
+    created_at: str
+    astrbot_version: str
+    plugin_count: int
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "name": self.name,
+            "description": self.description,
+            "author": self.author,
+            "version": self.version,
+            "created_at": self.created_at,
+            "astrbot_version": self.astrbot_version,
+            "plugin_count": self.plugin_count,
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> CollectionMetadata:
+        return cls(
+            name=str(data.get("name", "")),
+            description=str(data.get("description", "")),
+            author=str(data.get("author", "")),
+            version=str(data.get("version", "")),
+            created_at=str(data.get("created_at", "")),
+            astrbot_version=str(data.get("astrbot_version", "")),
+            plugin_count=int(data.get("plugin_count", 0) or 0),
+        )
+
+
+@dataclass(slots=True)
+class PluginCollection:
+    schema_version: str
+    metadata: CollectionMetadata
+    plugins: list[CollectionPlugin]
+    plugin_configs: dict[str, Any] | None = None
+    handler_priority_overrides: dict[str, int] | None = None
+
+    SCHEMA_VERSION: ClassVar[str] = "1.0"
+
+    JSON_SCHEMA: ClassVar[dict[str, Any]] = {
+        "$schema": "http://json-schema.org/draft-07/schema#",
+        "type": "object",
+        "required": ["schema_version", "metadata", "plugins"],
+        "additionalProperties": False,
+        "properties": {
+            "schema_version": {"type": "string", "enum": ["1.0"]},
+            "metadata": {
+                "type": "object",
+                "required": [
+                    "name",
+                    "description",
+                    "author",
+                    "version",
+                    "created_at",
+                    "astrbot_version",
+                    "plugin_count",
+                ],
+                "additionalProperties": False,
+                "properties": {
+                    "name": {"type": "string", "maxLength": 100},
+                    "description": {"type": "string", "maxLength": 500},
+                    "author": {"type": "string"},
+                    "version": {"type": "string"},
+                    "created_at": {"type": "string", "format": "date-time"},
+                    "astrbot_version": {"type": "string"},
+                    "plugin_count": {"type": "integer", "minimum": 0},
+                },
+            },
+            "plugins": {
+                "type": "array",
+                "items": {
+                    "type": "object",
+                    "required": ["name", "repo", "exported_version"],
+                    "additionalProperties": False,
+                    "properties": {
+                        "name": {"type": "string"},
+                        "repo": {"type": "string"},
+                        "exported_version": {"type": "string"},
+                        "display_name": {"type": ["string", "null"]},
+                    },
+                },
+            },
+            "plugin_configs": {
+                "type": ["object", "null"],
+                "additionalProperties": True,
+            },
+            "handler_priority_overrides": {
+                "type": ["object", "null"],
+                "additionalProperties": {"type": "integer"},
+            },
+        },
+    }
+
+    _validator: ClassVar[Draft7Validator] = Draft7Validator(JSON_SCHEMA)
+
+    def to_dict(self) -> dict[str, Any]:
+        data: dict[str, Any] = {
+            "schema_version": self.schema_version,
+            "metadata": self.metadata.to_dict(),
+            "plugins": [p.to_dict() for p in self.plugins],
+        }
+        if self.plugin_configs is not None:
+            data["plugin_configs"] = self.plugin_configs
+        if self.handler_priority_overrides is not None:
+            data["handler_priority_overrides"] = self.handler_priority_overrides
+        return data
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> PluginCollection:
+        cls.validate_dict(data)
+
+        meta = CollectionMetadata.from_dict(data["metadata"])
+        plugins = [CollectionPlugin.from_dict(p) for p in (data.get("plugins") or [])]
+        return cls(
+            schema_version=str(data.get("schema_version", cls.SCHEMA_VERSION)),
+            metadata=meta,
+            plugins=plugins,
+            plugin_configs=data.get("plugin_configs"),
+            handler_priority_overrides=data.get("handler_priority_overrides"),
+        )
+
+    @classmethod
+    def validate_dict(cls, data: dict[str, Any]) -> None:
+        errors = sorted(cls._validator.iter_errors(data), key=lambda e: list(e.path))
+        if not errors:
+            return
+        parts: list[str] = []
+        for err in errors:
+            loc = "/".join(str(p) for p in err.absolute_path)
+            prefix = f"{loc}: " if loc else ""
+            parts.append(prefix + err.message)
+        raise CollectionValidationError("; ".join(parts))
diff --git a/astrbot/core/collection/sensitive_filter.py b/astrbot/core/collection/sensitive_filter.py
new file mode 100644
index 000000000..43d9587d2
--- /dev/null
+++ b/astrbot/core/collection/sensitive_filter.py
@@ -0,0 +1,116 @@
+from __future__ import annotations
+
+import re
+from typing import Any
+
+
+class SensitiveFilter:
+    """Filter sensitive values from nested config structures.
+
+    Sensitive fields are removed instead of being replaced.
+    """
+
+    SENSITIVE_KEYWORDS = [
+        "key",
+        "secret",
+        "token",
+        "password",
+        "credential",
+        "api_key",
+        "access_token",
+        "private_key",
+        "auth",
+        "group_id",
+        "group",
+        "qq_group",
+        "guild",
+        "channel",
+        "user_id",
+        "user",
+        "qq",
+        "uin",
+        "openid",
+        "uid",
+        "endpoint",
+        "base_url",
+        "api_base",
+        "url",
+        "uri",
+        "webhook",
+        "callback",
+        "host",
+        "domain",
+    ]
+
+    SENSITIVE_KEY_PATTERNS = [
+        re.compile(r".*_key$", re.IGNORECASE),
+        re.compile(r".*_secret$", re.IGNORECASE),
+        re.compile(r".*_token$", re.IGNORECASE),
+        re.compile(r".*_password$", re.IGNORECASE),
+        re.compile(r".*_credential$", re.IGNORECASE),
+        re.compile(r".*_access_token$", re.IGNORECASE),
+        re.compile(r".*_private_key$", re.IGNORECASE),
+        re.compile(r".*_group(_id)?$", re.IGNORECASE),
+        re.compile(r".*_guild(_id)?$", re.IGNORECASE),
+        re.compile(r".*_channel(_id)?$", re.IGNORECASE),
+        re.compile(r".*_user(_id)?$", re.IGNORECASE),
+        re.compile(r".*_qq$", re.IGNORECASE),
+        re.compile(r".*_uin$", re.IGNORECASE),
+        re.compile(r".*_openid$", re.IGNORECASE),
+        re.compile(r".*_endpoint$", re.IGNORECASE),
+        re.compile(r".*_base_url$", re.IGNORECASE),
+        re.compile(r".*_api_base$", re.IGNORECASE),
+        re.compile(r".*_url$", re.IGNORECASE),
+        re.compile(r".*_uri$", re.IGNORECASE),
+        re.compile(r".*_webhook(_url)?$", re.IGNORECASE),
+        re.compile(r".*_callback(_url)?$", re.IGNORECASE),
+        re.compile(r".*_host$", re.IGNORECASE),
+        re.compile(r".*_domain$", re.IGNORECASE),
+    ]
+
+    SENSITIVE_VALUE_PATTERNS = [
+        re.compile(r"^sk-.*", re.IGNORECASE),
+        re.compile(r"^bearer\s+.+", re.IGNORECASE),
+        re.compile(r"^https?://.+", re.IGNORECASE),
+        re.compile(r"^wss?://.+", re.IGNORECASE),
+    ]
+
+    @classmethod
+    def is_sensitive_key(cls, key: str) -> bool:
+        key_lower = key.lower()
+        if any(k in key_lower for k in cls.SENSITIVE_KEYWORDS):
+            return True
+        return any(p.fullmatch(key) is not None for p in cls.SENSITIVE_KEY_PATTERNS)
+
+    @classmethod
+    def is_sensitive_value(cls, value: Any) -> bool:
+        if not isinstance(value, str):
+            return False
+        s = value.strip()
+        return any(p.match(s) is not None for p in cls.SENSITIVE_VALUE_PATTERNS)
+
+    @classmethod
+    def filter_data(cls, data: Any, *, depth: int = 0, max_depth: int = 20) -> Any:
+        if depth > max_depth:
+            return data
+
+        if isinstance(data, dict):
+            filtered: dict[str, Any] = {}
+            for k, v in data.items():
+                key = str(k)
+                if cls.is_sensitive_key(key):
+                    continue
+                if cls.is_sensitive_value(v):
+                    continue
+                filtered[key] = cls.filter_data(v, depth=depth + 1, max_depth=max_depth)
+            return filtered
+
+        if isinstance(data, list):
+            return [
+                cls.filter_data(v, depth=depth + 1, max_depth=max_depth) for v in data
+            ]
+
+        if cls.is_sensitive_value(data):
+            return None
+
+        return data
diff --git a/astrbot/dashboard/routes/__init__.py b/astrbot/dashboard/routes/__init__.py
index 481be2f89..da0cc167b 100644
--- a/astrbot/dashboard/routes/__init__.py
+++ b/astrbot/dashboard/routes/__init__.py
@@ -2,6 +2,7 @@
 from .backup import BackupRoute
 from .chat import ChatRoute
 from .chatui_project import ChatUIProjectRoute
+from .collection import CollectionRoute
 from .command import CommandRoute
 from .config import ConfigRoute
 from .conversation import ConversationRoute
@@ -25,6 +26,7 @@
     "BackupRoute",
     "ChatRoute",
     "ChatUIProjectRoute",
+    "CollectionRoute",
     "CommandRoute",
     "ConfigRoute",
     "ConversationRoute",
diff --git a/astrbot/dashboard/routes/collection.py b/astrbot/dashboard/routes/collection.py
new file mode 100644
index 000000000..3f9656a15
--- /dev/null
+++ b/astrbot/dashboard/routes/collection.py
@@ -0,0 +1,168 @@
+from __future__ import annotations
+
+import traceback
+from dataclasses import dataclass
+from typing import Any
+
+from quart import request
+
+from astrbot.core import DEMO_MODE, logger
+from astrbot.core.collection.exporter import CollectionExporter, ExportOptions
+from astrbot.core.collection.importer import CollectionImporter
+from astrbot.core.collection.models import (
+    CollectionValidationError,
+    ImportOptions,
+    PluginCollection,
+)
+from astrbot.core.core_lifecycle import AstrBotCoreLifecycle
+from astrbot.core.star.star_manager import PluginManager
+
+from .route import Response, Route, RouteContext
+
+
+@dataclass(slots=True)
+class _ImportRequest:
+    collection: dict[str, Any]
+    import_mode: str = "add"
+    apply_configs: bool = True
+    overwrite_existing_configs: bool = False
+    apply_priority: bool = True
+    proxy: str = ""
+
+
+class CollectionRoute(Route):
+    def __init__(
+        self,
+        context: RouteContext,
+        core_lifecycle: AstrBotCoreLifecycle,
+        plugin_manager: PluginManager,
+    ) -> None:
+        super().__init__(context)
+        self.core_lifecycle = core_lifecycle
+        self.plugin_manager = plugin_manager
+        self.exporter = CollectionExporter(plugin_manager)
+        self.importer = CollectionImporter(plugin_manager)
+
+        self.routes = {
+            "/plugin/collection/export": ("GET", self.export_collection_get),
+            "/plugin/collection/import": ("POST", self.import_collection),
+            "/plugin/collection/preview": ("POST", self.preview_collection),
+            "/plugin/collection/validate": ("POST", self.validate_collection),
+        }
+        self.register_routes()
+
+    async def export_collection_get(self):
+        if DEMO_MODE:
+            return (
+                Response()
+                .error("You are not permitted to do this operation in demo mode")
+                .__dict__
+            )
+
+        name = str(request.args.get("name") or "").strip()
+        if not name:
+            return Response().error("name is required").__dict__
+
+        options = ExportOptions(
+            name=name,
+            description=str(request.args.get("description") or ""),
+            author=str(request.args.get("author") or ""),
+            version=str(request.args.get("version") or "1.0.0"),
+            include_configs=str(request.args.get("include_configs", "true")).lower()
+            not in {"0", "false", "no"},
+            include_priority=str(request.args.get("include_priority", "true")).lower()
+            not in {"0", "false", "no"},
+            exclude_plugins=(
+                request.args.getlist("exclude_plugins")
+                if request.args.getlist("exclude_plugins")
+                else None
+            ),
+        )
+
+        try:
+            payload = await self.exporter.export(options)
+            return Response().ok(payload).__dict__
+        except Exception as e:
+            logger.error(
+                f"/api/plugin/collection/export(GET): {traceback.format_exc()}"
+            )
+            return Response().error(str(e)).__dict__
+
+    async def _parse_collection(self, body: Any) -> PluginCollection:
+        if not isinstance(body, dict):
+            raise CollectionValidationError("collection must be an object")
+        if "collection" in body and isinstance(body.get("collection"), dict):
+            body = body["collection"]
+        if not isinstance(body, dict):
+            raise CollectionValidationError("collection must be an object")
+        return PluginCollection.from_dict(body)
+
+    async def validate_collection(self):
+        try:
+            data = await request.get_json()
+            _ = await self._parse_collection(data)
+            return Response().ok({"valid": True}).__dict__
+        except CollectionValidationError as e:
+            return Response().ok({"valid": False, "errors": [str(e)]}).__dict__
+        except Exception as e:
+            logger.error(f"/api/plugin/collection/validate: {traceback.format_exc()}")
+            return Response().error(str(e)).__dict__
+
+    async def preview_collection(self):
+        try:
+            data = await request.get_json()
+            import_mode = "add"
+            if isinstance(data, dict) and data.get("import_mode") in {"add", "clean"}:
+                import_mode = str(data.get("import_mode"))
+            collection = await self._parse_collection(data)
+            preview = await self.importer.preview(collection, import_mode=import_mode)
+            return Response().ok(preview).__dict__
+        except CollectionValidationError as e:
+            return Response().error(str(e)).__dict__
+        except Exception as e:
+            logger.error(f"/api/plugin/collection/preview: {traceback.format_exc()}")
+            return Response().error(str(e)).__dict__
+
+    async def import_collection(self):
+        if DEMO_MODE:
+            return (
+                Response()
+                .error("You are not permitted to do this operation in demo mode")
+                .__dict__
+            )
+
+        try:
+            data = await request.get_json()
+            if not isinstance(data, dict):
+                return Response().error("Invalid request body").__dict__
+
+            raw_collection = data.get("collection")
+            req = _ImportRequest(
+                collection=raw_collection if isinstance(raw_collection, dict) else {},
+                import_mode=str(data.get("import_mode") or "add"),
+                apply_configs=bool(data.get("apply_configs", True)),
+                overwrite_existing_configs=bool(
+                    data.get("overwrite_existing_configs", False)
+                ),
+                apply_priority=bool(data.get("apply_priority", True)),
+                proxy=str(data.get("proxy") or ""),
+            )
+
+            collection = PluginCollection.from_dict(req.collection)
+            result = await self.importer.import_collection(
+                collection,
+                ImportOptions(
+                    import_mode=req.import_mode,
+                    apply_configs=req.apply_configs,
+                    overwrite_existing_configs=req.overwrite_existing_configs,
+                    apply_priority=req.apply_priority,
+                    proxy=req.proxy,
+                ),
+            )
+            return Response().ok(result).__dict__
+
+        except CollectionValidationError as e:
+            return Response().error(str(e)).__dict__
+        except Exception as e:
+            logger.error(f"/api/plugin/collection/import: {traceback.format_exc()}")
+            return Response().error(str(e)).__dict__
diff --git a/astrbot/dashboard/server.py b/astrbot/dashboard/server.py
index 57b8ad741..075a00ecf 100644
--- a/astrbot/dashboard/server.py
+++ b/astrbot/dashboard/server.py
@@ -72,6 +72,11 @@ def __init__(
             core_lifecycle,
             core_lifecycle.plugin_manager,
         )
+        self.collection_route = CollectionRoute(
+            self.context,
+            core_lifecycle,
+            core_lifecycle.plugin_manager,
+        )
         self.command_route = CommandRoute(self.context)
         self.cr = ConfigRoute(self.context, core_lifecycle)
         self.lr = LogRoute(self.context, core_lifecycle.log_broker)
diff --git a/dashboard/src/components/shared/ExtensionCard.vue b/dashboard/src/components/shared/ExtensionCard.vue
index 3ad621b29..7fe9b0f74 100644
--- a/dashboard/src/components/shared/ExtensionCard.vue
+++ b/dashboard/src/components/shared/ExtensionCard.vue
@@ -1,9 +1,13 @@
 <script setup lang="ts">
-import { ref, computed, inject } from "vue";
+import { ref, computed, inject, useAttrs } from "vue";
 import { useCustomizerStore } from "@/stores/customizer";
 import { useModuleI18n } from "@/i18n/composables";
 import UninstallConfirmDialog from "./UninstallConfirmDialog.vue";
 
+defineOptions({ inheritAttrs: false });
+
+const attrs = useAttrs();
+
 const props = defineProps({
   extension: {
     type: Object,
@@ -87,6 +91,7 @@ const viewChangelog = () => {
 
 <template>
   <v-card
+    v-bind="attrs"
     class="mx-auto d-flex flex-column"
     elevation="0"
     :style="{
@@ -197,11 +202,15 @@ const viewChangelog = () => {
                 </v-list-item>
 
                 <v-list-item @click="viewHandlers">
-                  <v-list-item-title
-                    >{{ tm("card.actions.viewHandlers") }} ({{
-                      extension.handlers.length
-                    }})</v-list-item-title
-                  >
+                  <v-list-item-title>
+                    {{
+                      tm("card.actions.viewHandlers", {
+                        count: Array.isArray(extension.handlers)
+                          ? extension.handlers.length
+                          : 0,
+                      })
+                    }}
+                  </v-list-item-title>
                 </v-list-item>
 
                 <v-list-item @click="updateExtension">
diff --git a/dashboard/src/i18n/locales/en-US/features/extension.json b/dashboard/src/i18n/locales/en-US/features/extension.json
index 52d03827b..5ad39392e 100644
--- a/dashboard/src/i18n/locales/en-US/features/extension.json
+++ b/dashboard/src/i18n/locales/en-US/features/extension.json
@@ -40,6 +40,82 @@
     "updateAll": "Update All",
     "deleteSource": "Delete Source"
   },
+  "collection": {
+    "buttons": {
+      "export": "Export Collection",
+      "import": "Import Collection",
+      "confirmImport": "Confirm Import"
+    },
+    "dialogs": {
+      "export": {
+        "title": "Export Collection"
+      },
+      "import": {
+        "title": "Import Collection"
+      },
+      "result": {
+        "title": "Import Result"
+      }
+    },
+    "fields": {
+      "name": "Collection Name",
+      "description": "Description (optional)",
+      "includeConfigs": "Include configs",
+      "includePriority": "Include priority",
+      "importMode": "Import mode",
+      "applyConfigs": "Apply configs",
+      "overwriteExistingConfigs": "Also apply configs to already installed extensions (overwrites keys)",
+      "overwriteExistingConfigsHint": "Only applies to Add (add) mode. When off, configs are applied only to newly installed extensions.",
+      "applyPriority": "Apply priority",
+      "unnamed": "Unnamed collection"
+    },
+    "labels": {
+      "pluginCount": "Plugins: {count}"
+    },
+    "importModes": {
+      "add": "Add (add)",
+      "clean": "Clean then import (clean)"
+    },
+    "cleanMode": {
+      "warning": "Clean mode will uninstall {count} existing extensions that are not reserved and are not in this collection.",
+      "confirmCheckbox": "I understand this will uninstall {count} extensions"
+    },
+    "preview": {
+      "loading": "Fetching import preview...",
+      "willInstall": "Will install: {count}",
+      "willSkip": "Will skip (already installed): {count}",
+      "willUninstall": "Will uninstall (clean mode): {count}",
+      "configsCount": "Configs: {count}",
+      "priorityOverrides": "Priority overrides: {value}"
+    },
+    "messages": {
+      "nameRequired": "Please enter a collection name",
+      "exportSuccess": "Exported. Download started.",
+      "exportFailed": "Export failed",
+      "invalidJson": "Invalid JSON",
+      "validateFailed": "Validation failed",
+      "previewFailed": "Preview failed",
+      "downloadBlocked": "Download might be blocked by your browser. Please allow downloads or save from the new tab.",
+      "readFailed": "Failed to read file",
+      "fileTooLarge": "File too large (max 10MB)",
+      "importFailed": "Import failed",
+      "importFinished": "Import finished"
+    },
+    "result": {
+      "installed": "Installed: {count}",
+      "failed": "Failed: {count}",
+      "skipped": "Skipped: {count}",
+      "uninstalled": "Uninstalled: {count}",
+      "uninstallFailed": "Uninstall failed: {count}",
+      "reloaded": "Reloaded: {count}",
+      "reloadFailed": "Reload failed: {count}",
+      "configsApplied": "Configs applied: {count}",
+      "exportedVersionNote": "Exported version note:",
+      "priorityApplied": "Priority applied: {count}",
+      "yes": "Yes",
+      "no": "No"
+    }
+  },
   "status": {
     "enabled": "Enabled",
     "disabled": "Disabled",
@@ -220,7 +296,7 @@
       "uninstallPlugin": "Uninstall Extension",
       "reloadPlugin": "Reload Extension",
       "togglePlugin": "Extension",
-      "viewHandlers": "View Handlers",
+      "viewHandlers": "View Handlers ({count})",
       "updateTo": "Update to",
       "reinstall": "Reinstall"
     },
diff --git a/dashboard/src/i18n/locales/zh-CN/features/extension.json b/dashboard/src/i18n/locales/zh-CN/features/extension.json
index 5f838789e..fc16d9b20 100644
--- a/dashboard/src/i18n/locales/zh-CN/features/extension.json
+++ b/dashboard/src/i18n/locales/zh-CN/features/extension.json
@@ -40,6 +40,82 @@
     "updateAll": "更新全部插件",
     "deleteSource": "删除源"
   },
+  "collection": {
+    "buttons": {
+      "export": "导出插件合集",
+      "import": "导入插件合集",
+      "confirmImport": "确认导入"
+    },
+    "dialogs": {
+      "export": {
+        "title": "导出插件合集"
+      },
+      "import": {
+        "title": "导入插件合集"
+      },
+      "result": {
+        "title": "导入结果"
+      }
+    },
+    "fields": {
+      "name": "合集名称",
+      "description": "描述（可选）",
+      "includeConfigs": "包含配置",
+      "includePriority": "包含优先级",
+      "importMode": "导入模式",
+      "applyConfigs": "应用配置",
+      "overwriteExistingConfigs": "对已安装插件也应用配置（会覆盖同名项）",
+      "overwriteExistingConfigsHint": "仅在追加（add）模式生效；关闭时仅对新安装插件应用配置。",
+      "applyPriority": "应用优先级",
+      "unnamed": "未命名合集"
+    },
+    "labels": {
+      "pluginCount": "插件数量：{count}"
+    },
+    "importModes": {
+      "add": "追加",
+      "clean": "清理后导入"
+    },
+    "cleanMode": {
+      "warning": "Clean 模式将卸载 {count} 个不在此合集内、且非系统保留（reserved）的已安装插件。",
+      "confirmCheckbox": "我已知晓将卸载 {count} 个插件"
+    },
+    "preview": {
+      "loading": "正在获取导入预览...",
+      "willInstall": "将安装：{count}",
+      "willSkip": "将跳过（已存在）：{count}",
+      "willUninstall": "将卸载（clean 模式）：{count}",
+      "configsCount": "配置数量：{count}",
+      "priorityOverrides": "优先级覆盖：{value}"
+    },
+    "messages": {
+      "nameRequired": "请填写合集名称",
+      "exportSuccess": "导出成功，已开始下载",
+      "exportFailed": "导出失败",
+      "invalidJson": "JSON 格式错误",
+      "validateFailed": "验证失败",
+      "previewFailed": "预览失败",
+      "downloadBlocked": "下载可能被浏览器拦截，请允许下载或在新标签页中手动保存",
+      "readFailed": "读取文件失败",
+      "fileTooLarge": "文件过大（上限 10MB）",
+      "importFailed": "导入失败",
+      "importFinished": "导入已完成"
+    },
+    "result": {
+      "installed": "已安装：{count}",
+      "failed": "失败：{count}",
+      "skipped": "跳过：{count}",
+      "uninstalled": "已卸载：{count}",
+      "uninstallFailed": "卸载失败：{count}",
+      "reloaded": "已重载：{count}",
+      "reloadFailed": "重载失败：{count}",
+      "configsApplied": "已应用配置：{count}",
+      "exportedVersionNote": "版本字段说明：",
+      "priorityApplied": "已应用优先级：{count}",
+      "yes": "是",
+      "no": "否"
+    }
+  },
   "status": {
     "enabled": "启用",
     "disabled": "禁用",
@@ -220,7 +296,7 @@
       "uninstallPlugin": "卸载插件",
       "reloadPlugin": "重载插件",
       "togglePlugin": "插件",
-      "viewHandlers": "查看行为",
+      "viewHandlers": "查看行为 ({count})",
       "updateTo": "更新到",
       "reinstall": "重新安装"
     },
diff --git a/dashboard/src/views/ExtensionPage.vue b/dashboard/src/views/ExtensionPage.vue
index c62637e3c..d8cea2757 100644
--- a/dashboard/src/views/ExtensionPage.vue
+++ b/dashboard/src/views/ExtensionPage.vue
@@ -176,6 +176,283 @@ const refreshingMarket = ref(false);
 const sortBy = ref("default"); // default, stars, author, updated
 const sortOrder = ref("desc"); // desc (降序) or asc (升序)
 
+// Plugin collection import/export
+const collectionExportDialog = reactive({
+  show: false,
+  name: "",
+  description: "",
+  includeConfigs: true,
+  includePriority: true,
+  loading: false,
+});
+
+const collectionImport = reactive({
+  validating: false,
+  importing: false,
+  rawText: "",
+  validatedCollection: null,
+  preview: null,
+  previewLoading: false,
+  showConfirm: false,
+  mode: "add",
+  applyConfigs: true,
+  overwriteExistingConfigs: false,
+  applyPriority: true,
+  proxy: "",
+  result: null,
+  showResult: false,
+});
+
+const cleanModeConfirmed = ref(false);
+
+const collectionFileInput = ref(null);
+
+const safeFileName = (name) =>
+  (name || "collection")
+    .toString()
+    .trim()
+    .replace(/[\\/:*?"<>|\n\r\t]+/g, "_")
+    .slice(0, 120);
+
+const downloadJson = (filename, data) => {
+  const json = JSON.stringify(data, null, 2);
+  const blob = new Blob([json], { type: "application/json;charset=utf-8" });
+  const url = URL.createObjectURL(blob);
+
+  try {
+    const a = document.createElement("a");
+    a.href = url;
+    a.download = filename;
+    a.rel = "noopener";
+    a.style.display = "none";
+    document.body.appendChild(a);
+    a.click();
+    a.remove();
+  } catch (e) {
+    // Some environments (or browser settings) may block programmatic downloads.
+    // Fallback to opening a new tab so user can save manually.
+    toast(tm("collection.messages.downloadBlocked"), "warning");
+    window.open(url, "_blank", "noopener");
+  } finally {
+    setTimeout(() => URL.revokeObjectURL(url), 1000);
+  }
+};
+
+const openExportCollectionDialog = () => {
+  collectionExportDialog.name = "";
+  collectionExportDialog.description = "";
+  collectionExportDialog.includeConfigs = true;
+  collectionExportDialog.includePriority = true;
+  collectionExportDialog.loading = false;
+  collectionExportDialog.show = true;
+};
+
+const exportCollection = async () => {
+  const name = (collectionExportDialog.name || "").trim();
+  if (!name) {
+    toast(tm("collection.messages.nameRequired"), "error");
+    return;
+  }
+
+  collectionExportDialog.loading = true;
+  try {
+    const res = await axios.get("/api/plugin/collection/export", {
+        params: {
+          name,
+          description: collectionExportDialog.description || undefined,
+          include_configs: collectionExportDialog.includeConfigs,
+          include_priority: collectionExportDialog.includePriority,
+        },
+      });
+
+    if (res.data.status === "error") {
+      toast(res.data.message || tm("collection.messages.exportFailed"), "error");
+      return;
+    }
+
+    const collection = res.data.data;
+    downloadJson(`${safeFileName(name)}.json`, collection);
+    toast(tm("collection.messages.exportSuccess"), "success");
+    collectionExportDialog.show = false;
+  } catch (err) {
+    const errorMsg = err.response?.data?.message || err.message || String(err);
+    toast(`${tm("collection.messages.exportFailed")}: ${errorMsg}`, "error");
+  } finally {
+    collectionExportDialog.loading = false;
+  }
+};
+
+const openImportFilePicker = () => {
+  if (!collectionFileInput.value) return;
+  collectionFileInput.value.value = null;
+  collectionFileInput.value.click();
+};
+
+const readSelectedCollectionFile = (file) => {
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onload = () => resolve(String(reader.result || ""));
+    reader.onerror = () => reject(reader.error || new Error("read failed"));
+    reader.readAsText(file);
+  });
+};
+
+const refreshCollectionPreview = async () => {
+  if (!collectionImport.validatedCollection) return;
+
+  collectionImport.previewLoading = true;
+  try {
+    const previewRes = await axios.post("/api/plugin/collection/preview", {
+      collection: collectionImport.validatedCollection,
+      import_mode: collectionImport.mode,
+    });
+
+    if (previewRes.data.status === "ok") {
+      collectionImport.preview = previewRes.data.data;
+    } else {
+      toast(
+        previewRes.data.message || tm("collection.messages.previewFailed"),
+        "warning",
+      );
+    }
+  } catch (e) {
+    const errorMsg = e.response?.data?.message || e.message || String(e);
+    toast(`${tm("collection.messages.previewFailed")}: ${errorMsg}`, "warning");
+  } finally {
+    collectionImport.previewLoading = false;
+  }
+};
+
+const validateAndPreviewCollection = async (rawText) => {
+  collectionImport.validating = true;
+  collectionImport.rawText = rawText;
+  collectionImport.validatedCollection = null;
+  collectionImport.preview = null;
+  collectionImport.previewLoading = false;
+  collectionImport.showConfirm = false;
+  collectionImport.result = null;
+  collectionImport.showResult = false;
+
+  let collectionObj;
+  try {
+    collectionObj = JSON.parse(rawText);
+  } catch (e) {
+    toast(tm("collection.messages.invalidJson"), "error");
+    collectionImport.validating = false;
+    return;
+  }
+
+  try {
+    const res = await axios.post("/api/plugin/collection/validate", {
+      collection: collectionObj,
+    });
+
+    if (res.data.status === "error") {
+      toast(res.data.message || tm("collection.messages.validateFailed"), "error");
+      return;
+    }
+
+    const valid = Boolean(res.data?.data?.valid);
+    if (!valid) {
+      const errors = Array.isArray(res.data?.data?.errors)
+        ? res.data.data.errors.join("; ")
+        : "";
+      toast(
+        `${tm("collection.messages.validateFailed")}${errors ? `: ${errors}` : ""}`,
+        "error",
+      );
+      return;
+    }
+
+    // Validation endpoint returns { valid: true } (not the collection).
+    // Keep the original parsed collection for preview + import.
+    collectionImport.validatedCollection = collectionObj;
+    collectionImport.mode = "add";
+    collectionImport.applyConfigs = true;
+    collectionImport.overwriteExistingConfigs = false;
+    collectionImport.applyPriority = true;
+    collectionImport.proxy = getSelectedGitHubProxy();
+
+    // Fetch preview so user can see what will happen before importing.
+    await refreshCollectionPreview();
+
+    collectionImport.showConfirm = true;
+  } catch (err) {
+    const errorMsg = err.response?.data?.message || err.message || String(err);
+    toast(`${tm("collection.messages.validateFailed")}: ${errorMsg}`, "error");
+  } finally {
+    collectionImport.validating = false;
+  }
+};
+
+const onCollectionFileSelected = async (e) => {
+  const file = e?.target?.files?.[0];
+  if (!file) return;
+
+  if (file.size > 10 * 1024 * 1024) {
+    toast(tm("collection.messages.fileTooLarge"), "error");
+    return;
+  }
+
+  try {
+    const text = await readSelectedCollectionFile(file);
+    await validateAndPreviewCollection(text);
+  } catch (err) {
+    const errorMsg = err?.message || String(err);
+    toast(`${tm("collection.messages.readFailed")}: ${errorMsg}`, "error");
+  }
+};
+
+const getCollectionPluginCount = (collection) => {
+  if (!collection) return 0;
+  const plugins = collection.plugins || collection.items || [];
+  if (Array.isArray(plugins)) return plugins.length;
+  if (typeof plugins === "object" && plugins) return Object.keys(plugins).length;
+  return 0;
+};
+
+const confirmImportCollection = async () => {
+  if (!collectionImport.validatedCollection) return;
+  if (collectionImport.mode === "clean" && !cleanModeConfirmed.value) return;
+
+  collectionImport.importing = true;
+  try {
+    const proxy = collectionImport.proxy;
+    const payload = {
+      collection: collectionImport.validatedCollection,
+      import_mode: collectionImport.mode,
+      apply_configs: collectionImport.applyConfigs,
+      overwrite_existing_configs: collectionImport.overwriteExistingConfigs,
+      apply_priority: collectionImport.applyPriority,
+      ...(proxy ? { proxy } : {}),
+    };
+
+    const res = await axios.post("/api/plugin/collection/import", payload);
+    if (res.data.status === "error") {
+      toast(res.data.message || tm("collection.messages.importFailed"), "error");
+      return;
+    }
+
+    collectionImport.result = res.data.data;
+    collectionImport.showConfirm = false;
+    collectionImport.showResult = true;
+
+    toast(tm("collection.messages.importFinished"), "success");
+
+    try {
+      await getExtensions();
+      await checkAndPromptConflicts();
+    } catch (e) {
+      // Ignore refresh errors
+    }
+  } catch (err) {
+    const errorMsg = err.response?.data?.message || err.message || String(err);
+    toast(`${tm("collection.messages.importFailed")}: ${errorMsg}`, "error");
+  } finally {
+    collectionImport.importing = false;
+  }
+};
+
 // 插件市场拼音搜索
 const normalizeStr = (s) => (s ?? "").toString().toLowerCase().trim();
 const toPinyinText = (s) =>
@@ -1075,6 +1352,19 @@ watch(isListView, (newVal) => {
   }
 });
 
+watch(
+  () => collectionImport.mode,
+  async (newMode, oldMode) => {
+    if (newMode === oldMode) return;
+    cleanModeConfirmed.value = false;
+
+    if (!collectionImport.showConfirm) return;
+    if (!collectionImport.validatedCollection) return;
+
+    await refreshCollectionPreview();
+  },
+);
+
 watch(
   () => route.fullPath,
   () => {
@@ -1204,6 +1494,26 @@ watch(activeTab, (newTab) => {
                   }}
                 </v-btn>
 
+                <v-btn
+                  class="ml-2"
+                  color="primary"
+                  variant="tonal"
+                  @click="openExportCollectionDialog"
+                >
+                  <v-icon>mdi-export</v-icon>
+                  {{ tm("collection.buttons.export") }}
+                </v-btn>
+
+                <v-btn
+                  class="ml-2"
+                  color="primary"
+                  variant="tonal"
+                  @click="openImportFilePicker"
+                >
+                  <v-icon>mdi-import</v-icon>
+                  {{ tm("collection.buttons.import") }}
+                </v-btn>
+
                 <v-btn
                   class="ml-2"
                   color="warning"
@@ -1437,11 +1747,7 @@ watch(activeTab, (newTab) => {
                             }}</v-tooltip>
                           </v-btn>
 
-                          <v-btn
-                            icon
-                            size="small"
-                            @click="reloadPlugin(item.name)"
-                          >
+                          <v-btn icon size="small" @click="reloadPlugin(item.name)">
                             <v-icon>mdi-refresh</v-icon>
                             <v-tooltip activator="parent" location="top">{{
                               tm("tooltips.reload")
@@ -1459,11 +1765,7 @@ watch(activeTab, (newTab) => {
                             }}</v-tooltip>
                           </v-btn>
 
-                          <v-btn
-                            icon
-                            size="small"
-                            @click="showPluginInfo(item)"
-                          >
+                          <v-btn icon size="small" @click="showPluginInfo(item)">
                             <v-icon>mdi-information</v-icon>
                             <v-tooltip activator="parent" location="top">{{
                               tm("tooltips.viewInfo")
@@ -1482,11 +1784,7 @@ watch(activeTab, (newTab) => {
                             }}</v-tooltip>
                           </v-btn>
 
-                          <v-btn
-                            icon
-                            size="small"
-                            @click="updateExtension(item.name)"
-                          >
+                          <v-btn icon size="small" @click="updateExtension(item.name)">
                             <v-icon>mdi-update</v-icon>
                             <v-tooltip activator="parent" location="top">{{
                               tm("tooltips.update")
@@ -1657,9 +1955,8 @@ watch(activeTab, (newTab) => {
                         >
                           {{
                             selectedSource
-                              ? customSources.find(
-                                  (s) => s.url === selectedSource,
-                                )?.name
+                              ? customSources.find((s) => s.url === selectedSource)
+                                  ?.name
                               : tm("market.defaultSource")
                           }}
                         </span>
@@ -1739,7 +2036,7 @@ watch(activeTab, (newTab) => {
                   "
                 ></div>
 
-                <!--右侧：操作按钮组-->
+                <!-- 右侧：操作按钮组 -->
                 <div class="d-flex align-center">
                   <v-tooltip location="top" :text="tm('market.addSource')">
                     <template v-slot:activator="{ props }">
@@ -2112,10 +2409,7 @@ watch(activeTab, (newTab) => {
                           </v-chip>
                         </template>
                         <v-list density="compact">
-                          <v-list-item
-                            v-for="tag in plugin.tags.slice(2)"
-                            :key="tag"
-                          >
+                          <v-list-item v-for="tag in plugin.tags.slice(2)" :key="tag">
                             <v-chip
                               :color="tag === 'danger' ? 'error' : 'primary'"
                               label
@@ -2221,6 +2515,345 @@ watch(activeTab, (newTab) => {
     </v-col>
   </v-row>
 
+  <input
+    ref="collectionFileInput"
+    type="file"
+    accept="application/json,.json"
+    style="display: none"
+    @change="onCollectionFileSelected"
+  />
+
+  <v-dialog v-model="collectionExportDialog.show" max-width="560">
+    <v-card>
+      <v-card-title class="text-h5 d-flex align-center">
+        <v-icon class="mr-2">mdi-export</v-icon>
+        {{ tm("collection.dialogs.export.title") }}
+      </v-card-title>
+      <v-card-text>
+        <v-text-field
+          v-model="collectionExportDialog.name"
+          :label="tm('collection.fields.name')"
+          variant="outlined"
+          density="comfortable"
+          required
+        ></v-text-field>
+        <v-text-field
+          v-model="collectionExportDialog.description"
+          :label="tm('collection.fields.description')"
+          variant="outlined"
+          density="comfortable"
+        ></v-text-field>
+        <v-switch
+          v-model="collectionExportDialog.includeConfigs"
+          :label="tm('collection.fields.includeConfigs')"
+          hide-details
+          density="comfortable"
+        ></v-switch>
+        <v-switch
+          v-model="collectionExportDialog.includePriority"
+          :label="tm('collection.fields.includePriority')"
+          hide-details
+          density="comfortable"
+        ></v-switch>
+      </v-card-text>
+      <v-card-actions>
+        <v-spacer></v-spacer>
+        <v-btn variant="text" @click="collectionExportDialog.show = false">{{
+          tm("buttons.cancel")
+        }}</v-btn>
+        <v-btn
+          color="primary"
+          variant="flat"
+          :loading="collectionExportDialog.loading"
+          @click="exportCollection"
+        >
+          {{ tm("collection.buttons.export") }}
+        </v-btn>
+      </v-card-actions>
+    </v-card>
+  </v-dialog>
+
+  <v-dialog v-model="collectionImport.showConfirm" max-width="640">
+    <v-card>
+      <v-card-title class="text-h5 d-flex align-center">
+        <v-icon class="mr-2">mdi-import</v-icon>
+        {{ tm("collection.dialogs.import.title") }}
+      </v-card-title>
+      <v-card-text>
+        <div class="mb-2">
+          <div class="text-subtitle-1 font-weight-medium">
+            {{ collectionImport.validatedCollection?.name || tm('collection.fields.unnamed') }}
+          </div>
+          <div class="text-body-2 text-medium-emphasis" v-if="collectionImport.validatedCollection?.description">
+            {{ collectionImport.validatedCollection.description }}
+          </div>
+          <div class="text-caption text-medium-emphasis mt-1">
+            {{ tm('collection.labels.pluginCount', { count: getCollectionPluginCount(collectionImport.validatedCollection) }) }}
+          </div>
+        </div>
+
+        <v-alert
+          v-if="collectionImport.previewLoading"
+          type="info"
+          variant="tonal"
+          density="compact"
+          class="mb-3"
+        >
+          {{ tm('collection.preview.loading') }}
+        </v-alert>
+
+        <v-alert
+          v-else-if="collectionImport.preview"
+          type="info"
+          variant="tonal"
+          density="compact"
+          class="mb-3"
+        >
+          <div class="text-body-2">
+            {{ tm('collection.preview.willInstall', { count: collectionImport.preview.plugins_to_install?.length ?? 0 }) }}
+          </div>
+          <div
+            class="text-caption text-medium-emphasis"
+            v-if="(collectionImport.preview.plugins_to_install?.length ?? 0) > 0"
+          >
+            {{ collectionImport.preview.plugins_to_install.map((p) => p.name).join(', ') }}
+          </div>
+          <div class="text-body-2 mt-2">
+            {{ tm('collection.preview.willSkip', { count: collectionImport.preview.plugins_to_skip?.length ?? 0 }) }}
+          </div>
+          <div class="text-body-2 mt-2" v-if="collectionImport.mode === 'clean'">
+            {{ tm('collection.preview.willUninstall', { count: collectionImport.preview.plugins_to_uninstall?.length ?? 0 }) }}
+          </div>
+          <div class="text-body-2 mt-2">
+            {{ tm('collection.preview.configsCount', { count: collectionImport.preview.configs_count ?? 0 }) }}
+          </div>
+          <div class="text-body-2 mt-2">
+            {{
+              tm('collection.preview.priorityOverrides', {
+                value: collectionImport.preview.has_priority_overrides
+                  ? tm('collection.result.yes')
+                  : tm('collection.result.no'),
+              })
+            }}
+          </div>
+        </v-alert>
+
+        <v-alert
+          v-if="collectionImport.mode === 'clean' && collectionImport.preview"
+          type="warning"
+          variant="tonal"
+          density="compact"
+          class="mb-3"
+        >
+          <div class="text-body-2">
+            {{
+              tm('collection.cleanMode.warning', {
+                count: collectionImport.preview.plugins_to_uninstall?.length ?? 0,
+              })
+            }}
+          </div>
+          <div
+            class="text-caption text-medium-emphasis"
+            v-if="(collectionImport.preview.plugins_to_uninstall?.length ?? 0) > 0"
+          >
+            {{ collectionImport.preview.plugins_to_uninstall.map((p) => p.name).join(', ') }}
+          </div>
+          <v-checkbox
+            v-model="cleanModeConfirmed"
+            hide-details
+            density="compact"
+            class="mt-2"
+            :label="tm('collection.cleanMode.confirmCheckbox', { count: collectionImport.preview.plugins_to_uninstall?.length ?? 0 })"
+          ></v-checkbox>
+        </v-alert>
+
+        <v-select
+          v-model="collectionImport.mode"
+          :items="[
+            { title: tm('collection.importModes.add'), value: 'add' },
+            { title: tm('collection.importModes.clean'), value: 'clean' },
+          ]"
+          :label="tm('collection.fields.importMode')"
+          variant="outlined"
+          density="comfortable"
+        ></v-select>
+
+        <v-switch
+          v-model="collectionImport.applyConfigs"
+          :label="tm('collection.fields.applyConfigs')"
+          hide-details
+          density="comfortable"
+        ></v-switch>
+
+        <div
+          v-if="collectionImport.applyConfigs"
+          class="pl-4"
+          style="border-left: 2px solid rgba(var(--v-border-color), 0.3)"
+        >
+          <v-switch
+            v-model="collectionImport.overwriteExistingConfigs"
+            :disabled="collectionImport.mode !== 'add'"
+            :label="tm('collection.fields.overwriteExistingConfigs')"
+            hide-details
+            density="comfortable"
+          ></v-switch>
+          <div class="text-caption text-medium-emphasis mt-1">
+            {{ tm('collection.fields.overwriteExistingConfigsHint') }}
+          </div>
+        </div>
+
+        <v-switch
+          v-model="collectionImport.applyPriority"
+          :label="tm('collection.fields.applyPriority')"
+          hide-details
+          density="comfortable"
+        ></v-switch>
+      </v-card-text>
+      <v-card-actions>
+        <v-spacer></v-spacer>
+        <v-btn variant="text" @click="collectionImport.showConfirm = false">{{
+          tm("buttons.cancel")
+        }}</v-btn>
+        <v-btn
+          color="primary"
+          variant="flat"
+          :loading="collectionImport.importing"
+          :disabled="collectionImport.mode === 'clean' && !cleanModeConfirmed"
+          @click="confirmImportCollection"
+        >
+          {{ tm('collection.buttons.confirmImport') }}
+        </v-btn>
+      </v-card-actions>
+    </v-card>
+  </v-dialog>
+
+  <v-dialog v-model="collectionImport.showResult" max-width="720">
+    <v-card>
+      <v-card-title class="text-h5 d-flex align-center">
+        <v-icon class="mr-2">mdi-check-circle-outline</v-icon>
+        {{ tm('collection.dialogs.result.title') }}
+      </v-card-title>
+      <v-card-text>
+        <div v-if="collectionImport.result" style="white-space: pre-wrap">
+          <div>
+            {{
+              tm('collection.result.installed', {
+                count: Array.isArray(collectionImport.result.installed)
+                  ? collectionImport.result.installed.length
+                  : collectionImport.result.installed ?? 0,
+              })
+            }}
+          </div>
+          <div v-if="Array.isArray(collectionImport.result.installed) && collectionImport.result.installed.length">
+            <div class="text-caption text-medium-emphasis">
+              {{ collectionImport.result.installed.map((p) => p.name).join(', ') }}
+            </div>
+          </div>
+
+          <div class="mt-2">
+            {{
+              tm('collection.result.failed', {
+                count: Array.isArray(collectionImport.result.failed)
+                  ? collectionImport.result.failed.length
+                  : collectionImport.result.failed ?? 0,
+              })
+            }}
+          </div>
+          <div v-if="Array.isArray(collectionImport.result.failed) && collectionImport.result.failed.length">
+            <div class="text-caption text-medium-emphasis">
+              {{ collectionImport.result.failed.map((p) => p.name).join(', ') }}
+            </div>
+          </div>
+
+          <div class="mt-2">
+            {{
+              tm('collection.result.skipped', {
+                count: Array.isArray(collectionImport.result.skipped)
+                  ? collectionImport.result.skipped.length
+                  : collectionImport.result.skipped ?? 0,
+              })
+            }}
+          </div>
+          <div v-if="Array.isArray(collectionImport.result.skipped) && collectionImport.result.skipped.length">
+            <div class="text-caption text-medium-emphasis">
+              {{ collectionImport.result.skipped.map((p) => p.name).join(', ') }}
+            </div>
+          </div>
+
+          <div class="mt-2">
+            {{
+              tm('collection.result.uninstalled', {
+                count: Array.isArray(collectionImport.result.uninstalled)
+                  ? collectionImport.result.uninstalled.length
+                  : collectionImport.result.uninstalled ?? 0,
+              })
+            }}
+          </div>
+
+          <div class="mt-2" v-if="Array.isArray(collectionImport.result.uninstall_failed) && collectionImport.result.uninstall_failed.length">
+            {{ tm('collection.result.uninstallFailed', { count: collectionImport.result.uninstall_failed.length }) }}
+            <div class="text-caption text-medium-emphasis">
+              {{ collectionImport.result.uninstall_failed.join(', ') }}
+            </div>
+          </div>
+
+          <div class="mt-2">
+            {{
+              tm('collection.result.configsApplied', {
+                count: collectionImport.result.configs_applied ?? 0,
+              })
+            }}
+          </div>
+
+          <div class="mt-2" v-if="Array.isArray(collectionImport.result.reloaded) && collectionImport.result.reloaded.length">
+            {{ tm('collection.result.reloaded', { count: collectionImport.result.reloaded.length }) }}
+            <div class="text-caption text-medium-emphasis">
+              {{ collectionImport.result.reloaded.join(', ') }}
+            </div>
+          </div>
+
+          <div class="mt-2" v-if="Array.isArray(collectionImport.result.reload_failed) && collectionImport.result.reload_failed.length">
+            {{ tm('collection.result.reloadFailed', { count: collectionImport.result.reload_failed.length }) }}
+            <div class="text-caption text-medium-emphasis">
+              {{ collectionImport.result.reload_failed.map((p) => p.name).join(', ') }}
+            </div>
+          </div>
+
+          <div class="mt-2" v-if="Array.isArray(collectionImport.result.installed) && collectionImport.result.installed.find((p) => p.exported_version_note)">
+            {{ tm('collection.result.exportedVersionNote') }}
+            <div class="text-caption text-medium-emphasis">
+              {{ collectionImport.result.installed.find((p) => p.exported_version_note)?.exported_version_note }}
+            </div>
+          </div>
+
+          <div class="mt-2">
+            {{
+              tm('collection.result.priorityApplied', {
+                count: collectionImport.result.priority_persisted === true
+                  ? tm('collection.result.yes')
+                  : collectionImport.result.priority_applied_in_memory === true
+                    ? 'yes (in memory)'
+                    : tm('collection.result.no'),
+              })
+            }}
+          </div>
+          <div
+            class="text-caption text-medium-emphasis"
+            v-if="collectionImport.result.priority_note"
+          >
+            {{ collectionImport.result.priority_note }}
+          </div>
+        </div>
+      </v-card-text>
+      <v-card-actions>
+        <v-spacer></v-spacer>
+        <v-btn variant="text" @click="collectionImport.showResult = false">{{
+          tm('buttons.close')
+        }}</v-btn>
+      </v-card-actions>
+    </v-card>
+  </v-dialog>
+
   <!-- 配置对话框 -->
   <v-dialog v-model="configDialog" max-width="900">
     <v-card>