@hupan56/wlkj 2.0.0

package/templates/qoder/scripts/common/feishu.py

@@ -0,0 +1,278 @@
+# -*- coding: utf-8 -*-
+"""
+feishu.py - 飞书机器人通知 (阶段 D)
+
+通过群机器人 webhook 推送消息卡片, 失败不阻塞主流程。
+
+配置 (.qoder/config.yaml):
+    feishu:
+      enabled: true
+      webhook_url: "https://open.feishu.cn/open-apis/bot/v2/hook/xxx"
+      secret: "签名密钥(可选)"
+      events: [task_finished, prd_published, eval_rejected, deadline_warning]
+
+环境变量覆盖 (优先于 config):
+    FEISHU_WEBHOOK_URL, FEISHU_SECRET
+
+核心 API:
+    send_card(title, content, event_type, theme) -> bool
+    notify_task_finished(task_name, assignee, hours)
+    notify_prd_published(req_id, title, eval_pct)
+    notify_eval_rejected(req_id, title, issues)
+    notify_deadline(task_name, days_left, assignee)
+"""
+
+import hashlib
+import hmac
+import json
+import os
+import sys
+import time
+from datetime import datetime
+from typing import Optional, List
+
+_THIS_DIR = os.path.dirname(os.path.abspath(__file__))
+if _THIS_DIR not in sys.path:
+    sys.path.insert(0, _THIS_DIR)
+
+__all__ = [
+    "send_card",
+    "send_text",
+    "notify_task_finished",
+    "notify_prd_published",
+    "notify_eval_rejected",
+    "notify_deadline",
+    "is_enabled",
+    "get_config",
+]
+
+# 主题色映射 (飞书 interactive card template)
+THEME_COLORS = {
+    'blue': 'blue',
+    'green': 'turquoise',
+    'orange': 'wathet',
+    'red': 'red',
+    'default': 'grey',
+}
+
+
+def _load_config():
+    """加载飞书配置 (config.yaml + 环境变量)。"""
+    # 读 config.yaml 的 feishu 段
+    config = {}
+    try:
+        import yaml
+        from .paths import get_repo_root
+        cfg_path = os.path.join(str(get_repo_root()), '.qoder', 'config.yaml')
+        with open(cfg_path, encoding='utf-8') as f:
+            full = yaml.safe_load(f) or {}
+        config = full.get('feishu') or {}
+    except Exception:
+        # PyYAML 不可用, 用简单解析
+        try:
+            from .paths import get_repo_root
+            cfg_path = os.path.join(str(get_repo_root()), '.qoder', 'config.yaml')
+            in_feishu = False
+            with open(cfg_path, encoding='utf-8') as f:
+                for line in f:
+                    if line.startswith('feishu:'):
+                        in_feishu = True
+                        continue
+                    if in_feishu:
+                        if line and not line[0].isspace() and line.strip():
+                            break  # 离开 feishu 段
+                        stripped = line.strip()
+                        if stripped.startswith('enabled:'):
+                            config['enabled'] = 'true' in stripped.lower()
+                        elif stripped.startswith('webhook_url:'):
+                            val = stripped.split(':', 1)[1].strip().strip('"').strip("'")
+                            config['webhook_url'] = val
+                        elif stripped.startswith('secret:'):
+                            val = stripped.split(':', 1)[1].strip().strip('"').strip("'")
+                            config['secret'] = val
+        except Exception:
+            pass
+
+    # 环境变量覆盖
+    env_url = os.environ.get('FEISHU_WEBHOOK_URL')
+    if env_url:
+        config['webhook_url'] = env_url
+    env_secret = os.environ.get('FEISHU_SECRET')
+    if env_secret:
+        config['secret'] = env_secret
+
+    return config
+
+
+def get_config():
+    """公开的配置获取 (供调试/检查用)。"""
+    return _load_config()
+
+
+def is_enabled(event_type: Optional[str] = None) -> bool:
+    """飞书推送是否启用 (含事件过滤)。
+
+    Args:
+        event_type: 若指定, 还检查该事件是否在 events 白名单里。
+    """
+    cfg = _load_config()
+    if not cfg.get('enabled'):
+        return False
+    if not cfg.get('webhook_url'):
+        return False
+    if event_type:
+        events = cfg.get('events')
+        # events 为空 = 全推 (向后兼容)
+        if events and event_type not in events:
+            return False
+    return True
+
+
+def _gen_sign(secret: str, timestamp: int) -> str:
+    """飞书签名校验: HMAC-SHA256(timestamp + "\n" + secret, "")."""
+    string_to_sign = f'{timestamp}\n{secret}'
+    hmac_code = hmac.new(string_to_sign.encode('utf-8'), digestmod=hashlib.sha256).digest()
+    import base64
+    return base64.b64encode(hmac_code).decode('utf-8')
+
+
+def _post_webhook(payload: dict) -> bool:
+    """POST 到飞书 webhook。用标准库 urllib (无第三方依赖)。
+
+    Returns:
+        True 若 HTTP 200 且飞书返回 code=0 (成功)。
+    """
+    cfg = _load_config()
+    url = cfg.get('webhook_url')
+    if not url:
+        return False
+
+    # 签名校验
+    secret = cfg.get('secret')
+    if secret:
+        timestamp = int(time.time())
+        payload['timestamp'] = str(timestamp)
+        payload['sign'] = _gen_sign(secret, timestamp)
+
+    try:
+        import urllib.request
+        data = json.dumps(payload, ensure_ascii=False).encode('utf-8')
+        req = urllib.request.Request(
+            url, data=data,
+            headers={'Content-Type': 'application/json'},
+            method='POST',
+        )
+        with urllib.request.urlopen(req, timeout=10) as resp:
+            body = resp.read().decode('utf-8')
+            result = json.loads(body)
+            # 飞书成功返回 {"code": 0, "msg": "success"}
+            return result.get('code') == 0 or result.get('StatusCode') == 0
+    except Exception as e:
+        # 失败不阻塞主流程, 仅记日志
+        sys.stderr.write(f'[feishu] 推送失败 (不阻塞): {e}\n')
+        return False
+
+
+def send_text(text: str) -> bool:
+    """发纯文本消息。"""
+    if not is_enabled():
+        return False
+    return _post_webhook({'msg_type': 'text', 'content': {'text': text}})
+
+
+def send_card(
+    title: str,
+    content_lines: List[str],
+    event_type: Optional[str] = None,
+    theme: Optional[str] = None,
+) -> bool:
+    """发交互式卡片消息。
+
+    Args:
+        title: 卡片标题。
+        content_lines: 正文行列表 (每行一个 markdown 段落)。
+        event_type: 事件类型 (用于过滤 + 选主题色)。
+        theme: 手动指定主题色 (覆盖 event_type 映射)。
+    """
+    if not is_enabled(event_type):
+        return False
+
+    cfg = _load_config()
+    # 主题色: 优先手动指定, 否则从 config.theme[event_type] 取
+    if not theme:
+        themes = cfg.get('theme') or {}
+        theme = themes.get(event_type, 'default')
+    color = THEME_COLORS.get(theme, 'grey')
+
+    # 构建交互式卡片 (飞书 interactive card v2)
+    elements = []
+    for line in content_lines:
+        elements.append({
+            'tag': 'div',
+            'text': {'tag': 'lark_md', 'content': line},
+        })
+
+    # 模板色 + 标题
+    template = color if color != 'grey' else 'blue'
+    payload = {
+        'msg_type': 'interactive',
+        'card': {
+            'config': {'wide_screen_mode': True},
+            'header': {
+                'title': {'tag': 'plain_text', 'content': title},
+                'template': template,
+            },
+            'elements': elements,
+        },
+    }
+    return _post_webhook(payload)
+
+
+# ============================================================
+# 事件专用通知 (D2 触发点调用)
+# ============================================================
+
+def notify_task_finished(task_name: str, assignee: str, hours: Optional[float] = None) -> bool:
+    """任务完成通知。"""
+    lines = [f'**任务完成** ✅', f'任务: {task_name}', f'负责人: {assignee}']
+    if hours is not None:
+        lines.append(f'用时: {hours:.1f} 小时')
+    lines.append(f'时间: {datetime.now().strftime("%Y-%m-%d %H:%M")}')
+    return send_card(f'任务完成: {task_name}', lines, event_type='task_finished')
+
+
+def notify_prd_published(req_id: str, title: str, eval_pct: Optional[float] = None) -> bool:
+    """PRD 发布通知。"""
+    lines = [f'**PRD 已发布** 📄', f'编号: {req_id}', f'标题: {title}']
+    if eval_pct is not None:
+        lines.append(f'EVA 评分: {eval_pct:.0f}%')
+    lines.append(f'时间: {datetime.now().strftime("%Y-%m-%d %H:%M")}')
+    return send_card(f'PRD 发布: {req_id}', lines, event_type='prd_published')
+
+
+def notify_eval_rejected(req_id: str, title: str, issues: List[str]) -> bool:
+    """EVA 门禁拒绝通知。"""
+    lines = [f'**PRD 未过质量门禁** ⛔', f'编号: {req_id}', f'标题: {title}', '']
+    lines.append('**问题:**')
+    for issue in issues[:5]:
+        lines.append(f'- {issue}')
+    if len(issues) > 5:
+        lines.append(f'- ... 还有 {len(issues) - 5} 个')
+    lines.append('')
+    lines.append('修复后重新提交, 或 admin 用 --skip-eval 跳过')
+    return send_card(f'⚠️ 质量门禁拦截: {req_id}', lines, event_type='eval_rejected')
+
+
+def notify_deadline(task_name: str, days_left: int, assignee: str, title: str = '') -> bool:
+    """截止日期临近通知。"""
+    if days_left < 0:
+        lines = [f'**任务已逾期** 🔴', f'任务: {task_name}', f'负责人: {assignee}',
+                 f'逾期 {-days_left} 天']
+        return send_card(f'逾期: {task_name}', lines, event_type='deadline_warning')
+    else:
+        urgency = '明天到期' if days_left <= 1 else f'{days_left} 天后到期'
+        lines = [f'**截止日期提醒** ⏰', f'任务: {task_name}', f'负责人: {assignee}',
+                 f'状态: {urgency}']
+        if title:
+            lines.append(f'标题: {title}')
+        return send_card(f'截止提醒: {task_name}', lines, event_type='deadline_warning')

