opencode-agora 0.1.0__py3-none-any.whl

agorad/access/store.py

@@ -0,0 +1,181 @@
+"""账本唯一磁盘接触点：append-only 账本四原语＋flock 单实例。
+
+布局 $AGORA_HOME：state/tasks.jsonl（全量快照行）、state/messages/<id>.md
+（不可变，头部 key: value 行＋空行＋正文）、events.jsonl（审计）、
+易失件（service.json 等，可覆写非账本）。
+"""
+import fcntl
+import json
+import os
+from pathlib import Path
+
+TAIL_BYTES = 1 << 20  # 启动尾读窗口：load 耗时与账本大小解耦；窗内无完整行回退全扫
+COMPACT_LINES = 500  # 瘦身阈值：行数超限即原子重写仅留末完整行（flock 单写者、迁移路径时机避开启动），账本有上界
+
+
+class Store:
+    def __init__(self, home: Path):
+        self.home = Path(home)
+        self._tasks = self.home / "state" / "tasks.jsonl"
+        self._events = self.home / "events.jsonl"
+        self._messages = self.home / "state" / "messages"
+        self._lock_path = self.home / "agorad.lock"
+        self._lock_fd = None
+        # 单写者内存计数器；重启扫目录文件名 max+1 恢复
+        self._next_mid = self.scan_max_msg_id() + 1
+        self._task_lines = None  # 懒播种的账本行数（flock 单写者安全）：免每次追加全文件重扫；崩溃漂移只挪瘦身时机
+
+    def append_state(self, snap: dict) -> None:
+        if self._task_lines is None:  # 播种在追加前：计磁盘实有行，此后内存自增不重扫
+            self._task_lines = self._count_lines() if self._tasks.exists() else 0
+        line = json.dumps(snap, ensure_ascii=False)
+        self._append_line(self._tasks, line)  # 先追加后瘦身：崩溃至多留下超限账本，状态不丢
+        self._task_lines += 1
+        if self._task_lines > COMPACT_LINES:
+            try:
+                self._compact(line)
+                self._task_lines = 1
+            except OSError:
+                pass  # 追加已 fsync 持久化，瘦身属维护动作：失败不回滚成功语义，计数器留超阈待下次追加重试
+
+    def load_state(self) -> dict | None:
+        if not self._tasks.exists():
+            return None
+        if self._tasks.stat().st_size > TAIL_BYTES:
+            snap = self._load_tail()
+            if snap is not None:
+                return snap
+            # 尾窗无完整行（巨行/断尾贯穿全窗）→ 回退全文件扫，末行胜出语义不变
+        snap = None
+        with self._tasks.open(encoding="utf-8") as f:
+            for line in f:
+                try:
+                    snap = json.loads(line)  # 断尾行丢弃，取最后完整行
+                except ValueError:
+                    pass
+        return snap
+
+    def _load_tail(self) -> dict | None:
+        with self._tasks.open("rb") as f:
+            f.seek(-TAIL_BYTES, os.SEEK_END)
+            block = f.read()
+        i = block.find(b"\n")  # 跨窗切割的首段残行丢弃，只解析完整行
+        if i == -1:
+            return None
+        snap = None
+        for raw in block[i + 1:].split(b"\n"):
+            try:
+                snap = json.loads(raw)  # 断尾行丢弃，取最后完整行（同全扫口径）
+            except ValueError:
+                pass
+        return snap
+
+    def _count_lines(self) -> int:
+        n = 0
+        with self._tasks.open("rb") as f:
+            for chunk in iter(lambda: f.read(TAIL_BYTES), b""):
+                n += chunk.count(b"\n")
+        return n
+
+    def _compact(self, line: str) -> None:
+        # 刚追加行即末完整行（flock 单写者）；原子重写同 write_ephemeral 口径
+        tmp = self._tasks.with_name(self._tasks.name + ".tmp")
+        with tmp.open("w", encoding="utf-8") as f:
+            f.write(line + "\n")
+            f.flush()
+            os.fsync(f.fileno())
+        os.replace(tmp, self._tasks)
+
+    def append_event(self, ev: dict) -> None:
+        self._append_line(self._events, json.dumps(ev, ensure_ascii=False))
+
+    def write_message(self, fm: dict, body: str) -> int:
+        mid = self._next_mid
+        self._next_mid += 1
+        header = f"id: {mid}\n" + "".join(
+            f"{k}: {fm[k]}\n" for k in sorted(fm)
+        )
+        path = self._messages / f"{mid:08d}.md"  # 补零保证文件名字典序＝msg-id 数值序
+        path.parent.mkdir(parents=True, exist_ok=True)
+        with path.open("x", encoding="utf-8") as f:  # "x"＝已存在即拒，id 不可变
+            f.write(f"{header}\n{body}")
+            f.flush()
+            os.fsync(f.fileno())
+        return mid
+
+    def scan_max_msg_id(self) -> int:
+        if not self._messages.exists():
+            return 0
+        return max((int(p.stem) for p in self._messages.glob("*.md")), default=0)
+
+    def read_messages(self) -> list[dict]:
+        """全库消息按 msg-id 升序（补零文件名序＝id 序）；frontmatter 键＋id(int)＋body。
+
+        门中崩溃撕裂件（坏头/断尾/空文件）跳过——同 load_state 断尾容错口径。
+        """
+        out = []
+        for p in sorted(self._messages.glob("*.md")):
+            try:
+                head, _, body = p.read_text(encoding="utf-8").partition("\n\n")
+                fm = dict(line.split(": ", 1) for line in head.splitlines())
+                fm["id"] = int(fm["id"])
+                fm["body"] = body
+            except (ValueError, KeyError, OSError):
+                continue
+            out.append(fm)
+        return out
+
+    def read_events(self, tid=None) -> list[dict]:
+        """events.jsonl 全量（tid 给定则按 task 过滤）按行序；断尾行丢弃同 load_state。"""
+        out = []
+        if not self._events.exists():
+            return out
+        with self._events.open(encoding="utf-8") as f:
+            for line in f:
+                try:
+                    ev = json.loads(line)
+                except ValueError:
+                    continue
+                if tid is None or ev.get("task") == tid:
+                    out.append(ev)
+        return out
+
+    def write_ephemeral(self, name: str, data: dict) -> None:
+        path = self.home / name
+        path.parent.mkdir(parents=True, exist_ok=True)
+        tmp = path.with_name(path.name + ".tmp")
+        with tmp.open("w", encoding="utf-8") as f:
+            f.write(json.dumps(data, ensure_ascii=False) + "\n")
+            f.flush()
+            os.fsync(f.fileno())
+        os.replace(tmp, path)  # 原子覆写：读者（lift 解析 service.json）不见半写
+
+    def read_ephemeral(self, name: str) -> dict | None:
+        path = self.home / name
+        if not path.exists():
+            return None
+        try:
+            return json.loads(path.read_text(encoding="utf-8"))
+        except ValueError:
+            return None  # 断尾/损坏件视为缺席，同 load_state 容错口径
+
+    def flock_singleton(self) -> bool:
+        if self._lock_fd is not None:
+            return True
+        self.home.mkdir(parents=True, exist_ok=True)
+        fd = os.open(self._lock_path, os.O_RDWR | os.O_CREAT, 0o644)
+        try:
+            fcntl.flock(fd, fcntl.LOCK_EX | fcntl.LOCK_NB)
+        except OSError:
+            os.close(fd)
+            return False
+        self._lock_fd = fd  # 持有至进程退出，关闭即释放
+        return True
+
+    @staticmethod
+    def _append_line(path: Path, line: str) -> None:
+        path.parent.mkdir(parents=True, exist_ok=True)
+        with path.open("a", encoding="utf-8") as f:
+            f.write(line + "\n")
+            f.flush()
+            os.fsync(f.fileno())

