message-poster 0.1.0__py3-none-any.whl

message_poster/__init__.py

@@ -0,0 +1,10 @@
+"""message-poster — pick up email and Teams events via OAuth, POST to a webhook."""
+
+from importlib.metadata import PackageNotFoundError, version as _version
+
+try:
+    __version__ = _version("message-poster")
+except PackageNotFoundError:  # running from a source tree that was never installed
+    __version__ = "0.0.0+unknown"
+
+USER_AGENT = "message-poster/" + __version__

message_poster/_version.py

@@ -0,0 +1,24 @@
+# file generated by vcs-versioning
+# don't change, don't track in version control
+from __future__ import annotations
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+version: str
+__version__: str
+__version_tuple__: tuple[int | str, ...]
+version_tuple: tuple[int | str, ...]
+commit_id: str | None
+__commit_id__: str | None
+
+__version__ = version = '0.1.0'
+__version_tuple__ = version_tuple = (0, 1, 0)
+
+__commit_id__ = commit_id = None

message_poster/auth.py

@@ -0,0 +1,171 @@
+"""
+Microsoft Graph auth and HTTP, via MSAL device-code flow.
+
+Device code is the default on purpose:
+  - it needs no redirect URI and no listening socket, so it works on managed
+    machines and under a scheduled task;
+  - the browser step can be completed in whichever session the tenant's
+    Conditional Access policy is willing to accept, which is not necessarily
+    the machine running this code.
+
+After the first sign-in the refresh token keeps later runs silent. Conditional
+Access can force periodic re-auth; when that happens the silent path returns
+nothing and we say so plainly rather than failing obscurely.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import time
+from pathlib import Path
+
+import msal
+import requests
+
+from . import USER_AGENT  # version-tracking, single definition
+
+GRAPH = "https://graph.microsoft.com/v1.0"
+
+# Delegated, read-only. This tool must never be able to send, delete or modify
+# anything in the source tenant.
+SCOPES = [
+    "Mail.Read",
+    "Chat.Read",
+    "ChannelMessage.Read.All",
+    "Team.ReadBasic.All",
+    "User.Read",
+]
+
+
+def cache_path(config_dir: Path, profile: str) -> Path:
+    return config_dir / f".token-cache-{profile}.json"
+
+
+def _build_app(cfg: dict, config_dir: Path, profile: str):
+    cache = msal.SerializableTokenCache()
+    p = cache_path(config_dir, profile)
+    if p.is_file():
+        cache.deserialize(p.read_text(encoding="utf-8"))
+
+    authority = "https://login.microsoftonline.com/" + cfg.get(
+        "azure_tenant_id", "organizations"
+    )
+    app = msal.PublicClientApplication(
+        client_id=cfg["azure_client_id"], authority=authority, token_cache=cache
+    )
+    return app, cache
+
+
+def _persist(cache, config_dir: Path, profile: str) -> None:
+    if cache.has_state_changed:
+        p = cache_path(config_dir, profile)
+        tmp = p.with_suffix(".tmp")
+        tmp.write_text(cache.serialize(), encoding="utf-8")
+        os.replace(tmp, p)
+        try:
+            os.chmod(p, 0o600)  # best effort; a no-op on some filesystems
+        except OSError:
+            pass
+
+
+def get_token(cfg: dict, config_dir: Path, profile: str, *, interactive: bool = False) -> str:
+    app, cache = _build_app(cfg, config_dir, profile)
+
+    accounts = app.get_accounts()
+    if accounts and not interactive:
+        result = app.acquire_token_silent(SCOPES, account=accounts[0])
+        if result and "access_token" in result:
+            _persist(cache, config_dir, profile)
+            return result["access_token"]
+
+    if not interactive:
+        raise RuntimeError(
+            f"no usable cached token — run: message-poster login --profile {profile}\n"
+            "(Conditional Access can force periodic re-auth; this is that.)"
+        )
+
+    flow = app.initiate_device_flow(scopes=SCOPES)
+    if "user_code" not in flow:
+        raise RuntimeError(
+            f"device flow failed to start: {flow.get('error_description')}"
+        )
+
+    print("\n" + "=" * 68)
+    print(f"  Go to: {flow['verification_uri']}")
+    print(f"  Code:  {flow['user_code']}")
+    print("=" * 68)
+    print("  Complete this in a browser session the tenant's Conditional")
+    print("  Access policy will accept. Waiting...\n", flush=True)
+
+    result = app.acquire_token_by_device_flow(flow)  # blocks until done/expired
+    if "access_token" not in result:
+        raise RuntimeError(
+            f"sign-in failed: {result.get('error')}: {result.get('error_description')}"
+        )
+    _persist(cache, config_dir, profile)
+    return result["access_token"]
+
+
+class GraphClient:
+    """Minimal Graph client: GET with paging, throttling and retry."""
+
+    def __init__(self, cfg: dict, config_dir: Path, profile: str):
+        self.cfg = cfg
+        self.config_dir = config_dir
+        self.profile = profile
+        self._token = None
+        self._fetched_at = 0.0
+        self.session = requests.Session()
+        self.session.headers["User-Agent"] = USER_AGENT
+
+    def _auth_header(self) -> dict:
+        # Tokens last ~1h; refresh early rather than racing expiry mid-run.
+        if not self._token or time.time() - self._fetched_at > 2400:
+            self._token = get_token(self.cfg, self.config_dir, self.profile)
+            self._fetched_at = time.time()
+        return {"Authorization": f"Bearer {self._token}"}
+
+    def get(self, path: str, params: dict | None = None) -> dict:
+        url = path if path.startswith("http") else GRAPH + path
+        for attempt in range(1, 5):
+            r = self.session.get(
+                url, headers=self._auth_header(), params=params, timeout=60
+            )
+
+            if r.status_code == 200:
+                return r.json()
+
+            # Graph throttles hard on a full-mailbox walk. Honour Retry-After.
+            if r.status_code == 429:
+                wait = int(r.headers.get("Retry-After", 2 ** attempt))
+                print(f"    throttled, waiting {wait}s", flush=True)
+                time.sleep(wait)
+                continue
+
+            if r.status_code == 401 and attempt == 1:
+                self._token = None  # force one refresh, then give up
+                continue
+
+            if r.status_code in (500, 502, 503, 504):
+                time.sleep(2 ** attempt)
+                continue
+
+            raise RuntimeError(f"GET {url} -> {r.status_code}: {r.text[:300]}")
+
+        raise RuntimeError(f"GET {url}: gave up after retries")
+
+    def paged(self, path: str, params: dict | None = None, cap: int = 1000):
+        """Yield items across @odata.nextLink pages, up to cap."""
+        seen = 0
+        data = self.get(path, params)
+        while True:
+            for item in data.get("value", []):
+                yield item
+                seen += 1
+                if seen >= cap:
+                    return
+            nxt = data.get("@odata.nextLink")
+            if not nxt:
+                return
+            data = self.get(nxt)  # nextLink already carries the query string

message_poster/cli.py

@@ -0,0 +1,234 @@
+"""
+message-poster — pick up email and Teams events, POST them to a webhook.
+
+    message-poster login   --profile work
+    message-poster whoami  --profile work
+    message-poster run     --profile work --dry-run
+    message-poster run     --profile work
+
+State lives next to the config file: a watermark per profile, so each run only
+picks up what is new. On a first run, with no saved watermark, the window
+defaults to the last 24 hours rather than the whole mailbox — a fresh install
+should never start by hauling years of history.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import sys
+from datetime import datetime, timedelta, timezone
+from pathlib import Path
+
+from . import collect as collect_mod
+from .auth import GraphClient, get_token
+from .render import Filters, newest_timestamp
+from .webhook import build_payload, chunked, post_batch
+
+ISO = "%Y-%m-%dT%H:%M:%SZ"
+DEFAULT_LOOKBACK_HOURS = 24
+
+
+def default_config_dir() -> Path:
+    env = os.environ.get("MESSAGE_POSTER_HOME")
+    if env:
+        return Path(env)
+    base = os.environ.get("APPDATA")  # Windows
+    if base:
+        return Path(base) / "message-poster"
+    return Path(os.path.expanduser("~")) / ".config" / "message-poster"
+
+
+def log(msg):
+    stamp = datetime.now(timezone.utc).strftime("%H:%M:%S")
+    print("[" + stamp + "] " + str(msg), flush=True)
+
+
+def load_json(path: Path, default=None):
+    if path.is_file():
+        try:
+            return json.loads(path.read_text(encoding="utf-8"))
+        except json.JSONDecodeError:
+            log("WARNING: " + path.name + " is not valid JSON")
+    return default
+
+
+def save_json(path: Path, data) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    tmp = path.with_suffix(".tmp")
+    tmp.write_text(json.dumps(data, indent=2, sort_keys=True), encoding="utf-8")
+    os.replace(tmp, path)
+
+
+def resolve_since(state_entry, args) -> str:
+    """Work out the window start.
+
+    Priority: explicit --since, then the saved watermark, then a 24h default.
+    The default matters: without it a first run would either fetch everything
+    or need a flag nobody remembers to pass.
+    """
+    if getattr(args, "since", None):
+        return args.since
+    saved = (state_entry or {}).get("watermark")
+    if saved:
+        return saved
+    hours = getattr(args, "lookback_hours", None) or DEFAULT_LOOKBACK_HOURS
+    start = datetime.now(timezone.utc) - timedelta(hours=hours)
+    log("no saved watermark — defaulting to the last " + str(hours) + "h")
+    return start.strftime(ISO)
+
+
+def cmd_login(cfg, cfg_dir, args) -> int:
+    get_token(cfg, cfg_dir, args.profile, interactive=True)
+    log("signed in")
+    return cmd_whoami(cfg, cfg_dir, args)
+
+
+def cmd_whoami(cfg, cfg_dir, args) -> int:
+    me = GraphClient(cfg, cfg_dir, args.profile).get("/me")
+    print("  " + str(me.get("displayName")) + " <" + str(me.get("userPrincipalName")) + ">")
+    return 0
+
+
+def cmd_run(cfg, cfg_dir, args) -> int:
+    state_path = cfg_dir / "state.json"
+    state = load_json(state_path, {}) or {}
+    entry = state.setdefault(args.profile, {})
+
+    since = resolve_since(entry, args)
+    log("profile=" + args.profile + " what=" + args.what + " since=" + since
+        + (" DRY-RUN" if args.dry_run else ""))
+
+    filters = Filters(cfg)
+    gc = GraphClient(cfg, cfg_dir, args.profile)
+
+    items = []
+    try:
+        if args.what in ("chats", "all"):
+            items += collect_mod.collect_chats(gc, filters, since, cfg, log)
+        if args.what in ("channels", "all"):
+            items += collect_mod.collect_channels(gc, filters, since, cfg, log)
+        if args.what in ("mail", "all"):
+            items += collect_mod.collect_mail(gc, filters, since, cfg, log)
+    except RuntimeError as e:
+        log("FATAL: " + str(e))
+        log("If this is an auth error: message-poster login --profile " + args.profile)
+        return 1
+
+    if filters.counts:
+        log("excluded by filter: " + json.dumps(filters.counts))
+
+    # Advance to the newest item actually seen, not wall-clock now: anything
+    # arriving mid-run would otherwise be skipped forever.
+    watermark = newest_timestamp(items) or since
+
+    if not items:
+        log("nothing new")
+        entry["watermark"] = watermark
+        entry["last_run"] = datetime.now(timezone.utc).strftime(ISO)
+        save_json(state_path, state)
+        return 0
+
+    log(str(len(items)) + " item(s) to post")
+
+    if args.dry_run:
+        out = cfg_dir / "dry-run"
+        out.mkdir(parents=True, exist_ok=True)
+        for it in items:
+            (out / it["filename"]).write_text(it["rendered"], encoding="utf-8")
+        log("DRY RUN: wrote " + str(len(items)) + " file(s) to " + str(out)
+            + " — nothing posted")
+        return 0
+
+    batches = list(chunked(items, cfg.get("max_batch_bytes", 32 * 1024 * 1024)))
+    written = 0
+    skipped = 0
+
+    for i, batch in enumerate(batches, 1):
+        payload = build_payload(
+            args.profile, batch, watermark,
+            complete=(i == len(batches)), excluded=filters.counts,
+        )
+        try:
+            res = post_batch(cfg, payload, log)
+        except RuntimeError as e:
+            log("FATAL: " + str(e))
+            log("watermark NOT advanced — the next run retries this window")
+            save_json(state_path, state)
+            return 1
+        written += res.get("written", 0) or 0
+        skipped += res.get("skipped_unchanged", 0) or 0
+        log("  batch " + str(i) + "/" + str(len(batches))
+            + ": " + json.dumps({k: res.get(k) for k in
+                                 ("written", "skipped_unchanged", "rejected")}))
+
+    # Only advance once every batch has landed.
+    entry["watermark"] = watermark
+    entry["last_run"] = datetime.now(timezone.utc).strftime(ISO)
+    entry["last_result"] = {"written": written, "skipped": skipped}
+    save_json(state_path, state)
+    log("done: written=" + str(written) + " skipped=" + str(skipped)
+        + "; watermark -> " + watermark)
+    return 0
+
+
+def main(argv=None) -> int:
+    ap = argparse.ArgumentParser(
+        prog="message-poster",
+        description="Pick up email and Teams events via OAuth, POST them to a webhook.",
+    )
+    ap.add_argument("--config-dir", type=Path, default=default_config_dir(),
+                    help="where config.json, state.json and token caches live")
+    sub = ap.add_subparsers(dest="command", required=True)
+
+    def common(p):
+        p.add_argument("--profile", default="default",
+                       help="named account/config to use (default: default)")
+
+    p_login = sub.add_parser("login", help="interactive device-code sign-in")
+    common(p_login)
+
+    p_who = sub.add_parser("whoami", help="verify the cached token")
+    common(p_who)
+
+    p_run = sub.add_parser("run", help="collect events and post them")
+    common(p_run)
+    p_run.add_argument("--what", choices=["chats", "channels", "mail", "all"],
+                       default="all")
+    p_run.add_argument("--dry-run", action="store_true",
+                       help="render locally and post nothing")
+    p_run.add_argument("--since", help="ISO8601 start; overrides the saved watermark")
+    p_run.add_argument("--lookback-hours", type=int, default=DEFAULT_LOOKBACK_HOURS,
+                       help="window to use when no watermark is saved (default: 24)")
+
+    args = ap.parse_args(argv)
+
+    cfg_dir = args.config_dir
+    cfg_path = cfg_dir / "config.json"
+    cfg = load_json(cfg_path)
+    if not cfg:
+        print("no config at " + str(cfg_path), file=sys.stderr)
+        print("create it — see the example in the README", file=sys.stderr)
+        return 2
+
+    required = ["azure_client_id"]
+    if args.command == "run" and not args.dry_run:
+        required += ["webhook_url", "hmac_secret"]
+    missing = [k for k in required if not cfg.get(k)]
+    if missing:
+        print("config missing: " + ", ".join(missing), file=sys.stderr)
+        return 2
+
+    handlers = {"login": cmd_login, "whoami": cmd_whoami, "run": cmd_run}
+    try:
+        return handlers[args.command](cfg, cfg_dir, args)
+    except RuntimeError as e:
+        print("ERROR: " + str(e), file=sys.stderr)
+        return 1
+    except KeyboardInterrupt:
+        return 130
+
+
+if __name__ == "__main__":
+    sys.exit(main())

