cdpilot 0.2.1 → 0.4.0

package/README.md

@@ -301,6 +301,10 @@ The only browser MCP with built-in test assertions. Here's what we've shipped an
 - [x] Pre-flight wizard (auto-installs dependencies on first run)
 - [x] Persistent MCP glow (stays on during entire AI session, like Claude's orange glow)
 - [x] DevExtension system (native JS injection without browser store)
+- [x] **Smart commands** — `smart-click`, `smart-fill`, `smart-select` — interact by visible text, no CSS selectors needed, no LLM required
+- [x] **Data extraction** (`extract`) — structured DOM data in text, JSON, or list format
+- [x] **Page observation** (`observe`) — list all interactive elements with available actions
+- [x] **Script runner** (`run`) — execute `.cdp` script files with pass/fail reporting
 
 ### Coming Soon
 

package/bin/cdpilot.js

@@ -324,6 +324,11 @@ function showHelp() {
     new-tab [url]      Open new tab
     close-tab [id]     Close tab
 
+  STEALTH & CAPTCHA
+    stealth [on|off]   Toggle anti-fingerprint patches (opt-in)
+    captcha-check      Detect CAPTCHA on active page (JSON output)
+    captcha-wait [s]   Pause until user solves CAPTCHA (default 300s)
+
   PROJECTS
     projects           List all project browser instances
     project-stop <id>  Stop a specific project's browser

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cdpilot",
-  "version": "0.2.1",
+  "version": "0.4.0",
   "description": "Zero-dependency browser automation from your terminal. One command, full control.",
   "bin": {
     "cdpilot": "./bin/cdpilot.js",

package/src/cdpilot.py

@@ -14,7 +14,7 @@ Environment:
   CDPILOT_PROFILE      Isolated browser profile directory
 """
 
-__version__ = "0.1.2"
+__version__ = "0.4.0"
 
 import asyncio
 import json
@@ -221,8 +221,250 @@ window.__cdpilot_waitFor = function(selector, timeout) {
   });
 };
 """
+# ─── Stealth & CAPTCHA Detection ──────────────────────────────────────────────
+# Zero-dependency anti-fingerprinting layer. Patches common automation tells
+# (navigator.webdriver, missing chrome.runtime, plugin list, WebGL vendor).
+# Runs via Page.addScriptToEvaluateOnNewDocument BEFORE any page script.
+# Notes:
+#   - Does NOT weaken web security (CSP, CORS, SOP intact).
+#   - Idempotent: guarded by window.__cdpilot_stealth flag.
+#   - Fails silently per-patch; one failure cannot break the page.
+#   - Opt-in via `cdpilot stealth on`. Default OFF for backward compatibility.
+STEALTH_JS = r"""
+(function() {
+  'use strict';
+  if (window.__cdpilot_stealth) return;
+  try { Object.defineProperty(window, '__cdpilot_stealth', {value: true, writable: false, configurable: false}); } catch(e) {}
+
+  // 1) navigator.webdriver — only patch if it's actually `true`.
+  // Vanilla Chrome (no --enable-automation) already returns `false` and the
+  // property exists on Navigator.prototype. Replacing the getter when it's
+  // already safe creates a worse fingerprint (returning `undefined` instead
+  // of `false` is itself a tell). Only mask when CDP/automation flagged it.
+  try {
+    var wdValue;
+    try { wdValue = navigator.webdriver; } catch (_) {}
+    if (wdValue === true) {
+      Object.defineProperty(Navigator.prototype, 'webdriver', {
+        get: function() { return false; },
+        configurable: true
+      });
+    }
+  } catch (e) {}
+
+  // 2) window.chrome — real Chrome exposes chrome.runtime even without extensions
+  try {
+    if (!window.chrome) {
+      window.chrome = {};
+    }
+    if (!window.chrome.runtime) {
+      window.chrome.runtime = {
+        OnInstalledReason: {}, OnRestartRequiredReason: {}, PlatformArch: {},
+        PlatformNackArch: {}, PlatformOs: {}, RequestUpdateCheckStatus: {}
+      };
+    }
+    if (typeof window.chrome.app === 'undefined') {
+      window.chrome.app = { isInstalled: false, InstallState: {}, RunningState: {} };
+    }
+  } catch (e) {}
+
+  // 3) Permissions.query — reconcile with Notification.permission (classic tell)
+  try {
+    if (navigator.permissions && navigator.permissions.query) {
+      var origQuery = navigator.permissions.query.bind(navigator.permissions);
+      navigator.permissions.query = function(p) {
+        if (p && p.name === 'notifications') {
+          return Promise.resolve({ state: Notification.permission, onchange: null });
+        }
+        return origQuery(p);
+      };
+    }
+  } catch (e) {}
+
+  // 4) navigator.plugins — empty array is a headless tell. Provide standard PDF set.
+  // Critical: must be a real PluginArray instance, not vanilla Array, or
+  // detection scripts catch it via `navigator.plugins instanceof PluginArray`.
+  try {
+    var PluginArrayProto = (window.PluginArray && window.PluginArray.prototype) || null;
+    var PluginProto = (window.Plugin && window.Plugin.prototype) || null;
+    var MimeTypeProto = (window.MimeType && window.MimeType.prototype) || null;
+
+    var makeMime = function(type, suffixes, plugin) {
+      var m = Object.create(MimeTypeProto || Object.prototype);
+      Object.defineProperties(m, {
+        type:        { value: type,        enumerable: true },
+        suffixes:    { value: suffixes,    enumerable: true },
+        description: { value: '',          enumerable: true },
+        enabledPlugin: { value: plugin,    enumerable: true }
+      });
+      return m;
+    };
+    var makePlugin = function(name, filename) {
+      var p = Object.create(PluginProto || Object.prototype);
+      var mime = makeMime('application/pdf', 'pdf', p);
+      Object.defineProperties(p, {
+        name:        { value: name,        enumerable: true },
+        filename:    { value: filename,    enumerable: true },
+        description: { value: 'Portable Document Format', enumerable: true },
+        length:      { value: 1,           enumerable: true },
+        '0':         { value: mime,        enumerable: true }
+      });
+      p.item = function(i) { return i === 0 ? mime : null; };
+      p.namedItem = function(n) { return n === mime.type ? mime : null; };
+      return p;
+    };
+    var pluginNames = [
+      ['PDF Viewer', 'internal-pdf-viewer'],
+      ['Chrome PDF Viewer', 'internal-pdf-viewer'],
+      ['Chromium PDF Viewer', 'internal-pdf-viewer'],
+      ['Microsoft Edge PDF Viewer', 'internal-pdf-viewer'],
+      ['WebKit built-in PDF', 'internal-pdf-viewer'],
+    ];
+    var plugins = Object.create(PluginArrayProto || Array.prototype);
+    for (var i = 0; i < pluginNames.length; i++) {
+      var p = makePlugin(pluginNames[i][0], pluginNames[i][1]);
+      Object.defineProperty(plugins, i, { value: p, enumerable: true });
+      Object.defineProperty(plugins, p.name, { value: p });
+    }
+    Object.defineProperty(plugins, 'length', { value: pluginNames.length });
+    plugins.item = function(i) { return plugins[i] || null; };
+    plugins.namedItem = function(n) {
+      for (var k = 0; k < plugins.length; k++) if (plugins[k].name === n) return plugins[k];
+      return null;
+    };
+    plugins.refresh = function() {};
+    Object.defineProperty(Navigator.prototype, 'plugins', {
+      get: function() { return plugins; },
+      configurable: true
+    });
+  } catch (e) {}
+
+  // 4b) Worker stealth — workers have their own global scope, so navigator.webdriver
+  // patches above do NOT propagate. Fingerprint scripts that probe via Worker
+  // (e.g. fpscanner.WEBDRIVER) catch this inconsistency. Fix: wrap the Worker
+  // constructor to prepend a navigator.webdriver patch via blob URL. Limitations:
+  // module workers and same-origin script URLs are best-effort (importScripts
+  // doesn't support module workers; cross-origin URLs may bypass via direct fetch).
+  try {
+    var OrigWorker = window.Worker;
+    if (OrigWorker && !window.__cdpilot_worker_patched) {
+      var workerPatch = "(function(){try{Object.defineProperty(self.navigator||{},'webdriver',{get:function(){return undefined;},configurable:true});}catch(e){}})();";
+      var WrappedWorker = function(scriptURL, options) {
+        try {
+          var isModule = options && options.type === 'module';
+          if (typeof scriptURL === 'string' && !isModule) {
+            // Wrap script in a blob that applies the patch then importScripts the original.
+            var wrapped = workerPatch + "importScripts(" + JSON.stringify(String(scriptURL)) + ");";
+            var blob = new Blob([wrapped], { type: 'application/javascript' });
+            scriptURL = URL.createObjectURL(blob);
+          }
+        } catch (e) {}
+        return new OrigWorker(scriptURL, options);
+      };
+      WrappedWorker.prototype = OrigWorker.prototype;
+      Object.setPrototypeOf(WrappedWorker, OrigWorker);
+      window.Worker = WrappedWorker;
+      Object.defineProperty(window, '__cdpilot_worker_patched', { value: true });
+    }
+  } catch (e) {}
+
+  // 5) WebGL vendor/renderer — UNMASKED_* params reveal "SwiftShader" in headless.
+  // Override returns generic Intel values. Read-only spoof; does not affect rendering.
+  try {
+    var spoofParam = function(orig, parameter) {
+      if (parameter === 37445) return 'Intel Inc.';                       // UNMASKED_VENDOR_WEBGL
+      if (parameter === 37446) return 'Intel Iris OpenGL Engine';         // UNMASKED_RENDERER_WEBGL
+      return orig.call(this, parameter);
+    };
+    if (window.WebGLRenderingContext) {
+      var gp1 = WebGLRenderingContext.prototype.getParameter;
+      WebGLRenderingContext.prototype.getParameter = function(p) { return spoofParam.call(this, gp1, p); };
+    }
+    if (window.WebGL2RenderingContext) {
+      var gp2 = WebGL2RenderingContext.prototype.getParameter;
+      WebGL2RenderingContext.prototype.getParameter = function(p) { return spoofParam.call(this, gp2, p); };
+    }
+  } catch (e) {}
+
+  // 6) navigator.hardwareConcurrency — 0 is a tell. Clamp to a sane default if missing.
+  try {
+    if (!navigator.hardwareConcurrency || navigator.hardwareConcurrency < 2) {
+      Object.defineProperty(Navigator.prototype, 'hardwareConcurrency', {
+        get: function() { return 8; },
+        configurable: true
+      });
+    }
+  } catch (e) {}
+})();
+"""
+
+# ─── CAPTCHA Detection ────────────────────────────────────────────────────────
+# Read-only DOM probe. Detects common CAPTCHA/challenge providers post-navigation.
+# Returns JSON string: {"detected": bool, "types": [...], "details": [...]}
+# Pure detection — no DOM mutation, no network, no user data leak.
+CAPTCHA_DETECT_JS = r"""
+(function() {
+  try {
+    var result = { detected: false, types: [], details: [] };
+    var add = function(type, provider, extra) {
+      result.detected = true;
+      if (result.types.indexOf(type) < 0) result.types.push(type);
+      var d = { type: type, provider: provider };
+      if (extra) for (var k in extra) d[k] = extra[k];
+      result.details.push(d);
+    };
+
+    // Cloudflare Turnstile
+    var ts = document.querySelectorAll('iframe[src*="challenges.cloudflare.com"]');
+    if (ts.length > 0) add('turnstile', 'Cloudflare', { count: ts.length });
+
+    // Cloudflare interstitial / managed challenge
+    var cfChallenge = document.querySelector('#challenge-form, #challenge-stage, #cf-challenge-running, #cf-please-wait');
+    var titleLower = (document.title || '').toLowerCase();
+    if (cfChallenge || titleLower.indexOf('just a moment') >= 0 || titleLower.indexOf('attention required') >= 0) {
+      add('cloudflare-challenge', 'Cloudflare');
+    }
+
+    // hCaptcha
+    var hc = document.querySelectorAll('iframe[src*="hcaptcha.com"]');
+    var hcDiv = document.querySelector('.h-captcha, [data-hcaptcha-sitekey]');
+    if (hc.length > 0 || hcDiv) add('hcaptcha', 'hCaptcha');
+
+    // reCAPTCHA (v2 visible, v2 invisible, v3, enterprise)
+    var rc = document.querySelectorAll('iframe[src*="recaptcha/api2"], iframe[src*="recaptcha/enterprise"]');
+    var rcDiv = document.querySelector('.g-recaptcha');
+    if (rc.length > 0 || (rcDiv && !hcDiv)) add('recaptcha', 'Google');
+
+    // DataDome
+    if (document.querySelector('#datadome-captcha, iframe[src*="captcha-delivery.com"]')) {
+      add('datadome', 'DataDome');
+    }
+
+    // PerimeterX / HUMAN
+    if (document.querySelector('#px-captcha, [class*="px-captcha"]')) {
+      add('perimeterx', 'HUMAN');
+    }
+
+    // Arkose Labs (FunCaptcha)
+    if (document.querySelector('iframe[src*="arkoselabs.com"], iframe[src*="funcaptcha.com"], #FunCaptcha')) {
+      add('arkose', 'Arkose Labs');
+    }
+
+    // GeeTest
+    if (document.querySelector('.geetest_holder, .geetest_panel, [id^="geetest_"]')) {
+      add('geetest', 'GeeTest');
+    }
+
+    return JSON.stringify(result);
+  } catch (e) {
+    return JSON.stringify({ detected: false, error: String(e) });
+  }
+})()
+"""
+
 PROXY_CONFIG_FILE = os.path.join(PROFILE_DIR, 'proxy.json')
 HEADLESS_CONFIG_FILE = os.path.join(PROFILE_DIR, 'headless.json')
+STEALTH_CONFIG_FILE = os.path.join(PROFILE_DIR, 'stealth.json')
 DOWNLOAD_CONFIG_FILE = os.path.join(PROFILE_DIR, 'download-config.json')
 SESSION_FILE = os.path.join(PROFILE_DIR, 'sessions.json')
 
@@ -542,11 +784,21 @@ window.__cdpilot_glow_timeout = setTimeout(function() {
 _glow_script_id = None  # addScriptToEvaluateOnNewDocument identifier
 
 async def _control_start(ws_url):
-    """Enable glow, input blocker, and visual feedback at command start."""
+    """Enable glow, input blocker, visual feedback, and (if enabled) stealth.
+
+    Stealth JS is registered via addScriptToEvaluateOnNewDocument so it runs
+    BEFORE any page script on the next navigation. It cannot un-fingerprint
+    the currently-loaded document — that's by design.
+    """
     global _glow_script_id
     try:
-        # Remove previous persistent script if exists (prevent accumulation)
-        cmds = []
+        # NOTE: addScriptToEvaluateOnNewDocument registered here is session-bound
+        # to the WS connection cdp_send opens — it dies when this call returns.
+        # That's fine for GLOW (also injected via Runtime.evaluate below) but
+        # NOT for stealth, which must run BEFORE page scripts. Stealth is
+        # therefore registered inside navigate_collect on the same WS as
+        # Page.navigate, so it survives long enough to apply.
+        cmds = [(898, "Page.enable", {})]
         if _glow_script_id:
             cmds.append((900, "Page.removeScriptToEvaluateOnNewDocument", {"identifier": _glow_script_id}))
             _glow_script_id = None
@@ -853,6 +1105,18 @@ async def navigate_collect(ws_url, url, network=False, console=False, glow=True)
             await ws.send(json.dumps({"id": sid, "method": f"{domain}.enable", "params": {}}))
             sid += 1
 
+        # Register stealth script BEFORE navigate, on this same WS session.
+        # addScriptToEvaluateOnNewDocument is session-bound: it persists only
+        # as long as this connection lives — which is exactly the window we
+        # need (until Page.loadEventFired below). Stealth must run before
+        # any page script inspects navigator; addScript guarantees that.
+        stealth_active = get_stealth_config()
+        if stealth_active:
+            await ws.send(json.dumps({
+                "id": 50, "method": "Page.addScriptToEvaluateOnNewDocument",
+                "params": {"source": STEALTH_JS}
+            }))
+
         # Navigate
         await ws.send(json.dumps({"id": 100, "method": "Page.navigate", "params": {"url": url}}))
 
@@ -1187,6 +1451,25 @@ def get_headless_config():
             pass
     return False
 
+
+def get_stealth_config():
+    """Return whether stealth fingerprint patches are enabled.
+
+    Default: False (opt-in) — preserves existing behavior, lets users enable
+    only when needed. Some sites detect inconsistent fingerprints and
+    block stealth-mode harder than they would block plain Chrome.
+    """
+    env = os.environ.get('CDPILOT_STEALTH', '')
+    if env:
+        return env.lower() in ('1', 'true', 'yes', 'on')
+    if os.path.exists(STEALTH_CONFIG_FILE):
+        try:
+            with open(STEALTH_CONFIG_FILE) as f:
+                return bool(json.load(f).get('stealth', False))
+        except (OSError, ValueError):
+            pass
+    return False
+
 # ─── Commands ───
 
 def cmd_launch():
@@ -1315,6 +1598,15 @@ async def cmd_go(url):
     ws, page = get_page_ws()
     content, _ = await navigate_collect(ws, url)
     print(content)
+    # Post-navigation CAPTCHA probe. Non-blocking: stderr warning only.
+    # Users can run `cdpilot captcha-wait` to pause for manual solve.
+    try:
+        info = await _detect_captcha(ws)
+        if info.get("detected"):
+            types = ",".join(info.get("types", [])) or "unknown"
+            sys.stderr.write(f"⚠️  CAPTCHA tespit edildi ({types}). Çözüm için: cdpilot captcha-wait\n")
+    except Exception:
+        pass
 
 
 async def cmd_content():
@@ -2297,6 +2589,135 @@ def cmd_headless(state=None):
     print('Restart browser (stop → launch).')
 
 
+def cmd_stealth(state=None):
+    """Toggle stealth fingerprint patches.
+
+    Usage:
+      cdpilot stealth            # show status
+      cdpilot stealth on|off     # toggle
+      cdpilot stealth status     # show status (alias)
+
+    Patches navigator.webdriver, chrome.runtime, plugins, WebGL vendor and
+    permissions API to defeat the most common automation tells. Effect
+    applies on the NEXT navigation (current pages keep their fingerprint).
+    Zero new dependencies. Disabled by default.
+    """
+    if state is None or state.lower() == 'status':
+        current = get_stealth_config()
+        print(f'Stealth: {"on" if current else "off"}')
+        if current:
+            print('  Patches: navigator.webdriver, chrome.runtime, plugins, WebGL vendor, permissions, hardwareConcurrency')
+        return
+
+    s = state.lower()
+    if s not in ('on', 'off', '1', '0', 'true', 'false', 'yes', 'no'):
+        print(f"Invalid state: {state}. Use 'on', 'off', or 'status'.", file=sys.stderr)
+        sys.exit(1)
+    enabled = s in ('on', '1', 'true', 'yes')
+    os.makedirs(os.path.dirname(STEALTH_CONFIG_FILE), exist_ok=True)
+    with open(STEALTH_CONFIG_FILE, 'w') as f:
+        json.dump({'stealth': enabled}, f)
+    print(f'Stealth: {"on" if enabled else "off"}')
+    print('Effect applies on next navigation (`cdpilot go <url>`).')
+
+
+async def _detect_captcha(ws_url):
+    """Run CAPTCHA_DETECT_JS in the active page, return parsed dict.
+
+    Returns: {"detected": bool, "types": [...], "details": [...], "error"?: str}
+    Never raises — failures return {"detected": False, "error": "..."}.
+    """
+    try:
+        r = await cdp_send(ws_url, [(1, "Runtime.evaluate", {
+            "expression": CAPTCHA_DETECT_JS,
+            "returnByValue": True,
+        })], timeout=5)
+        raw = r.get(1, {}).get("result", {}).get("value")
+        if not raw:
+            return {"detected": False}
+        try:
+            return json.loads(raw)
+        except (ValueError, TypeError):
+            return {"detected": False, "error": "parse_failed"}
+    except Exception as e:
+        return {"detected": False, "error": str(e)[:120]}
+
+
+async def cmd_captcha_check():
+    """One-shot CAPTCHA detection on the active page. Prints JSON.
+
+    Exit codes: 0 = no CAPTCHA, 3 = CAPTCHA detected, 1 = error.
+    Useful in scripts: `cdpilot captcha-check && do-stuff`.
+    """
+    ws, _ = get_page_ws()
+    info = await _detect_captcha(ws)
+    print(json.dumps(info, ensure_ascii=False))
+    if info.get("error") and not info.get("detected"):
+        sys.exit(1)
+    sys.exit(3 if info.get("detected") else 0)
+
+
+async def cmd_captcha_wait(timeout_arg=None):
+    """Detect CAPTCHA and wait for the user to solve it.
+
+    Behavior:
+      - Interactive (stdin is a TTY): print warning, block on Enter.
+      - Non-interactive (pipe / MCP): poll every 2s until the CAPTCHA
+        disappears or timeout expires; emit one JSON line per poll on
+        state change so callers can stream progress.
+
+    Args:
+      timeout_arg: int seconds (default 300, max 1800). Passed as string from CLI.
+
+    Exit codes: 0 = solved (or none detected), 2 = timeout, 1 = error.
+    """
+    try:
+        timeout = int(timeout_arg) if timeout_arg else 300
+    except (ValueError, TypeError):
+        print(f"Invalid timeout: {timeout_arg}", file=sys.stderr)
+        sys.exit(1)
+    timeout = max(5, min(timeout, 1800))
+
+    ws, _ = get_page_ws()
+    info = await _detect_captcha(ws)
+    if not info.get("detected"):
+        print(json.dumps({"detected": False, "status": "none"}, ensure_ascii=False))
+        return
+
+    types = ",".join(info.get("types", [])) or "unknown"
+    interactive = sys.stdin.isatty() and not IS_MCP_SESSION
+
+    if interactive:
+        sys.stderr.write(f"\n⚠️  CAPTCHA tespit edildi: {types}\n")
+        sys.stderr.write("    Tarayıcıda çözün, ardından Enter'a basın (Ctrl+C iptal)...\n")
+        sys.stderr.flush()
+        try:
+            input()
+        except (EOFError, KeyboardInterrupt):
+            print(json.dumps({"detected": True, "status": "cancelled", "types": info.get("types", [])}, ensure_ascii=False))
+            sys.exit(1)
+        # Verify it's gone
+        post = await _detect_captcha(ws)
+        if post.get("detected"):
+            print(json.dumps({"detected": True, "status": "still_present", "types": post.get("types", [])}, ensure_ascii=False))
+            sys.exit(2)
+        print(json.dumps({"detected": False, "status": "solved"}, ensure_ascii=False))
+        return
+
+    # Non-interactive: poll until solved or timeout
+    print(json.dumps({"detected": True, "status": "waiting", "types": info.get("types", []), "timeout": timeout}, ensure_ascii=False), flush=True)
+    deadline = time.time() + timeout
+    poll_interval = 2.0
+    while time.time() < deadline:
+        await asyncio.sleep(poll_interval)
+        post = await _detect_captcha(ws)
+        if not post.get("detected"):
+            print(json.dumps({"detected": False, "status": "solved", "elapsed": round(timeout - (deadline - time.time()), 1)}, ensure_ascii=False), flush=True)
+            return
+    print(json.dumps({"detected": True, "status": "timeout", "types": info.get("types", []), "waited": timeout}, ensure_ascii=False), flush=True)
+    sys.exit(2)
+
+
 def _stop_browser_on_port(port):
     """Stop the browser process listening on the given port."""
     import signal
@@ -2828,6 +3249,509 @@ async def cmd_describe():
     print(page_text[:2000])
 
 
+# ─── Data Extraction & Observation Commands ───
+
+async def cmd_extract(selector, output_format="text"):
+    """Extract structured data from elements matching selector.
+
+    Returns text content, attributes, or full JSON structure.
+    No LLM required — pure DOM extraction.
+
+    Usage:
+        cdpilot extract "table tr"              → text rows
+        cdpilot extract ".product" --json        → full JSON (tag, text, attrs, children)
+        cdpilot extract "a" --attrs=href,title   → specific attributes
+        cdpilot extract "ul li" --list           → clean list output
+    """
+    ws_url, _ = get_page_ws()
+    safe_sel = json.dumps(selector)
+
+    if output_format == "json":
+        js = f"""
+        (function() {{
+          var els = document.querySelectorAll({safe_sel});
+          if (!els.length) return JSON.stringify([]);
+          return JSON.stringify(Array.from(els).slice(0, 100).map(function(el) {{
+            var attrs = {{}};
+            for (var i = 0; i < el.attributes.length; i++) {{
+              attrs[el.attributes[i].name] = el.attributes[i].value;
+            }}
+            return {{
+              tag: el.tagName.toLowerCase(),
+              text: (el.textContent || '').trim().substring(0, 500),
+              attrs: attrs,
+              value: el.value || null,
+              href: el.href || null,
+              src: el.src || null
+            }};
+          }}));
+        }})()
+        """
+    elif output_format.startswith("attrs="):
+        attr_names = output_format.split("=", 1)[1].split(",")
+        attrs_js = ",".join(f'"{a}": el.getAttribute("{a}")' for a in attr_names)
+        js = f"""
+        (function() {{
+          var els = document.querySelectorAll({safe_sel});
+          if (!els.length) return JSON.stringify([]);
+          return JSON.stringify(Array.from(els).slice(0, 100).map(function(el) {{
+            return {{ {attrs_js} }};
+          }}));
+        }})()
+        """
+    elif output_format == "list":
+        js = f"""
+        (function() {{
+          var els = document.querySelectorAll({safe_sel});
+          if (!els.length) return '';
+          return Array.from(els).slice(0, 200).map(function(el, i) {{
+            return (i + 1) + '. ' + (el.textContent || '').trim().substring(0, 200);
+          }}).join('\\n');
+        }})()
+        """
+    else:
+        # Default: text content, one per line
+        js = f"""
+        (function() {{
+          var els = document.querySelectorAll({safe_sel});
+          if (!els.length) return '';
+          return Array.from(els).slice(0, 200).map(function(el) {{
+            return (el.textContent || '').trim().substring(0, 300);
+          }}).filter(function(t) {{ return t; }}).join('\\n');
+        }})()
+        """
+
+    r = await cdp_send(ws_url, [(1, "Runtime.evaluate", {"expression": js, "returnByValue": True})])
+    result = r.get(1, {}).get("result", {}).get("value", "")
+    if not result:
+        print(f"No elements found: {selector}", file=sys.stderr)
+        return
+    if output_format in ("json",) or output_format.startswith("attrs="):
+        # Pretty print JSON
+        try:
+            parsed = json.loads(result)
+            print(json.dumps(parsed, indent=2, ensure_ascii=False))
+        except (json.JSONDecodeError, TypeError):
+            print(result)
+    else:
+        print(result)
+
+
+async def cmd_observe():
+    """List all interactive elements on the page with actions.
+
+    Like Stagehand's observe() but deterministic — no LLM needed.
+    Shows what you CAN DO on the current page.
+    """
+    ws_url, _ = get_page_ws()
+    js = """
+    (function() {
+      var results = [];
+      var els = document.querySelectorAll(
+        'a, button, input, textarea, select, [role=button], [role=link], ' +
+        '[role=tab], [role=menuitem], [role=checkbox], [role=radio], ' +
+        '[onclick], [tabindex]:not([tabindex="-1"])'
+      );
+      var seen = new Set();
+      Array.from(els).forEach(function(el, i) {
+        if (i >= 50) return;
+        var rect = el.getBoundingClientRect();
+        if (rect.width === 0 && rect.height === 0) return;
+        var style = window.getComputedStyle(el);
+        if (style.display === 'none' || style.visibility === 'hidden') return;
+
+        var tag = el.tagName.toLowerCase();
+        var type = el.type || '';
+        var role = el.getAttribute('role') || '';
+        var text = (el.textContent || el.value || el.placeholder || '').trim().substring(0, 60);
+        var href = el.href || '';
+        var name = el.name || el.id || '';
+
+        // Determine action
+        var action = 'click';
+        if (tag === 'input' || tag === 'textarea') {
+          if (type === 'checkbox' || type === 'radio') action = 'toggle';
+          else if (type === 'submit') action = 'submit';
+          else if (type === 'file') action = 'upload';
+          else action = 'fill';
+        } else if (tag === 'select') {
+          action = 'select';
+        } else if (tag === 'a') {
+          action = 'navigate';
+        }
+
+        // Build selector
+        var sel = '';
+        if (el.id) sel = '#' + el.id;
+        else if (name) sel = tag + '[name=' + JSON.stringify(name) + ']';
+        else if (type) sel = tag + '[type=' + type + ']';
+        else sel = tag;
+
+        var key = action + ':' + sel + ':' + text;
+        if (seen.has(key)) return;
+        seen.add(key);
+
+        var line = action.toUpperCase() + '  ' + sel;
+        if (text) line += '  "' + text + '"';
+        if (href && action === 'navigate') line += '  → ' + href.substring(0, 80);
+        results.push(line);
+      });
+      return results.join('\\n') || 'No interactive elements found';
+    })()
+    """
+    r = await cdp_send(ws_url, [(1, "Runtime.evaluate", {"expression": js, "returnByValue": True})])
+    result = r.get(1, {}).get("result", {}).get("value", "No interactive elements found")
+    print(f"=== What you can do on this page ===\n")
+    print(result)
+
+
+# ─── Smart Commands (LLM-free intelligence) ───
+
+async def cmd_smart_click(text):
+    """Click element by visible text — fuzzy matching, no CSS selector needed.
+
+    Like Stagehand's act("Click login") but without LLM.
+    Searches: button text, link text, aria-label, placeholder, title, value.
+
+    Usage:
+        cdpilot smart-click "Login"
+        cdpilot smart-click "Submit Order"
+        cdpilot smart-click "Learn more"
+    """
+    ws_url, _ = get_page_ws()
+    safe_text = json.dumps(text.lower())
+    js = f"""
+    (function() {{
+      var search = {safe_text};
+      var candidates = [];
+
+      // Score: exact > startsWith > includes > partial
+      function score(str) {{
+        if (!str) return 0;
+        var s = str.toLowerCase().trim();
+        if (s === search) return 100;
+        if (s.startsWith(search)) return 80;
+        if (s.includes(search)) return 60;
+        // Partial word match
+        var words = search.split(/\\s+/);
+        var matched = words.filter(function(w) {{ return s.includes(w); }}).length;
+        if (matched > 0) return 20 + (matched / words.length) * 30;
+        return 0;
+      }}
+
+      var els = document.querySelectorAll(
+        'a, button, input[type=submit], input[type=button], ' +
+        '[role=button], [role=link], [role=tab], [role=menuitem], ' +
+        'summary, label, [onclick], [tabindex]'
+      );
+
+      Array.from(els).forEach(function(el) {{
+        var rect = el.getBoundingClientRect();
+        if (rect.width === 0 && rect.height === 0) return;
+        var style = window.getComputedStyle(el);
+        if (style.display === 'none' || style.visibility === 'hidden') return;
+
+        var texts = [
+          el.textContent || '',
+          el.getAttribute('aria-label') || '',
+          el.getAttribute('title') || '',
+          el.getAttribute('placeholder') || '',
+          el.value || '',
+          el.getAttribute('alt') || ''
+        ];
+
+        var bestScore = 0;
+        var bestMatch = '';
+        texts.forEach(function(t) {{
+          var s = score(t);
+          if (s > bestScore) {{ bestScore = s; bestMatch = t.trim().substring(0, 60); }}
+        }});
+
+        if (bestScore > 0) {{
+          candidates.push({{
+            el: el,
+            score: bestScore,
+            match: bestMatch,
+            tag: el.tagName.toLowerCase(),
+            cx: rect.x + rect.width / 2,
+            cy: rect.y + rect.height / 2
+          }});
+        }}
+      }});
+
+      if (candidates.length === 0) return JSON.stringify({{found: false}});
+
+      candidates.sort(function(a, b) {{ return b.score - a.score; }});
+      var best = candidates[0];
+      best.el.scrollIntoView({{block: 'center'}});
+      var rect = best.el.getBoundingClientRect();
+      best.el.click();
+      return JSON.stringify({{
+        found: true,
+        tag: best.tag,
+        text: best.match,
+        score: best.score,
+        x: rect.x + rect.width / 2,
+        y: rect.y + rect.height / 2,
+        alternatives: candidates.slice(1, 4).map(function(c) {{
+          return c.tag + ' "' + c.match + '" (score:' + c.score + ')';
+        }})
+      }});
+    }})()
+    """
+    r = await cdp_send(ws_url, [(1, "Runtime.evaluate", {"expression": js, "returnByValue": True})])
+    raw = r.get(1, {}).get("result", {}).get("value", "")
+    try:
+        data = json.loads(raw)
+    except (json.JSONDecodeError, TypeError):
+        print(f"Error parsing result", file=sys.stderr)
+        return
+
+    if not data.get("found"):
+        print(f'No element found matching: "{text}"', file=sys.stderr)
+        sys.exit(1)
+
+    await _vfx_ripple(ws_url, data["x"], data["y"])
+    print(f'Clicked: {data["tag"].upper()} "{data["text"]}" (score:{data["score"]})')
+    if data.get("alternatives"):
+        print(f'  Also found: {", ".join(data["alternatives"])}')
+
+
+async def cmd_smart_fill(text, value):
+    """Fill input by label/placeholder text — no CSS selector needed.
+
+    Finds input by: associated label, placeholder, aria-label, name, id match.
+
+    Usage:
+        cdpilot smart-fill "Email" "test@example.com"
+        cdpilot smart-fill "Password" "secret123"
+        cdpilot smart-fill "Search" "cdpilot"
+    """
+    ws_url, _ = get_page_ws()
+    safe_text = json.dumps(text.lower())
+    safe_value = json.dumps(value)
+    js = f"""
+    (function() {{
+      var search = {safe_text};
+      var value = {safe_value};
+      var candidates = [];
+
+      function score(str) {{
+        if (!str) return 0;
+        var s = str.toLowerCase().trim();
+        if (s === search) return 100;
+        if (s.startsWith(search)) return 80;
+        if (s.includes(search)) return 60;
+        return 0;
+      }}
+
+      var inputs = document.querySelectorAll('input, textarea, select, [contenteditable=true]');
+      Array.from(inputs).forEach(function(el) {{
+        var rect = el.getBoundingClientRect();
+        if (rect.width === 0 && rect.height === 0) return;
+
+        var scores = [];
+        // Check placeholder
+        scores.push(score(el.getAttribute('placeholder') || ''));
+        // Check aria-label
+        scores.push(score(el.getAttribute('aria-label') || ''));
+        // Check name/id
+        scores.push(score(el.name || ''));
+        scores.push(score(el.id || ''));
+        // Check associated label
+        if (el.id) {{
+          var label = document.querySelector('label[for="' + el.id + '"]');
+          if (label) scores.push(score(label.textContent || ''));
+        }}
+        // Check parent label
+        var parentLabel = el.closest('label');
+        if (parentLabel) scores.push(score(parentLabel.textContent || ''));
+        // Check preceding text node/label
+        var prev = el.previousElementSibling;
+        if (prev) scores.push(score(prev.textContent || ''));
+
+        var bestScore = Math.max.apply(null, scores);
+        if (bestScore > 0) {{
+          candidates.push({{el: el, score: bestScore, tag: el.tagName.toLowerCase(), type: el.type || ''}});
+        }}
+      }});
+
+      if (candidates.length === 0) return JSON.stringify({{found: false}});
+
+      candidates.sort(function(a, b) {{ return b.score - a.score; }});
+      var best = candidates[0];
+
+      // React-compatible value setting
+      var nativeSetter = Object.getOwnPropertyDescriptor(
+        window.HTMLInputElement.prototype, 'value'
+      ) || Object.getOwnPropertyDescriptor(
+        window.HTMLTextAreaElement.prototype, 'value'
+      );
+      if (nativeSetter && nativeSetter.set) {{
+        nativeSetter.set.call(best.el, value);
+      }} else {{
+        best.el.value = value;
+      }}
+      best.el.dispatchEvent(new Event('input', {{bubbles: true}}));
+      best.el.dispatchEvent(new Event('change', {{bubbles: true}}));
+
+      return JSON.stringify({{
+        found: true,
+        tag: best.tag,
+        type: best.type,
+        score: best.score,
+        placeholder: best.el.getAttribute('placeholder') || '',
+        name: best.el.name || best.el.id || ''
+      }});
+    }})()
+    """
+    r = await cdp_send(ws_url, [(1, "Runtime.evaluate", {"expression": js, "returnByValue": True})])
+    raw = r.get(1, {}).get("result", {}).get("value", "")
+    try:
+        data = json.loads(raw)
+    except (json.JSONDecodeError, TypeError):
+        print(f"Error parsing result", file=sys.stderr)
+        return
+
+    if not data.get("found"):
+        print(f'No input found matching: "{text}"', file=sys.stderr)
+        sys.exit(1)
+
+    ident = data.get("placeholder") or data.get("name") or data["tag"]
+    print(f'Filled: {data["tag"].upper()}[{data["type"]}] "{ident}" = {value} (score:{data["score"]})')
+
+
+async def cmd_smart_select(text, option_text):
+    """Select dropdown option by label text — no CSS selector needed.
+
+    Usage:
+        cdpilot smart-select "Country" "Turkey"
+        cdpilot smart-select "Size" "Large"
+    """
+    ws_url, _ = get_page_ws()
+    safe_text = json.dumps(text.lower())
+    safe_option = json.dumps(option_text.lower())
+    js = f"""
+    (function() {{
+      var search = {safe_text};
+      var optSearch = {safe_option};
+      var selects = document.querySelectorAll('select');
+      var best = null;
+      var bestScore = 0;
+
+      Array.from(selects).forEach(function(sel) {{
+        var texts = [
+          sel.getAttribute('aria-label') || '',
+          sel.name || '', sel.id || ''
+        ];
+        if (sel.id) {{
+          var label = document.querySelector('label[for="' + sel.id + '"]');
+          if (label) texts.push(label.textContent || '');
+        }}
+        var parent = sel.closest('label');
+        if (parent) texts.push(parent.textContent || '');
+
+        texts.forEach(function(t) {{
+          var s = t.toLowerCase().trim();
+          var sc = s === search ? 100 : s.includes(search) ? 60 : 0;
+          if (sc > bestScore) {{ bestScore = sc; best = sel; }}
+        }});
+      }});
+
+      if (!best) return JSON.stringify({{found: false}});
+
+      // Find matching option
+      var options = Array.from(best.options);
+      var match = options.find(function(o) {{
+        return o.text.toLowerCase().trim() === optSearch;
+      }}) || options.find(function(o) {{
+        return o.text.toLowerCase().includes(optSearch);
+      }});
+
+      if (!match) return JSON.stringify({{found: true, optionFound: false, available: options.map(function(o) {{ return o.text; }}).slice(0, 10)}});
+
+      best.value = match.value;
+      best.dispatchEvent(new Event('change', {{bubbles: true}}));
+      return JSON.stringify({{found: true, optionFound: true, selected: match.text, value: match.value}});
+    }})()
+    """
+    r = await cdp_send(ws_url, [(1, "Runtime.evaluate", {"expression": js, "returnByValue": True})])
+    raw = r.get(1, {}).get("result", {}).get("value", "")
+    try:
+        data = json.loads(raw)
+    except (json.JSONDecodeError, TypeError):
+        print("Error parsing result", file=sys.stderr)
+        return
+
+    if not data.get("found"):
+        print(f'No select found matching: "{text}"', file=sys.stderr)
+        sys.exit(1)
+    if not data.get("optionFound"):
+        print(f'Option "{option_text}" not found. Available: {", ".join(data.get("available", []))}', file=sys.stderr)
+        sys.exit(1)
+    print(f'Selected: "{data["selected"]}" (value={data["value"]})')
+
+
+async def cmd_run_script(script_path):
+    """Run a .cdp script file — sequential commands, one per line.
+
+    Script format (plain text):
+        go https://example.com
+        wait-for h1
+        assert h1 "Example Domain"
+        click a
+        shot /tmp/result.png
+
+    Lines starting with # are comments. Empty lines are skipped.
+    """
+    if not os.path.exists(script_path):
+        print(f"Script not found: {script_path}", file=sys.stderr)
+        sys.exit(1)
+
+    with open(script_path) as f:
+        lines = f.readlines()
+
+    import shlex
+    passed = 0
+    failed = 0
+    for line_num, line in enumerate(lines, 1):
+        line = line.strip()
+        if not line or line.startswith("#"):
+            continue
+        try:
+            parts = shlex.split(line)
+        except ValueError:
+            parts = line.split()
+        cmd_name = parts[0]
+        cmd_args = parts[1:]
+
+        print(f"[{line_num}] {line}")
+        try:
+            result = subprocess.run(
+                [sys.executable, __file__] + parts,
+                capture_output=True, text=True, timeout=30,
+                env={**os.environ, "CDPILOT_MCP_SESSION": "1"}
+            )
+            output = result.stdout.strip()
+            if output:
+                for out_line in output.split("\n"):
+                    print(f"     {out_line}")
+            if result.returncode != 0:
+                err = result.stderr.strip()
+                if err:
+                    print(f"     ERROR: {err}")
+                failed += 1
+            else:
+                passed += 1
+        except subprocess.TimeoutExpired:
+            print(f"     TIMEOUT")
+            failed += 1
+
+    print(f"\n{'─' * 40}")
+    print(f"Script: {script_path}")
+    print(f"Result: {passed} passed, {failed} failed, {passed + failed} total")
+
+
 # ─── Testing Commands ───
 
 async def cmd_assert(selector, expected_text=None, check_visible=True):
@@ -3658,6 +4582,16 @@ class MCPServer:
              "inputSchema": {"type": "object", "properties": {}}},
             {"name": "browser_close", "description": "Close the currently active browser tab. Use this to clean up after automation tasks or to close unwanted popups/tabs that were opened during navigation.",
              "inputSchema": {"type": "object", "properties": {}}},
+            {"name": "browser_extract", "description": "Extract structured data from elements matching a CSS selector. No LLM needed — pure DOM extraction. Returns text (default), JSON (with tag, text, attrs, href, src), specific attributes, or clean list. Use for scraping tables, lists, links, form values. Limit: 100 elements for JSON, 200 for text.",
+             "inputSchema": {"type": "object", "properties": {"selector": {"type": "string", "description": "CSS selector to match elements (e.g. 'table tr', '.product', 'a')"}, "format": {"type": "string", "enum": ["text", "json", "list"], "description": "Output format: 'text' (one per line), 'json' (full structure with attrs), 'list' (numbered)", "default": "text"}}, "required": ["selector"]}},
+            {"name": "browser_observe", "description": "List all interactive elements on the current page with their available actions (CLICK, FILL, NAVIGATE, TOGGLE, SELECT, SUBMIT, UPLOAD). Like Stagehand observe() but deterministic — no LLM needed. Shows what you CAN DO on the page. Use this to understand page structure before acting.",
+             "inputSchema": {"type": "object", "properties": {}}},
+            {"name": "browser_smart_click", "description": "Click an element by its visible text — no CSS selector needed. Uses fuzzy matching across text content, aria-label, title, placeholder, and value. Returns match score and alternatives. Like Stagehand act('Click login') but without LLM cost. Use when you know WHAT to click but not the exact selector.",
+             "inputSchema": {"type": "object", "properties": {"text": {"type": "string", "description": "Visible text of the element to click (e.g. 'Login', 'Submit Order', 'Learn more')"}}, "required": ["text"]}},
+            {"name": "browser_smart_fill", "description": "Fill an input by its label or placeholder text — no CSS selector needed. Finds input by associated label, placeholder, aria-label, name, or id. React-compatible value setting. Use when you know WHAT field to fill but not the exact selector.",
+             "inputSchema": {"type": "object", "properties": {"label": {"type": "string", "description": "Label or placeholder text of the input (e.g. 'Email', 'Password', 'Search')"}, "value": {"type": "string", "description": "Value to fill in the input"}}, "required": ["label", "value"]}},
+            {"name": "browser_smart_select", "description": "Select a dropdown option by label and option text — no CSS selector needed. Finds the select element by label/name, then selects the matching option. Use for dropdown interactions without knowing selectors.",
+             "inputSchema": {"type": "object", "properties": {"label": {"type": "string", "description": "Label text of the select dropdown"}, "option": {"type": "string", "description": "Text of the option to select"}}, "required": ["label", "option"]}},
             {"name": "browser_describe", "description": "Get a comprehensive page description combining three data sources: (1) accessibility tree with @N references for interactive elements, (2) a PNG screenshot saved to disk, and (3) visible text content. Use this when browser_a11y alone is insufficient — for canvas/WebGL content, visual verification, or complex dynamic UIs. This is the vision fallback tool.",
              "inputSchema": {"type": "object", "properties": {}}},
             {"name": "browser_assert", "description": "Assert that an element matching the CSS selector exists and optionally contains expected text. Returns PASS or FAIL with details. Use this for automated testing — verify page state after navigation or interaction. Checks visibility by default.",
@@ -3732,6 +4666,11 @@ class MCPServer:
             "browser_fill": lambda a: ["fill", a.get("selector", ""), a.get("value", "")],
             "browser_launch": lambda a: ["launch"],
             "browser_close": lambda a: ["close"],
+            "browser_extract": lambda a: ["extract", a.get("selector", "")] + ([f"--{a['format']}"] if a.get("format") and a["format"] != "text" else []),
+            "browser_observe": lambda a: ["observe"],
+            "browser_smart_click": lambda a: ["smart-click", a.get("text", "")],
+            "browser_smart_fill": lambda a: ["smart-fill", a.get("label", ""), a.get("value", "")],
+            "browser_smart_select": lambda a: ["smart-select", a.get("label", ""), a.get("option", "")],
             "browser_describe": lambda a: ["describe"],
             "browser_assert": lambda a: ["assert", a.get("selector", "")] + ([a["text"]] if a.get("text") else []),
             "browser_wait_for": lambda a: ["wait-for", a.get("selector", "")] + ([str(a["timeout"])] if a.get("timeout") else []),
@@ -3816,6 +4755,7 @@ if __name__ == "__main__":
         'version': cmd_version,
         'proxy': lambda: cmd_proxy(args[0] if args else None),
         'headless': lambda: cmd_headless(args[0] if args else None),
+        'stealth': lambda: cmd_stealth(args[0] if args else None),
         'session': cmd_session,
         'sessions': cmd_sessions,
         'session-close': lambda: cmd_session_close(args[0] if args else None),
@@ -3896,6 +4836,12 @@ if __name__ == "__main__":
         'a11y': lambda: cmd_a11y(' '.join(args)),
         'a11y-snapshot': cmd_a11y_snapshot,
         'describe': cmd_describe,
+        'extract': lambda: (require_args(1, 'extract <selector> [--json|--list|--attrs=href,title]'), None)[1] if not args else cmd_extract(args[0], next((a.lstrip('-') for a in args[1:] if a.startswith('--')), "text")),
+        'observe': cmd_observe,
+        'run': lambda: (require_args(1, 'run <script.cdp>'), None)[1] if not args else cmd_run_script(args[0]),
+        'smart-click': lambda: (require_args(1, 'smart-click <text>'), None)[1] if not args else cmd_smart_click(" ".join(args)),
+        'smart-fill': lambda: (require_args(2, 'smart-fill <label> <value>'), None)[1] if len(args) < 2 else cmd_smart_fill(args[0], " ".join(args[1:])),
+        'smart-select': lambda: (require_args(2, 'smart-select <label> <option>'), None)[1] if len(args) < 2 else cmd_smart_select(args[0], " ".join(args[1:])),
         'assert': lambda: (require_args(1, 'assert <selector> [text]'), None)[1] if not args else cmd_assert(args[0], args[1] if len(args) > 1 else None),
         'wait-for': lambda: (require_args(1, 'wait-for <selector> [timeout_ms]'), None)[1] if not args else cmd_wait_for(args[0], int(args[1]) if len(args) > 1 else 5000),
         'check': lambda: cmd_check(args[0] if args else None),
@@ -3920,12 +4866,15 @@ if __name__ == "__main__":
         'throttle': lambda: (require_args(1, 'throttle [slow3g|fast3g|offline|off|custom <down> <up> <lat>]'), None)[1] if not args else cmd_throttle(args[0], *args[1:]),
         'geo': lambda: (require_args(1, 'geo [<lat> <lng>|istanbul|london|newyork|off]'), None)[1] if not args else cmd_geo(args[0], args[1] if len(args) > 1 else None, args[2] if len(args) > 2 else None),
         'permission': lambda: (require_args(1, 'permission [grant|deny|reset] [<permission>]'), None)[1] if not args else cmd_permission(args[0], args[1] if len(args) > 1 else None),
+        'captcha-check': cmd_captcha_check,
+        'captcha-wait': lambda: cmd_captcha_wait(args[0] if args else None),
     }
 
     # Commands that do not require the visual indicator / input blocker
     NO_CONTROL_CMDS = {'glow', 'stop', 'tabs', 'close', 'close-tab', 'new-tab',
                        'dialog', 'download', 'throttle', 'permission', 'intercept',
-                       'batch', 'screenshot-diff'}
+                       'batch', 'screenshot-diff', 'run',
+                       'captcha-check', 'captcha-wait'}
     # Clean up idle sessions before running any command
     _cleanup_idle_sessions()