agorad/core/__init__.py

@@ -0,0 +1 @@
+"""agorad 域核心：纯逻辑，只 import stdlib；访问层对象一律构造注入。"""

agorad/core/app.py

@@ -0,0 +1,137 @@
+"""装配容器（R2）：字段即依赖图——main 独占构造，transport 只 import 本模块。"""
+import time
+from dataclasses import dataclass
+
+EV_MAIN_BOUND = "main_sid_bound"
+EV_WORKER_REBOUND = "worker_rebound"
+EV_DISPATCHER_REBOUND = "dispatcher_rebind"
+
+# worker 换号自愈口径活动态（词汇对齐 task._ACTIVE；core 禁兄弟 import 故字面量本地定义）
+_ACTIVE = {"dispatched", "running", "done", "verify_failed", "reopened", "blocked"}
+_NESTED_OPEN = _ACTIVE | {"todo"}  # 已建未派子任务同样保留父 worker 所有权
+
+
+@dataclass
+class App:
+    """聚合根：core 服务＋注入的 access 件＋装配元数据＋换号自愈绑定面（R25-A/gt-d55b9e）。"""
+    store: object
+    state: object
+    auth: object
+    router: object
+    task: object
+    peer: object
+    gate: object
+    health: object
+    recover: object
+    report: object
+    oc: object
+    gitx: object
+    main_sid: str
+
+    def bind_main(self, sid, caller):
+        """R25-A：root 牌调用登记主会话真实 sid（多主会话最近活跃覆盖）。
+
+        sid＝牌当前 sid（占位 "main" 或重启前旧绑定），caller＝X-Agora-Sid 真实
+        会话——改绑牌使后续 task 行 dispatcher 落真实 sid，拍人链边直达真会话；
+        重启后 main_sid 复位与牌不同步亦经此自愈。任务 worker 边会话拒绝绑定：
+        worker 凭据缺失回落 root 牌（B1）＋携 sid 属误附，不得抢主会话绑定。
+        返回对齐后 sid（拒绑＝原 sid）——本笔请求后续归属判定即以新 sid 走。
+        """
+        if caller != sid:
+            if any(t.get("worker_sid") == caller
+                   for t in self.state.snapshot()["tasks"].values()):
+                return sid
+            self.auth.rebind(sid, caller)
+        if self.main_sid != caller:
+            self.main_sid = caller
+            self.store.append_event({"ts": time.time(), "actor": caller,
+                                     "event": EV_MAIN_BOUND})
+        return caller
+
+    def bind_worker(self, sid, caller):
+        """gt-d55b9e：worker 牌换号自愈——持牌即身份，漂移即改绑（镜像 bind_main）。
+
+        sid＝牌注册 sid（dispatch 时落行的 worker_sid），caller＝X-Agora-Sid
+        真实续接会话。注册 sid 是某活动任务 worker_sid 且两者漂移 → rebind
+        （旧 sid 入血统，token 本体不变）＋任务行 worker_sid 同步覆写（与
+        recover.reinject 同口径）。改绑波及 authorship（gt-83185d R2）：worker
+        作为派发方的活动嵌套子任务行 dispatcher_sid 一并覆写为 caller——
+        嵌套任务所有权在换号后保持，不被归属终审 dispatcher_sid==caller 卡死。
+        守卫：终态/无主 sid 一律不动；worker_sid 行与 dispatcher_sid 行分别
+        覆写对应字段不串；已占 caller sid 拒绑（下）原样——worker 改绑只动
+        worker 牌，主会话/他牌不受累。返回改绑后 sid（调用方刷新身份）。
+        """
+        if caller == sid:
+            return sid
+        tasks = self.state.snapshot()["tasks"]
+        # 已占 sid 不抢绑（镜像 bind_main 守卫）：X-Agora-Sid 是自证头，worker 可从
+        # 任务页读到他任务 sid——caller 已是主会话/任一任务 dispatcher/worker 即拒
+        # （防跨任务冒充；真续接 sid 全新必不撞）。
+        if caller == self.main_sid or any(
+                caller in (t.get("worker_sid"), t.get("dispatcher_sid"))
+                for t in tasks.values()):
+            return sid
+        hit = [tid for tid, t in tasks.items()
+               if t.get("worker_sid") == sid and t["state"] in _ACTIVE]
+        if not hit:
+            return sid
+        # 快照后门线程可能已结案：零活动行不改绑（TOCTOU 复检，镜像 bind_dispatcher）
+        if not any(self.state.get(tid)["state"] in _ACTIVE for tid in hit):
+            return sid
+        self.auth.rebind(sid, caller)
+        for tid in hit:
+            if self.state.get(tid)["state"] not in _ACTIVE:
+                continue  # 改绑窗内结案：终态行冻结不覆写（TOCTOU 复检）
+            self.state.set_fields(tid, worker_sid=caller)
+            self.store.append_event({"ts": time.time(), "actor": sid,
+                                     "event": EV_WORKER_REBOUND, "task": tid,
+                                     "from": sid, "to": caller})
+        # R2 波及：嵌套子任务行只覆写 dispatcher_sid 字段（worker_sid 行不串）
+        nested = [tid for tid, t in tasks.items()
+                  if t.get("dispatcher_sid") == sid and t["state"] in _NESTED_OPEN]
+        for tid in nested:
+            if self.state.get(tid)["state"] not in _NESTED_OPEN:
+                continue  # 同上：终态行冻结不覆写（TOCTOU 复检）
+            self.state.set_fields(tid, dispatcher_sid=caller)
+            self.store.append_event({"ts": time.time(), "actor": sid,
+                                     "event": EV_WORKER_REBOUND, "task": tid,
+                                     "from": sid, "to": caller})
+        return caller
+
+    def bind_dispatcher(self, role, sid, t):
+        """F21：dispatcher 侧换号改绑（镜像 bind_worker，补壳重启死号缺口）——
+        root 牌 post 命中「非链边」前判愈合：登记 dispatcher_sid ≠ 调用者且该
+        会话已不存在（oc 存在性检查）→ auth.rebind（旧号入血统）＋活动任务行
+        dispatcher_sid 同步覆写＋dispatcher_rebind 审计（含新旧 sid 与任务），
+        本笔 post 按链边放行。守卫（不满足保持既有拒绝）：非 root 牌、活号
+        （防活号互抢）、任务终态（冻结不动）、oc 不可达≠死（recover 同口径免判）。"""
+        d = t.get("dispatcher_sid")
+        if role != "root" or not d or d == sid:
+            return
+        tasks = self.state.snapshot()["tasks"]
+        hit = [tid for tid, x in tasks.items()
+               if x.get("dispatcher_sid") == d and x["state"] in _ACTIVE]
+        if not hit:
+            return  # 终态不触发改绑
+        # 已占 sid 不抢绑（镜像 bind_worker 防跨任务冒充；真续接号全新必不撞；
+        # main_sid 不在守卫内：root 牌对齐后 sid==main_sid 是常态非冒充）。
+        if any(sid in (x.get("worker_sid"), x.get("dispatcher_sid"))
+               for x in tasks.values()):
+            return
+        try:
+            if self.oc.alive(d):
+                return  # 登记会话仍活不抢绑
+        except Exception:  # oc 不可达≠会话死：本轮免判（recover.startup 同口径）
+            return
+        # 探活窗内可能已全数结案：零活动行不改牌（TOCTOU 复检——rebind 是
+        # 持久身份换绑，无活动行即无消费方，凭陈旧快照换牌＝无谓身份漂移）
+        if not any(self.state.get(tid)["state"] in _ACTIVE for tid in hit):
+            return
+        self.auth.rebind(d, sid)
+        for tid in hit:
+            if self.state.get(tid)["state"] not in _ACTIVE:
+                continue  # 探活窗内门体或已结案：终态行冻结不覆写（TOCTOU 复检）
+            self.state.set_fields(tid, dispatcher_sid=sid)
+            self.store.append_event({"ts": time.time(), "actor": sid,
+                                     "event": EV_DISPATCHER_REBOUND,
+                                     "task": tid, "from": d, "to": sid})

