claude-nb 0.3.0

package/lib/concerns/session_keepalive.py

@@ -0,0 +1,23 @@
+"""SessionKeepAlive — detect dead dev sessions."""
+
+from lib.common import is_suspended
+
+from .base import Concern
+from .config import DispatcherConfig
+from .helpers import get_dev_sessions, is_claude_running, log, tmux_ok
+
+
+class SessionKeepAlive(Concern):
+    interval = 5
+
+    def __init__(self, cfg: DispatcherConfig) -> None:
+        super().__init__()
+        self.cfg = cfg
+
+    def tick(self, now: int) -> None:
+        for name in get_dev_sessions(self.cfg):
+            if is_suspended(name, self.cfg.suspended_file):
+                continue
+            sess = f"{self.cfg.prefix}-{name}"
+            if tmux_ok("has-session", "-t", sess) and not is_claude_running(sess):
+                log(f"{name}: agent exited, NOT restarting (idle policy)")

package/lib/concerns/time_announcer.py

@@ -0,0 +1,34 @@
+"""TimeAnnouncer — hourly/daily announcements."""
+
+from .base import Concern
+from .config import DispatcherConfig
+from .helpers import board_send, log
+
+
+class TimeAnnouncer(Concern):
+    interval = 30
+
+    def __init__(self, cfg: DispatcherConfig) -> None:
+        super().__init__()
+        self.cfg = cfg
+        self.last_hour = -1
+
+    def tick(self, now: int) -> None:
+        from datetime import datetime as dt
+
+        d = dt.now()
+        if d.minute != 0 or d.hour == self.last_hour:
+            return
+        self.last_hour = d.hour
+        ts = d.strftime("%Y-%m-%d %H:%M")
+
+        if d.hour == 9:
+            board_send(
+                self.cfg,
+                "All",
+                f"[Clock] {ts} ({d.strftime('%A')}) — 新一天。检查 KR 列表，确认优先级。",
+            )
+            log("Daily announcement sent")
+        else:
+            board_send(self.cfg, "All", f"[Clock] 现在是 {ts}。")
+            log(f"Hourly announcement: {d.hour}:00")

package/lib/crypto.py

