codebee 0.1.6 → 0.1.8

package/app/core/jobs.py

@@ -24,8 +24,8 @@ _seq = 0
 AI_REPAIR_PROMPT = """你是环境工程师。在 Windows 上执行下面的安装命令失败了，请诊断原因并给出修正命令。
 只输出一个 ```json 代码块，不要输出其他内容。JSON 结构：
 {"diagnosis": "失败原因（一句话）", "command": "修正后的完整安装命令", "safe": true/false}
-硬性约束：command 只能是本机包管理器的安装命令，前缀必须是 npm install / winget install /
-py -3.13 -m pip install 之一。给不出符合约束的安全命令时，safe 设为 false 且 command 留空。
+硬性约束：command 只能是本机包管理器的安装命令，前缀必须是 __ALLOW__ 之一。
+给不出符合约束的安全命令时，safe 设为 false 且 command 留空。
 
 ## 失败的命令
 __CMD__
@@ -36,8 +36,10 @@ __LOG__
 ## 本机环境
 __ENV__"""
 
-# AI 修复命令白名单：只放行包管理器的安装类命令
-AI_REPAIR_ALLOW = ("npm install ", "winget install", "py -3.13 -m pip install")
+# AI 修复命令白名单：只放行包管理器的安装类命令（提示词里的前缀清单由它生成，
+# 两处永远不会漂移）
+AI_REPAIR_ALLOW = ("npm install ", "winget install", "py -3.13 -m pip install",
+                   "uv tool install")
 
 
 def _repair_command_allowed(cmd):
@@ -139,6 +141,20 @@ AUTO_RESUME_DELAY_S = 300  # 自动续跑延迟入队秒数：网关限流/欠
                            # 立即重排会撞在同一堵墙上把续跑次数烧光（2026-09-17 七猫实测）
 
 
