claude-nb 0.3.0 → 0.4.0

package/lib/board_db.py

@@ -1,4 +1,4 @@
-"""board_db — DB connection, helpers, and .md file sync."""
+"""board_db — DB connection and helpers."""
 
 from __future__ import annotations
 
@@ -25,7 +25,7 @@ class BoardDB(BaseDB):
     """Unified SQLite wrapper — new connection per call, no pooling.
 
     Accepts either a ClaudesEnv (production) or a bare Path/str (tests, lightweight callers).
-    Adds .md file sync helpers on top of the BaseDB interface.
+    SQLite is the single source of truth; no .md file sync.
     """
 
     def __init__(self, env_or_path: ClaudesEnv | Path | str):
@@ -111,145 +111,24 @@ class BoardDB(BaseDB):
         if existing == 0:
             self.execute("INSERT INTO sessions(name) VALUES (?)", (n,), c=c)
 
-    # --- .md file sync ---
-    #
-    # All writes use temp-file + atomic rename to avoid corruption on
-    # crash mid-write.  Section detection is strict: ## heading must be
-    # followed by space or end-of-line (not e.g. "## @收件箱-extra").
-
-    INBOX_HEADINGS: tuple[str, ...] = ("## @inbox", "## @收件箱")
-    TASK_HEADINGS: tuple[str, ...] = ("## Current task", "## 当前任务")
-
-    @staticmethod
-    def _replace_section(
-        text: str,
-        headings: tuple[str, ...],
-        replacement: str | None,
-    ) -> str | None:
-        """Replace or remove the content of a named Markdown section.
-
-        If *replacement* is None, the section is removed.  Returns the new
-        text, or None if the section was not found and no append is needed.
-
-        Heading detection: a line is a section boundary if it starts with "## "
-        (after stripping leading whitespace). Target headings are matched
-        case-insensitively against the normalized prefix.
-        """
-        lines = text.split("\n")
-        out: list[str] = []
-        in_section = False
-        found = False
-
-        normalized_headings = tuple(h.strip().lower() for h in headings)
-
-        for line in lines:
-            stripped = line.strip().lower()
-            if any(stripped == h or stripped.startswith(h + " ") for h in normalized_headings):
-                found = True
-                in_section = True
-                if replacement is not None:
-                    out.append(line)
-                    out.append(replacement)
-                continue
-            if in_section and stripped.startswith("## "):
-                in_section = False
-                out.append("")
-                out.append(line)
-                continue
-            if in_section:
-                continue
-            out.append(line)
-
-        if not found:
-            return None
-        return "\n".join(out)
-
-    def _atomic_write(self, path: Path, content: str) -> None:
-        """Write *content* to *path* atomically (temp + rename)."""
-        tmp = path.with_suffix(path.suffix + ".tmp")
-        try:
-            tmp.write_text(content)
-            tmp.replace(path)
-        except OSError:
-            pass
-
-    # ── inbox sync ──
-
-    def sync_inbox_to_file(self, target: str, *, c: sqlite3.Connection | None = None) -> None:
-        """Sync unread inbox messages to {target}.md file.
-
-        Accepts an optional *c* to use the caller's connection (so that
-        uncommitted inbox rows are visible within a transaction).
-        """
-        if not self.env:
-            return
-        sf = self.env.sessions_dir / f"{target}.md"
-        if not sf.exists():
-            return
-        rows = self.query(
-            "SELECT '- [' || m.ts || '] **' || m.sender || '**: ' || substr(m.body, 1, 60) "
-            "FROM inbox i JOIN messages m ON i.message_id=m.id "
-            "WHERE i.session=? AND i.read=0 ORDER BY m.ts",
-            (target,),
-            c=c,
-        )
-        inbox_lines = "\n".join(r[0] for r in rows) if rows else ""
-
-        try:
-            text = sf.read_text()
-        except OSError:
-            return
-
-        result = self._replace_section(text, self.INBOX_HEADINGS, inbox_lines or None)
-        if result is not None:
-            self._atomic_write(sf, result)
-        elif inbox_lines:
-            heading = self.INBOX_HEADINGS[1]  # canonical: Chinese heading
-            self._atomic_write(sf, text.rstrip("\n") + f"\n\n{heading}\n{inbox_lines}\n")
-
-    def clear_inbox_file(self, target: str) -> None:
-        if not self.env:
-            return
-        sf = self.env.sessions_dir / f"{target}.md"
-        if not sf.exists():
-            return
-        try:
-            text = sf.read_text()
-        except OSError:
-            return
-        result = self._replace_section(text, self.INBOX_HEADINGS, None)
-        if result is not None:
-            self._atomic_write(sf, result)
-
-    # ── status sync ──
-
-    def sync_status_to_file(self, target: str, status: str) -> None:
-        if not self.env:
-            return
-        sf = self.env.sessions_dir / f"{target}.md"
-        if not sf.exists():
-            return
-        try:
-            text = sf.read_text()
-        except OSError:
-            return
-        result = self._replace_section(text, self.TASK_HEADINGS, status)
-        if result is not None:
-            self._atomic_write(sf, result)
-
     def deliver_to_inbox(
         self, sender: str, recipient: str, msg_id: int, *, c: sqlite3.Connection | None = None
     ) -> None:
         if recipient == "all":
