@kuandotdev/indicator 0.1.1 → 0.1.3

package/project/src/tv_indicator/browser/automation.py

@@ -0,0 +1,541 @@
+"""High-level Playwright flows for TradingView.
+
+Public functions (used by CLI and MCP):
+    session_check()                       -> bool
+    interactive_login()                   -> bool   (visible browser, user logs in once)
+    push_script(path, apply_to, screenshot, name) -> dict
+    screenshot_chart(symbol, layout_url, out_path) -> Path
+
+All flows reuse a persistent Playwright profile dir so login state survives runs.
+"""
+from __future__ import annotations
+
+import asyncio
+import os
+import subprocess
+import sys
+import time
+from contextlib import asynccontextmanager
+from pathlib import Path
+from typing import Optional
+from urllib.parse import parse_qsl, urlencode, urlparse, urlunparse
+
+from playwright.async_api import (
+    BrowserContext,
+    Page,
+    async_playwright,
+)
+
+from ..config import settings
+from . import selectors as sel
+
+
+# ─── Context manager ────────────────────────────────────────────────────────
+
+
+def _cleanup_stale_chromium_locks(profile_dir: Path) -> list[Path]:
+    """Remove stale Chromium SingletonLock/Cookie/Socket symlinks.
+
+    Chromium leaves these when the previous process didn't shut down cleanly
+    (e.g. force-killed by `timeout`). On the next launch it refuses to open
+    the profile, complaining "already in use by another instance". The lock
+    files are symlinks pointing at <hostname>-<pid>; if no such process exists,
+    they're safe to remove.
+    """
+    removed: list[Path] = []
+    for name in ("SingletonLock", "SingletonCookie", "SingletonSocket"):
+        p = profile_dir / name
+        if not p.exists() and not p.is_symlink():
+            continue
+        try:
+            if p.is_symlink():
+                target = os.readlink(str(p))
+                # Lock targets look like 'hostname-12345' (PID = last segment)
+                pid_part = target.rsplit("-", 1)[-1]
+                pid = int(pid_part) if pid_part.isdigit() else None
+                alive = False
+                if pid:
+                    try:
+                        os.kill(pid, 0)  # signal 0 = liveness probe
+                        alive = True
+                    except (OSError, ProcessLookupError):
+                        alive = False
+                if alive:
+                    continue  # real running instance; do not touch
+            p.unlink(missing_ok=True)
+            removed.append(p)
+        except Exception:
+            pass
+    return removed
+
+
+@asynccontextmanager
+async def tv_browser(headless: Optional[bool] = None):
+    """Open a Playwright context with persistent profile + TV cookies (if any).
+
+    Usage:
+        async with tv_browser() as (ctx, page):
+            await page.goto(...)
+    """
+    headless = settings.browser_headless if headless is None else headless
+    profile_dir = settings.browser_profile
+    profile_dir.mkdir(parents=True, exist_ok=True)
+    stale = _cleanup_stale_chromium_locks(profile_dir)
+    if stale:
+        print(f"  (cleaned {len(stale)} stale Chromium lock(s) from previous run)")
+
+    async with async_playwright() as pw:
+        ctx: BrowserContext = await pw.chromium.launch_persistent_context(
+            user_data_dir=str(profile_dir),
+            headless=headless,
+            viewport={"width": 1600, "height": 1000},
+            args=["--disable-blink-features=AutomationControlled"],
+        )
+
+        # Inject session cookies from .env if present (skips real login)
+        cookies = settings.session_cookies()
+        if cookies:
+            await ctx.add_cookies(cookies)
+
+        # Reuse the default page if Chromium opened one, else open a new tab
+        page = ctx.pages[0] if ctx.pages else await ctx.new_page()
+        try:
+            yield ctx, page
+        finally:
+            await ctx.close()
+
+
+# ─── Helpers ────────────────────────────────────────────────────────────────
+
+
+async def _is_signed_in(page: Page, quick: bool = False) -> bool:
+    """Robust login probe.
+
+    Priority order (cookie check is the source of truth):
+      1. Presence of a non-empty `sessionid` cookie on tradingview.com -> True.
+      2. DOM probe: any USER_MENU_SELECTORS matches  -> True.
+      3. DOM probe: any SIGN_IN_SELECTORS matches    -> False.
+      4. Otherwise -> False.
+
+    The cookie path is the most reliable because the chart page DOM doesn't have
+    the website header, so DOM-only checks fail there even when logged in.
+    """
+    # 1. Cookie check (works on any page, doesn't need header DOM)
+    try:
+        ctx = page.context
+        cookies = await ctx.cookies("https://www.tradingview.com")
+        sessionid = next(
+            (c.get("value") for c in cookies if c.get("name") == "sessionid"),
+            None,
+        )
+        if sessionid:
+            return True
+    except Exception:
+        pass
+
+    # 2. DOM positive signal
+    for selector in sel.USER_MENU_SELECTORS:
+        try:
+            if await page.locator(selector).count() > 0:
+                return True
+        except Exception:
+            continue
+
+    if quick:
+        return False
+
+    # 3. DOM negative signal
+    for selector in sel.SIGN_IN_SELECTORS:
+        try:
+            if await page.locator(selector).count() > 0:
+                return False
+        except Exception:
+            continue
+
+    return False
+
+
+async def _open_pine_editor(page: Page) -> None:
+    """Make sure the Pine Editor side panel is open and the Monaco editor is ready."""
+    # Is it already open? Probe for the dialog container.
+    try:
+        already_open = await page.locator(sel.PINE_DIALOG).is_visible(timeout=1500)
+    except Exception:
+        already_open = False
+
+    if not already_open:
+        # Click the toolbar Pine button to open the side panel
+        await page.click(sel.PINE_DIALOG_BUTTON, timeout=10_000)
+
+    # Wait for the Monaco editor inside the panel to be ready.
+    # First load is slow (~5-8 s) because TV lazy-loads the Monaco bundle.
+    await page.wait_for_selector(sel.PINE_MONACO, timeout=25_000, state="attached")
+    # Small extra grace period for the editor's content to be settled
+    await page.wait_for_timeout(800)
+
+
+async def _replace_editor_contents(page: Page, code: str) -> None:
+    """Clear the Monaco editor and write the new code in.
+
+    Strategy (in priority order):
+      1. Use Monaco's JS API directly via `editor.setValue(text)` if we can
+         reach the editor instance. This bypasses ALL keyboard handlers
+         (including Monaco's autoIndent, which silently re-indents pasted
+         code and corrupts multi-line `if`/`for` blocks).
+      2. Fall back to clipboard paste.
+      3. Fall back to typing.
+    """
+    editor_el = page.locator(sel.PINE_MONACO).first
+    await editor_el.focus()
+
+    # Strategy 1: direct Monaco model write (no keyboard handlers run)
+    try:
+        ok = await page.evaluate(
+            """text => {
+                // Find the Pine Editor's Monaco model. TV exposes monaco-editor
+                // globally on the chart page once it's loaded.
+                if (typeof monaco === 'undefined' || !monaco.editor) return false;
+                const models = monaco.editor.getModels();
+                if (!models || models.length === 0) return false;
+                // Pick the model that looks like Pine code (largest, or any)
+                const model = models[models.length - 1];
+                model.setValue(text);
+                // Notify any listeners that the content changed (TV's save
+                // dirty-tracking watches for this).
+                if (model.pushEditOperations) {
+                    model.pushEditOperations([], [], () => null);
+                }
+                return true;
+            }""",
+            code,
+        )
+        if ok:
+            # Editor now has the new content. Click into it so the user-input
+            # focus is restored (some TV save flows need focus on the editor).
+            await editor_el.focus()
+            await page.wait_for_timeout(500)
+            return
+    except Exception:
+        pass
+
+    # Strategy 2: clipboard paste (autoIndent may corrupt blocks but it's a fallback)
+    mod = "Meta" if _is_mac() else "Control"
+    await page.keyboard.press(f"{mod}+A")
+    await page.keyboard.press("Delete")
+    pasted = False
+    try:
+        await page.evaluate("text => navigator.clipboard.writeText(text)", code)
+        await editor_el.focus()
+        await page.keyboard.press(f"{mod}+V")
+        pasted = True
+    except Exception:
+        pasted = False
+
+    # Strategy 3: type it
+    if not pasted:
+        await editor_el.type(code, delay=0)
+
+    await page.wait_for_timeout(700)
+
+
+def _is_mac() -> bool:
+    import sys
+    return sys.platform == "darwin"
+
+
+def _with_symbol_param(url: str, symbol: str) -> str:
+    """Return a TradingView chart URL with `symbol=EXCHANGE:TICKER` set.
+
+    TV accepts URLs like `/chart/?symbol=NASDAQ%3ATSLA` and `/chart/<id>/?symbol=...`.
+    Using the URL param makes standalone screenshots more deterministic than relying only
+    on the symbol-search modal, especially when a saved layout opens on an unrelated symbol.
+    """
+    parsed = urlparse(url)
+    query = dict(parse_qsl(parsed.query, keep_blank_values=True))
+    query["symbol"] = symbol
+    return urlunparse(parsed._replace(query=urlencode(query)))
+
+
+# ─── Public flows ───────────────────────────────────────────────────────────
+
+
+async def session_check_async() -> dict:
+    """Diagnose login state across both auth paths.
+
+    Two ways the toolkit can be authenticated:
+      - `via_env_cookie`:    `TV_SESSIONID` is set in .env (injected per-run)
+      - `via_browser_profile`: `sessionid` cookie present in the Playwright profile
+                               (persisted by `make login`)
+
+    Either one is enough; `signed_in` is True if any path produces a valid cookie.
+    """
+    async with tv_browser(headless=True) as (ctx, page):
+        await page.goto(sel.CHART_URL, wait_until="domcontentloaded")
+        signed_in = await _is_signed_in(page)
+
+        # Inspect actual cookies on tradingview.com to see which path is providing auth
+        try:
+            cookies = await ctx.cookies("https://www.tradingview.com")
+        except Exception:
+            cookies = []
+        profile_sessionid = next(
+            (c.get("value") for c in cookies if c.get("name") == "sessionid"),
+            None,
+        )
+
+        env_set = bool(settings.tv_sessionid)
+        profile_set = bool(profile_sessionid)
+
+        # Which path actually authenticated us?
+        if env_set and not profile_set:
+            method = "env"
+        elif profile_set and not env_set:
+            method = "browser_profile"
+        elif env_set and profile_set:
+            method = "both"
+        else:
+            method = "none"
+
+        return {
+            "signed_in": signed_in,
+            "auth_method": method,
+            "via_env_cookie": env_set,
+            "via_browser_profile": profile_set,
+            "profile_dir": str(settings.browser_profile),
+        }
+
+
+def session_check() -> dict:
+    return asyncio.run(session_check_async())
+
+
+async def interactive_login_async(timeout_seconds: int = 300) -> dict:
+    """Open a visible browser; user logs in manually. Profile is saved.
+
+    Polls every second for the logged-in signal. As soon as login is detected,
+    the browser is closed automatically (via the `tv_browser` context manager).
+    """
+    async with tv_browser(headless=False) as (_ctx, page):
+        await page.goto(sel.LOGIN_URL, wait_until="domcontentloaded")
+        # Pull the window to the front. Playwright's bring_to_front handles
+        # the tab; on macOS we additionally activate Chromium so it isn't
+        # hidden behind the terminal that launched it.
+        try:
+            await page.bring_to_front()
+        except Exception:
+            pass
+        if sys.platform == "darwin":
+            try:
+                subprocess.run(
+                    ["osascript", "-e", 'tell application "Chromium" to activate'],
+                    check=False, timeout=2, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL,
+                )
+            except Exception:
+                pass
+        print("👉  A Chromium window has opened. Log into TradingView in that window.")
+        print("    If you don't see it, look behind other apps (or use Mission Control).")
+        print("    The window closes automatically once login is detected.")
+        deadline = time.time() + timeout_seconds
+        while time.time() < deadline:
+            if await _is_signed_in(page, quick=True):
+                # Give the page a brief moment to finish writing session cookies
+                # to disk before we tear down the context.
+                print("✓ Login detected. Closing browser…")
+                await asyncio.sleep(1.5)
+                return {"signed_in": True, "message": "Login captured and persisted."}
+            await asyncio.sleep(1)
+        return {"signed_in": False, "message": "Timed out waiting for login."}
+
+
+def interactive_login(timeout_seconds: int = 300) -> dict:
+    return asyncio.run(interactive_login_async(timeout_seconds))
+
+
+async def push_script_async(
+    script_path: Path,
+    apply_to: Optional[str] = None,
+    screenshot: bool = False,
+    script_name: Optional[str] = None,
+) -> dict:
+    """Paste a .pine file into TV's Pine Editor, save it, optionally apply + screenshot."""
+    script_path = Path(script_path).resolve()
+    if not script_path.exists():
+        raise FileNotFoundError(script_path)
+    code = script_path.read_text(encoding="utf-8")
+    script_name = script_name or script_path.stem
+
+    result: dict = {
+        "script": str(script_path),
+        "name": script_name,
+        "saved": False,
+        "applied": False,
+        "screenshot": None,
+        "errors": [],
+    }
+
+    async with tv_browser() as (_ctx, page):
+        target_url = settings.default_chart_url or sel.CHART_URL
+        await page.goto(target_url, wait_until="domcontentloaded")
+
+        if not await _is_signed_in(page):
+            result["errors"].append(
+                "Not signed in. Run `training-view browser login` first or set TV_SESSIONID in .env."
+            )
+            return result
+
+        # Optionally change symbol first (so the script applies to the right chart)
+        if apply_to:
+            try:
+                await _switch_symbol(page, apply_to)
+            except Exception as e:
+                result["errors"].append(f"Symbol change failed: {e}")
+
+        await _open_pine_editor(page)
+        await _replace_editor_contents(page, code)
+
+        # Save via Cmd/Ctrl+S — TV shows a "Save as" dialog for unnamed scripts
+        mod = "Meta" if _is_mac() else "Control"
+        await page.keyboard.press(f"{mod}+S")
+        # First-save dialog handling
+        try:
+            dialog = page.locator(sel.PINE_SCRIPT_NAME_DIALOG).first
+            await dialog.wait_for(timeout=4_000)
+            await page.locator(sel.PINE_SCRIPT_NAME_INPUT).fill(script_name)
+            await page.locator(sel.PINE_DIALOG_SUBMIT).first.click()
+        except Exception:
+            pass  # already-saved scripts skip the dialog
+
+        await page.wait_for_timeout(2500)
+        result["saved"] = True
+
+        # Apply to chart
+        try:
+            await page.click(sel.PINE_ADD_TO_CHART_BUTTON, timeout=8_000)
+            await page.wait_for_timeout(2500)
+            result["applied"] = True
+        except Exception as e:
+            result["errors"].append(f"Add-to-chart failed: {e}")
+
+        # Check for Pine compile errors
+        try:
+            err = await page.query_selector(sel.PINE_ERROR_BADGE)
+            if err:
+                txt = await err.inner_text()
+                result["errors"].append(f"Pine compile error: {txt}")
+        except Exception:
+            pass
+
+        # Screenshot
+        if screenshot:
+            settings.screenshot_dir.mkdir(parents=True, exist_ok=True)
+            stamp = time.strftime("%Y%m%d-%H%M%S")
+            tag = (apply_to or "chart").replace(":", "_")
+            out = settings.screenshot_dir / f"{script_name}__{tag}__{stamp}.png"
+            await page.screenshot(path=str(out), full_page=False)
+            result["screenshot"] = str(out)
+
+    return result
+
+
+def push_script(
+    script_path: Path | str,
+    apply_to: Optional[str] = None,
+    screenshot: bool = False,
+    script_name: Optional[str] = None,
+) -> dict:
+    return asyncio.run(
+        push_script_async(Path(script_path), apply_to, screenshot, script_name)
+    )
+
+
+async def _switch_symbol(page: Page, symbol: str) -> None:
+    """Open TV's symbol-search dialog and select `symbol` robustly."""
+    exchange, _, ticker = symbol.partition(":")
+    ticker = ticker or symbol
+
+    await page.click(sel.SYMBOL_SEARCH_BUTTON, timeout=8_000)
+
+    input_loc = page.locator(sel.SYMBOL_SEARCH_INPUT).first
+    await input_loc.wait_for(timeout=5_000)
+    await input_loc.click()
+    mod = "Meta" if _is_mac() else "Control"
+    await page.keyboard.press(f"{mod}+A")
+    await input_loc.fill(symbol)
+
+    rows = page.locator(sel.SYMBOL_SEARCH_RESULT_FIRST)
+    await rows.first.wait_for(timeout=5_000)
+
+    # Prefer a row that contains both ticker and exchange. If TV changes row
+    # markup, fall back to ticker-only, then the first row.
+    clicked = False
+    for candidate in (
+        rows.filter(has_text=ticker).filter(has_text=exchange).first,
+        rows.filter(has_text=ticker).first,
+        rows.first,
+    ):
+        try:
+            if await candidate.count() > 0:
+                await candidate.click(timeout=3_000)
+                clicked = True
+                break
+        except Exception:
+            continue
+
+    if not clicked:
+        await page.keyboard.press("Enter")
+
+    # Wait for the chart to re-render and the toolbar to reflect the target.
+    await page.wait_for_timeout(2500)
+    try:
+        await page.wait_for_function(
+            "([selector, ticker]) => (document.querySelector(selector)?.innerText || '').toUpperCase().includes(ticker.toUpperCase())",
+            [sel.SYMBOL_SEARCH_BUTTON, ticker],
+            timeout=8_000,
+        )
+    except Exception:
+        current = ""
+        try:
+            current = (await page.locator(sel.SYMBOL_SEARCH_BUTTON).inner_text(timeout=1_000)).strip()
+        except Exception:
+            pass
+        raise RuntimeError(f"symbol switch did not reach {symbol!r}; toolbar shows {current!r}")
+
+
+async def screenshot_chart_async(
+    symbol: Optional[str] = None,
+    layout_url: Optional[str] = None,
+    out_path: Optional[Path] = None,
+) -> Path:
+    async with tv_browser() as (_ctx, page):
+        url = layout_url or settings.default_chart_url or sel.CHART_URL
+        if symbol:
+            url = _with_symbol_param(url, symbol)
+        await page.goto(url, wait_until="domcontentloaded")
+        # Give the chart UI a moment to settle before interacting with the toolbar
+        await page.wait_for_timeout(4000)
+        if symbol:
+            try:
+                # The URL param usually switches the symbol. If a saved layout ignores it,
+                # force the switch via the toolbar and fail loudly if verification fails.
+                ticker = symbol.partition(":")[2] or symbol
+                toolbar = (await page.locator(sel.SYMBOL_SEARCH_BUTTON).inner_text(timeout=2_000)).upper()
+                if ticker.upper() not in toolbar:
+                    await _switch_symbol(page, symbol)
+            except Exception as e:
+                raise RuntimeError(f"symbol switch failed for {symbol!r}: {e}") from e
+
+        settings.screenshot_dir.mkdir(parents=True, exist_ok=True)
+        if out_path is None:
+            stamp = time.strftime("%Y%m%d-%H%M%S")
+            tag = (symbol or "chart").replace(":", "_")
+            out_path = settings.screenshot_dir / f"{tag}__{stamp}.png"
+        await page.screenshot(path=str(out_path), full_page=False)
+        return Path(out_path)
+
+
+def screenshot_chart(
+    symbol: Optional[str] = None,
+    layout_url: Optional[str] = None,
+    out_path: Optional[Path] = None,
+) -> Path:
+    return asyncio.run(screenshot_chart_async(symbol, layout_url, out_path))

