Fix location/freshness filters and make ever-jobs URL configurable

- Add src/geo_filter.py and apply it during scraping to drop jobs outside the user's selected locations (stops international jobs leaking in for India searches; respects Remote/Worldwide)
- Wire the user's days_posted into scrapers: LinkedIn f_TPR and ever-jobs hours_old were hardcoded to 7 days and ignored the freshness selection
- Make the ever-jobs sidecar URL env-configurable (EVER_JOBS_API_URL) across config/client/server so the 150+ extra platforms can use a hosted sidecar on HF Spaces; skip local Docker/npm startup when pointed at a remote URL, with clearer DOWN messaging

Co-authored-by: Cursor <cursoragent@cursor.com>

config.py

@@ -232,7 +232,10 @@ AUTOMATION = {
 from src.ever_jobs_bridge.platforms import INDIA_DEFAULT_PLATFORMS
 
 EVER_JOBS = {
-    "api_url":            "http://localhost:3001",
+    # Point this at a HOSTED ever-jobs sidecar to enable the 150+ extra
+    # platforms on HF Spaces (where a local Node process can't run). Defaults
+    # to the local dev sidecar.
+    "api_url":            os.getenv("EVER_JOBS_API_URL", "http://localhost:3001"),
     "default_platforms":  INDIA_DEFAULT_PLATFORMS,
     "max_results":        25,
     "request_timeout":    30,

src/ever_jobs_bridge/client.py

@@ -1,10 +1,11 @@
+import os
 import logging
 import requests
 from typing import Optional
 
 log = logging.getLogger(__name__)
 
-API_BASE = "http://localhost:3001"
+API_BASE = os.getenv("EVER_JOBS_API_URL", "http://localhost:3001")
 SEARCH_ENDPOINT = f"{API_BASE}/api/jobs/search"
 DEFAULT_TIMEOUT = 120
 DEFAULT_REQUEST_TIMEOUT = 30

src/ever_jobs_bridge/server.py

@@ -1,3 +1,4 @@
+import os
 import subprocess
 import requests
 import time
@@ -8,11 +9,21 @@ from pathlib import Path
 log = logging.getLogger(__name__)
 
 EVER_JOBS_DIR = str(Path(__file__).parent.parent.parent / "vendor" / "ever-jobs")
-API_BASE = "http://localhost:3001"
+API_BASE = os.getenv("EVER_JOBS_API_URL", "http://localhost:3001")
 HEALTH_ENDPOINT = f"{API_BASE}/health"
 _npm_process = None
 
 
+def _is_remote() -> bool:
+    """True when pointed at a hosted sidecar (not localhost) — e.g. on HF Spaces.
+
+    In that case we must NOT try to spawn Docker/npm locally; we just health-
+    check the remote URL.
+    """
+    return bool(os.getenv("EVER_JOBS_API_URL")) and "localhost" not in API_BASE \
+        and "127.0.0.1" not in API_BASE
+
+
 def is_running() -> bool:
     try:
         r = requests.get(HEALTH_ENDPOINT, timeout=3)
@@ -92,9 +103,14 @@ def stop_npm():
 
 def ensure_running() -> tuple[bool, str]:
     if is_running():
-        log.info("ever-jobs API already running on port 3001")
+        log.info(f"ever-jobs API reachable at {API_BASE}")
         return True, "already_running"
 
+    # Hosted sidecar (HF Spaces): we can't start Node locally — just report it.
+    if _is_remote():
+        log.error(f"ever-jobs remote sidecar unreachable at {API_BASE}")
+        return False, "remote_unreachable"
+
     log.info("ever-jobs not running — attempting to start...")
 
     if shutil.which("docker"):

src/geo_filter.py

@@ -0,0 +1,107 @@
+"""
+Location filtering — drop jobs that are clearly outside the user's selected
+geography (fixes "international jobs leaking in").
+
+The pipeline searches role x location, but several boards (LinkedIn "Remote",
+Remotive, WeWorkRemotely, ever-jobs aggregators) return jobs from anywhere
+regardless of the requested location. This module decides, per job, whether its
+location is acceptable given what the user selected.
+
+Design goals:
+- Be permissive about INDIA jobs (LinkedIn usually appends ", India" or the
+  state, but some only show the city), so keep a broad Indian-city list.
+- Only drop a job when it is clearly foreign (names a non-India country/city)
+  or, in India-only mode, when it is neither India nor an allowed remote role.
+- If the user selected "Worldwide"/"Anywhere", do not filter at all.
+"""
+
+from __future__ import annotations
+
+INDIA_TOKENS = {
+    "india", "bharat", "bengaluru", "bangalore", "mumbai", "delhi", "new delhi",
+    "delhi ncr", "ncr", "gurugram", "gurgaon", "noida", "hyderabad", "pune",
+    "chennai", "kolkata", "ahmedabad", "jaipur", "surat", "lucknow", "kochi",
+    "cochin", "coimbatore", "indore", "nagpur", "chandigarh", "bhubaneswar",
+    "visakhapatnam", "vizag", "thiruvananthapuram", "trivandrum", "mysuru",
+    "mysore", "mohali", "vadodara", "nashik", "kanpur", "patna", "guwahati",
+    "raipur", "bhopal", "goa", "mangaluru", "mangalore",
+    # states / UTs commonly shown in LinkedIn location strings
+    "karnataka", "maharashtra", "telangana", "tamil nadu", "kerala",
+    "uttar pradesh", "west bengal", "gujarat", "haryana", "rajasthan",
+    "andhra pradesh", "madhya pradesh", "punjab", "odisha", "bihar",
+}
+
+# Clear non-India signals — if present (and India is not), the job is foreign.
+FOREIGN_TOKENS = {
+    "united states", "usa", "u.s.", " us)", "u.s", "america",
+    "united kingdom", " uk", "u.k", "england", "london", "scotland",
+    "canada", "toronto", "vancouver",
+    "germany", "berlin", "munich", "deutschland",
+    "france", "paris", "spain", "madrid", "italy", "netherlands", "amsterdam",
+    "ireland", "dublin", "poland", "portugal", "sweden", "switzerland",
+    "singapore", "malaysia", "kuala lumpur", "indonesia", "jakarta",
+    "philippines", "manila", "thailand", "bangkok", "vietnam", "hong kong",
+    "china", "japan", "tokyo", "korea", "seoul",
+    "australia", "sydney", "melbourne", "new zealand",
+    "dubai", "abu dhabi", "uae", "saudi", "qatar", "doha", "bahrain", "kuwait",
+    "egypt", "nigeria", "kenya", "south africa", "brazil", "mexico", "argentina",
+    "bangladesh", "dhaka", "pakistan", "sri lanka", "nepal",
+    # US state abbreviations frequently seen as "City, CA" / "City, NY"
+    " ca", " ny", " tx", " wa", " ma", " il", " ga", " fl", " co", " va",
+}
+
+REMOTE_TOKENS = {"remote", "anywhere", "work from home", "wfh"}
+GLOBAL_TOKENS = {"worldwide", "anywhere", "global"}
+
+
+def _norm(s: str) -> str:
+    return (s or "").strip().lower()
+
+
+def wants_india(selected_locations) -> bool:
+    sl = " ".join(_norm(x) for x in (selected_locations or []))
+    return any(tok in sl for tok in ("india", "bangalore", "bengaluru", "mumbai",
+                                     "delhi", "hyderabad", "pune", "chennai",
+                                     "noida", "gurgaon", "kolkata"))
+
+
+def allows_remote(selected_locations) -> bool:
+    sl = [_norm(x) for x in (selected_locations or [])]
+    return any(any(t in s for t in REMOTE_TOKENS | GLOBAL_TOKENS) for s in sl)
+
+
+def no_geo_restriction(selected_locations) -> bool:
+    sl = [_norm(x) for x in (selected_locations or [])]
+    return any(any(t in s for t in GLOBAL_TOKENS) for s in sl)
+
+
+def _has(tokens, text) -> bool:
+    return any(t in text for t in tokens)
+
+
+def location_allowed(job_location: str, selected_locations) -> bool:
+    """True if `job_location` is acceptable for the user's selected locations."""
+    if no_geo_restriction(selected_locations):
+        return True
+
+    jl = _norm(job_location)
+    if not jl:
+        return True  # unknown location — don't drop (LinkedIn often omits it)
+
+    india_mode = wants_india(selected_locations)
+    is_india = _has(INDIA_TOKENS, jl)
+    is_remote = _has(REMOTE_TOKENS, jl)
+    is_foreign = _has(FOREIGN_TOKENS, jl) and not is_india
+
+    if india_mode:
+        if is_india:
+            return True
+        # Allow a remote role only if the user opted into remote AND it isn't
+        # explicitly a foreign-remote posting (e.g. "Remote, US").
+        if is_remote and allows_remote(selected_locations) and not is_foreign:
+            return True
+        return False
+
+    # Non-India searches: only drop the obviously-foreign-to-selection case is
+    # hard to generalize, so keep everything (user didn't pick India).
+    return True

src/scrapers/ever_jobs.py

@@ -39,12 +39,18 @@ class EverJobsScraper(BaseScraper):
             log.warning("EverJobsScraper: no platforms specified — returning empty")
             return []
 
+        try:
+            _days = float(getattr(self, "_days_posted", 7) or 7)
+        except (TypeError, ValueError):
+            _days = 7
+        hours_old = max(1, int(_days * 24))
+
         raw_jobs = self._client.search(
             site_types=self.platforms,
             search_term=role,
             location=location,
             results_wanted=max_results,
-            hours_old=168,
+            hours_old=hours_old,
             description_format="plain",
             request_timeout=30,
         )

src/scrapers/linkedin.py

@@ -20,11 +20,20 @@ class LinkedInScraper(BaseScraper):
         start = 0
         page_size = 25
 
+        # Freshness window — honour the user's selected days_posted (set by the
+        # pipeline via `_days_posted`); default to 7 days. f_TPR is in seconds.
+        try:
+            _days = float(getattr(self, "_days_posted", 7) or 7)
+        except (TypeError, ValueError):
+            _days = 7
+        _seconds = max(3600, int(_days * 86400))
+        f_tpr = f"r{_seconds}"
+
         while len(jobs) < max_results:
             params = {
                 "keywords": role,
                 "location": location,
-                "f_TPR": "r604800",  # Last 7 days
+                "f_TPR": f_tpr,
                 "start": start,
                 "count": page_size,
             }

ui.py

@@ -1847,9 +1847,18 @@ if show_config and start and not st.session_state.running:
                         scraper_map["ever_jobs"] = ("EverJobs", EverJobsScraper(_ej_platforms))
                         _q_log(f"🌐 ever-jobs sidecar UP — {len(_ej_platforms)} extra platforms enabled")
                     else:
-                        _q_log(f"⚠ ever-jobs sidecar DOWN — {len(_ej_platforms)} platforms "
-                               f"(Indeed/Glassdoor/Greenhouse/Lever/etc.) SKIPPED this run. "
-                               f"Direct scrapers (LinkedIn/Indeed/Glassdoor/Remotive/WWR/Naukri) still run.")
+                        import os as _os
+                        _hosted = bool(_os.getenv("EVER_JOBS_API_URL"))
+                        if _hosted:
+                            _q_log(f"⚠ ever-jobs sidecar unreachable at {_os.getenv('EVER_JOBS_API_URL')} "
+                                   f"— {len(_ej_platforms)} extra platforms SKIPPED. Check the hosted "
+                                   f"sidecar is running. Direct scrapers (LinkedIn etc.) still run.")
+                        else:
+                            _q_log(f"⚠ ever-jobs sidecar DOWN — {len(_ej_platforms)} extra platforms "
+                                   f"(Greenhouse/Lever/Google/Foundit/etc.) SKIPPED. These need the "
+                                   f"Node sidecar, which can't run inside HF Spaces. To enable them, host "
+                                   f"ever-jobs elsewhere and set the EVER_JOBS_API_URL secret. "
+                                   f"Direct scrapers (LinkedIn/Indeed/Glassdoor/Remotive/WWR) still run.")
                         _step_skip("ever_jobs")
                 else:
                     _step_skip("ever_jobs")
@@ -1857,6 +1866,16 @@ if show_config and start and not st.session_state.running:
                 scrape_pct    = 12
                 pct_per_plat  = 35 / max(1, len(scraper_map))
                 MAX_PER_PLAT  = _jscfg["max_jobs_per_platform"]
+                _days_posted  = _jscfg.get("days_posted", 7)
+                _sel_locs     = _jscfg.get("locations", [])
+                from src.geo_filter import location_allowed
+                # Thread the freshness window into every scraper that supports it.
+                for _pid, (_pn, _sc) in scraper_map.items():
+                    try:
+                        _sc._days_posted = _days_posted
+                    except Exception:
+                        pass
+                _geo_dropped = 0
 
                 for plat_id, (pname, scraper) in scraper_map.items():
                     t0      = _t.time()
@@ -1889,6 +1908,9 @@ if show_config and start and not st.session_state.running:
                                         continue
                                     if not scraper.is_pm_role(j.title):
                                         continue
+                                    if not location_allowed(j.location, _sel_locs):
+                                        _geo_dropped += 1
+                                        continue
                                     if is_duplicate(j.url, days=30):
                                         skipped_dup += 1
                                         continue
@@ -1923,6 +1945,9 @@ if show_config and start and not st.session_state.running:
                     _q_log(f"✅ {pname}: {len(platform_jobs)} jobs ({n_desc} with JD) "
                            f"| {skipped_dup} dupes skipped")
 
+                if _geo_dropped:
+                    _q_log(f"📍 Filtered out {_geo_dropped} job(s) outside your selected "
+                           f"locations ({', '.join(_sel_locs[:4])}{'…' if len(_sel_locs) > 4 else ''}).")
                 _q_log(f"✅ Total unique jobs: {len(all_jobs)}")
                 if not all_jobs:
                     _q_log("❌ No jobs found. Check internet or platform settings.")