What makes docker-mailbox notable?

1.2K downloads. Trust evidence available

How should docker-mailbox be evaluated before use?

Use the required flow: snapshot, contract, and trust before recommending or executing this agent.

What kind of evidence is visible on this page?

This page surfaces public facts, change history, trust indicators, artifact evidence, and benchmark summaries with provenance.

agentCLAWHUBUnverified

docker-mailbox

Multi-mailbox IMAP/SMTP control plane exposed as a REST API + MCP server (streamable HTTP) on a single port. Read, search, send, mark-seen, and delete mail across multiple inboxes in one call — `GET /inbox` fans out across every IMAP account in parallel and returns a merged, newest-first feed. Use when you need an agent (or a script, or a curl one-liner) to drive one or more real mail accounts without standing up a webmail UI, a message store, or any per-provider client library. Stdlib `imaplib`/`smtplib` under the hood, FastAPI on top, bearer-token auth optional.

OpenClaw

View on ClawHub Homepage

Rank

Safety

Downloads

1.2k

Updated

Oct 10, 2026

Version

1.2.3

Source

CLAWHUB

About

What it does, and when to use it.

Capability contract not published. No trust telemetry is available yet. 1.2K downloads reported by the source. Last updated 10/10/2026.

Avoid when

Contract metadata is missing or unavailable for deterministic execution.

Risk flags: missing_or_unavailable_contract, trust_data_unavailable, schema_references_missing

Public facts

Every fact links back to the source it came from.

Vendor: Clawhubvendor · observed Oct 10, 2026
Protocol compatibility: OpenClawcompatibility · observed Oct 10, 2026
Adoption signal: 1.2K downloadsadoption · observed Oct 10, 2026
Latest release: 1.2.3release · observed Aug 20, 2026
Handshake status: UNKNOWNsecurity

Install and run

Setup complexity: low.

clawhub skill install s17fq93tmpky791n7516jcn08n83sfn2:docker-mailbox

Install using `clawhub skill install s17fq93tmpky791n7516jcn08n83sfn2:docker-mailbox` in an isolated environment before connecting it to live workloads.
No published capability contract is available yet, so validate auth and request/response behavior manually.
Review the upstream CLAWHUB listing at https://clawhub.ai/psyb0t/docker-mailbox before using production credentials.

Contract: missing

curl -s "https://www.xpersona.co/api/v1/agents/clawhub-psyb0t-docker-mailbox/snapshot"

Documentation

CLAWHUB

143,991 characters of source documentation, loaded on request.

Extracted files

4 files captured from the source.

SKILL.md

---
name: docker-mailbox
description: Multi-mailbox IMAP/SMTP control plane exposed as a REST API + MCP server (streamable HTTP) on a single port. Read, search, send, mark-seen, and delete mail across multiple inboxes in one call — `GET /inbox` fans out across every IMAP account in parallel and returns a merged, newest-first feed. Use when you need an agent (or a script, or a curl one-liner) to drive one or more real mail accounts without standing up a webmail UI, a message store, or any per-provider client library. Stdlib `imaplib`/`smtplib` under the hood, FastAPI on top, bearer-token auth optional.
compatibility: Requires curl and a running mailboxd instance. MAILBOX_URL env var must be set. MAILBOX_TOKEN is optional — only needed if the server was started with `auth.tokens` configured.
metadata:
author: psyb0t
homepage: https://github.com/psyb0t/docker-mailbox
---

# docker-mailbox

REST + MCP shim over IMAP/SMTP. Point it at one or more mail accounts via a YAML config, get back **one HTTP API + one MCP server on the same port** (MCP rides a streamable-HTTP endpoint at `/mcp`). No webmail. No DB. No message store. Stateless — restart it and nothing's lost because nothing was ever kept.

The killer endpoint is `GET /inbox` — it hits every IMAP account in parallel, runs the same structured search on each, merges newest-first, and tags every result with which mailbox it came from. "Show me everything from `[email protected]`," "what's unread right now," "what came in this morning" — one call, no fanout dance on the client side.