package/project/src/tv_indicator/browser/selectors.py

@@ -0,0 +1,70 @@
+"""All TradingView DOM selectors in one place.
+
+TV's DOM changes occasionally. When automation breaks, fix selectors here only.
+Prefer role-based / text-based / data-name locators (resilient) over CSS class
+names (brittle — TV uses hashed class names like `button-abc123`).
+
+Last refreshed: May 2026.
+"""
+
+# ─── URLs ────────────────────────────────────────────────────────────────
+CHART_URL = "https://www.tradingview.com/chart/"
+LOGIN_URL = "https://www.tradingview.com/accounts/signin/"
+
+# ─── Login / auth state ──────────────────────────────────────────────────
+USER_MENU_SELECTORS = [
+    'button[aria-label="Open user menu"]',
+    'button[aria-label*="user menu" i]',
+    '[data-name="header-user-menu-button"]',   # legacy fallback
+]
+SIGN_IN_SELECTORS = [
+    'button[data-name="header-user-menu-sign-in"]',
+    'a[href*="/accounts/signin"]',
+    '[data-name="header-toolbar-sign-in"]',
+]
+SIGN_IN_BUTTON_TEXT = "Sign in"
+USER_MENU = USER_MENU_SELECTORS[0]  # back-compat alias
+
+# ─── Symbol search (top-left ticker) ─────────────────────────────────────
+# Click this to open the symbol-search dialog
+SYMBOL_SEARCH_BUTTON = "#header-toolbar-symbol-search"
+# The input that receives keystrokes inside the open dialog
+SYMBOL_SEARCH_INPUT = '[role="dialog"] input'
+# Each result row in the symbol-search results list
+SYMBOL_SEARCH_RESULT_FIRST = '[data-role="list-item"]'
+
+# ─── Pine Editor (slide-in panel from the right) ─────────────────────────
+# Click this to open / close the Pine Editor panel
+PINE_DIALOG_BUTTON = '[data-name="pine-dialog-button"]'
+# The container that wraps the whole Pine Editor panel (visible when open)
+PINE_DIALOG = '[data-name="pine-dialog"]'
+# Monaco-based code editor (inside PINE_DIALOG)
+PINE_MONACO = '[data-name="pine-dialog"] .monaco-editor textarea.inputarea'
+# Scoped buttons inside the Pine panel
+PINE_SAVE_BUTTON = '[data-name="pine-dialog"] button:has-text("Save")'
+PINE_ADD_TO_CHART_BUTTON = '[data-name="pine-dialog"] button:has-text("Add to chart")'
+PINE_PUBLISH_BUTTON = '[data-name="pine-dialog"] button:has-text("Publish script")'
+# Script title element (shows "Untitled script" / your script's name)
+PINE_TITLE = '[data-name="pine-dialog"] [class*="titleSlot"]'
+
+# Save-as / script-name dialog (appears on first save of an unnamed script)
+PINE_SCRIPT_NAME_DIALOG = '[role="dialog"]:has-text("Save as")'
+PINE_SCRIPT_NAME_INPUT = '[role="dialog"] input[type="text"]'
+PINE_DIALOG_SUBMIT = '[role="dialog"] button:has-text("Save")'
+
+# ─── Chart canvas / area (for screenshots) ───────────────────────────────
+CHART_CANVAS = ".chart-markup-table"
+CHART_CONTAINER = ".chart-container"
+
+# ─── Status indicators ───────────────────────────────────────────────────
+# Pine compilation status: badge / toast that appears on error
+PINE_ERROR_BADGE = '[data-name="pane-status-error"]'
+TOAST_NOTIFICATION = '[data-name="toast-container"]'
+
+# ─── Legacy selectors (kept for reference, no longer used) ───────────────
+# These were valid in earlier TV builds:
+#   - [data-name="legend-source-title"] (was the symbol search button)
+#   - [data-role="search"] input        (was the search input)
+#   - button:has-text("Pine Editor")    (was the editor tab)
+#   - button[data-name="save"]          (was the save button)
+#   - button[data-name="add-script-to-chart"] (was the add-to-chart button)