package/templates/qoder/scripts/common/filelock.py

@@ -0,0 +1,211 @@
+# -*- coding: utf-8 -*-
+"""
+filelock.py - 跨平台原子文件锁
+
+用 os.open(O_CREAT|O_EXCL) 实现真正的互斥（原子系统调用，无 TOCTOU 竞态）。
+Windows / macOS / Linux 均无需管理员权限。
+
+用法:
+    from common.filelock import FileLock
+    with FileLock('.qoder/.runtime/team-sync.lock', timeout=30):
+        # 临界区：同一时刻只有一个进程能进入
+        do_critical_work()
+
+设计:
+    - acquire: O_CREAT|O_EXCL 原子创建。失败则锁被持有，等待重试。
+    - stale 检测: 读锁文件里的 PID，若进程已不存在则视为 stale 可抢。
+    - timeout: 总等待秒数；超时抛 LockTimeoutError。
+    - release: 持有者才能释放（记录 holding_pid 校验）。
+"""
+
+import os
+import sys
+import time
+import errno
+from datetime import datetime
+from pathlib import Path
+from typing import Optional, Union
+
+__all__ = ["FileLock", "LockTimeoutError", "LockBusyError"]
+
+
+class LockTimeoutError(Exception):
+    """获取锁超过 timeout 秒。"""
+
+
+class LockBusyError(Exception):
+    """锁被他人持有且 timeout=0（非阻塞模式立即失败）。"""
+
+
+def _pid_alive(pid: int) -> bool:
+    """判断 PID 对应的进程是否还活着。跨平台尽力而为。"""
+    if pid <= 0:
+        return False
+    try:
+        if sys.platform == "win32":
+            # Windows: 用 OpenProcess 探测。0 表示句柄无效 → 进程已退出。
+            import ctypes
+            PROCESS_QUERY_LIMITED_INFORMATION = 0x1000
+            STILL_ACTIVE = 259
+            kernel32 = ctypes.windll.kernel32
+            h = kernel32.OpenProcess(PROCESS_QUERY_LIMITED_INFORMATION, False, pid)
+            if not h:
+                return False
+            try:
+                exit_code = ctypes.c_ulong()
+                if not kernel32.GetExitCodeProcess(h, ctypes.byref(exit_code)):
+                    return False
+                return exit_code.value == STILL_ACTIVE
+            finally:
+                kernel32.CloseHandle(h)
+        else:
+            # POSIX: kill(pid, 0) 不发信号，仅探测。EAGAIN 有时也表示存在。
+            try:
+                os.kill(pid, 0)
+                return True
+            except (OSError, ProcessLookupError):
+                return False
+            except PermissionError:
+                # 进程存在但属于他人
+                return True
+    except Exception:
+        # 任何探测失败都保守认为还活着（不抢他人锁）
+        return True
+
+
+class FileLock:
+    """原子文件锁（基于 O_CREAT|O_EXCL）。
+
+    Args:
+        path: 锁文件路径。
+        timeout: 获取锁的总等待秒数。0 = 非阻塞，立即失败。负数 = 永久等待。
+        stale_seconds: 锁文件持有超过此秒数，且持有进程已死，视为 stale 可抢。
+        poll_interval: 重试间隔秒数。
+
+    用法:
+        with FileLock('x.lock', timeout=30):
+            ...
+        # 或手动:
+        lock = FileLock('x.lock')
+        lock.acquire()
+        try:
+            ...
+        finally:
+            lock.release()
+    """
+
+    def __init__(
+        self,
+        path: Union[str, Path],
+        timeout: float = 30.0,
+        stale_seconds: float = 7200.0,
+        poll_interval: float = 0.2,
+    ) -> None:
+        self.path = str(path)
+        self.timeout = timeout
+        self.stale_seconds = stale_seconds
+        self.poll_interval = poll_interval
+        self._holding = False  # 本实例是否持有锁
+
+    def acquire(self) -> "FileLock":
+        os.makedirs(os.path.dirname(self.path) or ".", exist_ok=True)
+        start = time.monotonic()
+        while True:
+            # 原子创建尝试
+            try:
+                fd = os.open(
+                    self.path,
+                    os.O_CREAT | os.O_EXCL | os.O_WRONLY,
+                    0o644,
+                )
+                try:
+                    host = (os.environ.get("COMPUTERNAME")
+                            or (os.uname().nodename if hasattr(os, "uname") else "?"))
+                    content = "acquired={}\npid={}\nhost={}\n".format(
+                        datetime.now().isoformat(timespec="seconds"),
+                        os.getpid(),
+                        host,
+                    )
+                    os.write(fd, content.encode("utf-8"))
+                finally:
+                    os.close(fd)
+                self._holding = True
+                return self
+            except OSError as e:
+                if e.errno not in (errno.EEXIST, errno.EACCES):
+                    raise
+                # 锁已存在 —— 只在"看起来 stale"时才做昂贵的 PID 探测
+                # 正常等待: 仅 stat 看 age, 不读文件不探测进程
+                try:
+                    age = time.time() - os.stat(self.path).st_mtime
+                except OSError:
+                    age = 0
+                # age 超过 stale_seconds 才值得探测; 否则纯等待
+                looks_stale = age > self.stale_seconds
+                if looks_stale and self._is_stale():
+                    self._force_release_stale()
+                    continue  # 重试创建
+                # 还活着的锁 —— 决定等待还是失败
+                if self.timeout == 0:
+                    raise LockBusyError("锁被持有: {}".format(self.path))
+                if 0 <= self.timeout < (time.monotonic() - start):
+                    raise LockTimeoutError(
+                        "获取锁超时 ({}s): {}".format(self.timeout, self.path)
+                    )
+                time.sleep(self.poll_interval)
+
+    def release(self) -> None:
+        if not self._holding:
+            return
+        try:
+            os.remove(self.path)
+        except OSError:
+            pass
+        finally:
+            self._holding = False
+
+    def _is_stale(self) -> bool:
+        """锁文件是否可被视为 stale（持有进程已死 或 超过 stale_seconds 且进程不存活）。"""
+        try:
+            st = os.stat(self.path)
+        except OSError:
+            return False  # 文件没了，外层会重试创建
+        age = time.time() - st.st_mtime
+        pid = self._read_pid()
+        if pid is None:
+            # 读不出 PID；保守起见，超过 stale_seconds 才视为 stale
+            return age > self.stale_seconds
+        alive = _pid_alive(pid)
+        if not alive:
+            return True
+        # 进程活但锁放太久（可能僵死）—— 超阈值才抢
+        return age > self.stale_seconds
+
+    def _read_pid(self) -> Optional[int]:
+        """从锁文件解析 pid=N 标记（容忍它出现在行中任意位置）。"""
+        try:
+            with open(self.path, "r", encoding="utf-8", errors="replace") as f:
+                for line in f:
+                    # 同时支持 "pid=123" 在行首或行中（"2026-... pid=123"）
+                    for tok in line.replace("\t", " ").split():
+                        if tok.startswith("pid="):
+                            try:
+                                return int(tok.split("=", 1)[1].strip())
+                            except ValueError:
+                                continue
+        except OSError:
+            return None
+        return None
+
+    def _force_release_stale(self) -> None:
+        try:
+            os.remove(self.path)
+        except OSError:
+            pass
+
+    # 上下文管理器协议
+    def __enter__(self) -> "FileLock":
+        return self.acquire()
+
+    def __exit__(self, exc_type, exc_val, exc_tb) -> None:
+        self.release()