+def _task_active_run(task_id, exclude_run_id=None):
+    """该任务当前 queued/running 的运行（同任务单飞守卫用）；无则 None。"""
+    try:
+        from . import store
+        for r in store.task_runs(task_id):
+            if r.get("id") == exclude_run_id:
+                continue
+            if r.get("status") in ("queued", "running"):
+                return r
+    except Exception:
+        pass
+    return None
+
+
 def _maybe_auto_resume(run_id):
     """连载任务失败自动续跑：继承已完成章继续，最多 AUTO_RESUME_MAX 次。
 
@@ -157,11 +173,19 @@ def _maybe_auto_resume(run_id):
             return False   # 用户主动取消的运行绝不自动续跑
         if int(run.get("auto_resumes") or 0) >= AUTO_RESUME_MAX:
             return False
+        if _task_active_run(task["id"], exclude_run_id=run_id):
+            return False   # 同任务已有运行排队/在跑：再排副本只会与之撞车
         ok, err, new_run = store.retry_task(task["id"])
         if not ok or not new_run:
             return False
+        # 退避窗口要让用户看得见：把「预定入队时刻」写到 run 上，前端据此显示
+        # 「将在 HH:MM 自动续跑」而不是笼统的排队中（run 在建好到入队之间会
+        # 以 queued 状态干等 AUTO_RESUME_DELAY_S 秒）。
+        import time as _t
+        resume_at = _t.strftime("%Y-%m-%d %H:%M:%S",
+                                _t.localtime(_t.time() + AUTO_RESUME_DELAY_S))
         store.update_run(new_run["id"], auto_resumes=int(run.get("auto_resumes") or 0) + 1,
-                         auto_resumed_from=run_id)
+                         auto_resumed_from=run_id, resume_enqueue_at=resume_at)
 
         def _enqueue():
             _QUEUE.put({"kind": "orchestration",
@@ -238,6 +262,54 @@ def resume_interrupted(limit=3):
     return n
 
 
+def _yield_duplicate(run_id):
+    """同任务单飞（worker 出队时把关）：系统续跑副本出队时若同任务已有
+    运行排队/在跑，取消自己让位——恢复副本与原轮并行跑只会双烧评审。
+    用户轮不在此拦（retry_task 建轮时已拒运行中任务）。返回 True 表示
+    本运行已落 cancelled，不要执行。"""
+    try:
+        from . import store
+        r0 = store.get_run(run_id)
+        if not r0 or not r0.get("auto_resumed_from"):
+            return False
+        other = _task_active_run(r0.get("task_id"), exclude_run_id=run_id)
+        if not other or other.get("kind") != "orchestration":
+            return False
+        store.update_run(run_id, status="cancelled", ended_at=_now(),
+                         error="同任务已有运行在跑（%s），续跑副本自动让位" % other.get("id"))
+        return True
+    except Exception:
+        return False
+
+
+def requeue_pending(limit=10):
+    """启动补队：队列在内存里，进程一死排队项就没人管了（2026-09-18
+    七猫 r-162724 排队僵尸案：续跑副本 created 后服务重启，Timer 随进程
+    蒸发，运行永远停在「排队中」）。重启后把近 24h 的遗留 queued 编排运行
+    重新入队；同任务已有在跑/排队的不重复补。返回补队条数。"""
+    try:
+        from . import store
+    except Exception:
+        return 0
+    n = 0
+    try:
+        for run in store.list_runs(200):
+            if n >= limit:
+                break
+            if run.get("status") != "queued" or run.get("kind") != "orchestration":
+                continue
+            if not run.get("task_id") or not _recent(run):
+                continue
+            if _task_active_run(run["task_id"], exclude_run_id=run["id"]):
+                continue   # 同任务已有更活跃的运行，别再排一份
+            _QUEUE.put({"kind": "orchestration", "run_id": run["id"],
+                        "task_id": run["task_id"]})
+            n += 1
+    except Exception:
+        pass
+    return n
+
+
 def _worker():
     global _alive
     with _pool_lock:
@@ -262,6 +334,8 @@ def _worker():
                     r0 = store.get_run(run_id)
                     if r0 and r0.get("status") == "cancelled":
                         continue   # task_done 由 finally 统一收口，不能在此重复
+                    if job.get("kind") == "orchestration" and _yield_duplicate(run_id):
+                        continue   # 同任务单飞：续跑副本让位（已落 cancelled）
                 if job.get("kind") == "orchestration":
                     from . import pipeline
                     pipeline.execute_run(run_id)
@@ -314,12 +388,21 @@ def _do_mgmt(job, ev):
     if op in ("install", "upgrade", "uninstall"):
         res = manager.run_mgmt_command(entry, op, cancel_event=ev, log_path=str(log_abs))
         ok = res["ok"]
+        # 文件占用类失败（Windows 文件锁 EBUSY/EPERM）给人话结论并跳过 AI 修复：
+        # 修复智能体面对文件锁只会给出 taskkill 全杀 node 之类白名单必拒的危险
+        # 命令，白白烧一轮 300s 诊断（2026-09-18 dsh 同版本重装 EBUSY 案）
+        lock_hit = (not ok and op in ("install", "upgrade") and _file_lock_error(res))
+        if lock_hit:
+            summary = ("失败：安装文件被占用（可能有同名程序在运行，或杀毒软件正在扫描），"
+                       "请关闭占用该文件的程序后重试。完整输出见日志。")
+        else:
+            summary = ("完成" if ok else "失败") + (": " + res["error"][:300] if res.get("error") else "")
         store.finish_step(run_id, step["n"],
                           "done" if ok else "failed",
-                          summary=("完成" if ok else "失败") + (": " + res["error"][:300] if res.get("error") else ""),
+                          summary=summary,
                           exit_code=res.get("exit_code"))
         # AI 修复只针对安装类失败；卸载失败多为权限/程序占用，留给用户看日志处理
-        if not ok and op in ("install", "upgrade"):
+        if not ok and op in ("install", "upgrade") and not lock_hit:
             ok = _ai_repair(run_id, entry, ev, entry.get(op), log_abs)
     elif op == "smoke":
         from . import runner as _r
@@ -383,6 +466,12 @@ def _do_selfupgrade(job):
                      summary="CodeBee selfupgrade %s" % ("完成" if res["ok"] else "失败"))
 
 
+def _file_lock_error(res):
+    """安装/升级失败输出是否为文件占用类错误（npm/pip 的 EBUSY/EPERM 文件锁）。"""
+    err = (res or {}).get("error") or ""
+    return "EBUSY" in err or "EPERM" in err
+
+
 def _ai_repair(run_id, entry, ev, failed_cmd, orig_log):
     """安装失败后的 AI 诊断修复：诊断 → 白名单校验 → 执行 → 复检。"""
     from . import catalog, manager, registry, router, runner, store
@@ -405,7 +494,8 @@ def _ai_repair(run_id, entry, ev, failed_cmd, orig_log):
     ]
     prompt = (AI_REPAIR_PROMPT.replace("__CMD__", failed_cmd or "（未知）")
               .replace("__LOG__", log_tail)
-              .replace("__ENV__", "\n".join(env_lines)))
+              .replace("__ENV__", "\n".join(env_lines))
+              .replace("__ALLOW__", " / ".join(p.strip() for p in AI_REPAIR_ALLOW)))
     step, log_abs = store.add_step(run_id, "ai-repair", agent["id"], agent.get("label"),
                                    note="自动诊断修复")
     res = runner.run_agent(agent, prompt, readonly=True, timeout=300,
@@ -430,7 +520,9 @@ def _ai_repair(run_id, entry, ev, failed_cmd, orig_log):
     cmd = str((data or {}).get("command") or "").strip()
     safe = bool((data or {}).get("safe")) and _repair_command_allowed(cmd)
     try:
-        log_abs.write_text(
+        # write_bytes 而非 write_text(...encode())：bytes 传入文本模式 write 会
+        # TypeError 且被下面的裸 except 吞掉，诊断三行从未落过日志（2026-09-18 修）
+        log_abs.write_bytes(
             ("\n[AI 诊断] %s\n[AI 建议] %s\n[白名单] %s\n" %
              (diagnosis, cmd or "（无）", "通过" if safe else "不通过，拒绝自动执行")).encode("utf-8"))
     except Exception:
@@ -445,6 +537,9 @@ def _ai_repair(run_id, entry, ev, failed_cmd, orig_log):
     manager.detect_all(force=True)
     with manager._LOCK:
         manager._STATE["versions"].pop(entry["id"], None)
+    if fix["ok"]:
+        # 修复安装同样会改变版本结论，徽章缓存一并作废复检
+        manager.refresh_update_async(entry)
     installed = manager.detect_entry(entry)["installed"]
     store.finish_step(run_id, step["n"],
                       "done" if (fix["ok"] and installed) else "failed",

package/app/core/manager.py

@@ -9,7 +9,9 @@ from __future__ import annotations
 import json
 import os
 import re
+import shlex
 import shutil
+import signal
 import socket
 import subprocess
 import sys
@@ -21,7 +23,8 @@ from pathlib import Path
 
 from . import catalog, paths, runner
 
-CREATE_NO_WINDOW = 0x08000000
+# 非 Windows 置 0：POSIX 的 Popen 对非零 creationflags 抛 ValueError（runner 同款守卫）
+CREATE_NO_WINDOW = 0x08000000 if os.name == "nt" else 0
 VERSION_TTL = 300  # 版本缓存 5 分钟
 
 _LOCK = threading.RLock()
@@ -69,6 +72,43 @@ def detect_entry(entry):
     return {"installed": False, "detail": ""}
 
 
+def _orphan_signature(cl):
+    """「Tutti 专属调用签名」判定（两个平台的清扫共用）。"""
+    return (("opencode" in cl and "--model" in cl)
+            or ("codex" in cl and "--skip-git-repo-check" in cl)
+            or ("kimi-code" in cl and "main.mjs" in cl))
+
+
+def _sweep_orphans_posix():
+    """POSIX 版清扫：ps 一次拉全量，签名同 Windows。孤儿判据不同——POSIX 的
+    孤儿进程会被内核过继给 1 号进程（launchd/init），Windows 则保留死掉的
+    ppid，所以这里认 ppid==1；用户手动在终端里跑的同名 CLI 父进程是活着的
+    shell（ppid!=1），不会被误杀。"""
+    try:
+        r = subprocess.run(["ps", "-eo", "pid=,ppid=,command="],
+                           capture_output=True, timeout=60)
+        killed = 0
+        for ln in r.stdout.decode("utf-8", "replace").splitlines():
+            parts = ln.strip().split(None, 2)
+            if len(parts) != 3 or not parts[0].isdigit() or not parts[1].isdigit():
+                continue
+            pid, ppid, cmd = int(parts[0]), int(parts[1]), parts[2]
+            if pid == 1 or ppid != 1 or not _orphan_signature(cmd.lower()):
+                continue
+            try:
+                os.killpg(pid, signal.SIGKILL)  # 服务 spawn 用了 start_new_session，pgid==pid
+                killed += 1
+            except Exception:
+                try:
+                    os.kill(pid, signal.SIGKILL)
+                    killed += 1
+                except Exception:
+                    pass
+        return killed
+    except Exception:
+        return 0
+
+
 def sweep_orphan_cli_processes():
     """启动清扫：服务重启会孤儿化正在跑的 CLI 孙进程（外部只杀服务 PID，不带
     /T），僵尸 opencode 更会劫持后续会话——opencode 是客户端-服务端架构，新