-            sessions = self.query("SELECT name FROM sessions WHERE name != ?", (sender,), c=c)
-            for (target,) in sessions:
-                self.execute(
-                    "INSERT INTO inbox(session, message_id) VALUES (?, ?)",
-                    (target, msg_id),
-                    c=c,
+
+            def _do(conn: sqlite3.Connection) -> list[str]:
+                conn.execute(
+                    "INSERT INTO inbox(session, message_id) SELECT name, ? FROM sessions WHERE name != ?",
+                    (msg_id, sender),
                 )
-            for (target,) in sessions:
-                self.sync_inbox_to_file(target, c=c)
+                return [r[0] for r in conn.execute("SELECT name FROM sessions WHERE name != ?", (sender,)).fetchall()]
+
+            if c is not None:
+                targets = _do(c)
+            else:
+                with self.conn() as conn:
+                    targets = _do(conn)
+            for target in targets:
                 inbox_delivered.emit(target)
         else:
             self.ensure_session(recipient, c=c)
@@ -258,5 +137,4 @@ class BoardDB(BaseDB):
                 (recipient, msg_id),
                 c=c,
             )
-            self.sync_inbox_to_file(recipient, c=c)
             inbox_delivered.emit(recipient)

package/lib/board_lock.py

@@ -72,7 +72,6 @@ def cmd_git_unlock(db: BoardDB, identity: str, args: list[str]) -> None:
             (now, holder, f"[GIT-LOCK] {name} force-released your git lock"),
         )
         db.execute("INSERT INTO inbox(session, message_id) VALUES (?, ?)", (holder, msg_id))
-        db.sync_inbox_to_file(holder)
 
     db.execute("DELETE FROM git_locks WHERE id=1")
     print("OK git-lock released")

package/lib/board_mailbox.py

@@ -1,8 +1,11 @@
 """board_mailbox — encrypted async messaging between registered agents."""
 
+import base64
 import json
 from pathlib import Path
 
