codebee 0.1.23 → 0.1.25

package/app/core/portscan.py

@@ -1,188 +1,188 @@
-# -*- coding: utf-8 -*-
-"""端口/进程扫描与项目归属推断（借鉴 leftopen 38★）。
-
-三个机制：
-- **端口→进程→项目归属推断**：netstat/ss 拿端口→PID，再从进程 CWD 向上走找
-  .git/package.json 等项目根——知道该进程属于哪个项目/用户
-- **本地 vs LAN 区分**：127.0.0.1 与 0.0.0.0/LAN 的安全边界
-- **温和关闭**：SIGTERM only（Windows taskkill /PID 不带 /F），关闭前重验 PID
-
-跨平台（Windows netstat + PowerShell / POSIX ss + /proc）纯标准库。
-"""
-from __future__ import annotations
-
-import json
-import logging
-import os
-import re
-import subprocess
-
-log = logging.getLogger(__name__)
-
-_PROJECT_MARKERS = (".git", "package.json", "pyproject.toml", "Cargo.toml",
-                    "go.mod", "pom.xml", "build.gradle", ".codebee")
-_SYSTEM_PROCS = {"system", "idle", "kernel", "svchost", "launchd", "init",
-                 "systemd", "sshd", "explorer", "finder", "windowserver"}
-
-
-def _project_from_cwd(cwd):
-    """从 CWD 向上走到项目根（含标志文件的最深目录名）。"""
-    if not cwd:
-        return ""
-    cur = os.path.abspath(cwd)
-    origin = cur
-    home = os.path.abspath(os.path.expanduser("~"))
-    while cur and cur != os.path.dirname(cur):
-        # 家目录及以上散落的标志文件（package.json 等）是环境噪音不是项目；
-        # 只有进程就跑在家目录本身时才认它为归属。
-        if cur == home and cur != origin:
-            return ""
-        for marker in _PROJECT_MARKERS:
-            if os.path.exists(os.path.join(cur, marker)):
-                return os.path.basename(cur)
-        cur = os.path.dirname(cur)
-    return ""
-
-
-def _proc_detail(pid):
-    """POSIX：读 /proc/<pid>/cwd 和 comm 获取进程详情。"""
-    detail = {"name": "", "project": ""}
-    try:
-        cwd = os.readlink("/proc/%d/cwd" % pid)
-        with open("/proc/%d/comm" % pid) as f:
-            detail["name"] = f.read().strip()
-        proj = _project_from_cwd(cwd)
-        if proj:
-            detail["project"] = proj
-    except (OSError, PermissionError):
-        pass
-    return detail
-
-
-def _parse_ss(output):
-    """解析 ss/netstat -tlnp 输出为端口条目列表。"""
-    ports, pid_map = [], {}
-    for ln in output.splitlines():
-        m = re.search(r":(\d{4,5})\s", ln)
-        if not m:
-            continue
-        port = int(m.group(1))
-        pm = re.search(r"pid=(\d+)", ln)
-        pid = int(pm.group(1)) if pm else 0
-        local_only = "127.0.0.1" in ln or "[::1]" in ln or "localhost" in ln
-        if pid and pid not in pid_map:
-            pid_map[pid] = _proc_detail(pid)
-        ports.append({"port": port, "pid": pid, "local_only": local_only,
-                      "process": pid_map.get(pid, {}).get("name", ""),
-                      "project": pid_map.get(pid, {}).get("project", "")})
-    dedup = {}
-    for p in ports:
-        key = p["port"]
-        if key not in dedup or (p["pid"] and not dedup[key]["pid"]):
-            dedup[key] = p
-    return sorted(dedup.values(), key=lambda x: x["port"])
-
-
-def _ports_linux():
-    """Linux/macOS：ss 优先，netstat 兜底。"""
-    try:
-        proc = subprocess.run(["ss", "-tlnp"], capture_output=True, timeout=15)
-        if proc.returncode == 0 and proc.stdout:
-            return _parse_ss(proc.stdout.decode("utf-8", "replace"))
-    except (OSError, subprocess.TimeoutExpired):
-        pass
-    try:
-        proc = subprocess.run(["netstat", "-tlnp"], capture_output=True, timeout=15)
-        if proc.returncode == 0 and proc.stdout:
-            return _parse_ss(proc.stdout.decode("utf-8", "replace"))
-    except (OSError, subprocess.TimeoutExpired):
-        pass
-    return []
-
-
-def _ports_windows(with_names=True):
-    """Windows：netstat -ano -p TCP 拿端口，PowerShell 一次性补进程名。"""
-    try:
-        proc = subprocess.run(
-            ["C:\\Windows\\System32\\netstat.exe", "-ano", "-p", "TCP"],
-            capture_output=True, timeout=15)
-    except (OSError, subprocess.TimeoutExpired):
-        return []
-    ports = []
-    for ln in proc.stdout.decode("utf-8", "replace").splitlines():
-        parts = ln.split()
-        if len(parts) < 5 or parts[0] != "TCP" or parts[3] != "LISTENING":
-            continue
-        local = parts[1]
-        pid_str = parts[4]
-        if not pid_str.isdigit():
-            continue
-        addr, _, port_str = local.rpartition(":")
-        if not port_str.isdigit():
-            continue
-        ports.append({"port": int(port_str), "pid": int(pid_str),
-                      "local_only": addr in ("127.0.0.1", "[::1]", "::1"),
-                      "process": "", "project": ""})
-    if with_names and ports:
-        try:
-            pn = subprocess.run(
-                ["C:\\Windows\\System32\\WindowsPowerShell\\v1.0\\powershell.exe",
-                 "-NoProfile", "-Command",
-                 "Get-Process | Select-Object Id,ProcessName | ConvertTo-Json -Compress"],
-                capture_output=True, timeout=15)
-            procs = json.loads(pn.stdout.decode("utf-8", "replace"))
-            if isinstance(procs, dict):
-                procs = [procs]
-            name_map = {p.get("Id"): p.get("ProcessName", "") for p in procs}
-            for p in ports:
-                p["process"] = name_map.get(p["pid"], "")
-        except Exception:
-            pass
-    dedup = {}
-    for p in ports:
-        dedup.setdefault(p["port"], p)
-    return sorted(dedup.values(), key=lambda x: x["port"])
-
-
-def listening_ports(with_names=True):
-    """扫描本机所有 LISTEN 端口，返回 [{port, pid, process, project, local_only}]。
-
-    project 从进程 CWD 推断项目根目录名（POSIX /proc 可得，Windows 留空）。
-    with_names=False：跳过进程名/归属补全（Windows 下省掉 PowerShell 一次
-    起跳，重验场景用），process/project 恒为空串。
-    结果按端口号排序，重复端口去重（保留有 PID 信息的条目）。"""
-    if os.name == "nt":
-        return _ports_windows(with_names)
-    return _ports_linux()
-
-
-def close_port(port):
-    """温和关闭端口上的进程。返回 (ok, message)。关闭前重验 PID 绑定。"""
-    for p in listening_ports():
-        if p["port"] != port:
-            continue
-        pid = p.get("pid", 0)
-        if not pid or pid <= 4:
-            return False, "系统进程，不关闭"
-        if pid == os.getpid():
-            return False, "不能关闭自身服务进程"
-        if p.get("process", "").lower() in _SYSTEM_PROCS:
-            return False, "系统服务，不关闭"
-        # 重验 PID 仍在监听该端口（防 PID 复用竞态）；轻量扫描省掉 PowerShell
-        still = any(pp["port"] == port and pp["pid"] == pid
-                    for pp in listening_ports(with_names=False))
-        if not still:
-            return False, "PID %d 已不在端口 %d 上监听（竞态）" % (pid, port)
-        if os.name == "posix":
-            try:
-                os.kill(pid, 15)   # SIGTERM
-                return True, "已发送 SIGTERM（PID %d）" % pid
-            except OSError as e:
-                return False, str(e)[:160]
-        try:
-            subprocess.run(["taskkill", "/PID", str(pid)],
-                           timeout=10, capture_output=True)
-            return True, "已发送关闭信号（PID %d）" % pid
-        except Exception as e:
-            return False, str(e)[:160]
-    return False, "端口 %d 未找到监听进程" % port
+# -*- coding: utf-8 -*-
+"""端口/进程扫描与项目归属推断（借鉴 leftopen 38★）。
+
+三个机制：
+- **端口→进程→项目归属推断**：netstat/ss 拿端口→PID，再从进程 CWD 向上走找
+  .git/package.json 等项目根——知道该进程属于哪个项目/用户
+- **本地 vs LAN 区分**：127.0.0.1 与 0.0.0.0/LAN 的安全边界
+- **温和关闭**：SIGTERM only（Windows taskkill /PID 不带 /F），关闭前重验 PID
+
+跨平台（Windows netstat + PowerShell / POSIX ss + /proc）纯标准库。
+"""
+from __future__ import annotations
+
+import json
+import logging
+import os
+import re
+import subprocess
+
+log = logging.getLogger(__name__)
+
+_PROJECT_MARKERS = (".git", "package.json", "pyproject.toml", "Cargo.toml",
+                    "go.mod", "pom.xml", "build.gradle", ".codebee")
+_SYSTEM_PROCS = {"system", "idle", "kernel", "svchost", "launchd", "init",
+                 "systemd", "sshd", "explorer", "finder", "windowserver"}
+
+
+def _project_from_cwd(cwd):
+    """从 CWD 向上走到项目根（含标志文件的最深目录名）。"""
+    if not cwd:
+        return ""
+    cur = os.path.abspath(cwd)
+    origin = cur
+    home = os.path.abspath(os.path.expanduser("~"))
+    while cur and cur != os.path.dirname(cur):
+        # 家目录及以上散落的标志文件（package.json 等）是环境噪音不是项目；
+        # 只有进程就跑在家目录本身时才认它为归属。
+        if cur == home and cur != origin:
+            return ""
+        for marker in _PROJECT_MARKERS:
+            if os.path.exists(os.path.join(cur, marker)):
+                return os.path.basename(cur)
+        cur = os.path.dirname(cur)
+    return ""
+
+
+def _proc_detail(pid):
+    """POSIX：读 /proc/<pid>/cwd 和 comm 获取进程详情。"""
+    detail = {"name": "", "project": ""}
+    try:
+        cwd = os.readlink("/proc/%d/cwd" % pid)
+        with open("/proc/%d/comm" % pid) as f:
+            detail["name"] = f.read().strip()
+        proj = _project_from_cwd(cwd)
+        if proj:
+            detail["project"] = proj
+    except (OSError, PermissionError):
+        pass
+    return detail
+
+
+def _parse_ss(output):
+    """解析 ss/netstat -tlnp 输出为端口条目列表。"""
+    ports, pid_map = [], {}
+    for ln in output.splitlines():
+        m = re.search(r":(\d{4,5})\s", ln)
+        if not m:
+            continue
+        port = int(m.group(1))
+        pm = re.search(r"pid=(\d+)", ln)
+        pid = int(pm.group(1)) if pm else 0
+        local_only = "127.0.0.1" in ln or "[::1]" in ln or "localhost" in ln
+        if pid and pid not in pid_map:
+            pid_map[pid] = _proc_detail(pid)
+        ports.append({"port": port, "pid": pid, "local_only": local_only,
+                      "process": pid_map.get(pid, {}).get("name", ""),
+                      "project": pid_map.get(pid, {}).get("project", "")})
+    dedup = {}
+    for p in ports:
+        key = p["port"]
+        if key not in dedup or (p["pid"] and not dedup[key]["pid"]):
+            dedup[key] = p
+    return sorted(dedup.values(), key=lambda x: x["port"])
+
+
+def _ports_linux():
+    """Linux/macOS：ss 优先，netstat 兜底。"""
+    try:
+        proc = subprocess.run(["ss", "-tlnp"], capture_output=True, timeout=15)
+        if proc.returncode == 0 and proc.stdout:
+            return _parse_ss(proc.stdout.decode("utf-8", "replace"))
+    except (OSError, subprocess.TimeoutExpired):
+        pass
+    try:
+        proc = subprocess.run(["netstat", "-tlnp"], capture_output=True, timeout=15)
+        if proc.returncode == 0 and proc.stdout:
+            return _parse_ss(proc.stdout.decode("utf-8", "replace"))
+    except (OSError, subprocess.TimeoutExpired):
+        pass
+    return []
+
+
+def _ports_windows(with_names=True):
+    """Windows：netstat -ano -p TCP 拿端口，PowerShell 一次性补进程名。"""
+    try:
+        proc = subprocess.run(
+            ["C:\\Windows\\System32\\netstat.exe", "-ano", "-p", "TCP"],
+            capture_output=True, timeout=15)
+    except (OSError, subprocess.TimeoutExpired):
+        return []
+    ports = []
+    for ln in proc.stdout.decode("utf-8", "replace").splitlines():
+        parts = ln.split()
+        if len(parts) < 5 or parts[0] != "TCP" or parts[3] != "LISTENING":
+            continue
+        local = parts[1]
+        pid_str = parts[4]
+        if not pid_str.isdigit():
+            continue
+        addr, _, port_str = local.rpartition(":")
+        if not port_str.isdigit():
+            continue
+        ports.append({"port": int(port_str), "pid": int(pid_str),
+                      "local_only": addr in ("127.0.0.1", "[::1]", "::1"),
+                      "process": "", "project": ""})
+    if with_names and ports:
+        try:
+            pn = subprocess.run(
+                ["C:\\Windows\\System32\\WindowsPowerShell\\v1.0\\powershell.exe",
+                 "-NoProfile", "-Command",
+                 "Get-Process | Select-Object Id,ProcessName | ConvertTo-Json -Compress"],
+                capture_output=True, timeout=15)
+            procs = json.loads(pn.stdout.decode("utf-8", "replace"))
+            if isinstance(procs, dict):
+                procs = [procs]
+            name_map = {p.get("Id"): p.get("ProcessName", "") for p in procs}
+            for p in ports:
+                p["process"] = name_map.get(p["pid"], "")
+        except Exception:
+            pass
+    dedup = {}
+    for p in ports:
+        dedup.setdefault(p["port"], p)
+    return sorted(dedup.values(), key=lambda x: x["port"])
+
+
+def listening_ports(with_names=True):
+    """扫描本机所有 LISTEN 端口，返回 [{port, pid, process, project, local_only}]。
+
+    project 从进程 CWD 推断项目根目录名（POSIX /proc 可得，Windows 留空）。
+    with_names=False：跳过进程名/归属补全（Windows 下省掉 PowerShell 一次
+    起跳，重验场景用），process/project 恒为空串。
+    结果按端口号排序，重复端口去重（保留有 PID 信息的条目）。"""
+    if os.name == "nt":
+        return _ports_windows(with_names)
+    return _ports_linux()
+
+
+def close_port(port):
+    """温和关闭端口上的进程。返回 (ok, message)。关闭前重验 PID 绑定。"""
+    for p in listening_ports():
+        if p["port"] != port:
+            continue
+        pid = p.get("pid", 0)
+        if not pid or pid <= 4:
+            return False, "系统进程，不关闭"
+        if pid == os.getpid():
+            return False, "不能关闭自身服务进程"
+        if p.get("process", "").lower() in _SYSTEM_PROCS:
+            return False, "系统服务，不关闭"
+        # 重验 PID 仍在监听该端口（防 PID 复用竞态）；轻量扫描省掉 PowerShell
+        still = any(pp["port"] == port and pp["pid"] == pid
+                    for pp in listening_ports(with_names=False))
+        if not still:
+            return False, "PID %d 已不在端口 %d 上监听（竞态）" % (pid, port)
+        if os.name == "posix":
+            try:
+                os.kill(pid, 15)   # SIGTERM
+                return True, "已发送 SIGTERM（PID %d）" % pid
+            except OSError as e:
+                return False, str(e)[:160]
+        try:
+            subprocess.run(["taskkill", "/PID", str(pid)],
+                           timeout=10, capture_output=True)
+            return True, "已发送关闭信号（PID %d）" % pid
+        except Exception as e:
+            return False, str(e)[:160]
+    return False, "端口 %d 未找到监听进程" % port