message_poster/collect.py

@@ -0,0 +1,220 @@
+"""
+Collect message events from Microsoft Graph.
+
+Endpoints used (all delegated, all read-only):
+
+  GET /me/chats                      ?$expand=members
+  GET /me/chats/{id}/messages
+  GET /me/joinedTeams
+  GET /teams/{id}/channels
+  GET /teams/{id}/channels/{id}/messages
+  GET /me/mailFolders
+  GET /me/messages                   ?$filter=receivedDateTime ge ...
+
+Every function returns items in the shape the webhook receives:
+kind, source_id, filename, rendered.
+"""
+
+from __future__ import annotations
+
+import hashlib
+
+from .render import Filters, render_chat, render_email, slug
+
+
+def _hash8(value):
+    return hashlib.sha1(value.encode()).hexdigest()[:8]
+
+
+def _chat_title(chat, me_id=None):
+    """Group chats carry a topic; 1:1 chats do not, so name them by participant."""
+    if chat.get("topic"):
+        return chat["topic"]
+    names = [
+        m.get("displayName")
+        for m in (chat.get("members") or [])
+        if m.get("displayName") and m.get("userId") != me_id
+    ]
+    if names:
+        extra = len(names) - 3
+        return ", ".join(names[:3]) + (" +" + str(extra) if extra > 0 else "")
+    return "Direct chat"
+
+
+def _readable(chat):
+    """Skip calendar-derived stubs the caller cannot actually read.
+
+    Graph returns these with chatType 'unknownFutureValue' and no members;
+    fetching their messages fails with an ACL error.
+    """
+    return not (chat.get("chatType") == "unknownFutureValue" and not chat.get("members"))
+
+
+def collect_chats(gc, filters, since, cfg, log=print):
+    items = []
+    me_id = None
+    try:
+        me_id = gc.get("/me").get("id")
+    except RuntimeError:
+        pass  # only used to prettify 1:1 titles
+
+    chats = list(
+        gc.paged("/me/chats", {"$expand": "members", "$top": 50},
+                 cap=cfg.get("max_chats_per_run", 300))
+    )
+    log("chats: " + str(len(chats)) + " visible")
+
+    skipped_stub = 0
+    skipped_old = 0
+    for chat in chats:
+        cid = chat.get("id", "")
+        if not cid or filters.skip_source(cid):
+            continue
+        if not _readable(chat):
+            skipped_stub += 1
+            continue
+        if since and (chat.get("lastUpdatedDateTime") or "") <= since:
+            skipped_old += 1
+            continue
+
+        try:
+            msgs = list(
+                gc.paged("/me/chats/" + cid + "/messages",
+                         {"$top": 50, "$orderby": "createdDateTime desc"},
+                         cap=cfg.get("max_messages_per_chat", 200))
+            )
+        except RuntimeError as e:
+            log("  skip " + cid[:28] + ": " + str(e))
+            continue
+
+        msgs = [m for m in msgs if (m.get("body") or {}).get("content")]
+        if not msgs:
+            continue
+        msgs.sort(key=lambda m: m.get("createdDateTime") or "")
+
+        topic = _chat_title(chat, me_id)
+        rendered = render_chat(topic, "teams", msgs, filters)
+        if rendered.count("\n") < 3:
+            continue  # nothing but system events
+
+        items.append({
+            "kind": "chat",
+            "source_id": cid,
+            "filename": "chat-" + slug(topic) + "-" + _hash8(cid) + ".md",
+            "rendered": rendered,
+        })
+        log("  + " + topic[:52] + " (" + str(len(msgs)) + " msgs)")
+
+    if skipped_stub or skipped_old:
+        log("  (" + str(skipped_stub) + " unreadable stubs, "
+            + str(skipped_old) + " unchanged)")
+    return items
+
+
+def collect_channels(gc, filters, since, cfg, log=print):
+    """Team channel posts — often where decisions land, unlike 1:1 chat."""
+    items = []
+    try:
+        teams = list(gc.paged("/me/joinedTeams", cap=50))
+    except RuntimeError as e:
+        log("channels: skipped (" + str(e) + ")")
+        return items
+    log("teams: " + str(len(teams)))
+
+    for team in teams:
+        tid = team.get("id")
+        tname = team.get("displayName") or "team"
+        if not tid:
+            continue
+        try:
+            channels = list(gc.paged("/teams/" + tid + "/channels", cap=50))
+        except RuntimeError as e:
+            log("  " + tname + ": no channels (" + str(e) + ")")
+            continue
+
+        for ch in channels:
+            chid = ch.get("id")
+            chname = ch.get("displayName") or "channel"
+            key = tid + "/" + str(chid)
+            if not chid or filters.skip_source(key):
+                continue
+            try:
+                msgs = list(
+                    gc.paged("/teams/" + tid + "/channels/" + chid + "/messages",
+                             {"$top": 50},
+                             cap=cfg.get("max_messages_per_chat", 200))
+                )
+            except RuntimeError as e:
+                log("  " + tname + "/" + chname + ": " + str(e))
+                continue
+
+            msgs = [m for m in msgs if (m.get("body") or {}).get("content")]
+            if since:
+                msgs = [m for m in msgs if (m.get("createdDateTime") or "") > since]
+            if not msgs:
+                continue
+            msgs.sort(key=lambda m: m.get("createdDateTime") or "")
+
+            topic = tname + " / " + chname
+            rendered = render_chat(topic, "teams", msgs, filters)
+            if rendered.count("\n") < 3:
+                continue
+
+            items.append({
+                "kind": "chat",
+                "source_id": key,
+                "filename": "chat-" + slug(topic) + "-" + _hash8(key) + ".md",
+                "rendered": rendered,
+            })
+            log("  + " + topic[:52] + " (" + str(len(msgs)) + " msgs)")
+    return items
+
+
+def collect_mail(gc, filters, since, cfg, log=print):
+    items = []
+    account = cfg.get("account", "unknown")
+
+    # Resolve excluded folder names to ids, so exclusion can be checked against
+    # each message's parentFolderId.
+    excluded_ids = set()
+    try:
+        for f in gc.paged("/me/mailFolders", {"$top": 100}, cap=200):
+            if filters.skip_folder(f.get("displayName", "")):
+                excluded_ids.add(f.get("id"))
+    except RuntimeError as e:
+        log("mailFolders unavailable (" + str(e) + "); folder excludes not applied")
+
+    params = {
+        "$top": 50,
+        "$orderby": "receivedDateTime desc",
+        "$select": ("id,subject,from,toRecipients,receivedDateTime,"
+                    "body,bodyPreview,parentFolderId,hasAttachments"),
+    }
+    if since:
+        params["$filter"] = "receivedDateTime ge " + since
+
+    raw = list(gc.paged("/me/messages", params, cap=cfg.get("max_mail_per_run", 500)))
+    log("mail: " + str(len(raw)) + " candidates")
+
+    for m in raw:
+        mid = m.get("id", "")
+        if not mid or filters.skip_source(mid):
+            continue
+        if m.get("parentFolderId") in excluded_ids:
+            filters.bump("folder:excluded")
+            continue
+        frm = (m.get("from") or {}).get("emailAddress", {}).get("address", "")
+        if filters.skip_sender(frm):
+            continue
+
+        stamp = (m.get("receivedDateTime") or "")[:10].replace("-", "")
+        subj = slug(m.get("subject") or "no-subject", 40)
+        items.append({
+            "kind": "email",
+            "source_id": mid,
+            "filename": "mail-" + stamp + "-" + subj + "-" + _hash8(mid) + ".md",
+            "rendered": render_email(m, account, filters),
+        })
+
+    log("mail: " + str(len(items)) + " after filters")
+    return items

