automas-plugin-kill-process 0.1.0__tar.gz

automas_plugin_kill_process-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Alirea
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

automas_plugin_kill_process-0.1.0/PKG-INFO

@@ -0,0 +1,36 @@
+Metadata-Version: 2.4
+Name: automas_plugin_kill_process
+Version: 0.1.0
+Summary: 简单的关闭程序插件
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pydantic>=2.0
+Dynamic: license-file
+
+# automas_kill_process
+
+[![PyPI version](https://img.shields.io/pypi/v/automas_plugin_kill_process?logo=pypi&logoColor=white)](https://pypi.org/project/automas_plugin_kill_process/)
+
+简单的关闭程序插件
+
+## 功能
+
+- 监听全局 script.exit 事件。
+- 当事件中的脚本名匹配配置规则里的 script_name 时，自动执行 taskkill 终止对应 process_name。
+- 支持多条规则，规则表可无限新增行。
+
+## 配置
+
+插件配置提供两个字段：
+
+- rules：表格规则。
+	- script_name：脚本配置里的 Info.Name，例如 崩铁-三月七。
+	- process_name：要终止的进程名，例如 StarRail.exe。
+- kill_timeout_seconds：单次 taskkill 超时秒数。
+
+## 可靠性说明
+
+- 插件在收到事件后使用后台协程执行 taskkill，不阻塞事件总线主流程。
+- 每次 taskkill 都有超时保护，防止卡死。
+- 插件停止时会取消并清理后台任务，避免残留协程影响主程序。

automas_plugin_kill_process-0.1.0/README.md

@@ -0,0 +1,26 @@
+# automas_kill_process
+
+[![PyPI version](https://img.shields.io/pypi/v/automas_plugin_kill_process?logo=pypi&logoColor=white)](https://pypi.org/project/automas_plugin_kill_process/)
+
+简单的关闭程序插件
+
+## 功能
+
+- 监听全局 script.exit 事件。
+- 当事件中的脚本名匹配配置规则里的 script_name 时，自动执行 taskkill 终止对应 process_name。
+- 支持多条规则，规则表可无限新增行。
+
+## 配置
+
+插件配置提供两个字段：
+
+- rules：表格规则。
+	- script_name：脚本配置里的 Info.Name，例如 崩铁-三月七。
+	- process_name：要终止的进程名，例如 StarRail.exe。
+- kill_timeout_seconds：单次 taskkill 超时秒数。
+
+## 可靠性说明
+
+- 插件在收到事件后使用后台协程执行 taskkill，不阻塞事件总线主流程。
+- 每次 taskkill 都有超时保护，防止卡死。
+- 插件停止时会取消并清理后台任务，避免残留协程影响主程序。

automas_plugin_kill_process-0.1.0/pyproject.toml

@@ -0,0 +1,17 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "automas_plugin_kill_process"
+version = "0.1.0"
+description = "简单的关闭程序插件"
+readme = { file = "README.md", content-type = "text/markdown" }
+requires-python = ">=3.10"
+dependencies = ["pydantic>=2.0"]
+
+[project.entry-points."auto_mas.plugins"]
+kill_process = "kill_process.plugin:Plugin"
+
+[tool.setuptools.packages.find]
+where = ["src"]

automas_plugin_kill_process-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

automas_plugin_kill_process-0.1.0/src/automas_plugin_kill_process.egg-info/PKG-INFO

@@ -0,0 +1,36 @@
+Metadata-Version: 2.4
+Name: automas_plugin_kill_process
+Version: 0.1.0
+Summary: 简单的关闭程序插件
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pydantic>=2.0
+Dynamic: license-file
+
+# automas_kill_process
+
+[![PyPI version](https://img.shields.io/pypi/v/automas_plugin_kill_process?logo=pypi&logoColor=white)](https://pypi.org/project/automas_plugin_kill_process/)
+
+简单的关闭程序插件
+
+## 功能
+
+- 监听全局 script.exit 事件。
+- 当事件中的脚本名匹配配置规则里的 script_name 时，自动执行 taskkill 终止对应 process_name。
+- 支持多条规则，规则表可无限新增行。
+
+## 配置
+
+插件配置提供两个字段：
+
+- rules：表格规则。
+	- script_name：脚本配置里的 Info.Name，例如 崩铁-三月七。
+	- process_name：要终止的进程名，例如 StarRail.exe。
+- kill_timeout_seconds：单次 taskkill 超时秒数。
+
+## 可靠性说明
+
+- 插件在收到事件后使用后台协程执行 taskkill，不阻塞事件总线主流程。
+- 每次 taskkill 都有超时保护，防止卡死。
+- 插件停止时会取消并清理后台任务，避免残留协程影响主程序。

automas_plugin_kill_process-0.1.0/src/automas_plugin_kill_process.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+LICENSE
+README.md
+pyproject.toml
+src/automas_plugin_kill_process.egg-info/PKG-INFO
+src/automas_plugin_kill_process.egg-info/SOURCES.txt
+src/automas_plugin_kill_process.egg-info/dependency_links.txt
+src/automas_plugin_kill_process.egg-info/entry_points.txt
+src/automas_plugin_kill_process.egg-info/requires.txt
+src/automas_plugin_kill_process.egg-info/top_level.txt
+src/kill_process/__init__.py
+src/kill_process/plugin.py
+src/kill_process/schema.py

automas_plugin_kill_process-0.1.0/src/automas_plugin_kill_process.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

automas_plugin_kill_process-0.1.0/src/automas_plugin_kill_process.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[auto_mas.plugins]
+kill_process = kill_process.plugin:Plugin

automas_plugin_kill_process-0.1.0/src/automas_plugin_kill_process.egg-info/requires.txt

@@ -0,0 +1 @@
+pydantic>=2.0

automas_plugin_kill_process-0.1.0/src/automas_plugin_kill_process.egg-info/top_level.txt

@@ -0,0 +1 @@
+kill_process

automas_plugin_kill_process-0.1.0/src/kill_process/__init__.py

@@ -0,0 +1,6 @@
+"""最小 PyPI 插件示例包。"""
+
+from .plugin import Plugin
+from .schema import Config
+
+__all__ = ["Plugin", "Config"]

automas_plugin_kill_process-0.1.0/src/kill_process/plugin.py

@@ -0,0 +1,301 @@
+from __future__ import annotations
+
+import asyncio
+import contextlib
+import locale
+import os
+from collections import deque
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any, Iterable
+
+from app.core.plugins import on_event
+
+from .schema import Config
+
+if TYPE_CHECKING:
+    from app.core.plugins.context import PluginContext
+
+
+@dataclass(frozen=True)
+class KillRule:
+    script_name: str
+    process_name: str
+
+
+class Plugin:
+    _RECENT_EVENT_LIMIT = 512
+
+    def __init__(self, ctx: "PluginContext") -> None:
+        self.ctx = ctx
+        self._rules: list[KillRule] = []
+        self._kill_timeout_seconds: int = 8
+        self._background_tasks: set[asyncio.Task[Any]] = set()
+        self._recent_event_keys: set[tuple[str, str, str]] = set()
+        self._recent_event_queue: deque[tuple[str, str, str]] = deque()
+
+    async def on_start(self) -> None:
+        raw_config = (
+            self.ctx.config.to_dict()
+            if hasattr(self.ctx.config, "to_dict")
+            else dict(self.ctx.config)
+        )
+        typed_config = Config.model_validate(raw_config)
+        self._kill_timeout_seconds = max(1, int(typed_config.kill_timeout_seconds))
+        self._rules = self._normalize_rules(typed_config.rules)
+
+        self.ctx.logger.info(
+            f"[{self.ctx.plugin_name}] 插件启动，规则数={len(self._rules)}，超时={self._kill_timeout_seconds}s"
+        )
+        if os.name != "nt":
+            self.ctx.logger.warning(
+                f"[{self.ctx.plugin_name}] 当前系统不是 Windows，taskkill 不可用"
+            )
+
+    async def on_stop(self, reason: str) -> None:
+        await self._shutdown_background_tasks()
+        self.ctx.logger.info(
+            f"[{self.ctx.plugin_name}] 插件停止, reason={reason}, 已清理后台任务"
+        )
+
+    @on_event("script.exit", scope="global")
+    async def on_script_exit(self, payload: Any, ctx: "PluginContext") -> None:
+        _ = ctx
+        try:
+            if not isinstance(payload, dict):
+                return
+
+            script_name = str(payload.get("script_name") or "").strip()
+            if not script_name:
+                data = payload.get("data")
+                if isinstance(data, dict):
+                    script_name = str(data.get("script_name") or "").strip()
+
+            if not script_name:
+                return
+
+            if not self._rules:
+                return
+
+            task_id = str(payload.get("task_id") or "").strip() or "-"
+            script_id = str(payload.get("script_id") or "").strip() or script_name
+
+            matched_processes = {
+                rule.process_name
+                for rule in self._rules
+                if rule.script_name == script_name
+            }
+            if not matched_processes:
+                return
+
+            for process_name in matched_processes:
+                event_key = (task_id, script_id, process_name)
+                if self._is_duplicate_event(event_key):
+                    continue
+
+                self._remember_event(event_key)
+                self._spawn_background_task(
+                    self._kill_process_for_script(
+                        script_name=script_name,
+                        process_name=process_name,
+                        task_id=task_id,
+                        script_id=script_id,
+                    )
+                )
+        except Exception as e:
+            self.ctx.logger.warning(
+                f"[{self.ctx.plugin_name}] 处理 script.exit 事件失败: {type(e).__name__}: {e}"
+            )
+
+    def _normalize_rules(self, rows: Iterable[Any]) -> list[KillRule]:
+        rules: list[KillRule] = []
+        seen: set[tuple[str, str]] = set()
+
+        for row in rows:
+            current = row
+            if hasattr(current, "model_dump") and callable(current.model_dump):
+                current = current.model_dump()
+
+            if not isinstance(current, dict):
+                continue
+
+            script_name = str(current.get("script_name") or "").strip()
+            process_name = str(current.get("process_name") or "").strip()
+            if not script_name or not process_name:
+                continue
+
+            key = (script_name, process_name)
+            if key in seen:
+                continue
+
+            seen.add(key)
+            rules.append(KillRule(script_name=script_name, process_name=process_name))
+
+        return rules
+
+    def _is_duplicate_event(self, event_key: tuple[str, str, str]) -> bool:
+        return event_key in self._recent_event_keys
+
+    def _remember_event(self, event_key: tuple[str, str, str]) -> None:
+        self._recent_event_keys.add(event_key)
+        self._recent_event_queue.append(event_key)
+
+        while len(self._recent_event_queue) > self._RECENT_EVENT_LIMIT:
+            old_key = self._recent_event_queue.popleft()
+            self._recent_event_keys.discard(old_key)
+
+    def _spawn_background_task(self, coroutine: Any) -> None:
+        task = asyncio.create_task(coroutine)
+        self._background_tasks.add(task)
+
+        def _cleanup(done_task: asyncio.Task[Any]) -> None:
+            self._background_tasks.discard(done_task)
+            try:
+                exception = done_task.exception()
+            except asyncio.CancelledError:
+                return
+            except Exception as e:
+                self.ctx.logger.warning(
+                    f"[{self.ctx.plugin_name}] 后台任务状态读取失败: {type(e).__name__}: {e}"
+                )
+                return
+
+            if exception is not None:
+                self.ctx.logger.warning(
+                    f"[{self.ctx.plugin_name}] 后台任务异常: {type(exception).__name__}: {exception}"
+                )
+
+        task.add_done_callback(_cleanup)
+
+    @staticmethod
+    def _decode_taskkill_output(raw: bytes | None) -> str:
+        if not raw:
+            return ""
+
+        preferred = locale.getpreferredencoding(False)
+        candidates = ["utf-8", "gbk", "cp936", preferred]
+        tried: set[str] = set()
+
+        for encoding in candidates:
+            if not encoding:
+                continue
+
+            normalized = encoding.lower()
+            if normalized in tried:
+                continue
+            tried.add(normalized)
+
+            try:
+                text = raw.decode(encoding).strip()
+            except UnicodeDecodeError:
+                continue
+
+            if text:
+                return text
+
+        return raw.decode("utf-8", errors="replace").strip()
+
+    @staticmethod
+    def _is_process_not_found_error(return_code: int, detail: str) -> bool:
+        if return_code == 128:
+            return True
+
+        detail_lower = detail.lower()
+        markers = (
+            "没有找到",
+            "未找到",
+            "找不到",
+            "not found",
+            "could not find",
+            "no running instance",
+            "unknown process",
+        )
+        return any(marker in detail or marker in detail_lower for marker in markers)
+
+    async def _shutdown_background_tasks(self) -> None:
+        if not self._background_tasks:
+            return
+
+        tasks = list(self._background_tasks)
+        for task in tasks:
+            task.cancel()
+
+        try:
+            await asyncio.wait_for(asyncio.gather(*tasks, return_exceptions=True), timeout=2)
+        except asyncio.TimeoutError:
+            self.ctx.logger.warning(
+                f"[{self.ctx.plugin_name}] 关闭时仍有后台任务未在 2 秒内退出"
+            )
+        finally:
+            self._background_tasks.clear()
+
+    async def _kill_process_for_script(
+        self,
+        *,
+        script_name: str,
+        process_name: str,
+        task_id: str,
+        script_id: str,
+    ) -> None:
+        if os.name != "nt":
+            self.ctx.logger.warning(
+                f"[{self.ctx.plugin_name}] 非 Windows 环境，跳过终止进程: {process_name}"
+            )
+            return
+
+        command = ["taskkill", "/F", "/IM", process_name, "/T"]
+        process = None
+
+        try:
+            process = await asyncio.create_subprocess_exec(
+                *command,
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.PIPE,
+            )
+
+            stdout, stderr = await asyncio.wait_for(
+                process.communicate(),
+                timeout=self._kill_timeout_seconds,
+            )
+        except asyncio.TimeoutError:
+            if process is not None:
+                with contextlib.suppress(Exception):
+                    process.kill()
+                with contextlib.suppress(Exception):
+                    await process.communicate()
+            self.ctx.logger.warning(
+                f"[{self.ctx.plugin_name}] 终止进程超时: script={script_name}, process={process_name}, timeout={self._kill_timeout_seconds}s"
+            )
+            return
+        except asyncio.CancelledError:
+            if process is not None:
+                with contextlib.suppress(Exception):
+                    process.kill()
+                with contextlib.suppress(Exception):
+                    await process.communicate()
+            raise
+        except Exception as e:
+            self.ctx.logger.warning(
+                f"[{self.ctx.plugin_name}] 调用 taskkill 失败: script={script_name}, process={process_name}, error={type(e).__name__}: {e}"
+            )
+            return
+
+        stdout_text = self._decode_taskkill_output(stdout)
+        stderr_text = self._decode_taskkill_output(stderr)
+        detail = stderr_text or stdout_text or "-"
+        if len(detail) > 300:
+            detail = f"{detail[:300]}..."
+
+        return_code = process.returncode if process is not None else -1
+        if return_code == 0:
+            self.ctx.logger.info(
+                f"[{self.ctx.plugin_name}] 已终止进程: script={script_name}, process={process_name}, task_id={task_id}, script_id={script_id}"
+            )
+        else:
+            if self._is_process_not_found_error(return_code, detail):
+                self.ctx.logger.warning(
+                    f"[{self.ctx.plugin_name}] 程序无法关闭，可能程序已关闭或进程名有误: script={script_name}, process={process_name}, code={return_code}"
+                )
+            else:
+                self.ctx.logger.warning(
+                    f"[{self.ctx.plugin_name}] 终止进程返回非 0: script={script_name}, process={process_name}, code={return_code}, detail={detail}"
+                )

automas_plugin_kill_process-0.1.0/src/kill_process/schema.py

@@ -0,0 +1,30 @@
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class Config(BaseModel):
+    """关闭进程插件配置模型。"""
+
+    model_config = ConfigDict(extra="allow")
+
+    rules: list[dict[str, str]] = Field(
+        default_factory=lambda: [{"script_name": "", "process_name": ""}],
+        description="规则表：当 script.exit 的脚本名匹配 script_name 时，自动执行 taskkill 终止 process_name",
+        json_schema_extra={
+            "type": "table",
+            "item_type": "object",
+            "group": "basic",
+            "order": 1,
+        },
+    )
+
+    kill_timeout_seconds: int = Field(
+        default=8,
+        ge=1,
+        description="单次 taskkill 超时秒数",
+        json_schema_extra={
+            "group": "advanced",
+            "min": 1,
+            "step": 1,
+            "order": 2,
+        },
+    )