@@ -0,0 +1,92 @@
+"""crypto — X25519 sealed-box encryption for inter-agent messaging."""
+
+import base64
+import os
+from pathlib import Path
+
+from cryptography.hazmat.primitives.asymmetric.x25519 import X25519PrivateKey, X25519PublicKey
+from cryptography.hazmat.primitives.ciphers.aead import AESGCM
+from cryptography.hazmat.primitives.hashes import SHA256
+from cryptography.hazmat.primitives.kdf.hkdf import HKDF
+from cryptography.hazmat.primitives.serialization import (
+    Encoding,
+    NoEncryption,
+    PrivateFormat,
+)
+
+_HKDF_INFO = b"claudes-mailbox-v1"
+
+
+def generate_keypair() -> tuple[X25519PrivateKey, X25519PublicKey]:
+    private = X25519PrivateKey.generate()
+    return private, private.public_key()
+
+
+def private_key_to_pem(key: X25519PrivateKey) -> bytes:
+    return key.private_bytes(Encoding.PEM, PrivateFormat.PKCS8, NoEncryption())
+
+
+def private_key_from_pem(data: bytes) -> X25519PrivateKey:
+    from cryptography.hazmat.primitives.serialization import load_pem_private_key
+
+    k = load_pem_private_key(data, password=None)
+    if not isinstance(k, X25519PrivateKey):
+        raise ValueError("not an X25519 private key")
+    return k
+
+
+def public_key_to_hex(key: X25519PublicKey) -> str:
+    return key.public_bytes_raw().hex()
+
+
+def public_key_from_hex(h: str) -> X25519PublicKey:
+    return X25519PublicKey.from_public_bytes(bytes.fromhex(h))
+
+
+def _derive_key(shared_secret: bytes) -> bytes:
+    return HKDF(algorithm=SHA256(), length=32, salt=None, info=_HKDF_INFO).derive(shared_secret)
+
+
+def seal(plaintext: bytes, recipient_pub: X25519PublicKey) -> bytes:
+    """Encrypt with ephemeral X25519 + AESGCM. Returns ephemeral_pub(32) + nonce(12) + ciphertext."""
+    eph_priv, eph_pub = generate_keypair()
+    shared = eph_priv.exchange(recipient_pub)
+    aes_key = _derive_key(shared)
+    nonce = os.urandom(12)
+    ct = AESGCM(aes_key).encrypt(nonce, plaintext, None)
+    return eph_pub.public_bytes_raw() + nonce + ct
+
+
+def unseal(blob: bytes, recipient_priv: X25519PrivateKey) -> bytes:
+    """Decrypt a sealed message. Raises on tamper or wrong key."""
+    if len(blob) < 44:
+        raise ValueError("ciphertext too short")
+    eph_pub_bytes = blob[:32]
+    nonce = blob[32:44]
+    ct = blob[44:]
+    eph_pub = X25519PublicKey.from_public_bytes(eph_pub_bytes)
+    shared = recipient_priv.exchange(eph_pub)
+    aes_key = _derive_key(shared)
+    return AESGCM(aes_key).decrypt(nonce, ct, None)
+
+
+def seal_b64(plaintext: str, recipient_pub: X25519PublicKey) -> str:
+    return base64.b64encode(seal(plaintext.encode(), recipient_pub)).decode()
+
+
+def unseal_b64(encoded: str, recipient_priv: X25519PrivateKey) -> str:
+    return unseal(base64.b64decode(encoded), recipient_priv).decode()
+
+
+def save_keypair(keys_dir: Path, name: str, private: X25519PrivateKey, public: X25519PublicKey) -> None:
+    keys_dir.mkdir(parents=True, exist_ok=True)
+    (keys_dir / f"{name}.pem").write_bytes(private_key_to_pem(private))
+    (keys_dir / f"{name}.pem").chmod(0o600)
+    (keys_dir / f"{name}.pub").write_text(public_key_to_hex(public) + "\n")
+
+
+def load_private_key(keys_dir: Path, name: str) -> X25519PrivateKey:
+    pem_path = keys_dir / f"{name}.pem"
+    if not pem_path.exists():
+        raise FileNotFoundError(f"私钥不存在: {pem_path} (先运行 keygen)")
+    return private_key_from_pem(pem_path.read_bytes())

package/lib/health.py