message_poster/config.example.json

@@ -0,0 +1,19 @@
+{
+  "azure_client_id": "<application id from your Azure app registration>",
+  "azure_tenant_id": "organizations",
+  "account": "you@example.com",
+  "webhook_url": "https://ingest.example.com/ingest",
+  "hmac_secret": "<shared secret, same value the receiver holds>",
+  "webhook_headers": {},
+  "max_mail_per_run": 500,
+  "max_chats_per_run": 300,
+  "max_messages_per_chat": 200,
+  "max_batch_bytes": 33554432,
+  "gzip_over_bytes": 65536,
+  "filters": {
+    "exclude_folders": ["Junk Email", "Deleted Items"],
+    "exclude_sender_patterns": ["payroll@", "noreply@"],
+    "optout_source_ids": [],
+    "redact_patterns": []
+  }
+}

message_poster/render.py

@@ -0,0 +1,171 @@
+"""
+Render Graph objects to markdown, and filter what is allowed to leave.
+
+Rendering happens client-side so that only the text which will actually be
+posted ever leaves the tenant: no raw API payloads, no directory GUIDs, no
+delta tokens, no attachment URLs.
+
+Two output shapes, both plain text and both trivially greppable:
+
+  chat  ->  chat-<slug>-<hash8>.md
+            # Chat: <topic> (<channel>)
+            [YYYY-MM-DDTHH:MM] Sender: message
+
+  email ->  mail-<YYYYMMDD>-<slug>-<hash8>.md
+            From:/To:/Subject:/Date:/Account: headers, blank line, body
+"""
+
+from __future__ import annotations
+
+import re
+import unicodedata
+
+
+def slug(value: str, maxlen: int = 50) -> str:
+    value = unicodedata.normalize("NFKD", value or "")
+    value = value.encode("ascii", "ignore").decode("ascii")
+    value = re.sub(r"[^A-Za-z0-9]+", "-", value).strip("-").lower()
+    return value[:maxlen] or "untitled"
+
+
+def html_to_text(html: str) -> str:
+    """Chat and mail bodies are HTML. Keep the text, drop the markup."""
+    if not html:
+        return ""
+    s = re.sub(r"(?is)<(script|style).*?</\1>", "", html)
+    s = re.sub(r"(?i)<br\s*/?>", "\n", s)
+    s = re.sub(r"(?i)</(p|div|li|tr)>", "\n", s)
+    s = re.sub(r"(?i)<li[^>]*>", "- ", s)
+    s = re.sub(r"<[^>]+>", "", s)
+    for a, b in (
+        ("&nbsp;", " "), ("&amp;", "&"), ("&lt;", "<"),
+        ("&gt;", ">"), ("&quot;", '"'), ("&#39;", "'"),
+    ):
+        s = s.replace(a, b)
+    return re.sub(r"\n{3,}", "\n\n", s).strip()
+
+
+class Filters:
+    """Deny-list applied before anything is rendered or posted.
+
+    When mirroring a whole mailbox the failure mode inverts: anything NOT
+    excluded here gets sent. These rules are the safety mechanism, not an
+    optimisation, and deserve a deliberate read before an unattended run.
+    """
+
+    def __init__(self, cfg: dict):
+        f = (cfg or {}).get("filters", {})
+        self.folders = {x.lower() for x in f.get("exclude_folders", [])}
+        self.senders = [x.lower() for x in f.get("exclude_sender_patterns", [])]
+        self.optout = set(f.get("optout_source_ids", []))
+        self.redactions = [re.compile(p, re.I) for p in f.get("redact_patterns", [])]
+        self.counts: dict = {}
+
+    def bump(self, rule: str) -> None:
+        self.counts[rule] = self.counts.get(rule, 0) + 1
+
+    def skip_folder(self, name: str) -> bool:
+        if (name or "").lower() in self.folders:
+            self.bump("folder:" + str(name))
+            return True
+        return False
+
+    def skip_source(self, source_id: str) -> bool:
+        if source_id in self.optout:
+            self.bump("optout")
+            return True
+        return False
+
+    def skip_sender(self, addr: str) -> bool:
+        a = (addr or "").lower()
+        for pat in self.senders:
+            if pat in a:
+                self.bump("sender:" + pat)
+                return True
+        return False
+
+    def redact(self, text: str) -> str:
+        for rx in self.redactions:
+            text, n = rx.subn("[REDACTED]", text)
+            if n:
+                self.bump("redacted")
+        return text
+
+
+def render_chat(topic: str, channel: str, messages: list, filters: Filters) -> str:
+    lines = ["# Chat: " + (topic or "Untitled") + " (" + channel + ")", ""]
+    for m in messages:
+        ts = (m.get("createdDateTime") or "")[:16]  # YYYY-MM-DDTHH:MM
+        if not ts:
+            continue
+        frm = m.get("from") or {}
+        sender = (
+            (frm.get("user") or {}).get("displayName")
+            or (frm.get("application") or {}).get("displayName")
+            or "Unknown"
+        )
+        body = html_to_text((m.get("body") or {}).get("content", ""))
+        if not body.strip():
+            continue  # system events and reactions carry no text
+        body = filters.redact(body)
+
+        att = m.get("attachments") or []
+        if att:
+            names = ", ".join(
+                a.get("name") or a.get("contentType") or "file" for a in att
+            )
+            body += "\n[attachments: " + names + "]"  # metadata only, never bytes
+
+        lines.append("[" + ts + "] " + sender + ": " + body.replace("\n", "\n    "))
+        lines.append("")
+    return "\n".join(lines).rstrip() + "\n"
+
+
+def render_email(msg: dict, account: str, filters: Filters) -> str:
+    frm = (msg.get("from") or {}).get("emailAddress", {})
+    to = ", ".join(
+        r.get("emailAddress", {}).get("address", "")
+        for r in (msg.get("toRecipients") or [])
+    )
+    body = html_to_text((msg.get("body") or {}).get("content", "")) or (
+        msg.get("bodyPreview") or ""
+    )
+    body = filters.redact(body)
+
+    hdr = [
+        "From: " + str(frm.get("name", "")) + " <" + str(frm.get("address", "")) + ">",
+        "To: " + to,
+        "Subject: " + str(msg.get("subject", "(no subject)")),
+        "Date: " + str(msg.get("receivedDateTime", "")),
+        "Account: " + account,
+    ]
+    att = msg.get("attachments") or []
+    if att:
+        hdr.append(
+            "Attachments: "
+            + ", ".join(
+                str(a.get("name", "file")) + " (" + str(a.get("size", "?")) + "b)"
+                for a in att
+            )
+        )
+    return "\n".join(hdr) + "\n\n" + body.strip() + "\n"
+
+
+def newest_timestamp(items: list):
+    """Highest timestamp actually seen — a safer watermark than wall-clock now.
+
+    Using now() risks skipping anything that arrives while the run is in
+    flight; using the newest item actually processed cannot.
+    """
+    best = None
+    for it in items:
+        for line in it["rendered"].splitlines():
+            if line.startswith("[") and len(line) > 17:
+                ts = line[1:17]
+            elif line.startswith("Date: "):
+                ts = line[6:].strip()[:16]
+            else:
+                continue
+            if best is None or ts > best:
+                best = ts
+    return (best + ":00Z") if best and len(best) == 16 else None

