waidrop-cli 1.0.0__py3-none-any.whl

waidrop_cli/config.py

@@ -0,0 +1,359 @@
+"""Configuration, bound parsing and time-window resolution."""
+
+from __future__ import annotations
+
+import os
+import re
+from dataclasses import dataclass
+from datetime import datetime, timedelta, tzinfo
+from urllib.parse import urlsplit
+from zoneinfo import ZoneInfo
+
+from .auth import (
+    DEFAULT_API_BASE,
+    DEFAULT_APP_KEY,
+    DEFAULT_CONTENT_BASE,
+    DEFAULT_REVOKE_URL,
+    DEFAULT_TOKEN_URL,
+    load_credentials,
+    resolve_credentials_path,
+)
+from .errors import UsageError
+
+BOUND_RE = re.compile(
+    r"^(\d{4})-(\d{2})-(\d{2})"
+    r"(?:[T ](\d{2})(?::(\d{2})(?::(\d{2}))?)?)?$"
+)
+DURATION_RE = re.compile(r"^(\d+)([mhdw])$")
+ACCOUNT_RE = re.compile(r"^[A-Za-z0-9][A-Za-z0-9._-]*$")
+
+PRECISION_UNITS = {
+    "date": "days",
+    "hour": "hours",
+    "minute": "minutes",
+    "second": "seconds",
+}
+
+DEFAULT_ACCOUNT = "primary"
+
+
+@dataclass(frozen=True)
+class Window:
+    start_ms: int  # inclusive
+    end_ms: int  # exclusive
+    start: datetime
+    end: datetime
+    label: str
+
+
+@dataclass(frozen=True)
+class AuthConfig:
+    """Resolved Dropbox credentials (no archive key required)."""
+
+    app_key: str | None
+    token: str | None
+    refresh_token: str | None
+    app_secret: str | None
+    credentials_path: str
+    timeout: float
+    api_base: str = DEFAULT_API_BASE
+    content_base: str = DEFAULT_CONTENT_BASE
+    token_url: str = DEFAULT_TOKEN_URL
+    revoke_url: str = DEFAULT_REVOKE_URL
+    from_file: bool = False
+    token_expires_at: float | None = None
+
+
+@dataclass(frozen=True)
+class DropboxConfig:
+    token: str | None
+    refresh_token: str | None
+    app_key: str | None
+    app_secret: str | None
+    archive_key: str
+    account: str
+    folder: str
+    tz: tzinfo
+    timeout: float
+    max_parts: int
+    api_base: str = DEFAULT_API_BASE
+    content_base: str = DEFAULT_CONTENT_BASE
+    token_url: str = DEFAULT_TOKEN_URL
+    revoke_url: str = DEFAULT_REVOKE_URL
+    credentials_path: str | None = None
+    from_file: bool = False
+    token_expires_at: float | None = None
+
+    @property
+    def account_root(self) -> str:
+        return f"{self.folder}/account={self.account}"
+
+
+LOOPBACK_HOSTS = {"127.0.0.1", "localhost", "::1"}
+
+
+def _dropbox_urls(base: str) -> dict:
+    """Resolve the test endpoint override.
+
+    WAIDROP_TEST_DROPBOX_BASE redirects every Dropbox call, including the
+    OAuth token exchange and the bearer token, so a tampered environment must
+    not be able to point it at an arbitrary plaintext host. HTTPS is always
+    allowed; HTTP only for loopback test servers.
+    """
+    if not base:
+        return {}
+    parsed = urlsplit(base)
+    if parsed.scheme not in {"http", "https"} or not parsed.hostname:
+        raise UsageError("WAIDROP_TEST_DROPBOX_BASE must be an http(s) URL")
+    if parsed.scheme == "http" and parsed.hostname not in LOOPBACK_HOSTS:
+        raise UsageError(
+            "WAIDROP_TEST_DROPBOX_BASE must use https "
+            "(http is allowed only for loopback test servers)"
+        )
+    if parsed.username or parsed.password or parsed.query or parsed.fragment:
+        raise UsageError(
+            "WAIDROP_TEST_DROPBOX_BASE must not contain credentials, a query or a fragment"
+        )
+    return {
+        "api_base": f"{base}/2",
+        "content_base": f"{base}/2",
+        "token_url": f"{base}/oauth2/token",
+        "revoke_url": f"{base}/2/auth/token/revoke",
+    }
+
+
+def resolve_auth(args) -> AuthConfig:
+    """Resolve Dropbox credentials from flags, env, the env file, then the local file.
+
+    Precedence: CLI flag > environment variable > private env file > credentials
+    file. An explicit access or refresh token (flag/env) disables file lookups so
+    secrets injected by a host are never overwritten.
+    """
+
+    env_file_values = getattr(args, "env_file_values", {})
+
+    def value(flag: str, env: str) -> str:
+        return str(
+            getattr(args, flag, None) or os.environ.get(env) or env_file_values.get(env) or ""
+        ).strip()
+
+    app_key = value("dropbox_app_key", "WAIDROP_DROPBOX_APP_KEY") or None
+    token = value("dropbox_token", "WAIDROP_DROPBOX_TOKEN") or None
+    refresh_token = value("dropbox_refresh_token", "WAIDROP_DROPBOX_REFRESH_TOKEN") or None
+    app_secret = value("dropbox_app_secret", "WAIDROP_DROPBOX_APP_SECRET") or None
+
+    timeout = getattr(args, "timeout", None)
+    timeout = 60.0 if timeout is None else float(timeout)
+
+    credentials_path = resolve_credentials_path(args)
+    from_file = False
+    token_expires_at: float | None = None
+    if token is None and refresh_token is None:
+        creds = load_credentials(credentials_path)
+        if creds is not None:
+            token = creds.access_token
+            refresh_token = creds.refresh_token or None
+            token_expires_at = creds.expires_at
+            if app_key is None:
+                app_key = creds.app_key or None
+            from_file = True
+
+    if app_key is None:
+        app_key = DEFAULT_APP_KEY or None
+
+    base = (os.environ.get("WAIDROP_TEST_DROPBOX_BASE") or "").strip().rstrip("/")
+
+    return AuthConfig(
+        app_key=app_key,
+        token=token,
+        refresh_token=refresh_token,
+        app_secret=app_secret,
+        credentials_path=str(credentials_path),
+        timeout=timeout,
+        from_file=from_file,
+        token_expires_at=token_expires_at,
+        **_dropbox_urls(base),
+    )
+
+
+def parse_tz(name: str | None) -> tzinfo:
+    if not name:
+        return datetime.now().astimezone().tzinfo
+    try:
+        return ZoneInfo(name)
+    except Exception as exc:
+        raise UsageError(f"unknown timezone: {name}") from exc
+
+
+def _normalize_folder(value: str | None) -> str:
+    folder = str(value or "").strip().strip("/")
+    return f"/{folder}" if folder else ""
+
+
+def load_config(args) -> DropboxConfig:
+    auth = resolve_auth(args)
+
+    if not auth.token and not (auth.refresh_token and auth.app_key):
+        raise UsageError(
+            "Dropbox is not connected. Run `waidrop auth` to connect, or set "
+            "WAIDROP_DROPBOX_TOKEN (or WAIDROP_DROPBOX_REFRESH_TOKEN + "
+            "WAIDROP_DROPBOX_APP_KEY) for testing."
+        )
+
+    env_file_values = getattr(args, "env_file_values", {})
+
+    def value(flag: str, env: str) -> str:
+        return str(
+            getattr(args, flag, None) or os.environ.get(env) or env_file_values.get(env) or ""
+        ).strip()
+
+    archive_key = value("key", "WAIDROP_KEY")
+
+    account = value("account", "WAIDROP_ACCOUNT") or DEFAULT_ACCOUNT
+    if not ACCOUNT_RE.match(account):
+        raise UsageError("account alias may only contain letters, digits and . _ -")
+
+    folder = _normalize_folder(value("folder", "WAIDROP_FOLDER"))
+
+    if auth.timeout <= 0:
+        raise UsageError("--timeout must be positive")
+
+    max_parts = getattr(args, "max_parts", 1000)
+    if not isinstance(max_parts, int) or max_parts < 1:
+        raise UsageError("--max-parts must be a positive integer")
+
+    return DropboxConfig(
+        token=auth.token,
+        refresh_token=auth.refresh_token,
+        app_key=auth.app_key,
+        app_secret=auth.app_secret,
+        archive_key=archive_key,
+        account=account,
+        folder=folder,
+        tz=parse_tz(getattr(args, "tz", None)),
+        timeout=auth.timeout,
+        max_parts=max_parts,
+        api_base=auth.api_base,
+        content_base=auth.content_base,
+        token_url=auth.token_url,
+        revoke_url=auth.revoke_url,
+        credentials_path=auth.credentials_path,
+        from_file=auth.from_file,
+        token_expires_at=auth.token_expires_at,
+    )
+
+
+def parse_bound(text: str, tz: tzinfo) -> tuple[datetime, str]:
+    """Parse a bound and return (datetime, precision).
+
+    Accepted: YYYY-MM-DD, YYYY-MM-DDTHH, YYYY-MM-DDTHH:MM,
+    YYYY-MM-DDTHH:MM:SS (space separator also allowed).
+    """
+    match = BOUND_RE.match((text or "").strip())
+    if not match:
+        raise UsageError(
+            f"invalid date/time {text!r}; use YYYY-MM-DD, YYYY-MM-DDTHH, "
+            "YYYY-MM-DDTHH:MM or YYYY-MM-DDTHH:MM:SS"
+        )
+    year, month, day = int(match.group(1)), int(match.group(2)), int(match.group(3))
+    hour = int(match.group(4) or 0)
+    minute = int(match.group(5) or 0)
+    second = int(match.group(6) or 0)
+    try:
+        moment = datetime(year, month, day, hour, minute, second, tzinfo=tz)
+    except ValueError as exc:
+        raise UsageError(f"invalid date/time {text!r}: {exc}") from exc
+
+    if match.group(6) is not None:
+        precision = "second"
+    elif match.group(5) is not None:
+        precision = "minute"
+    elif match.group(4) is not None:
+        precision = "hour"
+    else:
+        precision = "date"
+    return moment, precision
+
+
+def _precision_delta(precision: str) -> timedelta:
+    return timedelta(**{PRECISION_UNITS[precision]: 1})
+
+
+def snap_start(moment: datetime, precision: str) -> datetime:
+    if precision == "date":
+        return moment.replace(hour=0, minute=0, second=0, microsecond=0)
+    if precision == "hour":
+        return moment.replace(minute=0, second=0, microsecond=0)
+    if precision == "minute":
+        return moment.replace(second=0, microsecond=0)
+    return moment.replace(microsecond=0)
+
+
+def snap_end_exclusive(moment: datetime, precision: str) -> datetime:
+    return snap_start(moment, precision) + _precision_delta(precision)
+
+
+def parse_duration(text: str) -> timedelta:
+    match = DURATION_RE.match((text or "").strip().lower())
+    if not match:
+        raise UsageError(f"invalid --last {text!r}; use e.g. 90m, 36h, 7d, 2w")
+    amount = int(match.group(1))
+    if amount < 1:
+        raise UsageError("--last must be at least 1 unit")
+    unit = match.group(2)
+    unit_name = {"m": "minutes", "h": "hours", "d": "days", "w": "weeks"}[unit]
+    return timedelta(**{unit_name: amount})
+
+
+def parse_context_before(text: str | None) -> timedelta:
+    value = (text or "").strip().lower()
+    if value in ("", "0"):
+        return timedelta(0)
+    match = DURATION_RE.match(value)
+    if not match:
+        raise UsageError(f"invalid --context-before {text!r}; use 0 or e.g. 30m, 36h, 7d, 2w")
+    amount = int(match.group(1))
+    unit = match.group(2)
+    unit_name = {"m": "minutes", "h": "hours", "d": "days", "w": "weeks"}[unit]
+    return timedelta(**{unit_name: amount})
+
+
+def _ms(moment: datetime) -> int:
+    return int(moment.timestamp() * 1000)
+
+
+def resolve_window(
+    from_text: str | None,
+    to_text: str | None,
+    last_text: str | None,
+    tz: tzinfo,
+    now: datetime | None = None,
+) -> Window:
+    now = now or datetime.now(tz)
+
+    if last_text:
+        if from_text or to_text:
+            raise UsageError("--last cannot be combined with --from/--to")
+        duration = parse_duration(last_text)
+        end = now
+        start = end - duration
+        label = f"last {last_text} ({start.isoformat()} .. {end.isoformat()})"
+        return Window(_ms(start), _ms(end) + 1, start, end, label)
+
+    if not from_text:
+        raise UsageError("provide --from or --last")
+
+    start_dt, start_precision = parse_bound(from_text, tz)
+    start = snap_start(start_dt, start_precision)
+
+    if to_text:
+        to_dt, to_precision = parse_bound(to_text, tz)
+        end = snap_end_exclusive(to_dt, to_precision)
+    else:
+        end = now
+
+    if end <= start:
+        raise UsageError("--to must be after --from")
+
+    label = f"{start.isoformat()} .. {end.isoformat()} (end exclusive)"
+    return Window(_ms(start), _ms(end), start, end, label)

