six-degrees 0.4.0 → 0.4.2

package/lib/linkedin-limits.js

@@ -5,8 +5,9 @@
 // changes here — the budget, and lifting a cooldown.
 //
 // The budget is searches (a day and a month) and profile views (a day). Profile
-// views are what got an account restricted (TRAPS §16), so their cap has no
-// "no limit", and the scanner also keeps any two a minute apart.
+// views got an account restricted (TRAPS §16), so their cap has no "no limit",
+// and the scanner also keeps any two a minute apart. Searches did too, at 373 in
+// 24 hours: the page asks before a risky search budget (lib/search-risk.js).
 //
 // They belong to the LinkedIn account, not to a profile in the app. TRAPS §35.
 
@@ -58,14 +59,18 @@ export function nextMonthStartPacific(ms = Date.now()) {
   return monthStartPacific(start + 40 * DAY * 1000);
 }
 
+const profileChoice = (n) => PROFILE_CHOICES.filter((c) => c <= n).pop() ?? PROFILE_CHOICES[0];
+
 export function readLimits(dir) {
   const raw = readJson(path.join(dir, 'scan-limits.json')) || {};
   const num = (v, d) => (Number.isInteger(v) && v >= 0 ? v : d);
   return {
     daily: num(raw.daily, DEFAULT_LIMITS.daily),
     monthly: num(raw.monthly, DEFAULT_LIMITS.monthly),
-    // 0 is "no limit" for searches; for profile views the scanner reads it as the default.
-    profiles: num(raw.profiles, 0) || DEFAULT_LIMITS.profiles,
+    // 0 is "no limit" for searches; for profile views the scanner reads it as the
+    // default. A number typed in by hand counts as the largest choice under it,
+    // as the scanner reads it (scrape.py search_limits).
+    profiles: profileChoice(num(raw.profiles, 0) || DEFAULT_LIMITS.profiles),
   };
 }
 

package/lib/reach.js

@@ -45,6 +45,10 @@ export function reachIndex(connections = [], degree2 = [], notes = {}) {
   for (const url of notes?.read || []) {
     if (url) read.add(keyFor({ profile_url: url }));
   }
+  const lists = new Map();
+  for (const [url, list] of Object.entries(notes?.lists || {})) {
+    if (url && list) lists.set(keyFor({ profile_url: url }), list);
+  }
   const reachedFrom = new Map();
   for (const row of connections || []) {
     const from = row?.unlocked_from_bridge_id;
@@ -53,7 +57,7 @@ export function reachIndex(connections = [], degree2 = [], notes = {}) {
     if (!list) reachedFrom.set(from, (list = []));
     list.push(row);
   }
-  return { scanned, read, hidden, reachedFrom };
+  return { scanned, read, hidden, reachedFrom, lists };
 }
 
 /**
@@ -111,3 +115,20 @@ export function circleScanCost(pages = 100) {
     minutes: searches >= 100 ? 55 : Math.max(5, Math.round(searches * 0.55)),
   };
 }
+
+/**
+ * How much of someone's circle is scanned, as 0–5 bars for the ring round
+ * their dot; null for no ring (not scanned, or their list is hidden).
+ * A list read to the end is 5. Part-read, it's the pages read against
+ * LinkedIn's own count of the list (about 10 a page), 1 to 4; with no count
+ * (read before the scanner kept one), 2.
+ */
+export function scanBars(person, reach) {
+  const state = circleState(person, reach);
+  const list = person?.profile_url ? reach.lists?.get(keyFor(person)) : null;
+  if (state === 'hidden') return null;
+  if (!list) return state === 'scanned' ? 2 : null;
+  if (!list.more) return 5;
+  if (!list.total) return 2;
+  return Math.max(1, Math.min(4, Math.round((5 * Math.min(1, (list.pages * 10) / list.total)))));
+}

package/lib/search-risk.js

@@ -0,0 +1,38 @@
+// How much searching is asking for trouble, for the Scan page's budget picker.
+// No Node imports, so the page and the tests share it (lib/linkedin-limits.js
+// reads files and can't load in the browser).
+//
+// The number behind it (TRAPS §16): on 2026-09-28 a real account was restricted
+// after 373 searches in 24 hours, run back to back, with the daily budget raised
+// to 500 and no monthly cap. It opened 7 profiles that day, so searches alone
+// were enough.
+
+export const RISKY_DAILY = 100;       // above this, the picker asks first
+export const RESTRICTED_AT = 373;     // searches in 24 hours when that account was restricted
+export const SAFE_LIMITS = { daily: 50, monthly: 250 };
+
+export const riskyDaily = (n) => Number(n) > RISKY_DAILY;
+export const riskyLimits = ({ daily, monthly } = {}) => riskyDaily(daily) || monthly === 0;
+
+/** What the picker asks before a change that raises the risk; null when there's nothing to ask. */
+export function limitQuestion(from = {}, to = {}) {
+  if (riskyDaily(to.daily) && Number(to.daily) > Number(from.daily)) {
+    return `${to.daily} searches a day is more than LinkedIn has put up with. A real account was `
+      + `restricted after ${RESTRICTED_AT} searches in 24 hours, run back to back. The default is `
+      + `${SAFE_LIMITS.daily} a day.\n\nSet ${to.daily} a day anyway?`;
+  }
+  if (to.monthly === 0 && from.monthly !== 0) {
+    return 'With no monthly cap, only the daily budget stops a scan. A real account was restricted '
+      + `after ${RESTRICTED_AT} searches in 24 hours with no monthly cap set.\n\nTurn the monthly cap off anyway?`;
+  }
+  return null;
+}
+
+/** The note under the picker while the budget is risky; null when it isn't. */
+export function limitNote({ daily, monthly } = {}) {
+  if (!riskyLimits({ daily, monthly })) return null;
+  const parts = [`A real account was restricted after ${RESTRICTED_AT} searches in 24 hours.`];
+  if (riskyDaily(daily)) parts.push(`${daily} a day can use up a free account's month in a day or two.`);
+  if (monthly === 0) parts.push('With no monthly cap, nothing but the daily budget stops a long run.');
+  return parts.join(' ');
+}

package/lib/ties.js

@@ -0,0 +1,23 @@
+// Ties between your own connections: two people you know who know each other.
+//
+// A circle scan reads everyone in someone's list, your own connections among
+// them, and the app sets those aside rather than saving them as 2nd degree
+// (lib/ingest.js splitAlreadyConnected). Each one is a tie between that
+// person and the one whose circle it is. Kept in connection_ties (db/schema.js),
+// for clustering and communities later; nothing reads them yet.
+
+/** The pairs to keep: the circle's person with each of your connections in it, each pair once, smaller URL first. */
+export function tiePairs(ownerUrl, urls = []) {
+  const seen = new Set();
+  const out = [];
+  if (!ownerUrl) return out;
+  for (const url of urls) {
+    if (!url || url === ownerUrl) continue;
+    const [a, b] = url < ownerUrl ? [url, ownerUrl] : [ownerUrl, url];
+    const key = `${a} ${b}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push({ a_url: a, b_url: b });
+  }
+  return out;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "six-degrees",
-  "version": "0.4.0",
+  "version": "0.4.2",
   "description": "Map your professional network as a galaxy — leverage tiers, bridges into new circles, and the shortest path to anyone. Runs locally on your own data.",
   "license": "MIT",
   "author": "Blake Burford",

package/scripts/scrape.py

@@ -1504,16 +1504,29 @@ def take_profile_view(now=None):
     with _Locked("linkedin-activity"):
         now = now if now is not None else time.time()
         data = _read_activity()
-        views = [t for t in data["profiles"] if t > now - DAY_SECONDS]
-        if len(views) >= search_limits()["profiles"]:
-            return None
-        # A time ahead of this clock (another computer's, imported) is left
-        # out of the gap: waiting for it could never end.
-        last = max((t for t in views if t <= now), default=None)
-        if last is not None and now - last < PROFILE_GAP:
-            return int(last + PROFILE_GAP - now) + 1
-        _charge(data, "profiles", 1, now)
-        return 0
+        wait = _profile_wait(data, now)
+        if wait == 0:
+            _charge(data, "profiles", 1, now)
+        return wait
+
+
+def profile_wait(now=None):
+    """take_profile_view's answer, writing nothing down: 0, seconds to wait, or None."""
+    with _Locked("linkedin-activity"):
+        now = now if now is not None else time.time()
+        return _profile_wait(_read_activity(), now)
+
+
+def _profile_wait(data, now):
+    views = [t for t in data["profiles"] if t > now - DAY_SECONDS]
+    if len(views) >= search_limits()["profiles"]:
+        return None
+    # A time ahead of this clock (another computer's, imported) is left
+    # out of the gap: waiting for it could never end.
+    last = max((t for t in views if t <= now), default=None)
+    if last is not None and now - last < PROFILE_GAP:
+        return int(last + PROFILE_GAP - now) + 1
+    return 0
 
 
 def search_limits():
@@ -1529,8 +1542,12 @@ def search_limits():
             return default
     return {"daily": num(data.get("daily"), DEFAULT_DAILY_SEARCHES),
             "monthly": num(data.get("monthly"), DEFAULT_MONTHLY_SEARCHES),
-            # 0 is no cap for searches, never for profile views.
-            "profiles": num(data.get("profiles"), DEFAULT_DAILY_PROFILES) or DEFAULT_DAILY_PROFILES}
+            # 0 is no cap for searches, never for profile views. A number typed
+            # in by hand counts as the largest choice under it: never past 100,
+            # and the Scan page shows the same one.
+            "profiles": max((c for c in (10, 25, 50, 100)
+                             if c <= (num(data.get("profiles"), DEFAULT_DAILY_PROFILES) or DEFAULT_DAILY_PROFILES)),
+                            default=10)}
 
 
 def linkedin_usage(now=None):
@@ -1684,6 +1701,12 @@ def _change_progress(change):
         print(f"  (could not note how far this read got: {exc})")
 
 
+# How long each list is, from LinkedIn's "About N results" line on the first
+# page read (RESULT_COUNT_JS), kept until the read's progress is written: the
+# app's rings round a dot show pages read against it. Approximate, like the line.
+_LIST_TOTALS = {}
+
+
 def record_bridge_progress(profile_url, name, pages, more, urn=None):
     """Note that someone's connections have been read through page `pages`.
 
@@ -1700,6 +1723,9 @@ def record_bridge_progress(profile_url, name, pages, more, urn=None):
                  "at": datetime.now().isoformat(timespec="seconds")}
         if urn or old.get("urn"):
             entry["urn"] = urn or old.get("urn")
+        total = _LIST_TOTALS.get(profile_url) or old.get("total")
+        if total:
+            entry["total"] = int(total)
         mine[profile_url] = entry
     _change_progress(change)
 
@@ -2461,6 +2487,7 @@ def _scrape_one_bridge(page, bridge_name, bridge_id, profile_url, max_pages=LINK
     except Exception:
         total = None
     if total:
+        _LIST_TOTALS[profile_url] = int(total)
         pages = -(-total // 10)
         print(f"  About {total:,} results in their list: {pages} pages"
               + (f", and LinkedIn shows the first {LINKEDIN_MAX_PAGES}." if pages > LINKEDIN_MAX_PAGES else "."))
@@ -3475,6 +3502,17 @@ def rescrape_bridge(bridge_name, headless=False, max_pages=LINKEDIN_MAX_PAGES):
         raise BudgetReached(0, searches_left()[1])
     if profiles_left() <= 0:              # a fresh read opens their profile
         raise BudgetReached(0, "profiles")
+    # The minute between profile views is waited out before anything is
+    # deleted: a Stop during it would otherwise leave the circle deleted and unread.
+    wait = profile_wait()
+    if wait is None:
+        raise BudgetReached(0, "profiles")
+    if wait:
+        print(f"  Waiting {wait}s before re-mapping: at least {PROFILE_GAP}s pass between any "
+              f"two profile views.", flush=True)
+        if not interruptible_sleep(wait, on_tick=lambda left: print(f"    {left}s to go", flush=True), step=10):
+            print("  Stopped before anything was deleted.")
+            return
 
     print(f"Deleting old cluster data...")
     bridge_id = delete_bridge_cluster(bridge_name)