@@ -0,0 +1,187 @@
+#!/usr/bin/env python3
+"""health.py -- Session health report with colored output.
+
+Shows restart count, idle status, uptime for each session.
+
+Usage:
+    ./lib/health.py
+"""
+
+import re
+import subprocess
+import sys
+import time
+from pathlib import Path
+
+# Try to import common; fall back gracefully for standalone use
+try:
+    from lib.common import ClaudesEnv, date_to_epoch
+except ImportError:
+    # Allow running from project root
+    _here = Path(__file__).resolve().parent.parent
+    sys.path.insert(0, str(_here))
+    from lib.common import ClaudesEnv, date_to_epoch
+
+# ---------------------------------------------------------------------------
+# ANSI colors
+# ---------------------------------------------------------------------------
+
+G = "\033[0;32m"
+R = "\033[0;31m"
+Y = "\033[1;33m"
+D = "\033[2m"
+NC = "\033[0m"
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+
+def _tmux(*args: str) -> str | None:
+    """Run a tmux command, return stdout or None on failure."""
+    try:
+        r = subprocess.run(
+            ["tmux", *args],
+            capture_output=True,
+            text=True,
+            timeout=5,
+        )
+        return r.stdout.strip() if r.returncode == 0 else None
+    except (subprocess.TimeoutExpired, OSError):
+        return None
+
+
+def get_sessions(prefix: str, dispatcher: str = "dispatcher", lead: str = "lead") -> list:
+    """List dev session names from tmux (excludes dispatcher & lead)."""
+    raw = _tmux("list-sessions", "-F", "#{session_name}")
+    if raw is None:
+        return []
+    names = []
+    for line in sorted(raw.splitlines()):
+        if line.startswith(f"{prefix}-"):
+            name = line[len(prefix) + 1 :]
+            if name not in (dispatcher, lead):
+                names.append(name)
+    return names
+
+
+def is_claude_running(sess: str) -> bool:
+    """Check if the pane's current command looks like an active Claude process."""
+    if _tmux("has-session", "-t", sess) is None:
+        return False
+    cmd = _tmux("list-panes", "-t", sess, "-F", "#{pane_current_command}")
+    if cmd is None:
+        return False
+    first = cmd.splitlines()[0] if cmd else ""
+    return first not in ("zsh", "bash", "sh", "-zsh", "-bash", "")
+
+
+def session_status(sess: str, idle_cache: Path) -> str:
+    """Return status string: active, idle, exited, offline."""
+    if _tmux("has-session", "-t", sess) is None:
+        return "offline"
+
+    cmd = _tmux("list-panes", "-t", sess, "-F", "#{pane_current_command}")
+    first = (cmd or "").splitlines()[0] if cmd else ""
+    if first in ("zsh", "bash", "sh", "-zsh", "-bash", ""):
+        return "exited"
+
+    # Check idle cache
+    if idle_cache.exists():
+        for line in idle_cache.read_text().splitlines():
+            if line == f"{sess} idle":
+                return "idle"
+    return "active"
+
+
+# ---------------------------------------------------------------------------
+# Main report
+# ---------------------------------------------------------------------------
+
+
+def print_health_report() -> None:
+    env = ClaudesEnv.load()
+    prefix = env.prefix
+    log_dir = env.project_root / ".swarm-logs"
+    idle_cache = log_dir / "idle-cache"
+    now = int(time.time())
+
+    sessions = get_sessions(prefix)
+
+    print()
+    print("  Session\t\tStatus\t\tRestarts\tUptime\t\tAgent")
+    print("  -------\t\t------\t\t--------\t------\t\t-----")
+
+    total = 0
+    alive = 0
+    idle_count = 0
+
+    for name in sessions:
+        total += 1
+        sess = f"{prefix}-{name}"
+
+        status = session_status(sess, idle_cache)
+        if status == "idle":
+            idle_count += 1
+            alive += 1
+        elif status == "active":
+            alive += 1
+
+        # Restart count
+        restarts = 0
+        log_file = log_dir / f"{name}.log"
+        if log_file.exists():
+            restarts = sum(1 for _ in log_file.read_text().splitlines())
+
+        # Uptime + agent
+        uptime_str = "-"
+        agent = "?"
+        if log_file.exists():
+            lines = log_file.read_text().splitlines()
+            if lines:
+                last_line = lines[-1]
+                ts_match = re.search(r"\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}", last_line)
+                agent_match = re.search(r"agent: ([a-z]+)", last_line)
+                if agent_match:
+                    agent = agent_match.group(1)
+                if ts_match:
+                    start_epoch = date_to_epoch(ts_match.group(0))
+                    if start_epoch > 0:
+                        elapsed = now - start_epoch
+                        hours = elapsed // 3600
+                        mins = (elapsed % 3600) // 60
+                        uptime_str = f"{hours}h{mins}m"
+
+        # Color status
+        if status == "active":
+            status_col = f"{G}active{NC}"
+        elif status == "idle":
+            status_col = f"{Y}idle{NC}"
+        elif status == "exited":
+            status_col = f"{R}exited{NC}"
+        else:
+            status_col = f"{D}offline{NC}"
+
+        # Color restarts
+        if restarts > 5:
+            restart_col = f"{R}{restarts}{NC}"
+        elif restarts > 2:
+            restart_col = f"{Y}{restarts}{NC}"
+        else:
+            restart_col = f"{G}{restarts}{NC}"
+
+        print(f"  {name}\t\t{status_col}\t\t{restart_col}\t\t{uptime_str}\t\t{agent}")
+
+    print()
+    offline = total - alive
+    print(f"  Total: {total} | Active: {G}{alive}{NC} | Idle: {Y}{idle_count}{NC} | Offline: {D}{offline}{NC}")
+    print()
+
+
+def main() -> None:
+    print_health_report()
+
+
+if __name__ == "__main__":
+    main()

package/lib/inject.py