waidrop_cli/context.py

@@ -0,0 +1,352 @@
+"""Group archive records into per-chat conversation chunks."""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass, field
+from datetime import tzinfo
+
+from .chats import ChatEntry
+from .config import Window
+from .fetch import effective_ts
+from .output import escape_text, record_body, record_moment, safe_cell
+
+
+@dataclass(frozen=True)
+class ChatMeta:
+    hash: str | None
+    id: str | None
+    name: str
+    phone: str | None
+    pushname: str | None
+    is_group: bool
+
+    @property
+    def key(self) -> str:
+        if self.hash:
+            return self.hash
+        if self.id:
+            return self.id
+        return f"name:{self.name.casefold()}"
+
+    def as_dict(self) -> dict:
+        return {
+            "hash": self.hash,
+            "id": self.id,
+            "name": self.name,
+            "phone": self.phone,
+            "pushname": self.pushname,
+            "isGroup": self.is_group,
+        }
+
+
+@dataclass
+class ChatThread:
+    meta: ChatMeta
+    messages: list[dict] = field(default_factory=list)
+    last_ts: int = 0
+
+
+@dataclass
+class ContextChunk:
+    chunk_id: str
+    meta: ChatMeta
+    window: Window
+    context_before_ms: int
+    part: int
+    parts: int
+    oversized: bool
+    messages: list[dict]
+
+    def as_dict(self) -> dict:
+        return {
+            "chunkVersion": 1,
+            "chunkId": self.chunk_id,
+            "chat": self.meta.as_dict(),
+            "window": {
+                "start": self.window.start_ms,
+                "end": self.window.end_ms,
+                "startIso": self.window.start.isoformat(),
+                "endIso": self.window.end.isoformat(),
+            },
+            "contextBeforeMs": self.context_before_ms,
+            "part": self.part,
+            "parts": self.parts,
+            "oversized": self.oversized,
+            "messages": self.messages,
+        }
+
+
+def _entry_maps(selected: list[ChatEntry]) -> tuple[dict[str, ChatEntry], dict[str, ChatEntry]]:
+    by_id = {entry.chat_id: entry for entry in selected if entry.chat_id}
+    counts: dict[str, int] = {}
+    for entry in selected:
+        name = entry.chat_name.casefold()
+        counts[name] = counts.get(name, 0) + 1
+    by_name = {
+        entry.chat_name.casefold(): entry
+        for entry in selected
+        if entry.chat_name and counts[entry.chat_name.casefold()] == 1
+    }
+    return by_id, by_name
+
+
+def _entry_meta(entry: ChatEntry) -> ChatMeta:
+    return ChatMeta(
+        hash=entry.hash or None,
+        id=entry.chat_id or None,
+        name=entry.chat_name or "unknown",
+        phone=entry.chat_phone or None,
+        pushname=entry.chat_pushname or None,
+        is_group=entry.is_group,
+    )
+
+
+CONTEXT_MEDIA_TYPES = {"image", "sticker", "gif", "media"}
+
+
+def is_media_record(record: dict) -> bool:
+    return record.get("type") in CONTEXT_MEDIA_TYPES
+
+
+def attach_media_exports(threads: list[ChatThread], entries: list[dict]) -> None:
+    """Attach export results to media messages in the given threads."""
+    by_id = {entry.get("msgId"): entry for entry in entries if entry.get("msgId")}
+    for thread in threads:
+        for message in thread.messages:
+            if not is_media_record(message):
+                continue
+            entry = by_id.get(message.get("msgId"))
+            if entry is None:
+                message["mediaExport"] = {
+                    "status": "skipped",
+                    "file": None,
+                    "error": "not considered for export",
+                }
+                continue
+            message["mediaExport"] = {
+                "status": entry.get("status") or "skipped",
+                "file": entry.get("file"),
+                "error": entry.get("error"),
+            }
+
+
+def group_records(
+    records: list[dict], selected: list[ChatEntry], window: Window
+) -> list[ChatThread]:
+    """Group records by chat, keep only chats with messages in the window."""
+    by_id, by_name = _entry_maps(selected)
+    threads: dict[str, ChatThread] = {}
+
+    for record in records:
+        ts = effective_ts(record)
+        if ts is None:
+            continue
+
+        raw_chat_id = record.get("chatId")
+        chat_id = raw_chat_id if isinstance(raw_chat_id, str) and raw_chat_id else None
+        name = str(record.get("chatName") or "").strip()
+
+        entry = by_id.get(chat_id) if chat_id else None
+        if entry is None and chat_id is None and name:
+            entry = by_name.get(name.casefold())
+
+        if entry is not None:
+            key = entry.chat_id
+            meta = _entry_meta(entry)
+        else:
+            label = name or "unknown"
+            key = chat_id or f"name:{label.casefold()}"
+            meta = ChatMeta(
+                hash=None,
+                id=chat_id,
+                name=label,
+                phone=str(record.get("chatPhone") or "") or None,
+                pushname=str(record.get("chatPushname") or "") or None,
+                is_group=bool(record.get("isGroup")) or bool(chat_id and chat_id.endswith("@g.us")),
+            )
+
+        thread = threads.get(key)
+        if thread is None:
+            thread = ChatThread(meta=meta)
+            threads[key] = thread
+
+        message = dict(record)
+        message["inWindow"] = bool(window.start_ms <= ts < window.end_ms)
+        thread.messages.append(message)
+
+    result: list[ChatThread] = []
+    for thread in threads.values():
+        thread.messages.sort(key=lambda item: (effective_ts(item) or 0, item.get("msgId") or ""))
+        in_window_ts = [effective_ts(item) for item in thread.messages if item.get("inWindow")]
+        if not in_window_ts:
+            continue
+        thread.last_ts = int(max(in_window_ts))
+        result.append(thread)
+
+    result.sort(key=lambda item: (-item.last_ts, item.meta.key))
+    return result
+
+
+def _escape_inline(value: object) -> str:
+    return escape_text(value)
+
+
+def _safe_header(value: object) -> str:
+    return safe_cell(str(value).replace("|", "/"))
+
+
+def _quote_path(path: object) -> str:
+    return json.dumps(str(path), ensure_ascii=False)
+
+
+def _media_annotation(record: dict) -> str:
+    export = record.get("mediaExport")
+    if not isinstance(export, dict):
+        return ""
+    file = export.get("file")
+    if file:
+        return f" (file: {_quote_path(file)})"
+
+    media = record.get("media") if isinstance(record.get("media"), dict) else {}
+    status = _escape_inline(media.get("status") or "")
+    if status and status != "stored":
+        return f" (media: {status})"
+    if export.get("status") == "failed":
+        return " (media: export failed)"
+    if export.get("status") == "skipped":
+        if not status:
+            return " (media: unavailable)"
+        return " (media: not exported)"
+    return ""
+
+
+def _message_line(record: dict, tz: tzinfo, context: bool) -> str:
+    moment = record_moment(record, tz)
+    stamp = moment.strftime("%Y-%m-%d %H:%M") if moment else "????-??-?? ??:??"
+    direction = record.get("direction")
+    glyph = "→" if direction == "out" else "←" if direction == "in" else "·"
+    sender = "You" if direction == "out" else (record.get("senderName") or "Unknown")
+    marker = "[context] " if context else ""
+    body = _escape_inline(record_body(record))
+    return f"[{stamp}] {marker}{glyph} {_escape_inline(sender)}: {body}{_media_annotation(record)}"
+
+
+def _duration_label(milliseconds: int) -> str:
+    seconds = max(milliseconds, 0) // 1000
+    for unit_seconds, suffix in ((604800, "w"), (86400, "d"), (3600, "h"), (60, "m")):
+        if seconds and seconds % unit_seconds == 0:
+            return f"{seconds // unit_seconds}{suffix}"
+    return f"{seconds}s"
+
+
+def _window_label(window: Window, tz: tzinfo) -> str:
+    start = window.start.astimezone(tz)
+    end = window.end.astimezone(tz)
+    zone = start.tzname() or start.strftime("%z")
+    if start.date() == end.date():
+        span = f"{start:%Y-%m-%d %H:%M}–{end:%H:%M}"
+    else:
+        span = f"{start:%Y-%m-%d %H:%M}–{end:%Y-%m-%d %H:%M}"
+    return f"{span} {zone}".strip()
+
+
+def _pack_messages(
+    messages: list[dict], max_chars: int, tz: tzinfo
+) -> list[tuple[list[dict], bool]]:
+    if max_chars <= 0:
+        return [(messages, False)]
+
+    parts: list[tuple[list[dict], bool]] = []
+    current: list[dict] = []
+    current_len = 0
+
+    for message in messages:
+        line_len = len(_message_line(message, tz, context=not message.get("inWindow", True)))
+        if line_len > max_chars:
+            if current:
+                parts.append((current, False))
+                current = []
+                current_len = 0
+            parts.append(([message], True))
+            continue
+
+        extra = line_len + (1 if current else 0)
+        if current and current_len + extra > max_chars:
+            parts.append((current, False))
+            current = [message]
+            current_len = line_len
+        else:
+            current.append(message)
+            current_len += extra
+
+    if current:
+        parts.append((current, False))
+    return parts or [(messages, False)]
+
+
+def build_chunks(
+    threads: list[ChatThread],
+    window: Window,
+    context_before_ms: int,
+    max_chars: int,
+    tz: tzinfo,
+) -> list[ContextChunk]:
+    chunks: list[ContextChunk] = []
+    for thread in threads:
+        packed = _pack_messages(thread.messages, max_chars, tz)
+        total = len(packed)
+        for index, (messages, oversized) in enumerate(packed, 1):
+            first_ts = int(effective_ts(messages[0]) or 0)
+            last_ts = int(effective_ts(messages[-1]) or first_ts)
+            chunks.append(
+                ContextChunk(
+                    chunk_id=f"{thread.meta.key}:{first_ts}:{last_ts}:{index}",
+                    meta=thread.meta,
+                    window=window,
+                    context_before_ms=context_before_ms,
+                    part=index,
+                    parts=total,
+                    oversized=oversized,
+                    messages=messages,
+                )
+            )
+    return chunks
+
+
+def render_chunks_ndjson(chunks: list[ContextChunk]) -> list[str]:
+    return [json.dumps(chunk.as_dict(), ensure_ascii=False) for chunk in chunks]
+
+
+def render_chunks_text(chunks: list[ContextChunk], tz: tzinfo) -> list[str]:
+    lines: list[str] = []
+    for chunk in chunks:
+        if lines:
+            lines.append("")
+
+        identity = chunk.meta.hash or chunk.meta.id or chunk.meta.name
+        kind = "group" if chunk.meta.is_group else "dm"
+        part = f" | part {chunk.part}/{chunk.parts}" if chunk.parts > 1 else ""
+        lines.append(
+            "=== CHAT "
+            f"{_safe_header(identity)} | {_safe_header(chunk.meta.name)} | {kind} | "
+            f"{_safe_header(chunk.meta.phone or '-')}{part} ==="
+        )
+        lines.append(f"[window {_window_label(chunk.window, tz)}]")
+
+        has_context = any(not message.get("inWindow", True) for message in chunk.messages)
+        if chunk.context_before_ms > 0 and has_context:
+            lines.append(f"[context before {_duration_label(chunk.context_before_ms)}]")
+
+        for message in chunk.messages:
+            lines.append(_message_line(message, tz, context=not message.get("inWindow", True)))
+
+        if chunk.part < chunk.parts:
+            lines.append(
+                f"=== END PART {chunk.part}/{chunk.parts} "
+                f"(continues in part {chunk.part + 1}/{chunk.parts}) ==="
+            )
+        else:
+            suffix = ", oversized message" if chunk.oversized else ""
+            lines.append(f"=== END CHAT ({chunk.part}/{chunk.parts}{suffix}) ===")
+    return lines