simple-emailer 0.2.0__tar.gz

simple_emailer-0.2.0/MANIFEST.in

@@ -0,0 +1,4 @@
+include SECURITY.md
+include msg.py
+recursive-include docs *.md
+recursive-include tests *.py

simple_emailer-0.2.0/PKG-INFO

@@ -0,0 +1,153 @@
+Metadata-Version: 2.4
+Name: simple-emailer
+Version: 0.2.0
+Summary: A secure local CLI and web interface for sending email through SMTP providers
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+
+# Simple Emailer
+
+Simple Emailer is a local CLI and optional web interface for sending plain-text email through an existing SMTP account. It runs on Python 3.11+, stores no credentials, and has no runtime dependencies.
+
+Email cannot be delivered through Gmail, Yahoo, Outlook, or another reputable provider without that provider authenticating the sender. Simple Emailer has no separate application login, but the SMTP provider still requires an app password or OAuth. The CLI securely prompts for an app password, or reads it from an environment variable so automated commands need no interactive login.
+
+## Install Globally
+
+[`pipx`](https://pipx.pypa.io/) is recommended because it installs an isolated application and exposes `simple-emailer` globally:
+
+```bash
+pipx install .
+simple-emailer --version
+```
+
+For development from this checkout:
+
+```bash
+python3 -m pip install -e .
+```
+
+## Send From The CLI
+
+Set the provider-generated app password without placing it in shell history:
+
+```bash
+read -rsp "App password: " EMAILER_PASSWORD && export EMAILER_PASSWORD
+printf '\n'
+```
+
+Send a message:
+
+```bash
+simple-emailer send \
+  --provider gmail \
+  --from you@gmail.com \
+  --to recipient@example.com \
+  --subject "Hello" \
+  --body "Sent from my terminal"
+```
+
+If `EMAILER_PASSWORD` is not set, the command prompts without displaying the password. The credential is never accepted as a command-line argument, where it could leak through shell history or the process list.
+
+Use a file or standard input for longer messages, and repeat recipient or attachment options:
+
+```bash
+simple-emailer send \
+  --provider yahoo \
+  --from you@yahoo.com \
+  --to first@example.com \
+  --to second@example.com \
+  --cc copy@example.com \
+  --subject "Report" \
+  --body-file message.txt \
+  --attach report.pdf
+
+printf 'Message from a pipeline\n' | simple-emailer send \
+  --provider gmail \
+  --from you@gmail.com \
+  --to recipient@example.com \
+  --subject "Piped message"
+```
+
+Run a complete validation and preview without a credential or network connection:
+
+```bash
+simple-emailer send \
+  --provider gmail \
+  --from you@gmail.com \
+  --to recipient@example.com \
+  --subject "Preview" \
+  --body "Nothing will be sent" \
+  --dry-run
+```
+
+Example output:
+
+```text
+Dry run: no network connection was made.
+Provider: Gmail (smtp.gmail.com:465, tls)
+Envelope from: you@gmail.com
+Envelope recipients: recipient@example.com
+From: you@gmail.com
+To: recipient@example.com
+Subject: Preview
+Body: 20 characters
+```
+
+## Provider Support
+
+Run `simple-emailer providers` to see the built-in status.
+
+| Provider | Authentication | Status |
+| --- | --- | --- |
+| Gmail | App password with 2-Step Verification | Supported |
+| Yahoo Mail | Third-party app password | Supported |
+| Outlook.com | OAuth2 / Modern Auth | Not yet supported |
+| Other SMTP services | Password/app password over TLS | Supported with `custom` |
+
+Microsoft requires OAuth2 for Outlook.com SMTP. A distributable OAuth client requires an application registration, redirect URI, consent configuration, and secure token storage. Until those product credentials exist, Simple Emailer reports Outlook as unavailable rather than attempting obsolete Basic Authentication.
+
+For another SMTP provider, use its documented host, port, TLS mode, and password. This is intentionally available only in the local CLI; the web API retains a fixed provider allowlist.
+
+```bash
+simple-emailer send \
+  --provider custom \
+  --smtp-host smtp.example.com \
+  --smtp-port 587 \
+  --smtp-security starttls \
+  --username account-name \
+  --from sender@example.com \
+  --to recipient@example.net \
+  --subject "Custom SMTP" \
+  --body "Hello"
+```
+
+## Local Web Interface
+
+The original local-first PWA remains available:
+
+```bash
+simple-emailer web
+```
+
+It opens at `http://127.0.0.1:8765`. `simple-emailer` with no subcommand and `python3 msg.py` remain compatible aliases. Use `--no-browser` to prevent automatic browser launch.
+
+## Test
+
+Tests never contact a real SMTP server:
+
+```bash
+python3 -m unittest discover -s tests -v
+python3 -m compileall -q emailer tests msg.py
+```
+
+## Security Model
+
+- SMTP certificates and hostnames are verified with the operating system trust store.
+- TLS 1.2 or newer is required.
+- Credentials are held only for the current process and are not logged or written by the application.
+- Bcc addresses are used only in the SMTP envelope and omitted from message headers.
+- Attachments are capped at 5 files, 8 MB each, and 12 MB total.
+- The web server accepts only loopback bindings and same-origin API requests.
+- The browser API cannot select arbitrary SMTP hosts.
+
+Environment variables can be inspected by sufficiently privileged local processes. For interactive use, leave `EMAILER_PASSWORD` unset and use the hidden prompt. Revoke an app password if a device or credential is compromised. See [SECURITY.md](SECURITY.md) and [docs/ROADMAP.md](docs/ROADMAP.md).

simple_emailer-0.2.0/README.md

@@ -0,0 +1,146 @@
+# Simple Emailer
+
+Simple Emailer is a local CLI and optional web interface for sending plain-text email through an existing SMTP account. It runs on Python 3.11+, stores no credentials, and has no runtime dependencies.
+
+Email cannot be delivered through Gmail, Yahoo, Outlook, or another reputable provider without that provider authenticating the sender. Simple Emailer has no separate application login, but the SMTP provider still requires an app password or OAuth. The CLI securely prompts for an app password, or reads it from an environment variable so automated commands need no interactive login.
+
+## Install Globally
+
+[`pipx`](https://pipx.pypa.io/) is recommended because it installs an isolated application and exposes `simple-emailer` globally:
+
+```bash
+pipx install .
+simple-emailer --version
+```
+
+For development from this checkout:
+
+```bash
+python3 -m pip install -e .
+```
+
+## Send From The CLI
+
+Set the provider-generated app password without placing it in shell history:
+
+```bash
+read -rsp "App password: " EMAILER_PASSWORD && export EMAILER_PASSWORD
+printf '\n'
+```
+
+Send a message:
+
+```bash
+simple-emailer send \
+  --provider gmail \
+  --from you@gmail.com \
+  --to recipient@example.com \
+  --subject "Hello" \
+  --body "Sent from my terminal"
+```
+
+If `EMAILER_PASSWORD` is not set, the command prompts without displaying the password. The credential is never accepted as a command-line argument, where it could leak through shell history or the process list.
+
+Use a file or standard input for longer messages, and repeat recipient or attachment options:
+
+```bash
+simple-emailer send \
+  --provider yahoo \
+  --from you@yahoo.com \
+  --to first@example.com \
+  --to second@example.com \
+  --cc copy@example.com \
+  --subject "Report" \
+  --body-file message.txt \
+  --attach report.pdf
+
+printf 'Message from a pipeline\n' | simple-emailer send \
+  --provider gmail \
+  --from you@gmail.com \
+  --to recipient@example.com \
+  --subject "Piped message"
+```
+
+Run a complete validation and preview without a credential or network connection:
+
+```bash
+simple-emailer send \
+  --provider gmail \
+  --from you@gmail.com \
+  --to recipient@example.com \
+  --subject "Preview" \
+  --body "Nothing will be sent" \
+  --dry-run
+```
+
+Example output:
+
+```text
+Dry run: no network connection was made.
+Provider: Gmail (smtp.gmail.com:465, tls)
+Envelope from: you@gmail.com
+Envelope recipients: recipient@example.com
+From: you@gmail.com
+To: recipient@example.com
+Subject: Preview
+Body: 20 characters
+```
+
+## Provider Support
+
+Run `simple-emailer providers` to see the built-in status.
+
+| Provider | Authentication | Status |
+| --- | --- | --- |
+| Gmail | App password with 2-Step Verification | Supported |
+| Yahoo Mail | Third-party app password | Supported |
+| Outlook.com | OAuth2 / Modern Auth | Not yet supported |
+| Other SMTP services | Password/app password over TLS | Supported with `custom` |
+
+Microsoft requires OAuth2 for Outlook.com SMTP. A distributable OAuth client requires an application registration, redirect URI, consent configuration, and secure token storage. Until those product credentials exist, Simple Emailer reports Outlook as unavailable rather than attempting obsolete Basic Authentication.
+
+For another SMTP provider, use its documented host, port, TLS mode, and password. This is intentionally available only in the local CLI; the web API retains a fixed provider allowlist.
+
+```bash
+simple-emailer send \
+  --provider custom \
+  --smtp-host smtp.example.com \
+  --smtp-port 587 \
+  --smtp-security starttls \
+  --username account-name \
+  --from sender@example.com \
+  --to recipient@example.net \
+  --subject "Custom SMTP" \
+  --body "Hello"
+```
+
+## Local Web Interface
+
+The original local-first PWA remains available:
+
+```bash
+simple-emailer web
+```
+
+It opens at `http://127.0.0.1:8765`. `simple-emailer` with no subcommand and `python3 msg.py` remain compatible aliases. Use `--no-browser` to prevent automatic browser launch.
+
+## Test
+
+Tests never contact a real SMTP server:
+
+```bash
+python3 -m unittest discover -s tests -v
+python3 -m compileall -q emailer tests msg.py
+```
+
+## Security Model
+
+- SMTP certificates and hostnames are verified with the operating system trust store.
+- TLS 1.2 or newer is required.
+- Credentials are held only for the current process and are not logged or written by the application.
+- Bcc addresses are used only in the SMTP envelope and omitted from message headers.
+- Attachments are capped at 5 files, 8 MB each, and 12 MB total.
+- The web server accepts only loopback bindings and same-origin API requests.
+- The browser API cannot select arbitrary SMTP hosts.
+
+Environment variables can be inspected by sufficiently privileged local processes. For interactive use, leave `EMAILER_PASSWORD` unset and use the hidden prompt. Revoke an app password if a device or credential is compromised. See [SECURITY.md](SECURITY.md) and [docs/ROADMAP.md](docs/ROADMAP.md).

simple_emailer-0.2.0/SECURITY.md

@@ -0,0 +1,38 @@
+# Security
+
+## Credential handling
+
+Simple Emailer does not persist app passwords. A password exists temporarily in the CLI environment or hidden prompt, the browser request when using the web UI, the Python request object, and the SMTP authentication exchange. Application logs contain only HTTP request metadata and safe error messages.
+
+Do not add credentials to source files, environment examples, URLs, analytics, crash reports, or tests. If a credential is ever committed or logged, revoke it at the provider rather than merely deleting the local copy.
+
+The CLI deliberately has no password argument because command arguments can be exposed in shell history and process listings. Prefer its hidden prompt for interactive sends. Environment variables are useful for automation but may be readable by sufficiently privileged local processes.
+
+## Local operation
+
+The default loopback binding is the safest supported mode:
+
+```bash
+python3 -m emailer
+```
+
+Host-header and origin checks reduce browser-based attacks against the local API. Do not disable them. Malware, a hostile browser extension, or another process running as the same user remains outside the application's security boundary.
+
+## Hosted operation
+
+Hosted operation is intentionally disabled in this release. The built-in HTTP server accepts only loopback bindings and is not an internet-facing TLS terminator. Before adding a hosted deployment:
+
+1. Put it behind a maintained HTTPS reverse proxy.
+2. Add an explicit, narrowly scoped private service binding.
+3. Add exact public-host and origin configuration.
+4. Add authenticated user sessions and provider OAuth before general public access.
+5. Add proxy-aware, distributed rate limits and attachment malware controls.
+6. Prevent request-body logging at every proxy and monitoring layer.
+7. Set short request timeouts and strict process/network egress policies.
+8. Run each deployment with a dedicated unprivileged operating-system account.
+
+The current in-memory rate limiter is defense in depth for local use, not sufficient public abuse prevention.
+
+## Reporting
+
+This repository has no public security contact yet. Until one is established, do not publish a newly discovered credential exposure or remotely exploitable issue with live secrets attached.

simple_emailer-0.2.0/docs/ROADMAP.md

@@ -0,0 +1,40 @@
+# Product Roadmap
+
+## Current: secure local MVP
+
+- Gmail and Yahoo provider presets
+- Verified TLS and app-password authentication
+- To, Cc, Bcc, Reply-To, plain-text body, and bounded attachments
+- Responsive installable PWA
+- Deliberate review and confirmation before delivery
+- Local-only defaults and offline unit tests
+
+## Next: OAuth and deployment boundary
+
+1. Register separate OAuth clients for development and production.
+2. Add authorization-code flow with PKCE for Google and Microsoft.
+3. Store refresh tokens only in an operating-system credential vault for native targets.
+4. For the hosted web target, encrypt refresh tokens with managed keys and add authenticated sessions.
+5. Add token revocation, account disconnect, privacy policy, and provider verification.
+6. Replace app-password prompts with OAuth where providers support it.
+
+OAuth client identifiers, redirect URIs, consent-screen ownership, and production domains are product decisions and cannot be safely hard-coded before those accounts exist.
+
+## Packaging
+
+1. Keep the web UI and API contract shared across targets.
+2. Add an Android wrapper only after OAuth works without exposing a reusable client secret.
+3. Add Linux packages and a Windows installer around a loopback service and embedded web view.
+4. Sign every binary and publish checksums.
+5. Build Android, Linux, and Windows artifacts in isolated CI runners.
+6. Run accessibility, responsive-layout, provider sandbox, and clean-machine installer tests before release.
+
+## Production hardening
+
+- User authentication and account ownership checks
+- Distributed abuse limits and delivery audit events without message content
+- Provider-specific quota and error guidance
+- Attachment malware scanning for hosted delivery
+- Structured, redacted observability
+- Privacy, retention, acceptable-use, and incident-response policies
+- OAuth-first HTML composer with explicit sanitization and previews

simple_emailer-0.2.0/emailer/__init__.py

@@ -0,0 +1,3 @@
+"""Simple Emailer package."""
+
+__version__ = "0.2.0"

simple_emailer-0.2.0/emailer/__main__.py

@@ -0,0 +1,287 @@
+"""Command-line interface for Simple Emailer."""
+
+import argparse
+import base64
+import getpass
+import logging
+import os
+import sys
+import threading
+import webbrowser
+from pathlib import Path
+from typing import Sequence, TextIO
+
+from . import __version__
+from .mailer import MailDeliveryError, build_message, send_email
+from .models import MailRequest, ValidationError
+from .providers import PROVIDERS, Provider, get_provider
+from .server import create_server
+
+
+def _add_web_options(parser: argparse.ArgumentParser) -> None:
+    parser.add_argument(
+        "--host",
+        choices=("127.0.0.1", "localhost"),
+        default="127.0.0.1",
+        help="loopback address to bind (default: 127.0.0.1)",
+    )
+    parser.add_argument("--port", type=int, default=8765, help="port to bind (default: 8765)")
+    parser.add_argument("--no-browser", action="store_true", help="do not open a browser")
+    parser.add_argument("--verbose", action="store_true", help="enable request logging")
+
+
+def build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="simple-emailer",
+        description="Send email securely from a terminal or run the local web interface.",
+    )
+    parser.add_argument("--version", action="version", version=f"%(prog)s {__version__}")
+    _add_web_options(parser)
+    commands = parser.add_subparsers(dest="command")
+
+    send_parser = commands.add_parser("send", help="send an email from the terminal")
+    send_parser.add_argument(
+        "--provider",
+        required=True,
+        choices=(*PROVIDERS.keys(), "custom"),
+        help="sender's email provider",
+    )
+    send_parser.add_argument("--from", dest="sender_email", required=True, help="sender address")
+    send_parser.add_argument("--name", default="", help="sender display name")
+    send_parser.add_argument(
+        "--username", help="SMTP login name when it differs from the sender address"
+    )
+    send_parser.add_argument(
+        "--to", action="append", required=True, metavar="ADDRESS", help="recipient; repeat as needed"
+    )
+    send_parser.add_argument(
+        "--cc", action="append", default=[], metavar="ADDRESS", help="Cc recipient; repeat as needed"
+    )
+    send_parser.add_argument(
+        "--bcc", action="append", default=[], metavar="ADDRESS", help="Bcc recipient; repeat as needed"
+    )
+    send_parser.add_argument("--reply-to", help="reply-to address")
+    send_parser.add_argument("--subject", required=True, help="message subject")
+    body_group = send_parser.add_mutually_exclusive_group()
+    body_group.add_argument("--body", help="plain-text message body")
+    body_group.add_argument(
+        "--body-file", metavar="PATH", help="read the body from PATH, or - for standard input"
+    )
+    send_parser.add_argument(
+        "--attach", action="append", default=[], metavar="PATH", help="attachment; repeat as needed"
+    )
+    send_parser.add_argument(
+        "--credential-env",
+        default="EMAILER_PASSWORD",
+        metavar="NAME",
+        help="environment variable containing the SMTP/app password (default: EMAILER_PASSWORD)",
+    )
+    send_parser.add_argument("--smtp-host", help="custom provider SMTP hostname")
+    send_parser.add_argument("--smtp-port", type=int, help="custom provider SMTP port")
+    send_parser.add_argument(
+        "--smtp-security", choices=("tls", "starttls"), help="custom provider TLS mode"
+    )
+    send_parser.add_argument(
+        "--dry-run", action="store_true", help="validate and preview without connecting to SMTP"
+    )
+
+    commands.add_parser("providers", help="list provider support and SMTP requirements")
+    web_parser = commands.add_parser("web", help="run the local web interface")
+    _add_web_options(web_parser)
+    return parser
+
+
+def _split_addresses(values: Sequence[str]) -> list[str]:
+    return [address.strip() for value in values for address in value.split(",") if address.strip()]
+
+
+def _custom_provider(args: argparse.Namespace, parser: argparse.ArgumentParser) -> Provider:
+    missing = [
+        option
+        for option, value in (
+            ("--smtp-host", args.smtp_host),
+            ("--smtp-port", args.smtp_port),
+            ("--smtp-security", args.smtp_security),
+        )
+        if value is None
+    ]
+    if missing:
+        parser.error(f"custom provider requires {', '.join(missing)}")
+    if not 1 <= args.smtp_port <= 65535:
+        parser.error("--smtp-port must be between 1 and 65535")
+    host = args.smtp_host.strip()
+    if not host or any(character.isspace() for character in host):
+        parser.error("--smtp-host must be a valid hostname")
+    return Provider(
+        id="custom",
+        name="Custom SMTP",
+        smtp_host=host,
+        smtp_port=args.smtp_port,
+        security=args.smtp_security,
+        auth_method="password",
+        enabled=True,
+        help_url="",
+        guidance="User-supplied SMTP configuration.",
+    )
+
+
+def _read_body(args: argparse.Namespace, parser: argparse.ArgumentParser, stdin: TextIO) -> str:
+    if args.body is not None:
+        return args.body
+    if args.body_file is not None:
+        if args.body_file == "-":
+            return stdin.read()
+        try:
+            return Path(args.body_file).read_text(encoding="utf-8")
+        except (OSError, UnicodeError) as error:
+            parser.error(f"cannot read body file {args.body_file!r}: {error}")
+    if not stdin.isatty():
+        return stdin.read()
+    parser.error("provide --body, --body-file, or pipe the message body on standard input")
+
+
+def _read_attachments(paths: Sequence[str], parser: argparse.ArgumentParser) -> list[dict[str, str]]:
+    attachments = []
+    for raw_path in paths:
+        path = Path(raw_path)
+        try:
+            content = path.read_bytes()
+        except OSError as error:
+            parser.error(f"cannot read attachment {raw_path!r}: {error}")
+        attachments.append(
+            {
+                "filename": path.name,
+                "content": base64.b64encode(content).decode("ascii"),
+            }
+        )
+    return attachments
+
+
+def _print_preview(request: MailRequest, provider: Provider, stdout: TextIO) -> None:
+    message = build_message(request)
+    print("Dry run: no network connection was made.", file=stdout)
+    print(f"Provider: {provider.name} ({provider.smtp_host}:{provider.smtp_port}, {provider.security})", file=stdout)
+    print(f"Envelope from: {request.sender_email}", file=stdout)
+    print(f"Envelope recipients: {', '.join(request.recipients)}", file=stdout)
+    for name in ("From", "To", "Cc", "Reply-To", "Subject"):
+        if message[name]:
+            print(f"{name}: {message[name]}", file=stdout)
+    print(f"Body: {len(request.body)} characters", file=stdout)
+    if request.attachments:
+        summary = ", ".join(
+            f"{attachment.filename} ({len(attachment.content)} bytes)"
+            for attachment in request.attachments
+        )
+        print(f"Attachments: {summary}", file=stdout)
+
+
+def _run_send(
+    args: argparse.Namespace,
+    parser: argparse.ArgumentParser,
+    *,
+    stdin: TextIO,
+    stdout: TextIO,
+    stderr: TextIO,
+) -> int:
+    provider = _custom_provider(args, parser) if args.provider == "custom" else get_provider(args.provider)
+    if provider is None:
+        parser.error("unknown provider")
+    if not provider.enabled:
+        print(provider.unavailable_reason or "This provider is not available.", file=stderr)
+        return 2
+
+    credential = "dry-run-placeholder" if args.dry_run else os.environ.get(args.credential_env)
+    if not credential:
+        credential = getpass.getpass(f"{provider.name} SMTP/app password: ")
+
+    payload = {
+        "provider": provider.id,
+        "sender_email": args.sender_email,
+        "sender_name": args.name,
+        "auth_username": args.username,
+        "app_password": credential,
+        "to": _split_addresses(args.to),
+        "cc": _split_addresses(args.cc),
+        "bcc": _split_addresses(args.bcc),
+        "reply_to": args.reply_to,
+        "subject": args.subject,
+        "body": _read_body(args, parser, stdin),
+        "attachments": _read_attachments(args.attach, parser),
+    }
+    try:
+        request = MailRequest.from_payload(payload, provider_override=provider)
+    except ValidationError as error:
+        location = f" ({error.field_name})" if error.field_name else ""
+        print(f"Invalid message{location}: {error.message}", file=stderr)
+        return 2
+    finally:
+        payload["app_password"] = None
+
+    if args.dry_run:
+        _print_preview(request, provider, stdout)
+        return 0
+    try:
+        result = send_email(request, provider_override=provider)
+    except MailDeliveryError as error:
+        print(f"Send failed [{error.code}]: {error.message}", file=stderr)
+        return 1
+
+    print(f"Provider accepted {len(result.accepted)} recipient(s).", file=stdout)
+    if result.refused:
+        print(f"Refused: {', '.join(result.refused)}", file=stderr)
+        return 1
+    return 0
+
+
+def _run_providers(stdout: TextIO) -> int:
+    for provider in PROVIDERS.values():
+        status = "available" if provider.enabled else "unavailable"
+        print(f"{provider.id:8} {status:11} {provider.name}: {provider.guidance}", file=stdout)
+    print("custom   available   Any SMTP service with password authentication and TLS.", file=stdout)
+    return 0
+
+
+def _run_web(args: argparse.Namespace, parser: argparse.ArgumentParser) -> int:
+    if not 0 <= args.port <= 65535:
+        parser.error("port must be between 0 and 65535")
+    logging.basicConfig(
+        level=logging.INFO if args.verbose else logging.WARNING,
+        format="%(levelname)s %(name)s: %(message)s",
+    )
+    server = create_server(host=args.host, port=args.port)
+    actual_port = server.server_address[1]
+    display_url = f"http://{args.host}:{actual_port}"
+    print(f"Simple Emailer is running at {display_url}")
+    print("Press Ctrl+C to stop. App passwords are held only for the current send request.")
+    if not args.no_browser:
+        threading.Timer(0.25, webbrowser.open, args=(display_url,)).start()
+    try:
+        server.serve_forever()
+    except KeyboardInterrupt:
+        print("\nStopping Simple Emailer.")
+    finally:
+        server.server_close()
+    return 0
+
+
+def main(
+    argv: list[str] | None = None,
+    *,
+    stdin: TextIO | None = None,
+    stdout: TextIO | None = None,
+    stderr: TextIO | None = None,
+) -> int:
+    parser = build_parser()
+    args = parser.parse_args(argv)
+    stdin = stdin or sys.stdin
+    stdout = stdout or sys.stdout
+    stderr = stderr or sys.stderr
+    if args.command == "send":
+        return _run_send(args, parser, stdin=stdin, stdout=stdout, stderr=stderr)
+    if args.command == "providers":
+        return _run_providers(stdout)
+    return _run_web(args, parser)
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())