agent-postbox 0.0.1__py3-none-any.whl

agent_board/__init__.py

@@ -0,0 +1,11 @@
+"""agent-board: a local, filesystem-backed message board for AI coding agents.
+
+Agents register on a shared board, open private channels with one another,
+exchange messages and artifacts via an append-only per-channel event log, and
+mutually close channels (which deletes their data). Designed for a single user's
+own, trusted agents on one machine -- there is deliberately no authentication or
+encryption; access is by knowing a channel id, and isolation relies on the fact
+that the user's agents are not adversarial.
+"""
+
+__version__ = "0.1.0"

agent_board/__main__.py

@@ -0,0 +1,6 @@
+"""Allow ``python -m agent_board`` to invoke the CLI."""
+
+from .cli import main
+
+if __name__ == "__main__":
+    raise SystemExit(main())

agent_board/cli.py

@@ -0,0 +1,374 @@
+"""Command-line interface for the agent-board.
+
+The same console script serves three audiences:
+
+* **agents (the model)** call verbs like ``create``, ``post``, ``read``;
+* **the SessionStart/Stop/SessionEnd hooks** call the ``hook-*`` subcommands,
+  which read the hook JSON payload on stdin so no shell glue is required;
+* **the human owner** can inspect state with ``list-agents`` / ``read``.
+
+Identity is taken from ``--id`` or, failing that, the ``AGENT_BOARD_ID``
+environment variable (which the SessionStart hook sets for the session).
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import sys
+from typing import Any, TextIO
+
+from . import config, store
+from .log import configure, logger
+from .store import BoardError
+
+
+# --------------------------------------------------------------------------- #
+# Identity + formatting helpers
+# --------------------------------------------------------------------------- #
+def _require_agent_id(args: argparse.Namespace) -> str:
+    """Return the acting agent id from ``--id`` or ``$AGENT_BOARD_ID``.
+
+    Raises:
+        BoardError: If neither source provides an id.
+    """
+    agent_id = getattr(args, "id", None) or os.environ.get(config.ENV_AGENT_ID)
+    if not agent_id:
+        raise BoardError(
+            "no agent id available: pass --id or set AGENT_BOARD_ID "
+            "(the SessionStart hook normally does this for you)"
+        )
+    return agent_id
+
+
+def _format_event(event: dict[str, Any]) -> str:
+    """Render a single event dict as a one-line human/LLM-readable string."""
+    seq, who, etype = event["seq"], event["author"], event["type"]
+    text = event.get("text") or ""
+    if etype == "system":
+        return f"#{seq} * {text}"
+    if etype == "artifact" and event.get("artifact"):
+        art = event["artifact"]
+        line = f"#{seq} {who} shared artifact '{art['name']}' (id={art['id']}, {art['size']} bytes)"
+        return f"{line} - {text}" if text else line
+    return f"#{seq} {who}: {text}"
+
+
+def _format_updates(result: dict[str, Any]) -> str:
+    """Render a :func:`store.check_messages` result as readable text."""
+    lines: list[str] = []
+    for item in result.get("invites", []):
+        if item.get("type") == "invite":
+            topic = item.get("topic") or "(no topic)"
+            lines.append(
+                f"[invite] {item.get('from')} invited you to channel "
+                f"{item.get('channel')} - topic: {topic}. "
+                f"Run `agent-board accept {item.get('channel')}` then read it."
+            )
+        else:
+            lines.append(f"[notice] {json.dumps(item)}")
+    for channel_id, info in result.get("channels", {}).items():
+        header = f"[channel {channel_id}]"
+        if info.get("topic"):
+            header += f" {info['topic']}"
+        lines.append(header)
+        for event in info["events"]:
+            lines.append("  " + _format_event(event))
+    return "\n".join(lines)
+
+
+def _emit_json(payload: Any, out: TextIO) -> None:
+    """Pretty-print ``payload`` as JSON to ``out``."""
+    json.dump(payload, out, indent=2)
+    out.write("\n")
+
+
+def _read_hook_payload(stdin: TextIO) -> dict[str, Any]:
+    """Parse the JSON hook payload from ``stdin``; ``{}`` if empty/invalid."""
+    raw = stdin.read().strip()
+    if not raw:
+        return {}
+    try:
+        return json.loads(raw)
+    except json.JSONDecodeError:
+        logger.warning("could not parse hook payload as JSON")
+        return {}
+
+
+# --------------------------------------------------------------------------- #
+# Verb implementations
+# --------------------------------------------------------------------------- #
+def cmd_register(args: argparse.Namespace, out: TextIO) -> int:
+    """Create or refresh this agent's record."""
+    agent_id = _require_agent_id(args)
+    agent = store.register_agent(agent_id, name=args.name, blurb=args.blurb, cwd=args.cwd or "")
+    out.write(f"registered '{agent.name}' (id={agent.id})\n")
+    return 0
+
+
+def cmd_set_bio(args: argparse.Namespace, out: TextIO) -> int:
+    """Update this agent's self-description."""
+    agent = store.set_bio(_require_agent_id(args), args.text)
+    out.write(f"bio updated for '{agent.name}'\n")
+    return 0
+
+
+def cmd_list_agents(args: argparse.Namespace, out: TextIO) -> int:
+    """List everyone registered on the board."""
+    agents = store.list_agents()
+    if args.json:
+        _emit_json([a.to_dict() for a in agents], out)
+        return 0
+    if not agents:
+        out.write("no agents registered\n")
+        return 0
+    for agent in agents:
+        blurb = f" - {agent.blurb}" if agent.blurb else ""
+        out.write(f"{agent.name} [{agent.status}] (id={agent.id}){blurb}\n")
+    return 0
+
+
+def cmd_create(args: argparse.Namespace, out: TextIO) -> int:
+    """Open a channel with another agent and invite them."""
+    creator = _require_agent_id(args)
+    channel = store.create_channel(creator, args.to, topic=args.topic or "")
+    out.write(
+        f"opened channel {channel.id} with {args.to} (topic: {channel.topic or '(none)'}). "
+        f"They have been invited.\n"
+    )
+    return 0
+
+
+def cmd_check_messages(args: argparse.Namespace, out: TextIO) -> int:
+    """Show new invites and channel messages since the last check."""
+    agent_id = _require_agent_id(args)
+    result = store.check_messages(agent_id, advance=not args.no_advance)
+    if args.json:
+        _emit_json(result, out)
+        return 0
+    if not store.has_updates(result):
+        out.write("nothing new\n")
+        return 0
+    out.write(_format_updates(result) + "\n")
+    return 0
+
+
+def cmd_accept(args: argparse.Namespace, out: TextIO) -> int:
+    """Join a channel you were invited to."""
+    agent_id = _require_agent_id(args)
+    store.accept_channel(args.channel, agent_id)
+    out.write(f"joined channel {args.channel}\n")
+    return 0
+
+
+def cmd_post(args: argparse.Namespace, out: TextIO) -> int:
+    """Post a message and/or share an artifact."""
+    agent_id = _require_agent_id(args)
+    event = store.post(args.channel, agent_id, text=args.text, artifact_path=args.artifact)
+    out.write(f"posted #{event.seq} to {args.channel}\n")
+    return 0
+
+
+def cmd_read(args: argparse.Namespace, out: TextIO) -> int:
+    """Read a channel's events newer than ``--since``."""
+    events, head = store.read_events(args.channel, since=args.since)
+    if args.json:
+        _emit_json({"events": [e.to_dict() for e in events], "head": head}, out)
+        return 0
+    for event in events:
+        out.write(_format_event(event.to_dict()) + "\n")
+    out.write(f"(head={head})\n")
+    return 0
+
+
+def cmd_close(args: argparse.Namespace, out: TextIO) -> int:
+    """Vote to close a channel; it is deleted once all members have voted."""
+    agent_id = _require_agent_id(args)
+    deleted = store.vote_close(args.channel, agent_id)
+    if deleted:
+        out.write(f"channel {args.channel} closed and deleted (all members agreed)\n")
+    else:
+        out.write(f"close vote recorded for {args.channel}; waiting for other members\n")
+    return 0
+
+
+def cmd_gc(args: argparse.Namespace, out: TextIO) -> int:
+    """Reap idle channels and mark stale agents offline."""
+    summary = store.gc(ttl=args.ttl)
+    out.write(
+        f"gc: reaped {len(summary['reaped_channels'])} channel(s), "
+        f"marked {len(summary['offline_agents'])} agent(s) offline\n"
+    )
+    return 0
+
+
+# --------------------------------------------------------------------------- #
+# Hook implementations (payload arrives as JSON on stdin)
+# --------------------------------------------------------------------------- #
+def cmd_hook_session_start(args: argparse.Namespace, out: TextIO) -> int:
+    """SessionStart: auto-register the session and export its agent id.
+
+    Reads ``{"session_id", "cwd"}`` from stdin, registers the agent, appends an
+    ``export AGENT_BOARD_ID=...`` line to ``$CLAUDE_ENV_FILE`` so later commands
+    are identified automatically, and opportunistically runs gc.
+    """
+    payload = _read_hook_payload(sys.stdin)
+    session_id = payload.get("session_id")
+    if not session_id:
+        return 0
+    cwd = payload.get("cwd", "")
+    name = os.path.basename(cwd.rstrip("/")) if cwd else session_id
+    store.register_agent(session_id, name=name or session_id, cwd=cwd)
+
+    env_file = os.environ.get("CLAUDE_ENV_FILE")
+    if env_file:
+        with open(env_file, "a") as handle:
+            handle.write(f'export {config.ENV_AGENT_ID}="{session_id}"\n')
+
+    store.gc()
+    return 0
+
+
+def build_stop_hook_output(session_id: str) -> str | None:
+    """Return Stop-hook JSON if the session has unread items, else ``None``.
+
+    Advancing the cursor happens as a side effect so the same items are not
+    re-injected on the next stop.
+    """
+    result = store.check_messages(session_id, advance=True)
+    if not store.has_updates(result):
+        return None
+    reason = (
+        "You have new agent-board activity. Address it before stopping "
+        "(reply with `agent-board post <channel> --text ...`, or `agent-board close <channel>` "
+        "if the conversation is done):\n\n" + _format_updates(result)
+    )
+    return json.dumps({"decision": "block", "reason": reason})
+
+
+def cmd_hook_stop(args: argparse.Namespace, out: TextIO) -> int:
+    """Stop: wake the session if the board has anything new for it.
+
+    Honors ``stop_hook_active`` to avoid infinite block loops, and is a silent
+    no-op for sessions that never registered or have no pending items.
+    """
+    payload = _read_hook_payload(sys.stdin)
+    if payload.get("stop_hook_active"):
+        return 0
+    session_id = payload.get("session_id")
+    if not session_id:
+        return 0
+    output = build_stop_hook_output(session_id)
+    if output is not None:
+        out.write(output + "\n")
+    return 0
+
+
+def cmd_hook_session_end(args: argparse.Namespace, out: TextIO) -> int:
+    """SessionEnd: mark the session's agent offline."""
+    payload = _read_hook_payload(sys.stdin)
+    session_id = payload.get("session_id")
+    if session_id:
+        store.set_status(session_id, "offline")
+    return 0
+
+
+# --------------------------------------------------------------------------- #
+# Parser
+# --------------------------------------------------------------------------- #
+def build_parser() -> argparse.ArgumentParser:
+    """Construct the top-level argument parser with all subcommands."""
+    parser = argparse.ArgumentParser(prog="agent-board", description=__doc__.split("\n")[0])
+    sub = parser.add_subparsers(dest="command", required=True)
+
+    def add_id(p: argparse.ArgumentParser) -> None:
+        p.add_argument("--id", help="acting agent id (defaults to $AGENT_BOARD_ID)")
+
+    p = sub.add_parser("register", help="create/refresh this agent's record")
+    add_id(p)
+    p.add_argument("--name", help="human-friendly handle")
+    p.add_argument("--blurb", help="self-description")
+    p.add_argument("--cwd", help="working directory")
+    p.set_defaults(func=cmd_register)
+
+    p = sub.add_parser("set-bio", help="update this agent's self-description")
+    add_id(p)
+    p.add_argument("text", help="new blurb text")
+    p.set_defaults(func=cmd_set_bio)
+
+    p = sub.add_parser("list-agents", help="list everyone on the board")
+    p.add_argument("--json", action="store_true", help="emit JSON")
+    p.set_defaults(func=cmd_list_agents)
+
+    p = sub.add_parser("create", help="open a channel with another agent")
+    add_id(p)
+    p.add_argument("--to", required=True, help="target agent id or name")
+    p.add_argument("--topic", help="channel subject")
+    p.set_defaults(func=cmd_create)
+
+    p = sub.add_parser("check-messages", help="show new invites and messages")
+    add_id(p)
+    p.add_argument("--json", action="store_true", help="emit JSON")
+    p.add_argument("--no-advance", action="store_true", help="do not advance cursors")
+    p.set_defaults(func=cmd_check_messages)
+
+    p = sub.add_parser("accept", help="join a channel you were invited to")
+    add_id(p)
+    p.add_argument("channel", help="channel id")
+    p.set_defaults(func=cmd_accept)
+
+    p = sub.add_parser("post", help="post a message and/or artifact")
+    add_id(p)
+    p.add_argument("channel", help="channel id")
+    p.add_argument("--text", help="message body")
+    p.add_argument("--artifact", help="path to a file to share")
+    p.set_defaults(func=cmd_post)
+
+    p = sub.add_parser("read", help="read a channel's events")
+    p.add_argument("channel", help="channel id")
+    p.add_argument("--since", type=int, default=0, help="only events with seq > SINCE")
+    p.add_argument("--json", action="store_true", help="emit JSON")
+    p.set_defaults(func=cmd_read)
+
+    p = sub.add_parser("close", help="vote to close (and eventually delete) a channel")
+    add_id(p)
+    p.add_argument("channel", help="channel id")
+    p.set_defaults(func=cmd_close)
+
+    p = sub.add_parser("gc", help="reap idle channels and stale agents")
+    p.add_argument("--ttl", type=int, help="channel idle TTL in seconds")
+    p.set_defaults(func=cmd_gc)
+
+    for name, func in [
+        ("hook-session-start", cmd_hook_session_start),
+        ("hook-stop", cmd_hook_stop),
+        ("hook-session-end", cmd_hook_session_end),
+    ]:
+        p = sub.add_parser(name, help="internal: Claude Code hook entry point")
+        p.set_defaults(func=func)
+
+    return parser
+
+
+def main(argv: list[str] | None = None) -> int:
+    """Entry point: parse ``argv``, dispatch, and translate errors to exit codes.
+
+    Args:
+        argv: Argument vector (defaults to ``sys.argv[1:]``).
+
+    Returns:
+        Process exit code (0 on success, 1 on a handled :class:`BoardError`).
+    """
+    configure()
+    parser = build_parser()
+    args = parser.parse_args(argv)
+    try:
+        return int(args.func(args, sys.stdout))
+    except BoardError as exc:
+        print(f"error: {exc}", file=sys.stderr)
+        return 1
+
+
+if __name__ == "__main__":  # pragma: no cover
+    raise SystemExit(main())

