Archive a Discord channel into the SQLite archive.

Incremental by default: only messages newer than the stored watermark (MAX message id per channel) are fetched. Use full=True for a one-time backfill. Requires the persistent Chrome daemon (auto-starts; the user must have logged into Discord in its profile at least once).

Long jobs run in the background: the call waits up to wait seconds (default 45) and returns the full result if the capture finished in time. If it is still running, it returns {"status": "running", ...} immediately and the capture continues — call capture() again for the same channel to fetch the final result, or watch progress via status()/recent(). Never fire captures for several channels in parallel: they queue on the global capture lock and serialize automatically (capture() reports waiting_for_lock while queued).

Args: channel: channel ID or full discord.com/channels/... URL. full: backfill the entire history instead of incrementing. since: explicit watermark message ID (overrides the stored one). limit: hard cap on messages (test runs). no_media: skip attachment + embed-image downloads (CDN links expire!). refresh: re-extract ALL visible messages, retrofitting embed images onto rows captured before image extraction existed (combine with full=True for the whole channel). wait: seconds to wait synchronously for completion before returning a "running" summary (keep below your client's request timeout (many clients cap it at ~60 s). Returns: Dict with new_messages, seen, stop_reason, total_in_db — or a {"status": "running", "job": {...}} summary for long backfills.

Read the most recent archived messages of a channel (no browser needed).

Args: channel: channel ID or full URL. since: only messages with id > this message ID (e.g. the watermark from status() before a capture, to see what's new). limit: max messages (default 100). include_embeds: include embed text (tweet payloads live there). Returns: Dict: {"messages": [ {id, ts, author, content, embeds, attachments}, ... ]}.

Substring search over the archive (message content, embeds, author).

Without scope this spans every archived server. Use server= or channel= to restrict; every hit carries its server_id/server_name.

Args: query: search term (substring match; % and _ match literally). server: optional server ID or name (case-insensitive, unique substring ok) to restrict to. channel: optional channel ID/URL to restrict to (applies within the server scope, if any). limit: max hits (default 50). Returns: Dict: {"hits": [ {id, server_id, server_name, channel_id, author_name, ts, content}, ... ]}.

Archive status: total messages, per-channel watermark and counts.

Args: channel: optional channel ID/URL to show only that channel. Returns: Dict with totals, per-channel rows (id, name, msgs, watermark) and active_captures (background capture/backfill jobs currently running or queued on the capture lock, if any).

List Discord servers known to the archive (id, name, channels, messages).

List channels known to the archive (optionally of one server).

Args: server: optional server ID or name to restrict to. Returns: Dict: {"channels": [ {id, server_id, server_name, name, last_message_id}, ... ]}.

List attachments AND embed images archived for a channel.

Downloaded files live under DMINE_MEDIA (default ~/.config/dmine/media//, embed images in /embeds/). Entries without local_path only carry the CDN URL, which may already be expired. Use remedia() to (re-)download while the links are valid.

Args: channel: channel ID or full URL. limit: max messages to scan (default 200). message_since: only messages with id > this message ID. Returns: Dict: {"media_dir": str, "count": int, "attachments": [ ... ]} with per-entry kind ("attachment"|"embed_image"), message_id, ts, author, filename, downloaded, local_path, url.

Re-download media (attachments + embed images) for ALREADY archived messages and persist local paths (idempotent, skips existing files). Also retries entries whose earlier download failed (no local file).

Like capture(), long runs continue in the background: the call returns a {"status": "running", ...} summary after wait seconds at the latest and the download continues — call remedia() again for the same channel to fetch the final result.

Args: channel: channel ID or full URL. limit: only the N most recent messages (None = all). wait: seconds to wait synchronously before returning a running summary. Returns: Dict: {"channel_id", "messages_with_media", "media_entries"}.

Export a channel from the archive to a file (jsonl or markdown).

The output path is sandboxed to the export directory (DMINE_EXPORT_DIR, default ~/.config/dmine/exports/) — absolute paths and '..' traversal are rejected.

Args: channel: channel ID or full URL. format: "jsonl" or "md". since: only messages with id > this message ID. out: filename relative to the export dir (default .). Returns: Dict with path, message_count.