Skill: fatihbtw/email-registration-scanner (version 1.0.0)

--- name: registration-scanner description: Scans email accounts (Gmail, iCloud, Outlook, Yahoo, AOL, GMX, Web.de, Fastmail, Proton, T-Online and more) for registration, welcome and confirmation emails to build a chronological list of all services the user has ever signed up for. Triggers on phrases like "where am I registered", "scan my email for registrations", "show me all my accounts", "welche dienste habe ich", "wo bin ich registriert", "liste mes inscriptions", "encuentra mis registros". user-invocable: true metadata: {"openclaw":{"emoji":"📋","always":false}} --- # Registration Scanner Scans one or more email accounts for registration-related emails and returns a deduplicated, date-sorted list of every service the user has ever signed up for. ## Supported Providers | Provider | Access Method | |---|---| | Gmail | Gmail tool / MCP connector | | iCloud Mail | IMAP – imap.mail.me.com:993 | | Outlook / Hotmail / Live | IMAP – outlook.office365.com:993 | | Yahoo Mail | IMAP – imap.mail.yahoo.com:993 | | AOL Mail | IMAP – imap.aol.com:993 | | GMX | IMAP – imap.gmx.net:993 | | Web.de | IMAP – imap.web.de:993 | | T-Online | IMAP – secureimap.t-online.de:993 | | Fastmail | IMAP – imap.fastmail.com:993 | | Proton Mail | IMAP Bridge – 127.0.0.1:1143 (Bridge required) | Full provider details and IMAP setup guides → `{baseDir}/references/providers.md` --- ## Step 1 – Identify Accounts Ask the user which email accounts to scan before doing anything else: > "Which email accounts should I scan? (e.g. Gmail, iCloud, Outlook, Yahoo, AOL, GMX, Web.de, T-Online, Fastmail, Proton – or all of them?)" Wait for the answer. Do not proceed until the user has confirmed. --- ## Step 2 – Collect Credentials ### Gmail Use the Gmail tool or Gmail MCP connector if already configured. If not configured, tell the user: > "Please connect your Gmail account first via `openclaw configure` or by enabling the Gmail MCP connector." ### IMAP Providers (iCloud, Outlook, Yahoo, AOL, GMX, Web.de, T-Online, Fastmail) Explain to the user: > "For [provider] I need your email address and an **app-specific password** (not your regular login password). You can generate one in your account's security settings. I will use it only for this session and never store it in plain text." Refer to provider-specific instructions for generating app passwords → `{baseDir}/references/providers.md` ### Proton Mail Proton Mail requires the **Proton Mail Bridge** to be running locally. > "For Proton Mail, please make sure the Proton Mail Bridge is running. I will connect to it locally at 127.0.0.1:1143." --- ## Step 3 – Run the Scan ### Gmail Use the Gmail tool to search with these queries in sequence. Collect all matching message IDs. Search queries across all languages → `{baseDir}/references/search-queries.md` ### IMAP Accounts Use the Python script at `{baseDir}/scripts/imap_scan.py` to connect and search: ```bash python3 "{baseDir}/scripts/imap_scan.py" \ --host "imap.mail.me.com" \ --port 993 \ --user "[REDACTED_SECRET]" \ --password "app-specific-password" \ --output "/tmp/registration_scan_results.json" ``` The script runs all search query batches automatically and returns a JSON list of matches. Run this for each IMAP account separately, saving results to different temp files. --- ## Step 4 – Parse and Deduplicate Results For every matched email: 1. Extract: `From`, `Date`, `Subject` 2. Derive the **service name** from the sender domain or subject line Example: `[REDACTED_SECRET]` → `Spotify`, `[REDACTED_SECRET]` → `Notion` 3. **Deduplicate by service**: keep only the **oldest** entry per service (= original registration) 4. **Skip**: transactional emails (password resets, receipts), pure newsletters with no registration context, internal/personal senders --- ## Step 5 – Output Present the final list sorted **newest first**. Use this format: ``` 📋 REGISTERED SERVICES – [Account Name] ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ Found: XX services | Range: YYYY – YYYY YYYY-MM-DD Service Name From: [REDACTED_SECRET] YYYY-MM-DD Service Name From: [REDACTED_SECRET] ... ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ ``` If multiple accounts were scanned, merge all results into one unified list sorted by date. After showing the list, ask: > "Should I save this as a file? Or filter by a specific service or date range?" --- ## Error Handling - **IMAP auth failure**: Ask the user to re-check their app password. Refer to `{baseDir}/references/providers.md` for setup steps. - **IMAP not enabled**: iCloud, Yahoo, Outlook may require IMAP to be turned on in account settings. Provider guide → `{baseDir}/references/providers.md` - **Proton Bridge not running**: Instruct the user to start the Proton Mail Bridge app first. - **Rate limiting**: Pause 1–2 seconds between search batches to avoid being throttled. - **Large mailbox**: Inform the user of progress. Large inboxes (100k+ emails) may take several minutes. --- ## Privacy & Security Rules - **Never** display passwords, app keys, or credentials in output or logs. - Use OpenClaw's Secret Store for credentials whenever possible. - Delete temp files (`/tmp/registration_scan_*.json`) after the session ends. - Do not send any email content to external services.

path: README.md
content: # 📋 Email Registration Scanner

An [OpenClaw](https://openclaw.ai) skill that scans your email accounts for registration, welcome, and confirmation emails — and builds a deduplicated, chronological list of every service you've ever signed up for.

## Who is this for?

This skill is for anyone who wants a clear overview of all the online services and accounts they've signed up for over the years — for example to **deactivate or delete old accounts**, reduce their digital footprint, clean up unused subscriptions, or simply regain control over their online presence. Instead of trying to remember every service manually, the scanner does the work by going through your emails automatically.

## Supported Providers

| Provider | Access |
|---|---|
| Gmail | Gmail MCP connector |
| iCloud Mail | IMAP |
| Outlook / Hotmail / Live | IMAP |
| Yahoo Mail | IMAP |
| AOL Mail | IMAP |
| GMX | IMAP |
| Web.de | IMAP |
| T-Online | IMAP |
| Fastmail | IMAP |
| Proton Mail | IMAP via Bridge |

## Supported Languages

English · Deutsch · Français · Español · Italiano · Português · Nederlands · Polski · Türkçe

## Installation

```bash
# Option 1 – via OpenClaw directly (paste this URL into your agent chat)
https://github.com/fatihbtw/email-registration-scanner

# Option 2 – manual
mkdir -p ~/.openclaw/skills/email-registration-scanner
cp -r . ~/.openclaw/skills/email-registration-scanner
```

## Usage

Just tell your OpenClaw agent:
- *"Scan my emails for registrations"*
- *"Where am I registered?"*
- *"Wo bin ich überall registriert?"*
- *"/registration-scanner"*

## File Structure

```
email-registration-scanner/
├── SKILL.md                        # Core workflow
├── references/
│   ├── providers.md                # IMAP settings + app password guides
│   └── search-queries.md          # Search terms in 9 languages
└── scripts/
    └── imap_scan.py               # Python IMAP scanner (stdlib only)
```

## Privacy & Security

- Credentials are never stored or logged
- All processing happens locally on your machine
- Temp files are deleted after each session
- Uses app-specific passwords (not your main account password)

## License

MIT


path: _meta.json
content: {
  "openclaw": {
    "emoji": "📋",
    "always": false
  }
}

path: references/providers.md
content: # Email Provider Reference

## IMAP Server Settings

| Provider | Host | Port | SSL | Notes |
|---|---|---|---|---|
| iCloud Mail | imap.mail.me.com | 993 | Yes | App password required |
| Outlook / Hotmail / Live | outlook.office365.com | 993 | Yes | App password required if MFA is on |
| Yahoo Mail | imap.mail.yahoo.com | 993 | Yes | App password required |
| AOL Mail | imap.aol.com | 993 | Yes | App password required |
| GMX | imap.gmx.net | 993 | Yes | IMAP must be enabled in settings |
| Web.de | imap.web.de | 993 | Yes | IMAP must be enabled in settings |
| T-Online | secureimap.t-online.de | 993 | Yes | E-Mail-Passwort (not account password) |
| Fastmail | imap.fastmail.com | 993 | Yes | App password recommended |
| Proton Mail | 127.0.0.1 | 1143 | No | Requires Proton Mail Bridge running locally |

---

## App Password Setup Guides

### iCloud Mail
1. Go to [appleid.apple.com](https://appleid.apple.com)
2. Sign In → **Security** section
3. Click **Generate Password…** under "App-Specific Passwords"
4. Label it "OpenClaw Registration Scanner"
5. Copy the generated password (format: `xxxx-xxxx-xxxx-xxxx`)

> **Note:** If IMAP isn't working, go to [icloud.com](https://icloud.com) → Settings → Mail → enable "IMAP Access".

---

### Outlook / Hotmail / Live
1. Go to [account.microsoft.com/security](https://account.microsoft.com/security)
2. Click **Advanced security options**
3. Under "App passwords", click **Create a new app password**
4. Use the generated password in place of your regular password

> **Note:** App passwords are only needed if two-step verification is enabled.  
> If 2FA is off, you can use your regular password – but enabling 2FA is strongly recommended.

---

### Yahoo Mail
1. Go to [login.yahoo.com](https://login.yahoo.com) → Account Security
2. Scroll to **Generate app password**
3. Select "Other App" → enter "OpenClaw"
4. Copy the 16-character app password

> **Note:** Make sure IMAP is enabled: Yahoo Mail Settings → Security → Allow apps that use less secure sign-in (or use app password).

---

### AOL Mail
1. Go to [myaccount.aol.com](https://myaccount.aol.com) → **Security**
2. Scroll to **Generate app password**
3. Select "Other App" → enter "OpenClaw"
4. Copy the generated password

> **Note:** If IMAP access is blocked: AOL Mail Settings → Security → enable "Allow apps that use less secure sign in".

---

### GMX
1. Go to [gmx.net](https://www.gmx.net) → Settings (⚙) → E-Mail → **POP3/IMAP abrufen**
2. Enable **IMAP**
3. GMX does not require an app password – use your regular GMX password
4. If login fails, go to Security settings and confirm "Allow external access"

---

### Web.de
1. Go to [web.de](https://web.de) → Settings → E-Mail → **POP3/IMAP**
2. Enable **IMAP access**
3. Use your regular Web.de password (no app password needed)

---

### T-Online (Telekom)
1. T-Online uses a separate **E-Mail-Passwort** (not your Telekom account password)
2. Set or retrieve it at [email.t-online.de](https://email.t-online.de) → Settings → Change E-Mail-Passwort
3. Username: your full T-Online email address (e.g. `[REDACTED_SECRET]`)

---

### Fastmail
1. Go to [fastmail.com](https://fastmail.com) → Settings → **Privacy & Security** → **Connected Apps & API Tokens**
2. Click **New App Password**
3. Label it "OpenClaw" and select "Mail (IMAP/SMTP)"
4. Copy the generated password

---

### Proton Mail (via Bridge)
1. Download and install **Proton Mail Bridge** from [proton.me/mail/bridge](https://proton.me/mail/bridge)
2. Sign in to Bridge with your Proton Mail account
3. Bridge exposes IMAP locally at `127.0.0.1:1143` (no SSL)
4. The IMAP password shown in Bridge is different from your Proton password – use the one shown in the Bridge app

> **Note:** Proton Mail Bridge must be running in the background the entire time the scan is active.


path: references/search-queries.md
content: # Registration Search Queries

Run these query batches in sequence. Each batch targets a different language or signal type.
For IMAP, each line is a separate `SEARCH SUBJECT "..."` command.
For Gmail, combine terms with `OR` inside `subject:(...)`.

---

## Batch 1 – English

```
welcome
account created
confirm your email
verify your email
verify your account
activate your account
you're registered
successfully registered
thanks for signing up
thank you for registering
you have subscribed
subscription confirmed
your account is ready
complete your registration
finish your registration
one more step
almost there
```

Gmail query:
```
subject:(welcome OR "account created" OR "confirm your email" OR "verify your email" OR "activate your account" OR "successfully registered" OR "thanks for signing up" OR "you have subscribed")
```

---

## Batch 2 – German

```
willkommen
konto erstellt
e-mail bestätigen
e-mail-adresse bestätigen
konto bestätigen
registrierung bestätigen
erfolgreich registriert
anmeldung bestätigt
danke für deine registrierung
danke für deine anmeldung
fast geschafft
nur noch ein schritt
ihr konto ist bereit
herzlich willkommen
```

Gmail query:
```
subject:(willkommen OR "konto erstellt" OR "e-mail bestätigen" OR "registrierung bestätigen" OR "erfolgreich registriert" OR "danke für deine registrierung" OR "herzlich willkommen")
```

---

## Batch 3 – French

```
bienvenue
compte créé
confirmez votre adresse
vérifiez votre e-mail
activez votre compte
inscription confirmée
vous êtes inscrit
merci de votre inscription
votre compte est prêt
finaliser votre inscription
encore une étape
```

Gmail query:
```
subject:(bienvenue OR "compte créé" OR "confirmez votre adresse" OR "vérifiez votre e-mail" OR "activez votre compte" OR "inscription confirmée" OR "merci de votre inscription")
```

---

## Batch 4 – Spanish

```
bienvenido
bienvenida
cuenta creada
confirma tu correo
verifica tu cuenta
activa tu cuenta
registro exitoso
gracias por registrarte
tu cuenta está lista
completar registro
un paso más
```

Gmail query:
```
subject:(bienvenido OR bienvenida OR "cuenta creada" OR "confirma tu correo" OR "verifica tu cuenta" OR "registro exitoso" OR "gracias por registrarte")
```

---

## Batch 5 – Italian

```
benvenuto
benvenuta
account creato
conferma la tua email
verifica il tuo account
attiva il tuo account
registrazione completata
grazie per la registrazione
il tuo account è pronto
```

Gmail query:
```
subject:(benvenuto OR benvenuta OR "account creato" OR "conferma la tua email" OR "verifica il tuo account" OR "registrazione completata" OR "grazie per la registrazione")
```

---

## Batch 6 – Portuguese

```
bem-vindo
bem-vinda
conta criada
confirme o seu email
verifique o seu email
ative a sua conta
registro confirmado
obrigado por se registrar
a sua conta está pronta
```

Gmail query:
```
subject:(bem-vindo OR bem-vinda OR "conta criada" OR "confirme o seu email" OR "verifique o seu email" OR "registro confirmado" OR "obrigado por se registrar")
```

---

## Batch 7 – Dutch

```
welkom
account aangemaakt
bevestig je e-mailadres
verifieer je account
activeer je account
registratie bevestigd
bedankt voor je registratie
je account is klaar
```

Gmail query:
```
subject:(welkom OR "account aangemaakt" OR "bevestig je e-mailadres" OR "activeer je account" OR "registratie bevestigd" OR "bedankt voor je registratie")
```

---

## Batch 8 – Polish

```
witamy
konto zostało utworzone
potwierdź swój adres e-mail
zweryfikuj konto
aktywuj konto
rejestracja potwierdzona
dziękujemy za rejestrację
twoje konto jest gotowe
```

Gmail query:
```
subject:(witamy OR "konto zostało utworzone" OR "potwierdź swój adres" OR "rejestracja potwierdzona" OR "dziękujemy za rejestrację")
```

---

## Batch 9 – Turkish

```
hoş geldiniz
hesabınız oluşturuldu
e-postanızı doğrulayın
hesabınızı doğrulayın
hesabınızı etkinleştirin
kayıt onaylandı
kayıt olduğunuz için teşekkürler
hesabınız hazır
```

Gmail query:
```
subject:(hoş geldiniz OR "hesabınız oluşturuldu" OR "e-postanızı doğrulayın" OR "kayıt onaylandı" OR "kayıt olduğunuz için teşekkürler")
```

---

## Batch 10 – Universal Patterns (all languages)

These subject-line patterns are language-agnostic and catch remaining registrations:

```
noreply
no-reply
donotreply
do-not-reply
```

For IMAP, search sender (`FROM`) not subject:
```
SEARCH FROM "noreply"
SEARCH FROM "no-reply"
SEARCH FROM "donotreply"
```

For Gmail:
```
from:(noreply OR no-reply OR donotreply) subject:(welcome OR confirm OR verify OR register OR activate OR subscri)
```

---

## Signals to Exclude (Noise Reduction)

Skip emails matching these patterns to reduce false positives:

- Subject contains: `password reset`, `passwort vergessen`, `mot de passe oublié`, `forgot password`, `invoice`, `rechnung`, `receipt`, `order`, `bestellung`, `shipment`, `delivery`, `unsubscribe`, `abmelden`
- Sender domain matches known transactional-only senders (payment processors, shipping companies)
- No company name extractable from sender or subject


path: scripts/imap_scan.py
content: #!/usr/bin/env python3
"""
registration-scanner IMAP helper
Connects to an IMAP server, searches for registration-related emails,
and writes results to a JSON file.

Usage:
  python3 imap_scan.py \
    --host imap.mail.me.com \
    --port 993 \
    --user [REDACTED_SECRET] \
    --password "app-specific-password" \
    --output /tmp/registration_scan_results.json

For Proton Mail Bridge (no SSL, local):
  python3 imap_scan.py \
    --host 127.0.0.1 \
    --port 1143 \
    --no-ssl \
    --user [REDACTED_SECRET] \
    --password "bridge-password" \
    --output /tmp/registration_scan_results.json
"""

import imaplib
import email
import json
import argparse
import ssl
import time
import sys
from email.header import decode_header
from datetime import datetime


SEARCH_SUBJECTS = [
    # English
    "welcome", "account created", "confirm your email", "verify your email",
    "verify your account", "activate your account", "successfully registered",
    "thanks for signing up", "thank you for registering", "you have subscribed",
    "subscription confirmed", "your account is ready", "complete your registration",
    # German
    "willkommen", "konto erstellt", "e-mail bestätigen", "registrierung bestätigen",
    "erfolgreich registriert", "anmeldung bestätigt", "danke für deine registrierung",
    "herzlich willkommen",
    # French
    "bienvenue", "compte créé", "confirmez votre adresse", "vérifiez votre e-mail",
    "activez votre compte", "inscription confirmée", "merci de votre inscription",
    # Spanish
    "bienvenido", "bienvenida", "cuenta creada", "confirma tu correo",
    "registro exitoso", "gracias por registrarte",
    # Italian
    "benvenuto", "benvenuta", "account creato", "conferma la tua email",
    "registrazione completata",
    # Portuguese
    "bem-vindo", "bem-vinda", "conta criada", "confirme o seu email",
    "registro confirmado",
    # Dutch
    "welkom", "account aangemaakt", "bevestig je e-mailadres",
    "registratie bevestigd",
    # Polish
    "witamy", "rejestracja potwierdzona",
    # Turkish
    "hoş geldiniz", "kayıt onaylandı",
]

SENDER_PATTERNS = ["noreply", "no-reply", "donotreply", "do-not-reply"]

EXCLUDE_SUBJECTS = [
    "password reset", "forgot password", "passwort vergessen",
    "invoice", "rechnung", "receipt", "order confirmation",
    "shipment", "delivery", "unsubscribe",
]


def decode_str(value):
    """Decode email header value to plain string."""
    if not value:
        return ""
    parts = decode_header(value)
    result = []
    for part, charset in parts:
        if isinstance(part, bytes):
            try:
                result.append(part.decode(charset or "utf-8", errors="replace"))
            except Exception:
                result.append(part.decode("latin-1", errors="replace"))
        else:
            result.append(part)
    return " ".join(result)


def extract_service_name(from_addr, subject):
    """Best-effort extraction of service name from sender or subject."""
    # Try sender domain first
    if "<" in from_addr:
        addr = from_addr.split("<")[1].rstrip(">").strip()
    else:
        addr = from_addr.strip()

    if "@" in addr:
        domain = addr.split("@")[1].lower()
        # Strip common prefixes
        parts = domain.split(".")
        if len(parts) >= 2:
            name = parts[-2]  # e.g. "spotify" from "mail.spotify.com"
            if name not in ("gmail", "yahoo", "hotmail", "outlook", "icloud",
                            "googlemail", "aol", "gmx", "web", "t-online"):
                return name.capitalize()

    # Fallback: try to parse from subject
    for skip in ["Re:", "Fwd:", "FW:", "[", "]"]:
        subject = subject.replace(skip, "").strip()
    return subject[:40] if subject else "Unknown"


def should_exclude(subject_lower):
    return any(excl in subject_lower for excl in EXCLUDE_SUBJECTS)


def connect_imap(host, port, user, password, use_ssl):
    """Connect and authenticate to IMAP server."""
    if use_ssl:
        context = ssl.create_default_context()
        imap = imaplib.IMAP4_SSL(host, port, ssl_context=context)
    else:
        imap = imaplib.IMAP4(host, port)
    imap.login(user, password)
    return imap


def search_imap(imap, query_bytes):
    """Run IMAP SEARCH and return list of message IDs."""
    try:
        status, data = imap.search(None, query_bytes)
        if status != "OK" or not data or not data[0]:
            return []
        return data[0].split()
    except Exception:
        return []


def fetch_email_headers(imap, msg_id):
    """Fetch From, Date, Subject headers for a message ID."""
    try:
        status, data = imap.fetch(msg_id, "(BODY.PEEK[HEADER.FIELDS (FROM DATE SUBJECT)])")
        if status != "OK" or not data or not data[0]:
            return None
        raw = data[0][1] if isinstance(data[0], tuple) else data[0]
        msg = email.message_from_bytes(raw)
        return {
            "from": decode_str(msg.get("From", "")),
            "date": decode_str(msg.get("Date", "")),
            "subject": decode_str(msg.get("Subject", "")),
        }
    except Exception:
        return None


def parse_date(date_str):
    """Parse email date string to ISO format, best effort."""
    from email.utils import parsedate_to_datetime
    try:
        dt = parsedate_to_datetime(date_str)
        return dt.strftime("%Y-%m-%d")
    except Exception:
        return date_str[:10] if date_str else "Unknown"


def main():
    parser = argparse.ArgumentParser(description="IMAP Registration Scanner")
    parser.add_argument("--host", required=True)
    parser.add_argument("--port", type=int, default=993)
    parser.add_argument("--user", required=True)
    parser.add_argument("--password", required=True)
    parser.add_argument("--output", required=True)
    parser.add_argument("--no-ssl", action="store_true")
    args = parser.parse_args()

    use_ssl = not args.no_ssl
    print(f"[scanner] Connecting to {args.host}:{args.port} ({'SSL' if use_ssl else 'plain'})...")

    try:
        imap = connect_imap(args.host, args.port, args.user, args.password, use_ssl)
    except Exception as e:
        print(f"[scanner] ERROR: Could not connect – {e}", file=sys.stderr)
        sys.exit(1)

    imap.select("INBOX", readonly=True)
    print("[scanner] Connected. Starting search...")

    seen_ids = set()
    results = []

    # Search by subject keywords
    for term in SEARCH_SUBJECTS:
        query = f'SUBJECT "{term}"'.encode()
        msg_ids = search_imap(imap, query)
        for mid in msg_ids:
            if mid not in seen_ids:
                seen_ids.add(mid)
        time.sleep(0.3)

    # Search by sender patterns
    for pattern in SENDER_PATTERNS:
        query = f'FROM "{pattern}"'.encode()
        msg_ids = search_imap(imap, query)
        for mid in msg_ids:
            if mid not in seen_ids:
                seen_ids.add(mid)
        time.sleep(0.3)

    print(f"[scanner] Found {len(seen_ids)} candidate emails. Fetching headers...")

    # Fetch headers for all candidates
    service_map = {}  # service_name -> earliest entry

    for i, mid in enumerate(seen_ids):
        headers = fetch_email_headers(imap, mid)
        if not headers:
            continue

        subject = headers["subject"]
        subject_lower = subject.lower()

        if should_exclude(subject_lower):
            continue

        service = extract_service_name(headers["from"], subject)
        date_str = parse_date(headers["date"])

        entry = {
            "service": service,
            "date": date_str,
            "from": headers["from"],
            "subject": subject,
        }

        # Keep only oldest entry per service
        if service not in service_map:
            service_map[service] = entry
        else:
            if date_str < service_map[service]["date"]:
                service_map[service] = entry

        if i % 50 == 0 and i > 0:
            print(f"[scanner] Processed {i}/{len(seen_ids)} emails...")
        time.sleep(0.05)

    imap.logout()

    final = sorted(service_map.values(), key=lambda x: x["date"], reverse=True)

    with open(args.output, "w", encoding="utf-8") as f:
        json.dump(final, f, ensure_ascii=False, indent=2)

    print(f"[scanner] Done. {len(final)} unique services found → {args.output}")


if __name__ == "__main__":
    main()


path: skill.yaml
content: name: email-registration-scanner
version: "1.0.0"
author: fatihbtw <[REDACTED_SECRET]>
description: Scans email accounts for registration, welcome and confirmation emails to build a chronological list of all services the user has ever signed up for.
tags: [privacy, security, audit, email, imap, gmail]
license: MIT

Security scan verdicts — ClawScan: suspicious | static analysis: clean | VirusTotal: clean | SkillSpector: suspicious (CRITICAL)