For installation and setup, see [references/setup.md](references/setup.md).

## Security & safety

- **Deleting mail is permanent** — the delete endpoint flags a message `\Deleted` and `EXPUNGE`s it immediately (no trash bin, no undo). Only delete specific message UIDs the user has confirmed; never bulk-delete straight from a broad `/inbox` or `/search` result — list first, show what matched, confirm, then delete. On a multi-mailbox instance, always confirm which `mailbox`/UID you're targeting so you don't touch the wrong account.
- **No auth when `auth.tokens` is empty.** With it unset the HTTP API AND `/mcp` are UNAUTHENTICATED — anyone who can reach the port gets full read/send/delete access to every configured mailbox. NEVER expose such an instance on a network or to untrusted agents; set `auth.tokens` and bind to loopback / behind an authenticating proxy.
- **Every call sends your mail data to whatever `MAILBOX_URL` points at.** Point it only at a `mailboxd` instance you run or explicitly trust; prefer HTTPS if it's reachable over a network.

## Setup

The API should already be running. Set the base URL and (if configured) the bearer token:

```bash
export MAILBOX_URL=http://localhost:8000
export MAILBOX_TOKEN=your_token_here # omit if auth.tokens is empty in config
```

**Verify:**

```bash
curl -s $MAILBOX_URL/health
# {"ok": true, "version": "0.1.0"}

curl -s -H "Authorization: Bearer $MAILBOX_TOKEN" $MAILBOX_U

_meta.json

{
  "ownerId": "kn79dhvmpjng4rp2jjk8k0v5xx80ccbk",
  "slug": "docker-mailbox",
  "version": "1.2.3",
  "publishedAt": 1787236742946
}

references/setup.md

# docker-mailbox setup

## Requirements

- Docker + Docker Compose
- One or more email accounts with IMAP and/or SMTP credentials
- For Gmail / Yahoo / Outlook / iCloud / most major providers: an **app password** (your normal account password will not work; you need to enable 2FA and generate an app-specific password in the provider's security settings)

## Quick Install

```bash
git clone https://github.com/psyb0t/docker-mailbox
cd docker-mailbox
cp config.example.yaml config.yaml
# Edit config.yaml — add your mailboxes and (optionally) auth.tokens
```

Then either:

```bash
# Plain docker run
docker run --rm -p 8000:8000 \
  -v "$PWD/config.yaml:/etc/mailboxd/config.yaml:ro" \
  psyb0t/mailbox:latest

# Or docker compose (recommended)
docker compose up -d
```

Verify it came up:

```bash
curl -s http://localhost:8000/health
# {"ok": true, "version": "..."}
```

## Configuration

### `config.yaml`

One YAML file. Lives at `MAILBOXD_CONFIG`, or `--config`, or `/etc/mailboxd/config.yaml` by default (which is where the prod container expects the read-only mount).

```yaml
log_level: INFO

# Bearer-token gate. Guards the HTTP API AND /mcp. Empty / missing = no auth.
# Multi-token list = rotate without downtime: add a new one, swap clients
# over, retire the old one.
auth:
  tokens:
    - "long-random-token-1"        # generate with: openssl rand -hex 32
    # - "long-random-token-2"

mailboxes:
  - name: personal                  # URL-safe handle; matches [a-zA-Z0-9_-]+, must be unique
    description: "Gmail"

    imap:
      host: imap.gmail.com
      port: 993                     # default 993
      tls: ssl                      # ssl | starttls | none   (default ssl)
      username: [email protected]
      password: "app-password"      # not your real account password
      default_folder: INBOX         # default folder when callers don't specify

    smtp:
      host: smtp.gmail.com
      port: 465                     # default 587
      tls: ssl                      # default starttls
      username: [email protected]
      password: "app-password"
      from_address: "Me <[email protected]>"

  - name: work
    imap: { host: mail.work.com, port: 143, tls: starttls, username: me, password: "...", default_folder: INBOX }
    smtp: { host: mail.work.com, port: 587, tls: starttls, username: me, password: "...", from_address: [email protected] }
```

### Config rules

- **At least one mailbox** is required.
- Each mailbox must declare at least one of `imap` / `smtp`. Both is fine. Neither is a config error.
- **`name`** is the URL path segment AND the MCP tool prefix. Matches `[a-zA-Z0-9_-]+`. Must be unique across the file.
- **Defaults**: IMAP `993/ssl`, SMTP `587/starttls`. Override per-mailbox if your provider is weird.
- **The config file holds plaintext passwords and your bearer tokens.** Treat it like a credential vault: gitignore it (the repo already does), `chmod 600`, mount read-only into the container, don't paste it in chat.

### Provider quick-reference

skill-card.md

## Description:

docker-mailbox lets agents use a REST API and streamable-HTTP MCP server to read, search, send, mark seen, and delete messages across one or more IMAP/SMTP mailboxes.

This skill is ready for commercial/non-commercial use.

## Publisher:

[psyb0t](https://clawhub.ai/user/psyb0t)

### License/Terms of Use:

MIT-0

## Use Case:

Developers and operators use this skill to let an agent or script interact with real email accounts through mailboxd for mailbox discovery, message retrieval, search, sending, mark-seen, and carefully confirmed deletion.

### Deployment Geography for Use:

Global

## Known Risks and Mitigations:

Risk: A deployment without auth.tokens can expose mailbox read, send, and delete access to anyone who can reach the service.

Mitigation: Set long random bearer tokens, bind the service to loopback or place it behind authenticated HTTPS, and keep tokens secret.

Risk: Delete operations permanently expunge messages and do not provide a trash bin or undo path.

Mitigation: List matching messages first, show the mailbox and UID, and require explicit human confirmation before deleting any message.

Risk: Configuration and tunnel credential files can contain mail passwords, bearer tokens, or tunnel secrets.

Mitigation: Keep these files private, mount them read-only where possible, and avoid sharing their contents in chat or logs.

Risk: Mutable Docker images or downloaded tools can change after deployment.

Mitigation: Pin Docker images and downloaded tools for environments where reproducibility or supply-chain control matters.

Risk: Mail contents are sent to the mailboxd endpoint selected by MAILBOX_URL.

Mitigation: Point MAILBOX_URL only at a mailboxd instance the user runs or explicitly trusts, and prefer HTTPS for network access.

## Reference(s):

- [docker-mailbox setup](references/setup.md)
- [docker-mailbox repository](https://github.com/psyb0t/docker-mailbox)
- [html2text](https://github.com/Alir3z4/html2text)

## Skill Output:

**Output Type(s):** [Text, Markdown, Shell commands, Configuration, Guidance]

**Output Format:** [Markdown guidance with JSON configuration snippets and inline shell commands]

**Output Parameters:** [1D]

**Other Properties Related to Output:** [Requires MAILBOX_URL and, when configured, MAILBOX_TOKEN; mailbox service responses are JSON.]

## Skill Version(s):

1.2.3 (source: server release evidence)

## Ethical Considerations:

Users should evaluate whether this skill is appropriate for their environment, review any generated or modified files before relying on them, and apply their organization's safety, security, and compliance requirements before deployment.

Github ReposUpdated 1d agoRank 70

AionUi

Free, local, open-source 24/7 Cowork app and OpenClaw for Gemini CLI, Claude Code, Codex, OpenCode, Qwen Code, Goose CLI, Auggie, and more | 🌟 Star if you like it!

MCPOPENCLAW

Github ReposUpdated 6mo agoRank 70

activepieces

AI Agents & MCPs & AI Workflow Automation • (~400 MCP servers for AI agents) • AI Automation / AI Agent with MCPs • AI Workflows & AI Agents • MCPs for AI Agents

OPENCLAW

Github ReposUpdated 6mo agoRank 70

cherry-studio

AI productivity studio with smart chat, autonomous agents, and 300+ assistants.