luckiest-co 1.0.47 → 1.0.49

package/skills/trends/scripts/lib/resolve.py

@@ -139,6 +139,47 @@ def _extract_github_user(items: list[dict]) -> str:
     return max(counts, key=counts.get)
 
 
+# Hosts that can never be a brand's own site; their presence in results is
+# platform noise, not an official-domain signal.
+_PLATFORM_HOSTS = {
+    "reddit.com", "x.com", "twitter.com", "github.com", "youtube.com",
+    "facebook.com", "instagram.com", "tiktok.com", "linkedin.com",
+    "wikipedia.org", "medium.com", "trustpilot.com", "crunchbase.com",
+    "bloomberg.com", "apple.com", "play.google.com", "google.com",
+    "threads.com", "pinterest.com", "glassdoor.com", "indeed.com",
+    "news.ycombinator.com", "substack.com", "amazon.com", "ebay.com",
+}
+
+
+def _extract_official_domain(topic: str, items: list[dict]) -> str:
+    """Extract the brand's own domain from search-result URLs.
+
+    Conservative on purpose: only a hostname whose registrable label
+    normalizes to the topic name qualifies ("ThriftBooks" -> thriftbooks.com).
+    This feeds Trustpilot targeting as a HINT (the engine retries via the
+    CLI's own search when the hint misses), so a miss here is cheap and a
+    wrong guess is recoverable.
+    """
+    want = re.sub(r"[^a-z0-9]", "", topic.lower())
+    if not want:
+        return ""
+    host_pattern = re.compile(r"https?://([A-Za-z0-9.-]+)")
+    for item in items:
+        for source in [item.get("url", ""), f"{item.get('title', '')} {item.get('snippet', '')}"]:
+            for host in host_pattern.findall(source):
+                host = host.lower().strip(".")
+                bare = host.removeprefix("www.")
+                if any(bare == p or bare.endswith("." + p) for p in _PLATFORM_HOSTS):
+                    continue
+                labels = bare.split(".")
+                if len(labels) < 2:
+                    continue
+                registrable = labels[-2] if labels[-2] not in ("co", "com") or len(labels) < 3 else labels[-3]
+                if re.sub(r"[^a-z0-9]", "", registrable) == want:
+                    return bare
+    return ""
+
+
 def _extract_github_repos(items: list[dict]) -> list[str]:
     """Extract owner/repo strings from search results."""
     repo_pattern = re.compile(r"github\.com/([A-Za-z0-9_.-]+/[A-Za-z0-9_.-]+)")
@@ -280,6 +321,7 @@ def auto_resolve(topic: str, config: dict) -> dict:
         "x_handle": "",
         "github_user": "",
         "github_repos": [],
+        "trustpilot_domain": "",
         "context": "",
         "category": None,
         "searches_run": 0,
@@ -329,16 +371,23 @@ def auto_resolve(topic: str, config: dict) -> dict:
     github_user = _extract_github_user(results.get("github", []))
     github_repos = canonicalize_github_repos(topic, _extract_github_repos(results.get("github", [])))
     context = _build_context_summary(results.get("news", []))
+    # Official-site domain doubles as the Trustpilot targeting hint (review
+    # pages are keyed by domain). Scan news first (official sites surface in
+    # coverage), then the handle query's profile-adjacent results.
+    trustpilot_domain = _extract_official_domain(
+        topic, (results.get("news") or []) + (results.get("x_handle") or [])
+    )
 
     subreddits, category = _merge_category_peers(topic, subreddits)
 
-    _log(f"Resolved {len(subreddits)} subreddits, x_handle={x_handle!r}, github_user={github_user!r}, github_repos={github_repos!r}, context_len={len(context)}, category={category!r}")
+    _log(f"Resolved {len(subreddits)} subreddits, x_handle={x_handle!r}, github_user={github_user!r}, github_repos={github_repos!r}, trustpilot_domain={trustpilot_domain!r}, context_len={len(context)}, category={category!r}")
 
     return {
         "subreddits": subreddits,
         "x_handle": x_handle,
         "github_user": github_user,
         "github_repos": github_repos,
+        "trustpilot_domain": trustpilot_domain,
         "context": context,
         "category": category,
         "searches_run": searches_run,

package/skills/trends/scripts/lib/safari_cookies.py

@@ -14,6 +14,8 @@ import struct
 import sys
 from pathlib import Path
 
+from .cookie_paths import path_exists
+
 # Mac epoch: 2001-01-01 00:00:00 UTC (not used for filtering, but documented)
 _MAC_EPOCH_OFFSET = 978307200  # seconds between Unix epoch and Mac epoch
 
@@ -98,7 +100,10 @@ def extract_safari_cookies_macos(
     Extract cookies from Safari on macOS.
 
     Args:
-        domain: Domain to match (substring match, e.g. "x.com")
+        domain: Registrable host to match, with or without a leading dot
+            (e.g. "x.com" or ".x.com"). A stored cookie host matches when it
+            equals the domain or is a subdomain of it; unrelated hosts that
+            merely contain the text (e.g. "x.com.evil.tld") do not.
         cookie_names: List of cookie names to extract (e.g. ["auth_token", "ct0"])
 
     Returns:
@@ -118,24 +123,47 @@ def extract_safari_cookies_macos(
         / "Cookies.binarycookies",
         Path.home() / "Library" / "Cookies" / "Cookies.binarycookies",
     ]
-    cookie_path = next((path for path in cookie_paths if path.exists()), cookie_paths[0])
+    denied = None
+    partial = None
+    for cookie_path in cookie_paths:
+        try:
+            if not path_exists(cookie_path):
+                continue
+            raw = cookie_path.read_bytes()
+        except PermissionError as exc:
+            if denied is None:
+                denied = exc
+            continue
+        except OSError:
+            continue
+        result = _parse_binary_cookies(raw, domain, cookie_names)
+        if result and all(result.get(name) for name in cookie_names):
+            return result
+        if result and partial is None:
+            partial = result
 
-    try:
-        raw = cookie_path.read_bytes()
-    except FileNotFoundError:
-        return None
-    except PermissionError:
+    if denied is not None:
         print(
             "[safari] Permission denied reading Cookies.binarycookies. "
-            "Enable Full Disk Access for Terminal in System Settings > "
-            "Privacy & Security > Full Disk Access.",
+            "Check the invoking app's browser-data permissions in System Settings > "
+            "Privacy & Security, then retry setup.",
             file=sys.stderr,
         )
-        return None
-    except OSError:
-        return None
+        raise denied
+    return partial
+
 
-    return _parse_binary_cookies(raw, domain, cookie_names)
+def _host_matches(stored_host: str, domain: str) -> bool:
+    """True when stored_host equals domain or is a subdomain of it.
+
+    Safari stores domain cookies with a leading dot (".x.com") and host-only
+    cookies without one ("x.com"); both spellings are accepted on either side.
+    """
+    host = stored_host.strip().lstrip(".").lower()
+    wanted = domain.strip().lstrip(".").lower()
+    if not host or not wanted:
+        return False
+    return host == wanted or host.endswith("." + wanted)
 
 
 def _parse_binary_cookies(
@@ -182,8 +210,7 @@ def _parse_binary_cookies(
         page_data = raw[offset : offset + ps]
         cookies = _parse_page(page_data)
         for c in cookies:
-            # Substring match on domain (handles leading dots like ".x.com")
-            if domain in c["url"] and c["name"] in names_set:
+            if _host_matches(c["url"], domain) and c["name"] in names_set:
                 result[c["name"]] = c["value"]
         offset += ps