@@ -81,6 +121,8 @@ def sweep_orphan_cli_processes():
       kimi：命令行含 kimi-code/dist/main.mjs（node 直启路径，2026-09-17 实测
       僵尸 kimi 会占住讯飞网关同钥请求队列，堵死后续所有 kimi 调用）
     claude 不扫（签名与用户手动使用难区分）。返回清扫数量。"""
+    if os.name != "nt":
+        return _sweep_orphans_posix()
     ps_exe = os.path.join(os.environ.get("SystemRoot", r"C:\Windows"),
                           "System32", "WindowsPowerShell", "v1.0", "powershell.exe")
     if not os.path.isfile(ps_exe):
@@ -101,10 +143,7 @@ def sweep_orphan_cli_processes():
         for i in items:
             cl = str(i.get("CommandLine") or "").lower()
             ppid = i.get("ParentProcessId")
-            is_ours = (("opencode" in cl and "--model" in cl)
-                       or ("codex" in cl and "--skip-git-repo-check" in cl)
-                       or ("kimi-code" in cl and "main.mjs" in cl))
-            if not is_ours or ppid in live or not i.get("ProcessId"):
+            if not _orphan_signature(cl) or ppid in live or not i.get("ProcessId"):
                 continue
             try:
                 subprocess.run(["taskkill", "/F", "/T", "/PID", str(i["ProcessId"])],
@@ -168,6 +207,8 @@ def _uwp_version(package_dir):
 
 
 def _exe_version(path):
+    if os.name != "nt":
+        return None  # exe 版本探测是 Windows 专属功能（PowerShell 读 PE 资源）
     try:
         r = subprocess.run(
             ["powershell", "-NoProfile", "-Command",
@@ -191,7 +232,11 @@ def version_of(entry):
     cli = (entry.get("detect") or {}).get("cli")
     if cli and det.get("installed"):
         try:
-            r = subprocess.run(["cmd", "/c", cli, "--version"], capture_output=True,
+            # Windows 下 CLI 可能是 npm .cmd 垫片，须经 cmd /c 才能直接点名跑；
+            # POSIX 没有垫片，符号链接直接跑即可
+            probe = ["cmd", "/c", cli, "--version"] if os.name == "nt" \
+                else [cli, "--version"]
+            r = subprocess.run(probe, capture_output=True,
                                creationflags=CREATE_NO_WINDOW, timeout=20)
             out = (r.stdout or b"").decode("utf-8", "replace").strip()
             if not out:
@@ -1440,9 +1485,13 @@ def launch(entry, open_browser=True):
         spawn_cmd = "%s > %s 2>&1" % (cmd, ('"%s"' % ls) if " " in ls else ls)
         try:
             log_path.parent.mkdir(parents=True, exist_ok=True)
-            subprocess.Popen(["cmd", "/c", spawn_cmd], cwd=str(paths.ROOT), env=env,
+            # 重定向语法 sh 与 cmd 通用，只换解释器；start_new_session 让子服务
+            # 脱离本服务进程组（杀树/退出互不牵连）
+            shell = ["cmd", "/c"] if os.name == "nt" else ["/bin/sh", "-c"]
+            subprocess.Popen(shell + [spawn_cmd], cwd=str(paths.ROOT), env=env,
                              stdin=subprocess.DEVNULL, stdout=subprocess.DEVNULL,
-                             stderr=subprocess.DEVNULL, creationflags=CREATE_NO_WINDOW)
+                             stderr=subprocess.DEVNULL, creationflags=CREATE_NO_WINDOW,
+                             start_new_session=(os.name != "nt"))
         except Exception as e:
             return {"ok": False, "error": "无法启动服务: %r" % e}
         if open_browser:
@@ -1452,8 +1501,25 @@ def launch(entry, open_browser=True):
                 "message": "%s 正在启动，就绪后浏览器会自动打开（%s）%s"
                            % (name, bare, ("；" + extra) if extra else "")}
 
+    if sys.platform == "darwin":
+        # Terminal.app 新开窗口跑交互 TUI；do script 的命令串常驻窗口，等价
+        # Windows 的 cmd /k（CLI 退出后窗口保留，报错不至于一闪而过）。
+        # 两层转义各管各的：shlex.quote 管 shell 层（cd 路径的引号），
+        # 反斜杠/双引号替换管 AppleScript 字符串层。
+        shell_cmd = "cd %s && %s" % (shlex.quote(str(paths.ROOT)), cmd)
+        asc = 'tell application "Terminal" to do script ' + \
+              '"' + shell_cmd.replace("\\", "\\\\").replace('"', '\\"') + '"'
+        try:
+            subprocess.Popen(["osascript", "-e", asc], cwd=str(paths.ROOT), env=env,
+                             stdin=subprocess.DEVNULL, stdout=subprocess.DEVNULL,
+                             stderr=subprocess.DEVNULL)
+        except Exception as e:
+            return {"ok": False, "error": "无法打开终端窗口: %r" % e}
+        return {"ok": True, "kind": "console", "message": "已在新的终端窗口打开 %s%s"
+                % (name, ("（" + extra + "）") if extra else "")}
+
     if sys.platform != "win32":
-        return {"ok": False, "error": "终端窗口拉起暂仅支持 Windows"}
+        return {"ok": False, "error": "终端窗口拉起暂仅支持 Windows/macOS"}
     # start 为目标命令新开一个可见终端窗口；cmd /k 让 CLI 退出后窗口保留，
     # 报错不至于一闪而过。外层 cmd 用 CREATE_NO_WINDOW 隐藏。
     argv = ["cmd", "/c", "start", "CodeBee %s" % name, "/D", str(paths.ROOT),
@@ -1510,10 +1576,31 @@ def run_mgmt_command(entry, op, cancel_event=None, log_path=None):
     detect_all(force=True)
     with _LOCK:
         _STATE["versions"].pop(entry["id"], None)
+    if res["ok"]:
+        # 安装/升级成功即作废该条目的更新检查缓存并后台复检：否则 10 分钟 TTL
+        # 内徽章仍显示「有新版本」，诱导同版本重装（重装易撞 EBUSY 文件锁，
+        # 2026-09-18 dsh 案）。
+        refresh_update_async(entry)
     return {"ok": res["ok"], "exit_code": res["exit_code"], "command": cmd,
             "error": "" if res["ok"] else (res["stderr"][-800:] or "退出码 %s" % res["exit_code"])}
 
 
+def refresh_update_async(entry):
+    """作废单条目的更新检查缓存，并后台立刻复检一次远端最新版本。
+
+    完成的安装/升级调用它，卡片徽章马上脱离旧结论（unknown → 几秒后
+    「已是最新/有新版本」），不用等 10 分钟缓存过期。npm view 在后台线程
+    跑，不阻塞 mgmt 任务收尾。
+    """
+    with _LOCK:
+        _UPDATE_CACHE.pop(entry["id"], None)
+    try:
+        threading.Thread(target=check_update, args=(entry,), kwargs={"force": True},
+                         name="update-recheck-%s" % entry.get("id"), daemon=True).start()
+    except Exception:
+        pass
+
+
 # ---------------------------------------------------------------- 版本检查
 
 _UPDATE_CACHE = {}   # agent_id → (ts, {current, latest, updatable, note})
@@ -1544,7 +1631,10 @@ def check_update(entry, force=False):
     cmd = entry.get("install") or entry.get("upgrade") or ""
     pkg = _npm_pkg_name(cmd)
     if pkg:
-        r = runner.run_process(argv=["cmd", "/c", "npm", "view", pkg, "version"], timeout=90)
+        # Windows 的 npm 是 .cmd 垫片须经 cmd /c；POSIX 直接跑
+        npm_view = ["cmd", "/c", "npm", "view", pkg, "version"] if os.name == "nt" \
+            else ["npm", "view", pkg, "version"]
+        r = runner.run_process(argv=npm_view, timeout=90)
         latest = ""
         if r["ok"]:
             for line in (r["stdout"] or "").splitlines():
@@ -1558,7 +1648,7 @@ def check_update(entry, force=False):
             result["updatable"] = bool(_ver_tuple(latest) > _ver_tuple(cur_num))
             if not result["updatable"]:
                 result["note"] = "已是最新版本"
-    elif "winget" in cmd:
+    elif os.name == "nt" and "winget" in cmd:
         m = re.search(r"--id\s+([A-Za-z0-9._-]+)", cmd)
         wid = m.group(1) if m else None
         if not wid: