line-ext-msg 1.0.0__py3-none-any.whl

line_ext_msg/__init__.py

@@ -0,0 +1,34 @@
+"""line-ext-msg: pull messages from LINE Chrome Extension via Playwright CDP."""
+
+__version__ = "1.0.0"
+
+from .client import LineClient
+from .messages import sender_stats
+from .errors import (
+    AppNotReady,
+    AttachFailed,
+    ChromeNotReady,
+    ExtensionMissing,
+    LineError,
+    LoginRequired,
+    RoomNotFound,
+)
+from .models import Message, Room, StepResult
+from .settings import Settings
+
+__all__ = [
+    "__version__",
+    "LineClient",
+    "sender_stats",
+    "Room",
+    "Message",
+    "StepResult",
+    "Settings",
+    "LineError",
+    "ChromeNotReady",
+    "AttachFailed",
+    "ExtensionMissing",
+    "AppNotReady",
+    "LoginRequired",
+    "RoomNotFound",
+]

line_ext_msg/auth.py

@@ -0,0 +1,58 @@
+"""Login check: distinguish 'not logged in' from 'selector mismatch'."""
+
+from playwright.sync_api import Page
+
+from .settings import SELECTORS
+
+# Fast login-screen locators (CSS-module hashes change, so match stable parts).
+LOGIN_LOCATORS = [
+    "[class*='loginPage']",
+    "text=QR code login",
+    "text=Log in",
+]
+
+# Fallback text markers when locators miss (checked on small scope only).
+LOGIN_MARKERS = [
+    "qr code", "qr login", "email address",
+    "เข้าสู่ระบบ", "ล็อกอิน",
+]
+
+
+def _has_login_ui(page: Page) -> bool:
+    """True if any login marker is visible (cheap locator checks)."""
+    for sel in LOGIN_LOCATORS:
+        try:
+            if page.locator(sel).count() > 0:
+                return True
+        except Exception:
+            continue
+    return False
+
+
+def check_login(page: Page, timeout_ms: int = 10000) -> tuple[bool, str]:
+    """Poll chat UI vs login UI; return as soon as either appears.
+
+    Return (logged_in, reason): 'chat' / 'login' / 'unknown'.
+    Caller must ensure the app finished rendering (wait_for_app_ready).
+    """
+    # Poll room rows (not the container: it may not exist as one element).
+    rows = [s.strip() for s in SELECTORS["room_item"].split(",")]
+    # Poll every 500ms; worst case only when page genuinely stuck.
+    for _ in range(max(1, timeout_ms // 500)):
+        for sel in rows:
+            try:
+                if page.locator(sel).count() > 0:
+                    return True, "chat"
+            except Exception:
+                continue
+        if _has_login_ui(page):
+            return False, "login"
+        page.wait_for_timeout(500)
+    # Final text fallback on rendered body before giving up.
+    try:
+        text = (page.inner_text("body") or "").lower()
+    except Exception:
+        text = ""
+    if any(m in text for m in LOGIN_MARKERS):
+        return False, "login"
+    return False, "unknown"

line_ext_msg/chrome.py

@@ -0,0 +1,94 @@
+"""Chrome lifecycle: ensure a debuggable instance on the isolated profile."""
+
+import os
+import subprocess
+import time
+import urllib.request
+
+from .settings import Settings
+
+
+def expand(path: str) -> str:
+    """Expand %VAR% on Windows and ~ on all platforms."""
+    return os.path.expandvars(os.path.expanduser(path))
+
+
+def find_chrome_exe() -> str | None:
+    """Search common install locations, return exe path or None."""
+    candidates = [
+        r"C:\Program Files\Google\Chrome\Application\chrome.exe",
+        r"C:\Program Files (x86)\Google\Chrome\Application\chrome.exe",
+        expand(r"%LOCALAPPDATA%\Google\Chrome\Application\chrome.exe"),
+    ]
+    for path in candidates:
+        if path and os.path.isfile(path):
+            return path
+    return None
+
+
+def is_debug_ready(settings: Settings, timeout_sec: int = 2) -> bool:
+    """Check CDP endpoint responds with valid Browser field."""
+    try:
+        with urllib.request.urlopen(f"{settings.cdp_endpoint}/json/version", timeout=timeout_sec) as res:
+            return "Browser" in res.read().decode("utf-8", errors="ignore")
+    except Exception:
+        return False
+
+
+def is_headless(settings: Settings, timeout_sec: int = 2) -> bool:
+    """Detect a headless instance squatting the debug port (no visible window)."""
+    try:
+        with urllib.request.urlopen(f"{settings.cdp_endpoint}/json/version", timeout=timeout_sec) as res:
+            return "Headless" in res.read().decode("utf-8", errors="ignore")
+    except Exception:
+        return False
+
+
+def _is_profile_locked(data_dir: str) -> bool:
+    """Detect SingletonLock (profile in use by a normal window)."""
+    return any(
+        os.path.exists(os.path.join(data_dir, name))
+        for name in ("SingletonLock", "SingletonSocket", "SingletonCookie")
+    )
+
+
+def start_chrome_debug(settings: Settings) -> None:
+    """Start detached Chrome on the isolated profile.
+
+    Chrome 136+ ignores --remote-debugging-port on the default profile,
+    hence the isolated dir. Login + install persist there after first setup.
+    """
+    from .errors import ChromeNotReady
+
+    exe = find_chrome_exe()
+    if exe is None:
+        raise ChromeNotReady("ไม่พบ chrome.exe กรุณาติดตั้ง Chrome ก่อน")
+    data_dir = expand(settings.profile_dir)
+    if _is_profile_locked(data_dir):
+        raise ChromeNotReady("โปรไฟล์ Chrome ถูกใช้อยู่ ปิดหน้าต่าง debug เก่าก่อนแล้วรันใหม่")
+    os.makedirs(data_dir, exist_ok=True)
+    subprocess.Popen(
+        [exe, f"--remote-debugging-port={settings.port}", f"--user-data-dir={data_dir}"],
+        stdout=subprocess.DEVNULL,
+        stderr=subprocess.DEVNULL,
+        creationflags=getattr(subprocess, "DETACHED_PROCESS", 0),
+    )
+    for _ in range(30):
+        if is_debug_ready(settings, timeout_sec=1):
+            return
+        time.sleep(0.5)
+    raise ChromeNotReady("เปิด Chrome แล้วแต่พอร์ต debug ไม่ตอบใน 15 วิ")
+
+
+def ensure_chrome(settings: Settings) -> None:
+    """Ensure headed debug Chrome is running; start it if the port is closed."""
+    from .errors import ChromeNotReady
+
+    if is_debug_ready(settings):
+        if is_headless(settings):
+            raise ChromeNotReady(
+                "พอร์ต debug ถูกโปรแกรมอื่น (headless) ใช้อยู่ ไม่มีหน้าต่างให้เห็น "
+                "รัน: Get-Process chrome | Stop-Process -Force แล้วรันใหม่"
+            )
+        return
+    start_chrome_debug(settings)

line_ext_msg/cli.py

@@ -0,0 +1,99 @@
+"""Thin CLI over LineClient: parse args, print results."""
+import argparse
+
+from .client import LineClient
+from .errors import LineError
+from .models import Room
+
+
+def _display(m) -> str:
+    """Readable line: text, or media label when the bubble has no text."""
+    if m.text:
+        return m.text[:80]
+    if m.type == "image":
+        return f"[รูปภาพ: {m.media or 'โหลดไม่สำเร็จ'}]"
+    if m.type == "sticker":
+        return "[สติกเกอร์]"
+    if m.type == "system":
+        return m.text
+    return f"[{m.type}]"
+
+
+def pick_room(rooms: list[Room]) -> Room:
+    """Show rooms in terminal and return user choice."""
+    print("\nห้องแชททั้งหมด:")
+    for r in rooms:
+        unread = f" ({r.unread} ไม่อ่าน)" if r.unread else ""
+        print(f"  [{r.index}] {r.name}{unread}")
+    while True:
+        raw = input("พิมพ์เลขห้อง > ").strip()
+        if raw.isdigit() and any(r.index == int(raw) for r in rooms):
+            return next(r for r in rooms if r.index == int(raw))
+        print("เลขไม่ถูกต้อง ลองใหม่")
+
+
+def main():
+    parser = argparse.ArgumentParser(description="ดึงข้อความล่าสุดจาก LINE Extension")
+    parser.add_argument("--limit", type=int, default=5, help="จำนวนข้อความล่าสุด")
+    parser.add_argument("--date", default=None, help="กรองเฉพาะวันที่ YYYY-MM-DD")
+    parser.add_argument("--date-from", default=None, help="ตั้งแต่วันที่ YYYY-MM-DD")
+    parser.add_argument("--date-to", default=None, help="ถึงวันที่ YYYY-MM-DD")
+    parser.add_argument("--time-from", default=None, help="ตั้งแต่เวลา HH:MM")
+    parser.add_argument("--time-to", default=None, help="ถึงเวลา HH:MM")
+    parser.add_argument("--sender", default=None, help="กรองชื่อคนส่ง (บางส่วน)")
+    parser.add_argument("--keyword", default=None, help="ค้นคำในข้อความ")
+    parser.add_argument("--search", default=None, metavar="KEYWORD",
+                        help="ค้นทุกห้อง แล้วสรุปห้องที่เจอ")
+    parser.add_argument("--unread", action="store_true", help="แสดงเฉพาะห้องที่ไม่อ่าน")
+    parser.add_argument("--save", action="store_true", help="เขียน rooms.json + messages ลงไฟล์ (default พิมพ์จออย่างเดียว)")
+    parser.add_argument("--dump", action="store_true", help="บันทึก DOM ดิบเพื่อจูน selector")
+    parser.add_argument("--dump-room", type=int, default=None, metavar="INDEX",
+                        help="เปิดห้องลำดับ INDEX แล้วบันทึก DOM เพื่อจูน selector ข้อความ")
+    args = parser.parse_args()
+
+    try:
+        with LineClient() as line:
+            if args.dump:
+                state = line.dump_page()
+                print(f"บันทึก line_dom.html แล้ว (state={state}) ส่งไฟล์นี้มาเพื่อจูน selector")
+                return
+            line.status()
+            if args.dump_room is not None:
+                room = line.dump_room(args.dump_room)
+                print(f"บันทึก line_room.html แล้ว (ห้อง {room.name}) ส่งไฟล์นี้มาเพื่อจูน selector ข้อความ")
+                return
+            rooms = line.list_rooms(unread_only=args.unread)
+            if not rooms:
+                print("อ่านรายชื่อห้องไม่ได้ รัน --dump แล้วส่ง line_dom.html มา")
+                return
+            if args.save:
+                path = line.save_rooms(unread_only=args.unread)
+                print(f"บันทึก {path} ({len(rooms)} ห้อง)")
+            if args.search:
+                for hit in line.search_all(args.search, date_from=args.date_from,
+                                           date_to=args.date_to or args.date):
+                    print(f"\n== {hit['room']['name']} ({len(hit['messages'])} ข้อความ) ==")
+                    for m in hit["messages"]:
+                        print(f"[{m['date']} {m['ts']}] {m['sender']}: {m['text'][:80]}")
+                return
+            chosen = pick_room(rooms)
+            filt = dict(limit=args.limit, date=args.date, date_from=args.date_from,
+                        date_to=args.date_to, time_from=args.time_from, time_to=args.time_to,
+                        sender=args.sender, keyword=args.keyword, media_dir="media")
+            if args.save:
+                out = line.save_messages(chosen, **filt)
+                print(f"บันทึก {out}")
+            print(f"กำลังเปิดห้อง {chosen.name} ...", flush=True)
+            msgs = line.get_messages(chosen, **filt)
+            if not msgs:
+                print("เปิดห้องได้แต่อ่านข้อความไม่ได้")
+                print(f"รัน uv run line-ext-msg --dump-room {chosen.index} แล้วส่ง line_room.html มา")
+                return
+            for m in msgs:
+                print(f"[{m.date} {m.ts}] {m.sender}: {_display(m)}")
+    except LineError as e:
+        print(e)
+
+
+if __name__ == "__main__":
+    main()

line_ext_msg/client.py

@@ -0,0 +1,287 @@
+"""LineClient: single facade owning the whole lifecycle.
+
+Typical use (also the shape MCP tools wrap)::
+
+    with LineClient() as line:
+        rooms = line.list_rooms(unread_only=True)
+        msgs = line.get_messages("ครอบครัว", limit=5)
+"""
+
+from dataclasses import asdict
+
+from . import auth
+from . import chrome as _chrome
+from . import messages as _messages
+from . import rooms as _rooms
+from . import session as _session
+from . import storage as _storage
+from .errors import (
+    AppNotReady,
+    AttachFailed,
+    ChromeNotReady,
+    ExtensionMissing,
+    LineError,
+    LoginRequired,
+)
+from .models import Message, Room, StepResult
+from .progress import Steps
+from .settings import Settings
+
+
+class LineClient:
+    """Owns ensure-chrome, attach, page, and readiness. Use as context manager."""
+
+    def __init__(self, settings: Settings | None = None, **overrides):
+        self.settings = settings or Settings(**overrides)
+        self._steps = Steps(5, quiet=self.settings.quiet)
+        self._pw = None
+        self._browser = None
+        self._context = None
+        self._page = None
+
+    # -- lifecycle ----------------------------------------------------
+
+    def __enter__(self) -> "LineClient":
+        return self
+
+    def __exit__(self, *exc) -> None:
+        self.close()
+
+    def close(self) -> None:
+        if self._pw is not None:
+            try:
+                self._pw.stop()
+            except Exception:
+                pass
+            self._pw = None
+            self._browser = self._context = self._page = None
+
+    # -- startup checklist (also serves MCP line_status) --------------
+
+    def status(self) -> list[StepResult]:
+        """Run the 5 readiness checks. Raises typed LineError on first failure."""
+        steps = self._steps
+        if not self.settings.quiet:
+            print("[0/5] เริ่มตรวจเงื่อนไข...", flush=True)
+        results: list[StepResult] = []
+
+        def record(name: str, passed: bool, detail: str = "", hint: str = "") -> StepResult:
+            if detail:
+                steps.detail(detail)
+            steps.check(name, passed, "" if passed else hint)
+            result = StepResult(name=name, passed=passed, detail=detail or hint)
+            results.append(result)
+            return result
+
+        try:
+            _chrome.ensure_chrome(self.settings)
+        except ChromeNotReady as e:
+            record("Chrome debug พร้อม", False, str(e))
+            steps.skip_rest("หยุดก่อน")
+            raise
+        record("Chrome debug พร้อม", True)
+
+        try:
+            self._pw, self._browser, self._context = _session.connect(self.settings)
+        except AttachFailed as e:
+            record("เกาะเบราว์เซอร์", False, str(e))
+            steps.skip_rest("หยุดก่อน")
+            raise
+        record("เกาะเบราว์เซอร์", True)
+
+        installed, detail = _session.check_installed(self._context, self.settings, self._browser)
+        if not record("Extension ติดตั้ง", installed,
+                       detail=detail, hint=f"ติดตั้งเองจาก: {self.settings.webstore_url}").passed:
+            _session.open_store_page(self._context, self.settings)
+            steps.skip_rest("รอติดตั้งก่อน")
+            raise ExtensionMissing(f"ติดตั้งเองจาก: {self.settings.webstore_url}")
+
+        self._page = _session.ensure_line_page(self._context, self.settings, self._browser)
+        state = _session.wait_ready(self._page, self.settings)
+        if not record("หน้า LINE พร้อม", state == "ready",
+                       detail=f"state={state}", hint="แอปโหลดไม่เสร็จในเวลาที่กำหนด ลองรันใหม่").passed:
+            steps.skip_rest("หยุดก่อน")
+            raise AppNotReady("แอปโหลดไม่เสร็จในเวลาที่กำหนด ลองรันใหม่")
+
+        logged_in, reason = auth.check_login(self._page, self.settings.login_poll_ms)
+        detail = "โครงหน้าเว็บไม่ตรง selector ที่รู้จัก" if reason == "unknown" and not logged_in else ""
+        if not record("ล็อกอินแล้ว", logged_in,
+                       detail=detail, hint="เปิดแท็บ LINE ล็อกอินด้วย QR/อีเมลก่อน แล้วรันใหม่").passed:
+            steps.skip_rest("รอ login ก่อน")
+            raise LoginRequired("ยังไม่ล็อกอิน LINE")
+        return results
+
+    def _ready_page(self):
+        """Page guaranteed ready; runs status() once, then reuses the session."""
+        if self._page is None:
+            self.status()
+        assert self._page is not None
+        return self._page
+
+    # -- domain API ---------------------------------------------------
+
+    def list_rooms(self, unread_only: bool = False, query: str | None = None) -> list[Room]:
+        """Rooms from the chats view, optionally filtered."""
+        rooms = _rooms.list_rooms(self._ready_page(), self.settings)
+        if unread_only:
+            rooms = [r for r in rooms if r.unread > 0]
+        if query:
+            rooms = [r for r in rooms if query in r.name]
+        return rooms
+
+    def open_room(self, ref: int | str | Room) -> Room:
+        """Open a room by index, data-mid, Room, or name substring."""
+        rooms = self.list_rooms()
+        return _rooms.open_room(self._ready_page(), ref, rooms, self.settings)
+
+    def get_messages(
+        self,
+        room: int | str | Room | None = None,
+        limit: int = 5,
+        date: str | None = None,
+        date_from: str | None = None,
+        date_to: str | None = None,
+        time_from: str | None = None,
+        time_to: str | None = None,
+        sender: str | None = None,
+        keyword: str | None = None,
+        media_dir: str | None = None,
+        include_media_data: bool = False,
+    ) -> list[Message]:
+        """Latest messages, optionally opening a room first and filtering.
+
+        Only rendered rows are visible (virtualized list); wide ranges
+        still return just what the DOM holds. media_dir=None keeps the
+        call side-effect free; set it to download image bubbles.
+        include_media_data embeds data URIs (for MCP/AI, off by default).
+        """
+        if room is not None:
+            rooms = self.list_rooms()
+            _rooms.open_room(self._ready_page(), room, rooms, self.settings)
+        return _messages.get_messages(
+            self._ready_page(), self.settings, limit=limit, date=date,
+            date_from=date_from, date_to=date_to, time_from=time_from,
+            time_to=time_to, sender=sender, keyword=keyword, media_dir=media_dir,
+            include_media_data=include_media_data,
+        )
+
+    def unread_digest(self) -> list[dict]:
+        """Rooms with unread>0 plus latest preview: answers 'what is unread' in one call."""
+        return [asdict(r) for r in self.list_rooms(unread_only=True)]
+
+    def unread_full(self, date: str | None = None, limit_per_room: int = 20) -> list[dict]:
+        """Unread rooms with their messages. date=None means today (local)."""
+        from datetime import date as _date
+        day = date or _date.today().isoformat()
+        out = []
+        for i, room in enumerate(self.list_rooms(unread_only=True)):
+            if not self.settings.quiet:
+                print(f"  ... ห้อง {i + 1}: {room.name}", flush=True)
+            rooms = self.list_rooms()
+            _rooms.open_room(self._ready_page(), room, rooms, self.settings)
+            msgs = self.get_messages(limit=limit_per_room, date=day)
+            out.append({"room": asdict(room), "messages": [asdict(m) for m in msgs]})
+        return out
+
+    def search_all(
+        self,
+        keyword: str,
+        date_from: str | None = None,
+        date_to: str | None = None,
+        rooms: list[int | str | Room] | None = None,
+        limit_per_room: int = 100,
+    ) -> list[dict]:
+        """Search keyword across rooms. Returns only rooms with matches.
+
+        Sequential (one room at a time); cost ~ seconds per room.
+        """
+        targets = self.list_rooms()
+        if rooms is not None:
+            wanted = []
+            for ref in rooms:
+                try:
+                    wanted.append(_rooms.resolve_ref(ref, targets))
+                except Exception:
+                    continue
+            targets = wanted
+        out = []
+        for i, room in enumerate(targets):
+            if not self.settings.quiet:
+                print(f"  ... ค้นห้อง {i + 1}/{len(targets)}: {room.name}", flush=True)
+            _rooms.open_room(self._ready_page(), room, self.list_rooms(), self.settings)
+            msgs = self.get_messages(
+                limit=limit_per_room, date_from=date_from, date_to=date_to, keyword=keyword,
+            )
+            if msgs:
+                out.append({"room": asdict(room), "messages": [asdict(m) for m in msgs]})
+        return out
+
+    # -- debugging helpers --------------------------------------------
+
+    def dump_page(self, path: str = "line_dom.html") -> str:
+        """Save current chats DOM for selector tuning. No login required."""
+        from . import chrome as _c
+
+        _c.ensure_chrome(self.settings)
+        if self._pw is None:
+            self._pw, self._browser, self._context = _session.connect(self.settings)
+        assert self._context is not None
+        page = _session.ensure_line_page(self._context, self.settings, self._browser)
+        state = _session.wait_ready(page, self.settings)
+        with open(path, "w", encoding="utf-8") as f:
+            f.write(page.content())
+        return state
+
+    def dump_room(self, ref: int | str | Room, path: str = "line_room.html") -> Room:
+        """Open a room then save its DOM for message-selector tuning."""
+        room = self.open_room(ref)
+        assert self._page is not None
+        with open(path, "w", encoding="utf-8") as f:
+            f.write(self._page.content())
+        return room
+
+    def save_rooms(
+        self,
+        path: str = "rooms.json",
+        unread_only: bool = False,
+        query: str | None = None,
+    ) -> str:
+        """Fetch rooms and save JSON. The only room method that writes files."""
+        rooms = self.list_rooms(unread_only=unread_only, query=query)
+        _storage.save_json(path, {"rooms": [asdict(r) for r in rooms]})
+        return path
+
+    def save_messages(
+        self,
+        ref: int | str | Room,
+        limit: int = 5,
+        date: str | None = None,
+        date_from: str | None = None,
+        date_to: str | None = None,
+        time_from: str | None = None,
+        time_to: str | None = None,
+        sender: str | None = None,
+        keyword: str | None = None,
+        media_dir: str | None = None,
+        include_media_data: bool = False,
+        path: str | None = None,
+    ) -> str:
+        """Open room, fetch messages, save JSON. The only message method that writes files."""
+        from datetime import datetime, timezone
+
+        room = self.open_room(ref)
+        msgs = self.get_messages(
+            limit=limit, date=date, date_from=date_from, date_to=date_to,
+            time_from=time_from, time_to=time_to, sender=sender, keyword=keyword,
+            media_dir=media_dir, include_media_data=include_media_data,
+        )
+        out = path or f"messages_{room.index}.json"
+        _storage.save_json(out, {
+            "room": asdict(room),
+            "fetched_at": datetime.now(timezone.utc).isoformat(),
+            "messages": [asdict(m) for m in msgs],
+        })
+        return out
+
+
+__all__ = ["LineClient", "LineError"]

line_ext_msg/errors.py

@@ -0,0 +1,34 @@
+"""Typed errors so callers (CLI, MCP) branch on kind, not message text."""
+
+
+class LineError(Exception):
+    """Base for all line-ext-msg failures."""
+
+
+class ChromeNotReady(LineError):
+    """Debug Chrome could not be started or reached."""
+
+
+class AttachFailed(LineError):
+    """CDP attach to the running Chrome failed."""
+
+
+class ExtensionMissing(LineError):
+    """LINE Extension is not installed in the debug profile."""
+
+
+class AppNotReady(LineError):
+    """LINE SPA did not finish rendering in time."""
+
+
+class LoginRequired(LineError):
+    """Login screen is showing; user must log in first."""
+
+
+class RoomNotFound(LineError):
+    """No visible room matches the given reference."""
+
+    def __init__(self, ref: object, available: list[str]):
+        self.ref = ref
+        self.available = available
+        super().__init__(f"ไม่เจอห้อง '{ref}' (มี: {', '.join(available) or '—'})")