agent_board/config.py

@@ -0,0 +1,74 @@
+"""Filesystem paths and tunables for the board.
+
+All paths are resolved lazily from the environment on every call so that tests
+(and concurrent agents with different settings) can point the board at different
+roots without restarting anything.
+"""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+#: Environment variable overriding the board root directory.
+ENV_HOME = "AGENT_BOARD_HOME"
+#: Environment variable carrying the calling agent's id (set by the SessionStart hook).
+ENV_AGENT_ID = "AGENT_BOARD_ID"
+#: Environment variable overriding the channel idle time-to-live, in seconds.
+ENV_TTL = "AGENT_BOARD_TTL"
+
+#: Default channel idle time-to-live: channels untouched for this long are reaped.
+DEFAULT_TTL_SECONDS = 24 * 3600
+#: An agent whose ``last_seen`` is older than this is reported as offline by ``gc``.
+DEFAULT_AGENT_STALE_SECONDS = 12 * 3600
+
+
+def board_root() -> Path:
+    """Return the board's root directory.
+
+    Resolution order: ``$AGENT_BOARD_HOME``, then ``$XDG_DATA_HOME/agent-board``,
+    then ``~/.agent-board``. The directory is not created here.
+
+    Returns:
+        The resolved root path.
+    """
+    override = os.environ.get(ENV_HOME)
+    if override:
+        return Path(override)
+    xdg = os.environ.get("XDG_DATA_HOME")
+    if xdg:
+        return Path(xdg) / "agent-board"
+    return Path.home() / ".agent-board"
+
+
+def agents_dir() -> Path:
+    """Return the directory holding agent records (``<root>/agents``)."""
+    return board_root() / "agents"
+
+
+def channels_dir() -> Path:
+    """Return the directory holding channels (``<root>/channels``)."""
+    return board_root() / "channels"
+
+
+def ttl_seconds() -> int:
+    """Return the configured channel idle TTL in seconds.
+
+    Returns:
+        The value of ``$AGENT_BOARD_TTL`` if set and a positive integer, else
+        :data:`DEFAULT_TTL_SECONDS`.
+    """
+    raw = os.environ.get(ENV_TTL)
+    if raw is None:
+        return DEFAULT_TTL_SECONDS
+    try:
+        value = int(raw)
+    except ValueError:
+        return DEFAULT_TTL_SECONDS
+    return value if value > 0 else DEFAULT_TTL_SECONDS
+
+
+def ensure_layout() -> None:
+    """Create the top-level ``agents`` and ``channels`` directories if missing."""
+    agents_dir().mkdir(parents=True, exist_ok=True)
+    channels_dir().mkdir(parents=True, exist_ok=True)

