fix(plugin): make installation lifecycle cancellable

app/application/plugin/install.py

@@ -2,11 +2,14 @@
 
 from __future__ import annotations
 
+import asyncio
 from collections.abc import Awaitable, Callable
 from dataclasses import dataclass, field
 from typing import Any, Optional
 
 from app.application.database import DatabaseWorkerOverloadedError
+from app.application.plugin.lifecycle import plugin_lifecycle
+from app.runtime.log import logger
 
 
 InstalledPluginsReader = Callable[[], list[str]]
@@ -58,6 +61,20 @@ class PluginInstallResult:
     rollback: PluginInstallRollback = field(default_factory=PluginInstallRollback)
 
 
+@dataclass
+class _InstallState:
+    """记录取消补偿所需的事务阶段。"""
+
+    checkpoint: Any = None
+    stage: str = "package_checkpoint"
+    package_installed: bool = False
+    installed_list_persisted: bool = False
+    runtime_touched: bool = False
+    registrations_touched: bool = False
+    committed: bool = False
+    original_plugins: list[str] = field(default_factory=list)
+
+
 class PluginInstallCommand:
     """协调插件检查、包事务、持久化、运行态刷新和安装上报。"""
 
@@ -96,9 +113,38 @@ class PluginInstallCommand:
         repo_url: Optional[str],
         release_version: Optional[str] = None,
         force: bool = False,
+    ) -> PluginInstallResult:
+        """串行执行同一插件的完整安装生命周期，并保证取消后的补偿。"""
+        state = _InstallState()
+        async with plugin_lifecycle.hold(plugin_id):
+            try:
+                return await self._execute_locked(
+                    plugin_id=plugin_id,
+                    repo_url=repo_url,
+                    release_version=release_version,
+                    force=force,
+                    state=state,
+                )
+            except asyncio.CancelledError:
+                await self._rollback_cancelled(
+                    plugin_id=plugin_id,
+                    original_plugins=state.original_plugins,
+                    state=state,
+                )
+                raise
+
+    async def _execute_locked(
+        self,
+        *,
+        plugin_id: str,
+        repo_url: Optional[str],
+        release_version: Optional[str],
+        force: bool,
+        state: _InstallState,
     ) -> PluginInstallResult:
         """执行插件安装，并在关键阶段失败时恢复可补偿状态。"""
         installed_plugins = list(self._installed_plugins_reader() or [])
+        state.original_plugins = installed_plugins
         refreshed_only = not force and plugin_id in self._plugin_ids_provider()
         if refreshed_only:
             return await self._refresh_existing(
@@ -112,8 +158,16 @@ class PluginInstallCommand:
                 failure_stage="validation",
             )
 
+        checkpoint_task = asyncio.create_task(self._package_checkpointer(plugin_id))
         try:
-            checkpoint = await self._package_checkpointer(plugin_id)
+            checkpoint = await asyncio.shield(checkpoint_task)
+            state.checkpoint = checkpoint
+        except asyncio.CancelledError:
+            try:
+                state.checkpoint = await asyncio.shield(checkpoint_task)
+            except BaseException:
+                pass
+            raise
         except Exception as err:
             return PluginInstallResult(
                 success=False,
@@ -121,13 +175,15 @@ class PluginInstallCommand:
                 failure_stage="package_checkpoint",
             )
 
+        state.stage = "package_install"
         try:
-            state, message = await self._package_installer(
+            package_installed, message = await self._package_installer(
                 plugin_id,
                 repo_url,
                 release_version,
                 force,
             )
+            state.package_installed = package_installed
         except Exception as err:
             result = await self._failure(
                 plugin_id=plugin_id,
@@ -140,7 +196,7 @@ class PluginInstallCommand:
             if isinstance(err, DatabaseWorkerOverloadedError):
                 raise
             return result
-        if not state:
+        if not package_installed:
             return await self._failure(
                 plugin_id=plugin_id,
                 original_plugins=installed_plugins,
@@ -156,6 +212,7 @@ class PluginInstallCommand:
             try:
                 await self._installed_plugins_writer(updated_plugins)
                 installed_list_persisted = True
+                state.installed_list_persisted = True
             except Exception as err:
                 result = await self._failure(
                     plugin_id=plugin_id,
@@ -169,6 +226,8 @@ class PluginInstallCommand:
                     raise
                 return result
 
+        state.stage = "runtime_reload"
+        state.runtime_touched = True
         try:
             await self._plugin_reloader(plugin_id)
         except Exception as err:
@@ -186,6 +245,8 @@ class PluginInstallCommand:
                 raise
             return result
 
+        state.stage = "registration_refresh"
+        state.registrations_touched = True
         try:
             await self._registration_refresher(plugin_id)
         except Exception as err:
@@ -205,13 +266,16 @@ class PluginInstallCommand:
             return result
 
         checkpoint_cleanup_error = ""
+        state.stage = "checkpoint_commit"
         try:
             await self._package_committer(checkpoint)
+            state.committed = True
         except Exception as err:
             checkpoint_cleanup_error = str(err)
 
         reported = False
         report_error = ""
+        state.stage = "report"
         try:
             report_result = await self._install_reporter(plugin_id, repo_url)
             reported = report_result is not False
@@ -237,6 +301,57 @@ class PluginInstallCommand:
             checkpoint_cleanup_error=checkpoint_cleanup_error,
         )
 
+    async def _rollback_cancelled(
+        self,
+        *,
+        plugin_id: str,
+        original_plugins: list[str],
+        state: _InstallState,
+    ) -> None:
+        """在保留取消语义的同时完成文件、清单和运行态补偿。"""
+        if state.committed:
+            logger.warning(
+                f"插件 {plugin_id} 在安装提交后被取消，Python 依赖环境可能已经改变"
+            )
+            return
+        if state.checkpoint is None:
+            logger.warning(
+                f"插件 {plugin_id} 在创建安装快照前被取消，无法执行文件补偿"
+            )
+            return
+
+        rollback_task = asyncio.create_task(
+            self._failure(
+                plugin_id=plugin_id,
+                original_plugins=original_plugins,
+                checkpoint=state.checkpoint,
+                stage=state.stage,
+                message="插件安装已取消",
+                package_installed=state.package_installed,
+                installed_list_persisted=state.installed_list_persisted,
+                runtime_touched=state.runtime_touched,
+                registrations_touched=state.registrations_touched,
+            )
+        )
+        try:
+            result = await asyncio.shield(rollback_task)
+        except asyncio.CancelledError:
+            try:
+                result = await asyncio.shield(rollback_task)
+            except BaseException as err:
+                logger.error(f"插件 {plugin_id} 取消后的补偿未完成：{err}")
+                return
+        except Exception as err:
+            logger.error(f"插件 {plugin_id} 取消后的补偿失败：{err}")
+            return
+        if result.rollback.errors:
+            logger.error(
+                f"插件 {plugin_id} 取消后的补偿存在错误：{'；'.join(result.rollback.errors)}"
+            )
+        logger.warning(
+            f"插件 {plugin_id} 安装已取消，插件文件已尝试恢复，Python 依赖环境可能已经改变"
+        )
+
     async def _refresh_existing(
         self,
         *,