six-degrees 0.4.0-beta.1 → 0.4.0

package/lib/photos.js

@@ -0,0 +1,47 @@
+// Profile photos are shown from this computer only.
+//
+// The scanner saves each photo into the data folder as it reads it
+// (scripts/image_store.py), and the row points at the saved file,
+// `/avatars/<name>`, which app/avatars/[file] serves. A row can also hold a
+// link: LinkedIn's own, which older versions stored until the scanner replaced
+// it, and which a copy of a network made by one carries too. A page never loads
+// a link: it would contact LinkedIn while someone is only looking at their map,
+// and the app goes online only when you act. That person shows initials until
+// the photo is saved, at the next scan or with Save photos on the Scan page.
+// The Content-Security-Policy in next.config.mjs holds the same line in the
+// browser.
+//
+// No imports, so the views and the server share it: every view and the routes
+// that store photos check with localPhoto, and the /avatars route serves the
+// names AVATAR_FILE allows.
+
+/** A photo the /avatars route serves: a plain file name, no folders. The route uses this same pattern. */
+export const AVATAR_FILE = /^[A-Za-z0-9_-]+\.(webp|jpg|jpeg|png)$/;
+
+const PREFIX = '/avatars/';
+
+/** The photo to show for a row's `profile_image_url`: its saved file's path, or null. */
+export function localPhoto(url) {
+  if (typeof url !== 'string' || !url.startsWith(PREFIX)) return null;
+  return AVATAR_FILE.test(url.slice(PREFIX.length)) ? url : null;
+}
+
+/**
+ * The photos still kept as links, one per person and link:
+ * [{ profileUrl, imageUrl }]. `db` is an open node:sqlite database. The
+ * scanner saves each (`GET /api/update-images`), or forgets the link on a
+ * definite no, so a link is tried until there's an answer.
+ */
+export function waitingPhotos(db) {
+  return db.prepare(`SELECT DISTINCT profile_url AS profileUrl, profile_image_url AS imageUrl
+      FROM linkedin_connections
+     WHERE profile_image_url IS NOT NULL AND profile_image_url <> ''
+       AND substr(profile_image_url, 1, 9) <> '/avatars/'
+     ORDER BY profile_url`).all()
+    .filter((r) => r.profileUrl && !localPhoto(r.imageUrl));
+}
+
+/** How many people have a photo waiting to be saved. */
+export function waitingPhotoCount(db) {
+  return new Set(waitingPhotos(db).map((r) => r.profileUrl)).size;
+}

package/lib/quest.js

@@ -9,6 +9,8 @@
 // sent, people who actually joined your network), never from browsing.
 // Plain functions; tests/quest.test.mjs.
 
+import { circleState } from './reach.js';
+
 export const STAGE_SIZE = 5;
 export const XP_SEND = { S: 25, A: 15, B: 10, C: 5, D: 2 };
 export const XP_ADDED = { S: 100, A: 60, B: 35, C: 15, D: 5 };