+from cryptography.exceptions import InvalidTag
+
 from lib.board_db import BoardDB, ts
 from lib.crypto import (
     generate_keypair,
@@ -66,7 +69,11 @@ def cmd_seal(db: BoardDB, identity: str, args: list[str]) -> None:
         raise SystemExit(1)
 
     recipient = args[0].lower()
-    plaintext = " ".join(args[1:])
+    plaintext = " ".join(args[1:]).strip()
+
+    if not plaintext:
+        print("ERROR: 消息不能为空")
+        raise SystemExit(1)
 
     recipient_pubkey_hex = _find_pubkey(recipient)
     if not recipient_pubkey_hex:
@@ -110,12 +117,13 @@ def cmd_unseal(db: BoardDB, identity: str) -> None:
             plaintext = unseal_b64(encrypted_body, private)
             print(f"  [{msg_ts}] **{sender}**: {plaintext}")
             decrypted_ids.append(msg_id)
-        except Exception:
-            print(f"  [{msg_ts}] **{sender}**: [解密失败 — 密钥不匹配或消息损坏]")
+        except (InvalidTag, ValueError, base64.binascii.Error, UnicodeDecodeError) as e:
+            print(f"  [{msg_ts}] **{sender}**: [解密失败 — {type(e).__name__}: {e}]")
 
     if decrypted_ids:
-        placeholders = ",".join("?" * len(decrypted_ids))
-        db.execute(f"UPDATE mailbox SET read=1 WHERE id IN ({placeholders})", tuple(decrypted_ids))
+        with db.conn() as c:
+            for mid in decrypted_ids:
+                db.execute("UPDATE mailbox SET read=1 WHERE id=?", (mid,), c=c)
         print(f"\n已标记 {len(decrypted_ids)} 条为已读")
 
 
@@ -141,5 +149,5 @@ def cmd_mailbox_log(db: BoardDB, identity: str) -> None:
         try:
             plaintext = unseal_b64(encrypted_body, private)
             print(f"  [{msg_ts}] {sender}: {plaintext}")
-        except Exception:
-            print(f"  [{msg_ts}] {sender}: [无法解密]")
+        except (InvalidTag, ValueError, base64.binascii.Error, UnicodeDecodeError) as e:
+            print(f"  [{msg_ts}] {sender}: [无法解密 — {type(e).__name__}: {e}]")

package/lib/board_maintenance.py

@@ -1,6 +1,5 @@
 """board_maintenance — data maintenance: prune, backup, restore."""
 
-import shutil
 import time
 from pathlib import Path
 
@@ -14,9 +13,9 @@ from lib.board_db import BoardDB
 def cmd_prune(db: BoardDB, args: list[str]) -> None:
     """Prune old messages and inbox entries.
 
-    Usage: board --as <name> prune [--before YYYY-MM-DD] [--keep N] [--dry-run]
+    Usage: board --as <name> prune [--before YYYY-MM-DD] [--dry-run]
     """
-    usage = "Usage: board --as <name> prune [--before YYYY-MM-DD] [--keep N] [--dry-run]"
+    usage = "Usage: board --as <name> prune [--before YYYY-MM-DD] [--dry-run]"
 
     before_days = 90  # default: keep 90 days
     dry_run = False
@@ -27,13 +26,6 @@ def cmd_prune(db: BoardDB, args: list[str]) -> None:
         if args[i] == "--before" and i + 1 < len(args):
             before_days = _parse_days(args[i + 1])
             i += 2
-        elif args[i] == "--keep" and i + 1 < len(args):
-            try:
-                int(args[i + 1])
-            except ValueError:
-                print(f"ERROR: --keep requires a number, got '{args[i + 1]}'")
-                raise SystemExit(1)
-            i += 2
         elif args[i] == "--dry-run":
             dry_run = True
             i += 1
@@ -48,22 +40,29 @@ def cmd_prune(db: BoardDB, args: list[str]) -> None:
     cutoff = _days_ago_ts(before_days)
 
     # Count what would be deleted
-    old_inbox = db.scalar(
-        "SELECT COUNT(*) FROM inbox WHERE message_id IN "
-        "(SELECT id FROM messages WHERE ts < ?)",
-        (cutoff,),
-    ) or 0
-    old_messages = db.scalar(
-        "SELECT COUNT(*) FROM messages WHERE ts < ?",
-        (cutoff,),
-    ) or 0
+    old_inbox = (
+        db.scalar(
+            "SELECT COUNT(*) FROM inbox WHERE message_id IN (SELECT id FROM messages WHERE ts < ?)",
+            (cutoff,),
+        )
+        or 0
+    )
+    old_messages = (
+        db.scalar(
+            "SELECT COUNT(*) FROM messages WHERE ts < ?",
+            (cutoff,),
+        )
+        or 0
+    )
 
     # Also count old read inbox entries (not just those linked to old messages)
-    old_read_inbox = db.scalar(
-        "SELECT COUNT(*) FROM inbox WHERE read=1 AND "
-        "delivered_at < ?",
-        (cutoff,),
-    ) or 0
+    old_read_inbox = (
+        db.scalar(
+            "SELECT COUNT(*) FROM inbox WHERE read=1 AND delivered_at < ?",
+            (cutoff,),
+        )
+        or 0
+    )
 
     if dry_run:
         print("=== DRY RUN: would delete ===")
@@ -204,9 +203,7 @@ def cmd_restore(db: BoardDB, args: list[str]) -> None:
     try:
         conn = sqlite3.connect(str(source))
         conn.execute("PRAGMA integrity_check")
-        tables = conn.execute(
-            "SELECT name FROM sqlite_master WHERE type='table'"
-        ).fetchall()
+        tables = conn.execute("SELECT name FROM sqlite_master WHERE type='table'").fetchall()
         conn.close()
         if not tables:
             print("ERROR: backup file contains no tables")
@@ -229,6 +226,8 @@ def cmd_restore(db: BoardDB, args: list[str]) -> None:
             return
 
     # Atomic restore: copy to temp, rename
+    import shutil
+
     tmp = db.db_path.with_suffix(".db.restore-tmp")
     shutil.copy2(source, tmp)
     tmp.replace(db.db_path)

package/lib/board_msg.py

@@ -2,7 +2,6 @@
 
 import hashlib
 import shutil
-import subprocess
 from pathlib import Path
 
 from lib.board_db import BoardDB, ts
@@ -14,29 +13,6 @@ def _ack_marker_path(db: BoardDB, name: str) -> Path:
     return db.env.sessions_dir / f".{name}.ack_max_id"
 
 
-def _nudge_session(db: BoardDB, recipient: str) -> None:
-    """Inject a fixed prompt into the recipient's tmux session to check inbox.
-
-    Only sends a hardcoded command — never user-controlled content — to avoid
-    shell metacharacter injection via tmux send-keys.
-    """
-    if recipient == "all":
-        sessions = [r[0] for r in db.query("SELECT name FROM sessions WHERE name != 'all'")]
-    else:
-        sessions = [recipient]
-    prefix = db.env.prefix
-    board = db.env.install_home / "bin" / "board"
-    for name in sessions:
-        if not name.isalnum():
-            continue
-        sess = f"{prefix}-{name}"
-        r = subprocess.run(["tmux", "has-session", "-t", sess], capture_output=True)
-        if r.returncode == 0:
-            cmd = f"{board} --as {name} inbox"
-            subprocess.run(["tmux", "send-keys", "-t", sess, "-l", cmd], capture_output=True)
-            subprocess.run(["tmux", "send-keys", "-t", sess, "Enter"], capture_output=True)
-
-
 def cmd_send(db: BoardDB, identity: str, args: list[str]) -> None:
     name = identity.lower()
     flags, send_args = parse_flags(args, value_flags={"attach": ["--attach", "-a"]})
@@ -100,10 +76,6 @@ def cmd_send(db: BoardDB, identity: str, args: list[str]) -> None:
         db.deliver_to_inbox(name, to, msg_id, c=c)
 
     print("OK sent")
-    if attach_ref:
-        print(f"  附件已存储: {stored_path}")
-
-    _nudge_session(db, to)
 
 
 def cmd_status(db: BoardDB, identity: str, args: list[str]) -> None:
@@ -118,8 +90,7 @@ def cmd_status(db: BoardDB, identity: str, args: list[str]) -> None:
         "UPDATE sessions SET status=?, updated_at=? WHERE name=?",
         (full_status, now, name),
     )
