A Rust-based Discord Quest Notifier that automatically fetches available quests from Discord's API and sends notifications via Discord Webhooks.

1. Authentication: Uses your Discord user token to access the Quest API
2. Quest Fetching: Polls Discord's /api/v10/quests/@me endpoint at configured intervals
3. Storage: Tracks previously seen quests in a JSON file (or memory)
4. Detection: Compares fetched quests with stored ones to find new quests
5. Notification: Sends Discord webhook embeds for new quests only
6. Multi-locale: Optionally checks all 33+ Discord locales to find region-specific quests

1. Prerequisites: Rust 1.70+ (Install)
2. Setup config:

   cp example.config.toml config.toml

3. Edit config:
   • Add Discord user token (How to get your token)
   • Add webhook URLs under [[discord.webhooks]]

4. Run:

   cargo run

• Fetches quests from Discord API (https://discord.com/api/v10/quests/@me)
• Multi-webhook support with optional names
• Reward filtering: all, orbs, or decor
• Persistent quest storage (JSON) or in-memory
• Configurable check intervals
• Multi-locale support (single or all 33+ locales)
• Docker-ready

[discord]
token = "your_discord_user_token"

[[discord.webhooks]]
url = "https://discordapp.com/api/webhooks/YOUR_ID/YOUR_TOKEN"
name = "Optional webhook name"  # optional

(() => {
    const info = {
        os: navigator.platform || "",
        browser: navigator.userAgent.includes("Chrome") ? "Chrome" :
                 navigator.userAgent.includes("Firefox") ? "Firefox" :
                 navigator.userAgent.includes("Safari") ? "Safari" :
                 "Unknown",
        device: "",
        system_locale: navigator.language || "",
        has_client_mods: false,
        browser_user_agent: navigator.userAgent,
        browser_version: (navigator.userAgent.match(/(Chrome|Firefox|Safari)\/([\d.]+)/) || [undefined,'',''])[2],
        os_version: navigator.userAgent.match(/(Windows NT|Mac OS X|Android|CPU iPhone OS) ([\d_]+)/)?.[2]?.replace(/_/g,".") || "",
        referrer: document.referrer || "",
        referring_domain: document.referrer ? (new URL(document.referrer)).hostname : "",
        referrer_current: location.href,
        referring_domain_current: location.hostname,
        release_channel: "stable",
        client_build_number: Math.floor(Math.random()*900000 + 100000),
        client_event_source: null
    };
    const json = JSON.stringify(info);
    const encoded = btoa(json);
    console.log(encoded);
})();

RUST_LOG=info cargo run

cargo build --release
./target/release/qwesty

docker build -t qwesty .
docker run -v $(pwd)/config.toml:/app/config.toml:ro -v /data:/data qwesty

Qwesty supports distributed multi-region quest monitoring through an Agent/Collector architecture. This allows you to monitor quests from multiple geographic regions (e.g., Korea, US, Europe) while centralizing notifications.

• Collector (Host A): Central hub that receives quest data from agents and sends notifications

  • Runs ingest server on port 8080 (configurable)
  • Also acts as agent for its local region
  • Sends unified notifications via configured webhooks

• Agent (Hosts B, C, ...): Lightweight workers in different regions

  • Fetches quests for assigned region
  • Sends quest data to Collector
  • No webhooks required

[mode]
role = "collector"
accept_token = "your-shared-secret"  # Agents must use this token
ingest_port = 8080  # Optional, defaults to 8080

[region]
code = "id-ID"  # Your collector's local region

[discord]
token = "your_discord_token"

[[discord.webhooks]]
name = "Global Notifications"
url = "https://discordapp.com/api/webhooks/ID/TOKEN"

Run Collector:

cargo run
# or with Docker, expose port 8080
docker run -p 8080:8080 -v $(pwd)/config.toml:/app/config.toml:ro qwesty

[mode]
role = "agent"
collector_url = "https://your-collector.example.com/ingest"
collector_token = "your-shared-secret"  # Must match collector's accept_token

[region]
code = "ko-KR"  # Agent's region (ko-KR, en-US, ja-JP, etc.)

[discord]
token = "your_discord_token"  # Still required to fetch quests

# No webhooks needed for agents

Run Agent:

cargo run
# or
docker run -v $(pwd)/config.toml:/app/config.toml:ro qwesty

Collector exposes:

• POST /ingest - Receives quest payloads from agents
  • Auth: Authorization: Bearer <token>
  • Body: { "region": "ko-KR", "quests": [...], "source": "agent" }
  • Returns: { "accepted": N, "deduped": M }
• GET /health - Health check endpoint

1. Agent fetches quests for its configured region
2. Agent POSTs quest data to Collector's /ingest endpoint with bearer token
3. Collector validates token, deduplicates quests by (region, id)
4. Collector sends Discord notifications for new quests
5. Collector persists deduplicated quests to storage

• Use HTTPS with reverse proxy (Caddy/Nginx recommended)
• Keep accept_token/collector_token secret and complex
• Rotate tokens periodically
• Optional: IP allowlist for known agents

When locale_mode = "all":

• Checks all 33+ Discord locales sequentially
• 60-70s random delay between checks (rate limiting)
• ~35-40 minutes per full cycle
• Quests deduplicated by ID across locales

Notifications are sent as Discord embeds with:

• Quest name and game title
• Reward type (Orbs 🟣, Decorations 🟢, or Other ⚫)
• Expiration time
• Color-coded by reward type

src/
├── main.rs             # Entry point, main loop
├── lib.rs              # Library exports
├── models/
│   ├── config.rs       # Config loading & parsing
│   ├── quest.rs        # Quest data structures
│   ├── errors.rs       # Error types
│   └── mod.rs
├── services/
│   ├── quest_client.rs # Discord API client
│   ├── webhook.rs      # Webhook sender
│   ├── storage.rs      # Quest persistence
│   └── mod.rs
└── utils/
    └── mod.rs          # Utilities

• Endpoint: GET https://discord.com/api/v10/quests/@me
• Auth: Discord user token in Authorization header
• Returns: Array of quest objects with metadata

This project is provided as-is for research and educational purposes only.

This project is licensed under the GNU Affero General Public License v3.0.