agorad/core/auth.py

@@ -0,0 +1,134 @@
+"""会话牌（token→sid/role）与 enforce 旗标：独立持久化＋角色判定矩阵（设计 §4.9）。
+
+牌不入 tasks 快照行与消息库，经 write_ephemeral("tokens") 独立落盘，kill -9 后
+新实例从盘恢复；enforce 旗标只内存持有、重启默认 on，开/关与拒绝均写审计
+（events.jsonl 经注入 store.append_event）。Store 构造注入，core 只 import stdlib。
+"""
+import secrets
+import time
+
+# worker 可创建并管理自己的嵌套子任务；update/cancel 的他任务隔离由 TaskService 归属终审
+WORKER_TOOLS = {"post", "check_mail", "repo_board", "wiki_read", "wiki_write",
+                "task_create", "task_dispatch", "task_update", "task_cancel"}
+# dispatcher 通用面＝worker 面＋建任务/观测；task_update/task_cancel 为 task 域单列
+DISPATCHER_TOOLS = WORKER_TOOLS | {"task_create", "board", "doctor"}
+
+# 血统封顶（gt-83185d R1）：牌血统最多留最近 16 条曾用名（FIFO 最旧出局），
+# 防持牌调用每次携随机新 X-Agora-Sid 把血统表与落盘无限撑大
+LINEAGE_CAP = 16
+
+# 审计事件名常量
+EV_ENFORCE_ON = "enforce_on"
+EV_ENFORCE_OFF = "enforce_off"
+EV_AUTH_DENIED = "auth_denied"
+EV_ROOT_ROTATED = "root_rotated"
+
+
+class Auth:
+    """每会话一牌：root/dispatcher/worker；多主会话各持 root 牌（角色非单例）。"""
+
+    def __init__(self, store):
+        self._store = store
+        data = store.read_ephemeral("tokens") or {}
+        self._tokens = {t: list(v) for t, v in data.items()}  # token -> [sid, role]
+        self._enforce = True  # 重启默认 on（旗标不落盘）
+
+    def issue(self, sid, role):
+        token = secrets.token_hex()
+        self._tokens[token] = [sid, role, []]
+        self._persist()
+        return token
+
+    @staticmethod
+    def _lineage(v):
+        """牌血统集（F16 曾用名）；旧格式两元组缺字段＝空集。"""
+        return v[2] if len(v) > 2 else []
+
+    def same_lineage(self, current_sid, historical_sid):
+        """F16：current_sid 现持牌的血统集含 historical_sid（换号链边连续）。"""
+        return any(historical_sid in self._lineage(v)
+                   for v in self._tokens.values() if v[0] == current_sid)
+
+    def identify(self, token):
+        v = self._tokens.get(token)
+        return (v[0], v[1]) if v else None
+
+    def rebind(self, old_sid, new_sid):
+        """按 sid 改绑牌到新会话（值 [new_sid, role]，token 本体不变）——
+        重注入后旧牌即续用；old_sid 入血统集随牌落盘（F16 换号链边连续）。
+        返回牌文本（供 inject 送达），无牌 None。"""
+        for tok, v in self._tokens.items():
+            if v[0] == old_sid:
+                v[0] = new_sid
+                if len(v) < 3:  # 旧格式起档
+                    v.append([])
+                if old_sid not in v[2]:
+                    v[2].append(old_sid)
+                del v[2][:-LINEAGE_CAP]  # 封顶：最旧出局
+                self._persist()
+                return tok
+        return None
+
+    def token_for(self, sid):
+        """按 sid 查牌文本（F25 周期重注入只读面，不改绑不轮换）；无牌 None。"""
+        return next((tok for tok, v in self._tokens.items() if v[0] == sid), None)
+
+    def revoke(self, token):
+        if token not in self._tokens:
+            return False
+        del self._tokens[token]
+        self._persist()
+        return True
+
+    def revoke_session(self, sid):
+        """按 sid 作废该会话全部牌（worker 单牌语义；cancel/重派/门尾取消共用）。"""
+        hit = [t for t, v in self._tokens.items() if v[0] == sid]
+        for t in hit:
+            del self._tokens[t]
+        if hit:
+            self._persist()
+        return bool(hit)
+
+    def rotate_root(self):
+        # doctor 一键轮换：全部旧 root 牌即废，新牌沿用最近 root 的 sid；其余角色不受累
+        roots = [t for t, v in self._tokens.items() if v[1] == "root"]
+        sid = self._tokens[roots[-1]][0] if roots else "root"
+        for t in roots:
+            del self._tokens[t]
+        token = self.issue(sid, "root")
+        self._store.append_event({"ts": time.time(), "actor": "root",
+                                  "event": EV_ROOT_ROTATED, "note": f"revoked={len(roots)}"})
+        return token
+
+    def may(self, role, tool, tid, state):
+        """矩阵：root→任意；worker→白名单；dispatcher→通用面＋task 域（须有任务行）。
+
+        state＝目标任务快照行（State.snapshot()["tasks"][tid]），无行即非己任；
+        归属终审（dispatcher_sid==caller sid）由持 actor_token 的 TaskService 负责。
+        """
+        if role == "root":
+            return True
+        if role == "worker":
+            return tool in WORKER_TOOLS
+        if role == "dispatcher":
+            if tool in ("task_update", "task_cancel"):
+                return state is not None
+            return tool in DISPATCHER_TOOLS
+        return False
+
+    def set_enforce(self, on, role):
+        """仅 root 生效；开/关与非 root 拒绝均写 events 审计行。"""
+        if role != "root":
+            self._store.append_event({"ts": time.time(), "actor": role,
+                                      "event": EV_AUTH_DENIED, "note": "enforce"})
+            return False
+        self._enforce = bool(on)
+        self._store.append_event({"ts": time.time(), "actor": role,
+                                  "event": EV_ENFORCE_ON if self._enforce else EV_ENFORCE_OFF})
+        return True
+
+    def enforce_on(self):
+        return self._enforce
+
+    def _persist(self):
+        self._store.write_ephemeral("tokens", self._tokens)