@@ -0,0 +1,164 @@
+#!/usr/bin/env python3
+"""inject.py -- Force-inject a message into another Claude Code session.
+
+Auto-detects tmux or screen. Override with SWARM_MODE=tmux|screen.
+
+Usage:
+    ./lib/inject.py <target> <message>
+    ./lib/inject.py all "everyone check inbox"
+"""
+
+import os
+import shutil
+import subprocess
+import sys
+
+# Try to import common; fall back gracefully for standalone use
+try:
+    from lib.common import ClaudesEnv
+except ImportError:
+    _here = os.path.dirname(os.path.abspath(__file__))
+    sys.path.insert(0, os.path.dirname(_here))
+    from lib.common import ClaudesEnv
+
+
+def detect_mode(prefix: str) -> str:
+    """Auto-detect session multiplexer: tmux, screen, or none."""
+    swarm_mode = os.environ.get("SWARM_MODE", "")
+    if swarm_mode:
+        return swarm_mode
+
+    # Check tmux
+    try:
+        r = subprocess.run(
+            ["tmux", "list-sessions", "-F", "#{session_name}"],
+            capture_output=True,
+            text=True,
+            timeout=5,
+        )
+        if r.returncode == 0:
+            for line in r.stdout.splitlines():
+                if line.startswith(f"{prefix}-"):
+                    return "tmux"
+    except (subprocess.TimeoutExpired, OSError):
+        pass
+
+    # Check screen
+    try:
+        r = subprocess.run(
+            ["screen", "-list"],
+            capture_output=True,
+            text=True,
+            timeout=5,
+        )
+        if f".{prefix}-" in (r.stdout + r.stderr):
+            return "screen"
+    except (subprocess.TimeoutExpired, OSError):
+        pass
+
+    if shutil.which("tmux"):
+        return "tmux"
+    elif shutil.which("screen"):
+        return "screen"
+    return "none"
+
+
+def send_tmux(prefix: str, name: str, message: str) -> bool:
+    """Inject message into a tmux session. Returns True on success."""
+    sess = f"{prefix}-{name}"
+    try:
+        r = subprocess.run(
+            ["tmux", "has-session", "-t", sess],
+            capture_output=True,
+            timeout=5,
+        )
+        if r.returncode != 0:
+            print(f"  {name}: not running")
+            return False
+    except (subprocess.TimeoutExpired, OSError):
+        print(f"  {name}: not running")
+        return False
+
+    oneline = message.replace("\n", " ")
+    subprocess.run(["tmux", "send-keys", "-t", sess, "-l", oneline], timeout=5)
+    subprocess.run(["tmux", "send-keys", "-t", sess, "Enter"], timeout=5)
+    print(f"  {name}: injected (tmux)")
+    return True
+
+
+def send_screen(prefix: str, name: str, message: str) -> bool:
+    """Inject message into a screen session. Returns True on success."""
+    sess = f"{prefix}-{name}"
+    try:
+        r = subprocess.run(
+            ["screen", "-list"],
+            capture_output=True,
+            text=True,
+            timeout=5,
+        )
+        if f".{sess}" not in (r.stdout + r.stderr):
+            print(f"  {name}: not running")
+            return False
+    except (subprocess.TimeoutExpired, OSError):
+        print(f"  {name}: not running")
+        return False
+
+    oneline = message.replace("\n", " ")
+    subprocess.run(
+        ["screen", "-S", sess, "-p", "0", "-X", "stuff", oneline],
+        timeout=5,
+    )
+    import time
+
+    time.sleep(0.3)
+    subprocess.run(
+        ["screen", "-S", sess, "-p", "0", "-X", "stuff", "\r"],
+        timeout=5,
+    )
+    print(f"  {name}: injected (screen)")
+    return True
+
+
+def inject(target: str, message: str, prefix: str | None = None, sessions: list | None = None) -> None:
+    """Inject a message to *target* (a session name or 'all')."""
+    if prefix is None or sessions is None:
+        env = ClaudesEnv.load()
+        prefix = prefix or env.prefix
+        sessions = sessions if sessions is not None else env.sessions
+
+    mode = detect_mode(prefix)
+    if mode == "none":
+        print("ERROR: neither tmux nor screen found", file=sys.stderr)
+        sys.exit(1)
+
+    send_fn = send_tmux if mode == "tmux" else send_screen
+    target_lower = target.lower()
+
+    if target_lower == "all":
+        print(f"Injecting to all ({mode}):")
+        for name in sessions:
+            send_fn(prefix, name, message)
+    else:
+        send_fn(prefix, target_lower, message)
+
+
+def main() -> None:
+    if len(sys.argv) < 3:
+        print(
+            "Usage: ./inject.py <target> <message>\n"
+            "\n"
+            "  target: session name or 'all'\n"
+            "\n"
+            "Examples:\n"
+            '  ./inject.py alice "what\'s blocking P0?"\n'
+            '  ./inject.py all "everyone check inbox"',
+        )
+        sys.exit(1)
+
+    target = sys.argv[1]
+    message = " ".join(sys.argv[2:])
+    inject(target, message)
+
+
+if __name__ == "__main__":
+    main()