package/app/core/redact.py

@@ -0,0 +1,38 @@
+# -*- coding: utf-8 -*-
+"""自由文本脱敏基础函数；不依赖业务模块，供各类本地台账复用。"""
+from __future__ import annotations
+
+import re
+
+
+_KEY_PATTERNS = (
+    (re.compile(r"\bsk-[A-Za-z0-9_-]{8,}"), "[key]"),
+    (re.compile(r"\b(?:Bearer|bearer)\s+\S+"), "Bearer [key]"),
+    (re.compile(r"(?i)\b((?:api[_-]?|access[_-]?|secret[_-]?|auth[_-]?)(?:key|token|secret))"
+                r"""["']?\s*[:=，,]\s*["']?[A-Za-z0-9._~+/=-]{8,}"""), r"\1[key]"),
+    (re.compile(r"\b[0-9a-fA-F]{40,}\b"), "[token]"),
+)
+
+_PATH_PATTERNS = (
+    (re.compile(r"(?i)\b[A-Z]:\\(?:[^\\/:*?\"<>|\r\n]+\\)*[^\\/:*?\"<>|\r\n]*"),
+     lambda m: "[path]" + m.group(0).split("\\")[-1]),
+    (re.compile(r"(?i)\b(?:\\\\[^\\\s]+\\[^\s]+)"), "[path]"),
+    (re.compile(r"(?:/Users/|/home/|~)[^\s\"':]+"),
+     lambda m: "[path]" + m.group(0).rsplit("/", 1)[-1]),
+)
+
+
+def scrub_text(text, limit=600):
+    """剥离常见密钥、令牌和绝对路径，再按字符上限截断。"""
+    if not isinstance(text, str):
+        text = "" if text is None else str(text)
+    out = text
+    for pattern, replacement in _KEY_PATTERNS:
+        out = pattern.sub(replacement, out)
+    for pattern, replacement in _PATH_PATTERNS:
+        try:
+            out = pattern.sub(replacement, out)
+        except Exception:
+            pass
+    out = out.strip()
+    return out[:limit] + "…" if len(out) > limit else out

