cdpilot 0.4.0 → 0.4.2

package/bin/cdpilot.js

@@ -329,6 +329,10 @@ function showHelp() {
     captcha-check      Detect CAPTCHA on active page (JSON output)
     captcha-wait [s]   Pause until user solves CAPTCHA (default 300s)
 
+  RELIABILITY
+    browser [name]     Show or set preferred browser (chrome|brave|chromium|edge|vivaldi|auto)
+    health             JSON status: alive, port, tabs, browser, today's crashes
+
   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.4.0",
+  "version": "0.4.2",
   "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.4.0"
+__version__ = "0.4.2"
 
 import asyncio
 import json
@@ -1227,44 +1227,110 @@ async def navigate_collect(ws_url, url, network=False, console=False, glow=True)
 
 # ─── Helper Functions ───
 
-def _find_browser():
-    """İşletim sistemine göre tarayıcı ikili dosyasını otomatik olarak bulur."""
-    for b in ["brave-browser", "google-chrome", "chromium-browser", "chromium"]:
-        found = shutil.which(b)
-        if found:
-            return found
-
-    system = platform.system()
-    if system == "Darwin":
-        paths = [
-            "/Applications/Brave Browser.app/Contents/MacOS/Brave Browser",
-            "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
-            "/Applications/Chromium.app/Contents/MacOS/Chromium",
-        ]
-    elif system == "Linux":
-        paths = [
-            "/usr/bin/brave-browser",
-            "/usr/bin/google-chrome",
-            "/usr/bin/chromium-browser",
-            "/usr/bin/chromium",
-            "/snap/bin/chromium",
-        ]
-    elif system == "Windows":
-        paths = [
-            os.path.expandvars(r"C:\Program Files\BraveSoftware\Brave-Browser\Application\brave.exe"),
-            os.path.expandvars(r"C:\Program Files\Google\Chrome\Application\chrome.exe"),
-            os.path.expandvars(r"C:\Program Files (x86)\Google\Chrome\Application\chrome.exe"),
-            os.path.expandvars(r"C:\Program Files\Chromium\Application\chromium.exe"),
-        ]
-    else:
+# ─── Browser preference & detection ───────────────────────────────────────────
+# Map of canonical browser names to platform-specific binary candidates.
+# Order matters within each list: first existing path wins.
+BROWSER_BINARIES = {
+    'brave':    {'Darwin':  ["/Applications/Brave Browser.app/Contents/MacOS/Brave Browser"],
+                 'Linux':   ["/usr/bin/brave-browser", "/usr/bin/brave"],
+                 'Windows': [os.path.expandvars(r"C:\Program Files\BraveSoftware\Brave-Browser\Application\brave.exe")]},
+    'chrome':   {'Darwin':  ["/Applications/Google Chrome.app/Contents/MacOS/Google Chrome"],
+                 'Linux':   ["/usr/bin/google-chrome", "/usr/bin/google-chrome-stable"],
+                 'Windows': [os.path.expandvars(r"C:\Program Files\Google\Chrome\Application\chrome.exe"),
+                             os.path.expandvars(r"C:\Program Files (x86)\Google\Chrome\Application\chrome.exe")]},
+    'vivaldi':  {'Darwin':  ["/Applications/Vivaldi.app/Contents/MacOS/Vivaldi"],
+                 'Linux':   ["/usr/bin/vivaldi", "/usr/bin/vivaldi-stable"],
+                 'Windows': [os.path.expandvars(r"C:\Program Files\Vivaldi\Application\vivaldi.exe")]},
+    'edge':     {'Darwin':  ["/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge"],
+                 'Linux':   ["/usr/bin/microsoft-edge"],
+                 'Windows': [os.path.expandvars(r"C:\Program Files (x86)\Microsoft\Edge\Application\msedge.exe")]},
+    'chromium': {'Darwin':  ["/Applications/Chromium.app/Contents/MacOS/Chromium"],
+                 'Linux':   ["/usr/bin/chromium", "/usr/bin/chromium-browser", "/snap/bin/chromium"],
+                 'Windows': [os.path.expandvars(r"C:\Program Files\Chromium\Application\chromium.exe")]},
+}
+
+BROWSER_CONFIG_FILE = os.path.join(CDPILOT_HOME, 'browser.json')
+
+
+def _macos_major():
+    """Return macOS major version (e.g. 26) or None on other platforms."""
+    if platform.system() != 'Darwin':
+        return None
+    try:
+        return int(platform.mac_ver()[0].split('.')[0])
+    except (ValueError, IndexError):
         return None
 
-    for path in paths:
+
+def _resolve_browser_name(name):
+    """Resolve a browser name to its binary path. Returns None if not installed."""
+    name = (name or '').lower().strip()
+    if name not in BROWSER_BINARIES:
+        return None
+    candidates = BROWSER_BINARIES[name].get(platform.system(), [])
+    for path in candidates:
         if os.path.exists(path):
             return path
     return None
 
 
+def get_browser_preference():
+    """Read user's persisted browser preference. Returns name or 'auto'."""
+    if os.path.exists(BROWSER_CONFIG_FILE):
+        try:
+            with open(BROWSER_CONFIG_FILE) as f:
+                return (json.load(f).get('browser') or 'auto').lower()
+        except (OSError, ValueError):
+            pass
+    return 'auto'
+
+
+def _auto_browser_priority():
+    """Default detection order. macOS 26 (Tahoe) demotes Brave because the
+    current Brave 1.89 build crashes deterministically at ~7min uptime
+    (SIGTRAP in ThreadPoolForegroundWorker, observed across 9+ dumps).
+    Vivaldi takes priority because it's Chromium-based AND honors
+    --load-extension (Chrome silently drops unpacked extensions in 147+).
+    """
+    if _macos_major() and _macos_major() >= 26:
+        return ['vivaldi', 'brave', 'chrome', 'chromium', 'edge']
+    return ['brave', 'chrome', 'vivaldi', 'chromium', 'edge']
+
+
+def _find_browser():
+    """Locate the browser binary. Priority:
+    1. CHROME_BIN env var (full path, backward-compatible)
+    2. ~/.cdpilot/browser.json preference (set via `cdpilot browser <name>`)
+    3. Auto-detection per _auto_browser_priority()
+    """
+    # 1) PATH lookup for common command names (Linux/Brew installs)
+    for b in ["brave-browser", "vivaldi", "google-chrome", "chromium-browser", "chromium"]:
+        found = shutil.which(b)
+        if found:
+            # Only use PATH match as fallback — preference still wins below.
+            path_match = found
+            break
+    else:
+        path_match = None
+
+    # 2) User preference from config (overrides auto)
+    pref = get_browser_preference()
+    if pref and pref != 'auto':
+        resolved = _resolve_browser_name(pref)
+        if resolved:
+            return resolved
+        # Configured browser not installed — fall through to auto with a warning.
+        sys.stderr.write(f"⚠️  Configured browser '{pref}' not found, falling back to auto-detect.\n")
+
+    # 3) Auto-detection in priority order
+    for name in _auto_browser_priority():
+        resolved = _resolve_browser_name(name)
+        if resolved:
+            return resolved
+
+    return path_match  # Last resort
+
+
 def _is_port_in_use(port):
     """Check if a port is actively in use."""
     return not _is_port_free(port)
@@ -1503,10 +1569,37 @@ def cmd_launch():
     proj_label = f' [{PROJECT_ID}]' if PROJECT_ID else ''
     print(f'Launching browser (isolated session, port {CDP_PORT}){proj_label}...')
 
+    # ─── Stability fixes (2026-04-21) ───
+    # Brave on Apple Silicon crashed with SIGTRAP/EXC_BREAKPOINT deterministically
+    # at ~7 min uptime on ThreadPoolForegroundWorker. Two changes:
+    #   1) `--disable-gpu-compositing` removed — conflicts with Metal accel on
+    #      M-series. Browser falls back to GPU-accel rendering which is the
+    #      Chromium default and matches what websites expect.
+    #   2) `--disable-features=...` added — catches Brave-specific background
+    #      tasks that individual `--disable-brave-*` flags don't fully kill
+    #      (Rewards ad scanner, Sync heartbeat, News fetcher).
+    # Per-browser profile isolation. Brave-written profiles include keys that
+    # confuse Vivaldi/Chrome (search_engines.json missing, prefs schema diffs),
+    # so each browser gets its own subdir. Brave keeps the original path for
+    # backward compatibility — existing users don't lose state on upgrade.
+    browser_basename = os.path.basename(CHROME_BIN).lower()
+    if 'brave' in browser_basename:
+        profile_dir = PROFILE_DIR
+    elif 'vivaldi' in browser_basename:
+        profile_dir = PROFILE_DIR + '-vivaldi'
+    elif 'edge' in browser_basename or 'msedge' in browser_basename:
+        profile_dir = PROFILE_DIR + '-edge'
+    elif 'chromium' in browser_basename:
+        profile_dir = PROFILE_DIR + '-chromium'
+    else:
+        # Default: chrome and unknown chromium-based browsers
+        profile_dir = PROFILE_DIR + '-chrome'
+    os.makedirs(profile_dir, exist_ok=True)
+
     chrome_args = [
         CHROME_BIN,
         f'--remote-debugging-port={CDP_PORT}',
-        f'--user-data-dir={PROFILE_DIR}',
+        f'--user-data-dir={profile_dir}',
         '--remote-allow-origins=*',
         '--disable-fre', '--no-default-browser-check', '--no-first-run',
         # ─── Brave-specific features (harmless on other Chromium builds) ───
@@ -1521,6 +1614,14 @@ def cmd_launch():
         '--disable-tor',
         '--disable-ipfs',
         '--disable-brave-extension',
+        # Feature-level disables — catch background workers the
+        # single-purpose flags above miss. Comma-joined string = one arg.
+        '--disable-features=' + ','.join([
+            'BraveRewards', 'BraveAds', 'BraveSync', 'BraveNewsToday',
+            'BraveVPN', 'BraveWalletBubble', 'SpeedReader', 'Tor',
+            'IPFSCompanion', 'Translate', 'OptimizationGuideModelDownloading',
+            'InterestFeedContentSuggestions', 'CalculateNativeWinOcclusion',
+        ]),
         # ─── Chromium performance flags ───
         '--disable-background-networking',
         '--disable-background-timer-throttling',
@@ -1542,7 +1643,9 @@ def cmd_launch():
         '--safebrowsing-disable-auto-update',
         '--password-store=basic',
         # ─── GPU / rendering ───
-        '--disable-gpu-compositing',
+        # --disable-gpu-compositing REMOVED: caused EXC_BREAKPOINT on Apple
+        # Silicon Brave 147+ after ~7min. Let the browser use its default
+        # (Metal-accelerated) compositor.
         '--disable-smooth-scrolling',
         '--new-window', 'about:blank',
     ]
@@ -2225,52 +2328,71 @@ def cmd_session_close(session_id=None):
 
 
 def cmd_extensions():
-    """List installed extensions."""
-    ext_dir = os.path.join(PROFILE_DIR, "Default", "Extensions")
-    if not os.path.isdir(ext_dir):
-        print("No extensions installed.")
-        return
+    """List installed extensions (packed via Chrome Web Store + dev mode unpacked).
 
-    prefs_path = os.path.join(PROFILE_DIR, "Default", "Preferences")
+    Two sources are checked independently — neither absence should hide the other.
+    Previously an early-return on missing Default/Extensions/ silently swallowed
+    dev-mode entries written by `ext-install`.
+    """
+    # 1) Packed (CRX) extensions live under Default/Extensions and are described
+    #    in Default/Preferences. Only present after the user installs from the
+    #    Chrome Web Store; ext-install does NOT write here.
+    ext_dir = os.path.join(PROFILE_DIR, "Default", "Extensions")
+    packed_ids = []
     ext_names = {}
-    if os.path.exists(prefs_path):
-        try:
-            with open(prefs_path) as f:
-                prefs = json.load(f)
-            settings = prefs.get("extensions", {}).get("settings", {})
-            for ext_id, info in settings.items():
-                manifest = info.get("manifest", {})
-                ext_names[ext_id] = {
-                    "name": manifest.get("name", ext_id),
-                    "version": manifest.get("version", "?"),
-                    "enabled": info.get("state", 1) == 1,
-                    "path": info.get("path", ""),
-                }
-        except Exception:
-            pass
+    if os.path.isdir(ext_dir):
+        prefs_path = os.path.join(PROFILE_DIR, "Default", "Preferences")
+        if os.path.exists(prefs_path):
+            try:
+                with open(prefs_path) as f:
+                    prefs = json.load(f)
+                settings = prefs.get("extensions", {}).get("settings", {})
+                for ext_id, info in settings.items():
+                    manifest = info.get("manifest", {})
+                    ext_names[ext_id] = {
+                        "name": manifest.get("name", ext_id),
+                        "version": manifest.get("version", "?"),
+                        "enabled": info.get("state", 1) == 1,
+                    }
+            except Exception:
+                pass
+        packed_ids = [d for d in os.listdir(ext_dir) if not d.startswith(".")]
+
+    # 2) Dev-mode (unpacked) extensions registered by `ext-install` —
+    #    loaded into the browser via --load-extension on each launch.
+    dev_exts = get_dev_extensions()
 
-    ext_ids = [d for d in os.listdir(ext_dir) if not d.startswith(".")]
-    if not ext_ids:
+    if not packed_ids and not dev_exts:
         print("No extensions installed.")
         return
 
-    for ext_id in sorted(ext_ids):
-        info = ext_names.get(ext_id, {})
-        name = info.get("name", ext_id)
-        version = info.get("version", "?")
-        enabled = info.get("enabled", True)
-        status = "✅" if enabled else "⏸️"
-        print(f"  {status} {name} (v{version})")
-        print(f"     ID: {ext_id}")
+    if packed_ids:
+        for ext_id in sorted(packed_ids):
+            info = ext_names.get(ext_id, {})
+            name = info.get("name", ext_id)
+            version = info.get("version", "?")
+            enabled = info.get("enabled", True)
+            status = "✅" if enabled else "⏸️"
+            print(f"  {status} {name} (v{version})")
+            print(f"     ID: {ext_id}")
+        print(f"\n{len(packed_ids)} packed extension{'s' if len(packed_ids) != 1 else ''}")
 
-    print(f"\n{len(ext_ids)} extensions")
-
-    dev_exts = get_dev_extensions()
     if dev_exts:
-        print(f'\nDev Mode Extensions ({len(dev_exts)}):')
+        if packed_ids:
+            print()
+        print(f"Dev Mode Extensions ({len(dev_exts)}):")
         for i, path in enumerate(dev_exts):
             exists = '✅' if os.path.isdir(path) else '❌ (directory not found)'
-            print(f'  {exists} [{i}] {path}')
+            # Try to read manifest for friendlier output
+            label = os.path.basename(path.rstrip('/'))
+            try:
+                with open(os.path.join(path, 'manifest.json')) as f:
+                    mf = json.load(f)
+                label = f"{mf.get('name', label)} (v{mf.get('version', '?')})"
+            except Exception:
+                pass
+            print(f"  {exists} [{i}] {label}")
+            print(f"        {path}")
 
 
 def cmd_ext_install(source):
@@ -2589,6 +2711,101 @@ def cmd_headless(state=None):
     print('Restart browser (stop → launch).')
 
 
+def cmd_browser(name=None):
+    """Show or set the preferred browser (chrome|brave|chromium|edge|vivaldi|auto).
+
+    The choice is persisted in ~/.cdpilot/browser.json and applies to all
+    projects. `auto` (default) picks per-platform priority — on macOS 26
+    Vivaldi is preferred over Brave due to a known Brave 1.89/macOS 26
+    crash. `CHROME_BIN` env var still overrides if set.
+
+    Usage:
+      cdpilot browser                # show current + which is detected
+      cdpilot browser vivaldi        # force Vivaldi
+      cdpilot browser auto           # restore platform default
+    """
+    if name is None or name.lower() == 'status':
+        pref = get_browser_preference()
+        resolved = _resolve_browser_name(pref) if pref != 'auto' else None
+        auto_resolved = _find_browser()
+        installed = [n for n in BROWSER_BINARIES if _resolve_browser_name(n)]
+        print(f"Preference:  {pref}")
+        if pref != 'auto':
+            print(f"  resolved:  {resolved or '(not found — falling back to auto)'}")
+        print(f"Auto-pick:   {auto_resolved or '(none)'}")
+        print(f"Installed:   {', '.join(installed) or '(none detected)'}")
+        if _macos_major() and _macos_major() >= 26:
+            print(f"Note: macOS {_macos_major()} demotes Brave in auto-pick (Brave 1.89 crashes ~7min).")
+        return
+
+    name = name.lower().strip()
+    if name not in BROWSER_BINARIES and name != 'auto':
+        valid = ', '.join(['auto'] + list(BROWSER_BINARIES.keys()))
+        print(f"Invalid browser: {name}. Valid: {valid}", file=sys.stderr)
+        sys.exit(1)
+
+    if name != 'auto' and not _resolve_browser_name(name):
+        print(f"⚠️  Browser '{name}' not installed on this system.", file=sys.stderr)
+        candidates = BROWSER_BINARIES[name].get(platform.system(), [])
+        if candidates:
+            print(f"   Looked at: {candidates[0]}", file=sys.stderr)
+        sys.exit(1)
+
+    os.makedirs(os.path.dirname(BROWSER_CONFIG_FILE), exist_ok=True)
+    with open(BROWSER_CONFIG_FILE, 'w') as f:
+        json.dump({'browser': name}, f)
+    print(f"Browser preference: {name}")
+    print('Restart the browser (`cdpilot stop` then any command) for the change to take effect.')
+
+
+def cmd_health():
+    """Print JSON health summary of the cdpilot browser session.
+
+    Output keys:
+      alive          — bool, CDP /json/version reachable
+      port           — int, current CDP port
+      project_id     — str|null, project identifier (multi-instance)
+      tabs           — int, count of page targets (when alive)
+      browser        — str|null, version string from /json/version
+      crashes_today  — int, Brave crash dump count from macOS today
+      stealth        — bool, current stealth config
+      uptime_warning — str|null, hint when browser is alive but very old
+
+    Exit codes: 0 = alive, 2 = down. Designed for shell watchdog loops:
+      `until cdpilot health >/dev/null; do cdpilot launch; sleep 2; done`
+    """
+    import datetime as _dt
+    import glob as _glob
+
+    info = {
+        'alive': False,
+        'port': CDP_PORT,
+        'project_id': PROJECT_ID,
+        'tabs': 0,
+        'browser': None,
+        'crashes_today': 0,
+        'stealth': get_stealth_config(),
+        'uptime_warning': None,
+    }
+    ver = cdp_get('/json/version')
+    if ver:
+        info['alive'] = True
+        info['browser'] = ver.get('Browser') or ver.get('browser') or ''
+        targets = cdp_get('/json') or []
+        info['tabs'] = sum(1 for t in targets if t.get('type') == 'page')
+
+    # Today's crash count from macOS DiagnosticReports (Brave only).
+    if platform.system() == 'Darwin':
+        today = _dt.date.today().strftime('%Y-%m-%d')
+        pattern = os.path.expanduser(f'~/Library/Logs/DiagnosticReports/Brave Browser-{today}-*.ips')
+        info['crashes_today'] = len(_glob.glob(pattern))
+        if info['crashes_today'] >= 3:
+            info['uptime_warning'] = f"{info['crashes_today']} Brave crashes today — consider `cdpilot stop` then relaunch"
+
+    print(json.dumps(info, ensure_ascii=False))
+    sys.exit(0 if info['alive'] else 2)
+
+
 def cmd_stealth(state=None):
     """Toggle stealth fingerprint patches.
 
@@ -4756,6 +4973,8 @@ if __name__ == "__main__":
         '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),
+        'browser': lambda: cmd_browser(args[0] if args else None),
+        'health': cmd_health,
         'session': cmd_session,
         'sessions': cmd_sessions,
         'session-close': lambda: cmd_session_close(args[0] if args else None),