@@ -26,8 +28,9 @@ export function levelFor(points) {
  * @param sentIds ids marked "invite sent"
  * @param added   1st-degree people who came through a cluster (unlocked_from_bridge_id set)
  * @param mappedIds ids of 1st-degree people whose own circle is mapped
+ * @param reach   lib/reach.js reachIndex(), which also knows hidden lists; mappedIds stands in without it
  */
-export function buildQuest({ recs = [], sentIds = new Set(), added = [], mappedIds = new Set() }) {
+export function buildQuest({ recs = [], sentIds = new Set(), added = [], mappedIds = new Set(), reach = null }) {
   const byBridge = new Map();
   const seen = new Set();
   for (const r of [...recs].sort((a, b) => (b.priority || 0) - (a.priority || 0))) {
@@ -112,8 +115,10 @@ export function buildQuest({ recs = [], sentIds = new Set(), added = [], mappedI
     level: levelFor(points),
     sentTotal,
     addedTotal,
-    // People you've added whose own circle isn't mapped yet: the next degree.
-    newDoors: added.filter((a) => a.unlocked_from_bridge_id && !mappedIds.has(a.id)),
+    // People you've added whose own circle can be scanned: the next degree.
+    // Hidden lists aren't doors (lib/reach.js, the rule Bridge Chains uses).
+    newDoors: added.filter((a) => a.unlocked_from_bridge_id
+      && circleState(a, reach || { scanned: mappedIds, hidden: new Set() }) === 'todo'),
     clearedStages: clusters.reduce((s, c) => s + (c.stage - 1) + (c.complete ? 1 : 0), 0),
   };
 }

package/lib/reach.js

@@ -0,0 +1,113 @@
+// Who you reached through a circle, and whether their own circle is next.
+//
+// Blake, 2026-09-25: "i would like to sigingy if a orb in the 2nd degree is
+// added already so it shows they are ready for a 2nd degree scan to get the 3rd
+// degree so it needs to be intuitive with the orb glowing".
+//
+// "Ready" is one rule, kept here once. It used to live in three slightly
+// different copies (Outlink's new doors, the profile page's mapping bar and the
+// Degrees panel's Auto-Bridge Next), and only one of them knew about hidden
+// lists. Someone is ready for a circle scan when all of these are true:
+//   - they're your connection now (degree 1);
+//   - they came to you through a circle: unlocked_from_bridge_id, which
+//     lib/promote.js keeps when it clears source_connection_id, and which a
+//     request sent from the app sets to the circle you asked through;
+//   - their own circle hasn't been scanned: nobody in it is saved, and the
+//     scanner has no note of reading it (bridge-progress.json);
+//   - their list isn't known to be hidden (bridge-skips.json).
+// A glow that fired on hidden lists would teach you to ignore it, so a hidden
+// list is its own state, never "ready".
+//
+// Plain functions, no React; tests/reach.test.mjs.
+
+import { keyFor, compareBridges } from './separation.js';
+
+/**
+ * What the rules read, built once per load.
+ *
+ * @param connections 1st-degree rows
+ * @param degree2     2nd-degree rows: whose circle each sits in
+ * @param notes       what the scanner noted, from /api/scraper?reach=1:
+ *                    { skips: [{ profileUrl }] (hidden lists), read: [profileUrl] (lists it has read) }
+ * @returns {{ scanned: Set, read: Set, hidden: Set, reachedFrom: Map }}
+ *   `reachedFrom` is circle id → the connections you reached through it.
+ */
+export function reachIndex(connections = [], degree2 = [], notes = {}) {
+  const scanned = new Set();
+  for (const row of degree2 || []) {
+    if (row?.source_connection_id != null) scanned.add(row.source_connection_id);
+  }
+  const hidden = new Set();
+  for (const s of notes?.skips || []) {
+    if (s?.profileUrl) hidden.add(keyFor({ profile_url: s.profileUrl }));
+  }
+  const read = new Set();
+  for (const url of notes?.read || []) {
+    if (url) read.add(keyFor({ profile_url: url }));
+  }
+  const reachedFrom = new Map();
+  for (const row of connections || []) {
+    const from = row?.unlocked_from_bridge_id;
+    if (from == null || row.degree !== 1) continue;
+    let list = reachedFrom.get(from);
+    if (!list) reachedFrom.set(from, (list = []));
+    list.push(row);
+  }
+  return { scanned, read, hidden, reachedFrom };
+}
+
+/**
+ * Their own circle: 'scanned' (someone in it is saved, or the scanner read
+ * their list and everyone on it was already yours), 'hidden' (they keep their
+ * connections private) or 'todo'.
+ */
+export function circleState(person, reach) {
+  if (!person) return 'todo';
+  if (reach.scanned.has(person.id)) return 'scanned';
+  if (person.profile_url && reach.read?.has(keyFor(person))) return 'scanned';
+  if (person.profile_url && reach.hidden.has(keyFor(person))) return 'hidden';
+  return 'todo';
+}
+
+/**
+ * For someone you reached through a circle: 'ready' (their circle can be
+ * scanned next), 'hidden' or 'scanned'. Null for anyone else: people who were
+ * always your connections, and 2nd-degree rows (a request sent from the app
+ * marks those with the circle it asked through, but they aren't yours yet).
+ */
+export function reachState(person, reach) {
+  if (!person || person.degree !== 1 || person.unlocked_from_bridge_id == null) return null;
+  const state = circleState(person, reach);
+  return state === 'todo' ? 'ready' : state;
+}
+
+/** Everyone ready for a circle scan, strongest first. */
+export function readyToScan(connections, reach) {
+  return (connections || []).filter((c) => reachState(c, reach) === 'ready').sort(compareBridges);
+}
+
+/** How many people you reached through each circle are ready, by circle id. */
+export function readyByCircle(reach) {
+  const out = new Map();
+  for (const [from, people] of reach.reachedFrom) {
+    const n = people.filter((p) => reachState(p, reach) === 'ready').length;
+    if (n) out.set(from, n);
+  }
+  return out;
+}
+
+/**
+ * What scanning one circle asks of LinkedIn: one profile view to find their
+ * list, then a search for every page of it, `pages` at most (LinkedIn shows
+ * 100). About 0.55 minutes a page with the scanner's rests (20 s before each
+ * page, a minute more after every 10), so about 55 minutes for a whole list.
+ * The Scan page and the Degrees panel both say it from here.
+ */
+export function circleScanCost(pages = 100) {
+  const searches = Math.max(1, Math.min(100, Math.round(pages) || 100));
+  return {
+    profileViews: 1,
+    searches,
+    minutes: searches >= 100 ? 55 : Math.max(5, Math.round(searches * 0.55)),
+  };
+}

package/lib/scan-state.js

@@ -40,6 +40,7 @@ export function runningNow(job) {
     case 'install': return 'The scanner\'s packages are being installed';
     case 'setup': return 'The scanner is being set up';
     case 'login': return 'The LinkedIn sign-in window is open';
+    case 'photos': return 'Profile photos are being saved';
     default: return 'A scan is running';
   }
 }

package/lib/scanner-setup.js

@@ -1,5 +1,6 @@
 // What the Scan page's first step says and offers, from the checks GET
-// /api/scraper reports (app/api/scraper/route.js, lib/scanner-python.js).
+// /api/scraper reports (app/api/scraper/route.js, lib/scanner-python.js), and
+// whether it asks for your field before that (askForField).
 // Plain data in, plain data out: the page draws it, and
 // tests/scanner-setup.test.mjs checks every state without a browser. No Node
 // imports here; the page runs in the browser.
@@ -102,3 +103,21 @@ function stepOnly(status) {
     button: null,
   };
 }
+
+/**
+ * Whether the Scan page asks for your field first (app/components/FieldStep.js):
+ * once, before the first scan. Never to someone who already has a network, has
+ * picked a sector (Scores → Your sector), or answered or skipped the question
+ * before (`fieldAsked`). `status` is GET /api/scraper's answer (null while it
+ * loads), `settings` GET /api/settings' `settings` (undefined while it loads,
+ * null when it couldn't be read). null means not known yet: the page waits,
+ * rather than show the steps and then swap them for the question.
+ */
+export function askForField(status, settings) {
+  if (!status) return null;
+  const n = status.network;
+  // No counts means the app couldn't be asked; a scan running is past asking.
+  if (!n || n.first || n.second || n.third || status.running) return false;
+  if (settings === undefined) return null;
+  return Boolean(settings && !settings.fieldAsked && !settings.sectorFocus?.sectors?.length);
+}