package/app/core/router.py

@@ -37,7 +37,7 @@ def _binding_bonus(agent_id, dispatch_mode=False):
         return 0.0
 
 
-def _history_bonus(stats, agent_id, ttype):
+def _history_bonus(stats, agent_id, ttype):
     s = (stats.get(agent_id) or {}).get(ttype) or {}
     if not s.get("runs"):
         return 0.0
@@ -47,9 +47,34 @@ def _history_bonus(stats, agent_id, ttype):
     # 偶发失败把智能体埋了）。0/3 全败 = -18：常挂的 CLI 必须排到无历史的新
     # 面孔之后（2026-09-17 前败率不扣分，0/3 还拿 +6 经验分，比没跑过还高）。
     loss_penalty = 24.0 * (1.0 - win_rate) * min(1.0, runs / 3.0)
-    return round(18.0 * win_rate + min(6.0, runs) - loss_penalty, 1)
-
-
+    return round(18.0 * win_rate + min(6.0, runs) - loss_penalty, 1)
+
+
+def _online_bonus(agent, role, ttype):
+    """近期真实运行信号：成功率、P95 延迟和均价只作软加减分。"""
+    try:
+        from . import usage
+        metrics = usage.routing_stats(task_type=ttype, role=role,
+                                      agent=agent.get("id") or "")
+        samples = int(metrics.get("samples") or 0)
+        if not samples:
+            return 0.0, ""
+        rate = float(metrics.get("success_rate") or 0.0)
+        success_score = max(-8.0, min(8.0, (rate - 0.75) * 24.0))
+        p95 = max(0.0, float(metrics.get("p95_duration_s") or 0.0))
+        latency_score = -min(6.0, max(0.0, (p95 - 45.0) / 10.0))
+        cost = max(0.0, float(metrics.get("avg_cost_usd") or 0.0))
+        cost_score = -min(4.0, max(0.0, (cost - 0.01) / 0.01))
+        total = round(success_score + latency_score + cost_score, 1)
+        success_samples = int(metrics.get("success_samples") or samples)
+        reason = ("，在线 %d/%d 验收成功（%+.1f），P95 %.1fs（%+.1f），均价 $%.4f（%+.1f）"
+                  % (int(metrics.get("successes") or 0), success_samples,
+                     success_score, p95, latency_score, cost, cost_score))
+        return total, reason
+    except Exception:
+        return 0.0, ""
+
+
 def score(agent, role, ttype, stats=None):
     """返回 (总分, 理由字符串)。配额惩罚：catalog 里配了
     quota_tokens_per_hour 的智能体，本小时用量越接近配额分越低
@@ -65,12 +90,13 @@ def score(agent, role, ttype, stats=None):
         btxt = "，绑定链可用（+%s）" % bb
     elif bb < 0:
         btxt = "，绑定链为空：相关步骤将判失败（%s）" % bb
-    hb = _history_bonus(stats, agent.get("id"), ttype)
+    hb = _history_bonus(stats, agent.get("id"), ttype)
+    online, online_txt = _online_bonus(agent, role, ttype)
     # 保持公开 score() 的历史绝对分值；运行级候选由 pipeline 标记画像后
     # 才启用能力亲和度，避免旧插件/测试调用被新权重悄然改变。
     affinity, affinity_txt = (dispatch.agent_affinity(agent.get("kind"), ttype, role)
                               if use_dispatch else (0.0, "兼容模式"))
-    total = base + bb + hb + affinity
+    total = base + bb + hb + affinity + online
     hs = (stats.get(agent.get("id")) or {}).get(ttype)
     htxt = ("，历史 %d/%d 胜（%s）" % (hs["wins"], hs["runs"], "%+.1f" % hb)) if hs else "，无历史记录"
     quota_txt = ""
@@ -87,8 +113,8 @@ def score(agent, role, ttype, stats=None):
             if penalty:
                 total += penalty
                 quota_txt = "，本小时 %d/%d tokens（%s）" % (used, quota, penalty)
-    return total, "能力基线 %d，%s%s%s%s，总分 %s" % (
-        base, affinity_txt, btxt, htxt, quota_txt, round(total, 1))
+    return total, "能力基线 %d，%s%s%s%s%s，总分 %s" % (
+        base, affinity_txt, btxt, htxt, online_txt, quota_txt, round(total, 1))
 
 
 def pick(agents, role, ttype, stats=None, exclude=()):

package/app/core/runner.py

@@ -768,9 +768,10 @@ def _resolve_attempts(agent):
     """
     chain = agent.get("call_chain") or []
     if chain:
-        return [{"model": (e.get("model") or "").strip() or None,
-                 "env": dict(e.get("env") or {}),
-                 "from_chain": True,
+        return [{"model": (e.get("model") or "").strip() or None,
+                 "env": dict(e.get("env") or {}),
+                 "provider": e.get("provider") or {},
+                 "from_chain": True,
                  "own_cp": "codex_provider" in e,
                  "codex_provider": e.get("codex_provider"),
                  "provider_id": e.get("provider_id") or "",
@@ -778,8 +779,12 @@ def _resolve_attempts(agent):
     base_model = agent.get("model")
     fb = [m for m in (agent.get("model_fallbacks") or []) if m and m != base_model]
     models_to_try = ([base_model] if base_model else []) + fb
-    return [{"model": m or None, "env": {}, "from_chain": False, "own_cp": False,
-             "codex_provider": None, "provider_id": "", "key_id": ""}
+    provider = agent.get("provider") or {}
+    return [{"model": m or None, "env": {}, "provider": provider,
+             "from_chain": False, "own_cp": False,
+             "codex_provider": None,
+             "provider_id": provider.get("id") if isinstance(provider, dict) else "",
+             "key_id": ""}
             for m in (models_to_try or [None])[:3]]
 
 
@@ -1056,9 +1061,11 @@ def run_agent(agent, prompt, workdir=None, readonly=True,
                         os.remove(tf)
                     except OSError:
                         pass
-            out = {"ok": res["ok"], "text": "", "json": None, "cost_usd": 0.0,
-                   "tokens": 0, "usage": None, "error": "", "error_code": "",
-                   "sid": "", "raw": res, "kind": kind, "model": att["model"]}
+            out = {"ok": res["ok"], "text": "", "json": None, "cost_usd": 0.0,
+                   "tokens": 0, "usage": None, "error": "", "error_code": "",
+                   "sid": "", "raw": res, "kind": kind, "model": att["model"],
+                   "provider_id": att.get("provider_id") or "",
+                   "provider": att.get("provider") or {}}
             if not res["ok"]:
                 # stderr 与 stdout 都要进错误串：codex 把 "Reading prompt from
                 # stdin..." 打在 stderr，真正的配额/限流错误全在 stdout 的 JSONL