message_poster/webhook.py

@@ -0,0 +1,112 @@
+"""
+POST collected events to a webhook.
+
+The payload is deliberately plain: a profile name, a run id, a watermark, and a
+list of items each carrying pre-rendered markdown. What the receiver does with
+them — store, index, forward, discard — is none of this tool's business.
+
+Every request is signed with HMAC-SHA256 over "<timestamp>.<raw body>" so the
+receiver can verify both origin and integrity, and reject replays. Optional
+extra headers (for an identity-aware proxy in front of the receiver) are passed
+through verbatim from config.
+
+NOTE: requests, never urllib. Some proxies and WAFs reject unknown or absent
+User-Agent strings outright, which surfaces as a confusing 403 that looks like
+an auth failure. A real session with an explicit User-Agent avoids it.
+"""
+
+from __future__ import annotations
+
+import gzip
+import hashlib
+import hmac
+import json
+import os
+import time
+
+import requests
+
+from . import USER_AGENT  # version-tracking, single definition
+
+
+def build_payload(profile, items, watermark, complete=True, excluded=None):
+    run_id = time.strftime("%Y%m%dT%H%M%SZ", time.gmtime()) + "-" + os.urandom(3).hex()
+    return {
+        "profile": profile,
+        "run_id": run_id,
+        "items": items,
+        "watermark": watermark,
+        "complete": complete,
+        "excluded_by_filter": excluded or {},
+    }
+
+
+def sign(secret, body, timestamp):
+    """HMAC-SHA256 over '<timestamp>.<body>'.
+
+    Binding the timestamp into the signed bytes is what makes a replay window
+    meaningful: an old body cannot be re-sent with a fresh timestamp without
+    invalidating the signature.
+    """
+    return "sha256=" + hmac.new(
+        secret.encode(), str(timestamp).encode() + b"." + body, hashlib.sha256
+    ).hexdigest()
+
+
+def post_batch(cfg, payload, log=print):
+    body = json.dumps(payload).encode()
+
+    headers = {
+        "Content-Type": "application/json",
+        "User-Agent": USER_AGENT,
+    }
+    headers.update(cfg.get("webhook_headers") or {})
+
+    if len(body) > cfg.get("gzip_over_bytes", 65536):
+        body = gzip.compress(body)
+        headers["Content-Encoding"] = "gzip"
+
+    ts = int(time.time())
+    headers["X-Timestamp"] = str(ts)
+    headers["X-Signature"] = sign(cfg["hmac_secret"], body, ts)
+
+    url = cfg["webhook_url"]
+    last = None
+    for attempt in range(1, 4):
+        try:
+            r = requests.post(url, data=body, headers=headers, timeout=60)
+            if r.status_code in (200, 207):
+                try:
+                    return r.json()
+                except ValueError:
+                    return {"status_code": r.status_code, "text": r.text[:200]}
+            # A 4xx other than 429 is our own bug; retrying will not fix it.
+            if 400 <= r.status_code < 500 and r.status_code != 429:
+                raise RuntimeError(
+                    "HTTP " + str(r.status_code) + ": " + r.text[:200]
+                )
+            last = "HTTP " + str(r.status_code) + ": " + r.text[:120]
+        except requests.RequestException as e:
+            last = str(e)
+        if attempt < 3:
+            wait = 2 ** attempt
+            log("  retry " + str(attempt) + "/3 in " + str(wait) + "s (" + str(last) + ")")
+            time.sleep(wait)
+
+    raise RuntimeError("upload failed after 3 attempts: " + str(last))
+
+
+def chunked(items, max_bytes):
+    """Split so no single POST exceeds the receiver's body cap."""
+    batch = []
+    size = 0
+    for it in items:
+        n = len(it["rendered"].encode()) + 400
+        if batch and size + n > max_bytes:
+            yield batch
+            batch = []
+            size = 0
+        batch.append(it)
+        size += n
+    if batch:
+        yield batch