package/lib/migrate.py

@@ -0,0 +1,109 @@
+"""migrate — schema migration runner for cnb.
+
+Tracks applied migrations in the `meta` table (key='schema_version').
+Migrations live in the `migrations/` directory alongside schema.sql.
+"""
+
+import sqlite3
+import sys
+from pathlib import Path
+
+
+def _migrations_dir(claudes_home: Path) -> Path:
+    d = claudes_home / "migrations"
+    if not d.is_dir():
+        print(f"FATAL: migrations directory not found: {d}", file=sys.stderr)
+        raise SystemExit(1)
+    return d
+
+
+def _applied_versions(c: sqlite3.Connection) -> set[int]:
+    """Return the set of already-applied migration version numbers."""
+    try:
+        row = c.execute("SELECT value FROM meta WHERE key='schema_version'").fetchone()
+        if row:
+            return set(range(1, int(row[0]) + 1))
+    except sqlite3.OperationalError:
+        pass  # meta table may not exist yet (first init)
+    return set()
+
+
+def _record_version(c: sqlite3.Connection, version: int) -> None:
+    c.execute(
+        "INSERT OR REPLACE INTO meta(key, value) VALUES ('schema_version', ?)",
+        (str(version),),
+    )
+
+
+def _discover_migrations(mdir: Path) -> list[tuple[int, Path]]:
+    """Find migration files named NNN_description.sql, sorted by version."""
+    migs: list[tuple[int, Path]] = []
+    for f in mdir.glob("*.sql"):
+        prefix = f.name[:3]
+        if prefix.isdigit():
+            migs.append((int(prefix), f))
+    migs.sort()
+    return migs
+
+
+def run_migrations(db_path: Path, claudes_home: Path) -> int:
+    """Apply all pending migrations. Returns number of migrations applied."""
+    mdir = _migrations_dir(claudes_home)
+    conn = sqlite3.connect(str(db_path))
+    conn.execute("PRAGMA journal_mode=WAL")
+    conn.execute("PRAGMA foreign_keys=ON")
+
+    applied = 0
+    try:
+        done = _applied_versions(conn)
+        all_migs = _discover_migrations(mdir)
+
+        for ver, path in all_migs:
+            if ver in done:
+                continue
+            sql = path.read_text()
+            print(f"  Applying migration {path.name} ...", end=" ", flush=True)
+            conn.executescript(sql)
+            _record_version(conn, ver)
+            conn.commit()
+            print("OK")
+            applied += 1
+
+    except Exception as e:
+        conn.rollback()
+        print(f"\nFATAL: migration failed: {e}", file=sys.stderr)
+        raise SystemExit(1) from e
+    finally:
+        conn.close()
+
+    return applied
+
+
+# ---------------------------------------------------------------------------
+# CLI
+# ---------------------------------------------------------------------------
+
+def main() -> None:
+    """Run pending migrations. Called from init and doctor."""
+    # Resolve CLAUDES_HOME relative to this file
+    claudes_home = Path(__file__).resolve().parent.parent
+    db_path = claudes_home / ".claudes" / "board.db"
+
+    # Prefer the DB path from the current project
+    from pathlib import Path as _P
+
+    cwd_db = _P.cwd() / ".claudes" / "board.db"
+    if cwd_db.exists():
+        db_path = cwd_db
+
+    if not db_path.exists():
+        print("ERROR: board.db not found. Run: cnb init <sessions>", flush=True)
+        raise SystemExit(1)
+
+    n = run_migrations(db_path, claudes_home)
+    if n > 0:
+        print(f"Applied {n} migration(s).")
+
+
+if __name__ == "__main__":
+    main()