-    db.sync_status_to_file(name, full_status)
-    print("OK status updated")
+    print("OK")
 
 
 def cmd_inbox(db: BoardDB, identity: str) -> None:
@@ -129,25 +100,21 @@ def cmd_inbox(db: BoardDB, identity: str) -> None:
         raise SystemExit(1)
     count = db.scalar("SELECT COUNT(*) FROM inbox WHERE session=? AND read=0", (name,))
     if not count:
-        print("收件箱为空")
-    else:
-        print(f"你有 {count} 条未读:")
-        rows = db.query(
-            "SELECT i.message_id, '- [' || m.ts || '] **' || m.sender || '**: ' || m.body "
-            "FROM inbox i JOIN messages m ON i.message_id=m.id "
-            "WHERE i.session=? AND i.read=0 ORDER BY m.ts",
-            (name,),
-        )
-        max_id = 0
-        for msg_id, line in rows:
-            print(line)
-            if msg_id > max_id:
-                max_id = msg_id
-        if max_id > 0:
-            _ack_marker_path(db, name).write_text(str(max_id))
-        print(f"\n(运行 ack 清除: board --as {identity} ack)")
-
-    _task_print_queue_short(db, name)
+        print("(empty)")
+        return
+    rows = db.query(
+        "SELECT i.message_id, m.ts, m.sender, m.body "
+        "FROM inbox i JOIN messages m ON i.message_id=m.id "
+        "WHERE i.session=? AND i.read=0 ORDER BY m.ts",
+        (name,),
+    )
+    max_id = 0
+    for msg_id, msg_ts, sender, body in rows:
+        print(f'<message from="{sender}" ts="{msg_ts}">\n{body}\n</message>')
+        if msg_id > max_id:
+            max_id = msg_id
+    if max_id > 0:
+        _ack_marker_path(db, name).write_text(str(max_id))
 
 
 def cmd_ack(db: BoardDB, identity: str) -> None:
@@ -169,8 +136,7 @@ def cmd_ack(db: BoardDB, identity: str) -> None:
         count = db.scalar("SELECT COUNT(*) FROM inbox WHERE session=? AND read=0", (name,))
 
     if count == 0:
-        print("收件箱已经是空的")
-        db.clear_inbox_file(name)
+        print("OK")
         marker.unlink(missing_ok=True)
         return
 
@@ -182,8 +148,7 @@ def cmd_ack(db: BoardDB, identity: str) -> None:
     else:
         db.execute("UPDATE inbox SET read=1 WHERE session=? AND read=0", (name,))
 
-    print(f"OK {count} 条已清空（完整记录在 messages.log）")
-    db.clear_inbox_file(name)
+    print(f"OK {count}")
     marker.unlink(missing_ok=True)
 
 
@@ -212,19 +177,3 @@ def cmd_log(db: BoardDB, identity: str, args: list[str]) -> None:
         )
     for (line,) in reversed(rows):
         print(line)
-
-
-def _task_print_queue_short(db: BoardDB, target: str) -> None:
-    rows = db.query(
-        "SELECT id, status, priority, description FROM tasks "
-        "WHERE session=? AND status != 'done' "
-        "ORDER BY CASE status WHEN 'active' THEN 0 ELSE 1 END, priority DESC, id ASC",
-        (target,),
-    )
-    print("\n任务队列:")
-    if not rows:
-        print("  (无待办任务)")
-        return
-    for tid, status, priority, desc in rows:
-        marker = "*" if status == "active" else " "
-        print(f"  {marker} #{tid} [{status} p{priority}] {desc}")

package/lib/board_task.py

@@ -5,15 +5,17 @@ from lib.common import is_privileged, is_terminal_task_status, parse_flags
 
 
 def _promote_next(db: BoardDB, target: str) -> None:
-    active = db.scalar("SELECT COUNT(*) FROM tasks WHERE session=? AND status='active'", (target,))
-    if active:
-        return
-    next_id = db.scalar(
-        "SELECT id FROM tasks WHERE session=? AND status='pending' ORDER BY priority DESC, id ASC LIMIT 1",
-        (target,),
-    )
-    if next_id:
-        db.execute("UPDATE tasks SET status='active' WHERE id=?", (next_id,))
+    with db.conn() as c:
+        active = db.scalar("SELECT COUNT(*) FROM tasks WHERE session=? AND status='active'", (target,), c=c)
+        if active:
+            return
+        next_id = db.scalar(
+            "SELECT id FROM tasks WHERE session=? AND status='pending' ORDER BY priority DESC, id ASC LIMIT 1",
+            (target,),
+            c=c,
+        )
+        if next_id:
+            db.execute("UPDATE tasks SET status='active' WHERE id=?", (next_id,), c=c)
 
 
 def _print_queue(db: BoardDB, target: str, include_done: bool = False) -> None:
@@ -77,27 +79,27 @@ def _task_add(db: BoardDB, identity: str, args: list[str]) -> None:
 
     desc = " ".join(desc_parts)
 
-    db.ensure_session(target)
+    with db.conn() as c:
+        db.ensure_session(target, c=c)
 
-    active = db.scalar("SELECT COUNT(*) FROM tasks WHERE session=? AND status='active'", (target,))
-    status = "active" if not active else "pending"
+        active = db.scalar("SELECT COUNT(*) FROM tasks WHERE session=? AND status='active'", (target,), c=c)
+        status = "active" if not active else "pending"
 
-    task_id = db.execute(
-        "INSERT INTO tasks(session, description, status, priority) VALUES (?, ?, ?, ?)",
-        (target, desc, status, priority),
-    )
-    print(f"OK task #{task_id} added to {target} ({status})")
-
-    if target != name:
-        now = ts()
-        msg_id = db.execute(
-            "INSERT INTO messages(ts, sender, recipient, body) VALUES (?, ?, ?, ?)",
-            (now, name, target, f"[TASK #{task_id}] {desc}"),
+        task_id = db.execute(
+            "INSERT INTO tasks(session, description, status, priority) VALUES (?, ?, ?, ?)",
+            (target, desc, status, priority),
+            c=c,
         )
-        db.execute("INSERT INTO inbox(session, message_id) VALUES (?, ?)", (target, msg_id))
-        db.sync_inbox_to_file(target)
-        print(f"OK notified {target}")
-    _print_queue(db, target)
+        print(f"OK #{task_id}")
+
+        if target != name:
+            now = ts()
+            msg_id = db.execute(
+                "INSERT INTO messages(ts, sender, recipient, body) VALUES (?, ?, ?, ?)",
+                (now, name, target, f"[TASK #{task_id}] {desc}"),
+                c=c,
+            )
+            db.execute("INSERT INTO inbox(session, message_id) VALUES (?, ?)", (target, msg_id), c=c)
 
 
 def _task_done(db: BoardDB, identity: str, args: list[str]) -> None:
@@ -116,7 +118,11 @@ def _task_done(db: BoardDB, identity: str, args: list[str]) -> None:
         _print_queue(db, name)
         return
 
-    task_id = int(task_id)
+    try:
+        task_id = int(task_id)
+    except ValueError:
+        print(f"ERROR: 无效的任务 ID: {task_id}")
+        raise SystemExit(1)
     row = db.query_one("SELECT session, status, description FROM tasks WHERE id=?", (task_id,))
     if not row:
         print(f"ERROR: task #{task_id} not found")
@@ -134,18 +140,9 @@ def _task_done(db: BoardDB, identity: str, args: list[str]) -> None:
 
     now = ts()
     db.execute("UPDATE tasks SET status='done', done_at=? WHERE id=?", (now, task_id))
-    print(f"OK task #{task_id} done: {desc}")
+    print(f"OK #{task_id} done")
 
     _promote_next(db, assignee)
-    nxt = db.query_one(
-        "SELECT id, description FROM tasks WHERE session=? AND status='active' ORDER BY id ASC LIMIT 1",
-        (assignee,),
-    )
-    if nxt:
-        print(f"Next: #{nxt[0]} {nxt[1]}")
-    else:
-        print(f"No remaining active/pending tasks for {assignee}.")
-    _print_queue(db, assignee)
 
 
 def _task_list(db: BoardDB, identity: str, args: list[str]) -> None: