codebee 0.1.0

package/app/core/remote.py

@@ -0,0 +1,303 @@
+# -*- coding: utf-8 -*-
+"""手机/远程访问：访问令牌 + 多端控制权锁 + 服务地址探测。
+
+令牌：首次启动生成，落盘 data/remote.json。本机（127.0.0.1）请求豁免，
+     非 loopback 请求必须带令牌（?token= 或 X-CodeBee-Token 头）。
+控制权：同一时刻只有一台设备能执行写操作。空闲自动接管、45s 无心跳自动释放，
+       可强制抢夺。纯内存状态，重启即清空。
+"""
+from __future__ import annotations
+
+import json
+import re
+import secrets
+import shutil
+import subprocess
+import threading
+import time
+
+from . import paths
+
+# ---------------------------------------------------------------- 访问令牌
+_TOK_LOCK = threading.Lock()
+_TOKEN = ""
+
+
+def token() -> str:
+    """读取（必要时生成）访问令牌。"""
+    global _TOKEN
+    if _TOKEN:
+        return _TOKEN
+    with _TOK_LOCK:
+        if _TOKEN:
+            return _TOKEN
+        p = paths.DATA_DIR / "remote.json"
+        try:
+            data = json.loads(p.read_text(encoding="utf-8"))
+            _TOKEN = str(data.get("token") or "")
+        except Exception:
+            _TOKEN = ""
+        if not _TOKEN:
+            _TOKEN = secrets.token_hex(4)  # 8 位十六进制，手机好输
+            try:
+                p.parent.mkdir(parents=True, exist_ok=True)
+                p.write_text(json.dumps(
+                    {"token": _TOKEN, "created": time.strftime("%Y-%m-%d %H:%M:%S")},
+                    ensure_ascii=False, indent=2), encoding="utf-8")
+            except Exception:
+                pass  # 落盘失败也照常工作（内存令牌，重启更换）
+        return _TOKEN
+
+
+# ---------------------------------------------------------------- 反向代理感知
+# Cloudflare Tunnel / frp 等都从本机回源：若不感知代理，公网请求一律被当成
+# 127.0.0.1 而豁免令牌——等于把控制台裸奔到公网。--trusted-proxy / TUTTI_TRUST_PROXY
+# 开启后：带转发头（CF-Connecting-IP / X-Forwarded-For）的请求视为经代理进来的
+# 远程请求，必须带令牌；不带转发头的 loopback 仍是真本机（浏览器直接开 localhost）。
+# 安全性：Cloudflare 边缘强制注入/覆盖 CF-Connecting-IP，外部无法伪造透传；
+# 而能直连本机端口的攻击者伪造转发头只会让自己从"本机豁免"变成"必须带令牌"。
+_TRUST_PROXY = False
+PUBLIC_URL = ""  # --public-url / 快速隧道：扫码弹框优先展示的公网地址
+PUBLIC_URL_KIND = ""  # quick（trycloudflare 临时，重启变）| fixed（自有域名）
+
+
+def set_trusted_proxy(on: bool, public_url: str = ""):
+    global _TRUST_PROXY, PUBLIC_URL
+    _TRUST_PROXY = bool(on)
+    if public_url:
+        PUBLIC_URL = str(public_url).rstrip("/")
+
+
+# ---------------------------------------------------------------- 快速隧道（trycloudflare）
+# 安装即公网：本机装了 cloudflared 就自动开一条 Cloudflare 快速隧道，
+# 拿到随机 *.trycloudflare.com 地址——零账号、零域名、零配置。
+# 安全强绑定：开隧道必然同时开启 trusted-proxy（否则回源 loopback 豁免=裸奔）。
+# 代价：每次重启地址会变（手机重新扫码即可）；要固定域名见 README 公网章节。
+_QUICK_PROC = None  # cloudflared 子进程，随主服务退出
+
+
+def cloudflared_exe() -> str:
+    import os
+    exe = shutil.which("cloudflared")
+    if exe:
+        return exe
+    guess = os.path.join(os.environ.get("ProgramFiles(x86)", ""), "cloudflared", "cloudflared.exe")
+    return guess if os.path.isfile(guess) else ""
+
+
+def has_local_creds() -> bool:
+    """~/.cloudflared 下有隧道凭据（用户已玩过 named tunnel）。
+
+    实测（2026-09）：本机存在凭据时 cloudflared 会把 quick tunnel 降级为
+    named 模式运行，随机域名恒 404；此时应走固定域名路径而不是 quick。
+    """
+    import os
+    d = os.path.join(os.path.expanduser("~"), ".cloudflared")
+    try:
+        return any(f.endswith(".json") for f in os.listdir(d))
+    except Exception:
+        return False
+
+
+def start_quick_tunnel(port: int, on_url) -> bool:
+    """后台起快速隧道，解析到随机 URL 后回调 on_url(url)（如在主线程打印+推送）。
+
+    返回 False 表示没装 cloudflared 或启动失败，调用方给出提示。
+    """
+    global _QUICK_PROC
+    exe = cloudflared_exe()
+    if not exe or not port:
+        return False
+    import subprocess
+    flags = 0x08000000 if hasattr(subprocess, "CREATE_NO_WINDOW") else 0  # CREATE_NO_WINDOW
+    try:
+        _QUICK_PROC = subprocess.Popen(
+            [exe, "tunnel", "--url", "http://localhost:%d" % port, "--no-autoupdate"],
+            stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
+            creationflags=flags, text=True, encoding="utf-8", errors="replace")
+    except Exception:
+        _QUICK_PROC = None
+        return False
+    import threading
+
+    def _watch():
+        global PUBLIC_URL, PUBLIC_URL_KIND
+        deadline = time.time() + 25
+        found = False
+        try:
+            for line in _QUICK_PROC.stdout:
+                if not found:
+                    m = re.search(r"https://[a-z0-9-]+\.trycloudflare\.com", line or "")
+                    if m:
+                        set_trusted_proxy(True)  # 公网暴露 ⇆ 强制反代感知，防回源豁免
+                        PUBLIC_URL = m.group(0)
+                        PUBLIC_URL_KIND = "quick"
+                        on_url(PUBLIC_URL)
+                        found = True
+                        # 不 break：必须继续消费日志，否则 cloudflared 写满管道
+                        # 缓冲后会整体阻塞，边缘连接注册无法完成（实测 530）
+                if time.time() > deadline and not found:
+                    break
+        except Exception:
+            pass
+
+    threading.Thread(target=_watch, daemon=True).start()
+    return True
+
+
+def stop_quick_tunnel():
+    global _QUICK_PROC
+    if _QUICK_PROC:
+        try:
+            _QUICK_PROC.terminate()
+        except Exception:
+            pass
+        _QUICK_PROC = None
+
+
+def effective_ip(socket_ip: str, forwarded: str) -> str:
+    """信任代理时从转发头取真实客户端 IP（第一跳），否则用 socket 地址。"""
+    if _TRUST_PROXY and forwarded:
+        first = forwarded.split(",")[0].strip()
+        if first:
+            return first
+    return socket_ip
+
+
+def request_authed(client_ip: str, forwarded: str, query_token: str, header_token: str) -> bool:
+    """本机豁免；远程（或经代理回源）请求必须带正确令牌。"""
+    loopback = client_ip in ("127.0.0.1", "::1")
+    if loopback and not (_TRUST_PROXY and forwarded):
+        return True  # 真本机（trust_proxy 下不带转发头的 loopback 也算）
+    tok = token()
+    if not tok:
+        return True
+    return secrets.compare_digest(str(query_token or ""), tok) or \
+        secrets.compare_digest(str(header_token or ""), tok)
+
+
+# ---------------------------------------------------------------- 控制权锁
+CTRL_TTL = 45.0  # 秒；持锁设备停止心跳后自动释放
+_CTRL = {"client_id": "", "name": "", "expires_at": 0.0}
+# RLock：acquire/release 持锁期间会调 control_view，它也要拿同一把锁
+_CTRL_LOCK = threading.RLock()
+
+
+def _live_ctrl():
+    """返回未过期的持锁信息；过期则视为空闲（惰性过期，无需定时线程）。"""
+    if _CTRL["client_id"] and time.time() > _CTRL["expires_at"]:
+        _CTRL.update({"client_id": "", "name": "", "expires_at": 0.0})
+    return _CTRL
+
+
+def control_view(client_id: str = "") -> dict:
+    """对外的控制权状态：free / held（mine 标记是否是请求方自己持有）。
+
+    expires_in 按 10s 桶化：SSE 靠对比该 dict 判断"控制权是否变了"，
+    精确到秒的倒计时会造成每秒一次假变化 → 全量推送。
+    """
+    with _CTRL_LOCK:
+        c = _live_ctrl()
+        if not c["client_id"]:
+            return {"mode": "free", "mine": False}
+        return {"mode": "held", "mine": bool(client_id) and c["client_id"] == client_id,
+                "holder": c["name"] or "其他设备",
+                "expires_in": max(10, int(c["expires_at"] - time.time()) // 10 * 10)}
+
+
+def acquire(client_id: str, name: str, force: bool = False):
+    """接管控制权。已持有则顺延心跳；空闲直接拿到；他人持有时除非 force 否则拒绝。
+
+    返回 (ok, control_view)。
+    """
+    client_id = str(client_id or "")
+    if not client_id:
+        client_id = "anon-" + secrets.token_hex(4)
+    with _CTRL_LOCK:
+        c = _live_ctrl()
+        if c["client_id"] == client_id:
+            c["expires_at"] = time.time() + CTRL_TTL
+            return True, control_view(client_id)
+        if c["client_id"] and not force:
+            return False, control_view(client_id)
+        _CTRL.update({"client_id": client_id,
+                      "name": _safe_name(name) or "其他设备",
+                      "expires_at": time.time() + CTRL_TTL})
+        return True, control_view(client_id)
+
+
+def release(client_id: str) -> dict:
+    with _CTRL_LOCK:
+        if client_id and _CTRL["client_id"] == client_id:
+            _CTRL.update({"client_id": "", "name": "", "expires_at": 0.0})
+        return control_view(client_id)
+
+
+def heartbeat(client_id: str):
+    """持锁续期。返回 (是否仍持有, control_view)。"""
+    ok, view = acquire(client_id, "")
+    return ok, view
+
+
+def _safe_name(s) -> str:
+    return re.sub(r"\s+", " ", str(s or "")).strip()[:24]
+
+
+# ---------------------------------------------------------------- 地址探测
+_TS_CACHE = {"ip": "", "ts": 0.0}  # tailscale CLI 调用有开销，30s 缓存
+
+
+def lan_ip() -> str:
+    """本机局域网 IP（UDP connect 只选路由不发包）。"""
+    import socket
+    s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+    try:
+        s.connect(("223.5.5.5", 80))
+        return s.getsockname()[0]
+    except Exception:
+        return ""
+    finally:
+        s.close()
+
+
+def tailscale_ip(max_age: float = 30.0) -> str:
+    """Tailscale 虚拟网 IP；未安装/未启动返回空。结果缓存 30s。"""
+    if max_age > 0 and time.time() - _TS_CACHE["ts"] < max_age:
+        return _TS_CACHE["ip"]
+    ip = _tailscale_ip_once()
+    _TS_CACHE.update({"ip": ip, "ts": time.time()})
+    return ip
+
+
+def _tailscale_ip_once() -> str:
+    exe = shutil.which("tailscale")
+    if not exe:
+        return ""
+    try:
+        out = subprocess.run([exe, "ip", "-4"], capture_output=True,
+                             text=True, timeout=5)
+        for line in (out.stdout or "").splitlines():
+            ip = line.strip()
+            if re.match(r"^\d+\.\d+\.\d+\.\d+$", ip):
+                return ip
+    except Exception:
+        pass
+    return ""
+
+
+def build_connect_urls(port: int) -> list:
+    """手机扫码可用的连接地址，按优先级排序：公网域名 > Tailscale > 局域网。"""
+    urls = []
+    if PUBLIC_URL:
+        label = ("公网 · 任何网络（重启会变，连不上重新扫码）" if PUBLIC_URL_KIND == "quick"
+                 else "公网 · 任何网络")
+        urls.append({"label": label, "url": "%s/?token=%s" % (PUBLIC_URL, token())})
+    ts = tailscale_ip()
+    if ts:
+        urls.append({"label": "Tailscale · 外网随时随地",
+                     "url": "http://%s:%d/?token=%s" % (ts, port, token())})
+    lan = lan_ip()
+    if lan:
+        urls.append({"label": "局域网 · 同一 WiFi",
+                     "url": "http://%s:%d/?token=%s" % (lan, port, token())})
+    return urls

package/app/core/repeat_guard.py

@@ -0,0 +1,124 @@
+# -*- coding: utf-8 -*-
+"""重复 CLI 调用检测：防止编排者用同一份 prompt 反复调同一 CLI 死循环。
+
+设计稿：docs/migration/01-defense-patterns.md §5C。
+参考 dsh packages/guard/repeat-tool-reminder/src/index.ts：
+  监听 tools/post-execute，按 (tool, canonical_args) 跟踪，3/5/8 阈值注入 user-message 提醒。
+
+Tutti 的 "tool" 对应到 "step role"，"canonical_args" 对应到 prompt 模板指纹。
+阈值更宽松（5/10/15），因 Tutti 步骤级别比 dsh 工具调用粗。
+"""
+from __future__ import annotations
+
+import hashlib
+import logging
+import threading
+import time
+
+log = logging.getLogger(__name__)
+
+# 渐进阈值：第 N 次命中时给提醒；最后一次及以上时强制停止。
+DEFAULT_THRESHOLDS = (5, 10, 15)
+
+REMINDER_TEMPLATE = (
+    "⚠️ 提醒：上一步使用了几乎相同的输入（已连续 {count} 次调用 {role}）。"
+    "请换一种方法：读不同的文件、用更具体的指令、或明确询问用户澄清。"
+)
+
+STOP_TEMPLATE = (
+    "已连续 {count} 次使用相同输入调用 {role}，超过 {last_thr} 次阈值，"
+    "强制停止本 step 以防止无限循环。请用户检查输入或调整 prompt 模板。"
+)
+
+
+def _prompt_fingerprint(prompt: str) -> str:
+    """prompt 指纹：用前 200 字符 + 总长度（CLI prompt 头几行通常是模板部分）。
+
+    不做严格 canonical args 比对（CLI prompt 通常很长，且 dsh 也用 JSON.stringify）；
+    指纹命中说明是同一个模板路径走过多次，已经够分辨。
+
+    用 SHA-256 取前 12 字符（96 bit）：48 亿分之一碰撞概率对去重足够；不追求密码学强度。
+    """
+    head = (prompt or "")[:200]
+    return hashlib.sha256(f"{head}|{len(prompt or '')}".encode("utf-8")).hexdigest()[:12]
+
+
+class RepeatGuard:
+    """每 (run_id, step_role) 独立计数；key = prompt 指纹。
+
+    计数仅统计相同 key 连续出现；新 prompt 会重置。
+    """
+
+    def __init__(self, thresholds=DEFAULT_THRESHOLDS, *, max_history=50):
+        self.thresholds = tuple(sorted(set(thresholds)))
+        self.max_history = max_history
+        self._lock = threading.Lock()
+        # chain[(run_id, role)] = [(ts, fingerprint)]
+        self._chains: dict = {}
+
+    def check(self, run_id: str, role: str, prompt: str) -> dict:
+        """检查并更新 (run_id, role) 的连续计数。
+
+        Returns:
+            {"count": int, "reminder": str | None, "should_stop": bool}
+        """
+        fp = _prompt_fingerprint(prompt)
+        chain_key = (run_id, role)
+        with self._lock:
+            chain = self._chains.setdefault(chain_key, [])
+            chain.append((time.time(), fp))
+            # 仅统计相同 fp 连续出现
+            count = 1
+            for _, prev_fp in reversed(chain[:-1]):
+                if prev_fp == fp:
+                    count += 1
+                else:
+                    break
+            # 截尾避免内存膨胀
+            if len(chain) > self.max_history:
+                self._chains[chain_key] = chain[-self.max_history:]
+
+        reminder = None
+        stop = False
+        last_thr = self.thresholds[-1]
+        if count >= last_thr:
+            stop = True
+            reminder = STOP_TEMPLATE.format(count=count, role=role, last_thr=last_thr)
+        elif count in self.thresholds:
+            reminder = REMINDER_TEMPLATE.format(count=count, role=role)
+
+        if reminder:
+            log.warning("repeat-guard %s/%s count=%d stop=%s reminder=%s",
+                        run_id, role, count, stop, reminder[:80])
+        return {"count": count, "reminder": reminder, "should_stop": stop}
+
+    def reset(self, run_id: str) -> int:
+        """重置某 run_id 的所有 (run_id, *) 链。返回清除的链条数。"""
+        with self._lock:
+            cleared = 0
+            for k in list(self._chains.keys()):
+                if k[0] == run_id:
+                    del self._chains[k]
+                    cleared += 1
+            return cleared
+
+    def stats(self, run_id: str, role: str) -> dict:
+        """读取 (run_id, role) 当前状态（不更新）。用于 UI 调试。"""
+        chain_key = (run_id, role)
+        with self._lock:
+            chain = self._chains.get(chain_key, [])
+            if not chain:
+                return {"chain_len": 0, "last_fp": ""}
+            # 当前连续计数
+            last_fp = chain[-1][1]
+            count = 1
+            for _, fp in reversed(chain[:-1]):
+                if fp == last_fp:
+                    count += 1
+                else:
+                    break
+            return {"chain_len": len(chain), "last_fp": last_fp, "count": count}
+
+
+# 模块级默认实例（pipeline 接线用；run_id 入键天然隔离多任务，测试无需替换）
+guard = RepeatGuard()

package/app/core/router.py

@@ -0,0 +1,120 @@
+# -*- coding: utf-8 -*-
+"""智能路由：能力基线 × 历史胜率 × 角色约束 → 选智能体，并给出可解释的理由。"""
+from __future__ import annotations
+
+from . import history
+
+# 各类智能体的能力基线（0-100）。真实 CLI 里官方双雄最高。
+CAPABILITY = {
+    "codex": 84, "claude": 84, "opencode": 74, "qwen": 72,
+    "aider": 70, "openclaw": 60, "generic": 55, "mock": 10,
+}
+
+MAX_REPAIR_ROUNDS = 2  # 自动修复循环上限
+
+
+def _binding_bonus(agent_id):
+    """绑定链可用性加分/减分：链上有可用条目 +8，解析为空（回落 CLI 本机默认）
+    -25。2026-09-16 实测：静态能力基线让配额烧干的 codex 永远压过健康备用 CLI，
+    绑定空的 CLI 更是连用户配置的模型都没用上——先按「能不能按配置跑起来」校准。"""
+    try:
+        from . import modelhub
+        b = modelhub.resolve_binding(agent_id)
+        return 8.0 if (b and b.get("call_chain")) else -25.0
+    except Exception:
+        return 0.0
+
+
+def _history_bonus(stats, agent_id, ttype):
+    s = (stats.get(agent_id) or {}).get(ttype) or {}
+    if not s.get("runs"):
+        return 0.0
+    win_rate = s["wins"] / s["runs"]
+    return round(18.0 * win_rate + min(6.0, s["runs"]), 1)  # 胜率为主，经验为辅
+
+
+def score(agent, role, ttype, stats=None):
+    """返回 (总分, 理由字符串)。配额惩罚：catalog 里配了
+    quota_tokens_per_hour 的智能体，本小时用量越接近配额分越低
+    （封顶 -45，足以盖过历史加分），满额后仅在没有其他选择时才会被选中。"""
+    stats = stats or {}
+    base = CAPABILITY.get(agent.get("kind"), 60)
+    bb = _binding_bonus(agent.get("id"))
+    btxt = ""
+    if bb > 0:
+        btxt = "，绑定链可用（+%s）" % bb
+    elif bb < 0:
+        btxt = "，绑定链为空将回落 CLI 本机默认配置（%s）" % bb
+    hb = _history_bonus(stats, agent.get("id"), ttype)
+    total = base + bb + hb
+    hs = (stats.get(agent.get("id")) or {}).get(ttype)
+    htxt = ("，历史 %d/%d 胜（+%s）" % (hs["wins"], hs["runs"], hb)) if hs else "，无历史记录"
+    quota_txt = ""
+    quota = int(agent.get("quota_tokens_per_hour") or 0)
+    if quota > 0:
+        try:
+            from . import usage
+            used = usage.agent_tokens_recent(agent.get("id"), hours=1)
+        except Exception:
+            used = 0
+        if used > 0:
+            ratio = min(1.0, used / float(quota))
+            penalty = round(-45.0 * ratio, 1)
+            if penalty:
+                total += penalty
+                quota_txt = "，本小时 %d/%d tokens（%s）" % (used, quota, penalty)
+    return total, "能力基线 %d%s%s%s，总分 %s" % (base, btxt, htxt, quota_txt, round(total, 1))
+
+
+def pick(agents, role, ttype, stats=None, exclude=()):
+    """按分选出最优智能体。返回 (agent, 理由) 或 (None, "")。"""
+    stats = stats or history.agent_stats()
+    best, best_reason = None, ""
+    for a in agents:
+        if a["id"] in exclude:
+            continue
+        total, reason = score(a, role, ttype, stats)
+        if best is None or total > best[0]:
+            best, best_reason = (total, a), reason
+    if best is None:
+        return None, ""
+    return best[1], best_reason
+
+
+def pick_reviewer(agents, impl, ttype, stats=None):
+    """评审者：跨厂商是硬规则（Codeband 的对抗式配对）——同族评审有同款盲区，
+    评审者必须来自与实现者不同的 kind；跨族池为空才回退同厂商并如实备注，
+    绝不把回退伪装成跨厂商。"""
+    stats = stats or history.agent_stats()
+    impl_kind = impl.get("kind")
+    real = [a for a in agents if a.get("mode") == "real" and a["id"] != impl["id"]]
+    cross = [a for a in real if a.get("kind") != impl_kind]
+    if cross:
+        best = max(cross, key=lambda a: score(a, "review", ttype, stats)[0])
+        _, reason = score(best, "review", ttype, stats)
+        return best, "跨厂商评审（%s ≠ %s）：%s" % (best.get("kind"), impl_kind, reason)
+    if real:
+        best = max(real, key=lambda a: score(a, "review", ttype, stats)[0])
+        _, reason = score(best, "review", ttype, stats)
+        return best, ("（无跨厂商智能体可用，回退同厂商 %s 评审——建议启用其他厂商的 CLI）"
+                      % impl_kind) + reason
+    mb = next((a for a in agents if a["id"] == "mock-b"), None)
+    if mb and impl.get("mode") != "mock":
+        return mb, "（无第二个真实智能体，用 mock 评审）"
+    return impl, "（自评：仅有实现者一个智能体可用）"
+
+
+def pick_critics(agents, ttype, stats=None, impl=None):
+    """小说评审组：全部真实智能体（排除作者本人——自评是最典型的同族盲区）；
+    面板与作者同厂商时在路由依据里明示，供用户决定是否补充其他厂商。
+    没有任何真实智能体时用内置 mock。"""
+    stats = stats or history.agent_stats()
+    real = [a for a in agents if a.get("mode") == "real" and (not impl or a["id"] != impl["id"])]
+    if real:
+        note = "全部真实智能体参与（按历史表现自动选择）"
+        if impl and impl.get("mode") == "real" \
+                and all(a.get("kind") == impl.get("kind") for a in real):
+            note += "；评审组与作者同为 %s，建议启用其他厂商 CLI 交叉评审" % impl.get("kind")
+        return real, note
+    mocks = [a for a in agents if a.get("mode") == "mock"] or agents[:2]
+    return mocks, "（无真实智能体，用内置 mock 演示）"