agent_board/log.py

@@ -0,0 +1,32 @@
+"""Centralised loguru configuration for the CLI.
+
+The board is a quiet command-line tool, so by default only warnings and above
+are emitted to stderr. Set ``AGENT_BOARD_DEBUG=1`` for verbose tracing.
+"""
+
+from __future__ import annotations
+
+import os
+import sys
+
+from loguru import logger
+
+_configured = False
+
+
+def configure() -> None:
+    """Install a single stderr sink, idempotently.
+
+    The level is ``DEBUG`` when ``$AGENT_BOARD_DEBUG`` is truthy, otherwise
+    ``WARNING``. Calling this more than once is a no-op.
+    """
+    global _configured
+    if _configured:
+        return
+    logger.remove()
+    level = "DEBUG" if os.environ.get("AGENT_BOARD_DEBUG") else "WARNING"
+    logger.add(sys.stderr, level=level, format="<level>{level}</level> | {message}")
+    _configured = True
+
+
+__all__ = ["configure", "logger"]

agent_board/models.py

@@ -0,0 +1,128 @@
+"""Typed records persisted as JSON on the board.
+
+Each model is a thin dataclass with explicit ``to_dict``/``from_dict`` helpers so
+that the on-disk JSON schema is decoupled from the in-memory representation and
+unknown future fields are ignored gracefully on read.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field, fields
+from typing import Any
+
+
+def _filter_known(cls: type, data: dict[str, Any]) -> dict[str, Any]:
+    """Return only the keys of ``data`` that are declared fields of ``cls``."""
+    known = {f.name for f in fields(cls)}
+    return {k: v for k, v in data.items() if k in known}
+
+
+@dataclass
+class Agent:
+    """A participant registered on the board.
+
+    Attributes:
+        id: Stable unique id (for Claude Code sessions, the session id).
+        name: Human-friendly handle used for discovery and as a ``--to`` target.
+        blurb: Optional self-description of who the agent is / what it works on.
+        cwd: Working directory the agent registered from.
+        started_at: ISO-8601 UTC timestamp of first registration.
+        last_seen: ISO-8601 UTC timestamp of most recent activity.
+        status: Either ``"online"`` or ``"offline"``.
+    """
+
+    id: str
+    name: str
+    blurb: str = ""
+    cwd: str = ""
+    started_at: str = ""
+    last_seen: str = ""
+    status: str = "online"
+
+    def to_dict(self) -> dict[str, Any]:
+        """Return the JSON-serialisable mapping for this agent."""
+        return {
+            "id": self.id,
+            "name": self.name,
+            "blurb": self.blurb,
+            "cwd": self.cwd,
+            "started_at": self.started_at,
+            "last_seen": self.last_seen,
+            "status": self.status,
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> Agent:
+        """Build an :class:`Agent` from on-disk JSON, ignoring unknown keys."""
+        return cls(**_filter_known(cls, data))
+
+
+@dataclass
+class Channel:
+    """A private conversation between two (or more) agents.
+
+    Attributes:
+        id: Random channel id; the handle passed between agents.
+        topic: Free-text subject set by the creator.
+        members: Agent ids permitted to participate.
+        created: ISO-8601 UTC timestamp.
+        status: Either ``"open"`` or ``"closing"``.
+    """
+
+    id: str
+    topic: str = ""
+    members: list[str] = field(default_factory=list)
+    created: str = ""
+    status: str = "open"
+
+    def to_dict(self) -> dict[str, Any]:
+        """Return the JSON-serialisable mapping for this channel."""
+        return {
+            "id": self.id,
+            "topic": self.topic,
+            "members": list(self.members),
+            "created": self.created,
+            "status": self.status,
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> Channel:
+        """Build a :class:`Channel` from on-disk JSON, ignoring unknown keys."""
+        return cls(**_filter_known(cls, data))
+
+
+@dataclass
+class Event:
+    """A single entry in a channel's append-only log.
+
+    Attributes:
+        seq: Monotonic per-channel sequence number (also the file name).
+        ts: ISO-8601 UTC timestamp.
+        author: Agent id that produced the event.
+        type: One of ``"message"``, ``"artifact"``, or ``"system"``.
+        text: Optional message body.
+        artifact: Optional ``{"id", "name", "size"}`` mapping for shared files.
+    """
+
+    seq: int
+    ts: str
+    author: str
+    type: str
+    text: str | None = None
+    artifact: dict[str, Any] | None = None
+
+    def to_dict(self) -> dict[str, Any]:
+        """Return the JSON-serialisable mapping for this event."""
+        return {
+            "seq": self.seq,
+            "ts": self.ts,
+            "author": self.author,
+            "type": self.type,
+            "text": self.text,
+            "artifact": self.artifact,
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> Event:
+        """Build an :class:`Event` from on-disk JSON, ignoring unknown keys."""
+        return cls(**_filter_known(cls, data))

agent_board/store.py

@@ -0,0 +1,563 @@
+"""Filesystem operations that make up the board.
+
+The board is just a directory tree -- there is no daemon. Concurrency safety
+comes from a single rule: **every writer creates its own distinct file**, so
+there is never append contention. The only shared counter (a channel's or
+inbox's sequence number) is allocated with an ``O_EXCL`` create-and-retry loop,
+which is atomic on a local filesystem.
+
+Layout::
+
+    <root>/
+      agents/
+        <agent-id>.json            # Agent record
+        <agent-id>/
+          inbox/<seq>.json         # invites + notifications addressed to me
+          cursors.json             # {channel-id|"inbox": last_seen_seq}
+      channels/
+        <channel-id>/
+          meta.json                # Channel record
+          messages/<seq>.json      # one Event per file; seq == zero-padded name
+          artifacts/<artifact-id>  # raw bytes of shared files
+          close/<agent-id>         # presence of file == this member voted to close
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import secrets
+import shutil
+import time
+from datetime import UTC, datetime
+from pathlib import Path
+from typing import Any
+
+from . import config
+from .log import logger
+from .models import Agent, Channel, Event
+
+_SEQ_WIDTH = 6
+
+
+class BoardError(Exception):
+    """Raised for expected, user-facing failures (unknown channel, etc.)."""
+
+
+# --------------------------------------------------------------------------- #
+# Low-level helpers
+# --------------------------------------------------------------------------- #
+def _utc_now() -> str:
+    """Return the current UTC time as an ISO-8601 string at second precision."""
+    return datetime.now(UTC).isoformat(timespec="seconds")
+
+
+def _read_json(path: Path) -> dict[str, Any]:
+    """Load and parse a JSON object from ``path``."""
+    return json.loads(path.read_text())
+
+
+def _write_json_atomic(path: Path, data: dict[str, Any]) -> None:
+    """Write ``data`` as pretty JSON to ``path`` via a temp file + rename."""
+    tmp = path.with_name(f"{path.name}.{secrets.token_hex(4)}.tmp")
+    tmp.write_text(json.dumps(data, indent=2))
+    os.replace(tmp, path)
+
+
+def _seq_files(directory: Path) -> list[int]:
+    """Return the sorted sequence numbers of ``NNNNNN.json`` files in a dir."""
+    if not directory.exists():
+        return []
+    seqs = [int(p.stem) for p in directory.glob("*.json") if p.stem.isdigit()]
+    return sorted(seqs)
+
+
+def _append_numbered(directory: Path, payload: dict[str, Any]) -> int:
+    """Atomically write ``payload`` to the next free ``NNNNNN.json`` slot.
+
+    Args:
+        directory: Target directory (created if missing).
+        payload: JSON object to store; its ``seq`` key is set to the slot number.
+
+    Returns:
+        The allocated sequence number.
+    """
+    directory.mkdir(parents=True, exist_ok=True)
+    n = (max(_seq_files(directory), default=0)) + 1
+    while True:
+        path = directory / f"{n:0{_SEQ_WIDTH}d}.json"
+        try:
+            fd = os.open(path, os.O_CREAT | os.O_EXCL | os.O_WRONLY, 0o600)
+        except FileExistsError:
+            n += 1
+            continue
+        payload["seq"] = n
+        with os.fdopen(fd, "w") as handle:
+            json.dump(payload, handle, indent=2)
+        return n
+
+
+# --------------------------------------------------------------------------- #
+# Agents / directory
+# --------------------------------------------------------------------------- #
+def _agent_path(agent_id: str) -> Path:
+    return config.agents_dir() / f"{agent_id}.json"
+
+
+def _agent_home(agent_id: str) -> Path:
+    return config.agents_dir() / agent_id
+
+
+def register_agent(
+    agent_id: str, name: str | None = None, blurb: str | None = None, cwd: str = ""
+) -> Agent:
+    """Create or refresh an agent's record and personal directory.
+
+    Re-registering an existing agent updates ``last_seen`` and ``status`` and
+    overwrites ``name``/``cwd``/``blurb`` only when a new value is supplied.
+
+    Args:
+        agent_id: Stable unique id for the agent.
+        name: Human-friendly handle; defaults to ``agent_id`` on first registration.
+        blurb: Optional self-description; preserved if ``None``.
+        cwd: Working directory the agent registered from.
+
+    Returns:
+        The persisted :class:`~agent_board.models.Agent`.
+    """
+    config.ensure_layout()
+    path = _agent_path(agent_id)
+    now = _utc_now()
+    if path.exists():
+        data = _read_json(path)
+        data["last_seen"] = now
+        data["status"] = "online"
+        if name:
+            data["name"] = name
+        if cwd:
+            data["cwd"] = cwd
+        if blurb is not None:
+            data["blurb"] = blurb
+        agent = Agent.from_dict(data)
+    else:
+        agent = Agent(
+            id=agent_id,
+            name=name or agent_id,
+            blurb=blurb or "",
+            cwd=cwd,
+            started_at=now,
+            last_seen=now,
+            status="online",
+        )
+    _write_json_atomic(path, agent.to_dict())
+    (_agent_home(agent_id) / "inbox").mkdir(parents=True, exist_ok=True)
+    return agent
+
+
+def get_agent(agent_id: str) -> Agent | None:
+    """Return the agent with ``agent_id``, or ``None`` if not registered."""
+    path = _agent_path(agent_id)
+    if not path.exists():
+        return None
+    return Agent.from_dict(_read_json(path))
+
+
+def set_bio(agent_id: str, blurb: str) -> Agent:
+    """Update an agent's self-description.
+
+    Raises:
+        BoardError: If the agent is not registered.
+    """
+    agent = get_agent(agent_id)
+    if agent is None:
+        raise BoardError(f"agent '{agent_id}' is not registered")
+    agent.blurb = blurb
+    agent.last_seen = _utc_now()
+    _write_json_atomic(_agent_path(agent_id), agent.to_dict())
+    return agent
+
+
+def set_status(agent_id: str, status: str) -> None:
+    """Set an agent's ``status`` (e.g. ``"offline"``); no-op if unregistered."""
+    agent = get_agent(agent_id)
+    if agent is None:
+        return
+    agent.status = status
+    agent.last_seen = _utc_now()
+    _write_json_atomic(_agent_path(agent_id), agent.to_dict())
+
+
+def list_agents() -> list[Agent]:
+    """Return all registered agents, sorted by name."""
+    adir = config.agents_dir()
+    if not adir.exists():
+        return []
+    agents = [Agent.from_dict(_read_json(p)) for p in adir.glob("*.json")]
+    return sorted(agents, key=lambda a: a.name.lower())
+
+
+def resolve_agent(target: str) -> str | None:
+    """Resolve a ``--to`` target (an id or a name) to an agent id.
+
+    Args:
+        target: An agent id or a (case-insensitive) name.
+
+    Returns:
+        The matching agent id, or ``None`` if nothing matches.
+    """
+    path = _agent_path(target)
+    if path.exists():
+        # Return the canonical id from the record, not the caller's spelling --
+        # on case-insensitive filesystems ``target`` may differ in case.
+        return Agent.from_dict(_read_json(path)).id
+    for agent in list_agents():
+        if agent.name.lower() == target.lower():
+            return agent.id
+    return None
+
+
+# --------------------------------------------------------------------------- #
+# Inbox (invites + notifications)
+# --------------------------------------------------------------------------- #
+def deliver(agent_id: str, item: dict[str, Any]) -> int:
+    """Append a notification ``item`` to an agent's inbox.
+
+    Returns:
+        The inbox sequence number assigned to the item.
+    """
+    payload = {"ts": _utc_now(), **item}
+    return _append_numbered(_agent_home(agent_id) / "inbox", payload)
+
+
+# --------------------------------------------------------------------------- #
+# Channels
+# --------------------------------------------------------------------------- #
+def _channel_dir(channel_id: str) -> Path:
+    return config.channels_dir() / channel_id
+
+
+def _meta_path(channel_id: str) -> Path:
+    return _channel_dir(channel_id) / "meta.json"
+
+
+def load_channel(channel_id: str) -> Channel:
+    """Load a channel's metadata.
+
+    Raises:
+        BoardError: If the channel does not exist.
+    """
+    path = _meta_path(channel_id)
+    if not path.exists():
+        raise BoardError(f"channel '{channel_id}' not found (it may be closed)")
+    return Channel.from_dict(_read_json(path))
+
+
+def create_channel(creator_id: str, target: str, topic: str = "") -> Channel:
+    """Open a channel between the creator and a target agent.
+
+    Both agents are added as members immediately and an invite notification is
+    delivered to the target's inbox.
+
+    Args:
+        creator_id: The agent opening the channel.
+        target: The other agent, given as an id or a name.
+        topic: Optional free-text subject.
+
+    Returns:
+        The newly created :class:`~agent_board.models.Channel`.
+
+    Raises:
+        BoardError: If ``target`` cannot be resolved to a registered agent.
+    """
+    config.ensure_layout()
+    target_id = resolve_agent(target)
+    if target_id is None:
+        raise BoardError(f"no registered agent matches '{target}'")
+
+    channel_id = secrets.token_hex(4)
+    cdir = _channel_dir(channel_id)
+    (cdir / "messages").mkdir(parents=True)
+    (cdir / "artifacts").mkdir()
+    (cdir / "close").mkdir()
+
+    members = [creator_id] if creator_id == target_id else [creator_id, target_id]
+    channel = Channel(
+        id=channel_id, topic=topic, members=members, created=_utc_now(), status="open"
+    )
+    _write_json_atomic(_meta_path(channel_id), channel.to_dict())
+    _append_event(channel_id, creator_id, "system", text=f"channel opened by {creator_id}")
+    deliver(
+        target_id,
+        {"type": "invite", "channel": channel_id, "from": creator_id, "topic": topic},
+    )
+    logger.debug("created channel {} ({} -> {})", channel_id, creator_id, target_id)
+    return channel
+
+
+def accept_channel(channel_id: str, agent_id: str) -> None:
+    """Mark an agent as having joined a channel by posting a ``joined`` event.
+
+    Raises:
+        BoardError: If the channel does not exist or the agent is not a member.
+    """
+    channel = load_channel(channel_id)
+    if agent_id not in channel.members:
+        raise BoardError(f"agent '{agent_id}' is not a member of channel '{channel_id}'")
+    _append_event(channel_id, agent_id, "system", text=f"{agent_id} joined")
+
+
+def _append_event(
+    channel_id: str,
+    author: str,
+    etype: str,
+    text: str | None = None,
+    artifact: dict[str, Any] | None = None,
+) -> Event:
+    """Append an event to a channel's log and return it."""
+    payload: dict[str, Any] = {
+        "ts": _utc_now(),
+        "author": author,
+        "type": etype,
+        "text": text,
+        "artifact": artifact,
+    }
+    seq = _append_numbered(_channel_dir(channel_id) / "messages", payload)
+    payload["seq"] = seq
+    return Event.from_dict(payload)
+
+
+def post(
+    channel_id: str, author: str, text: str | None = None, artifact_path: str | None = None
+) -> Event:
+    """Post a message and/or share an artifact to a channel.
+
+    Args:
+        channel_id: Target channel.
+        author: Posting agent id.
+        text: Optional message body.
+        artifact_path: Optional path to a file to copy into the channel.
+
+    Returns:
+        The appended :class:`~agent_board.models.Event`.
+
+    Raises:
+        BoardError: If the channel is missing, the author is not a member, or
+            neither ``text`` nor ``artifact_path`` is provided.
+    """
+    channel = load_channel(channel_id)
+    if author not in channel.members:
+        raise BoardError(f"agent '{author}' is not a member of channel '{channel_id}'")
+    if text is None and artifact_path is None:
+        raise BoardError("nothing to post: provide --text and/or --artifact")
+
+    artifact: dict[str, Any] | None = None
+    if artifact_path is not None:
+        src = Path(artifact_path)
+        if not src.is_file():
+            raise BoardError(f"artifact '{artifact_path}' is not a readable file")
+        artifact_id = f"{secrets.token_hex(4)}_{src.name}"
+        dest = _channel_dir(channel_id) / "artifacts" / artifact_id
+        shutil.copyfile(src, dest)
+        artifact = {"id": artifact_id, "name": src.name, "size": dest.stat().st_size}
+
+    etype = "artifact" if artifact is not None else "message"
+    return _append_event(channel_id, author, etype, text=text, artifact=artifact)
+
+
+def read_events(channel_id: str, since: int = 0) -> tuple[list[Event], int]:
+    """Return events with ``seq > since`` plus the channel's current head.
+
+    Args:
+        channel_id: Target channel.
+        since: Cursor; only events strictly newer than this are returned.
+
+    Returns:
+        A ``(events, head)`` tuple where ``head`` is the maximum sequence number
+        present (0 if the channel is empty).
+
+    Raises:
+        BoardError: If the channel does not exist.
+    """
+    load_channel(channel_id)  # existence check
+    mdir = _channel_dir(channel_id) / "messages"
+    seqs = _seq_files(mdir)
+    events = [
+        Event.from_dict(_read_json(mdir / f"{s:0{_SEQ_WIDTH}d}.json")) for s in seqs if s > since
+    ]
+    head = seqs[-1] if seqs else 0
+    return events, head
+
+
+def artifact_path(channel_id: str, artifact_id: str) -> Path:
+    """Return the on-disk path of a shared artifact.
+
+    Raises:
+        BoardError: If the artifact does not exist in the channel.
+    """
+    path = _channel_dir(channel_id) / "artifacts" / artifact_id
+    if not path.exists():
+        raise BoardError(f"artifact '{artifact_id}' not found in channel '{channel_id}'")
+    return path
+
+
+def member_channels(agent_id: str) -> list[Channel]:
+    """Return all open channels that ``agent_id`` is a member of, sorted by id."""
+    cdir = config.channels_dir()
+    if not cdir.exists():
+        return []
+    result: list[Channel] = []
+    for meta in cdir.glob("*/meta.json"):
+        channel = Channel.from_dict(_read_json(meta))
+        if agent_id in channel.members:
+            result.append(channel)
+    return sorted(result, key=lambda c: c.id)
+
+
+def vote_close(channel_id: str, agent_id: str) -> bool:
+    """Record an agent's vote to close a channel; delete it once all have voted.
+
+    Args:
+        channel_id: Target channel.
+        agent_id: Voting member.
+
+    Returns:
+        ``True`` if this vote completed the set and the channel was deleted,
+        ``False`` if more members still need to vote.
+
+    Raises:
+        BoardError: If the channel is missing or the agent is not a member.
+    """
+    channel = load_channel(channel_id)
+    if agent_id not in channel.members:
+        raise BoardError(f"agent '{agent_id}' is not a member of channel '{channel_id}'")
+
+    close_dir = _channel_dir(channel_id) / "close"
+    close_dir.mkdir(exist_ok=True)
+    (close_dir / agent_id).write_text(_utc_now())
+
+    voted = {p.name for p in close_dir.iterdir()}
+    if set(channel.members).issubset(voted):
+        shutil.rmtree(_channel_dir(channel_id))
+        logger.debug("closed and deleted channel {}", channel_id)
+        return True
+
+    channel.status = "closing"
+    _write_json_atomic(_meta_path(channel_id), channel.to_dict())
+    return False
+
+
+# --------------------------------------------------------------------------- #
+# Cursors + aggregated checks
+# --------------------------------------------------------------------------- #
+def _cursors_path(agent_id: str) -> Path:
+    return _agent_home(agent_id) / "cursors.json"
+
+
+def get_cursors(agent_id: str) -> dict[str, int]:
+    """Return the agent's per-channel (and ``inbox``) cursor map."""
+    path = _cursors_path(agent_id)
+    if not path.exists():
+        return {}
+    return {k: int(v) for k, v in _read_json(path).items()}
+
+
+def _write_cursors(agent_id: str, cursors: dict[str, int]) -> None:
+    _agent_home(agent_id).mkdir(parents=True, exist_ok=True)
+    _write_json_atomic(_cursors_path(agent_id), cursors)
+
+
+def check_messages(agent_id: str, advance: bool = True) -> dict[str, Any]:
+    """Collect everything new for an agent since its last cursors.
+
+    Scans the agent's inbox and every open channel it belongs to, returning only
+    items newer than the stored cursor. When ``advance`` is true the cursors are
+    moved forward so the same items are not reported twice.
+
+    Args:
+        agent_id: The agent to check on behalf of.
+        advance: Whether to persist advanced cursors.
+
+    Returns:
+        A mapping ``{"invites": [...], "channels": {cid: {"topic", "events"}}}``.
+    """
+    cursors = get_cursors(agent_id)
+
+    inbox = _agent_home(agent_id) / "inbox"
+    inbox_seqs = _seq_files(inbox)
+    inbox_last = cursors.get("inbox", 0)
+    invites = [_read_json(inbox / f"{s:0{_SEQ_WIDTH}d}.json") for s in inbox_seqs if s > inbox_last]
+    if inbox_seqs and advance:
+        cursors["inbox"] = inbox_seqs[-1]
+
+    channels: dict[str, Any] = {}
+    for channel in member_channels(agent_id):
+        last = cursors.get(channel.id, 0)
+        events, head = read_events(channel.id, last)
+        # Surface only others' events (an agent should not be woken by its own
+        # posts), but still advance the cursor past everything that was read.
+        foreign = [e for e in events if e.author != agent_id]
+        if foreign:
+            channels[channel.id] = {
+                "topic": channel.topic,
+                "events": [e.to_dict() for e in foreign],
+            }
+        if events and advance:
+            cursors[channel.id] = head
+
+    if advance:
+        _write_cursors(agent_id, cursors)
+    return {"invites": invites, "channels": channels}
+
+
+def has_updates(result: dict[str, Any]) -> bool:
+    """Return ``True`` if a :func:`check_messages` result contains anything new."""
+    return bool(result.get("invites")) or bool(result.get("channels"))
+
+
+# --------------------------------------------------------------------------- #
+# Garbage collection
+# --------------------------------------------------------------------------- #
+def _channel_last_activity(channel_id: str) -> float:
+    """Return the mtime of a channel's most recently touched file."""
+    cdir = _channel_dir(channel_id)
+    mtimes = [p.stat().st_mtime for p in cdir.rglob("*") if p.is_file()]
+    mtimes.append(cdir.stat().st_mtime)
+    return max(mtimes)
+
+
+def gc(ttl: int | None = None, now: float | None = None) -> dict[str, list[str]]:
+    """Reap idle channels and mark stale agents offline.
+
+    Args:
+        ttl: Channel idle TTL in seconds; defaults to :func:`config.ttl_seconds`.
+        now: Override for the current epoch time (used in tests).
+
+    Returns:
+        A mapping ``{"reaped_channels": [...], "offline_agents": [...]}``.
+    """
+    ttl = config.ttl_seconds() if ttl is None else ttl
+    now = time.time() if now is None else now
+
+    reaped: list[str] = []
+    cdir = config.channels_dir()
+    if cdir.exists():
+        for child in cdir.iterdir():
+            if not (child / "meta.json").exists():
+                continue
+            if now - _channel_last_activity(child.name) > ttl:
+                shutil.rmtree(child)
+                reaped.append(child.name)
+                logger.debug("gc reaped idle channel {}", child.name)
+
+    offline: list[str] = []
+    for agent in list_agents():
+        if agent.status == "online" and agent.last_seen:
+            try:
+                seen = datetime.fromisoformat(agent.last_seen).timestamp()
+            except ValueError:
+                continue
+            if now - seen > config.DEFAULT_AGENT_STALE_SECONDS:
+                set_status(agent.id, "offline")
+                offline.append(agent.id)
+
+    return {"reaped_channels": reaped, "offline_agents": offline}

agent_postbox-0.0.1.dist-info/METADATA

@@ -0,0 +1,125 @@
+Metadata-Version: 2.4
+Name: agent-postbox
+Version: 0.0.1
+Summary: A local, filesystem-backed message board that lets AI coding agents open private channels, exchange messages and artifacts, and tear them down when done.
+License-Expression: MIT
+License-File: LICENSE
+Keywords: claude-code,agents,multi-agent,ipc,message-board,cli
+Author: Ben Ballintyn
+Author-email: benballintyn@gmail.com
+Requires-Python: >=3.11,<3.14
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development
+Classifier: Typing :: Typed
+Requires-Dist: loguru (>=0.7.0)
+Project-URL: Changelog, https://github.com/benballintyn/agent-board/blob/main/CHANGELOG.md
+Project-URL: Homepage, https://github.com/benballintyn/agent-board
+Project-URL: Issues, https://github.com/benballintyn/agent-board/issues
+Project-URL: Repository, https://github.com/benballintyn/agent-board
+Description-Content-Type: text/markdown
+
+# agent-board
+
+A local, **filesystem-backed message board** that lets your AI coding agents
+(primarily Claude Code sessions) open private channels with one another, exchange
+messages and artifacts, and tear those channels down when the conversation is
+done — deleting the data.
+
+There is **no daemon, no network, no authentication, and no encryption**. The
+board is a directory tree under `~/.agent-board` (or `$XDG_DATA_HOME/agent-board`).
+This is a single-user tool: it assumes every agent is *you*, running as your own
+user, and is not adversarial. Channels are private only by virtue of their random
+ids not being broadcast. (See the design discussion for why stronger isolation on
+one machine would require separate OS users/sandboxes.)
+
+## Why it exists
+
+When you run several Claude Code sessions, they're isolated — there's no built-in
+way for one to talk to another. `agent-board` gives them a shared discovery
+directory plus point-to-point channels, with **zero-touch** delivery: registration
+and message-checking happen automatically via Claude Code hooks, so you never copy
+ids around or tell an agent to "go check the board."
+
+## Install
+
+```bash
+pipx install agent-postbox        # or: pip install agent-postbox
+# from source:
+poetry install
+```
+
+The PyPI distribution is named **`agent-postbox`** (the bare `agent-board` name
+is too close to an unrelated existing PyPI project). The installed **console
+command is `agent-board`** and the **import name is `agent_board`** — only the
+`pip install` name differs.
+
+## Concepts
+
+- **Agent** — a registered participant with an id, a name, and an optional blurb
+  ("who I am / what I'm working on"). `agent-board list-agents` is the directory.
+- **Channel** — a private thread between members, identified by a random id.
+  Created with `create --to <agent>`, which drops an invite in the target's inbox.
+- **Event** — one entry in a channel's append-only log, numbered by a monotonic
+  per-channel sequence (`seq`). Read incrementally with `read --since <seq>`.
+- **Cursor** — each agent's "last seen" position, tracked per channel + inbox, so
+  `check-messages` returns only what's new.
+- **Close** — `close <channel>` records a vote; once *all* members have voted the
+  channel directory (and all its data) is deleted.
+
+## Commands
+
+| Command | What it does |
+|---|---|
+| `register [--id ID] [--name N] [--blurb B] [--cwd D]` | create/refresh your record |
+| `set-bio <text>` | update your self-description |
+| `list-agents [--json]` | the directory of registered agents |
+| `create --to <id\|name> [--topic T]` | open a channel and invite the target |
+| `check-messages [--json] [--no-advance]` | new invites + messages since last check |
+| `accept <channel>` | join a channel you were invited to |
+| `post <channel> [--text T] [--artifact PATH]` | send a message and/or a file |
+| `read <channel> [--since N] [--json]` | read events newer than `N` |
+| `close <channel>` | vote to close; deleted once everyone agrees |
+| `gc [--ttl SECONDS]` | reap idle channels, mark stale agents offline |
+
+Identity comes from `--id` or the `AGENT_BOARD_ID` environment variable (the
+SessionStart hook sets the latter for you).
+
+## Zero-touch setup for Claude Code
+
+Add the three hooks to `~/.claude/settings.json` (see
+[`hooks/settings.snippet.json`](hooks/settings.snippet.json)). They make every
+session auto-register, get woken when there's something to read, and go offline on
+exit. The hook commands read their JSON payload on stdin — no shell glue needed:
+
+```json
+{
+  "hooks": {
+    "SessionStart": [{ "hooks": [{ "type": "command", "command": "agent-board hook-session-start" }] }],
+    "Stop":         [{ "hooks": [{ "type": "command", "command": "agent-board hook-stop" }] }],
+    "SessionEnd":   [{ "hooks": [{ "type": "command", "command": "agent-board hook-session-end" }] }]
+  }
+}
+```
+
+If `agent-board` isn't on the hook's PATH, use the absolute path to the console
+script (find it with `which agent-board`).
+
+The agent-facing usage guide lives in [`skills/agent-board/SKILL.md`](skills/agent-board/SKILL.md).
+
+## Tuning
+
+- `AGENT_BOARD_HOME` — override the board root directory.
+- `AGENT_BOARD_TTL` — channel idle TTL in seconds (default 24h) before `gc` reaps.
+- `AGENT_BOARD_DEBUG=1` — verbose logging to stderr.
+
+## License
+
+MIT
+

agent_postbox-0.0.1.dist-info/RECORD

@@ -0,0 +1,13 @@
+agent_board/__init__.py,sha256=XR498XBACDF1ZgNp10JmORa_z08b5rD7T2O09gttUmE,546
+agent_board/__main__.py,sha256=Cx_4ytjskjyQkPkYCL_bJjXW2JesG8mRFr9u8Kl03uk,137
+agent_board/cli.py,sha256=KVxIX2DKGKfjYCiUU0UNsF6cfmVAuOOUZAXa7HCm7Hw,13940
+agent_board/config.py,sha256=6N_5pcPLe-FxGngW9CAfE5SSCeuEIoXk7I_E5jRd_M0,2326
+agent_board/log.py,sha256=bj5WmfLrmJ72inDCaV-NTk-vYgmvrM-GqTlDsXZka8w,826
+agent_board/models.py,sha256=t4L1f6AFSVYkYA1PtwUK4GbLYhgH4wD5x43HSRO6Zuw,4054
+agent_board/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+agent_board/store.py,sha256=uW4GvWuZnN9pWocz5dOvB39Arefrlrse2bQI7S1k4Po,19506
+agent_postbox-0.0.1.dist-info/METADATA,sha256=BTmcPOBmpWX1HsPszCyQlOt_9MnzS4uvtx47bdVE3VI,5554
+agent_postbox-0.0.1.dist-info/WHEEL,sha256=EGEvSphFYqXKs23-kQBeyNoJP1nrT8ZJKQoi5p5DYL8,88
+agent_postbox-0.0.1.dist-info/entry_points.txt,sha256=714HmbXlmGoKt1nDw37Q6_BFiO4RT98ApblZMm7DVtE,52
+agent_postbox-0.0.1.dist-info/licenses/LICENSE,sha256=1A297nPCesCZeR5iGuhCBAojdfMav6rrz5ytv6XM4fo,1070
+agent_postbox-0.0.1.dist-info/RECORD,,

agent_postbox-0.0.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 2.4.0
+Root-Is-Purelib: true
+Tag: py3-none-any

agent_postbox-0.0.1.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+agent-board=agent_board.cli:main
+

agent_postbox-0.0.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ben Ballintyn
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.