signalpipe-daemon 1.0.0__tar.gz

signalpipe_daemon-1.0.0/LICENSE

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

signalpipe_daemon-1.0.0/PKG-INFO

@@ -0,0 +1,103 @@
+Metadata-Version: 2.4
+Name: signalpipe-daemon
+Version: 1.0.0
+Summary: User-side sender for SignalPipe v4 — streams pre-drafted, pre-approved missions and posts them with your own Reddit/X credentials. The math runs on SignalPipe; the sending runs on you.
+Author: SignalPipe
+License: MIT
+Project-URL: Homepage, https://signalpipe.io
+Keywords: signalpipe,outreach,reddit,twitter,sse,automation
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Communications
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.28
+Provides-Extra: reddit
+Requires-Dist: praw>=7.7; extra == "reddit"
+Provides-Extra: twitter
+Requires-Dist: tweepy>=4.14; extra == "twitter"
+Provides-Extra: all
+Requires-Dist: praw>=7.7; extra == "all"
+Requires-Dist: tweepy>=4.14; extra == "all"
+Dynamic: license-file
+
+# signalpipe-daemon
+
+**The user-side sender for [SignalPipe](https://signalpipe.io) v4.**
+
+> SignalPipe is the intelligence layer for outreach. We never see your Reddit
+> credentials, never see your LLM keys, never store your prospects.
+> **The math runs on us. The sending runs on you.**
+
+This daemon holds a Server-Sent-Events stream open to your SignalPipe brain,
+receives missions the brain has already scored, drafted, and approved, posts
+them with **your own** platform credentials, and acknowledges the result. It
+never sees your LLM keys, never scores or drafts anything itself, and stores no
+prospects. It only sends.
+
+## Install
+
+```bash
+pip install "signalpipe-daemon[all]"     # both Reddit + X senders
+pip install "signalpipe-daemon[reddit]"  # Reddit only
+pip install "signalpipe-daemon[twitter]" # X / Twitter only
+pip install signalpipe-daemon            # base; pulls only `requests`
+```
+
+The platform SDKs (`praw`, `tweepy`) are optional extras and are imported only
+when a mission for that channel actually arrives — install just the ones you use.
+
+## Configure
+
+Copy `.env.example` to `.env` and fill it in, or export the variables directly.
+A real environment variable always wins over a `.env` entry.
+
+| Variable | Purpose |
+| --- | --- |
+| `SIGNALPIPE_KEY` | **Required.** Your operator key from the dashboard. |
+| `SIGNALPIPE_API_URL` | Brain URL. Defaults to `https://api.signalpipe.io`. |
+| `REDDIT_CLIENT_ID` / `REDDIT_CLIENT_SECRET` / `REDDIT_USERNAME` / `REDDIT_PASSWORD` | A Reddit *script* app on your sending account. Enables `reddit_comment` and `reddit_dm`. |
+| `X_API_KEY` / `X_API_SECRET` / `X_ACCESS_TOKEN` / `X_ACCESS_SECRET` | X / Twitter app creds. Enables `twitter_reply`. |
+| `MAX_TWITTER_ACTIONS_PER_DAY` | Default 10. |
+| `MAX_REDDIT_DMS_PER_DAY` | Default 5. |
+| `MAX_REDDIT_COMMENTS_PER_DAY` | Default 15. |
+
+Your platform credentials stay on your machine. They are used only to talk to
+Reddit / X directly and are **never** sent to SignalPipe.
+
+## Run
+
+```bash
+signalpipe-daemon status          # validate the key, print queue depth, exit
+signalpipe-daemon run             # stream missions and send them
+signalpipe-daemon run --dry-run   # log intended sends without posting or acking
+```
+
+`run` holds the stream open and reconnects with exponential backoff on any
+network drop. A rejected key (401) is fatal and exits non-zero; everything else
+is treated as transient. Stop with `Ctrl-C`.
+
+## How a mission flows
+
+1. The brain scores a signal, drafts a reply, and (once approved) marks the
+   mission ready. It streams the mission to this daemon over SSE.
+2. The daemon posts the pre-written draft on the mission's channel
+   (`twitter_reply`, `reddit_comment`, or `reddit_dm`) using your credentials.
+   Missions on the `manual` channel are skipped — you send those yourself.
+3. The daemon acks the outcome. A failure tagged `banned` or `rate_limited`
+   tells the brain to pause your stream for a cool-down.
+
+**Daily caps** pace your sending; when a cap is hit the mission is *skipped*, not
+failed, so it remains queued and retries after the next local-midnight reset.
+
+**Delivery:** missions are delivered at-least-once. Within a running process the
+daemon will never post the same mission twice, even across reconnects — so a
+dropped connection is always safe to recover from.
+
+## License
+
+MIT — see [LICENSE](LICENSE).

signalpipe_daemon-1.0.0/README.md

@@ -0,0 +1,76 @@
+# signalpipe-daemon
+
+**The user-side sender for [SignalPipe](https://signalpipe.io) v4.**
+
+> SignalPipe is the intelligence layer for outreach. We never see your Reddit
+> credentials, never see your LLM keys, never store your prospects.
+> **The math runs on us. The sending runs on you.**
+
+This daemon holds a Server-Sent-Events stream open to your SignalPipe brain,
+receives missions the brain has already scored, drafted, and approved, posts
+them with **your own** platform credentials, and acknowledges the result. It
+never sees your LLM keys, never scores or drafts anything itself, and stores no
+prospects. It only sends.
+
+## Install
+
+```bash
+pip install "signalpipe-daemon[all]"     # both Reddit + X senders
+pip install "signalpipe-daemon[reddit]"  # Reddit only
+pip install "signalpipe-daemon[twitter]" # X / Twitter only
+pip install signalpipe-daemon            # base; pulls only `requests`
+```
+
+The platform SDKs (`praw`, `tweepy`) are optional extras and are imported only
+when a mission for that channel actually arrives — install just the ones you use.
+
+## Configure
+
+Copy `.env.example` to `.env` and fill it in, or export the variables directly.
+A real environment variable always wins over a `.env` entry.
+
+| Variable | Purpose |
+| --- | --- |
+| `SIGNALPIPE_KEY` | **Required.** Your operator key from the dashboard. |
+| `SIGNALPIPE_API_URL` | Brain URL. Defaults to `https://api.signalpipe.io`. |
+| `REDDIT_CLIENT_ID` / `REDDIT_CLIENT_SECRET` / `REDDIT_USERNAME` / `REDDIT_PASSWORD` | A Reddit *script* app on your sending account. Enables `reddit_comment` and `reddit_dm`. |
+| `X_API_KEY` / `X_API_SECRET` / `X_ACCESS_TOKEN` / `X_ACCESS_SECRET` | X / Twitter app creds. Enables `twitter_reply`. |
+| `MAX_TWITTER_ACTIONS_PER_DAY` | Default 10. |
+| `MAX_REDDIT_DMS_PER_DAY` | Default 5. |
+| `MAX_REDDIT_COMMENTS_PER_DAY` | Default 15. |
+
+Your platform credentials stay on your machine. They are used only to talk to
+Reddit / X directly and are **never** sent to SignalPipe.
+
+## Run
+
+```bash
+signalpipe-daemon status          # validate the key, print queue depth, exit
+signalpipe-daemon run             # stream missions and send them
+signalpipe-daemon run --dry-run   # log intended sends without posting or acking
+```
+
+`run` holds the stream open and reconnects with exponential backoff on any
+network drop. A rejected key (401) is fatal and exits non-zero; everything else
+is treated as transient. Stop with `Ctrl-C`.
+
+## How a mission flows
+
+1. The brain scores a signal, drafts a reply, and (once approved) marks the
+   mission ready. It streams the mission to this daemon over SSE.
+2. The daemon posts the pre-written draft on the mission's channel
+   (`twitter_reply`, `reddit_comment`, or `reddit_dm`) using your credentials.
+   Missions on the `manual` channel are skipped — you send those yourself.
+3. The daemon acks the outcome. A failure tagged `banned` or `rate_limited`
+   tells the brain to pause your stream for a cool-down.
+
+**Daily caps** pace your sending; when a cap is hit the mission is *skipped*, not
+failed, so it remains queued and retries after the next local-midnight reset.
+
+**Delivery:** missions are delivered at-least-once. Within a running process the
+daemon will never post the same mission twice, even across reconnects — so a
+dropped connection is always safe to recover from.
+
+## License
+
+MIT — see [LICENSE](LICENSE).

signalpipe_daemon-1.0.0/pyproject.toml

@@ -0,0 +1,36 @@
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "signalpipe-daemon"
+version = "1.0.0"
+description = "User-side sender for SignalPipe v4 — streams pre-drafted, pre-approved missions and posts them with your own Reddit/X credentials. The math runs on SignalPipe; the sending runs on you."
+readme = "README.md"
+requires-python = ">=3.9"
+license = { text = "MIT" }
+authors = [{ name = "SignalPipe" }]
+keywords = ["signalpipe", "outreach", "reddit", "twitter", "sse", "automation"]
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Topic :: Communications",
+]
+dependencies = ["requests>=2.28"]
+
+[project.optional-dependencies]
+reddit = ["praw>=7.7"]
+twitter = ["tweepy>=4.14"]
+all = ["praw>=7.7", "tweepy>=4.14"]
+
+[project.scripts]
+signalpipe-daemon = "signalpipe_daemon.cli:main"
+
+[project.urls]
+Homepage = "https://signalpipe.io"
+
+[tool.setuptools]
+packages = ["signalpipe_daemon"]

signalpipe_daemon-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

signalpipe_daemon-1.0.0/signalpipe_daemon/__init__.py

@@ -0,0 +1,12 @@
+"""SignalPipe Daemon — the user-side sender for SignalPipe v4.
+
+The math runs on SignalPipe. The sending runs on you.
+
+This daemon holds a Server-Sent-Events stream open to your SignalPipe brain,
+receives missions the brain has already scored, drafted, and approved, posts
+them with YOUR own platform credentials, and acknowledges the result. It never
+sees your LLM keys, never scores or drafts anything itself, and stores no
+prospects. It only sends.
+"""
+
+__version__ = "1.0.0"

signalpipe_daemon-1.0.0/signalpipe_daemon/cli.py

@@ -0,0 +1,72 @@
+"""Command-line entry point: `signalpipe-daemon run` / `status`."""
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+from typing import Optional, Sequence
+
+from . import __version__
+from .client import AuthError, SignalPipeClient
+from .config import load_config
+from .daemon import run
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    p = argparse.ArgumentParser(
+        prog="signalpipe-daemon",
+        description="Send SignalPipe missions with your own platform "
+                    "credentials. The math runs on SignalPipe; the sending "
+                    "runs on you.",
+    )
+    p.add_argument("--version", action="version",
+                   version=f"signalpipe-daemon {__version__}")
+    p.add_argument("--api-url", default=None,
+                   help="Brain URL (default: $SIGNALPIPE_API_URL or "
+                        "https://api.signalpipe.io)")
+    p.add_argument("--key", default=None,
+                   help="Operator key (default: $SIGNALPIPE_KEY)")
+
+    sub = p.add_subparsers(dest="command")
+
+    run_p = sub.add_parser("run", help="Stream missions and send them.")
+    run_p.add_argument("--dry-run", action="store_true",
+                       help="Log intended sends without posting or acking.")
+
+    sub.add_parser("status", help="Print account/queue status and exit.")
+    return p
+
+
+def main(argv: Optional[Sequence[str]] = None) -> int:
+    parser = _build_parser()
+    args = parser.parse_args(argv)
+
+    config = load_config(api_url=args.api_url, key=args.key)
+    if not config.key:
+        print("error: no operator key. Set SIGNALPIPE_KEY or pass --key.",
+              file=sys.stderr)
+        return 2
+
+    command = args.command or "run"
+
+    if command == "status":
+        client = SignalPipeClient(config.api_url, config.key)
+        try:
+            print(json.dumps(client.status(), indent=2))
+            return 0
+        except AuthError:
+            print("operator key rejected (401).", file=sys.stderr)
+            return 2
+        except Exception as e:  # noqa: BLE001
+            print(f"error: {e}", file=sys.stderr)
+            return 1
+
+    if command == "run":
+        return run(config, dry_run=getattr(args, "dry_run", False))
+
+    parser.print_help()
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

signalpipe_daemon-1.0.0/signalpipe_daemon/client.py

@@ -0,0 +1,70 @@
+"""HTTP transport to the SignalPipe brain: SSE mission stream + ack + status."""
+from __future__ import annotations
+
+from typing import Iterator, Tuple
+
+import requests
+
+from .sse import parse_sse
+
+_CONNECT_TIMEOUT = 10
+# Read timeout must exceed the server heartbeat (~30s) so a quiet-but-alive
+# stream is not torn down between frames.
+_READ_TIMEOUT = 90
+
+
+class AuthError(Exception):
+    """The operator key was rejected (401) — fatal, do not retry."""
+
+
+class SignalPipeClient:
+    def __init__(self, api_url: str, key: str):
+        self.api_url = api_url.rstrip("/")
+        self.key = key
+
+    def _auth_header(self) -> dict:
+        return {"Authorization": f"Bearer {self.key}"}
+
+    def status(self) -> dict:
+        """GET /v4/sender/status — validates the key and returns queue depth."""
+        r = requests.get(f"{self.api_url}/v4/sender/status",
+                         headers=self._auth_header(), timeout=20)
+        if r.status_code == 401:
+            raise AuthError("operator key rejected (401)")
+        r.raise_for_status()
+        return r.json()
+
+    def ack(self, mission_id: str, outcome: str,
+            error_class: str | None = None,
+            platform_response: str | None = None) -> None:
+        """POST /v4/missions/{id}/ack — report the send result.
+
+        outcome is "success" or "failed". On failure, error_class in
+        {"banned","rate_limited",...} lets the brain pause this tenant's stream.
+        """
+        body: dict = {"outcome": outcome}
+        if error_class:
+            body["error_class"] = error_class
+        if platform_response:
+            body["platform_response"] = platform_response[:500]
+        r = requests.post(f"{self.api_url}/v4/missions/{mission_id}/ack",
+                          json=body, headers=self._auth_header(), timeout=20)
+        if r.status_code == 401:
+            raise AuthError("operator key rejected (401)")
+        r.raise_for_status()
+
+    def stream_missions(self) -> Iterator[Tuple[str, dict]]:
+        """Hold GET /v4/missions/stream open, yielding (event_name, data) frames.
+
+        Raises AuthError on 401; lets requests exceptions propagate on a network
+        drop so the caller can reconnect with backoff.
+        """
+        headers = self._auth_header()
+        headers["Accept"] = "text/event-stream"
+        resp = requests.get(f"{self.api_url}/v4/missions/stream",
+                            headers=headers, stream=True,
+                            timeout=(_CONNECT_TIMEOUT, _READ_TIMEOUT))
+        if resp.status_code == 401:
+            raise AuthError("operator key rejected (401)")
+        resp.raise_for_status()
+        yield from parse_sse(resp.iter_lines(decode_unicode=True))

signalpipe_daemon-1.0.0/signalpipe_daemon/config.py

@@ -0,0 +1,115 @@
+"""Configuration — read entirely from environment variables (optionally a .env).
+
+The daemon needs three things:
+  1. Your SignalPipe operator key   -> SIGNALPIPE_KEY
+  2. The brain URL                   -> SIGNALPIPE_API_URL (defaults to prod)
+  3. Your platform send credentials  -> Reddit and/or X env vars below
+
+Your platform credentials stay on this machine. They are used only to talk to
+Reddit / X directly and are NEVER sent to SignalPipe.
+
+Precedence: an explicit CLI flag > a real environment variable > a .env entry >
+the built-in default.
+"""
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass
+
+DEFAULT_API_URL = "https://api.signalpipe.io"
+
+
+def _load_dotenv(path: str = ".env") -> None:
+    """Minimal KEY=VALUE .env loader so we don't take a dependency on python-dotenv.
+
+    Uses os.environ.setdefault, so a real environment variable always wins over
+    a .env entry.
+    """
+    if not os.path.isfile(path):
+        return
+    try:
+        with open(path, "r", encoding="utf-8") as fh:
+            for line in fh:
+                line = line.strip()
+                if not line or line.startswith("#") or "=" not in line:
+                    continue
+                key, _, val = line.partition("=")
+                val = val.strip().strip('"').strip("'")
+                os.environ.setdefault(key.strip(), val)
+    except OSError:
+        pass
+
+
+def _first(*names: str, default: str = "") -> str:
+    for n in names:
+        v = os.getenv(n)
+        if v:
+            return v
+    return default
+
+
+def _int_env(name: str, default: int) -> int:
+    try:
+        return int(os.getenv(name, "") or default)
+    except (TypeError, ValueError):
+        return default
+
+
+@dataclass
+class Config:
+    api_url: str
+    key: str
+    # Reddit — a "script" app's creds on the SENDING account. Enables
+    # reddit_comment (public first-touch) and reddit_dm.
+    reddit_client_id: str = ""
+    reddit_client_secret: str = ""
+    reddit_username: str = ""
+    reddit_password: str = ""
+    reddit_user_agent: str = "signalpipe-daemon/1.0"
+    # X / Twitter — enables twitter_reply.
+    x_api_key: str = ""
+    x_api_secret: str = ""
+    x_access_token: str = ""
+    x_access_secret: str = ""
+    # Daily send caps, per channel. Reset at local midnight. Anti-spam pacing.
+    max_twitter_per_day: int = 10
+    max_reddit_dms_per_day: int = 5
+    max_reddit_comments_per_day: int = 15
+
+    @property
+    def reddit_ready(self) -> bool:
+        return bool(
+            self.reddit_client_id and self.reddit_client_secret
+            and self.reddit_username and self.reddit_password
+        )
+
+    @property
+    def twitter_ready(self) -> bool:
+        return bool(
+            self.x_api_key and self.x_api_secret
+            and self.x_access_token and self.x_access_secret
+        )
+
+
+def load_config(api_url: str | None = None, key: str | None = None,
+                dotenv: bool = True) -> Config:
+    """Build a Config from CLI overrides + environment + optional .env file."""
+    if dotenv:
+        _load_dotenv()
+    return Config(
+        api_url=(api_url or _first("SIGNALPIPE_API_URL", "MANTIDAE_API_URL",
+                                    default=DEFAULT_API_URL)).rstrip("/"),
+        key=key or _first("SIGNALPIPE_KEY", "MANTIDAE_KEY"),
+        reddit_client_id=_first("REDDIT_CLIENT_ID"),
+        reddit_client_secret=_first("REDDIT_CLIENT_SECRET"),
+        reddit_username=_first("REDDIT_USERNAME"),
+        reddit_password=_first("REDDIT_PASSWORD"),
+        reddit_user_agent=_first("REDDIT_USER_AGENT", default="signalpipe-daemon/1.0"),
+        x_api_key=_first("X_API_KEY"),
+        x_api_secret=_first("X_API_SECRET"),
+        x_access_token=_first("X_ACCESS_TOKEN"),
+        x_access_secret=_first("X_ACCESS_SECRET"),
+        max_twitter_per_day=_int_env("MAX_TWITTER_ACTIONS_PER_DAY", 10),
+        max_reddit_dms_per_day=_int_env("MAX_REDDIT_DMS_PER_DAY", 5),
+        max_reddit_comments_per_day=_int_env("MAX_REDDIT_COMMENTS_PER_DAY", 15),
+    )

signalpipe_daemon-1.0.0/signalpipe_daemon/daemon.py

@@ -0,0 +1,176 @@
+"""The daemon loop: hold the mission stream open, send, ack, reconnect.
+
+This is the orchestrator. It owns no platform knowledge (senders.py) and no wire
+format (client.py / sse.py) — it wires them together with a reconnect-with-
+backoff policy and at-least-once delivery handling.
+
+Delivery model: the brain streams every 'approved' mission and only stops once
+it receives an ack. Within one process a `seen` set guarantees each mission is
+posted at most once, even across reconnects. A lost ack therefore never causes a
+double-send (the cardinal outreach sin) — at worst it leaves the brain's copy
+'approved' for later reconciliation. Exactly-once across process *restarts* needs
+brain-side idempotency and is tracked separately.
+"""
+from __future__ import annotations
+
+import time
+from typing import Set
+
+from .client import AuthError, SignalPipeClient
+from .config import Config
+from .senders import Senders
+
+_BACKOFF_START = 1.0
+_BACKOFF_MAX = 60.0
+_ACK_RETRIES = 3
+
+
+def _log(msg: str) -> None:
+    print(f"[signalpipe] {msg}", flush=True)
+
+
+def _version() -> str:
+    from . import __version__
+    return __version__
+
+
+def run(config: Config, dry_run: bool = False) -> int:
+    """Run the sender until interrupted. Returns a process exit code."""
+    client = SignalPipeClient(config.api_url, config.key)
+    senders = Senders(config)
+
+    # Preflight: validate the key and surface account state before streaming.
+    try:
+        status = client.status()
+    except AuthError:
+        _log("operator key rejected (401). Check SIGNALPIPE_KEY.")
+        return 2
+    except Exception as e:  # noqa: BLE001 — network/DNS/timeout at startup
+        _log(f"cannot reach brain at {config.api_url}: {e}")
+        return 1
+
+    _summary(config, status, dry_run)
+
+    seen: Set[str] = set()         # mission ids fully handled this process
+    skip_logged: Set[str] = set()  # skip reasons already printed once
+    backoff = _BACKOFF_START
+
+    try:
+        while True:
+            try:
+                for event, data in client.stream_missions():
+                    if event == "connected":
+                        backoff = _BACKOFF_START  # healthy: fast reconnects
+                        _log(f"connected — auto-fire threshold "
+                             f"{data.get('auto_threshold')}")
+                    elif event == "mission_ready":
+                        _handle(client, senders,
+                                data.get("payload") or data,
+                                seen, skip_logged, dry_run)
+                    elif event == "heartbeat":
+                        if data.get("paused"):
+                            _log(f"stream paused (backoff until "
+                                 f"{data.get('backoff_until')})")
+                    elif event == "shutdown":
+                        reason = data.get("reason")
+                        if reason == "unauthorized":
+                            _log("brain closed stream: unauthorized — exiting.")
+                            return 2
+                        _log(f"brain closed stream ({reason}); reconnecting.")
+                        break
+                # generator exhausted: stream closed cleanly → reconnect below
+            except AuthError:
+                _log("operator key rejected mid-stream (401) — exiting.")
+                return 2
+            except KeyboardInterrupt:
+                raise
+            except Exception as e:  # noqa: BLE001 — any network drop: reconnect
+                _log(f"stream error: {e}; reconnecting in {backoff:.0f}s")
+                time.sleep(backoff)
+                backoff = min(backoff * 2, _BACKOFF_MAX)
+                continue
+            time.sleep(backoff)
+            backoff = min(backoff * 2, _BACKOFF_MAX)
+    except KeyboardInterrupt:
+        _log("shutting down (Ctrl-C).")
+        return 0
+
+
+def _handle(client, senders, mission, seen, skip_logged, dry_run) -> None:
+    mid = mission.get("id")
+    if not mid:
+        _log("mission_ready with no id — ignoring.")
+        return
+    if mid in seen:
+        return  # already handled in this process (at-least-once stream)
+
+    channel = mission.get("outreach_channel") or "manual"
+    result = senders.send(mission, dry_run=dry_run)
+
+    # Skip: nothing was sent. Don't ack, don't mark seen — the mission stays
+    # 'approved' on the brain and we retry it on a future reconnect (e.g. once a
+    # daily cap resets, or once the operator sends a 'manual' one themselves).
+    if result.is_skip:
+        if mid not in skip_logged:
+            _log(f"skip {mid} [{channel}]: {result.detail}")
+            skip_logged.add(mid)
+        return
+
+    if dry_run:
+        _log(f"would-send {mid} [{channel}]: {result.detail}")
+        seen.add(mid)
+        return
+
+    # Past this point the mission is processed exactly once in this process,
+    # regardless of whether the ack lands — so we can never double-send.
+    seen.add(mid)
+
+    if result.outcome == "success":
+        _log(f"sent {mid} [{channel}]: {result.detail}")
+        _ack(client, mid, "success", platform_response=result.detail)
+    else:
+        _log(f"failed {mid} [{channel}] ({result.error_class}): {result.detail}")
+        _ack(client, mid, "failed", error_class=result.error_class,
+             platform_response=result.detail)
+
+
+def _ack(client, mid, outcome, error_class=None, platform_response=None) -> None:
+    """Best-effort ack with a short retry. The mission is already in `seen`, so a
+    lost ack never re-triggers a send; at worst the brain's copy stays 'approved'
+    for later reconciliation."""
+    for attempt in range(_ACK_RETRIES):
+        try:
+            client.ack(mid, outcome, error_class=error_class,
+                       platform_response=platform_response)
+            return
+        except AuthError:
+            raise  # fatal — bubble to run()
+        except Exception as e:  # noqa: BLE001
+            if attempt == _ACK_RETRIES - 1:
+                _log(f"ack({outcome}) for {mid} failed after retries: {e}")
+                return
+            time.sleep(2)
+
+
+def _summary(config: Config, status: dict, dry_run: bool) -> None:
+    _log(f"SignalPipe daemon v{_version()} — the sending runs on you.")
+    _log(f"brain:    {config.api_url}")
+    _log(f"account:  status={status.get('status', '?')} "
+         f"pending={status.get('missions_pending', '?')} "
+         f"auto_threshold={status.get('auto_threshold', '?')}")
+
+    channels = []
+    if config.twitter_ready:
+        channels.append("twitter_reply")
+    if config.reddit_ready:
+        channels.append("reddit_comment")
+        channels.append("reddit_dm")
+    _log(f"channels: {', '.join(channels) if channels else 'NONE configured'}")
+    _log(f"caps/day: twitter={config.max_twitter_per_day} "
+         f"reddit_dm={config.max_reddit_dms_per_day} "
+         f"reddit_comment={config.max_reddit_comments_per_day}")
+    if dry_run:
+        _log("MODE: dry-run — will NOT send or ack; logs intended actions only.")
+    if not channels:
+        _log("WARNING: no platform credentials set — every mission will fail. "
+             "Configure REDDIT_* and/or X_* env vars.")

signalpipe_daemon-1.0.0/signalpipe_daemon/senders.py

@@ -0,0 +1,218 @@
+"""Platform senders — Reddit (PRAW) and X/Twitter (tweepy), lazily imported.
+
+This is the ONLY module that touches your platform credentials. praw and tweepy
+are optional extras: a base install carries neither, and each client is imported
+only when a mission for that channel actually arrives. So a Reddit-only operator
+never needs tweepy on disk, and vice-versa.
+
+Nothing here scores, drafts, or stores anything. A mission arrives pre-drafted
+from the brain; we post the text with your creds and report the outcome.
+"""
+from __future__ import annotations
+
+import time
+from dataclasses import dataclass
+from random import uniform
+from typing import Optional
+
+# Outcomes the brain understands, plus a local-only "skip" that is never acked.
+_SUCCESS = "success"
+_FAILED = "failed"
+_SKIP = "skip"
+
+
+@dataclass
+class SendResult:
+    outcome: str
+    error_class: Optional[str] = None
+    detail: Optional[str] = None
+    sent: bool = False  # True only once we have actually hit the platform API
+
+    @property
+    def is_skip(self) -> bool:
+        return self.outcome == _SKIP
+
+
+def _classify_error(msg: str) -> str:
+    """Map a platform exception string to the brain's error_class vocabulary.
+
+    The brain pauses a tenant's stream on "banned" (1h) or "rate_limited" (5m);
+    "unknown" is reported for the audit trail but triggers no backoff.
+    """
+    m = msg.lower()
+    if "ratelimit" in m or "rate limit" in m or "429" in m or "too many" in m:
+        return "rate_limited"
+    if any(w in m for w in ("forbidden", "banned", "suspend", "403",
+                            "401", "blocked", "not allowed")):
+        return "banned"
+    return "unknown"
+
+
+def _strip_u(author: str) -> str:
+    """Normalize a Reddit handle: 'u/spez' / '/u/spez' -> 'spez'.
+
+    Uses prefix slicing, NOT str.lstrip — lstrip is character-set based and
+    would eat a leading 'u' from a name like 'umbrella'.
+    """
+    a = author.strip()
+    if a.startswith("/u/"):
+        return a[3:]
+    if a.startswith("u/"):
+        return a[2:]
+    return a
+
+
+class Senders:
+    """Holds the platform clients and per-day send counters.
+
+    Clients are built on first use (lazy import of praw / tweepy) and cached for
+    the life of the process. Counters reset at local midnight.
+    """
+
+    def __init__(self, config):
+        self.config = config
+        self._tw = None
+        self._reddit = None
+        self._day = time.localtime().tm_yday
+        self._twitter_sent = 0
+        self._reddit_dms_sent = 0
+        self._reddit_comments_sent = 0
+
+    # --- lazy clients -----------------------------------------------------
+    def _twitter(self):
+        if self._tw is None:
+            import tweepy  # extra: pip install signalpipe-daemon[twitter]
+            c = self.config
+            self._tw = tweepy.Client(
+                consumer_key=c.x_api_key,
+                consumer_secret=c.x_api_secret,
+                access_token=c.x_access_token,
+                access_token_secret=c.x_access_secret,
+            )
+        return self._tw
+
+    def _reddit_client(self):
+        if self._reddit is None:
+            import praw  # extra: pip install signalpipe-daemon[reddit]
+            c = self.config
+            self._reddit = praw.Reddit(
+                client_id=c.reddit_client_id,
+                client_secret=c.reddit_client_secret,
+                username=c.reddit_username,
+                password=c.reddit_password,
+                user_agent=c.reddit_user_agent,
+            )
+        return self._reddit
+
+    # --- daily caps -------------------------------------------------------
+    def _reset_daily(self) -> None:
+        today = time.localtime().tm_yday
+        if today != self._day:
+            self._day = today
+            self._twitter_sent = 0
+            self._reddit_dms_sent = 0
+            self._reddit_comments_sent = 0
+
+    # --- dispatch ---------------------------------------------------------
+    def send(self, mission: dict, dry_run: bool = False) -> SendResult:
+        """Post one mission's draft on its channel and return the outcome."""
+        self._reset_daily()
+        channel = mission.get("outreach_channel") or "manual"
+        draft = (mission.get("draft_content") or "").strip()
+        target = mission.get("target") or {}
+
+        # "manual" = the brain flagged this for a human. Never auto-send; the
+        # operator handles it through the dashboard/plugin.
+        if channel == "manual":
+            return SendResult(_SKIP, detail="manual channel — operator handles")
+
+        if not draft:
+            return SendResult(_FAILED, error_class="config",
+                              detail="empty draft_content")
+
+        if channel == "twitter_reply":
+            return self._send_twitter(draft, target, dry_run)
+        if channel == "reddit_comment":
+            return self._send_reddit_comment(draft, target, dry_run)
+        if channel == "reddit_dm":
+            return self._send_reddit_dm(draft, target, dry_run)
+
+        return SendResult(_FAILED, error_class="config",
+                          detail=f"unknown channel '{channel}'")
+
+    # --- per-channel ------------------------------------------------------
+    def _send_twitter(self, draft, target, dry_run) -> SendResult:
+        if not self.config.twitter_ready:
+            return SendResult(_FAILED, error_class="config",
+                              detail="X credentials not configured")
+        if self._twitter_sent >= self.config.max_twitter_per_day:
+            # Skip, not fail: the mission stays 'approved' and retries tomorrow.
+            return SendResult(_SKIP, detail="daily twitter cap reached")
+
+        url = (target.get("url") or "").rstrip("/")
+        tweet_id = url.split("/")[-1] if url else ""
+        if not tweet_id.isdigit():
+            return SendResult(_FAILED, error_class="config",
+                              detail=f"cannot parse tweet id from '{url}'")
+
+        if dry_run:
+            return SendResult(_SUCCESS, sent=False,
+                              detail=f"[dry-run] reply to tweet {tweet_id}")
+        try:
+            self._twitter().create_tweet(text=draft,
+                                         in_reply_to_tweet_id=tweet_id)
+        except Exception as e:  # noqa: BLE001 — SDKs raise many exception types
+            return SendResult(_FAILED, sent=True,
+                              error_class=_classify_error(str(e)), detail=str(e))
+        self._twitter_sent += 1
+        time.sleep(uniform(30, 90))  # anti-spam pacing between sends
+        return SendResult(_SUCCESS, sent=True, detail=f"replied to {tweet_id}")
+
+    def _send_reddit_comment(self, draft, target, dry_run) -> SendResult:
+        if not self.config.reddit_ready:
+            return SendResult(_FAILED, error_class="config",
+                              detail="Reddit credentials not configured")
+        if self._reddit_comments_sent >= self.config.max_reddit_comments_per_day:
+            return SendResult(_SKIP, detail="daily reddit-comment cap reached")
+
+        url = (target.get("url") or "").strip()
+        if not url:
+            return SendResult(_FAILED, error_class="config",
+                              detail="no target url for reddit_comment")
+
+        if dry_run:
+            return SendResult(_SUCCESS, sent=False,
+                              detail=f"[dry-run] comment on {url}")
+        try:
+            self._reddit_client().submission(url=url).reply(draft)
+        except Exception as e:  # noqa: BLE001
+            return SendResult(_FAILED, sent=True,
+                              error_class=_classify_error(str(e)), detail=str(e))
+        self._reddit_comments_sent += 1
+        time.sleep(uniform(30, 90))
+        return SendResult(_SUCCESS, sent=True, detail=f"commented on {url}")
+
+    def _send_reddit_dm(self, draft, target, dry_run) -> SendResult:
+        if not self.config.reddit_ready:
+            return SendResult(_FAILED, error_class="config",
+                              detail="Reddit credentials not configured")
+        if self._reddit_dms_sent >= self.config.max_reddit_dms_per_day:
+            return SendResult(_SKIP, detail="daily reddit-DM cap reached")
+
+        author = _strip_u(target.get("author") or "")
+        if not author:
+            return SendResult(_FAILED, error_class="config",
+                              detail="no target author for reddit_dm")
+
+        if dry_run:
+            return SendResult(_SUCCESS, sent=False,
+                              detail=f"[dry-run] DM to u/{author}")
+        try:
+            self._reddit_client().redditor(author).message(
+                subject="Quick question", message=draft)
+        except Exception as e:  # noqa: BLE001
+            return SendResult(_FAILED, sent=True,
+                              error_class=_classify_error(str(e)), detail=str(e))
+        self._reddit_dms_sent += 1
+        time.sleep(uniform(60, 180))
+        return SendResult(_SUCCESS, sent=True, detail=f"DM sent to u/{author}")

signalpipe_daemon-1.0.0/signalpipe_daemon/sse.py

@@ -0,0 +1,45 @@
+"""Server-Sent-Events frame parser — pure stdlib (json only), no transport.
+
+Kept separate from client.py so it carries no `requests` dependency and can be
+unit-tested against a plain list of lines.
+"""
+from __future__ import annotations
+
+import json
+from typing import Iterable, Iterator, Tuple
+
+
+def parse_sse(lines: Iterable[str]) -> Iterator[Tuple[str, dict]]:
+    """Turn a stream of SSE text lines into (event_name, data_dict) frames.
+
+    A frame ends on a blank line. `event:` sets the name (default "message");
+    `data:` lines are concatenated with newlines then JSON-decoded. Comment
+    lines (starting with ":") and id/retry fields are ignored. Malformed JSON is
+    surfaced as {"_raw": <text>} rather than silently dropped.
+    """
+    event: str | None = None
+    data_lines: list[str] = []
+    for raw in lines:
+        if raw is None:
+            continue
+        line = raw.rstrip("\r")
+        if line == "":
+            if event is not None or data_lines:
+                payload = "\n".join(data_lines)
+                try:
+                    data = json.loads(payload) if payload else {}
+                except json.JSONDecodeError:
+                    data = {"_raw": payload}
+                yield (event or "message", data)
+            event, data_lines = None, []
+            continue
+        if line.startswith(":"):
+            continue  # SSE comment / keep-alive ping
+        field, _, value = line.partition(":")
+        if value.startswith(" "):
+            value = value[1:]
+        if field == "event":
+            event = value
+        elif field == "data":
+            data_lines.append(value)
+        # id / retry fields are intentionally ignored

signalpipe_daemon-1.0.0/signalpipe_daemon.egg-info/PKG-INFO

@@ -0,0 +1,103 @@
+Metadata-Version: 2.4
+Name: signalpipe-daemon
+Version: 1.0.0
+Summary: User-side sender for SignalPipe v4 — streams pre-drafted, pre-approved missions and posts them with your own Reddit/X credentials. The math runs on SignalPipe; the sending runs on you.
+Author: SignalPipe
+License: MIT
+Project-URL: Homepage, https://signalpipe.io
+Keywords: signalpipe,outreach,reddit,twitter,sse,automation
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Communications
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.28
+Provides-Extra: reddit
+Requires-Dist: praw>=7.7; extra == "reddit"
+Provides-Extra: twitter
+Requires-Dist: tweepy>=4.14; extra == "twitter"
+Provides-Extra: all
+Requires-Dist: praw>=7.7; extra == "all"
+Requires-Dist: tweepy>=4.14; extra == "all"
+Dynamic: license-file
+
+# signalpipe-daemon
+
+**The user-side sender for [SignalPipe](https://signalpipe.io) v4.**
+
+> SignalPipe is the intelligence layer for outreach. We never see your Reddit
+> credentials, never see your LLM keys, never store your prospects.
+> **The math runs on us. The sending runs on you.**
+
+This daemon holds a Server-Sent-Events stream open to your SignalPipe brain,
+receives missions the brain has already scored, drafted, and approved, posts
+them with **your own** platform credentials, and acknowledges the result. It
+never sees your LLM keys, never scores or drafts anything itself, and stores no
+prospects. It only sends.
+
+## Install
+
+```bash
+pip install "signalpipe-daemon[all]"     # both Reddit + X senders
+pip install "signalpipe-daemon[reddit]"  # Reddit only
+pip install "signalpipe-daemon[twitter]" # X / Twitter only
+pip install signalpipe-daemon            # base; pulls only `requests`
+```
+
+The platform SDKs (`praw`, `tweepy`) are optional extras and are imported only
+when a mission for that channel actually arrives — install just the ones you use.
+
+## Configure
+
+Copy `.env.example` to `.env` and fill it in, or export the variables directly.
+A real environment variable always wins over a `.env` entry.
+
+| Variable | Purpose |
+| --- | --- |
+| `SIGNALPIPE_KEY` | **Required.** Your operator key from the dashboard. |
+| `SIGNALPIPE_API_URL` | Brain URL. Defaults to `https://api.signalpipe.io`. |
+| `REDDIT_CLIENT_ID` / `REDDIT_CLIENT_SECRET` / `REDDIT_USERNAME` / `REDDIT_PASSWORD` | A Reddit *script* app on your sending account. Enables `reddit_comment` and `reddit_dm`. |
+| `X_API_KEY` / `X_API_SECRET` / `X_ACCESS_TOKEN` / `X_ACCESS_SECRET` | X / Twitter app creds. Enables `twitter_reply`. |
+| `MAX_TWITTER_ACTIONS_PER_DAY` | Default 10. |
+| `MAX_REDDIT_DMS_PER_DAY` | Default 5. |
+| `MAX_REDDIT_COMMENTS_PER_DAY` | Default 15. |
+
+Your platform credentials stay on your machine. They are used only to talk to
+Reddit / X directly and are **never** sent to SignalPipe.
+
+## Run
+
+```bash
+signalpipe-daemon status          # validate the key, print queue depth, exit
+signalpipe-daemon run             # stream missions and send them
+signalpipe-daemon run --dry-run   # log intended sends without posting or acking
+```
+
+`run` holds the stream open and reconnects with exponential backoff on any
+network drop. A rejected key (401) is fatal and exits non-zero; everything else
+is treated as transient. Stop with `Ctrl-C`.
+
+## How a mission flows
+
+1. The brain scores a signal, drafts a reply, and (once approved) marks the
+   mission ready. It streams the mission to this daemon over SSE.
+2. The daemon posts the pre-written draft on the mission's channel
+   (`twitter_reply`, `reddit_comment`, or `reddit_dm`) using your credentials.
+   Missions on the `manual` channel are skipped — you send those yourself.
+3. The daemon acks the outcome. A failure tagged `banned` or `rate_limited`
+   tells the brain to pause your stream for a cool-down.
+
+**Daily caps** pace your sending; when a cap is hit the mission is *skipped*, not
+failed, so it remains queued and retries after the next local-midnight reset.
+
+**Delivery:** missions are delivered at-least-once. Within a running process the
+daemon will never post the same mission twice, even across reconnects — so a
+dropped connection is always safe to recover from.
+
+## License
+
+MIT — see [LICENSE](LICENSE).

signalpipe_daemon-1.0.0/signalpipe_daemon.egg-info/SOURCES.txt

@@ -0,0 +1,17 @@
+LICENSE
+README.md
+pyproject.toml
+signalpipe_daemon/__init__.py
+signalpipe_daemon/cli.py
+signalpipe_daemon/client.py
+signalpipe_daemon/config.py
+signalpipe_daemon/daemon.py
+signalpipe_daemon/senders.py
+signalpipe_daemon/sse.py
+signalpipe_daemon.egg-info/PKG-INFO
+signalpipe_daemon.egg-info/SOURCES.txt
+signalpipe_daemon.egg-info/dependency_links.txt
+signalpipe_daemon.egg-info/entry_points.txt
+signalpipe_daemon.egg-info/requires.txt
+signalpipe_daemon.egg-info/top_level.txt
+tests/test_daemon.py

signalpipe_daemon-1.0.0/signalpipe_daemon.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

signalpipe_daemon-1.0.0/signalpipe_daemon.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+signalpipe-daemon = signalpipe_daemon.cli:main

signalpipe_daemon-1.0.0/signalpipe_daemon.egg-info/requires.txt

@@ -0,0 +1,11 @@
+requests>=2.28
+
+[all]
+praw>=7.7
+tweepy>=4.14
+
+[reddit]
+praw>=7.7
+
+[twitter]
+tweepy>=4.14

signalpipe_daemon-1.0.0/signalpipe_daemon.egg-info/top_level.txt

@@ -0,0 +1 @@
+signalpipe_daemon

signalpipe_daemon-1.0.0/tests/test_daemon.py

@@ -0,0 +1,148 @@
+"""Offline unit tests — pure stdlib, no network, no requests/praw/tweepy.
+
+Deliberately imports only sse, senders, and config so the suite runs on a base
+checkout with zero third-party deps installed.
+
+    python tests/test_daemon.py        # plain runner
+    python -m pytest tests/            # also works
+"""
+import os
+import sys
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from signalpipe_daemon.config import Config
+from signalpipe_daemon.senders import Senders, _classify_error, _strip_u
+from signalpipe_daemon.sse import parse_sse
+
+
+def test_parse_sse():
+    lines = [
+        ": keep-alive ping",
+        "event: connected",
+        'data: {"auto_threshold": 1.01, "heartbeat_seconds": 30}',
+        "",
+        "event: mission_ready",
+        'data: {"payload": {"id": "m1", "outreach_channel": "manual"}}',
+        "",
+        "event: heartbeat",
+        'data: {"paused": false}',
+        "",
+    ]
+    frames = list(parse_sse(lines))
+    assert frames[0][0] == "connected"
+    assert frames[0][1]["auto_threshold"] == 1.01
+    assert frames[1][0] == "mission_ready"
+    assert frames[1][1]["payload"]["id"] == "m1"
+    assert frames[2][0] == "heartbeat"
+    assert frames[2][1]["paused"] is False
+
+
+def test_parse_sse_malformed_json():
+    frames = list(parse_sse(["data: not json", ""]))
+    assert frames[0][1] == {"_raw": "not json"}
+
+
+def test_parse_sse_multiline_data():
+    frames = list(parse_sse(['data: {"a":', 'data: 1}', ""]))
+    assert frames[0][1] == {"a": 1}
+
+
+def test_classify_error():
+    assert _classify_error("429 Too Many Requests") == "rate_limited"
+    assert _classify_error("RATELIMIT: try again later") == "rate_limited"
+    assert _classify_error("403 Forbidden") == "banned"
+    assert _classify_error("account suspended") == "banned"
+    assert _classify_error("connection reset by peer") == "unknown"
+
+
+def test_strip_u():
+    assert _strip_u("u/spez") == "spez"
+    assert _strip_u("/u/spez") == "spez"
+    assert _strip_u("spez") == "spez"
+    assert _strip_u("umbrella") == "umbrella"  # not eaten by a naive lstrip
+
+
+def _cfg(**kw):
+    base = dict(api_url="https://x", key="k")
+    base.update(kw)
+    return Config(**base)
+
+
+def _x_creds(**kw):
+    return _cfg(x_api_key="a", x_api_secret="b",
+                x_access_token="c", x_access_secret="d", **kw)
+
+
+def test_dispatch_manual_skips():
+    r = Senders(_cfg()).send({"id": "m1", "outreach_channel": "manual",
+                              "draft_content": "hi"})
+    assert r.is_skip and not r.sent
+
+
+def test_dispatch_empty_draft_fails():
+    r = Senders(_x_creds()).send({"id": "m1", "outreach_channel": "twitter_reply",
+                                  "draft_content": "   "})
+    assert r.outcome == "failed" and r.error_class == "config"
+
+
+def test_dispatch_unknown_channel_fails():
+    r = Senders(_cfg()).send({"id": "m1", "outreach_channel": "carrier_pigeon",
+                              "draft_content": "hi"})
+    assert r.outcome == "failed"
+
+
+def test_dispatch_twitter_dry_run():
+    r = Senders(_x_creds()).send(
+        {"id": "m1", "outreach_channel": "twitter_reply",
+         "draft_content": "hello",
+         "target": {"url": "https://x.com/u/status/12345"}},
+        dry_run=True)
+    assert r.outcome == "success"
+    assert r.sent is False  # dry-run never hits the API
+
+
+def test_dispatch_twitter_no_creds_fails():
+    r = Senders(_cfg()).send(
+        {"id": "m1", "outreach_channel": "twitter_reply",
+         "draft_content": "hello",
+         "target": {"url": "https://x.com/u/status/12345"}},
+        dry_run=True)
+    assert r.outcome == "failed" and r.error_class == "config"
+
+
+def test_dispatch_twitter_bad_url_fails():
+    r = Senders(_x_creds()).send(
+        {"id": "m1", "outreach_channel": "twitter_reply",
+         "draft_content": "hello",
+         "target": {"url": "https://x.com/u/no-numeric-id/"}},
+        dry_run=True)
+    assert r.outcome == "failed" and r.error_class == "config"
+
+
+def test_dispatch_twitter_cap_skips():
+    r = Senders(_x_creds(max_twitter_per_day=0)).send(
+        {"id": "m1", "outreach_channel": "twitter_reply",
+         "draft_content": "hello",
+         "target": {"url": "https://x.com/u/status/12345"}},
+        dry_run=True)
+    assert r.is_skip
+
+
+def test_dispatch_reddit_comment_dry_run():
+    cfg = _cfg(reddit_client_id="i", reddit_client_secret="s",
+               reddit_username="u", reddit_password="p")
+    r = Senders(cfg).send(
+        {"id": "m1", "outreach_channel": "reddit_comment",
+         "draft_content": "hello",
+         "target": {"url": "https://reddit.com/r/x/comments/abc/post/"}},
+        dry_run=True)
+    assert r.outcome == "success" and r.sent is False
+
+
+if __name__ == "__main__":
+    tests = [v for k, v in sorted(globals().items()) if k.startswith("test_")]
+    for t in tests:
+        t()
+        print(f"  ok  {t.__name__}")
+    print(f"\nall {len(tests)} tests passed")