message_poster-0.1.0.dist-info/METADATA

@@ -0,0 +1,343 @@
+Metadata-Version: 2.4
+Name: message-poster
+Version: 0.1.0
+Summary: Mirror mail and chat from Microsoft Graph to a webhook, as plain markdown
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/omarmciver/message-poster
+Project-URL: Issues, https://github.com/omarmciver/message-poster/issues
+Keywords: microsoft-graph,outlook,teams,export,mirror,webhook
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: System Administrators
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Communications :: Email
+Classifier: Topic :: System :: Archiving :: Mirroring
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: msal>=1.28
+Requires-Dist: requests>=2.31
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Dynamic: license-file
+
+# message-poster
+
+Pick up recent **email, Teams chats and Teams channel posts** from Microsoft
+Graph, render them to plain markdown, and POST them to a webhook you control.
+
+What the receiver does with the payload — store it, index it, feed it to
+something else, drop it — is out of scope. This tool's only job is to collect
+and deliver.
+
+- **Read-only.** Delegated Graph scopes only; it cannot send, delete or modify
+  anything in the source tenant.
+- **Rendered client-side.** Only the text that will actually be posted leaves
+  the tenant — no raw API payloads, no directory GUIDs, no delta tokens, no
+  attachment URLs.
+- **Attachments are metadata only.** Filename, size and type. Never bytes.
+- **Signed.** Every request carries an HMAC-SHA256 signature over the exact
+  bytes sent.
+
+## Install
+
+```bash
+pip install message-poster
+```
+
+Python 3.9+. Two dependencies (`msal`, `requests`) — deliberately small,
+because this installs on managed machines where every extra package is a
+question somebody has to answer.
+
+## Quick start
+
+```bash
+# 1. Register an Azure app (see below) and write config.json
+# 2. Sign in — device code, so no redirect URI and no listening socket
+message-poster login --profile work
+
+# 3. Check the token works
+message-poster whoami --profile work
+
+# 4. See what would be sent, without sending it
+message-poster run --profile work --dry-run
+
+# 5. For real
+message-poster run --profile work
+```
+
+## Commands
+
+| Command | What it does |
+|---|---|
+| `login` | Interactive device-code sign-in. Prints a URL and a code; caches the refresh token afterwards. |
+| `whoami` | Fetches `/me` with the cached token. The fastest way to tell auth from everything else. |
+| `run` | Collects events since the watermark and POSTs them. |
+
+`run` options:
+
+| Flag | Default | Meaning |
+|---|---|---|
+| `--what {chats,channels,mail,all}` | `all` | Which sources to collect. |
+| `--dry-run` | off | Render to `<config-dir>/dry-run/` and post nothing. |
+| `--since ISO8601` | — | Explicit window start. Overrides the saved watermark. |
+| `--lookback-hours N` | `24` | Window to use when no watermark is saved. |
+
+`--profile NAME` (default `default`) selects a named account within one config
+directory; each profile keeps its own token cache and its own watermark.
+`--config-dir PATH` overrides where everything lives.
+
+Exit codes: `0` success, `1` a run or auth failure, `2` a config problem,
+`130` interrupted.
+
+## Configuration
+
+Config lives at `~/.config/message-poster/config.json`
+(`%APPDATA%\message-poster\config.json` on Windows). Override with
+`--config-dir` or the `MESSAGE_POSTER_HOME` environment variable.
+
+```json
+{
+  "azure_client_id": "<application id from your Azure app registration>",
+  "azure_tenant_id": "organizations",
+  "account": "you@example.com",
+  "webhook_url": "https://ingest.example.com/ingest",
+  "hmac_secret": "<shared secret, same value the receiver holds>",
+  "webhook_headers": {},
+  "max_mail_per_run": 500,
+  "max_chats_per_run": 300,
+  "max_messages_per_chat": 200,
+  "max_batch_bytes": 33554432,
+  "gzip_over_bytes": 65536,
+  "filters": {
+    "exclude_folders": ["Junk Email", "Deleted Items"],
+    "exclude_sender_patterns": ["payroll@", "noreply@"],
+    "optout_source_ids": [],
+    "redact_patterns": []
+  }
+}
+```
+
+| Key | Meaning |
+|---|---|
+| `azure_client_id` | Application (client) ID of your app registration. Required. |
+| `azure_tenant_id` | `organizations`, `common`, or a specific tenant ID. |
+| `account` | Written into each email's `Account:` header, so a receiver can tell mailboxes apart. |
+| `webhook_url` | Where batches are POSTed. Required for a real run. |
+| `hmac_secret` | Shared secret for request signing. Required for a real run. |
+| `webhook_headers` | Free-form map merged into every request — see below. |
+| `max_batch_bytes` | Split threshold, so no single POST exceeds the receiver's body cap. |
+| `gzip_over_bytes` | Bodies larger than this are gzipped. |
+
+`config.json`, `state.json` and `.token-cache-*.json` all live in the config
+directory and none of them belong in version control.
+
+### `webhook_headers`
+
+A free-form map merged into every request. This is where an identity-aware
+proxy's credentials go, so the tool needs no knowledge of any particular proxy:
+
+```json
+"webhook_headers": {
+  "Proxy-Authorization": "Bearer <token>",
+  "X-Tenant": "acme"
+}
+```
+
+### Filters are a **deny-list**
+
+Read this twice before an unattended run. When you mirror a whole mailbox the
+failure mode inverts: **anything not excluded gets sent.** These rules are the
+safety mechanism, not an optimisation.
+
+| Key | Effect |
+|---|---|
+| `exclude_folders` | Mail folder display names to skip entirely. |
+| `exclude_sender_patterns` | Substring match, case-insensitive, against the sender address. |
+| `optout_source_ids` | Chat IDs, `teamId/channelId` pairs or message IDs to never collect. |
+| `redact_patterns` | Regexes; every match becomes `[REDACTED]` before the text is posted. |
+
+Every exclusion is counted and reported in the payload's `excluded_by_filter`,
+so a receiver can see that filtering happened without seeing what was filtered.
+
+## Azure app registration
+
+This is the main setup hurdle. In the Azure portal, under **App registrations**:
+
+1. **New registration.** Any name. No redirect URI is needed.
+2. Under **Authentication**, enable **"Allow public client flows"** — the
+   device-code flow will not start without it.
+3. Under **API permissions**, add these **delegated** Microsoft Graph
+   permissions, all read-only:
+   - `Mail.Read`
+   - `Chat.Read`
+   - `ChannelMessage.Read.All`
+   - `Team.ReadBasic.All`
+   - `User.Read`
+4. Copy the **Application (client) ID** into `azure_client_id`.
+
+Some tenants require an administrator to grant consent for
+`ChannelMessage.Read.All`. If channel collection comes back empty while chats
+and mail work, that is usually why.
+
+## The watermark
+
+State lives in `state.json` next to the config, one entry per profile. Two
+rules matter:
+
+- **The watermark is the newest message actually seen**, not wall-clock `now()`.
+  Using `now()` would permanently skip anything that arrived while the run was
+  in flight.
+- **It only advances after every batch has landed.** A failed POST leaves it
+  where it was, so the next run retries that window.
+
+On a first run with no saved watermark the window defaults to the **last 24
+hours**, not the whole mailbox. `--lookback-hours` widens it and `--since`
+overrides it outright. There is deliberately no `--backfill`: a fresh install
+should never start by hauling years of history through a webhook.
+
+## Payload contract
+
+Anyone can write a receiver. A batch is POSTed as JSON:
+
+```json
+{
+  "profile": "work",
+  "run_id": "20260916T180000Z-a1b2c3",
+  "watermark": "2026-09-16T17:55:00Z",
+  "complete": true,
+  "excluded_by_filter": {"sender:payroll@": 3},
+  "items": [
+    {
+      "kind": "chat",
+      "source_id": "19:abc...@thread.v2",
+      "filename": "chat-project-sync-a1b2c3d4.md",
+      "rendered": "# Chat: Project Sync (teams)\n\n[2026-09-16T09:10] Alice Chen: ...\n"
+    }
+  ]
+}
+```
+
+| Field | Meaning |
+|---|---|
+| `profile` | The `--profile` the run used. |
+| `run_id` | Unique per batch-set: `<UTC timestamp>-<6 hex>`. |
+| `watermark` | Where the sender intends to resume. |
+| `complete` | `false` on every batch but the last of a run. Wait for `true` before treating the window as fully delivered. |
+| `excluded_by_filter` | Counts per rule. Diagnostic only. |
+| `items[].kind` | `chat` or `email`. |
+| `items[].source_id` | Stable Graph identifier for the conversation or message. |
+| `items[].filename` | Suggested filename. Safe: `^[A-Za-z0-9._-]+$`. |
+| `items[].rendered` | The markdown. This is the content. |
+
+A successful receiver responds `200` or `207`. If it returns JSON, the keys
+`written`, `skipped_unchanged` and `rejected` are logged by the sender; any
+other body is ignored.
+
+`rendered` comes in two shapes:
+
+```
+# Chat: <topic> (teams)
+
+[2026-09-16T09:10] Alice Chen: message text
+    continued lines are indented four spaces
+    [attachments: budget.xlsx]
+```
+
+```
+From: Alice Chen <alice@example.com>
+To: bob@example.com
+Subject: Quarterly numbers
+Date: 2026-09-16T09:10:00Z
+Account: you@example.com
+Attachments: budget.xlsx (2048b)
+
+Body text, HTML stripped.
+```
+
+### Verifying a request
+
+Each POST carries:
+
+| Header | Value |
+|---|---|
+| `X-Timestamp` | Unix seconds when the request was signed. |
+| `X-Signature` | `sha256=<hmac_sha256(secret, "<X-Timestamp>." + raw_body)>` |
+| `Content-Encoding` | `gzip`, if the body exceeded `gzip_over_bytes`. |
+
+**The signature covers the compressed bytes as sent.** Verify before you
+decompress.
+
+```python
+import hashlib, hmac
+
+def verify(secret, raw_body, timestamp, signature):
+    expected = "sha256=" + hmac.new(
+        secret.encode(), str(timestamp).encode() + b"." + raw_body, hashlib.sha256
+    ).hexdigest()
+    return hmac.compare_digest(expected, signature)
+```
+
+Two things a receiver should also do:
+
+- **Reject timestamps outside about ±5 minutes** of its own clock. Binding the
+  timestamp into the signed bytes is what makes that window meaningful — an old
+  body cannot be replayed under a fresh timestamp without breaking the
+  signature.
+- **Treat `(source_id, sha256(rendered))` as an idempotency key.** Chats are
+  re-sent whole when they change, so the same `source_id` will arrive more than
+  once; the content hash is what tells a genuine update from a repeat.
+
+## Delivery behaviour
+
+- Batches are split so none exceeds `max_batch_bytes`.
+- Bodies over `gzip_over_bytes` are gzipped.
+- **429 and 5xx retry** three times with exponential backoff.
+- **Any other 4xx fails immediately.** A signature or config error will not fix
+  itself by retrying.
+- Graph throttling (`429`) is honoured via `Retry-After` during collection.
+
+## Running it unattended
+
+`login` is interactive exactly once; after that the cached refresh token keeps
+runs silent, so `run` is safe in cron or a scheduled task. Conditional Access
+can still force periodic re-auth — when it does, the run exits `1` and tells
+you to sign in again rather than failing obscurely.
+
+Device code was chosen for precisely this reason: it needs no redirect URI and
+no listening socket, so the browser step can be completed in whichever session
+the tenant's Conditional Access policy is willing to accept — not necessarily
+the machine running the tool.
+
+## Development
+
+```bash
+pip install -e ".[dev]"
+pytest -q
+```
+
+## Releasing
+
+The **git tag is the version**. `setuptools-scm` derives it at build time, so
+there is no version to bump in a file and nothing that can disagree with the
+tag:
+
+```bash
+git tag v0.1.1
+git push origin v0.1.1
+```
+
+That runs the tests, builds, verifies the built version matches the tag, and
+publishes to PyPI via [Trusted Publishing](https://docs.pypi.org/trusted-publishers/)
+— no API token is stored anywhere — then attaches the artifacts to a GitHub
+Release.
+
+To rehearse the whole path without spending a version number, run the Release
+workflow manually from the Actions tab: a `workflow_dispatch` publishes to
+**TestPyPI** instead of PyPI.
+
+A build from an untagged commit gets a `.devN+g<sha>` suffix, and the release
+job refuses to publish it under a real version number.
+
+## License
+
+MIT — see [LICENSE](LICENSE).

message_poster-0.1.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+message_poster/__init__.py,sha256=xrBKRA6I7GMFsFFZz8CxKy0Yp6bz49hfu6hrQvTfdGU,375
+message_poster/_version.py,sha256=n_5vdJsPNu7wZ57LGuRL585uvll-hiuvZUBWzdG0RQU,520
+message_poster/auth.py,sha256=ZdU5lvhAggeEzXZwpM85r3omNX-VcA0V0LXcBMxR_Ag,5955
+message_poster/cli.py,sha256=jt-7hoiF89TGzAT5B-9R-1tNmEhQEIqEJh91rqpQYUg,8298
+message_poster/collect.py,sha256=GzZHiaI-8Dgb2dBWYMkwzgsN4uJG-Pp3PysJr5W5TuA,7346
+message_poster/config.example.json,sha256=blrFQiD4-1GYbpH0w9IlWLGou_9CONfCGPXNZ-Zy_Xs,627
+message_poster/render.py,sha256=CtvPupw5oz0FDamlDeE_1eOIB4PpR_ddY8FwwhsZIss,5917
+message_poster/webhook.py,sha256=D5gFo4N4R-zuVSGw5ftbEPVaRBS--eRrfM2NJF1V4mw,3674
+message_poster-0.1.0.dist-info/licenses/LICENSE,sha256=jtFXXGHSU3uBIfHbaMfC9YaHg6bcsVnRObY5_c8HImY,1068
+message_poster-0.1.0.dist-info/METADATA,sha256=m6Lxg6CCFc2SPTENK09S6mPBfH3BcKlCiyuEINNeJaU,12145
+message_poster-0.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+message_poster-0.1.0.dist-info/entry_points.txt,sha256=QzR-Z5cSSlg4OPKnrpSdqyYqg8kYB0zGnV4rv6oPr2g,59
+message_poster-0.1.0.dist-info/top_level.txt,sha256=8FhrYyGlwHxZ_WYDwco4HivNk7K1G0z_2EkyVU2-NZc,15
+message_poster-0.1.0.dist-info/RECORD,,

message_poster-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

message_poster-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+message-poster = message_poster.cli:main

message_poster-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Omar McIver
+
+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.

message_poster-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+message_poster